Header Ads

Protección contra ataques ARP Spoofing

El envenenamiento ARP (ARP Spoofing) ocurre cuando un usuario legítimo o un atacante envía manual o de forma automatizada, mensajes falsos a la red local, puerta de enlace (router, servidor, etc) o a un equipo específico dentro de la red local, usando el protocolo de resolución de nombres ARP, responsable de encontrar la dirección de hardware (también conocidas como direcciones MAC), que corresponde a una determinada dirección IP, alterando el enrutamiento en una red.
Según Wikipedia, "la finalidad es asociar la dirección MAC del atacante con la dirección IP de otro nodo (el nodo atacado), como por ejemplo la puerta de enlace predeterminada. Cualquier tráfico dirigido a la dirección IP de ese nodo, será erróneamente enviado al atacante, en lugar de a su destino real. El atacante, puede entonces elegir, entre reenviar el tráfico a la puerta de enlace predeterminada real (ataque pasivo o escucha), o modificar los datos antes de reenviarlos (ataque activo). El atacante puede incluso lanzar un ataque de tipo DoS (denegación de servicio) contra una víctima, asociando una dirección MAC inexistente con la dirección IP de la puerta de enlace predeterminada de la víctima".
El problema con este tipo de "ataque" es que las direcciones IP y MAC a pesar de estar vinculadas, trabajan en capas diferentes del modelo OSI y estas últimas no se pueden bloquear con un firewall (cortafuegos) tradicional. Entonces si usamos un firewall con reglas iptables o cualquier otro similar, no servirán de mucho. Tampoco son muy útiles los firewalls, routers o switch por hardware, excepto aquellos que trabajen en la capa de enlace de datos (capa 2) e incluyan funcionalidades avanzadas de filtrado ARP, y por lo general son costosos y no se consiguen a la vuelta de la esquina.
Y qué puede hacer un pobre usuario de a pie para salvarse de esta pesadilla
Lo primero es aclarar por qué lo llamamos "ataque" (entre comillas). La cosa es que a veces no lo es, al menos no de manera consciente. Supongamos el siguiente escenario. Un usuario legítimo de nuestra red local, necesita descargar una película o jugar en línea. Hay mucha gente conectada a la red y hay un proxy con restricciones de ancho de banda y bloqueo de sitios. Entonces al usuario se le ocurre la gran idea de evadir estos controles con netcut (windows) o tuxcut (linux), y dejar literalmente sin conectividad a toda la red, excepto su equipo, monopolizando el ancho de banda sin restricciones.
El usuario no tiene la menor idea de lo que hacen estas aplicaciones (inundar la red local de mensajes falsos ARP y de paso regalarle las direcciones MAC de la red local y su ubicación al portal arcai.com para hacer con ellas quién sabe qué), sin embargo logra su objetivo que es lo que le importa y poco o nada pueden hacer el firewall o el proxy para impedirlo. Que belleza...
Afortunadamente existen algunas aplicaciones que pueden ayudarnos (ver tabla Defense) y también comandos, pero la manera más efectiva de protegernos de un envenenamiento ARP siempre será tener una tabla ARP estática, sin embargo es una tarea de nunca acabar, ya que constantemente cambian y debemos estar escaneando la red local para saber las IP/MAC de los equipos y la puerta de enlace para agregarla a la tabla ARP de nuestro PC, por tanto trataremos de automatizar un poco este proceso para que no sea tan traumático para el usuario.
En la tabla referenciada anteriormente, aparece una sencilla aplicación con la que podemos ser "salvados por la campana" y es ArpON.  Su instalación y configuración es simple:
apt -y install arpon
Según la documentación tiene 3 modos: SARPI (entradas estáticas), DARPI (para entradas dinámicas - DHCP) y HARPI (una especie de híbrido que incluye ambos modos). Por defecto viene seleccionada SARPI, por tanto, en teoría, lo único que deberíamos hacer es agregar las direcciones IP/MAC al archivo /etc/arpon.conf.
Si manejamos un servidor Linux en nuestra red local, que administra las conexiones, y este servidor usa ISC-DHCP-SERVER
apt -y install isc-dhcp-server
Entonces podemos extraer las direcciones de arrendamiento de los equipos y mandarlas al archivo de configuración de ArpON:
cat /var/lib/dhcp/dhcpd.leases | egrep -o 'lease.*{|ethernet.*;' | awk '{print $2}' | xargs -n 2 | cut -d ';' -f 1 > /etc/arpon.conf
Sin embargo, en pruebas realizadas ArpON no bloqueó netcut o tuxcut en modo SARPI (por defecto), por tanto no servirá de mucho agregar las entradas ARP estáticas a arpon.conf. En cambio, en modo DARPI mostró resultados muy prometedores (y si descartamos usar arpon.conf para las entradas estáticas, el modo HARPI es innecesario, ya que vendía siendo lo mismo que DARPI). Sin embargo en este modo hay que configurar un par de cosas antes.
Si lo vamos a hacer manual, editamos ArpON
nano /etc/default/arpon
Y activamos DARPI
# DAEMON_ARGS="--sarpi"
DAEMON_ARGS="--darpi"
# DAEMON_ARGS="--harpi"
Ahora creamos el siguiente script (para las entradas estáticas) y directorio (para el log):
mkdir -p /var/log/arpon
touch /etc/network/if-up.d/arpstatic
Y agregamos a arpstatic las entradas ARP estáticas de dhcpd.leases (podemos agregar las entradas manualmente si no queremos usar dhcpd.leases). Le damos un nombre y permisos chmod y si queremos lo programamos en el cron.
Nota: Cambie en la variable lan por el nombre de su tarjeta de red local
#!/bin/bash
lan=enp2s0
cat /var/lib/dhcp/dhcpd.leases | egrep -o 'lease.*{|ethernet.*;' | awk '{print $2}' | xargs -n 2 | cut -d ';' -f 1 | xargs -I {} echo {} | sed -e "s/^/arp -i $lan -s /" | sed -e '1i#!/bin/bash\' > /etc/network/if-up.d/arpstatic
Para conocer nuestra tabla ARP ejecutamos el comando arp -a y la salida debería ser algo más o menos así:
? (192.168.1.1) at XX:XX:XX:XX:XX:XX [ether] PERM on enp2s0
Donde PERM significa que la entrada es permanente (estática) para la interfaz de red elegida (en este ejemplo es enp2s0 pero esto depende del nombre de las interfaces de red del equipo que utilicemos). En cualquier caso, el script arpstatic debe quedar con un contenido similar a este:
#!/bin/bash
arp -i enp2s0 -s 192.168.1.101 a4:ca:a0:xx:xx:xx
arp -i enp2s0 -s 192.168.1.102 0c:8f:ff:yy:yy:yy
También puede limpiar la tabla antes:
# Para eliminar de la tabla ARP los terminales que no sean PERM, utilizar:
ip -s -s neigh flush all
# Para eliminar manualmente entradas PERM de la tabla ARP:
arp -d 192.168.1.30
# Para eliminar cualquier entrada PERM de la tabla ARP:
localip=192.168.1.11 # Excluyendo la IPv4 del equipo local
arp -a | grep -i perm | grep -oP '(\d+\.){3}\d+' | grep -v $localip | xargs -I {} arp -d {}
Desventajas 
La desventaja de agregar entradas con la utilidad arp con el script arpstatic es que hay que reiniciar después de cualquier cambio para que el script inicie con el sistema. En caso de que no lo hagamos, eventualmente los equipos que se agregaron o modificaron en la tabla ARP pueden perder conectividad. Esta es una de las razones por la cual muchos portales especializados la consideran obsoleta y recomiendan usar ip neighbour en reemplazo de arp. A continuación algunos ejemplos de ip neighbour:
# Para agregar una entrada permanente a la tabla arp:
ip neighbour add 192.168.1.230 lladdr d4:63:c6:11:22:33 nud permanent dev enp2s0
# Si la entrada ya existe (error RTNETLINK answers: File exists)
ip neigh replace 192.168.1.230 lladdr d4:63:c6:11:22:33 nud permanent dev enp2s0
# Para mostrar las entradas permanentes:
ip neighbour show nud permanent
# Para eliminar las entradas permanentes:
ip neighbour flush nud permanent
# para eliminar todas las entradas de una interfaz específica (ej: enp2s0):
ip neigh flush dev enp2s0
Sin importar el método que utilice, lo importante es que las entradas en su tabla ARP sean estáticas, ya que mejora la tasa de éxito de ArpON al bloquear un envenenamiento ARP.
Iniciando ArpON
Dicho lo anterior iniciamos ArpON. La versión actual ya no utiliza /etc/init.d sino systemctl, y lo hace con los siguientes comandos (donde @lan es el nombre de su interface de red a monitorear):
systemctl enable arpon@$lan
systemctl start arpon@$lan
Sin embargo ArpOn tiene un Bug que duplica los LOG (syslog y arpon.log) y si iniciamos de este modo activamos el bug y la solución del desarrollador es compilar. Para evitarlo hay que iniciar ArpON como demonio:
/usr/sbin/arpon -d -i $lan --DARPI
Automatizando ArpON
Para mayor comodidad a continuación ofrecemos un script con la mayoría de las opciones necesarias para que el programa funcione. Puede comentar o descomentar las líneas que vaya a usar (ejemplo):
#!/bin/bash
# VARIABLES
# path mac adresses (reclace)
route=/etc/acl
# local interface (replace)
lan=enp2s0
# actual date
date=`date +%d/%m/%Y" "%H:%M:%S`
# change mode (darpi, sarpi, harpi)
mode=darpi
# Local IP (replace)
localip=192.168.0.10

