Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
tengu — KI-gestützter Penetrationstest MCP Server | Kitploit
Tools/GitHubGitHub/rfunix/tengu
OSINT (Open-Source-Intelligence)Penetrationstest-FrameworksAufklärungSchwachstellenscannerExploit-FrameworksWebsicherheitNetzwerksicherheitCloud-SicherheitLernen & BildungRed TeamingKI-Sicherheit
588vor 5 MonatenVon Kitploit geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen
GitHub
rfunix/tengu

tengu

KI-gestützter Penetrationstest MCP Server

Repository anzeigen

Tengu — MCP-Server für Pentesting

Tengu

"In der japanischen Mythologie ist der Tengu ein wilder Berggeist – Meisterstratege, Krieger und Ausbilder von Samurai. In der Cybersicherheit führt er dich durch jede Phase der Jagd."

Von der Aufklärung bis zum Bericht – KI-gestütztes Pentesting in einem Befehl.

CI License Python MCP Tools Version Agent


Tengu ist ein MCP-Server, der Claude in einen Copilot für Penetrationstests verwandelt. Er orchestriert 80 Sicherheitstools – von Nmap bis Metasploit – mit integrierten Sicherheitskontrollen, Audit-Logs und professionellen Berichten.

  • Was ist es? Ein MCP-Server, der Claude mit branchenüblichen Pentest-Tools verbindet
  • Warum verwenden? Automatisiert Recon und Scanning, während der Mensch die Kontrolle über Exploits behält
  • Für wen ist es? Pentester, Red-Teamer, Sicherheitsstudenten und Beratungsunternehmen

Hauptfunktionen

  • 80 Tools — Nmap, Metasploit, SQLMap, Nuclei, Hydra, Burp-kompatibles ZAP und mehr
  • KI-gesteuert — Claude entscheidet anhand bisheriger Erkenntnisse über das nächste Tool
  • Sicherheit zuerst — Allowlist, Ratenbegrenzung, Audit-Logs und Human-in-the-loop für destruktive Aktionen
  • Automatische Berichte — Korreliert Ergebnisse und erstellt professionelle Pentest-Berichte (MD/HTML/PDF)
  • 35 Workflows — Vorgefertigte Prompts für vollständiges Pentesting, Webanwendungen, AD, Cloud und mehr
  • 20 Ressourcen — Integrierte OWASP Top 10, MITRE ATT&CK, PTES und Pentest-Checklisten
  • Tarnschicht — Optionales Tor/SOCKS5-Proxy-Routing, UA-Rotation und Timing-Jitter

MCP-Server-Modus (Copilot)

Verwende Claude als interaktiven Pentest-Copilot – du leitest den Einsatz, Claude wählt die richtigen Tools und verknüpft sie automatisch.

Tengu Copilot Demo

Schnellstart```bash

git clone https://github.com/rfunix/tengu.git && cd tengu make docker-build make docker-up

root@kitploit:~
Verbinde Claude Code mit dem laufenden Server:```bash
claude mcp add --transport sse tengu http://localhost:8000/sse

Dann frag Claude: Führe einen vollständigen Pentest auf http://192.168.1.100 durch

Claude verknüpft Tools automatisch: validate_target → whatweb → nmap → nikto → nuclei → sqlmap → correlate_findings → generate_report

Docker-Profile

BefehlWas gestartet wird

Benutzerdefinierte Ziele ohne Dateibearbeitung scannen:```bash TENGU_ALLOWED_HOSTS="192.168.1.0/24,10.0.0.0/8" make docker-up

root@kitploit:~
### Image-Stufen

Wählen Sie die richtige Größe für Ihren Einsatzbereich:

| Tier | Größe | MCP Tools | Einsatzbereich |
|------|------|-----------|----------|
| `minimal` | ~480MB | 17 | Leichtgewichtige Analyse, CVE-Recherche, Berichterstellung |
| `core` | ~7GB | 47 | Komplettes Pentest-Toolkit (Standard) |
| `full` | ~8GB | 80 | Alles + AD, Wireless, Stealth/OPSEC |```bash
TENGU_TIER=minimal make docker-build   # lightweight
TENGU_TIER=core    make docker-build   # default
TENGU_TIER=full    make docker-build   # everything

