funbrowser 0.1.0__py3-none-any.whl

funbrowser/solver/client.py

@@ -0,0 +1,244 @@
+"""Async client for the funsolver.com captcha API.
+
+The API surface follows the 2captcha / anti-captcha JSON convention
+(``POST /createTask`` then poll ``POST /getTaskResult``). If the actual
+funsolver.com endpoints diverge, override ``base_url`` or subclass and
+override ``_create_task`` / ``_poll`` rather than monkey-patching.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class FunSolverError(Exception):
+    """A funsolver.com request failed or returned an error response."""
+
+    def __init__(self, message: str, *, code: int | None = None) -> None:
+        super().__init__(message)
+        self.code = code
+
+
+class FunSolverClient:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = "https://api.funsolver.com",
+        timeout: float = 120.0,
+        poll_interval: float = 3.0,
+        http_timeout: float = 30.0,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        self._api_key = api_key
+        self._base = base_url.rstrip("/")
+        self._timeout = timeout
+        self._poll_interval = poll_interval
+        self._http = httpx.AsyncClient(timeout=http_timeout, transport=transport)
+
+    async def close(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> FunSolverClient:
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.close()
+
+    async def balance(self) -> float:
+        data = await self._post("/getBalance", {"clientKey": self._api_key})
+        return float(data.get("balance", 0.0))
+
+    async def solve_turnstile(
+        self,
+        *,
+        sitekey: str,
+        page_url: str,
+        action: str | None = None,
+        cdata: str | None = None,
+    ) -> str:
+        task: dict[str, Any] = {
+            "type": "TurnstileTask",
+            "websiteURL": page_url,
+            "websiteKey": sitekey,
+        }
+        if action is not None:
+            task["action"] = action
+        if cdata is not None:
+            task["data"] = cdata
+        return await self._solve(task)
+
+    async def solve_recaptcha_v2(
+        self,
+        *,
+        sitekey: str,
+        page_url: str,
+        invisible: bool = False,
+        data_s: str | None = None,
+        is_enterprise: bool = False,
+    ) -> str:
+        """reCAPTCHA v2 — both checkbox and invisible variants.
+
+        ``data_s`` is the value of the ``data-s`` attribute used on
+        Google-owned properties; safe to omit elsewhere. ``is_enterprise``
+        switches the task type for Enterprise sites.
+        """
+        if is_enterprise:
+            task_type = "RecaptchaV2EnterpriseTaskProxyless"
+        else:
+            task_type = "RecaptchaV2TaskProxyless"
+        task: dict[str, Any] = {
+            "type": task_type,
+            "websiteURL": page_url,
+            "websiteKey": sitekey,
+        }
+        if invisible:
+            task["isInvisible"] = True
+        if data_s is not None:
+            task["recaptchaDataSValue"] = data_s
+        return await self._solve(task)
+
+    async def solve_recaptcha_v3(
+        self,
+        *,
+        sitekey: str,
+        page_url: str,
+        action: str = "verify",
+        min_score: float = 0.7,
+        is_enterprise: bool = False,
+    ) -> str:
+        """reCAPTCHA v3 — score-based, needs the page's expected action name."""
+        task_type = (
+            "RecaptchaV3EnterpriseTaskProxyless" if is_enterprise else "RecaptchaV3TaskProxyless"
+        )
+        return await self._solve(
+            {
+                "type": task_type,
+                "websiteURL": page_url,
+                "websiteKey": sitekey,
+                "pageAction": action,
+                "minScore": min_score,
+            }
+        )
+
+    async def solve_hcaptcha(
+        self,
+        *,
+        sitekey: str,
+        page_url: str,
+        is_invisible: bool = False,
+        enterprise_payload: dict[str, Any] | None = None,
+    ) -> str:
+        task: dict[str, Any] = {
+            "type": "HCaptchaTaskProxyless",
+            "websiteURL": page_url,
+            "websiteKey": sitekey,
+        }
+        if is_invisible:
+            task["isInvisible"] = True
+        if enterprise_payload is not None:
+            task["enterprisePayload"] = enterprise_payload
+        return await self._solve(task)
+
+    async def solve_funcaptcha(
+        self,
+        *,
+        public_key: str,
+        page_url: str,
+        surl: str | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> str:
+        """FunCaptcha / Arkose Labs.
+
+        ``public_key`` is the value of the widget's ``data-pkey``.
+        ``surl`` is the FunCaptcha API URL — required for some setups,
+        ``data`` carries additional context the site computes (the
+        encrypted ``data`` blob).
+        """
+        task: dict[str, Any] = {
+            "type": "FunCaptchaTaskProxyless",
+            "websiteURL": page_url,
+            "websitePublicKey": public_key,
+        }
+        if surl is not None:
+            task["funcaptchaApiJSSubdomain"] = surl
+        if data is not None:
+            task["data"] = data
+        return await self._solve(task)
+
+    async def solve_geetest(
+        self,
+        *,
+        gt: str,
+        challenge: str,
+        page_url: str,
+        api_server: str | None = None,
+        version: int = 3,
+        init_parameters: dict[str, Any] | None = None,
+    ) -> str:
+        """GeeTest v3/v4.
+
+        For v3: pass ``gt`` and ``challenge`` (both fetched from the
+        site's challenge endpoint just before solving). For v4: pass
+        ``gt`` as the captchaId and set ``version=4``.
+        """
+        task: dict[str, Any] = {
+            "type": "GeeTestTaskProxyless",
+            "websiteURL": page_url,
+            "gt": gt,
+            "challenge": challenge,
+            "version": version,
+        }
+        if api_server is not None:
+            task["geetestApiServerSubdomain"] = api_server
+        if init_parameters is not None:
+            task["initParameters"] = init_parameters
+        return await self._solve(task)
+
+    async def _solve(self, task: dict[str, Any]) -> str:
+        task_id = await self._create_task(task)
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + self._timeout
+        while True:
+            await asyncio.sleep(self._poll_interval)
+            data = await self._post(
+                "/getTaskResult",
+                {"clientKey": self._api_key, "taskId": task_id},
+            )
+            status = data.get("status")
+            if status == "ready":
+                token = data.get("solution", {}).get("token")
+                if not token:
+                    raise FunSolverError("solver returned ready without a token")
+                return str(token)
+            if loop.time() > deadline:
+                raise FunSolverError(f"task {task_id} did not complete within {self._timeout}s")
+
+    async def _create_task(self, task: dict[str, Any]) -> int:
+        data = await self._post(
+            "/createTask",
+            {"clientKey": self._api_key, "task": task},
+        )
+        task_id = data.get("taskId")
+        if not task_id:
+            raise FunSolverError("solver did not return a taskId")
+        return int(task_id)
+
+    async def _post(self, path: str, body: dict[str, Any]) -> dict[str, Any]:
+        r = await self._http.post(f"{self._base}{path}", json=body)
+        r.raise_for_status()
+        data = r.json()
+        if not isinstance(data, dict):
+            raise FunSolverError(f"non-dict response from {path}: {data!r}")
+        if data.get("errorId"):
+            raise FunSolverError(
+                data.get("errorDescription") or data.get("errorCode") or "solver error",
+                code=int(data.get("errorId", 0)),
+            )
+        return data

funbrowser/solver/scripts/_bootstrap.js

@@ -0,0 +1,30 @@
+(() => {
+  if (window.__funbrowser) return;
+  const pending = new Map();
+  let nextId = 0;
+
+  window.__funbrowser = {
+    solve(req) {
+      return new Promise((resolve, reject) => {
+        const id = ++nextId;
+        pending.set(id, { resolve, reject });
+        // The binding is a CDP-injected function that takes a single string.
+        try {
+          window.__funbrowser_solve(JSON.stringify({ id, ...req }));
+        } catch (e) {
+          pending.delete(id);
+          reject(e);
+        }
+      });
+    },
+  };
+
+  // Called by the host (Python side) via Runtime.evaluate.
+  window.__funbrowser_resolve = (id, result) => {
+    const p = pending.get(id);
+    if (!p) return;
+    pending.delete(id);
+    if (result && result.ok) p.resolve(result.token);
+    else p.reject(new Error((result && result.error) || 'funsolver: unknown error'));
+  };
+})();

funbrowser/solver/scripts/funcaptcha.js

@@ -0,0 +1,74 @@
+// FunCaptcha / Arkose Labs.
+//
+// Common attach points:
+//   <div class="funcaptcha" data-pkey="..."></div>
+//   <input data-pkey="...">  (some sites mark it on an input)
+//   iframe[src*="funcaptcha"]  → look up parent for data-pkey
+//
+// Response goes into one of: input[name="fc-token"],
+// input[name="arkose-token"], input[name="verification-token"].
+// Optional data-callback name on the host element.
+(() => {
+  if (!window.__funbrowser) return;
+  if (window.__funbrowser._funcaptchaInstalled) return;
+  window.__funbrowser._funcaptchaInstalled = true;
+
+  const seen = new WeakSet();
+
+  function injectToken(token) {
+    document
+      .querySelectorAll(
+        'input[name="fc-token"], input[name="arkose-token"], input[name="verification-token"]'
+      )
+      .forEach((inp) => {
+        inp.value = token;
+        inp.dispatchEvent(new Event('input', { bubbles: true }));
+        inp.dispatchEvent(new Event('change', { bubbles: true }));
+      });
+  }
+
+  async function handle(el) {
+    if (seen.has(el)) return;
+    seen.add(el);
+    const pkey = el.dataset.pkey || el.getAttribute('data-pkey');
+    if (!pkey) return;
+
+    const surl =
+      el.dataset.surl || el.getAttribute('data-surl') || undefined;
+
+    try {
+      const token = await window.__funbrowser.solve({
+        type: 'funcaptcha',
+        sitekey: pkey,
+        url: location.href,
+        surl,
+      });
+      injectToken(token);
+      const cb = el.dataset.callback || el.getAttribute('data-callback');
+      if (cb && typeof window[cb] === 'function') {
+        try { window[cb](token); } catch (e) {}
+      }
+    } catch (e) {
+      console.error('[funbrowser] funcaptcha solve failed:', e);
+    }
+  }
+
+  function scan(root) {
+    (root || document).querySelectorAll('[data-pkey]').forEach(handle);
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => scan());
+  } else {
+    scan();
+  }
+  new MutationObserver((muts) => {
+    for (const m of muts) {
+      m.addedNodes.forEach((n) => {
+        if (n.nodeType !== 1) return;
+        if (n.dataset && n.dataset.pkey) handle(n);
+        else scan(n);
+      });
+    }
+  }).observe(document.documentElement, { childList: true, subtree: true });
+})();

