Autenticación Rota

Cómo Funciona Autenticación Rota

La autenticación rota explota fallos fundamentales en cómo las aplicaciones verifican la identidad del usuario y gestionan las sesiones autenticadas. A diferencia de ataques dirigidos como la fuerza bruta o el credential stuffing, la autenticación rota describe debilidades sistémicas en la arquitectura de autenticación — las decisiones de diseño y errores de implementación que hacen posibles esos ataques dirigidos. Un solo fallo de autenticación rota puede socavar todo el modelo de seguridad de una aplicación, porque la autenticación es la puerta de entrada a toda la funcionalidad autorizada.

Ejemplos Reales

Impacto y Evaluación de Riesgo

La autenticación rota se clasifica consistentemente entre las vulnerabilidades de aplicaciones web más críticas porque socava directamente el límite de seguridad fundamental entre usuarios autenticados y no autenticados. La explotación exitosa otorga a los atacantes el mismo acceso que los usuarios legítimos — o administradores — sin activar los controles de autorización. El impacto incluye toma masiva de cuentas, acceso no autorizado a datos sensibles, fraude financiero, robo de identidad, violaciones regulatorias (GDPR, HIPAA, PCI DSS) y destrucción reputacional. En entornos empresariales, la autenticación comprometida puede proporcionar el punto de entrada inicial para amenazas persistentes avanzadas (APTs), permitiendo movimiento lateral, escalación de privilegios y exfiltración de datos a largo plazo. El Informe de Investigaciones de Brechas de Datos de Verizon de 2023 encontró que las credenciales robadas estuvieron involucradas en el 49% de todas las brechas de datos.

Cómo Detectar Autenticación Rota

Monitorear los sistemas de autenticación en busca de patrones anómalos: altas tasas de intentos de inicio de sesión fallidos, inicios de sesión exitosos desde ubicaciones geográficas o direcciones IP inusuales, sesiones activas simultáneas desde diferentes ubicaciones, inicios de sesión fuera del horario laboral normal, y solicitudes de restablecimiento de contraseña para cuentas sin cambios posteriores de contraseña. Implementar detección de anomalías de sesión para identificar tokens robados o falsificados — cambios repentinos en user agent, dirección IP o huella digital del dispositivo a mitad de sesión indican secuestro de sesión. Registrar todos los eventos de autenticación con metadatos contextuales (IP, user agent, ID de dispositivo, geolocalización) e implementar alertas en tiempo real sobre patrones de autenticación de alto riesgo. Realizar auditorías regulares del almacenamiento de credenciales para asegurar algoritmos de hashing y uso de salt adecuados. Probar los flujos de restablecimiento de contraseña para detectar fugas de información y predictibilidad de tokens.

Cómo Prevenir Autenticación Rota

Implementar autenticación multifactor (MFA) para todas las cuentas de usuario, especialmente el acceso administrativo — MFA mitiga la mayoría de los ataques basados en credenciales. Aplicar políticas de contraseñas fuertes: mínimo 12 caracteres, verificar contra listas de brechas conocidas (HaveIBeenPwned) y prevenir patrones de contraseñas comunes. Usar bcrypt, scrypt o Argon2id para el hashing de contraseñas con factores de trabajo apropiados. Implementar gestión de sesiones adecuada: generar tokens de sesión criptográficamente aleatorios (mínimo 128 bits de entropía), rotar tokens después de la autenticación, establecer tiempos de expiración apropiados e invalidar sesiones al cerrar sesión y cambiar contraseña. Establecer los atributos Secure, HttpOnly y SameSite en las cookies de sesión. Implementar bloqueo de cuenta con retroceso exponencial después de intentos fallidos. Usar flujos seguros de restablecimiento de contraseña con tokens de un solo uso, limitados en tiempo y criptográficamente aleatorios. Implementar limitación de velocidad en todos los endpoints de autenticación. Las pruebas de seguridad regulares deben incluir casos de prueba específicos de autenticación que cubran gestión de credenciales, manejo de sesiones y escenarios de bypass de autenticación.

Ejemplos de Código

