Buckets:

download
raw
27.3 kB
#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║ 🔥 ZEN-AI-PENTEST - KOMPLETTES PENTEST FRAMEWORK ║
║ 72 Tools | 12 Kategorien | 5 Phasen ║
╚══════════════════════════════════════════════════════════════════════════════╝
Ein durchdachtes Framework für professionelle Penetrationstests.
Nutzt alle verfügbaren Tools in einem strukturierten Workflow.
"""
import asyncio
import json
import logging
import shutil
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from pathlib import Path
from typing import Dict, List
# Setup Logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s | %(levelname)-8s | %(message)s",
datefmt="%H:%M:%S",
)
logger = logging.getLogger(__name__)
class Phase(Enum):
"""Die 5 Phasen eines Pentests nach PTES (Penetration Testing Execution Standard)"""
PRE_ENGAGEMENT = "Pre-Engagement"
RECONNAISSANCE = "Reconnaissance"
SCANNING = "Scanning & Enumeration"
EXPLOITATION = "Exploitation"
POST_EXPLOITATION = "Post-Exploitation"
REPORTING = "Reporting"
class Category(Enum):
"""12 Tool-Kategorien"""
NETWORK = "Network & Scanning"
WEB = "Web Security"
RECON = "Reconnaissance"
OSINT = "OSINT"
EXPLOIT = "Exploitation"
BRUTE_FORCE = "Brute Force"
AD = "Active Directory"
WIRELESS = "Wireless"
CODE = "Code Analysis"
CONTAINER = "Container & Cloud"
SYSTEM = "System Utilities"
CORE = "AI & Core"
@dataclass
class ToolResult:
"""Ergebnis eines Tool-Runs"""
tool: str
category: str
command: str
stdout: str
stderr: str
returncode: int
duration: float
timestamp: datetime = field(default_factory=datetime.now)
@property
def success(self) -> bool:
return self.returncode == 0
def to_dict(self) -> Dict:
return {
"tool": self.tool,
"category": self.category,
"command": self.command,
"success": self.success,
"duration": self.duration,
"timestamp": self.timestamp.isoformat(),
"output": self.stdout[:1000] if self.stdout else "",
"errors": self.stderr[:500] if self.stderr else "",
}
@dataclass
class Finding:
"""Sicherheits-Finding"""
title: str
severity: str # Critical, High, Medium, Low, Info
category: str
description: str
evidence: str
remediation: str
tool: str
timestamp: datetime = field(default_factory=datetime.now)
class PentestFramework:
"""
🎯 Haupt-Framework für Pentests
Nutzt alle 72 Tools in einem strukturierten Workflow:
Phase 1: Reconnaissance (OSINT, Network Discovery)
Phase 2: Scanning (Port Scanning, Service Detection)
Phase 3: Enumeration (Web, AD, Wireless)
Phase 4: Exploitation (Vuln Scanning, Exploits)
Phase 5: Post-Exploitation (Privilege Escalation, Lateral Movement)
Phase 6: Reporting
"""
def __init__(self, target: str, output_dir: str = "./pentest_results"):
self.target = target
self.output_dir = Path(output_dir)
self.output_dir.mkdir(exist_ok=True)
self.results: List[ToolResult] = []
self.findings: List[Finding] = []
self.session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
# Tool-Verfügbarkeit prüfen
self.available_tools = self._check_tool_availability()
logger.info(f"🔧 Framework initialisiert für Ziel: {target}")
logger.info(f"📊 Verfügbare Tools: {len(self.available_tools)}/72")
def _check_tool_availability(self) -> Dict[str, bool]:
"""Prüft welche Tools verfügbar sind"""
tools = {
# Network
"nmap": "nmap",
"masscan": "masscan",
"scapy": 'python3 -c "import scapy"',
"tshark": "tshark",
"tcpdump": "tcpdump",
# Web
"sqlmap": "sqlmap",
"nikto": "nikto",
"ffuf": "ffuf",
"gobuster": "gobuster",
"wafw00f": "wafw00f",
"whatweb": "whatweb",
"nuclei": "nuclei",
"curl": "curl",
"wget": "wget",
# Recon
"subfinder": "subfinder",
"amass": "amass",
"httpx": "httpx",
"sherlock": "sherlock",
"theharvester": "theharvester",
# AD
"netexec": "netexec",
"responder": "responder",
"bloodhound-python": "bloodhound-python",
# Exploit
"msfconsole": "msfconsole",
"searchsploit": "searchsploit",
# Brute Force
"hydra": "hydra",
"hashcat": "hashcat",
"john": "john",
# Wireless
"aircrack-ng": "aircrack-ng",
# Code
"semgrep": "semgrep",
"trufflehog": "trufflehog",
"gitleaks": "gitleaks",
"bandit": "bandit",
# Container
"trivy": "trivy",
"docker": "docker",
"kubectl": "kubectl",
# System
"nc": "nc",
"socat": "socat",
"openssl": "openssl",
}
available = {}
for name, cmd in tools.items():
available[name] = shutil.which(cmd.split()[0]) is not None
return available
async def run_tool(self, name: str, category: str, cmd: List[str], timeout: int = 300) -> ToolResult:
"""Führt ein Tool aus"""
logger.info(f"🔍 [{category}] {name}: {' '.join(cmd[:3])}...")
start = datetime.now()
try:
proc = await asyncio.create_subprocess_exec(
*cmd,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
duration = (datetime.now() - start).total_seconds()
result = ToolResult(
tool=name,
category=category,
command=" ".join(cmd),
stdout=stdout.decode(errors="ignore"),
stderr=stderr.decode(errors="ignore"),
returncode=proc.returncode,
duration=duration,
)
self.results.append(result)
status = "✅" if result.success else "❌"
logger.info(f"{status} {name} completed in {duration:.1f}s")
return result
except asyncio.TimeoutError:
logger.warning(f"⏱️ {name} timed out after {timeout}s")
return ToolResult(name, category, " ".join(cmd), "", "Timeout", -1, timeout)
except Exception as e:
logger.error(f"💥 {name} failed: {e}")
return ToolResult(name, category, " ".join(cmd), "", str(e), -1, 0)
# ═══════════════════════════════════════════════════════════════════════
# PHASE 1: RECONNAISSANCE (OSINT & Network Discovery)
# ═══════════════════════════════════════════════════════════════════════
async def phase1_reconnaissance(self) -> List[ToolResult]:
"""
🕵️ Phase 1: Reconnaissance
Tools:
- Subfinder, Amass (Subdomain Discovery)
- Sherlock (Username OSINT)
- TheHarvester (Email/OSINT)
- Whois/Dig (DNS Info)
- Nmap (Host Discovery)
"""
logger.info("\n" + "=" * 70)
logger.info("🕵️ PHASE 1: RECONNAISSANCE")
logger.info("=" * 70)
results = []
domain = self.target.replace("http://", "").replace("https://", "").split("/")[0]
# 1. Subdomain Discovery
if self.available_tools.get("subfinder"):
results.append(
await self.run_tool(
"subfinder",
"Recon",
[
"subfinder",
"-d",
domain,
"-o",
str(self.output_dir / "subdomains.txt"),
],
)
)
if self.available_tools.get("amass"):
results.append(
await self.run_tool(
"amass",
"Recon",
[
"amass",
"enum",
"-d",
domain,
"-o",
str(self.output_dir / "amass.txt"),
],
)
)
# 2. HTTP Probing
if self.available_tools.get("httpx"):
subdomains_file = self.output_dir / "subdomains.txt"
if subdomains_file.exists():
results.append(
await self.run_tool(
"httpx",
"Recon",
[
"httpx",
"-l",
str(subdomains_file),
"-o",
str(self.output_dir / "live_hosts.txt"),
],
)
)
# 3. DNS Enumeration
results.append(await self.run_tool("dns_lookup", "System", ["dig", "+short", domain]))
# 4. Host Discovery (Nmap Ping Scan)
if self.available_tools.get("nmap"):
results.append(
await self.run_tool(
"nmap_ping",
"Network",
["nmap", "-sn", "-PE", "-PP", "-PM", domain],
)
)
self._save_phase_results("phase1_reconnaissance", results)
return results
# ═══════════════════════════════════════════════════════════════════════
# PHASE 2: SCANNING (Port & Service Scanning)
# ═══════════════════════════════════════════════════════════════════════
async def phase2_scanning(self) -> List[ToolResult]:
"""
🔍 Phase 2: Scanning & Enumeration
Tools:
- Nmap (Port Scanning, Service Detection)
- Masscan (High-speed Scanning)
- Nuclei (Vulnerability Scanning)
"""
logger.info("\n" + "=" * 70)
logger.info("🔍 PHASE 2: SCANNING & ENUMERATION")
logger.info("=" * 70)
results = []
# 1. Nmap Top Ports Scan
if self.available_tools.get("nmap"):
results.append(
await self.run_tool(
"nmap_top_ports",
"Network",
[
"nmap",
"-sV",
"-sC",
"--top-ports",
"1000",
"-oA",
str(self.output_dir / "nmap_top"),
self.target,
],
timeout=600,
)
)
# 2. Full Port Scan (nur wenn schnelles Netzwerk)
# results.append(await self.run_tool(
# 'nmap_full', 'Network',
# ['nmap', '-p-', '-sV', '-sC', '-oA',
# str(self.output_dir / 'nmap_full'), self.target],
# timeout=1800
# ))
# 3. Technology Detection
if self.available_tools.get("whatweb"):
results.append(await self.run_tool("whatweb", "Web", ["whatweb", "-a", "3", self.target]))
# 4. WAF Detection
if self.available_tools.get("wafw00f"):
results.append(await self.run_tool("wafw00f", "Web", ["wafw00f", self.target]))
self._save_phase_results("phase2_scanning", results)
return results
# ═══════════════════════════════════════════════════════════════════════
# PHASE 3: WEB APPLICATION TESTING
# ═══════════════════════════════════════════════════════════════════════
async def phase3_web_testing(self) -> List[ToolResult]:
"""
🕸️ Phase 3: Web Application Testing
Tools:
- Nikto (Web Scanner)
- SQLMap (SQL Injection)
- FFuF/Gobuster (Directory Fuzzing)
- Nuclei (Template-based Scanning)
"""
logger.info("\n" + "=" * 70)
logger.info("🕸️ PHASE 3: WEB APPLICATION TESTING")
logger.info("=" * 70)
results = []
# 1. Nikto Scan
if self.available_tools.get("nikto"):
results.append(
await self.run_tool(
"nikto",
"Web",
[
"nikto",
"-h",
self.target,
"-o",
str(self.output_dir / "nikto.txt"),
],
timeout=300,
)
)
# 2. Directory Fuzzing
if self.available_tools.get("gobuster"):
wordlist = "/usr/share/wordlists/dirb/common.txt"
if Path(wordlist).exists():
results.append(
await self.run_tool(
"gobuster",
"Web",
[
"gobuster",
"dir",
"-u",
self.target,
"-w",
wordlist,
"-o",
str(self.output_dir / "gobuster.txt"),
],
timeout=300,
)
)
# 3. Nuclei Scan
if self.available_tools.get("nuclei"):
results.append(
await self.run_tool(
"nuclei",
"Exploit",
[
"nuclei",
"-u",
self.target,
"-o",
str(self.output_dir / "nuclei.txt"),
],
timeout=600,
)
)
self._save_phase_results("phase3_web", results)
return results
# ═══════════════════════════════════════════════════════════════════════
# PHASE 4: AUTHENTICATION & BRUTE FORCE
# ═══════════════════════════════════════════════════════════════════════
async def phase4_authentication(self) -> List[ToolResult]:
"""
🔐 Phase 4: Authentication Testing
Tools:
- Hydra (Login Brute Force)
- Sherlock (Username Enumeration)
- SQLMap (Auth Bypass)
"""
logger.info("\n" + "=" * 70)
logger.info("🔐 PHASE 4: AUTHENTICATION TESTING")
logger.info("=" * 70)
results = []
# Hinweis: Brute Force nur mit expliziter Erlaubnis!
logger.info("⚠️ Brute Force Tests übersprungen (erfordert explizite Erlaubnis)")
# SQLMap für Login-Formulare (falls gefunden)
# Dies würde hier implementiert werden
return results
# ═══════════════════════════════════════════════════════════════════════
# PHASE 5: ACTIVE DIRECTORY (falls Domain gefunden)
# ═══════════════════════════════════════════════════════════════════════
async def phase5_active_directory(self, domain: str = None) -> List[ToolResult]:
"""
🏢 Phase 5: Active Directory Testing
Tools:
- NetExec (SMB/WinRM/LDAP)
- BloodHound (AD Enumeration)
- Responder (LLMNR Poisoning)
"""
if not domain:
logger.info("\n🏢 Phase 5 übersprungen (keine Domain erkannt)")
return []
logger.info("\n" + "=" * 70)
logger.info("🏢 PHASE 5: ACTIVE DIRECTORY TESTING")
logger.info("=" * 70)
results = []
# 1. NetExec SMB Enumeration
if self.available_tools.get("netexec"):
results.append(await self.run_tool("netexec_smb", "AD", ["netexec", "smb", domain, "--shares"]))
# 2. BloodHound Data Collection
if self.available_tools.get("bloodhound-python"):
results.append(
await self.run_tool(
"bloodhound",
"AD",
["bloodhound-python", "-d", domain, "-c", "All"],
)
)
return results
# ═══════════════════════════════════════════════════════════════════════
# PHASE 6: CODE & CONTAINER ANALYSIS
# ═══════════════════════════════════════════════════════════════════════
async def phase6_code_analysis(self, repo_path: str = None) -> List[ToolResult]:
"""
📝 Phase 6: Code & Container Analysis
Tools:
- Semgrep (SAST)
- TruffleHog (Secret Scanning)
- Trivy (Container Scanning)
- Bandit (Python Security)
"""
logger.info("\n" + "=" * 70)
logger.info("📝 PHASE 6: CODE & CONTAINER ANALYSIS")
logger.info("=" * 70)
results = []
# Secret Scanning
if self.available_tools.get("trufflehog"):
results.append(
await self.run_tool(
"trufflehog",
"Code",
["trufflehog", "filesystem", ".", "--json"],
timeout=300,
)
)
if self.available_tools.get("gitleaks"):
results.append(await self.run_tool("gitleaks", "Code", ["gitleaks", "detect", "-v", "-r", "."]))
# SAST (falls Python-Code vorhanden)
if self.available_tools.get("bandit") and Path(".").glob("*.py"):
results.append(
await self.run_tool(
"bandit",
"Code",
[
"bandit",
"-r",
".",
"-f",
"json",
"-o",
str(self.output_dir / "bandit.json"),
],
)
)
return results
# ═══════════════════════════════════════════════════════════════════════
# REPORTING
# ═══════════════════════════════════════════════════════════════════════
def generate_report(self) -> Dict:
"""
📊 Generate Final Report
"""
logger.info("\n" + "=" * 70)
logger.info("📊 GENERATING REPORT")
logger.info("=" * 70)
report = {
"session_id": self.session_id,
"target": self.target,
"timestamp": datetime.now().isoformat(),
"summary": {
"total_tools_run": len(self.results),
"successful": sum(1 for r in self.results if r.success),
"failed": sum(1 for r in self.results if not r.success),
"total_duration": sum(r.duration for r in self.results),
},
"tools_by_category": self._group_by_category(),
"findings": [f.__dict__ for f in self.findings],
"all_results": [r.to_dict() for r in self.results],
}
# Save JSON Report
report_file = self.output_dir / f"pentest_report_{self.session_id}.json"
with open(report_file, "w") as f:
json.dump(report, f, indent=2, default=str)
# Save Markdown Report
md_file = self.output_dir / f"pentest_report_{self.session_id}.md"
self._generate_markdown_report(md_file, report)
logger.info(f"📄 Report saved: {report_file}")
logger.info(f"📄 Markdown report: {md_file}")
return report
def _group_by_category(self) -> Dict:
"""Gruppiere Ergebnisse nach Kategorie"""
categories = {}
for result in self.results:
cat = result.category
if cat not in categories:
categories[cat] = []
categories[cat].append(result.tool)
return categories
def _save_phase_results(self, phase_name: str, results: List[ToolResult]):
"""Speichere Phase-Ergebnisse"""
phase_file = self.output_dir / f"{phase_name}_{self.session_id}.json"
with open(phase_file, "w") as f:
json.dump([r.to_dict() for r in results], f, indent=2, default=str)
def _generate_markdown_report(self, filepath: Path, report: Dict):
"""Generiere Markdown-Report"""
with open(filepath, "w") as f:
f.write(f"""# 🎯 Pentest Report
**Target:** {report["target"]}
**Session:** {report["session_id"]}
**Date:** {report["timestamp"]}
## 📊 Summary
| Metric | Value |
|--------|-------|
| Tools Run | {report["summary"]["total_tools_run"]} |
| Successful | {report["summary"]["successful"]} ✅ |
| Failed | {report["summary"]["failed"]} ❌ |
| Total Duration | {report["summary"]["total_duration"]:.1f}s |
## 🛠️ Tools by Category
""")
for cat, tools in report["tools_by_category"].items():
f.write(f"### {cat}\n")
for tool in tools:
f.write(f"- {tool}\n")
f.write("\n")
# ═══════════════════════════════════════════════════════════════════════
# MAIN EXECUTION
# ═══════════════════════════════════════════════════════════════════════
async def run_full_pentest(self, skip_phases: List[int] = None) -> Dict:
"""
🚀 Führe kompletten Pentest durch
Args:
skip_phases: Liste von Phasen zum Überspringen (z.B. [5] für kein AD)
"""
skip_phases = skip_phases or []
start_time = datetime.now()
logger.info("\n" + "=" * 70)
logger.info("🚀 STARTING FULL PENTEST WORKFLOW")
logger.info(f"🎯 Target: {self.target}")
logger.info("=" * 70)
# Phase 1: Reconnaissance
if 1 not in skip_phases:
await self.phase1_reconnaissance()
# Phase 2: Scanning
if 2 not in skip_phases:
await self.phase2_scanning()
# Phase 3: Web Testing
if 3 not in skip_phases:
await self.phase3_web_testing()
# Phase 4: Authentication
if 4 not in skip_phases:
await self.phase4_authentication()
# Phase 5: AD (optional)
if 5 not in skip_phases:
# Hier Domain aus Phase 1 extrahieren
await self.phase5_active_directory()
# Phase 6: Code Analysis
if 6 not in skip_phases:
await self.phase6_code_analysis()
# Generate Report
report = self.generate_report()
duration = (datetime.now() - start_time).total_seconds()
logger.info("\n" + "=" * 70)
logger.info(f"✅ PENTEST COMPLETED in {duration:.1f}s")
logger.info(f"📊 Results: {self.output_dir}")
logger.info("=" * 70)
return report
# ═══════════════════════════════════════════════════════════════════════════════
# CLI INTERFACE
# ═══════════════════════════════════════════════════════════════════════════════
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(
description="Zen-AI-Pentest Framework",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
# Full pentest
python pentest_framework.py -t example.com
# Skip AD testing
python pentest_framework.py -t example.com --skip 5
# Only reconnaissance
python pentest_framework.py -t example.com --only 1
""",
)
parser.add_argument("-t", "--target", required=True, help="Target domain/IP")
parser.add_argument("-o", "--output", default="./pentest_results", help="Output directory")
parser.add_argument("--skip", type=int, nargs="+", help="Phases to skip (1-6)")
parser.add_argument("--only", type=int, help="Run only specific phase (1-6)")
args = parser.parse_args()
# Initialize Framework
framework = PentestFramework(args.target, args.output)
# Run
if args.only:
skip = [i for i in range(1, 7) if i != args.only]
else:
skip = args.skip or []
asyncio.run(framework.run_full_pentest(skip))

Xet Storage Details

Size:
27.3 kB
·
Xet hash:
d513227476e42c0f296720c64e27d5757cd085f1fdbd8b4e3aca1ef685b05f31

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.