Umgehung von Turnstile und hCaptcha: Schutztechnologien und Lösungsansätze

Cloudflare Turnstile und hCaptcha sind zum Standard für den Schutz von Webdiensten vor Bots geworden und haben die traditionelle reCAPTCHA ersetzt. Diese Systeme analysieren Dutzende von Parametern des Browsers und der Netzwerkumgebung, was die Nutzung von Proxys zu einer ernsthaften Herausforderung für die Automatisierung macht. In diesem Artikel werden wir untersuchen, wie diese Technologien auf technischer Ebene funktionieren und welche Umgehungsmethoden tatsächlich effektiv sind, wenn man über Proxys arbeitet.

Wie Cloudflare Turnstile funktioniert

Cloudflare Turnstile ist ein Schutzsystem der nächsten Generation, das als "unsichtbare Alternative zu CAPTCHA" positioniert wird. Im Gegensatz zur klassischen reCAPTCHA erfordert Turnstile nicht, dass der Benutzer Ampeln oder Fußgängerüberwege auswählt. Stattdessen analysiert das System die Verhaltens- und technischen Merkmale des Browsers im Hintergrund.

Technisch gesehen funktioniert Turnstile in drei Phasen. Die erste Phase ist das Laden des JavaScript-Widgets, das über ein iframe in die Seite eingebettet wird. Die zweite Phase ist die Sammlung von Telemetriedaten: Das System sammelt Daten über den Browser, einschließlich WebGL-Fingerabdruck, Canvas-Fingerabdruck, Schriftartenliste, Bildschirmauflösung, Zeitzone, Systemsprache und viele andere Parameter. Die dritte Phase ist die Validierung auf den Cloudflare-Servern, wo die gesammelten Daten mit bekannten Mustern von Bots und Proxys verglichen werden.

Ein Schlüsselmerkmal von Turnstile ist die Verwendung eines Reputationssystems für IP-Adressen. Cloudflare verfügt über eine riesige Datenbank, die von Millionen von Websites gesammelt wurde, die ihr CDN und ihren DDoS-Schutz nutzen. Wenn eine IP-Adresse in verdächtiger Aktivität erkannt wird, sinkt die Wahrscheinlichkeit, dass sie Turnstile erfolgreich passiert. Dies stellt das erste Problem für Proxy-Nutzer dar - selbst saubere Residential IPs können aufgrund früherer Besitzer eine niedrige Reputation haben.

Die Technologie von hCaptcha und Erkennungsmethoden

hCaptcha entstand als Konkurrent von Google reCAPTCHA mit einem Fokus auf Datenschutz und Monetarisierung durch maschinelles Lernen. Das System bietet Website-Besitzern an, für die Nutzung von Benutzerdaten zur Schulung von KI-Modellen zu bezahlen. Aus technischer Sicht ist hCaptcha aggressiver in der Erkennung von Automatisierung als Turnstile.

Der Hauptmechanismus von hCaptcha umfasst mehrere Schutzebenen. Die erste Ebene ist die Überprüfung von Netzwerkparametern: Das System analysiert die TTL von Paketen, Netzwerkverzögerungen, die Konsistenz der Geolokalisierung der IP-Adresse und die angegebene Zeitzone des Browsers. Die zweite Ebene sind JavaScript-Aufrufe: hCaptcha überprüft die Verfügbarkeit und die korrekte Funktionsweise von Web-APIs, einschließlich WebRTC, Battery API, Sensor API. Die dritte Ebene ist die Verhaltensanalyse von Mausbewegungen, Scrollgeschwindigkeit und Klickmustern.

Ein besonderes Merkmal von hCaptcha ist die Verwendung von Challenge-basierten Überprüfungen. Wenn das System einen Bot vermutet, zeigt es visuelle Aufgaben an: Auswahl von Bildern mit bestimmten Objekten, Lösen von Rätseln, Erkennen von Text auf verzerrten Bildern. Die Schwierigkeit der Aufgaben steigt dynamisch bei jedem misslungenen Versuch. Für Proxy-Nutzer bedeutet dies, dass selbst mit dem richtigen Fingerabdruck eine endlose Kette von Captchas auftreten kann.

Browser-Fingerprinting und Proxys

