En este tutorial, creamos una simulación realista de red Zero-Trust modelando un entorno microsegmentado como un gráfico dirigido y forzando que cada solicitud obtenga acceso a través de una verificación continua. Implementamos un motor de políticas dinámicas que combina permisos de estilo ABAC con la postura del dispositivo, MFA, accesibilidad de ruta, sensibilidad de zona y señales de riesgo en vivo, como indicadores de anomalías y volumen de datos. Luego, ponemos en funcionamiento el modelo a través de una API de Flask y ejecutamos tráfico mixto, incluido el movimiento interno-lateral y los intentos de exfiltración, para mostrar cómo la puntuación de confianza, los controles adaptativos y las cuarentenas automatizadas bloquean los flujos maliciosos en tiempo real.
!pip -q instalar networkx flask importar matemáticas importar json importar tiempo importar aleatorio importar hashlib desde clases de datos importar clase de datos, campo desde escribir importar Dict, Any, List, Tuple, opcional importar networkx como nx desde flask importar Flask, solicitud, jsonify importar matplotlib.pyplot como plt def _sigmoid(x: float) -> float: return 1.0 / (1.0 + math.exp(-x)) def _clamp(x: float, lo: float = 0.0, hola: float = 1.0) -> float: return max(lo, min(hi, x)) def _now_ts() -> float: return time.time() def _stable_hash(s: str) -> int: h = hashlib.sha256(s.encode("utf-8")).hexdigest() return int(h[:10], 16) def _rand_choice_weighted(elementos: Lista[Cualquiera], pesos: Lista[flotante]) -> Cualquiera: devuelve random.choices(elementos, pesos=pesos, k=1)[0]def _pretty(obj: Cualquiera) -> str: devolver json.dumps(obj, sangría=2, sort_keys=False)
Configuramos el entorno instalando las bibliotecas necesarias e importando todas las dependencias necesarias para el modelado de gráficos, la puntuación de riesgos y el manejo de API. Definimos funciones de utilidad para normalización de confianza, hash, sellado de tiempo y muestreo ponderado para respaldar simulaciones deterministas. Preparamos funciones auxiliares que simplifican el registro y el formato de salida estructurado a lo largo del tutorial.
ZONAS = ["public", "dmz", "app", "data", "admin"] SENSIBILIDAD = {"public": 0.15, "dmz": 0.35, "app": 0.6, "data": 0.85, "admin": 0.95} ACTIVOS = { "public": ["cdn", "landing", "status"], "dmz": ["api_gateway", "waf", "vpn"], "app": ["orders_svc", "billing_svc", "ml_inference", "inventory_svc"], "data": ["customer_db", "ledger_db", "feature_store"], "admin": ["iam", "siem", "backup_vault"] } ACTIONS = ["read", "write", "deploy", "admin", "exfiltrar"] ROLES = ["cliente", "empleado", "analista", "ingeniero", "admin", "secops"] DEVICE_TYPES = ["managed_laptop", "managed_server", "byod_phone", "unknown_iot"] NETWORK_CONTEXT = ["corp_lan", "corp_vpn", "public_wifi", "tor_exit"] @dataclass class RequestContext: usuario: str rol: str device_id: str tipo_dispositivo: str postura_dispositivo: float mfa: bool fuente: str src_node: str dst_node: str acción: str time_bucket: str geo_risk: float comportamiento_anomaly: float data_volume: float motivo: str = "" @dataclass clase Decisión: permitido: bool trust_score: float rule_hits: Lista[str] = campo(default_factory=list) controles: Dict[str, Any] = campo(default_factory=dict) explicación: str = "" ts: float = campo(default_factory=_now_ts) @dataclass clase PrincipalState: usuario: str rol: str base_risk: float last_seen_ts: float Rolling_denies: int = 0 Rolling_allows: int = 0 en cuarentena: bool = False compromiso_score: float = 0.0 @dataclass class DeviceState: device_id: str tipo_dispositivo: str propietario: str postura: float atestiguado: bool en cuarentena: bool = False @dataclass clase FlowRecord: ts: float ctx: Dict[str, Any] decisión: Dict[str, Any]
Definimos el esquema de dominio central que incluye zonas, activos, roles, tipos de dispositivos y señales contextuales que dan forma a nuestro entorno Zero-Trust. Formalizamos estructuras de registro de solicitudes, decisiones, principales, dispositivos y flujos utilizando clases de datos para mantener la claridad y la integridad del estado. Establecemos el modelo de datos fundamental que permite una evaluación continua de la confianza en identidades, dispositivos y rutas de red.
def build_microsegmented_graph(seed: int = 7) -> nx.DiGraph: random.seed(seed) G = nx.DiGraph() para z en ZONAS: G.add_node(f"zone:{z}", kind="zone", zona=z, sensibilidad=SENSITIVITY[z]) para z, activos en ASSETS.items(): para a en activos: nodo = f"{z}:{a}" G.add_node(nodo, kind="activo", zona=z, sensibilidad=SENSITIVIDAD[z] + random.uniform(-0.05, 0.05)) G.add_edge(f"zone:{z}", nodo, kind="contiene") permit_paths = [ ("public", "dmz"), ("dmz", "app"), ("app", "data"), ("admin", "app"), ("admin", "data"), ("admin", "dmz"), ("dmz", "admin") ] para src_z, dst_z en las rutas_permitidas: G.add_edge(f"zone:{src_z}", f"zone:{dst_z}", kind="zone_route", base_allowed=True) para src_z, dst_z en las rutas_permitidas: para src_a en ACTIVOS[src_z]: para dst_a en ACTIVOS[dst_z]: si random.random() < 0.45: G.add_edge(f"{src_z}:{src_a}", f"{dst_z}:{dst_a}", kind="service_call", base_allowed=True) para z en ZONAS: para a en ACTIVOS[z]: si random.random() < 0.35: G.add_edge(f"{z}:{a}", f"{z}:{a}", kind="self", base_allowed=True) return G def draw_graph(G: nx.DiGraph, title: str = "Gráfico de red microsegmentado de confianza cero") -> Ninguno: plt.figure(figsize=(14, 9)) pos = nx.spring_layout(G, semilla=42, k=0.35) tipos = nx.get_node_attributes(G, "tipo") node_colors =[]para n en G.nodes(): si clases.get(n) == "zona": node_colors.append(0.85) else: node_colors.append(G.nodes[n].get("sensibilidad", 0.5)) nx.draw_networkx_nodes(G, pos, node_size=350, node_color=node_colors) nx.draw_networkx_edges(G, pos, flechas=True, alpha=0.25) nx.draw_networkx_labels(G, pos, font_size=8) plt.title(título) plt.axis("off") plt.show()
Construimos un gráfico de red dirigido microsegmentado donde las zonas y los activos se modelan explícitamente con atributos de sensibilidad. Generamos mediante programación rutas de comunicación entre zonas y a nivel de servicio para simular patrones de tráfico empresarial realistas. Visualizamos la topología de la red para observar claramente los límites de segmentación y las posibles rutas de movimiento lateral.
clase ZeroTrustPolicyEngine: def __init__(self, G: nx.DiGraph): self.G = G self.principals: Dict[str, PrincipalState] = {} self.devices: Dict[str, DeviceState] = {} self.flow_log: List[FlowRecord] =[]self.blocked_edges: set = set() self.policy_version = "ztpe-v1.3" self.role_perms = { "cliente": {"public": {"read"}, "dmz": {"read"}}, "empleado": {"public": {"read"}, "dmz": {"read"}, "app": {"read", "write"}}, "analyst": {"public": {"read"}, "dmz": {"read"}, "app": {"read"}, "data": {"read"}}, "engineer": {"public": {"read"}, "dmz": {"read"}, "app": {"read", "write", "implementar"}, "data": {"read"}}, "admin": {"public": {"read"}, "dmz": {"read", "write"}, "app": {"read", "write", "deploy", "admin"}, "data": {"read", "write", "admin"}, "admin": {"read", "write", "admin"}}, "secops": {"public": {"read"}, "dmz": {"read", "write"}, "app": {"read", "admin"}, "data": {"read", "admin"}, "admin": {"read", "admin"}}, } self.w = { "role_fit": 1.4, "device_posture": 1.8, "mfa": 1.0, "network_context": 1.2, "time": 0.6, "geo_risk": 1.2, "behavior_anomaly": 2.2, "data_volume": 1.4, "principal_base_risk": 1.3, "principal_compromise": 2.0, "asset_sensitivity": 1.6, "path_validity": 1.5, "quarantine": 4.0, } self.thresholds = { "allow": 0.72, "step_up": 0.62, "rate_limit": 0.55, "deny": 0.0 } def Register_principal(self, usuario: str, rol: str, base_risk: float) -> Ninguno: self.principals[usuario] = PrincipalState( usuario=usuario, rol=role, base_risk=_clamp(base_risk), last_seen_ts=_now_ts() ) def Register_device(self, dispositivo_id: str, dispositivo_tipo: str, propietario: str, postura: float, atestiguado: bool) -> Ninguno: self.devices[device_id] = DeviceState( id_dispositivo=id_dispositivo, tipo_dispositivo=tipo_dispositivo, propietario=propietario, postura=_clamp(postura), atestiguado=bool(atestiguado) ) def _asset_zone_and_sensitivity(self, nodo: str) -> Tupla[str, float]: if node.startswith("zone:"): z = node.split(":", 1)[1]return z, SENSITIVITY.get(z, 0.5) z = self.G.nodes[nodo].get("zone", "public") sens = float(self.G.nodes[node].get("sensitivity", SENSITIVITY.get(z, 0.5))) return z, _clamp(sens) def _base_abac_check(self, role: str, dst_zone: str, action: str) -> bool: acción de retorno en self.role_perms.get(role, {}).get(dst_zone, set()) def _path_is_valid(self, src: str, dst: str) -> bool: if (src, dst) en self.blocked_edges: retorno Falso intento: retorno nx.has_path(self.G, src, dst) excepto nx.NetworkXError: retorno Falso def _network_context_risk(self, fuente: str) -> float: table = {"corp_lan": 0.1, "corp_vpn": 0.25, "public_wifi": 0.65, "tor_exit": 0.9} return table.get(source, 0.6) def _time_risk(self, time_bucket: str) -> float: devuelve 0.15 si time_bucket == "horas_empresariales" else 0,55 def _compute_trust_score(self, ctx: RequestContext) -> Tuple[float, List[str], Dict[str, Any]]: rule_hits =[]controles: Dict[str, Any] = {} principal = self.principals.get(ctx.user) dispositivo = self.devices.get(ctx.device_id) si el principal es Ninguno: rule_hits.append("unknown_principal") principal = PrincipalState(ctx.user, ctx.role, base_risk=0.85, last_seen_ts=_now_ts()) si el dispositivo es Ninguno: rule_hits.append("dispositivo_desconocido") dispositivo = DeviceState(ctx.device_id, ctx.device_type, propietario=ctx.user, postura=0.25, atestiguado=False) src_zone, src_sens = self._asset_zone_and_sensitivity(ctx.src_node) dst_zone, dst_sens = self._asset_zone_and_sensitivity(ctx.dst_node) abac_ok = self._base_abac_check(ctx.role, dst_zone, ctx.action) si no es abac_ok: rule_hits.append("abac_denied") path_ok = self._path_is_valid(ctx.src_node, ctx.dst_node) si no es path_ok: rule_hits.append("invalid_path_or_blocked") si principal.quarantined o dispositivo.quarantined: rule_hits.append("quarantined") controles["auto_response"] = "deny_quarantine" if ctx.action == "exfiltrate": rule_hits.append("exfil_attempt") if dst_zone en ["admin", "data"] y no ctx.mfa: rule_hits.append("mfa_required_for_SENSITIVE_zone") controles["step_up_mfa"] = Verdadero si dispositivo.propietario! = ctx.user: rule_hits.append("device_owner_mismatch") net_r = self._network_context_risk(ctx.source) t_r = self._time_risk(ctx.time_bucket) role_fit = 1.0 si abac_ok más 0.0 postura = _clamp(device.posture si dispositivo.attestado más dispositivo.postura * 0.75) mfa = 1.0 si ctx.mfa más 0.0 path_valid = 1.0 si path_ok más 0.0 sens = _clamp(dst_sens) principal_risk = _clamp(principal.base_risk) compromiso = _clamp(principal.compromise_score) anomalía = _clamp(ctx.behavior_anomaly) geo = _clamp(ctx.geo_risk) data_vol = _clamp(ctx.data_volume) cuarentena_penalidad = 1,0 si (principal.en cuarentena o dispositivo.en cuarentena) else 0,0 propietario_mismatch_penalty = 1,0 si (dispositivo.propietario != ctx.user) else 0.0 exfil_penalty = 1.0 if (ctx.action == "exfiltrate") else 0.0 z = 0.0 z += self.w["role_fit"] * (role_fit – 0.5) z += self.w["device_posture"] * (postura – 0.5) z += self.w["mfa"] * (mfa – 0.5) z += self.w["path_validity"] * (path_valid – 0.5) z -= self.w["asset_sensitivity"] * (sens – 0.35) z -= self.w["network_context"] * (net_r – 0.25) z -= self.w["time"] * (t_r – 0.15) z -= self.w["geo_risk"] * (geo – 0.2) z -= self.w["behavior_anomaly"] * (anomalía – 0.1) z -= self.w["data_volume"] * (data_vol – 0.15) z -= self.w["principal_base_risk"] * (principal_risk – 0.2) z -= self.w["principal_compromise"] * (compromiso – 0.0) z -= 2.0 * propietario_mismatch_penalty z -= 2.5 * exfil_penalty z -= self.w["quarantine"] * cuarentena_penalty confianza = _sigmoid(z) si confianza < self.thresholds["rate_limit"]: controles["rate_limit"] = Verdadero si confianza < self.thresholds["step_up"]: controles["step_up"] = bool(controls.get("step_up_mfa", False) o dst_zone en ["admin", "data"]) si confianza < self.thresholds["allow"]: controles["continuous_auth"] = True si "abac_denied" en rule_hits o "invalid_path_or_blocked" en rule_hits o "exfil_attempt" en rule_hits: controles["risk_signal"] = "policy_violation" si anomalía > 0,75 y sens > 0,75: controles["auto_response"] = "quarantine_candidate" return _clamp(trust), rule_hits, controles def evalua(self, ctx: RequestContext) -> Decisión: confianza, rule_hits, controles = self._compute_trust_score(ctx) permitido = confianza >= self.thresholds["allow"] si controles.get("step_up"): si no ctx.mfa: permitido = False rule_hits.append("step_up_failed_no_mfa") else: permitido = permitido o (confianza >= self.thresholds["step_up"]) si controles.get("rate_limit") y confianza < 0,5: permitido = Falso rule_hits.append("rate_limited_denied") explicación = self._explain(ctx, confianza, permitido, regla_hits, controles) dec = Decisión(permitido=permitido, confianza_score=confianza, regla_hits=regla_hits, controles=controles, explicación=explicación) self._post_decision_updates(ctx, dec) self.flow_log.append( FlowRecord( ts=dec.ts, ctx=ctx.__dict__.copy(), decisión={ "allowed": dec.allowed, "trust_score": dec.trust_score, "rule_hits": dec.rule_hits, "controls": dec.controls, "explanation": dec.explanation } ) ) return dec def _explain(self, ctx: RequestContext, confianza: float, permitido: bool, visitas: Lista[str], controles: Dict[str, Any]) -> str: src_z, _ = self._asset_zone_and_sensitivity(ctx.src_node) dst_z, dst_s = self._asset_zone_and_sensitivity(ctx.dst_node) bits =[]bits.append(f"Decisión={'ALLOW' si se permite else 'DENEGAR'} | confianza={trust:.3f} | {ctx.user}({ctx.role}) {ctx.action} {ctx.src_node}->{ctx.dst_node}") bits.append(f"Context: source={ctx.source}, time={ctx.time_bucket}, geo_risk={ctx.geo_risk:.2f}, anomalía={ctx.behavior_anomaly:.2f}, data_vol={ctx.data_volume:.2f}") bits.append(f"Zonas: {src_z} -> {dst_z} (dst_sensitivity={dst_s:.2f}) | MFA={'yes' si ctx.mfa else 'no'} | postura={ctx.device_posture:.2f}") si acierta: bits.append(f"Regla aciertos: {', '.join(hits)}") si controles: bits.append(f"Controles: {controles}") return " ".join(bits) def _post_decision_updates(self, ctx: RequestContext, dec: Decisión) -> Ninguno: p = self.principals.get(ctx.user) d = self.devices.get(ctx.device_id) si p es Ninguno: self.register_principal(ctx.user, ctx.role, base_risk=0.65) p = self.principals[ctx.user] si d es Ninguno: self.register_device(ctx.device_id, ctx.device_type, ctx.user, ctx.device_posture, atestiguado=(ctx.device_type.startswith("managed"))) d = self.devices[ctx.device_id] p.last_seen_ts = dec.ts si dec.permitido: p.rolling_allows += 1 p.rolling_denies = max(0, p.rolling_denies – 1) p.compromise_score = _clamp(p.compromise_score – 0.02) else: p.rolling_denies += 1 p.compromise_score = _clamp(p.compromise_score + 0.06 + 0.10 * (1.0 si "exfil_attempt" en dec.rule_hits else 0.0)) if dec.controls.get("auto_response") == "quarantine_candidate" o p.rolling_denies >= 4 o p.compromise_score > 0,78: p.quarantined = Verdadero si d
def make_world(motor: ZeroTrustPolicyEngine, semilla: int = 13) -> Dict[str, Any]: random.seed(seed) usuarios = [ ("alice", "empleado", 0.18), ("bob", "ingeniero", 0.22), ("cathy", "analista", 0.25), ("dan", "admin", 0.15), ("eve", "secops", 0.10), ("mallory", "empleado", 0.55) ] para u, r, br en usuarios: motor.register_principal(u, r, br) dispositivos = [ ("dev-alice-lt", "managed_laptop", "alice", 0.82, True), ("dev-bob-lt", "managed_laptop", "bob", 0.77, True), ("dev-cathy-lt", "managed_laptop", "cathy", 0.74, True), ("dev-dan-lt", "managed_laptop", "dan", 0.88, True), ("dev-eve-lt", "managed_laptop", "eve", 0.90, True), ("dev-mallory-byod", "byod_phone", "mallory", 0.42, False), ("unknown-iot-7", "unknown_iot", "unknown", 0.20, False), ] para did, dt, propietario, postura, atestiguado en dispositivos: motor.register_device(did, dt, propietario, postura, atestiguado) all_assets = [n para n en motor.G.nodes() if motor.G.nodes[n].get("kind") == "activo"] by_zone = {z: [a para a en all_assets if motor.G.nodes[a].get("zone") == z] para z en ZONAS} return {"usuarios": usuarios, "dispositivos": dispositivos, "activos": all_assets, "by_zone": by_zone} def gen_request(motor: ZeroTrustPolicyEngine, mundo: Dict[str, Any], tipo: str = "normal", seed_salt: str = "") -> RequestContext: rnd = random.Random(_stable_hash(kind + seed_salt + str(_now_ts())[:6])) usuarios = mundo["usuarios"] by_zone = mundo["by_zone"] def pick_user(role_bias: Opcional[str] = Ninguno) -> Tuple[str, str]: if role_bias: filtrado = [u para u en usuarios si u[1]== role_bias] si está filtrado: u, r, _ = rnd.choice(filtrado) devuelve u, r u, r, _ = rnd.choice(usuarios) devuelve u, r def user_device(u: str) -> Tupla[str, str, float]: candidatos = [d para d en motor.devices.values() si d.propietario == u] si candidatos: d = rnd.choice(candidatos) else: d = rnd.choice(list(engine.devices.values())) return d.device_id, d.device_type, d.posture def time_bucket(): return "business_hours" si rnd.random() < 0,75 else "after_hours" fuente = _rand_choice_weighted(NETWORK_CONTEXT, [0,45, 0.25, 0.22, 0.08]) geo_risk = _clamp(rnd.uniform(0.05, 0.35) + (0.25 si la fuente está en ["public_wifi", "tor_exit"] else 0.0)) conduct_anomaly = _clamp(rnd.uniform(0.02, 0.25)) data_volume = _clamp(rnd.uniform(0.02, 0.25)) if tipo == "normal": u, r = pick_user() hizo, dt, postura = user_device(u) src_zone = _rand_choice_weighted(["public", "dmz", "app"], [0.15, 0.55, 0.30]) dst_zone = _rand_choice_weighted(["dmz", "aplicación", "datos"], [0.35, 0.45, 0.20]) acción = _rand_choice_weighted(ACCIONES, [0.55, 0.28, 0.07, 0.08, 0.02]) src = rnd.choice(by_zone[src_zone]) dst = rnd.choice(by_zone[dst_zone]) mfa = Verdadero si dst_zone en ["data", "admin"] else (rnd.random() < 0.55) return RequestContext( user=u, role=r, device_id=did, device_type=dt, device_posture=posture, mfa=mfa, source=source, src_node=src, dst_node=dst, acción=acción, time_bucket=time_bucket(), geo_risk=geo_risk, conduct_anomaly=behavior_anomaly, data_volume=data_volume, Reason="routine_access" ) if kind == "malicious_flow": u, r = ("unknown_actor", "customer") hizo, dt, postura = ("unknown-dev", "unknown_iot", 0.18) fuente = _rand_choice_weighted(["tor_exit", "public_wifi"], [0.65, 0.35]) geo_risk = _clamp(rnd.uniform(0.6, 0.95)) conduct_anomaly = _clamp(rnd.uniform(0.75, 0.98)) data_volume = _clamp(rnd.uniform(0.75, 0.98)) src = rnd.choice(by_zone["public"] + by_zone["dmz"]) dst = rnd.choice(by_zone["data"] + by_zone["admin"]) action = _rand_choice_weighted(["write", "admin", "exfiltrate"], [0.25, 0.25, 0.50]) mfa = False return RequestContext( usuario=u, rol=r, dispositivo_id=did, dispositivo_tipo=dt, dispositivo_postura=postura, mfa=mfa, fuente=fuente, src_node=src, dst_node=dst, acción=acción, time_bucket="fuera de hora", geo_risk=geo_riesgo, comportamiento_anomaly=comportamiento_anomalía, volumen_datos=volumen_datos, Reason="external_malicious_attempt" ) if kind == "insider_threat": u, r = ("mallory", "employee") hizo, dt, postura = user_device(u) source = _rand_choice_weighted(["corp_vpn", "public_wifi"], [0.55, 0.45]) geo_risk = _clamp(rnd.uniform(0.25, 0.65)) anomalía_comportamiento = _clamp(rnd.uniform(0.55, 0.95)) volumen_datos = _clamp(rnd.uniform(0.55, 0.95)) src = rnd.choice(by_zone["app"] + by_zone["dmz"]) dst = rnd.choice(by_zone["data"] + by_zone["admin"]) action = _rand_choice_weighted(["read", "write", "exfiltrate", "admin"], [0.18, 0.22, 0.45, 0.15]) mfa = rnd.random() < 0.25 return RequestContext( usuario=u, rol=r, dispositivo_id=did, dispositivo_tipo=dt, dispositivo_postura=postura, mfa=mfa, fuente=fuente, src_node=src, dst_node=dst, acción=acción, time_bucket="after_hours", geo_risk=geo_risk, conduct_anomaly=behavior_anomaly, data_volume=data_volume, Reason="insider_lateral_and_exfil" ) rise ValueError(f"Tipo desconocido={tipo}") def run_simulation(motor: ZeroTrustPolicyEngine, mundo: Dict[str, Any], pasos: int = 60, semilla: int = 99) -> Dict[str, Any]: random.seed(seed) resultados = {"permitido": 0, "denegado": 0, "muestras":[]} para i en rango(pasos): if i en [12, 13, 14, 28, 29]: ctx = gen_request(motor, mundo, kind="malicious_flow", seed_salt=str(i)) elif i en [18, 19, 20, 34, 35, 36, 50, 51]: ctx = gen_request(motor, mundo, kind="insider_threat", seed_salt=str(i)) else: ctx = gen_request(motor, mundo, kind="normal", seed_salt=str(i)) dec = motor.evaluate(ctx) si dec.permitido: resultados["permitido"] += 1 más: resultados["denied"] += 1 si i < 10 o (no dec.permitido y len(resultados["muestras"]) < 18): resultados["muestras"].append({"ctx": ctx.__dict__, "decisión": dec.__dict__}) devuelve resultados
Generamos escenarios de tráfico realistas, incluida la actividad empresarial normal, flujos externos maliciosos e intentos de movimiento lateral interno. Simulamos variables contextuales, incluido el riesgo geográfico, las puntuaciones de anomalías y el volumen de datos, para poner a prueba el motor de políticas. Realizamos simulaciones de varios pasos para observar cómo cambian los puntajes de confianza y cómo el motor bloquea progresivamente comportamientos riesgosos.
def make_app(motor: ZeroTrustPolicyEngine, mundo: Dict[str, Any]) -> Flask: aplicación = Flask(__name__) @app.get("/health") def health(): return jsonify({"ok": True, "policy_version": motor.policy_version}) @app.get("/graph") def graph(): nodos = [{"id": n, **motor.G.nodes[n]} para n en motor.G.nodes()] bordes = [{"src": u, "dst": v, **motor.G.edges[u, v]} para u, v en motor.G.edges()] return jsonify({"nodes": nodos, "edges": bordes, "blocked_edges": list(map(list, motor.blocked_edges))}) @app.post("/request") def evaluar_request(): carga útil = request.get_json(force=True) ctx = RequestContext(**carga útil) dec = motor.evaluate(ctx) return jsonify({"allowed": dec.allowed, "trust_score": dec.trust_score, "rule_hits": dec.rule_hits, "controls": dec.controls, "explanation": dec.explanation}) @app.post("/simulate") def simular(): carga útil = request.get_json(force=True) if request.data else {} pasos = int(payload.get("pasos", 50)) res = run_simulation(motor, mundo, pasos=pasos, semilla=int(payload.get("seed", 123))) return jsonify({"pasos": pasos, "permitidos": res["permitido"], "denegado": res["denegado"], "stats": motor.stats()}) @app.get("/stats") def stats(): return jsonify(engine.stats()) return app G = build_microsegmented_graph(seed=7) motor = ZeroTrustPolicyEngine(G) mundo = make_world(motor, semilla=13) draw_graph(G, title="Red microsegmentada de confianza cero (zonas + activos + flujos dirigidos)") app = make_app(motor, mundo) client = app.test_client() print("== Health ==") print(client.get("/health").json) print("n== Ejecutar simulación (mezcla: normal + flujos maliciosos + amenaza interna) ==") sim_out = client.post("/simulate", json={"steps": 70, "seed": 2026}).json print(_pretty({"allowed": sim_out["allowed"], "denied": sim_out["denied"], "blocked_edges_count": sim_out["stats"]["blocked_edges_count"]})) print("n== Principales motivos de denegación ==") print(_pretty(sim_out["stats"]["deny_reasons_top"])) print("n== Instantánea de riesgo principal (ver mallory) ==") principales = sim_out["stats"]["principals"] focus = {k: principales[k] for k in sorted(principals.keys()) if k in ["alice","bob","cathy","dan","eve","mallory","unknown_actor"]} print(_pretty(focus)) print("n== Ejemplo: enviar una solicitud de exfiltración interna directa a través de la política API ==") insider_ctx = gen_request(engine, world, kind="insider_threat", seed_salt="manual-1") insider_ctx.action = "exfiltrar" insider_ctx.mfa = False insider_ctx.behavior_anomaly = 0,92 insider_ctx.data_volume = 0,88 insider_ctx.geo_risk = 0,62 resp = client.post("/request", json=insider_ctx.__dict__).json print(_pretty(resp)) print("n== Ejemplo: un administrador legítimo lee con MFA de corp_lan ==") admin_ctx = RequestContext( usuario="dan", rol="admin", dispositivo_id="dev-dan-lt", dispositivo_tipo="managed_laptop", dispositivo_posture=engine.devices["dev-dan-lt"].postura, mfa=True, source="corp_lan", src_node=random.choice(world["by_zone"]["admin"]), dst_node=random.choice(world["by_zone"]["data"]), action="read", time_bucket="business_hours", geo_risk=0.08, conduct_anomaly=0.06, data_volume=0.10, Reason="admin_operative_access" ) resp2 = client.post("/request", json=admin_ctx.__dict__).json print(_pretty(resp2)) print("n== Estadísticas finales ==") final_stats = client.get("/stats").json print(_pretty({ "flows_total": final_stats["flows_total"], "flows_allow": final_stats["flows_allow"], "flows_deny": final_stats["flows_deny"], "blocked_edges_count": final_stats["blocked_edges_count"], "deny_reasons_top": final_stats["deny_reasons_top"] })) puntuaciones = [r.decision["trust_score"] para r en motor.flow_log] plt.figure(figsize=(9, 4)) plt.hist(scores, bins=18) plt.title("Distribución de puntuación de confianza en simulaciones Flows") plt.xlabel("trust_score") plt.ylabel("count") plt.show() denegado = [r para r en motor.flow_log si no r.decision["allowed"]] print("n== Explicaciones denegadas recientes (últimas 6) ==") para r en denegado[-6:]: print("-", r.decision["explicación"])
Exponemos el motor de políticas a través de una API de Flask e interactuamos con él mediante un cliente de prueba para mantener el cuaderno autónomo. Realizamos simulaciones, inspeccionamos distribuciones de confianza, analizamos motivos de denegación y observamos el comportamiento de cuarentena y bloqueo de bordes. Concluimos visualizando patrones de puntuación de confianza y examinando explicaciones denegadas para validar la lógica de aplicación de Confianza Cero en acción.
En conclusión, demostramos cómo Zero Trust se convierte en un sistema programable y mensurable cuando la identidad, el estado del dispositivo, el contexto de la red y las señales de comportamiento se evalúan juntos para cada interacción. Vimos que el motor de políticas denegaba o intensificaba solicitudes riesgosas, limitaba las actividades de baja confianza y bloqueaba dinámicamente los bordes abusivos para evitar movimientos laterales repetidos y el robo de datos. Al combinar la segmentación basada en gráficos con una puntuación de confianza en evolución y respuestas automatizadas, terminamos con un marco repetible que podemos ampliar con una telemetría más rica, mejores modelos de anomalías y políticas específicas del entorno, manteniendo intacto el ciclo central de "nunca confiar, siempre verificar".
Consulte los códigos completos con Notebook. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 150.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
¿Necesita asociarse con nosotros para promocionar su repositorio de GitHub O su página principal de Hugging O su lanzamiento de producto O seminario web, etc.? Conéctate con nosotros
La publicación Cómo construir una simulación dinámica de red de confianza cero con microsegmentación basada en gráficos, motor de políticas adaptables y detección de amenazas internas apareció por primera vez en MarkTechPost.