Nerva
_{Nerva: CLI veloce per il fingerprinting dei servizi}

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

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

Nerva rileva e identifica rapidamente i servizi in esecuzione sulle porte di rete aperte. Usalo insieme a scanner di porte come Naabu per fare fingerprinting dei servizi individuati, oppure integralo nelle tue pipeline di sicurezza per la ricognizione automatizzata.

Funzionalità

• Oltre 170 plugin di protocollo — Database, accesso remoto, servizi web, messaggistica, protocolli industriali e di telecomunicazioni
• 76 fingerprinter HTTP — Rileva tecnologie web tra cui firewall, database, server AI/LLM e altro ancora
• Rilevamento di misconfigurazioni 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 avanzati — Estrae versioni, configurazioni e dettagli rilevanti per la sicurezza da ciascun servizio
• Modalità veloce — Scansiona solo le porte predefinite per una ricognizione rapida (--fast)
• Output flessibile — Formati JSON, CSV o leggibile dall'uomo
• Compatibile con le pipeline — Riceve input da Naabu, Nmap o qualsiasi strumento che restituisce host:port
• Libreria Go — Importabile direttamente nelle tue applicazioni Go

Installazione

Release

Scarica un binario precompilato dalla pagina Releases.

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

Impronta 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

Il riferimento completo — ogni sottocomando, alias e flag, inclusi quelli nascosti da --help — è generato in docs/CLI.md.

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

### 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

**Scansione UDP** (potrebbe richiedere i privilegi 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 di sicurezza errate

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

Misconfigurazioni rilevate:

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

⚠️ Limitazioni UDP: UDP attraverso SOCKS5 ha un supporto 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 controllato** (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

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

Moduli di Fingerprinting HTTP (66)

Rilevamento tecnologico per servizi web, organizzati per categoria:

Firewall e Sicurezza di Rete (12)

AI/LLM e Machine Learning (6)

Database e Data Store (12)

DevOps e Infrastruttura (14)

Server Web e Framework (10)

Enterprise e Business (8)

Domestico e IoT (2)

Altro (2)

Database (20)

Accesso Remoto (6)

Web e API (2)

Messaggistica e Code (10)

Servizi di 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/main/examples/service-fingerprinting-example.go) per un esempio completo funzionante.

## Casi d'uso

### Penetration Testing

Identificare rapidamente i servizi scoperti durante la ricognizione per individuare potenziali vettori di attacco.

### Pipeline di Asset Discovery

Combina con Naabu o Masscan per un inventario di 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 sui target in scope per trovare endpoint interessanti.

Analisi di Reti di Telecomunicazioni

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

• Default più intelligenti: Nerva controlla prima il protocollo più probabile in base al numero di porta
• Output strutturato: Supporto nativo JSON/CSV per un facile parsing e integrazione nelle pipeline
• Focalizzato: Solo fingerprinting dei servizi — abbinalo a scanner di porte dedicati per la discovery

vs zgrab2

• Rilevamento automatico: Non è necessario 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 non è stato rilevato alcun servizio supportato.

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

### Errori di timeout

**Causa**: 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: abilitare con il flag -U (potrebbe richiedere i privilegi di root):```sh sudo nerva -t example.com:53 -U

### SCTP non funzionante

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

**Soluzione**: Esegui 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
• Fast Mode: Scansione solo della porta predefinita per ciascun protocollo (ottimizzazione 80/20)
• Transport: Protocollo a livello di rete (TCP, UDP o SCTP)

Supporto

Se trovi Nerva utile, considera di assegnargli una stella:

Contribuire

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

Licenza

Apache 2.0 — consulta LICENSE per i dettagli.

Riconoscimenti

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

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