Alle Stufen enthalten alle 35 Prompts und 20 Ressourcen — nur die binären Werkzeuge unterscheiden sich.

Manuelle Installation (ohne Docker)

Voraussetzungen: Python 3.12+, uv, Kali Linux (empfohlen)```bash git clone https://github.com/rfunix/tengu.git && cd tengu

Install Python dependencies

uv sync

Install external pentesting tools (Kali/Debian)

make install-tools

Run the MCP server (stdio transport)

uv run tengu

root@kitploit:~
Claude Code verbinden:```bash
claude mcp add --scope user tengu -- uv run --directory /path/to/tengu tengu

Konfigurieren Sie erlaubte Ziele in tengu.toml:```toml [targets] allowed_hosts = ["192.168.1.0/24", "example.com"]

root@kitploit:~
Für Claude Desktop, VM/SSE-Fernsetup und erweiterte Konfigurationen siehe [docs/deployment-guide.md](https://github.com/rfunix/tengu/blob/HEAD/docs/deployment-guide.md).

</details>

### Konfigurationsreferenz```toml
[targets]
# REQUIRED: Only these hosts will be scanned
allowed_hosts = ["192.168.1.0/24", "example.com"]
blocked_hosts = []  # Always blocked, even if in allowed_hosts

[stealth]
enabled = false  # Route traffic through Tor/proxy

[stealth.proxy]
enabled = false
type = "socks5h"
host = "127.0.0.1"
port = 9050

[osint]
shodan_api_key = ""  # Required for shodan_lookup

[tools.defaults]
scan_timeout = 300   # seconds
Tool herunterladen
make docker-upTengu MCP-Server (:8000)
make docker-lab+ Juice Shop, DVWA (sichere Übungsziele)
make docker-pentest+ Metasploit, OWASP ZAP (reale Ziele)
make docker-full+ Metasploit, ZAP und Laborziele

Siehe docs/configuration-reference.md für die vollständige Referenz.


Autonomer Agenten-Modus

Führen Sie einen vollständig autonomen Pentest ohne manuellen Tool-Aufruf durch. Der Agent nutzt Claude als strategisches Gehirn und Tengu als Ausführungswerkzeug, wobei er der PTES-Methodik von der Aufklärung bis zur Berichterstattung folgt.

Tengu autonomous agent demo

Schnellstart```bash

cp .env.example .env

Edit .env: set ANTHROPIC_API_KEY and TENGU_AGENT_TARGET

root@kitploit:~
**Laborziele (Juice Shop, DVWA):**```bash
make docker-lab
make docker-agent          # default model (sonnet)
make docker-agent-haiku    # cheaper — claude-haiku-4-5, max_tokens=1024
make docker-agent-sonnet   # balanced — claude-sonnet-4-6, max_tokens=4096

Praxisnahe Pentests (Tengu + MSF + ZAP, keine Labor-Container):```bash make docker-pentest make docker-agent

root@kitploit:~
**Berichte im Browser anzeigen:**```bash
make docker-report-view          # http://localhost:8888 — styled HTML, all reports
make docker-report-browse        # same, auto-opens browser
REPORT_PORT=9999 make docker-report-view   # custom port

Tengu Berichtsanzeige

Ohne Docker:```bash uv sync --extra agent python autonomous_tengu.py 192.168.1.100 --scope 192.168.1.0/24 --type blackbox

Cost-optimised run

python autonomous_tengu.py 192.168.1.100 --model claude-haiku-4-5 --max-tokens 1024 --timeout 30

root@kitploit:~
**Cost control** — drei Umgebungsvariablen / CLI-Flags:

| Flag | Umgebungsvariable | Standard |
|---|---|---|
| `--model` | `TENGU_AGENT_MODEL` | `claude-sonnet-4-6` |
| `--max-tokens` | `TENGU_AGENT_MAX_TOKENS` | `2048` |
| `--timeout` | `TENGU_AGENT_TIMEOUT` | `60` (Minuten, `0`=unbegrenzt) |

### So funktioniert es```
START → initializer → strategist ─┬─→ executor → analyst ─┬─→ strategist (loop)
                                   │                        └─→ reporter → END
                                   ├─→ human_gate → executor
                                   └─→ reporter → END

