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

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

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

bhp_pro-1.3.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+bhp_pro.py,sha256=i5J-aBNaC14n76DYyym6cs2BBkHF7kT_cLImMl1zb38,777565
+bhp_pro-1.3.2.dist-info/METADATA,sha256=p5i7atVTfveV5iPPzgiUMtczuAsgD6xN-sDAzPCGT_E,600
+bhp_pro-1.3.2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+bhp_pro-1.3.2.dist-info/entry_points.txt,sha256=Yn3HpraGX3lXX4FPq3Gm-lHh3SwQA-5rtgPWNWMFXkw,41
+bhp_pro-1.3.2.dist-info/top_level.txt,sha256=1xjbIaVM77UJz9Tsi1JjILgE0YDG7iLhY6KSMNEi9zM,8
+bhp_pro-1.3.2.dist-info/RECORD,,

{bhp_pro-1.3.0.dist-info → bhp_pro-1.3.2.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,696 @@ 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'
-            }
-
-            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()
+        import os
+        import re
+        import socket
+        import time
+        import threading
+        import ipaddress
+        from queue import Queue
+        from tqdm import tqdm
 
-        def access_main():
+        FREE_SERVERS = {
+            'google': 'www.google.com',
+            'cloudflare': '1.1.1.1',
+            'open_dns': '208.67.222.222',
+            'quad9': '9.9.9.9',
+            'example': 'example.com',
+            'test_server': 'test.server.com'
+        }
 
+        XHTTP_PAYLOADS = {
+            "1": {
+                "name": "Standard HTTP/1.1",
+                "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: [UA]\r\nAccept: */*\r\nConnection: keep-alive\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "2": {
+                "name": "HTTP/1.1 Keep-Alive",
+                "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: [UA]\r\nConnection: Keep-Alive\r\nKeep-Alive: timeout=30\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "3": {
+                "name": "Chrome User-Agent",
+                "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-US,en;q=0.9\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "4": {
+                "name": "CONNECT Method",
+                "payload": "CONNECT [HOST]:443 HTTP/1.1\r\nHost: [HOST]:443\r\nUser-Agent: [UA]\r\nProxy-Connection: Keep-Alive\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "5": {
+                "name": "X-Online-Host Injection",
+                "payload": f"GET / HTTP/1.1\r\nHost: [HOST]\r\nX-Online-Host: {FREE_SERVERS['google']}\r\nUser-Agent: [UA]\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "6": {
+                "name": "X-Forwarded-Host Injection",
+                "payload": f"GET / HTTP/1.1\r\nHost: [HOST]\r\nX-Forwarded-Host: {FREE_SERVERS['example']}\r\nUser-Agent: [UA]\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "7": {
+                "name": "Simple POST Request",
+                "payload": "POST / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: [UA]\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 0\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "8": {
+                "name": "HTTP/2 Preface",
+                "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: [UA]\r\nUpgrade: h2c\r\nHTTP2-Settings: AAEAAEAAAAIAAAABAAMAAABkAAQBAAAAAAUAAEAA\r\nConnection: Upgrade, HTTP2-Settings\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "9": {
+                "name": "Mobile Safari UA",
+                "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-US,en;q=0.9\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "10": {
+                "name": "No Cache Headers",
+                "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: [UA]\r\nCache-Control: no-cache, no-store, must-revalidate\r\nPragma: no-cache\r\nExpires: 0\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "11": {
+                "name": "Double Host Header",
+                "payload": f"GET / HTTP/1.1\r\nHost: [HOST]\r\nHost: {FREE_SERVERS['example']}\r\nUser-Agent: [UA]\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "12": {
+                "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\nSec-WebSocket-Extensions: permessage-deflate; client_max_window_bits\r\n\r\n",
+                "type": "WS"
+            },
+            "13": {
+                "name": "Google Bot UA",
+                "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Googlebot/2.1; +http://www.google.com/bot.html) Chrome/120.0.0.0 Safari/537.36\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "14": {
+                "name": "Forwarded Headers",
+                "payload": f"GET / HTTP/1.1\r\nHost: [HOST]\r\nUser-Agent: [UA]\r\nForwarded: for=192.168.1.1;proto=http;host={FREE_SERVERS['test_server']}\r\nX-Forwarded-For: 192.168.1.1\r\nX-Real-IP: 192.168.1.1\r\n\r\n",
+                "type": "XHTTP"
+            },
+            "15": {
+                "name": "Pipelined Request",
+                "payload": "GET / HTTP/1.1\r\nHost: [HOST]\r\n\r\nGET /favicon.ico HTTP/1.1\r\nHost: [HOST]\r\n\r\n",
+                "type": "XHTTP"
+            }
+        }
 
