Turnstile और hCaptcha का обход: सुरक्षा तकनीकें और समाधान के तरीके

Cloudflare Turnstile और hCaptcha बॉट्स से वेब सेवाओं की सुरक्षा के लिए मानक बन गए हैं, जिन्होंने पारंपरिक reCAPTCHA को बदल दिया है। ये सिस्टम ब्राउज़र और नेटवर्क वातावरण के दर्जनों पैरामीटर का विश्लेषण करते हैं, जिससे प्रॉक्सी का उपयोग स्वचालन के लिए एक गंभीर चुनौती बन जाता है। इस लेख में, हम देखेंगे कि ये तकनीकें तकनीकी स्तर पर कैसे काम करती हैं और प्रॉक्सी के माध्यम से काम करते समय किन обход विधियों का वास्तव में प्रभावी हैं।

Cloudflare Turnstile कैसे काम करता है

Cloudflare Turnstile एक नई पीढ़ी की सुरक्षा प्रणाली है, जिसे "CAPTCHA का अदृश्य विकल्प" के रूप में प्रस्तुत किया गया है। पारंपरिक reCAPTCHA के विपरीत, Turnstile उपयोगकर्ता से ट्रैफिक लाइट या पैदल यात्री क्रॉसिंग चुनने की आवश्यकता नहीं होती है। इसके बजाय, सिस्टम पृष्ठभूमि में ब्राउज़र के व्यवहार और तकनीकी विशेषताओं का विश्लेषण करता है।

तकनीकी रूप से, Turnstile तीन चरणों में काम करता है। पहला — JavaScript विजेट का लोड होना, जो iframe के माध्यम से पृष्ठ पर एम्बेड किया जाता है। दूसरा — टेलीमेट्री का संग्रह: सिस्टम ब्राउज़र के बारे में डेटा एकत्र करता है, जिसमें WebGL फिंगरप्रिंट, कैनवास फिंगरप्रिंट, फ़ॉन्ट की सूची, स्क्रीन का संकल्प, समय क्षेत्र, सिस्टम की भाषा और कई अन्य पैरामीटर शामिल हैं। तीसरा चरण — Cloudflare के सर्वरों पर मान्यता, जहां एकत्रित डेटा ज्ञात बॉट और प्रॉक्सी पैटर्न के साथ मिलान किया जाता है।

Turnstile की एक प्रमुख विशेषता IP पते की प्रतिष्ठा प्रणाली का उपयोग है। Cloudflare के पास लाखों साइटों से एकत्रित विशाल डेटाबेस है, जो उनके CDN और DDoS सुरक्षा का उपयोग कर रहे हैं। यदि IP पता संदिग्ध गतिविधि में देखा जाता है, तो Turnstile पास करने की संभावना तेजी से घट जाती है। यह प्रॉक्सी उपयोगकर्ताओं के लिए पहली समस्या उत्पन्न करता है — यहां तक कि स्वच्छ निवासी IP भी पिछले मालिकों के कारण कम प्रतिष्ठा रख सकते हैं।

hCaptcha तकनीक और पहचान के तरीके

hCaptcha Google reCAPTCHA का एक प्रतिस्पर्धी विकल्प के रूप में उभरा है, जो गोपनीयता और मशीन लर्निंग के माध्यम से मुद्रीकरण पर जोर देता है। सिस्टम वेबसाइट मालिकों को उपयोगकर्ताओं के डेटा का उपयोग करने के लिए भुगतान करने की पेशकश करता है ताकि AI मॉडल को प्रशिक्षित किया जा सके। तकनीकी दृष्टिकोण से, hCaptcha स्वचालन की पहचान में Turnstile की तुलना में अधिक आक्रामक है।

hCaptcha का मुख्य कार्य तंत्र कई सुरक्षा स्तरों को शामिल करता है। पहला स्तर — नेटवर्क पैरामीटर की जांच: सिस्टम पैकेट के TTL, नेटवर्क में देरी, IP पते की भू-स्थानिकता और ब्राउज़र के घोषित समय क्षेत्र का विश्लेषण करता है। दूसरा स्तर — JavaScript कॉल: hCaptcha Web API की उपस्थिति और कार्यक्षमता की जांच करता है, जिसमें WebRTC, Battery API, Sensor API शामिल हैं। तीसरा स्तर — माउस की गति, स्क्रॉलिंग की गति, क्लिक पैटर्न का व्यवहारात्मक विश्लेषण।

