Configuración de NAT y Reenvío de Paquetes en Linux

Por /

En el mundo de la administración de redes, iptables es una herramienta esencial en sistemas Linux para el control y manejo del tráfico de red. A través de iptables, podemos configurar reglas que determinan cómo se procesan los paquetes de red que pasan a través del sistema. En este artículo, exploraremos dos comandos específicos de iptables y una modificación en la configuración de sysctl que son fundamentales para configurar un dispositivo como un enrutador o una pasarela de red.

Comando 1:

El primer comando que vamos a analizar es:

sudo iptables -t nat -A POSTROUTING --out-interface wlan0 -j MASQUERADE

Descomponiendo este comando, encontramos varios elementos clave:

  • sudo se usa para ejecutar el comando con privilegios de superusuario, necesarios para modificar las reglas de iptables.
  • iptables es la herramienta de línea de comandos utilizada para configurar el firewall y las reglas de manipulación de paquetes en Linux.
  • -t nat especifica que estamos trabajando con la tabla NAT (Network Address Translation), que se utiliza para modificar las direcciones IP de los paquetes.
  • -A POSTROUTING indica que estamos añadiendo (-A de «append») una regla a la cadena POSTROUTING de la tabla NAT. La cadena POSTROUTING afecta a los paquetes después de que se haya determinado su ruta de salida.
  • --out-interface wlan0 significa que la regla se aplicará a los paquetes que salen por la interfaz wlan0, que normalmente es una interfaz de red Wi-Fi.
  • -j MASQUERADE especifica que se debe aplicar el objetivo MASQUERADE a los paquetes. La mascarada es un tipo de NAT que oculta generalmente las direcciones IP privadas detrás de la dirección IP pública aunque en este caso se utilizará con la interfaz wlan0. Es particularmente útil cuando la dirección IP de la interfaz de salida puede cambiar dinámicamente.

El propósito de este comando es permitir que el dispositivo actúe como un enrutador, ocultando las direcciones IP internas de la red local detrás de la dirección IP de la interfaz wlan0.

Comando 2:

El segundo comando a considerar es:

sudo iptables -A FORWARD --in-interface ztuzeqcgeb -j ACCEPT

Vamos a desglosarlo:

  • Nuevamente, sudo permite ejecutar el comando con privilegios elevados.
  • iptables configura las reglas de firewall.
  • -A FORWARD añade una regla a la cadena FORWARD. Esta cadena maneja el tráfico de paquetes que atraviesa el dispositivo, no destinados a él.
  • --in-interface ztuzeqcgeb especifica que la regla se aplica a los paquetes que entran por la interfaz ztuzeqcgeb.
  • -j ACCEPT establece que los paquetes que coincidan con esta regla deben ser aceptados y reenviados.

Este comando facilita el reenvío de paquetes que ingresan por la interfaz ztuzeqcgeb hacia su destino final, lo cual es crucial para el funcionamiento de un enrutador que debe dirigir el tráfico entre diferentes interfaces de red.

Otros ejemplos:

Ejemplo 1: Permitir el Acceso SSH

Para permitir el acceso SSH (puerto 22) desde cualquier dirección IP a tu servidor, puedes usar la siguiente regla:

sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

Explicación:

  • -A INPUT: Añade la regla a la cadena INPUT, que gestiona los paquetes que ingresan al sistema.
  • -p tcp: Aplica la regla a los paquetes del protocolo TCP.
  • --dport 22: Especifica que la regla se aplica a los paquetes cuyo puerto de destino es el 22, que es el puerto estándar para SSH.
  • -j ACCEPT: Acepta los paquetes que coincidan con los criterios anteriores, permitiendo el acceso SSH.

Ejemplo 2: Bloquear Todo el Tráfico de Entrada Excepto el Permitido

Para bloquear todo el tráfico de entrada y permitir solo el tráfico específico (por ejemplo, HTTP y SSH), usa las siguientes reglas:

sudo iptables -P INPUT DROP
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT

Explicación:

  • -P INPUT DROP: Establece la política predeterminada para la cadena INPUT en DROP, bloqueando todo el tráfico de entrada por defecto.
  • Las siguientes reglas permiten excepciones específicas:
  • -A INPUT -p tcp --dport 22 -j ACCEPT: Permite el tráfico SSH.
  • -A INPUT -p tcp --dport 80 -j ACCEPT: Permite el tráfico HTTP en el puerto 80.

Ejemplo 3: Permitir Todo el Tráfico de Salida

Para permitir que todos los paquetes salientes puedan salir del sistema sin restricciones, utiliza la siguiente regla:

sudo iptables -P OUTPUT ACCEPT

Explicación:

  • -P OUTPUT ACCEPT: Establece la política predeterminada para la cadena OUTPUT en ACCEPT, permitiendo que todos los paquetes salientes sean aceptados.