# check arpon
arponbin=$(which arpon)
if [ -z "$arponbin" ]; then
  apt -y install arpon >/dev/null 2>&1
  if [ ! -d /var/log/arpon ]; then mkdir /var/log/arpon; fi
fi

# check dependencies
# notify-send
pkgs='dpkg -s libnotify-bin'
if ! dpkg -s $pkgs >/dev/null 2>&1; then
  apt -y install $pkgs >/dev/null 2>&1
fi

# ip2mac
function ip2mac(){
 # SARPI + ISC-DHCP-SERVER + arpon.conf
 # capture mac/ip from /var/lib/dhcp/dhcpd.leases (out format: ip  mac)
 #cat /var/lib/dhcp/dhcpd.leases | egrep -o 'lease.*{|ethernet.*;' | awk '{print $2}' | xargs -n 2 | cut -d ';' -f 1 > /etc/arpon.conf

 # SARPI + arpon.conf
 # capture mac+ip from mac* adresses files and add to /etc/arpon.conf (string format mac*: a;mac;ip;HOST)
 # example mac files: $route/macadmin $route/macusers
 #awk -F";" '{print $3 " " $2}' $route/mac* | xargs -I {} echo {} > /etc/arpon.conf

 # DARPI + arpstatic
 # optional: activate DARPI in /etc/default/arpon (not necessary)
 #sed -i '/DAEMON_ARGS="--sarpi"/s/^#*/#/g' /etc/default/arpon
 #sed -i '/DAEMON_ARGS="--darpi"/s/^#*\s*//g' /etc/default/arpon

 # check script (with ip neigh)
 # capture mac+ip from mac* adresses files and add to arpstatic (string format mac*: a;mac;ip;HOST)
 # example mac files: $route/macadmin $route/macusers
 echo '#!/bin/bash' > arpstatic
 awk -F";" '{print "ip neigh replace " $3 " lladdr " $2 " nud permanent dev '$lan'"}' $route/mac* | sort -t . -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n | uniq >> arpstatic

 # check script (with arp)
 # capture mac+ip from mac* adresses files and add to arpstatic (string format mac*: a;mac;ip;HOST)
 # example mac files: $route/macadmin $route/macusers
 #awk -F";" '{print $3 " " $2}' $route/mac* | sed -e "s/^/arp -i $lan -s /" | sort -t . -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n | uniq | sed -e '1i#!/bin/bash\' > arpstatic
}

