bhp-pro 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

{bhp_pro-1.2.2.dist-info → bhp_pro-1.2.3.dist-info}/METADATA

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

bhp_pro-1.2.3.dist-info/RECORD

@@ -0,0 +1,6 @@
+bhp_pro.py,sha256=rF2jOsRh8wscEdzWp9kKFNtX4SItwfh99oy9R80iN0Q,744358
+bhp_pro-1.2.3.dist-info/METADATA,sha256=QRATsusWg7bRojFoFOe774rXyUbf0cerWwY_Ejo591w,600
+bhp_pro-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bhp_pro-1.2.3.dist-info/entry_points.txt,sha256=Yn3HpraGX3lXX4FPq3Gm-lHh3SwQA-5rtgPWNWMFXkw,41
+bhp_pro-1.2.3.dist-info/top_level.txt,sha256=1xjbIaVM77UJz9Tsi1JjILgE0YDG7iLhY6KSMNEi9zM,8
+bhp_pro-1.2.3.dist-info/RECORD,,

bhp_pro.py

@@ -7818,40 +7818,34 @@ def open_port_checker():
 def udp_tcp():
     
     generate_ascii_banner("UDP", "TCP")
-
     import socket
     import ssl
     import os
     import re
     import requests
-    import dns.resolver
     import ipaddress
     from concurrent.futures import ThreadPoolExecutor, as_completed
     import time
+    from tqdm import tqdm
 
-    # Constants
-    SAVE_FILE = 'scan_results.txt'
-    TIMEOUT = 1.5  # Reduced timeout from 2 to 1.5 seconds
-    MAX_THREADS = 100  # Increased thread pool size
+    TIMEOUT = 1.5
+    MAX_THREADS = 100
 
-    # Optimized port list - focusing on most common ports first
     COMMON_PORTS = [
-        80, 443, 22, 21, 25, 53, 110, 143, 465, 587, 993, 995,  # Common web/email
-        3389, 3306, 5432, 27017, 1521, 1433,  # Database ports
-        8080, 8443, 8888, 8000,  # Alternative web ports
-        161, 162, 137, 139, 445,  # Network services
-        23, 69, 123, 514,  # Misc services
+        80, 443, 22, 21, 25, 53, 110, 143, 465, 587, 993, 995,
+        3389, 3306, 5432, 27017, 1521, 1433,
+        8080, 8443, 8888, 8000,
+        161, 162, 137, 139, 445,
+        23, 69, 123, 514,
     ]
 
-    # Dictionary for common UDP ports with payloads (optimized for most common first)
     common_ports_payloads = {
-        53: b'\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x07example\x03com\x00\x00\x01\x00\x01',  # DNS
-        123: b'\x1b' + 47 * b'\0',  # NTP
-        161: b'\x30\x26\x02\x01\x00\x04\x06public\xa0\x19\x02\x04\x13\x79\xf9\xa9\x02\x01\x00\x02\x01\x00\x30\x0b\x30\x09\x06\x05\x2b\x06\x01\x02\x01\x05\x00',  # SNMP
-        137: b'\x82\x28\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x20\x43\x4B\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x00\x00\x21\x00\x01',  # NetBIOS
-        500: b'\x00' * 100,  # ISAKMP
-        1900: b'M-SEARCH * HTTP/1.1\r\nHOST:239.255.255.250:1900\r\nMAN:"ssdp:discover"\r\nMX:1\r\nST:ssdp:all\r\n',  # SSDP
-        # Removed less common UDP ports to speed up scanning
+        53: b'\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x07example\x03com\x00\x00\x01\x00\x01',
+        123: b'\x1b' + 47 * b'\0',
+        161: b'\x30\x26\x02\x01\x00\x04\x06public\xa0\x19\x02\x04\x13\x79\xf9\xa9\x02\x01\x00\x02\x01\x00\x30\x0b\x30\x09\x06\x05\x2b\x06\x01\x02\x01\x05\x00',
+        137: b'\x82\x28\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x20\x43\x4B\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x00\x00\x21\x00\x01',
+        500: b'\x00' * 100,
+        1900: b'M-SEARCH * HTTP/1.1\r\nHOST:239.255.255.250:1900\r\nMAN:"ssdp:discover"\r\nMX:1\r\nST:ssdp:all\r\n',
     }
 
     def send_udp_packet(ip, port, payload):
