Nerva
_{Nerva: CLI veloce per fingerprinting di servizi}

Funzionalità • Installazione • Avvio rapido • Utilizzo • Protocolli • Libreria • Casi d'uso • Risoluzione dei problemi

Fingerprinting di servizi ad alte prestazioni scritto in Go. Identifica 170+ protocolli di rete su trasporti TCP, UDP e SCTP con estrazione di metadati completi.

Nerva rileva e identifica rapidamente i servizi in esecuzione su porte di rete aperte. Utilizzalo insieme a scanner di porte come Naabu per eseguire il fingerprinting dei servizi scoperti, o integralo nei tuoi pipeline di sicurezza per ricognizione automatizzata.

Funzionalità

• 170+ Plugin di protocolli — Database, accesso remoto, servizi web, messaggistica, protocolli industriali e di telecomunicazione
• 76 Fingerprint HTTP — Rileva tecnologie web inclusi firewall, database, server AI/LLM e altro
• Rilevamento di configurazioni errate di sicurezza — Identifica problemi di sicurezza comuni come API non autenticate e protocolli in chiaro (--misconfigs)
• Supporto multi-trasporto — TCP (predefinito), UDP (--udp) e SCTP (--sctp, solo Linux)
• Supporto proxy — Instrada il traffico di scansione in modo trasparente attraverso proxy SOCKS5 o HTTP con risoluzione DNS configurabile
• Metadati ricchi — Estrai versioni, configurazioni e dettagli rilevanti per la sicurezza da ogni servizio
• Modalità rapida — Scansiona solo le porte predefinite per ricognizione rapida (--fast)
• Output flessibile — Formati JSON, CSV o leggibili dall'uomo
• Amichevole per pipeline — Pipe da Naabu, Nmap o qualsiasi strumento che produce host:port
• Libreria Go — Importa direttamente nelle tue applicazioni Go

Installazione

Rilasci

Scarica un binario precompilato dalla pagina Rilasci.

Da GitHub```sh

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

### Dal sorgente```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

## Avvio rapido

Esegui il fingerprinting di un singolo target:```sh
nerva -t example.com:22
# ssh://example.com:22

Ottieni metadati JSON dettagliati:```sh nerva -t example.com:22 --json

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

Pipe da uno scanner di porte:```sh
naabu -host example.com -silent | nerva
# http://example.com:80
# ssh://example.com:22
# https://example.com:443

Utilizzo```

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