funbrowser/solver/scripts/geetest.js

@@ -0,0 +1,76 @@
+// GeeTest v3 + v4.
+//
+// Pages typically fetch /geetest/register first to get {gt, challenge}, then
+// call window.initGeetest({gt, challenge, ...}, onSuccessCallback) for v3 or
+// initGeetest4({captchaId, ...}, cb) for v4. We hook both so the params get
+// forwarded to funsolver and the page's success callback fires with a real
+// validated payload.
+(() => {
+  if (!window.__funbrowser) return;
+  if (window.__funbrowser._geetestInstalled) return;
+  window.__funbrowser._geetestInstalled = true;
+
+  function fillFields(payload) {
+    // v3 payload fields
+    if (payload.geetest_challenge !== undefined) {
+      document
+        .querySelectorAll('[name="geetest_challenge"]')
+        .forEach((i) => { i.value = payload.geetest_challenge; });
+    }
+    if (payload.geetest_validate !== undefined) {
+      document
+        .querySelectorAll('[name="geetest_validate"]')
+        .forEach((i) => { i.value = payload.geetest_validate; });
+    }
+    if (payload.geetest_seccode !== undefined) {
+      document
+        .querySelectorAll('[name="geetest_seccode"]')
+        .forEach((i) => { i.value = payload.geetest_seccode; });
+    }
+  }
+
+  function hookInit(name, version) {
+    const orig = window[name];
+    if (typeof orig === 'function' && orig.__fbHooked) return;
+
+    const hooked = function (opts, callback) {
+      const gt = (opts && (opts.gt || opts.captchaId)) || '';
+      const challenge = (opts && opts.challenge) || '';
+      if (!gt) {
+        return orig ? orig.call(this, opts, callback) : undefined;
+      }
+      window.__funbrowser
+        .solve({
+          type: 'geetest',
+          gt,
+          challenge,
+          url: location.href,
+          version,
+          apiServer: opts && opts.api_server,
+        })
+        .then((tokenRaw) => {
+          let payload;
+          try { payload = JSON.parse(tokenRaw); } catch (e) { payload = { token: tokenRaw }; }
+          fillFields(payload);
+          if (typeof callback === 'function') {
+            try { callback(payload); } catch (e) {}
+          }
+        })
+        .catch((e) => console.error('[funbrowser] geetest solve failed:', e));
+    };
+    hooked.__fbHooked = true;
+    window[name] = hooked;
+  }
+
+  hookInit('initGeetest', 3);
+  hookInit('initGeetest4', 4);
+
+  // Re-hook periodically in case the GeeTest loader replaces window.initGeetest
+  // after our patch (it often does once the loader script lands).
+  let attempts = 30;
+  const interval = setInterval(() => {
+    hookInit('initGeetest', 3);
+    hookInit('initGeetest4', 4);
+    if (--attempts <= 0) clearInterval(interval);
+  }, 1000);
+})();