@@ -7860,96 +7854,104 @@ def udp_tcp():
             try:
                 sock.sendto(payload, (ip, port))
                 data, _ = sock.recvfrom(1024)
-                return data
-            except (socket.timeout, ConnectionResetError):
-                return None
+                # Got actual UDP response (port is open)
+                return 'open', data
+            except socket.timeout:
+                # No response (port might be open/filtered)
+                # UDP scanning limitation: can't distinguish open vs filtered
+                return 'timeout', None
+            except ConnectionResetError:
+                # ICMP port unreachable (port is closed)
+                return 'closed', None
             except Exception as e:
-                return None
+                # Other error
+                return 'error', None
 
-    def detect_net_server(ip, port):
+    def service_detection(ip, port, protocol='tcp'):
         try:
-            with socket.create_connection((ip, port), timeout=TIMEOUT) as sock:
-                sock.settimeout(TIMEOUT)
-                sock.sendall(b"HEAD / HTTP/1.0\r\n\r\n")
-                data = sock.recv(1024)
-                return f"Inferred Net Server: {parse_net_server(data)}"
-        except Exception:
-            return "Unknown Net Server"
-
-    def parse_net_server(data):
-        try:
-            text = data.decode('utf-8', errors='ignore').lower()
-            return "Unknown Net Server"
-        except Exception:
-            return "Unknown Net Server"
-
-
-    def service_detection(ip, port):
-        try:
-            # HTTP
-            if port == 80:
-                response = requests.head(f'http://{ip}', timeout=TIMEOUT, allow_redirects=True)
-                server = response.headers.get('Server', '').strip()
-                if not server:
-                    return detect_net_server(ip, port)
-                return f"HTTP Service: {server}"
-            
-            # HTTPS
-            elif port == 443:
-                response = requests.head(f'https://{ip}', timeout=TIMEOUT, verify=False, allow_redirects=True)
-                server = response.headers.get('Server', '').strip()
-                if not server:
-                    return detect_net_server(ip, port)
-                return f"HTTPS Service: {server}"
-            
-            # SSH
-            elif port == 22:
-                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                    s.settimeout(TIMEOUT)
-                    s.connect((ip, port))
-                    banner = s.recv(1024).decode('utf-8', errors='ignore').strip()
-                    return f"SSH Banner: {banner}"
-
-            # Common TCP services with banners
-            elif port in [21, 3306, 5432, 27017]:
-                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                    s.settimeout(TIMEOUT)
-                    s.connect((ip, port))
-                    banner = s.recv(1024).decode('utf-8', errors='ignore').strip()
-                    return f"Banner: {banner[:100]}"
-
-            # UDP - optional but fragile (SNMP, NTP)
-            elif port in [53, 161, 123, 500, 1900]:
-                with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
-                    s.settimeout(TIMEOUT)
-                    s.sendto(b'\x00', (ip, port))
-                    data, _ = s.recvfrom(1024)
-                    if data:
-                        return f"UDP Response: {data[:100]}"
-            
-            # Generic TCP banner grabbing fallback
-            elif port in COMMON_PORTS:
-                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                    s.settimeout(TIMEOUT)
-                    s.connect((ip, port))
-                    banner = s.recv(1024).decode(errors='ignore').strip()
-                    return f"TCP Banner: {banner[:100]}"
-
+            if protocol == 'tcp':
+                if port == 80:
+                    response = requests.head(f'http://{ip}', timeout=TIMEOUT, allow_redirects=True)
+                    server = response.headers.get('Server', '').strip()
+                    if not server:
+                        return "HTTP Service"
+                    return f"HTTP: {server}"
+                elif port == 443:
+                    response = requests.head(f'https://{ip}', timeout=TIMEOUT, verify=False, allow_redirects=True)
+                    server = response.headers.get('Server', '').strip()
+                    if not server:
+                        return "HTTPS Service"
+                    return f"HTTPS: {server}"
+                elif port == 22:
+                    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                        s.settimeout(TIMEOUT)
+                        s.connect((ip, port))
+                        banner = s.recv(1024).decode('utf-8', errors='ignore').strip()
+                        return f"SSH: {banner[:50]}"
+                elif port in [21, 3306, 5432, 27017]:
+                    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                        s.settimeout(TIMEOUT)
+                        s.connect((ip, port))
+                        banner = s.recv(1024).decode('utf-8', errors='ignore').strip()
+                        return f"{banner[:50]}"
+                elif port in COMMON_PORTS:
+                    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                        s.settimeout(TIMEOUT)
+                        s.connect((ip, port))
+                        banner = s.recv(1024).decode(errors='ignore').strip()
+                        return f"{banner[:50]}"
+            
+            elif protocol == 'udp':
+                if port == 53:
+                    return "DNS Service"
+                elif port == 123:
+                    return "NTP Service"
+                elif port == 161:
+                    return "SNMP Service"
+                elif port == 137:
+                    return "NetBIOS Service"
+                elif port == 500:
+                    return "ISAKMP Service"
+                elif port == 1900:
+                    return "SSDP Service"
+                else:
+                    return "UDP Service"
+                    
         except Exception:
