# FireWall con iptables (por donde empezar?)

## nachopro

Hola a todos  :Smile: 

Tengo muchas dudas y no sé por donde empezar. Leí varios tutoriales pero no termino de entender.

Les cuento, tengo un VPS con gentoo.

Primero: Cómo verifico que tenga el Kernel listo para utilizar iptables?

Segundo: Instalé iptables e hice algunos estragos (que no pude resolver y tuve que reiniciar Gentoo)

Es simple, tengo dos interfaces, lo y eth0.

Quiero bloquear todo, excepto los puertos de mi interés...

Espero no molestarlos pq se que hay miles de cosas al respecto... pero lo que abunda molesta  :Sad: 

----------

## pelelademadera

http://www.gentoo.org/doc/es/home-router-howto.xml#doc_chap2

esta bastante claro...

----------

## nachopro

gracias por no leer mi post

----------

## pelelademadera

iptables -A INPUT -i ${LAN} -d 0/0 --dport 0:1023 -j DROP

ahi esta la regla para bajar puertos que no te gusten

man iptables te tira que hace cada opcion.

en definitiva, tenes que decir que rebote los puertos que no quieras, de la interface eth0

iptables -A INPUT -i eth0 -dport x:y -j DROP

----------

## gringo

yo ya no me rompo la cabeza con netfilter y uso scripts de terceros para crear mis reglas de cortafuegos, uso el script de arno ahora mismo p.ej. ( está disponible en portage) :

http://rocky.eld.leidenuniv.nl/joomla/

para saber que es lo que te hace falta del kernel realmente tendrías que ir módulo a módulo porque depende de tus necesidades y el uso que vayas a hacer del cortafuegos. Ante la duda habilita todo como módulo dentro de la sección "Network packet filtering framework ", que serán unos cuántos.

que dicho sea de paso, iptables son las herramientas, el cortafuegos en si se llama Netfilter ( o Xtables en sus veriones mas modernas).

saluetes  :Wink: 

----------

## Stolz

 *nachopro wrote:*   

> Es simple, tengo dos interfaces, lo y eth0.
> 
> Quiero bloquear todo, excepto los puertos de mi interés...

 

Respuesta rápida:

No soy ningún experto en iptables pero aquí va mi humilde aportación basada en lo que he ido leyendo en los foros a lo largo de los años. Para lo que pides, creo que esto sería suficiente

```
# Limpiar todas las reglas y cadenas existentes

iptables -F

iptables -X

# Política por defecto si un paquete no corresponde a ninguna de las reglas que definiremos luego:

#  - Rechazar todo lo que entre para nosotros

#  - Rechazar todo lo que entre para otros

#  - Aceptar todo lo que salga de nosotros

iptables -P INPUT DROP

iptables -P FORWARD DROP

iptables -P OUTPUT ACCEPT

# Aceptar todas las conexiones entrantes que sean consecuencia de nuestras conexiones salientes

iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Aceptar la entrada de todo lo que provenga de la interfaz loopback (lo)

iptables -A INPUT -i lo -j ACCEPT 

# Aceptar conexiones en el puerto XXXX protocolo TCP y puerto YYYY protocolo UDP

iptables -A INPUT -p tcp --dport XXXX -m state --state NEW -j ACCEPT

iptables -A INPUT -p udp --dport YYYY -j ACCEPT
```

Respuesta larga:

Si te aburre la teoría ve directo al paso 2.

1.- Sintaxis de una regla

Una regla de IPTABLES tiene la siguiente forma:

 iptables [-t <tabla>] <comando> <cadena> <parámetro 1><opción 1>...<parámetro N> <opción N> <acción>

Donde:

<tabla>:

 • filter: Es la tabla por defecto y la que se encarga de filtrar los paquetes de red.

 • nat: Es la tabla usada para alterar las direcciones origen y/o destino en los paquetes de entrada ó salida que establecen conexiones.

 • mangle: Permite realizar alteraciones locales del origen o destino de los paquetes, lo que permite por ejemplo, balancear el tráfico que accede a un servicio a un conjunto de ordenadores.

 • raw: Permite configurar excepciones en el seguimiento de los paquetes de las conexiones.

<comando>:

-A Añade la regla especificada al final de la cadena especificada.

-C Chequea una regla antes de que sea añadida por el usuario a la cadena especificada.

-D Borra una regla de la cadena especificada. Puede especificarse por un número que indique su posición, comenzando a contar siempre en 1, o bien escribir la regla completa a borrar.

