La wiki de TempWin

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== 212.1 Configuring a router ======

Pertenece a [[informatica:certificaciones:lpic:lpic-2:212_system_security|Topic 212: System Security]]

  * **Weight**: 3
  * **Description**: Candidates should be able to configure a system to forward IP packet and perform network address translation (NAT, IP masquerading) and state its significance in protecting a network. This objective includes configuring port redirection, managing filter rules and averting attacks.
  * **Key Knowledge Areas**:
    * iptables and ip6tables configuration files, tools and utilities
    * Tools, commands and utilities to manage routing tables.
    * Private address ranges (IPv4) and Unique Local Addresses as well as Link Local Addresses (IPv6)
    * Port redirection and IP forwarding
    * List and write filtering and rules that accept or block IP packets based on source or destination protocol, port and address
    * Save and reload filtering configurations
  * **Terms** and **Utilities**:
    * ''/proc/sys/net/ipv4/''
    * ''/proc/sys/net/ipv6/''
    * ''/etc/services''
    * ''iptables''
    * ''ip6tables''

===== Enrutamiento =====

La función de enrutamiento se integra de forma nativa en el núcleo de Linux. Cualquier máquina Linux es un router en potencia

La activación del enrutamiento en un servidor Linux se puede hacer tocando las opciones del kernel:

<code>
echo 1 > /proc/sys/net/ipv4/ip_forward
</code>

También se puede hacer así:

<code>
sysctl net.ipv4.ip_forward=1
</code>

Si embargo, los métodos anteriores son volátiles, deben volver a introducirse después de cada reinicio. Para que la configuración permanezca, debemos incluir en el fichero ''/etc/sysctl.conf'' lo siguiente:

<code>
net.ipv4.ip_forward=1
</code>

==== route ====

Comando que permite crear y visualizar las rutas para las interfaces de nuestra máquina local.

  * ''route'': Visualizar las rutas actuales.
  * ''route -n'': Visualizar las rutas actuales mostrando las direcciones IP.
  * ''route add –net 127.0.0.1'': Creación de entrada loopback.
  * ''route add –net 192.168.3.0 netmask 255.255.255.0 eth0'': Crea la ruta hacia la red 192.168.3.0 vía ''eth0''.
  * ''route add default gw 192.168.3.1'': Añadir una puerta de enlace por defecto.
  * ''route del –net 192.168.3.0 netmask 255.255.255.0 eth0'': Eliminar una ruta 

<code>
linux:~# route -n
Kernel IP routing table
Destination    Gateway       Genmask       Flags Metric Ref Use Iface
192.168.1.0    0.0.0.0       255.255.255.0 U     0      0   0   eth1
192.168.0.0    0.0.0.0       255.255.255.0 U     0      0   0   eth0
0.0.0.0        192.168.0.1   0.0.0.0       UG    0      0   0   eth0
</code>

<WRAP center round info 60%>
El parámetro ''-n'' es opcional, pero sirve para ahorrar mucho tiempo en la visualización, ya que no fuerza a que el comando intente resolver los nombres de las redes devueltas.</WRAP>

También podríamos usar el comando ''netstat'' para lo mismo:

<code>
netstat -nr
</code>

Ejemplo de adición de rutas:

<code>
linux:~# route -n
Kernel IP routing table
Destination    Gateway       Genmask       Flags Metric Ref Use Iface
192.168.1.0    0.0.0.0       255.255.255.0 U     0      0   0   eth1
192.168.0.0    0.0.0.0       255.255.255.0 U     0      0   0   eth0
0.0.0.0        192.168.0.1   0.0.0.0       UG    0      0   0   eth0

beta:~# route add -net 10.0.0.0 netmask 255.0.0.0 gw 192.168.1.99

beta:~# route -n
Kernel IP routing table
Destination    Gateway       Genmask       Flags Metric Ref Use Iface
192.168.1.0    0.0.0.0       255.255.255.0 U     0      0   0   eth1
192.168.0.0    0.0.0.0       255.255.255.0 U     0      0   0   eth0
10.0.0.0       192.168.1.99  255.0.0.0     UG    0      0   0   eth1
0.0.0.0        192.168.0.1   0.0.0.0       UG    0      0   0   eth0
</code>
==== iptables ====

Se utiliza para gestionar el filtrado de paquetes IP en un sistema Linux.

<WRAP center round info 60%>
El paquete ''iptables'' viene instalado por defecto.
</WRAP>

Puede filtrar tanto el tráfico que transita por un router Linux, como el tráfico entrante y saliente de cualquier servidor o estación de trabajo en una sola interfaz.