hCaptcha की विशेषता चुनौती-आधारित जांच का उपयोग है। यदि सिस्टम बॉट पर संदेह करता है, तो यह दृश्य कार्य दिखाता है: निश्चित वस्तुओं के साथ छवियों का चयन, पहेलियों को हल करना, विकृत चित्रों पर पाठ की पहचान करना। कार्यों की कठिनाई हर असफल प्रयास पर गतिशील रूप से बढ़ती है। प्रॉक्सी उपयोगकर्ताओं के लिए, इसका अर्थ है कि सही फिंगरप्रिंट के साथ भी अनंत कैप्चा श्रृंखला प्राप्त की जा सकती है।

ब्राउज़र फिंगरप्रिंटिंग और प्रॉक्सी

ब्राउज़र फिंगरप्रिंटिंग एक तकनीक है जो उपयोगकर्ता की पहचान को ब्राउज़र और उपकरण की अद्वितीय विशेषताओं के सेट के माध्यम से करती है। भले ही आप IP पते को बदलने के लिए प्रॉक्सी का उपयोग कर रहे हों, फिंगरप्रिंट अपरिवर्तित रहता है और स्वचालन के उपयोग का खुलासा कर सकता है। आधुनिक सुरक्षा प्रणालियाँ फिंगरप्रिंट बनाने के लिए 50 से 200+ पैरामीटर एकत्र करती हैं।

फिंगरप्रिंट के मुख्य घटक में शामिल हैं: कैनवास फिंगरप्रिंट (ग्राफिक्स का अद्वितीय रेंडरिंग, जो GPU और ड्राइवरों पर निर्भर करता है), WebGL फिंगरप्रिंट (ग्राफिक्स त्वरक के पैरामीटर), ऑडियो कॉन्टेक्स्ट फिंगरप्रिंट (ध्वनि प्रसंस्करण की विशेषताएँ), स्थापित फ़ॉन्ट की सूची, स्क्रीन के पैरामीटर (संकल्प, रंग गहराई, पिक्सेल अनुपात), उपयोगकर्ता-एजेंट और ब्राउज़र हेडर, भाषा सेटिंग्स, समय क्षेत्र, प्लगइन्स और एक्सटेंशन की उपस्थिति।

प्रॉक्सी उपयोगकर्ताओं के लिए समस्या असंगतियों में निहित है। उदाहरण के लिए, यदि आपका IP पता जर्मनी में स्थान दिखाता है, जबकि ब्राउज़र का समय क्षेत्र मास्को पर सेट है — यह एक लाल झंडा है। यदि WebRTC लीक आपके असली IP पते को उजागर करता है, जो प्रॉक्सी से भिन्न है — सिस्टम तुरंत प्रतिस्थापन की पहचान करता है। यदि उपयोगकर्ता-एजेंट Windows का दावा करता है, लेकिन कैनवास फिंगरप्रिंट Linux के अनुरूप है — पहचान सुनिश्चित है।

// बुनियादी फिंगरप्रिंट संग्रह का उदाहरण
const fingerprint = {
  canvas: getCanvasFingerprint(),
  webgl: getWebGLFingerprint(),
  fonts: getFonts(),
  screen: {
    width: screen.width,
    height: screen.height,
    colorDepth: screen.colorDepth,
    pixelRatio: window.devicePixelRatio
  },
  timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
  language: navigator.language,
  platform: navigator.platform,
  hardwareConcurrency: navigator.hardwareConcurrency,
  deviceMemory: navigator.deviceMemory,
  webrtc: await getWebRTCIPs()
};

function getCanvasFingerprint() {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  ctx.textBaseline = 'top';
  ctx.font = '14px Arial';
  ctx.fillText('Browser fingerprint', 2, 2);
  return canvas.toDataURL();
}

प्रॉक्सी सर्वरों की पहचान के तरीके

