#!/usr/bin/env python3
"""
APEX - Advanced Penetration and Exploitation eXecution Framework
The Most Powerful Ethical Hacking Tool

Features:
- Multi-stage reconnaissance (passive & active)
- Advanced vulnerability scanning
- Automated exploitation
- Web application security testing
- Network penetration testing
- Wireless security assessment
- Post-exploitation modules
- Advanced reporting and analytics
- Plugin architecture
- Automation and scripting
"""

import sys
import os
import argparse
import json
import asyncio
from pathlib import Path
from datetime import datetime
from typing import Dict, List, Any
import importlib.util

# ANSI Color codes
class Colors:
    HEADER = '\033[95m'
    BLUE = '\033[94m'
    CYAN = '\033[96m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'
    END = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'

class ApexFramework:
    """Main APEX Framework Class"""

    VERSION = "1.0.0"
    BANNER = f"""
{Colors.CYAN}{Colors.BOLD}
    ╔═╗╔═╗╔═╗═╗ ╦
    ╠═╣╠═╝║╣ ╔╩╦╝
    ╩ ╩╩  ╚═╝╩ ╚═
{Colors.END}{Colors.GREEN}
    Advanced Penetration and
    Exploitation eXecution Framework

    Version: {VERSION}
    {Colors.YELLOW}The Ultimate Ethical Hacking Tool{Colors.END}
{Colors.CYAN}═══════════════════════════════════════{Colors.END}
"""

    def __init__(self, config_file=None):
        """Initialize APEX Framework"""
        self.home_dir = Path.home() / ".apex"
        self.home_dir.mkdir(exist_ok=True)

        self.config_file = config_file or self.home_dir / "apex.json"
        self.plugins_dir = self.home_dir / "plugins"
        self.plugins_dir.mkdir(exist_ok=True)

        self.results_dir = self.home_dir / "results"
        self.results_dir.mkdir(exist_ok=True)

        self.wordlists_dir = self.home_dir / "wordlists"
        self.wordlists_dir.mkdir(exist_ok=True)

        self.config = self.load_config()
        self.modules = {}
        self.session_data = {}

    def load_config(self) -> Dict:
        """Load configuration"""
        default_config = {
            "version": self.VERSION,
            "global": {
                "threads": 50,
                "timeout": 10,
                "user_agent": "APEX/1.0",
                "verify_ssl": False,
                "proxy": None,
                "output_format": "json"
            },
            "reconnaissance": {
                "passive_enum": True,
                "active_enum": True,
                "deep_scan": False
            },
            "scanning": {
                "service_detection": True,
                "os_detection": False,
                "vulnerability_scan": True
            },
            "exploitation": {
                "auto_exploit": False,
                "safe_mode": True,
                "payload_encoding": True
            },
            "web_testing": {
                "sql_injection": True,
                "xss_testing": True,
                "csrf_testing": True,
                "file_inclusion": True,
                "command_injection": True,
                "authentication_bypass": True
            },
            "wireless": {
                "capture_handshakes": True,
                "wps_testing": True,
                "evil_twin": False
            },
            "reporting": {
                "auto_report": True,
                "report_format": ["html", "json", "pdf"],
                "include_screenshots": True
            }
        }

        if self.config_file.exists():
            try:
                with open(self.config_file, 'r') as f:
                    loaded = json.load(f)
                    # Merge with defaults
                    return {**default_config, **loaded}
            except:
                pass

        # Save default config
        with open(self.config_file, 'w') as f:
            json.dump(default_config, f, indent=4)

        return default_config

    def save_config(self):
        """Save configuration"""
        with open(self.config_file, 'w') as f:
            json.dump(self.config, f, indent=4)

    def register_module(self, name: str, module_class):
        """Register a module"""
        self.modules[name] = module_class

    def print_banner(self):
        """Print APEX banner"""
        print(self.BANNER)

    def print_info(self, message):
        """Print info message"""
        print(f"{Colors.BLUE}[*]{Colors.END} {message}")

    def print_success(self, message):
        """Print success message"""
        print(f"{Colors.GREEN}[+]{Colors.END} {message}")

    def print_warning(self, message):
        """Print warning message"""
        print(f"{Colors.YELLOW}[!]{Colors.END} {message}")

    def print_error(self, message):
        """Print error message"""
        print(f"{Colors.RED}[-]{Colors.END} {message}")

    def print_header(self, message):
        """Print section header"""
        print(f"\n{Colors.CYAN}{Colors.BOLD}{'═' * 50}{Colors.END}")
        print(f"{Colors.CYAN}{Colors.BOLD} {message}{Colors.END}")
        print(f"{Colors.CYAN}{Colors.BOLD}{'═' * 50}{Colors.END}\n")

    def load_plugins(self):
        """Load plugins from plugins directory"""
        self.print_info("Loading plugins...")
        count = 0

        for plugin_file in self.plugins_dir.glob("*.py"):
            try:
                spec = importlib.util.spec_from_file_location(
                    plugin_file.stem, plugin_file
                )
                module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(module)

                if hasattr(module, 'register'):
                    module.register(self)
                    count += 1
                    self.print_success(f"Loaded plugin: {plugin_file.stem}")
            except Exception as e:
                self.print_error(f"Failed to load {plugin_file.stem}: {e}")

        self.print_success(f"Loaded {count} plugins")

    def save_results(self, module_name: str, results: Dict):
        """Save results to file"""
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = self.results_dir / f"{module_name}_{timestamp}.json"

        with open(filename, 'w') as f:
            json.dump(results, f, indent=4)

        self.print_success(f"Results saved to: {filename}")

    def interactive_mode(self):
        """Interactive console mode"""
        self.print_banner()
        self.print_info("Entering interactive mode (type 'help' for commands)")

        while True:
            try:
                cmd = input(f"\n{Colors.CYAN}apex>{Colors.END} ").strip()

                if not cmd:
                    continue

                if cmd.lower() in ['exit', 'quit', 'q']:
                    self.print_info("Exiting APEX...")
                    break

                elif cmd.lower() == 'help':
                    self.show_help()

                elif cmd.lower() == 'modules':
                    self.list_modules()

                elif cmd.lower() == 'info':
                    self.show_info()

                elif cmd.startswith('use '):
                    module_name = cmd[4:].strip()
                    self.use_module(module_name)

                elif cmd.startswith('set '):
                    parts = cmd[4:].split(None, 1)
                    if len(parts) == 2:
                        self.set_option(parts[0], parts[1])

                elif cmd.lower() == 'options':
                    self.show_options()

                elif cmd.lower() in ['run', 'execute']:
                    self.execute_current_module()

                elif cmd.lower() == 'back':
                    self.session_data.pop('current_module', None)
                    self.print_info("Returned to main menu")

                else:
                    self.print_error(f"Unknown command: {cmd}")

            except KeyboardInterrupt:
                print()
                continue
            except EOFError:
                print()
                break

    def show_help(self):
        """Show help menu"""
        help_text = f"""
{Colors.BOLD}Available Commands:{Colors.END}

{Colors.CYAN}Core Commands:{Colors.END}
  help              - Show this help menu
  modules           - List all available modules
  info              - Show framework information
  exit/quit         - Exit APEX

{Colors.CYAN}Module Commands:{Colors.END}
  use <module>      - Select a module
  options           - Show module options
  set <option> <val>- Set an option value
  run/execute       - Execute current module
  back              - Return to main menu

{Colors.CYAN}Example Workflow:{Colors.END}
  apex> modules
  apex> use recon/subdomain_enum
  apex> set TARGET example.com
  apex> run
"""
        print(help_text)

    def list_modules(self):
        """List all available modules"""
        self.print_header("Available Modules")

        categories = {
            "Reconnaissance": [],
            "Scanning": [],
            "Exploitation": [],
            "Web Testing": [],
            "Wireless": [],
            "Post-Exploitation": [],
            "Auxiliary": []
        }

        # Add built-in modules
        modules_list = [
            ("Reconnaissance", "recon/subdomain_enum", "Subdomain enumeration"),
            ("Reconnaissance", "recon/dns_enum", "DNS enumeration"),
            ("Reconnaissance", "recon/port_scan", "Port scanning"),
            ("Reconnaissance", "recon/network_mapper", "Network mapping"),
            ("Reconnaissance", "recon/osint", "OSINT gathering"),
            ("Scanning", "scan/vuln_scan", "Vulnerability scanning"),
            ("Scanning", "scan/service_detect", "Service detection"),
            ("Scanning", "scan/ssl_scan", "SSL/TLS analysis"),
            ("Web Testing", "web/sql_injection", "SQL injection testing"),
            ("Web Testing", "web/xss_scanner", "XSS vulnerability scanner"),
            ("Web Testing", "web/lfi_scanner", "LFI/RFI scanner"),
            ("Web Testing", "web/directory_brute", "Directory bruteforce"),
            ("Web Testing", "web/api_fuzzer", "API endpoint fuzzing"),
            ("Exploitation", "exploit/auto_exploit", "Automated exploitation"),
            ("Exploitation", "exploit/payload_gen", "Payload generator"),
            ("Exploitation", "exploit/reverse_shell", "Reverse shell generator"),
            ("Wireless", "wireless/wpa_crack", "WPA/WPA2 cracking"),
            ("Wireless", "wireless/deauth", "Deauthentication attack"),
            ("Post-Exploitation", "post/privilege_esc", "Privilege escalation"),
            ("Post-Exploitation", "post/persistence", "Persistence mechanisms"),
            ("Auxiliary", "aux/report_gen", "Report generator"),
        ]

        for category, module, description in modules_list:
            print(f"  {Colors.GREEN}{module:<30}{Colors.END} - {description}")

    def show_info(self):
        """Show framework information"""
        self.print_header("APEX Framework Information")

        info_text = f"""
{Colors.BOLD}Version:{Colors.END} {self.VERSION}
{Colors.BOLD}Home Directory:{Colors.END} {self.home_dir}
{Colors.BOLD}Config File:{Colors.END} {self.config_file}
{Colors.BOLD}Plugins Directory:{Colors.END} {self.plugins_dir}
{Colors.BOLD}Results Directory:{Colors.END} {self.results_dir}

{Colors.BOLD}Loaded Modules:{Colors.END} {len(self.modules)}
{Colors.BOLD}Global Threads:{Colors.END} {self.config['global']['threads']}
{Colors.BOLD}Global Timeout:{Colors.END} {self.config['global']['timeout']}s
"""
        print(info_text)

    def use_module(self, module_name: str):
        """Use a specific module"""
        self.session_data['current_module'] = module_name
        self.print_success(f"Module selected: {module_name}")

    def set_option(self, option: str, value: str):
        """Set an option value"""
        if 'module_options' not in self.session_data:
            self.session_data['module_options'] = {}

        self.session_data['module_options'][option.upper()] = value
        self.print_success(f"Set {option.upper()} => {value}")

    def show_options(self):
        """Show current module options"""
        if 'current_module' not in self.session_data:
            self.print_error("No module selected. Use 'use <module>' first")
            return

        module = self.session_data['current_module']
        self.print_header(f"Options for {module}")

        # Display current options
        if 'module_options' in self.session_data:
            for key, value in self.session_data['module_options'].items():
                print(f"  {Colors.CYAN}{key:<20}{Colors.END} => {value}")
        else:
            print("  No options set")

    def execute_current_module(self):
        """Execute the current module"""
        if 'current_module' not in self.session_data:
            self.print_error("No module selected. Use 'use <module>' first")
            return

        module = self.session_data['current_module']
        options = self.session_data.get('module_options', {})

        self.print_info(f"Executing {module}...")
        self.print_warning("Module execution not yet implemented (framework foundation)")