-            return "Service detected"
-
-        return "Unknown service"
-
+            return "Service"
+        return "Service"
+
+    def categorize_port(port):
+        port_categories = {
+            'Web': [80, 443, 8080, 8443, 8888, 8000],
+            'Email': [25, 110, 143, 465, 587, 993, 995],
+            'SSH': [22, 3389],
+            'Database': [3306, 5432, 27017, 1521, 1433],
+            'DNS': [53],
+            'Network': [161, 162, 137, 139, 445],
+            'FTP': [21, 23, 69],
+            'Time': [123],
+            'VPN': [500],
+            'Discovery': [1900],
+            'Syslog': [514]
+        }
+        
+        for category, ports in port_categories.items():
+            if port in ports:
+                return category
+        return "Other"
 
-    def fast_tcp_scan(ip, ports, scan_results):
+    def fast_tcp_scan(ip, ports, stats, pbar, results_store):
+        found_ports = []
+        
         def check_port(ip, port):
             try:
                 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                     s.settimeout(TIMEOUT)
                     result = s.connect_ex((ip, port))
                     if result == 0:
-                        service = service_detection(ip, port)
-                        return port, f"TCP open - {service}"
+                        service = service_detection(ip, port, 'tcp')
+                        return port, service
             except Exception:
                 pass
             return None, None
@@ -7957,66 +7959,125 @@ def udp_tcp():
         with ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:
             futures = [executor.submit(check_port, ip, port) for port in ports]
             for future in as_completed(futures):
-                port, status = future.result()
+                port, service = future.result()
                 if port:
-                    scan_results[port] = status
+                    stats['tcp'] += 1
+                    stats['total'] += 1
+                    category = categorize_port(port)
+                    found_ports.append((port, service, category))
+                    
+                    results_store['tcp'].append(f"{ip}:{port} ({category}) - {service}")
+                    
+                    if pbar:
+                        pbar.set_description(f"TCP: {stats['tcp']} UDP: {stats['udp']}")
+        
+        return found_ports
 
-    def fast_udp_scan(ip, ports, scan_results):
+    def fast_udp_scan(ip, ports, stats, pbar, results_store):
+        found_ports = []
+        
         def check_udp_port(ip, port):
+            if port not in common_ports_payloads:
+                return None, None
+                
             payload = common_ports_payloads.get(port, b'')
-            response = send_udp_packet(ip, port, payload)
-            if response is not None:
-                service = service_detection(ip, port)
-                return port, f"UDP open - {service}"
+            status, data = send_udp_packet(ip, port, payload)
+            
+            # Only count as open if we got actual UDP response
+            if status == 'open':
+                service = service_detection(ip, port, 'udp')
+                return port, service
             return None, None
 
         with ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:
             futures = [executor.submit(check_udp_port, ip, port) for port in ports if port in common_ports_payloads]
             for future in as_completed(futures):
-                port, status = future.result()
+                port, service = future.result()
                 if port:
-                    scan_results[port] = status
-
-    def scan_target(ip):
-        scan_results = {}
-        print(f"Scanning {ip}...", end='\r')
+                    stats['udp'] += 1
+                    stats['total'] += 1
+                    category = categorize_port(port)
+                    found_ports.append((port, service, category))
+                    
+                    results_store['udp'].append(f"{ip}:{port} ({category}) - {service}")
+                    
+                    if pbar:
+                        pbar.set_description(f"TCP: {stats['tcp']} UDP: {stats['udp']}")
         
