Nerva
_{Nerva: Schnelle CLI für Dienst-Fingerprinting}

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

Hochleistungsfähiges Dienst-Fingerprinting, geschrieben in Go. Identifiziert über 170 Netzwerkprotokolle über TCP-, UDP- und SCTP-Transporte mit umfangreicher Metadatenextraktion.

Nerva erkennt und identifiziert schnell Dienste, die auf offenen Netzwerk-Ports laufen. Verwenden Sie es zusammen mit Port-Scannern wie Naabu, um entdeckte Dienste zu fingerprinten, oder integrieren Sie es in Ihre Sicherheits-Pipelines für automatisierte Erkundung.

Funktionen

• 170+ Protokoll-Plugins — Datenbanken, Remote-Zugriff, Webdienste, Messaging, Industrie- und Telekommunikationsprotokolle
• 76 HTTP-Fingerprint-Tools — Erkennung von Web-Technologien einschließlich Firewalls, Datenbanken, AI/LLM-Servern und mehr
• Erkennung von Sicherheitsfehlkonfigurationen — Identifiziert häufige Sicherheitsprobleme wie nicht authentifizierte APIs und Klartext-Protokolle (--misconfigs)
• Unterstützung mehrerer Transportschichten — TCP (Standard), UDP (--udp) und SCTP (--sctp, nur Linux)
• Proxy-Unterstützung — Leitet Scan-Traffic transparent über SOCKS5- oder HTTP-Proxys mit konfigurierbarer DNS-Auflösung
• Umfangreiche Metadaten — Extrahiert Versionen, Konfigurationen und sicherheitsrelevante Details aus jedem Dienst
• Schnellmodus — Scannt nur Standard-Ports für schnelle Erkundung (--fast)
• Flexible Ausgabe — JSON, CSV oder menschenlesbare Formate
• Pipeline-freundlich — Einlesen von Naabu, Nmap oder jedem Tool, das host:port ausgibt
• Go-Bibliothek — Direkter Import in Ihre Go-Anwendungen

Installation

Veröffentlichungen

Laden Sie ein vorgefertigtes Binärprogramm von der Seite Veröffentlichungen herunter.

Von GitHub```sh

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

### Aus dem Quellcode```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

Ein einzelnes Ziel fingerprinten:```sh
nerva -t example.com:22
# ssh://example.com:22

Holen Sie detaillierte JSON-Metadaten:```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 Port-Scanner:```sh
naabu -host example.com -silent | nerva
# http://example.com:80
# ssh://example.com:22
# https://example.com:443

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

### Flags

| Flag | Short | Beschreibung | Standard |
|------|-------|--------------|----------|
| `--targets` | `-t` | Ziel oder durch Komma getrennte Zielliste | — |
| `--list` | `-l` | Eingabedatei mit Zielen | — |
| `--output` | `-o` | Ausgabedateipfad | stdout |
| `--json` | | Ausgabe im JSON-Format | false |
| `--csv` | | Ausgabe im CSV-Format | false |
| `--misconfigs` | | Sicherheitskonfigurationserkennung aktivieren | false |
| `--proxy` | | Proxy-URL (z.B. socks5://127.0.0.1:1080) | — |
| `--proxy-auth` | | SOCKS5-Proxy-Authentifizierung (z.B. Benutzername:Passwort) | — |
| `--dns-order` | | DNS-Auflösungsreihenfolge: `p`, `l`, `lp`, `pl` | `lp` |
| `--fast` | `-f` | Schnellmodus (nur Standard-Ports) | false |
| `--capabilities` | `-c` | Verfügbare Fähigkeiten auflisten und beenden | false |
| `--udp` | `-U` | UDP-Plugins ausführen | false |
| `--sctp` | `-S` | SCTP-Plugins ausführen (nur Linux) | false |
| `--timeout` | `-w` | Timeout in Millisekunden | 2000 |
| `--verbose` | `-v` | Ausführliche Ausgabe auf stderr | false |
| `--workers` | `-W` | Gleichzeitige Scan-Arbeiter | 50 |
| `--max-host-conn` | `-H` | Maximale gleichzeitige Verbindungen pro Host-IP (0=unbegrenzt) | 0 |
| `--rate-limit` | `-R` | Maximale Scans pro Sekunde global (0=unbegrenzt) | 0 |

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

**Schnellmodus** (nur Standardports):```sh
nerva -l large-target-list.txt --fast --json

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

