StackPractices
advanced Por Mathias Paulenko

Reglas avanzadas de firewall con iptables

Endurece un servidor Linux con iptables: límites anti-DDoS, connection tracking, IPv6, logging de paquetes, fail2ban, migración a nftables y port knocking.

Temas: security

Visión General

Un VPS recién creado empieza a recibir escaneos en minutos — sondas al puerto 22, crawlers de HTTP, ruido UDP aleatorio. En esa máquina, “escribir un par de reglas de iptables” deja de ser un ejercicio de tutorial y pasa a ser la diferencia entre detectar un ataque en tus logs y ni enterarte.

Esta recipe reúne los conjuntos de reglas que van más allá de lo básico: connection tracking, SSH con rate limit, límites anti-DDoS, paridad IPv6, logging de paquetes, fail2ban, la ruta de migración a nftables y port knocking. Si primero necesitas los fundamentos — NAT, port forwarding, bloquear unas pocas IPs — Configurar reglas de firewall con iptables y Bash los cubre; esta recipe asume esa base y construye encima la capa de hardening.

Todos los scripts de abajo también se pueden descargar desde el repositorio complementario.

Cuándo Usar

  • Para endurecer un VPS o un servidor dedicado expuesto a internet.
  • Cuando necesitas reglas que sobrevivan un reinicio — y que fallen cerradas, no abiertas.
  • Para sacar la presión de fuerza bruta de SSH sin pagar un WAF ni un filtro hosted.
  • Cuando migras políticas legacy de iptables a nftables sin reescribir todo de una vez.

Cuándo No Usar

  • Tu tráfico ya se filtra upstream. Los security groups de la nube o un firewall perimetral hacen el mismo trabajo con menos mantenimiento — mantén las reglas del host como segunda capa, no como la única.
  • Quieres la configuración más simple posible. ufw (Ubuntu/Debian) o firewalld (RHEL/Fedora) envuelven casi todo esto en un par de comandos.
  • Empiezas de cero en una distribución moderna. Escribe reglas de nftables directamente en lugar de aprender una sintaxis que ya es legacy.
  • Necesitas filtrado de capa de aplicación — rutas HTTP, inspección TLS, rate limits por ruta. Eso es trabajo de un reverse proxy o un WAF, no de netfilter.

Solución

Conjunto de reglas base

La base: denegación por defecto en entrada, salida permitida, tráfico establecido de vuelta adentro, SSH con rate limit y persistencia del resultado.

#!/usr/bin/env bash
set -euo pipefail

# Restablecer reglas y contadores
iptables -F
iptables -X
iptables -Z

# Políticas por defecto: denegar entrada/forward, permitir salida
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT

# Loopback — los servicios locales dependen de él
iptables -A INPUT -i lo -j ACCEPT

# Respuestas a conexiones que iniciamos nosotros
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# SSH con rate limit: >4 conexiones nuevas por 60s desde una IP se descartan
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --set
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 4 -j DROP
iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# Tráfico web
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# Persistir (iptables-persistent escribe aquí; crea el directorio si falta)
mkdir -p /etc/iptables
iptables-save > /etc/iptables/rules.v4

echo "Reglas de firewall aplicadas"

Dos cosas a tener en cuenta antes de correr esto en un servidor remoto. Primero, aplícalo mientras tengas una sesión abierta — si la política descarta tu paquete de SSH, quieres una shell viva para arreglarlo. Segundo, iptables -P INPUT DROP toma efecto al instante; la regla de SSH dos líneas después es la que te salva, así que nunca las dividas en comandos separados.

Paridad IPv6 con ip6tables

Las reglas IPv4 no hacen nada por el tráfico IPv6 — un servidor escuchando en :: queda expuesto aunque el conjunto IPv4 sea perfecto. Replica la misma estructura con ip6tables, más una adición crítica: ICMPv6 no es opcional, el neighbor discovery depende de él.

#!/usr/bin/env bash
set -euo pipefail

ip6tables -F
ip6tables -X
ip6tables -Z

ip6tables -P INPUT DROP
ip6tables -P FORWARD DROP
ip6tables -P OUTPUT ACCEPT

ip6tables -A INPUT -i lo -j ACCEPT
ip6tables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# ICMPv6 es obligatorio — neighbor discovery, path MTU y MLD se rompen sin él
ip6tables -A INPUT -p icmpv6 -j ACCEPT