Ejemplo 4: Redireccionar el Tráfico HTTP a HTTPS

Para redirigir el tráfico HTTP (puerto 80) al puerto HTTPS (443), usa esta regla en la tabla NAT:

sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 443

Explicación:

  • -t nat: Selecciona la tabla NAT para trabajar con el enmascaramiento y la redirección de puertos.
  • -A PREROUTING: Añade la regla a la cadena PREROUTING, que afecta a los paquetes antes de que se determine su destino.
  • -p tcp --dport 80: Se aplica a los paquetes TCP que van al puerto 80.
  • -j REDIRECT --to-port 443: Redirige el tráfico al puerto 443 (HTTPS).

Ejemplo 5: Limitar el Número de Conexiones SSH por Dirección IP

Para limitar el número de nuevas conexiones SSH permitidas por dirección IP a 5 por minuto, usa la siguiente regla:

sudo iptables -A INPUT -p tcp --dport 22 -m state --state NEW -m recent --set
sudo iptables -A INPUT -p tcp --dport 22 -m state --state NEW -m recent --update --seconds 60 --hitcount 5 -j DROP

Explicación:

  • La primera regla establece un «tracker» para las nuevas conexiones SSH:
  • -m state --state NEW: Coincide con los nuevos paquetes de conexión.
  • -m recent --set: Marca las direcciones IP de los paquetes nuevos en una lista temporal.
  • La segunda regla limita el número de conexiones desde la misma IP:
  • -m recent --update --seconds 60 --hitcount 5: Permite hasta 5 nuevas conexiones en 60 segundos desde la misma IP.
  • -j DROP: Descarta las conexiones que excedan este límite.

Ejemplo 6: Habilitar NAT para Compartir Conexión a Internet

Para habilitar NAT y permitir que una red interna acceda a Internet a través de una interfaz específica (eth0), usa estas reglas:

sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo iptables -A FORWARD -i eth0 -o eth1 -m state --state RELATED,ESTABLISHED -j ACCEPT
sudo iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT

Explicación:

  • La primera regla configura NAT en la interfaz de salida (eth0):
  • -t nat -A POSTROUTING -o eth0 -j MASQUERADE: Aplica la mascarada a los paquetes salientes por eth0.
  • Las siguientes reglas permiten el reenvío de paquetes entre eth0 (Internet) y eth1 (red interna):
  • -A FORWARD -i eth0 -o eth1 -m state --state RELATED,ESTABLISHED -j ACCEPT: Permite las conexiones que están relacionadas o establecidas.
  • -A FORWARD -i eth1 -o eth0 -j ACCEPT: Permite el tráfico desde eth1 hacia eth0.

Ejemplo 7: Bloquear el Tráfico de una IP Específica

Para bloquear todo el tráfico entrante desde una dirección IP específica (por ejemplo, 192.168.1.100), usa la siguiente regla:

sudo iptables -A INPUT -s 192.168.1.100 -j DROP

Explicación:

  • -A INPUT: Añade la regla a la cadena INPUT.
  • -s 192.168.1.100: Aplica la regla a los paquetes con la dirección IP de origen 192.168.1.100.
  • -j DROP: Descarta cualquier paquete que coincida con esta regla.

Ejemplo 8: Permitir el Ping (ICMP Echo Request)

Para permitir que tu servidor responda a solicitudes de ping (ICMP echo request), usa la siguiente regla:

sudo iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT

Explicación:

  • -A INPUT: Añade la regla a la cadena INPUT.
  • -p icmp --icmp-type echo-request: Aplica la regla a los paquetes ICMP de tipo echo request (ping).
  • -j ACCEPT: Acepta los paquetes que coincidan con esta regla.

Ejemplo 9: Registrar Paquetes Bloqueados

Para registrar los paquetes que son bloqueados por el firewall (útil para auditorías y análisis), usa la siguiente regla antes de la regla DROP:

sudo iptables -A INPUT -j LOG --log-prefix "IPTables-Dropped: " --log-level 4

Explicación:

  • -A INPUT: Añade la regla a la cadena INPUT.
  • -j LOG: Registra los paquetes en los registros del sistema.
  • --log-prefix "IPTables-Dropped: ": Añade un prefijo a cada entrada de registro para identificarla fácilmente.
  • --log-level 4: Establece el nivel de registro (informativo).

Ejemplo 10: Bloquear el Acceso a un Puerto Específico

Para bloquear el acceso al puerto 8080 en tu servidor, usa la siguiente regla:

sudo iptables -A INPUT -p tcp --dport 8080 -j REJECT

Explicación:

  • -A INPUT: Añade la regla a la cadena INPUT.
  • -p tcp --dport 8080: Aplica la regla a los paquetes TCP cuyo puerto de destino es el 8080.
  • -j REJECT: Rechaza los paquetes y envía una respuesta al remitente.

