Zamanlama Saldırılarıyla Otomasyon Tespiti Nasıl Önlenir: Selenium ve Puppeteer ile Koruma

Zamanlama saldırıları, tarayıcıda kullanıcı eylemlerinin yürütülme sürelerini analiz eden bir bot tespit yöntemidir. Facebook, Google, TikTok ve diğer platformların modern dolandırıcılık önleme sistemleri, yalnızca ne yaptığınızı değil, ne kadar hızlı yaptığınızı da analiz eder. Çok hızlı tıklamalar, anlık sayfa yüklemeleri, doğal durakların olmaması — bunların hepsi otomasyonu ortaya çıkarır. Bu yazıda, Selenium, Puppeteer ve anti-detect tarayıcılarla çalışan geliştiriciler için zamanlama saldırılarına karşı koruma tekniklerini inceleyeceğiz.

Zamanlama saldırıları nedir ve nasıl çalışır

Zamanlama saldırısı, kullanıcı eylemleri arasındaki zaman aralıklarını ölçmeye dayanan bir otomasyon tespit yöntemidir. Dolandırıcılık önleme sistemleri, sayfa yüklemesinden ilk tıklamaya kadar geçen süreyi, kullanıcının ne kadar hızlı kaydırdığını, form doldururken duraklamaların olup olmadığını toplar. Bu veriler, gerçek insanların davranış modelleriyle karşılaştırılır.

Koruma sistemlerinin analiz ettiği temel zaman metrikleri:

• İlk Etkileşim Süresi (TTFI) — sayfa yüklemesinden ilk eyleme (tıklama, kaydırma, metin girişi) kadar geçen süre. Botlar genellikle DOM yüklendikten hemen sonra harekete geçer, insanlar ise 0.5-3 saniye sonra.
• Tıklama zamanlama kalıpları — tıklamalar arasındaki aralıklar. Otomatikleştirilmiş betikler genellikle aynı sıklıkta tıklar (örneğin, tam olarak her 2 saniyede bir), insanlar ise rastgele.
• Yazma hızı tutarlılığı — metin yazma hızı. Botlar metni anında veya karakterler arasında sabit bir gecikme ile girer, insanlar ise değişken hız ve duraklamalarla.
• Fare hareket hızı — imlecin hareket hızı. Selenium varsayılan olarak imleci gerekli noktaya anında taşır, insanlar ise fareyi hızlanma ve yavaşlama ile hareket ettirir.
• Kaydırma davranışı — sayfa kaydırma kalıpları. Botlar genellikle tam olarak sabit bir piksel sayısı kadar kaydırır, insanlar ise düzensiz, duraklamalarla kaydırır.

Tespit sistemleri, bu metrikleri analiz etmek için makine öğrenimini kullanır. Davranış profili oluşturur ve kullanıcının bir bot olma olasılığını hesaplar. Eğer zamanlama kalıpları çok mükemmel veya çok hızlıysa — bu bir kırmızı bayraktır.

Zamansal kalıplar aracılığıyla otomasyon tespit yöntemleri

Modern dolandırıcılık önleme sistemleri, zamanlama özelliklerinin analizinde birkaç katman kullanır. Facebook, Google, Cloudflare ve diğer platformların uyguladığı belirli teknikleri inceleyelim.

1. Performans API Analizi

Tarayıcılar, sayfa yükleme ile ilgili ayrıntılı telemetri toplayan Performans API'si sunar. Dolandırıcılık önleme sistemleri şunları analiz eder:

// Performans API verileri örneği
performance.timing = {
  navigationStart: 1234567890000,
  domLoading: 1234567890150,      // +150ms
  domInteractive: 1234567890300,  // +300ms
  domComplete: 1234567890500,     // +500ms
  loadEventEnd: 1234567890600     // +600ms
}

// Botlar için şüpheli kalıplar:
// - Çok hızlı yükleme (domComplete < 200ms)
// - Olaylar arasındaki mükemmel aralıklar
// - Dış kaynakların yüklenmesi sırasında gecikme olmaması