-            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()]
-            else:
-                domains = [user_input]
+        class Config:
+            def __init__(self):
+                self.payloads = []
+                self.targets = []
+                self.proxies = []
+                self.output_file = "working_configs.txt"
+                self.timeout = 3
+                self.threads = 50
+
+        class PayloadManager:
+            @staticmethod
+            def generate_websocket_key():
+                import base64, os
+                return base64.b64encode(os.urandom(16)).decode()
+            
+            @staticmethod
+            def prepare_payload(payload_template, target_domain):
+                replacements = {
+                    '[HOST]': target_domain,
+                    '[UA]': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                    '[KEY]': PayloadManager.generate_websocket_key()
+                }
+                payload = payload_template
+                for placeholder, value in replacements.items():
+                    payload = payload.replace(placeholder, value)
+                return payload
+            
+            @staticmethod
+            def format_config(result):
+                escaped_payload = result['sent_payload'].replace('\r\n', '[crlf]')
+                return 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 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/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'])}
+        # ====================================================
 
-            if os.path.exists(OUTPUT_FILE):
-                os.remove(OUTPUT_FILE)
+        """
+            
+            @staticmethod
+            def save_results(results, filename, status_filter='All'):
+                if not results:
+                    return 0
+                
+                with open(filename, 'w', encoding='utf-8') as f:
+                    f.write(f"""# HTTP Injector Configurations
+        # Generated: {time.strftime('%Y-%m-%d %H:%M:%S')}
+        # Total Configs: {len(results)}
+        # Status Filter: {status_filter}
+        # 
+        # HOW TO USE:
+        # 1. Copy each [CONFIG] section
+        # 2. Create new config in HTTP Injector
+        # 3. Paste the settings
+        # ====================================================
 