# arpon run
function arponrun(){
if [[ `ps -ef | grep -w '[a]rpon'` != "" ]];then
 # optional rule: flush ARP table
 ip -s -s neigh flush all >/dev/null 2>&1
 # optional rule: flush ARP table (PERM)
 arp -a | grep -i perm | grep -oP '(\d+\.){3}\d+' | grep -v $localip | xargs -I {} arp -d {} >/dev/null 2>&1
 # run script and add ip+mac to ARP Table (DARPI + arpstatic)
 chmod +x ./arpstatic && ./arpstatic >/dev/null 2>&1
 # log
 echo "ArpON ONLINE" >> /var/log/syslog
 notify-send "ArpON Status" "ONLINE" -i checkbox
  else
 # optional rule: flush ARP table
 ip -s -s neigh flush all >/dev/null 2>&1
 # optional rule: flush ARP table (PERM)
 arp -a | grep -i perm | grep -oP '(\d+\.){3}\d+' | grep -v $localip | xargs -I {} arp -d {} >/dev/null 2>&1
 # run script and add ip+mac to ARP Table (DARPI + arpstatic)
 chmod +x ./arpstatic && ./arpstatic >/dev/null 2>&1
 # start ArpON
 /usr/sbin/arpon -d -i $lan --$mode > /dev/null 2>&1
 # log
 echo "ArpON start $date" >> /var/log/syslog
 notify-send "ArpON status" "Start $date" -i checkbox
fi
}