Headless tarayıcılar (özellikle eski Puppeteer ve Selenium sürümleri) genellikle anormal derecede hızlı navigationStart ve domLoading değerleri gösterir, çünkü görüntüleri, yazı tiplerini ve diğer kaynakları normal bir tarayıcı gibi yüklemezler.

2. Olay Zamanlama Analizi

JavaScript izleyicileri, tüm olayların zaman damgalarını (tıklamalar, fare hareketleri, tuş vuruşları) takip eder ve kalıpları analiz eder:

// Olay telemetrisinin toplanması örneği
const events = [];

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

// Şüpheli kalıpların analizi:
// - Tıklamalar tam olarak her N milisaniyede gerçekleşiyor
// - Tıklama öncesinde farede mikromovements yok
// - İlk tıklama sayfa yüklendikten hemen sonra gerçekleşiyor

3. Tuş Vuruşu Dinamikleri

Form doldururken, dolandırıcılık önleme sistemleri tuş vuruşlarının dinamiklerini analiz eder — her bireyin benzersiz biyometrik göstergesi:

• Bekleme süresi — tuşun basılı kalma süresi (keydown'dan keyup'a kadar). İnsanlarda 50 ile 200 ms arasında değişir, botlarda ise sabittir.
• Uçuş süresi — bir tuşun bırakılması ile bir sonraki tuşa basılması arasındaki süre. İnsanlarda 100 ile 500 ms arasında değişir, botlarda ise sabit bir gecikme vardır.
• Yazma ritmi — genel yazma ritmi. İnsanlar noktalama işaretlerinde duraklar, hataları düzeltir, botlar ise bunu yapmaz.

Kodu insan benzeri gecikmelerle taklit etme

Zamanlama saldırılarına karşı ilk koruma seviyesi, eylemler arasında gecikmeler eklemektir. Ancak önemli olan sadece time.sleep(2) eklemek değil, doğal davranışı taklit etmektir.

Python'da (Selenium) temel gecikme taklidi

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):
    """İnsanı taklit eden rastgele gecikme"""
    delay = random.uniform(min_sec, max_sec)
    time.sleep(delay)

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

# İlk eylemden önce gecikme (insan sayfayı okur)
human_delay(1.5, 4.0)

# Eleman üzerinde tıklama
button = driver.find_element(By.ID, "submit-btn")
button.click()

# Sonraki eylemden önce gecikme
human_delay(0.8, 2.5)

Normal dağılım ile gelişmiş taklit

Eşit dağılım (uniform) doğal görünmez. İnsan gecikmeleri, uç değerlerle normal dağılıma tabidir:

import numpy as np

def realistic_delay(mean=1.5, std_dev=0.5, min_val=0.3, max_val=5.0):
    """
    Normal dağılım ile gecikme
    mean: ortalama gecikme süresi
    std_dev: standart sapma
    min_val, max_val: sınırlar (uç değerleri önlemek için)
    """
    delay = np.random.normal(mean, std_dev)
    delay = max(min_val, min(max_val, delay))  # Aralığı sınırlıyoruz
    time.sleep(delay)
    return delay

# Kullanım
realistic_delay(mean=2.0, std_dev=0.7)  # Ortalama 2 sn, ama varyasyonlarla

Bağlam gecikmeleri

Farklı eylemler farklı süreler gerektirir. Farklı senaryolar için gecikme profilleri oluşturun:

class HumanBehavior:
    """Farklı eylem türleri için gecikme profilleri"""
    
    @staticmethod
    def page_load_delay():
        """Sayfa yüklendikten sonraki gecikme (içeriği okuma)"""
        return realistic_delay(mean=2.5, std_dev=1.0, min_val=1.0, max_val=6.0)
    
    @staticmethod
    def before_click():
        """Tıklamadan önceki gecikme (gözle elemanı arama)"""
        return realistic_delay(mean=0.8, std_dev=0.3, min_val=0.3, max_val=2.0)
    
    @staticmethod
    def before_typing():
        """Metin girişi öncesi gecikme"""
        return realistic_delay(mean=1.2, std_dev=0.5, min_val=0.5, max_val=3.0)
    
    @staticmethod
    def between_form_fields():
        """Form alanları arasında gecikme"""
        return realistic_delay(mean=0.6, std_dev=0.2, min_val=0.2, max_val=1.5)