-        # Scan TCP ports first (faster)
-        fast_tcp_scan(ip, COMMON_PORTS, scan_results)
+        return found_ports
+
+    def scan_target(ip, stats, pbar, results_store):
+        if pbar:
+            pbar.set_description(f"Scanning {ip}")
         
-        # Only scan UDP if we found open TCP ports (heuristic to save time)
-        if scan_results:
-            fast_udp_scan(ip, COMMON_PORTS, scan_results)
+        tcp_ports = fast_tcp_scan(ip, COMMON_PORTS, stats, pbar, results_store)
+        udp_ports = fast_udp_scan(ip, COMMON_PORTS, stats, pbar, results_store)
         
-        # SSL check only if 443 is open
-        if 443 in COMMON_PORTS and any(p == 443 for p in scan_results):
+        ssl_cert = None
+        if any(port[0] == 443 for port in tcp_ports):
             try:
                 context = ssl.create_default_context()
                 with socket.create_connection((ip, 443), timeout=TIMEOUT) as sock:
                     with context.wrap_socket(sock, server_hostname=ip) as sslsock:
                         cert = sslsock.getpeercert()
-                        scan_results['SSL'] = f"Certificate: {cert.get('subject', '')}"
+                        ssl_cert = f"{ip}:443 - SSL Certificate: {cert.get('subject', '')}"
+                        results_store['ssl'].append(ssl_cert)
             except Exception:
                 pass
+        
+        return ip, tcp_ports, udp_ports, ssl_cert
 
-        return scan_results
+    def save_live_results(results_store, file_handle):
+        if results_store['tcp']:
+            for result in results_store['tcp']:
+                file_handle.write(f"[TCP] {result}\n")
+            results_store['tcp'].clear()
+        
+        if results_store['udp']:
+            for result in results_store['udp']:
+                file_handle.write(f"[UDP] {result}\n")
+            results_store['udp'].clear()
+        
+        if results_store['ssl']:
+            for result in results_store['ssl']:
+                file_handle.write(f"[SSL] {result}\n")
+            results_store['ssl'].clear()
+        
+        file_handle.flush()
 
-    def batch_scan(targets):
+    def batch_scan(targets, stats, filepath):
         all_results = {}
