Nerva
_{Nerva: तेज़ सेवा फ़िंगरप्रिंटिंग CLI}

सुविधाएँ • स्थापना • त्वरित आरंभ • उपयोग • प्रोटोकॉल • लाइब्रेरी • उपयोग के मामले • समस्या निवारण

Go में लिखा गया उच्च-प्रदर्शन सेवा फ़िंगरप्रिंटिंग। TCP, UDP और SCTP ट्रांसपोर्ट पर समृद्ध मेटाडेटा निष्कर्षण के साथ 170+ नेटवर्क प्रोटोकॉल की पहचान करें।

Nerva खुले नेटवर्क पोर्ट पर चल रही सेवाओं का तेज़ी से पता लगाता है और पहचान करता है। खोजी गई सेवाओं की फ़िंगरप्रिंटिंग के लिए इसे पोर्ट स्कैनर जैसे Naabu के साथ उपयोग करें, या स्वचालित टोही के लिए अपनी सुरक्षा पाइपलाइनों में एकीकृत करें।

सुविधाएँ

• 170+ प्रोटोकॉल प्लगइन्स — डेटाबेस, दूरस्थ पहुँच, वेब सेवाएँ, मैसेजिंग, औद्योगिक और दूरसंचार प्रोटोकॉल
• 76 HTTP फ़िंगरप्रिंटर — फ़ायरवॉल, डेटाबेस, AI/LLM सर्वर और अधिक सहित वेब तकनीकों का पता लगाएँ
• सुरक्षा गलत कॉन्फ़िगरेशन का पता लगाना — अनप्रमाणित APIs और क्लियरटेक्स्ट प्रोटोकॉल जैसी सामान्य सुरक्षा समस्याओं की पहचान करें (--misconfigs)
• मल्टी-ट्रांसपोर्ट समर्थन — TCP (डिफ़ॉल्ट), UDP (--udp), और SCTP (--sctp, केवल Linux)
• प्रॉक्सी समर्थन — कॉन्फ़िगरेबल DNS रिज़ॉल्यूशन के साथ SOCKS5 या HTTP प्रॉक्सी के माध्यम से स्कैनिंग ट्रैफ़िक को पारदर्शी रूप से रूट करें
• समृद्ध मेटाडेटा — प्रत्येक सेवा से संस्करण, कॉन्फ़िगरेशन और सुरक्षा-प्रासंगिक विवरण निकालें
• फ़ास्ट मोड — तीव्र टोही के लिए केवल डिफ़ॉल्ट पोर्ट स्कैन करें (--fast)
• लचीला आउटपुट — JSON, CSV या मानव-पठनीय प्रारूप
• पाइपलाइन-अनुकूल — Naabu, Nmap या किसी भी उपकरण से पाइप करें जो host:port आउटपुट करता है
• Go लाइब्रेरी — अपने Go अनुप्रयोगों में सीधे आयात करें

स्थापना

रिलीज़

रिलीज़ पृष्ठ से पूर्व-निर्मित बाइनरी डाउनलोड करें।

GitHub से```sh

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

### स्रोत से```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

## त्वरित आरंभ

एकल लक्ष्य का फिंगरप्रिंट लें:```sh
nerva -t example.com:22
# ssh://example.com:22

विस्तृत JSON मेटाडेटा प्राप्त करें:```sh nerva -t example.com:22 --json

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

पोर्ट स्कैनर से पाइप:```sh
naabu -host example.com -silent | nerva
# http://example.com:80
# ssh://example.com:22
# https://example.com:443

उपयोग```

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

### झंडे