सुरक्षा प्रणालियाँ प्रॉक्सी की पहचान के लिए कई तकनीकों का उपयोग करती हैं। पहला तरीका — ज्ञात प्रॉक्सी और VPN के डेटाबेस के माध्यम से जांच करना। IPHub, IP2Proxy, MaxMind GeoIP2 जैसी सेवाएँ लाखों IP पतों को प्रॉक्सी, VPN, होस्टिंग प्रदाताओं के रूप में वर्गीकृत करती हैं। Cloudflare और hCaptcha ऐसे डेटाबेस के साथ एकीकृत होते हैं और संदिग्ध IP के लिए स्वचालित रूप से जांच के स्तर को बढ़ाते हैं।

दूसरा तरीका — ASN (स्वायत्त प्रणाली संख्या) का विश्लेषण करना। डेटा सेंटर प्रॉक्सी आमतौर पर होस्टिंग प्रदाताओं (AWS, DigitalOcean, OVH) की होती हैं, जिसे ASN द्वारा आसानी से पहचाना जा सकता है। निवासी प्रॉक्सी सामान्य इंटरनेट प्रदाताओं (Comcast, Verizon, Deutsche Telekom) की ASN का उपयोग करते हैं, जिससे वे कम संदिग्ध बनते हैं। हालाँकि, यहां तक कि निवासी नेटवर्क भी आंशिक रूप से समझौता किए जा सकते हैं, यदि प्रदाता प्रॉक्सी बेचने के लिए जाना जाता है।

तीसरा तरीका — नेटवर्क स्तर पर व्यवहारात्मक विश्लेषण। सिस्टम असामान्यताओं को ट्रैक करते हैं: पैकेट के लिए बहुत कम या बहुत अधिक TTL, असामान्य देरी, गैर-मानक पोर्ट का उपयोग, भू-स्थानिकता और रूटिंग पथ का असंगत होना। उदाहरण के लिए, यदि IP पता अमेरिका में भू-स्थानिक है, लेकिन ट्रेसरूट यूरोपीय सर्वरों के माध्यम से मार्ग दिखाता है — यह प्रॉक्सी का संकेत है।

निवासी प्रॉक्सी के रूप में मूल समाधान

निवासी प्रॉक्सी Turnstile और hCaptcha का обход करने के लिए आधार हैं। डेटा सेंटर प्रॉक्सी के विपरीत, निवासी प्रॉक्सी वास्तविक उपकरणों के IP पतों का उपयोग करते हैं: घरेलू राउटर, मोबाइल फोन, IoT उपकरण। यह उन्हें नेटवर्क अवसंरचना के दृष्टिकोण से सामान्य उपयोगकर्ताओं से लगभग अपरिवर्तनीय बनाता है।

कैप्चा को पार करने के लिए निवासी प्रॉक्सी के प्रमुख लाभ: ISP (इंटरनेट सेवा प्रदाता) से संबंधित होना, न कि होस्टिंग प्रदाताओं से; अधिकांश मामलों में IP पतों की स्वच्छ प्रतिष्ठा; सही भू-स्थानिकता और रूटिंग; काले सूचियों में शामिल होने की कम संभावना। हालाँकि, सभी निवासी प्रॉक्सी समान रूप से प्रभावी नहीं होते हैं। कई कारक महत्वपूर्ण हैं।

पहला कारक — IP पतों का रोटेशन। स्थिर निवासी प्रॉक्सी (स्टिकी सत्र) एक IP को कुछ मिनटों से लेकर कुछ घंटों तक उपयोग करने की अनुमति देती हैं। यह उन परिदृश्यों के लिए अनुकूल है जहां सत्र बनाए रखना आवश्यक है: प्रमाणीकरण, फ़ॉर्म भरना, बहु-चरणीय संचालन। रोटेशनल प्रॉक्सी प्रत्येक अनुरोध पर या टाइमर के अनुसार IP बदलती हैं, जो पार्सिंग के लिए उपयोगी होती हैं, लेकिन अक्सर संदर्भ के लगातार परिवर्तन के कारण कैप्चा के साथ समस्याएँ उत्पन्न कर सकती हैं।

दूसरा कारक — भौगोलिक वितरण। कैप्चा को पार करने के लिए, यह महत्वपूर्ण है कि IP की भू-स्थानिकता साइट के लक्षित क्षेत्र और ब्राउज़र की सेटिंग्स के साथ मेल खाती हो। यदि आप एक जर्मन साइट के साथ काम कर रहे हैं, तो जर्मन निवासी प्रॉक्सी का उपयोग करें और ब्राउज़र में संबंधित समय क्षेत्र (Europe/Berlin), भाषा (de-DE) और स्थानीयता सेट करें।