Browser-Fingerprinting ist eine Technik zur Identifizierung von Benutzern anhand eines einzigartigen Satzes von Eigenschaften des Browsers und des Geräts. Selbst wenn Sie einen Proxy verwenden, um die IP-Adresse zu ändern, bleibt der Fingerabdruck unverändert und kann die Verwendung von Automatisierung verraten. Moderne Schutzsysteme sammeln zwischen 50 und 200+ Parameter zur Erstellung eines Fingerabdrucks.

Die Hauptkomponenten des Fingerabdrucks umfassen: Canvas-Fingerabdruck (einzigartiges Rendering von Grafiken, abhängig von GPU und Treibern), WebGL-Fingerabdruck (Parameter des Grafikbeschleunigers), Audio Context-Fingerabdruck (Besonderheiten der Audioverarbeitung), Liste der installierten Schriftarten, Bildschirmparameter (Auflösung, Farbtiefe, Pixelverhältnis), User-Agent und Browser-Header, Spracheinstellungen, Zeitzone, Vorhandensein von Plugins und Erweiterungen.

Das Problem für Proxy-Nutzer liegt in den Inkonsistenzen. Wenn Ihre IP-Adresse beispielsweise einen Standort in Deutschland anzeigt, die Zeitzone des Browsers jedoch auf Moskau eingestellt ist, ist das ein rotes Signal. Wenn ein WebRTC-Leck Ihre echte IP-Adresse offenbart, die sich von der des Proxys unterscheidet, identifiziert das System sofort die Täuschung. Wenn der User-Agent Windows angibt, der Canvas-Fingerabdruck jedoch mit Linux übereinstimmt, ist die Erkennung garantiert.

// Beispiel zur Sammlung eines grundlegenden Fingerabdrucks
const fingerprint = {
  canvas: getCanvasFingerprint(),
  webgl: getWebGLFingerprint(),
  fonts: getFonts(),
  screen: {
    width: screen.width,
    height: screen.height,
    colorDepth: screen.colorDepth,
    pixelRatio: window.devicePixelRatio
  },
  timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
  language: navigator.language,
  platform: navigator.platform,
  hardwareConcurrency: navigator.hardwareConcurrency,
  deviceMemory: navigator.deviceMemory,
  webrtc: await getWebRTCIPs()
};

function getCanvasFingerprint() {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  ctx.textBaseline = 'top';
  ctx.font = '14px Arial';
  ctx.fillText('Browser fingerprint', 2, 2);
  return canvas.toDataURL();
}

Methoden zur Erkennung von Proxy-Servern

Schutzsysteme verwenden viele Techniken zur Erkennung von Proxys. Die erste Methode ist die Überprüfung von Datenbanken bekannter Proxys und VPNs. Dienste wie IPHub, IP2Proxy, MaxMind GeoIP2 enthalten Millionen von IP-Adressen, die als Proxys, VPNs oder Hosting-Anbieter klassifiziert sind. Cloudflare und hCaptcha sind mit solchen Datenbanken integriert und erhöhen automatisch die Überprüfungsstufe für verdächtige IPs.

Die zweite Methode ist die Analyse von ASN (Autonomous System Number). Datacenter-Proxys gehören normalerweise Hosting-Anbietern (AWS, DigitalOcean, OVH), was leicht anhand der ASN erkannt werden kann. Residential Proxys verwenden ASN von normalen Internetanbietern (Comcast, Verizon, Deutsche Telekom), was sie weniger verdächtig macht. Allerdings können selbst Residential-Netzwerke teilweise kompromittiert sein, wenn der Anbieter bekannt dafür ist, Proxys zu verkaufen.

Die dritte Methode ist die Verhaltensanalyse auf Netzwerkebene. Systeme überwachen Anomalien: zu niedrige oder hohe TTL von Paketen, untypische Verzögerungen, Verwendung nicht standardmäßiger Ports, Inkonsistenzen in der Geolokalisierung und Routing-Pfaden. Wenn beispielsweise eine IP-Adresse in den USA geolokalisiert ist, aber der Traceroute über europäische Server führt, ist das ein Hinweis auf einen Proxy.

Residential Proxys als grundlegende Lösung