| झंडा | संक्षिप्त | विवरण | डिफ़ॉल्ट |
|------|-----------|--------|---------|
| `--targets` | `-t` | लक्ष्य या अल्पविराम से अलग किया गया लक्ष्य सूची | — |
| `--list` | `-l` | लक्ष्यों वाली इनपुट फ़ाइल | — |
| `--output` | `-o` | आउटपुट फ़ाइल पथ | stdout |
| `--json` | | JSON प्रारूप में आउटपुट | false |
| `--csv` | | CSV प्रारूप में आउटपुट | false |
| `--misconfigs` | | सुरक्षा गलत कॉन्फ़िगरेशन जाँच सक्षम करें | false |
| `--proxy` | | प्रॉक्सी URL (उदा. socks5://127.0.0.1:1080) | — |
| `--proxy-auth` | | SOCKS5 प्रॉक्सी प्रमाणीकरण (उदा. username:password) | — |
| `--dns-order` | | DNS रिज़ॉल्यूशन क्रम: `p`, `l`, `lp`, `pl` | `lp` |
| `--fast` | `-f` | तेज़ मोड (केवल डिफ़ॉल्ट पोर्ट) | false |
| `--capabilities` | `-c` | उपलब्ध क्षमताओं की सूची दिखाएँ और बाहर निकलें | false |
| `--udp` | `-U` | UDP प्लगइन चलाएँ | false |
| `--sctp` | `-S` | SCTP प्लगइन चलाएँ (केवल Linux) | false |
| `--timeout` | `-w` | मिलीसेकंड में टाइमआउट | 2000 |
| `--verbose` | `-v` | stderr पर विस्तृत आउटपुट | false |
| `--workers` | `-W` | समवर्ती स्कैन कर्मचारी | 50 |
| `--max-host-conn` | `-H` | प्रति होस्ट IP अधिकतम समवर्ती कनेक्शन (0=असीमित) | 0 |
| `--rate-limit` | `-R` | वैश्विक रूप से प्रति सेकंड अधिकतम स्कैन (0=असीमित) | 0 |

### उदाहरण

**एकाधिक लक्ष्य:**```sh
nerva -t example.com:22,example.com:80,example.com:443

फ़ाइल से:```sh nerva -l targets.txt --json -o results.json

**UDP स्कैनिंग** (रूट की आवश्यकता हो सकती है):```sh
sudo nerva -t example.com:53 -U
# dns://example.com:53

SCTP scanning (केवल लिनक्स):```sh nerva -t telecom-server:3868 -S

diameter://telecom-server:3868

**तेज़ मोड** (केवल डिफ़ॉल्ट पोर्ट):```sh
nerva -l large-target-list.txt --fast --json

Proxy routing के साथ remote DNS resolution:```sh nerva -t target.internal:80 --proxy socks5://127.0.0.1:1080 --dns-order p

### सुरक्षा गलत-कॉन्फ़िगरेशन का पता लगाना

Nerva `--misconfigs` के साथ सक्षम होने पर सामान्य सुरक्षा गलत-कॉन्फ़िगरेशन की पहचान कर सकता है:```sh
nerva -t example.com:2375 --misconfigs --json

पहचानी गई गलत कॉन्फ़िगरेशन:

गलत कॉन्फ़िगरेशन के साथ उदाहरण आउटपुट:```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" } ] }

### प्रॉक्सी समर्थन

Nerva SOCKS5 और HTTP प्रॉक्सी के माध्यम से स्कैनिंग ट्रैफ़िक को कॉन्फ़िगरेबल DNS रिज़ॉल्यूशन के साथ रूट करने का समर्थन करता है।

**समर्थित प्रॉक्सी स्कीम:**

- `socks5://` - स्थानीय DNS रिज़ॉल्यूशन के साथ SOCKS5 प्रॉक्सी
- `socks5h://` - प्रॉक्सी-साइड DNS रिज़ॉल्यूशन के साथ SOCKS5 प्रॉक्सी (हमेशा)
- `http://` - HTTP CONNECT प्रॉक्सी
- `https://` - HTTPS CONNECT प्रॉक्सी

**प्रॉक्सी प्रमाणीकरण:**```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 समाधान रणनीतियाँ (--dns-order):

नोट: socks5h:// स्कीम स्वचालित रूप से प्रॉक्सी-पक्ष DNS समाधान को बाध्य करती है (--dns-order p के समतुल्य)

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

⚠️ UDP सीमाएं: SOCKS5 के माध्यम से UDP का सीमित समर्थन है। सभी SOCKS5 सर्वर UDP एसोसिएशन का समर्थन नहीं करते हैं। स्थानीय UDP फ़ॉलबैक हो सकता है।

दर सीमा के साथ समानांतर स्कैनिंग:```sh nerva -l large-target-list.txt -W 100 -H 5 -R 50 -v

**सुरुचिपूर्ण शटडाउन** (Ctrl+C आंशिक परिणाम लौटाता है):```sh
nerva -l huge-target-list.txt -W 50 -v
# Press Ctrl+C to stop — collected results are still printed

समर्थित प्रोटोकॉल

TCP, UDP और SCTP पर 170+ सेवा पहचान प्लगइन्स:

HTTP फिंगरप्रिंट मॉड्यूल (66)

वेब सेवाओं के लिए प्रौद्योगिकी का पता लगाना, श्रेणी के अनुसार व्यवस्थित:

फ़ायरवॉल और नेटवर्क सुरक्षा (12)

AI/LLM और मशीन लर्निंग (6)

डेटाबेस और डेटा स्टोर (12)

DevOps और बुनियादी ढाँचा (14)

वेब सर्वर और फ्रेमवर्क (10)

एंटरप्राइज और व्यवसाय (8)

होम और IoT (2)

अन्य (2)

डेटाबेस (20)

रिमोट एक्सेस (6)

वेब और API (2)

मैसेजिंग और क्यूज़ (10)

फ़ाइल और निर्देशिका सेवाएँ (7)

नेटवर्क सेवाएँ (11)

औद्योगिक नियंत्रण प्रणाली (18)

दूरसंचार और VoIP (17)

VPN और सुरक्षा (11)

रिमोट एक्सेस और प्रबंधन (10)

डेवलपर टूल्स (8)

लाइब्रेरी उपयोग

अपने Go अनुप्रयोगों में Nerva आयात करें:```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)
}

}

