Nerva
_{Nerva : CLI rapide d'empreinte de services}

Fonctionnalités • Installation • Démarrage rapide • Utilisation • Protocoles • Bibliothèque • Cas d'usage • Dépannage

Empreinte de services haute performance écrite en Go. Identifiez plus de 170 protocoles réseau sur les transports TCP, UDP et SCTP avec une extraction riche de métadonnées.

Nerva détecte et identifie rapidement les services s'exécutant sur des ports réseau ouverts. Utilisez-le en complément de scanners de ports comme Naabu pour établir l'empreinte des services découverts, ou intégrez-le dans vos pipelines de sécurité pour une reconnaissance automatisée.

Fonctionnalités

• Plus de 170 plugins de protocoles — Bases de données, accès distant, services web, messagerie, protocoles industriels et télécoms
• 76 empreinteurs HTTP — Détectez les technologies web, notamment les pare-feu, les bases de données, les serveurs IA/LLM, et plus encore
• Détection des mauvaises configurations de sécurité — Identifiez les problèmes de sécurité courants comme les API non authentifiées et les protocoles en clair (--misconfigs)
• Prise en charge multi-transport — TCP (par défaut), UDP (--udp) et SCTP (--sctp, Linux uniquement)
• Prise en charge des proxys — Acheminez le trafic de scan de manière transparente via des proxys SOCKS5 ou HTTP avec résolution DNS configurable
• Métadonnées riches — Extrayez les versions, les configurations et les détails pertinents pour la sécurité de chaque service
• Mode rapide — Scannez uniquement les ports par défaut pour une reconnaissance rapide (--fast)
• Sortie flexible — Formats JSON, CSV ou lisible par l'humain
• Compatible avec les pipelines — Recevez les données de Naabu, Nmap ou tout outil produisant host:port
• Bibliothèque Go — Importez directement dans vos applications Go

Installation

Releases

Téléchargez un binaire précompilé depuis la page Releases.

Depuis GitHub```sh

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

### Depuis la source```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

## Démarrage rapide

Empreinte d'une cible unique :```sh
nerva -t example.com:22
# ssh://example.com:22

Obtenir des métadonnées JSON détaillées :```sh nerva -t example.com:22 --json

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

Pipe depuis un scanner de ports :```sh
naabu -host example.com -silent | nerva
# http://example.com:80
# ssh://example.com:22
# https://example.com:443

La référence complète — chaque sous-commande, alias et option, y compris ceux masqués de --help — est générée dans docs/CLI.md.

Utilisation```

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

### Exemples

**Cibles multiples :**```sh
nerva -t example.com:22,example.com:80,example.com:443

Depuis le fichier :```sh nerva -l targets.txt --json -o results.json

**Scan UDP** (peut nécessiter les droits root) :```sh
sudo nerva -t example.com:53 -U
# dns://example.com:53

Scan SCTP (Linux uniquement) :```sh nerva -t telecom-server:3868 -S

diameter://telecom-server:3868

**Mode rapide** (ports par défaut uniquement) :```sh
nerva -l large-target-list.txt --fast --json

Routage proxy avec résolution DNS distante :```sh nerva -t target.internal:80 --proxy socks5://127.0.0.1:1080 --dns-order p

### Détection des erreurs de configuration de sécurité

Nerva peut identifier les erreurs de configuration de sécurité courantes lorsqu'il est activé avec `--misconfigs` :```sh
nerva -t example.com:2375 --misconfigs --json

Mauvaises configurations détectées :

Exemple de sortie avec mauvaises configurations :```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" } ] }

### Prise en charge des proxys

Nerva prend en charge le routage du trafic de scan via des proxys SOCKS5 et HTTP avec une résolution DNS configurable.

**Schémas de proxy pris en charge :**

- `socks5://` - proxy SOCKS5 avec résolution DNS locale
- `socks5h://` - proxy SOCKS5 avec résolution DNS côté proxy (toujours)
- `http://` - proxy HTTP CONNECT
- `https://` - proxy HTTPS CONNECT

**Authentification par 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

Stratégies de résolution DNS (--dns-order) :

Remarque : le schéma socks5h:// force automatiquement le DNS côté proxy (équivalent à --dns-order p)

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

⚠️ Limitations UDP : UDP via SOCKS5 dispose d'une prise en charge limitée. Tous les serveurs SOCKS5 ne prennent pas en charge l'association UDP. Un repli UDP local peut se produire.

Analyse parallèle avec limitation de débit :```sh nerva -l large-target-list.txt -W 100 -H 5 -R 50 -v

**Arrêt gracieux** (Ctrl+C renvoie les résultats partiels) :```sh
nerva -l huge-target-list.txt -W 50 -v
# Press Ctrl+C to stop — collected results are still printed

Protocoles pris en charge

Plus de 170 plugins de détection de services sur TCP, UDP et SCTP :

Modules d'empreinte HTTP (66)

Détection de technologies pour les services web, organisée par catégorie :

Pare-feu et sécurité réseau (12)

IA/LLM et apprentissage automatique (6)

Bases de données et magasins de données (12)

DevOps et infrastructure (14)

Serveurs web et frameworks (10)

Entreprise et business (8)

Domotique et IoT (2)

Autres (2)

Bases de données (20)

Accès à distance (6)

Web et API (2)

Messagerie et files d'attente (10)

Services de fichiers et d'annuaires (7)

Services réseau (11)

Systèmes de contrôle industriels (18)

Télécoms et VoIP (17)

VPN et sécurité (11)

Accès à distance et gestion (10)

Outils de développement (8)

Utilisation de la bibliothèque

Importez Nerva dans vos applications 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)
}

}

