Como proteger un servidor de ataques DDoS

Los ataques por Ddos (Denegación de servicio distribuido) son, básicamente, intentos maliciosos para interrumpir el tráfico normal de un servidor, servicio o red. Y ello, con el objetivo inicial de que estos no estén disponibles para los usuarios finales.

Una vez que estos intentos logren impactar la ciberseguridad de una organización, por lo general estos recursos afectados son luego usados para distribuir masivamente malware a otros dispositivos.

Cuando un atacante logra obtener el control de una red donde están conectados varios dispositivos, comienza a distribuir malware a través de ellos. Con esto logra crear una especie de red zombie, la cual es comúnmente conocida como botnet.

Una vez que se haya establecido la botnet, el atacante podrá enviar peticiones maliciosas a otras redes o IP’s objetivos. Ello causa una denegación de servicio en dicho tráfico normal. Generalmente es difícil identificar un bot, ya que el mismo proviene de un dispositivo existente.

Tipos de ataques de Ddos

Los ataques de denegación de servicio consisten en atacar de manera constante los recursos de red, usando una o más categorías. Algunos suelen combinar técnicas sofisticadas empleando diferentes vectores. Las categorías que son utilizadas para realizar estos ataques son:

• Ataques basados por volúmenes – Se envían cantidades masivas de tráfico hasta colapsar el ancho de banda.
• Ataques por protocolos – Se enfocan en buscar vulnerabilidades en los recursos de los servidores y eventualmente los explotan.
• Ataques por aplicaciones web – Son los ataques más sofisticados, ya que se enfocan en ciertas aplicaciones webs.
• Ataques por conexiones TCP – Encuentran vulnerabilidades en conexiones TCP y posteriormente inundan de tráfico el servidor web.
• Ataques por fragmentación – Se da cuando se logra explotar el proceso de fragmentación de datagramas, en el cual una IP es dividida en paquetes más pequeños. Durante el ataque se inyectan paquetes falsos maliciosos que colapsarán eventualmente el servidor.

Existen varias formulas de frenar ataques DDos, ninguna te puede garantizar una protección absoluta, paro si que iptables te ofrecerá mas fiabilidad que el resto.

Las vemos:

1. Protección a nivel de PHP: Bloquea acceso total de bots, de modo que no haya excesiva carga. No es una buena solución.
2. Protección a nivel de Apache: Usando el módulo mod_evasive. Tampoco es una solución efectiva.
3. Nivel de protección nginx: Excelente solución con la cual podras evitar muchos ataques. Veremos como en un próximo articulo. muchos ataques.
4. Protección con iptables: Con una configuración apropiada, es una de las soluciones más efectivas y confiables a la hora de proteger un servidor. En este articulo trataremos esta opción.

Evitar ataques DDos con iptables

Obtener listado de módulos disponibles en iptables.

ls /lib/modules/$(uname -r)/kernel/net/ipv4/netfilter/

ejemplo…

arptable_filter.ko ipt_MASQUERADE.ko nf_nat_pptp.ko
arp_tables.ko ipt_REJECT.ko nf_nat_proto_gre.ko
arpt_mangle.ko ipt_rpfilter.ko nf_nat_snmp_basic.ko
iptable_filter.ko ipt_SYNPROXY.ko nf_reject_ipv4.ko
iptable_mangle.ko nf_conntrack_ipv4.ko nf_tables_arp.ko
iptable_nat.ko nf_defrag_ipv4.ko nf_tables_ipv4.ko
iptable_raw.ko nf_dup_ipv4.ko nft_chain_nat_ipv4.ko
iptable_security.ko nf_log_arp.ko nft_chain_route_ipv4.ko
ip_tables.ko nf_log_ipv4.ko nft_dup_ipv4.ko
ipt_ah.ko nf_nat_h323.ko nft_masq_ipv4.ko
ipt_CLUSTERIP.ko nf_nat_ipv4.ko nft_redir_ipv4.ko
ipt_ECN.ko nf_nat_masquerade_ipv4.ko nft_reject_ipv4.ko

