reCAPTCHA v2 Enterprise

var __test_grc = undefined;
var __test_enterprise = undefined;
var __test_render = undefined;
var __test_render_widget = undefined;
var __test_render_args = undefined; // here will be the object with which render is called

var __test_handler = {
  get: function(target, name, receiver) {
    if (name == 'enterprise') {
      return __test_enterprise ? __test_enterprise : (__test_enterprise = new Proxy(target[name], __test_handler));
    } else if (name == 'render') {
      __test_render = target[name];
      return (function(a, b) {
        __test_render_args = b;
        __test_render_widget = a;
        return __test_render(a, {sitekey: b.sitekey}); });
    } else {
      return target[name];
    }
  }
};

Object.defineProperty(window, 'grecaptcha', {
  enumerable: true,
  configurable: false,
  get: function() {
    return __test_grc;
  },
  set: function(value) {
    __test_grc = new Proxy(value, __test_handler);
  }
});

(() => {
  const payload = {};
  let sitekey = null;

  document.querySelectorAll('.g-recaptcha').forEach(div => {
    if (div.dataset.sitekey) sitekey = div.dataset.sitekey;

    for (const [key, value] of Object.entries(div.dataset)) {
      if (key !== 'sitekey') {
        payload[key] = value;
      }
    }
  });

  const scriptTags = Array.from(document.querySelectorAll("script:not([src])"));
  const regex = /grecaptcha\.enterprise\.render\([^,]+,\s*\{(.*?)\}/s;

  scriptTags.forEach(tag => {
    const match = regex.exec(tag.textContent);
    if (match) {
      const obj = match[1];
      const paramRegex = /(\w+)\s*:\s*['"]([^'"]+)['"]/g;
      let p;
      while ((p = paramRegex.exec(obj)) !== null) {
        const key = p[1];
        const val = p[2];
        if (key === "sitekey") sitekey = val;
        else payload[key] = val;
      }
    }
  });

  console.log("sitekey:", sitekey);
  console.log("enterprisePayload:", payload);
})();

import { chromium } from 'playwright';

(async () => {
  const browser = await chromium.launch({ headless: false });
  const context = await browser.newContext();
  const page = await context.newPage();

  let sitekey = null;
  const enterprisePayload = {};

  const targetUrl = 'https://example.com';
  await page.goto(targetUrl, { timeout: 60000 });
  await page.waitForTimeout(3000);

  const recaptchaDivs = await page.$$('.g-recaptcha');
  for (const div of recaptchaDivs) {
    const attrs = ['data-sitekey', 'data-s', 'data-cdata', 'data-type', 'data-context'];
    for (const attr of attrs) {
      const val = await div.getAttribute(attr);
      if (val) {
        const key = attr.replace('data-', '');
        if (key === 'sitekey') {
          sitekey = val;
        } else {
          enterprisePayload[key] = val;
        }
      }
    }
  }

  const inlineScripts = await page.$$eval("script:not([src])", (scripts) =>
    scripts.map((s) => s.textContent)
  );

  const pattern = /grecaptcha\.enterprise\.render\([^,]+,\s*\{(.*?)\}/s;

  for (const script of inlineScripts) {
    const match = script.match(pattern);
    if (match) {
      const obj = match[1];
      const keyValuePattern = /(\w+)\s*:\s*['"]([^'"]+)['"]/g;
      let keyValueMatch;
      while ((keyValueMatch = keyValuePattern.exec(obj)) !== null) {
        const key = keyValueMatch[1];
        const val = keyValueMatch[2];
        if (key === 'sitekey') {
          sitekey = val;
        } else {
          enterprisePayload[key] = val;
        }
      }
      break;
    }
  }

  console.log(`sitekey: ${sitekey}`);
  console.log("enterprisePayload:");
  for (const [key, value] of Object.entries(enterprisePayload)) {
    console.log(`  ${key}: ${value}`);
  }

  await browser.close();
})();

import asyncio
import re
from playwright.async_api import async_playwright

async def extract_recaptcha_v2_enterprise(url):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context()
        page = await context.new_page()

        sitekey = None
        enterprise_payload = {}

        await page.goto(url, timeout=60000)
        await page.wait_for_timeout(3000)

        recaptcha_divs = await page.query_selector_all(".g-recaptcha")
        for div in recaptcha_divs:
            attrs = ["data-sitekey", "data-s", "data-cdata", "data-type", "data-context"]
            for attr in attrs:
                val = await div.get_attribute(attr)
                if val:
                    key = attr.replace("data-", "")
                    if key == "sitekey":
                        sitekey = val
                    else:
                        enterprise_payload[key] = val

        inline_scripts = await page.locator("script:not([src])").all_text_contents()
        pattern = re.compile(r"grecaptcha\.enterprise\.render\([^,]+,\s*\{(.*?)\}", re.DOTALL)

        for script in inline_scripts:
            match = pattern.search(script)
            if match:
                obj = match.group(1)
                for pair in re.finditer(r"(\w+)\s*:\s*['\"]([^'\"]+)['\"]", obj):
                    key = pair.group(1)
                    val = pair.group(2)
                    if key == "sitekey":
                        sitekey = val
                    else:
                        enterprise_payload[key] = val
                break

        await browser.close()

        print(f"sitekey: {sitekey}")
        print("enterprisePayload:")
        for k, v in enterprise_payload.items():
            print(f"  {k}: {v}")

asyncio.run(extract_recaptcha_v2_enterprise("https://example.com"))