diff --git a/src/services/browser_captcha.py b/src/services/browser_captcha.py index 8e7de5cc..2e01e32c 100644 --- a/src/services/browser_captcha.py +++ b/src/services/browser_captcha.py @@ -2482,25 +2482,12 @@ async def _execute_custom_captcha( if primary_host == "https://www.recaptcha.net" else "https://www.recaptcha.net" ) - script_path = ( - "recaptcha/enterprise.js" if enterprise else "recaptcha/api.js" - ) execute_target = ( "grecaptcha.enterprise.execute" if enterprise else "grecaptcha.execute" ) ready_target = ( "grecaptcha.enterprise.ready" if enterprise else "grecaptcha.ready" ) - wait_expression = ( - ( - "typeof grecaptcha !== 'undefined' && typeof grecaptcha.enterprise !== 'undefined' && " - "typeof grecaptcha.enterprise.execute === 'function'" - ) - if enterprise - else ( - "typeof grecaptcha !== 'undefined' && typeof grecaptcha.execute === 'function'" - ) - ) api_label = "enterprise.js" if enterprise else "api.js" debug_logger.log_info( @@ -2586,42 +2573,15 @@ def handle_request_failed(request): ) await asyncio.sleep(warmup_seconds) - try: - await page.wait_for_function(wait_expression, timeout=15000) - except Exception as e: - debug_logger.log_warning( - f"[BrowserCaptcha] Token-{self.token_id} 自定义 grecaptcha 未就绪,尝试补注入脚本: {type(e).__name__}: {str(e)[:200]}" - ) - try: - await page.evaluate( - f""" - (primaryUrl, secondaryUrl) => {{ - const existing = Array.from(document.scripts || []).some((script) => {{ - const src = script?.src || ""; - return src.includes('/recaptcha/'); - }}); - if (existing) return; - const urls = [primaryUrl, secondaryUrl]; - const loadScript = (index) => {{ - if (index >= urls.length) return; - const script = document.createElement('script'); - script.src = urls[index]; - script.async = true; - script.onerror = () => loadScript(index + 1); - document.head.appendChild(script); - }}; - loadScript(0); - }} - """, - f"{primary_host}/{script_path}?render={website_key}", - f"{secondary_host}/{script_path}?render={website_key}", - ) - await page.wait_for_function(wait_expression, timeout=15000) - except Exception as inject_error: - debug_logger.log_warning( - f"[BrowserCaptcha] Token-{self.token_id} 自定义 grecaptcha 最终未就绪: {type(inject_error).__name__}: {str(inject_error)[:200]}" - ) - return None + if not await self._wait_for_enterprise_ready( + page, + website_key, + primary_host, + secondary_host, + context_label="自定义", + enterprise=enterprise, + ): + return None await self._capture_page_fingerprint(page) @@ -2710,6 +2670,104 @@ def get_last_fingerprint(self) -> Optional[Dict[str, Any]]: return None return dict(self._last_fingerprint) + ENTERPRISE_READY_EXPRESSION = ( + "() => typeof grecaptcha !== 'undefined' && " + "typeof grecaptcha.enterprise !== 'undefined' && " + "typeof grecaptcha.enterprise.execute === 'function'" + ) + + INJECT_RECAPTCHA_SCRIPT_JS = r""" + ({url, timeoutMs}) => new Promise((resolve, reject) => { + const script = document.createElement('script'); + // The nonce attribute is hidden by browsers; its property retains the value. + const nonceSource = Array.from(document.scripts).find(node => node.nonce); + if (nonceSource) script.nonce = nonceSource.nonce; + script.async = true; + let settled = false; + const finish = (error) => { + if (settled) return; + settled = true; + clearTimeout(timer); + script.onload = null; + script.onerror = null; + if (error) { + script.remove(); + reject(error); + } else { + resolve(true); + } + }; + const timer = setTimeout(() => { + finish(new Error('reCAPTCHA script load timeout')); + }, timeoutMs); + script.onload = () => finish(); + script.onerror = () => finish(new Error('reCAPTCHA script failed to load')); + try { + try { + script.src = url; + } catch (error) { + const policyKey = '__flow2apiRecaptchaScriptURLPolicy'; + if (!window[policyKey]) { + window[policyKey] = window.trustedTypes.createPolicy( + 'flow2api-recaptcha', + {createScriptURL: value => value} + ); + } + script.src = window[policyKey].createScriptURL(url); + } + (document.head || document.documentElement).appendChild(script); + } catch (error) { + finish(error); + } + }) + """ + + async def _poll_enterprise_ready( + self, page, timeout_ms: int, expression: Optional[str] = None + ) -> bool: + """用 evaluate 检测就绪,避免 wait_for_function 在页面内触发字符串 eval。""" + probe = expression or self.ENTERPRISE_READY_EXPRESSION + deadline = time.monotonic() + max(0.0, timeout_ms / 1000.0) + last_error = None + while True: + try: + ready = await page.evaluate(probe) + last_error = None + if ready: + return True + except Exception as e: + last_error = f"{type(e).__name__}: {str(e)[:150]}" + if page.is_closed(): + return False + remaining = deadline - time.monotonic() + if remaining <= 0: + if last_error: + debug_logger.log_warning( + f"[BrowserCaptcha] Token-{self.token_id} reCAPTCHA 就绪检测失败: {last_error}" + ) + return False + await asyncio.sleep(min(0.25, remaining)) + + async def _inject_recaptcha_script( + self, page, url: str, *, timeout_ms: int = 15000 + ) -> bool: + """等待脚本加载结果;失败时清理本次节点,允许备用域名继续加载。""" + try: + await asyncio.wait_for( + page.evaluate( + self.INJECT_RECAPTCHA_SCRIPT_JS, + {"url": url, "timeoutMs": timeout_ms}, + ), + timeout=max(0.0, timeout_ms / 1000.0) + 1.0, + ) + return True + except Exception as e: + debug_logger.log_warning( + f"[BrowserCaptcha] Token-{self.token_id} reCAPTCHA 脚本加载失败 " + f"({urlparse(url).netloc}): {type(e).__name__}: {str(e)[:150]}" + ) + return False + async def _wait_for_enterprise_ready( self, page, @@ -2719,69 +2777,35 @@ async def _wait_for_enterprise_ready( *, timeout_ms: int = 15000, context_label: str = "", + enterprise: bool = True, ) -> bool: - """等待 grecaptcha.enterprise 就绪,必要时补注入 enterprise.js。""" - wait_expression = ( - "typeof grecaptcha !== 'undefined' && " - "typeof grecaptcha.enterprise !== 'undefined' && " - "typeof grecaptcha.enterprise.execute === 'function'" + """等待 reCAPTCHA 就绪,并在主域名加载失败后尝试备用域名。""" + wait_expression = self.ENTERPRISE_READY_EXPRESSION if enterprise else ( + "() => typeof grecaptcha !== 'undefined' && " + "typeof grecaptcha.execute === 'function'" ) label = f"{context_label} " if context_label else "" - try: - await page.wait_for_function(wait_expression, timeout=timeout_ms) - return True - except Exception as e: - debug_logger.log_warning( - f"[BrowserCaptcha] Token-{self.token_id} {label}grecaptcha 未就绪,尝试补注入脚本: " - f"{type(e).__name__}: {str(e)[:200]}" - ) - - try: - await page.evaluate( - """ - (primaryUrl, secondaryUrl) => { - const existing = Array.from(document.scripts || []).some((script) => { - const src = script?.src || ""; - return src.includes('/recaptcha/enterprise.js'); - }); - if (existing) return; - const urls = [primaryUrl, secondaryUrl]; - const loadScript = (index) => { - if (index >= urls.length) return; - const script = document.createElement('script'); - script.src = urls[index]; - script.async = true; - script.onerror = () => loadScript(index + 1); - document.head.appendChild(script); - }; - loadScript(0); - } - """, - f"{primary_host}/recaptcha/enterprise.js?render={website_key}", - f"{secondary_host}/recaptcha/enterprise.js?render={website_key}", - ) - await page.wait_for_function(wait_expression, timeout=timeout_ms) + if await self._poll_enterprise_ready(page, timeout_ms, wait_expression): return True - except Exception as inject_error: - debug_logger.log_warning( - f"[BrowserCaptcha] Token-{self.token_id} {label}页面内注入失败" - f"(新版 CSP 会拒绝动态 script),改用 Playwright add_script_tag: " - f"{type(inject_error).__name__}: {str(inject_error)[:150]}" - ) - # 最终兜底:Playwright add_script_tag(配合 CSP 剥除 route 生效) + debug_logger.log_warning( + f"[BrowserCaptcha] Token-{self.token_id} {label}grecaptcha 未就绪,尝试补注入脚本" + ) + script_path = "recaptcha/enterprise.js" if enterprise else "recaptcha/api.js" for script_host in (primary_host, secondary_host): - try: - await page.add_script_tag( - url=f"{script_host}/recaptcha/enterprise.js?render={website_key}" - ) - await page.wait_for_function(wait_expression, timeout=timeout_ms) + deadline = time.monotonic() + max(0.0, timeout_ms / 1000.0) + if not await self._inject_recaptcha_script( + page, f"{script_host}/{script_path}?render={website_key}", + timeout_ms=timeout_ms, + ): + continue + remaining_ms = max(0, int((deadline - time.monotonic()) * 1000)) + if await self._poll_enterprise_ready(page, remaining_ms, wait_expression): return True - except Exception as tag_error: - debug_logger.log_warning( - f"[BrowserCaptcha] Token-{self.token_id} {label}add_script_tag({script_host}) 失败: " - f"{type(tag_error).__name__}: {str(tag_error)[:150]}" - ) + debug_logger.log_warning( + f"[BrowserCaptcha] Token-{self.token_id} {label}脚本已加载但 grecaptcha 仍未就绪 " + f"({urlparse(script_host).netloc})" + ) return False @staticmethod diff --git a/src/services/recaptcha_runtime.py b/src/services/recaptcha_runtime.py index ae77f052..a1e669bb 100644 --- a/src/services/recaptcha_runtime.py +++ b/src/services/recaptcha_runtime.py @@ -61,119 +61,86 @@ RECAPTCHA_EXECUTE_SOURCE = r"""(async (siteKey, requestedAction, timeoutMs) => { const storageKey = '__flow2apiTrustedRecaptchaExecute'; - for (let attempt = 0; attempt < 40; attempt += 1) { - if (window[storageKey]) break; - await new Promise(resolve => setTimeout(resolve, 250)); - } - - const capturedExecute = !!window[storageKey]; - let execute = window[storageKey]; - let executeSource = ''; - try { - executeSource = String(execute || ''); - } catch (error) {} + const deadline = Date.now() + Math.max(0, timeoutMs); + const captured = window[storageKey]; + const enterprise = window.grecaptcha && window.grecaptcha.enterprise; + const debug = { + hookInstalled: !!window.__flow2apiTrustedRecaptchaHookInstalled, + actionGuard: !!window.__flow2apiRecaptchaActionGuardInstalled, + captured: typeof captured === 'function', + executeType: enterprise ? typeof enterprise.execute : 'missing', + renderType: enterprise ? typeof enterprise.render : 'missing' + }; + const errors = []; + const strategies = []; + let container = null; - if (!execute) { - const enterprise = window.grecaptcha && window.grecaptcha.enterprise; - execute = enterprise && enterprise.execute; - try { - executeSource = String(execute || ''); - } catch (error) {} + if (typeof captured === 'function') { + strategies.push(['captured', () => captured(siteKey, {action: requestedAction})]); + } + if (enterprise && typeof enterprise.execute === 'function') { + let executeSource = ''; + try { executeSource = String(enterprise.execute); } catch (error) {} if ( executeSource.includes('extension_hijack_detected') && - !window.__flow2apiRecaptchaActionGuardInstalled + !debug.actionGuard ) { - return { - ok: false, - error: 'trusted reCAPTCHA action guard is unavailable', - debug: { - hookInstalled: !!window.__flow2apiTrustedRecaptchaHookInstalled, - actionGuard: !!window.__flow2apiRecaptchaActionGuardInstalled, - captured: !!window.__flow2apiTrustedRecaptchaExecute, - url: location.href - } - }; + // Both public paths use the same wrapper and require the guard. + errors.push('trusted reCAPTCHA action guard is unavailable'); + } else { + strategies.push(['direct', () => enterprise.execute.call( + enterprise, siteKey, {action: requestedAction} + )]); + if (typeof enterprise.render === 'function') { + strategies.push(['render', () => { + container = document.createElement('div'); + container.setAttribute('data-flow2api-recaptcha', '1'); + container.style.display = 'none'; + (document.body || document.documentElement).appendChild(container); + const clientId = enterprise.render( + container, {sitekey: siteKey, size: 'invisible', action: requestedAction} + ); + return enterprise.execute.call( + enterprise, clientId, {action: requestedAction} + ); + }]); + } } } - if (typeof execute !== 'function') { - return { ok: false, error: 'reCAPTCHA execute is unavailable' }; - } - - let executeTarget = siteKey; - try { - if ( - !capturedExecute && - window.grecaptcha && - window.grecaptcha.enterprise && - typeof window.grecaptcha.enterprise.render === 'function' && - window.__flow2apiRecaptchaClientId === undefined - ) { - const holder = document.createElement('div'); - holder.style.display = 'none'; - (document.body || document.documentElement).appendChild(holder); - window.__flow2apiRecaptchaClientId = - window.grecaptcha.enterprise.render( - holder, - { sitekey: siteKey, size: 'invisible', action: requestedAction } - ); + for (let index = 0; index < strategies.length; index += 1) { + const [label, factory] = strategies[index]; + const remaining = deadline - Date.now(); + if (remaining <= 0) { + errors.push(label + ': total execute timeout'); + break; } - if (window.__flow2apiRecaptchaClientId !== undefined) { - executeTarget = window.__flow2apiRecaptchaClientId; - } - } catch (renderError) { - return { - ok: false, - error: renderError && renderError.message - ? renderError.message - : String(renderError) - }; - } - - try { - const token = await new Promise((resolve, reject) => { - let settled = false; - const finish = (handler, value) => { - if (settled) return; - settled = true; - handler(value); - }; - const timer = setTimeout(() => { - finish(reject, new Error('execute timeout')); - }, timeoutMs); - try { - Promise.resolve(execute(executeTarget, { action: requestedAction })) - .then(value => { - clearTimeout(timer); - finish(resolve, value); - }) - .catch(error => { - clearTimeout(timer); - finish(reject, error); - }); - } catch (error) { - clearTimeout(timer); - finish(reject, error); + // Reserve time for each remaining fallback within the caller's budget. + const attemptMs = Math.max(1, Math.floor(remaining / (strategies.length - index))); + let timer; + try { + const token = await new Promise((resolve, reject) => { + timer = setTimeout(() => reject(new Error('execute timeout')), attemptMs); + Promise.resolve(factory()).then(resolve, reject); + }); + const normalized = typeof token === 'string' ? token.trim() : ''; + if (normalized) return {ok: true, token: normalized, debug}; + errors.push(label + ': empty token'); + } catch (error) { + errors.push(label + ': ' + (error && error.message ? error.message : String(error))); + } finally { + clearTimeout(timer); + if (container) { + container.remove(); + container = null; } - }); - return { ok: true, token }; - } catch (error) { - const debug = { - captured: capturedExecute, - actionGuard: !!window.__flow2apiRecaptchaActionGuardInstalled, - renderType: window.grecaptcha && window.grecaptcha.enterprise - ? typeof window.grecaptcha.enterprise.render - : 'missing', - clientId: String(window.__flow2apiRecaptchaClientId), - executeTarget: String(executeTarget), - url: location.href - }; - return { - ok: false, - error: (error && error.message ? error.message : String(error)) - + ' | ' + JSON.stringify(debug) - }; + } } + return { + ok: false, + error: errors.join(' | ') || 'reCAPTCHA execute is unavailable', + debug + }; })(__SITE_KEY__, __REQUESTED_ACTION__, __TIMEOUT_MS__)""" diff --git a/tests/test_browser_recaptcha_compat.py b/tests/test_browser_recaptcha_compat.py new file mode 100644 index 00000000..091e2dc0 --- /dev/null +++ b/tests/test_browser_recaptcha_compat.py @@ -0,0 +1,174 @@ +"""reCAPTCHA loading coverage with intercepted browser requests.""" + +import asyncio +import os +import sys +import unittest +from pathlib import Path +from types import SimpleNamespace +from unittest.mock import AsyncMock, Mock, patch +from urllib.parse import urlparse + +with patch.dict(os.environ, {"DOCKER_CONTAINER": "1", "ALLOW_DOCKER_HEADED_CAPTCHA": "false"}): + from src.services.browser_captcha import TokenBrowser + + +class RecaptchaReadinessTests(unittest.IsolatedAsyncioTestCase): + async def test_ready_page_needs_no_injection(self): + browser = object.__new__(TokenBrowser) + browser.token_id = 7 + browser._inject_recaptcha_script = AsyncMock() + page = SimpleNamespace(evaluate=AsyncMock(return_value=True)) + self.assertTrue(await browser._wait_for_enterprise_ready( + page, "site-key", "https://www.google.com", "https://www.recaptcha.net" + )) + browser._inject_recaptcha_script.assert_not_awaited() + + async def test_poll_recovers_after_navigation_error(self): + browser = object.__new__(TokenBrowser) + browser.token_id = 7 + page = SimpleNamespace( + evaluate=AsyncMock(side_effect=[RuntimeError("context destroyed"), False, True]), + is_closed=Mock(return_value=False), + wait_for_function=AsyncMock(), + ) + self.assertTrue(await browser._poll_enterprise_ready(page, 1000)) + page.wait_for_function.assert_not_awaited() + + async def test_custom_captcha_stops_when_runtime_is_not_ready(self): + for enterprise in (False, True): + with self.subTest(enterprise=enterprise): + browser = object.__new__(TokenBrowser) + browser.token_id = 7 + browser._browser_proxy_active = False + browser._apply_browser_environment_patch = AsyncMock() + browser._wait_for_enterprise_ready = AsyncMock(return_value=False) + browser._capture_page_fingerprint = AsyncMock() + page = SimpleNamespace( + add_init_script=AsyncMock(), on=Mock(), goto=AsyncMock(), + evaluate=AsyncMock(return_value="complete"), bring_to_front=AsyncMock(), + mouse=SimpleNamespace(move=AsyncMock(), wheel=AsyncMock()), close=AsyncMock(), + ) + context = SimpleNamespace(new_page=AsyncMock(return_value=page)) + with patch("src.services.browser_captcha.asyncio.sleep", new=AsyncMock()): + result = await browser._execute_custom_captcha( + context, "https://captcha.invalid/", "site-key", "login", enterprise=enterprise + ) + self.assertIsNone(result) + self.assertEqual(browser._wait_for_enterprise_ready.call_args.kwargs["enterprise"], enterprise) + self.assertTrue(all("grecaptcha" not in call.args[0] for call in page.evaluate.call_args_list)) + browser._capture_page_fingerprint.assert_not_awaited() + page.close.assert_awaited_once() + + +class RecaptchaCspBrowserTests(unittest.IsolatedAsyncioTestCase): + async def asyncSetUp(self): + from playwright.async_api import async_playwright + + self.playwright = await async_playwright().start() + if not Path(self.playwright.chromium.executable_path).is_file(): + await self.playwright.stop() + if os.name == "nt": + cache = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData/Local")) / "ms-playwright" + elif sys.platform == "darwin": + cache = Path.home() / "Library/Caches/ms-playwright" + else: + cache = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")) / "ms-playwright" + with patch.dict(os.environ, {"PLAYWRIGHT_BROWSERS_PATH": str(cache)}): + self.playwright = await async_playwright().start() + self.addAsyncCleanup(self.playwright.stop) + if not Path(self.playwright.chromium.executable_path).is_file(): + self.skipTest("Playwright Chromium is not installed") + self.browser = await self.playwright.chromium.launch(headless=True) + self.addAsyncCleanup(self.browser.close) + self.solver = object.__new__(TokenBrowser) + self.solver.token_id = 7 + + async def make_page(self, *, failed_hosts=(), native_failed_script=False, enterprise=True): + page = await self.browser.new_page() + requests = [] + primary = "https://www.google.com/recaptcha/enterprise.js?render=site-key" + html = '
' + if native_failed_script: + html += f'' + html += "" + + async def route_request(route): + parsed = urlparse(route.request.url) + if route.request.url == "https://captcha.invalid/": + await route.fulfill(content_type="text/html", body=html, headers={ + "Content-Security-Policy": "require-trusted-types-for 'script'; script-src 'nonce-captcha-test'", + }) + elif parsed.path in ("/recaptcha/enterprise.js", "/recaptcha/api.js"): + requests.append(route.request.url) + if parsed.hostname in failed_hosts: + await route.abort("failed") + else: + body = "window.grecaptcha={enterprise:{execute:()=>Promise.resolve('captcha')}}" if enterprise else ( + "window.grecaptcha={execute:()=>Promise.resolve('captcha')}" + ) + await route.fulfill(content_type="text/javascript", body=body) + else: + await route.abort() + + await page.route("**/*", route_request) + await page.goto("https://captcha.invalid/") + return page, requests + + async def test_nonce_and_trusted_types_allow_injected_script(self): + page, requests = await self.make_page() + self.assertTrue(await self.solver._inject_recaptcha_script( + page, "https://www.google.com/recaptcha/enterprise.js?render=site-key", timeout_ms=1000 + )) + self.assertTrue(await self.solver._poll_enterprise_ready(page, 100)) + self.assertEqual(len(requests), 1) + self.assertEqual(await page.locator("script[src]").evaluate("node => node.nonce"), "captcha-test") + + async def test_failed_native_tag_does_not_suppress_secondary_host(self): + page, requests = await self.make_page(failed_hosts=("www.google.com",), native_failed_script=True) + self.assertTrue(await self.solver._wait_for_enterprise_ready( + page, "site-key", "https://www.google.com", "https://www.recaptcha.net", timeout_ms=1000 + )) + self.assertEqual([urlparse(url).hostname for url in requests], [ + "www.google.com", "www.google.com", "www.recaptcha.net" + ]) + # Only the original failed native tag and the successful fallback remain. + self.assertEqual(await page.locator("script[src]").count(), 2) + + async def test_both_hosts_failed_return_false_and_remove_owned_tags(self): + page, requests = await self.make_page(failed_hosts=("www.google.com", "www.recaptcha.net")) + self.assertFalse(await self.solver._wait_for_enterprise_ready( + page, "site-key", "https://www.google.com", "https://www.recaptcha.net", timeout_ms=1000 + )) + self.assertEqual([urlparse(url).hostname for url in requests], ["www.google.com", "www.recaptcha.net"]) + self.assertEqual(await page.locator("script[src]").count(), 0) + + async def test_standard_api_uses_its_own_readiness_and_script(self): + page, requests = await self.make_page(enterprise=False) + self.assertTrue(await self.solver._wait_for_enterprise_ready( + page, "site-key", "https://www.google.com", "https://www.recaptcha.net", timeout_ms=1000, + enterprise=False, + )) + self.assertEqual(urlparse(requests[0]).path, "/recaptcha/api.js") + self.assertFalse(await page.evaluate("() => !!window.grecaptcha.enterprise")) + + async def test_script_load_timeout_removes_owned_tag(self): + page, _ = await self.make_page() + release = asyncio.Event() + + async def hold_request(route): + await release.wait() + await route.abort() + + await page.route("**/recaptcha/enterprise.js*", hold_request) + try: + self.assertFalse(await self.solver._inject_recaptcha_script( + page, "https://www.google.com/recaptcha/enterprise.js?render=site-key", timeout_ms=100 + )) + self.assertEqual(await page.locator("script[src]").count(), 0) + finally: + release.set() + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_recaptcha_runtime.py b/tests/test_recaptcha_runtime.py index a203c766..cbc3e5cf 100644 --- a/tests/test_recaptcha_runtime.py +++ b/tests/test_recaptcha_runtime.py @@ -115,5 +115,160 @@ def test_shared_execute_script_preserves_requested_action(self): self.assertEqual(result.returncode, 0, result.stderr) +@unittest.skipUnless(shutil.which("node"), "Node.js is required for the JavaScript contract") +class RecaptchaExecutionContractTests(unittest.TestCase): + def run_contract(self, setup, assertions, *, virtual_time=False, timeout_ms=150): + source = r""" +const vm = require('vm'); +const input = JSON.parse(require('fs').readFileSync(0, 'utf8')); +(async () => { + let now = 0; + const sandbox = { setTimeout, clearTimeout, location: { href: 'https://flow.google.com/project/example' } }; + if (input.virtualTime) { + sandbox.Date = { now: () => now }; + sandbox.setTimeout = (callback, delay) => setTimeout(() => { now += delay; callback(); }, 0); + } + sandbox.window = sandbox; + vm.createContext(sandbox); + vm.runInContext(` + globalThis.nodes = []; + globalThis.document = { + createElement: () => ({ + children: [], style: {}, setAttribute() {}, + remove() { nodes.splice(nodes.indexOf(this), 1); } + }), + body: { appendChild(node) { nodes.push(node); } }, + documentElement: { children: ['head', 'body'] } + }; + `, sandbox); + vm.runInContext(input.setup, sandbox); + sandbox.result = await vm.runInContext(input.script, sandbox); + sandbox.elapsed = now; + vm.runInContext(input.assertions, sandbox); +})().catch(error => { process.stderr.write(error.stack); process.exitCode = 1; }); +""" + result = subprocess.run( + [shutil.which("node"), "-e", source], + input=json.dumps({ + "setup": setup, + "assertions": assertions, + "script": build_recaptcha_execute_script('site-key"\\value', "IMAGE_GENERATION", timeout_ms), + "virtualTime": virtual_time, + }), + capture_output=True, + text=True, + timeout=15, + ) + self.assertEqual(result.returncode, 0, result.stderr) + + def test_no_capture_calls_direct_execute_with_receiver_and_action(self): + self.run_contract( + r""" + globalThis.calls = []; + globalThis.grecaptcha = { enterprise: { + execute(key, options) { + calls.push({ receiver: this === grecaptcha.enterprise, key, action: options.action }); + return Promise.resolve(' captcha '); + }, + render() { throw Error('direct execute must precede render'); } + }}; + """, + r""" + if (!result.ok || result.token !== 'captcha') throw Error(JSON.stringify(result)); + if (calls.length !== 1 || !calls[0].receiver) throw Error('incorrect execute receiver'); + if (calls[0].key !== 'site-key"\\value' || calls[0].action !== 'IMAGE_GENERATION') throw Error('changed arguments'); + """, + ) + + def test_empty_captured_and_rejected_direct_fall_back_to_fresh_render(self): + self.run_contract( + r""" + globalThis.targets = []; + globalThis.__flow2apiTrustedRecaptchaExecute = () => Promise.resolve(' '); + globalThis.grecaptcha = { enterprise: { + execute(target, options) { + if (this !== grecaptcha.enterprise || options.action !== 'IMAGE_GENERATION') throw Error('changed execute context'); + targets.push(target); + if (target === 7) return Promise.resolve('captcha'); + return Promise.reject(new Error('direct unavailable')); + }, + render(container, options) { + if (container === document.documentElement || container.children.length) throw Error('container is not empty'); + if (!nodes.includes(container) || options.sitekey !== 'site-key"\\value') throw Error('invalid render'); + if (options.size !== 'invisible') throw Error('widget must remain invisible'); + return 7; + } + }}; + """, + r""" + if (!result.ok || result.token !== 'captcha') throw Error(JSON.stringify(result)); + if (targets.length !== 2 || targets[1] !== 7) throw Error('render fallback was not executed'); + if (nodes.length) throw Error('render container leaked'); + """, + ) + + def test_missing_action_guard_blocks_both_public_paths(self): + self.run_contract( + r""" + globalThis.calls = 0; + globalThis.grecaptcha = { enterprise: { + execute() { calls += 1; return Promise.resolve('extension_hijack_detected'); }, + render() { calls += 1; return 7; } + }}; + """, + r""" + if (result.ok || !result.error.includes('action guard')) throw Error(JSON.stringify(result)); + if (calls !== 0) throw Error('unguarded public execution was attempted'); + """, + ) + + def test_trusted_capture_can_succeed_without_public_action_guard(self): + self.run_contract( + r""" + globalThis.__flow2apiTrustedRecaptchaExecute = () => Promise.resolve('captcha'); + globalThis.grecaptcha = { enterprise: { + execute() { throw Error('extension_hijack_detected'); }, + render() { throw Error('public render was attempted'); } + }}; + """, + "if (!result.ok || result.token !== 'captcha') throw Error(JSON.stringify(result));", + ) + + def test_hung_strategies_leave_render_within_total_budget(self): + self.run_contract( + r""" + globalThis.__flow2apiTrustedRecaptchaExecute = () => new Promise(() => {}); + globalThis.grecaptcha = { enterprise: { + execute(target) { return target === 7 ? Promise.resolve('captcha') : new Promise(() => {}); }, + render() { return 7; } + }}; + """, + r""" + if (!result.ok || result.token !== 'captcha') throw Error(JSON.stringify(result)); + if (elapsed >= 150) throw Error('fallback exhausted the total budget: ' + elapsed); + if (nodes.length) throw Error('render container leaked'); + """, + virtual_time=True, + ) + + def test_failures_preserve_each_strategy_error_and_clean_container(self): + self.run_contract( + r""" + globalThis.__flow2apiTrustedRecaptchaExecute = () => { throw Error('capture failed'); }; + globalThis.grecaptcha = { enterprise: { + execute(target) { return Promise.reject(new Error(target === 7 ? 'widget failed' : 'direct failed')); }, + render() { return 7; } + }}; + """, + r""" + if (result.ok) throw Error('failed execution returned success'); + for (const message of ['capture failed', 'direct failed', 'widget failed']) { + if (!result.error.includes(message)) throw Error('lost error: ' + message); + } + if (nodes.length) throw Error('failed render container leaked'); + """, + ) + + if __name__ == "__main__": unittest.main()