```html

Selenium और Puppeteer को डिटेक्शन से छिपाने के लिए पूर्ण गाइड

आधुनिक एंटी-बॉट सुरक्षा प्रणालियाँ स्वचालित ब्राउज़रों को कई संकेतों के आधार पर आसानी से पहचान लेती हैं: JavaScript वेरिएबल से लेकर WebDriver के व्यवहार की विशेषताओं तक। साइटें Cloudflare, DataDome, PerimeterX और अपने स्वयं के समाधानों का उपयोग करती हैं, जो मानक कॉन्फ़िगरेशन में Selenium और Puppeteer से 90% तक अनुरोधों को ब्लॉक कर देती हैं।

इस गाइड में हम स्वचालन छिपाने के सभी तरीकों पर चर्चा करेंगे: बुनियादी सेटिंग्स से लेकर उन्नत डिटेक्शन बायपास तकनीकों तक। आप Python और Node.js के लिए कोड उदाहरणों के साथ तैयार समाधान प्राप्त करेंगे, जो अधिकांश सुरक्षा प्रणालियों के खिलाफ काम करते हैं।

साइटें स्वचालन को कैसे पहचानती हैं

एंटी-बॉट सुरक्षा प्रणालियाँ एक साथ कई पैरामीटर के आधार पर ब्राउज़र का विश्लेषण करती हैं। यदि आप एक संकेत को छिपाते हैं, तो अन्य स्वचालन को उजागर कर देंगे। सभी डिटेक्शन विधियों को समझना प्रभावी छिपाने की कुंजी है।

WebDriver संकेतक

पहचानने का सबसे सरल तरीका JavaScript वेरिएबल की जांच करना है, जो केवल स्वचालित ब्राउज़रों में मौजूद होते हैं:

// ये वेरिएबल Selenium/Puppeteer को उजागर करते हैं
navigator.webdriver === true
window.navigator.webdriver === true
document.$cdc_ // ChromeDriver विशिष्ट वेरिएबल
window.document.documentElement.getAttribute("webdriver")
navigator.plugins.length === 0 // स्वचालित ब्राउज़रों में कोई प्लगइन नहीं होते
navigator.languages === "" // भाषाओं की सूची खाली है

Cloudflare और इसी तरह की प्रणालियाँ पहले इन गुणों की जांच करती हैं। यदि इनमें से कोई भी सकारात्मक परिणाम लौटाता है — अनुरोध को ब्लॉक कर दिया जाता है।

ब्राउज़र फिंगरप्रिंटिंग

उन्नत प्रणालियाँ दर्जनों पैरामीटर के आधार पर ब्राउज़र का एक अद्वितीय फिंगरप्रिंट बनाती हैं:

Canvas फिंगरप्रिंटिंग — छिपी हुई छवियों का रेंडरिंग और पिक्सेल डेटा का विश्लेषण
WebGL फिंगरप्रिंटिंग — ग्राफिक्स रेंडरर और ग्राफिक्स कार्ड के पैरामीटर
Audio Context — ऑडियो प्रोसेसिंग की अद्वितीय विशेषताएँ
Fonts फिंगरप्रिंटिंग — सिस्टम में स्थापित फोंट की सूची
Screen Resolution — स्क्रीन का रिज़ॉल्यूशन, रंग की गहराई, उपलब्ध क्षेत्र
Timezone & Language — समय क्षेत्र, ब्राउज़र की भाषाएँ, सिस्टम की स्थानीयता

स्वचालित ब्राउज़र अक्सर इन पैरामीटर के असामान्य संयोजन रखते हैं। उदाहरण के लिए, Headless Chrome में प्लगइन्स नहीं होते, लेकिन यह WebGL का समर्थन करता है — ऐसा संयोजन वास्तविक उपयोगकर्ताओं में बहुत दुर्लभ होता है।

व्यवहारात्मक विश्लेषण

आधुनिक प्रणालियाँ व्यवहार के पैटर्न को ट्रैक करती हैं:

माउस मूवमेंट — बॉट सीधे रेखाओं में कर्सर को चलाते हैं या बिल्कुल भी नहीं चलाते
क्रियाओं की गति — फॉर्म का तात्कालिक भरना, मानव रहित क्लिक की गति
स्क्रॉलिंग पैटर्न — चिकनी स्क्रॉलिंग के बजाय तेज कूद
कीबोर्ड इवेंट्स — दबावों के बीच प्राकृतिक देरी का अभाव
अनुरोधों की आवृत्ति — क्रियाओं के बीच बहुत नियमित अंतराल

महत्वपूर्ण: DataDome और PerimeterX व्यवहार का विश्लेषण करने के लिए मशीन लर्निंग का उपयोग करते हैं। वे लाखों सत्रों पर प्रशिक्षित हैं और तकनीकी पैरामीटर की सही छिपाने के बावजूद बॉट को पहचान सकते हैं, यदि व्यवहार अप्राकृतिक प्रतीत होता है।

Selenium की बुनियादी छिपाने की तकनीक

Selenium WebDriver मानक कॉन्फ़िगरेशन में कई निशान छोड़ता है। डिटेक्शन को न्यूनतम करने के लिए Python और ChromeDriver के उदाहरण के साथ चरण-दर-चरण सेटअप पर विचार करें।

WebDriver फ्लैग को बंद करना

पहला कदम navigator.webdriver वेरिएबल को छिपाना है। यह Chrome DevTools प्रोटोकॉल के माध्यम से किया जाता है:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options

# Chrome विकल्पों को सेट करना
chrome_options = Options()

# स्वचालन फ्लैग को बंद करना
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

# ड्राइवर बनाना
driver = webdriver.Chrome(options=chrome_options)

# CDP के माध्यम से वेबड्राइवर को हटाना
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        })
    '''
})

driver.get('https://example.com')

User-Agent और अन्य हेडर सेट करना

Headless ब्राउज़र अक्सर पुराने या विशिष्ट User-Agent स्ट्रिंग का उपयोग करते हैं। एक वास्तविक ब्राउज़र का अद्यतन User-Agent स्थापित करना आवश्यक है:

# Windows पर Chrome का अद्यतन User-Agent
user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
chrome_options.add_argument(f'user-agent={user_agent}')

# छिपाने के लिए अतिरिक्त तर्क
chrome_options.add_argument('--disable-blink-features=AutomationControlled')
chrome_options.add_argument('--disable-dev-shm-usage')
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-gpu')

# वास्तविक उपयोगकर्ता के समान विंडो का आकार
chrome_options.add_argument('--window-size=1920,1080')
chrome_options.add_argument('--start-maximized')

प्लगइन्स और भाषाएँ जोड़ना

स्वचालित ब्राउज़र में प्लगइन्स नहीं होते हैं और अक्सर भाषाओं की सूची खाली दिखाते हैं। इसे CDP के माध्यम से ठीक किया जा सकता है:

driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'languages', {
            get: () => ['en-US', 'en', 'ru']
        });
        
        Object.defineProperty(navigator, 'plugins', {
            get: () => [
                {
                    0: {type: "application/x-google-chrome-pdf", suffixes: "pdf", description: "Portable Document Format"},
                    description: "Portable Document Format",
                    filename: "internal-pdf-viewer",
                    length: 1,
                    name: "Chrome PDF Plugin"
                },
                {
                    0: {type: "application/pdf", suffixes: "pdf", description: ""},
                    description: "",
                    filename: "mhjfbmdgcfjbbpaeojofohoefgiehjai",
                    length: 1,
                    name: "Chrome PDF Viewer"
                }
            ]
        });
        
        Object.defineProperty(navigator, 'platform', {
            get: () => 'Win32'
        });
    '''
})

Selenium सेटअप का पूर्ण उदाहरण

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import random

def create_stealth_driver():
    chrome_options = Options()
    
    # छिपाने की बुनियादी सेटिंग्स
    chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
    chrome_options.add_experimental_option('useAutomationExtension', False)
    chrome_options.add_argument('--disable-blink-features=AutomationControlled')
    
    # User-Agent
    user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
    chrome_options.add_argument(f'user-agent={user_agent}')
    
    # विंडो का आकार
    chrome_options.add_argument('--window-size=1920,1080')
    chrome_options.add_argument('--start-maximized')
    
    driver = webdriver.Chrome(options=chrome_options)
    
    # CDP के माध्यम से छिपाने का स्क्रिप्ट
    stealth_script = '''
        Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
        Object.defineProperty(navigator, 'languages', {get: () => ['en-US', 'en']});
        Object.defineProperty(navigator, 'platform', {get: () => 'Win32'});
        
        window.chrome = {
            runtime: {}
        };
        
        Object.defineProperty(navigator, 'plugins', {
            get: () => [1, 2, 3, 4, 5]
        });
    '''
    
    driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
        'source': stealth_script
    })
    
    return driver

# उपयोग
driver = create_stealth_driver()
driver.get('https://bot.sannysoft.com/')  # डिटेक्शन के परीक्षण के लिए साइट

डिटेक्शन को बायपास करने के लिए Puppeteer सेटअप

Puppeteer को Selenium के समान डिटेक्शन की समस्याएँ हैं। हालाँकि, Node.js के लिए एक तैयार पुस्तकालय puppeteer-extra-plugin-stealth है, जो अधिकांश छिपाने की सेटिंग्स को स्वचालित करता है।

puppeteer-extra स्थापित करना

npm install puppeteer puppeteer-extra puppeteer-extra-plugin-stealth

stealth प्लगइन के साथ बुनियादी कॉन्फ़िगरेशन

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

// छिपाने के प्लगइन को जोड़ना
puppeteer.use(StealthPlugin());

(async () => {
    const browser = await puppeteer.launch({
        headless: 'new', // Chrome का नया हेडलेस मोड
        args: [
            '--no-sandbox',
            '--disable-setuid-sandbox',
            '--disable-dev-shm-usage',
            '--disable-accelerated-2d-canvas',
            '--disable-gpu',
            '--window-size=1920,1080',
            '--disable-web-security',
            '--disable-features=IsolateOrigins,site-per-process'
        ]
    });
    
    const page = await browser.newPage();
    
    // viewport सेट करना
    await page.setViewport({
        width: 1920,
        height: 1080,
        deviceScaleFactor: 1
    });
    
    // User-Agent सेट करना
    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
    
    // अतिरिक्त हेडर
    await page.setExtraHTTPHeaders({
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8'
    });
    
    await page.goto('https://bot.sannysoft.com/');
    
    // परीक्षण के लिए स्क्रीनशॉट
    await page.screenshot({ path: 'test.png' });
    
    await browser.close();
})();

प्लगइन्स के बिना मैन्युअल सेटअप

यदि आप पूर्ण नियंत्रण चाहते हैं या तृतीय-पक्ष पुस्तकालयों का उपयोग नहीं कर सकते हैं, तो मैन्युअल रूप से छिपाने की सेटिंग्स करें:

const puppeteer = require('puppeteer');

(async () => {
    const browser = await puppeteer.launch({
        headless: 'new',
        args: ['--no-sandbox', '--disable-setuid-sandbox']
    });
    
    const page = await browser.newPage();
    
    // webdriver और अन्य गुणों को ओवरराइड करना
    await page.evaluateOnNewDocument(() => {
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
        
        Object.defineProperty(navigator, 'languages', {
            get: () => ['en-US', 'en']
        });
        
        Object.defineProperty(navigator, 'plugins', {
            get: () => [1, 2, 3, 4, 5]
        });
        
        // Chrome headless को छिपाना
        Object.defineProperty(navigator, 'platform', {
            get: () => 'Win32'
        });
        
        window.chrome = {
            runtime: {}
        };
        
        // permissions को ओवरराइड करना
        const originalQuery = window.navigator.permissions.query;
        window.navigator.permissions.query = (parameters) => (
            parameters.name === 'notifications' ?
                Promise.resolve({ state: Notification.permission }) :
                originalQuery(parameters)
        );
    });
    
    await page.goto('https://example.com');
    await browser.close();
})();

Cloudflare को बायपास करने के लिए सेटअप

Cloudflare उन्नत डिटेक्शन विधियों का उपयोग करता है। बायपास करने के लिए यादृच्छिक देरी और क्रियाओं की अनुकरण जोड़ना आवश्यक है:

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

async function bypassCloudflare(url) {
    const browser = await puppeteer.launch({
        headless: 'new',
        args: [
            '--no-sandbox',
            '--disable-setuid-sandbox',
            '--disable-web-security'
        ]
    });
    
    const page = await browser.newPage();
    
    // यादृच्छिक User-Agent
    const userAgents = [
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
    ];
    await page.setUserAgent(userAgents[Math.floor(Math.random() * userAgents.length)]);
    
    // पृष्ठ पर जाना
    await page.goto(url, { waitUntil: 'networkidle2' });
    
    // Cloudflare की जांच का इंतजार करें (आमतौर पर 5-10 सेकंड)
    await page.waitForTimeout(8000);
    
    // यादृच्छिक माउस मूवमेंट
    await page.mouse.move(100, 100);
    await page.mouse.move(200, 200);
    
    const content = await page.content();
    await browser.close();
    
    return content;
}

JavaScript फिंगरप्रिंटिंग से लड़ना

JavaScript फिंगरप्रिंटिंग एक अद्वितीय ब्राउज़र फिंगरप्रिंट बनाने की प्रक्रिया है जो कई पैरामीटर के आधार पर होती है। भले ही आपने वेबड्राइवर को छिपा लिया हो, प्रणालियाँ स्वचालन की पहचान के लिए सैकड़ों अन्य गुणों का विश्लेषण करती हैं।

फिंगरप्रिंटिंग के मुख्य वेक्टर

एंटी-बॉट सुरक्षा प्रणालियाँ निम्नलिखित पैरामीटर की जांच करती हैं:

पैरामीटर	क्या जांचा जाता है	डिटेक्शन का जोखिम
navigator.webdriver	स्वचालन फ्लैग की उपस्थिति	महत्वपूर्ण
navigator.plugins	प्लगइन्स की संख्या और प्रकार	उच्च
window.chrome	Chrome API की उपस्थिति	मध्यम
navigator.permissions	ब्राउज़र की अनुमतियों का API	मध्यम
screen.colorDepth	स्क्रीन की रंग गहराई	कम
navigator.hardwareConcurrency	CPU के कोर की संख्या	कम

छिपाने का समग्र स्क्रिप्ट

नीचे दिया गया स्क्रिप्ट अधिकांश समस्याग्रस्त गुणों को ओवरराइड करता है। इसे CDP (Selenium) या evaluateOnNewDocument (Puppeteer) के माध्यम से लागू करें:

const stealthScript = `
    // webdriver को हटाना
    Object.defineProperty(navigator, 'webdriver', {
        get: () => undefined
    });
    
    // chrome ऑब्जेक्ट जोड़ना
    window.chrome = {
        runtime: {},
        loadTimes: function() {},
        csi: function() {},
        app: {}
    };
    
    // permissions को ओवरराइड करना
    const originalQuery = window.navigator.permissions.query;
    window.navigator.permissions.query = (parameters) => (
        parameters.name === 'notifications' ?
            Promise.resolve({ state: Notification.permission }) :
            originalQuery(parameters)
    );
    
    // प्लगइन्स को छिपाना
    Object.defineProperty(navigator, 'plugins', {
        get: () => {
            return [
                {
                    0: {type: "application/x-google-chrome-pdf", suffixes: "pdf"},
                    description: "Portable Document Format",
                    filename: "internal-pdf-viewer",
                    length: 1,
                    name: "Chrome PDF Plugin"
                },
                {
                    0: {type: "application/pdf", suffixes: "pdf"},
                    description: "Portable Document Format",
                    filename: "internal-pdf-viewer",
                    length: 1,
                    name: "Chrome PDF Viewer"
                },
                {
                    0: {type: "application/x-nacl"},
                    description: "Native Client Executable",
                    filename: "internal-nacl-plugin",
                    length: 2,
                    name: "Native Client"
                }
            ];
        }
    });
    
    // भाषाएँ
    Object.defineProperty(navigator, 'languages', {
        get: () => ['en-US', 'en']
    });
    
    // प्लेटफॉर्म
    Object.defineProperty(navigator, 'platform', {
        get: () => 'Win32'
    });
    
    // विक्रेता
    Object.defineProperty(navigator, 'vendor', {
        get: () => 'Google Inc.'
    });
    
    // Selenium के निशान हटाना
    delete window.cdc_adoQpoasnfa76pfcZLmcfl_Array;
    delete window.cdc_adoQpoasnfa76pfcZLmcfl_Promise;
    delete window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol;
    
    // बैटरी API (headless में अनुपस्थित)
    if (!navigator.getBattery) {
        navigator.getBattery = () => Promise.resolve({
            charging: true,
            chargingTime: 0,
            dischargingTime: Infinity,
            level: 1
        });
    }