# Betikte kullanım
driver.get("https://example.com/login")
HumanBehavior.page_load_delay()

username_field = driver.find_element(By.ID, "username")
HumanBehavior.before_typing()
# ... kullanıcı adını girme ...

HumanBehavior.between_form_fields()

password_field = driver.find_element(By.ID, "password")
HumanBehavior.before_typing()
# ... şifreyi girme ...

Eylemlerin yürütülme süresinin rastgeleleştirilmesi

Eylemler arasındaki aynı gecikmeler, istatistiksel bir anormalliktir. Eğer 100 betik örneğini çalıştırıyorsanız ve hepsi sayfa yüklendikten sonra tam olarak 2.5 saniye sonra tıklıyorsa — bu kolayca tespit edilir. Birkaç seviyede rastgeleleştirme gereklidir.

1. Eylem sırasının rastgeleleştirilmesi

Eylem sırasına değişkenlik ekleyin. Örneğin, form doldurmadan önce bazen sayfayı kaydırın, bazen kaydırmayın:

def fill_form_naturally(driver):
    # Form doldurmadan önce sayfayı kaydırma olasılığı %30
    if random.random() < 0.3:
        driver.execute_script("window.scrollBy(0, 200)")
        human_delay(0.5, 1.5)
    
    # Rastgele bir yere tıklama olasılığı %20 (okuma taklidi)
    if random.random() < 0.2:
        body = driver.find_element(By.TAG_NAME, "body")
        body.click()
        human_delay(0.3, 0.8)
    
    # Ana eylem — form doldurma
    username_field = driver.find_element(By.ID, "username")
    type_like_human(username_field, "myusername")

2. Yazma hızında değişkenlik

Anında metin girişi yerine, değişken hızda karakter karakter yazmayı taklit edin:

def type_like_human(element, text):
    """İnsan yazma hızını taklit ederek metin girişi"""
    for char in text:
        element.send_keys(char)
        
        # Karakterler arasındaki temel gecikme
        base_delay = random.uniform(0.05, 0.15)
        
        # Boşluk ve noktalama işaretlerinde ek duraklamalar
        if char in [' ', '.', ',', '!', '?']:
            base_delay += random.uniform(0.1, 0.3)
        
        # Rastgele "düşünme" anları (uzun bir duraklama için %5 olasılık)
        if random.random() < 0.05:
            base_delay += random.uniform(0.5, 1.5)
        
        time.sleep(base_delay)
    
    # Bazen yazım hatası yapıyoruz ve düzeltiyoruz (yüzde 10 olasılık)
    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])  # Son karakteri yeniden giriyoruz

3. Puppeteer: yavaş metin girişi

Puppeteer'de delay seçeneği, type() yöntemi için mevcuttur, ancak bunu rastgeleleştirmek gerekir:

// Temel kullanım (TAVSİYE EDİLMİYOR — sabit gecikme)
await page.type('#username', 'myusername', { delay: 100 });

// Doğru yaklaşım — her karakter için rastgeleleştirme
async function typeWithVariableSpeed(page, selector, text) {
  await page.click(selector);
  
  for (const char of text) {
    await page.keyboard.type(char);
    
    // 50 ile 150 ms arasında rastgele gecikme
    let delay = Math.random() * 100 + 50;
    
    // Boşluklarda ek duraklama
    if (char === ' ') {
      delay += Math.random() * 200 + 100;
    }
    
    // Rastgele uzun duraklamalar (yüzde 5 olasılık)
    if (Math.random() < 0.05) {
      delay += Math.random() * 1000 + 500;
    }
    
    await page.waitForTimeout(delay);
  }
}