Schlüsselverhalten:

  • Strategist (Claude) liest die aktuelle PTES-Phase und den akkumulierten Zustand, um jede Aktion zu entscheiden.
  • Executor ruft genau ein Tengu MCP-Tool pro Iteration auf.
  • Analyst (Claude) extrahiert strukturierte Daten aus der Tool-Ausgabe und schreitet in den Phasen voran.
  • Human Gate unterbricht die Ausführung vor destruktiven Tools (msf_run_module, hydra_attack, impacket_kerberoast, sqlmap_scan mit Level≥3).
  • Läuft, bis alle 7 PTES-Phasen abgedeckt sind oder --max-iterations erreicht ist.
  • Abschließend ruft Reporter correlate_findings + score_risk + generate_report auf.

PTES-Methodik – 7 Phasen

PhaseNameWas Tengu tutWichtige Tools
1Pre-Engagementvalidate_target bestätigt den Umfang, check_tools prüft die Bereitschaftvalidate_target, check_tools
2Intelligence GatheringOSINT, DNS-Aufklärung, Subdomain-Enumeration, Technologie-Fingerprintingnmap, subfinder, amass, shodan, whatweb
3Threat ModelingClaude analysiert gesammelte Informationen, priorisiert die Angriffsfläche, erstellt Bedrohungsszenarien(KI-gesteuert – kein externes Tool)
4Vulnerability AnalysisTemplate-Scanning, Web-App-Tests, SSL/TLS-Analyse, Parameter-Fuzzingnuclei, nikto, ffuf, sqlmap, testssl
5ExploitationKontrollierte Ausnutzung bestätigter Schwachstellen mit Human-in-the-Loopmsf_run_module, sqlmap, hydra, searchsploit
6Post-ExploitationCredential-Harvesting, Lateral-Movement-Bewertung, Privilege Escalationimpacket_kerberoast, nxc_enum, enum4linux
7ReportingAlle Ergebnisse korrelieren, Risikobewertungen berechnen, professionellen Bericht erstellencorrelate_findings, score_risk, generate_report

Tool-Katalog

minimal (17 Tools, ~480MB) · core (47 Tools, ~7GB, Standard) · full (80 Tools, ~8GB) Erstellen mit: TENGU_TIER=<tier> make docker-build. Alle Stufen enthalten alle 35 Prompts und 20 Ressourcen.

KategorieToolsAnzahl
AufklärungNmap, Masscan, Amass, Subfinder, Gowitness, HTTrack, Katana, httpx, SNMPwalk, RustScan10
Web-ScanningNikto, Nuclei, FFUF, Gobuster, WPScan, Feroxbuster, OWASP ZAP, wafw00f8
SSL/TLSsslyze, testssl.sh, HTTP-Header-Analyse, CORS-Tester4
DNSDNS Enumerate, DNSRecon, Subjack, WHOIS4
OSINTtheHarvester, Shodan, WhatWeb, DNStwist4
Injection-TestsSQLMap, Dalfox (XSS), Commix, CRLFuzz, GraphQL Security Check, Arjun6
Brute ForceHydra, John the Ripper, Hashcat, CeWL4
ExploitationMetasploit (search, info, run, sessions, cmd), SearchSploit6
Social EngineeringSET Credential Harvester, QR-Code-Angriff, Payload-Generator3
Geheimnisse & CodeTruffleHog, Gitleaks2
Container & CloudTrivy, Checkov, ScoutSuite, Prowler4
Active DirectoryNetExec, Enum4linux, Impacket (Kerberoast, secretsdump, psexec, wmiexec, smbclient), BloodHound, Responder, SMBMap10
Drahtlosaircrack-ng / airodump-ng1
Anonymität & StealthTor-Prüfung/-Rotation, Proxy-Prüfung, Identitätsrotation5
Analyse & BerichterstellungErgebnis-Korrelation, CVSS-Risikobewertung, Berichterstellung3
CVE-IntelligenzCVE-Abfrage (NVD), CVE-Suche nach Schlüsselwort/Produkt/Schweregrad2
DienstprogrammeTool-Checker, Ziel-Validierung2
Vollständige Tool-Liste (80 Tools)

