Nerva
_{Nerva: CLI de fingerprinting de servicios rápido}

Características • Instalación • Inicio rápido • Uso • Protocolos • Biblioteca • Casos de uso • Solución de problemas

Fingerprinting de servicios de alto rendimiento escrito en Go. Identifica más de 170 protocolos de red en los transportes TCP, UDP y SCTP con extracción de metadatos enriquecidos.

Nerva detecta e identifica rápidamente servicios que se ejecutan en puertos de red abiertos. Úsalo junto con escáneres de puertos como Naabu para hacer fingerprinting de los servicios descubiertos, o intégralo en tus pipelines de seguridad para reconocimiento automatizado.

Características

• Más de 170 plugins de protocolos — Bases de datos, acceso remoto, servicios web, mensajería, protocolos industriales y de telecomunicaciones
• 76 fingerprinters HTTP — Detecta tecnologías web, incluidos firewalls, bases de datos, servidores de IA/LLM y más
• Detección de malas configuraciones de seguridad — Identifica problemas de seguridad comunes como APIs sin autenticación y protocolos en texto claro (--misconfigs)
• Soporte multi-transporte — TCP (predeterminado), UDP (--udp) y SCTP (--sctp, solo Linux)
• Soporte de proxy — Enruta el tráfico de escaneo de forma transparente a través de proxies SOCKS5 o HTTP con resolución DNS configurable
• Metadatos enriquecidos — Extrae versiones, configuraciones y detalles relevantes para la seguridad de cada servicio
• Modo rápido — Escanea solo los puertos predeterminados para un reconocimiento rápido (--fast)
• Salida flexible — Formatos JSON, CSV o legible por humanos
• Compatible con pipelines — Canaliza desde Naabu, Nmap o cualquier herramienta que genere host:port
• Biblioteca Go — Impórtala directamente en tus aplicaciones Go

Instalación

Releases

Descarga un binario precompilado desde la página de Releases.

Desde GitHub```sh

go install github.com/praetorian-inc/nerva/cmd/nerva@latest

### Desde el código fuente```sh
git clone https://github.com/praetorian-inc/nerva.git
cd nerva
go build ./cmd/nerva
./nerva -h

Docker```sh

git clone https://github.com/praetorian-inc/nerva.git cd nerva docker build -t nerva . docker run --rm nerva -h docker run --rm nerva -t example.com:80 --json

## Inicio rápido

Huella digital de un único objetivo:```sh
nerva -t example.com:22
# ssh://example.com:22

Obtener metadatos JSON detallados:```sh nerva -t example.com:22 --json

{"host":"example.com","ip":"93.184.216.34","port":22,"protocol":"ssh","transport":"tcp","metadata":{...}}

Canalizar desde un escáner de puertos:```sh
naabu -host example.com -silent | nerva
# http://example.com:80
# ssh://example.com:22
# https://example.com:443

La referencia completa — cada subcomando, alias y flag, incluidos los ocultos de --help — se genera en docs/CLI.md.

Uso```

nerva [flags]

TARGET SPECIFICATION: Requires host:port or ip:port format. Assumes ports are open.

EXAMPLES: nerva -t example.com:80 nerva -t example.com:80,example.com:443 nerva -l targets.txt nerva --json -t example.com:80 cat targets.txt | nerva

### Ejemplos

**Múltiples objetivos:**```sh
nerva -t example.com:22,example.com:80,example.com:443

Del archivo:```sh nerva -l targets.txt --json -o results.json

**Escaneo UDP** (puede requerir root):```sh
sudo nerva -t example.com:53 -U
# dns://example.com:53

Escaneo SCTP (solo Linux):```sh nerva -t telecom-server:3868 -S

diameter://telecom-server:3868

**Modo rápido** (solo puertos predeterminados):```sh
nerva -l large-target-list.txt --fast --json

Enrutamiento de proxy con resolución DNS remota:```sh nerva -t target.internal:80 --proxy socks5://127.0.0.1:1080 --dns-order p

### Detección de configuraciones de seguridad incorrectas

Nerva puede identificar configuraciones de seguridad incorrectas comunes cuando se habilita con `--misconfigs`:```sh
nerva -t example.com:2375 --misconfigs --json