Residential Proxys sind die Grundlage für die Umgehung von Turnstile und hCaptcha. Im Gegensatz zu Datacenter-Proxys verwenden Residential Proxys IP-Adressen von echten Geräten: Heimroutern, Mobiltelefonen, IoT-Geräten. Dies macht sie aus Sicht der Netzwerk-Infrastruktur praktisch nicht von normalen Benutzern zu unterscheiden.

Die wichtigsten Vorteile von Residential Proxys zur Umgehung von Captchas: Zugehörigkeit zu ISPs (Internet Service Provider) und nicht zu Hosting-Anbietern; saubere IP-Reputation in den meisten Fällen; korrekte Geolokalisierung und Routing; geringe Wahrscheinlichkeit, auf schwarze Listen zu gelangen. Allerdings sind nicht alle Residential Proxys gleich effektiv. Mehrere Faktoren sind entscheidend.

Der erste Faktor ist die Rotation der IP-Adressen. Statische Residential Proxys (sticky sessions) ermöglichen die Verwendung einer IP für mehrere Minuten bis mehrere Stunden. Dies ist optimal für Szenarien, in denen eine Sitzung aufrechterhalten werden muss: Autorisierung, Ausfüllen von Formularen, mehrstufige Operationen. Rotierende Proxys ändern die IP bei jeder Anfrage oder nach einem Timer, was nützlich für das Scraping ist, aber aufgrund häufiger Kontextwechsel Probleme mit Captchas verursachen kann.

Der zweite Faktor ist die geografische Verteilung. Für die Umgehung von Captchas ist es wichtig, dass die Geolokalisierung der IP mit dem Targeting der Website und den Browsereinstellungen übereinstimmt. Wenn Sie mit einer deutschen Website arbeiten, verwenden Sie deutsche Residential Proxys und stellen Sie die entsprechende Zeitzone (Europe/Berlin), Sprache (de-DE) und Locale im Browser ein.

Der dritte Faktor ist die Qualität des Proxy-Anbieters. Günstige Residential Proxys werden oft durch fragwürdige Methoden gesammelt (kostenlose VPN-Anwendungen, infizierte Geräte), was zu einer niedrigen Reputation des IP-Pools führt. Professionelle Anbieter arbeiten mit legitimen SDK-Partnerschaften und überwachen die Netzwerkqualität sorgfältig. Überprüfen Sie die Erfolgsquote des Anbieters auf den Zielwebsites, bevor Sie skalieren.

Automatisierungstools: Selenium, Puppeteer, Playwright

Die Wahl des Automatisierungstools hat einen entscheidenden Einfluss auf die Fähigkeit, Captchas zu umgehen. Selenium, Puppeteer und Playwright sind drei Hauptlösungen, jede mit ihren eigenen Erkennungsmerkmalen. Schutzsysteme können die Verwendung dieser Tools anhand von Dutzenden von Anzeichen erkennen.

Selenium ist das älteste und am leichtesten erkennbare Tool. Ein vom Selenium gesteuerter Browser hat offensichtliche Marker: Die Variable window.navigator.webdriver ist auf true gesetzt, einige Eigenschaften des Navigator-Objekts fehlen, die Fenstergrößen sind charakteristisch für die Automatisierung. Selbst mit Proxys scheitert Selenium oft an den Überprüfungen von Turnstile und hCaptcha ohne zusätzliche Obfuskation.

Puppeteer und Playwright sind modernere Tools, die auf dem Chrome DevTools-Protokoll basieren. Sie werden ebenfalls erkannt, haben jedoch weniger offensichtliche Anzeichen. Die Hauptmethoden zur Erkennung sind: Überprüfung von chrome.runtime, Analyse der Permissions API, Erkennung des Headless-Modus durch das Fehlen von Plugins und spezifische Fenstergrößen, Überprüfung des Vorhandenseins von DevTools durch Timing-Angriffe.

// Grundkonfiguration von Puppeteer mit Proxy und Anti-Detect
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
  headless: false, // headless: true wird leicht erkannt
  args: [
    '--proxy-server=http://your-proxy:port',
    '--disable-blink-features=AutomationControlled',
    '--disable-dev-shm-usage',
    '--no-sandbox',
    '--disable-setuid-sandbox',
    '--disable-web-security',
    '--disable-features=IsolateOrigins,site-per-process',
    `--window-size=1920,1080`,
    '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  ]
});

const page = await browser.newPage();

