> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/Gowtham-Darkseid/AutoPentestX/llms.txt > Use this file to discover all available pages before exploring further. # Overview > Understanding AutoPentestX architecture and core capabilities AutoPentestX is a complete, automated penetration testing toolkit that orchestrates multiple security tools and methodologies into a single, streamlined workflow. Built for educational purposes and authorized security assessments, it combines network reconnaissance, vulnerability detection, risk analysis, and exploitation simulation. ## What is AutoPentestX? AutoPentestX is a Python-based CLI tool that automates the entire penetration testing lifecycle—from initial network scanning through final report generation. It integrates industry-standard tools (Nmap, Nikto, SQLMap, Metasploit) with custom risk assessment and exploitation engines. AutoPentestX is designed for **authorized testing only**. Always obtain written permission before scanning any system you don't own. ## Core Architecture The tool is built around a modular architecture with eight specialized modules: ### Main Orchestrator The `AutoPentestX` class in `main.py:27` serves as the central orchestrator: ```python theme={null} class AutoPentestX: def __init__(self, target, tester_name="AutoPentestX Team", safe_mode=True, skip_web=False, skip_exploit=False): self.target = target self.safe_mode = safe_mode self.db = Database() # Initialize modules... ``` ### Module Structure SQLite-based persistence layer storing all scan results, vulnerabilities, and exploits for historical analysis Nmap integration for comprehensive port scanning, service detection, OS fingerprinting, and banner grabbing Nikto and SQLMap integration for web vulnerability detection and SQL injection testing Automated CVE database queries to identify known vulnerabilities in detected services CVSS-based risk scoring that calculates overall system risk from multiple vulnerability factors Metasploit integration with safe-mode exploitation simulation (see `exploit_engine.py:14`) Professional report generation with executive summaries, findings, and remediation recommendations ## Key Features ### Automated Workflow Single-command execution that runs all seven phases automatically: ```bash theme={null} python main.py -t 192.168.1.100 ``` No manual intervention required—the tool handles the entire assessment from start to finish. ### Safe Mode by Default As implemented in `exploit_engine.py:15`, safe mode is **enabled by default**: ```python theme={null} class ExploitEngine: def __init__(self, safe_mode=True): self.safe_mode = safe_mode ``` This prevents destructive actions and ensures exploitation is simulated rather than executed. ### Comprehensive Data Storage All results are stored in a SQLite database with five normalized tables: * `scans` - Scan metadata and timing * `ports` - Open port information * `vulnerabilities` - Detected vulnerabilities * `web_vulnerabilities` - Web-specific issues * `exploits` - Exploitation attempts ### Professional Reporting Generates publication-ready PDF reports including: * Executive summary * Technical findings * Risk assessment * Exploitation results * Prioritized remediation steps ## Technical Stack Python 3.8+ with modern async/await patterns Nmap for port scanning and service detection Nikto and SQLMap for web vulnerability assessment Metasploit Framework integration (optional) ## Dependencies ```python theme={null} # Core Python packages python-nmap==0.7.1 # Nmap integration requests>=2.31.0 # HTTP/API requests reportlab>=4.0.4 # PDF generation sqlparse>=0.4.4 # SQL parsing ``` ```bash theme={null} # System tools sudo apt install nmap nikto sqlmap metasploit-framework ``` ## Design Philosophy ### Education First AutoPentestX is designed as an educational tool that demonstrates penetration testing methodologies in a safe, controlled manner. Every run displays legal warnings and requires authorization confirmation. ### Safety by Design Multiple safety mechanisms protect against accidental damage: * Safe mode enabled by default * Authorization prompts before execution * Non-destructive scanning techniques * Simulation-only exploitation * Comprehensive logging for audit trails ### Professional Output Generated reports meet professional standards suitable for: * Academic projects and coursework * Security audit documentation * Client deliverables (authorized testing) * Bug bounty submissions * Red team exercises ## Performance Characteristics **Typical scan times:** * Quick scan (ports only): 5-10 minutes * Standard scan (with web): 10-20 minutes * Full assessment: 20-30 minutes Resource usage is moderate: * **CPU**: High during Nmap scanning phase * **Memory**: \~100-200 MB typical * **Disk**: \~50 MB for installation * **Network**: High traffic during active scanning ## Extensibility The modular architecture allows easy extension: ```python theme={null} # Add new vulnerability checks class CustomScanner: def scan(self, target): # Your custom logic return results # Integrate into workflow vuln_scanner.add_scanner(CustomScanner()) ``` ## Use Cases Practice penetration testing in controlled VM environments Authorized vulnerability assessments for clients Reconnaissance for authorized bug bounty programs Quick reconnaissance for capture-the-flag events ## What's Next? Learn about the complete assessment process Understand safe vs unsafe exploitation Critical legal requirements and ethical guidelines Start using AutoPentestX in 5 minutes Never use AutoPentestX on systems without explicit written authorization. Unauthorized access is illegal and can result in criminal prosecution.