तीसरा कारक — प्रॉक्सी प्रदाता की गुणवत्ता। सस्ते निवासी प्रॉक्सी अक्सर संदिग्ध तरीकों से एकत्रित होते हैं (फ्री VPN ऐप, संक्रमित उपकरण), जिससे IP पूल की प्रतिष्ठा कम हो जाती है। पेशेवर प्रदाता वैध SDK साझेदारियों के साथ काम करते हैं और नेटवर्क की गुणवत्ता की बारीकी से निगरानी करते हैं। स्केलिंग से पहले लक्षित साइटों पर प्रदाता की सफलता दर की जांच करें।

स्वचालन उपकरण: Selenium, Puppeteer, Playwright

स्वचालन उपकरण का चयन कैप्चा को पार करने की क्षमता पर महत्वपूर्ण प्रभाव डालता है। Selenium, Puppeteer और Playwright — तीन मुख्य समाधान हैं, प्रत्येक के अपने पहचान के विशेषताएँ हैं। सुरक्षा प्रणालियाँ इन उपकरणों के उपयोग को दर्जनों संकेतों के माध्यम से पहचान सकती हैं।

Selenium — सबसे पुराना और सबसे आसानी से पहचाने जाने वाला उपकरण है। Selenium द्वारा नियंत्रित ब्राउज़र में स्पष्ट मार्कर होते हैं: window.navigator.webdriver को true पर सेट किया गया है, कुछ विशेषताओं की कमी, जो स्वचालन के लिए विशिष्ट ब्राउज़र विंडो के आकार होते हैं। प्रॉक्सी के साथ भी, Selenium अक्सर बिना अतिरिक्त ओबफस्केशन के Turnstile और hCaptcha की जांच में विफल रहता है।

Puppeteer और Playwright — Chrome DevTools प्रोटोकॉल पर आधारित अधिक आधुनिक उपकरण हैं। ये भी पहचाने जाते हैं, लेकिन इनमें कम स्पष्ट संकेत होते हैं। पहचान के मुख्य तरीके: chrome.runtime की जांच, permissions API का विश्लेषण, प्लगइन्स की अनुपस्थिति और विशिष्ट viewport आकार के माध्यम से headless मोड की पहचान, टाइमिंग हमलों के माध्यम से DevTools की उपस्थिति की जांच।

// प्रॉक्सी और एंटी-डिटेक्ट के साथ Puppeteer की बुनियादी सेटिंग
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
  headless: false, // headless: true आसानी से पहचाना जाता है
  args: [
    '--proxy-server=http://your-proxy:port',
    '--disable-blink-features=AutomationControlled',
    '--disable-dev-shm-usage',
    '--no-sandbox',
    '--disable-setuid-sandbox',
    '--disable-web-security',
    '--disable-features=IsolateOrigins,site-per-process',
    `--window-size=1920,1080`,
    '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  ]
});

const page = await browser.newPage();

// प्रॉक्सी प्रमाणीकरण
await page.authenticate({
  username: 'proxy_user',
  password: 'proxy_pass'
});

// webdriver प्रॉपर्टी को ओवरराइड करना
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'webdriver', {
    get: () => false
  });
  
  // headless के लिए प्लगइन्स का अनुकरण
  Object.defineProperty(navigator, 'plugins', {
    get: () => [1, 2, 3, 4, 5]
  });
});

गंभीर रूप से कैप्चा को पार करने के लिए, विशेष एंटी-डिटेक्ट ब्राउज़रों का उपयोग करने की सिफारिश की जाती है: Multilogin, GoLogin, AdsPower, Dolphin Anty। ये समाधान अद्वितीय फिंगरप्रिंट के साथ अलग-अलग ब्राउज़र प्रोफाइल बनाते हैं, कुकीज़ और सत्र भंडारण का प्रबंधन करते हैं, प्रॉक्सी के भू-स्थान के साथ समय क्षेत्र को स्वचालित रूप से समन्वयित करते हैं, यथार्थवादी कैनवास और WebGL फिंगरप्रिंट का अनुकरण करते हैं।

कैप्चा समाधान सेवाएँ: एकीकरण और प्रभावशीलता

