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) ofirewalld(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.
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
| Enfoque | Herramienta | Complejidad | Cuándo usar |
|---|---|---|---|
| Conjunto manual | iptables / ip6tables | Media | Servidores existentes, scripts que ya mantienes |
| Conjunto moderno | nft | Media | Distros nuevas; un solo conjunto cubre IPv4 e IPv6 |
| Wrapper simple | ufw | Baja | Ubuntu/Debian, hardening rápido |
| Wrapper por zonas | firewalld | Baja | RHEL/CentOS/Fedora, zonas dinámicas |
| Filtrado upstream | Security groups / NACLs | Baja | VMs 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
- 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.
- Persiste solo después de probar.
iptables-saveescribe 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. - Limita SSH y loguea los descartes. La fuerza bruta es ruido de fondo constante;
-m recentmás una reglaLOGlimitada lo convierte en una métrica en lugar de una amenaza. - Mantén IPv6 a la par. Cada regla que escribes para
iptablesnecesita su gemela enip6tables, o una sola tablaineten nftables. Una vía IPv6 abierta convierte el conjunto IPv4 en decoración. - 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
- Olvidar las conexiones establecidas. Sin la regla
conntrack, toda solicitud saliente — DNS, apt, NTP — muere esperando una respuesta que el firewall descarta. - Poner
INPUT DROPantes 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. - Loguear sin rate limit. Un solo
nmapcontra un targetLOGsin límite llena el disco — siempre combínalo con-m limit. - Limpiar reglas para “arreglar” la conectividad.
-Fdeja 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. - Asumir que
--log-uidfunciona en INPUT. Solo tiene sentido para tráfico generado localmente en OUTPUT — en paquetes entrantes el campo no loguea nada útil.
Ver también
- Página man de iptables y documentación de netfilter
- Wiki de nftables — el framework de reemplazo y su sintaxis
- Documentación de fail2ban — configuración de jails y acciones
- Guía de iptables-persistent en Debian — persistencia de reglas entre reinicios
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.
Recursos Relacionados
Configurar Reglas de Firewall iptables con Bash
Configura un firewall iptables endurecido con bash: reglas seguras para SSH, NAT port forwarding, bloqueo de IPs y persistencia tras reinicios.
RecipeGestión de Llaves SSH en Bash
Genera, rota y distribuye llaves SSH con scripts bash.
RecipeAislamiento de Red Docker y Seguridad Entre Contenedores
Asegura la comunicación entre contenedores con redes Docker personalizadas, segmentación de red y políticas de control de acceso.
DocPlantilla de Política de Segmentación de Red
Una plantilla para documentar zonas de seguridad de red, reglas de segmentación y controles de tráfico entre entornos e inquilinos.
DocPlantilla de Gestion de Certificados SSL
Una plantilla para rastrear el inventario, renovaciones, despliegues y riesgos de vencimiento de certificados TLS/SSL en dominios y servicios.