Aufklärung

ToolBeschreibung
nmap_scanPort-Scanning und Service-/BS-Erkennung
masscan_scanHochgeschwindigkeits-Port-Scanner für große Netzwerke
subfinder_enumPassive Subdomain-Enumeration
amass_enumAngriffsflächen-Mapping und DNS-Brute-Force
dnsrecon_scanDNS-Aufklärung (Zonentransfer, Brute-Force, PTR)
dns_enumerateDNS-Record-Enumeration (A, MX, NS, TXT, SOA…)
whois_lookupWHOIS-Domain- und IP-Abfrage
subjack_checkSubdomain-Übernahme-Erkennung
gowitness_screenshotWeb-Screenshot-Erfassung für Dokumentation
httrack_mirrorVollständiger Website-Mirror für Offline-Analyse und Forensik
katana_crawlSchneller Webcrawler zur Link-Erkennung und Endpunkt-Mapping
httpx_probeHTTP-Probe – Statuscodes, Tech-Stack, Weiterleitungen
snmpwalk_scanSNMP-Enumeration und MIB-Walking
rustscan_scanUltra-schnelles Port-Scanning (findet offene Ports für Nmap-Nachverfolgung)

Web-Scanning

OSINT

ToolBeschreibung
theharvester_scanE-Mail-, Subdomain- und Host-Enumeration aus öffentlichen Quellen

Injection-Tests

Exploitation

Social Engineering

ToolBeschreibung
set_credential_harvesterEine Website klonen und übermittelte Anmeldedaten erfassen (autorisierte Phishing-Simulationen)
set_qrcode_attackQR-Code generieren, der auf eine URL verweist, für physische Social-Engineering-Bewertungen
set_payload_generatorSocial-Engineering-Payloads generieren (PowerShell, HTA) für autorisierte Kampagnen

Brute Force

ToolBeschreibung
hydra_attackNetzwerk-Login-Brute-Force (SSH, FTP, HTTP, SMB…)

Proxy / DAST

ToolBeschreibung
zap_spiderOWASP ZAP Web Spider
zap_active_scanOWASP ZAP aktiver Schwachstellen-Scan
zap_get_alertsZAP-Scan-Ergebnisse abrufen

Geheimnisse & Code-Analyse

ToolBeschreibung
trufflehog_scanErkennung durchgesickerter Geheimnisse in Git-Repositories
gitleaks_scanAnmeldedaten-Scanning im Git-Verlauf

Container-Sicherheit

ToolBeschreibung
trivy_scanSchwachstellen-Scanning für Docker-Images, IaC und SBOM

Cloud-Sicherheit

ToolBeschreibung
scoutsuite_scanCloud-Sicherheitsaudit (AWS, Azure, GCP)
prowler_scanAWS/GCP/Azure-Sicherheitsbest Practices und Compliance-Audit

Active Directory

Drahtlos

ToolBeschreibung
aircrack_scanPassiver drahtloser Netzwerkscan (airodump-ng)

IaC-Sicherheit

ToolBeschreibung
checkov_scanIaC-Fehlkonfigurationsscan (Terraform, K8s, Dockerfile)

Stealth / OPSEC

Analyse & Dienstprogramme


Workflows & Prompts (35)

Vorgefertigte Workflow-Vorlagen, die Claude durch vollständige Engagements führen.