// Proxy-Authentifizierung
await page.authenticate({
  username: 'proxy_user',
  password: 'proxy_pass'
});

// Überschreibung der webdriver-Eigenschaft
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'webdriver', {
    get: () => false
  });
  
  // Emulation von Plugins für Headless
  Object.defineProperty(navigator, 'plugins', {
    get: () => [1, 2, 3, 4, 5]
  });
});

Für ernsthafte Captcha-Umgehungen wird empfohlen, spezialisierte Anti-Detect-Browser zu verwenden: Multilogin, GoLogin, AdsPower, Dolphin Anty. Diese Lösungen erstellen isolierte Browserprofile mit einzigartigen Fingerabdrücken, verwalten Cookies und Session Storage, synchronisieren automatisch die Zeitzone mit der Geolokalisierung des Proxys und emulieren realistische Canvas- und WebGL-Fingerabdrücke.

Captcha-Lösungsdienste: Integration und Effizienz

Wenn technische Methoden nicht ausreichen, kommen Captcha-Lösungsdienste ins Spiel. Sie lassen sich in zwei Typen unterteilen: menschliche (Crowdsourcing) und automatische (maschinelles Lernen). Für Turnstile und hCaptcha variiert die Effizienz.

Menschliche Dienste (2Captcha, AntiCaptcha, CapSolver, CapMonster Cloud) arbeiten nach dem Prinzip der verteilten Arbeit: Ihr Captcha wird an eine echte Person gesendet, die es manuell löst. Vorteile: hohe Erfolgsquote (95-99% für hCaptcha, 85-95% für Turnstile), Unterstützung komplexer visueller Aufgaben, relative Stabilität. Nachteile: Lösungszeit von 10-60 Sekunden, Kosten von 1-3 USD pro 1000 Captchas, Abhängigkeit von der Verfügbarkeit von Betreibern.

Automatische Dienste verwenden KI-Modelle zur Erkennung. Sie sind schneller (1-5 Sekunden) und günstiger, haben jedoch eine niedrigere Erfolgsquote für moderne Captchas - normalerweise 60-80% für hCaptcha und 50-70% für Turnstile. Sie sind effektiv für einfache Challenge-basierte Aufgaben, scheitern jedoch häufig bei unsichtbaren Überprüfungen.

// Integration von 2Captcha zur Lösung von hCaptcha
const axios = require('axios');

async function solveHCaptcha(sitekey, pageUrl, proxyConfig) {
  const API_KEY = 'your_2captcha_api_key';
  
  // Aufgabe senden
  const createTask = await axios.post('https://2captcha.com/in.php', null, {
    params: {
      key: API_KEY,
      method: 'hcaptcha',
      sitekey: sitekey,
      pageurl: pageUrl,
      proxy: `${proxyConfig.type}:${proxyConfig.host}:${proxyConfig.port}:${proxyConfig.user}:${proxyConfig.pass}`,
      json: 1
    }
  });
  
  const taskId = createTask.data.request;
  
  // Warten auf Lösung
  let solution = null;
  for (let i = 0; i < 60; i++) {
    await new Promise(resolve => setTimeout(resolve, 3000));
    
    const result = await axios.get('https://2captcha.com/res.php', {
      params: {
        key: API_KEY,
        action: 'get',
        id: taskId,
        json: 1
      }
    });
    
    if (result.data.status === 1) {
      solution = result.data.request;
      break;
    }
  }
  
  return solution; // Token zum Einfügen in das Formular
}

// Verwendung in Puppeteer
const captchaToken = await solveHCaptcha(
  'site-key-from-page',
  'https://example.com',
  { type: 'http', host: 'proxy.example.com', port: 8080, user: 'user', pass: 'pass' }
);

await page.evaluate((token) => {
  document.querySelector('[name="h-captcha-response"]').value = token;
  document.querySelector('[name="g-recaptcha-response"]').value = token;
}, captchaToken);

Es ist entscheidend, die richtigen Proxy-Parameter an den Captcha-Lösungsdienst zu übergeben. Wenn das Captcha von einer IP gelöst wird und das Token dann von einer anderen verwendet wird, schlägt die Validierung fehl. Moderne Captchas binden das Token an die IP-Adresse, den User-Agent und andere Sitzungsparameter.