-E Renombra una cadena definida por el usuario. Esta acción no afecta a la estructura de la tabla donde se encuentra la cadena.

-F Borra todas la reglas de la cadena especificada. Si no se especifica la cadena, todas las reglas de todas las cadenas son borradas.

-h Proporciona información de ayuda.

-I Inserta una regla en la cadena en la posición indicada. Si no se indica ninguna posición la regla es insertada al principio de la cadena.

-L Lista todas las reglas. Los valores -v, -x y -n, permiten especificar que la salida sea más extensa, que se de en valores exactos y no abreviados con K (miles), M (millones), etc., y que se de en valor numérico de direcciones IP y puertos, respectivamente.

-N Crea una nueva cadena con el nombre especificado por el usuario.

-P Asigna la política por defecto a una cadena, de forma que si un paquete no corresponde a ninguna regla, esta será la acción por defecto a aplicar.

-R Reemplaza la regla situada en la posición indicada de la cadena por la regla especificada. Como en la opción –D empieza a contar en 1.

-X Borra una cadena especificada por el usuario. Borrar una cadena predefinida de una tabla no esta permitido.

-Z Inicializa a cero el contador de bytes y paquetes en todas las cadenas de una tabla.

<cadena>:

tabla filter:

 • INPUT: Se aplica a los paquetes destinados a un proceso local.

 • OUTPUT: Se aplica a los paquetes generados de forma local por un proceso y que van a ser enviados por la red.

 • FORWARD: Se aplica a los paquetes recibidos por un dispositivo de red y que van a ser reenviados por otro dispositivo de red del ordenador sin ser procesados por algún proceso local.

tabla nat:

 • PREROUTING: Se aplica a los paquetes recibidos por un dispositivo de red antes de ser procesados.

 • OUTPUT: Se aplica a los paquetes generados por un proceso local antes de ser enviados.

 • POSTROUTING: Se aplica a los paquetes antes de que salgan a la red.

tabla mangle:

 • PREROUTING: Se aplica a los paquetes recibidos por un dispositivo de red antes de ser enrutados.

 • INPUT: Se aplica a los paquetes destinados a un proceso local.

 • OUTPUT: Se aplica a los paquetes generados de forma local por un proceso antes de ser enrutados.

 • FORWARD: Se aplica a los paquetes que son reenviados a través de dos dispositivos de red del ordenador sin la intervención de ningún proceso local.

 • POSTROUTING: Se aplica a los paquetes antes de salir a la red.

tabla raw:

 • PREROUTING: Se aplica a los paquetes recibidos por cualquier dispositivo de red.

 • OUTPUT: Se aplica a los paquetes generados localmente por un proceso local.

<parámetro>: (solo los que suelo usar, para una lista completa consultar la documentación de IPtables)

 • -d: dirección IP y/o red que es el destino del paquete.

 • -i: Identifica el dispositivo de red de entrada, como ppp0 ó eth0, al que se debe aplicar la regla. Si ningún dispositivo de red es especificado se toma que todos los dispositivos de red existentes.

 • -j: Especifica una acción concreta cuando el paquete coincide con la regla.

 • -o: Similar a -i pero para interfaces de salida

 • -p: Selecciona el protocolo IP al que se aplicará la regla, por ejemplo tcp, udp, icmp, etc., o all para todos los protocolos soportados.

 • -s: Selecciona el nombre del ordenador, dirección IP o red, que es el origen del paquete.

 • -m: Activa el módulo indicado. Iptables soporta módulos para buscar distintos tipos de coincidencias en los paquetes. Esta opcion activa el módulo indicado.

<acción>

 • ACCEPT: Que indica que el paquete no debe ser analizado por el resto de reglas y tablas y debe permitirse su continuación hasta el destino.

 • DROP: Que especifica que el paquete debe ser rechazado sin enviar ningún tipo de mensaje a la dirección de origen del paquete.

 • QUEUE: Indica que el paquete debe ser enviado para su análisis a un módulo en el espacio del usuario.

 • RETURN: Devuelve el paquete a la regla siguiente a la que ocasiono la llamada a la regla que contiene esta acción. Suele ser utilizada en las reglas que se encuentran en las cadenas definidas por los usuarios.

2.- Configurar el kernel

La mayoría de gente se limita a marcar todas las opciones del kernel relacionadas con Netfilter, yo prefiero marcar solo las que realmente uso, que de momento son las siguientes:

a) Configuración básica

Estas son las opciones mínimas para usar IPTABLES como firewall (es decir, dar soporte a la tabla filter):

