Secuestro de Sesión

Cómo Funciona Secuestro de Sesión

Las aplicaciones web utilizan tokens de sesión (generalmente almacenados en cookies) para mantener el estado después de la autenticación. El token actúa como una credencial al portador: quien lo presente es tratado como el usuario autenticado. El secuestro de sesión apunta a este token a través de varios vectores — intercepción de red, cross-site scripting, malware o explotación de generación débil de tokens. A diferencia del robo de credenciales, el secuestro de sesión evade la autenticación multifactor por completo porque la sesión ya está establecida después de la autenticación.

Ejemplos Reales

Impacto y Evaluación de Riesgo

El secuestro de sesión proporciona al atacante acceso completo a la sesión autenticada de la víctima, evadiendo todos los mecanismos de autenticación incluyendo la autenticación multifactor. El impacto es equivalente a una toma de control total de la cuenta: los atacantes pueden acceder a datos sensibles, modificar configuraciones de la cuenta, realizar transacciones financieras, suplantar al usuario en comunicaciones y potencialmente escalar a acceso administrativo. En entornos empresariales, una sesión de administrador secuestrada puede comprometer toda la aplicación y sus datos. El secuestro de sesión es particularmente peligroso porque deja evidencia forense mínima — las acciones del atacante aparecen como actividad legítima del usuario en los registros de auditoría. La detección es difícil porque la sesión es genuinamente válida y los controles de seguridad tradicionales (firewalls, IDS/IPS) no pueden inspeccionar valores de cookies cifradas.

Cómo Detectar Secuestro de Sesión

Implementar detección de anomalías de sesión: monitorear cambios repentinos en las características del cliente durante la sesión, incluyendo cambios de dirección IP (especialmente entre regiones geográficas), cambios en la cadena de User Agent, cambios en la huella digital del dispositivo y patrones de viaje imposible (inicio de sesión desde Nueva York, luego Londres minutos después). Rastrear sesiones concurrentes por usuario y alertar cuando el mismo token de sesión se use desde múltiples direcciones IP simultáneamente. Registrar eventos del ciclo de vida de la sesión (creación, actividad, renovación, destrucción) con metadatos del cliente para análisis forense. Monitorear indicadores de XSS que podrían permitir el robo de cookies — los informes de violación de CSP frecuentemente señalan intentos de explotación activos. Implementar validación de sesión del lado del servidor que compare la huella digital original del cliente de la sesión con cada solicitud.

Cómo Prevenir Secuestro de Sesión

Generar tokens de sesión usando generadores de números aleatorios criptográficamente seguros con al menos 128 bits de entropía. Configurar los atributos de seguridad de las cookies: HttpOnly (previene el acceso por JavaScript, bloqueando el robo vía XSS), Secure (transmite solo sobre HTTPS, previniendo la captura de red), SameSite=Lax o Strict (previene ataques de solicitud entre sitios) y restricciones apropiadas de Domain/Path. Forzar HTTPS en todas partes — redirigir todas las solicitudes HTTP a HTTPS y usar cabeceras HSTS con max-age largo. Rotar los tokens de sesión inmediatamente después de la autenticación para prevenir la fijación de sesión. Implementar tiempos de espera absolutos de sesión (tiempo de vida máximo independientemente de la actividad) y tiempos de espera por inactividad (expiración tras inactividad). Vincular las sesiones a atributos del cliente (rango de IP, huella TLS) cuando sea factible, rechazando sesiones que muestren cambios significativos del cliente. Invalidar sesiones al cerrar sesión, al cambiar la contraseña y al escalar privilegios. Desplegar cabeceras de Content Security Policy (CSP) para mitigar XSS. Usar el prefijo de cookie __Host- para forzar Secure y prevenir la manipulación del alcance de subdominios.

Ejemplos de Código

const session = require('express-session');