`;

WebDriver गुणों को हटाना

ChromeDriver और अन्य WebDriver कार्यान्वयन वैश्विक स्कोप में विशिष्ट वेरिएबल जोड़ते हैं। ये वेरिएबल cdc_ प्रीफिक्स से शुरू होते हैं और सुरक्षा प्रणालियों द्वारा आसानी से पहचाने जाते हैं।

cdc वेरिएबल का पता लगाना

इन वेरिएबल की उपस्थिति की जांच एक सरल स्क्रिप्ट द्वारा की जा सकती है:

// सभी cdc वेरिएबल की खोज
for (let key in window) {
    if (key.includes('cdc_')) {
        console.log('WebDriver वेरिएबल मिली:', key);
    }
}

// सामान्य ChromeDriver वेरिएबल:
// cdc_adoQpoasnfa76pfcZLmcfl_Array
// cdc_adoQpoasnfa76pfcZLmcfl_Promise
// cdc_adoQpoasnfa76pfcZLmcfl_Symbol
// $cdc_asdjflasutopfhvcZLmcfl_

विधि 1: CDP के माध्यम से हटाना

सबसे विश्वसनीय तरीका है कि पृष्ठ लोड होने से पहले वेरिएबल को Chrome DevTools प्रोटोकॉल के माध्यम से हटा दिया जाए:

from selenium import webdriver

driver = webdriver.Chrome()

# सभी cdc वेरिएबल को हटाना
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        // ज्ञात cdc वेरिएबल को हटाना
        const cdcProps = [
            'cdc_adoQpoasnfa76pfcZLmcfl_Array',
            'cdc_adoQpoasnfa76pfcZLmcfl_Promise',
            'cdc_adoQpoasnfa76pfcZLmcfl_Symbol',
            '$cdc_asdjflasutopfhvcZLmcfl_'
        ];
        
        cdcProps.forEach(prop => {
            delete window[prop];
        });
        
        // सभी वेरिएबल को हटाना जो 'cdc_' शामिल करते हैं
        Object.keys(window).forEach(key => {
            if (key.includes('cdc_') || key.includes('$cdc_')) {
                delete window[key];
            }
        });
    '''
})

विधि 2: ChromeDriver में संशोधन

एक अधिक कट्टर दृष्टिकोण है ChromeDriver बाइनरी फ़ाइल को संशोधित करना, cdc_ को किसी अन्य वर्ण अनुक्रम से बदलना। यह इन वेरिएबल के निर्माण को रोकता है:

import re

def patch_chromedriver(driver_path):
    """
    ChromeDriver को पैच करता है, 'cdc_' को यादृच्छिक स्ट्रिंग से बदलता है
    """
    with open(driver_path, 'rb') as f:
        content = f.read()
    
    # 'cdc_' के सभी उदाहरणों को 'dog_' (या समान लंबाई की कोई अन्य स्ट्रिंग) से बदलना
    patched = content.replace(b'cdc_', b'dog_')
    
    with open(driver_path, 'wb') as f:
        f.write(patched)
    
    print(f'ChromeDriver पैच किया गया: {driver_path}')

# उपयोग
patch_chromedriver('/path/to/chromedriver')

ध्यान दें: ChromeDriver बाइनरी फ़ाइल में संशोधन करने से इसकी कार्यक्षमता बाधित हो सकती है। पैचिंग से पहले हमेशा बैकअप लें। यह विधि सभी ChromeDriver संस्करणों के साथ काम नहीं करती है।

विधि 3: undetected-chromedriver का उपयोग

undetected-chromedriver पुस्तकालय स्वचालित रूप से ChromeDriver को लॉन्च करते समय पैच करता है:

pip install undetected-chromedriver

import undetected_chromedriver as uc

# स्वचालित पैचिंग के साथ ड्राइवर बनाना
driver = uc.Chrome()

driver.get('https://nowsecure.nl/')  # डिटेक्शन के परीक्षण के लिए साइट
input('बंद करने के लिए Enter दबाएँ...')
driver.quit()

Canvas, WebGL और Audio API को छिपाना

Canvas, WebGL और Audio फिंगरप्रिंटिंग ग्राफिक्स के रेंडरिंग और ऑडियो प्रोसेसिंग की विशेषताओं के आधार पर अद्वितीय फिंगरप्रिंट बनाने के तरीके हैं। ब्राउज़र, OS और हार्डवेयर का प्रत्येक संयोजन एक अद्वितीय परिणाम देता है।

Canvas फिंगरप्रिंटिंग

प्रणालियाँ Canvas पर छिपी हुई छवि को चित्रित करती हैं और प्राप्त पिक्सेल का विश्लेषण करती हैं। Headless ब्राउज़र अक्सर GPU एक्सेलेरेशन की अनुपस्थिति के कारण असामान्य परिणाम देते हैं।

// सामान्य Canvas फिंगरप्रिंटिंग कोड
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
ctx.textBaseline = 'top';
ctx.font = '14px Arial';
ctx.fillText('Browser fingerprint', 2, 2);
const fingerprint = canvas.toDataURL();

सुरक्षा के लिए Canvas API में यादृच्छिक शोर जोड़ने पर विचार करें:

const canvasNoiseScript = `
    // Canvas में यादृच्छिक शोर जोड़ना
    const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
    const originalToBlob = HTMLCanvasElement.prototype.toBlob;
    const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
    
    // शोर जोड़ने का कार्य
    const addNoise = (canvas, context) => {
        const imageData = originalGetImageData.call(context, 0, 0, canvas.width, canvas.height);
        for (let i = 0; i < imageData.data.length; i += 4) {
            // RGB में न्यूनतम शोर जोड़ना (आंखों को दिखाई नहीं देता)
            imageData.data[i] += Math.floor(Math.random() * 3) - 1;
            imageData.data[i + 1] += Math.floor(Math.random() * 3) - 1;
            imageData.data[i + 2] += Math.floor(Math.random() * 3) - 1;
        }
        context.putImageData(imageData, 0, 0);
    };
    
    // toDataURL को ओवरराइड करना
    HTMLCanvasElement.prototype.toDataURL = function() {
        if (this.width > 0 && this.height > 0) {
            const context = this.getContext('2d');
            addNoise(this, context);
        }
        return originalToDataURL.apply(this, arguments);
    };
