Ataque HTTP/2 Rapid Reset

Cómo Funciona Ataque HTTP/2 Rapid Reset

HTTP/2 introdujo la multiplexación de streams: múltiples intercambios concurrentes de solicitud/respuesta sobre una sola conexión TCP, identificados por IDs de stream. El protocolo incluye frames RST_STREAM para cancelar streams individuales — un mecanismo legítimo para cancelar descargas o abortar solicitudes innecesarias. El ataque Rapid Reset lo convierte en arma explotando una asimetría en el diseño del protocolo: enviar un frame HEADERS (abriendo un stream) le cuesta al cliente aproximadamente 9 bytes de sobrecarga de framing, mientras que el servidor debe asignar memoria para el estado del stream, analizar los encabezados (potencialmente descomprimiendo encabezados codificados con HPACK), inicializar la lógica de enrutamiento de solicitudes, asignar buffers y comenzar a procesar la solicitud. Cuando el RST_STREAM llega milisegundos después, el servidor debe entonces liberar todas esas asignaciones y limpiar los recursos. Este ciclo de asignación-liberación, repetido millones de veces por segundo a través de miles de conexiones, abruma la CPU y la memoria del servidor sin generar tráfico de respuesta significativo — el servidor queda atrapado en un bucle infinito de configuración y limpieza.

Ejemplos Reales

Impacto y Evaluación de Riesgo

HTTP/2 Rapid Reset representa un cambio de paradigma en DDoS a nivel de aplicación porque explota un fallo de diseño del protocolo en lugar de abrumar el ancho de banda o explotar errores de implementación. El ataque logra tasas de solicitud 10-100 veces más altas que las inundaciones HTTP tradicionales mientras usa una fracción del ancho de banda, haciéndolo excepcionalmente rentable para los atacantes. El impacto se amplifica por el despliegue casi universal de HTTP/2: más del 35% de todos los sitios web usan HTTP/2 a partir de 2024, y virtualmente cada servidor web moderno, nodo de borde de CDN, gateway de API y balanceador de carga implementa el protocolo. El costo del lado del servidor está dominado por el consumo de CPU (gestión del ciclo de vida de streams, descompresión HPACK, enrutamiento de solicitudes) en lugar del ancho de banda, lo que significa que las mitigaciones DDoS volumétricas tradicionales son ineficaces. Las fallas en cascada son comunes: los proxies frontend abrumados pasan solicitudes parciales a los backends, saturando los servidores de aplicación y los pools de conexiones a base de datos. La sigilosidad del ataque es notable — porque RST_STREAM cancela la solicitud antes de que se genere una respuesta, los registros de acceso pueden no capturar el tráfico de ataque, y la limitación de tasa tradicional basada en solicitudes no se activa porque ninguna solicitud se 'completa.'

Cómo Detectar Ataque HTTP/2 Rapid Reset

Monitorear métricas a nivel de frames HTTP/2, no solo conteos de solicitudes/respuestas. El indicador definitivo es una alta proporción de frames RST_STREAM respecto a respuestas completadas — durante la operación normal, RST_STREAM representa menos del 1% de los cierres de stream; durante un ataque Rapid Reset, se acerca al 100%. Rastrear la tasa de creación de streams por conexión: los clientes legítimos rara vez exceden 10-20 streams concurrentes, mientras que las conexiones de ataque reciclan miles de IDs de stream por segundo. Monitorear la brecha entre frames HEADERS y RST_STREAM — durante los ataques, RST_STREAM llega dentro del mismo segmento TCP o dentro de 1-2 RTTs del frame HEADERS, un patrón nunca visto en la navegación legítima. Correlacionar los picos de utilización de CPU con las métricas de conexión HTTP/2: un aumento de CPU sin un aumento correspondiente en solicitudes completadas o bytes de respuesta indica sobrecarga de procesamiento por la rotación del ciclo de vida de streams. Verificar los registros de error del servidor web en busca de patrones de reinicio de conexión y altas tasas de estado 499 (cliente cerró la conexión) o entradas de cancelación de stream. Implementar registro a nivel de frames HTTP/2 (disponible en compilaciones de depuración de Nginx y HAProxy a nivel de registro de tráfico) para capturar secuencias de frames HEADERS/RST_STREAM para análisis forense.

Cómo Prevenir Ataque HTTP/2 Rapid Reset

