cloudsneak 1.0.0__tar.gz

cloudsneak-1.0.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: cloudsneak
+Version: 1.0.0
+Summary: Cloudflare clearance cookie and Turnstile token solver service
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn[standard]>=0.20.0
+Requires-Dist: playwright>=1.35.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: py-ghost-cursor>=0.1.1
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+
+# cloudsneak
+
+Cloudflare clearance cookie (`cf_clearance`) and Turnstile token solver service ported to Python.
+
+## Features
+
+- **Turnstile Token Solver**: Render and solve Cloudflare Turnstile challenge widgets using synthetic injection and local script replacement.
+- **IUAM clearance cookie Extraction**: Intercept responses to extract `cf_clearance` cookies and corresponding `User-Agent`.
+- **Anti-Detect Browser Integration**: Custom Chrome launch configurations with Playwright.
+- **FastAPI REST API**: Server with TTL caching, authentication token checks, and concurrency throttling.
+
+## Installation
+
+```bash
+pip install .
+```
+
+Ensure Playwright browsers are installed:
+
+```bash
+playwright install chromium
+```
+
+## Running the Server
+
+Start the REST service:
+
+```bash
+cloudsneak --host 0.0.0.0 --port 8742
+```
+
+Or via python:
+
+```bash
+python -m cloudsneak.cli
+```
+
+## API Usage
+
+### `POST /cloudflare`
+
+#### Turnstile Mode
+
+```json
+{
+  "mode": "turnstile",
+  "domain": "https://example.com",
+  "siteKey": "0x4AAAAAAACk534..."
+}
+```
+
+#### IUAM Mode
+
+```json
+{
+  "mode": "iuam",
+  "domain": "https://example.com"
+}
+```

cloudsneak-1.0.0/README.md

@@ -0,0 +1,59 @@
+# cloudsneak
+
+Cloudflare clearance cookie (`cf_clearance`) and Turnstile token solver service ported to Python.
+
+## Features
+
+- **Turnstile Token Solver**: Render and solve Cloudflare Turnstile challenge widgets using synthetic injection and local script replacement.
+- **IUAM clearance cookie Extraction**: Intercept responses to extract `cf_clearance` cookies and corresponding `User-Agent`.
+- **Anti-Detect Browser Integration**: Custom Chrome launch configurations with Playwright.
+- **FastAPI REST API**: Server with TTL caching, authentication token checks, and concurrency throttling.
+
+## Installation
+
+```bash
+pip install .
+```
+
+Ensure Playwright browsers are installed:
+
+```bash
+playwright install chromium
+```
+
+## Running the Server
+
+Start the REST service:
+
+```bash
+cloudsneak --host 0.0.0.0 --port 8742
+```
+
+Or via python:
+
+```bash
+python -m cloudsneak.cli
+```
+
+## API Usage
+
+### `POST /cloudflare`
+
+#### Turnstile Mode
+
+```json
+{
+  "mode": "turnstile",
+  "domain": "https://example.com",
+  "siteKey": "0x4AAAAAAACk534..."
+}
+```
+
+#### IUAM Mode
+
+```json
+{
+  "mode": "iuam",
+  "domain": "https://example.com"
+}
+```

cloudsneak-1.0.0/cloudsneak/__init__.py

@@ -0,0 +1,16 @@
+"""
+cloudsneak package initialization.
+"""
+
+__version__ = "1.0.0"
+
+from cloudsneak.browser import connect, check_turnstile
+from cloudsneak.iuam import solve_iuam
+from cloudsneak.turnstile import solve_turnstile
+
+__all__ = [
+    "connect",
+    "check_turnstile",
+    "solve_iuam",
+    "solve_turnstile",
+]

cloudsneak-1.0.0/cloudsneak/browser.py

