Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
NetLogic — NetLogic is an advanced network analysis and cybersecurity toolkit for traffic inspection, packet analysis, and threat detection | Kitploit
उपकरण/GitHubGitHub/dmitryflynn/netlogic
OSINT (Open Source Intelligence)ReconnaissanceVulnerability ScannersWeb SecurityNetwork SecurityPenetration TestingCloud SecuritySubdomain EnumerationDNS AnalysisAI Security
GitHubdmitryflynn/netlogic

NetLogic

11 महीना पहलेअभी तक समीक्षित नहीं

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

NetLogic is an advanced network analysis and cybersecurity toolkit for traffic inspection, packet analysis, and threat detection

रिपॉजिटरी देखें

NetLogic

Cloud-Native Attack Surface Mapper & Vulnerability Correlator — v3.0

NetLogic एक नेटवर्क सुरक्षा प्लेटफॉर्म है जो सक्रिय पोर्ट स्कैनिंग, CVE सहसंबंध (लाइव NVD API), SSL/TLS विश्लेषण, HTTP सुरक्षा ऑडिटिंग, DNS/ईमेल सुरक्षा मूल्यांकन, सबडोमेन टेकओवर पहचान, निष्क्रिय OSINT, सक्रिय भेद्यता जांच, AI-संचालित तर्क इंजन, क्रॉस-होस्ट अटैक चेन खोज, और डीप प्रोब एजेंट आर्किटेक्चर को जोड़ता है — इसे वेब ऐप (React डैशबोर्ड + FastAPI) के रूप में प्रस्तुत किया गया है। कोर स्कैन इंजन शुद्ध Python 3.9+ stdlib है जिसमें कोई तृतीय-पक्ष निर्भरता नहीं है।

Python 3.9+ License: MIT Platform

विशेषताएँ

मॉड्यूलविवरण
पोर्ट स्कैनर43/58 पोर्ट के साथ TCP कनेक्ट स्कैन, 22 सेवा प्रोब, बैनर ग्रैबिंग
CVE सहसंबंधकलाइव NVD API v2.0 + FIRST.org के माध्यम से EPSS संवर्धन
TLS विश्लेषकप्रोटोकॉल संस्करण, कमजोर सिफर, POODLE/BEAST/CRIME/DROWN, प्रमाणपत्र समाप्ति
HTTP हेडर ऑडिटHSTS, CSP, X-Frame-Options, CORS, कुकी फ्लैग; 0–100 स्कोर
स्टैक फिंगरप्रिंटCMS, फ्रेमवर्क, क्लाउड प्रदाता, CDN, WAF का बैनर/हेडर/बॉडी से पता लगाना
DNS सुरक्षाSPF, DKIM, DMARC, DNSSEC, ज़ोन ट्रांसफर, स्पूफेबिलिटी स्कोर
निष्क्रिय OSINTसर्टिफिकेट ट्रांसपेरेंसी लॉग, DoH DNS, ASN लुकअप — कोई सीधा लक्ष्य संपर्क नहीं
सेवा प्रोबरअप्रमाणित Redis/Mongo/ES/Docker/K8s/etcd प्रोब, 33 एडमिन पथ
टेकओवर डिटेक्टरCT लॉग सबडोमेन खोज + 25 क्लाउड प्रदाता CNAME फिंगरप्रिंट
Nuclei एकीकरण13k+ सामुदायिक टेम्पलेट (CVE, तकनीक, एक्सपोज़र, मिसकॉन्फ़िग) के लिए रैपर — MIT लाइसेंस
फ्यूजन पाइपलाइनमल्टी-सेंसर सिग्नल गेट → नियतात्मक समझौता → AI निर्णय → अटैक ग्राफ → 6-सेक्शन रिपोर्ट
वेब फिंगरप्रिंटफ़ेविकॉन हैश (Shodan-संगत mmh3), JS रहस्य, संस्करण मार्कर, एक्सपोज़्ड फ़ाइलें, डिफ़ॉल्ट लैंडर पहचान
AI विश्लेषणOpenAI / Anthropic / OpenRouter / Ollama / Gemini / Groq / Kimi / Qwen — टोकन-स्ट्रीमिंग SSE
तर्क इंजनअनुकूली observe→reason→act लूप EvidenceGraph, हाइपोथीसिस इंजन, विश्वास क्षय, प्रोवेनेंस, शेड्यूलर, प्लेबुक, परिवर्तन पहचान, सक्रिय मान्यता के साथ
डीप प्रोबप्रति-सेवा एजेंट आर्किटेक्चर: ScoutAgent (रिकॉन), ProbeAgent (लक्षित CVE जाँच), Coordinator, Sandbox
AI जांच एजेंटReAct-शैली लूप: बेसलाइन सेंसर के बाद, AI एक क्यूरेटेड, स्कोप-गेटेड, ऑडिटेड टूल सरफेस (~35 उपकरण) चलाता है ताकि लीड्स की पुष्टि करे और अटैक चेन बनाए — अधिकृत लक्ष्यों के लिए ऑप्ट-इन आक्रामक उपकरणों (क्रैश प्रोब, फ्रीफॉर्म प्रूफ, फ्रीफॉर्म एक्सप्लॉइट) के साथ
सत्यापन इंजनAI-संचालित CVE पुनः-सत्यापन: CVE संदर्भ से रॉ-HTTP प्रोब योजनाएँ डिज़ाइन करता है, stdlib सॉकेट के माध्यम से निष्पादित करता है

कैसे चलाएँ

NetLogic को चलाने के दो तरीके हैं:

मोडकमांडयह क्या करता है
वेब ऐपnetlogic --guiFastAPI शुरू करता है + React SPA + इन-प्रोसेस स्कैन एजेंट प्रदान करता है, स्वचालित रूप से रहस्य उत्पन्न करता है, और आपके ब्राउज़र में डैशबोर्ड खोलता है। वेब ऐप चलाने का यही एकमात्र तरीका है।
CLI

उत्पाद सतह वेब ऐप (React डैशबोर्ड + FastAPI) है। src/ के तहत स्कैन इंजन UI से शुरू किए गए कार्यों को संचालित करता है।

त्वरित प्रारंभ```bash

One-time install

pip install -r requirements-api.txt pip install -e .

Run the web dashboard

netlogic --gui

→ Dashboard at http://localhost:8000, auto-generated secrets in ~/.netlogic/secrets.json

(first run builds the dashboard automatically; requires Node.js)

Or a one-shot CLI scan

netlogic scanme.nmap.org --full

root@kitploit:~
## CLI संदर्भ```
netlogic [target] [flags]

प्रवेश बिंदु api.cli:main है (pyproject.toml में परिभाषित), जो netlogic.py:main() को कार्य सौंपता है। सभी स्कैन तर्क src/ में हैं।

लक्ष्य विनिर्देश

स्कैन क्षेत्र```

Basic scan — 43 common ports + CVE correlation

netlogic example.com

Full scan — all modules enabled

netlogic example.com --full

Deep TLS + HTTP header audit

netlogic example.com --tls --headers

Subdomain takeover detection

netlogic example.com --takeover

Passive OSINT only

netlogic example.com --osint

Technology stack + WAF fingerprinting

netlogic example.com --stack

DNS/email security (SPF, DKIM, DMARC, DNSSEC)

netlogic example.com --dns

Active service probing (unauthenticated access, default creds, CVE-specific checks)

netlogic 10.0.0.5 --probe

Everything — all flags combined

netlogic example.com --full --probe

root@kitploit:~
### पोर्ट चयन```
# Quick — 43 common ports (default)
netlogic example.com --ports quick

