
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:
- Protección a nivel de PHP: Bloquea acceso total de bots, de modo que no haya excesiva carga. No es una buena solución.
- Protección a nivel de Apache: Usando el módulo mod_evasive. Tampoco es una solución efectiva.
- Nivel de protección nginx: Excelente solución con la cual podras evitar muchos ataques. Veremos como en un próximo articulo. muchos ataques.
- 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)
Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36
buenas noches amigo solo te falta corregir /sbin/service iptables save por «sudo /sbin/iptables-save»
Warning: Undefined array key 1 in /var/www/html/sysadminsdecuba/wp-content/plugins/wp-useragent/wp-useragent-detect-os.php on line 668
Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:90.0) Gecko/20100101 Firefox/90.0
Buenisimo el ariculo, hace rato no veia algo asi .
Igual se pudiera implementar Net IDS https://humanos.uci.cu/2018/02/15/networktools-ids-sistemas-de-prevenciondeteccion-de-intrusos/