Si quieres obtener info sobre todos los módulos.

modinfo /lib/modules/$(uname -r)/kernel/net/ipv4/netfilter/*.ko

Protegernos contra ataques DDos SYN flood

Es el ataque más común, consiste en el envío de una gran cantidad de paquetes SYN al servidor.

Puedes revisar las conexiones abiertas con netstat.

netstat -lptun

Bueno… comenzamos a editar.

Debemos establecer tcp_syncookies en 1 (de manera predeterminada tiene ese valor), puedes comprobarlo con:

cat /proc/sys/net/ipv4/tcp_syncookies
# ejemplo
1

Verificamos las conexiones máximas abiertas, tcp_max_syn_backlog (normalmente 1024).

cat /proc/sys/net/ipv4/tcp_max_syn_backlog

Aumentamos el máximo de conexiones.

echo "40000" > /proc/sys/net/ipv4/tcp_max_syn_backlog

Ahora verificamos el tiempo de espera de la conexión, el parámetro a usar es tcp_synack_retries.

cat /proc/sys/net/ipv4/tcp_synack_retries

De manera predeterminada la espera es 5, que equivalen a «180» segundos. El tiempo de espera es excesivo, lo reduciremos a 1 que equivale a 9 segundos.

echo "1" > /proc/sys/net/ipv4/tcp_synack_retries

Verificamos el tcp_fin_timeout, un valor ideal es 30. Si tienes otro valor lo modificas tal como te indico.

cat /proc/sys/net/ipv4/tcp_fin_timeout
# Ejemplo
60

Modificamos el valor a 30.

echo "30" > /proc/sys/net/ipv4/tcp_fin_timeout

Revisamos la opción tcp_keepalive_probes (se usa para que una vez completada la conexión se considerará interrumpida).

cat /proc/sys/net/ipv4/tcp_keepalive_probes

Por defecto es 9, la estableceremos en 5.

echo "5" > /proc/sys/net/ipv4/tcp_keepalive_probes

También reduciremos el tcp_keepalive_intvl.

Verificamos el valor actual, por defecto 75.

cat /proc/sys/net/ipv4/tcp_keepalive_intvl

Aplicamos un valor 15.

echo "15" > /proc/sys/net/ipv4/tcp_keepalive_intvl

netdev_max_backlog se usa para especificar el número máximo de paquetes por cola de procesamiento, para que lo entiendas mejor… en caso de ataques DDos la interfaz recibirá los paquetes mucho más rápido de lo que el kernel puede procesar. Lo verificamos.

cat /proc/sys/net/core/netdev_max_backlog

Por defecto 1000, lo aumentaremos a 20.000.

echo "20000" > /proc/sys/net/core/netdev_max_backlog

El número máximo de sockets abiertos esperando una conexión, también debe ser aumentado a 20.000.

echo "20000" > /proc/sys/net/core/somaxconn

Modificamos el tcp_syncookies.

echo 1 > /proc/sys/net/ipv4/tcp_syncookies

Ya tenemos gran parte de nuestro servidor protegido (continua en el siguiente articulo), pero claro… las reglas de iptables no son permanentes, por tanto en el momento que reiniciemos el servidor se perderán.

Hacemos que sean permanentes:
nano /etc/rc.local

Copia y pega lo siguiente…

echo "20000" > /proc/sys/net/ipv4/tcp_max_syn_backlog
echo "1" > /proc/sys/net/ipv4/tcp_synack_retries
echo "30" > /proc/sys/net/ipv4/tcp_fin_timeout
echo "5" > /proc/sys/net/ipv4/tcp_keepalive_probes
echo "15" > /proc/sys/net/ipv4/tcp_keepalive_intvl
echo "20000" > /proc/sys/net/core/netdev_max_backlog
echo "20000" > /proc/sys/net/core/somaxconn

Guarda y cierra el editor.

Añadimos las restricciones a iptables.

iptables -N syn_flood
iptables -A INPUT -p tcp --syn -j syn_flood
iptables -A syn_flood -m limit --limit 500/s --limit-burst 2000 -j RETURN
iptables -A syn_flood -j DROP

Hemos establecido un limite para los nuevos paquetes SYN (500 por segundo), y al usar el límite de 2000, los nuevos paquetes serán bloqueados.

Establecemos opciones diversas muy útiles a la hora de frenar ataques DDos.

iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
iptables -A INPUT -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
iptables -A INPUT -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
iptables -A INPUT -p tcp --tcp-flags FIN,RST FIN,RST -j DROP
iptables -A INPUT -p tcp --tcp-flags ACK,FIN FIN -j DROP
iptables -A INPUT -p tcp --tcp-flags ACK,PSH PSH -j DROP
iptables -A INPUT -p tcp --tcp-flags ACK,URG URG -j DROP

Bien, llegado este punto hacemos un inciso.

Ya deberías de saber que cuando iptables recopila muchas disecciones IP, ralentiza el sistema (depende de tu maquina, pero normalmente a partir de 100 direcciones empieza a disminuir progresivamente).

Para evitar este problema usaremos IPSet

Lo instalamos en nuestra distribución Linux.

Redhat, CentOS y derivados:

yum install ipset

Debian, Ubuntu y derivados:

apt-get install ipset

Una vez instalado agregaremos la regla de bloqueo en iptables (dos, es la tabla de IPset).

iptables -I INPUT 1 -m set --set dos src -j DROP

Creamos un «hash» para la tabla dos.

ipset -N dos iphash

Nota: si en vez de bloquear una ip, quieres bloquear la subred completa, cambia iphash por nethash.

Guardamos las reglas de Iptables.

/sbin/service iptables save

Ya lo tenemos, tan solo nos falta un script para detener automáticamente los ataques «syn flood»

Creamos el script *.sh.

nano anti-ddos.sh

Copia y pega lo siguiente:

#!/bin/bash
IFCONFIG=/sbin/ifconfig
GREP=/bin/grep
AWK=/bin/awk
CUT=/bin/cut
NETSTAT=/bin/netstat
IPSET=/usr/sbin/ipset
IPTABLES=/sbin/iptables
SORT=/bin/sort
UNIQ=/usr/bin/uniq
srvIP=`$IFCONFIG eth0 | $GREP 'inet addr' | $AWK '{print $2}' | $CUT -f2 -d ":"`
for i in `$NETSTAT -ntu | $GREP SYN_RECV | $AWK '{print $5}' | $CUT -f1 -d ":" | $SORT | $UNIQ | $GREP -v ${srvIP}`
do
$IPSET -A dos $i
done
$IPSET -S > /etc/sysconfig/ipset

Guarda el archivo y cierra el editor.

Lo puedes ejecutar en el momento que notes un ataque, con:

bash anti-ddos.sh

Pero mi consejo es que crees una tarea cron que ejecute el sh (se recomienda su ejecución entre 1 y 5 minutos).

Puedes ver las direcciones que están bloqueadas, con:

ipset -L | head

ejemplo de salida….
ipset -L | head
Name: dos
Type: hash:ip
Header: family inet hashsize 1024 maxelem 65536
Size in memory: 20104
References: 1
Members:
200.170.151.14
196.21.39.13
180.250.209.2
203.89.27.150

Otros detalles de un ataque, con:

netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -n

Espero te resulte de util este tutorial,

Fuente: sololinux.es
Recomendamos:
Rasguñando Netfilter (parte 1)
Rasguñando Netfilter (parte 2) Rasguñando Netfilter (parte 3) Rasguñando Netfilter (parte 4)