Ataque de Inundación UDP

Cómo Funciona Ataque de Inundación UDP

UDP es inherentemente vulnerable a las inundaciones porque no proporciona estado de conexión, autenticación ni control de flujo. Un emisor puede transmitir datagramas UDP a cualquier combinación IP:puerto sin negociación previa, y el host receptor debe procesar cada paquete para determinar si un servicio está escuchando. Cuando un paquete UDP llega a un puerto cerrado, el kernel del sistema operativo genera un mensaje ICMP Port Unreachable — consumiendo CPU y ancho de banda de salida. Cuando llega a un puerto abierto (DNS en 53, NTP en 123, SNMP en 161), la aplicación en escucha debe analizar y rechazar los datos malformados, consumiendo recursos a nivel de aplicación. A altas tasas de paquetes (millones de paquetes por segundo), la tarjeta de interfaz de red del objetivo, la pila de red del kernel y las tablas de seguimiento de conexiones del firewall se convierten en cuellos de botella. A diferencia de las inundaciones TCP que explotan el estado del protocolo, las inundaciones UDP son ataques puros de agotamiento de ancho de banda — la única defensa es tener más capacidad que el atacante o filtrar upstream.

Ejemplos Reales

Impacto y Evaluación de Riesgo

Las inundaciones UDP son la técnica DDoS volumétrica más simple y común, representando aproximadamente el 55-62% de todos los ataques DDoS por volumen. Su efectividad proviene de la combinación de la naturaleza sin estado de UDP (sin handshake significa falsificación ilimitada), la disponibilidad de botnets masivas y la física fundamental de la saturación de ancho de banda — ninguna cantidad de endurecimiento del servidor ayuda cuando el tubo de red está lleno. El impacto se extiende más allá del objetivo: los entornos de hosting compartido ven a todos los clientes afectados cuando uno es atacado; los enlaces de ISP upstream pueden saturarse, causando daño colateral a redes no relacionadas; y los dispositivos de seguridad con estado (firewalls, IDS) a lo largo del camino pueden fallar bajo la carga de rastrear millones de flujos UDP. Los servicios dependientes de UDP se ven desproporcionadamente afectados: las llamadas VoIP se cortan con tan solo un 1% de pérdida de paquetes, los juegos en línea se vuelven injugables con 50ms de latencia adicional y la resolución DNS falla cuando el puerto UDP 53 se ve abrumado. El impacto financiero escala con la duración del tiempo de inactividad — las compañías de gaming reportan pérdidas de $25,000-$40,000 por hora durante ataques DDoS, mientras que las empresas con obligaciones de SLA enfrentan penalidades contractuales además de la pérdida directa de ingresos.

Cómo Detectar Ataque de Inundación UDP

Monitorear las tasas de paquetes UDP entrantes y compararlas con las líneas base establecidas — un servidor web típico recibe tráfico UDP mínimo (principalmente respuestas DNS y NTP), por lo que un pico repentino de cientos a cientos de miles de paquetes por segundo es un indicador claro. Rastrear la proporción de tráfico UDP respecto a TCP; el tráfico web legítimo es abrumadoramente TCP, por lo que un cambio donde UDP excede el 30-40% del tráfico total indica una probable inundación. Analizar la entropía de IPs de origen: el tráfico UDP legítimo proviene de un conjunto relativamente estable de resolvers DNS y servidores NTP, mientras que las inundaciones UDP muestran miles de IPs de origen únicas con alta entropía en el espacio de direcciones. Monitorear la tasa de generación de ICMP Port Unreachable — un aumento pronunciado indica paquetes UDP llegando a puertos cerrados a altas tasas. Verificar la utilización de la tabla conntrack en firewalls y dispositivos con estado: el llenado rápido de la tabla de seguimiento de conexiones con entradas UDP señala una inundación. Desplegar análisis NetFlow/sFlow en el perímetro de red para detectar anomalías de volumen antes de que impacten los servicios — los datos de flujo capturan patrones de tráfico con mínima sobrecarga incluso durante eventos de alto volumen.

Cómo Prevenir Ataque de Inundación UDP