# Full — 58 extended ports
netlogic example.com --ports full

# Custom list
netlogic example.com --ports custom=22,80,443,8080,9200

AI विश्लेषण```

OpenRouter (default)

netlogic example.com --ai --ai-key $KEY

OpenAI

netlogic example.com --ai --ai-provider openai --ai-key $KEY --ai-model gpt-4o-mini

Anthropic

netlogic example.com --ai --ai-provider anthropic --ai-key $KEY

Gemini

netlogic example.com --ai --ai-provider gemini --ai-key $KEY --ai-model gemini-2.0-flash

Local Ollama

netlogic example.com --ai --ai-provider ollama

Custom OpenAI-compatible endpoint

netlogic example.com --ai --ai-provider custom --ai-base-url https://... --ai-model model-name

root@kitploit:~
### समर्थित AI प्रदाता

| प्रदाता | डिफ़ॉल्ट मॉडल | API शैली |
|---|---|---|
| `openrouter` | `anthropic/claude-sonnet-4` | OpenAI |
| `openai` | `gpt-4o-mini` | OpenAI |
| `anthropic` | `claude-3-5-sonnet-20241022` | Anthropic Messages |
| `kimi` (Moonshot) | `kimi-k2.6` | OpenAI |
| `qwen` (Alibaba) | `qwen-plus` | OpenAI |
| `groq` | `llama-3.3-70b-versatile` | OpenAI |
| `gemini` (Google) | `gemini-2.0-flash` | OpenAI |
| `ollama` | `llama3` | OpenAI |
| `custom` | उपयोगकर्ता-निर्दिष्ट | OpenAI |

### तर्क इंजन```
# Adaptive observe→reason→act loop (deterministic by default; AI-augmented with --ai)
netlogic example.com --reason

# Multi-host world modeling — discovers in-scope neighbours, reasons per host
netlogic example.com --reason --multi-host

# Change detection — diffs against prior saved report
netlogic example.com --since-last

# Active validation — confirms hypotheses with safe non-destructive GETs
netlogic example.com --reason --active-validate

# Deep probe — per-service agent architecture with context isolation
netlogic example.com --deep-probe

एआई अन्वेषण एजेंट

बेसलाइन सेंसर चलने के बाद, एक वैकल्पिक ReAct-शैली एजेंट AI को अपने स्वयं के उपकरणों को चलाने देता है ताकि लीड्स को सत्यापित किया जा सके और आक्रमण श्रृंखलाएं बनाई जा सकें, बजाय इसके कि संस्करण/बैनर CVE हिट्स को असत्यापित लीड्स के रूप में छोड़ दिया जाए। AI टूल कॉल प्रस्तावित करता है; एक नियतात्मक रनटाइम उन्हें निष्पादित करता है — प्रत्येक टूल लक्ष्य के लिए स्कोप-गेटेड, स्वच्छित, और एक अवलोकन के रूप में रिकॉर्ड किया जाता है। AI कभी सीधे वायर को स्पर्श नहीं करता है।```

AI chooses tools after baseline (needs --ai)

netlogic example.com --ai --ai-agent

Depth mode — higher budgets, chases CVE leads + attack chains, blocks early stop

netlogic example.com --ai --agent-depth --agent-max-steps 24 --agent-max-requests 80

root@kitploit:~
एजेंट में डिफ़ॉल्ट रूप से लगभग 35 रीड-ओनली/सेफ-एक्टिव टूल्स हैं: HTTP/TLS/DNS प्रोब्स, `dir_enum`, `confirm_tech`, `timing_probe`, `cve_probe` (क्यूरेटेड ज्ञात-CVE मार्कर जाँच), `sqli_boolean`/`sqli_time`, `ssrf_canary`, `idor_diff`, `file_disclosure`, `browser_get` (हेडलेस, JS चुनौतियों को पास करता है), साथ ही HackerOne बुककीपिंग (`record_poc`, `severity_suggest`, `submit_readiness`)।

**ऑप्ट-इन आक्रामक टूल्स** — डिफ़ॉल्ट रूप से बंद, **केवल अधिकृत/स्वामित्व वाले इन-स्कोप लक्ष्यों पर** (सार्वजनिक या अजनबी स्कैन पर कभी नहीं)। प्रत्येक को `--ai-agent` की आवश्यकता है:

| फ़्लैग | टूल | यह क्या अनलॉक करता है | रखी गई सीमाएँ |
|---|---|---|---|
| `--allow-crash-probes` | `crash_probe` | क्यूरेटेड क्रैश/DoS CVE जाँच (http.sys, MS15-034) जो होस्ट को क्रैश कर सकती हैं | निश्चित 3-CVE कैटलॉग — मुक्त रूप नहीं |
| `--allow-freeform-proof` | `http_proof` | टियर C: मुक्त रूप GET/HEAD/OPTIONS (+ सर्च/लॉगिन/ग्राफ़क्यूएल-जैसे पथों पर POST) | विनाशकारी पैटर्न + PUT/PATCH/DELETE अवरुद्ध; प्रमाण, उत्परिवर्तन नहीं |
| `--allow-exploit-requests` | `exploit_request` | टियर E: **कोई भी विधि** (PUT/PATCH/DELETE सहित) + लक्ष्य के विरुद्ध मनमाना पथ/हेडर/बॉडी | स्कोप-गेटेड; सामूहिक-विनाशकारी पैटर्न (DROP/TRUNCATE TABLE, `rm -rf`) और CR/LF हेडर इंजेक्शन पर फेल-क्लोज़्ड; प्रत्येक अनुरोध ऑडिटेड |

नियतिवादी ActionGate कोर को `safe_active` पर रखता है; ये तीन फ़्लैग इसके ऊपर स्पष्ट, ऑडिटेड ऑप्ट-इन हैं। उदाहरण (स्वामित्व वाला लैब बॉक्स + स्थानीय मॉडल):```
netlogic YOUR_LAB_HOST --full --ai --ai-agent --agent-depth \
  --allow-crash-probes --allow-exploit-requests \
  --ai-provider ollama --ai-model gemma4:31b-cloud \
  --ai-base-url http://localhost:11434/v1 --ai-key ollama

प्रमाणित स्कैनिंग```

SSH key-based — reads real installed package versions

netlogic example.com --ssh-user admin --ssh-key ~/.ssh/id_rsa

SSH password (requires sshpass)

netlogic example.com --ssh-user admin --ssh-pass SECRET

Custom SSH port

netlogic example.com --ssh-user admin --ssh-key ~/.ssh/id_rsa --ssh-port 2222

root@kitploit:~
### बेंचमार्क```
# Fusion pipeline benchmark against recorded cassettes (oracle mode — perfect AI upper bound)
netlogic --benchmark

# With real AI model
netlogic --benchmark --benchmark-ai

# Export report
netlogic --benchmark --benchmark-export report.md

# Verbose per-subject output
netlogic --benchmark --benchmark-verbose

