sx es el escáner de red de línea de comandos diseñado para seguir la filosofía UNIX.

El objetivo de este proyecto es crear el escáner de red más rápido con un código limpio y simple.

📖 Índice de contenidos

• Features
• Install
• Build from source
• Quick Start
• References
• Contributing
• Credits
• License

✨ Características

• ⚡ 30 veces más rápido que nmap
• Escaneo ARP: Escanea tus redes locales para detectar dispositivos activos
• Escaneo ICMP: Usa técnicas avanzadas de escaneo ICMP para detectar hosts activos y reglas de firewall
• Escaneo TCP SYN: Escaneo tradicional de media apertura para encontrar puertos TCP abiertos
• Escaneos TCP FIN / NULL / Xmas: Técnicas de escaneo para eludir algunas reglas de firewall
• Escaneos TCP personalizados con cualquier flag TCP: Envía los paquetes exóticos que quieras y obtén un resultado con todas las flags TCP establecidas en el paquete de respuesta
• Escaneo UDP: Escanea puertos UDP y obtén respuestas ICMP completas para detectar puertos abiertos o reglas de firewall
• Escaneos de aplicación:
  • Escaneo SOCKS5: Detecta proxies SOCKS5 activos escaneando un rango de IP o una lista de pares ip/puerto desde un archivo
• Iteración aleatoria sobre direcciones IP usando grupos multiplicativos cíclicos finitos
• Soporte de salida JSON: sx está diseñado específicamente para el procesamiento automático conveniente de resultados

📦 Instalación

La forma más sencilla es descargar desde GitHub Releases y colocar el ejecutable en tu PATH.

🛠 Compilar desde el código fuente

Requisitos:

• Go 1.25 o posterior
• libpcap (ya instalado si usas wireshark)

En macOS, instala primero las Xcode Command Line Tools para que CGO pueda enlazar con libpcap del sistema:

xcode-select --install

Desde la raíz del árbol fuente, ejecuta:

go build

🚀 Inicio rápido

Aquí hay algunos ejemplos rápidos que muestran cómo puedes escanear redes con sx.

Escaneo ARP

Escanea tu red local y muestra la dirección IP, dirección MAC y el fabricante de hardware asociado de los dispositivos conectados:

sx arp 192.168.0.1/24

salida de ejemplo:

192.168.0.1          b0:be:76:40:05:8d    TP-LINK TECHNOLOGIES CO.,LTD.
192.168.0.111        80:c5:f2:0b:02:e3    AzureWave Technology Inc.
192.168.0.171        88:53:95:2d:3c:af    Apple, Inc.

con salida JSON:

sx arp --json 192.168.0.1/24

salida de ejemplo:

{"ip":"192.168.0.1","mac":"b0:be:76:40:05:8d","vendor":"TP-LINK TECHNOLOGIES CO.,LTD."}
{"ip":"192.168.0.111","mac":"80:c5:f2:0b:02:e3","vendor":"AzureWave Technology Inc."}
{"ip":"192.168.0.171","mac":"88:53:95:2d:3c:af","vendor":"Apple, Inc."}

espera 5 segundos antes de salir para recibir paquetes de respuesta retrasados; por defecto, sx espera 300 milisegundos:

sx arp --exit-delay 5s 192.168.0.1/24

Modo de escaneo en vivo que reescanee la red cada 10 segundos:

sx arp 192.168.0.1/24 --live 10s

Escaneo TCP

A diferencia de nmap y otros escáneres que realizan implícitamente solicitudes ARP para resolver direcciones IP en direcciones MAC antes del escaneo real, sx utiliza explícitamente el concepto de caché ARP. El archivo de caché ARP es un archivo de texto simple que contiene una cadena JSON en cada línea (archivo JSONL), que tiene los mismos campos JSON que la salida JSON del escaneo ARP descrita anteriormente. Los escaneos de protocolos de nivel superior como TCP y UDP leen el archivo de caché ARP desde la entrada estándar y luego comienzan el escaneo real.

Esto no solo simplifica el diseño del programa, sino que también acelera el proceso de escaneo, ya que no es necesario realizar un escaneo ARP cada vez.

Supongamos que la caché ARP real está en el archivo arp.cache. Podemos crearlo manualmente o usar el escaneo ARP como se muestra a continuación:

sx arp 192.168.0.1/24 --json | tee arp.cache

Una vez que tenemos el archivo de caché ARP, podemos ejecutar escaneos de protocolos de nivel superior como el escaneo TCP SYN:

cat arp.cache | sx tcp -p 1-65535 192.168.0.171

salida de ejemplo:

192.168.0.171        22
192.168.0.171        443

En este caso, descubrimos que los puertos 22 y 443 están abiertos.

Si ves send: No buffer space available durante escaneos grandes, generalmente significa que el emisor está superando los búferes del kernel/socket raw. La primera solución es agregar --rate y reducir el burst de envío, por ejemplo -r 100000/s o menos si es necesario. En algunos sistemas, ajustar los límites de búfer del sistema operativo también puede ayudar, pero la limitación de velocidad es la solución principal.

escaneo con salida JSON:

cat arp.cache | sx tcp  --json -p 1-65535 192.168.0.171

salida de ejemplo:

{"scan":"tcpsyn","ip":"192.168.0.171","port":22}
{"scan":"tcpsyn","ip":"192.168.0.171","port":443}

escanea múltiples rangos de puertos:

cat arp.cache | sx tcp -p 1-23,25-443 192.168.0.171

o puertos individuales:

cat arp.cache | sx tcp -p 22,443 192.168.0.171

o usa la opción --ports-file para especificar un archivo con puertos o rangos de puertos para escanear, uno por línea.

escanea pares ip/puerto desde un archivo con salida JSON:

cat arp.cache | sx tcp --json -f ip_ports_file.jsonl

Cada línea del archivo de entrada es una cadena JSON, que debe contener los campos ip y port.

archivo de entrada de ejemplo:

{"ip":"10.0.1.1","port":1080}
{"ip":"10.0.2.2","port":1081}

Es posible especificar el archivo de caché ARP usando las opciones -a o --arp-cache:

sx tcp -a arp.cache -p 22,443 192.168.0.171

o redirección de entrada estándar:

sx tcp -p 22,443 192.168.0.171 < arp.cache

También puedes usar el subcomando tcp syn en lugar de tcp:

cat arp.cache | sx tcp syn -p 22 192.168.0.171

tcp es solo una abreviatura del subcomando tcp syn a menos que se pase la opción --flags, ver más abajo.

Interfaces VPN

sx soporta el escaneo con interfaces de red virtuales (wireguard, openvpn, etc.) y en este caso no es necesario usar la caché ARP, ya que estas interfaces requieren paquetes IP sin procesar en lugar de tramas Ethernet como entrada. Por ejemplo, escanear una dirección IP en una red vpn:

sx tcp 10.1.27.1 -p 80 --json

Escaneo TCP FIN