NetLogic ist ein fortschrittliches Toolkit für Netzwerkanalyse und Cybersicherheit zur Datenverkehrsinspektion, Paketanalyse und Bedrohungserkennung.
Cloud-native Angriffsflächen-Mapper & Schwachstellen-Korrelator — v3.0
NetLogic ist eine Netzwerksicherheitsplattform, die aktives Port-Scanning, CVE-Korrelation (live NVD-API), SSL/TLS-Analyse, HTTP-Sicherheitsaudit, DNS-/E-Mail-Sicherheitsbewertung, Subdomain-Übernahmeerkennung, passives OSINT, aktives Schwachstellen-Scanning, eine KI-gesteuerte Reasoning-Engine, Cross-Host-Angriffsketten-Erkennung und Deep-Probe-Agent-Architektur kombiniert – bereitgestellt als Web-App (React-Dashboard + FastAPI). Die Kern-Scan-Engine ist reines Python 3.9+ stdlib ohne Drittanbieter-Abhängigkeiten.
| Modul | Beschreibung |
|---|---|
| Port-Scanner | TCP-Connect-Scan mit 43/58 Ports, 22 Service-Probes, Banner-Grabbing |
| CVE-Korrelator | Live NVD API v2.0 + EPSS-Anreicherung über FIRST.org |
| TLS-Analyzer | Protokollversionen, schwache Cipher, POODLE/BEAST/CRIME/DROWN, Zertifikatsablauf |
| HTTP-Header-Audit | HSTS, CSP, X-Frame-Options, CORS, Cookie-Flags; 0–100 Punkte |
| Stack-Fingerprint | CMS, Framework, Cloud-Provider, CDN, WAF-Erkennung aus Banner/Header/Body |
| DNS-Sicherheit | SPF, DKIM, DMARC, DNSSEC, Zonenübertragung, Spoofability-Score |
| Passives OSINT | Certificate-Transparency-Logs, DoH-DNS, ASN-Abfrage – kein direkter Zielkontakt |
| Service-Prober | Unauthentifizierte Redis/Mongo/ES/Docker/K8s/etcd-Probes, 33 Admin-Pfade |
| Takeover-Detektor | CT-Log-Subdomain-Erkennung + 25 Cloud-Provider-CNAME-Fingerprints |
| Nuclei-Integration | Wrapper für 13k+ Community-Vorlagen (CVE, Tech, Exposure, Misconfig) – MIT-Lizenz |
| Fusion-Pipeline | Multi-Sensor-Signal-Gate → deterministische Übereinstimmung → KI-Entscheidung → Angriffsgraph → 6-teiliger Bericht |
| Web-Fingerprint | Favicon-Hash (Shodan-kompatibel mmh3), JS-Secrets, Versionsmarker, exponierte Dateien, Standard-Lander-Erkennung |
| KI-Analyse | OpenAI / Anthropic / OpenRouter / Ollama / Gemini / Groq / Kimi / Qwen – Token-Streaming-SSE |
| Reasoning-Engine | Adaptive Observe→Reason→Act-Schleife mit EvidenceGraph, Hypothesen-Engine, Confidence-Delay, Provenance, Scheduler, Playbooks, Änderungserkennung, aktiver Validierung |
| Deep Probe | Pro-Service-Agent-Architektur: ScoutAgent (Recon), ProbeAgent (gezielte CVE-Checks), Koordinator, Sandbox |
| KI-Untersuchungs-Agent | ReAct-artige Schleife: Nach den Basis-Sensoren treibt die KI eine kuratierte, bereichsbegrenzte, überwachte Tool-Oberfläche (~35 Tools) an, um Leads zu verifizieren und Angriffsketten aufzubauen – mit optionalen aggressiven Tools (Crash-Probes, freiform Beweis, freiform Exploit) für autorisierte Ziele |
Es gibt genau zwei Möglichkeiten, NetLogic auszuführen:
| Modus | Befehl | Funktion |
|---|---|---|
| Web-App | netlogic --gui | Startet FastAPI + serviert die React-SPA + In-Process-Scan-Agent, generiert automatisch Secrets und öffnet das Dashboard im Browser. Dies ist die einzige Möglichkeit, die Web-App auszuführen. |
| CLI |
Die Produktoberfläche ist die Web-App (React-Dashboard + FastAPI). Die Scan-Engine unter src/ betreibt über die Benutzeroberfläche gestartete Jobs.
pip install -r requirements-api.txt pip install -e .
netlogic --gui
netlogic scanme.nmap.org --full
## CLI-Referenz```
netlogic [target] [flags]
Der Einstiegspunkt ist api.cli:main (definiert in pyproject.toml), welcher an netlogic.py:main() delegiert. Die gesamte Scan-Logik befindet sich in src/.
netlogic example.com
netlogic example.com --full
netlogic example.com --tls --headers
netlogic example.com --takeover
netlogic example.com --osint
netlogic example.com --stack
netlogic example.com --dns
netlogic 10.0.0.5 --probe
netlogic example.com --full --probe
### Portauswahl```
# 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
netlogic example.com --ai --ai-key $KEY
netlogic example.com --ai --ai-provider openai --ai-key $KEY --ai-model gpt-4o-mini
netlogic example.com --ai --ai-provider anthropic --ai-key $KEY
netlogic example.com --ai --ai-provider gemini --ai-key $KEY --ai-model gemini-2.0-flash
netlogic example.com --ai --ai-provider ollama
netlogic example.com --ai --ai-provider custom --ai-base-url https://... --ai-model model-name
### Unterstützte KI-Anbieter
| Anbieter | Standardmodell | API-Stil |
| `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` | benutzerdefiniert | OpenAI |
### Reasoning-Engine```
# 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
Nachdem die Basis-Sensoren ausgeführt wurden, ermöglicht ein optionaler ReAct-ähnlicher Agent der KI, eigene Werkzeuge zu steuern, um Hinweise zu überprüfen und Angriffsketten aufzubauen, anstatt Treffer zu Versionen/Bannern von CVEs als unbestätigte Hinweise stehen zu lassen. Die KI schlägt Werkzeugaufrufe vor; eine deterministische Laufzeitumgebung führt sie aus – jedes Werkzeug ist bereichsbeschränkt auf das Ziel, bereinigt und als Beobachtung aufgezeichnet. Die KI berührt niemals direkt die Leitung.```
netlogic example.com --ai --ai-agent
netlogic example.com --ai --agent-depth --agent-max-steps 24 --agent-max-requests 80
Der Agent hat standardmäßig ~35 schreibgeschützte/sichere aktive Werkzeuge: HTTP/TLS/DNS-Sonden, `dir_enum`, `confirm_tech`,
`timing_probe`, `cve_probe` (kuratierte bekannte-CVE-Marker-Prüfungen), `sqli_boolean`/`sqli_time`, `ssrf_canary`,
`idor_diff`, `file_disclosure`, `browser_get` (headless, umgeht JS-Herausforderungen), plus HackerOne-Buchhaltung
(`record_poc`, `severity_suggest`, `submit_readiness`).
**Opt-in aggressive Werkzeuge** — standardmäßig deaktiviert, **NUR für AUTORISIERTE / eigene In-Scope-Ziele** (niemals bei einem öffentlichen oder fremden Scan). Jedes erfordert `--ai-agent`:
| Flagge | Werkzeug | Was es freischaltet | Beibehaltene Einschränkungen |
|---|---|---|---|
| `--allow-crash-probes` | `crash_probe` | Kuratierte Crash/DoS-CVE-Prüfungen (http.sys, MS15-034), die den Host ZUM ABSTURZ BRINGEN KÖNNEN | Fester Katalog von 3 CVEs — nicht freiform |
| `--allow-freeform-proof` | `http_proof` | Stufe C: freiform GET/HEAD/OPTIONS (+ POST auf Such-/Login-/graphql-artigen Pfaden) | Destruktive Muster + PUT/PATCH/DELETE blockiert; Beweis, keine Mutation |
| `--allow-exploit-requests` | `exploit_request` | Stufe E: **beliebige Methode** (inkl. PUT/PATCH/DELETE) + beliebiger Pfad/Header/Body gegen das Ziel | Scope-begrenzt; fail-closed bei massiv destruktiven Mustern (DROP/TRUNCATE TABLE, `rm -rf`) und CR/LF-Header-Injection; jede Anfrage geprüft |
Das deterministische ActionGate hält den Kern auf `safe_active`; diese drei Flags sind die expliziten, geprüften Opt-ins darüber. Beispiel (eigene Laborbox + lokales Modell):```
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
netlogic example.com --ssh-user admin --ssh-key ~/.ssh/id_rsa
netlogic example.com --ssh-user admin --ssh-pass SECRET
netlogic example.com --ssh-user admin --ssh-key ~/.ssh/id_rsa --ssh-port 2222
### Benchmark```
# 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
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
netlogic example.com --out ./reports
netlogic example.com --min-cvss 7.0
netlogic example.com --no-color
### NVD Cache-Verwaltung```
netlogic --cache-stats
netlogic example.com --nvd-key YOUR_NVD_KEY
netlogic --version # Show version and exit netlogic --gui # Start web dashboard
---
## Fusions-Pipeline
Die Fusions-Pipeline ist ein **Sensoren → Gate → KI-Beurteilung → Synthese**-Trichter, der monolithische KI-Aufrufe durch ein Präzisions-Gate ersetzt. Sie befindet sich in `src/fusion/` (12 Dateien).
### Signal-Schema (`src/fusion/signals.py`)
Beweisführender Datenvertrag. Jeder Sensor gibt `Signal`-Objekte aus:
- `source`: `probe`/`banner`/`nuclei`/`wappalyzer`/`nvd`/`osv`/`tls`/`dns`
- `kind`: `vuln`/`tech`/`exposure`/`misconfig`/`service`
- `claim`: normalisierter Betreff (z. B. `"CVE-2021-44228"`, `"nginx"`)
- `host`, `port`, `service`, `evidence` (auf 600 Zeichen begrenzt)
- `confidence` (0..1), `reliability` (`high`/`medium`/`low`)
- `kev`, `epss` (0..1), `cvss` (0..10), `exploit_available`, `version_matched`, `probe_confirmed`
- `exposure` dict (Erreichbarkeit, WAF, Sichtweise)
- `observed_data` (rohe Bytes, die an die KI gesendet werden – KEINE Sensornamen oder Schweregrade, um Label-Bias zu vermeiden)
- `ai_view()` entfernt Sensor-Metadaten, gibt nur beobachtete Fakten zurück
### Gate (`src/fusion/gate.py`)
Deterministische Übereinstimmung – gegeben `list[Signal]`, gruppiert nach Betreff und gibt `list[Verdict]` zurück:
| Bedingung | Urteil |
|---|---|
| KEV-gelistet ODER probe-bestätigt ODER kritisch+exploit/hoher EPSS | **Bestätigt** (festgelegt – nicht entfernbar) |
| ≥2 unabhängige Quellen stimmen überein, ≥1 hohe Zuverlässigkeit | **Bestätigt** (außer alle sind version-gematched → grau) |
| Alleinstehend niedrige Zuverlässigkeit, niedrige/mittlere Auswirkung, keine Bestätigung | **Verworfen** |
| Alles andere | **Grau** (kostet ein KI-Token) |
### KI-Beurteilung (`src/fusion/adjudicator.py`)
Betrifft nur den grauen Bereich. Sicherheitsbeschränkungen im Code (nicht im Prompt) erzwungen:
- Hohe/kritische graue Elemente können NIE verworfen werden – höchstens auf `potential` herabgestuft
- Nur version-matches werden auf `potential` begrenzt (Distributionen backporten ohne Versionssprünge)
- KI entdeckt auch neue Befunde aus dem vollständigen Host-Kontext
- Fehlertolerant: KI-Ausfall belässt grauen Bereich als `potential` – kein stiller Datenverlust
### Synthese (`src/fusion/synthesis.py`)
`build_attack_graph(verdicts)` → deterministischer Erreichbarkeitsgraph aus BESTÄTIGTEN Befunden.
`full_synthesize(...)` → 6-teiliger KI-Bericht:
1. Zusammenfassung
2. Wichtigste Befunde (Tabelle)
3. Angriffsketten (graphbasiert, LLM erzählt echte Kanten)
4. Jenseits bekannter CVEs
5. False Positives & Rauschen
6. Behebung
### Sensoren
| Sensor | Datei | Was es produziert |
|---|---|---|
| Engine-Brücke | `engine_bridge.py` | Konvertiert Scan-Artefakte → Signale von NVD, Probes, Stack, Nuclei, Verifier |
| Wappalyzer | `sensors/wappalyzer.py` | Null-Abhängigkeits-Wappalyzer-kompatibles Fingerprinting von HTTP-Antworten |
| Nuclei | `sensors/nuclei.py` | Führt YAML-Vorlagen gegen Antworten aus (Teilmenge der Nuclei-Syntax) |
| Cassette | `cassette.py` | Aufnahme/Wiedergabe von HTTP-Cassetten (Offline-Benchmark-Daten) |
### Hostübergreifend (`src/fusion/cross_host.py`)
Nach der Beurteilung erfolgt die gruppierung von Urteilen über Hosts hinweg nach gemeinsamem Dienst+Version für die Erzählung von Mehrsprung-Angriffsketten in der Synthese.
### Pipeline-Ablauf```
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
Befindet sich in src/reasoning/ (~58 Dateien). Mehrphasiger, sicherheitsgesteuerter observe→reason→act-Loop. Aktiviert mit --reason.
src/reasoning/director.py — ReconDirector.run())StrategyManager wählt Persona → Scheduler wählt Aktion → SensorStep führt aus → EvidenceGraph faltet Beobachtungen ein → ConfidenceEngine aktualisiert ÜberzeugungenProposal-Hüllen vor → AICoordinator normalisiert/bewertet/verifiziert → akzeptierte Vorschläge werden in den Zustand eingespeist → Compiler → ExecutionPlanner → ExecutionKernel führt Sonden aus → InferenceEngine löst aufCrossHostGraph, erzeugt untergeordnete HostReasoner-Instanzensrc/reasoning/state.py)src/reasoning/ai/)Pipeline: Generieren → Normalisieren → Bewerten → (MetaReasoner pruning) → Verifizieren → Speichern
Befindet sich in src/deep/ (7 Dateien). Wird mit --deep-probe verwendet. Pro‑Dienst‑Agentenarchitektur für kontextisolierte Sondenausführung.
DeepCoordinator.run()‑Ablauf:
_build_sensor_plan via sensor_director)ScoutAgent für passive Aufklärung entsendenProbeAgent‑Instanzen (jede mit isoliertem CVE/‑Technologiekontext)Befindet sich in src/verifier/ (3 Dateien). KI‑gestützte CVE‑Bestätigung mit gezielten Sonden.
Phase‑2‑Neuverifikation (reverify_with_context) stellt vollständigen Host‑Kontext zur Verfügung, um fehlgeschlagene Tests zu verfeinern.
Befindet sich in src/directors/ (4 Dateien). LLM‑gesteuerte Scan‑Parameterauswahl.
Befindet sich in src/orchestrator.py. Wird durch kommagetrennte Ziele ausgelöst. Führt run_scan() pro Host aus, aggregiert Ergebnisse, baut hostübergreifenden Kontext aus kombinierten Fusion‑Entscheidungen auf. Hostübergreifende Gruppen erkennen gemeinsame Dienste/Versionen über mehrere Hosts hinweg für Multi‑Hop‑Angriffskettenerzählung.
src/nvd_lookup.py)--nvd-key)src/epss.py): FIRST.org‑API in Batches von 100 CVE‑IDs, 24h‑Festplatten‑Cache unter ~/.netlogic/epss_cache.json, Fail‑Soft auf 0,0src/external/nuclei_runner.py kapselt das Nuclei‑Binary (MIT‑Lizenz). Optional — verhält sich gnädig, wenn das Binary nicht gefunden wird. Ergebnisse fließen als typisierte Signale in die Fusion‑Pipeline (Schweregrad‑Labels entfernt, um LLM‑Verzerrung zu verhindern).```
scoop install nuclei # Windows brew install nuclei # macOS go install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest # Linux
---
## Fusion Benchmark
`src/fusion/benchmark.py` — Offline-Messung gegen gelabelte HTTP-Kassetten (`benchmark/*.json` und `src/fusion/data/`). Metriken:
| Metrik | Schwellenwert |
|---|---|
| FP-Reduktion | ≥ 80% |
| Kritischer Recall | = 100% |
Zwei Modi:
- **Orakel** (`--benchmark`): Obergrenze perfekter KI – misst allein die deterministische Mechanik
- **Echtes Modell** (`--benchmark --benchmark-ai`): gemessen mit konfiguriertem LLM
---
## Architektur```
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
Alle Routen unter dem Präfix /v1/. Authentifizierung:
POST /v1/auth/token → HS256 JWT (Standard-Ablauf 1h)require_org-Abhängigkeit verifiziert gegen JWKSPOST /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]
### Stellen```
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
### Lizenz / Einstellungen```
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
## Umgebungsvariablen
### Controller
| Variable | Standard | Beschreibung |
|---|---|---|
| `NETLOGIC_ENV` | _(nicht gesetzt)_ | `production`/`prod` = geheime Validierung beim Start |
| `NETLOGIC_JWT_SECRET` | `changeme-in-production` | HS256-Signierungsschlüssel, ≥32 Zeichen |
| `NETLOGIC_JWT_EXPIRY` | `3600` | JWT-Lebensdauer in Sekunden |
| `NETLOGIC_ADMIN_KEY` | `admin-changeme` | Admin-Anmeldedaten, ≥32 Zeichen in Produktion |
| `NETLOGIC_API_KEYS` | _(leer)_ | Startwerte: `key1:org1,key2:org2,...` |
| `NETLOGIC_CORS_ORIGINS` | _(leer)_ | Erlaubte Ursprünge (CORS deaktiviert, wenn leer) |
| `NETLOGIC_PORT` | `8000` | Binde-Port |
| `NETLOGIC_HOST` | `0.0.0.0` | Binde-Adresse |
| `NETLOGIC_NO_BROWSER` | _(nicht gesetzt)_ | `1` deaktiviert automatisches Öffnen |
| `NETLOGIC_OIDC_ISSUER` | _(nicht gesetzt)_ | Clerk Frontend-API-URL → OIDC-Anmeldung |
| `NETLOGIC_OIDC_AUDIENCE` | _(nicht gesetzt)_ | OIDC-Zielgruppe |
| `NETLOGIC_OIDC_DEFAULT_ORG` | _(nicht gesetzt)_ | Fallback-org_id für OIDC-Benutzer |
| `NETLOGIC_DATABASE_URL` | _(nicht gesetzt)_ | PostgreSQL-Verbindungszeichenfolge |
| `NETLOGIC_SECRETS_KEY` | _(nicht gesetzt)_ | Fernet-Schlüssel für ruhende Anmeldedaten |
| `NETLOGIC_AGENT_TOKEN_MAX_AGE` | `604800` | Agent-Token-Lebensdauer (7 Tage) |
| `NETLOGIC_AGENT_PENDING_CAP` | `50` | Max. Anzahl wartender Aufgaben pro Agent |
| `NETLOGIC_MAX_AGENTS_PER_ORG` | `100` | Max. Anzahl registrierter Agents |
| `NETLOGIC_AI_PROVIDER` | `openrouter` | Standard-KI-Anbieter |
| `NETLOGIC_AI_API_KEY` | _(leer)_ | Standard-KI-Schlüssel |
| `NETLOGIC_AI_MODEL` | Standard des Anbieters | Standardmodell |
| `NETLOGIC_AI_BASE_URL` | Standard des Anbieters | Benutzerdefinierte Basis-URL |
| `NETLOGIC_NVD_KEY` | _(leer)_ | NVD-API-Schlüssel |
| `NETLOGIC_VALID_LICENSES` | _(leer)_ | Entwicklungs-/Test-Lizenzüberschreibungen |
| `NETLOGIC_LICENSE_KEY` | _(leer)_ | Instanzlizenzschlüssel |
| `NETLOGIC_SCANS_DIR` | _(Standard)_ | Verzeichnis für Scan-Speicher |
| `NETLOGIC_SIEM_ENDPOINT` | _(leer)_ | URL für Audit-Log-Versand |
| `NETLOGIC_WAPPALYZER_DATA` | _(eingebaut)_ | Pfad zu Wappalyzer-Fingerabdrücken |
### Agent
| Variable | Standard | Beschreibung |
|---|---|---|
| `NETLOGIC_CONTROLLER` | `http://localhost:8000` | Basis-URL des Controllers |
| `NETLOGIC_API_KEY` | _(nicht gesetzt)_ | API-Schlüssel für die Registrierung |
---
## Sicherheitsarchitektur
### Middleware-Stapel (Reihenfolge der Anwendung)
1. **AuditMiddleware** — `X-Request-ID`-Korrelation, strukturiertes JSON-Audit-Log, SIEM-Versand
2. **RequestSizeLimitMiddleware** — 10-MB-Byte-Limit (DoS-Schutz)
3. **LicenseMiddleware** — blockiert alle `/v1/`-Routen, wenn keine Lizenz vorhanden (gibt 402 zurück)
4. **SecurityHeadersMiddleware** — HSTS (1 Jahr), CSP (differenziert HTML vs. API), X-Frame-Options, X-Content-Type-Options, Permissions-Policy, Referrer-Policy
5. **OriginCheckMiddleware** — POST/PUT/DELETE-Origin-Validierung (CSRF-Tiefenverteidigung)
6. **CORSMiddleware** — restriktiv: kein Wildcard, nur bestimmte Ursprünge
### Authentifizierung
- **API-Schlüssel**: SHA-256-gehasht im Ruhezustand; Klartext nur bei `create()` und im Anforderungstext während `verify()`
- **JWT**: HS256 mit stdlib (`hashlib`+`hmac`+`base64`), `alg`-Feld vor der Verifizierung festgelegt (verhindert alg=none), flüchtiger zufälliger Fallback für die Entwicklung
- **OIDC**: Clerk/Auth0/WorkOS — RS256 + JWKS, erstellt automatisch Benutzer und Organisationen bei der ersten Anmeldung
- **Agent-Token**: SHA-256-gehasht im Registry, konstanter Zeitvergleich, 7-Tage-Ablauf
### Ratenbegrenzung
Sliding-Window im Arbeitsspeicher. Pro Endpunkt, pro Bereich (IP, org_id, agent_id). IP-Sperrung nach 5 fehlgeschlagenen Token-Austauschen in 10 Minuten (1 Stunde Sperre).
### Datenschutz
- LLM-API-Schlüssel: Fernet-verschlüsselt im Ruhezustand (AES-128-CBC + HMAC-SHA256). Produktion-fail-closed: erfordert `NETLOGIC_SECRETS_KEY`
- Multi-Tenancy: Alle Daten auf `org_id` beschränkt; organisationsübergreifende Suche gibt 404 zurück (nicht 403)
- Pfaddurchquerung: Alle Speicherpfade werden validiert, Trennzeichen und `..` werden abgelehnt
---
## CI / Tests```bash
pip install -r requirements-dev.txt
python -m pytest
CI-Pipeline (.github/workflows/ci.yml) — 5 Jobs:
pip-auditnpm ci + npm run buildNetLogic ist nur für autorisierte Sicherheitsbewertungen, Penetrationstests und Netzwerkadministration bestimmt. Das Scannen oder Testen von Hosts ohne ausdrückliche schriftliche Genehmigung ist in den meisten Rechtsordnungen illegal. Der Autor übernimmt keine Haftung für unbefugte Nutzung.
MIT © 2026 Dmitry Flynn — Siehe LICENSE.txt
| Verifier-Engine |
| KI-gesteuerte CVE-Neuverifikation: Entwirft rohe HTTP-Probe-Pläne aus CVE-Kontext, führt über stdlib-Sockets aus |
| Multi-Host-Orchestrierung | Vollständige Scan-Pipeline pro Host → cross-host-Kontext und Erreichbarkeitsmatrix → Angriffsketten-Erkennung |
| KI-Sensor-Direktoren | LLM entscheidet, welche Sensoren basierend auf offenen Ports, Tech-Stack und CVEs priorisiert werden |
| Authentifiziertes SSH | Credentialed ssh-Subprozess liest echte installierte Paketversionen (60+ Produktzuordnungen) |
| Service-Enum | Protokollebene-Attributextraktion (SSH KEX, SMBv1, RDP NLA, SNMP Community, HTTP-Auth-Status) |
| Topologie-Mapper | Reverse-DNS, IPv6, Traceroute, ASN/Org/Land über ip-api.com |
| Erreichbarkeits-Prober | Post-Compromise-Lateral-Movement-Matrix aus Subnetz-Adjazenz |
| Netzwerk-Prober | Aktiver Subnetz-Sweep (/24 private Nachbarn) mit zweiphasiger Erkennung (Live-Sweep → vollständiger Port-Scan) |
| Scan-Diff | Änderungen im Zeitverlauf: Vergleicht aktuellen Scan mit dem letzten vorherigen JSON-Bericht pro Ziel |
| Lizenzverwaltung | Kommerzielles Lizenzsystem mit Schlüsselaktivierung (Stub für Stripe/Paddle/Lemon Squeezy) |
| Pro-Org-KI-Konfiguration | Jede Organisation speichert ihre eigenen LLM-Zugangsdaten, ruhend mit Fernet verschlüsselt |
| OIDC / Clerk | Menschliche Logins über von Clerk ausgestellte Session-JWTs, verifiziert gegen öffentliches JWKS mit automatischer Bereitstellung |
| PostgreSQL | Vollständige Multi-Tenant-Persistenz mit automatisch angewendeten Migrationen (Scan-Jobs, Org-Einstellungen, Reasoning-Status, Audit) |
| Fusion-Benchmark | Offline-Benchmark gegen aufgezeichnete HTTP-Cassetten; Precision/Recall/Critical-Recall/FP-Reduction-Metriken |
netlogic <target> [flags] |
| Einmaliger Terminal-Scan (kein Server), gibt Bericht aus/schreibt ihn. |
| Format | Beispiel | Modus |
|---|
| Hostname | example.com | Einzelhost-Scan |
| IPv4 | 10.0.0.5 | Einzelhost-Scan |
| CIDR | 192.168.1.0/24 | CIDR-Sweep (nur Scanner, keine Fusion) |
| Kommagetrennt | target1,target2 | Multi-Host-Orchestrierung (kontextübergreifend) |
GoalPlanner erzeugt UntersuchungspläneReasoningValidator Integritätsaudit → ProvenanceBuilder zeichnet Kanten auf → Zustand wird persistiert| Ebene | Klasse | Was wird nachverfolgt |
|---|
| WorldModel | WorldModel | EvidenceGraph, Beobachtungen, Überzeugungen, Hosts, Technologie, Erreichbarkeit |
| InvestigationState | InvestigationState | Ziele (DAG), Hypothesen, Widersprüche, Sackgassen, aktuelle Persona |
| ExecutionState | ExecutionState | Budget, probe_history, Provenienz, investigation_plans, AI-Transkript |
| LearnedPatterns | LearnedPatterns | Scannübergreifende Heuristiken + Playbooks |
| Komponente | Datei | Beschreibung |
|---|
| EvidenceGraph | evidence_graph.py | Deduplizierter temporaler Entitätsgraph (inhaltsadressierte Beobachtungen via SHA‑256) |
| Hypothesen‑Engine | hypothesis.py | Konkurrierende Kandidaten mit Wahrscheinlichkeiten, Entropie, Informationsgewinn, posteriorer Auflösung |
| ConfidenceEngine | confidence.py | Noisy‑OR über verschiedene Quellen; versionsabhängig gedeckelt bei 0,60; KEV/Probe fest bei 0,97 |
| ProvenanceBuilder | provenance.py | Beobachtung→Schlussfolgerung→Hypothese‑Kanten, inhaltsadressiert |
| Scheduler | scheduler.py | Informationsgewinn‑Aktionsauswahl mit explore_reserve (10 %) |
| StrategyManager | strategy.py | Meta‑Reasoning: Personenauswahl, explore/exploit‑Modus, Plateauerkennung |
| ActionGate | action_gate.py | Defense‑in‑Depth: Risikostufen (READ_ONLY < SAFE_ACTIVE < INTRUSIVE < EXPLOIT), Kern maximal SAFE_ACTIVE |
| InferenceEngine | inference.py | Deterministische Regeln aus rules/*.json, schreibt nie Konfidenz |
| NovelInferenceEngine | novel_inference.py | Regeln für Cache‑Poisoning, Request‑Smuggling, Auth‑Bypass usw. |
| ExecutionKernel | execution_kernel.py | Validiert + führt aus + verfolgt Sonden (Scope → Read‑Only → Budget → Dedup → Tiefe) |
| Playbook‑System | playbooks.py | YAML‑Playbooks mit Auslösebedingungen und Intent‑Vorlagen |
| Änderungserkennung | change_detection.py | Phase 7: Differenzen von unveränderlichen Beobachtungen (nicht Zustand), erzeugt ScanDelta mit DeltaEvents |
| Aktive Validierung | active_validation.py | Phase 8b: nicht‑zerstörerische SAFE_ACTIVE‑Sonden durch ActionGate |
| Datei | Komponente |
|---|
coordinator.py | AICoordinator — gestufte Pipeline‑Orchestrierung |
proposals.py | Typisierte Proposal‑Hülle mit art‑spezifischer Nutzlast, Provenienz, Wirtschaftlichkeit |
normalize.py | ProposalNormalizer — totale Validierungsschranke |
rank.py | ProposalRanker — Score = raw_score × prob_correct × reputation_weight |
meta_reasoner.py | Deterministisches Pruning (Schleifenerkennung, Unsicherheitsreduktion) |
verifier.py | 4‑Stufen: Syntax → Semantik → Beweis → Sicherheit |
store.py | ProposalStore — Lebenszyklus‑Ledger |
transcript.py | InvestigationTranscript — kausale Kettenaufzeichnung |
evaluation.py | Kassettenbasierte deterministische Evaluierungsharnische |
reputation.py | AgentReputation — verfolgt Annahme‑/Ablehnungsrate pro Agent |
agents/hypothesis_generator.py | C1 — schlägt konkurrierende Erklärungen + neue Schwachstellenhypothesen vor |
agents/counterfactual.py | C11 — schlägt Widerlegungsziele vor |
agents/investigation_designer.py | C2 — entwirft Beweissammelpläne |
| Komponente | Datei | Beschreibung |
|---|
DeepCoordinator | coordinator.py | Orchestriert die gesamte Tiefen‑Pipeline: AI‑Sensorplan → ScoutAgent → Pro‑Dienst‑ProbeAgent → Dienstaufzählung → Nuclei → Verifizierer → Übernahme → Subnetz‑Sonde → Topologie → Authentifizierung → Diff → Erreichbarkeit |
ScoutAgent | scout_agent.py | Passive Aufklärung: TLS, Header, Stack, DNS, OSINT |
ProbeAgent | probe_agent.py | Zielt auf einen Dienst mit isoliertem CVE/Tech‑Kontext — führt Sonden + Verifizierer aus |
ExploitChain | chain.py | BFS‑Angriffspfadplanung über fusion‑bestätigte Entscheidungen, PoC‑Generierung |
Sandbox | sandbox.py | Eingeschränkter Unterprozess für PoC‑Validierung (tmp‑Verzeichnis, Timeout, Bereinigung) |
Mission / AgentReport | models.py | Datenmodelle für Agentenweisungen und Ergebnisse |
| Komponente | Datei | Beschreibung |
|---|
run_verifier() | engine.py | Orchestriert: Pläne generieren → ausführen → sondenbestätigte Signale konstruieren |
generate_plans_for_cves() | planner.py | Pro CVE (CVSS ≥ 7,0): prüft ~20 integrierte Pläne → KI generiert rohen HTTP‑Plan (Methode, Pfad, Header, Body, erwarteter Status/Body) |
run_test() | runner.py | Raw‑TCP/TLS‑Socket‑Ausführung, manuelle HTTP/1.0‑Analyse, erwartetes Body‑Muster‑Matching |
| Director | Datei | Was wird entschieden |
|---|
SensorDirector | sensor_director.py | Welche Sensoren aktiviert/deaktiviert werden und mit welcher Priorität, basierend auf offenen Ports + Technologie‑Stack + CVEs |
ReprobeDirector | reprobe.py | Ob potenzielle Funde mit gezielten HTTP‑Sonden aufgelöst werden können |
NucleiSelector | nuclei_selector.py | Welche Nuclei‑Vorlagen‑Tags ein‑/ausgeschlossen werden (reduziert irrelevante Läufe) |
SubnetDirector | subnet_director.py | Welche benachbarten Hosts sondiert werden, welche Ports, in welcher Tiefe (skip/quick/standard/deep) |