Umgehung des Schutzes von PerimeterX und Akamai: Praktische Antidetect-Methoden

PerimeterX und Akamai Bot Manager sind zwei der fortschrittlichsten Lösungen zum Schutz vor Bots, die von den größten E-Commerce-Plattformen, Finanzdienstleistungen und Unternehmenswebsites eingesetzt werden. Diese Systeme analysieren Hunderte von Parametern des Browsers, des Nutzerverhaltens und der Netzwerkeigenschaften und schaffen einen mehrschichtigen Schutz, der nicht einfach durch einen Wechsel der IP-Adresse umgangen werden kann.

In diesem Leitfaden werden wir die Architektur beider Systeme im Detail untersuchen, ihre Erkennungsmethoden analysieren und eine umfassende Umgehungsstrategie entwickeln, die auf realen Anwendungsfällen und technischen Experimenten basiert.

Architektur von PerimeterX und Akamai: Wie die Erkennung funktioniert

PerimeterX (jetzt HUMAN Security) und Akamai Bot Manager funktionieren als mehrschichtige Schutzsysteme, die sich in verschiedenen Phasen der Anfrageverarbeitung integrieren. Das Verständnis ihrer Architektur ist entscheidend für die Entwicklung einer Umgehungsstrategie.

Architektur von PerimeterX

PerimeterX arbeitet in drei Phasen. In der ersten Phase wird ein JavaScript-Sensor in die HTML-Seite eingebettet und im Browser des Clients ausgeführt, um Daten über die Ausführungsumgebung zu sammeln: WebGL-Fingerprint, Canvas-Fingerprint, Audio-Kontext, verfügbare Schriftarten, Plugins, Bildschirmauflösung und viele andere Parameter. Dieser Sensor ist obfuskiert und wird regelmäßig aktualisiert, was seine Analyse erschwert.

In der zweiten Phase analysiert die serverseitige Komponente von PerimeterX die HTTP-Header, den TLS-Fingerprint, die IP-Reputation und die Netzwerkeigenschaften, noch bevor die Anfrage die Hauptanwendung erreicht. Das System verwendet eine eigene Datenbank bekannter Bots und verdächtiger IP-Adressen, die in Echtzeit aktualisiert wird.

Die dritte Phase ist die Verhaltensanalyse. PerimeterX verfolgt Mausbewegungen, Scrollgeschwindigkeit, Klickmuster, Zeit zwischen Aktionen und erstellt ein Verhaltensprofil. Modelle des maschinellen Lernens vergleichen dieses Profil mit Mustern realer Benutzer und bekannter Bots.

Architektur des Akamai Bot Managers

Akamai Bot Manager integriert sich auf der CDN-Ebene, was ihm einen Geschwindigkeitsvorteil bei der Analyse verschafft. Das System verwendet die eigene Technologie BMP (Bot Manager Premier), die Anfragen auf den Edge-Servern von Akamai analysiert, bevor sie an den Origin-Server weitergeleitet werden.

Ein entscheidender Unterschied bei Akamai ist die Nutzung von Telemetrie von Millionen von Websites, die durch ihr CDN geschützt sind. Dies ermöglicht es dem System, neue Bot-Typen schnell zu identifizieren und die Erkennungsregeln global zu aktualisieren. Akamai verwendet auch eine Web-SDK-Technologie, die dem Sensor von PerimeterX ähnlich ist, jedoch mit einem Fokus auf die kryptografische Integritätsprüfung des Clients.

Erkennungsmethoden: Was die Schutzsysteme analysieren

Moderne Antibot-Systeme analysieren Anfragen anhand von Hunderte von Parametern, die in mehrere Kategorien unterteilt sind. Das Verständnis jeder Kategorie ermöglicht es, systematisch Automatisierungsmarker zu beseitigen.

Analyse der HTTP-Header und TLS

Die Reihenfolge der HTTP-Header ist eine der einfachsten Methoden zur Erkennung. Browser senden Header in einer streng definierten Reihenfolge, die zwischen Versionen und Herstellern variiert. Bibliotheken wie requests in Python oder axios in Node.js verwenden ihre eigene Reihenfolge, die sofort Automatisierung verrät.