ip6tables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --set
ip6tables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 4 -j DROP
ip6tables -A INPUT -p tcp --dport 22 -j ACCEPT

ip6tables -A INPUT -p tcp --dport 80 -j ACCEPT
ip6tables -A INPUT -p tcp --dport 443 -j ACCEPT

mkdir -p /etc/iptables
ip6tables-save > /etc/iptables/rules.v6

echo "Reglas de firewall IPv6 aplicadas"

Mitigación de DDoS con límites de conexión

connlimit limita las conexiones concurrentes por origen; SYNPROXY delega la validación del handshake SYN al kernel para que un flood nunca llegue a tu servicio. Ninguno reemplaza un servicio de mitigación ante un ataque volumétrico real, pero absorben el ruido de fondo — crawlers lentos, port scanners, botnets perezosos — que de otro modo te consumiría sockets.

#!/usr/bin/env bash
set -euo pipefail

# Limitar conexiones concurrentes por IP única
iptables -A INPUT -p tcp -m connlimit --connlimit-above 50 --connlimit-mask 32 -j DROP

# Conexiones nuevas: aceptar hasta 20/s con ráfaga de 40, descartar el resto
iptables -A INPUT -p tcp -m conntrack --ctstate NEW -m limit --limit 20/s --limit-burst 40 -j ACCEPT
iptables -A INPUT -p tcp -m conntrack --ctstate NEW -j DROP

# Paquetes spoofed o malformados nunca pertenecen a una conexión válida
iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

# SYNPROXY (kernel 3.12+): valida handshakes sin retener sockets
iptables -t raw -A PREROUTING -p tcp -m tcp --syn -j CT --notrack
iptables -A INPUT -p tcp -m tcp --syn -m conntrack --ctstate UNTRACKED,INVALID -j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460
iptables -A INPUT -p tcp -m tcp --syn -m conntrack --ctstate UNTRACKED,INVALID -j DROP

# ICMP: suficiente para diagnóstico, no para un ping flood
iptables -A INPUT -p icmp -m limit --limit 1/s --limit-burst 3 -j ACCEPT
iptables -A INPUT -p icmp -j DROP

echo "Reglas de mitigación de DDoS aplicadas"

Logging de paquetes descartados

Un DROP silencioso esconde tanto los ataques como tus propios errores de configuración. Loguea los descartes a una tasa limitada — sin el match limit, un port scan te llena el disco — y rutealos a su propio archivo con rsyslog para que journalctl siga siendo legible.

#!/usr/bin/env bash
set -euo pipefail

# Log de descartes con rate limit: 5/min con ráfaga de 10
iptables -A INPUT -m limit --limit 5/min --limit-burst 10 -j LOG \
    --log-prefix "iptables-DROP: " \
    --log-level 4 \
    --log-ip-options \
    --log-tcp-options

# Todo lo demás sigue cayendo en la política DROP por defecto

# Leer los descartes
# journalctl -k | grep "iptables-DROP"
# o: dmesg | grep "iptables-DROP"

# Archivo de log dedicado vía rsyslog
cat > /etc/rsyslog.d/10-iptables.conf << 'EOF'
:msg, contains, "iptables-DROP" /var/log/iptables.log
& stop
EOF
systemctl restart rsyslog

Integración con fail2ban

El rate limit frena la fuerza bruta; fail2ban elimina a los reincidentes por completo. Su acción iptables-multiport crea una cadena propia (f2b-sshd) e inserta reglas DROP para las IPs que disparan un jail, así que tus reglas manuales quedan intactas.

#!/usr/bin/env bash
set -euo pipefail

# Instalar: apt install fail2ban  O  yum install fail2ban