KategoriePrompts
Pentest-Workflowsfull_pentest, quick_recon, web_app_assessment
Schwachstellenbewertungassess_injection, assess_access_control, assess_crypto, assess_misconfig
OSINTosint_investigation
Berichteexecutive_report, technical_report, full_pentest_report, finding_detail, risk_matrix, remediation_plan, retest_report, save_report
Stealth/OPSECstealth_assessment, opsec_checklist
Spezialisiertad_assessment, api_security_assessment, container_assessment, cloud_assessment, wireless_assessment, bug_bounty_workflow, compliance_assessment
Schnellaktionenexplore_url, map_network, hunt_subdomains, find_vulns, find_secrets, go_stealth, crack_wifi, pwn_target, msf_exploit_workflow
Social Engineeringsocial_engineering_assessment

Integrierte Ressourcen (20)

Statische Referenzdaten, die Claude während Engagements lädt.

URIInhalt
owasp://top10/2025OWASP Top 10:2025 vollständige Liste
owasp://top10/2025/{A01..A10}Detailinformationen pro Kategorie + Testcheckliste
owasp://api-security/top10OWASP API Security Top 10 (2023)
owasp://api-security/top10/{API1..API10}Detailinformationen pro Kategorie
ptes://phasesPTES 7-Phasen-Methodik-Übersicht
ptes://phase/{1..7}Phasendetails (Ziele, Tools, Liefergegenstände)
checklist://web-applicationWeb-App-Pentest-Checkliste (OWASP Testing Guide)
checklist://apiAPI-Pentest-Checkliste
checklist://networkNetzwerkinfrastruktur-Checkliste
mitre://attack/tacticsMITRE ATT&CK Enterprise-Taktiken + Techniken
mitre://attack/technique/{T1xxx}Technikdetail nach ID
creds://defaults/{product}Standard-Anmeldedaten-Datenbank
payloads://{type}Kuratierte Payload-Listen nach Typ (xss, sqli, lfi, ssti, etc.)
stealth://techniquesReferenzleitfaden für operationelle Sicherheitstechniken
stealth://proxy-guideSchritt-für-Schritt-Anleitung zur Proxy- und Tor-Konfiguration
tools://catalogLive-Status der Tool-Verfügbarkeit
tools://{tool}/usageNutzungsanleitung für nmap, nuclei, sqlmap, metasploit, trivy, amass
prompts://listListe aller verfügbaren Prompts mit Beschreibungen
prompts://category/{category}Nach Kategorie gefilterte Prompts

