← Zurück zum Blog
RUENZHESARPTDEFRJAKOITTRIDVIFAHI

Wie man die Erkennung von Automatisierung durch Timing-Angriffe vermeidet: Schutz in Selenium und Puppeteer

Timing-Angriffe sind eine der komplexesten Methoden zur Erkennung von Automatisierung. Wir erklären, wie man sich vor der Analyse der Ausführungszeit von Aktionen im Browser schützt.

📅10. Januar 2026
```html

Timing-Angriffe sind eine Methode zur Erkennung von Bots, die auf der Analyse der Ausführungszeiten von Aktionen im Browser basiert. Moderne Anti-Fraud-Systeme von Facebook, Google, TikTok und anderen Plattformen analysieren nicht nur, was Sie tun, sondern auch, wie schnell Sie es tun. Zu schnelle Klicks, sofortiges Laden von Seiten, das Fehlen natürlicher Pausen – all dies verrät die Automatisierung. In diesem Artikel werden wir technische Schutzmethoden gegen Timing-Angriffe für Entwickler untersuchen, die mit Selenium, Puppeteer und Anti-Detect-Browsern arbeiten.

Was sind Timing-Angriffe und wie funktionieren sie

Ein Timing-Angriff ist eine Methode zur Erkennung von Automatisierung, die auf der Messung der Zeitintervalle zwischen den Aktionen eines Benutzers basiert. Anti-Fraud-Systeme sammeln Telemetrie: wie viel Zeit vom Laden der Seite bis zum ersten Klick vergangen ist, wie schnell der Benutzer scrollt, ob es Pausen beim Ausfüllen von Formularen gibt. Diese Daten werden mit Verhaltensmodellen von echten Menschen verglichen.

Die wichtigsten zeitlichen Metriken, die von Schutzsystemen analysiert werden:

  • Time to First Interaction (TTFI) – die Zeit vom Laden der Seite bis zur ersten Aktion (Klick, Scrollen, Texteingabe). Bots handeln normalerweise sofort nach dem Laden des DOM, Menschen – nach 0,5-3 Sekunden.
  • Klick-Zeitmuster – Intervalle zwischen Klicks. Automatisierte Skripte klicken oft mit gleicher Frequenz (z.B. genau alle 2 Sekunden), Menschen – chaotisch.
  • Konsistenz der Tippgeschwindigkeit – Geschwindigkeit der Texteingabe. Bots geben Text sofort oder mit konstanten Verzögerungen zwischen den Zeichen ein, Menschen – mit variabler Geschwindigkeit und Pausen.
  • Mausbewegungsgeschwindigkeit – Geschwindigkeit der Cursorbewegung. Selenium teleportiert den Cursor standardmäßig sofort an den gewünschten Punkt, Menschen bewegen die Maus mit Beschleunigung und Verzögerung.
  • Scrollverhalten – Muster beim Scrollen der Seite. Bots scrollen oft genau um eine feste Anzahl von Pixeln, Menschen – unregelmäßig, mit Stopps.

Die Erkennungssysteme verwenden maschinelles Lernen zur Analyse dieser Metriken. Sie erstellen ein Verhaltensprofil und berechnen die Wahrscheinlichkeit, dass der Benutzer ein Bot ist. Wenn die zeitlichen Muster zu perfekt oder zu schnell sind – ist das ein rotes Signal.

Wichtig: Timing-Angriffe sind besonders effektiv gegen Massenautomatisierung. Wenn Sie 100 Browser mit den gleichen zeitlichen Mustern ausführen, wird das Anti-Fraud-System sie leicht aufgrund statistischer Anomalien erkennen.

Methoden zur Erkennung von Automatisierung durch zeitliche Muster

Moderne Anti-Fraud-Systeme verwenden mehrere Schichten der Analyse zeitlicher Merkmale. Lassen Sie uns spezifische Techniken betrachten, die Facebook, Google, Cloudflare und andere Plattformen anwenden.

1. Analyse der Performance API

Browser bieten die Performance API, die detaillierte Telemetrie zum Laden von Seiten sammelt. Anti-Fraud-Systeme analysieren: 

// Beispiel für Performance API-Daten
performance.timing = {
  navigationStart: 1234567890000,
  domLoading: 1234567890150,      // +150ms
  domInteractive: 1234567890300,  // +300ms
  domComplete: 1234567890500,     // +500ms
  loadEventEnd: 1234567890600     // +600ms
}

// Verdächtige Muster für Bots:
// - Zu schnelles Laden (domComplete < 200ms)
// - Perfekt gleichmäßige Intervalle zwischen Ereignissen
// - Keine Verzögerungen beim Laden externer Ressourcen

Headless-Browser (insbesondere ältere Versionen von Puppeteer und Selenium) zeigen oft anormal schnelle Werte für navigationStart und domLoading, da sie Bilder, Schriftarten und andere Ressourcen nicht so laden wie ein normaler Browser.

2. Ereignis-Zeit-Analyse

JavaScript-Tracker verfolgen die Zeitstempel aller Ereignisse (Klicks, Mausbewegungen, Tasteneingaben) und analysieren Muster: 

// Beispiel für das Sammeln von Telemetrieereignissen
const events = [];

document.addEventListener('click', (e) => {
  events.push({
    type: 'click',
    timestamp: performance.now(),
    x: e.clientX,
    y: e.clientY
  });
});

// Analyse verdächtiger Muster:
// - Klicks erfolgen genau alle N Millisekunden
// - Keine Mikrobewegungen der Maus vor dem Klick
// - Der erste Klick erfolgt sofort nach dem Laden der Seite

3. Tastenanschlag-Dynamik

Beim Ausfüllen von Formularen analysieren Anti-Fraud-Systeme die Dynamik der Tastenanschläge – ein einzigartiger biometrischer Indikator jeder Person:

  • Dwell time – die Zeit, in der eine Taste gedrückt wird (von keydown bis keyup). Bei Menschen variiert sie zwischen 50 und 200 ms, bei Bots ist sie konstant.
  • Flight time – die Zeit zwischen dem Loslassen einer Taste und dem Drücken der nächsten. Bei Menschen beträgt sie zwischen 100 und 500 ms mit Variationen, bei Bots ist sie eine feste Verzögerung.
  • Tipp-Rhythmus – das allgemeine Tempo des Tippens. Menschen machen Pausen bei Satzzeichen, korrigieren Fehler, Bots nicht.

Beispiel für die Erkennung: Wenn Sie element.send_keys("text") in Selenium verwenden, wird der gesamte Text in 1-2 Millisekunden eingegeben – das verrät sofort die Automatisierung.

Nachahmung menschlicher Verzögerungen im Code

Die erste Schutzebene gegen Timing-Angriffe besteht darin, Verzögerungen zwischen den Aktionen hinzuzufügen. Es ist jedoch wichtig, nicht einfach time.sleep(2) einzufügen, sondern ein natürliches Verhalten zu simulieren.

Grundlegende Nachahmung von Verzögerungen in Python (Selenium)

import time
import random
from selenium import webdriver
from selenium.webdriver.common.by import By

def human_delay(min_sec=0.5, max_sec=2.0):
    """Zufällige Verzögerung, die einen Menschen imitiert"""
    delay = random.uniform(min_sec, max_sec)
    time.sleep(delay)

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

# Verzögerung vor der ersten Aktion (der Mensch liest die Seite)
human_delay(1.5, 4.0)

# Klick auf das Element
button = driver.find_element(By.ID, "submit-btn")
button.click()

# Verzögerung vor der nächsten Aktion
human_delay(0.8, 2.5)

Fortgeschrittene Nachahmung mit normaler Verteilung

Eine gleichmäßige Verteilung (uniform) sieht unnatürlich aus. Menschliche Verzögerungen folgen einer Normalverteilung mit Ausreißern: 

import numpy as np

def realistic_delay(mean=1.5, std_dev=0.5, min_val=0.3, max_val=5.0):
    """
    Verzögerung mit normaler Verteilung
    mean: durchschnittliche Verzögerungszeit
    std_dev: Standardabweichung
    min_val, max_val: Grenzen (um extreme Werte zu vermeiden)
    """
    delay = np.random.normal(mean, std_dev)
    delay = max(min_val, min(max_val, delay))  # Begrenzen des Bereichs
    time.sleep(delay)
    return delay

# Verwendung
realistic_delay(mean=2.0, std_dev=0.7)  # Durchschnitt 2 Sek., aber mit Variationen

Kontextuelle Verzögerungen

Verschiedene Aktionen erfordern unterschiedliche Zeiten. Erstellen Sie Verzögerungsprofile für verschiedene Szenarien: 

class HumanBehavior:
    """Verzögerungsprofile für verschiedene Arten von Aktionen"""
    
    @staticmethod
    def page_load_delay():
        """Verzögerung nach dem Laden der Seite (Inhalt lesen)"""
        return realistic_delay(mean=2.5, std_dev=1.0, min_val=1.0, max_val=6.0)
    
    @staticmethod
    def before_click():
        """Verzögerung vor dem Klick (Element mit den Augen suchen)"""
        return realistic_delay(mean=0.8, std_dev=0.3, min_val=0.3, max_val=2.0)
    
    @staticmethod
    def before_typing():
        """Verzögerung vor dem Beginn der Texteingabe"""
        return realistic_delay(mean=1.2, std_dev=0.5, min_val=0.5, max_val=3.0)
    
    @staticmethod
    def between_form_fields():
        """Verzögerung zwischen den Formularfeldern"""
        return realistic_delay(mean=0.6, std_dev=0.2, min_val=0.2, max_val=1.5)

# Verwendung im Skript
driver.get("https://example.com/login")
HumanBehavior.page_load_delay()

username_field = driver.find_element(By.ID, "username")
HumanBehavior.before_typing()
# ... Eingabe des Benutzernamens ...

HumanBehavior.between_form_fields()

password_field = driver.find_element(By.ID, "password")
HumanBehavior.before_typing()
# ... Eingabe des Passworts ...

Randomisierung der Ausführungszeiten von Aktionen

Gleiche Verzögerungen zwischen den Aktionen sind eine statistische Anomalie. Wenn Sie 100 Instanzen des Skripts ausführen und alle genau 2,5 Sekunden nach dem Laden auf die Schaltfläche klicken – wird dies leicht erkannt. Eine Randomisierung auf mehreren Ebenen ist erforderlich.

1. Randomisierung der Reihenfolge der Aktionen

Fügen Sie Variabilität in die Reihenfolge der Aktionen ein. Zum Beispiel scrollen Sie manchmal die Seite, bevor Sie das Formular ausfüllen, manchmal nicht: 

def fill_form_naturally(driver):
    # 30% Wahrscheinlichkeit, die Seite vor dem Ausfüllen zu scrollen
    if random.random() < 0.3:
        driver.execute_script("window.scrollBy(0, 200)")
        human_delay(0.5, 1.5)
    
    # 20% Wahrscheinlichkeit, an eine zufällige Stelle zu klicken (Nachahmung des Lesens)
    if random.random() < 0.2:
        body = driver.find_element(By.TAG_NAME, "body")
        body.click()
        human_delay(0.3, 0.8)
    
    # Hauptaktion – Ausfüllen des Formulars
    username_field = driver.find_element(By.ID, "username")
    type_like_human(username_field, "myusername")

2. Variable Tippgeschwindigkeit

Anstelle einer sofortigen Texteingabe simulieren Sie die Eingabe Zeichen für Zeichen mit variabler Geschwindigkeit: 

def type_like_human(element, text):
    """Texteingabe mit Nachahmung der menschlichen Tippgeschwindigkeit"""
    for char in text:
        element.send_keys(char)
        
        # Grundverzögerung zwischen den Zeichen
        base_delay = random.uniform(0.05, 0.15)
        
        # Zusätzliche Pausen bei Leerzeichen und Satzzeichen
        if char in [' ', '.', ',', '!', '?']:
            base_delay += random.uniform(0.1, 0.3)
        
        # Zufällige "Nachdenklichkeit" (5% Wahrscheinlichkeit für lange Pausen)
        if random.random() < 0.05:
            base_delay += random.uniform(0.5, 1.5)
        
        time.sleep(base_delay)
    
    # Manchmal machen wir einen Tippfehler und korrigieren ihn (10% Wahrscheinlichkeit)
    if random.random() < 0.1:
        time.sleep(random.uniform(0.2, 0.5))
        element.send_keys(Keys.BACKSPACE)
        time.sleep(random.uniform(0.1, 0.3))
        element.send_keys(text[-1])  # Letztes Zeichen erneut eingeben

3. Puppeteer: langsame Texteingabe

In Puppeteer gibt es eine eingebaute Option delay für die Methode type(), aber sie muss randomisiert werden: 

// Grundlegende Verwendung (NICHT empfohlen – feste Verzögerung)
await page.type('#username', 'myusername', { delay: 100 });

// Richtiger Ansatz – Randomisierung für jedes Zeichen
async function typeWithVariableSpeed(page, selector, text) {
  await page.click(selector);
  
  for (const char of text) {
    await page.keyboard.type(char);
    
    // Zufällige Verzögerung von 50 bis 150 ms
    let delay = Math.random() * 100 + 50;
    
    // Zusätzliche Pause bei Leerzeichen
    if (char === ' ') {
      delay += Math.random() * 200 + 100;
    }
    
    // Zufällige lange Pausen (5% Wahrscheinlichkeit)
    if (Math.random() < 0.05) {
      delay += Math.random() * 1000 + 500;
    }
    
    await page.waitForTimeout(delay);
  }
}

// Verwendung
await typeWithVariableSpeed(page, '#username', 'myusername');

Natürliches Mausbewegung und Scrollgeschwindigkeit

Selenium und Puppeteer bewegen den Mauszeiger standardmäßig nicht – sie teleportieren ihn sofort an den gewünschten Punkt und klicken. Dies ist eines der offensichtlichsten Anzeichen für Automatisierung. Um menschliche Mausbewegungen zu simulieren, sind spezielle Bibliotheken erforderlich.

Bibliothek pyautogui für sanfte Mausbewegungen

Die Bibliothek pyautogui ermöglicht es, den Cursor entlang einer Bézier-Kurve mit Beschleunigung und Verzögerung zu bewegen: 

import pyautogui
from selenium.webdriver.common.action_chains import ActionChains

def move_mouse_naturally(driver, element):
    """Sanfte Bewegung der Maus zum Element mit Nachahmung eines Menschen"""
    # Holen Sie sich die Koordinaten des Elements
    location = element.location
    size = element.size
    
    # Zielpunkt (Mitte des Elements + kleine Zufälligkeit)
    target_x = location['x'] + size['width'] / 2 + random.randint(-5, 5)
    target_y = location['y'] + size['height'] / 2 + random.randint(-5, 5)
    
    # Sanfte Bewegung mit variabler Geschwindigkeit
    # duration – Bewegungszeit (0,5-1,5 Sek. für Realismus)
    duration = random.uniform(0.5, 1.5)
    
    # tweening – Beschleunigungsfunktion (easeInOutQuad imitiert menschliche Bewegung)
    pyautogui.moveTo(target_x, target_y, duration=duration, tween=pyautogui.easeInOutQuad)
    
    # Kleine Pause vor dem Klick (der Mensch klickt nicht sofort)
    time.sleep(random.uniform(0.05, 0.15))
    
    # Klick
    element.click()

Wichtig: Diese Methode funktioniert nur, wenn Selenium ein echtes Browserfenster steuert (nicht headless). Für den Headless-Modus ist die Mausbewegung nutzlos, da Anti-Fraud-Systeme den Cursor nicht sehen.

Puppeteer: Nachahmung der Mausbewegung

In Puppeteer kann die Bibliothek ghost-cursor für realistische Cursorbewegungen verwendet werden: 

// Installation: npm install ghost-cursor
const { createCursor } = require("ghost-cursor");
const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch({ headless: false });
  const page = await browser.newPage();
  const cursor = createCursor(page);
  
  await page.goto("https://example.com");
  
  // Sanfte Bewegung zum Element und Klick
  const button = await page.$("#submit-btn");
  await cursor.click(button);  // Der Cursor bewegt sich entlang einer Bézier-Kurve!
  
  // Alternativ – Bewegung zu Koordinaten
  await cursor.move("#username");  // Wir bewegen den Cursor einfach ohne Klick
  await page.waitForTimeout(300);
  await cursor.click();  // Wir klicken an der aktuellen Position
})();

Nachahmung des Scrollens

Menschen scrollen nicht die Seite genau um 500 Pixel auf einmal. Das Scrollen sollte unregelmäßig sein, mit Pausen und manchmal Rückscrollen: 

def scroll_like_human(driver, target_position=None):
    """
    Nachahmung menschlichen Scrollens
    target_position: Zielposition in Pixeln (wenn None – scrollen wir bis zum Ende)
    """
    current_position = driver.execute_script("return window.pageYOffset;")
    
    if target_position is None:
        # Scrollen bis zum Ende der Seite
        target_position = driver.execute_script("return document.body.scrollHeight;")
    
    while current_position < target_position:
        # Zufälliger Scrollschritt (100-400 Pixel)
        scroll_step = random.randint(100, 400)
        current_position += scroll_step
        
        # Scrollen
        driver.execute_script(f"window.scrollTo(0, {current_position});")
        
        # Pause zwischen den Scrolls (der Mensch liest den Inhalt)
        time.sleep(random.uniform(0.3, 1.2))
        
        # Manchmal scrollen wir ein wenig zurück (10% Wahrscheinlichkeit)
        if random.random() < 0.1:
            back_scroll = random.randint(50, 150)
            current_position -= back_scroll
            driver.execute_script(f"window.scrollTo(0, {current_position});")
            time.sleep(random.uniform(0.2, 0.6))

# Verwendung
scroll_like_human(driver, target_position=2000)  # Scrollen bis 2000px

Ladezeiten von Seiten und AJAX-Anfragen

Anti-Fraud-Systeme analysieren nicht nur die Aktionen des Benutzers, sondern auch die Ladecharakteristika von Seiten. Headless-Browser laden oft anormal schnell, da sie Bilder nicht laden, einige Skripte nicht ausführen und CSS nicht rendern.

Problem: Zu schnelles Laden

Vergleichen Sie die typischen Werte der Performance API für einen normalen Browser und headless:

Metrik Normaler Browser Headless (verdächtig)
domContentLoaded 800-2000 ms 50-200 ms
loadEventEnd 2000-5000 ms 100-500 ms
Anzahl der geladenen Ressourcen 50-200 (Bilder, CSS, JS) 5-20 (nur kritische)

Lösung: Künstliche Ladeverzögerung

Fügen Sie eine künstliche Verzögerung nach dem Laden der Seite hinzu, damit die Metriken natürlicher aussehen: 

def load_page_naturally(driver, url):
    """Laden der Seite mit Nachahmung einer natürlichen Ladezeit"""
    start_time = time.time()
    driver.get(url)
    
    # Warten auf das vollständige Laden des DOM
    WebDriverWait(driver, 10).until(
        lambda d: d.execute_script("return document.readyState") == "complete"
    )
    
    # Berechnen der tatsächlichen Ladezeit
    actual_load_time = time.time() - start_time
    
    # Wenn das Laden zu schnell war (< 1 Sek.), fügen Sie eine Verzögerung hinzu
    if actual_load_time < 1.0:
        additional_delay = random.uniform(1.0, 2.5) - actual_load_time
        time.sleep(additional_delay)
    
    # Zusätzliche Verzögerung für "Seitenlesen"
    time.sleep(random.uniform(0.5, 2.0))

# Verwendung
load_page_naturally(driver, "https://example.com")

Warten auf AJAX-Anfragen

Moderne Websites laden Inhalte asynchron über AJAX. Wenn Ihr Skript beginnt zu handeln, bevor alle AJAX-Anfragen abgeschlossen sind – ist das verdächtig. Verwenden Sie explizite Wartezeiten: 

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def wait_for_ajax(driver, timeout=10):
    """Warten auf den Abschluss aller AJAX-Anfragen (jQuery)"""
    WebDriverWait(driver, timeout).until(
        lambda d: d.execute_script("return jQuery.active == 0")
    )

# Für Websites ohne jQuery – Warten auf ein bestimmtes Element
def wait_for_dynamic_content(driver, selector, timeout=10):
    """Warten auf das Erscheinen eines dynamisch geladenen Elements"""
    WebDriverWait(driver, timeout).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, selector))
    )
    # Zusätzliche Verzögerung nach dem Erscheinen des Elements
    time.sleep(random.uniform(0.3, 0.8))

Einstellungen zum Schutz in Anti-Detect-Browsern

Wenn Sie mit Arbitrage, Multi-Accounting oder anderen Aufgaben arbeiten, bei denen Anonymität entscheidend ist, verwenden Sie Anti-Detect-Browser: Dolphin Anty, AdsPower, Multilogin, GoLogin. Sie verfügen über integrierte Schutzmechanismen gegen Timing-Angriffe, müssen jedoch richtig konfiguriert werden.

Dolphin Anty: Einstellung der menschlichen Eingabe

In Dolphin Anty gibt es die Funktion "Human Typing" – automatische Nachahmung der menschlichen Texteingabe. Einstellungen:

  • Öffnen Sie das Browserprofil → Registerkarte "Automation"
  • Aktivieren Sie "Human Typing Emulation"
  • Konfigurieren Sie die Parameter:
    • Durchschnittliche Tippgeschwindigkeit: 150-250 Zeichen/Minute (realistische Geschwindigkeit)
    • Variation: 30-50% (Schwankungen der Geschwindigkeit zwischen den Zeichen)
    • Pausen bei Satzzeichen: aktiviert (Pausen bei Satzzeichen)
    • Zufällige Tippfehler: 2-5% (zufällige Tippfehler mit Korrektur)

Danach wird jede Texteingabe über die API von Dolphin automatisch einen Menschen nachahmen.

AdsPower: Einstellung der Mausbewegung

AdsPower ermöglicht es, die Bewegungsmuster eines echten Benutzers aufzuzeichnen und wiederzugeben:

  1. Öffnen Sie das Profil → "Erweiterte Einstellungen" → "Mausverhalten"
  2. Wählen Sie den Modus "Real User aufzeichnen":
    • Öffnen Sie den Browser im normalen Modus
    • Führen Sie typische Aktionen aus (Klicks, Scrollen, Mausbewegungen)
    • AdsPower wird die Bewegungsbahnen aufzeichnen
  3. Bei der Automatisierung über die API wird AdsPower die aufgezeichneten Muster mit Variationen wiedergeben

Multilogin: Canvas Noise und WebGL Timing

Multilogin fügt Rauschen (noise) in Canvas- und WebGL-Fingerabdrücke ein, was sich auf Timing-Angriffe auswirkt, die mit dem Rendering verbunden sind:

  • Profil → "Fingerprint-Einstellungen" → "Canvas"
  • Aktivieren Sie "Canvas Noise" (fügt Mikrozögerungen beim Rendern von Canvas hinzu)
  • Aktivieren Sie "WebGL Metadata Masking" (maskiert GPU-Eigenschaften, die die Rendergeschwindigkeit beeinflussen)

Dies schützt vor der Erkennung durch die Analyse der Ausführungszeit von Canvas.toDataURL() und WebGL-Operationen.

Empfehlung: Wenn Sie mit Multi-Accounting auf Facebook, Instagram oder TikTok arbeiten, verwenden Sie unbedingt Anti-Detect-Browser in Kombination mit hochwertigen residential Proxys – das minimiert das Risiko von Chain-Bans und Erkennung durch IP.

Fortgeschrittene Techniken zur Umgehung der Timing-Erkennung

Für besonders geschützte Plattformen (Google, Facebook, Bankwebsites) sind grundlegende Methoden möglicherweise nicht ausreichend. Lassen Sie uns fortgeschrittene Techniken betrachten.

1. Umgehung der Performance API

Sie können die Methoden der Performance API überschreiben, um realistische Werte anstelle der tatsächlichen zurückzugeben: 

// Skriptinjektion zur Umgehung von performance.now()
const script = `
  (function() {
    const originalNow = performance.now.bind(performance);
    let offset = 0;
    let lastValue = 0;
    
    performance.now = function() {
      const realValue = originalNow();
      // Fügen Sie zufälligen Rauschen zur Zeit hinzu
      const noise = Math.random() * 2 - 1; // von -1 bis +1 ms
      let fakeValue = realValue + offset + noise;
      
      // Gewährleistung der Monotonie (Zeit läuft nicht zurück)
      if (fakeValue <= lastValue) {
        fakeValue = lastValue + 0.1;
      }
      
      lastValue = fakeValue;
      return fakeValue;
    };
  })();
