टाइमिंग हमले स्वचालन का पता लगाने की एक विधि है, जो ब्राउज़र में उपयोगकर्ता क्रियाओं के निष्पादन के समय के विश्लेषण पर आधारित है। फेसबुक, गूगल, टिकटॉक और अन्य प्लेटफार्मों की आधुनिक एंटी-फ्रॉड प्रणालियाँ केवल यह नहीं देखतीं कि आप क्या कर रहे हैं, बल्कि आप कितनी तेजी से कर रहे हैं। बहुत तेज़ क्लिक, पृष्ठों का तात्कालिक लोड होना, स्वाभाविक विराम का अभाव - ये सभी स्वचालन को उजागर करते हैं। इस लेख में, हम Selenium, Puppeteer और एंटी-डिटेक्ट ब्राउज़रों के साथ काम करने वाले डेवलपर्स के लिए टाइमिंग हमलों से सुरक्षा के तकनीकी तरीकों पर चर्चा करेंगे।
टाइमिंग हमले क्या हैं और ये कैसे काम करते हैं
टाइमिंग हमला स्वचालन का पता लगाने की एक विधि है, जो उपयोगकर्ता क्रियाओं के बीच के समय अंतराल को मापने पर आधारित है। एंटी-फ्रॉड प्रणालियाँ टेलीमेट्री एकत्र करती हैं: पृष्ठ लोड होने से पहले क्लिक करने तक कितना समय बीता, उपयोगकर्ता कितनी तेजी से स्क्रॉल करता है, क्या फॉर्म भरने में विराम हैं। ये डेटा वास्तविक लोगों के व्यवहारात्मक मॉडलों के साथ तुलना की जाती हैं।
मुख्य समय मेट्रिक्स, जिनका विश्लेषण सुरक्षा प्रणालियाँ करती हैं:
- Time to First Interaction (TTFI) - पृष्ठ लोड होने से पहले पहले क्रिया (क्लिक, स्क्रॉल, टेक्स्ट इनपुट) तक का समय। बॉट आमतौर पर DOM लोड होने के तुरंत बाद कार्य करना शुरू करते हैं, जबकि मानव 0.5-3 सेकंड में कार्य करते हैं।
- Click timing patterns - क्लिकों के बीच के अंतराल। स्वचालित स्क्रिप्ट अक्सर समान आवृत्ति से क्लिक करती हैं (उदाहरण के लिए, हर 2 सेकंड में), जबकि मानव - अनियमित रूप से।
- Typing speed consistency - टेक्स्ट टाइप करने की गति। बॉट टेक्स्ट को तुरंत या अक्षरों के बीच एक स्थिर देरी के साथ टाइप करते हैं, जबकि मानव - परिवर्तनशील गति और विराम के साथ।
- Mouse movement velocity - कर्सर की गति। Selenium डिफ़ॉल्ट रूप से कर्सर को आवश्यक बिंदु पर तुरंत टेलीपोर्ट करता है, जबकि मानव माउस को तेजी और धीमी गति से चलाते हैं।
- Scroll behavior - पृष्ठ स्क्रॉलिंग पैटर्न। बॉट अक्सर ठीक एक निश्चित संख्या में पिक्सल स्क्रॉल करते हैं, जबकि मानव - असमान रूप से, रुकावटों के साथ।
डिटेक्शन सिस्टम इन मेट्रिक्स के विश्लेषण के लिए मशीन लर्निंग का उपयोग करते हैं। वे व्यवहार का प्रोफ़ाइल बनाते हैं और यह गणना करते हैं कि उपयोगकर्ता बॉट है या नहीं। यदि समय पैटर्न बहुत आदर्श या बहुत तेज़ हैं - तो यह एक लाल झंडा है।
महत्वपूर्ण: टाइमिंग हमले विशेष रूप से बड़े पैमाने पर स्वचालन के खिलाफ प्रभावी होते हैं। यदि आप 100 ब्राउज़रों को समान समय पैटर्न के साथ चलाते हैं, तो एंटी-फ्रॉड प्रणाली आसानी से सांख्यिकीय विसंगतियों के माध्यम से उन्हें पहचान लेगी।
टाइमिंग पैटर्न के माध्यम से स्वचालन का पता लगाने के तरीके
आधुनिक एंटी-फ्रॉड प्रणालियाँ समय विशेषताओं के विश्लेषण के लिए कई स्तरों का उपयोग करती हैं। आइए हम फेसबुक, गूगल, क्लाउडफ्लेयर और अन्य प्लेटफार्मों द्वारा उपयोग की जाने वाली विशिष्ट तकनीकों पर चर्चा करते हैं।
1. प्रदर्शन API का विश्लेषण
ब्राउज़र प्रदर्शन API प्रदान करते हैं, जो पृष्ठ लोडिंग की विस्तृत टेलीमेट्री एकत्र करता है। एंटी-फ्रॉड प्रणालियाँ विश्लेषण करती हैं:
// प्रदर्शन API डेटा का उदाहरण
performance.timing = {
navigationStart: 1234567890000,
domLoading: 1234567890150, // +150ms
domInteractive: 1234567890300, // +300ms
domComplete: 1234567890500, // +500ms
loadEventEnd: 1234567890600 // +600ms
}
// बॉट के लिए संदिग्ध पैटर्न:
// - बहुत तेज़ लोडिंग (domComplete < 200ms)
// - घटनाओं के बीच बिल्कुल समान अंतराल
// - बाहरी संसाधनों के लोड होने पर कोई देरी नहींहेडलेस ब्राउज़र (विशेष रूप से पुराने संस्करणों के Puppeteer और Selenium) अक्सर navigationStart और domLoading के असामान्य रूप से तेज़ मान दिखाते हैं, क्योंकि वे चित्र, फ़ॉन्ट और अन्य संसाधनों को सामान्य ब्राउज़र की तरह लोड नहीं करते हैं।
2. इवेंट टाइमिंग विश्लेषण
जावास्क्रिप्ट ट्रैकर्स सभी घटनाओं (क्लिक्स, माउस मूवमेंट, की प्रेस) के टाइमस्टैम्प को ट्रैक करते हैं और पैटर्न का विश्लेषण करते हैं:
// घटनाओं की टेलीमेट्री एकत्र करने का उदाहरण
const events = [];
document.addEventListener('click', (e) => {
events.push({
type: 'click',
timestamp: performance.now(),
x: e.clientX,
y: e.clientY
});
});
// संदिग्ध पैटर्न का विश्लेषण:
// - क्लिक ठीक हर N मिलीसेकंड में होते हैं
// - क्लिक से पहले माउस में कोई माइक्रोमूवमेंट नहीं
// - पहला क्लिक पृष्ठ लोड होने के तुरंत बाद होता है3. कीस्ट्रोक डायनेमिक्स
फॉर्म भरने के दौरान एंटी-फ्रॉड प्रणालियाँ कीस्ट्रोक के डायनेमिक्स का विश्लेषण करती हैं - हर व्यक्ति का एक अनूठा बायोमेट्रिक संकेत:
- Dwell time - कुंजी को दबाए रखने का समय (keydown से keyup तक)। मानव के लिए 50 से 200 मिलीसेकंड के बीच भिन्न होता है, बॉट के लिए - स्थिर।
- Flight time - एक कुंजी को छोड़ने और अगली कुंजी को दबाने के बीच का समय। मानव के लिए - 100 से 500 मिलीसेकंड के बीच भिन्नता के साथ, बॉट के लिए - निश्चित देरी।
- Typing rhythm - टाइपिंग का सामान्य रिदम। मानव विराम चिह्नों पर विराम लेते हैं, गलतियों को सुधारते हैं, बॉट नहीं।
डिटेक्शन का उदाहरण: यदि आप element.send_keys("टेक्स्ट") का उपयोग करते हैं Selenium में, तो पूरा टेक्स्ट 1-2 मिलीसेकंड में टाइप होता है - यह तुरंत स्वचालन को उजागर करता है।
कोड में मानव-जैसी देरी का अनुकरण
टाइमिंग हमलों से सुरक्षा का पहला स्तर - क्रियाओं के बीच देरी जोड़ना। लेकिन यह महत्वपूर्ण है कि केवल time.sleep(2) डालना नहीं है, बल्कि स्वाभाविक व्यवहार का अनुकरण करना है।
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):
"""मनुष्य का अनुकरण करने वाली यादृच्छिक देरी"""
delay = random.uniform(min_sec, max_sec)
time.sleep(delay)
driver = webdriver.Chrome()
driver.get("https://example.com")
# पहले क्रिया से पहले देरी (मनुष्य पृष्ठ पढ़ता है)
human_delay(1.5, 4.0)
# तत्व पर क्लिक करें
button = driver.find_element(By.ID, "submit-btn")
button.click()
# अगले क्रिया से पहले देरी
human_delay(0.8, 2.5)सामान्य वितरण के साथ उन्नत अनुकरण
समान वितरण (uniform) स्वाभाविक नहीं लगता। मानव की देरी सामान्य वितरण के साथ विसंगतियों के अधीन होती है:
import numpy as np
def realistic_delay(mean=1.5, std_dev=0.5, min_val=0.3, max_val=5.0):
"""
सामान्य वितरण के साथ देरी
mean: देरी का औसत समय
std_dev: मानक विचलन
min_val, max_val: सीमाएँ (अत्यधिक मानों से बचने के लिए)
"""
delay = np.random.normal(mean, std_dev)
delay = max(min_val, min(max_val, delay)) # सीमा निर्धारित करें
time.sleep(delay)
return delay
# उपयोग
realistic_delay(mean=2.0, std_dev=0.7) # औसत 2 सेकंड, लेकिन भिन्नताओं के साथसंदर्भ देरी
विभिन्न क्रियाओं के लिए विभिन्न समय की आवश्यकता होती है। विभिन्न परिदृश्यों के लिए देरी के प्रोफाइल बनाएं:
class HumanBehavior:
"""विभिन्न प्रकार की क्रियाओं के लिए देरी के प्रोफाइल"""
@staticmethod
def page_load_delay():
"""पृष्ठ लोड होने के बाद की देरी (सामग्री पढ़ना)"""
return realistic_delay(mean=2.5, std_dev=1.0, min_val=1.0, max_val=6.0)
@staticmethod
def before_click():
"""क्लिक करने से पहले की देरी (आंखों से तत्व को खोजना)"""
return realistic_delay(mean=0.8, std_dev=0.3, min_val=0.3, max_val=2.0)
@staticmethod
def before_typing():
"""टेक्स्ट टाइप करने से पहले की देरी"""
return realistic_delay(mean=1.2, std_dev=0.5, min_val=0.5, max_val=3.0)
@staticmethod
def between_form_fields():
"""फॉर्म के फ़ील्ड के बीच की देरी"""
return realistic_delay(mean=0.6, std_dev=0.2, min_val=0.2, max_val=1.5)
# स्क्रिप्ट में उपयोग
driver.get("https://example.com/login")
HumanBehavior.page_load_delay()
username_field = driver.find_element(By.ID, "username")
HumanBehavior.before_typing()
# ... लॉगिन टाइप करें ...
HumanBehavior.between_form_fields()
password_field = driver.find_element(By.ID, "password")
HumanBehavior.before_typing()
# ... पासवर्ड टाइप करें ...क्रियाओं के निष्पादन के समय का रैंडमाइजेशन
क्रियाओं के बीच समान देरी सांख्यिकीय विसंगति है। यदि आप 100 स्क्रिप्ट के उदाहरण चलाते हैं, और वे सभी लोड होने के बाद ठीक 2.5 सेकंड में क्लिक करते हैं - तो यह आसानी से पता लगाया जा सकता है। कई स्तरों पर रैंडमाइजेशन की आवश्यकता है।
1. क्रियाओं के क्रम का रैंडमाइजेशन
क्रियाओं के अनुक्रम में विविधता जोड़ें। उदाहरण के लिए, फॉर्म भरने से पहले कभी-कभी पृष्ठ को स्क्रॉल करें, कभी-कभी नहीं:
def fill_form_naturally(driver):
# भरने से पहले पृष्ठ को स्क्रॉल करने की 30% संभावना
if random.random() < 0.3:
driver.execute_script("window.scrollBy(0, 200)")
human_delay(0.5, 1.5)
# यादृच्छिक स्थान पर क्लिक करने की 20% संभावना (पढ़ने का अनुकरण)
if random.random() < 0.2:
body = driver.find_element(By.TAG_NAME, "body")
body.click()
human_delay(0.3, 0.8)
# मुख्य क्रिया - फॉर्म भरना
username_field = driver.find_element(By.ID, "username")
type_like_human(username_field, "myusername")2. टाइपिंग गति में विविधता
तुरंत टेक्स्ट टाइप करने के बजाय, वर्णानुक्रम में टाइपिंग का अनुकरण करें जिसमें विविधता हो:
def type_like_human(element, text):
"""मानव टाइपिंग गति का अनुकरण करते हुए टेक्स्ट टाइप करें"""
for char in text:
element.send_keys(char)
# वर्णों के बीच बुनियादी देरी
base_delay = random.uniform(0.05, 0.15)
# विराम चिह्नों और संकेतों पर अतिरिक्त विराम
if char in [' ', '.', ',', '!', '?']:
base_delay += random.uniform(0.1, 0.3)
# यादृच्छिक "सोचने" (5% संभावना लंबी विराम)
if random.random() < 0.05:
base_delay += random.uniform(0.5, 1.5)
time.sleep(base_delay)
# कभी-कभी टाइपिंग में गलती करें और सुधारें (10% संभावना)
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]) # अंतिम वर्ण को फिर से टाइप करें3. Puppeteer: धीमी टाइपिंग
Puppeteer में delay के लिए एक अंतर्निहित विकल्प है type() विधि के लिए, लेकिन इसे रैंडमाइज करना आवश्यक है:
// बुनियादी उपयोग (अनुशंसित नहीं - निश्चित देरी)
await page.type('#username', 'myusername', { delay: 100 });
// सही दृष्टिकोण - प्रत्येक वर्ण के लिए रैंडमाइजेशन
async function typeWithVariableSpeed(page, selector, text) {
await page.click(selector);
for (const char of text) {
await page.keyboard.type(char);
// 50 से 150 मिलीसेकंड के बीच यादृच्छिक देरी
let delay = Math.random() * 100 + 50;
// विराम चिह्नों पर अतिरिक्त विराम
if (char === ' ') {
delay += Math.random() * 200 + 100;
}
// यादृच्छिक लंबी विराम (5% संभावना)
if (Math.random() < 0.05) {
delay += Math.random() * 1000 + 500;
}
await page.waitForTimeout(delay);
}
}
// उपयोग
await typeWithVariableSpeed(page, '#username', 'myusername');स्वाभाविक माउस गति और स्क्रॉलिंग की गति
Selenium और Puppeteer डिफ़ॉल्ट रूप से कर्सर को नहीं चलाते हैं - वे इसे आवश्यक बिंदु पर तुरंत टेलीपोर्ट करते हैं और क्लिक करते हैं। यह स्वचालन के सबसे स्पष्ट संकेतों में से एक है। मानव माउस गति का अनुकरण करने के लिए विशेष पुस्तकालयों की आवश्यकता होती है।
माउस के लिए pyautogui पुस्तकालय
pyautogui पुस्तकालय कर्सर को बेज़ियर वक्र के साथ गति देने की अनुमति देता है, जिसमें तेजी और धीमी गति होती है:
import pyautogui
from selenium.webdriver.common.action_chains import ActionChains
def move_mouse_naturally(driver, element):
"""मनुष्य का अनुकरण करते हुए तत्व की ओर माउस को धीरे-धीरे चलाना"""
# तत्व के निर्देशांक प्राप्त करें
location = element.location
size = element.size
# लक्ष्य बिंदु (तत्व का केंद्र + थोड़ी यादृच्छिकता)
target_x = location['x'] + size['width'] / 2 + random.randint(-5, 5)
target_y = location['y'] + size['height'] / 2 + random.randint(-5, 5)
# परिवर्तनशील गति के साथ धीरे-धीरे चलाना
# अवधि - गति का समय (यथार्थता के लिए 0.5-1.5 सेकंड)
duration = random.uniform(0.5, 1.5)
# tweening - गति का कार्य (easeInOutQuad मानव गति का अनुकरण करता है)
pyautogui.moveTo(target_x, target_y, duration=duration, tween=pyautogui.easeInOutQuad)
# क्लिक से पहले थोड़ी देरी (मनुष्य तुरंत क्लिक नहीं करता है)
time.sleep(random.uniform(0.05, 0.15))
# क्लिक करें
element.click()महत्वपूर्ण: यह विधि केवल तभी काम करती है जब Selenium एक वास्तविक ब्राउज़र विंडो को नियंत्रित करता है (हेडलेस नहीं)। हेडलेस मोड के लिए, माउस गति बेकार है, क्योंकि एंटी-फ्रॉड प्रणालियाँ कर्सर को नहीं देखती हैं।
Puppeteer: माउस गति का अनुकरण
Puppeteer में आप कर्सर की यथार्थवादी गति के लिए ghost-cursor पुस्तकालय का उपयोग कर सकते हैं:
// स्थापना: 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");
// तत्व की ओर धीरे-धीरे चलना और क्लिक करना
const button = await page.$("#submit-btn");
await cursor.click(button); // कर्सर बेज़ियर वक्र के साथ चलता है!
// वैकल्पिक रूप से - निर्देशांकों की ओर चलना
await cursor.move("#username"); // क्लिक किए बिना कर्सर को बस चलाते हैं
await page.waitForTimeout(300);
await cursor.click(); // वर्तमान स्थिति में क्लिक करें
})();स्क्रॉलिंग का अनुकरण
मानव एक बार में ठीक 500 पिक्सल स्क्रॉल नहीं करता है। स्क्रॉलिंग असमान होनी चाहिए, विराम के साथ और कभी-कभी पीछे की ओर स्क्रॉलिंग:
def scroll_like_human(driver, target_position=None):
"""
मानव स्क्रॉलिंग का अनुकरण
target_position: पिक्सल में लक्ष्य स्थिति (यदि None - अंत तक स्क्रॉल करें)
"""
current_position = driver.execute_script("return window.pageYOffset;")
if target_position is None:
# पृष्ठ के अंत तक स्क्रॉल करें
target_position = driver.execute_script("return document.body.scrollHeight;")
while current_position < target_position:
# स्क्रॉल के लिए यादृच्छिक कदम (100-400 पिक्सल)
scroll_step = random.randint(100, 400)
current_position += scroll_step
# स्क्रॉल करें
driver.execute_script(f"window.scrollTo(0, {current_position});")
# स्क्रॉल के बीच में विराम (मनुष्य सामग्री पढ़ता है)
time.sleep(random.uniform(0.3, 1.2))
# कभी-कभी थोड़ा पीछे स्क्रॉल करें (10% संभावना)
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))
# उपयोग
scroll_like_human(driver, target_position=2000) # 2000px तक स्क्रॉल करेंपृष्ठों और AJAX अनुरोधों का लोडिंग समय
एंटी-फ्रॉड प्रणालियाँ केवल उपयोगकर्ता की क्रियाओं का ही नहीं, बल्कि पृष्ठों के लोडिंग के गुणों का भी विश्लेषण करती हैं। हेडलेस ब्राउज़र अक्सर असामान्य रूप से तेज़ लोड होते हैं, क्योंकि वे चित्रों को लोड नहीं करते, कुछ स्क्रिप्ट नहीं चलाते, CSS को रेंडर नहीं करते हैं।
समस्या: बहुत तेज़ लोडिंग
सामान्य ब्राउज़र और हेडलेस के लिए प्रदर्शन API के सामान्य मानों की तुलना करें:
| मेट्रिक | सामान्य ब्राउज़र | हेडलेस (संदिग्ध) |
|---|---|---|
| domContentLoaded | 800-2000 मिलीसेकंड | 50-200 मिलीसेकंड |
| loadEventEnd | 2000-5000 मिलीसेकंड | 100-500 मिलीसेकंड |
| लोड किए गए संसाधनों की संख्या | 50-200 (चित्र, CSS, JS) | 5-20 (केवल महत्वपूर्ण) |
समाधान: लोडिंग में मजबूर देरी
पृष्ठ लोड होने के बाद कृत्रिम देरी जोड़ें, ताकि मेट्रिक्स अधिक स्वाभाविक दिखें:
def load_page_naturally(driver, url):
"""प्राकृतिक लोडिंग समय का अनुकरण करते हुए पृष्ठ लोड करें"""
start_time = time.time()
driver.get(url)
# DOM के पूरी तरह से लोड होने की प्रतीक्षा करें
WebDriverWait(driver, 10).until(
lambda d: d.execute_script("return document.readyState") == "complete"
)
# वास्तविक लोडिंग समय की गणना करें
actual_load_time = time.time() - start_time
# यदि लोडिंग बहुत तेज़ थी (< 1 सेकंड), तो देरी जोड़ें
if actual_load_time < 1.0:
additional_delay = random.uniform(1.0, 2.5) - actual_load_time
time.sleep(additional_delay)
# "पृष्ठ पढ़ने" के लिए अतिरिक्त देरी
time.sleep(random.uniform(0.5, 2.0))
# उपयोग
load_page_naturally(driver, "https://example.com")AJAX अनुरोधों की प्रतीक्षा
आधुनिक वेबसाइटें सामग्री को AJAX के माध्यम से असिंक्रोनस रूप से लोड करती हैं। यदि आपका स्क्रिप्ट सभी AJAX अनुरोधों के पूरा होने से पहले कार्य करना शुरू करता है - तो यह संदिग्ध है। स्पष्ट प्रतीक्षा का उपयोग करें:
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
def wait_for_ajax(driver, timeout=10):
"""सभी AJAX अनुरोधों के पूरा होने की प्रतीक्षा करें (jQuery)"""
WebDriverWait(driver, timeout).until(
lambda d: d.execute_script("return jQuery.active == 0")
)
# jQuery के बिना साइटों के लिए - एक विशेष तत्व की प्रतीक्षा करें
def wait_for_dynamic_content(driver, selector, timeout=10):
"""गतिशील रूप से लोड किए गए तत्व के प्रकट होने की प्रतीक्षा करें"""
WebDriverWait(driver, timeout).until(
EC.presence_of_element_located((By.CSS_SELECTOR, selector))
)
# तत्व के प्रकट होने के बाद अतिरिक्त देरी
time.sleep(random.uniform(0.3, 0.8))एंटी-डिटेक्ट ब्राउज़रों में सुरक्षा सेटिंग्स
यदि आप आर्बिट्रेशन, मल्टी-एकाउंटिंग या अन्य कार्यों के साथ काम कर रहे हैं जहाँ गुमनामी महत्वपूर्ण है, तो एंटी-डिटेक्ट ब्राउज़रों का उपयोग करें: डॉल्फिन एंटी, एड्सपावर, मल्टीलॉगिन, गो लॉगिन। इनमें टाइमिंग हमलों से सुरक्षा के लिए अंतर्निहित तंत्र होते हैं, लेकिन इन्हें सही तरीके से सेटअप करना आवश्यक है।
डॉल्फिन एंटी: मानव टाइपिंग सेटिंग्स
डॉल्फिन एंटी में "मानव टाइपिंग" फ़ीचर है - मानव टाइपिंग का स्वचालित अनुकरण। सेटिंग्स:
- ब्राउज़र प्रोफ़ाइल खोलें → "Automation" टैब
- "Human Typing Emulation" सक्षम करें
- सेटिंग्स कॉन्फ़िगर करें:
- औसत टाइपिंग गति: 150-250 वर्ण/मिनट (यथार्थवादी गति)
- विविधता: 30-50% (वर्णों के बीच गति का फैलाव)
- विराम चिह्नों पर विराम: सक्षम (विराम चिह्नों पर विराम)
- यादृच्छिक टाइपिंग गलतियाँ: 2-5% (यादृच्छिक गलतियाँ और सुधार)
इसके बाद, डॉल्फिन के API के माध्यम से कोई भी टेक्स्ट इनपुट स्वचालित रूप से मानव का अनुकरण करेगा।
एड्सपावर: माउस मूवमेंट सेटिंग्स
एड्सपावर वास्तविक उपयोगकर्ता की माउस गति के पैटर्न को रिकॉर्ड करने और उन्हें पुन: प्रस्तुत करने की अनुमति देता है:
- प्रोफ़ाइल खोलें → "Advanced Settings" → "Mouse Behavior"
- "Record Real User" मोड चुनें:
- ब्राउज़र को सामान्य मोड में खोलें
- विशिष्ट क्रियाएँ करें (क्लिक्स, स्क्रॉलिंग, माउस मूवमेंट)
- एड्सपावर गति की पथों को रिकॉर्ड करेगा
- API के माध्यम से स्वचालन करते समय, एड्सपावर रिकॉर्ड किए गए पैटर्न को विविधताओं के साथ पुन: प्रस्तुत करेगा
मल्टीलॉगिन: कैनवास शोर और वेबजीएल टाइमिंग
मल्टीलॉगिन कैनवास और वेबजीएल फिंगरप्रिंट्स में शोर (noise) जोड़ता है, जो रेंडरिंग से संबंधित टाइमिंग हमलों पर प्रभाव डालता है:
- प्रोफ़ाइल → "Fingerprint settings" → "Canvas"
- "Canvas Noise" सक्षम करें (कैनवास के रेंडरिंग में माइक्रोडिलेज जोड़ता है)
- "WebGL Metadata Masking" सक्षम करें (GPU की विशेषताओं को छुपाता है, जो रेंडरिंग की गति को प्रभावित करता है)
यह Canvas.toDataURL() और WebGL संचालन के समय के विश्लेषण के माध्यम से पहचान से सुरक्षा करता है।
सिफारिश: यदि आप फेसबुक, इंस्टाग्राम या टिकटॉक पर मल्टी-एकाउंटिंग के साथ काम कर रहे हैं, तो एंटी-डिटेक्ट ब्राउज़रों का उपयोग करना सुनिश्चित करें, साथ ही गुणवत्ता वाले रहवासी प्रॉक्सी का उपयोग करें - यह चेन-बैन और IP द्वारा पहचान के जोखिम को कम करता है।
टाइमिंग डिटेक्शन को बायपास करने की उन्नत तकनीकें
विशेष रूप से सुरक्षित प्लेटफार्मों (गूगल, फेसबुक, बैंकिंग साइटें) के लिए, बुनियादी विधियाँ पर्याप्त नहीं हो सकती हैं। आइए हम उन्नत तकनीकों पर चर्चा करते हैं।
1. प्रदर्शन API का प्रतिस्थापन
आप प्रदर्शन API के तरीकों को फिर से परिभाषित कर सकते हैं ताकि वास्तविक मानों के बजाय यथार्थवादी मान लौटाए जा सकें:
// प्रदर्शन.now() को प्रतिस्थापित करने के लिए स्क्रिप्ट का इंजेक्शन
const script = `
(function() {
const originalNow = performance.now.bind(performance);
let offset = 0;
let lastValue = 0;
performance.now = function() {
const realValue = originalNow();
// समय में यादृच्छिक शोर जोड़ें
const noise = Math.random() * 2 - 1; // -1 से +1 मिलीसेकंड
let fakeValue = realValue + offset + noise;
// निरंतरता सुनिश्चित करें (समय पीछे नहीं जाता)
if (fakeValue <= lastValue) {
fakeValue = lastValue + 0.1;
}
lastValue = fakeValue;
return fakeValue;
};
})();
`;
// Puppeteer: पृष्ठ बनाने पर इंजेक्शन
await page.evaluateOnNewDocument(script);ध्यान दें: इस विधि का पता लगाया जा सकता है यदि मूल विधियों की अखंडता की जांच की जाती है। केवल उन साइटों पर उपयोग करें जिनकी सुरक्षा मजबूत नहीं है।
2. CPU और नेटवर्क को थ्रॉटलिंग करना
Chrome DevTools प्रोटोकॉल कृत्रिम रूप से CPU और नेटवर्क को धीमा करने की अनुमति देता है, ताकि लोडिंग मेट्रिक्स अधिक स्वाभाविक दिखें:
// Puppeteer: CPU को 2 गुना धीमा करना
const client = await page.target().createCDPSession();
await client.send('Emulation.setCPUThrottlingRate', { rate: 2 });
// नेटवर्क को धीमा करना (3G का अनुकरण)
await page.emulateNetworkConditions({
offline: false,
downloadThroughput: 1.5 * 1024 * 1024 / 8, // 1.5 Mbps
uploadThroughput: 750 * 1024 / 8, // 750 Kbps
latency: 40 // 40ms की देरी
});यह पृष्ठों के लोडिंग और जावास्क्रिप्ट के निष्पादन के समय को बढ़ाएगा, जिससे प्रोफ़ाइल अधिक वास्तविक उपयोगकर्ता के समान हो जाएगा, जिसकी इंटरनेट गति औसत है।
3. पृष्ठभूमि गतिविधि का अनुकरण
वास्तविक उपयोगकर्ता एक ही टैब पर नहीं रहते - वे टैब के बीच स्विच करते हैं, विंडो को मिनिमाइज करते हैं, विचलित होते हैं। इसका अनुकरण करें:
async function simulateTabSwitch(page) {
// दूसरे टैब पर स्विच करने का अनुकरण (पृष्ठ दृश्यता API)
await page.evaluate(() => {
Object.defineProperty(document, 'hidden', {
get: () => true,
configurable: true
});
document.dispatchEvent(new Event('visibilitychange'));
});
// विराम (उपयोगकर्ता दूसरे टैब को देखता है)
await page.waitForTimeout(Math.random() * 3000 + 2000);
// टैब पर वापस लौटें
await page.evaluate(() => {
Object.defineProperty(document, 'hidden', {
get: () => false,
configurable: true
});
document.dispatchEvent(new Event('visibilitychange'));
});
}
// उपयोग: काम करते समय यादृच्छिक रूप से "विचलित" होते हैं
if (Math.random() < 0.15) { // 15% संभावना
await simulateTabSwitch(page);
}4. वास्तविक उपयोगकर्ता टाइमिंग मार्क्स का उपयोग
कुछ साइटें उपयोगकर्ता टाइमिंग API के माध्यम से अपनी स्वयं की टाइमिंग मार्क्स बनाती हैं। यथार्थवादी मार्क्स जोड़ें:
// यथार्थवादी टाइमिंग मार्क्स बनाना
await page.evaluate(() => {
// उपयोगकर्ता के कार्य करने से पहले "सोचने" का अनुकरण
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. सांख्यिकीय सहसंबंध को कम करने के लिए प्रॉक्सी का रोटेशन
भले ही आपके स्क्रिप्ट के प्रत्येक उदाहरण में रैंडमाइज्ड देरी हो, एंटी-फ्रॉड प्रणालियाँ यह पहचान सकती हैं कि सभी अनुरोध एक ही IP से आ रहे हैं। प्रॉक्सी का रोटेशन का उपयोग करें:
- पार्सिंग और बड़े पैमाने पर कार्यों के लिए: डेटा सेंटर प्रॉक्सी जो हर 5-10 मिनट में स्वचालित रूप से रोटेट होती हैं
- सोशल मीडिया और विज्ञापन के साथ काम करने के लिए: रहवासी प्रॉक्सी जो सत्र के लिए बंधी होती हैं (स्टिकी सत्र)
- मोबाइल प्लेटफार्मों (इंस्टाग्राम, टिकटॉक) के लिए: मोबाइल प्रॉक्सी जो टाइमर या अनुरोध के अनुसार रोटेट होती हैं
IP का रोटेशन यह संभावना कम करता है कि एंटी-फ्रॉड प्रणाली आपके टाइमिंग पैटर्न के सांख्यिकीय विश्लेषण के लिए पर्याप्त डेटा एकत्र कर सके।
निष्कर्ष
टाइमिंग हमले स्वचालन का पता लगाने की एक जटिल विधि है, जो सुरक्षा के लिए एक समग्र दृष्टिकोण की आवश्यकता होती है। मुख्य निष्कर्ष:
- निश्चित देरी का उपयोग न करें - हमेशा क्रियाओं के बीच के समय को सामान्य वितरण का उपयोग करके रैंडमाइज करें
- संदर्भ देरी का अनुकरण करें - विभिन्न क्रियाओं के लिए विभिन्न समय की आवश्यकता होती है (पृष्ठ पढ़ना ≠ बटन पर क्लिक करना)
- क्रियाओं के अनुक्रम में विविधता जोड़ें - यादृच्छिक स्क्रॉल, क्लिक, टैब स्विचिंग
- स्वाभाविक माउस गति का उपयोग करें - ghost-cursor (Puppeteer) या pyautogui (Selenium) पुस्तकालय
- स्वाभाविक टाइपिंग गति का अनुकरण करें - विराम चिह्नों पर विराम के साथ वर्णानुक्रम में टाइपिंग
- एंटी-डिटेक्ट ब्राउज़रों को कॉन्फ़िगर करें - डॉल्फिन एंटी, एड्सपावर और मल्टीलॉगिन में टाइमिंग हमलों से सुरक्षा के लिए अंतर्निहित तंत्र होते हैं
- गुणवत्ता वाली प्रॉक्सी के साथ संयोजन करें - IP का रोटेशन सांख्यिकीय विश्लेषण की संभावना को कम करता है
याद रखें: आदर्श सुरक्षा नहीं होती। एंटी-फ्रॉड प्रणालियाँ लगातार विकसित होती रहती हैं, नए डिटेक्शन तरीकों को जोड़ती हैं। आपका कार्य स्क्रिप्ट के व्यवहार को वास्तविक उपयोगकर्ता के जितना संभव हो सके करीब लाना और बायपास के तरीकों को नियमित रूप से अपडेट करना है।
यदि आप पार्सिंग, परीक्षण या अन्य कार्यों के लिए ब्राउज़र स्वचालन के साथ काम कर रहे हैं, तो रहवासी प्रॉक्सी का उपयोग करने की सिफारिश की जाती है - ये अधिकतम स्तर की गुमनामी प्रदान करते हैं और IP पते के द्वारा पहचान के जोखिम को कम करते हैं। मोबाइल प्लेटफार्मों के लिए, मोबाइल प्रॉक्सी बेहतर होते हैं, जो मोबाइल ऑपरेटरों के वास्तविक उपयोगकर्ताओं का अनुकरण करते हैं।