Nerva
_{Nerva: Schnelles Service-Fingerprinting-CLI}

Funktionen • Installation • Schnellstart • Verwendung • Protokolle • Bibliothek • Anwendungsfälle • Fehlerbehebung

Hochperformantes Service-Fingerprinting in Go. Identifizieren Sie über 170 Netzwerkprotokolle über TCP-, UDP- und SCTP-Transporte mit umfangreicher Metadatenextraktion.

Nerva erkennt und identifiziert schnell Dienste, die auf offenen Netzwerkports laufen. Verwenden Sie es zusammen mit Portscannern wie Naabu, um entdeckte Dienste zu fingerprinten, oder integrieren Sie es in Ihre Sicherheitspipelines für automatisierte Aufklärung.

Funktionen

• Über 170 Protokoll-Plugins — Datenbanken, Fernzugriff, Webdienste, Messaging, industrielle und Telekommunikationsprotokolle
• 76 HTTP-Fingerprinter — Erkennung von Webtechnologien einschließlich Firewalls, Datenbanken, KI/LLM-Servern und mehr
• Erkennung von Sicherheitsfehlkonfigurationen — Identifizierung häufiger Sicherheitsprobleme wie nicht authentifizierte APIs und Klartextprotokolle (--misconfigs)
• Unterstützung mehrerer Transporte — TCP (Standard), UDP (--udp) und SCTP (--sctp, nur Linux)
• Proxy-Unterstützung — Scannen Sie Datenverkehr transparent über SOCKS5- oder HTTP-Proxys mit konfigurierbarer DNS-Auflösung
• Umfangreiche Metadaten — Extrahieren Sie Versionen, Konfigurationen und sicherheitsrelevante Details aus jedem Dienst
• Schnellmodus — Scannen Sie nur Standardports für eine schnelle Aufklärung (--fast)
• Flexible Ausgabe — JSON-, CSV- oder menschenlesbare Formate
• Pipeline-freundlich — Pipe von Naabu, Nmap oder jedem Tool, das host:port ausgibt
• Go-Bibliothek — Direkt in Ihre Go-Anwendungen importierbar

Installation

Releases

Laden Sie eine vorgefertigte Binärdatei von der Releases-Seite herunter.

Von GitHub```sh

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

### Aus der Quelle```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

## Schnellstart

Einen einzelnen Host fingerprinten:```sh
nerva -t example.com:22
# ssh://example.com:22

Detaillierte JSON-Metadaten abrufen:```sh nerva -t example.com:22 --json

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

Pipe von einem Portscanner:```sh
naabu -host example.com -silent | nerva
# http://example.com:80
# ssh://example.com:22
# https://example.com:443

Die vollständige Referenz — jeder Unterbefehl, Alias und jedes Flag, einschließlich der in --help verborgenen — wird in docs/CLI.md generiert.

Verwendung```

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

### Beispiele

**Mehrere Ziele:**```sh
nerva -t example.com:22,example.com:80,example.com:443

Aus Datei:```sh nerva -l targets.txt --json -o results.json

**UDP-Scanning** (erfordert möglicherweise Root):```sh
sudo nerva -t example.com:53 -U
# dns://example.com:53

SCTP-Scanning (nur Linux):```sh nerva -t telecom-server:3868 -S

diameter://telecom-server:3868

**Schneller Modus** (nur Standard-Ports):```sh
nerva -l large-target-list.txt --fast --json

Proxy-Routing mit Remote-DNS-Auflösung:```sh nerva -t target.internal:80 --proxy socks5://127.0.0.1:1080 --dns-order p

### Erkennung von Sicherheitsfehlkonfigurationen

Nerva kann gängige Sicherheitsfehlkonfigurationen identifizieren, wenn es mit `--misconfigs` aktiviert wird:```sh
nerva -t example.com:2375 --misconfigs --json

Erkannte Fehlkonfigurationen:

Beispielausgabe mit Fehlkonfigurationen:```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" } ] }

### Proxy-Unterstützung

Nerva unterstützt das Routing von Scan-Verkehr über SOCKS5- und HTTP-Proxys mit konfigurierbarer DNS-Auflösung.

**Unterstützte Proxy-Schemata:**

- `socks5://` - SOCKS5-Proxy mit lokaler DNS-Auflösung
- `socks5h://` - SOCKS5-Proxy mit proxyseitiger DNS-Auflösung (immer)
- `http://` - HTTP-CONNECT-Proxy
- `https://` - HTTPS-CONNECT-Proxy

**Proxy-Authentifizierung:**```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

DNS-Auflösungsstrategien (--dns-order):

Hinweis: Das Schema socks5h:// erzwingt automatisch DNS über den Proxy (entspricht --dns-order p)

Tor-Scan-Beispiel:```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 über Proxy:**```sh
# UDP scanning through SOCKS5 proxy (limited support)
nerva -t target.com:161 --proxy socks5://127.0.0.1:1080 --udp

⚠️ UDP-Einschränkungen: UDP über SOCKS5 wird nur eingeschränkt unterstützt. Nicht alle SOCKS5-Server unterstützen UDP-Assoziation. Ein lokaler UDP-Fallback kann auftreten.

Paralleles Scannen mit Ratenbegrenzung:```sh nerva -l large-target-list.txt -W 100 -H 5 -R 50 -v

