bhp-pro 1.3.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

{bhp_pro-1.3.0.dist-info → bhp_pro-1.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bhp_pro
-Version: 1.3.0
+Version: 1.3.1
 Summary: Web Enumeration Tool
 Author: ssskingsss12
 Author-email: smalls3000i@gmail.com

bhp_pro-1.3.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+bhp_pro.py,sha256=GGMBJqGY4Iq_tvfOx8CvjlMDFwfiAmkkZ1vkCDyiLxo,772565
+bhp_pro-1.3.1.dist-info/METADATA,sha256=CxccyEJF5lcdMjCpVWa1Dq3YCjrXtcsn3YDD10T9mYQ,600
+bhp_pro-1.3.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+bhp_pro-1.3.1.dist-info/entry_points.txt,sha256=Yn3HpraGX3lXX4FPq3Gm-lHh3SwQA-5rtgPWNWMFXkw,41
+bhp_pro-1.3.1.dist-info/top_level.txt,sha256=1xjbIaVM77UJz9Tsi1JjILgE0YDG7iLhY6KSMNEi9zM,8
+bhp_pro-1.3.1.dist-info/RECORD,,

{bhp_pro-1.3.0.dist-info → bhp_pro-1.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

bhp_pro.py

@@ -16875,89 +16875,564 @@ def menu3():
     #===SUBDOmain TAKEOVER===#
     def access_control():
 
-        generate_ascii_banner("ACCESS", "CONTROL")
-        THREAD_COUNT = 100
-
-        LOCK = threading.Lock()
-        user_input = input("Enter a domain or .txt file: ").strip()
-        OUTPUT_FILE = input("Enter output file name (default is x_requested_with_results.txt): ").strip() or "x_requested_with_results.txt"
-        def check_domain(domain, progress):
-            preflight_headers = {
-                'Origin': 'https://yahoo.com/',
-                'Access-Control-Request-Method': 'GET',
-                'Access-Control-Request-Headers': 'X-Requested-With, X-Online-Host, X-Forwarded-For',
-                'User-Agent': 'Mozilla/5.0'
+        def xhttp_payload_validator():
+            os.system('clear' if os.name == 'posix' else 'cls')
+            print("""
+        ╔══════════════════════════════════════════════════════════╗
+        ║                XHTTP TUNNEL PAYLOAD TESTER              ║
+        ║       Generate HTTP Injector Configs from Live Tests    ║
+        ╚══════════════════════════════════════════════════════════╝
+            """)
+            
+            # XHTTP payload templates
+            XHTTP_PAYLOADS = {
+                "1": {
+                    "name": "Basic HTTP Request",
+                    "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: [UA]\r\n\r\n",
+                    "type": "XHTTP"
+                },
+                "2": {
+                    "name": "CONNECT Tunnel",
+                    "payload": "CONNECT [HOST]:443 HTTP/1.1\r\nHost: [HOST]:443\r\nUser-Agent: [UA]\r\n\r\n",
+                    "type": "XHTTP"
+                },
+                "3": {
+                    "name": "WebSocket Upgrade",
+                    "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: [KEY]\r\nSec-WebSocket-Version: 13\r\n\r\n",
+                    "type": "WS"
+                },
+                "4": {
+                    "name": "X-Online-Host Injection",
+                    "payload": "GET / HTTP/1.1\r\nHost: example.com\r\nX-Online-Host: [HOST]\r\nUser-Agent: [UA]\r\n\r\n",
+                    "type": "XHTTP"
+                },
+                "5": {
+                    "name": "Double Host Header",
+                    "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nHost: [HOST]\r\nUser-Agent: [UA]\r\n\r\n",
+                    "type": "XHTTP"
+                },
+                "6": {
+                    "name": "POST Request Smuggling",
+                    "payload": "POST / HTTP/1.1\r\nHost: [HOST]\r\nContent-Length: 28\r\n\r\nGET / HTTP/1.1\r\nHost: [HOST]\r\n\r\n",
+                    "type": "XHTTP"
+                },
+                "7": {
+                    "name": "Cloudflare Trace + Smuggle",
+                    "payload": "GET /cdn-cgi/trace HTTP/1.1\r\nHost: [HOST]\r\n\r\nGET / HTTP/1.1\r\nHost: [HOST]\r\n\r\n",
+                    "type": "XHTTP"
+                }
             }
+            
+            class Config:
+                def __init__(self):
+                    self.payloads = []
+                    self.targets = []
+                    self.proxies = []
+                    self.output_file = "working_configs.txt"
+                    self.timeout = 10
+                    self.threads = 100
+            
+            class PayloadGenerator:
+                @staticmethod
+                def generate_websocket_key():
+                    import base64
+                    import os
+                    return base64.b64encode(os.urandom(16)).decode()
+                
+                @staticmethod
+                def prepare_payload(payload_template, target_domain):
+                    """Replace [HOST] placeholder with actual target domain"""
+                    replacements = {
+                        '[HOST]': target_domain,  # THIS IS CRITICAL - use the actual target
+                        '[UA]': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                        '[KEY]': PayloadGenerator.generate_websocket_key()
+                    }
+                    
+                    payload = payload_template
+                    for placeholder, value in replacements.items():
+                        payload = payload.replace(placeholder, value)
+                    
+                    return payload
+                
+                @staticmethod
+                def format_for_http_injector(result):
+                    """Format working config as HTTP Injector .ehi entry"""
+                    # Original payload template (with [HOST] placeholder)
+                    original_payload = result['payload_template']
+                    
+                    # Convert payload to HTTP Injector format ([crlf] instead of \r\n)
+                    escaped_payload = original_payload.replace('\r\n', '[crlf]')
+                    
+                    config = f"""# ====================================================
+        # CONFIG #{result['config_id']}
+        # ====================================================
+        [CONFIG]
+        Name={result['payload_name']} | {result['status_code']} | {result['proxy_host']}:{result['proxy_port']}
+        Server={result['proxy_host']}
+        Port={result['proxy_port']}
+        Protocol=XHTTP
+        SNI={result['target']}
+        ProxyType=HTTP
+
+        [PAYLOAD]
+        {escaped_payload}
+
+        [HEADERS]
+        User-Agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
+        Accept=*/*
+        Accept-Language=en-US,en;q=0.9
+        Accept-Encoding=gzip, deflate
+        Connection=keep-alive
+
+        [SETTINGS]
+        ForwardHost=true
+        UseSNI=true
+
+        [TEST_INFO]
+        Date={time.strftime("%Y-%m-%d %H:%M:%S")}
+        Target={result['target']}
+        Status=HTTP {result['status_code']}
+        Response_Time={result['response_time']:.2f}s
+        Server={result['server']}
+        Bypass_Indicators={','.join(result['bypass_indicators'])}
+        Payload_Sent={result['sent_payload'][:1000].replace(chr(10), ' ').replace(chr(103), '')}...
+
+        # ====================================================
 
-            for protocol in ['http://', 'https://']:
-                url = protocol + domain
-                try:
-                    response = requests.options(url, headers=preflight_headers, timeout=5)
-                    status = response.status_code
-                    allowed_headers = response.headers.get('Access-Control-Allow-Headers', '').lower()
-
-                    allowed = []
-                    if 'x-requested-with' in allowed_headers:
-                        allowed.append('X-Requested-With')
-                    if 'x-online-host' in allowed_headers:
-                        allowed.append('X-Online-Host')
-                    if 'x-forwarded-for' in allowed_headers:
-                        allowed.append('X-Forwarded-For')
-
-                    if allowed:
-                        server = response.headers.get('Server', 'Unknown')
-                        print(f"✅ {url} - ALLOWS: {', '.join(allowed)} | Status: {status}")
-                        with LOCK:
-                            with open(OUTPUT_FILE, "a") as f:
-                                f.write(f"{url} | Status: {status} | Server: {server} | Allowed Headers: {', '.join(allowed)}\n")
-                    else:
-                        print(f"⚠️ {url} - None of the desired X-* headers allowed.")
-
-                except requests.exceptions.RequestException as e:
-                    print(f"❌ {url} - Request failed: {e}")
-                finally:
-                    with LOCK:
-                        progress.update(1)
-
-
-        def worker(domain_queue, progress):
-            while not domain_queue.empty():
-                domain = domain_queue.get()
-                check_domain(domain, progress)
-                domain_queue.task_done()
-
-        def access_main():
-
+        """
+                    return config
+                
+                @staticmethod
+                def save_all_results(results, filename):
+                    """Save all working configs in one file"""
+                    if not results:
+                        return 0
+                    
+                    with open(filename, 'w', encoding='utf-8') as f:
+                        # Header
+                        f.write(f"""# HTTP Injector Configurations
+        # Generated: {time.strftime('%Y-%m-%d %H:%M:%S')}
+        # Total Working Configs: {len(results)}
+        # 
+        # HOW TO USE:
+        # 1. Copy each [CONFIG] section below
+        # 2. Create new config in HTTP Injector
+        # 3. Paste the settings
+        # 4. Use with the specified proxy: {results[0]['proxy_host']}:{results[0]['proxy_port']}
+        # 
+        # ====================================================
 
-            if os.path.isfile(user_input) and user_input.endswith('.txt'):
-                with open(user_input, 'r') as file:
-                    domains = [line.strip() for line in file if line.strip()]
+        """)
+                        
+                        # Summary section
+                        f.write("[SUMMARY]\n")
+                        f.write(f"Total_Configs={len(results)}\n")
+                        f.write(f"Tested_Targets={len(set(r['target'] for r in results))}\n")
+                        working_proxies = len(set(f"{r['proxy_host']}:{r['proxy_port']}" for r in results))
+                        f.write(f"Working_Proxies={working_proxies}\n")
+                        f.write(f"Success_Rate={(len(results) / (len(results) + len([r for r in results if not r.get('success', True)]))) * 1000:.1f}%\n\n")
+                        
+                        # Group by status code
+                        status_stats = {}
+                        for result in results:
+                            status = result['status_code']
+                            status_stats[status] = status_stats.get(status, 0) + 1
+                        
+                        f.write("[STATUS_CODES]\n")
+                        for status, count in sorted(status_stats.items()):
+                            f.write(f"HTTP_{status}={count}\n")
+                        f.write("\n")
+                        
+                        # Group by payload
+                        payload_stats = {}
+                        for result in results:
+                            payload = result['payload_name']
+                            if payload not in payload_stats:
+                                payload_stats[payload] = {
+                                    'count': 0,
+                                    'bypass': 0,
+                                    'targets': set()
+                                }
+                            payload_stats[payload]['count'] += 1
+                            if result['bypass_indicators']:
+                                payload_stats[payload]['bypass'] += 1
+                            payload_stats[payload]['targets'].add(result['target'])
+                        
+                        f.write("[PAYLOAD_STATS]\n")
+                        for payload, stats in sorted(payload_stats.items(), key=lambda x: x[1]['count'], reverse=True):
+                            f.write(f"{payload.replace(' ', '_')}={stats['count']}|{stats['bypass']}|{len(stats['targets'])}\n")
+                        f.write("\n")
+                        
+                        # Now write each config
+                        f.write("# ====================================================\n")
+                        f.write("# WORKING CONFIGURATIONS\n")
+                        f.write("# ====================================================\n\n")
+                        
+                        for i, result in enumerate(results, 1):
+                            result['config_id'] = i
+                            config_text = PayloadGenerator.format_for_http_injector(result)
+                            f.write(config_text)
+                    
+                    return len(results)
+            
+            class ProxyManager:
+                @staticmethod
+                def parse_proxy_input(proxy_input, ports):
+                    proxies = []
+                    
+                    # Already has port
+                    if ':' in proxy_input:
+                        parts = proxy_input.split(':', 1)
+                        ip_part = parts[0]
+                        port = int(parts[1])
+                        
+                        if '/' in ip_part:  # CIDR with port
+                            try:
+                                network = ipaddress.ip_network(ip_part, strict=False)
+                                for ip in network.hosts():
+                                    proxies.append((str(ip), port))
+                            except:
+                                pass
+                        else:  # Single IP with port
+                            proxies.append((ip_part, port))
+                        return proxies
+                    
+                    # CIDR without port
+                    if '/' in proxy_input:
+                        try:
+                            network = ipaddress.ip_network(proxy_input, strict=False)
+                            for ip in network.hosts():
+                                for port in ports:
+                                    proxies.append((str(ip), port))
+                        except:
+                            pass
+                        return proxies
+                    
+                    # IP range
+                    if '-' in proxy_input:
+                        parts = proxy_input.split('-')
+                        if len(parts) == 2:
+                            base_ip = parts[0].rsplit('.', 1)[0]
+                            start = int(parts[0].rsplit('.', 1)[1])
+                            end = int(parts[1])
+                            
+                            for i in range(start, end + 1):
+                                ip = f"{base_ip}.{i}"
+                                for port in ports:
+                                    proxies.append((ip, port))
+                        return proxies
+                    
+                    # Single IP without port
+                    for port in ports:
+                        proxies.append((proxy_input.strip(), port))
+                    
+                    return proxies
+            
+            class NetworkTester:
+                def __init__(self, config):
+                    self.config = config
+                    self.working_configs = []
+                    self.lock = threading.Lock()
+                    self.queue = Queue()
+                    self.tested = 0
+                    self.successful = 0
+                    
+                def test_connection(self, payload_info, target_domain, proxy_host, proxy_port):
+                    """Test payload with target domain through proxy"""
+                    try:
+                        # CRITICAL FIX: Use target domain in payload, not proxy IP
+                        sent_payload = PayloadGenerator.prepare_payload(payload_info['payload'], target_domain)
+                        
+                        # Connect to PROXY
+                        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                        sock.settimeout(self.config.timeout)
+                        sock.connect((proxy_host, proxy_port))
+                        
+                        # Send payload (with target domain in Host header)
+                        start_time = time.time()
+                        sock.send(sent_payload.encode())
+                        
+                        # Receive response FROM PROXY
+                        response = b""
+                        while time.time() - start_time < 5:
+                            try:
+                                sock.settimeout(1)
+                                chunk = sock.recv(4096)
+                                if not chunk:
+                                    break
+                                response += chunk
+                            except socket.timeout:
+                                break
+                        
+                        sock.close()
+                        response_time = time.time() - start_time
+                        
+                        # Parse response
+                        response_text = response.decode('utf-8', errors='ignore')
+                        status_code = None
+                        server_info = "Unknown"
+                        
+                        # Get status code
+                        status_match = re.search(r'HTTP/\d\.\d\s+(\d{3})', response_text)
+                        if status_match:
+                            status_code = int(status_match.group(1))
+                        else:
+                            return {'success': False, 'error': 'No HTTP response'}
+                        
+                        # Get server header
+                        server_match = re.search(r'Server:\s*([^\r\n]+)', response_text, re.IGNORECASE)
+                        if server_match:
+                            server_info = server_match.group(1)
+                        
+                        # Check bypass indicators
+                        bypass_indicators = self.check_bypass_indicators(response_text)
+                        
+                        return {
+                            'payload_name': payload_info['name'],
+                            'payload_template': payload_info['payload'],  # Original template
+                            'sent_payload': sent_payload,  # Actual payload sent
+                            'target': target_domain,  # The domain we're trying to reach
+                            'proxy_host': proxy_host,
+                            'proxy_port': proxy_port,
+                            'status_code': status_code,
+                            'response_time': response_time,
+                            'server': server_info,
+                            'bypass_indicators': bypass_indicators,
+                            'response_preview': response_text[:200],
+                            'success': True
+                        }
+                        
+                    except Exception as e:
+                        return {'success': False, 'error': str(e)}
+                
+                def check_bypass_indicators(self, response_text):
+                    indicators = []
+                    checks = [
+                        (r'CF-RAY', 'Cloudflare Proxy'),
+                        (r'X-Cache', 'Caching Proxy'),
+                        (r'Via:', 'Proxy Chain'),
+                        (r'squid/', 'Squid Proxy'),
+                        (r'varnish', 'Varnish Cache'),
+                        (r'nginx/', 'Nginx Proxy'),
+                        (r'Apache/', 'Apache Proxy'),
+                        (r'Connection established', 'CONNECT Successful'),
+                        (r'101 Switching Protocols', 'WebSocket Upgrade'),
+                        (r'HTTP/1.1 200.*HTTP/1.1', 'Request Smuggling')
+                    ]
+                    
+                    for pattern, meaning in checks:
+                        if re.search(pattern, response_text, re.IGNORECASE | re.DOTALL):
+                            indicators.append(meaning)
+                    
+                    return indicators
+                
+                def worker(self):
+                    while not self.queue.empty():
+                        try:
+                            task = self.queue.get()
+                            payload_info, target, proxy_host, proxy_port = task
+                            
+                            result = self.test_connection(payload_info, target, proxy_host, proxy_port)
+                            
+                            with self.lock:
+                                self.tested += 1
+                                
+                                if result['success']:
+                                    self.successful += 1
+                                    self.working_configs.append(result)
+                                    
+                                    # Live display
+                                    status = result['status_code']
+                                    proxy_display = f"{proxy_host}:{proxy_port}"
+                                    
+                                    if 200 <= status < 300:
+                                        icon = "✅"
+                                    elif 300 <= status < 400:
+                                        icon = "↪️"
+                                    elif 400 <= status < 500:
+                                        icon = "⚠️"
+                                    else:
+                                        icon = "❌"
+                                    
+                                    if result['bypass_indicators']:
+                                        icon += "🚀"
+                                    
+                                    print(f"{icon} {result['payload_name']:25} → {target:20} HTTP {status:3} via {proxy_display:20}")
+                            
+                            self.queue.task_done()
+                            
+                        except Exception:
+                            self.queue.task_done()
+                
+                def run_tests(self):
+                    # Build task queue
+                    for payload_info in self.config.payloads:
+                        for target in self.config.targets:
+                            if self.config.proxies:
+                                for proxy_host, proxy_port in self.config.proxies:
+                                    self.queue.put((payload_info, target, proxy_host, proxy_port))
+                            else:
+                                # Direct connection (no proxy)
+                                self.queue.put((payload_info, target, target, 80))
+                    
+                    total_tests = self.queue.qsize()
+                    
+                    print(f"\n{'='*60}")
+                    print(f"🧪 TESTING CONFIGURATION")
+                    print(f"{'='*60}")
+                    print(f"Payloads: {len(self.config.payloads)}")
+                    print(f"Targets: {len(self.config.targets)}")
+                    print(f"Proxies: {len(self.config.proxies) if self.config.proxies else 'Direct'}")
+                    print(f"Total Tests: {total_tests}")
+                    print(f"Threads: {self.config.threads}")
+                    print(f"{'='*60}")
+                    print("\n📡 TESTING IN PROGRESS...\n")
+                    
+                    # Start workers
+                    threads = []
+                    for _ in range(min(self.config.threads, total_tests)):
+                        t = threading.Thread(target=self.worker)
+                        t.daemon = True
+                        t.start()
+                        threads.append(t)
+                    
+                    # Wait for completion
+                    self.queue.join()
+                    
+                    print(f"\n{'='*60}")
+                    print(f"✅ TESTING COMPLETE")
+                    print(f"{'='*60}")
+                    print(f"Tests Completed: {self.tested}")
+                    print(f"Successful Responses: {self.successful}")
+                    print(f"Working Configs Found: {len(self.working_configs)}")
+                    
+                    return self.working_configs
+            
+            # Main execution
+            config = Config()
+            
+            # Select payloads
+            print("\n📋 AVAILABLE PAYLOAD TEMPLATES:")
+            print("-" * 55)
+            for key, info in XHTTP_PAYLOADS.items():
+                print(f"{key}. {info['name']} ({info['type']})")
+            
+            selection = input("\nSelect payloads (numbers comma-separated, or 'all'): ").strip()
+            
+            if selection.lower() == 'all':
+                selected_keys = list(XHTTP_PAYLOADS.keys())
             else:
-                domains = [user_input]
-
-            if os.path.exists(OUTPUT_FILE):
-                os.remove(OUTPUT_FILE)
-
-            domain_queue = Queue()
-            for domain in domains:
-                domain_queue.put(domain)
-
-            progress = tqdm(total=len(domains) * 2, desc="Checking", ncols=80)
-
-            threads = []
-            for _ in range(THREAD_COUNT):
-                t = threading.Thread(target=worker, args=(domain_queue, progress))
-                t.start()
-                threads.append(t)
-
-            for t in threads:
-                t.join()
-
-            progress.close()
-            print(f"\n✅ Finished checking. Results saved to {OUTPUT_FILE}")
+                selected_keys = [s.strip() for s in selection.split(',') if s.strip() in XHTTP_PAYLOADS]
+            
+            if not selected_keys:
+                print("❌ No payloads selected!")
+                return
+            
+            for key in selected_keys:
+                config.payloads.append(XHTTP_PAYLOADS[key])
+            
+            # Get targets - THESE ARE THE DOMAINS WE WANT TO REACH
+            targets_input = input("\n🎯 Enter target domain(s) to test against (comma-separated or file): ").strip()
+            
+            if os.path.isfile(targets_input):
+                with open(targets_input, 'r') as f:
+                    config.targets = [line.strip() for line in f if line.strip()]
+            else:
+                config.targets = [t.strip() for t in targets_input.split(',') if t.strip()]
+            
+            if not config.targets:
+                print("❌ No target domains specified!")
+                return
+            
+            # Get proxies - THESE ARE THE PROXIES WE TEST THROUGH
+            print("\n🔄 PROXY SETTINGS")
+            print("1. Use proxies (for tunneling)")
+            print("2. Direct connection (no proxy)")
+            
+            proxy_choice = input("\nSelect option (1-2): ").strip()
+            
+            if proxy_choice == '1':
+                proxy_input = input("Enter proxy (IP, IP:PORT, CIDR, or IP range): ").strip()
+                
+                ports_input = input("Ports to test (comma-separated, default=80,443): ").strip()
+                if ports_input:
+                    ports = [int(p.strip()) for p in ports_input.split(',') if p.strip().isdigit()]
+                else:
+                    ports = [80, 443]  # Default to HTTP and HTTPS ports
+                
+                config.proxies = ProxyManager.parse_proxy_input(proxy_input, ports)
+                
+                if not config.proxies:
+                    print("❌ Invalid proxy input!")
+                    return
+                
+                print(f"✅ Loaded {len(config.proxies)} proxy endpoints")
+            
+            # Output file
+            output_file = input("\n💾 Output file (default=working_configs.txt): ").strip()
+            if output_file:
+                if not output_file.endswith('.txt'):
+                    output_file += '.txt'
+                config.output_file = output_file
+            
+            # Confirm
+            print(f"\n{'='*60}")
+            print("READY TO TEST")
+            print(f"{'='*60}")
+            print(f"Payloads: {len(config.payloads)}")
+            print(f"Target Domains: {', '.join(config.targets[:3])}{'...' if len(config.targets) > 3 else ''}")
+            print(f"Proxies: {len(config.proxies) if config.proxies else 'Direct'}")
+            print(f"Output: {config.output_file}")
+            print(f"{'='*60}")
+            
+            confirm = input("\nStart testing? (y/n): ").strip().lower()
+            if confirm != 'y':
+                print("❌ Cancelled")
+                return
+            
+            # Run tests
+            start_time = time.time()
+            tester = NetworkTester(config)
+            working_configs = tester.run_tests()
+            
+            # Save results - SINGLE FILE ONLY
+            if working_configs:
+                saved_count = PayloadGenerator.save_all_results(working_configs, config.output_file)
+                
+                elapsed = time.time() - start_time
+                
+                print(f"\n{'='*60}")
+                print("📦 RESULTS SAVED")
+                print(f"{'='*60}")
+                print(f"✅ Generated {saved_count} HTTP Injector configs")
+                print(f"📁 Single output file: {config.output_file}")
+                print(f"⏱️  Total time: {elapsed:.1f} seconds")
+                print(f"{'='*60}")
+                
+                # Show what's in the file
+                print("\n📋 FILE CONTENTS:")
+                print(f"1. [SUMMARY] - Test statistics")
+                print(f"2. [STATUS_CODES] - HTTP status breakdown")
+                print(f"3. [PAYLOAD_STATS] - Success rate per payload")
+                print(f"4. Multiple [CONFIG] sections - Ready for HTTP Injector")
+                
+                # Show sample
+                if working_configs:
+                    sample = working_configs[0]
+                    print(f"\n🎯 SAMPLE CONFIG #{1}:")
+                    print(f"   Payload: {sample['payload_name']}")
+                    print(f"   Target: {sample['target']}")
+                    print(f"   Proxy: {sample['proxy_host']}:{sample['proxy_port']}")
+                    print(f"   Status: HTTP {sample['status_code']}")
+                    print(f"   Payload sent: {sample['sent_payload'][:800]}...")
+                    
+                    print(f"\n💡 Import {config.output_file} into HTTP Injector")
+                    print(f"   Each [CONFIG] section is a separate tunnel config")
+            else:
+                print("\n❌ No working configurations found!")
 
 
-        access_main()
+        xhttp_payload_validator()
 
 
     def x_menu():
@@ -17058,7 +17533,7 @@ def banner():
     MAGENTA + "██╔═══╝ ██╔══██╗██║   ██║" + LIME + "user should understand that useage of this script may be" + ENDC,
     MAGENTA + "██║     ██║  ██║╚██████╔╝" + LIME + "concidered an attack on a data network, and may violate terms" + ENDC,
     MAGENTA + "╚═╝     ╚═╝  ╚═╝ ╚═════╝" + LIME + "of service, use on your own network or get permission first" + ENDC,
-    PURPLE + "script_version@ 1.3.0 ®" + ENDC,
+    PURPLE + "script_version@ 1.3.1 ®" + ENDC,
     ORANGE + "All rights reserved 2022-2026 ♛: ®" + ENDC, 
     MAGENTA + "In Collaboration whit Ayan Rajpoot ® " + ENDC,
     BLUE +  "Support: https://t.me/BugScanX 💬" + ENDC,     

bhp_pro-1.3.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-bhp_pro.py,sha256=WJ2J94cH1-qKf3AynRr8Q4t0GhzNxs2VunaQip0T7zA,748620
-bhp_pro-1.3.0.dist-info/METADATA,sha256=t7JildGhotdLKQG8WAcZWV-rFl9R6FhukOP2UhCNEMs,600
-bhp_pro-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bhp_pro-1.3.0.dist-info/entry_points.txt,sha256=Yn3HpraGX3lXX4FPq3Gm-lHh3SwQA-5rtgPWNWMFXkw,41
-bhp_pro-1.3.0.dist-info/top_level.txt,sha256=1xjbIaVM77UJz9Tsi1JjILgE0YDG7iLhY6KSMNEi9zM,8
-bhp_pro-1.3.0.dist-info/RECORD,,