Architektur```

┌─────────────┐ MCP ┌─────────────────┐ subprocess ┌─────────────────┐ │ Claude │◄────────────►│ Tengu │─────────────────►│ Nmap, SQLMap, │ │ (Desktop / │ stdio/SSE │ MCP Server │ (never shell=T) │ Metasploit... │ │ Code) │ │ │ └─────────────────┘ └─────────────┘ └────────┬─────────┘ │ Every tool call passes through: │ ┌────────▼─────────┐ │ Safety Pipeline │ │ │ │ 1. sanitizer │ ← strip metacharacters, validate format │ 2. allowlist │ ← check target against tengu.toml │ 3. rate_limiter │ ← sliding window + concurrent slots │ 4. audit logger │ ← JSON log to ./logs/tengu-audit.log └──────────────────┘

root@kitploit:~
---

## Konfigurationsdateien

Tengu verwendet drei Konfigurationsdateien. Die Bearbeitung der falschen Datei ist die häufigste Ursache für Verwirrung beim Wechsel zwischen lokalen und Docker-Workflows.

| Datei | Verwendungszweck | Steuerung |
|------|-------------|------------------|
| `tengu.toml` (Stamm) | Lokal ausführen: `uv run tengu`, `uv run python autonomous_tengu.py` | MCP-Server-Konfiguration: `allowed_hosts`, Tool-Pfade, Ratenlimits, Stealth |
| `docker/tengu.toml` | Ausführen über Docker: `make docker-up`, `make docker-agent` | Gleiche Einstellungen wie root, aber vorkonfiguriert für Docker-Netzwerk (`172.16.0.0/12`, Service-DNS-Aliase). Wird zur Build-Zeit in das Image eingebacken — **Neubau erforderlich** nach Änderungen (`make docker-rebuild-tengu`) |
| `.env` | Sowohl lokal als auch Docker | Geheimnisse und Laufzeitvariablen: `ANTHROPIC_API_KEY`, `TENGU_AGENT_TARGET`, `TENGU_AGENT_MODEL`, `TENGU_AGENT_MAX_TOKENS`, etc. Gelesen von `docker compose` und `load_dotenv()` |
| `.env.example` | Nur als Referenz | Vorlage, die alle verfügbaren Umgebungsvariablen auflistet |

**Schnellkonfiguration für Copilot-Modus (lokal):** Bearbeiten Sie `tengu.toml` im Projektstamm — fügen Sie Ihr Ziel zu `[targets] allowed_hosts` hinzu.

**Schnellkonfiguration für Agent-Modus (Docker):** Bearbeiten Sie `docker/tengu.toml`, führen Sie dann `make docker-rebuild-tengu` vor `make docker-agent` aus.

> **Häufige Falle:** Wenn Scans mit `TargetNotAllowedError` in Docker fehlschlagen, haben Sie wahrscheinlich `tengu.toml` (Stamm) statt `docker/tengu.toml` bearbeitet. Docker verwendet eine eigene Kopie, die in das Image eingebacken ist. Führen Sie nach der Bearbeitung `make docker-rebuild-tengu` aus.

---

## Sicherheit durch Design

Tengu ist als **Kraftverstärker für menschliche Pentester** konzipiert, nicht als autonomes Angriffstool.

| Kontrolle | Beschreibung |
|---------|-------------|
| **Zielerlaubnisliste** | Es werden nur vorab genehmigte Ziele in `tengu.toml` gescannt |
| **Eingabebereinigung** | Alle Eingaben werden vor Erreichen eines Tools anhand strenger Muster validiert |
| **Ratenbegrenzung** | Gleitfenster + gleichzeitige Slot-Limits verhindern unbeabsichtigte DoS-Angriffe |
| **Prüfprotokollierung** | Jeder Tool-Aufruf wird im JSON-Format in `./logs/tengu-audit.log` protokolliert |
| **Human-in-the-Loop** | `msf_run_module`, `hydra_attack` und `impacket_kerberoast` erfordern explizite Bestätigung |
| **Kein shell=True — niemals** | Alle Unterprozessaufrufe verwenden `asyncio.create_subprocess_exec` |

---

## Entwicklung```bash
make install-dev    # Install Python deps + dev extras
make test           # Run unit + security tests
make lint           # ruff check
make typecheck      # mypy strict
make check          # lint + typecheck
make coverage       # pytest --cov
make inspect        # Open MCP Inspector
make doctor         # Check which pentest tools are installed

Tengu verfügt über 2643+ Tests, die Unit-Logik, Sicherheit (Befehlseinschleusung, Eingabevalidierung) und Integrationsszenarien abdecken. Die vollständige Mitwirkenden-Anleitung finden Sie in CLAUDE.md.


Rechtlicher Hinweis

Tengu ist ausschließlich für autorisierte Sicherheitstests konzipiert. Scannen Sie nur Systeme, die Sie besitzen oder für die Sie eine ausdrückliche schriftliche Genehmigung haben. Nicht autorisiertes Scannen ist in den meisten Rechtsordnungen illegal. Die Autoren übernehmen keine Haftung für Missbrauch.