Desplegar mitigación DDoS upstream (scrubbing basado en la nube o filtrado a nivel de ISP) como defensa principal — el hardware en las instalaciones no puede mitigar una inundación que excede la capacidad del enlace de red. Configurar firewalls para descartar paquetes UDP a puertos donde no hay servicio escuchando, eliminando la generación de ICMP Port Unreachable y reduciendo la carga de CPU. Deshabilitar las respuestas ICMP Port Unreachable en el kernel (net.ipv4.icmp_ratemask en Linux) para prevenir que el tráfico ICMP saliente amplifique el impacto de ancho de banda de la inundación. Implementar ajustes de la tabla conntrack: aumentar nf_conntrack_max, reducir los valores de timeout UDP (net.netfilter.nf_conntrack_udp_timeout=10 en lugar del valor predeterminado de 30) y considerar usar reglas NOTRACK para servicios UDP de alto volumen para evadir completamente el seguimiento de conexiones. Para servicios UDP que deben permanecer accesibles (DNS, servidores de juegos), implementar limitación de tasa a nivel de aplicación, validación de paquetes (verificar la estructura del paquete antes de procesarlo) y filtrado geográfico (descartar tráfico de regiones sin usuarios legítimos). Implementar BCP 38 validación de dirección de origen en el borde de su red y promover su adopción por los proveedores upstream — la adopción generalizada de BCP 38 eliminaría completamente las inundaciones UDP falsificadas. Considerar aparatos dedicados de mitigación DDoS posicionados en línea para organizaciones con conexiones de alto ancho de banda.

Ejemplos de Código

# === Kernel tuning for UDP flood resilience ===

# Disable ICMP Port Unreachable responses to prevent outbound amplification
# Bit 3 in icmp_ratemask controls Port Unreachable (Type 3)
iptables -A OUTPUT -p icmp --icmp-type port-unreachable -j DROP

# Increase conntrack table size (default 65536 is too small under flood)
sysctl -w net.netfilter.nf_conntrack_max=2000000
sysctl -w net.netfilter.nf_conntrack_buckets=500000

# Reduce UDP conntrack timeout (default 30s → 10s)
# Entries expire faster, freeing conntrack slots during floods
sysctl -w net.netfilter.nf_conntrack_udp_timeout=10
sysctl -w net.netfilter.nf_conntrack_udp_timeout_stream=30

# Increase network receive buffer sizes
sysctl -w net.core.rmem_max=67108864
sysctl -w net.core.rmem_default=8388608
sysctl -w net.core.netdev_max_backlog=50000

# === iptables rules to filter UDP flood traffic ===

# Drop UDP packets to ports where no service listens
# List your legitimate UDP services explicitly
iptables -A INPUT -p udp --dport 53 -j ACCEPT     # DNS (if you run a DNS server)
iptables -A INPUT -p udp --dport 123 -j ACCEPT    # NTP (if you run NTP)
iptables -A INPUT -p udp --dport 1194 -j ACCEPT   # OpenVPN (if applicable)
# Drop all other inbound UDP
iptables -A INPUT -p udp -j DROP

# If you must accept UDP on certain ports, rate-limit per source IP
iptables -A INPUT -p udp --dport 53 -m hashlimit \
  --hashlimit-above 50/sec \
  --hashlimit-burst 100 \
  --hashlimit-mode srcip \
  --hashlimit-name udp_dns_limit \
  -j DROP

# Bypass conntrack for high-volume UDP services (reduces state table pressure)
iptables -t raw -A PREROUTING -p udp --dport 53 -j NOTRACK
iptables -t raw -A OUTPUT -p udp --sport 53 -j NOTRACK

# Anti-spoofing: enable reverse path filtering
sysctl -w net.ipv4.conf.all.rp_filter=1
sysctl -w net.ipv4.conf.default.rp_filter=1

# Persist all sysctl settings
sysctl -p

import subprocess
import time
import logging
from collections import defaultdict

logger = logging.getLogger('udp_flood_monitor')

def get_udp_stats():
    """Read UDP statistics from /proc/net/snmp and conntrack"""
    stats = {}

    # Parse /proc/net/snmp for UDP counters
    with open('/proc/net/snmp', 'r') as f:
        lines = f.readlines()
        for i, line in enumerate(lines):
            if line.startswith('Udp:') and i + 1 < len(lines):
                headers = line.split()
                values = lines[i + 1].split()
                if headers[0] == 'Udp:' and values[0] == 'Udp:':
                    for h, v in zip(headers[1:], values[1:]):
                        stats[f'udp_{h}'] = int(v)
                break

    # Get conntrack stats
    try:
        result = subprocess.run(
            ['cat', '/proc/sys/net/netfilter/nf_conntrack_count'],
            capture_output=True, text=True
        )
        stats['conntrack_count'] = int(result.stdout.strip())

        result = subprocess.run(
            ['cat', '/proc/sys/net/netfilter/nf_conntrack_max'],
            capture_output=True, text=True
        )
        stats['conntrack_max'] = int(result.stdout.strip())
    except (ValueError, FileNotFoundError):
        pass

    return stats