Estos ejemplos ilustran cómo usar iptables para gestionar el tráfico de red en Linux de manera efectiva. Cada regla tiene un propósito específico y puede ser combinada con otras para formar un conjunto completo de políticas de firewall.

Modificación del Archivo /etc/sysctl.conf

Además de configurar las reglas de iptables, debemos asegurarnos de que el sistema Linux esté configurado para reenviar paquetes entre interfaces. Esto se logra mediante una modificación en el archivo de configuración sysctl.conf.

Usamos el comando:

sudo nano /etc/sysctl.conf

Este comando abre el archivo de configuración con el editor de texto nano y privilegios de superusuario. Dentro del archivo, buscamos la línea:

#net.ipv4.ip_forward=1

Y removemos el carácter # para descomentarla, quedando como:

net.ipv4.ip_forward=1

Esta configuración habilita el reenvío de paquetes IPv4 en el sistema, permitiendo que el dispositivo transmita paquetes desde una interfaz de red a otra.

Después de modificar el archivo, aplicamos los cambios ejecutando:

sudo sysctl -p

Este comando recarga la configuración sin necesidad de reiniciar el sistema.

En conjunto, estas configuraciones permiten que un sistema Linux actúe como un enrutador, manejando y reenviando el tráfico de red entre diferentes interfaces. Esto es esencial para aplicaciones como compartir una conexión a Internet o crear redes complejas en entornos domésticos o de oficina. A través del uso combinado de iptables y sysctl, podemos lograr un control preciso y flexible sobre el tráfico de red en un sistema Linux.

Para asegurarte de que las reglas de iptables se mantengan después de reiniciar tu sistema Linux, es necesario guardarlas de manera persistente. Aquí te explico cómo hacerlo de manera más sencilla para las principales distribuciones de Linux.

Guardar Reglas de iptables de Forma Persistente

En Distribuciones Basadas en Debian (Debian, Ubuntu, etc.)

  1. Instalar iptables-persistent:
    Este paquete guarda y restaura las reglas de iptables automáticamente al arrancar y apagar el sistema.
   sudo apt-get install iptables-persistent

Durante la instalación, se te preguntará si deseas guardar las reglas actuales. Acepta para guardar las reglas de IPv4 e IPv6.

  1. Guardar las reglas manualmente:
    Si necesitas guardar las reglas actuales en cualquier momento, ejecuta:
   sudo netfilter-persistent save

Esto guarda las reglas en los archivos /etc/iptables/rules.v4 y /etc/iptables/rules.v6.

  1. Restaurar las reglas al inicio:
    Las reglas guardadas se restaurarán automáticamente en cada reinicio. Para recargarlas manualmente, usa:
   sudo netfilter-persistent reload

En Distribuciones Basadas en Red Hat (RHEL, CentOS, Fedora, etc.)

  1. Guardar las reglas actuales:
    Usa el comando iptables-save para guardar las reglas actuales en un archivo.
   sudo iptables-save > /etc/iptables/rules.v4
   sudo ip6tables-save > /etc/iptables/rules.v6

Estos archivos almacenarán las reglas de iptables en un formato que iptables-restore puede leer.

  1. Restaurar las reglas al inicio:
    Para asegurarte de que las reglas se carguen al iniciar el sistema, crea un servicio de systemd:
  • Crea un archivo de servicio: sudo nano /etc/systemd/system/iptables-restore.service
  • Añade este contenido: [Unit] Description=Restore iptables rules Before=network-pre.target Wants=network-pre.target DefaultDependencies=no [Service] Type=oneshot ExecStart=/usr/sbin/iptables-restore < /etc/iptables/rules.v4 ExecStart=/usr/sbin/ip6tables-restore < /etc/iptables/rules.v6 RemainAfterExit=yes [Install] WantedBy=multi-user.target
  • Guarda el archivo y habilita el servicio: sudo systemctl enable iptables-restore.service Este servicio aplicará automáticamente las reglas guardadas cada vez que el sistema se inicie.

Método General (Para Cualquier Distribución)

  1. Uso de scripts de inicio:
    Puedes agregar comandos para restaurar las reglas de iptables a un script que se ejecute al iniciar el sistema. Usa el archivo rc.local, si está disponible:
  • Abre el archivo rc.local: sudo nano /etc/rc.local
  • Añade estas líneas antes de exit 0: /sbin/iptables-restore < /etc/iptables/rules.v4 /sbin/ip6tables-restore < /etc/iptables/rules.v6
  • Guarda el archivo y hazlo ejecutable: sudo chmod +x /etc/rc.local

Con estos pasos, te aseguras de que las reglas de iptables que configures se mantendrán activas incluso después de reiniciar tu sistema.

Entradas relacionadas

Scroll al inicio
WordPress Appliance - Powered by TurnKey Linux