आउटपुट```

Report format

netlogic example.com --report terminal # terminal output (default) netlogic example.com --report json # JSON file netlogic example.com --report html # HTML report netlogic example.com --report all # terminal + JSON + HTML

Output directory

netlogic example.com --out ./reports

CVSS threshold

netlogic example.com --min-cvss 7.0

Colour

netlogic example.com --no-color

root@kitploit:~
### NVD कैश प्रबंधन```
netlogic --cache-stats
netlogic example.com --nvd-key YOUR_NVD_KEY

विविध```

netlogic --version # Show version and exit netlogic --gui # Start web dashboard

root@kitploit:~
## फ़्यूज़न पाइपलाइन

फ़्यूज़न पाइपलाइन एक **सेंसर → गेट → AI निर्णयन → संश्लेषण** फ़नल है जो मोनोलिथिक AI कॉल को एक सटीक गेट से बदल देता है। यह `src/fusion/` (12 फ़ाइलें) में स्थित है।

### सिग्नल स्कीमा (`src/fusion/signals.py`)

साक्ष्य-युक्त डेटा अनुबंध। प्रत्येक सेंसर `Signal` ऑब्जेक्ट उत्सर्जित करता है:
- `source`: `probe`/`banner`/`nuclei`/`wappalyzer`/`nvd`/`osv`/`tls`/`dns`
- `kind`: `vuln`/`tech`/`exposure`/`misconfig`/`service`
- `claim`: सामान्यीकृत विषय (जैसे `"CVE-2021-44228"`, `"nginx"`)
- `host`, `port`, `service`, `evidence` (अधिकतम 600 वर्ण)
- `confidence` (0..1), `reliability` (`high`/`medium`/`low`)
- `kev`, `epss` (0..1), `cvss` (0..10), `exploit_available`, `version_matched`, `probe_confirmed`
- `exposure` dict (पहुँच, WAF, दृष्टिकोण)
- `observed_data` (AI को भेजे गए कच्चे बाइट्स — लेबल पूर्वाग्रह रोकने के लिए सेंसर नाम या गंभीरता नहीं)
- `ai_view()` सेंसर मेटाडेटा हटाता है, केवल देखे गए तथ्य लौटाता है

### गेट (`src/fusion/gate.py`)

नियतात्मक सहमति — `list[Signal]` दिए जाने पर, विषय के अनुसार समूह करता है और `list[Verdict]` लौटाता है:

| शर्त | निर्णय |
|---|---|
| KEV-सूचीबद्ध या प्रोब-पुष्टि या critical+exploit/उच्च-EPSS | **पुष्टि** (पिन किया गया — हटाने योग्य नहीं) |
| ≥2 स्वतंत्र स्रोत सहमत, ≥1 उच्च-विश्वसनीयता | **पुष्टि** (जब तक सभी संस्करण-मिलान न हों → ग्रे) |
| एकल निम्न-विश्वसनीयता, निम्न/मध्यम प्रभाव, कोई पुष्टि नहीं | **खारिज** |
| बाकी सब | **ग्रे** (AI टोकन की लागत) |

### AI निर्णयन (`src/fusion/adjudicator.py`)

केवल ग्रे बैंड को छूता है। सुरक्षा बाधाएँ कोड में लागू की गई हैं (प्रॉम्प्ट में नहीं):
- उच्च/गंभीर ग्रे आइटम कभी भी खारिज नहीं किए जा सकते — सबसे बुरी स्थिति में `potential` पर डिमोट किया जाता है
- केवल संस्करण-मिलान `potential` पर सीमित (डिस्ट्रोज़ बिना संस्करण बढ़ाए बैकपोर्ट करते हैं)
- AI पूर्ण होस्ट संदर्भ से नई खोजों की भी खोज करता है
- सॉफ्ट-फेल: AI आउटेज ग्रे बैंड को `potential` के रूप में छोड़ देता है — कोई मौन डेटा हानि नहीं

### संश्लेषण (`src/fusion/synthesis.py`)

`build_attack_graph(verdicts)` → पुष्टि किए गए निष्कर्षों से नियतात्मक पहुँच ग्राफ।
`full_synthesize(...)` → 6-खंड AI रिपोर्ट:
1. कार्यकारी सारांश
2. मुख्य निष्कर्ष (तालिका)
3. हमले की श्रृंखलाएँ (ग्राफ-आधारित, LLM वास्तविक किनारों का वर्णन करता है)
4. ज्ञात CVE से परे
5. झूठी सकारात्मकताएँ और शोर
6. सुधार

### सेंसर

| सेंसर | फ़ाइल | यह क्या उत्पन्न करता है |
|---|---|---|
| Engine bridge | `engine_bridge.py` | स्कैन आर्टिफैक्ट्स को NVD, प्रोब्स, स्टैक, Nuclei, वेरिफ़ायर से Signals में बदलता है |
| Wappalyzer | `sensors/wappalyzer.py` | HTTP प्रतिक्रियाओं की शून्य-निर्भरता Wappalyzer-संगत फ़िंगरप्रिंटिंग |
| Nuclei | `sensors/nuclei.py` | प्रतिक्रियाओं के विरुद्ध YAML टेम्पलेट चलाता है (Nuclei सिंटैक्स का उपसमूह) |
| Cassette | `cassette.py` | HTTP कैसेट से रिकॉर्ड/रीप्ले (ऑफ़लाइन बेंचमार्क डेटा) |

### क्रॉस-होस्ट (`src/fusion/cross_host.py`)

निर्णयन के बाद होस्टों में साझा सेवा+संस्करण द्वारा निर्णयों का समूहीकरण, संश्लेषण में मल्टी-हॉप हमले श्रृंखला वर्णन के लिए।

### पाइपलाइन प्रवाह```
Engine artifacts / Cassette data
    ↓
engine_bridge.py / cassette.py     → Signal list
    ↓
gate.py::adjudicate()              → Verdict list (confirmed/discarded/gray)
    ↓
adjudicator.py::run_adjudication() → AI on gray band only
    ↓
synthesis.py::full_synthesize()    → 6-section report + attack graph

तर्क इंजन

src/reasoning/ (~58 फ़ाइलें) में स्थित। बहु-चरण, सुरक्षा-गेटेड, निरीक्षण→तर्क→क्रिया लूप। --reason के साथ सक्षम।

कोर लूप (src/reasoning/director.py — ReconDirector.run())

  1. चरण 2 सेंसर स्वीप: StrategyManager व्यक्तित्व चुनता है → Scheduler कार्रवाई चुनता है → SensorStep निष्पादित करता है → EvidenceGraph अवलोकनों को मोड़ता है → ConfidenceEngine विश्वासों को ताज़ा करता है
  2. चरण 3 AI चक्र: डिटरमिनिस्टिक जनरेटर उद्देश्यों/परिकल्पनाओं को आबाद करते हैं → AI एजेंट टाइप किए गए Proposal लिफ़ाफ़े प्रस्तावित करते हैं → AICoordinator सामान्यीकरण/रैंक/सत्यापन करता है → स्वीकृत प्रस्ताव स्थिति को बीजित करते हैं → Compiler → ExecutionPlanner → ExecutionKernel प्रोब चलाता है → InferenceEngine हल करता है
  3. चरण 6c मल्टी-होस्ट: CrossHostGraph के माध्यम से क्रॉस-होस्ट खोज, चाइल्ड HostReasoner इंस्टेंस उत्पन्न करता है

स्थिति पदानुक्रम (src/reasoning/state.py)