जब तकनीकी तरीके अपर्याप्त होते हैं, तो कैप्चा समाधान सेवाएँ मदद करती हैं। इन्हें दो प्रकारों में विभाजित किया गया है: मानव (क्राउडसोर्सिंग) और स्वचालित (मशीन लर्निंग)। Turnstile और hCaptcha के लिए प्रभावशीलता भिन्न होती है।

मानव सेवाएँ (2Captcha, AntiCaptcha, CapSolver, CapMonster Cloud) वितरित श्रम के सिद्धांत पर काम करती हैं: आपकी कैप्चा एक वास्तविक व्यक्ति को भेजी जाती है, जो इसे मैन्युअल रूप से हल करता है। लाभ: उच्च सफलता दर (hCaptcha के लिए 95-99%, Turnstile के लिए 85-95%), जटिल दृश्य कार्यों का समर्थन, सापेक्ष स्थिरता। नुकसान: समाधान की गति 10-60 सेकंड, 1000 कैप्चा के लिए लागत $1-3, ऑपरेटरों की उपलब्धता पर निर्भरता।

स्वचालित सेवाएँ पहचान के लिए AI मॉडल का उपयोग करती हैं। ये तेजी से (1-5 सेकंड) और सस्ती होती हैं, लेकिन आधुनिक कैप्चा के लिए कम सफलता दर होती है — सामान्यतः hCaptcha के लिए 60-80% और Turnstile के लिए 50-70%। ये सरल चुनौती-आधारित कार्यों के लिए प्रभावी होती हैं, लेकिन अक्सर अदृश्य जांचों पर विफल हो जाती हैं।

// hCaptcha को हल करने के लिए 2Captcha का एकीकरण
const axios = require('axios');

async function solveHCaptcha(sitekey, pageUrl, proxyConfig) {
  const API_KEY = 'your_2captcha_api_key';
  
  // कार्य भेजना
  const createTask = await axios.post('https://2captcha.com/in.php', null, {
    params: {
      key: API_KEY,
      method: 'hcaptcha',
      sitekey: sitekey,
      pageurl: pageUrl,
      proxy: `${proxyConfig.type}:${proxyConfig.host}:${proxyConfig.port}:${proxyConfig.user}:${proxyConfig.pass}`,
      json: 1
    }
  });
  
  const taskId = createTask.data.request;
  
  // समाधान की प्रतीक्षा करना
  let solution = null;
  for (let i = 0; i < 60; i++) {
    await new Promise(resolve => setTimeout(resolve, 3000));
    
    const result = await axios.get('https://2captcha.com/res.php', {
      params: {
        key: API_KEY,
        action: 'get',
        id: taskId,
        json: 1
      }
    });
    
    if (result.data.status === 1) {
      solution = result.data.request;
      break;
    }
  }
  
  return solution; // फॉर्म में डालने के लिए टोकन
}

// Puppeteer में उपयोग
const captchaToken = await solveHCaptcha(
  'site-key-from-page',
  'https://example.com',
  { type: 'http', host: 'proxy.example.com', port: 8080, user: 'user', pass: 'pass' }
);

await page.evaluate((token) => {
  document.querySelector('[name="h-captcha-response"]').value = token;
  document.querySelector('[name="g-recaptcha-response"]').value = token;
}, captchaToken);

कैप्चा समाधान सेवा में प्रॉक्सी के सही पैरामीटर को भेजना महत्वपूर्ण है। यदि कैप्चा एक IP से हल किया जाता है, और फिर टोकन दूसरे IP के साथ उपयोग किया जाता है — मान्यता विफल हो जाएगी। आधुनिक कैप्चा टोकन को IP पते, उपयोगकर्ता-एजेंट और अन्य सत्र पैरामीटर से जोड़ते हैं।

उन्नत तकनीकें: उपकरणों का अनुकरण और TLS फिंगरप्रिंटिंग

सबसे सुरक्षित प्रणालियों को पार करने के लिए उन्नत तकनीकों की आवश्यकता होती है, जो प्रॉक्सी और ब्राउज़र की बुनियादी सेटिंग्स से परे जाती हैं। दो प्रमुख क्षेत्र — मोबाइल उपकरणों का अनुकरण और TLS फिंगरप्रिंट का प्रबंधन।

