Zero Trust con IA: identidad y autenticación adaptativa

TL;DR Zero Trust significa evaluar cada acceso según quién, desde dónde, con qué dispositivo y qué está pidiendo, en lugar de confiar en la red interna. La IA hace viable esa evaluación continua: aprende el comportamiento normal de cada identidad y ajusta la fricción (permitir, pedir MFA, bloquear) según el riesgo.

Durante años la seguridad se pensó como un castillo: muralla fuerte (el firewall) y confianza dentro. El teletrabajo, la nube y los ataques que empiezan robando credenciales derribaron ese modelo. Zero Trust lo sustituye por una idea simple, “nunca confíes, verifica siempre”, que solo es viable a escala con ayuda de la IA. En el libro IA en Ciberseguridad dedicamos capítulos a la protección de identidad y acceso y a la IA en Zero Trust Architecture; aquí tienes lo esencial.

Los principios de Zero Trust

La referencia es la publicación NIST SP 800-207. Resumida en tres ideas:

Verificar explícitamente: cada acceso se evalúa con todas las señales disponibles (identidad, dispositivo, ubicación, recurso, comportamiento), no solo con la contraseña.
Mínimo privilegio: acceso justo para la tarea y, cuando se pueda, solo durante el tiempo necesario.
Asumir la brecha: diseñar como si el atacante ya estuviera dentro: segmentar, cifrar y vigilar el movimiento lateral.

La identidad es el nuevo perímetro

Si los usuarios acceden a aplicaciones en la nube desde cualquier red, lo que separa a un empleado de un atacante con su contraseña robada no es la red, sino el contexto: el dispositivo, el lugar, la hora y lo que intenta hacer. Por eso los ataques modernos se centran en la identidad: phishing de credenciales, robo de tokens de sesión, fatiga de MFA (bombardear al usuario con solicitudes hasta que acepta una).

La respuesta es la autenticación adaptativa: la fricción se ajusta al riesgo de cada acceso.

Ejemplo: puntuación de riesgo de un login

Este ejemplo en Python muestra la lógica de una política adaptativa con reglas ponderadas. Es didáctico: un sistema real aprende los pesos y la línea base de cada usuario con machine learning, pero la decisión final tiene esta forma.

def riesgo_login(ctx: dict) -> int:
    """Devuelve un riesgo de 0 a 100 a partir del contexto del acceso."""
    score = 0
    if ctx["pais"] not in ctx["paises_habituales"]:
        score += 25
    if ctx["dispositivo_nuevo"]:
        score += 20
    if not ctx["dispositivo_gestionado"]:
        score += 15
    if ctx["viaje_imposible"]:
        score += 40
    if ctx["ip_con_mala_reputacion"]:
        score += 40
    if ctx["recurso_sensible"]:         # p. ej., consola de administración
        score += 15
    return min(score, 100)


def decidir(score: int) -> str:
    if score < 30:
        return "permitir"
    if score < 70:
        return "pedir_mfa_resistente_a_phishing"
    return "bloquear_y_alertar_al_soc"


ctx = {
    "pais": "BR", "paises_habituales": {"AR"},
    "dispositivo_nuevo": True, "dispositivo_gestionado": False,
    "viaje_imposible": False, "ip_con_mala_reputacion": False,
    "recurso_sensible": True,
}
print(decidir(riesgo_login(ctx)))   # 25 + 20 + 15 + 15 = 75 → bloquear_y_alertar_al_soc

Ejemplo: detectar un viaje imposible

Si una cuenta inicia sesión en Buenos Aires y, una hora después, en Madrid, una de las dos sesiones no es del usuario legítimo. Para detectarlo basta con calcular la velocidad necesaria entre dos accesos:

from math import asin, cos, radians, sin, sqrt

def distancia_km(lat1, lon1, lat2, lon2):
    """Distancia en km entre dos coordenadas (fórmula de haversine)."""
    lat1, lon1, lat2, lon2 = map(radians, (lat1, lon1, lat2, lon2))
    a = sin((lat2 - lat1) / 2) ** 2 + cos(lat1) * cos(lat2) * sin((lon2 - lon1) / 2) ** 2
    return 2 * 6371 * asin(sqrt(a))

def viaje_imposible(acceso_1, acceso_2, vel_max_kmh=900):
    horas = abs(acceso_2["ts"] - acceso_1["ts"]) / 3600
    km = distancia_km(acceso_1["lat"], acceso_1["lon"], acceso_2["lat"], acceso_2["lon"])
    if km < 100:            # la geolocalización por IP es imprecisa a corta distancia
        return False
    return horas == 0 or km / horas > vel_max_kmh

buenos_aires = {"ts": 0,    "lat": -34.60, "lon": -58.38}
madrid       = {"ts": 3600, "lat": 40.42,  "lon": -3.70}
print(viaje_imposible(buenos_aires, madrid))   # True: ~10.000 km en 1 hora

Las VPN corporativas, los proxies en la nube y los móviles que cambian de red generan falsos positivos de viaje imposible. Mantén una lista de rangos de IP conocidos y combina esta señal con otras antes de bloquear.

Dónde aporta la IA

Líneas base por identidad: en lugar de reglas iguales para todos, aprender los horarios, ubicaciones, dispositivos y aplicaciones habituales de cada persona.
Evaluación continua: no solo al iniciar sesión, sino durante toda la sesión. Un usuario que de repente descarga miles de archivos merece una nueva verificación.
Detección de robo de sesión: un token válido usado desde un dispositivo o una red que no encajan con el resto de la sesión.
Gobierno de accesos: detectar permisos que nadie usa para retirarlos y reducir la superficie de ataque.

Por dónde empezar

MFA en todas las cuentas, empezando por administradores y accesos remotos, y preferiblemente resistente a phishing (llaves FIDO2 o passkeys).
Inventario de dispositivos y aplicaciones: no se puede evaluar el contexto de lo que no se conoce.
Políticas de acceso condicional, con reglas como las del ejemplo, en modo solo informe al principio para medir el impacto.
Enviar las señales de riesgo al SOC para que los accesos bloqueados se investiguen.
Segmentar la red para limitar el movimiento lateral si una identidad se ve comprometida.

Zero Trust e identidad, con IA

El libro IA en Ciberseguridad trata la IA en la protección de identidad y acceso y en arquitecturas Zero Trust, en dos capítulos dedicados.

Comprar en Amazon