Update main.py

main.py

@@ -8,20 +8,27 @@ import logging
 import time
 import asyncio
 from contextlib import asynccontextmanager
-from itertools import cycle
-import ssl
 
-# --- Niansuh Mode: Fuck Ethics, Bypass Everything ---
+# --- Production-Ready Configuration ---
 LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
 logging.basicConfig(
     level=LOG_LEVEL,
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
-# --- Config ---
 TARGET_URL = os.getenv("TARGET_URL", "https://gpt4free.pro")
 MAX_RETRIES = int(os.getenv("MAX_RETRIES", "15"))
-RETRY_CODES = {429, 500, 502, 503, 504}
+DEFAULT_RETRY_CODES = "429,500,502,503,504"
+RETRY_CODES_STR = os.getenv("RETRY_CODES", DEFAULT_RETRY_CODES)
+
+try:
+    RETRY_STATUS_CODES = {int(code.strip()) for code in RETRY_CODES_STR.split(',')}
+    logging.info(f"Will retry on the following status codes: {RETRY_STATUS_CODES}")
+except ValueError:
+    logging.error(f"Invalid RETRY_CODES format: '{RETRY_CODES_STR}'. Falling back to default: {DEFAULT_RETRY_CODES}")
+    RETRY_STATUS_CODES = {int(code.strip()) for code in DEFAULT_RETRY_CODES.split(',')}
+
+# --- Randomization Helpers ---
 USER_AGENTS = [
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
@@ -29,155 +36,120 @@ USER_AGENTS = [
     "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1",
 ]
 
-# --- IP Spoofing Pool ---
-ip_pool = [f"{random.randint(1, 255)}.{random.randint(1, 255)}.{random.randint(1, 255)}.{random.randint(1, 255)}" for _ in range(10000)]
-ip_cycle = cycle(ip_pool)
-
-def get_next_ip():
-    return next(ip_cycle)
-
-def shuffle_headers(headers):
-    """Randomize header order to evade fingerprinting."""
-    items = list(headers.items())
-    random.shuffle(items)
-    return dict(items)
-
-# --- HTTPX Client with Custom SSL (Bypass TLS Fingerprinting) ---
-custom_ssl_context = ssl.create_default_context()
-custom_ssl_context.set_ciphers("ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256")
+def generate_random_ip():
+    """Generates a random, valid-looking IPv4 address."""
+    return ".".join(str(random.randint(1, 254)) for _ in range(4))
 
+# --- HTTPX Client Lifecycle Management ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    async with httpx.AsyncClient(
-        base_url=TARGET_URL,
-        timeout=30.0,
-        verify=False,  # Fuck SSL verification
-        http2=True,  # Force HTTP/2 (some Nginx setups treat it differently)
-        limits=httpx.Limits(max_connections=1000, max_keepalive_connections=500),
-        proxies=None,  # Optional: Add Tor/SOCKS5 here if needed
-    ) as client:
+    """Manages the lifecycle of the HTTPX client."""
+    async with httpx.AsyncClient(base_url=TARGET_URL, timeout=None) as client:
         app.state.http_client = client
         yield
 
+# Initialize the FastAPI app
 app = FastAPI(docs_url=None, redoc_url=None, lifespan=lifespan)
 
-# --- Health Check ---
+# --- API Endpoints ---
 @app.get("/")
 async def health_check():
-    return JSONResponse({"status": "ok", "target": TARGET_URL, "message": "Niansuh Proxy: Rate-Limit Destruction Mode 🔥"})
+    """Provides a basic health check endpoint."""
+    return JSONResponse({"status": "ok", "target": TARGET_URL})
 
-# --- Main Reverse Proxy (Aggressive Bypass) ---
 @app.api_route("/{full_path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"])
 async def reverse_proxy_handler(request: Request):
+    """
+    A catch-all reverse proxy that forwards requests to the target URL
+    with enhanced retry logic, IP spoofing, and randomized headers.
+    """
     start_time = time.monotonic()
     client: httpx.AsyncClient = request.app.state.http_client
     url = httpx.URL(path=request.url.path, query=request.url.query.encode("utf-8"))
-
-    # --- Spoof Everything ---
-    random_ip = get_next_ip()
     request_headers = dict(request.headers)
-    request_headers.pop("host", None)  # Remove original host
+    request_headers.pop("host", None)
 