मोबाइल प्रॉक्सी और मोबाइल ब्राउज़रों के अनुकरण के संयोजन से कैप्चा के खिलाफ उच्च प्रभावशीलता मिलती है। कारण: मोबाइल ट्रैफ़िक का ट्रस्ट स्कोर अधिक होता है, मोबाइल IP पते (विशेषकर 4G/5G) अक्सर गतिशील होते हैं और स्वाभाविक रूप से बदलते हैं, मोबाइल उपकरणों के पास फिंगरप्रिंट पैरामीटर का एक अलग सेट होता है, कई साइटें मोबाइल उपयोगकर्ताओं के लिए जांचों को सरल बनाती हैं।

मोबाइल उपकरण का सही अनुकरण करने के लिए आवश्यक है: मोबाइल उपयोगकर्ता-एजेंट का उपयोग करना (उपकरण के मॉडल के साथ सटीक मेल), सही viewport और devicePixelRatio सेट करना, माउस इवेंट्स के बजाय टच इवेंट्स का अनुकरण करना, मोबाइल मानों का उपयोग करना navigator.platform और navigator.maxTouchPoints, विशिष्ट उपकरण मॉडल के लिए WebGL और कैनवास फिंगरप्रिंट को सेट करना।

// Playwright में iPhone 13 Pro का अनुकरण
const { chromium, devices } = require('playwright');

const iPhone13Pro = devices['iPhone 13 Pro'];

const browser = await chromium.launch({
  proxy: {
    server: 'http://mobile-proxy:port',
    username: 'user',
    password: 'pass'
  }
});

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

const page = await context.newPage();

// फिंगरप्रिंट के लिए अतिरिक्त सेटिंग
await page.addInitScript(() => {
  Object.defineProperty(navigator, 'hardwareConcurrency', {
    get: () => 6 // iPhone 13 Pro में 6 कोर हैं
  });
  
  Object.defineProperty(navigator, 'deviceMemory', {
    get: () => 6 // 6GB RAM
  });
});

TLS फिंगरप्रिंटिंग एक विधि है जो ग्राहक की पहचान TLS/SSL कनेक्शन के पैरामीटर के माध्यम से करती है। प्रत्येक ब्राउज़र और ऑपरेटिंग सिस्टम में अद्वितीय cipher suites, extensions, elliptic curves का संयोजन होता है, जो HTTPS कनेक्शन स्थापित करते समय भेजा जाता है। सुरक्षा प्रणालियाँ TLS फिंगरप्रिंट का विश्लेषण करती हैं और इसे घोषित उपयोगकर्ता-एजेंट के साथ तुलना करती हैं।

मानक स्वचालन उपकरणों की समस्या यह है कि वे बुनियादी Chromium का TLS फिंगरप्रिंट उपयोग करते हैं, जो पूर्ण Chrome से भिन्न होता है। यह असंगति पहचानी जाती है। समाधान: curl-impersonate या Python के लिए tls-client जैसी लाइब्रेरी का उपयोग करना, जो विशिष्ट ब्राउज़रों के TLS फिंगरप्रिंट का अनुकरण करती हैं; कस्टम TLS के साथ HTTP क्लाइंट का उपयोग करना (उदाहरण के लिए, Node.js के लिए cycletls); headless मोड के बजाय पूर्ण ब्राउज़रों का उपयोग करना।

कोड के व्यावहारिक उदाहरण

चलिए Turnstile के обход का एक पूरा उदाहरण देखते हैं, जिसमें Playwright, निवासी प्रॉक्सी और एंटी-डिटेक्ट तकनीकों का उपयोग किया गया है। यह कोड समस्या के समाधान के लिए एक समग्र दृष्टिकोण का प्रदर्शन करता है।

const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

// प्रॉक्सी कॉन्फ़िगरेशन
const proxyConfig = {
  server: 'http://residential-proxy.proxycove.com:8080',
  username: 'your_username',
  password: 'your_password'
};

// जर्मनी से वास्तविक उपयोगकर्ता का अनुकरण करने के लिए सेटिंग्स
const userConfig = {
  viewport: { width: 1920, height: 1080 },
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  locale: 'de-DE',
  timezoneId: 'Europe/Berlin',
  geolocation: { latitude: 52.5200, longitude: 13.4050 }, // बर्लिन
  permissions: ['geolocation']
};