`;

WebGL फिंगरप्रिंटिंग

WebGL ग्राफिक्स कार्ड और ड्राइवरों के बारे में जानकारी प्रदान करता है। Headless ब्राउज़र अक्सर वास्तविक GPU के बजाय SwiftShader (सॉफ़्टवेयर रेंडरर) दिखाते हैं:

const webglMaskScript = `
    // WebGL पैरामीटर को छिपाना
    const getParameter = WebGLRenderingContext.prototype.getParameter;
    WebGLRenderingContext.prototype.getParameter = function(parameter) {
        // UNMASKED_VENDOR_WEBGL
        if (parameter === 37445) {
            return 'Intel Inc.';
        }
        // UNMASKED_RENDERER_WEBGL
        if (parameter === 37446) {
            return 'Intel Iris OpenGL Engine';
        }
        return getParameter.call(this, parameter);
    };
    
    // WebGL2 के लिए भी
    if (typeof WebGL2RenderingContext !== 'undefined') {
        const getParameter2 = WebGL2RenderingContext.prototype.getParameter;
        WebGL2RenderingContext.prototype.getParameter = function(parameter) {
            if (parameter === 37445) {
                return 'Intel Inc.';
            }
            if (parameter === 37446) {
                return 'Intel Iris OpenGL Engine';
            }
            return getParameter2.call(this, parameter);
        };
    }