Misconfiguraciones detectadas:

Ejemplo de salida con misconfiguraciones:```json { "host": "example.com", "port": 2375, "protocol": "docker", "anonymous_access": true, "security_findings": [ { "id": "docker-unauth-api", "severity": "critical", "description": "Docker API accessible without authentication", "evidence": "Successfully queried /version endpoint without credentials" } ] }

### Soporte de Proxy

Nerva admite el enrutamiento del tráfico de escaneo a través de proxies SOCKS5 y HTTP con resolución DNS configurable.

**Esquemas de proxy compatibles:**

- `socks5://` - Proxy SOCKS5 con resolución DNS local
- `socks5h://` - Proxy SOCKS5 con resolución DNS del lado del proxy (siempre)
- `http://` - Proxy HTTP CONNECT
- `https://` - Proxy HTTPS CONNECT

**Autenticación de proxy:**```sh
# Inline authentication (URL format)
nerva -t example.com:80 --proxy socks5://username:[email protected]:1080

# Separate authentication flag
nerva -t example.com:80 --proxy socks5://127.0.0.1:1080 --proxy-auth username:password

Estrategias de resolución DNS (--dns-order):

Nota: el esquema socks5h:// fuerza automáticamente el DNS del lado del proxy (equivalente a --dns-order p)

Ejemplo de escaneo con Tor:```sh

Scan .onion services through Tor (SOCKS5 proxy on port 9050)

nerva -t http://example.onion:80 --proxy socks5h://127.0.0.1:9050

**UDP a través de proxy:**```sh
# UDP scanning through SOCKS5 proxy (limited support)
nerva -t target.com:161 --proxy socks5://127.0.0.1:1080 --udp

⚠️ Limitaciones de UDP: UDP a través de SOCKS5 tiene soporte limitado. No todos los servidores SOCKS5 admiten la asociación UDP. Puede ocurrir una reserva local de UDP.

Escaneo paralelo con limitación de velocidad:```sh nerva -l large-target-list.txt -W 100 -H 5 -R 50 -v

**Apagado controlado** (Ctrl+C devuelve resultados parciales):```sh
nerva -l huge-target-list.txt -W 50 -v
# Press Ctrl+C to stop — collected results are still printed

Protocolos compatibles

Más de 170 plugins de detección de servicios en TCP, UDP y SCTP:

Módulos de huella HTTP (66)

Detección de tecnología para servicios web, organizados por categoría:

Cortafuegos y seguridad de red (12)

IA/LLM y aprendizaje automático (6)

Bases de datos y almacenes de datos (12)

DevOps e infraestructura (14)

Servidores web y frameworks (10)

Empresarial y de negocio (8)

Hogar e IoT (2)

Otros (2)

Bases de datos (20)

Acceso remoto (6)

Web y API (2)

Mensajería y colas (10)

Servicios de archivos y directorios (7)

Servicios de red (11)

Sistemas de control industrial (18)

Telecomunicaciones y VoIP (17)

VPN y seguridad (11)

Acceso remoto y administración (10)

Herramientas de desarrollo (8)

Uso de la biblioteca

Importa Nerva en tus aplicaciones Go:```go package main

import ( "context" "fmt" "log" "net/netip" "time"

"github.com/praetorian-inc/nerva/pkg/plugins"
"github.com/praetorian-inc/nerva/pkg/scan"

)

func main() { // Configure scan config := scan.Config{ DefaultTimeout: 2 * time.Second, FastMode: false, UDP: false, Proxy: "socks5://127.0.0.1:1080", // optional ProxyAuth: "username:password", // optional DNSOrder: "p", // resolver strategy }

// Create target
ip, _ := netip.ParseAddr("93.184.216.34")
target := plugins.Target{
    Address: netip.AddrPortFrom(ip, 22),
    Host:    "example.com",
}

// Run scan
results, err := scan.ScanTargets(context.Background(), []plugins.Target{target}, config)
if err != nil {
    log.Fatal(err)
}

// Process results
for _, result := range results {
    fmt.Printf("%s:%d - %s (%s)\n",
        result.Host, result.Port,
        result.Protocol, result.Transport)
}

}