@@ -0,0 +1,196 @@
+"""
+Browser management module for cloudsneak.
+Handles anti-detect Playwright browser context initialization, mouse movements,
+and Turnstile iframe / widget click detection.
+"""
+
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+from playwright.async_api import async_playwright, Browser, BrowserContext, Page
+from py_ghost_cursor import path
+
+logger = logging.getLogger("cloudsneak.browser")
+
+DEFAULT_CHROME_FLAGS = [
+    "--no-sandbox",
+    "--disable-dev-shm-usage",
+    "--disable-blink-features=AutomationControlled",
+    "--window-size=1920,1080",
+]
+
+
+async def check_turnstile(page: Page) -> bool:
+    """
+    Checks for Turnstile challenge response inputs or bounding box coordinates
+    and simulates a click if found.
+    """
+    try:
+        # Check for explicit turnstile response elements
+        elements = await page.query_selector_all('[name="cf-turnstile-response"]')
+        if elements:
+            for element in elements:
+                try:
+                    parent = await element.evaluate_handle("el => el.parentElement")
+                    element_handle = parent.as_element()
+                    if element_handle:
+                        box = await element_handle.bounding_box()
+                        if box:
+                            click_x = box["x"] + 30
+                            click_y = box["y"] + box["height"] / 2
+                            await page.mouse.click(click_x, click_y)
+                except Exception as err:
+                    logger.debug(f"Error clicking turnstile response parent: {err}")
+            return True
+
+        # Fallback: search for div elements with width between 290px and 310px
+        js_find_coords = """
+        () => {
+            let coordinates = [];
+            document.querySelectorAll('div').forEach(item => {
+                try {
+                    let rect = item.getBoundingClientRect();
+                    let css = window.getComputedStyle(item);
+                    if (css.margin === "0px" && css.padding === "0px" && rect.width > 290 && rect.width <= 310 && !item.querySelector('*')) {
+                        coordinates.push({ x: rect.x, y: rect.y, w: rect.width, h: rect.height });
+                    }
+                } catch (e) {}
+            });
+
+            if (coordinates.length === 0) {
+                document.querySelectorAll('div').forEach(item => {
+                    try {
+                        let rect = item.getBoundingClientRect();
+                        if (rect.width > 290 && rect.width <= 310 && !item.querySelector('*')) {
+                            coordinates.push({ x: rect.x, y: rect.y, w: rect.width, h: rect.height });
+                        }
+                    } catch (e) {}
+                });
+            }
+
+            return coordinates;
+        }
+        """
+        coords: List[Dict[str, float]] = await page.evaluate(js_find_coords)
+        for item in coords:
+            try:
+                click_x = item["x"] + 30
+                click_y = item["y"] + item["h"] / 2
+                await page.mouse.click(click_x, click_y)
+            except Exception as err:
+                logger.debug(f"Error clicking candidate div: {err}")
+        return True
+    except Exception as e:
+        logger.debug(f"check_turnstile exception: {e}")
+        return False
+
+
+async def start_turnstile_loop(page: Page, stop_event: asyncio.Event) -> None:
+    """
+    Runs a loop to check and click turnstile widgets until stop_event is set or page closes.
+    """
+    while not stop_event.is_set():
+        if page.is_closed():
+            break
+        try:
+            await check_turnstile(page)
+        except Exception:
+            pass
+        await asyncio.sleep(1.0)
+
+
+class PlaywrightManager:
+    """
+    Manager for Playwright lifecycle and anti-detect page instances.
+    """
+
+    def __init__(self) -> None:
+        self.pw = None
+        self.browser: Optional[Browser] = None
+        self.context: Optional[BrowserContext] = None
+
+    async def initialize(
+        self,
+        headless: bool = False,
+        args: Optional[List[str]] = None,
+        proxy: Optional[Dict[str, str]] = None,
+    ) -> Tuple[Browser, BrowserContext]:
+        if self.browser and self.browser.is_connected():
+            return self.browser, self.context
+
+        self.pw = await async_playwright().start()
+
+        launch_args = list(DEFAULT_CHROME_FLAGS)
+        if args:
+            launch_args.extend(args)
+
+        proxy_config = None
+        if proxy and proxy.get("host") and proxy.get("port"):
+            server_str = f"{proxy['host']}:{proxy['port']}"
+            if not server_str.startswith("http://") and not server_str.startswith("https://") and not server_str.startswith("socks5://"):
+                server_str = f"http://{server_str}"
+            proxy_config = {"server": server_str}
+            if proxy.get("username") and proxy.get("password"):
+                proxy_config["username"] = proxy["username"]
+                proxy_config["password"] = proxy["password"]
+
+        self.browser = await self.pw.chromium.launch(
+            headless=headless,
+            args=launch_args,
+            proxy=proxy_config,
+        )
+
+        self.context = await self.browser.new_context(
+            viewport={"width": 1920, "height": 1080},
+            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"
+            ),
+        )
+
+        # Anti-detection script injection
+        await self.context.add_init_script(
+            "Object.defineProperty(navigator, 'webdriver', {get: () => undefined});"
+        )
+
+        return self.browser, self.context
+
+    async def get_page(self, turnstile: bool = False) -> Tuple[Page, Optional[asyncio.Event]]:
+        if not self.context:
+            await self.initialize()
+
+        page = await self.context.new_page()
+
+        stop_event = None
+        if turnstile:
+            stop_event = asyncio.Event()
+            asyncio.create_task(start_turnstile_loop(page, stop_event))
+
+        return page, stop_event
+
+    async def close(self) -> None:
+        if self.context:
+            await self.context.close()
+            self.context = None
+        if self.browser:
+            await self.browser.close()
+            self.browser = None
+        if self.pw:
+            await self.pw.stop()
+            self.pw = None
+
+
+async def connect(
+    headless: bool = False,
+    args: Optional[List[str]] = None,
+    proxy: Optional[Dict[str, str]] = None,
+    turnstile: bool = False,
+) -> Tuple[PlaywrightManager, Page]:
+    """
+    Connect function matching the reference API. Returns (manager, page).
+    """
+    manager = PlaywrightManager()
+    await manager.initialize(headless=headless, args=args, proxy=proxy)
+    page, _ = await manager.get_page(turnstile=turnstile)
+    return manager, page