`;

ऑडियो संदर्भ फिंगरप्रिंटिंग

ऑडियो API भी एक अद्वितीय फिंगरप्रिंट प्रदान करता है। ऑडियो प्रोसेसिंग में शोर जोड़ें:

const audioMaskScript = `
    // ऑडियो संदर्भ में शोर जोड़ना
    const AudioContext = window.AudioContext || window.webkitAudioContext;
    if (AudioContext) {
        const originalCreateAnalyser = AudioContext.prototype.createAnalyser;
        AudioContext.prototype.createAnalyser = function() {
            const analyser = originalCreateAnalyser.call(this);
            const originalGetFloatFrequencyData = analyser.getFloatFrequencyData;
            analyser.getFloatFrequencyData = function(array) {
                originalGetFloatFrequencyData.call(this, array);
                // न्यूनतम शोर जोड़ना
                for (let i = 0; i < array.length; i++) {
                    array[i] += Math.random() * 0.0001;
                }
            };
            return analyser;
        };
    }
`;

मानव व्यवहार की नकल करना

भले ही तकनीकी छिपाने में पूरी तरह से सफल हो जाएं, बॉट्स अपने व्यवहार से खुद को उजागर कर देते हैं। मशीन लर्निंग प्रणालियाँ माउस मूवमेंट, क्रियाओं की गति और घटनाओं के अनुक्रम का विश्लेषण करती हैं।

क्रियाओं के बीच यादृच्छिक देरी

कभी भी निश्चित देरी का उपयोग न करें। वास्तविक उपयोगकर्ता विभिन्न अवधि के लिए विराम देते हैं:

import random
import time

def human_delay(min_seconds=1, max_seconds=3):
    """मनुष्य की नकल करते हुए यादृच्छिक देरी"""
    delay = random.uniform(min_seconds, max_seconds)
    time.sleep(delay)

# उपयोग
driver.get('https://example.com')
human_delay(2, 4)  # 2-4 सेकंड का विराम

element = driver.find_element(By.ID, 'search')
human_delay(0.5, 1.5)  # इनपुट से पहले छोटी देरी

element.send_keys('search query')
human_delay(1, 2)

माउस का चिकना मूवमेंट

बॉट्स माउस को सीधे रेखाओं में चलाते हैं या कर्सर को टेलीपोर्ट करते हैं। वास्तविक उपयोगकर्ता त्वरण और धीमी गति के साथ घुमावदार पथ बनाते हैं:

// Puppeteer: माउस का चिकना मूवमेंट
async function humanMouseMove(page, targetX, targetY) {
    const steps = 25; // मध्य बिंदुओं की संख्या
    const currentPos = await page.evaluate(() => ({
        x: window.mouseX || 0,
        y: window.mouseY || 0
    }));
    
    for (let i = 0; i <= steps; i++) {
        const t = i / steps;
        // चिकनाई के लिए easing का उपयोग करें
        const ease = t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
        
        const x = currentPos.x + (targetX - currentPos.x) * ease;
        const y = currentPos.y + (targetY - currentPos.y) * ease;
        
        await page.mouse.move(x, y);
        await page.waitForTimeout(Math.random() * 10 + 5);
    }
    
    // स्थिति सहेजें
    await page.evaluate((x, y) => {
        window.mouseX = x;
        window.mouseY = y;
    }, targetX, targetY);
}

// उपयोग
await humanMouseMove(page, 500, 300);
await page.mouse.click(500, 300);

प्राकृतिक स्क्रॉलिंग

वास्तविक उपयोगकर्ता चिकनी स्क्रॉलिंग करते हैं, सामग्री पढ़ने के लिए विराम लेते हैं:

async function humanScroll(page) {
    const scrollHeight = await page.evaluate(() => document.body.scrollHeight);
    const viewportHeight = await page.evaluate(() => window.innerHeight);
    
    let currentPosition = 0;
    
    while (currentPosition < scrollHeight - viewportHeight) {
        // यादृच्छिक स्क्रॉलिंग कदम (200-500px)
        const scrollStep = Math.floor(Math.random() * 300) + 200;
        currentPosition += scrollStep;
        
        // चिकनी स्क्रॉलिंग
        await page.evaluate((pos) => {
            window.scrollTo({
                top: pos,
                behavior: 'smooth'
            });
        }, currentPosition);
        
        // सामग्री "पढ़ने" के लिए विराम (1-3 सेकंड)
        await page.waitForTimeout(Math.random() * 2000 + 1000);
    }
}

// उपयोग
await page.goto('https://example.com');
await humanScroll(page);

प्राकृतिक टेक्स्ट इनपुट

लोग विभिन्न गति से टाइप करते हैं, टाइपिंग में गलतियाँ करते हैं और उन्हें ठीक करते हैं:

async function humanTypeText(page, selector, text) {
    await page.click(selector);
    
    for (let char of text) {
        // कुंजी दबाने के बीच यादृच्छिक देरी (50-200ms)
        const delay = Math.random() * 150 + 50;
        await page.waitForTimeout(delay);
        
        // 5% मौका गलत टाइप करने का
        if (Math.random() < 0.05) {
            // यादृच्छिक वर्ण टाइप करें
            const wrongChar = String.fromCharCode(97 + Math.floor(Math.random() * 26));
            await page.keyboard.type(wrongChar);
            await page.waitForTimeout(100 + Math.random() * 100);
            // हटाना (Backspace)
            await page.keyboard.press('Backspace');
            await page.waitForTimeout(50 + Math.random() * 50);
        }
        
        await page.keyboard.type(char);
    }
}

// उपयोग
await humanTypeText(page, '#search-input', 'example search query');

पूर्ण गुमनामी के लिए प्रॉक्सी एकीकरण

ब्राउज़र को छिपाना बेकार है यदि सभी अनुरोध एक ही IP पते से आते हैं। एंटी-बॉट सुरक्षा प्रणालियाँ प्रत्येक IP से अनुरोधों की संख्या को ट्रैक करती हैं और संदिग्ध गतिविधियों को ब्लॉक करती हैं। प्रॉक्सी किसी भी गंभीर स्वचालन का अनिवार्य घटक है।

प्रॉक्सी के प्रकार का चयन

विभिन्न कार्यों के लिए विभिन्न प्रकार के प्रॉक्सी की आवश्यकता होती है:

प्रॉक्सी का प्रकार	लाभ	उपयोग
HTTP प्रॉक्सी	सरल सेटअप, अधिकांश साइटों के लिए कार्य करता है	सामान्य वेब स्क्रैपिंग
SOCKS प्रॉक्सी	लचीलापन, सभी प्रकार के ट्रैफ़िक के लिए समर्थन	टोरेंटिंग, गेमिंग
रोटेटिंग प्रॉक्सी	IP पते को स्वचालित रूप से बदलता है	डेटा संग्रहण, वेब स्क्रैपिंग
प्रॉक्सी सर्वर	पूर्ण नियंत्रण, अनुकूलन क्षमता	व्यवसायिक उपयोग

तैयार पुस्तकालय और उपकरण

यहाँ कुछ उपयोगी पुस्तकालय और उपकरण हैं जो स्वचालन छिपाने में मदद कर सकते हैं:

puppeteer-extra — Puppeteer के लिए एक प्लगइन जो स्वचालन को छिपाने में मदद करता है।
undetected-chromedriver — स्वचालित रूप से ChromeDriver को पैच करता है।
Selenium — स्वचालन के लिए एक लोकप्रिय पुस्तकालय।
html2canvas — HTML सामग्री के लिए स्क्रीनशॉट लेने के लिए।

डिटेक्शन स्तर का परीक्षण

अपनी सेटिंग्स की प्रभावशीलता का परीक्षण करने के लिए, आप विभिन्न डिटेक्शन परीक्षण साइटों का उपयोग कर सकते हैं:

SannySoft Bot Detection — स्वचालन की पहचान के लिए एक परीक्षण साइट।
BrowserLeaks — ब्राउज़र की जानकारी का परीक्षण करने के लिए।
WhatIsMyBrowser — ब्राउज़र की पहचान के लिए।

निष्कर्ष

स्वचालन छिपाना एक निरंतर प्रक्रिया है, क्योंकि एंटी-बॉट सुरक्षा प्रणालियाँ लगातार विकसित हो रही हैं। इस गाइड में वर्णित तकनीकों का उपयोग करके, आप अपनी स्वचालन सेटिंग्स को अधिक प्रभावी बना सकते हैं और डिटेक्शन से बच सकते हैं।

```

Selenium और Puppeteer के उपयोग को कैसे छिपाएं