Parchear todas las implementaciones HTTP/2 inmediatamente — esta es la acción más crítica. Aplicar parches de proveedores para: Nginx (directiva http2_max_concurrent_streams + limitación de tasa de RST_STREAM), Apache (mod_http2 con limitación de tasa de streams), HAProxy (tune.h2.max-concurrent-streams + contabilidad de RST_STREAM), Node.js, Go, .NET Kestrel y todas las demás bibliotecas HTTP/2 en su stack. Configurar límites de tasa de streams por conexión: limitar el número total de streams creados (no solo concurrentes) dentro de una ventana de tiempo — por ejemplo, no más de 100 nuevos streams por segundo por conexión. Implementar limitación de tasa de RST_STREAM: desconectar conexiones que envían frames RST_STREAM a una tasa que exceda un umbral configurable (por ejemplo, 50 RST_STREAMs por segundo). Reducir SETTINGS_MAX_CONCURRENT_STREAMS al mínimo requerido para su aplicación (típicamente 64-128 en lugar del valor predeterminado de 256). Desplegar un proxy reverso o balanceador de carga como frontend que absorba la complejidad de conexiones HTTP/2 y reenvíe solo solicitudes validadas y completas a los servidores backend usando HTTP/1.1. Habilitar limitación de tasa a nivel de conexión basada en patrones de ciclo de vida de streams en lugar de solo conteo de solicitudes. Para entornos donde HTTP/2 no es requerido, considerar degradar a HTTP/1.1 como mitigación temporal hasta que toda la infraestructura esté parcheada. Desplegar un WAF con inspección a nivel de protocolo HTTP/2 que pueda detectar y bloquear patrones Rapid Reset en tiempo real.

Ejemplos de Código

# Nginx configuration hardened against HTTP/2 Rapid Reset (CVE-2023-44487)
# Requires Nginx ≥ 1.25.3 (or backported security patch)

worker_processes auto;
worker_rlimit_nofile 65535;

events {
    worker_connections 65535;
    multi_accept on;
    use epoll;
}

http {
    # === HTTP/2 stream limits ===

    # Maximum concurrent streams per connection (default 128)
    # Lower values reduce Rapid Reset impact but may slow legitimate multiplexing
    http2_max_concurrent_streams 64;

    # Maximum number of requests per HTTP/2 connection before forcing reconnect
    # Limits total stream IDs an attacker can cycle through
    keepalive_requests 1000;

    # Connection idle timeout — close unused connections quickly
    keepalive_timeout 15s;

    # === Rate limiting at the request level ===
    limit_req_zone $binary_remote_addr zone=http2_rate:10m rate=50r/s;
    limit_conn_zone $binary_remote_addr zone=http2_conn:10m;

    server {
        listen 443 ssl;
        http2 on;

        ssl_certificate     /etc/ssl/certs/server.crt;
        ssl_certificate_key /etc/ssl/private/server.key;

        # TLS 1.2+ only (HTTP/2 requires TLS)
        ssl_protocols TLSv1.2 TLSv1.3;

        # Limit connections per IP
        limit_conn http2_conn 20;

        # Limit request rate per IP
        limit_req zone=http2_rate burst=100 nodelay;

        # Aggressive timeouts for request processing
        client_header_timeout  5s;
        client_body_timeout    10s;
        send_timeout           10s;

        location / {
            proxy_pass http://backend;
            proxy_http_version 1.1;  # Forward to backends as HTTP/1.1
            proxy_set_header Connection "";
            proxy_connect_timeout 3s;
            proxy_read_timeout    15s;
        }
    }
}

import re
import time
import logging
from collections import defaultdict
from datetime import datetime, timedelta

logger = logging.getLogger('rapid_reset_detector')

def parse_nginx_log_line(line):
    """Parse Nginx combined log format with HTTP/2 info"""
    # Pattern: IP - - [timestamp] "METHOD URI PROTO" status bytes "ref" "ua"
    pattern = (
        r'(\S+) \S+ \S+ \[([^\]]+)\] '
        r'"(\S+) (\S+) (\S+)" (\d+) (\d+) '
        r'"([^"]*)" "([^"]*)"'
    )
    match = re.match(pattern, line)
    if not match:
        return None
    return {
        'ip': match.group(1),
        'timestamp': match.group(2),
        'method': match.group(3),
        'uri': match.group(4),
        'protocol': match.group(5),
        'status': int(match.group(6)),
        'bytes': int(match.group(7)),
        'user_agent': match.group(9)
    }