Fortgeschrittene Techniken: Geräteemulation und TLS-Fingerprinting

Für die Umgehung der am besten geschützten Systeme sind fortgeschrittene Techniken erforderlich, die über die grundlegende Konfiguration von Proxys und Browsern hinausgehen. Zwei Schlüsselbereiche sind die Emulation von Mobilgeräten und die Verwaltung von TLS-Fingerprinting.

Mobile Proxys in Kombination mit der Emulation mobiler Browser bieten eine hohe Effizienz gegen Captchas. Gründe: Mobiler Traffic hat eine höhere Vertrauenswürdigkeit, mobile IP-Adressen (insbesondere 4G/5G) sind oft dynamisch und ändern sich auf natürliche Weise, mobile Geräte haben einen anderen Satz von Fingerabdruckparametern, viele Websites vereinfachen die Überprüfungen für mobile Benutzer.

Für eine korrekte Emulation eines mobilen Geräts ist es notwendig: einen mobilen User-Agent zu verwenden (genaue Übereinstimmung mit dem Modell des Geräts), die korrekte Viewport- und devicePixelRatio einzustellen, Touch-Events anstelle von Maus-Events zu emulieren, mobile Werte für navigator.platform und navigator.maxTouchPoints zu verwenden, WebGL und Canvas-Fingerabdruck an das spezifische Modell des Geräts anzupassen.

// Emulation eines iPhone 13 Pro in Playwright
const { chromium, devices } = require('playwright');

const iPhone13Pro = devices['iPhone 13 Pro'];

const browser = await chromium.launch({
  proxy: {
    server: 'http://mobile-proxy:port',
    username: 'user',
    password: 'pass'
  }
});

const context = await browser.newContext({
  ...iPhone13Pro,
  locale: 'en-US',
  timezoneId: 'America/New_York',
  geolocation: { latitude: 40.7128, longitude: -74.0060 },
  permissions: ['geolocation']
});

const page = await context.newPage();

// Zusätzliche Fingerabdruckanpassung
await page.addInitScript(() => {
  Object.defineProperty(navigator, 'hardwareConcurrency', {
    get: () => 6 // iPhone 13 Pro hat 6 Kerne
  });
  
  Object.defineProperty(navigator, 'deviceMemory', {
    get: () => 6 // 6GB RAM
  });
});

TLS-Fingerprinting ist eine Methode zur Identifizierung des Clients anhand der Parameter der TLS/SSL-Verbindung. Jeder Browser und jedes Betriebssystem haben eine einzigartige Kombination von Cipher Suites, Extensions, elliptischen Kurven, die bei der Herstellung einer HTTPS-Verbindung übermittelt werden. Schutzsysteme analysieren den TLS-Fingerabdruck und vergleichen ihn mit dem angegebenen User-Agent.

Das Problem standardmäßiger Automatisierungstools besteht darin, dass sie den TLS-Fingerabdruck der Basisversion von Chromium verwenden, der sich von dem vollständigen Chrome unterscheidet. Diese Inkonsistenz wird erkannt. Lösungen: Verwendung von Bibliotheken wie curl-impersonate oder tls-client für Python, die den TLS-Fingerabdruck spezifischer Browser emulieren; Anwendung von HTTP-Clients mit Anpassung des TLS (z. B. cycletls für Node.js); Verwendung vollständiger Browser anstelle von Headless-Modi.

Praktische Codebeispiele

Lassen Sie uns ein vollständiges Beispiel für die Umgehung von Turnstile mit Playwright, Residential Proxys und Anti-Detect-Techniken betrachten. Dieser Code demonstriert einen umfassenden Ansatz zur Lösung der Aufgabe.

const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

// Proxy-Konfiguration
const proxyConfig = {
  server: 'http://residential-proxy.proxycove.com:8080',
  username: 'your_username',
  password: 'your_password'
};

// Einstellungen zur Simulation eines echten Benutzers aus Deutschland
const userConfig = {
  viewport: { width: 1920, height: 1080 },
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  locale: 'de-DE',
  timezoneId: 'Europe/Berlin',
  geolocation: { latitude: 52.5200, longitude: 13.4050 }, // Berlin
  permissions: ['geolocation']
};