```
Networking  --->

  [*] Networking support

    Networking options  --->

      [*] Network packet filtering framework (Netfilter)  --->

        Core Netfilter Configuration  --->

          <M> Netfilter Xtables support (required for ip_tables)

        IP: Netfilter Configuration  --->

          <M> IP tables support (required for filtering/masq/NAT)

          <M>   Packet filtering
```

Con esta configuración mínima podremos hacer reglas básicas con un aspecto similar a este:

```
iptables -A INPUT -p tcp --sport http  -j ACCEPT
```

b) Relacionar paquetes con conexiones

Si además queremos poder hacer un seguimiento de los paquetes que han pasado por el ordenador para saber cuales son consecuencia de las conexiones que hemos realizado o si queremos utilizar el estado de una conexión (INVALID, ESTABLISHED, NEW, RELATED) como condición en una regla, entonces debemos de añadir la siguiente opción:

```
Networking  --->

  [*] Networking support

    Networking options  --->

      [*] Network packet filtering framework (Netfilter)  --->

        Core Netfilter Configuration  --->

          <M> Netfilter connection tracking support
```

Lo cual hace que a aparezcan nuevas opciones de las cuales debemos marcar las siguientes:

```
        Core Netfilter Configuration  --->

          <M>   "state" match support

        IP: Netfilter Configuration  --->

          <M> IPv4 connection tracking support (required for NAT)
```

Con esta configuración podremos hacer reglas con un aspecto similar a este:

```
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
```

c) Rangos de puertos

Para poder indicar rangos de puertos en una regla no es necesario activar nada, con separarlos por ":" es suficiente. Por ejemplo:

```
iptables -A INPUT -p tcp --sport 500:550  -j ACCEPT
```

Pero para poder indicar una lista de puertos no consecutivos tenemos que añadir una nueva opción:

```
Networking  --->

  [*] Networking support

    Networking options  --->

      [*] Network packet filtering framework (Netfilter)  --->

        Core Netfilter Configuration  --->

        [*]   Advanced netfilter configuration
```

Lo cual hace que a aparezcan nuevas opciones de las cuales debemos marcar las siguientes:

```
        Core Netfilter Configuration  --->

          <M>   "multiport" Multiple port match support
```

Con esta configuración podremos hacer reglas con un aspecto similar a este:

```
iptables -A INPUT -p tcp -m multiport --sport http,https  -j ACCEPT
```

d) Dejar constancia de los paquetes en el LOG del sistema

Podemos usar la función LOG de iptables para saber qué paquetes se están filtrando. Esta función es útil por ejemplo para saber qué intentos de ataque ha sufrido nuestra máquina o qué uso se intenta hacer de la red. También es útil para conocer los puertos que usa algún programa poco común el cual hemos observado que deja de funcionar con el firewall activado (obviamenteuna vez detectados lo mejor es desactivar el log porque carga el sistema). Para disponer de esta función de iptables tenemos que añadir una nueva opción:

```
Networking  --->

  [*] Networking support

    Networking options  --->

      [*] Network packet filtering framework (Netfilter)  --->

        IP: Netfilter Configuration  --->

          <M>   LOG target support
```

Con esta configuración podremos hacer reglas con un aspecto similar a este:

```
iptables -A INPUT -j LOG --log-level 2 --log-prefix "Firewall: "
```

Si además quieres que no se llene el log puedes usar el modulo limit para limitar cuanta informacion se guarda. Para activarlo hacer lo mismo que en c) pero en el ultimo paso marcar

```
          <M>   "limit" match support
```

Con lo que la regla con el límite aplicado quedaría:

```
iptables -A INPUT -m limit --limit 3/minute --limit-burst 3 -j LOG --log-level 2 --log-prefix "Firewall: "
```

3.- Instalación en Gentoo

```
emerge iptables
```

Como uso fail2ban que añade reglas de forma dinámica, no me interesa que se guarden al apagar el ordenador, por eso he hecho el siguiente cambio

```
$EDITOR /etc/conf.d/iptables

SAVE_ON_STOP="no"
```

Si queremos guardar nuestra configuración actual

```
/etc/init.d/iptables save
```

y para restaurarla

```
/etc/init.d/iptables restore
```

4.- Ejemplo de configuración

Esta esparte del script que uso actualmente. Como ya he dicho, no soy ningún experto en iptables así es que pueden haber cosas mal.