// VULNERABLE: Multiple security issues
app.use(session({
  secret: 'mysecret',        // Weak, hardcoded secret
  name: 'sessionid',          // Predictable name
  cookie: {
    // secure: false,         // Default — sent over HTTP!
    // httpOnly: false,       // Accessible via JavaScript!
    // sameSite: 'none',      // Sent on cross-origin requests!
    maxAge: 30 * 24 * 3600000 // 30 days — excessively long!
  },
  resave: true,
  saveUninitialized: true,    // Creates sessions for unauthenticated users
}));

// VULNERABLE: No session regeneration on login
app.post('/login', async (req, res) => {
  const user = await authenticate(req.body.username, req.body.password);
  if (user) {
    // Session fixation: same session ID before and after auth!
    req.session.userId = user.id;
    res.redirect('/dashboard');
  }
});

// VULNERABLE: Session not destroyed on logout
app.post('/logout', (req, res) => {
  req.session.userId = null;  // Only clears data, session persists!
  res.redirect('/login');
});

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

app.use(session({
  store: new RedisStore({ client: redisClient, ttl: 3600 }),
  secret: process.env.SESSION_SECRET,  // Strong, env-stored secret
  name: '__Host-sid',                  // __Host- enforces Secure + no Domain
  resave: false,
  saveUninitialized: false,            // No sessions for unauthenticated users
  rolling: true,                       // Reset expiry on activity
  genid: () => crypto.randomBytes(32).toString('hex'),
  cookie: {
    secure: true,                      // HTTPS only
    httpOnly: true,                    // No JavaScript access
    sameSite: 'lax',                   // Cross-site protection
    maxAge: 3600000,                   // 1 hour
    path: '/',
  },
}));

// Secure login with session regeneration
app.post('/login', async (req, res) => {
  const user = await authenticate(req.body.username, req.body.password);
  if (!user) return res.status(401).json({ error: 'Invalid credentials' });

  // Regenerate session ID to prevent fixation
  const oldSession = { ...req.session };
  req.session.regenerate((err) => {
    if (err) return res.status(500).json({ error: 'Session error' });
    
    req.session.userId = user.id;
    req.session.loginTime = Date.now();
    req.session.clientIP = req.ip;
    req.session.userAgent = req.get('User-Agent');
    
    res.json({ success: true });
  });
});

// Session binding middleware — detect hijacking
function sessionGuard(req, res, next) {
  if (!req.session.userId) return next();
  
  // Detect significant client changes mid-session
  const currentIP = req.ip;
  const currentUA = req.get('User-Agent');
  
  if (req.session.userAgent && req.session.userAgent !== currentUA) {
    // User agent changed — possible hijacking
    req.session.destroy();
    return res.status(401).json({ error: 'Session invalidated' });
  }
  
  next();
}
app.use(sessionGuard);

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

from flask import Flask, request, session, abort
from functools import wraps
import hashlib
import logging

logger = logging.getLogger('security')

def fingerprint_client():
    """Generate a fingerprint of the client's characteristics"""
    components = [
        request.headers.get('User-Agent', ''),
        request.headers.get('Accept-Language', ''),
        request.headers.get('Accept-Encoding', ''),
    ]
    return hashlib.sha256('|'.join(components).encode()).hexdigest()[:16]

def session_guard(f):
    """Middleware to detect session hijacking indicators"""
    @wraps(f)
    def decorated(*args, **kwargs):
        if 'user_id' not in session:
            return f(*args, **kwargs)
        
        current_fp = fingerprint_client()
        stored_fp = session.get('client_fingerprint')
        
        if stored_fp and current_fp != stored_fp:
            logger.warning(
                'Session anomaly detected: fingerprint mismatch '
                f'user={session["user_id"]} '
                f'ip={request.remote_addr} '
                f'expected_fp={stored_fp} '
                f'actual_fp={current_fp}'
            )
            session.clear()
            abort(401)
        
        # Update fingerprint on first request
        if not stored_fp:
            session['client_fingerprint'] = current_fp
        
        return f(*args, **kwargs)
    return decorated

Preguntas Frecuentes

Ataques Relacionados