async function bypassTurnstile(url) {
  const browser = await chromium.launch({
    headless: false, // जटिल कैप्चा के लिए महत्वपूर्ण
    proxy: proxyConfig,
    args: [
      '--disable-blink-features=AutomationControlled',
      '--no-sandbox',
      '--disable-dev-shm-usage'
    ]
  });

  const context = await browser.newContext({
    ...userConfig,
    // अतिरिक्त हेडर
    extraHTTPHeaders: {
      'Accept-Language': 'de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7',
      'Accept-Encoding': 'gzip, deflate, br',
      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
      'DNT': '1',
      'Connection': 'keep-alive',
      'Upgrade-Insecure-Requests': '1'
    }
  });

  const page = await context.newPage();

  // एंटी-डिटेक्ट स्क्रिप्टों को एम्बेड करना
  await page.addInitScript(() => {
    // webdriver को छिपाना
    Object.defineProperty(navigator, 'webdriver', {
      get: () => undefined
    });

    // chrome runtime का अनुकरण करना
    window.chrome = {
      runtime: {}
    };

    // अनुमतियों को ओवरराइड करना
    const originalQuery = window.navigator.permissions.query;
    window.navigator.permissions.query = (parameters) => (
      parameters.name === 'notifications' ?
        Promise.resolve({ state: Notification.permission }) :
        originalQuery(parameters)
    );

    // Windows के लिए अधिक यथार्थवादी मान
    Object.defineProperty(navigator, 'platform', {
      get: () => 'Win32'
    });

    Object.defineProperty(navigator, 'hardwareConcurrency', {
      get: () => 8
    });

    Object.defineProperty(navigator, 'deviceMemory', {
      get: () => 8
    });
  });

  // मानव व्यवहार का अनुकरण
  async function humanLikeDelay(min = 1000, max = 3000) {
    const delay = Math.random() * (max - min) + min;
    await page.waitForTimeout(delay);
  }

  async function humanLikeMouseMove() {
    const viewportSize = page.viewportSize();
    const x = Math.random() * viewportSize.width;
    const y = Math.random() * viewportSize.height;
    await page.mouse.move(x, y, { steps: 10 });
  }

  try {
    // पृष्ठ पर जाना
    await page.goto(url, { waitUntil: 'networkidle' });
    
    await humanLikeDelay(2000, 4000);
    await humanLikeMouseMove();

    // Turnstile के लोड होने की प्रतीक्षा करना
    await page.waitForSelector('iframe[src*="turnstile"]', { timeout: 10000 });
    
    console.log('Turnstile का पता लगाया गया, स्वचालित समाधान की प्रतीक्षा...');
    
    // प्रबंधित मोड में Turnstile अक्सर स्वचालित रूप से हल होता है
    // टोकन के प्रकट होने की प्रतीक्षा करें
    await page.waitForFunction(() => {
      const response = document.querySelector('[name="cf-turnstile-response"]');
      return response && response.value.length > 0;
    }, { timeout: 30000 });

    console.log('Turnstile सफलतापूर्वक पार किया गया!');
    
    // साइट पर आगे की क्रियाएँ
    await humanLikeDelay();
    
    // उदाहरण: फॉर्म भरना
    await page.fill('#email', 'user@example.com');
    await humanLikeDelay(500, 1500);
    
    await page.fill('#password', 'SecurePassword123');
    await humanLikeDelay(500, 1500);
    
    await humanLikeMouseMove();
    await page.click('button[type="submit"]');
    
    await page.waitForNavigation({ waitUntil: 'networkidle' });
    
    console.log('प्रमाणीकरण सफल');

  } catch (error) {
    console.error('Turnstile के обход में त्रुटि:', error.message);
    
    // डिबगिंग के लिए स्क्रीनशॉट
    await page.screenshot({ path: 'turnstile_error.png', fullPage: true });
    
  } finally {
    await browser.close();
  }
}

// प्रारंभ
bypassTurnstile('https://example.com/login');

दृश्य कार्यों के साथ hCaptcha के लिए समाधान सेवा का एकीकरण आवश्यक होगा। यहाँ 2Captcha का उपयोग करते हुए एक उदाहरण है:

const axios = require('axios');