// Kullanım
await typeWithVariableSpeed(page, '#username', 'myusername');

Doğal fare hareketi ve kaydırma hızı

Selenium ve Puppeteer varsayılan olarak fare imlecini hareket ettirmez — imleci anında gerekli noktaya taşır ve tıklar. Bu, otomasyonun en belirgin işaretlerinden biridir. İnsan fare hareketini taklit etmek için özel kütüphanelere ihtiyaç vardır.

Fare hareketi için pyautogui kütüphanesi

pyautogui kütüphanesi, imleci Bezier eğrisi boyunca hızlanma ve yavaşlama ile hareket ettirmenizi sağlar:

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

def move_mouse_naturally(driver, element):
    """İnsanı taklit ederek eleman üzerine yumuşak hareket"""
    # Elemanın koordinatlarını al
    location = element.location
    size = element.size
    
    # Hedef nokta (elemanın merkezi + küçük bir rastgelelik)
    target_x = location['x'] + size['width'] / 2 + random.randint(-5, 5)
    target_y = location['y'] + size['height'] / 2 + random.randint(-5, 5)
    
    # Değişken hızla yumuşak hareket
    # duration — hareket süresi (gerçekçilik için 0.5-1.5 sn)
    duration = random.uniform(0.5, 1.5)
    
    # tweening — hızlandırma fonksiyonu (easeInOutQuad insan hareketini taklit eder)
    pyautogui.moveTo(target_x, target_y, duration=duration, tween=pyautogui.easeInOutQuad)
    
    # Tıklamadan önce küçük bir duraklama (insan anında tıklamaz)
    time.sleep(random.uniform(0.05, 0.15))
    
    # Tıklama
    element.click()

Önemli: Bu yöntem yalnızca Selenium gerçek bir tarayıcı penceresini yönetiyorsa çalışır (headless değil). Headless modda fare hareketi gereksizdir, çünkü dolandırıcılık önleme sistemleri imleci göremez.

Puppeteer: fare hareketini taklit etme

Puppeteer'de, gerçekçi imleç hareketi için ghost-cursor kütüphanesini kullanabilirsiniz:

// Kurulum: 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");
  
  // Eleman üzerine yumuşak hareket ve tıklama
  const button = await page.$("#submit-btn");
  await cursor.click(button);  // İmleç Bezier eğrisi boyunca hareket eder!
  
  // Alternatif olarak — koordinatlara hareket
  await cursor.move("#username");  // Tıklamadan imleci hareket ettiriyoruz
  await page.waitForTimeout(300);
  await cursor.click();  // Mevcut konumda tıklıyoruz
})();

Kaydırma taklidi

İnsan bir sayfayı tam olarak 500 piksel kaydırmaz. Kaydırma düzensiz olmalı, duraklamalarla ve bazen geriye kaydırma ile:

def scroll_like_human(driver, target_position=None):
    """
    İnsanı taklit eden kaydırma
    target_position: piksel cinsinden hedef konum (None ise — sayfanın sonuna kadar kaydır)
    """
    current_position = driver.execute_script("return window.pageYOffset;")
    
    if target_position is None:
        # Sayfanın sonuna kadar kaydır
        target_position = driver.execute_script("return document.body.scrollHeight;")
    
    while current_position < target_position:
        # Rastgele kaydırma adımı (100-400 piksel)
        scroll_step = random.randint(100, 400)
        current_position += scroll_step
        
        # Kaydırma
        driver.execute_script(f"window.scrollTo(0, {current_position});")
        
        # Kaydırmalar arasındaki duraklama (insan içeriği okur)
        time.sleep(random.uniform(0.3, 1.2))
        
        # Bazen biraz geri kaydırıyoruz (yüzde 10 olasılık)
        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))

# Kullanım
scroll_like_human(driver, target_position=2000)  # 2000px'e kadar kaydır

Sayfa yükleme süreleri ve AJAX istekleri