```
# Limpiar todas las reglas y cadenas existentes

iptables -F

iptables -X

# Política por defecto si un paquete no corresponde a ninguna de las reglas que definiremos luego:

#  - Rechazar todo lo que entre para nosotros

#  - Rechazar todo lo que entre para otros

#  - Aceptar todo lo que salga de nosotros

iptables -P INPUT DROP

iptables -P FORWARD DROP

iptables -P OUTPUT ACCEPT

# ------ REGLAS ---------------------------------------------------------------

# Para un ordenador cliente que no tenga programas a la escucha de conexiones

# debería ser suficiente con indicar esta regla:

# Aceptar todas las conexiones entrantes que sean consecuencia de nuestras conexiones salientes

iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Pero para un ordenador servidor deberemos de añadir reglas para permitir el acceso a los diferentes

# servicios que ofrezca. A continuación pongo algunas de las reglas típicas, (des)coméntalas según te convenga.

# NOTA: Si en el caso del ordenador servidor decides usar la regla explicada para el ordenador cliente

# muchas (por no decir todas) las reglas de tipo "Aceptar respuestas" que vienen a continuación se pueden

# omitir pues ya están incluidas en la regla anterior. Solo están listadas por si decides prescindir de la regla anterior

# para tener más control de las conexiones

echo loopback

# ===========

# Aceptar la entrada de todo lo que provenga de la interfaz loopback (lo)

iptables -A INPUT -i lo -j ACCEPT

echo ping ICMP

# ============

# Aceptar respuestas

iptables -A INPUT -p icmp --icmp-type echo-reply -j ACCEPT

# Aceptar peticiones

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

echo DNS

# ======

# Aceptar respuestas

iptables -A INPUT -p udp --sport domain -j ACCEPT

# Aceptar conexiones

iptables -A INPUT -p udp --dport domain -m state --state NEW -j ACCEPT

echo HTTP y HTTPs

# ===============

# Aceptar respuestas

iptables -A INPUT -p tcp -m multiport --sport http,https -j ACCEPT

# Aceptar conexiones

iptables -A INPUT -p tcp -m multiport --dport http,https -m state --state NEW -j ACCEPT

echo SSH

# ======

# Aceptar respuestas

iptables -A INPUT -p tcp --sport ssh -j ACCEPT

# Aceptar conexiones

iptables -A INPUT -p tcp --dport ssh -m state --state NEW -j ACCEPT

echo NTP

# ======

# Aceptar respuestas

iptables -A INPUT -p udp --sport ntp -j ACCEPT

# Aceptar peticiones

iptables -A INPUT -p udp --sport ntp -m state --state NEW -j ACCEPT

echo POP3 y POP3s

# ===============

# Aceptar respuestas

iptables -A INPUT -p tcp -m multiport --sport pop3,pop3s -j ACCEPT

# Aceptar conexiones

iptables -A INPUT -p tcp -m multiport --sport pop3,pop3s -m state --state NEW -j ACCEPT

echo SMTP

# =======

# Aceptar respuestas

iptables -A INPUT -p tcp --sport smtp -j ACCEPT

# Aceptar peticiones

iptables -A INPUT -p tcp --dport smtp -m state --state NEW -j ACCEPT

echo FTP

# ======

# Aceptar peticiones

iptables -A INPUT -p tcp --dport ftp -m state --state NEW -j ACCEPT

#Conexiones pasivas

iptables -A INPUT -p tcp --dport 2690:2695 -m state --state NEW -j ACCEPT

echo RSYNC

# ========

# Aceptar respuestas

iptables -A INPUT -p tcp --sport rsync -j ACCEPT

# Aceptar peticiones

iptables -A INPUT -p tcp --dport rsync -m state --state NEW -j ACCEPT

echo MySQL

# ========

# Aceptar respuestas

iptables -A INPUT -p tcp --sport mysql -j ACCEPT

# Aceptar peticiones

iptables -A INPUT -p tcp --dport mysql -m state --state NEW -j ACCEPT

echo NFS

# =======

# Aceptar peticiones

#...Portmap

iptables -A INPUT -p tcp --dport 111 -j ACCEPT

iptables -A INPUT -p udp --dport 111 -j ACCEPT

#...NFS

iptables -A INPUT -p tcp --dport 2049 -j ACCEPT

iptables -A INPUT -p udp --dport 2049 -j ACCEPT

#...nlockmgr (modulo lockd)

iptables -A INPUT -p tcp --dport 4001 -j ACCEPT

iptables -A INPUT -p udp --dport 4001 -j ACCEPT

#...status y mountd

iptables -A INPUT -p tcp --dport 32764:32767 -j ACCEPT

iptables -A INPUT -p udp --dport 32764:32767 -j ACCEPT

echo SAMBA

# ========

# Aceptar peticiones

iptables -A INPUT -p udp --dport 137:138 -m state --state NEW -j ACCEPT

iptables -A INPUT -p tcp --dport 139 -m state --state NEW -j ACCEPT

# Activar la siguiente solo si usamos 'Microsoft Active Directory'

iptables -A INPUT -p tcp --dport 445  -m state --state NEW-j ACCEPT

echo Distcc

# =========

#Para el servidor

iptables -A INPUT -p tcp --dport 3632 -m state --state NEW -j ACCEPT

#Si usas Avahi (zeroconf) para descubrir máquinas disponibles

iptables -A INPUT -p udp --dport 5353 -d 224.0.0.251 -j ACCEPT

echo SVN

# ======

# Aceptar conexiones

iptables -A INPUT -p udp --dport svn -m state --state NEW -j ACCEPT

iptables -A INPUT -p tcp --dport svn -m state --state NEW -j ACCEPT

echo Otros

# ========

# Denegar el acceso a todos los servicios a una determinada IP

iptables -I INPUT 1 -s 11.22.33.44 -j DROP

echo Guardando cambios

/etc/init.d/iptables save

iptables -L
```