cloudsneak-1.0.0/cloudsneak/cli.py

@@ -0,0 +1,33 @@
+"""
+CLI entry point for cloudsneak.
+"""
+
+import argparse
+import sys
+from cloudsneak.server import start_server, PORT
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="cloudsneak - Cloudflare clearance cookie and Turnstile token solver service"
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host address to bind the server (default: 0.0.0.0)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=PORT,
+        help=f"Port to run the server on (default: {PORT})",
+    )
+
+    args = parser.parse_args()
+    print(f"Starting cloudsneak server on {args.host}:{args.port}...")
+    start_server(host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

cloudsneak-1.0.0/cloudsneak/iuam.py

@@ -0,0 +1,117 @@
+"""
+Cloudflare Under Attack Mode (IUAM) clearance solver.
+Extracts cf_clearance cookie and associated User-Agent.
+"""
+
+import asyncio
+import re
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+from playwright.async_api import Page, Request, Response
+
+API_JS_PATH = Path(__file__).parent / "js" / "api.js"
+
+
+async def solve_iuam(
+    data: Dict[str, Any],
+    page: Page,
+    timeout_ms: int = 60000,
+) -> Dict[str, Any]:
+    """
+    Solves Cloudflare IUAM challenge on target domain and returns cf_clearance cookie info.
+
+    :param data: Dictionary containing 'domain' and optional 'proxy' info.
+    :param page: Playwright Page instance.
+    :param timeout_ms: Maximum time to wait for solution in milliseconds.
+    :return: Dict containing cf_clearance, user_agent, and elapsed time.
+    """
+    domain = data.get("domain")
+    if not domain:
+        raise ValueError("Missing domain parameter")
+
+    proxy = data.get("proxy", {})
+    if proxy.get("username") and proxy.get("password"):
+        # Credentials are set at context launch or routed in playwright context
+        pass
+
+    api_js_content: Optional[bytes] = None
+    if API_JS_PATH.exists():
+        try:
+            api_js_content = API_JS_PATH.read_bytes()
+        except Exception as e:
+            print(f"Failed to read local api.js: {e}")
+
+    start_time = time.time()
+    solved_future: asyncio.Future = asyncio.get_running_loop().create_future()
+
+    async def handle_route(route: Any, request: Request):
+        url = request.url
+        try:
+            if "challenges.cloudflare.com/turnstile/v0/b/88d68f5d5ea3/api.js" in url:
+                if api_js_content:
+                    await route.fulfill(
+                        status=200,
+                        content_type="application/javascript",
+                        body=api_js_content,
+                        headers={"Access-Control-Allow-Origin": "*"},
+                    )
+                else:
+                    await route.continue_()
+            elif (
+                url == domain
+                or url == domain.rstrip("/") + "/"
+                or "challenges.cloudflare.com" in url
+                or "/cdn-cgi/challenge-platform/" in url
+            ):
+                await route.continue_()
+            else:
+                await route.abort()
+        except Exception:
+            try:
+                await route.continue_()
+            except Exception:
+                pass
+
+    async def handle_response(response: Response):
+        url = response.url
+        if "/cdn-cgi/challenge-platform/" in url:
+            try:
+                headers = await response.headers_array()
+                set_cookie_headers = [
+                    h["value"] for h in headers if h["name"].lower() == "set-cookie"
+                ]
+                combined_cookies = "\n".join(set_cookie_headers)
+                match = re.search(r"cf_clearance=([^;]+)", combined_cookies)
+                if match and not solved_future.done():
+                    cf_clearance = match.group(1)
+                    req_headers = await response.request.all_headers()
+                    user_agent = req_headers.get("user-agent", "")
+                    elapsed = f"{time.time() - start_time:.2f}s"
+                    solved_future.set_result(
+                        {
+                            "cf_clearance": cf_clearance,
+                            "user_agent": user_agent,
+                            "elapsed": elapsed,
+                        }
+                    )
+            except Exception:
+                pass
+
+    # Register route interception and response listener
+    await page.route("**/*", handle_route)
+    page.on("response", handle_response)
+
+    try:
+        await page.goto(domain, wait_until="domcontentloaded")
+
+        result = await asyncio.wait_for(solved_future, timeout=timeout_ms / 1000.0)
+        return result
+    except asyncio.TimeoutError:
+        raise TimeoutError("Timeout Error resolving IUAM challenge")
+    finally:
+        try:
+            await page.unroute("**/*", handle_route)
+        except Exception:
+            pass
+        page.remove_listener("response", handle_response)