-            domain_queue = Queue()
-            for domain in domains:
-                domain_queue.put(domain)
+        """)
+                    f.write("[SUMMARY]\n")
+                    f.write(f"Total_Configs={len(results)}\n")
+                    f.write(f"Status_Filter={status_filter}\n")
+                    
+                    status_stats = {}
+                    for result in results:
+                        status = result['status_code']
+                        status_category = f"{status//100}xx"
+                        status_stats[status_category] = status_stats.get(status_category, 0) + 1
+                    
+                    f.write("\n[STATUS_DISTRIBUTION]\n")
+                    for status, count in sorted(status_stats.items()):
+                        f.write(f"{status}={count}\n")
+                    
+                    f.write(f"\n#{'='*50}\n# WORKING CONFIGURATIONS\n#{'='*50}\n\n")
+                    
+                    for i, result in enumerate(results, 1):
+                        result['config_id'] = i
+                        f.write(PayloadManager.format_config(result))
+                
+                return len(results)
 
-            progress = tqdm(total=len(domains) * 2, desc="Checking", ncols=80)
+        class ProxyManager:
+            @staticmethod
+            def parse_proxy_input(proxy_input, ports):
+                proxies = []
+                
+                if ':' in proxy_input:
+                    ip_part, port = proxy_input.split(':', 1)
+                    port = int(port)
+                    
+                    if '/' in ip_part:
+                        try:
+                            network = ipaddress.ip_network(ip_part, strict=False)
+                            for ip in network.hosts():
+                                proxies.append((str(ip), port))
+                        except:
+                            pass
+                    else:
+                        proxies.append((ip_part, port))
+                    return proxies
+                
+                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
+                
+                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
+                
+                for port in ports:
+                    proxies.append((proxy_input.strip(), port))
+                
+                return proxies
 
-            threads = []
-            for _ in range(THREAD_COUNT):
-                t = threading.Thread(target=worker, args=(domain_queue, progress))
-                t.start()
-                threads.append(t)
+        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
+                self.failed = 0
+            
+            def detect_provider(self, response_text, target):
+                provider_indicators = {
+                    'Google': ['Google', 'gws', 'GSE', 'YouTube'],
+                    'Microsoft': ['Microsoft', 'IIS', 'Azure', 'Office'],
+                    'Facebook': ['Facebook', 'fb', 'Instagram'],
+                    'Cloudflare': ['Cloudflare', 'CF-RAY', 'cf-cache-status'],
+                    'Akamai': ['Akamai', 'Akamai-Ghost'],
+                    'Amazon': ['Amazon', 'AWS', 'CloudFront', 'S3'],
+                    'Alibaba': ['Alibaba', 'Aliyun', 'EMAS', 'AlibabaCloud'],
+                    'Tencent': ['Tencent', 'QCloud', 'TCB'],
+                    'Baidu': ['Baidu', 'baidu.com'],
+                    'Fastly': ['Fastly', 'Fastly error'],
+                    'CDN77': ['CDN77', 'NetDNA'],
+                    'Cloudflare': ['Cloudflare', 'CF-RAY'],
+                    'Nginx': ['nginx'],
+                    'Apache': ['Apache', 'httpd'],
+                    'LiteSpeed': ['LiteSpeed', 'LSWS'],
+                    'Varnish': ['Varnish'],
+                    'Sucuri': ['Sucuri'],
+                    'Imperva': ['Imperva', 'Imperva Incapsula']
+                }
+                
+                for provider, indicators in provider_indicators.items():
+                    for indicator in indicators:
+                        if indicator.lower() in response_text.lower():
+                            return provider
+                
+                return 'Unknown'
+            
+            def test_connection(self, payload_info, target, proxy_host, proxy_port):
+                try:
+                    sent_payload = PayloadManager.prepare_payload(payload_info['payload'], target)
+                    
+                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                    sock.settimeout(self.config.timeout)
+                    
+                    start_time = time.time()
+                    sock.connect((proxy_host, proxy_port))
+                    sock.send(sent_payload.encode())
+                    
+                    response = b""
+                    try:
+                        sock.settimeout(self.config.timeout)
+                        while True:
+                            chunk = sock.recv(1024)
+                            if not chunk:
+                                break
+                            response += chunk
+                            if len(response) > 8192:
+                                break
+                    except socket.timeout:
+                        pass
+                    
+                    sock.close()
+                    response_time = time.time() - start_time
+                    
+                    response_text = response.decode('utf-8', errors='ignore')
+                    
+                    status_match = re.search(r'HTTP/\d\.\d\s+(\d{3})', response_text)
+                    status_code = int(status_match.group(1)) if status_match else 0
+                    
+                    if status_code == 0:
+                        return {'success': False, 'error': 'No HTTP response'}
+                    
+                    server_match = re.search(r'Server:\s*([^\r\n]+)', response_text, re.IGNORECASE)
+                    server_info = server_match.group(1) if server_match else "Unknown"
+                    
+                    bypass_indicators = self._check_bypass_indicators(response_text)
+                    provider = self.detect_provider(response_text, target)
+                    
+                    return {
+                        'payload_name': payload_info['name'],
+                        'payload_template': payload_info['payload'],
+                        'sent_payload': sent_payload,
+                        'target': target,
+                        'proxy_host': proxy_host,
+                        'proxy_port': proxy_port,
+                        'status_code': status_code,
+                        'response_time': response_time,
+                        'server': server_info,
+                        'bypass_indicators': bypass_indicators,
+                        'provider': provider,
+                        'success': True
+                    }
+                    
+                except socket.timeout:
+                    return {'success': False, 'error': 'Connection timeout'}
+                except ConnectionRefusedError:
+                    return {'success': False, 'error': 'Connection refused'}
+                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'Connection established', 'CONNECT Successful'),
+                    (r'101 Switching Protocols', 'WebSocket Upgrade'),
+                    (r'HTTP/1.1 200.*HTTP/1.1', 'Request Smuggling'),
+                    (r'Upgrade:', 'Protocol Upgrade'),
+                    (r'Keep-Alive', 'Connection Persistence'),
+                    (r'X-Forwarded-For', 'Forwarded Request'),
+                    (r'X-Real-IP', 'Real IP Header'),
+                    (r'X-Forwarded-Host', 'Host Bypass'),
+                    (r'X-Original-Host', 'Original Host'),
+                    (r'Via:', 'Proxy Chain'),
+                    (r'Proxy-Connection', 'Proxy Support'),
+                    (r'Transfer-Encoding: chunked', 'Chunked Encoding'),
+                    (r'Content-Encoding: gzip', 'Compression Support'),
+                    (r'Server:.*nginx', 'Nginx Server'),
+                    (r'Server:.*Apache', 'Apache Server'),
+                    (r'Set-Cookie', 'Session Cookie'),
+                    (r'Vary:', 'Cache Variation'),
+                    (r'Age:', 'Cache Age')
+                ]
+                
+                for pattern, meaning in checks:
+                    if re.search(pattern, response_text, re.IGNORECASE | re.DOTALL):
+                        indicators.append(meaning)
+                
+                return indicators
+            
+            def worker(self, progress_bar):
+                while True:
+                    try:
+                        task = self.queue.get_nowait()
+                    except:
+                        break
+                    
+                    try:
+                        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)
+                                
+                                icon = "✅" if 200 <= result['status_code'] < 300 else \
+                                    "↪️" if 300 <= result['status_code'] < 400 else \
+                                    "⚠️" if 400 <= result['status_code'] < 500 else "❌"
+                                
+                                if result['bypass_indicators']:
+                                    icon += "🚀"
+                                
+                                provider_icon = {
+                                    'Google': '🔍',
+                                    'Microsoft': '🪟',
+                                    'Facebook': '👥',
+                                    'YouTube': '📺',
+                                    'Amazon': '📦',
+                                    'Cloudflare': '🛡️'
+                                }.get(result['provider'], '🌐')
+                                
+                                print(f"\r{icon}{provider_icon} {result['payload_name'][:20]:20} → "
+                                    f"{target[:15]:15} HTTP {result['status_code']:3} via {proxy_host}:{proxy_port}")
+                            else:
+                                self.failed += 1
+                        
+                        progress_bar.update(1)
+                        self.queue.task_done()
+                        
+                    except Exception as e:
+                        with self.lock:
+                            self.tested += 1
+                            self.failed += 1
+                        progress_bar.update(1)
+                        self.queue.task_done()
+            
+            def run_tests(self):
+                tasks = []
+                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:
+                                tasks.append((payload_info, target, proxy_host, proxy_port))
+                        else:
+                            tasks.append((payload_info, target, target, 80))
+                
+                for task in tasks:
+                    self.queue.put(task)
+                
+                total_tests = len(tasks)
+                
+                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: {min(self.config.threads, total_tests)}")
+                print(f"{'='*60}")
+                
+                print("\n📡 TESTING IN PROGRESS...\n")
+                
+                thread_count = min(self.config.threads, total_tests, 100)
+                
+                self.working_configs = []
+                self.tested = 0
+                self.successful = 0
+                self.failed = 0
+                
+                with tqdm(total=total_tests, desc="Testing", unit="test", ncols=80) as progress_bar:
+                    threads = []
+                    for _ in range(thread_count):
+                        t = threading.Thread(target=self.worker, args=(progress_bar,))
+                        t.daemon = True
+                        t.start()
+                        threads.append(t)
+                    
+                    for t in threads:
+                        t.join()
+                
+                print("\r" + " " * 80 + "\r", end="")
+                
+                print(f"\n{'='*60}")
+                print(f"✅ TESTING COMPLETE")
+                print(f"{'='*60}")
+                print(f"Tests Completed: {self.tested}")
+                print(f"Successful: {self.successful}")
+                print(f"Failed: {self.failed}")
+                print(f"Configs Found: {len(self.working_configs)}")
+                
+                return self.working_configs
 
-            for t in threads:
-                t.join()
+        def get_user_input():
+            config = Config()
+            
+            print("\n📋 AVAILABLE PAYLOADS:")
+            for key, info in XHTTP_PAYLOADS.items():
+                print(f"{key:>2}. {info['name']:25} [{info['type']:6}]")
+            
+            selection = input("\nSelect payloads (comma-separated, or 'all'): ").strip()
+            
+            if selection.lower() == 'all':
+                selected_keys = list(XHTTP_PAYLOADS.keys())
+            else:
+                selected_keys = [s.strip() for s in selection.split(',') if s.strip() in XHTTP_PAYLOADS]
+            
+            if not selected_keys:
+                print("❌ No payloads selected!")
+                return None
+            
+            for key in selected_keys:
+                config.payloads.append(XHTTP_PAYLOADS[key])
+            
+            print(f"\n✅ Selected {len(config.payloads)} payloads")
+            
+            targets_input = input("\nEnter target domain(s) (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 targets specified!")
+                return None
+            
+            print("\n🔄 PROXY SETTINGS")
+            print("1. Use proxies")
+            print("2. Direct connection")
+            
+            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 (default=80,443,8080,8443): ").strip()
+                ports = [int(p.strip()) for p in ports_input.split(',') if p.strip().isdigit()] if ports_input else [80, 443, 8080, 8443]
+                
+                config.proxies = ProxyManager.parse_proxy_input(proxy_input, ports)
+                
+                if not config.proxies:
+                    print("❌ Invalid proxy input!")
+                    return None
+                
+                print(f"✅ Loaded {len(config.proxies)} proxies")
+            
+            return config
 
-            progress.close()
-            print(f"\n✅ Finished checking. Results saved to {OUTPUT_FILE}")
+        def show_status_distribution(working_configs):
+            status_details = {}
+            for config in working_configs:
+                status = config['status_code']
+                status_details[status] = status_details.get(status, 0) + 1
+            
+            print(f"\n{'='*60}")
+            print("📊 STATUS CODE DISTRIBUTION")
+            print(f"{'='*60}")
+            
+            for status, count in sorted(status_details.items()):
+                print(f"  HTTP {status}: {count} configs")
+            
+            print(f"\n{'='*60}")
+            print("💾 SAVE RESULTS")
+            print(f"{'='*60}")
+            print("Which status codes to save?")
+            print("1. All status codes")
+            print("2. Only 2xx (Success)")
+            print("3. Only 3xx (Redirection)")
+            print("4. Only 4xx (Client Error)")
+            print("5. Only 5xx (Server Error)")
+            print("6. Success (2xx and 3xx)")
+            
+            while True:
+                choice = input("\nSelect option (1-6): ").strip()
+                
+                if choice in ['1', '2', '3', '4', '5', '6']:
+                    status_filter_map = {
+                        '1': 'all',
+                        '2': '2xx',
+                        '3': '3xx',
+                        '4': '4xx',
+                        '5': '5xx',
+                        '6': 'success'
+                    }
+                    status_filter = status_filter_map[choice]
+                    
+                    if choice == '2' and not any(200 <= s < 300 for s in status_details.keys()):
+                        print("⚠️ No 2xx responses found!")
+                        continue
+                    elif choice == '3' and not any(300 <= s < 400 for s in status_details.keys()):
+                        print("⚠️ No 3xx responses found!")
+                        continue
+                    elif choice == '4' and not any(400 <= s < 500 for s in status_details.keys()):
+                        print("⚠️ No 4xx responses found!")
+                        continue
+                    elif choice == '5' and not any(500 <= s < 600 for s in status_details.keys()):
+                        print("⚠️ No 5xx responses found!")
+                        continue
+                    elif choice == '6' and not any(200 <= s < 400 for s in status_details.keys()):
+                        print("⚠️ No success responses found!")
+                        continue
+                    elif choice == '':
+                        print("⚠️ Back to main menu.")
+                        continue
+                    
+                    return status_filter
+                else:
+                    print("❌ Invalid option!")
+
+        def save_with_filter(results, filename, status_filter):
+            if not results:
+                return 0
+            
+            if status_filter == 'all':
+                filtered_results = results
+            elif status_filter == '2xx':
+                filtered_results = [r for r in results if 200 <= r['status_code'] < 300]
+            elif status_filter == '3xx':
+                filtered_results = [r for r in results if 300 <= r['status_code'] < 400]
+            elif status_filter == '4xx':
+                filtered_results = [r for r in results if 400 <= r['status_code'] < 500]
+            elif status_filter == '5xx':
+                filtered_results = [r for r in results if 500 <= r['status_code'] < 600]
+            elif status_filter == 'success':
+                filtered_results = [r for r in results if 200 <= r['status_code'] < 400]
+            else:
+                filtered_results = results
+            
+            if not filtered_results:
+                print(f"❌ No results matching filter: {status_filter}")
+                return 0
+            
+            return PayloadManager.save_results(filtered_results, filename, status_filter)
 
+        def xhttp_payload_validator():
+            os.system('clear' if os.name == 'posix' else 'cls')
+            
+            banner = """
+            ╔══════════════════════════════════════════════════════════╗
+            ║                XHTTP TUNNEL PAYLOAD TESTER              ║
+            ║       Generate HTTP Injector Configs from Live Tests    ║
+            ╚══════════════════════════════════════════════════════════╝
+            """
+            print(banner)
+            
+            config = get_user_input()
+            if not config:
+                return
+            
+            estimated_tests = len(config.payloads) * len(config.targets) * max(len(config.proxies), 1)
+            
+            print(f"\n{'='*60}")
+            print("READY TO TEST")
+            print(f"{'='*60}")
+            print(f"Payloads: {len(config.payloads)}")
+            print(f"Targets: {len(config.targets)}")
+            print(f"Proxies: {len(config.proxies) if config.proxies else 'Direct'}")
+            print(f"Estimated Tests: {estimated_tests}")
+            print(f"{'='*60}")
+            
+            if input("\nStart testing? (y/n): ").strip().lower() != 'y':
+                print("❌ Cancelled")
+                return
+            
+            start_time = time.time()
+            tester = NetworkTester(config)
+            working_configs = tester.run_tests()
+            
+            if working_configs:
+                status_filter = show_status_distribution(working_configs)
+                
+                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
+                
+                saved_count = save_with_filter(working_configs, config.output_file, status_filter)
+                elapsed = time.time() - start_time
+                
+                if saved_count > 0:
+                    print(f"\n{'='*60}")
+                    print("📦 RESULTS SAVED")
+                    print(f"{'='*60}")
+                    print(f"✅ Generated {saved_count} configs")
+                    print(f"📁 Output: {config.output_file}")
+                    print(f"⏱️  Time: {elapsed:.1f}s")
+                    print(f"{'='*60}")
+            else:
+                print("\n❌ No working configurations found!")
 
-        access_main()
+        xhttp_payload_validator()
 
 
     def x_menu():
@@ -17058,7 +17665,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.2 ®" + 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,,