`;

// Puppeteer: Injektion beim Erstellen der Seite
await page.evaluateOnNewDocument(script);

Achtung: Diese Methode kann durch die Überprüfung der Integrität nativer Methoden erkannt werden. Verwenden Sie sie nur auf Websites ohne starken Schutz.

2. Drosselung von CPU und Netzwerk

Das Chrome DevTools-Protokoll ermöglicht es, CPU und Netzwerk künstlich zu verlangsamen, damit die Ladezeiten natürlicher aussehen: 

// Puppeteer: Verlangsamung der CPU um das Zweifache
const client = await page.target().createCDPSession();
await client.send('Emulation.setCPUThrottlingRate', { rate: 2 });

// Verlangsamung des Netzwerks (Emulation von 3G)
await page.emulateNetworkConditions({
  offline: false,
  downloadThroughput: 1.5 * 1024 * 1024 / 8, // 1.5 Mbps
  uploadThroughput: 750 * 1024 / 8,          // 750 Kbps
  latency: 40                                 // 40ms Verzögerung
});

Dies erhöht die Ladezeiten von Seiten und die Ausführung von JavaScript und macht das Profil ähnlicher zu einem echten Benutzer mit durchschnittlicher Internetgeschwindigkeit.

3. Nachahmung von Hintergrundaktivitäten

Echte Benutzer bleiben nicht auf einem Tab – sie wechseln zwischen Tabs, minimieren Fenster, lassen sich ablenken. Imitieren Sie dies: 

async function simulateTabSwitch(page) {
  // Emulieren des Wechsels zu einem anderen Tab (Page Visibility API)
  await page.evaluate(() => {
    Object.defineProperty(document, 'hidden', {
      get: () => true,
      configurable: true
    });
    
    document.dispatchEvent(new Event('visibilitychange'));
  });
  
  // Pause (Benutzer sieht sich einen anderen Tab an)
  await page.waitForTimeout(Math.random() * 3000 + 2000);
  
  // Zurück zum Tab wechseln
  await page.evaluate(() => {
    Object.defineProperty(document, 'hidden', {
      get: () => false,
      configurable: true
    });
    
    document.dispatchEvent(new Event('visibilitychange'));
  });
}

// Verwendung: zufällig während der Arbeit "ablenken"
if (Math.random() < 0.15) {  // 15% Wahrscheinlichkeit
  await simulateTabSwitch(page);
}

4. Verwendung realer User Timing Marks

Einige Websites erstellen ihre eigenen Zeitmarken über die User Timing API. Fügen Sie realistische Marken hinzu: 

// Erstellen realistischer Timing-Marken
await page.evaluate(() => {
  // Nachahmung des "Denkens" des Benutzers vor einer Aktion
  performance.mark('user-started-reading');
  
  setTimeout(() => {
    performance.mark('user-found-button');
    performance.measure('reading-time', 'user-started-reading', 'user-found-button');
  }, Math.random() * 2000 + 1000);
});

5. Rotation von Proxys zur Verringerung der statistischen Korrelation

Selbst wenn jede Instanz Ihres Skripts randomisierte Verzögerungen hat, können Anti-Fraud-Systeme Korrelationen erkennen, wenn alle Anfragen von einer IP kommen. Verwenden Sie die Rotation von Proxys:

  • Für Parsing- und Massenaufgaben: Datacenter-Proxys mit automatischer Rotation alle 5-10 Minuten
  • Für die Arbeit mit sozialen Netzwerken und Werbung: residential Proxys mit Sitzungsbindung (sticky sessions)
  • Für mobile Plattformen (Instagram, TikTok): Mobile Proxys mit Rotation nach Timer oder auf Anfrage

Die Rotation von IPs verringert die Wahrscheinlichkeit, dass das Anti-Fraud-System genügend Daten für die statistische Analyse Ihrer Timing-Muster sammeln kann.

Fazit

Timing-Angriffe sind eine komplexe Methode zur Erkennung von Automatisierung, die einen umfassenden Schutzansatz erfordert. Die wichtigsten Erkenntnisse:

  • Verwenden Sie keine festen Verzögerungen – randomisieren Sie immer die Zeit zwischen den Aktionen unter Verwendung einer Normalverteilung
  • Nachahmung kontextueller Verzögerungen – verschiedene Aktionen erfordern unterschiedliche Zeiten (Seiten lesen ≠ auf einen Button klicken)
  • Fügen Sie Variabilität in die Reihenfolge der Aktionen ein – zufällige Scrolls, Klicks, Tabwechsel
  • Verwenden Sie sanfte Mausbewegungen – Bibliotheken wie ghost-cursor (Puppeteer) oder pyautogui (Selenium)
  • Nachahmung der natürlichen Tippgeschwindigkeit – zeichenweise Eingabe mit Pausen bei Satzzeichen
  • Konfigurieren Sie Anti-Detect-Browser – Dolphin Anty, AdsPower und Multilogin haben integrierte Schutzmechanismen gegen Timing-Angriffe
  • Kombinieren Sie mit hochwertigen Proxys – die Rotation von IPs verringert die Möglichkeit statistischer Analysen

Denken Sie daran: Es gibt keinen perfekten Schutz. Anti-Fraud-Systeme entwickeln sich ständig weiter und fügen neue Erkennungsmethoden hinzu. Ihre Aufgabe ist es, das Verhalten des Skripts so nah wie möglich an einem echten Benutzer zu halten und die Umgehungsmethoden regelmäßig zu aktualisieren.

Wenn Sie mit der Automatisierung von Browsern für Parsing, Tests oder andere Aufgaben arbeiten, empfehlen wir die Verwendung von residential Proxys – sie bieten das höchste Maß an Anonymität und minimieren das Risiko der Erkennung durch die IP-Adresse. Für mobile Plattformen sind mobile Proxys besser geeignet, die echte Benutzer von Mobilfunkanbietern nachahmen.

```