funbrowser/solver/scripts/hcaptcha.js

@@ -0,0 +1,76 @@
+// hCaptcha — `.h-captcha[data-sitekey]` widgets.
+//
+// Response goes into `textarea[name="h-captcha-response"]` (some pages
+// also expect g-recaptcha-response for back-compat). Optional
+// data-callback on the div.
+(() => {
+  if (!window.__funbrowser) return;
+  if (window.__funbrowser._hcaptchaInstalled) return;
+  window.__funbrowser._hcaptchaInstalled = true;
+
+  const seen = new WeakSet();
+
+  function injectToken(token) {
+    document
+      .querySelectorAll(
+        'textarea[name="h-captcha-response"], textarea[name="g-recaptcha-response"]'
+      )
+      .forEach((ta) => {
+        ta.value = token;
+        ta.dispatchEvent(new Event('input', { bubbles: true }));
+        ta.dispatchEvent(new Event('change', { bubbles: true }));
+      });
+    if (window.hcaptcha) {
+      try {
+        window.hcaptcha.getResponse = function () { return token; };
+      } catch (e) {}
+    }
+  }
+
+  async function handle(el) {
+    if (seen.has(el)) return;
+    seen.add(el);
+    const sitekey = el.dataset.sitekey || el.getAttribute('data-sitekey');
+    if (!sitekey) return;
+
+    const invisible =
+      (el.dataset.size || el.getAttribute('data-size')) === 'invisible';
+
+    try {
+      const token = await window.__funbrowser.solve({
+        type: 'hcaptcha',
+        sitekey,
+        url: location.href,
+        invisible,
+      });
+      injectToken(token);
+      const cb = el.dataset.callback || el.getAttribute('data-callback');
+      if (cb && typeof window[cb] === 'function') {
+        try { window[cb](token); } catch (e) {}
+      }
+    } catch (e) {
+      console.error('[funbrowser] hcaptcha solve failed:', e);
+    }
+  }
+
+  function scan(root) {
+    (root || document)
+      .querySelectorAll('.h-captcha[data-sitekey]')
+      .forEach(handle);
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => scan());
+  } else {
+    scan();
+  }
+  new MutationObserver((muts) => {
+    for (const m of muts) {
+      m.addedNodes.forEach((n) => {
+        if (n.nodeType !== 1) return;
+        if (n.classList && n.classList.contains('h-captcha')) handle(n);
+        else scan(n);
+      });
+    }
+  }).observe(document.documentElement, { childList: true, subtree: true });
+})();