5.- Desactivar IPtables (aceptar todo)

```
iptables -P INPUT ACCEPT

iptables -P FORWARD ACCEPT

iptables -P OUTPUT ACCEPT

iptables -F

iptables -X
```

----------

## opotonil

Un par de tonterias:

```

echo FTP 

# ====== 

# Aceptar peticiones 

iptables -A INPUT -p tcp --dport ftp -m state --state NEW -j ACCEPT 

#Conexiones pasivas 

iptables -A INPUT -p tcp --dport 2690:2695 -m state --state NEW -j ACCEPT

```

Te puedes ahorrar la parte de las conexiones pasivas si cargas el modulo "nf_conntrack_ftp" (yo suelo abrir también el puerto 20 "ftp-data", no se si realmente es necesario). Si utilizas Sane, en red, funciona de manera similar al FTP y hay un modulo similar "nf_conntrack_sane" (es experimental, pero me esta funcionando sin problemas). Por otra parte nunca he conseguido que funcione bien Samba sin cargar el modulo "nf_conntrack_netbios_ns".

Para gustos colores, pero a mi me gusta mas crear las reglas mediante "chains" me parece que queda todo mas organizado. Un mini ejemplo:

```

# Default policy.

iptables -P INPUT DROP

# Chain ftp accept.

iptables -N ftp    

iptables -A ftp -p tcp --dport ftp-data:ftp -j ACCEPT

# Chain samba accept.

iptables -N samba    

iptables -A samba -p tcp -m multiport --dport netbios-ssn,microsoft-ds -j ACCEPT

iptables -A samba -p udp --dport netbios-ns:netbios-dgm -j ACCEPT

# Rule input.

iptables -A INPUT -m state --state INVALID -j DROP

iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -A INPUT -i lo -j ACCEPT

iptables -A INPUT -j ftp

iptables -A INPUT -s 192.168.100.0/24 -j samba

```

Salu2.

----------

## nachopro

Bueno, luego de digerir todo lo que leí... di con el problema de muchos scripts.

Stolz, he probado scripts como el que mostrás.. pero tienen un "defecto"

primero hay que poner todo lo que queremos permitir, y luego denegar. en caso contrario queda la negación prioritaria sobre la aceptación.

me he hecho un simple pero efectivo script que verifica la IP de mi dominio dyndns, y se corre por cron.

en caso de que mi dyndns cambie se ejecuta la siguiente regla:

```

#!/bin/bash

# Limpio las reglas

iptables -F

# Casa

iptables -A INPUT  -i eth0 -s MI.DYNDNS -d IP.DE.MI.SERVIDOR -p tcp --dport 22 -j ACCEPT

iptables -A OUTPUT -o eth0 -s IP.DE.MI.SERVIDOR -d MI.DYNDNS  -p tcp --sport 22 -j ACCEPT

# Trabajo

iptables -A INPUT  -i eth0 -s DNS.DE.MI.TRABAJO  -d IP.DE.MI.SERVIDOR -p tcp --dport 22 -j ACCEPT

iptables -A OUTPUT -o eth0 -s IP.DE.MI.SERVIDOR -d DNS.DE.MI.TRABAJO  -p tcp --sport 22 -j ACCEPT

# Chau al resto

iptables -A INPUT  -i eth0 -s 0/0 -d IP.DE.MI.SERVIDOR -p tcp --dport 22 -j DROP
```