class HCaptchaSolver {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://2captcha.com';
  }

  async solve(sitekey, pageUrl, proxy = null) {
    // कार्य बनाना
    const params = {
      key: this.apiKey,
      method: 'hcaptcha',
      sitekey: sitekey,
      pageurl: pageUrl,
      json: 1
    };

    if (proxy) {
      params.proxy = `${proxy.type}:${proxy.host}:${proxy.port}:${proxy.username}:${proxy.password}`;
      params.proxytype = proxy.type.toUpperCase();
    }

    const createResponse = await axios.post(`${this.baseUrl}/in.php`, null, { params });
    
    if (createResponse.data.status !== 1) {
      throw new Error(`कार्य बनाने में त्रुटि: ${createResponse.data.request}`);
    }

    const taskId = createResponse.data.request;
    console.log(`कार्य बनाया गया: ${taskId}`);

    // परिणाम की पोलिंग
    for (let attempt = 0; attempt < 60; attempt++) {
      await new Promise(resolve => setTimeout(resolve, 5000));

      const resultResponse = await axios.get(`${this.baseUrl}/res.php`, {
        params: {
          key: this.apiKey,
          action: 'get',
          id: taskId,
          json: 1
        }
      });

      if (resultResponse.data.status === 1) {
        console.log('hCaptcha हल किया गया!');
        return resultResponse.data.request;
      }

      if (resultResponse.data.request !== 'CAPCHA_NOT_READY') {
        throw new Error(`हल करने में त्रुटि: ${resultResponse.data.request}`);
      }

      console.log(`कोशिश ${attempt + 1}/60: कैप्चा अभी भी हल हो रहा है...`);
    }

    throw new Error('समय सीमा: कैप्चा 5 मिनट में हल नहीं हुआ');
  }
}

// Playwright के साथ उपयोग
async function bypassHCaptcha(page, proxyConfig) {
  // पृष्ठ से sitekey प्राप्त करना
  const sitekey = await page.getAttribute('[data-sitekey]', 'data-sitekey');
  const pageUrl = page.url();

  const solver = new HCaptchaSolver('your_2captcha_api_key');
  
  const token = await solver.solve(sitekey, pageUrl, {
    type: 'http',
    host: 'residential-proxy.proxycove.com',
    port: 8080,
    username: 'your_username',
    password: 'your_password'
  });

  // पृष्ठ पर टोकन डालना
  await page.evaluate((captchaToken) => {
    document.querySelector('[name="h-captcha-response"]').value = captchaToken;
    
    // कुछ साइटों के लिए g-recaptcha-response भी आवश्यक है
    const gRecaptcha = document.querySelector('[name="g-recaptcha-response"]');
    if (gRecaptcha) {
      gRecaptcha.value = captchaToken;
    }
    
    // कॉलबैक के लिए घटना को ट्रिगर करना
    const event = new Event('change', { bubbles: true });
    document.querySelector('[name="h-captcha-response"]').dispatchEvent(event);
  }, token);

  console.log('hCaptcha टोकन डाला गया');
}

निष्कर्ष

Turnstile और hCaptcha का प्रॉक्सी के माध्यम से обход एक जटिल कार्य है, जिसमें सुरक्षा तंत्रों की समझ और तकनीकों का सही संयोजन आवश्यक है। मुख्य निष्कर्ष: गुणवत्ता वाले निवासी या मोबाइल प्रॉक्सी का उपयोग करें, डेटा सेंटर प्रॉक्सी के बजाय; सभी वातावरण पैरामीटर (IP भू-स्थान, समय क्षेत्र, भाषा, स्थानीयता) का समन्वय करें; स्वचालन को छिपाने के लिए एंटी-डिटेक्ट तकनीकों का उपयोग करें; यथार्थवादी मानव व्यवहार का अनुकरण करें; कठिन मामलों के लिए कैप्चा समाधान सेवाओं का उपयोग करें।

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

कैप्चा के साथ पेशेवर काम करने के लिए, उन विशेष स्वचालन प्लेटफार्मों का उपयोग करने पर विचार करें जो प्रॉक्सी, एंटी-डिटेक्ट ब्राउज़रों और समाधान सेवाओं को एकीकृत करते हैं। यह एकीकृत करने की जटिलता को कम करता है और परिणामों की स्थिरता को बढ़ाता है। अपने लक्षित साइटों पर गुणवत्ता वाले प्रॉक्सी का परीक्षण करके शुरू करें — यह आधुनिक सुरक्षा प्रणालियों के सफल обход के लिए आधार है।