### Erkennung von Sicherheitsfehlkonfigurationen

Nerva kann häufige Sicherheitsfehlkonfigurationen erkennen, 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 die Weiterleitung von Scan-Verkehr durch 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: socks5h://-Schema erzwingt automatisch Proxy-seitige DNS (äquivalent zu --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. Lokaler UDP-Fallback kann auftreten.

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

**Sanftes Herunterfahren** (Ctrl+C gibt 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

170+ Serviceerkennungs-Plugins über TCP, UDP und SCTP:

HTTP-Fingerprint-Module (66)

Technologieerkennung für Webdienste, nach Kategorie organisiert:

Firewalls & Netzwerksicherheit (12)

AI/LLM & Maschinelles Lernen (6)

Datenbanken & Datenspeicher (12)

DevOps & Infrastruktur (14)

Webserver & Frameworks (10)

Unternehmen & Geschäft (8)

Haus & IoT (2)

Sonstige (2)

Datenbanken (20)

Fernzugriff (6)

Web & API (2)

Messaging & Queues (10)

Datei- & Verzeichnisdienste (7)

Netzwerkdienste (11)

Industrielle Steuerungssysteme (18)

Telekommunikation & VoIP (17)

VPN & Sicherheit (11)

Fernzugriff & Verwaltung (10)

Entwicklerwerkzeuge (8)

Bibliotheksnutzung

Importieren Sie Nerva in Ihre 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/HEAD/examples/service-fingerprinting-example.go) für ein vollständiges funktionierendes Beispiel.

## Anwendungsfälle

### Penetrationstests

Fingerabdrücke von Diensten, die während der Aufklärung entdeckt wurden, schnell erstellen, um potenzielle Angriffsvektoren zu identifizieren.

### Asset Discovery Pipelines

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

CI/CD-Sicherheitsscanning

In Bereitstellungspipelines integrieren, um zu überprüfen, dass nur erwartete Dienste exponiert sind.

Bug-Bounty-Aufklärung

Dienste schnell über Zielbereiche hinweg aufzählen, um interessante Endpunkte zu finden.

Telekommunikationsnetzwerkanalyse

Fingerabdruck von Diameter-Knoten in LTE/5G-Netzen mittels SCTP-Transport (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 überprüft zuerst das wahrscheinlichste Protokoll 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: Keine vorherige Angabe des Protokolls erforderlich
• Einfachere Nutzung: nerva -t host:port vs echo host | zgrab2 http -p port

Fehlerbehebung

Keine Ausgabe

Ursache: Port ist geschlossen oder 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 standardmäßig deaktiviert.

Lösung: Aktivieren mit dem Flag -U (erfordert möglicherweise Root-Rechte):```sh sudo nerva -t example.com:53 -U

### SCTP funktioniert nicht

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

**Lösung**: Führen Sie es auf einem Linux-System oder in einem Container aus:```sh
docker run --rm nerva -t telecom:3868 -S

Terminologie

• Dienst: Ein Netzwerkdienst, der auf einem Port läuft (SSH, HTTP, PostgreSQL, usw.)
• Fingerprinting: Erkennung und Identifizierung des Diensttyps, der Version und der Konfiguration
• Plugin: Ein protokollspezifisches Erkennungsmodul
• Schnellmodus: Scan nur der Standardports für jedes Protokoll (80/20-Optimierung)
• Transport: Netzwerkschichtprotokoll (TCP, UDP oder SCTP)

Unterstützung

Wenn Sie Nerva nützlich finden, erwägen Sie bitte, einen Stern zu vergeben:

Mitwirken

Wir begrüßen 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