प्रमुख घटक

AI उपतंत्र (src/reasoning/ai/)

पाइपलाइन: उत्पन्न करें → सामान्यीकरण करें → रैंक करें → (MetaReasoner प्रून) → सत्यापित करें → संग्रहित करें

डीप प्रोब आर्किटेक्चर

src/deep/ (7 फ़ाइलें) में स्थित। --deep-probe के साथ उपयोग किया जाता है। संदर्भ-पृथक प्रोब निष्पादन के लिए प्रति-सेवा एजेंट आर्किटेक्चर।

DeepCoordinator.run() प्रवाह:

  1. AI सेंसर योजना बनाएँ (_build_sensor_plan sensor_director के माध्यम से)
  2. निष्क्रिय रिकॉन के लिए ScoutAgent भेजें
  3. सेवा द्वारा निष्कर्षों को समूहित करें → प्रति-सेवा ProbeAgent इंस्टेंस (प्रत्येक में पृथक CVE/तकनीक संदर्भ)
  4. सेवा गणना, Nuclei (AI-चयनित टैग), सत्यापक इंजन, अधिग्रहण, AI-निर्देशित सबनेट प्रोब, टोपोलॉजी, प्रमाणित SSH, स्कैन अंतर, पहुँच प्रोबिंग चलाएँ

सत्यापक इंजन

src/verifier/ (3 फ़ाइलें) में स्थित। लक्षित प्रोब के साथ AI-संचालित CVE पुष्टिकरण।

चरण 2 पुनः-सत्यापन (reverify_with_context) विफल परीक्षणों को परिष्कृत करने के लिए पूर्ण होस्ट संदर्भ प्रदान करता है।

AI सेंसर निदेशक

src/directors/ (4 फ़ाइलें) में स्थित। LLM-संचालित स्कैन पैरामीटर चयन।

मल्टी-होस्ट ऑर्केस्ट्रेशन

src/orchestrator.py में स्थित। अल्पविराम से अलग किए गए लक्ष्यों द्वारा ट्रिगर। प्रति होस्ट run_scan() चलाता है, परिणाम एकत्रित करता है, संयुक्त फ्यूज़न निर्णयों से क्रॉस-होस्ट संदर्भ बनाता है। क्रॉस-होस्ट समूह मल्टी-हॉप हमला श्रृंखला वर्णन के लिए होस्टों में साझा सेवाओं/संस्करणों का पता लगाते हैं।

CVE कवरेज

लाइव: NVD API v2.0 (src/nvd_lookup.py)

  • अनावृत्त उत्पादों/संस्करणों के लिए लाइव लुकअप
  • एयर-गैप्ड वातावरण के लिए 192 ऑफ़लाइन हस्ताक्षर
  • परमाणु लेखन के साथ ऑन-डिस्क कैश
  • उच्च दर सीमा के लिए NVD API कुंजी (--nvd-key)

संवर्धन

  • EPSS (src/epss.py): 100 CVE IDs के बैच में FIRST.org API, ~/.netlogic/epss_cache.json पर 24 घंटे डिस्क कैश, 0.0 पर फेल-सॉफ्ट
  • CISA KEV: जंगली में सक्रिय रूप से शोषित CVEs
  • सार्वजनिक शोषण ट्रैकिंग: Metasploit और PoC मार्कर

Nuclei एकीकरण