async function bypassTurnstile(url) {
  const browser = await chromium.launch({
    headless: false, // wichtig für komplexe Captchas
    proxy: proxyConfig,
    args: [
      '--disable-blink-features=AutomationControlled',
      '--no-sandbox',
      '--disable-dev-shm-usage'
    ]
  });

  const context = await browser.newContext({
    ...userConfig,
    // Zusätzliche Header
    extraHTTPHeaders: {
      'Accept-Language': 'de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7',
      'Accept-Encoding': 'gzip, deflate, br',
      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
      'DNT': '1',
      'Connection': 'keep-alive',
      'Upgrade-Insecure-Requests': '1'
    }
  });

  const page = await context.newPage();

  // Einfügen von Anti-Detect-Skripten
  await page.addInitScript(() => {
    // Verstecken des Webdrivers
    Object.defineProperty(navigator, 'webdriver', {
      get: () => undefined
    });

    // Emulation von Chrome-Runtime
    window.chrome = {
      runtime: {}
    };

    // Überschreibung der Berechtigungen
    const originalQuery = window.navigator.permissions.query;
    window.navigator.permissions.query = (parameters) => (
      parameters.name === 'notifications' ?
        Promise.resolve({ state: Notification.permission }) :
        originalQuery(parameters)
    );

    // Realistischere Werte für Windows
    Object.defineProperty(navigator, 'platform', {
      get: () => 'Win32'
    });

    Object.defineProperty(navigator, 'hardwareConcurrency', {
      get: () => 8
    });

    Object.defineProperty(navigator, 'deviceMemory', {
      get: () => 8
    });
  });

  // Emulation menschlichen Verhaltens
  async function humanLikeDelay(min = 1000, max = 3000) {
    const delay = Math.random() * (max - min) + min;
    await page.waitForTimeout(delay);
  }

  async function humanLikeMouseMove() {
    const viewportSize = page.viewportSize();
    const x = Math.random() * viewportSize.width;
    const y = Math.random() * viewportSize.height;
    await page.mouse.move(x, y, { steps: 10 });
  }

  try {
    // Gehe zur Seite
    await page.goto(url, { waitUntil: 'networkidle' });
    
    await humanLikeDelay(2000, 4000);
    await humanLikeMouseMove();

    // Warten auf das Laden von Turnstile
    await page.waitForSelector('iframe[src*="turnstile"]', { timeout: 10000 });
    
    console.log('Turnstile erkannt, warte auf automatische Lösung...');
    
    // Turnstile im managed Modus wird oft automatisch gelöst
    // Warten auf das Erscheinen des Tokens
    await page.waitForFunction(() => {
      const response = document.querySelector('[name="cf-turnstile-response"]');
      return response && response.value.length > 0;
    }, { timeout: 30000 });

    console.log('Turnstile erfolgreich passiert!');
    
    // Weitere Aktionen auf der Website
    await humanLikeDelay();
    
    // Beispiel: Ausfüllen eines Formulars
    await page.fill('#email', 'user@example.com');
    await humanLikeDelay(500, 1500);
    
    await page.fill('#password', 'SecurePassword123');
    await humanLikeDelay(500, 1500);
    
    await humanLikeMouseMove();
    await page.click('button[type="submit"]');
    
    await page.waitForNavigation({ waitUntil: 'networkidle' });
    
    console.log('Anmeldung erfolgreich');

  } catch (error) {
    console.error('Fehler bei der Umgehung von Turnstile:', error.message);
    
    // Screenshot zur Fehlersuche
    await page.screenshot({ path: 'turnstile_error.png', fullPage: true });
    
  } finally {
    await browser.close();
  }
}

// Ausführung
bypassTurnstile('https://example.com/login');

Für hCaptcha mit visuellen Aufgaben ist eine Integration des Lösungsdienstes erforderlich. Hier ist ein Beispiel mit der Verwendung von 2Captcha:

const axios = require('axios');