def main():
    """Main entry point"""
    parser = argparse.ArgumentParser(
        description="APEX - The Ultimate Ethical Hacking Framework",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  apex.py                           # Interactive mode
  apex.py --module recon/subdomain_enum --target example.com
  apex.py --config custom.json
  apex.py --list-modules

For more information: https://github.com/apex-framework
"""
    )

    parser.add_argument(
        '--module', '-m',
        help='Module to run'
    )

    parser.add_argument(
        '--target', '-t',
        help='Target (IP, domain, URL, etc.)'
    )

    parser.add_argument(
        '--config', '-c',
        help='Configuration file'
    )

    parser.add_argument(
        '--list-modules', '-l',
        action='store_true',
        help='List all available modules'
    )

    parser.add_argument(
        '--interactive', '-i',
        action='store_true',
        help='Start interactive mode'
    )

    parser.add_argument(
        '--version', '-v',
        action='version',
        version=f'APEX Framework v{ApexFramework.VERSION}'
    )

    args = parser.parse_args()

    # Initialize framework
    apex = ApexFramework(config_file=args.config)

    # Load plugins
    apex.load_plugins()

    if args.list_modules:
        apex.print_banner()
        apex.list_modules()
    elif args.interactive or (not args.module and not args.target):
        apex.interactive_mode()
    else:
        apex.print_banner()
        if args.module:
            apex.use_module(args.module)
            if args.target:
                apex.set_option('TARGET', args.target)
            apex.execute_current_module()
        else:
            apex.print_error("No module specified")
            apex.interactive_mode()


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print(f"\n{Colors.YELLOW}[!] Interrupted by user{Colors.END}")
        sys.exit(0)
    except Exception as e:
        print(f"{Colors.RED}[!] Fatal error: {e}{Colors.END}")
        sys.exit(1)