src/external/nuclei_runner.py Nuclei बाइनरी (MIT लाइसेंस) को लपेटता है। वैकल्पिक — बाइनरी न मिलने पर सुचारू रूप से डिग्रेड होता है। परिणाम टाइप किए गए सिग्नल के रूप में फ्यूज़न पाइपलाइन में फीड होते हैं (LLM पूर्वाग्रह को रोकने के लिए गंभीरता लेबल हटा दिए जाते हैं)।```

Install Nuclei

scoop install nuclei # Windows brew install nuclei # macOS go install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest # Linux

root@kitploit:~
---

## फ्यूजन बेंचमार्क

`src/fusion/benchmark.py` — लेबल किए गए HTTP कैसेट्स (`benchmark/*.json` और `src/fusion/data/`) के खिलाफ ऑफलाइन माप। मीट्रिक्स:

| मीट्रिक | गेट थ्रेशोल्ड |
|---|---|
| एफपी कमी | ≥ 80% |
| क्रिटिकल रिकॉल | = 100% |

दो मोड:
- **Oracle** (`--benchmark`): परफेक्ट-एआई ऊपरी सीमा — केवल नियतात्मक मशीनरी को मापता है
- **Real model** (`--benchmark --benchmark-ai`): कॉन्फ़िगर किए गए LLM के साथ मापा गया

---

## आर्किटेक्चर```
netlogic/
├── netlogic.py                  ← Local launcher (`--gui`, optional CLI helpers)
│
├── src/                         ← Scan engine (used by the web API)
│   ├── scanner.py               ← TCP scanner, 22 service probes, banner grabbing
│   ├── engine.py                ← Orchestrator: SensorStep pipeline, all scan modules + fusion
│   ├── orchestrator.py          ← Multi-host: per-host scan → cross-host context
│   ├── ai_analyst.py            ← LLM integration (9 providers, stdlib-only transport)
│   ├── cve_correlator.py        ← CVE matching: NVD 
│   ├── nvd_lookup.py            ← NVD API v2.0 client, disk cache, CISA KEV
│   ├── epss.py                  ← EPSS enrichment (FIRST.org, 24h cache)
│   ├── service_prober.py        ← Unauthenticated service access, default creds, admin paths
│   ├── vuln_prober.py           ← CVE-specific safe active probes
│   ├── osint.py                 ← DoH, CT logs, ASN lookup
│   ├── tls_analyzer.py          ← SSL/TLS deep analysis
│   ├── header_audit.py          ← HTTP security header audit
│   ├── stack_fingerprint.py     ← CMS, framework, cloud, CDN, WAF detector
│   ├── web_fingerprint.py       ← Favicon mmh3, JS secrets, version files, exposed paths, lander detection
│   ├── dns_security.py          ← SPF, DKIM, DMARC, DNSSEC, zone transfer
│   ├── takeover.py              ← Subdomain takeover (25 provider fingerprints)
│   ├── authenticated.py         ← SSH subprocess: dpkg/rpm/apk parsing, 60+ product mappings
│   ├── topology.py              ← PTR, IPv6, traceroute, ASN/org/country
│   ├── reachability_prober.py   ← Lateral movement matrix from subnet adjacency
│   ├── network_prober.py        ← /24 subnet sweep: live-host → full port scan
│   ├── service_enum.py          ← Protocol attribute extraction (SSH KEX, SMBv1, RDP NLA, SNMP)
│   ├── ssl_utils.py             ← Configurable SSL context management, TLS probe
│   ├── scan_diff.py             ← Change-over-time: diffs against prior JSON report
│   ├── json_bridge.py           ← Streaming JSON events for agent / REST API
│   ├── reporter.py              ← Terminal, JSON, HTML output renderers
│   │
│   ├── fusion/                  ← Precision funnel (12 files)
│   │   ├── signals.py           ← Signal schema
│   │   ├── gate.py              ← Deterministic agreement
│   │   ├── adjudicator.py       ← AI adjudication (gray band only)
│   │   ├── synthesis.py         ← Attack graph + 6-section report
│   │   ├── ai.py                ← CompleteFn/StreamCompleteFn adapter
│   │   ├── engine_bridge.py     ← Artifacts → Signals → verdicts
│   │   ├── benchmark.py         ← Offline benchmark (oracle + real model)
│   │   ├── cassette.py          ← HTTP cassette record/replay
│   │   ├── corpus.py            ← Cassette→case conversion + CLI
│   │   ├── cross_host.py        ← Cross-host verdict correlation
│   │   ├── sensors/nuclei.py    ← Nuclei YAML → Signal conversion
│   │   └── sensors/wappalyzer.py← Wappalyzer fingerprint → Signal
│   │
│   ├── directors/               ← AI sensor directors (4 files)
│   │   ├── sensor_director.py   ← LLM selects which sensors to enable
│   │   ├── reprobe.py           ← LLM designs re-probe plans
│   │   ├── nuclei_selector.py   ← LLM selects Nuclei template tags
│   │   └── subnet_director.py   ← LLM directs subnet probing
│   │
│   ├── verifier/                ← AI CVE verification (3 files)
│   │   ├── engine.py            ← Verifier orchestration
│   │   ├── planner.py           ← Built-in + AI-generated probe plans
│   │   └── runner.py            ← Raw TCP/TLS probe execution
│   │
│   ├── deep/                    ← Deep probe agents (7 files)
│   │   ├── coordinator.py       ← Full deep pipeline orchestrator
│   │   ├── scout_agent.py       ← Passive recon agent
│   │   ├── probe_agent.py       ← Per-service probe agent
│   │   ├── chain.py             ← Exploit chain planning + PoC generation
│   │   ├── sandbox.py           ← Restricted PoC execution
│   │   ├── base_agent.py        ← Abstract base
│   │   └── models.py            ← Mission/AgentReport data models
│   │
│   ├── reasoning/               ← Adaptive reasoning engine (~58 files)
│   │   ├── director.py          ← ReconDirector (main loop)
│   │   ├── state.py             ← WorldModel/InvestigationState/ExecutionState
│   │   ├── hypothesis.py        ← Hypothesis engine (competing candidates)
│   │   ├── evidence_graph.py    ← Temporal entity graph (content-addressed obs)
│   │   ├── confidence.py        ← Noisy-OR belief computation
│   │   ├── provenance.py        ← Observation→Inference→Hypothesis edges
│   │   ├── scheduler.py         ← Information-gain action selection
│   │   ├── strategy.py          ← Meta-reasoning: personas, explore/exploit
│   │   ├── strategies.py        ← Concrete strategy implementations
│   │   ├── action_gate.py       ← Risk-tiered probe authorisation
│   │   ├── change_detection.py  ← Phase 7: observation-level diff
│   │   ├── active_validation.py ← Phase 8b: SAFE_ACTIVE probes
│   │   ├── cross_host.py        ← Cross-host world modeling
│   │   ├── objective.py         ← Objective DAG management
│   │   ├── intent.py            ← Intent model + EvidenceType enum (29 types)
│   │   ├── candidate.py         ← Action candidate with lazy factory
│   │   ├── actions.py           ← Action model with RiskTier + Predicate
│   │   ├── compiler.py          ← Intent → InvestigationGraph
│   │   ├── execution_planner.py ← InvestigationGraph → ProbePlanGraph
│   │   ├── execution_kernel.py  ← Probe execution with validators
│   │   ├── probe_executor.py    ← Read-only probe backends
│   │   ├── primitive_registry.py← Probe primitive catalogue
│   │   ├── generators.py        ← Deterministic objective/hypothesis population
│   │   ├── playbooks.py         ← YAML playbook system
│   │   ├── planning_pass.py     ← GoalPlanner integration
│   │   ├── budget.py            ← Probe budget management
│   │   ├── inference.py         ← Deterministic rule-based inference
│   │   ├── novel_inference.py   ← Novel-vuln hypothesis rules
│   │   ├── investigation_planner.py  ← Goal-directed investigation planning
│   │   ├── investigation_memory.py   ← Strategy attempt memory
│   │   ├── observation_translator.py ← Raw data → structured observations
│   │   ├── observation.py       ← Immutable, content-addressed observation
│   │   ├── reflect.py           ← PlannerFeedback generation
│   │   ├── reasoning_validator.py ← Continuous integrity audit
│   │   ├── builder.py           ← State population from artifacts
│   │   ├── trace.py             ← Execution tracing
│   │   ├── explanation.py       ← Explanation records
│   │   ├── ai/                  ← AI cognitive layer (subsystem)
│   │   ├── packs/               ← Technology pack calibration
│   │   ├── playbooks/           ← YAML playbook templates
│   │   └── rules/               ← JSON inference rules
│   │
│   └── external/nuclei_runner.py ← Nuclei binary wrapper
│
├── api/                         ← FastAPI controller
│   ├── main.py                  ← App factory, lifespan, middleware stack
│   ├── cli.py                   ← Typer -> netlogic.py bridge
│   ├── db.py                    ← PostgreSQL connection + migration runner
│   ├── crypto.py                ← Fernet seal/unseal (AES-128-CBC + HMAC-SHA256)
│   ├── auth/
│   │   ├── api_keys.py          ← Dual-store (memory/PG), SHA-256 hashed
│   │   ├── jwt_handler.py       ← Stdlib-only HS256 JWT
│   │   ├── oidc.py              ← Clerk/IdP OIDC (RS256 + JWKS)
│   │   ├── license.py           ← LicenseManager (stub → real payment API)
│   │   ├── rate_limit.py        ← Sliding-window, IP banning
│   │   ├── provisioning.py      ← Clerk auto-provisioning
│   │   └── dependencies.py      ← require_org FastAPI dependency
│   ├── agents/
│   │   ├── registry.py          ← Agent lifecycle (concurrency-aware, JSON persistence)
│   │   └── local_agent.py       ← Built-in in-process agent
│   ├── jobs/
│   │   ├── manager.py           ← ScanJob lifecycle, capped event deque (10k), SSE, Postgres
│   │   └── executor.py          ← Dispatch (capability/selector, least-loaded, reclaimer)
│   ├── middleware/audit.py      ← X-Request-ID + structured audit + SIEM shipping
│   ├── models/
│   │   ├── scan_request.py      ← Pydantic ScanRequest (ipaddress validation)
│   │   └── agent.py             ← AgentRegistration constraints
│   ├── routes/
│   │   ├── auth.py              ← /v1/auth/*
│   │   ├── jobs.py              ← /v1/jobs/*
│   │   ├── agents.py            ← /v1/agents/*
│   │   ├── health.py            ← /health + /v1/health
│   │   ├── license.py           ← /v1/license/*
│   │   └── settings.py          ← /v1/settings/*
│   └── storage/
│       ├── json_store.py         ← 10 MB cap, 500 file cap, atomic writes
│       ├── pg_store.py           ← Postgres JSONB upsert
│       └── reasoning_store.py    ← Dual-store for reasoning state
│
├── dashboard/                   ← React SPA (Vite + TypeScript + Tailwind + Clerk)
│   └── src/
│       └── pages/               ← Dashboard, NewScan, ScanDetail, Agents, Targets,
│                                   TargetTimeline, Settings, License, Login, SignUp, Legal
│
├── docs/                        ← Design documentation
│   ├── DEPLOY_SAAS.md, saas-auth.md
│   ├── REASONING_ENGINE_DESIGN.md
│   ├── LEGAL_COMPLIANCE.md
│   ├── ENTERPRISE_READINESS.md
│   └── DESIGN_PARTNER_PACK.md
│
├── db/migrations/               ← PostgreSQL schema migrations
└── benchmark/                   ← HTTP cassette recordings for fusion benchmark

एपीआई संदर्भ

सभी रूट /v1/ उपसर्ग के अंतर्गत हैं। प्रमाणीकरण:

  • मशीन: API key → POST /v1/auth/token → HS256 JWT (डिफ़ॉल्ट 1 घंटे की समाप्ति)
  • मानव: Clerk OIDC session JWT → require_org निर्भरता JWKS के विरुद्ध सत्यापित करता है

प्रमाणीकरण```

POST /v1/auth/token Exchange API key for JWT [10/min/IP] POST /v1/auth/keys Create API key (X-Admin-Key) [admin] GET /v1/auth/keys List keys (masked) [admin] DELETE /v1/auth/keys Revoke key (body, not URL) [admin]

root@kitploit:~
### कार्य```
POST   /v1/jobs                Create scan job                    [30/min/org]
GET    /v1/jobs                List recent jobs
GET    /v1/jobs/history/{target}  Scan history for target
GET    /v1/jobs/{id}           Job detail
GET    /v1/jobs/{id}/stream    SSE event stream                   [60/min/org]
GET    /v1/jobs/{id}/export    Export (format=json|md|raw)
POST   /v1/jobs/{id}/explore-beyond  AI deep-dive on finding
POST   /v1/jobs/{id}/cancel    Cancel job
DELETE /v1/jobs/{id}           Remove job

एजेंट```

POST /v1/agents/register Register agent [5/hr/IP] POST /v1/agents/{id}/heartbeat Keep-alive [3/min] GET /v1/agents/{id}/tasks Poll pending jobs POST /v1/agents/{id}/tasks/{job_id}/events Submit events [60/min, 500/batch] POST /v1/agents/{id}/tasks/{job_id}/complete Mark done/failed GET /v1/agents List agents (org-scoped) GET /v1/agents/{id} Agent detail DELETE /v1/agents/{id} Deregister POST /v1/agents/{id}/activate Enable agent POST /v1/agents/{id}/deactivate Disable agent

root@kitploit:~
### लाइसेंस / सेटिंग्स```
GET    /v1/license              License status
POST   /v1/license/activate     Activate key                    [3/hr/IP]
GET    /v1/settings/ai          Get org AI config (key masked)
POST   /v1/settings/ai          Update org AI config (encrypted)
POST   /v1/settings/ai/test     Test AI connection

सिस्टम```

GET /health Service status + uptime GET /docs OpenAPI docs GET /redoc ReDoc docs

root@kitploit:~
---

## पर्यावरण चर

### नियंत्रक

| चर | डिफ़ॉल्ट | विवरण |
|---|---|---|
| `NETLOGIC_ENV` | _(सेट नहीं)_ | `production`/`prod` = स्टार्टअप पर गुप्त मान्यता |
| `NETLOGIC_JWT_SECRET` | `changeme-in-production` | HS256 हस्ताक्षर रहस्य, ≥32 वर्ण |
| `NETLOGIC_JWT_EXPIRY` | `3600` | JWT जीवनकाल सेकंड में |
| `NETLOGIC_ADMIN_KEY` | `admin-changeme` | व्यवस्थापक क्रेडेंशियल, उत्पादन में ≥32 वर्ण |
| `NETLOGIC_API_KEYS` | _(खाली)_ | बीज कुंजियाँ: `key1:org1,key2:org2,...` |
| `NETLOGIC_CORS_ORIGINS` | _(खाली)_ | अनुमत मूल (CORS खाली होने पर अक्षम) |
| `NETLOGIC_PORT` | `8000` | बाइंड पोर्ट |
| `NETLOGIC_HOST` | `0.0.0.0` | बाइंड पता |
| `NETLOGIC_NO_BROWSER` | _(सेट नहीं)_ | `1` स्वतः-खोलना अक्षम करता है |
| `NETLOGIC_OIDC_ISSUER` | _(सेट नहीं)_ | Clerk फ्रंटएंड API URL → OIDC लॉगिन |
| `NETLOGIC_OIDC_AUDIENCE` | _(सेट नहीं)_ | OIDC श्रोता |
| `NETLOGIC_OIDC_DEFAULT_ORG` | _(सेट नहीं)_ | OIDC उपयोगकर्ताओं के लिए फ़ॉलबैक org_id |
| `NETLOGIC_DATABASE_URL` | _(सेट नहीं)_ | PostgreSQL कनेक्शन स्ट्रिंग |
| `NETLOGIC_SECRETS_KEY` | _(सेट नहीं)_ | आराम पर क्रेडेंशियल के लिए Fernet कुंजी |
| `NETLOGIC_AGENT_TOKEN_MAX_AGE` | `604800` | एजेंट टोकन जीवनकाल (7 दिन) |
| `NETLOGIC_AGENT_PENDING_CAP` | `50` | प्रति एजेंट अधिकतम कतारबद्ध कार्य |
| `NETLOGIC_MAX_AGENTS_PER_ORG` | `100` | अधिकतम पंजीकृत एजेंट |
| `NETLOGIC_AI_PROVIDER` | `openrouter` | डिफ़ॉल्ट AI प्रदाता |
| `NETLOGIC_AI_API_KEY` | _(खाली)_ | डिफ़ॉल्ट AI कुंजी |
| `NETLOGIC_AI_MODEL` | प्रदाता डिफ़ॉल्ट | डिफ़ॉल्ट मॉडल |
| `NETLOGIC_AI_BASE_URL` | प्रदाता डिफ़ॉल्ट | कस्टम आधार URL |
| `NETLOGIC_NVD_KEY` | _(खाली)_ | NVD API कुंजी |
| `NETLOGIC_VALID_LICENSES` | _(खाली)_ | देव/परीक्षण लाइसेंस ओवरराइड |
| `NETLOGIC_LICENSE_KEY` | _(खाली)_ | इंस्टेंस लाइसेंस कुंजी |
| `NETLOGIC_SCANS_DIR` | _(डिफ़ॉल्ट)_ | स्कैन संग्रहण निर्देशिका |
| `NETLOGIC_SIEM_ENDPOINT` | _(खाली)_ | ऑडिट लॉग शिपिंग URL |
| `NETLOGIC_WAPPALYZER_DATA` | _(बिल्ट-इन)_ | Wappalyzer फ़िंगरप्रिंट पथ |

### एजेंट

| चर | डिफ़ॉल्ट | विवरण |
|---|---|---|
| `NETLOGIC_CONTROLLER` | `http://localhost:8000` | नियंत्रक आधार URL |
| `NETLOGIC_API_KEY` | _(सेट नहीं)_ | पंजीकरण के लिए API कुंजी |

---

## सुरक्षा वास्तुकला

### मिडलवेयर स्टैक (लागू क्रम)
1. **AuditMiddleware** — `X-Request-ID` सहसंबंध, संरचित JSON ऑडिट लॉग, SIEM शिपिंग
2. **RequestSizeLimitMiddleware** — 10 MB बॉडी सीमा (DoS सुरक्षा)
3. **LicenseMiddleware** — बिना लाइसेंस के सभी `/v1/` रूट को ब्लॉक करता है (402 लौटाता है)
4. **SecurityHeadersMiddleware** — HSTS (1y), CSP (HTML बनाम API के लिए विभेदित), X-Frame-Options, X-Content-Type-Options, Permissions-Policy, Referrer-Policy
5. **OriginCheckMiddleware** — POST/PUT/DELETE Origin मान्यता (CSRF गहराई में सुरक्षा)
6. **CORSMiddleware** — प्रतिबंधात्मक: कोई वाइल्डकार्ड नहीं, केवल विशिष्ट मूल

### प्रमाणीकरण
- **API कुंजियाँ**: आराम पर SHA-256 हैश्ड; केवल `create()` पर और `verify()` के दौरान अनुरोध बॉडी में सादा पाठ
- **JWT**: मानक लाइब्रेरी (`hashlib`+`hmac`+`base64`) के साथ HS256, सत्यापन से पहले `alg` फ़ील्ड पिन किया गया (alg=none को रोकता है), देव के लिए क्षणिक यादृच्छिक फ़ॉलबैक
- **OIDC**: Clerk/Auth0/WorkOS — RS256 + JWKS, पहले लॉगिन पर स्वचालित रूप से उपयोगकर्ता + संगठन प्रावधान करता है
- **एजेंट टोकन**: रजिस्ट्री में SHA-256 हैश्ड, स्थिर-समय तुलना, 7 दिन की समाप्ति

### दर सीमा
स्लाइडिंग-विंडो इन-मेमोरी। प्रति-एंडपॉइंट, प्रति-स्कोप (IP, org_id, agent_id)। 10 मिनट में 5 असफल टोकन आदान-प्रदान के बाद IP प्रतिबंध (1 घंटा प्रतिबंध)।

### डेटा सुरक्षा
- LLM API कुंजियाँ: आराम पर Fernet-एन्क्रिप्टेड (AES-128-CBC + HMAC-SHA256)। उत्पादन-फेल-क्लोज़: `NETLOGIC_SECRETS_KEY` की आवश्यकता है
- मल्टी-टेनेंसी: सभी डेटा `org_id` तक सीमित; क्रॉस-ऑर्ग लुकअप 404 (403 नहीं) लौटाता है
- पथ ट्रैवर्सल: सभी संग्रहण पथ मान्य, विभाजक और `..` अस्वीकार

---

## सीआई / परीक्षण```bash
pip install -r requirements-dev.txt
python -m pytest

CI पाइपलाइन (.github/workflows/ci.yml) — 5 कार्य:

  1. परीक्षण — 1,000+ pytest केस
  2. postgres-एकीकरण — DB माइग्रेशन + टिकाऊ कार्य + प्रति-संगठन कुंजियाँ
  3. fusion-बेंचमार्क — FP कमी ≥ 80% + महत्वपूर्ण रिकॉल = 100%
  4. सुरक्षा — Bandit (HIGH) + pip-audit
  5. build-डैशबोर्ड — npm ci + npm run build

कानूनी सूचना

NetLogic केवल अधिकृत सुरक्षा मूल्यांकन, पैठ परीक्षण, और नेटवर्क प्रशासन के लिए है। स्पष्ट लिखित अनुमति के बिना होस्ट को स्कैन करना या जांचना अधिकांश न्यायक्षेत्रों में अवैध है। लेखक अनधिकृत उपयोग के लिए कोई दायित्व नहीं लेता है।

लाइसेंस

MIT © 2026 Dmitry Flynn — देखें LICENSE.txt

टूल डाउनलोड करें
मल्टी-होस्ट ऑर्केस्ट्रेशनप्रति होस्ट पूर्ण स्कैन पाइपलाइन → क्रॉस-होस्ट संदर्भ और रीचैबिलिटी मैट्रिक्स → अटैक चेन खोज
AI सेंसर निदेशकLLM तय करता है कि खुले पोर्ट, तकनीक स्टैक और CVE के आधार पर किन सेंसरों को प्राथमिकता दी जाए
प्रमाणित SSHप्रमाणित ssh सबप्रोसेस वास्तविक इंस्टॉल किए गए पैकेज संस्करण (60+ उत्पाद मैपिंग) पढ़ता है
सेवा गणनाप्रोटोकॉल-स्तरीय विशेषता निष्कर्षण (SSH KEX, SMBv1, RDP NLA, SNMP समुदाय, HTTP प्रमाणीकरण स्थिति)
टोपोलॉजी मैपररिवर्स DNS, IPv6, ट्रेसरूट, ip-api.com के माध्यम से ASN/संगठन/देश
रीचैबिलिटी प्रोबरसमझौता के बाद सबनेट आसन्नता से पार्श्व आंदोलन मैट्रिक्स
नेटवर्क प्रोबरसक्रिय सबनेट स्वीप (/24 निजी पड़ोसी) दो-चरण खोज के साथ (लाइव स्वीप → पूर्ण पोर्ट स्कैन)
स्कैन अंतरसमय के साथ परिवर्तन: वर्तमान स्कैन की तुलना प्रति लक्ष्य सबसे हाल के पिछले JSON रिपोर्ट से करता है
लाइसेंस प्रबंधनवाणिज्यिक लाइसेंस प्रणाली कुंजी सक्रियण के साथ (Stripe/Paddle/Lemon Squeezy के लिए स्टब)
प्रति-संगठन AI कॉन्फ़िगप्रत्येक संगठन अपने स्वयं के LLM क्रेडेंशियल्स को Fernet के माध्यम से एन्क्रिप्टेड रूप में संग्रहीत करता है
OIDC / ClerkClerk द्वारा जारी सत्र JWT के माध्यम से मानव लॉगिन, सार्वजनिक JWKS के विरुद्ध सत्यापित, ऑटो-प्रोविज़निंग के साथ
PostgreSQLपूर्ण मल्टी-टेनेंट स्थिरता ऑटो-एप्लाइड माइग्रेशन के साथ (स्कैन जॉब, संगठन सेटिंग्स, तर्क स्थिति, ऑडिट)
फ्यूजन बेंचमार्करिकॉर्ड किए गए HTTP कैसेट के विरुद्ध ऑफलाइन बेंचमार्क; सटीकता/रिकॉल/क्रिटिकल-रिकॉल/FP-कमी मीट्रिक्स
netlogic <target> [flags]
एक-शॉट टर्मिनल स्कैन (कोई सर्वर नहीं), रिपोर्ट प्रिंट/लिखता है।
प्रारूपउदाहरणमोड
होस्टनामexample.comएकल-होस्ट स्कैन
IPv410.0.0.5एकल-होस्ट स्कैन
CIDR192.168.1.0/24CIDR स्वीप (केवल स्कैनर, कोई फ्यूज़न नहीं)
अल्पविराम-पृथक्कृतtarget1,target2बहु-होस्ट ऑर्केस्ट्रेशन (क्रॉस-होस्ट संदर्भ)
  • चरण 8 योजना पास: GoalPlanner जांच योजनाएँ उत्पन्न करता है
  • सतत: ReasoningValidator अखंडता ऑडिट → ProvenanceBuilder किनारों को रिकॉर्ड करता है → स्थिति स्थायी
    • परतवर्गक्या ट्रैक करता है
    WorldModelWorldModelEvidenceGraph, अवलोकन, विश्वास, होस्ट, प्रौद्योगिकी, पहुँच
    InvestigationStateInvestigationStateउद्देश्य (DAG), परिकल्पनाएँ, विरोधाभास, मृत-अंत, वर्तमान व्यक्तित्व
    ExecutionStateExecutionStateबजट, probe_history, प्रोवेनेंस, investigation_plans, AI प्रतिलेख
    LearnedPatternsLearnedPatternsक्रॉस-स्कैन ह्यूरिस्टिक्स + प्लेबुक
    घटकफ़ाइलविवरण
    EvidenceGraphevidence_graph.pyडिडुप्लिकेटेड अस्थायी एंटिटी ग्राफ़ (SHA-256 के माध्यम से सामग्री-संबोधित अवलोकन)
    हाइपोथीसिस इंजनhypothesis.pyसंभावनाओं, एंट्रॉपी, सूचना लाभ, पश्चवर्ती समाधान के साथ प्रतिस्पर्धी उम्मीदवार
    ConfidenceEngineconfidence.pyअलग-अलग स्रोतों पर Noisy-OR; केवल संस्करण 0.60 पर सीमित; KEV/प्रोब 0.97 पर पिन किया गया
    ProvenanceBuilderprovenance.pyअवलोकन→अनुमान→परिकल्पना किनारे, सामग्री-हैश संबोधित
    Schedulerscheduler.pyexplore_reserve (10%) के साथ सूचना-लाभ कार्रवाई चयन
    StrategyManagerstrategy.pyमेटा-रीज़निंग: व्यक्तित्व चयन, अन्वेषण/दोहन मोड, पठार का पता लगाना
    ActionGateaction_gate.pyगहराई में सुरक्षा: जोखिम स्तर (READ_ONLY < SAFE_ACTIVE < INTRUSIVE < EXPLOIT), कोर अधिकतम SAFE_ACTIVE है
    InferenceEngineinference.pyrules/*.json से डिटरमिनिस्टिक नियम, कभी आत्मविश्वास नहीं लिखता
    NovelInferenceEnginenovel_inference.pycache_poisoning, request_smuggling, auth_bypass आदि के लिए नियम
    ExecutionKernelexecution_kernel.pyप्रोब को मान्य करता है + निष्पादित करता है + ट्रेस करता है (स्कोप → रीड-ओनली → बजट → डिडुप → डेप्थ)
    प्लेबुक सिस्टमplaybooks.pyट्रिगर शर्तों और इंटेंट टेम्पलेट्स के साथ YAML प्लेबुक
    परिवर्तन का पता लगानाchange_detection.pyचरण 7: अपरिवर्तनीय अवलोकनों (स्थिति नहीं) का अंतर, DeltaEvents का ScanDelta उत्पन्न करता है
    सक्रिय सत्यापनactive_validation.pyचरण 8b: ActionGate के माध्यम से गैर-विनाशकारी SAFE_ACTIVE प्रोब
    फ़ाइलघटक
    coordinator.pyAICoordinator — चरणबद्ध पाइपलाइन ऑर्केस्ट्रेशन
    proposals.pyटाइप किया गया Proposal लिफ़ाफ़ा जिसमें काइंड-विशिष्ट पेलोड, प्रोवेनेंस, अर्थशास्त्र
    normalize.pyProposalNormalizer — कुल मान्यता गेट
    rank.pyProposalRanker — स्कोर = raw_score × prob_correct × reputation_weight
    meta_reasoner.pyडिटरमिनिस्टिक प्रूनिंग (लूप डिटेक्शन, अनिश्चितता में कमी)
    verifier.py4-चरण: सिंटैक्स → अर्थगत → साक्ष्य → सुरक्षा
    store.pyProposalStore — जीवनचक्र बहीखाता
    transcript.pyInvestigationTranscript — कारण श्रृंखला रिकॉर्डिंग
    evaluation.pyकैसेट-आधारित डिटरमिनिस्टिक मूल्यांकन हार्नेस
    reputation.pyAgentReputation — प्रति एजेंट स्वीकृति/अस्वीकृति दर ट्रैक करता है
    agents/hypothesis_generator.pyC1 — प्रतिस्पर्धी स्पष्टीकरण + नवीन-वल्न परिकल्पनाएँ प्रस्तावित करता है
    agents/counterfactual.pyC11 — खंडन उद्देश्य प्रस्तावित करता है
    agents/investigation_designer.pyC2 — साक्ष्य-संग्रह योजनाएँ डिज़ाइन करता है
    घटकफ़ाइलविवरण
    DeepCoordinatorcoordinator.pyपूर्ण डीप पाइपलाइन को ऑर्केस्ट्रेट करता है: AI सेंसर योजना → ScoutAgent → प्रति-सेवा ProbeAgent → सेवा गणना → Nuclei → सत्यापक → अधिग्रहण → सबनेट प्रोब → टोपोलॉजी → प्रमाणीकरण → अंतर → पहुँच
    ScoutAgentscout_agent.pyनिष्क्रिय रिकॉन: TLS, हेडर, स्टैक, DNS, OSINT
    ProbeAgentprobe_agent.pyपृथक CVE/तकनीक संदर्भ के साथ एक सेवा को लक्षित करता है — प्रोब + सत्यापक चलाता है
    ExploitChainchain.pyफ्यूज़न-पुष्ट निर्णयों पर BFS हमला पथ योजना, PoC उत्पादन
    Sandboxsandbox.pyPoC मान्यता के लिए प्रतिबंधित उपप्रक्रिया (अस्थायी निर्देशिका, टाइमआउट, सफाई)
    Mission / AgentReportmodels.pyएजेंट निर्देशों और परिणामों के लिए डेटा मॉडल
    घटकफ़ाइलविवरण
    run_verifier()engine.pyऑर्केस्ट्रेट करता है: योजनाएँ उत्पन्न करें → निष्पादित करें → प्रोब-पुष्ट सिग्नल बनाएँ
    generate_plans_for_cves()planner.pyप्रति CVE (CVSS ≥ 7.0): ~20 अंतर्निहित योजनाएँ जाँचता है → AI कच्ची HTTP योजना उत्पन्न करता है (विधि, पथ, हेडर, बॉडी, अपेक्षित स्थिति/बॉडी)
    run_test()runner.pyकच्चा TCP/TLS सॉकेट निष्पादन, मैन्युअल HTTP/1.0 पार्सिंग, अपेक्षित बॉडी पैटर्न मिलान
    निदेशकफ़ाइलक्या निर्णय लेता है
    SensorDirectorsensor_director.pyखुले पोर्ट + तकनीक स्टैक + CVEs के आधार पर कौन से सेंसर सक्षम/अक्षम करने हैं और किस प्राथमिकता पर
    ReprobeDirectorreprobe.pyक्या संभावित निष्कर्षों को लक्षित HTTP प्रोब से हल किया जा सकता है
    NucleiSelectornuclei_selector.pyकौन से Nuclei टेम्पलेट टैग शामिल/बहिष्कृत करने हैं (अप्रासंगिक रन कम करता है)
    SubnetDirectorsubnet_director.pyकौन से आसन्न होस्ट को प्रोब करना है, कौन से पोर्ट, किस गहराई पर (स्किप/क्विक/स्टैंडर्ड/डीप)