cat > /etc/fail2ban/jail.local << 'EOF'
[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 3
banaction = iptables-multiport

[sshd]
enabled = true
port = ssh
logpath = %(sshd_log)s
backend = systemd

[nginx-http-auth]
enabled = true
port = http,https
logpath = /var/log/nginx/error.log

[recidive]
enabled = true
logpath = /var/log/fail2ban.log
bantime = 86400
findtime = 86400
maxretry = 5
EOF

systemctl enable fail2ban
systemctl start fail2ban

# Inspeccionar
fail2ban-client status sshd

# Ban manual
fail2ban-client set sshd banip 198.51.100.1
fail2ban-client set sshd unbanip 198.51.100.1

# Ver las reglas generadas: iptables -L f2b-sshd -n --line-numbers

El jail recidive vale la pena mantenerlo aunque desactives los demás — banea las IPs que se banean repetidamente, que es un buen proxy de “esta no se va a ir”.

Migración a nftables

iptables es legacy — la mayoría de las distribuciones modernas ya lo corren sobre un backend de nftables. Cuando estés listo para migrar, traduce el conjunto guardado en lugar de reescribirlo, y después limpia el resultado a mano.

#!/usr/bin/env bash
set -euo pipefail

# Traducir las reglas existentes
iptables-restore-translate -f /etc/iptables/rules.v4 > /etc/nftables.conf

# O escribir nftables directamente — el equivalente del conjunto base
cat > /etc/nftables.conf << 'EOF'
#!/usr/sbin/nft -f

flush ruleset

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        iif "lo" accept
        ct state established,related accept
        ct state invalid drop

        # ICMP en ambas familias — solo echo-request, con rate limit
        icmp type echo-request limit rate 1/second accept
        icmpv6 type echo-request limit rate 1/second accept

        tcp dport 22 ct state new limit rate 4/minute accept
        tcp dport { 80, 443 } accept

        limit rate 5/minute log prefix "nft-DROP: " level warn
        drop
    }

    chain forward {
        type filter hook forward priority 0; policy drop;
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }
}
EOF

nft -f /etc/nftables.conf
systemctl enable nftables
systemctl start nftables

nft list ruleset

Fíjate en lo que una sola tabla inet te compra: reglas IPv4 e IPv6 en un mismo conjunto — sin un archivo ip6tables paralelo que mantener sincronizado.

Port knocking para servicios ocultos

El port knocking mantiene SSH cerrado para todos hasta que un cliente toca una secuencia secreta de puertos. Es seguridad por oscuridad, así que trátalo como complemento — el daemon solo abre el puerto, SSH todavía tiene que estar endurecido con claves y rate limits. Mira Gestión de claves SSH en Bash para esa mitad.

#!/usr/bin/env bash
set -euo pipefail

# Requiere knockd: apt install knockd

cat > /etc/knockd.conf << 'EOF'
[openSSH]
    sequence    = 7000,8000,9000
    seq_timeout = 15
    tcpflags    = syn
    start_command = iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
    cmd_timeout   = 30
    stop_command  = iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT

[closeSSH]
    sequence    = 9000,8000,7000
    seq_timeout = 15
    tcpflags    = syn
    start_command = iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
EOF

systemctl enable knockd
systemctl start knockd

# Del lado del cliente: golpea primero, después conecta
# knock -v server-ip 7000 8000 9000 && ssh user@server-ip
# knock -v server-ip 9000 8000 7000   # cierra al terminar

Explicación

iptables evalúa las reglas a través de tablas (filter para política, nat para traducción de direcciones, raw para exenciones, mangle para reescritura de paquetes), cada una con cadenas (INPUT, OUTPUT, FORWARD, más PREROUTING/POSTROUTING fuera de la máquina local). Cada paquete recorre una cadena de arriba hacia abajo; gana la primera regla que coincide, y si nada coincide, decide la política por defecto de la cadena. Por eso el orden importa tanto: el ACCEPT de ESTABLISHED,RELATED tiene que ir antes que cualquier ACCEPT amplio, y la regla de SSH tiene que existir antes de que la política INPUT DROP pueda aplicarse de forma segura.

flowchart diagram: Paquete entrante

Dos módulos hacen el trabajo pesado en estos scripts. conntrack asocia cada paquete a un estado de conexión, que es lo que permite que una política de entrada DROP coexista con tráfico saliente — las respuestas vuelven a caballo de ESTABLISHED. recent mantiene una lista de timestamps por IP bajo /proc/net/xt_recent/, que es como el rate limit de SSH cuenta intentos sin ningún daemon corriendo. Cuando migres a nftables, ambas ideas sobreviven como ct state y expresiones nativas limit rate — cambia la sintaxis, no el modelo.

Variantes

