Estoy seguro de que los administradores de sistemas Linux están bastante familiarizados con iptablesla interfaz de usuario y el netfiltermarco de filtrado de paquetes.
Ahora, esta "Pregunta" está destinada a ser un Wiki de la Comunidad para recopilar varios trozos de iptablessabiduría. Nada es demasiado común o demasiado oscuro. Publica todo lo que sepas que ayude a otros a aprovechar al máximo iptables.
Respuestas:
#!/bin/bash
WHITELIST=/whitelist.txt
BLACKLIST=/blacklist.txt
#THIS WILL CLEAR ALL EXISTING RULES!
echo 'Clearing all rules'
iptables -F
#
## Whitelist
#
for x in `grep -v ^# $WHITELIST | awk '{print $1}'`; do
echo "Permitting $x..."
$IPTABLES -A INPUT -t filter -s $x -j ACCEPT
done
#
## Blacklist
#
for x in `grep -v ^# $BLACKLIST | awk '{print $1}'`; do
echo "Denying $x..."
$IPTABLES -A INPUT -t filter -s $x -j DROP
done
#!/bin/bash
ALLOWEDTCP="80 3128 3784"
ALLOWEDUDP="3128 3784"
#
## Permitted Ports
#
for port in $ALLOWEDTCP; do
echo "Accepting port TCP $port..."
$IPTABLES -A INPUT -t filter -p tcp --dport $port -j ACCEPT
done
for port in $ALLOWEDUDP; do
echo "Accepting port UDP $port..."
$IPTABLES -A INPUT -t filter -p udp --dport $port -j ACCEPT
done
# Attempt to block portscans
# Anyone who tried to portscan us is locked out for an entire day.
iptables -A INPUT -m recent --name portscan --rcheck --seconds 86400 -j DROP
iptables -A FORWARD -m recent --name portscan --rcheck --seconds 86400 -j DROP
# Once the day has passed, remove them from the portscan list
iptables -A INPUT -m recent --name portscan --remove
iptables -A FORWARD -m recent --name portscan --remove
# These rules add scanners to the portscan list, and log the attempt.
iptables -A INPUT -p tcp -m tcp --dport 139 -m recent --name portscan --set -j LOG --log-prefix "Portscan:"
iptables -A INPUT -p tcp -m tcp --dport 139 -m recent --name portscan --set -j DROP
iptables -A FORWARD -p tcp -m tcp --dport 139 -m recent --name portscan --set -j LOG --log-prefix "Portscan:"
iptables -A FORWARD -p tcp -m tcp --dport 139 -m recent --name portscan --set -j DROP
# Reject spoofed packets
# These adresses are mostly used for LAN's, so if these would come to a WAN-only server, drop them.
iptables -A INPUT -s 10.0.0.0/8 -j DROP
iptables -A INPUT -s 169.254.0.0/16 -j DROP
iptables -A INPUT -s 172.16.0.0/12 -j DROP
iptables -A INPUT -s 127.0.0.0/8 -j DROP
#Multicast-adresses.
iptables -A INPUT -s 224.0.0.0/4 -j DROP
iptables -A INPUT -d 224.0.0.0/4 -j DROP
iptables -A INPUT -s 240.0.0.0/5 -j DROP
iptables -A INPUT -d 240.0.0.0/5 -j DROP
iptables -A INPUT -s 0.0.0.0/8 -j DROP
iptables -A INPUT -d 0.0.0.0/8 -j DROP
iptables -A INPUT -d 239.255.255.0/24 -j DROP
iptables -A INPUT -d 255.255.255.255 -j DROP
# Drop all invalid packets
iptables -A INPUT -m state --state INVALID -j DROP
iptables -A FORWARD -m state --state INVALID -j DROP
iptables -A OUTPUT -m state --state INVALID -j DROP
# Stop smurf attacks
iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
iptables -A INPUT -p icmp -m icmp -j DROP
# Drop excessive RST packets to avoid smurf attacks
iptables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT
# Don't allow pings through
iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j DROP
iptablesen la línea 8, y luego $IPTABLESmás adelante. ¿Es suficiente usarlo en iptablestodas partes? De lo contrario, supongo que deberías asignar algo como IPTABLES=/sbin/iptables¿no?
ipsetSi escribe muchas reglas similares basadas en meras IP, puertos o ambos, considere usar ipsetpara optimizar el rendimiento de netfilter.
Por ejemplo:
iptables -s 192.168.1.11 -j ACCEPT
iptables -s 192.168.1.27 -j ACCEPT
iptables -s 192.168.1.44 -j ACCEPT
... hundreds of similar rules ...
iptables -s 192.168.251.177 -j ACCEPT
Esto significa que un paquete con la dirección de origen 192.168.251.177 primero debe atravesar cientos de reglas antes de poder obtener su veredicto de ACEPTAR.
Por supuesto, los administradores de sistemas experimentados dividirán las reglas por subred. Pero eso todavía significa cientos de reglas.
ipset ¡al rescate!
Primero, defina un conjunto de IP de ipmaptipo:
ipset -N Allowed_Hosts ipmap --network 192.168.0.0/16
Luego, complételo con las direcciones:
for ip in $LIST_OF_ALLOWED_IP; do ipset -A Allowed_Hosts $ip; done
Finalmente, reemplace los cientos de reglas de iptables anteriores con una regla:
iptables -m set --match-set Allowed_Hosts src -j ACCEPT
Cuando llega un paquete, netfilter realizará una búsqueda de mapa de bits muy rápida para la IP de origen (src) del paquete contra el Allowed_Hostsconjunto de IP. Todos los paquetes procedentes de 192.168.0.0/16 experimentarán una regla. Y créanme que buscar un mapa de bits es al menos dos órdenes de magnitud más rápido que realizar cientos de comprobaciones de reglas de iptables.
ipsetno se limita a las direcciones IP. También puede coincidir en función de los puertos, la tupla de puerto IP, las direcciones de red / subred, la tupla de IP-MAC, y así sucesivamente. Y puede coincidir con esos criterios como origen o destino o una combinación de ambos (en el caso de las tuplas).
Y finalmente, con ipsetusted puede poner automáticamente las direcciones IP en listas negras / blancas. Estas listas negras / blancas también pueden "envejecer", eliminando así automáticamente la dirección IP después de que haya transcurrido un período de tiempo configurable.
Consulte ipsetla página de manual de '' para obtener más detalles.
Es posible que algunas distribuciones de Linux no tengan soporte 'listo para usar' ipset(por ejemplo, Ubuntu 10.04 tuvo este problema). En estos sistemas, un método es instalar ipsetdesde el código fuente.
En su lugar, descargue ipsetla fuente de su sitio web: http://ipset.netfilter.org/install.html
Alternativamente, si usa xtables-addons, ipset se incluye en su fuente: http://xtables-addons.sourceforge.net/
Agregue las siguientes reglas, preferiblemente en -t raw -A PREROUTING
-p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
-p tcp --tcp-flags SYN,RST SYN,RST -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,PSH,URG -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN,RST,PSH,ACK,URG -j DROP
Los ataques que se bloquean son, respectivamente:
(siéntase libre de editar los nombres de los ataques anteriores)
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN,RST,PSH,ACK,URG -j DROPpodría eliminarse, ya -p tcp --tcp-flags FIN,SYN FIN,SYN -j DROPque capturará cada paquete que pueda bloquear.
echo 1 > /proc/sys/net/ipv4/ip_forward /sbin/iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADEEl paso 1 establece el parámetro del kernel para permitir el reenvío de ip, el paso 2 configura una regla de iptables que habilita NAT en la interfaz eth0.
/etc/sysctl.conf net.ipv4.ip_forward = 1. (Suponiendo Red Hat o derivado)
Agregue las siguientes reglas, preferiblemente en -t raw -A PREROUTING
-p icmp -m u32 ! --u32 "4&0x3FFF=0" -j DROP
-p icmp -m length --length 1492:65535 -j DROP
La primera regla bloquea todos los paquetes ICMP cuyo "indicador de fragmentación" no es 0. (ICMP nunca debe estar fragmentado; deben llevar pequeñas cargas útiles)
La segunda regla bloquea los paquetes ICMP no fragmentados de gran tamaño.
usando FireHOL - conveniente envoltorio de iptables
Lo encontré mucho más intuitivo que los comandos directos de iptables. Especialmente para personas con experiencia previa con otros firewalls:
FireHOL es un generador de firewall de iptables que produce firewalls de filtrado de paquetes de iptables con estado, en hosts y enrutadores Linux con cualquier número de interfaces de red, cualquier número de rutas, cualquier número de servicios servidos, cualquier complejidad entre las variaciones de los servicios (incluyendo positivo y negativo) expresiones).
(de mi archivo iptables_tricks.txt, compilado de muchos lugares: P)
Hace que iptables espere 15 segundos entre nuevas conexiones desde la misma IP en el puerto 22 (SSH):
iptables -A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --update --seconds 15 -j DROP
iptables -A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --set -j ACCEPT
-A INPUT -p tcp --dport 22 -m state --state NEW -m recent --set --name SSH -A INPUT -p tcp --dport 22 -m state --state NEW -m recent --update --seconds 60 --hitcount 5 --rttl --name SSH -j DROP
Video tutoriales de IPTABLES
Episodio 1 http://www.youtube.com/watch?v=ldB8kDEtTZA&feature=player_embedded
Episodio 2 http://www.youtube.com/watch?v=aDaEXxRHeXY&feature=related
Episodio final
http://www.youtube.com/watch?v=JojqHKcSxpo&feature=player_embedded
Será un buen comienzo para cualquier novato.
Ya hay una respuesta que menciona los conjuntos de IP. Sin embargo, es más bien unidimensional porque se enfoca en las ganancias de rendimiento sobre las reglas clásicas y el hecho de que los conjuntos de IP mitigan el problema que se tiene con muchas direcciones IP individuales que no se pueden expresar fácilmente como una subred en notación CIDR.
Porque ipsetusaré la notación leída ipset restorey escrita por ipset save.
En correspondencia con iptables(y ip6tables) reglas, usaré la notación como leída iptables-restorey escrita por iptables-save. Esto hace una notación más corta y me permite resaltar posibles reglas solo IPv4 (prefijadas -4) o solo IPv6 (prefijadas -6).
En algunos ejemplos, desviaremos el flujo de paquetes a otra cadena. Se supone que la cadena existe en ese punto, por lo que no se producen las líneas para crear las cadenas (ni se menciona el nombre de la tabla ni los comandos COMMITal final).
Los conjuntos de IP pueden hacer mucho más de lo que se mencionó en la otra respuesta y definitivamente debe leer la documentación del conjunto de IP ( ipset(8)) junto con iptables-extensions(8)esta breve entrada aquí.
Por ejemplo voy a centrar principalmente en tres tipos de conjuntos: hash:ip, hash:nety list:set, pero no son más que aquellos y todos ellos tienen casos de uso válidos.
Por ejemplo, también puede hacer coincidir los números de puerto, no solo las direcciones IP .
iptables-saveyiptables-restorePuede crear declaraciones de conjuntos de IP en masa e importarlas canalizándolas en ipset restore. Si desea que su comando sea más resistente frente a entradas ya existentes, use ipset -exist restore.
Si sus reglas están en un archivo llamado default.setque usaría:
ipset -exist restore < default.set
Un archivo como ese puede contener entradas a createconjuntos y a addentradas en ellos. Pero, en general, la mayoría de los comandos de la línea de comandos parecen tener una versión correspondiente en los archivos. Ejemplo (crear un conjunto de servidores DNS):
create dns4 hash:ip family inet
create dns6 hash:ip family inet6
# Google DNS servers
add dns4 8.8.8.8
add dns4 8.8.4.4
add dns6 2001:4860:4860::8888
add dns6 2001:4860:4860::8844
Aquí se crea un conjunto para IPv4 ( dns4) y uno para IPv6 ( dns6).
Los tiempos de espera en conjuntos de IP pueden establecerse como predeterminados por conjunto y también por entrada. Esto es muy útil para escenarios en los que desea bloquear a alguien temporalmente (por ejemplo, para escanear puertos o intentar forzar por fuerza bruta su servidor SSH).
La forma en que funciona es la siguiente (predeterminado durante la creación de conjuntos de IP):
create ssh_loggedon4 hash:ip family inet timeout 5400
create ssh_loggedon6 hash:ip family inet6 timeout 5400
create ssh_dynblock4 hash:ip family inet timeout 1800
create ssh_dynblock6 hash:ip family inet6 timeout 1800
Regresaremos a estos conjuntos en particular a continuación y la justificación de por qué están configurados como están.
Si desea establecer su tiempo de espera para una dirección IP en particular, simplemente puede decir:
add ssh_dynblock4 1.2.3.4 timeout 7200
Para bloquear IP 1.2.3.4 durante dos horas en lugar de la media hora predeterminada (establecida).
Si tuviera que ver eso con ipset save ssh_dynblock4un poco de tiempo, vería algo en la línea de:
create ssh_dynblock4 hash:ip family inet hashsize 1024 maxelem 65536 timeout 1800
add ssh_dynblock4 1.2.3.4 timeout 6954
Kernel error received: Unknown error -1).sudo ipset add ssh_dynblock4 1.2.3.4 timeout $((120*60))Dentro de sus scripts puede ser útil ver si ya existe una entrada. Esto se puede lograr con lo ipset testque devuelve cero si la entrada existe y, de lo contrario, no es cero. Por lo tanto, las comprobaciones habituales se pueden aplicar en un script:
if ipset test dns4 8.8.8.8; then
echo "Google DNS is in the set"
fi
Sin embargo, en muchos casos es preferible usar el -existinterruptor para ipsetque no se queje de las entradas existentes.
iptablesreglasEsta, en mi opinión, es una de las características principales de los conjuntos de IP. No solo puede hacer coincidir las entradas de un conjunto de IP, sino que también puede agregar nuevas entradas a un conjunto de IP existente.
Por ejemplo, en esta respuesta a esta pregunta tienes:
-A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --update --seconds 15 -j DROP
-A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --set -j ACCEPT
... con la intención de limitar la velocidad de los intentos de conexión a SSH (puerto TCP 22). El módulo utilizado recentrealiza un seguimiento de los intentos de conexión recientes. Sin embargo, en lugar del statemódulo, prefiero el conntrackmódulo.
# Say on your input chain of the filter table you have
-A INPUT -i eth+ -p tcp --dport ssh -j SSH
# Then inside the SSH chain you can
# 1. create an entry in the recent list on new connections
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
# 2. check whether 3 connection attempts were made within 2 minutes
# and if so add or update an entry in the ssh_dynblock4 IP set
-4 -A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock4 src --exist
-6 -A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock6 src --exist
# 3. last but not least reject the packets if the source IP is in our
# IP set
-4 -A SSH -m set --match-set ssh_dynblock4 src -j REJECT
-6 -A SSH -m set --match-set ssh_dynblock6 src -j REJECT
En este caso, estoy redirigiendo el flujo a la SSHcadena de modo que no tenga que repetirme -p tcp --dport sshpara cada regla.
Reiterar:
-m setse da iptablescuenta de que estamos usando conmutadores del setmódulo (que maneja conjuntos de IP)--match-set ssh_dynblock4 srcle dice iptablesque haga coincidir la dirección de origen ( src) con el conjunto nombrado ( ssh_dynblock4)
sudo ipset test ssh_dynblock4 $IP(donde $IPcontiene la dirección IP de origen para el paquete)-j SET --add-set ssh_dynblock4 src --existagrega o actualiza la dirección de origen ( src) del paquete en el conjunto de IP ssh_dynblock4. Si existe una entrada ( --exist), simplemente se actualizará.
sudo ipset -exist add ssh_dynblock4 $IP(donde $IPcontiene la dirección IP de origen para el paquete)Si en cambio quisieras hacer coincidir la dirección de destino / destino, usarías en dstlugar de src. Consulte el manual para más opciones.
Los conjuntos de IP pueden contener otros conjuntos. Ahora, si siguió el artículo hasta aquí, se habrá preguntado si es posible combinar conjuntos. Y por supuesto que es. Para los conjuntos de IP de arriba, podemos crear dos conjuntos de conjuntos ssh_dynblocky, ssh_loggedonrespectivamente, contener los conjuntos solo IPv4 y solo IPv6:
create ssh_loggedon4 hash:ip family inet timeout 5400
create ssh_loggedon6 hash:ip family inet6 timeout 5400
create ssh_dynblock4 hash:ip family inet timeout 1800
create ssh_dynblock6 hash:ip family inet6 timeout 1800
# Sets of sets
create ssh_loggedon list:set
create ssh_dynblock list:set
# Populate the sets of sets
add ssh_loggedon ssh_loggedon4
add ssh_loggedon ssh_loggedon6
add ssh_dynblock ssh_dynblock4
add ssh_dynblock ssh_dynblock6
Y la siguiente pregunta que debería surgir en su mente es si esto nos permite hacer coincidir y manipular conjuntos de IP de una manera independiente de la versión de IP.
Y la respuesta a eso es un rotundo: ¡SÍ! (por desgracia, esto no se documentó explícitamente la última vez que lo verifiqué)
En consecuencia, las reglas de la sección anterior se pueden reescribir para leer:
-A INPUT -i eth+ -p tcp --dport ssh -j SSH
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
-A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock src --exist
-A SSH -m set --match-set ssh_dynblock src -j REJECT
lo cual es mucho más conciso. Y sí, esto está probado y probado y funciona de maravilla.
En mis servidores, tengo un script ejecutado como un crontrabajo que toma un montón de nombres de host y los resuelve en direcciones IP, luego lo introduce en el conjunto de IP para "hosts de confianza". La idea es que los hosts de confianza tengan más intentos de iniciar sesión en el servidor y no estén necesariamente bloqueados por el tiempo que nadie más.
Por el contrario, tengo países enteros bloqueados para conectarse a mi servidor SSH, con la excepción (potencial) de hosts confiables (es decir, el orden de las reglas es importante).
Sin embargo, eso se deja como un ejercicio para el lector. Aquí me gustaría agregar una solución ordenada que utilizará los conjuntos contenidos en el ssh_loggedonconjunto para permitir que los intentos de conexión posteriores se transmitan y no estén sujetos al mismo escrutinio que los otros paquetes.
Es importante recordar los tiempos de espera predeterminados de 90 minutos ssh_loggedony 30 minutos ssh_dynblockal observar las siguientes iptablesreglas:
-A INPUT -i eth+ -p tcp --dport ssh -j SSH
-A SSH -m set --match-set ssh_loggedon src -j ACCEPT
-A SSH -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
-A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock src --exist
-A SSH -m set --match-set ssh_dynblock src -j REJECT
Ahora debería preguntarse cómo termina la dirección IP de conexión en los ssh_loggedonsubconjuntos. Entonces sigue leyendo ...
Si ha experimentado con sshrcy amigos, se habrá enterado de sus defectos. Pero PAM viene al rescate. Un módulo llamado pam_exec.sonos permite invocar un script durante el inicio de sesión SSH en un punto en el que sabemos que el usuario está admitido.
A /etc/pam.d/sshdcontinuación, las entradas pam_envy pam_selinuxagregan la siguiente línea:
session optional pam_exec.so stdout /path/to/your/script
y asegúrese de que su versión del script ( /path/to/your/scriptarriba) exista y sea ejecutable.
PAM usa variables de entorno para comunicar lo que está sucediendo, por lo que puede usar un script simple como este:
#!/bin/bash
# When called via pam_exec.so ...
SETNAME=ssh_loggedon
if [[ "$PAM_TYPE" == "open_session" ]] && [[ -n "$PAM_RHOST" ]]; then
[[ "x$PAM_RHOST" != "x${PAM_RHOST//:/}" ]] && SETNAME="${SETNAME}6" || SETNAME="${SETNAME}4"
ipset -exist add $SETNAME "$PAM_RHOST"
fi
Desafortunadamente, la ipsetutilidad no parece tener la inteligencia incorporada de netfilter. Por lo tanto, debemos distinguir entre IPv4 e IPv6 IP al agregar nuestra entrada. De ipsetlo contrario , supondremos que queremos agregar otro conjunto al conjunto de conjuntos, en lugar de la IP. Y, por supuesto, es poco probable que haya un conjunto con el nombre de una IP :)
Por lo tanto, verificamos :la dirección IP y agregamos 6el nombre del conjunto en tal caso y de 4otra manera.
El fin.
Otra GUI que se puede utilizar para configurar iptables es Firewall Builder . Permite a los usuarios crear elementos de regla como objetos en una base de datos y luego arrastrar y soltar estos objetos en un editor de reglas para crear la política de firewall deseada. Luego, la aplicación genera un archivo de script con todos los comandos de iptables necesarios para implementar las reglas.
A diferencia de otras soluciones de GUI de iptables donde solo puede administrar una configuración de iptables a la vez, con Firewall Builder puede administrar una gran cantidad de configuraciones de iptables desde una sola aplicación. Firewall Builder se ejecuta en Linux, Windows y Mac OS X, ha existido durante más de 10 años y tiene miles de usuarios activos en todo el mundo.
Divulgación completa: soy el cofundador de NetCitadel, que es la compañía que desarrolla Firewall Builder.
registrar la conexión saliente con uid
iptables -A OUTPUT -m state --state NEW -m tcp -p tcp -m limit --limit 5/m -j LOG --log-uid --log-prefix="outgoing connection: "
puerto / reenvío de conexión:
iptables -A PREROUTING -t nat -i eth1 -p tcp --dport 80 -j DNAT --to 10.0.1.7:80
iptables -A INPUT -p tcp -m state --state NEW --dport 80 -i eth1 -j ACCEPT
NFLOGobjetivo. Permite un prefijo de línea más largo y el demonio de modo de usuario también puede iniciar sesión en bases de datos.
Ejemplo: ¿tiene eth0 y eth1 desea permitir tráfico entre ellos?
iptables -A FORWARD -i eth+ -o eth+ -j ACCEPT
Lo he usado en el pasado para hacer coincidir las veth<something>interfaces creadas y nombradas dinámicamente por LXC. Entonces puedo combinar todo a la vez con veth+.
También mencioné intencionalmente algunas interfaces _<something>para hacer coincidir _+.
iptables -t mangle -A PREROUTING -p tcp \
-m conntrack --ctstate NEW -m tcpmss ! --mss 536:65535 -j DROP
El propósito de este objetivo es verificar si el host que envió el paquete SYN establece la conexión o no hace nada después de iniciar la conexión SYN. Si no hace nada, descarta el paquete con un mínimo esfuerzo.
Establecer paquetes de sincronización en la tabla de seguimiento de conexiones en la tabla sin formato
iptables -t raw -A PREROUTING -p tcp -m tcp --dport 80 --syn -j CT --notrack
Habilite synproxy para el servidor http:
iptables -A INPUT -p tcp -m tcp --dport 80 -m conntrack --ctstate INVALID,UNTRACKED \
-j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460
Recurso: objetivo SYNPROXY del blog RHEL
Limitar todas las direcciones IP individuales a una cuota de ancho de banda saliente con conjuntos de IP
Puede configurar su servidor para permitir solo cada IP 15GiByte individual de uso de ancho de banda por mes, con la esperanza de reflejar o esquivar un ataque de uso de ancho de banda, tal vez para su cuota de ancho de banda medida en su ISP. Se puede lograr de la siguiente manera:
Primero cree los conjuntos de IP para IPv4 e IPv6:
ipset create IP_QUOTA_SET_OUT hash:ip timeout 345600 counters
ipset create IP_QUOTA_SET_OUT_INET6 hash:ip timeout 345600 counters family inet6
Ahora agregue sus reglas de iptables. La primera línea agregará la IP al conjunto si aún no está allí. La segunda línea no coincidirá si los bytes transferidos para la IP en el conjunto son mayores que la cantidad especificada. Luego, se hace lo mismo para IPv6.
iptables -I OUTPUT -m set ! --match-set IP_QUOTA_SET_OUT dst -j SET --add-set IP_QUOTA_SET_OUT dst --timeout 345600
iptables -I OUTPUT -m set --match-set IP_QUOTA_SET_OUT dst --bytes-gt 16106127360 -j DROP
ip6tables -I OUTPUT -m set ! --match-set IP_QUOTA_SET_OUT_INET6 src -j SET --add-set IP_QUOTA_SET_OUT_INET6 src --timeout 345600
ip6tables -I OUTPUT -m set --match-set IP_QUOTA_SET_OUT_INET6 src --bytes-gt 16106127360 -j DROP
Esto evitará ataques como que un usuario solicite un archivo grande de su servidor web durante un largo período de tiempo, o de cualquier servicio para el caso. Lo mismo se puede hacer para la cadena INPUT.
Algo que hago, principalmente debido a mi ignorancia de una solución más elegante, es verificar manualmente mis registros de Nginx cada 4 horas y el servidor de correo registra cada 2 minutos para acceso excesivo por IP individuales. Ejecuto algunos scripts juntos que:
access.logy enumere las 10 principales IP organizadas por la cantidad de visitas que tienen al servidoriptables.saveAsí es como se ve:
autoBanIPs_mail.sh#!/bin/bash
# This script checks the last 2 minutes of log entries to see if any
# IP has made over 99 connections
now=$(date +"%m_%d_%Y")
/root/bin/checkBadIPs_mail.sh > /home/ipChecker/ipcheckMAIL_$now.txt
cat /home/ipChecker/ipcheckMAIL_$now.txt | \
grep " \\(\\([9][9]\\)\\|\\([0-9][0-9][0-9]\\+\\)\\) " | \
awk '{print $2}' > /home/ipChecker/badMailIPs_$now.sh
sed -i "s/^/\/usr\/local\/sbin\/blockIP /g" /home/ipChecker/badMailIPs_$now.sh
/bin/bash /home/ipChecker/badMailIPs_$now.sh
cat /home/ipChecker/ipcheckMAIL_$now.txt >> /home/ipChecker/ipcheckMAIL_$now.log
rm /home/ipChecker/ipcheckMAIL_$now.txt
rm /home/ipChecker/badMailIPs_$now.sh
Una cosa que es MUY importante tener en cuenta aquí es que NECESITA configurar una lista blanca o comenzará a bloquear una gran cantidad de IP auténticas de los servidores de los que acaba de recibir una gran cantidad de correo electrónico o en el caso de otros registros, IP que simplemente golpea mucho tu servidor por razones legítimas. Mi lista blanca acaba de integrarse en este script agregando tuberías grep justo después | grep ']' | que se parece a esto "grep -v 127.0 |" .
Debe tomarse el tiempo para enseñarle a su servidor qué IP de alto tráfico son legítimas y cuáles no. Para mí, esto significaba que tenía que pasar la primera semana más o menos revisando mis registros manualmente cada dos horas, buscando IP de alto tráfico en iplocation.net y luego agregando los legítimos como amazon, box.com o incluso mi hogar / oficina Los rangos de IP a esta lista blanca. Si no lo hace, probablemente será bloqueado de su propio servidor o comenzará a bloquear servidores legítimos de correo / web y causará interrupciones en el correo electrónico o el tráfico.
cat /var/log/mail.log | awk \
-v d1="$(date --date="-2 min" "+%b %_d %H:%M")" \
-v d2="$(date "+%b %_d %H:%M")" \
'$0 > d1 && $0 < d2 || $0 ~ d2' | \
grep '\[' | grep '\]' | \
grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -v 127.0 | \
awk '{print $1}' | sort | uniq -c | sort -n | tail -10
#!/bin/bash
sudo iptables -I INPUT -s $1 -j DROP
sudo bash -c "iptables-save > /etc/network/iptables.save"
Una vez más, sé que esto es grosero como el infierno y probablemente haya un buen protocolo limpio y eficiente que haga todo esto, pero no lo sabía y esto ha estado funcionando durante un año o dos y mantiene a raya a los malos. Lo único que recomendaría SERIAMENTE es que tenga un proxy u otro servidor en las alas que pueda usar para acceder a su servidor principal. La razón es que si está haciendo desarrollo web algún día de la nada y usted haga ping 2000 veces en 5 horas para algunas pruebas que podría bloquear sin tener que volver a entrar, excepto por un proxy.
Puede ver que checkBadIPs.shhe puesto grep -v 127.0 y en mis archivos reales tengo un montón de reglas de ignorar mis propias IP y otros rangos de IP confiables, pero a veces su IP cambia, olvida actualizar y luego está bloqueado fuera de su propio servidor.
De todos modos, espero que ayude.
He cambiado un poco las cosas para que ahora, en lugar de verificar cada dos horas, revise algunos registros cada 2 minutos, principalmente mi registro de autenticación ssh y el registro de correo, ya que estaban siendo machacados :(.
Configuré secuencias de comandos específicas para cada archivo de registro, aunque sería bastante fácil a partir de la secuencia de comandos manual que uso cuando quiero inspeccionar los registros. Se ve como esto:
#!/bin/bash
log=$1 time=$2
cat /var/log/${log} | awk \
-v d1="$(date --date="-${time} min" "+%b %_d %H:%M")" \
-v d2="$(date "+%b %_d %H:%M")" \
'$0 > d1 && $0 < d2 || $0 ~ d2' | \
grep '\[' | grep '\]' | \
grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | \
sort | uniq -c | sort -n | tail -10
Esto requiere 2 entradas cuando se ejecuta, el archivo de registro que desea escanear y qué tan atrás en el pasado desea escanear.
Entonces, si quisiera verificar mail.log para ver los conteos de IP, digamos 75 minutos en el pasado, ejecutaría:
$ sudo script.sh mail.log 75
ipsetlugar de alargar la cadena de iptables, pero la idea es genial y creo que los aplicaré a mis servidores de producción. ¡Gracias por compartir!
Estoy de acuerdo con los comentarios sobre ipsets y tcp flags, pero todavía falta mucho:
Use xtables-addons geoip match en lugar de ipsets para las listas de países. Actualice los datos de geoip regularmente (al menos una vez al mes). Los datos son más dinámicos que una lista de ipset disparar y olvidar.
Considere el seguimiento del estado de conexión con banderas tcp. Por ejemplo, un tcp RST o ACK solo tiene sentido para una conexión establecida. SYN tiene sentido solo para conexiones nuevas y relacionadas. Un SYN para una conexión establecida significa que se perdió su SYN + ACK o un intento de pirateo y debe restablecerse ya que ambos lados de la conexión no están de acuerdo en cuanto al estado.
Aunque ninguno, SYN + RST y FIN + RST son combinaciones ilegales, SYN + FIN ahora es válido en TCP de apertura rápida (opción TCP 34), especialmente para DNS. Los paquetes SYN, incluso con apertura rápida, no deben fragmentarse. No considero que las reglas con las banderas PSH y URG sean útiles. No confunda el estado de seguimiento de la conexión con el estado TCP: se establece una respuesta RST a un paquete SYN para fines de seguimiento.
SYNPROXY es para paquetes reenviados y no agrega nada para los entregados localmente más allá del soporte de syncookie.
Los paquetes de error ICMP siempre estarán en el estado relacionado y de longitud 48: 576 si son válidos. Longitud 84: 1280 para IPv6. Todos los demás deben ser ignorados. Como su tamaño máximo es también el MTU mínimo, nunca deben fragmentarse. Las solicitudes de ICMP (pings, marcas de tiempo, etc.) siempre serán nuevas y las respuestas se establecerán. Descarte paquetes ICMP en otros estados.
Al igual que el ejemplo de SSH con una lista reciente y que acepta solo paquetes SYN posteriores, lo mismo debe hacerse para SMTP, y es similar a la "lista gris" en el dato de la dirección IP solo.
En la tabla de filtro, la primera regla (o la segunda, si acepta paquetes de estado establecidos primero) en las cadenas de entrada y salida debe aceptar todo en la interfaz de bucle invertido. Debe confiar en sus propios paquetes internos. Si no puede, tiene mayores problemas más allá de una solución de firewall.
Por último, no copie ciegamente las reglas a menos que realmente comprenda lo que hacen. Tantas listas similares de reglas hacen eso, y la mayoría de las veces, el resultado es ridículo.
#!/bin/bash
# The following iptables/ip6tables configurations have
# been kindly shared with us from ArckWiki. There are
# a few additions apart from what has been defined.
#
#=================Flush current definitions==============
iptables -F
ip6tables -F
iptables -X
ip6tables -X
#
#=================Chains=================================
#
#----Define chains for opened ports
iptables -N TCP
ip6tables -N TCP
iptables -N UDP
ip6tables -N UDP
#
#----Setting up the filter table for NAT
# iptables -N fw-interfaces
# ip6tables -N fw-interfaces
# iptables -N fw-open
# ip6tables -N fw-open
#
#================Default Chain reactions=================
#
#----Default FORWARD reaction
iptables -P FORWARD DROP
ip6tables -P FORWARD DROP
#
#----Default OUTPUT reaction
iptables -P OUTPUT ACCEPT
ip6tables -P OUTPUT ACCEPT
#
#----Shellshock
iptables -A INPUT -m string --algo bm --hex-string '|28 29 20 7B|' -j DROP
ip6tables -A INPUT -m string --algo bm --hex-string '|28 29 20 7B|' -j DROP
#
#----Default INPUT reaction
iptables -P INPUT DROP
ip6tables -P INPUT DROP
#
#----Drop spoofing packets
iptables -A INPUT -i eth0 -s 127.0.0.0/8 -j DROP
iptables -A INPUT -i wlan0 -s 127.0.0.0/8 -j DROP
iptables -A INPUT -i wlan1 -s 127.0.0.0/8 -j DROP
iptables -A INPUT -s 10.0.0.0/8 -j DROP
iptables -A INPUT -s 169.254.0.0/16 -j DROP
iptables -A INPUT -s 172.16.0.0/12 -j DROP
iptables -A INPUT -s 224.0.0.0/4 -j DROP
iptables -A INPUT -d 224.0.0.0/4 -j DROP
iptables -A INPUT -s 240.0.0.0/5 -j DROP
iptables -A INPUT -d 240.0.0.0/5 -j DROP
iptables -A INPUT -s 0.0.0.0/8 -j DROP
iptables -A INPUT -d 0.0.0.0/8 -j DROP
iptables -A INPUT -d 239.255.255.0/24 -j DROP
iptables -A INPUT -d 255.255.255.255 -j DROP
#
#================Ping rate limiting globally=============
iptables -A INPUT -p icmp --icmp-type 8 -m limit --limit 30/min --limit-burst 8 -j ACCEPT
ip6tables -A INPUT -p icmpv6 --icmpv6-type 8 --match limit --limit-burst 8 -j ACCEPT
iptables -A INPUT -p icmp --icmp-type 8 -j DROP
ip6tables -A INPUT -p icmpv6 --icmpv6-type 8 -j DROP
#
#----flooding RST packets, smurf attack Rejection
iptables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT
ip6tables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT
#
#----Bogus packet DROP
iptables -A INPUT -p tcp -m tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
ip6tables -A INPUT -p tcp -m tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
iptables -A INPUT -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j DROP
ip6tables -A INPUT -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j DROP
#
#================RELATED,ESTABLISHED reaction============
iptables -A INPUT --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
ip6tables -A INPUT --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
#
#================unfetered loopback======================
iptables -A INPUT -i lo -j ACCEPT
ip6tables -A INPUT -i lo -j ACCEPT
#
#================INVALID catagory of packets=============
iptables -A INPUT -p 41 -j ACCEPT
iptables -A INPUT --match conntrack --ctstate INVALID -j DROP
ip6tables -A INPUT --match conntrack --ctstate INVALID -j DROP
#
#================IPv6 reactions and definitions==========
ip6tables -A INPUT -s fe80::/10 -p icmpv6 -j ACCEPT
ip6tables -t raw -A PREROUTING -p icmpv6 -s fe80::/10 -j ACCEPT
ip6tables -t raw -A PREROUTING --match rpfilter -j ACCEPT
ip6tables -t raw -A PREROUTING -j DROP
#
#=======Acceptable INVALIDs and a curteous response======
iptables -A INPUT -p udp --match conntrack --ctstate NEW -j UDP
ip6tables -A INPUT -p udp --match conntrack --ctstate NEW -j UDP
iptables -A INPUT -p tcp --syn --match conntrack --ctstate NEW -j TCP
ip6tables -A INPUT -p tcp --syn --match conntrack --ctstate NEW -j TCP
#
#================Defining the TCP and UDP chains
#
#########################################################
# Notes for port open definitions #
# It is important to note that this should be config- #
# ured differently if you're providing any routing #
# activity for any purpose. it is up to you to actively #
# define what suites your needs to get the job done. #
# In this example, I'm exempting IPv6 from being able #
# to interact with SSH protocols for two reasons. The #
# first is because it is generally easier and more com- #
# for internal networks to be deployed with IPv4. The #
# second reason is, IPv6 can be deployed globally. #
#########################################################
#
#----SSH configured for eth0
iptables -A TCP -i eth0 -p tcp --dport ssh -j ACCEPT
#!---Blocking SSH interactions in IPv6
ip6tables -A TCP -p tcp --dport ssh -j DROP
#!---Leave commented for end service device
# iptables -A TCP -p tcp --dport 80 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 80 -j ACCEPT
# iptables -A TCP -p tcp --dport 443 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 443 -j ACCEPT
#
#!---Uncomment for remote service to this device
# iptables -A TCP -p tcp --dport 22 -j ACCEPT
# ip6tables -A TCP -p tcp --dport 22 -j ACCEPT
#
#!---Uncomment if you're providing routing services
# iptables -A UDP -p udp 53 -j ACCEPT
# ip6tables -A UDP -p udp 53 -j ACCEPT
#
#=================Tricking port scanners=================
#
#----SYN scans
iptables -I TCP -p tcp --match recent --update --seconds 60 --name TCP-PORTSCAN -j DROP
ip6tables -I TCP -p tcp --match recent --update --seconds 60 --name TCP-PORTSCAN -j DROP
iptables -A INPUT -p tcp --match recent --set --name TCP-PORTSCAN -j DROP
ip6tables -A INPUT -p tcp --match recent --set --name TCP-PORTSCAN -j DROP
#
#----UDP scans
iptables -I UDP -p udp --match recent --update --seconds 60 --name UDP-PORTSCAN -j DROP
ip6tables -I UDP -p udp --match recent --update --seconds 60 --name UDP-PORTSCAN -j DROP
iptables -A INPUT -p udp --match recent --set --name UDP-PORTSCAN -j DROP
ip6tables -A INPUT -p udp --match recent --set --name UDP-PORTSCAN -j DROP
#
#----For SMURF attack protection
iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
iptables -A INPUT -p icmp -m limit --limit 2/second --limit-burst 2 -j ACCEPT
ip6tables -A INPUT -p icmpv6 -m limit --limit 2/second --limit-burst 2 -j ACCEPT
#
#----Ending all other undefined connections
iptables -A INPUT -j DROP
ip6tables -A INPUT -j DROP
#
#=======Defining the IN_SSH chain for bruteforce of SSH==
#
#!---I've elected to keep IPv6 out of this realm for
#!---ease of use
iptables -N IN_SSH
iptables -A INPUT -p tcp --dport ssh --match conntrack --ctstate NEW -j IN_SSH
iptables -A IN_SSH --match recent --name sshbf --rttl --rcheck --hitcount 3 --seconds 10 -j DROP
iptables -A IN_SSH --match recent --name sshbf --rttl --rcheck --hitcount 4 --seconds 1800 -j DROP
iptables -A IN_SSH --match recent --name sshbf --set -j ACCEPT
iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -j IN_SSH
#
#==================Setting up a NAT gateway==============
#
#########################################################
# #
# I commented this half out because it's not something #
# that will apply to all setups. Make note of all par- #
# tinate interfaces and what exactly is going on. #
# #
#########################################################
#
#----Setting up the FORWARD chain
# iptables -A FORWARD --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
# ip6tables -A FORWARD --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
#
#
#----Defining the fw-interfaces/open chains for FORWARD
# iptables -A FORWARD -j fw-interfaces
# ip6tables -A FORWARD -j fw-interfaces
# iptables -A FORWARD -j fw-open
# ip6tables -A FORWARD -j fw-open
# iptables -A FORWARD -j DROP # Should be REJECT. But, fuck them
# ip6tables -A FORWARD -j DROP
# iptables -P FORWARD DROP
# ip6tables -P FORWARD DROP
#
#
#----Setting up the nat table
# iptables -A fw-interfaces -i ### -j ACCEPT
# ip6tables -A fw-interfaces -i ### -j ACCEPT
# iptables -t nat -A POSTROUTING -s w.x.y.z/S -o ppp0 -j MASQUERADE
# ip6tables -t nat -A POSTROUTING -s fe::/10 -o ppp0 -j MASQUERADE
#----The above lines should be repeated specifically for EACH interface
#
#----Setting up the PREROUTING chain
#
#######################################################
# #
# The PREROUTING chain will redirect either port #
# targets to be redirected. This can also redirect #
# traffic inbound to your network from the gateway #
# to this machine. This can be useful if you're using #
# a honeypot or have any service within your network #
# that you want to be pointed to a specific device. #
# #
#######################################################
#
#----SSH honeypot server
# iptables -A fw-open -d HONEYPOT_IP -p tcp --dport 22 -j ACCEPT
# ip6tables -A fw-open -d HONEYPOT_IP -p tcp --dport 22 -j ACCEPT
#----With intuition, you can configure the above to also direct specific
#----requests to other devices providing those services. The bellow will
#----be for a squid server
# iptables -A fw-open -d SQUID_IP -p tcp --dport 80 -j ACCEPT
# ip6tables -A fw-open -d SQUID_IP -p tcp --dport 80 -j ACCEPT
# iptables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to SQUID_IP
# ip6tables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to SQUID_IP
#
#===============Declare configurations=================
iptables -nvL
ip6tables -nvL