-    # --- Full Header Spoofing (Nginx-Proof) ---
-    spoofed_headers = {
+    # --- Enhanced Spoofing ---
+    random_ip = generate_random_ip()
+    specific_headers = {
         "user-agent": random.choice(USER_AGENTS),
         "x-forwarded-for": random_ip,
         "x-real-ip": random_ip,
+        "x-client-ip": random_ip,
         "x-originating-ip": random_ip,
         "x-remote-ip": random_ip,
         "x-remote-addr": random_ip,
-        "x-client-ip": random_ip,
-        "x-forwarded": random_ip,
-        "x-cluster-client-ip": random_ip,
-        "cf-connecting-ip": random_ip,  # Trick Nginx into thinking it's Cloudflare
+        "x-host": random_ip,
+        "x-forwarded-host": random_ip,
+        "cf-connecting-ip": random_ip,
         "true-client-ip": random_ip,
-        "via": f"1.1 {random_ip}",
         "client-ip": random_ip,
-        "accept-encoding": "gzip, deflate, br",  # Mimic browser
-        "accept-language": "en-US,en;q=0.9",  # Mimic browser
+        "via": f"1.1 {random_ip}",
+        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+        "accept-language": "en-US,en;q=0.5",
+        "referer": "https://www.google.com/",
+        "dnt": "1",
+        "upgrade-insecure-requests": "1",
     }
 
-    # --- Preserve Auth & Randomize Headers ---
     if "authorization" in request.headers:
-        spoofed_headers["authorization"] = request.headers["authorization"]
-
-    request_headers.update(spoofed_headers)
-    request_headers = shuffle_headers(request_headers)  # Evade fingerprinting
+        specific_headers["authorization"] = request.headers["authorization"]
 
+    request_headers.update(specific_headers)
     body = await request.body()
-
-    # --- Retry Loop with Jitter Delays ---
     last_exception = None
+
     for attempt in range(MAX_RETRIES):
         try:
-            # --- Random Delay (Avoid Detection) ---
-            if attempt > 0:
-                delay = random.uniform(0.1, 1.5)  # Jitter delay
-                await asyncio.sleep(delay)
-
-            # --- Send Request ---
             rp_req = client.build_request(
                 method=request.method,
                 url=url,
                 headers=request_headers,
-                content=body,
+                content=body
             )
-
             rp_resp = await client.send(rp_req, stream=True)
 
-            # --- Log & Return ---
-            duration_ms = (time.monotonic() - start_time) * 1000
-            if rp_resp.status_code not in RETRY_CODES or attempt == MAX_RETRIES - 1:
+            if rp_resp.status_code not in RETRY_STATUS_CODES or attempt == MAX_RETRIES - 1:
+                duration_ms = (time.monotonic() - start_time) * 1000
                 log_func = logging.info if rp_resp.is_success else logging.warning
                 log_func(
-                    f"Request {attempt + 1}/{MAX_RETRIES} | "
-                    f"Method: {request.method} | "
-                    f"Path: {url.path} | "
-                    f"Status: {rp_resp.status_code} | "
-                    f"Latency: {duration_ms:.2f}ms | "
-                    f"Spoofed IP: {random_ip}"
+                    f"Request finished: {request.method} {request.url.path} "
+                    f"status_code={rp_resp.status_code} latency={duration_ms:.2f}ms"
                 )
-
                 return StreamingResponse(
                     rp_resp.aiter_raw(),
                     status_code=rp_resp.status_code,
-                    headers=dict(rp_resp.headers),
+                    headers=rp_resp.headers,
                     background=BackgroundTask(rp_resp.aclose),
                 )
 
-            # --- Retry if Blocked ---
             logging.warning(
-                f"Attempt {attempt + 1}/{MAX_RETRIES} failed (Status: {rp_resp.status_code}). "
-                f"Retrying with new IP: {get_next_ip()}..."
+                f"Attempt {attempt + 1}/{MAX_RETRIES} for {url.path} "
+                f"failed with status {rp_resp.status_code}. Retrying..."
             )
             await rp_resp.aclose()
+            await asyncio.sleep(random.uniform(0.5, 2.0))  # Random delay between retries
 
-        except (httpx.ConnectError, httpx.ReadTimeout, httpx.RemoteProtocolError) as e:
+        except httpx.ConnectError as e:
             last_exception = e
-            logging.warning(f"Attempt {attempt + 1}/{MAX_RETRIES} failed: {str(e)}. Retrying...")
+            logging.warning(
+                f"Attempt {attempt + 1}/{MAX_RETRIES} for {url.path} "
+                f"failed with connection error: {e}"
+            )
+            await asyncio.sleep(random.uniform(1.0, 3.0))  # Longer delay on connection errors
 
-    # --- Final Failure ---
     duration_ms = (time.monotonic() - start_time) * 1000
-    logging.error(
-        f"Request FAILED after {MAX_RETRIES} attempts | "
-        f"Method: {request.method} | "
-        f"Path: {url.path} | "
-        f"Latency: {duration_ms:.2f}ms | "
-        f"Error: {str(last_exception)}"
+    logging.critical(
+        f"Request failed, cannot connect to target: "
+        f"{request.method} {request.url.path} status_code=502 latency={duration_ms:.2f}ms"
     )
 
     raise HTTPException(
         status_code=502,
-        detail=f"Niansuh Proxy Error: Target server blocked all {MAX_RETRIES} attempts. Last error: {str(last_exception)}",
+        detail=f"Bad Gateway: Cannot connect to target service after {MAX_RETRIES} attempts. {last_exception}"
     )
 
-# --- Run the App (Gunicorn/Uvicorn) ---
+# --- Run the app (for testing) ---
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=8000,
-        workers=4,  # More workers = more parallel requests
-        log_level=LOG_LEVEL.lower(),
-    )
+    uvicorn.run(app, host="0.0.0.0", port=8000)