Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /SHAdd0WTAka_Zen-Ai-Pentest /pentest_framework.py
| #!/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" | |
| 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) | |
| 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 "", | |
| } | |
| 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.