Dolandırıcılık önleme sistemleri yalnızca kullanıcı eylemlerini değil, aynı zamanda sayfa yükleme özelliklerini de analiz eder. Headless tarayıcılar genellikle anormal derecede hızlı yüklenir, çünkü görüntüleri yüklemez, bazı betikleri çalıştırmaz, CSS'yi render etmez.

Sorun: çok hızlı yükleme

Normal bir tarayıcı ve headless için Performans API'sinin tipik değerlerini karşılaştırın:

Çözüm: yükleme süresini zorla geciktirme

Sayfa yüklendikten sonra yapay bir gecikme ekleyin, böylece metrikler daha doğal görünür:

def load_page_naturally(driver, url):
    """Doğal yükleme süresi taklidi ile sayfa yükleme"""
    start_time = time.time()
    driver.get(url)
    
    # DOM'un tamamen yüklenmesini bekleyin
    WebDriverWait(driver, 10).until(
        lambda d: d.execute_script("return document.readyState") == "complete"
    )
    
    # Gerçek yükleme süresini hesapla
    actual_load_time = time.time() - start_time
    
    # Eğer yükleme çok hızlıysa (< 1 sn), gecikme ekleyin
    if actual_load_time < 1.0:
        additional_delay = random.uniform(1.0, 2.5) - actual_load_time
        time.sleep(additional_delay)
    
    # "Sayfayı okuma" için ek gecikme
    time.sleep(random.uniform(0.5, 2.0))

# Kullanım
load_page_naturally(driver, "https://example.com")

AJAX isteklerini bekleme

Modern web siteleri içeriği asenkron olarak AJAX ile yükler. Eğer betiğiniz tüm AJAX istekleri tamamlanmadan harekete geçerse — bu şüphelidir. Açık beklemeler kullanın:

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

def wait_for_ajax(driver, timeout=10):
    """Tüm AJAX isteklerinin tamamlanmasını bekleme (jQuery)"""
    WebDriverWait(driver, timeout).until(
        lambda d: d.execute_script("return jQuery.active == 0")
    )

# jQuery olmayan siteler için — belirli bir elemanı bekleme
def wait_for_dynamic_content(driver, selector, timeout=10):
    """Dinamik olarak yüklenen elemanın görünmesini bekleme"""
    WebDriverWait(driver, timeout).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, selector))
    )
    # Eleman göründükten sonra ek gecikme
    time.sleep(random.uniform(0.3, 0.8))

Anti-detect tarayıcılarda koruma ayarları

Eğer arbitraj, çoklu hesap yönetimi veya anonimliğin kritik olduğu diğer görevlerle çalışıyorsanız, Dolphin Anty, AdsPower, Multilogin, GoLogin gibi anti-detect tarayıcıları kullanın. Bu tarayıcılar, zamanlama saldırılarına karşı yerleşik koruma mekanizmalarına sahiptir, ancak bunları doğru bir şekilde ayarlamak gerekir.

Dolphin Anty: İnsan Yazımı ayarları

Dolphin Anty'de "İnsan Yazımı" özelliği vardır — otomatik olarak insan yazımını taklit eder. Ayarlar:

• Tarayıcı profilini açın → "Otomasyon" sekmesi
• "İnsan Yazımı Taklidi" seçeneğini etkinleştirin
• Ayarları yapılandırın:
  • Ortalama yazma hızı: 150-250 karakter/dakika (gerçekçi hız)
  • Varyasyon: %30-50 (karakterler arasındaki hızda değişkenlik)
  • Noktalama işaretlerinde duraklama: etkin (noktalama işaretlerinde duraklamalar)
  • Rastgele yazım hataları: %2-5 (rastgele yazım hataları ve düzeltmeler)

Bunun ardından, Dolphin API'si aracılığıyla yapılan her metin girişi otomatik olarak insanı taklit edecektir.

AdsPower: Fare Hareketi ayarları

AdsPower, gerçek bir kullanıcının fare hareketlerini kaydetmenize ve bunları yeniden oynatmanıza olanak tanır:

1. Profilinizi açın → "Gelişmiş Ayarlar" → "Fare Davranışı"
2. "Gerçek Kullanıcıyı Kaydet" modunu seçin:
   • Tarayıcıyı normal modda açın
   • Tipik eylemleri gerçekleştirin (tıklamalar, kaydırmalar, fare hareketleri)
   • AdsPower hareket yollarını kaydedecektir
3. API aracılığıyla otomasyon yaparken, AdsPower kaydedilen kalıpları varyasyonlarla yeniden oynatacaktır

Multilogin: Canvas Gürültüsü ve WebGL Zamanlaması

Multilogin, Canvas ve WebGL parmak izlerine gürültü (noise) ekler, bu da render ile ilgili zamanlama saldırılarını etkiler:

• Profil → "Parmak izi ayarları" → "Canvas"
• "Canvas Gürültüsü" seçeneğini etkinleştirin (Canvas renderine mikro gecikmeler ekler)
• "WebGL Metadata Masking" seçeneğini etkinleştirin (GPU özelliklerini maskeleyerek render hızını etkiler)

Bu, Canvas.toDataURL() ve WebGL işlemleri üzerinden zamanlama analizi ile tespiti engeller.

Zamanlama tespitini aşmanın ileri teknikleri

Özellikle korunan platformlar (Google, Facebook, bankacılık siteleri) için temel yöntemler yetersiz olabilir. İleri teknikleri inceleyelim.

1. Performans API'sini değiştirme

Performans API'sinin yöntemlerini yeniden tanımlayarak gerçek değerler yerine gerçekçi değerler döndürebilirsiniz:

// performance.now() değiştirmek için script enjekte etme
const script = `
  (function() {
    const originalNow = performance.now.bind(performance);
    let offset = 0;
    let lastValue = 0;
    
    performance.now = function() {
      const realValue = originalNow();
      // Zamanın üzerine rastgele gürültü ekliyoruz
      const noise = Math.random() * 2 - 1; // -1 ile +1 ms arasında
      let fakeValue = realValue + offset + noise;
      
      // Monotonluğu sağla (zaman geri gitmesin)
      if (fakeValue <= lastValue) {
        fakeValue = lastValue + 0.1;
      }
      
      lastValue = fakeValue;
      return fakeValue;
    };
  })();
`;

// Puppeteer: sayfa oluşturulurken enjekte etme
await page.evaluateOnNewDocument(script);

Dikkat: Bu yöntem, yerel yöntemlerin bütünlüğünü kontrol ederek tespit edilebilir. Sadece güçlü koruma olmayan sitelerde kullanın.

2. CPU ve Ağ Yavaşlatma

Chrome DevTools Protokolü, yükleme metriklerinin daha doğal görünmesi için CPU ve ağı yapay olarak yavaşlatmanıza olanak tanır:

// Puppeteer: CPU'yu 2 kat yavaşlatma
const client = await page.target().createCDPSession();
await client.send('Emulation.setCPUThrottlingRate', { rate: 2 });

// Ağı yavaşlatma (3G emülasyonu)
await page.emulateNetworkConditions({
  offline: false,
  downloadThroughput: 1.5 * 1024 * 1024 / 8, // 1.5 Mbps
  uploadThroughput: 750 * 1024 / 8,          // 750 Kbps
  latency: 40                                 // 40ms gecikme
});

Bu, sayfaların yüklenme süresini ve JavaScript'in yürütülme süresini artırarak profilin gerçek bir kullanıcının ortalama internet hızıyla daha benzer hale gelmesini sağlar.

3. Arka Plan Aktivitesini Taklit Etme

Gerçek kullanıcılar bir sekmede oturmaz — sekmeler arasında geçiş yapar, pencereleri küçültür, dikkati dağılır. Bunu taklit edin:

