GeeTest-Token-Injection in Browser-Automatisierungs-Frameworks

GeeTest v3 gibt nach der Lösung drei Werte zurück: geetest_challenge, geetest_validate und geetest_seccode. Um diese korrekt in eine Browser-Automatisierungssitzung einzufügen, muss man verstehen, wo die Site sie erwartet – versteckte Formularfelder, JavaScript-Rückrufe oder XHR-Payloads. Hier erfahren Sie, wie Sie dies in jedem wichtigen Framework tun.

Was Sie injizieren

CaptchaAI gibt ein dreiteiliges Ergebnis zurück:

{
  "geetest_challenge": "a1b2c3d4e5...modified_challenge",
  "geetest_validate": "abc123def456_validate",
  "geetest_seccode": "abc123def456_validate|jordan"
}

Alle drei Werte müssen injiziert werden. Das Fehlen eines Eintrags führt zu einem Verifizierungsfehler.

Schritt 1: Parameter extrahieren und lösen

Allen Frameworks gemeinsam – extrahieren Sie gt und challenge und lösen Sie dann mit CaptchaAI:

import requests
import time

def solve_geetest(gt, challenge, page_url):
    resp = requests.post("https://ocr.captchaai.com/in.php", data={
        "key": "YOUR_API_KEY",
        "method": "geetest",
        "gt": gt,
        "challenge": challenge,
        "pageurl": page_url,
        "json": 1
    })
    task_id = resp.json()["request"]

    for _ in range(60):
        time.sleep(3)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": "YOUR_API_KEY",
            "action": "get",
            "id": task_id,
            "json": 1
        })
        data = result.json()
        if data["status"] == 1:
            return data["request"]  # Returns dict with three values
    raise TimeoutError("GeeTest solve timed out")

Schritt 2: In Playwright (Python) einfügen

Parameter extrahieren

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    page = browser.new_page()

    # Capture GeeTest registration response
    geetest_data = {}
    def capture_geetest(response):
        if "register" in response.url and response.status == 200:
            try:
                data = response.json()
                if "gt" in data and "challenge" in data:
                    geetest_data.update(data)
            except Exception:
                pass

    page.on("response", capture_geetest)
    page.goto("https://example.com/login")
    page.wait_for_selector(".geetest_holder")

    gt = geetest_data["gt"]
    challenge = geetest_data["challenge"]

Lösung injizieren

    # Mit CaptchaAI lösen
    solution = solve_geetest(gt, challenge, page.url)

    # Method 1: Set hidden form fields
    page.evaluate(f"""
        const fields = {{
            'geetest_challenge': '{solution["geetest_challenge"]}',
            'geetest_validate': '{solution["geetest_validate"]}',
            'geetest_seccode': '{solution["geetest_seccode"]}'
        }};
        for (const [name, value] of Object.entries(fields)) {{
            let input = document.querySelector(`input[name="${{name}}"]`);
            if (!input) {{
                input = document.createElement('input');
                input.type = 'hidden';
                input.name = name;
                document.querySelector('form').appendChild(input);
            }}
            input.value = value;
        }}
    """)

    # Submit the form
    page.click("#submit-button")

Methode 2: Lösen Sie den GeeTest-Rückruf aus

Einige Websites verwenden den JavaScript-Rückruf von GeeTest anstelle von Formularfeldern:

page.evaluate(f"""
    // Find the GeeTest captcha object
    if (window.captchaObj) {{
        // Simulate a successful solve
        const result = {{
            geetest_challenge: '{solution["geetest_challenge"]}',
            geetest_validate: '{solution["geetest_validate"]}',
            geetest_seccode: '{solution["geetest_seccode"]}'
        }};

        // Override getValidate to return our solution
        window.captchaObj.getValidate = function() {{ return result; }};

        // Trigger the success callback
        const successEvent = new Event('geetest_success');
        document.dispatchEvent(successEvent);
    }}
""")

Schritt 3: In Puppeteer einfügen (JavaScript)

const puppeteer = require('puppeteer');

async function solveAndInject() {
  const browser = await puppeteer.launch({ headless: false });
  const page = await browser.newPage();

  // Capture GeeTest params
  let gt, challenge;
  page.on('response', async (response) => {
    if (response.url().includes('register') && response.status() === 200) {
      try {
        const data = await response.json();
        if (data.gt && data.challenge) {
          gt = data.gt;
          challenge = data.challenge;
        }
      } catch (e) {}
    }
  });

  await page.goto('https://example.com/login');
  await page.waitForSelector('.geetest_holder');

  // Mit CaptchaAI lösen (Implementierung wie oben)
  const solution = await solveCaptcha(gt, challenge, page.url());

  // Inject the three values
  await page.evaluate((sol) => {
    // Set hidden inputs
    const form = document.querySelector('form');
    ['geetest_challenge', 'geetest_validate', 'geetest_seccode'].forEach(name => {
      let input = document.querySelector(`input[name="${name}"]`);
      if (!input) {
        input = document.createElement('input');
        input.type = 'hidden';
        input.name = name;
        form.appendChild(input);
      }
      input.value = sol[name];
    });
  }, solution);

  await page.click('#submit-button');
}

Schritt 4: Selen (Python) injizieren

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("https://example.com/login")

# Wait for GeeTest widget
WebDriverWait(driver, 15).until(
    EC.presence_of_element_located((By.CLASS_NAME, "geetest_holder"))
)

# Extract gt and challenge from the page
gt = driver.execute_script(
    "return document.querySelector('[data-gt]')?.dataset.gt"
)
challenge = driver.execute_script(
    "return document.querySelector('[data-challenge]')?.dataset.challenge"
)

# Mit CaptchaAI lösen
solution = solve_geetest(gt, challenge, driver.current_url)

# Inject via JavaScript
driver.execute_script(f"""
    var fields = {{
        'geetest_challenge': '{solution["geetest_challenge"]}',
        'geetest_validate': '{solution["geetest_validate"]}',
        'geetest_seccode': '{solution["geetest_seccode"]}'
    }};
    var form = document.querySelector('form');
    for (var name in fields) {{
        var input = document.querySelector('input[name="' + name + '"]');
        if (!input) {{
            input = document.createElement('input');
            input.type = 'hidden';
            input.name = name;
            form.appendChild(input);
        }}
        input.value = fields[name];
    }}
""")

driver.find_element(By.ID, "submit-button").click()

Bearbeitung von XHR-basierten Einreichungen

Einige Websites übermitteln GeeTest-Ergebnisse über XHR statt per POST. Fangen Sie die Anfrage ab und ändern Sie sie:

# Playwright: Intercept the XHR and inject values
def handle_route(route):
    if "login" in route.request.url and route.request.method == "POST":
        # Modify the POST data to include our solution
        post_data = route.request.post_data
        # Add GeeTest values to the request
        route.continue_(post_data=modified_data)
    else:
        route.continue_()

page.route("**/api/login**", handle_route)

Fehlerbehebung

Verwandte Leitfäden

• GeeTest v3 per API lösen
• GeeTest v3 Slider-Parameter extrahieren
• GeeTest-Token in Browser injizieren: Challenge-Response-Workflow