def get_interface_counters(interface='eth0'):
    """Read packet and byte counters from /sys/class/net"""
    base = f'/sys/class/net/{interface}/statistics'
    counters = {}
    for stat in ['rx_packets', 'rx_bytes', 'tx_packets', 'tx_bytes']:
        try:
            with open(f'{base}/{stat}', 'r') as f:
                counters[stat] = int(f.read().strip())
        except FileNotFoundError:
            counters[stat] = 0
    return counters

def monitor_udp_flood(
    interface='eth0',
    pps_threshold=100000,
    bps_threshold=1_000_000_000,  # 1 Gbps
    conntrack_pct_threshold=80,
    check_interval=5
):
    """Continuous UDP flood monitoring with multi-indicator alerting"""
    prev_counters = get_interface_counters(interface)
    prev_stats = get_udp_stats()
    prev_time = time.time()

    while True:
        time.sleep(check_interval)

        curr_counters = get_interface_counters(interface)
        curr_stats = get_udp_stats()
        curr_time = time.time()
        elapsed = curr_time - prev_time

        # Calculate rates
        rx_pps = (curr_counters['rx_packets'] - prev_counters['rx_packets']) / elapsed
        rx_bps = (curr_counters['rx_bytes'] - prev_counters['rx_bytes']) * 8 / elapsed
        tx_pps = (curr_counters['tx_packets'] - prev_counters['tx_packets']) / elapsed

        # UDP-specific: NoPorts = ICMP Dest Unreachable generated (closed port hits)
        noports_rate = 0
        if 'udp_NoPorts' in curr_stats and 'udp_NoPorts' in prev_stats:
            noports_rate = (curr_stats['udp_NoPorts'] - prev_stats['udp_NoPorts']) / elapsed

        # Conntrack utilization
        conntrack_pct = 0
        if 'conntrack_count' in curr_stats and 'conntrack_max' in curr_stats:
            conntrack_pct = (curr_stats['conntrack_count'] / curr_stats['conntrack_max']) * 100

        # Alert conditions
        if rx_pps > pps_threshold:
            logger.critical(
                f'HIGH PACKET RATE: {rx_pps:,.0f} pps inbound '
                f'({rx_bps / 1e9:.2f} Gbps), threshold: {pps_threshold:,}'
            )

        if noports_rate > 1000:
            logger.warning(
                f'UDP closed-port hits: {noports_rate:,.0f}/sec '
                f'(generating ICMP Port Unreachable responses)'
            )

        if conntrack_pct > conntrack_pct_threshold:
            logger.critical(
                f'CONNTRACK TABLE {conntrack_pct:.1f}% full '
                f'({curr_stats["conntrack_count"]:,}/{curr_stats["conntrack_max"]:,}) — '
                f'risk of dropping all new connections'
            )

        prev_counters = curr_counters
        prev_stats = curr_stats
        prev_time = curr_time

if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    monitor_udp_flood()

# Nginx reverse proxy architecture for UDP flood resilience.
# Nginx only processes TCP/HTTP — UDP floods hit the OS, not the application.
# Combined with kernel hardening, this isolates web services from UDP attacks.

worker_processes auto;
worker_rlimit_nofile 65535;

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

http {
    # Aggressive timeouts to reclaim resources during attacks
    keepalive_timeout       10s;
    client_header_timeout   5s;
    client_body_timeout     5s;
    send_timeout            5s;
    reset_timedout_connection on;

    # Connection and rate limiting per IP
    limit_conn_zone $binary_remote_addr zone=conn_per_ip:10m;
    limit_req_zone  $binary_remote_addr zone=req_per_ip:10m rate=30r/s;

    # Health check endpoint for load balancer monitoring
    server {
        listen 80;
        server_name _;

        # Quick health check — responds even under heavy load
        location /health {
            access_log off;
            return 200 'OK';
            add_header Content-Type text/plain;
        }
    }

    server {
        listen 443 ssl http2 backlog=65535;

        limit_conn conn_per_ip 30;
        limit_req zone=req_per_ip burst=50 nodelay;

        location / {
            proxy_pass http://backend;
            proxy_connect_timeout 3s;
            proxy_read_timeout    15s;
            proxy_send_timeout    5s;
        }
    }
}

Preguntas Frecuentes

Ataques Relacionados