def detect_rapid_reset_patterns(
    log_file='/var/log/nginx/access.log',
    window_seconds=10,
    status_499_threshold=50,
    zero_bytes_threshold=100
):
    """Detect HTTP/2 Rapid Reset indicators in Nginx access logs.

    Key indicators:
    - Status 499: client closed connection before response (RST_STREAM)
    - Status 0: connection reset with no response sent
    - 0-byte responses: request cancelled before body sent
    - HTTP/2 protocol with high request rates from single IPs
    """
    ip_windows = defaultdict(lambda: {
        'total': 0, 'status_499': 0, 'status_0': 0,
        'zero_bytes': 0, 'http2_requests': 0,
        'user_agents': set()
    })

    with open(log_file, 'r') as f:
        for line in f:
            entry = parse_nginx_log_line(line.strip())
            if not entry:
                continue

            ip = entry['ip']
            stats = ip_windows[ip]
            stats['total'] += 1

            if entry['status'] == 499:
                stats['status_499'] += 1
            elif entry['status'] == 0:
                stats['status_0'] += 1

            if entry['bytes'] == 0:
                stats['zero_bytes'] += 1

            if 'HTTP/2' in entry['protocol']:
                stats['http2_requests'] += 1

            stats['user_agents'].add(entry['user_agent'])

    # Analyze for Rapid Reset patterns
    alerts = []
    for ip, stats in ip_windows.items():
        if stats['total'] < 10:
            continue

        cancelled_pct = (stats['status_499'] + stats['status_0']) / stats['total'] * 100
        zero_bytes_pct = stats['zero_bytes'] / stats['total'] * 100

        # Rapid Reset signature: high cancellation rate + HTTP/2 + high volume
        is_suspicious = (
            cancelled_pct > 80 and
            stats['http2_requests'] > stats['total'] * 0.5 and
            stats['total'] > status_499_threshold
        )

        if is_suspicious:
            alerts.append({
                'ip': ip,
                'total_requests': stats['total'],
                'cancelled_pct': round(cancelled_pct, 1),
                'zero_bytes_pct': round(zero_bytes_pct, 1),
                'http2_pct': round(stats['http2_requests'] / stats['total'] * 100, 1),
                'user_agents': len(stats['user_agents']),
                'severity': 'critical' if stats['total'] > 1000 else 'high'
            })
            logger.critical(
                f'RAPID RESET PATTERN: {ip} — {stats["total"]} requests, '
                f'{cancelled_pct:.0f}% cancelled, {stats["http2_requests"]} HTTP/2'
            )

    return alerts

if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    alerts = detect_rapid_reset_patterns()
    print(f'Detected {len(alerts)} suspicious IPs')
    for alert in alerts:
        print(f'  {alert["ip"]}: {alert["total_requests"]} req, '
              f'{alert["cancelled_pct"]}% cancelled')

#!/bin/bash
# Audit script to verify HTTP/2 components are patched against
# CVE-2023-44487 (Rapid Reset). Run on each server in your infrastructure.

echo "=== HTTP/2 Rapid Reset (CVE-2023-44487) Patch Audit ==="
echo

# Check Nginx
if command -v nginx &>/dev/null; then
    version=$(nginx -v 2>&1 | grep -oP '[\d.]+')
    echo "Nginx: $version"
    if [[ "$(printf '%s\n' "1.25.3" "$version" | sort -V | head -1)" == "1.25.3" ]]; then
        echo "  ✓ Patched (≥ 1.25.3)"
    else
        echo "  ✗ VULNERABLE — update to ≥ 1.25.3"
    fi
    # Check if stream limits are configured
    if nginx -T 2>/dev/null | grep -q 'http2_max_concurrent_streams'; then
        echo "  ✓ http2_max_concurrent_streams configured"
    else
        echo "  ! http2_max_concurrent_streams not set (using default)"
    fi
fi

# Check Apache
if command -v httpd &>/dev/null || command -v apache2 &>/dev/null; then
    version=$(httpd -v 2>/dev/null || apache2 -v 2>/dev/null | grep -oP '[\d.]+')
    echo "Apache: $version"
    if [[ "$(printf '%s\n' "2.4.58" "$version" | sort -V | head -1)" == "2.4.58" ]]; then
        echo "  ✓ Patched (≥ 2.4.58)"
    else
        echo "  ✗ VULNERABLE — update to ≥ 2.4.58"
    fi
fi

# Check HAProxy
if command -v haproxy &>/dev/null; then
    version=$(haproxy -v 2>&1 | grep -oP '[\d.]+')
    echo "HAProxy: $version"
fi

# Check Node.js
if command -v node &>/dev/null; then
    version=$(node -v | tr -d 'v')
    echo "Node.js: $version"
    major=$(echo "$version" | cut -d. -f1)
    if [[ $major -ge 21 ]]; then
        echo "  ✓ Major version ≥ 21"
    elif [[ $major -eq 20 ]]; then
        if [[ "$(printf '%s\n' "20.8.1" "$version" | sort -V | head -1)" == "20.8.1" ]]; then
            echo "  ✓ Patched (≥ 20.8.1)"
        else
            echo "  ✗ VULNERABLE — update to ≥ 20.8.1"
        fi
    elif [[ $major -eq 18 ]]; then
        if [[ "$(printf '%s\n' "18.18.2" "$version" | sort -V | head -1)" == "18.18.2" ]]; then
            echo "  ✓ Patched (≥ 18.18.2)"
        else
            echo "  ✗ VULNERABLE — update to ≥ 18.18.2"
        fi
    fi
fi

# Check Go
if command -v go &>/dev/null; then
    version=$(go version | grep -oP '[\d.]+')
    echo "Go: $version"
    if [[ "$(printf '%s\n' "1.21.3" "$version" | sort -V | head -1)" == "1.21.3" ]]; then
        echo "  ✓ Patched (≥ 1.21.3)"
    else
        echo "  ✗ VULNERABLE — update to ≥ 1.21.3"
    fi
fi

# Check if HTTP/2 is enabled on common ports
echo
echo "=== HTTP/2 Exposure Check ==="
for port in 443 8443 8080; do
    if ss -tlnp | grep -q ":${port} "; then
        echo "Port $port: LISTENING"
    fi
done

Preguntas Frecuentes

Ataques Relacionados