Con esto he solucionado los ataques masivos que sufría mi probre sshd son cientos de usuarios y passwords aleatorios  :Smile: 

es importante destacar que al momento de agregar la regla, iptables resuelve la IP y ésta queda grabada

por eso si el dyndns llega a cambiar, hay que volver a correr el script

espero le sirva a alguien

----------

## nachopro

 *gringo wrote:*   

> 
> 
> para saber que es lo que te hace falta del kernel realmente tendrías que ir módulo a módulo porque depende de tus necesidades y el uso que vayas a hacer del cortafuegos. Ante la duda habilita todo como módulo dentro de la sección "Network packet filtering framework ", que serán unos cuántos.

 

Claro, eso lo vi en varios lados y lo sabía de antes

pero en mi VPS al parecer viene todo compilado en el Kernel y no como módulo, ya que al hacer un lsmod no veo NADA!

pero se ve que funcionan las reglas que cargo con iptables

----------

## gringo

 *Quote:*   

> pero en mi VPS al parecer viene todo compilado en el Kernel y no como módulo, ya que al hacer un lsmod no veo NADA! 

 

normal, usar módulos es considerado por muchos un agujero de seguridad y la mayoría de distro orientadas a servidores deshabilitan este soporte por defecto. Si usas una distro para servidores ( rhel, centos, novel, etc) casi seguro que ya tienes todo lo que necesitas en tu kernel.

saluetes

----------

## ZaPa

Hola a todos.

Nachopro, el ejemplo que te indica más arriba Stolz su función es esa.

Prioritariamente DENEGAR el tráfico y despues aplicamos reglas de aceptación de tráfico...

```

iptables -A INPUT -j DROP

iptables -A OUTPUT -j DROP

iptables -A FORWARD -j DROP

```

Estas 3 lineas son las 3 primeras lineas del script de Stolz, con lo que esta diciendo que "de primeras" todo el tráfico entrante se dropea, el saliente también se dropea y el que "traspasa" nuestro pc (el tráfico se dirije hacia otro equipo) también se dropea. 

Dropear = Rechazar/Eliminar el paquete sin aviso ninguno. Al contrario de REJECT que descarta el paquete y informa al administrador.

Incluir la acción por defecto DROP a enganches (INPUT,FORWARD,OUTPUT) siempre se ha visto como algo muy "heavy" pero muy seguro, ya qué, todo el tráfico que no tengamos definido para aceptarlo (ACCEPT) se descartará (DROP).

Cláro está, que si utilizas la politica por defecto DROP, tendrás que declarar más abajo todo el tráfico que debe aceptarse (el que tú necesitas) por lo contrario, se eliminarán estos paquetes.

Con esto quiero decirte que ese ejemplo que te facilitó, eso que comentas no es un "defecto" , su funcionalidad es esa.

Un saludo.

----------

## nachopro

 *ZaPa wrote:*   

> Hola a todos.
> 
> Nachopro, el ejemplo que te indica más arriba Stolz su función es esa.
> 
> Prioritariamente DENEGAR el tráfico y despues aplicamos reglas de aceptación de tráfico...
> ...

 

Gracias Zapa, cada vez digiero mejor este tema gracias a sus aportes  :Smile: 

lo que pasó con mis primeros intentos de hacer el FW, y ahora me doy cuenta, es que hacía esos drops generales, abria los INPUTs pero no los OUTPUTs y así era cómo me quedaba sin acceso al servidor (por suerte los VPS incluyen una terminal ajax  :Wink: )

----------

## ZaPa

Hola de nuevo..

Exácto nachopro ese era el problema.

Cuando se aplica la politica DROP por defecto se tiene que trabajar con el tráfico de entrada (input) y tráfico de salida (output),cosa que si aplicas ACCEPT como politica por defecto no es necesario.

Si no quieres complicarte mucho puedes aplicar reglas ACCEPT por defecto y despues vas denegando a tu gusto, (seria lo más recomendable para empezar).

Realmente iptables no es tan tan dificil como parece, (parece mentira que yo iva a decir esto jeje) una vez comprendes claramente el transcurso que realiza un paquete cuando entra/sale de nuestro sistema, lo demás ya va solito.

Sigue dandole fuerte a iptables!.

Un saludo.

----------