Consulta [examples/service-fingerprinting-example.go](https://github.com/praetorian-inc/nerva/blob/main/examples/service-fingerprinting-example.go) para ver un ejemplo completo y funcional.

## Casos de uso

### Pruebas de penetración

Identifica rápidamente los servicios descubiertos durante el reconocimiento para detectar posibles vectores de ataque.

### Pipelines de descubrimiento de activos

Combínalo con Naabu o Masscan para el inventario de activos a gran escala:```sh
naabu -host 10.0.0.0/24 -silent | nerva --json | jq '.protocol'

Escaneo de seguridad en CI/CD

Integrar en pipelines de despliegue para verificar que solo los servicios esperados estén expuestos.

Reconocimiento en Bug Bounty

Enumerar rápidamente servicios en los objetivos del alcance para encontrar endpoints interesantes.

Análisis de redes de telecomunicaciones

Identificar nodos Diameter en redes LTE/5G usando transporte SCTP (Linux):```sh nerva -t mme.telecom.local:3868 -S --json

## Arquitectura```mermaid
graph LR
    A[host:port input] --> B[Target Parser]
    B --> C[Scan Engine]
    C --> D{Transport}
    D -->|TCP| E[TCP Plugins]
    D -->|UDP| F[UDP Plugins]
    D -->|SCTP| G[SCTP Plugins]
    E --> H[Service Detection]
    F --> H
    G --> H
    H --> I[Metadata Extraction]
    I --> J[JSON/CSV/Text Output]

¿Por qué Nerva?

vs Nmap

• Valores predeterminados más inteligentes: Nerva comprueba primero el protocolo más probable según el número de puerto
• Salida estructurada: Compatibilidad nativa con JSON/CSV para facilitar el análisis e integración en pipelines
• Enfocado: Solo fingerprinting de servicios — combínalo con escáneres de puertos dedicados para el descubrimiento

vs zgrab2

• Detección automática: No es necesario especificar el protocolo de antemano
• Uso más sencillo: nerva -t host:port vs echo host | zgrab2 http -p port

Solución de problemas

Sin salida

Causa: El puerto está cerrado o no se ha detectado ningún servicio compatible.

Solución: Verifica que el puerto esté abierto:```sh nc -zv example.com 80

### Errores de tiempo de espera

**Causa**: El tiempo de espera predeterminado de 2 segundos es demasiado corto para servicios lentos.

**Solución**: Aumentar el tiempo de espera:```sh
nerva -t example.com:80 -w 5000  # 5 seconds

Servicios UDP no detectados

Causa: El escaneo UDP está deshabilitado por defecto.

Solución: Habilítalo con la opción -U (puede requerir root):```sh sudo nerva -t example.com:53 -U

### SCTP no funciona

**Causa**: SCTP solo es compatible con Linux.

**Solución**: Ejecutar en un sistema o contenedor Linux:```sh
docker run --rm nerva -t telecom:3868 -S

Terminología

• Servicio: Un servicio de red que se ejecuta en un puerto (SSH, HTTP, PostgreSQL, etc.)
• Fingerprinting: Detección e identificación del tipo de servicio, versión y configuración
• Plugin: Un módulo de detección específico de protocolo
• Modo rápido: Escaneo únicamente del puerto predeterminado para cada protocolo (optimización 80/20)
• Transporte: Protocolo de capa de red (TCP, UDP o SCTP)

Soporte

Si encuentras útil Nerva, considera darle una estrella:

Contribuciones

¡Aceptamos contribuciones! Consulta CONTRIBUTING.md para obtener las directrices.

Licencia

Apache 2.0 — consulta LICENSE para más detalles.

Agradecimientos

Nerva es un fork mantenido de fingerprintx, desarrollado originalmente por la clase de becarios de Praetorian de 2022:

• Soham Roy
• Jue Huang
• Henry Jung
• Tristan Wiesepape
• Joseph Henry
• Noah Tutt
• Nathan Sportsman