Der TLS-Fingerprint (JA3-Fingerprint) wird aus den Parametern des TLS-Handshakes erstellt: TLS-Version, Liste der unterstützten Cipher, Erweiterungen und deren Reihenfolge. Jede Kombination aus Browser und Betriebssystem erzeugt einen einzigartigen Fingerprint. Zum Beispiel hat Chrome 120 auf Windows 11 einen Fingerprint, der sich von Chrome 120 auf macOS oder von Firefox auf demselben System unterscheidet.

// Beispiel für eine Diskrepanz zwischen User-Agent und TLS-Fingerprint
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0
TLS Fingerprint: JA3-Hash entspricht Python requests
// Ergebnis: sofortige Blockierung

JavaScript-Ausführungsumgebung

Headless-Browser hinterlassen Dutzende von Spuren in der JavaScript-Umgebung. Es werden Eigenschaften wie navigator.webdriver, das Vorhandensein von Objekten window.chrome, Diskrepanzen in navigator.plugins und Anomalien im WebGL und Canvas-Rendering überprüft.

PerimeterX und Akamai verwenden fortschrittliche Prüfmethoden: Sie messen die Ausführungszeit von JavaScript-Funktionen (in Headless-Browsern unterscheidet sie sich), überprüfen das Vorhandensein von Automatisierungsartefakten im DOM und analysieren den Funktionsaufrufstack. Die Systeme überprüfen auch die Konsistenz der Daten — zum Beispiel, wenn der User-Agent auf ein mobiles Gerät hinweist, aber navigator.maxTouchPoints gleich 0 ist, ist das ein Erkennungs-Trigger.

Netzwerkeigenschaften und IP-Reputation

Die Schutzsysteme überprüfen die IP-Adresse anhand vieler Parameter: Zugehörigkeit zu bekannten Proxy-Anbietern, Listung in Blacklists, Aktivitätsgeschichte von dieser IP und Konsistenz der Geolokalisierung mit anderen Anfrageparametern (Sprache des Browsers, Zeitzone).

Besonderes Augenmerk wird auf die Nutzungsmuster der IP gelegt. Wenn von einer Adresse Anfragen mit unterschiedlichen User-Agents oder Browser-Fingerprints kommen, ist das ein starkes Signal für Automatisierung. Ebenso, wenn die IP innerhalb einer Sitzung zu oft wechselt (aggressive Proxy-Rotation), wird dies als Trigger für eine Blockierung angesehen.

Browser-Fingerprinting und TLS-Fingerprints

Browser-Fingerprinting ist eine Technik zur Erstellung einer einzigartigen Identifikation des Browsers basierend auf seinen Eigenschaften. Selbst ohne Cookies können die Schutzsysteme Benutzer verfolgen und Anomalien erkennen.

Canvas- und WebGL-Fingerprinting

Canvas-Fingerprinting funktioniert durch das Rendern eines unsichtbaren Bildes mit Text und Grafiken. Aufgrund von Unterschieden in Grafiktreibern, Schriftarten und Anti-Aliasing-Einstellungen erzeugt jedes System ein leicht unterschiedliches Bild. Der Hash dieses Bildes wird Teil des Fingerprints.

WebGL-Fingerprinting verwendet 3D-Rendering, um einen noch einzigartigeren Fingerprint zu erstellen. Das System fragt Informationen über die GPU, unterstützte Erweiterungen, maximale Texturgrößen und andere Parameter ab. Die Kombination dieser Daten erzeugt einen Fingerprint mit ausreichender Entropie zur Identifizierung des Geräts.

// Beispiel für das Erhalten eines WebGL-Fingerprints
const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl');
const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);

// Ergebnis kann sein: "Google Inc. (NVIDIA)" + "ANGLE (NVIDIA GeForce RTX 3080)"
// Einzigartige Kombination für jedes Gerät

Audio-Kontext und Schriftarten

