Kali Linux IPv6 Toolkit Explicado

https://www.onlinetis.com

Kali Linux IPv6 Toolkit Explicado

IPv6 Toolkit (también conocido como SI6 Networks' IPv6 Toolkit) es una de las suites más potentes en Kali Linux para la seguridad, análisis y solución de problemas en redes IPv6.

A diferencia de IPv4, el protocolo IPv6 tiene mecanismos únicos (como el Neighbor Discovery) que esta suite permite manipular para auditorías de red.

## Principales Herramientas del Toolkit

La suite se compone de varios comandos específicos. Aquí tienes los más importantes explicados:

scan6: Es la herramienta de escaneo de red. Permite descubrir nodos activos en un segmento IPv6, incluso si intentan ocultarse.
addr6: Se utiliza para el análisis y manipulación de direcciones IPv6. Útil para entender el desglose de una dirección (prefijo, ID de interfaz, etc.).
ra6: Sirve para manipular o enviar paquetes de Router Advertisement. Es fundamental para ataques de "Man-in-the-Middle" o para probar la seguridad del autoconfigurado de red (SLAAC).
ns6 / na6: Permiten enviar paquetes de Neighbor Solicitation y Neighbor Advertisement. Básicamente, es el equivalente al ARP en IPv4.
icmp6: Una herramienta genérica para enviar cualquier tipo de mensaje ICMPv6 y observar cómo responde el objetivo.

## Ejemplos de uso común

Si quieres empezar a experimentar, aquí tienes un par de comandos básicos:

Escanear la red local en busca de dispositivos:
Bash
```
scan6 -i eth0 -L
```
(Donde -i es tu interfaz y -L indica que busque en el enlace local).
Analizar una dirección específica:
Bash
```
addr6 -a fe80::1 -i
```
(Muestra información detallada sobre la estructura de esa IP).

## ¿Por qué es importante en Kali?

IPv6 suele estar activado por defecto en la mayoría de los sistemas operativos modernos, pero muchas veces no está correctamente protegido por firewalls que solo filtran IPv4. El IPv6 Toolkit permite a los auditores encontrar esas "puertas traseras" abiertas por una mala configuración del nuevo protocolo.

## Instalación (si no lo tienes)

Aunque suele venir preinstalado en la versión "Large" de Kali, puedes instalarlo manualmente con:

sudo apt update && sudo apt install ipv6toolkit

Realizar una prueba de Router Advertisement (RA) Spoofing es una excelente forma de entender cómo funciona la autoconfiguración en IPv6 y por qué es un vector de ataque crítico. En IPv6, los dispositivos usan mensajes RA para encontrar puertas de enlace y obtener prefijos de red automáticamente (SLAAC).

Al falsificar estos mensajes, puedes hacer que todo el tráfico de las víctimas pase por tu máquina (Man-in-the-Middle).

## Escenario de Prueba

Para esta práctica usaremos la herramienta ra6 de la suite ipv6toolkit.

Tu IP (Atacante): Supongamos que es fe80::1337
Interfaz: eth0 (o wlan0)
Objetivo: Inyectar una ruta falsa para interceptar tráfico.

## Pasos para realizar el Spoofing

1. Preparar tu sistema (Forwarding)

Antes de enviar los paquetes, debes decirle a tu kernel de Linux que actúe como un router, de lo contrario, recibirás los paquetes de la víctima pero los descartarás.

Bash

sudo sysctl -w net.ipv6.conf.all.forwarding=1

2. Lanzar el ataque con `ra6`

El siguiente comando envía anuncios de router falsos indicando que tú eres el router legítimo:

Bash

sudo ra6 -i eth0 -d ff02::1 -s fe80::1 -M 1 -O 1 -p 100

Desglose del comando:

-i eth0: La interfaz de red que vas a usar.
-d ff02::1: Dirección de destino (Multicast para "todos los nodos").
-s fe80::1: La IP que quieres suplantar (normalmente la del router real).
-M 1 / -O 1: Activa los flags de "Managed" y "Other config", forzando a los clientes a buscar un servidor DHCPv6 (que tú podrías controlar).
-p 100: Establece una preferencia alta para que los dispositivos elijan tu ruta sobre la del router real.

## Cómo verificar si funcionó

En una máquina víctima conectada a la misma red, revisa la tabla de rutas IPv6:

En Linux: ip -6 route
En Windows: netsh interface ipv6 show route

Si el ataque es exitoso, verás una ruta predeterminada apuntando hacia la dirección IP de tu máquina Kali.

### ## Medidas de Mitigación (RA Guard)

Es importante saber que este ataque se puede prevenir en switches empresariales usando una característica llamada RA Guard (RFC 6105). Esta función bloquea los mensajes de Router Advertisement que provienen de puertos que no están autorizados para actuar como routers.

Nota de seguridad: Realiza estas pruebas siempre en entornos controlados o laboratorios virtuales (como VirtualBox o VMware). Inyectar RAs falsos en una red real puede desconectar a todos los usuarios de internet.

Para completar el ataque de interceptación (Man-in-the-Middle) tras haber desviado el tráfico con los anuncios de router (RA), el siguiente paso lógico es configurar un servidor DHCPv6 falso. Esto te permite asignar a las víctimas no solo una ruta, sino también direcciones DNS bajo tu control.

Aquí te explico cómo hacerlo usando dnsmasq, que es ligero y muy efectivo en Kali Linux.

## Configuración de un DHCPv6 Falso con `dnsmasq`

El objetivo aquí es responder a las solicitudes de las víctimas y decirles: "Yo soy tu servidor DNS".

1. Crear el archivo de configuración

Crea un archivo llamado fake_dhcp6.conf:

Bash
interface=eth0
# Rango de IPs a repartir y tiempo de concesión
dhcp-range=2001:db8:1::100,2001:db8:1::200,64,12h
# Tu IP como servidor DNS (puedes poner la tuya o una externa controlada)
dhcp-option=option6:dns-server,[2001:4860:4860::8888]
# Activar el log para ver quién cae en la trampa
log-dhcp

2. Ejecutar el servidor

Lánzalo con privilegios de superusuario:

Bash

sudo dnsmasq -C fake_dhcp6.conf -d

## Interceptación de Datos (Sniffing)

Ahora que el tráfico fluye a través de tu máquina Kali, necesitas capturarlo y analizarlo. Tienes dos opciones principales:

Wireshark: La opción visual. Filtra por ipv6 o icmpv6 para ver el intercambio de mensajes de control, y por http o dns para ver la actividad del usuario.
tcpdump: Ideal para la línea de comandos.
Bash
```
sudo tcpdump -i eth0 -vv ip6
```

## El flujo completo del ataque

Forwarding: Tu PC se vuelve router (sysctl).
RA Spoofing (ra6): Convences a la red de que tú eres la salida a internet.
DHCPv6 Falso (dnsmasq): Te posicionas como su servidor DNS.
Sniffing: Capturas las credenciales o consultas que viajen por la red.

## ¿Cómo protegerse? (Nivel Administrador)

Si estás aprendiendo esto para defender una red, estas son las tres configuraciones que debes implementar en tus switches:

RA Guard: Bloquea mensajes RA de puertos no autorizados.
DHCPv6 Guard: Similar al anterior, pero para respuestas DHCPv6.
IPv6 Source Guard: Evita que un dispositivo use una dirección IP que no le pertenece.

Para detectar un ataque de RA Spoofing o DHCPv6 Falso con Wireshark, no necesitas ser un experto en protocolos, solo saber qué buscar. Estos ataques generan un "ruido" muy específico en la red.

## 1. Configuración de Wireshark para IPv6

Abre Wireshark en tu interfaz de red (eth0 o wlan0) y utiliza el siguiente filtro en la barra superior para limpiar el tráfico irrelevante:

icmpv6.type == 134 || dhcpv6

Type 134: Son los mensajes de Router Advertisement.
dhcpv6: Muestra las solicitudes y respuestas de asignación de IP/DNS.

## 2. Señales de Alerta (Red Flags)

A. Múltiples Routers Advertisements

Si ves paquetes de Router Advertisement provenientes de dos direcciones MAC distintas, es una señal clara de alerta. Normalmente, solo debería haber uno (tu router real).

B. El campo "Preference" (Preferencia)

Haz clic en un paquete ICMPv6 (Type 134) y expande la sección "Router Advertisement". Busca el campo Default Preference.

Normal: Suele ser Medium.
Ataque: El atacante suele ponerlo en High (Alto) para obligar a los dispositivos a usar su ruta.

C. Mensajes DHCPv6 "Reply" no solicitados

Si ves mensajes de tipo Reply o Advertise de DHCPv6 sin que tu máquina haya enviado un Solicit previo, alguien está intentando "empujar" una configuración DNS falsa a tu sistema.

## 3. Análisis de la MAC del atacante

Una vez que identifiques el paquete malicioso en Wireshark:

Ve a la sección Ethernet II.
Busca la Source MAC address.
Usa una herramienta como nmap o consulta una base de datos de OUI para ver qué dispositivo es. Si la MAC pertenece a una tarjeta "Realtek" o "Intel" en lugar de una marca de routers profesional (como Cisco o Juniper), sospecha inmediatamente.

## ¿Qué hacer si detectas el ataque?

Si estás en una red que administras, puedes usar la herramienta anona6 de la suite ipv6toolkit para intentar "anular" los efectos del anuncio falso enviando un RA con un Lifetime de 0, lo que le dice a los clientes que dejen de usar esa ruta de inmediato.

Bash

sudo ra6 -i eth0 -d ff02::1 -s [IP_DEL_ATACANTE] -t 0

Para automatizar la detección de ataques IPv6 sin tener que mirar Wireshark todo el día, la mejor herramienta en Python es Scapy. Scapy permite "olfatear" (sniff) el tráfico de red y analizar campos específicos de los paquetes en tiempo real.

Aquí tienes un script básico pero funcional para detectar RA Spoofing y anuncios de DHCPv6 sospechosos.

## Script de Detección en Python (Scapy)

Este script monitorea la red y lanza una alerta si detecta un mensaje de Router Advertisement (ICMPv6 Tipo 134) o paquetes DHCPv6.

Python
from scapy.all import sniff, ICMPv6ND_RA, DHCP6_Advertise, IPv6

# Define la dirección MAC de tu router legítimo para evitar falsos positivos
MAC_ROUTER_LEGAL = "00:aa:bb:cc:dd:ee" 

def analizar_paquete(pkt):
    # 1. Detectar Router Advertisements (RA)
    if pkt.haslayer(ICMPv6ND_RA):
        mac_origen = pkt.src
        interfaz_ip = pkt[IPv6].src
        
        print(f"[!] RA detectado desde {interfaz_ip} ({mac_origen})")
        
        # Alerta si la MAC no coincide con la del router oficial
        if mac_origen.lower() != MAC_ROUTER_LEGAL.lower():
            print(f"   [ALERTA] ¡Posible RA Spoofing! MAC desconocida: {mac_origen}")
            # Aquí podrías añadir una notificación al sistema o un log

    # 2. Detectar servidores DHCPv6 falsos
    if pkt.haslayer(DHCP6_Advertise):
        print(f"[!] DHCPv6 Advertise detectado desde {pkt[IPv6].src}")
        print("    [ALERTA] Alguien está ofreciendo direcciones IPv6/DNS en la red.")

print("[*] Iniciando monitor de seguridad IPv6... (Presiona Ctrl+C para detener)")
# Sniffing de tráfico ICMPv6 y DHCPv6
sniff(filter="icmp6 or udp port 546 or udp port 547", prn=analizar_paquete, store=0)

## Cómo ejecutarlo en Kali Linux

Instalar Scapy: Normalmente ya viene en Kali, pero si no: pip install scapy.
Permisos: El acceso a la tarjeta de red para sniffing requiere privilegios de root.
Bash
```
sudo python3 monitor_ipv6.py
```

## ¿Qué está pasando bajo el capó?

El Filtro: Usamos un filtro BPF (icmp6 or udp port 546...) para que Python no pierda tiempo procesando todo el tráfico de la red (como videos de YouTube o descargas), enfocándose solo en los protocolos de control.
Capas de Red: Scapy desglosa el paquete. Al buscar ICMPv6ND_RA, estamos yendo directamente al mensaje de "Anuncio de Router".
Detección de MAC: Esta es la defensa más robusta. Un atacante puede cambiar su IP fácilmente, pero cambiar la MAC en un entorno de red local suele delatarlos si tienes una lista blanca (whitelist).

## Siguiente nivel de automatización

Podrías mejorar este script para que, en cuanto detecte un ataque, ejecute automáticamente el comando de ipv6toolkit que vimos antes (ra6 -t 0) para "anular" el ataque del intruso en milisegundos.

Convertir un script de detección pasiva en uno de Defensa Activa (IPS - Intrusion Prevention System) es el siguiente paso lógico.

Lo que haremos será usar la librería os de Python para llamar a la herramienta ra6 de la ipv6toolkit en el milisegundo en que detectemos un paquete malicioso. Esto enviará un mensaje de "anulación" (Router Advertisement con Lifetime 0) para que los dispositivos de la red ignoren al atacante.

## Script de Defensa Activa IPv6

Este script no solo avisa, sino que neutraliza el ataque de forma automática.

Python
import os
from scapy.all import sniff, ICMPv6ND_RA, IPv6

# --- CONFIGURACIÓN ---
INTERFAZ = "eth0"
MAC_ROUTER_LEGAL = "00:aa:bb:cc:dd:ee"  # Pon la MAC real de tu router aquí
# ---------------------

def contra_ataque(ip_atacante):
    print(f"[!] ENVIANDO CONTRAMEDIDA contra {ip_atacante}...")
    # Usamos ra6 para enviar un anuncio con tiempo de vida 0 (-t 0)
    # Esto invalida al router falso en las tablas de los clientes.
    comando = f"sudo ra6 -i {INTERFAZ} -d ff02::1 -s {ip_atacante} -t 0"
    os.system(comando)
    print("[+] Ataque neutralizado.")

def analizar_y_defender(pkt):
    if pkt.haslayer(ICMPv6ND_RA):
        mac_origen = pkt.src
        ip_origen = pkt[IPv6].src
        
        # Si la MAC no es la autorizada... ¡Fuego!
        if mac_origen.lower() != MAC_ROUTER_LEGAL.lower():
            print(f"\n[ALERTA CRÍTICA] RA Ilegal detectado de {ip_origen} ({mac_origen})")
            contra_ataque(ip_origen)

print(f"[*] Sistema de Defensa Activa iniciado en {INTERFAZ}...")
print(f"[*] Router de confianza: {MAC_ROUTER_LEGAL}")

# Filtramos solo por paquetes ICMPv6 de control (RA)
sniff(filter="icmp6 and ip6[40] == 134", prn=analizar_y_defender, store=0)

## ¿Cómo funciona técnicamente?

Detección Quirúrgica: El filtro ip6[40] == 134 es un filtro BPF avanzado que busca específicamente el byte que identifica al Router Advertisement, haciendo que el script sea extremadamente rápido.
El "Kill-Switch" de IPv6: Cuando un cliente recibe un RA con un Router Lifetime de 0, el protocolo dicta que ese router debe ser eliminado de la lista de rutas por defecto inmediatamente.
Guerra de Mensajes: En una red real, esto se convierte en una carrera. El atacante envía un anuncio para ser el router, y tu script envía casi instantáneamente otro diciendo "ese router ya no existe". Los clientes suelen quedarse con la última instrucción válida o la de mayor prioridad.

## Consideraciones Importantes

Bucle de Mensajes: Asegúrate de que la MAC de tu router legal sea correcta. Si te equivocas, podrías terminar "atacando" a tu propio router legítimo y dejando a toda la red sin internet.
Permisos de Ejecución: Como el script llama a ra6 y usa scapy, debe ejecutarse con sudo.
Persistencia: Para un entorno real, este script debería correr como un servicio de fondo (systemd) para proteger la red 24/7.

Advertencia de Seguridad: Este script es una herramienta de aprendizaje y defensa. Úsalo con responsabilidad, ya que enviar mensajes de control de red puede causar inestabilidad si no se configura correctamente.

Para que este sistema de defensa sea realmente útil en un entorno de trabajo, no basta con que actúe en la terminal; necesitas enterarte al instante de lo que está ocurriendo sin tener que mirar una cascada de texto.

Vamos a añadirle notificaciones de escritorio (estilo "pop-up") y un archivo de registro (log) para que tengas un historial forense de los ataques.

## Script de Defensa Activa con Notificaciones Visuales

Para esto usaremos la librería notify2 (o os.system con notify-send, que ya viene en Kali) y el módulo logging de Python.

Python
import os
import logging
from datetime import datetime
from scapy.all import sniff, ICMPv6ND_RA, IPv6

# --- CONFIGURACIÓN ---
INTERFAZ = "eth0"
MAC_ROUTER_LEGAL = "00:aa:bb:cc:dd:ee"
LOG_FILE = "defensa_ipv6.log"

# Configuración del log
logging.basicConfig(filename=LOG_FILE, level=logging.INFO, 
                    format='%(asctime)s - %(message)s')

def enviar_notificacion(ip, mac):
    # Envía un aviso visual al escritorio de Kali/Linux
    titulo = "¡ALERTA DE SEGURIDAD IPv6!"
    mensaje = f"Ataque detectado desde IP: {ip}\nMAC: {mac}\nNeutralizando..."
    os.system(f'notify-send -u critical "{titulo}" "{mensaje}"')

def contra_ataque(ip_atacante):
    # Acción defensiva usando ipv6toolkit
    comando = f"sudo ra6 -i {INTERFAZ} -d ff02::1 -s {ip_atacante} -t 0"
    os.system(comando)
    logging.info(f"ATAQUE NEUTRALIZADO: IP {ip_atacante}")

def monitor_seguro(pkt):
    if pkt.haslayer(ICMPv6ND_RA):
        mac_origen = pkt.src
        ip_origen = pkt[IPv6].src
        
        if mac_origen.lower() != MAC_ROUTER_LEGAL.lower():
            # Loguear el evento
            logging.warning(f"RA ILEGAL: {ip_origen} desde MAC {mac_origen}")
            
            # Notificar visualmente
            enviar_notificacion(ip_origen, mac_origen)
            
            # Contra-atacar
            contra_ataque(ip_origen)
            print(f"[!] Amenaza procesada: {ip_origen}")

print(f"[*] Escudo IPv6 Activo. Logs en: {LOG_FILE}")
sniff(filter="icmp6 and ip6[40] == 134", prn=monitor_seguro, store=0)

## Cómo leer los resultados más tarde

Si dejas este script corriendo en segundo plano, puedes revisar qué pasó durante el día consultando el archivo log:

Bash

cat defensa_ipv6.log

Verás algo como esto:

2026-03-20 14:00:01 - RA ILEGAL: fe80::abc:123 desde MAC 08:00:27:12:34:56
2026-03-20 14:00:02 - ATAQUE NEUTRALIZADO: IP fe80::abc:123

## Consejos Finales de Implementación

Instala el notificador: Si notify-send no funciona, instálalo con sudo apt install libnotify-bin.
Lista Blanca Extendida: Si tu red tiene varios routers legítimos, puedes cambiar la variable MAC_ROUTER_LEGAL por una lista: MAC_AUTORIZADAS = ["mac1", "mac2"] y verificar con if mac_origen not in MAC_AUTORIZADAS:.
Ejecución Silenciosa: Puedes correr el script en una terminal y minimizarla, o usar nohup para que siga vivo aunque cierres la sesión.

Con esto, has pasado de simplemente "usar una herramienta" a construir tu propio sistema de seguridad perimetral para IPv6.

Para que tu script de defensa sea una herramienta profesional y no solo un experimento de una sola vez, vamos a convertirlo en un servicio de sistema (systemd). Esto hará que se ejecute automáticamente en segundo plano cada vez que inicies Kali Linux, sin necesidad de abrir una terminal.

## 1. Preparar el Script

Primero, asegúrate de que tu script tenga una ruta fija y permisos de ejecución. Supongamos que lo guardamos en /usr/local/bin/escudo_ipv6.py.

Mueve el archivo:
sudo mv monitor_ipv6.py /usr/local/bin/escudo_ipv6.py
Dale permisos de ejecución:
sudo chmod +x /usr/local/bin/escudo_ipv6.py

## 2. Crear el archivo de Unidad de Servicio

Crea un archivo de configuración para que Linux sepa cómo gestionar tu script:

Bash

sudo nano /etc/systemd/system/escudo-ipv6.service

Pega el siguiente contenido (ajusta tu usuario si es necesario):

Ini, TOML
[Unit]
Description=Servicio de Defensa Activa IPv6 contra RA Spoofing
After=network.target

[Service]
# Ejecutar como root es necesario para Scapy y ipv6toolkit
ExecStart=/usr/bin/python3 /usr/local/bin/escudo_ipv6.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

## 3. Activar y Probar el Servicio

Ahora solo queda decirle al sistema que cargue y arranque tu nuevo "escudo":

Recargar la configuración del sistema:
sudo systemctl daemon-reload
Habilitar para que inicie con el sistema:
sudo systemctl enable escudo-ipv6.service
Arrancar el servicio ahora mismo:
sudo systemctl start escudo-ipv6.service

¿Cómo saber si está funcionando?

Puedes verificar el estado de tu defensa en cualquier momento con:

sudo systemctl status escudo-ipv6.service

Si alguien intenta lanzar un ataque, verás las alertas en los logs del sistema (journalctl -u escudo-ipv6.service) y recibirás la notificación en tu escritorio si tienes la sesión iniciada.

## Resumen de tu herramienta personalizada

Has construido un ecosistema completo de seguridad:

Detección: Basada en Scapy (Python).
Respuesta: Automatizada con ipv6toolkit (ra6).
Logging: Registro forense en archivo .log.
UX: Notificaciones visuales de escritorio.
Persistencia: Servicio nativo de Linux (systemd).

¡Has pasado de ser un usuario de herramientas a ser un desarrollador de soluciones de seguridad!

Para cerrar el círculo de la seguridad en redes locales IPv6, debemos hablar del Neighbor Advertisement (NA) Spoofing. En IPv4 usábamos el ARP para asociar IPs con direcciones MAC; en IPv6 usamos el protocolo NDP (Neighbor Discovery Protocol).

Si un atacante envía mensajes NA falsos, puede convencer a tu computadora de que la dirección MAC de la puerta de enlace es la suya. Esto es el equivalente exacto al ARP Poisoning.

## 1. El concepto: NDP Poisoning

A diferencia del ataque anterior (RA Spoofing), que afectaba la ruta de salida a Internet, el NA Spoofing se usa para interceptar tráfico entre dos dispositivos en la misma red local (por ejemplo, entre tú y una impresora o un servidor de archivos).

## 2. Actualizando el Script de Defensa

Podemos integrar la detección de este ataque en nuestro script actual de Scapy añadiendo el análisis del paquete ICMPv6ND_NA (Tipo 136).

Añade este bloque dentro de tu función monitor_seguro:

Python
from scapy.all import ICMPv6ND_NA

# ... dentro de la función analizar_y_defender o monitor_seguro ...

    if pkt.haslayer(ICMPv6ND_NA):
        target_ip = pkt[ICMPv6ND_NA].tgt
        mac_real_anunciada = pkt.src
        
        # Si alguien dice ser el Router pero su MAC no coincide
        if target_ip == "FE80::1" and mac_real_anunciada.lower() != MAC_ROUTER_LEGAL.lower():
            logging.critical(f"¡NDP POISONING DETECTADO! {mac_real_anunciada} intenta suplantar al router.")
            enviar_notificacion("ATAQUE ARP/NDP", f"MAC atacante: {mac_real_anunciada}")
            
            # Contra-ataque: Re-anunciar la MAC correcta del router
            # Usamos na6 de ipv6toolkit
            os.system(f"sudo na6 -i {INTERFAZ} -d ff02::1 -s {target_ip} -E {MAC_ROUTER_LEGAL} -L -W")

## 3. Uso de `na6` (La herramienta de fuerza)

En la suite ipv6toolkit, la herramienta na6 es la que gestiona estos paquetes. En el comando anterior:

-s {target_ip}: La IP que estamos protegiendo (el router).
-E {MAC_ROUTER_LEGAL}: La MAC verdadera que queremos imponer.
-L y -W: Flags para indicar que somos el nodo "objetivo" y que los demás deben actualizar su caché inmediatamente.

## Resumen de tu Suite de Protección Personalizada

Ataque	Herramienta de Ataque	Herramienta de Defensa	Protocolo
RA Spoofing	`ra6`	Tu script + `ra6 -t 0`	ICMPv6 Tipo 134
DHCPv6 Fake	`dnsmasq`	Tu script (Detección UDP 547)	UDP 546/547
NDP Poisoning	`na6`	Tu script + `na6 -W`	ICMPv6 Tipo 136

## Próximos pasos recomendados

Ya tienes un sistema que detecta y responde. Lo último para ser un experto en la suite es aprender a limpiar tu propia huella o realizar auditorías de inundación de tablas de vecinos (Neighbor Cache Exhaustion) para probar la resistencia de tus equipos de red.