funbrowser/solver/scripts/recaptcha_v2.js

@@ -0,0 +1,79 @@
+// reCAPTCHA v2 — checkbox + invisible.
+//
+// Widget: <div class="g-recaptcha" data-sitekey="..."> (with optional
+// data-size="invisible", data-callback="myFn", data-s="...").
+// Response: textarea#g-recaptcha-response. For pages with multiple
+// widgets the textareas are numbered (g-recaptcha-response-0, -1, ...).
+(() => {
+  if (!window.__funbrowser) return;
+  if (window.__funbrowser._recaptchaV2Installed) return;
+  window.__funbrowser._recaptchaV2Installed = true;
+
+  const seen = new WeakSet();
+
+  function injectToken(token) {
+    document
+      .querySelectorAll(
+        'textarea[id^="g-recaptcha-response"], textarea[name="g-recaptcha-response"]'
+      )
+      .forEach((ta) => {
+        ta.value = token;
+        ta.dispatchEvent(new Event('input', { bubbles: true }));
+        ta.dispatchEvent(new Event('change', { bubbles: true }));
+      });
+    if (window.grecaptcha) {
+      try {
+        window.grecaptcha.getResponse = function () { return token; };
+      } catch (e) {}
+    }
+  }
+
+  async function handle(el) {
+    if (seen.has(el)) return;
+    seen.add(el);
+    const sitekey = el.dataset.sitekey || el.getAttribute('data-sitekey');
+    if (!sitekey) return;
+
+    const invisible =
+      (el.dataset.size || el.getAttribute('data-size')) === 'invisible';
+    const dataS = el.dataset.s || el.getAttribute('data-s') || undefined;
+
+    try {
+      const token = await window.__funbrowser.solve({
+        type: 'recaptcha2',
+        sitekey,
+        url: location.href,
+        invisible,
+        dataS,
+      });
+      injectToken(token);
+      const cb = el.dataset.callback || el.getAttribute('data-callback');
+      if (cb && typeof window[cb] === 'function') {
+        try { window[cb](token); } catch (e) {}
+      }
+    } catch (e) {
+      console.error('[funbrowser] recaptcha2 solve failed:', e);
+    }
+  }
+
+  function scan(root) {
+    (root || document)
+      .querySelectorAll('.g-recaptcha[data-sitekey]')
+      .forEach(handle);
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => scan());
+  } else {
+    scan();
+  }
+  new MutationObserver((muts) => {
+    for (const m of muts) {
+      m.addedNodes.forEach((n) => {
+        if (n.nodeType !== 1) return;
+        if (n.classList && n.classList.contains('g-recaptcha')) handle(n);
+        else scan(n);
+      });
+    }
+  }).observe(document.documentElement, { childList: true, subtree: true });
+})();