Das Audio Context API ermöglicht die Erstellung eines einzigartigen Fingerprints basierend auf der Audioverarbeitung. Unterschiede im Audio-Stack des Betriebssystems führen zu mikroskopisch kleinen Unterschieden in der Verarbeitung des Audiosignals, die gemessen werden können und zur Identifizierung verwendet werden.

Die Liste der installierten Schriftarten ist ebenfalls einzigartig für jedes System. Die Schutzsysteme verwenden die Technik zur Messung der Textgrößen mit verschiedenen Schriftarten — wenn die Schriftart nicht installiert ist, verwendet der Browser einen Fallback, was die Größen verändert. Die Überprüfung von Hunderten von Schriftarten erzeugt eine einzigartige Signatur.

TLS- und HTTP/2-Fingerprinting

Der JA3-Fingerprint wird aus den Parametern des TLS Client Hello erstellt: SSL/TLS-Version, Liste der Cipher Suites, Liste der Erweiterungen, Liste der unterstützten elliptischen Kurven. Diese Parameter werden verknüpft und gehasht, um eine einzigartige Zeichenfolge zu erstellen.

Der HTTP/2-Fingerprint analysiert die Parameter des SETTINGS-Frames, die Reihenfolge und Prioritäten der Streams sowie die Werte von Window-Updates. Jeder Browser verwendet einzigartige HTTP/2-Einstellungen, was es ermöglicht, den Client selbst bei einem korrekten TLS-Fingerprint zu identifizieren.

Verhaltensanalyse und maschinelles Lernen

Die Verhaltensanalyse ist der schwierigste Aspekt moderner Antibot-Systeme zu umgehen. Selbst mit einem perfekten technischen Fingerprint wird un menschliches Verhalten die Automatisierung verraten.

Analyse von Mausbewegungen und Interaktionen

PerimeterX und Akamai verfolgen die Trajektorien der Mausbewegungen, Beschleunigung und Verzögerung, Mikrobewegungen, die für die menschliche Hand charakteristisch sind. Bots bewegen den Cursor normalerweise in geraden Linien oder erzeugen überhaupt keine Mausereignisse. Die Systeme analysieren auch die Reaktionszeit — ein Klick sofort nach dem Laden der Seite ohne Mausbewegung sieht verdächtig aus.

Scrollmuster sind ebenfalls einzigartig. Menschen scrollen die Seite unregelmäßig: schnell am Anfang, verlangsamen zum Lesen, scrollen manchmal zurück. Bots scrollen normalerweise mit konstanter Geschwindigkeit oder verwenden window.scrollTo() für sofortiges Scrollen.

Zeitliche Muster und Geschwindigkeit der Aktionen

Die Zeit zwischen den Aktionen ist ein kritischer Parameter. Ein Mensch kann ein Formular mit 10 Feldern nicht in 0,5 Sekunden ausfüllen oder 50 Links in einer Minute anklicken. Die Schutzsysteme erstellen ein Geschwindigkeitsprofil für jede Art von Aktion und vergleichen es mit dem Verhalten des Benutzers.

Besonderes Augenmerk wird auf die Konsistenz der Verzögerungen gelegt. Wenn zwischen jedem Klick genau 2 Sekunden vergehen, ist das ein offensichtliches Zeichen für sleep(2000) im Code. Menschliche Verzögerungen weisen natürliche Variabilität auf und folgen bestimmten statistischen Verteilungen.

Modelle des maschinellen Lernens

Beide Systeme verwenden ML-Modelle, die auf Millionen von Sitzungen realer Benutzer und bekannter Bots trainiert wurden. Die Modelle analysieren Hunderte von Merkmalen gleichzeitig: die Reihenfolge der Aktionen, die Tiefe des Seitenbesuchs, Navigationsmuster, Interaktionen mit Elementen.

PerimeterX verwendet ein Ensemble von Modellen mit unterschiedlichen Gewichten für verschiedene Typen von Websites. Das Modell für E-Commerce konzentriert sich auf Kaufmuster, das Modell für Medienseiten auf Lesemuster. Dies macht die Umgehung schwieriger, da es eine Anpassung an die Spezifik der jeweiligen Website erfordert.