Voir [examples/service-fingerprinting-example.go](https://github.com/praetorian-inc/nerva/blob/main/examples/service-fingerprinting-example.go) pour un exemple complet et fonctionnel.

## Cas d'utilisation

### Tests d'intrusion

Identifier rapidement les services découverts lors de la reconnaissance afin de repérer les vecteurs d'attaque potentiels.

### Pipelines de découverte d'actifs

Combinez avec Naabu ou Masscan pour un inventaire d'actifs à grande échelle :```sh
naabu -host 10.0.0.0/24 -silent | nerva --json | jq '.protocol'

Analyse de sécurité CI/CD

Intégrez-le dans les pipelines de déploiement pour vérifier que seuls les services attendus sont exposés.

Reconnaissance pour bug bounty

Énumérez rapidement les services sur les cibles du périmètre pour trouver des points de terminaison intéressants.

Analyse de réseaux télécoms

Identifiez les nœuds Diameter dans les réseaux LTE/5G en utilisant le transport SCTP (Linux) :```sh nerva -t mme.telecom.local:3868 -S --json

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

Pourquoi Nerva ?

vs Nmap

• Des valeurs par défaut plus intelligentes : Nerva vérifie d'abord le protocole le plus probable en fonction du numéro de port
• Sortie structurée : Prise en charge native de JSON/CSV pour un parsing facile et une intégration dans des pipelines
• Ciblé : Empreinte de service uniquement — à associer avec des scanners de ports dédiés pour la découverte

vs zgrab2

• Détection automatique : Pas besoin de spécifier le protocole à l'avance
• Utilisation plus simple : nerva -t host:port vs echo host | zgrab2 http -p port

Dépannage

Aucune sortie

Cause : Le port est fermé ou aucun service pris en charge n'a été détecté.

Solution : Vérifiez que le port est ouvert :```sh nc -zv example.com 80

### Erreurs de délai d'attente

**Cause** : Délai d'attente par défaut de 2 secondes trop court pour les services lents.

**Solution** : Augmenter le délai d'attente :```sh
nerva -t example.com:80 -w 5000  # 5 seconds

Services UDP non détectés

Cause : analyse UDP désactivée par défaut.

Solution : Activer avec l'option -U (peut nécessiter les droits root) :```sh sudo nerva -t example.com:53 -U

### SCTP ne fonctionne pas

**Cause** : SCTP n'est pris en charge que sur Linux.

**Solution** : Exécutez sur un système Linux ou dans un conteneur :```sh
docker run --rm nerva -t telecom:3868 -S

Terminologie

• Service : Un service réseau s'exécutant sur un port (SSH, HTTP, PostgreSQL, etc.)
• Fingerprinting : Détection et identification du type de service, de la version et de la configuration
• Plugin : Un module de détection spécifique à un protocole
• Fast Mode : Analyse uniquement du port par défaut pour chaque protocole (optimisation 80/20)
• Transport : Protocole de couche réseau (TCP, UDP ou SCTP)

Support

Si vous trouvez Nerva utile, pensez à lui attribuer une étoile :

Contribution

Nous accueillons les contributions ! Consultez CONTRIBUTING.md pour les directives.

Licence

Apache 2.0 — voir LICENSE pour plus de détails.

Remerciements

Nerva est un fork maintenu de fingerprintx, développé à l'origine par la promotion de stagiaires 2022 de Praetorian :

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