ToolBeschreibung
nuclei_scanTemplate-basierter Schwachstellen-Scanner (CVEs, Fehlkonfigurationen)
nikto_scanWebserver-Fehlkonfigurations- und Veraltete-Software-Scanner
ffuf_fuzzVerzeichnis-, Parameter- und Vhost-Fuzzing
gobuster_scanVerzeichnis-, DNS- und Vhost-Brute-Force
wpscan_scanWordPress-Schwachstellen-Scanner
testssl_checkUmfassende SSL/TLS-Konfigurationsanalyse
analyze_headersHTTP-Sicherheitsheader-Analyse und -Bewertung
test_corsCORS-Fehlkonfigurationserkennung
ssl_tls_checkSSL/TLS-Zertifikats- und Chiffre-Prüfung (sslyze)
wafw00f_scanWeb Application Firewall-Erkennung und Fingerprinting
feroxbuster_scanSchnelle, rekursive Inhaltserkennung per Brute-Force
shodan_lookupShodan-Host- und Asset-Suche
whatweb_scanWeb-Technologie-Fingerprinting (CMS, WAF, Frameworks)
dnstwist_scanDomain-Permutations- und Typosquatting-Erkennung
ToolBeschreibung
sqlmap_scanAutomatisierte SQL-Injection-Erkennung und -Ausnutzung
xss_scanXSS-Erkennung mittels Dalfox
commix_scanAutomatisierte Command-Injection-Erkennung und -Ausnutzung
crlfuzz_scanCRLF-Injection-Fuzzing für Header-Injection-Schwachstellen
graphql_security_checkGraphQL-Introspection, Batching, Tiefenbeschränkung, Feldvorschläge
arjun_discoverVersteckte HTTP-Parameter-Erkennung
ToolBeschreibung
msf_searchMetasploit-Module durchsuchen
msf_module_infoDetaillierte Metasploit-Modulinformationen abrufen
msf_run_moduleEin Metasploit-Modul ausführen (erfordert explizite Bestätigung)
msf_sessions_listAktive Metasploit-Sitzungen auflisten
msf_session_cmdEinen Befehl auf einer aktiven Sitzung ausführen (Shell/Meterpreter)
searchsploit_queryExploit-DB-Offline-Datenbank durchsuchen
hash_crack
Wörterbuch-Hash-Knacken (Hashcat / John the Ripper)
hash_identifyHash-Typ-Identifizierung
cewl_generateBenutzerdefinierte Wortlistengenerierung von einer Zielwebsite
ToolBeschreibung
enum4linux_scanSMB/NetBIOS-Enumeration
nxc_enumActive-Directory-Enumeration über NetExec
impacket_kerberoastKerberoasting mit Impacket GetUserSPNs
impacket_secretsdumpFern-SAM/LSA/NTDS-Geheimnis-Dump über Impacket
impacket_psexecFernbefehlsausführung über SMB (PsExec-Stil)
impacket_wmiexecFernbefehlsausführung über WMI
impacket_smbclientSMB-Freigabe-Enumeration und Dateizugriff
bloodhound_collectBloodHound AD-Datenerfassung (SharpHound/bloodhound-python)
responder_captureLLMNR/NBT-NS/MDNS-Poisoning zur Anmeldedatenerfassung
smbmap_scanSMB-Freigabe-Enumeration und Zugriffstests
ToolBeschreibung
tor_checkTor-Verbindung und Exit-Node-IP überprüfen
tor_new_identityNeuen Tor-Circuit anfordern (NEWNYM)
check_anonymityFreigegebene IP, DNS-Lecks und Anonymitätsstufe prüfen
proxy_checkProxy-Latenz, Exit-IP und Anonymitätstyp validieren
rotate_identityTor-Circuit und User-Agent gleichzeitig rotieren
ToolBeschreibung
check_toolsÜberprüfen, welche externen Tools installiert sind
validate_targetZiel gegen Whitelist validieren
correlate_findingsErgebnisse über mehrere Scans hinweg korrelieren
score_riskCVSS-basierte Risikobewertung
cve_lookupCVE-Details von NVD (CVSS, CWE, betroffene Produkte)
cve_searchCVEs nach Schlüsselwort, Produkt oder Schweregrad suchen
generate_reportPentest-Bericht in Markdown/HTML/PDF erstellen