import hashlib
import time

# VULNERABLE: Predictable session token generation
def create_session_vulnerable(user_id):
    # Token based on timestamp + user_id — predictable!
    token = hashlib.md5(f"{time.time()}{user_id}".encode()).hexdigest()
    return token

# VULNERABLE: Session doesn't expire, no rotation
sessions = {}

def login_vulnerable(username, password):
    user = db.query("SELECT * FROM users WHERE username = %s", (username,))
    # Weak: plain comparison, no hashing
    if user and user.password == password:
        token = create_session_vulnerable(user.id)
        sessions[token] = {'user_id': user.id}  # Never expires!
        return token
    return None

import secrets
import bcrypt
from datetime import datetime, timedelta

SESSION_TIMEOUT = timedelta(hours=1)
MAX_FAILED_ATTEMPTS = 5
LOCKOUT_DURATION = timedelta(minutes=15)

def hash_password(password):
    """Hash password with bcrypt (work factor 12)"""
    return bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))

def verify_password(password, hashed):
    """Constant-time password verification"""
    return bcrypt.checkpw(password.encode(), hashed)

def create_session_secure(user_id):
    """Generate cryptographically random session token"""
    token = secrets.token_urlsafe(32)  # 256 bits of entropy
    session_store.set(token, {
        'user_id': user_id,
        'created_at': datetime.utcnow(),
        'last_activity': datetime.utcnow(),
        'ip': request.remote_addr,
        'user_agent': request.headers.get('User-Agent')
    }, ex=int(SESSION_TIMEOUT.total_seconds()))
    return token

def login_secure(username, password):
    """Secure login with rate limiting and session rotation"""
    # Check account lockout
    attempts = get_failed_attempts(username)
    if attempts >= MAX_FAILED_ATTEMPTS:
        lockout_until = get_lockout_time(username)
        if datetime.utcnow() < lockout_until:
            raise AuthError('Account temporarily locked')

    user = db.query("SELECT * FROM users WHERE username = %s", (username,))
    
    # Constant-time response whether user exists or not
    if not user or not verify_password(password, user.password_hash):
        increment_failed_attempts(username)
        # Generic message — don't reveal if username exists
        raise AuthError('Invalid username or password')

    # Reset failed attempts on success
    reset_failed_attempts(username)
    
    # Invalidate any existing sessions (prevent session fixation)
    invalidate_user_sessions(user.id)
    
    # Generate new session token
    token = create_session_secure(user.id)
    
    # Audit log
    log_auth_event('login_success', user.id, request.remote_addr)
    
    return token

const session = require('express-session');
const RedisStore = require('connect-redis').default;
const crypto = require('crypto');

app.use(session({
  store: new RedisStore({ client: redisClient }),
  
  // Cryptographically random secret
  secret: process.env.SESSION_SECRET,
  
  // Session configuration
  name: '__Host-sid',  // __Host- prefix enforces Secure + no Domain
  resave: false,
  saveUninitialized: false,
  
  cookie: {
    secure: true,      // HTTPS only
    httpOnly: true,     // No JavaScript access
    sameSite: 'lax',   // CSRF protection
    maxAge: 3600000,   // 1 hour expiration
    path: '/',
  },
  
  // Generate secure session IDs
  genid: () => crypto.randomBytes(32).toString('hex'),
  
  // Rolling expiration — extends on activity
  rolling: true,
}));

// Rotate session ID after authentication
app.post('/login', async (req, res) => {
  const user = await authenticate(req.body);
  if (!user) return res.status(401).json({ error: 'Invalid credentials' });

  // Regenerate session to prevent fixation
  req.session.regenerate((err) => {
    if (err) return res.status(500).json({ error: 'Session error' });
    req.session.userId = user.id;
    req.session.loginTime = Date.now();
    res.json({ success: true });
  });
});

// Proper logout — destroy session server-side
app.post('/logout', (req, res) => {
  req.session.destroy((err) => {
    res.clearCookie('__Host-sid');
    res.json({ success: true });
  });
});

Preguntas Frecuentes

Ataques Relacionados