# find duplicates
# switch between $route/mac* or /var/lib/dhcp/dhcpd.leases depending on rules you will use
function duplicate(){
 acls=`for field in 2 3 4; do cut -d\; -f${field} $route/mac* | sort | uniq -d; done`
 if [ "${acls}" == "" ]; then
 ip2mac
 arponrun
 echo Done
  else
 echo "Warning Abort: Duplicate: $acls. $date" >> /var/log/syslog
 notify-send "Warning: Abort" "Duplicate: $acls. $date" -i error
 exit
fi
}
duplicate
Este script instala y configura arpon (si no lo tiene instalado) con sus dependencias. No usa el archivo de configuración ya que lo arranca directamente como demonio con los parámetros requeridos, para evitar el Bug (logs solo en arpon.log). Por defecto escanea la ruta donde se encuentren los archivos de sus direcciones mac+ip y verifica que no haya duplicados antes de agregar las mac+ip al script arpstatic y correr ArpON y si hay duplicados frena el script y envía una alerta a syslog y por notify-send. Se recomienda que cambie las variables:
# path mac adresses (cámbiela por la ruta a su/s ACL/s con las mac+ip)
route=/etc/acl
# local interface (cámbiela por el nombre de su interfaz de red)
lan=enp2s0
# change mode (darpi, sarpi, harpi)
mode=darpi
# Local IP
localip=192.168.0.10
Y el nombre de los archivos que contienen las direcciones mac+ip, con el formato a;mac;ip;HOST
# example mac files: $route/macadmin $route/macusers
$route/mac*
Puede programarlo en el crontab para que inicie con el sistema.
chown root:root /etc/init.d/arponstart.sh
chmod +x /etc/init.d/arponstart.sh
crontab -l | { cat; echo "@reboot /etc/init.d/arponstart"; } | crontab -
Resultados
Ahora lanzamos netcut desde otra máquina.
ataque de arcai netcut sobre la IP 192.168.1.21
Log:
ArpON DARPI bloqueando envenenamiento ARP de NetCut. 
IP 192.168.1.21 MAC real 14:18:77:XX:XX:XX (allow) MAC falsa 08:00:27:XX:XX:XX (deny)
Algo similar ocurre con tuxcut:
Tuxcut intentando cortar conexión del host 192.168.1.16
y suplantando MAC 8:0:27:3a:50:95 (Allow) por MAC falsa 8:0:27:40:b0:3d (Deny)
Host
Host 192.168.1.16. MAC 8:0:27:3a:50:95 accediendo a Internet normalmente
Y lo mismo sucede con kickthemout, ettercap, arpspoof, CSArp-Netcut, etc.
Consideraciones
1. Mantenga una rotación regular (logrotate) del LOG arpon.log, ya que tiende a llenarse muy rápido.
2. Como protección adicional se recomienda bloquear el sitio arcai.com para impedir el acceso al panel de administración netcut (para la versión 3x).
3. Si queremos monitorear la suplantación en tiempo real y que nos notifique, podemos usar el script de monitoreo de initbrain
4. Existen otros métodos para contrarrestar este ataque, con nftables. Puede encontrar más en el post 5 Ways to Protect Your Computer Against NetCut’s ARP Spoofing Attack
5. Lo más importante: Este tipo de soluciones no son mágicas ni milagrosas. El sysadmin debe tener su red centralizada y protegida, de lo contrario ningún programa o regla podrá detener un ataque Arp Spoofing.

Imagen cortesía de medium.com
Con la tecnología de Blogger.