Es lo que hace que nuestra máquina Linux pueda convertirse en un router o firewall.

iptables funciona a través de reglas.

**Tablas**:

Iptables se basa en tablas asociadas a un modo funcional. Según el tipo de regla que se desea añadir en el funcionamiento de iptables, se precisará la tabla asociada:

  * ''filter'': Tabla de filtrado de paquetes (por defecto).
  * ''nat'': Tabla de traducción de direcciones entre una red privada y una pública.
  * ''mangle'' Tabla que sirve para modificar paquetes.

En función de la tabla que se use, definirán las acciones que podemos realizar sobre los paquetes y qué tipo de paquetes podremos utilizar.

**Cadenas**

  * ''INPUT'': Identifica el tráfico entrante.
  * ''OUTPUT'': Identifica el tráfico saliente.
  * ''FORWARD'': Identifica el tráfico que atraviesa la máquina.
  * ''PREROUTING'': En NAT, sirve para tratar paquetes antes del enrutamiento.
  * ''POSTROUTING'': Se utiliza en la configuración de NAT, tiene como objetivo tratar paquetes después de una operación de enrutamiento.

Una cadena de iptables representa un tipo de tráfico desde el punto de vista de su circulación por una máquina. Las cadenas permiten especificar si una regla debe aplicarse al tráfico que entra en una máquina, que sale o que la cruza.

**Acciones**:

  * ''ACCEPT'': Permite el paso del paquete.
  * ''DROP'': Destruye el paquete.

Un cortafuegos puede funcionar según dos modelos distintos:

  * Todo lo que no está autorizado está prohibido.
  * Todo lo que no está prohibido está autorizado.

Para definir el comportamiento por defecto, **iptables** permite definir para cada cadena una **acción por defecto**:

<code>
iptables -P <cadena> <acción>
</code>

Ejemplo:

<code>
iptables -P OUTPUT DROP
</code>

Estaríamos diciendo que, por defecto, ningún paquete puede salir de nuestra máquina.

Cadenas usadas en cada tabla:
 
^          ^ PREROUTING ^ INPUT ^ FORWARD ^ OUTPUT ^ POSTROUTING ^
| FILTER   |            |   X   |    X    |   X    |             |
| NAT      |      X     |       |         |   X    |      X      |
| MANGLE   |      X     |       |         |   X    |             |

=== Sintaxis reglas ===

Para cada elemento de tráfico que debe estar permitido o prohibido, habrá que crear una regla específica.

<WRAP center round info 60%>
Si no usamos la opción ''-t'', la tabla que se elegirá será **filter**.
</WRAP>

<code>
iptables -A <cadena> -s <ip_origen> -d <ip_destino> -p <protocolo> --dport <puerto> -j <acción>
</code>

  * ''-A <cadena>'': se añade una regla en la cadena ''cadena'' (INPUT, OUTPUT o FORWARD)
  * ''-s <ip_origen>'': (Opcional) la dirección IP origen de donde provienen los paquetes sometidos a la regla. Si la dirección es una dirección de red, hay que especificar la máscara.
  * ''-d <ip_destino>'': (Opcional) la dirección IP destino a la que van los paquetes sometidos a la regla. Si la dirección es una dirección de red, hay que especificar la máscara.
  * ''-p <protocolo>'': indica el protocolo utilizado en el paquete sometido a la regla. Valores comunes: ''udp'', ''tcp'', ''icmp''.
  * ''%%--%%dport <puerto>'': (Opcional) indica el puerto de destino del paquete sometido a la regla.
  * ''-j <acción>'': indica cómo tratar el paquete sometido a la regla (''ACCEPT'' o ''DROP'')

A continuación veremos ejemplos de reglas de **iptables**. Autorización de ping saliente y entrante:

<code>
iptables -A OUTPUT -p icmp -j ACCEPT
iptables -A INPUT -p icmp -j ACCEPT
</code>

Lo mismo, pero por IPv6:

<code>
ip6tables -A OUTPUT -p icmp -j ACCEPT
ip6tables -A INPUT -p icmp -j ACCEPT
</code>

Autorización del tráfico HTTP que pase por la máquina con origen una red determinada (subred 192.168.1.0/24):

<code>
iptables -A FORWARD -s 192.168.1.0/24 -p tcp --dport 80 -j ACCEPT
</code>

Es decir, todos los paquetes que vengan de la subred 192.168.1.0/24 del protocolo TCP y destino puerto 80, se aceptarán. Básicamente estaríamos permitiendo a nuestras máquinas locales acceder a páginas web.

<WRAP center round important 60%>
Cargar las reglas de esta manera no es permanente sino que solo se almacenan en memoria. Al reiniciar el equipo, las habremos perdido.
</WRAP>

