Complete guide to iptables: fundamentals, syntax, and practical examples

¿Qué es iptables?

iptables es la herramienta de línea de comandos utilizada para configurar, mantener e inspeccionar las tablas de reglas de filtrado de paquetes del firewall Netfilter en el kernel de Linux. Actúa como una interfaz entre el administrador y el subsistema Netfilter, permitiendo definir políticas que controlan el tráfico de entrada, salida y forwarded.

Estructura básica: tablas y cadenas

Netfilter organiza las reglas en varias tablas, cada una diseñada para un tipo de procesamiento distinto. Las tablas más comunes son:

  • filter: la tabla predeterminada, utilizada para filtrar paquetes (INPUT, FORWARD, OUTPUT).
  • nat: empleada para traducción de direcciones (PREROUTING, POSTROUTING, OUTPUT).
  • mangle: permite alterar campos especiales de los paquetes (TTL, TOS, MARK).
  • raw: usado para excluir paquetes del seguimiento de conexiones.
  • security: aplica reglas de seguridad basadas en SELinux u otros mecanismos.

Cada tabla contiene cadenas (chains) que representan puntos de inspección en el recorrido del paquete. Por ejemplo, en la tabla filter encontramos las cadenas INPUT (paquetes destinados al host), FORWARD (paquetes que atraviesan el host) y OUTPUT (paquetes generados por el host).

Sintaxis de una regla

Una regla típica sigue el patrón:

iptables [-t tabla] cadena coincidencia [salto]

Donde:

  • -t tabla especifica la tabla (si se omite se usa filter).
  • cadena es el nombre de la cadena (INPUT, FORWARD, etc.).
  • coincidencia incluye condiciones como dirección de origen (-s), destino (-d), protocolo (-p), puerto (--dport, --sport), interfaz (-i, -o), estado (-m state --state), etc.
  • salto indica la acción a tomar cuando se cumple la coincidencia: ACCEPT, DROP, REJECT, LOG, o un salto a otra cadena definida por el usuario.

Ejemplos prácticos

A continuación se presentan algunos escenarios comunes y sus comandos iptables correspondientes.

1. Bloquear tráfico entrante desde una IP específica

Para descartar todos los paquetes que provienen de la dirección 203.0.113.5:

iptables -A INPUT -s 203.0.113.5 -j DROP

2. Permitir solo SSH (puerto 22) desde una red confiable

Supongamos que la red confiable es 10.0.0.0/24:

iptables -A INPUT -p tcp -s 10.0.0.0/24 --dport 22 -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -j DROP

3. Redirigir tráfico HTTP a un puerto interno (NAT)

Si queremos que las peticiones al puerto 80 del firewall se redirijan a un servidor web interno en 192.168.1.10:8080:

iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.1.10:8080
iptables -A FORWARD -p tcp -d 192.168.1.10 --dport 8080 -j ACCEPT

4. Limitar la tasa de conexiones para mitigar ataques de fuerza bruta

Utilizando el módulo limit:

iptables -A INPUT -p tcp --dport 22 -m state --state NEW -m limit --limit 3/min --limit-burst 5 -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -j DROP

Guardar y restaurar las reglas

Las reglas de iptables son volátiles; se pierden al reiniciar el sistema. Para hacerlas persistentes:

  • En distribuciones basadas en Debian/Ubuntu: iptables-save > /etc/iptables/rules.v4 y restaurar con iptables-restore < /etc/iptables/rules.v4.
  • En RHEL/CentOS/Fedora: usar el servicio iptables.service o firewalld (aunque firewalld es la capa superior, iptables sigue siendo el backend).
  • También se puede crear un script de inicialización en /etc/network/if-up.d/ o usar systemd con una unidad personalizada.

Buenas prácticas y recomendaciones

  • Comenzar con una política predeterminada de DROP en las cadenas INPUT y FORWARD, y luego agregar explícitamente las excepciones necesarias.
  • Utilizar cadenas definidas por el usuario para agrupar reglas relacionadas (por ejemplo, una cadena WEB para todo el tráfico HTTP/HTTPS).
  • Documentar cada regla con comentarios usando el salto -m comment --comment 'texto'.
  • Probar los cambios en un entorno de staging o usando iptables -I para insertar reglas en la parte superior y verificar antes de hacerlas permanentes.
  • Monitorizar los registros con LOG y herramientas como fail2ban o nfsen para detectar patrones anómalos.
  • Mantener el kernel actualizado; muchas mejoras de Netfilter y parches de seguridad se lanzan con cada versión.

Solución de problemas comunes

Cuando las reglas no se comportan como se espera, es útil seguir un proceso de diagnóstico sistemático.

  • Verificar la tabla y cadena correcta: usar iptables -t filter -L INPUT -v -n para ver contadores.
  • Comprobar que el paquete realmente atraviesa la cadena esperada usando iptables -L -v -n y observando los incrementos de paquetes y bytes.
  • Utilizar el objetivo LOG para registrar paquetes que coinciden con una regla antes de decidir su destino.
  • Revisar el orden de las reglas: la primera coincidencia detiene el procesamiento; una regla demasiado amplia ubicada antes puede bloquear el tráfico deseado.
  • Para problemas de NAT, asegurarse de que el forwarding esté habilitado (sysctl net.ipv4.ip_forward=1) y que las reglas de FORWARD permitan el tráfico.
  • En entornos con Docker o Kubernetes, comprobar que no exista otra capa de reglas (como iptables generadas por el runtime) que pueda interferir.

Finalmente, recordar que iptables -L muestra las reglas en formato legible, mientras que iptables -S las muestra en formato de comandos, útil para replicar configuraciones.

Trabajando con IPv6: ip6tables

Aunque iptables gestiona IPv4, su hermana ip6tables maneja el tráfico IPv6 con una sintaxis prácticamente idéntica.

  • Las mismas tablas (filter, nat, mangle) existen en ip6tables, aunque algunas extensiones son específicas de IPv6.
  • Ejemplo: bloquear ping IPv6:
  • ip6tables -A INPUT -p icmpv6 --icmp-type echo-request -j DROP
  • Es importante aplicar reglas tanto en iptables como en ip6tables si el sistema tiene ambas pilas activas.

Conclusión

Iptables sigue siendo una pieza fundamental del arsenal de seguridad en sistemas Linux, a pesar de la aparición de alternativas como nftables. Su modelo basado en tablas y cadenas ofrece un control granular y flexible sobre el tráfico de red. Dominar su sintaxis, comprender el flujo de los paquetes y aplicar buenas prácticas permite construir firewalls robustos y adaptados a las necesidades específicas de cada entorno.