EnfoqueHerramientaComplejidadCuándo usar
Conjunto manualiptables / ip6tablesMediaServidores existentes, scripts que ya mantienes
Conjunto modernonftMediaDistros nuevas; un solo conjunto cubre IPv4 e IPv6
Wrapper simpleufwBajaUbuntu/Debian, hardening rápido
Wrapper por zonasfirewalldBajaRHEL/CentOS/Fedora, zonas dinámicas
Filtrado upstreamSecurity groups / NACLsBajaVMs en la nube — primera línea de defensa

Para filtrado entre contenedores el cálculo cambia — mira Aislamiento de redes Docker cuando las cargas viven en contenedores y no en el host.

Lo que funciona

  1. Denegación por defecto, permitir explícitamente. Una política DROP convierte cada regla olvidada en un ticket de soporte, no en una brecha — el modo de fallo que te conviene.
  2. Persiste solo después de probar. iptables-save escribe lo que esté activo, incluido el error que te deja fuera. Aplica, verifica la conectividad desde una segunda sesión y recién ahí guarda.
  3. Limita SSH y loguea los descartes. La fuerza bruta es ruido de fondo constante; -m recent más una regla LOG limitada lo convierte en una métrica en lugar de una amenaza.
  4. Mantén IPv6 a la par. Cada regla que escribes para iptables necesita su gemela en ip6tables, o una sola tabla inet en nftables. Una vía IPv6 abierta convierte el conjunto IPv4 en decoración.
  5. Apila las defensas. iptables del host detrás de security groups, fail2ban encima de los rate limits — cada capa cubre los puntos ciegos de la que tiene debajo.

Errores Comunes

  1. Olvidar las conexiones establecidas. Sin la regla conntrack, toda solicitud saliente — DNS, apt, NTP — muere esperando una respuesta que el firewall descarta.
  2. Poner INPUT DROP antes que la regla de SSH. La política aplica al instante; en cuanto corre, tu sesión desaparece. La vuelta es acceso a consola o un reinicio.
  3. Loguear sin rate limit. Un solo nmap contra un target LOG sin límite llena el disco — siempre combínalo con -m limit.
  4. Limpiar reglas para “arreglar” la conectividad. -F deja la política DROP activa, que es peor: todo sigue descartándose, y tus ACCEPT ya no están. Restablece las políticas a ACCEPT explícitamente si necesitas empezar de cero.
  5. Asumir que --log-uid funciona en INPUT. Solo tiene sentido para tráfico generado localmente en OUTPUT — en paquetes entrantes el campo no loguea nada útil.

Ver también

Preguntas frecuentes

¿Cuál es la diferencia entre iptables y nftables?

iptables es el frontend legacy; nftables es su reemplazo moderno con sintaxis unificada y una sola tabla inet que maneja IPv4 e IPv6 juntas. En la mayoría de las distros actuales, los comandos iptables ya corren sobre un backend nftables por compatibilidad — razón de más para aprender nft directamente a largo plazo.

¿Cómo persisto las reglas de iptables entre reinicios?

Corre iptables-save > /etc/iptables/rules.v4 (e ip6tables-save para rules.v6), y restáuralas en el arranque con el paquete iptables-persistent o un systemd oneshot que llame a iptables-restore. Guarda siempre después de verificar — la persistencia congela lo que esté activo, incluidos los errores.

¿Cómo pruebo reglas de firewall sin quedarme fuera?

Mantén una sesión SSH verificada abierta mientras aplicas reglas desde una segunda terminal, o agenda un iptables-restore de un conjunto conocido-bueno vía at o cron en unos minutos como interruptor de hombre muerto. Si el nuevo conjunto mata tu sesión, el restore programado la devuelve.

¿DROP o REJECT para tráfico externo?

DROP para reglas expuestas a internet — sin respuesta los escaneos son más lentos y filtras menos información. REJECT tiene sentido en redes internas, donde a los clientes les sirve un "connection refused" inmediato en lugar de esperar un timeout.

¿Puede fail2ban reemplazar un conjunto de reglas iptables manual?

No — hacen trabajos distintos. fail2ban banea IPs que se comportan mal en capa de aplicación insertando reglas temporales en sus propias cadenas; tu conjunto base define la política permanente. Usa fail2ban encima de un default-deny sólido, no en su lugar.