-        with ThreadPoolExecutor(max_workers=100) as executor:  # Scan multiple IPs in parallel
-            future_to_ip = {executor.submit(scan_target, ip): ip for ip in targets}
-            for future in as_completed(future_to_ip):
-                ip = future_to_ip[future]
-                try:
-                    results = future.result()
-                    if results:
-                        all_results[ip] = results
-                except Exception as e:
-                    print(f"Error scanning {ip}:")
+        results_store = {'tcp': [], 'udp': [], 'ssl': []}
+        
+        with open(filepath, "w") as f:
+            f.write(f"PORT SCAN RESULTS - Live Feed\n")
+            f.write(f"Started: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write("=" * 60 + "\n\n")
+            f.flush()
+            
+            with tqdm(total=len(targets), desc="Scanning targets", unit="target") as pbar:
+                with ThreadPoolExecutor(max_workers=100) as executor:
+                    future_to_ip = {executor.submit(scan_target, ip, stats, pbar, results_store): ip for ip in targets}
+                    for future in as_completed(future_to_ip):
+                        ip = future_to_ip[future]
+                        try:
+                            ip_result, tcp_ports, udp_ports, ssl_cert = future.result()
+                            if tcp_ports or udp_ports:
+                                all_results[ip_result] = (tcp_ports, udp_ports, ssl_cert)
+                        except Exception:
+                            pass
+                        pbar.update(1)
+                        pbar.set_description(f"TCP: {stats['tcp']} UDP: {stats['udp']}")
+                        
+                        save_live_results(results_store, f)
+            
+            f.write("\n" + "=" * 60 + "\n")
+            f.write(f"SCAN COMPLETE\n")
+            f.write(f"Total TCP: {stats['tcp']} | Total UDP: {stats['udp']} | Total: {stats['total']}\n")
+            f.write(f"Ended: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+        
         return all_results
 
-
-
     def get_targets_from_input(input_str):
         targets = set()
         try:
@@ -8026,29 +8087,21 @@ def udp_tcp():
                     for line in lines:
                         line = line.strip()
                         targets.update(get_targets_from_input(line))
-            elif "/" in input_str:  # CIDR
+            elif "/" in input_str:
                 net = ipaddress.ip_network(input_str, strict=False)
                 targets.update(str(ip) for ip in net.hosts())
-            elif re.match(r"^\d{1,3}(\.\d{1,3}){3}$", input_str):  # IP
+            elif re.match(r"^\d{1,3}(\.\d{1,3}){3}$", input_str):
                 targets.add(input_str)
-            else:  # Domain
+            else:
                 try:
                     ip = socket.gethostbyname(input_str)
                     targets.add(ip)
                 except:
-                    print(f"Failed to resolve domain: {input_str}")
-        except Exception as e:
-            print(f"Error processing input:")
+                    print(f"Failed to resolve: {input_str}")
+        except Exception:
+            print("Error processing input")
         return list(targets)
 
-    def save_results_to_file(results):
-        with open(SAVE_FILE, "w") as f:
-            for ip, ports in results.items():
-                f.write(f"\n[+] {ip}\n")
-                for port, info in ports.items():
-                    f.write(f"  {port}: {info}\n")
-
-
     def udp_tcp_main098():
         user_input = input("Enter IP/URL/CIDR or file path: ")
         targets = get_targets_from_input(user_input)
@@ -8057,13 +8110,34 @@ def udp_tcp():
             print("No valid targets found.")
             return
         
+        output_file = input("Enter output filename (e.g., results.txt): ").strip()
+        if not output_file:
+            output_file = "scan_results.txt"
+        
+        if not output_file.endswith('.txt'):
+            output_file += '.txt'
+        
+        cwd = os.getcwd()
+        filepath = os.path.join(cwd, output_file)
+        
+        print(f"\nStarting scan of {len(targets)} target(s)...")
+        print(f"Live results saving to: {filepath}")
+        print("-" * 60)
+        
+        stats = {'tcp': 0, 'udp': 0, 'total': 0}
         start_time = time.time()
-        all_results = batch_scan(targets)
+        
+        all_results = batch_scan(targets, stats, filepath)
+        
         elapsed = time.time() - start_time
         
-        save_results_to_file(all_results)
-        print(f"\nScanned {len(targets)} targets in {elapsed:.2f} seconds")
-        print(f"Results saved to '{SAVE_FILE}'")
+        print(f"\n" + "-" * 60)
+        print(f"Scan completed in {elapsed:.2f} seconds")
+        print(f"TCP: {stats['tcp']} | UDP: {stats['udp']} | Total: {stats['total']}")
+        print(f"Results saved to: {filepath}")
+        
+        if stats['total'] == 0:
+            print("No open ports found.")
 
     udp_tcp_main098()
 
@@ -16876,7 +16950,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.2.2 ®" + ENDC,
+    PURPLE + "script_version@ 1.2.3 ®" + ENDC,
     ORANGE + "All rights reserved 2022-2025 ♛: ®" + ENDC, 
     MAGENTA + "In Collaboration whit Ayan Rajpoot ® " + ENDC,
     BLUE +  "Support: https://t.me/BugScanX 💬" + ENDC,     

bhp_pro-1.2.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-bhp_pro.py,sha256=ffczA1rUc3B6RfEVLFDHMwTRLfAbKX3rjYwHFuUtU2E,741124
-bhp_pro-1.2.2.dist-info/METADATA,sha256=J8ckwZ92dhcVHH6iW-Ob9RphX-f_Z5zR7IwfGuLbefA,600
-bhp_pro-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bhp_pro-1.2.2.dist-info/entry_points.txt,sha256=Yn3HpraGX3lXX4FPq3Gm-lHh3SwQA-5rtgPWNWMFXkw,41
-bhp_pro-1.2.2.dist-info/top_level.txt,sha256=1xjbIaVM77UJz9Tsi1JjILgE0YDG7iLhY6KSMNEi9zM,8
-bhp_pro-1.2.2.dist-info/RECORD,,