Configuración de un cortafuegos
(firewall) en Debian
Un cortafuegos se construye mediante un
filtro de paquetes y tiene el propósito de controlar el tipo de
acceso o salida por las interfases de red y resguardar el computador de
ataques maliciosos. El filtro de paquetes es un código que lee el
encabezado de un paquete que recibe una interfase (e.g. lo,
eth0 o ppp0) y luego decide si aceptarlo o rechazarlo
completamente antes de alcanzar un proceso local (demonio). En Linux, el
filtro de paquetes es parte del núcleo. A partir de la
versión 2.4 se reescribió completamente y pasó a
llamarse 'iptables', reemplazando al antiguo 'ipchains'.
La palabra "cortafuegos" puede dar una sensación falsa de
seguridad. No existe red complemente segura y si bien un cortafuegos
puede ser considerado como una primera línea de defensa, la
vigilancia ante actividades extrañas en el computador son
esenciales para mantener el sistema seguro. Si no has leído
aún sobre la seguridad del sistema
Debian sugerimos que lo hagas antes de continuar.
Configurar un cortafuegos puede resultar extremadamente complejo
si el servidor presta servicios en forma restrictiva. Este es
comúnmente el caso de redes comerciales en donde se está
más interesado en controlar y bloquear el uso de la red por parte
de los empleados que de resguardar la red de intrusos. Aquí
obviamente no estamos interesados en este tipo de aplicaciones. Nuestra
propuesta de configuración intenta ser lo más simple y
transparente posible y está ideada para proteger un servidor
Debian de intrusos externos sin restringir de ningún modo al
usuario.
Si tienes el núcleo de instalación con el sabor
bf24 (versión 2.4), tienes en el sistema todos los
módulos del filtro. Estos van a ser cargados en forma
automática cuando uses la herramienta iptables. Si
tienes el núcleo con el sabor idepci (versión
2.2) sugerimos que actualices a la versión 2.4 (lee sobre la compilación del núcleo de
Linux), compilando con los siguientes componentes: En la
sección " Networking options", marca " Networking
packet filtering", luego en la subsección " IP: Netfilter
Configuration", marca como módulo " Connection
tracking" y todos los soportes asociados, marca " IP tables
support" y todos los soportes asociados, incluyendo los de
" Packet filtering", " Full NAT" y " Packet
mangling".
Filtro de paquetes
iptables es la herramienta que inserta o remueve "reglas"
en la tabla del filtro de paquetes del núcleo y es instalada por
omisión en el sistema base. El núcleo parte con una
tabla que contiene tres listas básicas de reglas llamadas
"cadenas". Estas son INPUT, OUTPUT y FORWARD,
respectivamente (entrada, salida y redirección). Cuando un
paquete entra a una interfase de red, el núcleo examina primero
el destino del paquete y decide que ruta tomar (INPUT o FORWARD). Luego
el paquete es examinado en la cadena, en donde la decisión de
desechar ( DROP) o aceptar ( ACCEPT) el paquete es tomada.
Si la decisión es aceptar, el paquete continua hacia el destino,
siendo recibido por algún proceso local (demonio). En cambio, si
la decisión es desechar, el paquete es descartado completamente,
muriendo en el lugar, antes de alcanzar un proceso local.
_____
Entrante / \ Saliente
-->[Decisión]--->|FORWARD|------->
[de ruta ] \_____/ ^
| |
v ____
___ / \
/ \ |OUTPUT|
|INPUT| \____/
\___/ ^
| |
----> Proceso local ----
Un cadena es entonces una lista de reglas de
control. Cada regla dice, "si el encabezado del paquete es de esta
manera, aplico tal acción sobre él". La regla puede estar
compuesta de una o múltiples condiciones. Si cualquiera de las
condiciones de la regla no se cumple, la próxima regla es
consultada. Si el paquete llega al final de la cadena sin que alguna
regla le aplique, el núcleo consulta la "norma" (policy) definida
para la cadena. La norma puede ser DROP o ACCEPT. En un sistema en donde
la seguridad es prioridad, la norma de las cadenas INPUT y FORWARD
debería ser DROP.
Un programa o proceso también puede generar un paquete para
ser enviado, pasando por la cadena OUTPUT. Si la decisión es
ACCEPT, el paquete continua, saliendo por la interfase de red. Un
sistema en donde el control sobre sus usuarios es mínimo, la
norma de la cadena OUTPUT debería ser ACCEPT.
Aparte de las tres cadenas básicas, que son imborrables,
iptables permite crear nuevas cadenas e insertar reglas en ellas. Estas
no tienen norma y al llegar al final retornan al punto que fueron
llamadas. Las operaciones que se pueden realizar sobre una cadena
son:
- Crear una nueva cadena (-N).
- Borrar una cadena vacía (-X).
- Cambiar la norma de una cadena básica (-P).
- Lista de reglas en una cadena (-L).
- Vaciar las reglas de una cadena (-F).
- Volver a cero el contador de paquetes y bytes de todas las
reglas de una cadena (-Z).
Las operaciones para manipular una regla
dentro de una cadena son:
- Añadir una regla a una cadena (-A).
- Insertar una regla en algún punto de la cadena
(-I).
- Reemplazar una regla en algún punto de la cadena
(-R).
- Borrar una regla en algún punto de la cadena, o la
primera que coincida (-D).
A modo de ejemplo
Para comenzar, da el comando 'iptables -L' para producir
una lista de las cadenas y reglas. Ya que la tabla del filtro de
paquetes no ha sido manipulada, el comando retornará a la
pantalla las tres cadenas básicas vacías de reglas,
Chain INPUT (policy ACCEPT)
target prot opt source destination
Chain FORWARD (policy ACCEPT)
target prot opt source destination
Chain OUTPUT (policy ACCEPT)
target prot opt source destination
La norma por omisión de las tres
cadenas es ACCEPT.
A modo de ejemplo, vamos a manipular la tabla para bloquear
paquetes del protocolo ICMP (Internet Control Message Protocol)
provenientes de la dirección IP 127.0.0.1 (loopback). Este
protocolo es usado por ejemplo por ping para recibir un eco de
un servidor en la red. Para comenzar da el comando,
# ping -c1 127.0.0.1
PING 127.0.0.1 (127.0.0.1): 56 data bytes
64 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.1 ms
--- 127.0.0.1 ping statistics ---
1 packets transmitted, 1 packets received, 0% packet loss
round-trip min/avg/max = 0.1/0.1/0.1 ms
Este comando envía un paquete ICMP
tipo 8 (echo request) a la interfase loopback y el servidor (localhost)
responde con otro paquete ICMP tipo 0 (echo reply). El argumento
-c1 obliga a ping a enviar uno de estos paquetes y
luego terminar.
Vamos a añadir (-A) una regla a la cadena INPUT
para que pruebe todos aquellos paquetes cuyo protocolo (-p) es
ICMP, provenientes de la fuente (source, -s) 127.0.0.1 y luego
"salte" (jump, -j) al blanco (target) DROP,
# iptables -A INPUT -p ICMP -s 127.0.0.1 -j DROP
Ahora la lista en la tabla (iptables -L) contiene la
regla recién introducida,
# iptables -L INPUT
Chain INPUT (policy ACCEPT)
target prot opt source destination
DROP icmp -- localhost anywhere
Si un paquete recibido proviene de la fuente
127.0.0.1 y cuyo protocolo es ICMP, entonces la regla es cumplida y
salta (-j) al blanco DROP, es decir, el paquete es descartado.
El blanco también puede ser ACCEPT o el nombre de otra cadena, en
cuyo caso el paquete sufre un nuevo escrutinio con las reglas de esa
cadena. Todas las partes de una regla tienen que cumplirse para que la
regla salte al blanco. Si no es así, se consulta la siguiente
regla hasta que haya un concordancia completa o llegue al final de la
cadena y se le aplique la norma.
El comando 'ping -c1 127.0.0.1' no producirá eco
alguno del servidor, pues el paquete enviado morirá en la
interfase loopback antes que se produzca una respuesta. Para terminar
ping cancela con <ctrl>-<c>. Nota que la
primera manipulación de la tabla inserta automáticamente
los módulos ip_iptables y iptable_filter en el
núcleo. Nota también que cualquier regla que insertes en
la tabla será borrada cada vez que reinicies el computador.
Más adelante mostraremos como hacerlas permanentes en el sistema
Debian.
Para borrar la regla recién insertada existen varias
posibilidades. El comando 'iptables -D INPUT 1' borra la
primera regla de la cadena INPUT. Una réplica del comando,
reemplazando '-A' por '-D', 'iptables -D INPUT -p
ICMP -s 127.0.0.1 -j DROP', produce el mismo efecto. Esta
última forma es conveniente de usar cuando la cadena contiene
reglas complejas. Finalmente, el comando 'iptables -F INPUT'
vacía la cadena INPUT de todas sus reglas.
El protocolo (-p) del paquete a que se aplica la regla
puede ser 'TCP', 'UDP', 'ICMP' o
'ALL' (todos). Mayúsculas o minúsculas no tienen
importancia. El prefijo "!" invierte el argumento. Por ejemplo,
'-p ! TCP' especifica todos los protocolos a excepción
de los de tipo TCP. "!" es equivalente a un not
lógico.
La dirección de la fuente (-s) o destino
(-d) puede especificarse de cuatro maneras. Puede ser un
nombre, como 'localhost' o 'fusion.nuclear.cl', o un
número IP. También puede ser un rango de números
IP, como '200.79.123.0/24' o equivalentemente
'200.79.123.0/255.255.255.0'. Ambos casos especifican el rango
de números IP de 200.79.123.0 a
200.79.123.255. Los dígitos después de "/"
denotan la parte del número IP que es significativo.
"/24" dice que los 24 primeros bits del número son
significativos, o si quieres, los tres primeros grupos de 8 bits.
"/32" o "/255.255.255.255" es equivalente a una
correspondencia completa del número IP que va delante.
"/0" o "/0.0.0.0" especifica cualquier número
IP y es quivalente a omitir -s o -d completamente. La
cuarta forma de especificar la fuente o destino es similar a la
máscara de red y es por ende conveniente de usar cuando la
máscara es poco convencional. El prefijo "!" invierte el
argumento. Por ejemplo, '-s ! localhost' especifica toda fuente
a excepción de localhost.
Existen muchos blancos. Aquí vamos a usar solo los blancos
DROP y ACCEPT. Otro blanco común es RETURN usado para
terminar la cadena actual y retornar a la cadena inicial.
También se puede especificar la interfase de entrada
(-i), la que recibe el paquete, o la interfase de salida
(-o). Por ejemplo, '-i eth0' o '-i ppp0'. En
ambos casos se puede invertir el argumento con un "!".
El puerto de destino del paquete o el puerto de la fuente lo
especifican las opciones '--destination-port' (o
'--dport') y '--source-port' (o '--sport').
Por ejemplo, '--dport 80', prueba aquellos paquetes destinados
al puerto http. Para saber qué número de puerto
corresponde a cada protocolo consulta el archivo
/etc/services.
Existen condiciones genéricas, implícitas y
explícitas. Las genéricas son aquellas condiciones que no
dependen del protocolo que se está probando, por ejemplo, el
protocolo (-p), la fuente (-s), el destino
(-d), la interfase de entrada (-i) o de salida
(-o). Las condiciones implícitas son aquellas que
están asociadas a un protocolo, por ejemplo, el puerto de la
fuente o destino, '-p TCP --sport 80' y '-p UDP --dport
80', respectivamente, o el tipo de paquete ICMP, '-p ICMP
--icmp-type 8'. Las condiciones explícitas, a diferencia de
las implícitas, no son cargadas automáticamente por
iptables y tienen que cargarse con la opción
'-m' antes de la condición. Por ejemplo, la
condición '--state' requiere declararse previamente,
'-m state --state NEW,RELATED,ESTABLISHED'.
Cortafuegos
Ahora vamos a manipular la tabla en serio, modificando la norma de
las cadenas básicas, creando nuevas cadenas e insertando reglas
en ellas para probar todos los paquetes recibidos por red. Primero es
necesario crear un "script", darle permisos de ejecución y
protegerlo de que sea leído por otros,
# touch cortafuegos.sh
# chmod 700 cortafuegos.sh
Una advertencia. Existen procesos internos que funcionan haciendo
llamados a la interfase loopback (127.0.0.1) u otros números IP
de las redes privadas. Puede suceder que un cortafuegos mal configurado
bloquee estos procesos causando una pérdida del control de
computador. Para evitar esto, mientras configuras el cortafuegos,
sugerimos correr un "cron" que cada cierto tiempo borre la tabla. Da el
comando 'crontab -e' e inserta las siguientes
líneas,
# m
h dom
mon dow command
*/15 *
*
*
* /etc/init.d/iptables clear
Luego sal del editor. Este cron va a borrar
la tabla cada 15 minutos. Si el computador se cuelga, espera a que la
hora sea un múltiplo de 15 minutos y volverás a controlar
el computador. Una vez que el cortafuegos este configurado, comenta o
borra la segunda línea corriendo 'crontab -e'
nuevamente.
Cortafuegos para ppp0
La primera propuesta de cortafuego es apta para un sistema Debian
conectado a la red por módem o ADSL (interfase ppp0) y
que no presta ningún servicio de red. Si tienes una
conexión tipo T1 (ethernet) sugerimos que igual estudies el
ejemplo ya que contiene aspectos comunes que se usarán más
adelante. Edita el archivo cortafuegos.sh e inserta las
siguientes líneas:
-----------------------------------------------------------------------------
#!/bin/sh
# 1) Borrar la actual tabla
/etc/init.d/iptables clear
# 2) Definir la norma de cada cadena básica
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT
# 3) Manipular la cadena INPUT
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -m state --state NEW -i ! ppp0 -j ACCEPT
#iptables -A INPUT -j LOG --log-level debug --log-prefix "Drop INPUT: "
# 4) Grabar las reglas de la tabla
/etc/init.d/iptables save active
-----------------------------------------------------------------------------
En 1) se borra la actual tabla de todas sus
cadenas y reglas a excepción de las cadenas básicas que
quedan vacías.
En 2) se modifica la norma de las cadenas INPUT y FORWARD a DROP.
Nota que la cadena OUTPUT se deja con la norma ACCEPT. A estas alturas,
la tabla va a descartar cualquier paquete entrante o redirigido en
cualquier interfase de red y va aceptar cualquier paquete saliente.
En 3) se añade una regla a la cadena INPUT que acepta todo
paquete de una conexión ya establecida o
relacionada. Si una interfase envía o recibe un paquete de
cualquier dirección interna o externa requiriendo una
conexión, todo paquete que el receptor o emisor envíe de
vuelta y llegue a INPUT será en estado establecido o relacionado,
siendo aceptada por esta regla. La próxima línea acepta
todo paquete en INPUT que requiere una nueva conexión pero que no
provenga de la interfase ppp0, es decir la interfase externa.
En particular, cualquier nueva conexión requerida por la
interfase loopback será aceptada. Esto es aceptable solo si
tienes una (y solo una) interfase ( ppp0) conectada a la red
externa. Cualquier otra interfase conectada al exterior (una tarjeta
ethernet en eth0 o un segundo módem en ppp1)
quedará desprotegida con esta regla, creando un agujero por el
cual un intruso podría meterse. La tercera regla (que esta
comentada) sirve para hacer diagnósticos. Al descomentarla todo
paquete que no haya cumplido ninguna de las dos reglas previas es
registrado con syslog. El blanco LOG siempre retorna a donde
fue llamado. El nivel de registro puede ser ' debug',
' info', ' notice', ' warning', ' err',
' crit', ' alert' o ' emerg'. Si el nivel es
' debug' todo paquete descartado por la norma será
registrado en /var/log/debug con el prefijo " Drop
INPUT:". Como ves, un paquete que cruza una cadena lo hace en forma
secuencial, probándose cada regla una por una. Si la regla no se
aplica al paquete en su totalidad, la próxima regla es probada.
Si el paquete cumple cualquiera de estas reglas, salta inmediatamente al
blanco y sale de la cadena. Si un paquete logra llegar al final de la
cadena, es descartado por la norma de INPUT. La regla que está
comentada es para
Finalmente, en 4) se graba la tabla con el nombre
' active'. En Debian, la tabla se graba en el directorio
/var/lib/iptables con el nombre especificado.
Ahora corre el script ' ./cortafuegos.sh', luego
conéctate a la red con PPP o PPPoE y prueba conexiones a
servidores externos. Si no encuentras ningún problema, puedes
borrar el cron usado para borrar la tabla cada 15 minutos. Si deseas
puede ir a la sección que describe como hacer las reglas permanentes en la tabla.
Cortafuegos para eth0
Ahora vamos a presentar un cortafuegos de uso más amplio,
apto para un servidor conectado a la red por una interfase ethernet
( eth0) y que presta algunos servicios de red, como servicios
ftp, http, ssh, ntp y otros.
------------------------------------------------------
#!/bin/sh
/etc/init.d/iptables clear
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT
# 1) Definir la interfase externa y loopback y respectivos no. IPs
INET_IFACE="eth0"
INET_IP="200.89.74.17"
LO_IFACE="lo"
LO_IP="127.0.0.0/8"
# 2) Cadena INPUT general
iptables -A INPUT -i $INET_IFACE -p TCP -j bloquear-spoof
iptables -A INPUT -p TCP -m state --state NEW ! --syn -j DROP
iptables -A INPUT -i $INET_IFACE -s $INET_IP -j DROP
iptables -A INPUT -i $INET_IFACE -d ! $INET_IP -j DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -i $LO_IFACE -p ALL -s $LO_IP -j ACCEPT
iptables -A INPUT -i $LO_IFACE -p ALL -s $INET_IP -j ACCEPT
iptables -A INPUT -i $INET_IFACE -p ICMP -j pqtes-icmp-permitidos
iptables -A INPUT -i $INET_IFACE -p UDP -j pqtes-udp-permitidos
iptables -A INPUT -i $INET_IFACE -p TCP -j pqtes-tcp-permitidos
# 3) Cadena OUTPUT
iptables -A OUTPUT -o $INET_IFACE -p TCP -j bloquear-spoof
iptables -A OUTPUT -p TCP -m state --state NEW ! --syn -j DROP
# 4) Definir la cadena "bloquear-spoof" para proteger
números IP privados desde el exterior
iptables -N bloquear-spoof
iptables -A bloquear-spoof -p TCP -s 192.168.0.0/16 -j DROP
iptables -A bloquear-spoof -p TCP -s 10.0.0.0/8 -j DROP
iptables -A bloquear-spoof -p TCP -s 172.16.0.0/12 -j DROP
# 5) Cadena "pqtes-icmp-permitidos"
iptables -A pqtes-icmp-permitidos -i $INET_IFACE -p ICMP --icmp-type 8 -j ACCEPT
iptables -A pqtes-icmp-permitidos -i $INET_IFACE -p ICMP --icmp-type 11 -j ACCEPT
iptables -A pqtes-icmp-permitidos -i $INET_IFACE -p ICMP -j DROP
# 6) Cadena "pqtes-udp-permitidos"
iptables -N pqtes-udp-permitidos
iptables -A pqtes-udp-permitidos -i $INET_IFACE -p UDP -m state --state NEW \
--dport 123 -j ACCEPT
iptables -A pqtes-udp-permitidos -i $INET_IFACE -p UDP -j DROP
# 7) Cadena "pqtes-tcp-permitidos"
iptables -N pqtes-tcp-permitidos
iptables -A pqtes-tcp-permitidos -i $INET_IFACE -p TCP -m state --state NEW \
-m multiport --dport 21,25,80,443 -j ACCEPT
iptables -A pqtes-tcp-permitidos -i $INET_IFACE -p TCP -m state --state NEW \
-s 200.89.74.0/24 --dport 22 -j ACCEPT
iptables -A pqtes-tcp-permitidos -i $INET_IFACE -p TCP -j DROP
/etc/init.d/iptables save active
------------------------------------------------------
Recuerda que esta es una
proposición para ser modificada de acuerdo a tus necesidades.
Comenta o borra toda línea que no se aplique a tu caso en
particular.
En 1) se define la interfase conectada al la red externa
( eth0) y loopback ( lo) y sus respectivos
números IP. Modifica la variable INET_IP con el
número IP de tu servidor.
En 2) comienza la manipulación de la cadena INPUT. La
primera regla hace saltar todo paquete que llega a la interfase externa
a la cadena " bloquear-spoof" para descartar todo paquete
obviamente malicioso. La segunda regla requiere explicación. Todo
paquete TCP tiene una serie de indicadores llamados banderines
(flags). En iptables los banderines TCP se prueban con
' --tcp-flags', por ejemplo, ' iptables -p TCP --tcp-flags
SYN,ACK,FIN SYN'. En este caso, los banderines SYN, ACK y FIN son
probados exigiéndose que SYN esté puesto pero no ACK y
FIN. En un paquete TCP que requiere una nueva conexión, SYN
debería estar puesto, pero no ACK y FIN. El acrónimo
' --syn' es equivalente a esto. La segunda regla dice entonces
que descarte todo paquete TCP en estado nuevo que no tenga los
banderines SYN puestos y ACK y FIN no puestos. La tercera regla descarta
todo paquete que llega a la interfase externa con un número IP
idéntico al mio. La cuarta regla descarta todo paquete que llega
a la interfase externa cuyo destino no soy yo. La quinta regla acepta
todo paquete en estado establecido y relacionado. La sexta y septima
regla acepta todo paquete que llega a la interfase loopback provenientes
de 127.0.0.0/24 y del número IP del servidor. Las proximas tres
reglas hacen saltar todo paquete de los protocolos ICMP, UDP y TCP que
llega a la interfase externa en INPUT a las cadenas
" pqtes-icmp-permitidos", " pqtes-udp-permitidos" y
" pqtes-tcp-permitidos", respectivemante.
En 3) se manipula la cadena OUTPUT para que bloquear
números IP indebidos y paquetes tipo TCP en estado nuevo que no
tengas los banderines correctos.
En 4) se define la cadena " bloquear-spoof" para descartar
paquetes TCP en la interfase externa cuya fuente son números IP
de las redes privadas. Estos números son reservados para redes
internas y no deberían circular en forma externa.
En 5) se define la cadena " pqtes-icmp-permitidos" con
reglas relacionadas al protocolo ICMP. La primera regla acepta paquetes
ICMP de tipo 8 (echo request) para permitir que la red externa reciba
una respuesta con ping. La segunda regla acepta paquetes ICMP
de tipo 11 (time exceeded). La última regla de la cadena descarta
todo paquete ICMP que no haya cumplido las reglas previas. Al no
especificarse una dirección de la fuente con ' -s' las
reglas aceptan todo número IP.
En 6) se define la cadena " pqtes-udp-permitidos" con
reglas relacionadas al protocolo UDP. La primera regla prueba paquetes
de la interfase externa, en estado nuevo, cuyo destino es el puerto ntp
(puerto 123) para permitir a ntp
servir correctamente requerimientos externos. La última regla de
la cadena descarta todo paquete UDP que no haya cumplido la regla
previa.
En 7) se define la cadena " pqtes-tcp-permitidos" con
reglas relacionadas al protocolo TCP. En la primera regla los puertos 21
(ftp), 25 (smtp), 80 (http) y 443 (https) son abiertos a requerimientos
de todo número IP por la interfase de la red externa. Para poder
especificar múltiples puertos es necesario cargar la
condición ' multiport' explícitamente. Si no
prestas servicios por cualquiera de estos puertos, borra el
número correspondiente, o agrega propios. Para que la regla del
puerto 21 (ftp) funcione correctamente, es necesario insertar en
módulo ip_conntrack_ftp en el núcleo. Abrir el
puerto 25 (smtp) es necesario para recibir correo electrónico con
exim. La regla siguiente permite a los números IP
200.89.74.0 a 200.89.74.255 hacer requerimientos SSH (puerto 22). La
última regla de la cadena descarta todo paquete TCP que no haya
cumplido las reglas previas.
Las reglas en las cadenas " pqtes-icmp-permitidos",
" pqtes-udp-permitidos" y " pqtes-tcp-permitidos" son
las que definen los servicios permitidos y las que deberías
modificar para tu caso en particular. El resto de cadenas y reglas son
de uso general y no requieren modificación alguna.
Ahora corre el script ' ./cortafuegos.sh', prueba
conexiones a servidores externos y si tienes acceso a un computador
externo a tu red, prueba conexiones a los servicios de red que prestas.
Si no encuentras ningún problema, puedes borrar el cron usado
para borrar la tabla cada 15 minutos.
Reglas permanentes
Para hacer permanentes las reglas insertadas en la tabla, edita el
archivo de configuración /etc/default/iptables y
modifica la variable ' enable_autosave' a ' true'. Luego
anda al directorio /etc/rcS.d/ y da el comando,
# ln -s ../init.d/iptables S38iptables
para crear un link simbólico de
/etc/init.d/iptables a /etc/rcS.d/S38iptables. Esto va
a permitir que la tabla grabada en /var/lib/iptables bajo el
nombre 'active' sea cargada al momento de arranque. Nota en
particular que la tabla se va a cargar antes de que la red sea activada
ya que ésta se carga con /etc/rcS.d/S40networking.
El comando 'iptables -L -v' hará un listado de las
cadenas y reglas de la tabla del filtro con los contadores de paquetes y
bytes.
Finalmente, hemos basado estas instrucciones en la
documentación, escrita por el creador de iptables, 'Rusty'
Russell, incluida en el paquete Debian iptables y que puedes
encontrar en,
/usr/share/doc/iptables/html/packet-filtering-HOWTO.html
También hemos usado el tutorial
escrito por Oskar Andreasson y que puedes encontrar en el depositario de software (paquete
iptables-tutorial).
© Copyright 2002-2004 Ricardo Yanez
|
