LeakingCode | LC On Top!

EXPIRATION_DATE = datetime(2024, 9, 31)

def check_expiration():
    today = datetime.now()
    if today > EXPIRATION_DATE:
        print(Fore.RED + "The script has expired. Please contact the developer. t.me/Lintar21")
        sys.exit(1)

import random
import requests
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

def generate_random_ip():
    ip_ranges = [
        (10, 254),    # IP privat (10.0.0.0/8)
        (172, 31),    # IP privat (172.16.0.0/12)
        (192, 168)    # IP privat (192.168.0.0/16)
    ] # add kostum sendiri klw mau
    
    range_choice = random.choice(ip_ranges)
    if range_choice[0] <= range_choice[1]:
        ip = f"{random.randint(range_choice[0], range_choice[1])}.{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(0, 255)}"
    else:
        ip = f"{random.randint(1, 254)}.{random.randint(0, 255)}.{random.randint(0, 255)}.{random.randint(0, 255)}"
    return ip

def generate_random_port():
    common_ports = [8080, 8888, 3128, 80, 1080, 9050]
    return random.choice(common_ports)

def check_proxy_quality(ip, port, protocol):
    proxy = f"{protocol}://{ip}:{port}"
    print(f"Check-in Proxy {proxy}")
    try:
        start_time = time.time()
        response = requests.get('http://httpbin.org/ip', proxies={protocol: proxy}, timeout=5)
        elapsed_time = time.time() - start_time
        if response.status_code == 200:
            print(f"FOUND Valid {protocol.upper()} proxy {proxy} - Response Time: {elapsed_time:.2f}s")
            return True, elapsed_time
    except requests.RequestException:
        pass
    print(f"Failed {protocol.upper()} Proxy {proxy}")
    return False, None

def process_proxy(ip, port):
    protocols = ['http', 'https']
    results = []
    for protocol in protocols:
        print(f"Create Random Proxy {protocol}://{ip}:{port}")
        is_valid, response_time = check_proxy_quality(ip, port, protocol)
        results.append((protocol, is_valid, response_time))
    return ip, port, results

def main():
    active_proxies = {'http': [], 'https': []}
    dead_proxies = {'http': [], 'https': []}
    high_quality_proxies = {'http': [], 'https': []}
    num_proxies = 100
    max_response_time = 2
    
    proxies_to_test = [(generate_random_ip(), generate_random_port()) for _ in range(num_proxies)]

    with ThreadPoolExecutor(max_workers=20) as executor:
        future_to_proxy = {executor.submit(process_proxy, ip, port): (ip, port) for ip, port in proxies_to_test}
        
        for future in as_completed(future_to_proxy):
            ip, port = future_to_proxy[future]
            try:
                result = future.result()
                ip, port, results = result
                for protocol, is_valid, response_time in results:
                    if is_valid:
                        if response_time and response_time < max_response_time:
                            high_quality_proxies[protocol].append(f"{ip}:{port}")
                        else:
                            active_proxies[protocol].append(f"{ip}:{port}")
                    else:
                        dead_proxies[protocol].append(f"{ip}:{port}")
            except Exception as exc:
                print(f"Proxy {ip}:{port} generated an exception: {exc}")

    with open('HighQualityProxies.txt', 'w') as file:
        for protocol in high_quality_proxies:
            for proxy in high_quality_proxies[protocol]:
                file.write(f"{proxy}\n")

    print(f"Total high quality proxies:")
    for protocol in high_quality_proxies:
        print(f"  {protocol.upper()}: {len(high_quality_proxies[protocol])}")
    print(f"Total active proxies:")
    for protocol in active_proxies:
        print(f"  {protocol.upper()}: {len(active_proxies[protocol])}")
    print(f"Total dead proxies:")
    for protocol in dead_proxies:
        print(f"  {protocol.upper()}: {len(dead_proxies[protocol])}")

if __name__ == "__main__":
    main()