### Bandiera | Abbreviazione | Descrizione | Predefinito |
|------|-------|-------------|---------|
| `--targets` | `-t` | Target o elenco di target separati da virgola | — |
| `--list` | `-l` | File di input contenente i target | — |
| `--output` | `-o` | Percorso del file di output | stdout |
| `--json` | | Output in formato JSON | false |
| `--csv` | | Output in formato CSV | false |
| `--misconfigs` | | Abilita il rilevamento di configurazioni errate di sicurezza | false |
| `--proxy` | | URL del proxy (es. socks5://127.0.0.1:1080) | — |
| `--proxy-auth` | | Autenticazione proxy SOCKS5 (es. username:password) | — |
| `--dns-order` | | Ordine di risoluzione DNS: `p`, `l`, `lp`, `pl` | `lp` |
| `--fast` | `-f` | Modalità veloce (solo porte predefinite) | false |
| `--capabilities` | `-c` | Elenca le capacità disponibili ed esci | false |
| `--udp` | `-U` | Esegui plugin UDP | false |
| `--sctp` | `-S` | Esegui plugin SCTP (solo Linux) | false |
| `--timeout` | `-w` | Timeout in millisecondi | 2000 |
| `--verbose` | `-v` | Output verboso su stderr | false |
| `--workers` | `-W` | Worker di scansione simultanei | 50 |
| `--max-host-conn` | `-H` | Max connessioni simultanee per IP host (0=illimitato) | 0 |
| `--rate-limit` | `-R` | Max scansioni al secondo a livello globale (0=illimitato) | 0 |

### Esempi

**Target multipli:**```sh
nerva -t example.com:22,example.com:80,example.com:443

Dal file:```sh nerva -l targets.txt --json -o results.json

**UDP scanning** (potrebbe richiedere i permessi di root):```sh
sudo nerva -t example.com:53 -U
# dns://example.com:53

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

diameter://telecom-server:3868

**Modalità veloce** (solo porte predefinite):```sh
nerva -l large-target-list.txt --fast --json

Routing proxy con risoluzione DNS remota:```sh nerva -t target.internal:80 --proxy socks5://127.0.0.1:1080 --dns-order p

### Rilevamento di configurazioni errate di sicurezza

Nerva può identificare configurazioni errate di sicurezza comuni quando abilitato con `--misconfigs`:```sh
nerva -t example.com:2375 --misconfigs --json

Misconfigurazioni rilevate:

Esempio di output con misconfigurazioni:```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" } ] }

### Supporto Proxy

Nerva supporta l'instradamento del traffico di scansione attraverso proxy SOCKS5 e HTTP con risoluzione DNS configurabile.

**Schemi proxy supportati:**

- `socks5://` - Proxy SOCKS5 con risoluzione DNS locale
- `socks5h://` - Proxy SOCKS5 con risoluzione DNS lato proxy (sempre)
- `http://` - Proxy HTTP CONNECT
- `https://` - Proxy HTTPS CONNECT

**Autenticazione 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

Strategie di risoluzione DNS (--dns-order):

Nota: lo schema socks5h:// forza automaticamente la risoluzione DNS lato proxy (equivalente a --dns-order p)

Esempio di scansione 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 tramite proxy:**```sh
# UDP scanning through SOCKS5 proxy (limited support)
nerva -t target.com:161 --proxy socks5://127.0.0.1:1080 --udp

⚠️ Limitazioni UDP: Il supporto per UDP tramite SOCKS5 è limitato. Non tutti i server SOCKS5 supportano l'associazione UDP. Potrebbe verificarsi un fallback UDP locale.

Scansione parallela con limitazione della velocità:```sh nerva -l large-target-list.txt -W 100 -H 5 -R 50 -v

**Arresto graduale** (Ctrl+C restituisce risultati parziali):```sh
nerva -l huge-target-list.txt -W 50 -v
# Press Ctrl+C to stop — collected results are still printed

Protocolli Supportati

170+ plugin di rilevamento dei servizi su TCP, UDP e SCTP:

Moduli di Riconoscimento HTTP (66)

Riconoscimento della tecnologia per servizi web, organizzati per categoria:

Firewall e Sicurezza di Rete (12)

AI/LLM e Machine Learning (6)

Database e Archivi Dati (12)

DevOps e Infrastruttura (14)

Server Web e Framework (10)

Enterprise e Business (8)

Casa e IoT (2)

Altro (2)

Database (20)

Accesso Remoto (6)

Web e API (2)

Messaggistica e Code (10)

Servizi File e Directory (7)

Servizi di Rete (11)

Sistemi di Controllo Industriale (18)

Telecomunicazioni e VoIP (17)

VPN e Sicurezza (11)

Accesso Remoto e Gestione (10)

Strumenti per Sviluppatori (8)

Utilizzo della Libreria

Importa Nerva nelle tue applicazioni 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)
}

}

Vedi [examples/service-fingerprinting-example.go](https://github.com/praetorian-inc/nerva/blob/HEAD/examples/service-fingerprinting-example.go) per un esempio completo funzionante.

## Casi d'Uso

### Test di Penetrazione

Fingerprint rapidamente i servizi scoperti durante la ricognizione per identificare potenziali vettori d'attacco.

### Pipeline di Scoperta degli Asset

Combina con Naabu o Masscan per un inventario degli asset su larga scala:```sh
naabu -host 10.0.0.0/24 -silent | nerva --json | jq '.protocol'

Scansione di sicurezza CI/CD

Integra nelle pipeline di deployment per verificare che siano esposti solo i servizi previsti.

Ricognizione per Bug Bounty

Enumera rapidamente i servizi tra i target in ambito per trovare endpoint interessanti.

Analisi di reti di telecomunicazione

Identifica i nodi Diameter nelle reti LTE/5G utilizzando il trasporto SCTP (Linux):```sh nerva -t mme.telecom.local:3868 -S --json

## Architettura```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]

Perché Nerva?

vs Nmap

• Impostazioni predefinite più intelligenti: Nerva controlla prima il protocollo più probabile in base al numero di porta
• Output strutturato: Supporto nativo per JSON/CSV per un facile parsing e integrazione in pipeline
• Mirato: Solo fingerprinting del servizio — abbinalo a scanner di porte dedicati per la scoperta

vs zgrab2

• Rilevamento automatico: Nessuna necessità di specificare il protocollo in anticipo
• Utilizzo più semplice: nerva -t host:port vs echo host | zgrab2 http -p port

Risoluzione dei problemi

Nessun output

Causa: La porta è chiusa o nessun servizio supportato rilevato.

Soluzione: Verifica che la porta sia aperta:```sh nc -zv example.com 80

### Errori di timeout

**Causa**: Il timeout predefinito di 2 secondi è troppo breve per servizi lenti.

**Soluzione**: Aumentare il timeout:```sh
nerva -t example.com:80 -w 5000  # 5 seconds

Servizi UDP non rilevati

Causa: Scansione UDP disabilitata per impostazione predefinita.

Soluzione: Abilitala con il flag -U (potrebbe richiedere i permessi di root):```sh sudo nerva -t example.com:53 -U

### SCTP non funzionante

**Causa**: SCTP è supportato solo su Linux.

**Soluzione**: Eseguire su un sistema o container Linux:```sh
docker run --rm nerva -t telecom:3868 -S

Terminologia

• Servizio: Un servizio di rete in esecuzione su una porta (SSH, HTTP, PostgreSQL, ecc.)
• Fingerprinting: Rilevamento e identificazione del tipo di servizio, versione e configurazione
• Plugin: Un modulo di rilevamento specifico per protocollo
• Modalità veloce: Scansione solo della porta predefinita per ogni protocollo (ottimizzazione 80/20)
• Trasporto: Protocollo di livello rete (TCP, UDP o SCTP)

Supporto

Se trovi Nerva utile, considera di dargli una stella:

Contribuire

Accogliamo con favore i contributi! Vedi CONTRIBUTING.md per le linee guida.

Licenza

Apache 2.0 — vedi LICENSE per i dettagli.

Riconoscimenti

Nerva è un fork mantenuto di fingerprintx, originariamente sviluppato dalla classe di stagisti di Praetorian del 2022:

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