// Beispiel für menschliche Verzögerungen mit Variabilität
function humanDelay(baseMs) {
  // Lognormalverteilung statt gleichverteilt
  const variance = baseMs * 0.3;
  const delay = baseMs + (Math.random() - 0.5) * variance;
  // Fügen Sie Mikroverzögerungen hinzu, die für die Verarbeitung von Ereignissen im Browser charakteristisch sind
  const microDelay = Math.random() * 50;
  return Math.max(100, delay + microDelay);
}

// Verwendung: await new Promise(r => setTimeout(r, humanDelay(2000)));

Strategie zur Auswahl und Rotation von Proxys

Die Wahl des Proxytyps und der Rotationsstrategie ist entscheidend bei der Arbeit mit PerimeterX und Akamai. Eine falsche Proxy-Konfiguration macht alle Bemühungen zur Maskierung des Browser-Fingerprints zunichte.

Residenzielle vs. mobile vs. Datacenter-Proxys

Datacenter-Proxys haben die niedrigsten Kosten, aber auch das höchste Risiko der Erkennung. PerimeterX und Akamai unterstützen Datenbanken mit IP-Adressen von Rechenzentren und erhöhen automatisch das Prüfungsniveau für solche Anfragen. Die Verwendung von Datacenter-Proxys ist nur für niedrigpriorisierte Aufgaben oder in Kombination mit einem sehr qualitativ hochwertigen Browser-Fingerprint möglich.

Residenzielle Proxys verwenden IP-Adressen echter Internetanbieter, was die Wahrscheinlichkeit der Erkennung erheblich verringert. Die Qualität der residential Proxys variiert jedoch stark. Es ist wichtig, Anbieter mit sauberen IP-Pools auszuwählen, bei denen die Adressen zuvor nicht für Spam oder andere verdächtige Aktivitäten verwendet wurden.

Mobile Proxys bieten das höchste Maß an Vertrauen, da sie IP-Adressen von Mobilfunkanbietern verwenden. Diese Adressen werden normalerweise zwischen vielen Benutzern geteilt (Carrier-Grade NAT), was die Blockierung erschwert. Mobile Proxys sind besonders effektiv gegen Akamai, das bei der Blockierung von mobilem Traffic vorsichtiger ist.

Rotationsstrategien

Aggressive Rotation (Änderung der IP bei jeder Anfrage) ist ein häufiger Fehler. Dies erzeugt ein verdächtiges Muster: Ein Benutzer kann physisch nicht alle paar Sekunden die IP-Adresse wechseln. Effektiver ist die Sitzungsrotation, bei der eine IP für die gesamte Benutzersitzung (10-30 Minuten Aktivität) verwendet wird.

Für längere Operationen werden sticky sessions mit einer Dauer von 30-60 Minuten empfohlen. Dies imitiert das Verhalten eines echten Benutzers, der während der Sitzung auf einer IP bleibt. Dabei ist es wichtig, nicht zu lange eine IP zu verwenden — Sitzungen, die mehrere Stunden dauern, sehen ebenfalls verdächtig aus.

Geografische Konsistenz

Es ist entscheidend, Übereinstimmung zwischen der Geolokalisierung der IP-Adresse und anderen Parametern zu gewährleisten: Sprache des Browsers, Zeitzone, Locale-Einstellungen. Wenn die IP-Adresse aus Deutschland stammt, aber navigator.language "en-US" zurückgibt und die Zeitzone "America/New_York" ist, ist das ein sofortiger Erkennungs-Trigger.

Bei der Arbeit mit mehreren geografischen Regionen sollten separate Browserprofile für jede Region verwendet werden. Das Wechseln zwischen Regionen innerhalb einer Sitzung (IP aus Frankreich, dann aus Japan) ist für einen echten Benutzer unmöglich und wird sofort erkannt.

Konfiguration von Antidetect-Browsern und -Tools

Die richtige Konfiguration von Automatisierungstools ist ein entscheidender Faktor für den erfolgreichen Umgang mit PerimeterX und Akamai. Selbst die besten Proxys helfen nicht, wenn der Browser-Fingerprint offensichtliche Automatisierungsmarker enthält.