Las reglas se aplican en su orden de creación y el sistema les asigna automáticamente un número de orden.

Visualización de reglas efectivas:

<code>
iptables- L
</code>

Ejemplo de salida:

<code>
Chain INPUT (policy ACCEPT)
target     prot opt source               destination
Chain INPUT (policy ACCEPT)
target     prot opt source               destination
f2b-sshd   tcp  --  anywhere             anywhere             multiport dports ssh

Chain FORWARD (policy DROP)
target     prot opt source               destination
DOCKER-USER  all  --  anywhere             anywhere
DOCKER-ISOLATION-STAGE-1  all  --  anywhere             anywhere
ACCEPT     all  --  anywhere             anywhere             ctstate RELATED,ESTABLISHED
DOCKER     all  --  anywhere             anywhere
ACCEPT     all  --  anywhere             anywhere
ACCEPT     all  --  anywhere             anywhere
ACCEPT     all  --  anywhere             anywhere             ctstate RELATED,ESTABLISHED
DOCKER     all  --  anywhere             anywhere
(...)
</code>

Visualización de los números de reglas efectivas:

<code>
iptables -L <cadena> --line-numbers -n
</code>

Ejemplo:

<code>
iptables -L FORWARD --line-numbers -n
</code>

Eliminación de un regla:

<code>
iptables -D <cadena> <número>
</code>

Ejemplo:

<code>
iptables -D FORWARD 1
</code>

=== iptables con la tabla nat ===

**NAT** consiste en reescribir la cabecera IP de un paquete que viaja de una red pública a una red privada y viceversa. Básicamente es lo que hace un router doméstico cuando desde un equipo local queremos salir a Internet. En los equipos locales tenemos IPs privadas y es necesario tener una IP pública para salir a Internet. El router modifica los paquetes enviados desde los equipos locales y enmascara su dirección poniéndole la pública.

{{ :informatica:certificaciones:lpic:lpic-2:212_system_security:iptables-nat.png?nolink |}}

Las **cadenas** que se tratan en la tabla NAT son ''PREROUTING'', ''POSTROUTING'' y ''OUTPUT'', que representan el tráfico que hay que modificar antes del enrutamiento, después del enrutamiento o directamente en la salida de la máquina.

Visualización de la configuración NAT:

<code>
iptables -t nat -L
</code>

**Acciones de NAT**:

  * ''MASQUERADE'': cambia la IP de origen (cuando es dinámica, como pasa en los routers domésticos).
  * ''SNAT'': cambia la IP de origen (cuando es estática).
  * ''DNAT'': cambia la IP de destino.

**Configuración de NAT**:

<code>
iptables -t nat -A POSTROUTING -o <tarjeta_exterior> -j <acción_nat>
</code>

  * ''-t nat'': la regla afecta a la tabla **NAT**.
  * ''-A POSTROUTING'': se añade una regla a la cadena POSTROUTING para el procesado después del enrutamiento.
  * ''-o <tarjeta_exterior>'': identifica la tarjeta de red por la cual salen los paquetes del cortafuegos.
  * ''-j <acción_nat>'': identifica el modo de acción de NAT, soporta dos opciones: ''SNAT'' si la dirección pública es fija y ''MASQUERADE'' si la dirección pública es dinámica.

Ejemplo:

<code>
iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE
</code>

Ese router/equipo Linux tendría dos interfaces de red, una que va a la red local (eth0) y otra a Internet (WAN). Lo que hacemos es que todos los paquetes que salgan a Internet (interfaz eth1), se enmascaren con la IP pública del propio router.

==== Fichero de reglas de iptables ====

Lo normal es crear un fichero con las reglas de iptables para luego cargarlos al arranque del sistema. Lo primero que debe de haber en este fichero es una limpieza de las tablas y cadenas personalizadas.

Limpiar todas las tablas:

<code>
iptables -t mangle -F
iptables -t nat -F
iptables -t filter -F
</code>

Limpiar todas las cadenas personalizadas de las tablas

<code>
iptables -t mangle -X
iptables -t nat -X
iptables -t filter -X
</code>

De este modo nos aseguramos de que se borran todas las reglas que hubiese disponibles y podemos cargar las nuestras correctamente.

''iptables-save'': comando que permite almacenar la configuración iptables en un fichero. 

Ejemplo:

<code>
iptables-save > /etc/iptables.rules
</code>

''iptables-restore'': comando que permite cargar la configuración iptables desde un fichero.

Ejemplo:

<code>
iptables-restore < /etc/iptables.rules
</code>