class HCaptchaSolver {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://2captcha.com';
  }

  async solve(sitekey, pageUrl, proxy = null) {
    // Aufgabe erstellen
    const params = {
      key: this.apiKey,
      method: 'hcaptcha',
      sitekey: sitekey,
      pageurl: pageUrl,
      json: 1
    };

    if (proxy) {
      params.proxy = `${proxy.type}:${proxy.host}:${proxy.port}:${proxy.username}:${proxy.password}`;
      params.proxytype = proxy.type.toUpperCase();
    }

    const createResponse = await axios.post(`${this.baseUrl}/in.php`, null, { params });
    
    if (createResponse.data.status !== 1) {
      throw new Error(`Fehler beim Erstellen der Aufgabe: ${createResponse.data.request}`);
    }

    const taskId = createResponse.data.request;
    console.log(`Aufgabe erstellt: ${taskId}`);

    // Polling des Ergebnisses
    for (let attempt = 0; attempt < 60; attempt++) {
      await new Promise(resolve => setTimeout(resolve, 5000));

      const resultResponse = await axios.get(`${this.baseUrl}/res.php`, {
        params: {
          key: this.apiKey,
          action: 'get',
          id: taskId,
          json: 1
        }
      });

      if (resultResponse.data.status === 1) {
        console.log('hCaptcha gelöst!');
        return resultResponse.data.request;
      }

      if (resultResponse.data.request !== 'CAPCHA_NOT_READY') {
        throw new Error(`Fehler bei der Lösung: ${resultResponse.data.request}`);
      }

      console.log(`Versuch ${attempt + 1}/60: Captcha wird noch gelöst...`);
    }

    throw new Error('Timeout: Captcha wurde nicht innerhalb von 5 Minuten gelöst');
  }
}

// Verwendung mit Playwright
async function bypassHCaptcha(page, proxyConfig) {
  // Sitekey von der Seite abrufen
  const sitekey = await page.getAttribute('[data-sitekey]', 'data-sitekey');
  const pageUrl = page.url();

  const solver = new HCaptchaSolver('your_2captcha_api_key');
  
  const token = await solver.solve(sitekey, pageUrl, {
    type: 'http',
    host: 'residential-proxy.proxycove.com',
    port: 8080,
    username: 'your_username',
    password: 'your_password'
  });

  // Token auf die Seite einfügen
  await page.evaluate((captchaToken) => {
    document.querySelector('[name="h-captcha-response"]').value = captchaToken;
    
    // Für einige Websites ist möglicherweise auch g-recaptcha-response erforderlich
    const gRecaptcha = document.querySelector('[name="g-recaptcha-response"]');
    if (gRecaptcha) {
      gRecaptcha.value = captchaToken;
    }
    
    // Ereignis für Callback auslösen
    const event = new Event('change', { bubbles: true });
    document.querySelector('[name="h-captcha-response"]').dispatchEvent(event);
  }, token);

  console.log('hCaptcha-Token eingefügt');
}

Fazit

Die Umgehung von Turnstile und hCaptcha über Proxys ist eine komplexe Aufgabe, die ein Verständnis der Schutzmechanismen und eine kluge Kombination von Technologien erfordert. Wichtige Erkenntnisse: Verwenden Sie qualitativ hochwertige Residential oder mobile Proxys anstelle von Datacenter-Proxys; synchronisieren Sie alle Umgebungsparameter (IP-Geolokalisierung, Zeitzone, Sprache, Locale); wenden Sie Anti-Detect-Techniken an, um die Automatisierung zu verbergen; emulieren Sie realistisch menschliches Verhalten; verwenden Sie Captcha-Lösungsdienste als zusätzliche Schutzebene.

Die Effektivität der Methoden hängt von der spezifischen Website und den Schutzvorkehrungen ab. Es wird empfohlen, mit einer grundlegenden Konfiguration zu beginnen und schrittweise zu verfeinern, während die Erfolgsquote überwacht wird. Testen Sie mit kleinen Volumina, bevor Sie skalieren, um eine Sperrung des IP-Pools zu vermeiden. Aktualisieren Sie regelmäßig die Fingerabdruckparameter und den User-Agent auf die aktuellen Versionen der Browser.

Für die professionelle Arbeit mit Captchas sollten Sie die Verwendung spezialisierter Automatisierungsplattformen in Betracht ziehen, die Proxys, Anti-Detect-Browser und Lösungsdienste in einem einzigen Ökosystem vereinen. Dies reduziert die Integrationskomplexität und erhöht die Stabilität der Ergebnisse. Beginnen Sie mit Tests qualitativ hochwertiger Proxys auf Ihren Zielwebsites - dies ist die Grundlage für die erfolgreiche Umgehung moderner Schutzsysteme.