Playwright und Puppeteer: Fortgeschrittene Konfiguration

Die Basiseinrichtung von Playwright oder Puppeteer erstellt einen offensichtlichen Headless-Browser. Es ist notwendig, Stealth-Plugins und zusätzliche Konfigurationen zur Maskierung der Automatisierung zu verwenden. Die Bibliothek puppeteer-extra-plugin-stealth verbirgt die Hauptmarker, erfordert jedoch zusätzliche Anpassungen.

// Fortgeschrittene Konfiguration von Playwright mit Antidetect
const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

chromium.use(stealth);

const browser = await chromium.launch({
  headless: false, // Headless-Modus wird leicht erkannt
  args: [
    '--disable-blink-features=AutomationControlled',
    '--disable-features=IsolateOrigins,site-per-process',
    '--disable-site-isolation-trials',
    '--no-sandbox',
    '--disable-setuid-sandbox',
    '--disable-dev-shm-usage',
    '--disable-accelerated-2d-canvas',
    '--disable-gpu',
    '--window-size=1920,1080',
    '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  ]
});

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

Selenium mit undetected-chromedriver

Der Standard-Selenium-WebDriver wird leicht über die Eigenschaft navigator.webdriver erkannt. Die Bibliothek undetected-chromedriver patcht automatisch ChromeDriver, entfernt die Hauptmarker der Automatisierung und wird regelmäßig aktualisiert, um neue Erkennungsmethoden zu umgehen.

import undetected_chromedriver as uc
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--no-sandbox')
options.add_argument('--window-size=1920,1080')

# Verwendung einer bestimmten Version von Chrome für Konsistenz
driver = uc.Chrome(options=options, version_main=120)

# Zusätzliche Maskierung über CDP
driver.execute_cdp_cmd('Network.setUserAgentOverride', {
    "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
})

driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")

Antidetect-Browser: AdsPower, Multilogin, GoLogin

Kommerzielle Antidetect-Browser bieten fertige Lösungen zur Verwaltung von Fingerprints. AdsPower und Multilogin ermöglichen das Erstellen von Profilen mit einzigartigen Canvas-, WebGL-, Audio-Fingerprints und deren Verwaltung über API. Diese Tools sind besonders nützlich, wenn man mit vielen Konten arbeitet.

Der entscheidende Vorteil ist die Möglichkeit, einen konsistenten Fingerprint zwischen den Sitzungen zu speichern. Jedes Profil hat feste Parameter für Canvas, WebGL, Fonts, was für die langfristige Arbeit entscheidend ist. Dabei ist es wichtig, realistische Konfigurationen zu verwenden — die Generierung zufälliger Fingerprints kann technisch unmögliche Kombinationen erzeugen, die leicht erkannt werden.

HTTP-Clients mit korrekten Fingerprints

Für Aufgaben, die kein JavaScript-Rendering erfordern, sind HTTP-Clients mit korrekten TLS- und HTTP/2-Fingerprints effektiver. Bibliotheken wie curl-impersonate (für Python — curl_cffi) und tls-client ermöglichen es, TLS-Fingerprints realer Browser zu imitieren.

from curl_cffi import requests

# Imitation von Chrome 120 mit korrektem TLS- und HTTP/2-Fingerprint
response = requests.get(
    'https://example.com',
    impersonate="chrome120",
    proxies={
        "http": "http://user:pass@proxy:port",
        "https": "http://user:pass@proxy:port"
    },
    headers={
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept-Encoding': 'gzip, deflate, br',
        'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"Windows"'
    }
)

# TLS-Fingerprint entspricht automatisch Chrome 120

Automatisierungstechniken ohne Erkennungs-Trigger

Selbst mit einem perfekten technischen Fingerprint können Automatisierungsmuster einen Bot verraten. Es ist notwendig, menschliches Verhalten auf der Ebene der Interaktion mit der Website zu imitieren.

Emulation von Mausbewegungen

Eine geradlinige Bewegung der Maus von Punkt A nach Punkt B ist ein offensichtliches Zeichen für Automatisierung. Die menschliche Hand erzeugt sanfte Kurven mit Mikro-Korrekturen. Bibliotheken wie pyautogui ermöglichen es, realistische Trajektorien unter Verwendung von Bézier-Kurven zu generieren.

// Generierung einer menschlichen Mausbewegungstrajektorie
async function humanMouseMove(page, targetX, targetY) {
  const current = await page.evaluate(() => ({
    x: window.mouseX || 0,
    y: window.mouseY || 0
  }));
  
  const steps = 25 + Math.floor(Math.random() * 15);
  const points = generateBezierCurve(current.x, current.y, targetX, targetY, steps);
  
  for (let point of points) {
    await page.mouse.move(point.x, point.y);
    await new Promise(r => setTimeout(r, 10 + Math.random() * 20));
  }
  
  // Mikro-Korrekturen vor dem Klicken
  await page.mouse.move(targetX + (Math.random() - 0.5) * 2, 
                        targetY + (Math.random() - 0.5) * 2);
}

function generateBezierCurve(x1, y1, x2, y2, steps) {
  const cp1x = x1 + (x2 - x1) * (0.3 + Math.random() * 0.2);
  const cp1y = y1 + (y2 - y1) * (0.3 + Math.random() * 0.2);
  const points = [];
  
  for (let i = 0; i <= steps; i++) {
    const t = i / steps;
    const x = Math.pow(1-t, 2) * x1 + 2 * (1-t) * t * cp1x + Math.pow(t, 2) * x2;
    const y = Math.pow(1-t, 2) * y1 + 2 * (1-t) * t * cp1y + Math.pow(t, 2) * y2;
    points.push({x: Math.round(x), y: Math.round(y)});
  }
  return points;
}

Realistisches Scrollen und Lesen von Inhalten

Menschen scrollen die Seite, um Inhalte zu lesen, und halten an interessanten Abschnitten an. Bots scrollen normalerweise schnell bis zum Ende der Seite oder bis zum gewünschten Element. Die Imitation des Lesens erfordert die Analyse von Inhalten und die Erstellung realistischer Pausen.

async function humanScroll(page, targetElement) {
  const elementPosition = await page.evaluate(el => {
    const rect = el.getBoundingClientRect();
    return rect.top + window.pageYOffset;
  }, targetElement);
  
  const currentScroll = await page.evaluate(() => window.pageYOffset);
  const distance = elementPosition - currentScroll;
  const scrollSteps = Math.floor(Math.abs(distance) / 100);
  
  for (let i = 0; i < scrollSteps; i++) {
    const scrollAmount = (distance / scrollSteps) * (0.8 + Math.random() * 0.4);
    await page.evaluate((amount) => {
      window.scrollBy({top: amount, behavior: 'smooth'});
    }, scrollAmount);
    
    // Zufällige Pausen für "Lesen"
    if (Math.random() > 0.7) {
      await new Promise(r => setTimeout(r, 1000 + Math.random() * 2000));
    } else {
      await new Promise(r => setTimeout(r, 200 + Math.random() * 400));
    }
  }
}

Natürliche Navigationsmuster

Benutzer springen nicht direkt zur Zielseite — sie interagieren auf natürliche Weise mit der Website. Beginnen Sie auf der Startseite, besuchen Sie mehrere Abschnitte, verwenden Sie die Suche oder das Navigationsmenü. Dies schafft eine Interaktionshistorie, die das Vertrauen der Schutzsysteme erhöht.

Es ist auch wichtig, Fehler und Korrekturen zu imitieren — ein Mensch kann auf den falschen Link klicken und zurückgehen, beim Eingeben im Suchfeld einen Fehler machen und den Tippfehler korrigieren. Ein ideal gerader Weg zum Ziel sieht verdächtig aus.

Verwaltung von Cookies und Storage

PerimeterX und Akamai verwenden Cookies und localStorage zur Verfolgung von Sitzungen. Das vollständige Löschen von Cookies zwischen Anfragen sieht verdächtig aus — ein echter Browser speichert einige Cookies (Analytik, Einstellungen). Speichern Sie Cookies zwischen den Sitzungen für einen "Benutzer", verwenden Sie jedoch unterschiedliche Cookie-Sets für verschiedene Profile.

Praktische Anwendungsfälle und Lösungen für typische Probleme

Lassen Sie uns spezifische Szenarien zur Umgehung von PerimeterX und Akamai mit Lösungen für typische Probleme, die während des Prozesses auftreten, betrachten.

Fall 1: Parsing von E-Commerce mit PerimeterX

Aufgabe: Daten über Produkte von einem großen Online-Shop zu extrahieren, der durch PerimeterX geschützt ist. Die Website blockiert nach 3-5 Anfragen, selbst von verschiedenen IPs.

Lösung: Verwendung einer Kombination aus residential Proxys mit sticky sessions (30 Minuten) und Playwright mit vollständiger Emulation des Verhaltens. Wichtige Punkte: Beginnen Sie auf der Startseite, verwenden Sie die Suche oder Kategorien zur Navigation, fügen Sie zufällige Verzögerungen von 3-7 Sekunden zwischen den Anfragen hinzu, imitieren Sie das Scrollen und Mausbewegungen. Kritisch ist die Speicherung von _px-Cookies zwischen den Anfragen innerhalb einer Sitzung.

// Beispiel für eine Sitzung mit Aufwärmung
async function scrapeWithWarmup(page, targetUrls) {
  // Aufwärmung des Profils
  await page.goto('https://example.com');
  await humanScroll(page, await page.$('footer'));
  await new Promise(r => setTimeout(r, 3000 + Math.random() * 2000));
  
  // Navigation durch das Menü
  await humanMouseMove(page, menuX, menuY);
  await page.click('nav a.category');
  await new Promise(r => setTimeout(r, 2000 + Math.random() * 1000));
  
  // Nur nach dem Aufwärmen zu den Zielseiten wechseln
  for (let url of targetUrls) {
    await page.goto(url);
    await humanScroll(page, await page.$('.product-info'));
    // Daten extrahieren
    const data = await page.evaluate(() => extractProductData());
    await new Promise(r => setTimeout(r, 5000 + Math.random() * 3000));
  }
}

Fall 2: Umgehung von Akamai für API-Anfragen

Aufgabe: Zugriff auf eine API, die durch Akamai Bot Manager geschützt ist. Die API erfordert spezifische Header und Token, die durch JavaScript auf der Seite generiert werden.

Lösung: Akamai verwendet häufig sensor_data — eine verschlüsselte Zeichenfolge mit den Ergebnissen der Browserüberprüfungen. Diese Zeichenfolge wird durch JavaScript generiert und muss in die Anfrage aufgenommen werden. Verwenden Sie die Browserautomatisierung, um gültige sensor_data zu erhalten, und wenden Sie es dann in einem HTTP-Client mit korrektem TLS-Fingerprint an.

// Extraktion von sensor_data über den Browser
async function getSensorData(page) {
  await page.goto('https://example.com');
  
  // Warten auf die Ausführung des Akamai-Sensors
  await page.waitForTimeout(5000);
  
  // sensor_data aus Cookies oder localStorage extrahieren
  const sensorData = await page.evaluate(() => {
    const cookie = document.cookie.split(';')
      .find(c => c.trim().startsWith('_abck='));
    return cookie ? cookie.split('=')[1] : null;
  });
  
  return sensorData;
}

// Verwendung im HTTP-Client
const sensorData = await getSensorData(page);
const response = await fetch('https://example.com/api/data', {
  headers: {
    'Cookie': `_abck=${sensorData}`,
    'User-Agent': 'Mozilla/5.0...',
    // Weitere Header müssen mit dem Browser übereinstimmen
  }
});

Fall 3: Lösung von CAPTCHA und Challenge-Seiten

Problem: Selbst bei korrekter Konfiguration zeigen PerimeterX oder Akamai manchmal Challenge-Seiten oder CAPTCHA zur zusätzlichen Überprüfung an.

Lösung: Challenge-Seiten von PerimeterX führen normalerweise zusätzliche...