See [examples/service-fingerprinting-example.go](https://github.com/praetorian-inc/nerva/blob/HEAD/examples/service-fingerprinting-example.go) for a complete working example.

## उपयोग के मामले

### पैठ परीक्षण

टोही के दौरान खोजी गई सेवाओं का तेजी से फिंगरप्रिंट लें, ताकि संभावित हमले के वैक्टर की पहचान हो सके।

### एसेट डिस्कवरी पाइपलाइनें

बड़े पैमाने पर एसेट इन्वेंट्री के लिए Naabu या Masscan के साथ संयोजित करें:```sh
naabu -host 10.0.0.0/24 -silent | nerva --json | jq '.protocol'

CI/CD सुरक्षा स्कैनिंग

तैनाती पाइपलाइनों में एकीकृत करें ताकि केवल अपेक्षित सेवाओं के उजागर होने की पुष्टि हो सके।

बग बाउंटी टोही

दिलचस्प एंडपॉइंट्स खोजने के लिए दायरे वाले लक्ष्यों पर सेवाओं की त्वरित गणना करें।

दूरसंचार नेटवर्क विश्लेषण

LTE/5G नेटवर्कों में SCTP ट्रांसपोर्ट (Linux) का उपयोग करके डायमीटर नोड्स की पहचान करें:```sh nerva -t mme.telecom.local:3868 -S --json

## आर्किटेक्चर```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]

Nerva क्यों?

Nmap की तुलना में

• स्मार्ट डिफ़ॉल्ट: Nerva पोर्ट नंबर के आधार पर पहले सबसे संभावित प्रोटोकॉल की जाँच करता है
• संरचित आउटपुट: आसान पार्सिंग और पाइपलाइन एकीकरण के लिए मूल JSON/CSV समर्थन
• केंद्रित: केवल सेवा फिंगरप्रिंटिंग — खोज के लिए समर्पित पोर्ट स्कैनर के साथ जोड़ें

zgrab2 की तुलना में

• स्वतः पहचान: पहले से प्रोटोकॉल निर्दिष्ट करने की आवश्यकता नहीं
• सरल उपयोग: nerva -t host:port बनाम echo host | zgrab2 http -p port

समस्या निवारण

कोई आउटपुट नहीं

कारण: पोर्ट बंद है या कोई समर्थित सेवा का पता नहीं चला।

समाधान: पोर्ट खुला है इसे सत्यापित करें:```sh nc -zv example.com 80

### समय समाप्ति त्रुटियाँ

**कारण**: डिफ़ॉल्ट 2-सेकंड टाइमआउट धीमी सेवाओं के लिए बहुत छोटा है।

**समाधान**: टाइमआउट बढ़ाएँ:```sh
nerva -t example.com:80 -w 5000  # 5 seconds

UDP सेवाएं पता नहीं चलीं

कारण: UDP स्कैनिंग डिफ़ॉल्ट रूप से अक्षम है।

समाधान: -U फ़्लैग से सक्षम करें (रूट की आवश्यकता हो सकती है):```sh sudo nerva -t example.com:53 -U

### SCTP काम नहीं कर रहा है

**कारण**: SCTP केवल Linux पर समर्थित है।

**समाधान**: Linux सिस्टम या कंटेनर पर चलाएँ:```sh
docker run --rm nerva -t telecom:3868 -S

शब्दावली

• सेवा: एक नेटवर्क सेवा जो एक पोर्ट पर चलती है (SSH, HTTP, PostgreSQL, आदि)
• फिंगरप्रिंटिंग: सेवा प्रकार, संस्करण और कॉन्फ़िगरेशन का पता लगाना और पहचानना
• प्लगइन: एक प्रोटोकॉल-विशिष्ट पहचान मॉड्यूल
• फास्ट मोड: प्रत्येक प्रोटोकॉल के लिए केवल डिफ़ॉल्ट पोर्ट को स्कैन करना (80/20 अनुकूलन)
• ट्रांसपोर्ट: नेटवर्क लेयर प्रोटोकॉल (TCP, UDP, या SCTP)

सहायता

यदि आपको Nerva उपयोगी लगता है, तो कृपया इसे एक स्टार देने पर विचार करें:

योगदान

हम योगदान का स्वागत करते हैं! दिशानिर्देशों के लिए CONTRIBUTING.md देखें।

लाइसेंस

Apache 2.0 — विवरण के लिए LICENSE देखें।

आभार

Nerva fingerprintx का एक अनुरक्षित फोर्क है, जिसे मूल रूप से प्रेटोरियन के 2022 के इंटर्न क्लास द्वारा विकसित किया गया था:

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