**Graceful Shutdown** (Strg+C liefert Teilergebnisse zurück):```sh
nerva -l huge-target-list.txt -W 50 -v
# Press Ctrl+C to stop — collected results are still printed

Unterstützte Protokolle

Über 170 Service-Erkennungs-Plugins für TCP, UDP und SCTP:

HTTP-Fingerprint-Module (66)

Technologie-Erkennung für Webdienste, organisiert nach Kategorien:

Firewalls & Netzwerksicherheit (12)

KI/LLM & Maschinelles Lernen (6)

Datenbanken & Datenspeicher (12)

DevOps & Infrastruktur (14)

Webserver & Frameworks (10)

Enterprise & Business (8)

Home & IoT (2)

Sonstige (2)

Datenbanken (20)

Fernzugriff (6)

Web & API (2)

Messaging & Warteschlangen (10)

Datei- & Verzeichnisdienste (7)

Netzwerkdienste (11)

Industrielle Steuerungssysteme (18)

Telekommunikation & VoIP (17)

VPN & Sicherheit (11)

Fernzugriff & -verwaltung (10)

Entwicklerwerkzeuge (8)

Bibliotheksnutzung

Importiere Nerva in deine Go-Anwendungen:```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)
}

}

Siehe [examples/service-fingerprinting-example.go](https://github.com/praetorian-inc/nerva/blob/main/examples/service-fingerprinting-example.go) für ein vollständiges funktionierendes Beispiel.

## Anwendungsfälle

### Penetrationstests

Fingerprinting von Diensten, die während der Aufklärung entdeckt wurden, um potenzielle Angriffsvektoren schnell zu identifizieren.

### Asset-Discovery-Pipelines

Kombinieren Sie es mit Naabu oder Masscan für eine groß angelegte Asset-Inventarisierung:```sh
naabu -host 10.0.0.0/24 -silent | nerva --json | jq '.protocol'

CI/CD-Sicherheitsscans

In Deployment-Pipelines integrieren, um zu überprüfen, dass nur erwartete Dienste exponiert sind.

Bug-Bounty-Aufklärung

Dienste über Scope-Ziele hinweg schnell enumerieren, um interessante Endpunkte zu finden.

Telekommunikationsnetzwerkanalyse

Diameter-Knoten in LTE/5G-Netzen mittels SCTP-Transport fingerprinten (Linux):```sh nerva -t mme.telecom.local:3868 -S --json

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

Warum Nerva?

vs Nmap

• Intelligentere Standardeinstellungen: Nerva prüft das wahrscheinlichste Protokoll zuerst basierend auf der Portnummer
• Strukturierte Ausgabe: Native JSON/CSV-Unterstützung für einfaches Parsen und Pipeline-Integration
• Fokussiert: Nur Service-Fingerprinting — kombinieren Sie es mit dedizierten Port-Scannern für die Erkennung

vs zgrab2

• Automatische Erkennung: Kein Protokoll muss im Voraus angegeben werden
• Einfachere Verwendung: nerva -t host:port vs echo host | zgrab2 http -p port

Fehlerbehebung

Keine Ausgabe

Ursache: Der Port ist geschlossen oder es wurde kein unterstützter Dienst erkannt.

Lösung: Überprüfen Sie, ob der Port geöffnet ist:```sh nc -zv example.com 80

### Timeout-Fehler

**Ursache**: Standard-Timeout von 2 Sekunden zu kurz für langsame Dienste.

**Lösung**: Timeout erhöhen:```sh
nerva -t example.com:80 -w 5000  # 5 seconds

UDP-Dienste nicht erkannt

Ursache: UDP-Scanning ist standardmäßig deaktiviert.

Lösung: Mit dem -U-Flag aktivieren (erfordert möglicherweise root):```sh sudo nerva -t example.com:53 -U

### SCTP funktioniert nicht

**Ursache**: SCTP wird nur unter Linux unterstützt.

**Lösung**: Auf einem Linux-System oder in einem Container ausführen:```sh
docker run --rm nerva -t telecom:3868 -S

Terminologie

• Dienst: Ein Netzwerkdienst, der auf einem Port läuft (SSH, HTTP, PostgreSQL usw.)
• Fingerprinting: Erkennen und Identifizieren von Diensttyp, Version und Konfiguration
• Plugin: Ein protokollspezifisches Erkennungsmodul
• Fast Mode: Scannen nur des Standardports für jedes Protokoll (80/20-Optimierung)
• Transport: Netzwerkschichtprotokoll (TCP, UDP oder SCTP)

Unterstützung

Wenn Sie Nerva nützlich finden, ziehen Sie bitte in Betracht, ihm einen Stern zu geben:

Mitwirken

Wir freuen uns über Beiträge! Siehe CONTRIBUTING.md für Richtlinien.

Lizenz

Apache 2.0 — siehe LICENSE für Details.

Danksagungen

Nerva ist ein gepflegter Fork von fingerprintx, ursprünglich entwickelt von Praetorians Praktikantenklasse von 2022:

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