Nerva
_{Nerva : CLI Rapide d'Empreinte de Services}

Fonctionnalités • Installation • Démarrage rapide • Utilisation • Protocoles • Bibliothèque • Cas d'utilisation • 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 aux côtés de scanners de ports comme Naabu pour prendre l'empreinte des services découverts, ou intégrez-le dans vos pipelines de sécurité pour une reconnaissance automatisée.

Fonctionnalités

• 170+ Plugins de protocole — Bases de données, accès distant, services web, messagerie, protocoles industriels et de télécommunication
• 76 Empreintes HTTP — Détectez les technologies web incluant pare-feux, bases de données, serveurs IA/LLM, et plus
• Détection de 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)
• Support multi-transport — TCP (par défaut), UDP (--udp), et SCTP (--sctp, Linux uniquement)
• Support proxy — 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 versions, configurations et 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 lisibles par l'humain
• Adapté aux pipelines — Alimentez depuis Naabu, Nmap ou tout outil qui produit host:port
• Bibliothèque Go — Importez directement dans vos applications Go

Installation

Releases

Téléchargez un binaire précompilé depuis la page des 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

Obtenez 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

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

### Flags

| Flag | Court | Description | Défaut |
|------|-------|-------------|---------|
| `--targets` | `-t` | Cible ou liste de cibles séparées par des virgules | — |
| `--list` | `-l` | Fichier d'entrée contenant les cibles | — |
| `--output` | `-o` | Chemin du fichier de sortie | stdout |
| `--json` | | Sortie au format JSON | false |
| `--csv` | | Sortie au format CSV | false |
| `--misconfigs` | | Activer la détection de mauvaise configuration de sécurité | false |
| `--proxy` | | URL du proxy (p. ex. socks5://127.0.0.1:1080) | — |
| `--proxy-auth` | | Authentification proxy SOCKS5 (p. ex. username:password) | — |
| `--dns-order` | | Ordre de résolution DNS : `p`, `l`, `lp`, `pl` | `lp` |
| `--fast` | `-f` | Mode rapide (ports par défaut uniquement) | false |
| `--capabilities` | `-c` | Capacités disponibles et sortie | false |
| `--udp` | `-U` | Exécuter les plugins UDP | false |
| `--sctp` | `-S` | Exécuter les plugins SCTP (Linux uniquement) | false |
| `--timeout` | `-w` | Délai d'attente en millisecondes | 2000 |
| `--verbose` | `-v` | Sortie détaillée vers stderr | false |
| `--workers` | `-W` | Travailleurs de scan simultanés | 50 |
| `--max-host-conn` | `-H` | Nombre max de connexions simultanées par IP hôte (0=illimité) | 0 |
| `--rate-limit` | `-R` | Nombre max de scans par seconde globalement (0=illimité) | 0 |

### 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'elle est activée 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 du 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 la résolution DNS côté proxy (équivalent à --dns-order p)

Exemple de scan via 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 : L'UDP via SOCKS5 bénéficie d'un support limité. Tous les serveurs SOCKS5 ne prennent pas en charge l'association UDP. Un repli local UDP peut se produire.

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

**Arrêt en douceur** (Ctrl+C retourne 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

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

Modules d'empreinte HTTP (66)

Détection de technologies pour 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 stockages de données (12)

DevOps et Infrastructure (14)

Serveurs web et frameworks (10)

Entreprise et Business (8)

Maison 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 répertoires (7)

Services réseau (11)

Systèmes de contrôle industriel (18)

Télécom et VoIP (17)

VPN et Sécurité (11)

Accès à distance et Gestion (10)

Outils pour développeurs (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/HEAD/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 pour trouver des vecteurs d'attaque potentiels.

### Pipelines de découverte d'actifs

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

Scan de sécurité CI/CD

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

Reconnaissance Bug Bounty

Énumérer rapidement les services sur les cibles dans le périmètre pour trouver des points d'accès intéressants.

Analyse des réseaux de télécommunications

Empreintes des 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

• Paramètres par défaut plus intelligents : Nerva vérifie d'abord le protocole le plus probable en fonction du numéro de port
• Sortie structurée : Support natif JSON/CSV pour un parsing facile et une intégration dans les pipelines
• Ciblé : Reconnaissance de services 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 supporté n'est détecté.

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

### Erreurs de timeout

**Cause**: Le timeout par défaut de 2 secondes est trop court pour les services lents.

**Solution**: Augmentez le timeout :```sh
nerva -t example.com:80 -w 5000  # 5 seconds

Services UDP non détectés

Cause: Le scan UDP est désactivé 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 est uniquement pris en charge sur Linux.

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

Terminologie

• Service : Service réseau s'exécutant sur un port (SSH, HTTP, PostgreSQL, etc.)
• Empreinte numérique : Détection et identification du type de service, de sa version et de sa configuration
• Plugin : Module de détection spécifique à un protocole
• Mode rapide : 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, merci de lui accorder une étoile :

Contribuer

Les contributions sont les bienvenues ! Voir CONTRIBUTING.md pour les directives.

Licence

Apache 2.0 — Voir LICENSE pour les détails.

Remerciements

Nerva est un fork maintenu de fingerprintx, initialement développé par la promotion stagiaire 2022 de Praetorian :

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