async function simulateTabSwitch(page) {
  // Diğer bir sekmeye geçişi taklit etme (Sayfa Görünürlük API'si)
  await page.evaluate(() => {
    Object.defineProperty(document, 'hidden', {
      get: () => true,
      configurable: true
    });
    
    document.dispatchEvent(new Event('visibilitychange'));
  });
  
  // Duraklama (kullanıcı diğer sekmeye bakıyor)
  await page.waitForTimeout(Math.random() * 3000 + 2000);
  
  // Sekmeye geri dön
  await page.evaluate(() => {
    Object.defineProperty(document, 'hidden', {
      get: () => false,
      configurable: true
    });
    
    document.dispatchEvent(new Event('visibilitychange'));
  });
}

// Kullanım: çalışma sırasında rastgele "dikkatimizi dağıtıyoruz"
if (Math.random() < 0.15) {  // %15 olasılık
  await simulateTabSwitch(page);
}

4. Gerçek Kullanıcı Zamanlama İşaretlerini Kullanma

Bazı siteler, Kullanıcı Zamanlama API'si aracılığıyla kendi zaman damgalarını oluşturur. Gerçekçi zaman damgaları ekleyin:

// Gerçekçi zaman damgaları oluşturma
await page.evaluate(() => {
  // Kullanıcının eylemden önce "düşünmesini" taklit etme
  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. İstatistiksel Korelasyonu Azaltmak için Proxy Döngüsü

Her betik örneğinizin rastgeleleştirilmiş gecikmeleri olsa bile, dolandırıcılık önleme sistemleri, tüm isteklerin tek bir IP'den geldiğini tespit edebilir. Proxy döngüsü kullanın:

• Veri çekme ve kitlesel görevler için: veri merkezi proxy'leri her 5-10 dakikada bir otomatik döngü ile
• Sosyal medya ve reklamlarla çalışmak için: konut proxy'leri oturum bağlantısı ile (sticky sessions)
• Mobil platformlar (Instagram, TikTok) için: mobil proxy'ler zamanlayıcıya veya isteğe bağlı döngü ile

IP döngüsü, dolandırıcılık önleme sisteminin zamanlama kalıplarınızı istatistiksel analiz için yeterince veri toplama olasılığını azaltır.

Sonuç

Zamanlama saldırıları, otomasyonu tespit etmenin karmaşık bir yöntemidir ve koruma için kapsamlı bir yaklaşım gerektirir. Temel çıkarımlar:

• Sabit gecikmeler kullanmayın — her zaman eylemler arasındaki süreyi normal dağılım kullanarak rastgeleleştirin
• Bağlam gecikmelerini taklit edin — farklı eylemler farklı süreler gerektirir (sayfayı okuma ≠ butona tıklama)
• Eylem sırasına değişkenlik ekleyin — rastgele kaydırmalar, tıklamalar, sekme geçişleri
• Yumuşak fare hareketi kullanın — ghost-cursor (Puppeteer) veya pyautogui (Selenium) kütüphaneleri
• Doğal yazma hızını taklit edin — karakter karakter giriş ile noktalama işaretlerinde duraklamalar
• Anti-detect tarayıcıları ayarlayın — Dolphin Anty, AdsPower ve Multilogin, zamanlama saldırılarına karşı yerleşik koruma mekanizmalarına sahiptir
• Kaliteli proxy'lerle birleştirin — IP döngüsü istatistiksel analizi azaltır

Unutmayın: mükemmel bir koruma yoktur. Dolandırıcılık önleme sistemleri sürekli evrim geçirir ve yeni tespit yöntemleri ekler. Göreviniz, betiğin davranışını gerçek bir kullanıcıya mümkün olduğunca yakın hale getirmek ve geçiş yöntemlerini düzenli olarak güncellemektir.

Eğer veri çekme, test etme veya diğer görevler için tarayıcı otomasyonu ile çalışıyorsanız, konut proxy'leri kullanmanızı öneririz — bunlar maksimum anonimlik sağlar ve IP adresi üzerinden tespit riskini en aza indirir. Mobil platformlar için ise mobil proxy'ler daha uygundur, çünkü gerçek mobil operatör kullanıcılarını taklit eder.