funbrowser/solver/scripts/recaptcha_v3.js

@@ -0,0 +1,45 @@
+// reCAPTCHA v3 — score-based, no visible widget.
+//
+// Pages call `grecaptcha.execute(sitekey, {action: 'login'})` to get a
+// token. We hook execute() so it asks funsolver for a real token instead
+// of running Google's verifier.
+(() => {
+  if (!window.__funbrowser) return;
+  if (window.__funbrowser._recaptchaV3Installed) return;
+  window.__funbrowser._recaptchaV3Installed = true;
+
+  function install() {
+    if (!window.grecaptcha || !window.grecaptcha.execute) return false;
+    if (window.grecaptcha.execute.__fbHooked) return true;
+    const orig = window.grecaptcha.execute;
+    const hooked = async function (sitekey, options) {
+      const action = (options && options.action) || 'verify';
+      try {
+        return await window.__funbrowser.solve({
+          type: 'recaptcha3',
+          sitekey,
+          url: location.href,
+          action,
+          minScore: 0.7,
+        });
+      } catch (e) {
+        console.error('[funbrowser] recaptcha3 solve failed:', e);
+        return orig.call(this, sitekey, options);
+      }
+    };
+    hooked.__fbHooked = true;
+    window.grecaptcha.execute = hooked;
+    return true;
+  }
+
+  if (install()) return;
+  // grecaptcha may load after our script — poll for up to 30s and watch DOM.
+  let attempts = 30;
+  const interval = setInterval(() => {
+    if (install() || --attempts <= 0) clearInterval(interval);
+  }, 1000);
+  const observer = new MutationObserver(() => {
+    if (install()) observer.disconnect();
+  });
+  observer.observe(document.documentElement, { childList: true, subtree: true });
+})();

funbrowser/solver/scripts/turnstile.js

@@ -0,0 +1,60 @@
+(() => {
+  if (!window.__funbrowser) return;
+  if (window.__funbrowser._turnstileInstalled) return;
+  window.__funbrowser._turnstileInstalled = true;
+
+  const seen = new WeakSet();
+
+  async function handle(el) {
+    if (seen.has(el)) return;
+    seen.add(el);
+
+    const sitekey = el.dataset.sitekey || el.getAttribute('data-sitekey');
+    if (!sitekey) return;
+
+    try {
+      const token = await window.__funbrowser.solve({
+        type: 'turnstile',
+        sitekey,
+        url: location.href,
+        action: el.dataset.action || el.getAttribute('data-action') || undefined,
+        cdata: el.dataset.cdata || el.getAttribute('data-cdata') || undefined,
+      });
+
+      // Drop the token into the textarea Turnstile creates.
+      const ta = document.querySelector('[name="cf-turnstile-response"]');
+      if (ta) {
+        ta.value = token;
+        ta.dispatchEvent(new Event('input', { bubbles: true }));
+        ta.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+
+      // Trigger the site's success callback (string or function).
+      const cb = el.dataset.callback || el.getAttribute('data-callback');
+      if (cb && typeof window[cb] === 'function') {
+        try { window[cb](token); } catch (e) { console.error('[funbrowser] callback threw:', e); }
+      }
+    } catch (e) {
+      console.error('[funbrowser] turnstile solve failed:', e);
+    }
+  }
+
+  function scan(root) {
+    (root || document).querySelectorAll('.cf-turnstile').forEach(handle);
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => scan());
+  } else {
+    scan();
+  }
+  new MutationObserver((muts) => {
+    for (const m of muts) {
+      m.addedNodes.forEach((n) => {
+        if (n.nodeType !== 1) return;
+        if (n.classList && n.classList.contains('cf-turnstile')) handle(n);
+        else scan(n);
+      });
+    }
+  }).observe(document.documentElement, { childList: true, subtree: true });
+})();