Nerva
Nerva: CLI de huella digital de servicios rápida
Características •
Instalación •
Inicio rápido •
Uso •
Protocolos •
Biblioteca •
Casos de uso •
Solución de problemas
Huella digital de servicios de alto rendimiento escrita en Go. Identifica más de 170 protocolos de red a través de transportes TCP, UDP y SCTP con extracción de metadatos enriquecida.
Nerva detecta e identifica rápidamente los servicios que se ejecutan en puertos de red abiertos. Úsalo junto con escáneres de puertos como Naabu para obtener la huella digital de los servicios descubiertos, o intégralo en tus canalizaciones de seguridad para un reconocimiento automatizado.
Características
- Más de 170 complementos de protocolo — Bases de datos, acceso remoto, servicios web, mensajería, protocolos industriales y de telecomunicaciones
- 76 rastreadores de huella HTTP — Detecta tecnologías web, incluidos firewalls, bases de datos, servidores de IA/LLM y más
- Detección de configuraciones incorrectas de seguridad — Identifica problemas de seguridad comunes como API no autenticadas y protocolos en texto claro (
--misconfigs)
- Soporte para múltiples transportes — TCP (predeterminado), UDP (
--udp) y SCTP (--sctp, solo Linux)
- Soporte para 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 legibles por humanos
- Compatible con canalizaciones — Canaliza desde Naabu, Nmap o cualquier herramienta que genere
host:puerto
- Biblioteca Go — Importar directamente en tus aplicaciones Go
Instalación
Lanzamientos
Descarga un binario precompilado desde la página de Lanzamientos.
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
Analizar un único objetivo:```sh
nerva -t example.com:22
# ssh://example.com:22
Obtén metadatos JSON detallados:```sh
nerva -t example.com:22 --json
Tubería 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
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
### Flags
| Flag | Short | Description | Default |
|------|-------|-------------|---------|
| `--targets` | `-t` | Objetivo o lista de objetivos separados por comas | — |
| `--list` | `-l` | Archivo de entrada que contiene objetivos | — |
| `--output` | `-o` | Ruta del archivo de salida | stdout |
| `--json` | | Salida en formato JSON | false |
| `--csv` | | Salida en formato CSV | false |
| `--misconfigs` | | Habilitar detección de configuraciones incorrectas de seguridad | false |
| `--proxy` | | URL del proxy (ej. socks5://127.0.0.1:1080) | — |
| `--proxy-auth` | | Autenticación del proxy SOCKS5 (ej. usuario:contraseña) | — |
| `--dns-order` | | Orden de resolución DNS: `p`, `l`, `lp`, `pl` | `lp` |
| `--fast` | `-f` | Modo rápido (solo puertos predeterminados) | false |
| `--capabilities` | `-c` | Listar capacidades disponibles y salir | false |
| `--udp` | `-U` | Ejecutar plugins UDP | false |
| `--sctp` | `-S` | Ejecutar plugins SCTP (solo Linux) | false |
| `--timeout` | `-w` | Tiempo de espera en milisegundos | 2000 |
| `--verbose` | `-v` | Salida detallada a stderr | false |
| `--workers` | `-W` | Trabajadores de escaneo concurrentes | 50 |
| `--max-host-conn` | `-H` | Máximo de conexiones concurrentes por IP de host (0=ilimitado) | 0 |
| `--rate-limit` | `-R` | Máximo de escaneos por segundo globalmente (0=ilimitado) | 0 |
### Examples
**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
**UDP scanning** (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
**Modo rápido** (solo puertos por defecto):```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 Incorrectas de Seguridad
Nerva puede identificar configuraciones incorrectas de seguridad comunes cuando se habilita con `--misconfigs`:```sh
nerva -t example.com:2375 --misconfigs --json
Configuraciones incorrectas detectadas:
Ejemplo de salida con configuraciones incorrectas:```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 soporta 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 la resolución DNS del lado del proxy (equivalente a --dns-order p)
Ejemplo de escaneo 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: La compatibilidad de UDP a través de SOCKS5 es limitada. No todos los servidores SOCKS5 admiten la asociación UDP. Puede ocurrir una falla 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 elegante** (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 Soportados
170+ plugins de detección de servicios en TCP, UDP y SCTP:
Módulos de Huellas HTTP (66)
Detección de tecnologías 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 Negocio (8)
Hogar e IoT (2)
| Módulo | Descripción |
|---|
| Home Assistant | Plataforma de automatización del hogar |
| UniFi/EdgeOS | Dispositivos de red Ubiquiti |
Otros (2)
| Módulo | Descripción |
|---|
| Go pprof | Puntos finales de perfilado Go |
| NATS | Broker de mensajes |
Bases de Datos (20)
Acceso Remoto (6)
Web y API (2)
| Protocolo | Transporte | Notas |
|---|
| HTTP/HTTPS | TCP | HTTP/2, detección de tecnologías mediante Wappalyzer |
| Kubernetes | TCP | Detección de servidor API |
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 y Administración Remota (10)
Herramientas de Desarrollo (8)
Uso de la Librería
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)
}
}
See [examples/service-fingerprinting-example.go](https://github.com/praetorian-inc/nerva/blob/HEAD/examples/service-fingerprinting-example.go) for a complete working example.
## Casos de Uso
### Pruebas de Penetración
Fingerprint rápidamente servicios descubiertos durante el reconocimiento para identificar posibles vectores de ataque.
### Tuberías de Descubrimiento de Activos
Combine con Naabu o Masscan para un inventario de activos a gran escala:```sh
naabu -host 10.0.0.0/24 -silent | nerva --json | jq '.protocol'
Escaneo de seguridad CI/CD
Integre en las canalizaciones de implementación para verificar que solo se expongan los servicios esperados.
Reconocimiento de Bug Bounty
Enumere rápidamente los servicios en los objetivos del alcance para encontrar endpoints interesantes.
Análisis de redes de telecomunicaciones
Identifique 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]
Why Nerva?
vs Nmap
- Valores predeterminados más inteligentes: Nerva verifica primero el protocolo más probable según el número de puerto
- Salida estructurada: Soporte nativo de JSON/CSV para facilitar el análisis y la integración en pipelines
- Enfocado: Solo huellas digitales de servicios — combínalo con escáneres de puertos dedicados para descubrimiento
vs zgrab2
- Detección automática: No es necesario especificar el protocolo de antemano
- Uso más simple:
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 detectó 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:
sn0int -t 5 scan
nerva -t example.com:80 -w 5000 # 5 seconds
```
### UDP services not detected
**Causa**: Escaneo UDP deshabilitado por defecto.
**Solución**: Habilítelo con la bandera `-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 ejecutándose en un puerto (SSH, HTTP, PostgreSQL, etc.)
- **Huella digital**: Detectar e identificar el tipo de servicio, versión y configuración
- **Plugin**: Un módulo de detección específico del protocolo
- **Modo rápido**: Escanear solo el 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:
[](https://github.com/praetorian-inc/nerva)
## Contribuciones
¡Agradecemos las contribuciones! Consulta [CONTRIBUTING.md](https://github.com/praetorian-inc/nerva/blob/HEAD/CONTRIBUTING.md) para las pautas.
## Licencia
Apache 2.0 — consulta [LICENSE](https://github.com/praetorian-inc/nerva/blob/HEAD/LICENSE) para más detalles.
## Agradecimientos
Nerva es un fork mantenido de [fingerprintx](https://github.com/praetorian-inc/fingerprintx), desarrollado originalmente por la clase de pasantes de Praetorian de 2022:
* [Soham Roy](https://github.com/praetorian-sohamroy)
* [Jue Huang](https://github.com/jue-huang)
* [Henry Jung](https://github.com/henryjung64)
* [Tristan Wiesepape](https://github.com/qwetboy10)
* [Joseph Henry](https://github.com/jwhenry28)
* [Noah Tutt](https://github.com/noahtutt)
* [Nathan Sportsman](https://github.com/nsportsman)
praetorian-inc/nerva
