विवरण

इस रिपॉज़िटरी में Google के एंटीबॉट (reCAPTCHA) का तकनीकी विश्लेषण है, जो निम्न पर केंद्रित है:

पेलोड संरचना और मान
फ़िंगरप्रिंटिंग तकनीकें
ऑबफस्केशन तकनीकें
एंटी-डीबगिंग/टैम्परिंग तकनीकें
वर्चुअल मशीनें

संपर्क

Discord: @g_recaptcha
Telegram: @lyxlobyx

ऑबफस्केशन तकनीकें

reCAPTCHA उन एंटी-बॉट सिस्टमों में से एक है जिनमें सबसे परिष्कृत ऑबफस्केशन तकनीकें होती हैं, जो अनेक परिवर्तनों का उपयोग करती हैं जो कोड को कम पठनीय और रिवर्स इंजीनियरिंग के लिए अधिक कठिन बनाते हैं। अधिकांश ऑबफस्केशन को Abstract Syntax Tree (AST) का उपयोग करके आसानी से हेरफेर किया जा सकता है, लेकिन कुछ को रनटाइम पर प्रोसेस किया जाता है, जिससे ऐसे मामलों में AST बेकार हो जाता है। कोड में पॉलीमॉर्फिज्म भी लागू किया जाता है ताकि स्क्रिप्ट के हर संस्करण में इसकी संरचना बदलती रहे। उदाहरण के लिए, कोड क्रिया को सीधे नहीं करता। इसके बजाय, यह ऐसी वस्तुओं या फ़ंक्शनों का उपयोग करता है जो आकार बदलते हैं

अनुक्रम अभिव्यक्तियाँ कोड को प्रत्येक ब्लॉक स्टेटमेंट को एक सतत कॉमा-पृथक अभिव्यक्ति में परिवर्तित करके समतल (flatten) किया जाता है; यह if स्टेटमेंट, फ़ंक्शन आर्गुमेंट्स और यहाँ तक कि ऑब्जेक्ट्स के भीतर भी प्रकट हो सकता है
मिश्रित बूलियन अंकगणित अंकगणितीय संक्रियाओं (जोड़, घटाव, गुणा) को बिटवाइज़ संक्रियाओं (AND, OR, XOR, NOT) के साथ इस प्रकार उलझाता है कि मूल तर्क छिप जाता है, उदाहरण के लिए -2 * ~(h & H) + -2 + (h ^ H)
अप्रत्यक्ष फ़ंक्शन तालिका प्रत्येक फ़ंक्शन एक तालिका के भीतर बनाया जाता है, और उसके इंडेक्स का उपयोग करके कॉल किया जाता है, जैसे functions[index](https://github.com/elyelysiox/recaptcha/blob/HEAD/args)
इनलाइन कॉन्स्टेंट सरणी एक स्थानीय array लिटरल को अभिव्यक्ति के बीच में ही इनलाइन असाइन किया जाता है; array उन स्थिरांकों (संख्याएँ, स्ट्रिंग्स) को समूहबद्ध करता है जिन्हें फ़ंक्शन बॉडी में इंडेक्स एक्सेस के माध्यम से पुनः उपयोग किया जाता है
```
// b = [14, 1, "call"] assigned inline inside a sequence expression
function(Y, Q, c, l, G, X, W, J, b, P) {
    (Y & 94) == Y && (b = [14, 1, "call"], ...)
    W[b[2]](J, G)   // W.call(J, G)
    Y >> b[1] & b[0]  // Y >> 1 & 14
}
```
फ़ंक्शन मल्टीप्लेक्सिंग कई तार्किक रूप से भिन्न फ़ंक्शनों को एक में मिला दिया जाता है, और ब्लॉक चयनकर्ता के रूप में एक संख्यात्मक पैरामीटर का उपयोग किया जाता है। सक्रिय ब्लॉक पैरामीटर का बिटवाइज़ शर्तों के विरुद्ध मूल्यांकन करके निर्धारित किया जाता है। कॉल करने वाले पक्ष चयनकर्ता के रूप में एक संख्यात्मक लिटरल पास करते हैं
```
function(N, y, U, Y, h, H, m, C, u) {
    C = [26, 47, 6];

    // block 1
    if ((N - 2 ^ 14) < N && (N - C[2] | 28) >= N) {
        // convert value to string logic
    }

    // block 2
    if ((N + 4 & 40) >= N && (N + 5 & C[0]) < N) {
        Y = bB();
        throw Error(Y === void 0 ? "unexpected value " + U + y : Y);
    }

    return u;
}
```
लॉजिकल ऑपरेटर ब्रांचिंग if स्टेटमेंट और if/else ब्लॉकों को लॉजिकल ऑपरेटर शॉर्ट-सर्किट मूल्यांकन द्वारा प्रतिस्थापित किया जाता है, जिससे नियंत्रण प्रवाह अभिव्यक्तियों में बदल जाता है। अनुक्रम अभिव्यक्तियों के साथ संयुक्त होने पर, कई शाखाएँ एक सतत कॉमा-पृथक अभिव्यक्ति के रूप में दिखाई देती हैं
```
// if (a) { block }
a && (block)

// if (!a) { block }
a || (block)

// if (a) { x } else { y }
a ? x : y

// combined with CFF and sequence expressions:
(Y | 1) & 14 || (c = Q.O, J = c.O.length + c.g.length),
(Y ^ 59) >> 3 == 3 && (Q.classList
    ? Q.classList.add(c)
    : Z[31](31, Q, c) || (l = f[0](84, "string", "", Q), ...)),
```
बाइंड नेटिव मेथड कॉन्स्टेंट्स नेटिव ब्राउज़र मेथड्स को उनके मूल रिसीवर्स से बाइंड करके स्थिरांक के रूप में संग्रहीत करता है, ताकि छेड़छाड़ (tampering) को रोका जा सके
```
LO = (Tw = self) == null ? void 0 :
 (K9 = Tw.Math) == null ? void 0 :
 (v4 = K9.floor) == null ? void 0 :
 (mF = v4.bind) == null ? void 0 :
 mF.call(v4, Math)  // Math.floor.bind(Math)

LO(x)           // Math.floor(x)
U4()            // Math.random()
Ge(obj, prop)   // Object.defineProperty(obj, prop)
```
डेड कोड अप्राप्य या अप्रयुक्त कोड ब्लॉक पूरी फ़ाइल में इंजेक्ट किए जाते हैं, जिससे इसका आकार 60,000 से अधिक पंक्तियों तक बढ़ जाता है; यह स्थैतिक विश्लेषण और LLM-आधारित रिवर्स इंजीनियरिंग को कठिन बना देता है
कंट्रोल फ्लो फ्लैटनिंग कोड के प्रत्येक भाग (घोषणाएँ और लूप) को एक समतल स्टेट मशीन में रूपांतरित करता है। यह सभी कोड ब्लॉकों को एक केंद्रीय 'डिस्पैचर' ब्लॉक के माध्यम से मार्गबद्ध करके मूल निष्पादन तर्क को छिपाता है

डिस्पैचर आकार बदल सकते हैं; कुछ में 2-3 स्टेट वेरिएबल होते हैं, और लूप/कंडीशन का प्रकार बदलता रहता है। वे इस प्रकार दिखते हैं

यह एक CFF है जिसमें 2 स्टेट वेरिएबल हैं; एक catch ब्लॉक को संभालता है और दूसरा try ब्लॉक को।
एन्क्रिप्टेड स्ट्रिंग पूल सभी string लिटरल (DOM APIs, ब्राउज़र प्रॉपर्टीज़, CSS मान, त्रुटि संदेश, आदि) एक विशाल स्ट्रिंग पूल में एन्क्रिप्ट कर दिए जाते हैं। एक डिक्रिप्शन फ़ंक्शन प्रत्येक स्ट्रिंग को रनटाइम पर निकालने के लिए एक सीड और LCG-आधारित XOR साइफर का उपयोग करता है

पूरे कोड में 1990+ कॉल साइटें फैली हुई हैं; डिक्रिप्शन फ़ंक्शन एक रनिंग key का उपयोग करता है जो डिकोड किए गए कोडपॉइंट्स को संचित करता है, जिससे प्रत्येक अक्षर पिछले सभी अक्षरों पर निर्भर हो जाता है
```
X = function(J, b, P, F, U) {
    U = ["codePointAt", 127, "char encrypted pool"];
    for (F = (P = 0, b = "", l); P < Q; P++)
        J = (U[2][U[0]](c + P) ^ F) & U[1],  // XOR with running key
        b += String.fromCodePoint(J),
        F += J; // accumulate key
    return G = b;
}

// call sites pass a seed to locate and decrypt each string
Z[23](64, 4, 54961, 103)()  // → "lang"
Z[23](66, 4, 54961, 103)()  // → "addEventListener"
Z[23](32, 12, 20287, 852)() // → "inline-block"
```
स्टेटफुल वैल्यू इटरेटर reCAPTCHA एक स्टेटफुल फ़ंक्शन का उपयोग करता है जो रनटाइम ऑब्जेक्ट्स और मानों (जैसे window, document.body, संख्यात्मक स्थिरांक) का एक क्रम एक निश्चित क्रम में लौटाता है; प्रत्येक कॉल एक आंतरिक कर्सर को आगे बढ़ाता है, इसे क्रम से बाहर या बहुत अधिक बार कॉल करने से बाद के सभी रीड दूषित हो जाते हैं। एक टाइमआउट तंत्र एक निश्चित अंतराल के बाद स्थिति को अमान्य कर देता है, जिससे किसी भी देर से रीड के लिए null लौटता है
```
// sequential calls return different values:
c()  // → window
c()  // → document.body
c()  // → 123
c()  // → null (timeout expired)

l(c(), G[2], G[W[1]], G[1]) + l(c(), G[2], G[W[1]], 12)
// ↑ window                     ↑ window

10 * l(c(), G[2], G[W[1]], G[1]) + l(c(), G[2], G[W[1]], 12))

c().querySelectorAll(a[X[2]](98, X[1], X[1]))
// ↑ document.body  
```
कम्प्यूटेड फ़ंक्शन तालिका यह Indirect Function Table के समान है, लेकिन यहाँ प्राप्त किए जाने वाले फ़ंक्शन का इंडेक्स रनटाइम पर एक सीड के साथ, XOR और मॉडुलस का उपयोग करके गणना किया जाता है
```
c = ((Q ^ no | U[1]) >> 5) + no
A = mN[(c % U[2] + U[2]) % U[2]]  // mN is the function table (50+ functions)
```
```
q[29](5, 6977)   // seed=6977  → index resolves to function at mN[X]
q[29](53, 6187)  // seed=6187  → different index, different function
```
रनटाइम वैल्यू एन्क्रिप्शन कुछ मान (captcha कॉन्फ़िगरेशन पैरामीटर, ऐंकर पैरामीटर, आदि) कभी भी सादे पाठ में संग्रहीत नहीं किए जाते; वे संग्रह के तुरंत बाद एन्क्रिप्ट किए जाते हैं और केवल उपयोग के समय डिक्रिप्ट होते हैं; उनकी शुरुआत में B प्रीफिक्स होता है
एसिंक कंट्रोल फ्लो ऑबफस्केशन सिंक्रोनस तर्क को जनरेटर-आधारित स्टेट मशीनों में परिवर्तित किया जाता है, जो पुनरावर्ती Promise श्रृंखलाओं में लिपटे होते हैं; डीबगर में किसी भी मान को ट्रेस करने पर कई एसिंक हैंडलरों से गुजरना पड़ता है, और प्रत्येक .then() सीमा पर मूल निष्पादन संदर्भ खो जाता है

एंकर पेलोड/रेस्पॉन्स

पेलोड संरचना

reCAPTCHA आरंभ करने के घटक``` ar: <WidgetInit?> k: co: hl: v: size: sa: anchor-ms: execute-ms: cb:

### प्रतिक्रिया

प्रतिक्रिया में निम्न शामिल हैं:
- CAPTCHA iframe विंडो डिज़ाइन
- पेलोड सत्यापन के लिए उपयोग किया जाने वाला Anchor टोकन (/reload)
- प्रारंभिकरण के लिए मुख्य कॉन्फ़िगरेशन, जिसे recaptcha_en.js में प्राप्त करने के लिए `recaptcha.anchor.Main.init` विधि में निष्पादित किया जाता है

### संरचना:

नोट: Recaptcha BotGuard को `04/01/2026` को हटा दिया गया था, आप कुछ नमूने [यहाँ](https://github.com/elyelysiox/recaptcha-payload/tree/main/botguard_scripts) देख सकते हैं```javascript
[
    "ainput",
    [
        "bgdata",
        "",
        "LyogQW50aS1zcGFtLiBXYW50IHRvIHNheSBoZWxsbz8gQ29ud...", // BotGuard Script Base64-Encoded
        "YWVtZ0h5MGNCWXJDQ2lidGh0RW13RmhWdlc3aU5yeVpzSmx6U...", // BotGuard VM Bytecode Double Base64-Encoded 
        "wrB8fsOVU8K0YAzDsyQpw7ZHw6jDnMK1AMO6SRcvw53CsGlQw6/DuMO0wqr" // VM Config Bytecode Base64-Encoded
    ],
    null,
    [
        "conf",
        null,
        "6LfTV4gkAAAAACDVrUvp9_DalxUPvFSU7M2HJDO-", // Website Key
        0,
        null,
        null,
        null,
        1,
        // Indexes for fingerprinting or something else
        [16, 21, 125, 63, 73, 95, 87, 41, 43, 42, 83, 102, 105, 109, 121],
        [-7614991, 137],
        0,
        null,
        null,
        null,
        null,
        0,
        null,
        0,
        null,
        700, // Time Start for Time Variances of Fingerprint Values
        1,
        null,
        0,
        // Encoded metadata for the VM's main bytecode constructs
        "CvsCEg8I8ajhFRgAOgZUOU5CNWISDwjmjuIVGAA6BlFCb29IYxIPCMfm1DgYADoGZHhkTmlkEg8Is4qgOBgBOgZMV0o1a2ISDwiB7OgVGAA6Bkh1dlBqZhIPCK6e6zcYADoGR2JpT1FkEg8I94jmNxgAOgZvaWxlRGQSDwjwzeMVGAE6BmZJVkloYhIPCOLKoDcYAToGZ0xOQ0hjEg8I3r+3NxgBOgZlYXp1NmQSDwjY0oEyGAA6BkFxNzd2ZhIOCLjllDIYAToFUUJPRDASDwio7784GAA6BkdGVU5jZhIPCLWzqzgYAToGb3JZVjZkEg8I0tuVNxgAOgZmZmFXQWUSDwiV2JQyGAE6BlBxNjBuZBIPCKuRyjgYADoGQVo0TmJiEg8IxfOINxgAOgZhWG9pYWMSDwiNyoYyGAE6Bk93TjR0ZhIOCIr9iDcYADoFTWZJSTQaJwgDEiMdJv3NgTUZp4oJGYQKGZzijAIZzPMRGa+VQBnqsCYZ5a8MGQ==",
        0,
        1,
        null,
        null,
        1,
        null,
        null,
        0,
        null,
        null,
        0,
        0,
        "cf5e3c3a6ab6c494c829a7932d9577c1e6de862dd4912e55dc7fe2e40a1f7604"
    ],
    "https://who.clickbait.team:443", // Website URL:Port
    null,
    [
        3,
        1,
        1
    ],
    null,
    null,
    null,
    1,
    3600,
    [
        "https://www.google.com/intl/es/policies/privacy/",
        "https://www.google.com/intl/es/policies/terms/"
    ],
    "vQWNjTpMwdevQPWmE8akDzp8jsOZfa1VqTzVHaPiQ/c=",
    1,
    0,
    null,
    1,
    1777669303203, // Fingerprint Data Encryption Key
    0,
    0,
    [203], // Config Bytecode Key
    null,
    [185], // Config Bytecode Key
    "RC--rg1OSRnOD0ayA",
    null,
    null,
    null,
    null,
    null,
    // Bft Token, Used in reCAPTCHA V2
    "0dAFcWeA4RepD9zDjeMQE73pAT27pXZ7Nz_419U2K36QNqzHaKtLIDkwZQLi-Ud8OvSZHbDEcxQxusBQnsF5QQErMRpJMcUplaFg",
    1777752103288 // "oc" Data Encryption Key
]

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

मान पहले नमूने के फ़िंगरप्रिंट से डिक्रिप्ट किए गए मानों पर आधारित हैं, यहाँ देखें।

फ़िंगरप्रिंट मानों के प्रत्येक उपक्षेत्र का एक आधार प्रारूप होता है:

[value, key, elapsed]

जहाँ key एन्क्रिप्शन कुंजी है, और elapsed वह समय है जो कलेक्टर को मान प्राप्त करने और एन्क्रिप्ट करने में लगा। यह reCAPTCHA को निम्न का पता लगाने की अनुमति देता है:

अत्यधिक तेज़ निष्पादन
हुक्स
ब्रेकपॉइंट्स और सैंडबॉक्सिंग

कलेक्टर निष्पादन क्रम

सिस्टम एक आंतरिक शेड्यूलर का उपयोग करता है:``` [42, 45, 53, 30, 28, 54, 29, 31, 32, 33, 34, 35, 37, 36, 38, 39, 43, 40, 41, 46, 48, 57, 58, 60, 61, 62, 63, 64, 66, 68, 69, 71, 72, 79, 55]

यह निम्नलिखित दर्शाता है:

- निष्पादन क्रम
- कलेक्टर पाइपलाइन
- सिग्नल जनरेशन अनुक्रम

### फिंगरप्रिंट सिग्नल कोड और कुंजी व्युत्पत्ति
फिंगरप्रिंट सिग्नल्स को बहु-चरणीय व्युत्पत्ति पाइपलाइन के माध्यम से नियतात्मक एन्क्रिप्शन कुंजियों में रूपांतरित करता है

प्रत्येक फिंगरप्रिंट मान है:

- सामान्यीकृत
- एक संक्षिप्त सिग्नल कोड में एन्कोड किया जाता है
- एक संख्यात्मक एन्क्रिप्शन कुंजी में परिवर्तित किया जाता है
- व्युत्पन्न कुंजी का उपयोग करके एन्क्रिप्ट किया जाता है

यह प्रक्रिया नियतात्मक है, अर्थात समान इनपुट मान हमेशा समान सिग्नल कोड और एन्क्रिप्शन कुंजी उत्पन्न करता है।```
Raw Value
   ↓
Signal Code Derivation
   ↓
Compact Signal Code
   ↓
Numeric Key Derivation
   ↓
Encryption Key
   ↓
Value Encryption

उदाहरण

इनपुट सिग्नल``` "BUTTON,195a81c9"

***चरण 1 - सिग्नल कोड व्युत्पन्न करें***```javascript
deriveSignalCode("BUTTON,195a81c9")
// → "wg"

उत्पन्न सिग्नल कोड मूल मान के लिए एक संक्षिप्त निर्धारणात्मक पहचानकर्ता है।

चरण 2 - संख्यात्मक कुंजी व्युत्पन्न करें```javascript deriveKey("wg") // → 3792

सिग्नल कोड को एक संख्यात्मक एन्क्रिप्शन कुंजी में बदल दिया जाता है।

***चरण 3 — मान एन्क्रिप्ट करें***```javascript
encryptValueWithKey(3792, "wgia1z9pwq")
// → "bYVbh6BUsE_5pLA"

अगला मान व्युत्पन्न कुंजी के साथ, संग्राहक क्रम के अनुसार एन्क्रिप्ट किया जाएगा।

समग्र फ़िंगरप्रिंट संरचना

सभी उत्पन्न सिग्नल कोड एक संक्षिप्त क्रमबद्ध संरचना में एकत्रित किए जाते हैं

प्रक्रिया``` value -> "BUTTON,195a81c9" seed code -> wg key -> 3792 value -> "wgia1z9pwq" seed code -> 21 key -> 1599 value -> 1 seed code -> p1 key -> 3521 value -> "8cc68d83" seed code -> ld key -> 3448 value -> "https://nextcaptcha.com/demo..." seed code -> 9p key -> 1879 value -> 4 seed code -> op key -> 3553 value -> false seed code -> 1r key -> 1633 value -> 7 seed code -> qf key -> 3605 value -> "jYAQSHAEAI" seed code -> 1z key -> 1641 value -> "" seed code -> 80 key -> 1784 value -> 2 seed code -> jk key -> 3393 value -> "AAAAAAAAAA" seed code -> 1z key -> 1641 value -> "h3" seed code -> 9p key -> 1879 value -> "0,BUTTON,195a81c9" seed code -> ia key -> 3352 value -> -1 seed code -> 1u key -> 1636 value -> 0 seed code -> wq key -> 3802 value -> "74,fbfbc5b3" seed code -> 6z key -> 1796 value -> 0 seed code -> wq key -> 3802 value -> 0 seed code -> wq key -> 3802 value -> 2 seed code -> jk key -> 3393 value -> 0 seed code -> wq key -> 3802 value -> "-1,-1" seed code -> 1m key -> 1628 value -> "static.cloudflareinsights.co,..." seed code -> 1g key -> 1622 value -> "" seed code -> 80 key -> 1784 value -> "https://nextcaptcha.com,https...." seed code -> pd key -> 3572 value -> "[4,"CABIBQAggA","BAgAAgAAgA"]" seed code -> 1n key -> 1629 value -> "Demostración empresarial de reCAPTCHA v3..." seed code -> 1k key -> 1626 value -> "[2,76852,77850,77351]" seed code -> 9b key -> 1865 value -> "sha384-TNm" seed code -> 23 key -> 1601 value -> "[1680,1050,876,1166,844,876]" seed code -> 13 key -> 1570 value -> "[300,null,1778502450481]" seed code -> ex key -> 3251 value -> "[null,null,"",""]" seed code -> rx key -> 3654 value -> "[2147483648,70806416,65303240]" seed code -> 2r key -> 1664 value -> "GA1.1.354395113.1778502448" seed code -> 1g key -> 1622 value -> false seed code -> 1r key -> 1633 value -> "[[[1,"wg"],..." seed code -> 85 key -> 1789

**अंतिम**```json
[
  [
    [1, "wg"], [1, "21"], [1, "p1"],
    [1, "ld"], [1, "9p"], [1, "op"],
    [1, "1r"], [1, "qf"], [1, "1z"],
    [1, "80"], [1, "jk"], [1, "1z"],
    [1, "9p"], [1, "ia"], [1, "1u"],
    [1, "wq"], [1, "6z"], [1, "wq"],
    [1, "wq"], [1, "jk"], [1, "wq"],
    [1, "1m"], [1, "1g"], [1, "80"],
    [1, "pd"], [1, "1n"], [1, "1k"],
    [1, "9b"], [1, "23"], [1, "13"],
    [1, "ex"], [1, "rx"], [1, "2r"],
    [1, "1g"], [1, "1r"]
  ],
  "54"
]

संकेत

Idx 4 (string)
- मान: 3ccb
- हैश किया गया: true
- विवरण: window.localStorage.getItem("rc::a ") + "6d" को बाइट्स में परिवर्तित करके उस कुंजी से एक HMAC कुंजी उत्पन्न करता है, HMAC-SHA256(siteKey) की गणना करता है, और परिणाम के पहले 4 हेक्साडेसिमल वर्ण लौटाता है।
  
  rc::a का मान बेतरतीब ढंग से उत्पन्न base64 है।
Idx 5 (integer)
- मान: window.localStorage.length * 2
- हैश किया गया: false
- विवरण: window.localStorage.length की लंबाई 2 से गुणा
Idx 16 (string)
- मान: yM5Us/j/fn6EDgtmPlP4Pxj605nMJN9dRYHyy5Mn

कुछ reCAPTCHA सिग्नल उपलब्ध नहीं हो सकते हैं या एकत्र नहीं किए जा सकते (डिबगिंग-संबंधित टाइमआउट के कारण)। ऐसे मामलों में, लापता सिग्नल को बेतरतीब ढंग से उत्पन्न base64-एनकोडेड मान से भर दिया जाता है। उदाहरण के लिए:``` ["CMXZyamk3ZHNjdGsyaQ==", 3249, 591]

एक बार फिंगरप्रिंट निर्माण पूरा हो जाने पर, इसे एक स्ट्रिंग में क्रमबद्ध (serialize) किया जाता है और एंकर फ़ील्ड (index 18) से लोड की गई एन्क्रिप्शन कुंजी का उपयोग करके एन्क्रिप्ट किया जाता है। एन्क्रिप्टेड परिणाम फिर `/reload` पेलोड के index `16` फ़ील्ड में संग्रहीत किया जाता है।

## VM सिग्नल

निम्नलिखित आंतरिक reCAPTCHA VM द्वारा प्राप्त ब्राउज़र मान हैं, साथ ही सिग्नल कुंजी भी। कुछ मान नमूना फिंगरप्रिंट में नहीं दिखाए गए हैं क्योंकि VM केवल कॉन्फ़िगरेशन बाइटकोड से कुछ मान निकालता है। इसलिए, अन्य मान प्रदर्शित किए जाएंगे। अधिक विवरण के लिए, [यहाँ](https://github.com/elyelysiox/recaptcha-vm) देखें।

आधार सिग्नल प्रारूप:```
[
  null,
  collectorElapsed,
  encryptElapsed,
  value
]

जहाँ collectorElapsed का अर्थ है कि कलेक्टर को मान प्राप्त करने में कितना समय (ms) लगा और encryptElapsed का अर्थ है कि मान को एन्क्रिप्ट करने में कितना समय (ms) लगा। ये समय VM के निष्पादन के दौरान मापे जाते हैं।

संरचना```json

[ null, 7, 0, "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36" ], null, null, [ null, 0, 0, "[]" ], null, null, [ null, 4, 0, "["Join And Get Free Trial!","","Captcha Solving Service","Products","Docs"]" ], [ null, 0, 0, "false" ], null, [ null, 0, 0, "0" ], [ null, 1, 0, "[null,null,null,null,"false"]" ], [ null, 3, 4, "[[[0,921],[1,2053]],[[235054,1,1,1],[164277,3,4,1]],2,39]" ], [ null, 1, 4, "[[[0,0,979]],1,0]" ], [ null, 1, 1, "[[[1,0]]]" ], [ null, 4, 1, "[886,2300,262.2099999997952,392.7600000009595,2050.2399999993577]" ], [ null, 1, 1, "[[[1123,0,0]]]" ], [ null, 1, 2, "[[[1123,0]]]" ], [ null, 1, 3, "[0,null,null,null,null,null,null]" ], [ null, 5, 9, "[1,[[2050,125,633,266,[609,266,105,44],3,1,50,1,1]],[3,3,318],[28,777,858,28],0,0,25]" ], [ null, 0, 0, "" ], [ null, 0, 0, "229.6" ], [ null, 0, 0, "false" ], [ null, 1, 0, "[1,0,0,Infinity]" ], [ null, 1, 1, "["0",-1,-1,999]" ], [ null, 1, 0, "["undefined",3]" ], [ null, 1, 6, "[2,4,53324367238]" ], [ null, 12, 0, "["Google Inc. (Intel Inc.)","ANGLE (Intel Inc., Intel(R) UHD Graphics 630, OpenGL 4.1)",30]" ], [ null, 28, 2, "[1542343452,0,105002991,3556653,96784904,-731949068,-902263026,-1914850612,571474391,-1588406278,3443508,1967713171,-1249474914,-1588406278,0,918504841,-807058197]" ]

- **Key 417** (`string`)
  - Value: `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...`
  - विवरण: पूर्ण ब्राउज़र User-Agent

- **Key 727** (`array`)
  - Value: `[]`
  - विवरण: उत्पाद मूल्य ब्लॉक, इसमें वेबसाइट पर मौजूद वाणिज्यिक उत्पादों की कीमतें होती हैं, ये Amazon, eBay, AliExpress आदि जैसी मार्केटप्लेस वेबसाइटों पर दिख सकती हैं, [Sample](https://github.com/elyelysiox/recaptcha/blob/main/findProductPricesBlock.js)

- **Key 150** (`array`)
  - Value: `[\"Join And Get Free Trial!\",\"\",\"Captcha Solving Service\",\"Prod...`
  - विवरण: वेबसाइट के `<a>` एलिमेंट्स से निकाले गए लिंक, VM इन मानों को बहुत कम निकालता है

- **Key 545** (`boolean`)
  - Value: `false`
  - विवरण: `navigator.webdriver`

- **Key 370** (`integer`)
  - Value: `0`
  - विवरण: अधिकतम डिवाइस टच पॉइंट्स `navigator.maxTouchPoints`

- **Key 779** (`array`)
  - Value: `[null,null,null,null,"false"]`
  - विवरण: शिपिंग/बिलिंग फ़ील्ड से डेटा निकालता है, [Sample](https://github.com/elyelysiox/recaptcha/blob/main/formFieldScrape.js)
  
    `postal|postalcode|postalcode|postal_code|zip` → पोस्टल कोड फ़ील्ड खोजता है
    
    `ship|deliver` → शिपिंग अनुभाग
    
    `billing|payment|credit` → बिलिंग अनुभाग
    
    `country` → देश चयनकर्ता
    
    `addr.*(match|equal)|(match|equal).*address` → "समान पता" चेकबॉक्स
    
    प्रत्येक एलिमेंट का name, id, autocomplete, className पढ़ता है
    तीन चरण: टेक्स्ट इनपुट, SELECT स्टेटमेंट, चेकबॉक्स

- **Key 659** (`array`)
  - Value: `[[[0,921],[1,2053]],[[235054,1,1,1],[164277,3,4,1]],2,39]`
  - विवरण: पृष्ठ पर दबाए गए एलिमेंट्स का डेटा `[[[count,timestamp]],[[hashedElem,tagType,type,autoComplete]],pressedCount,behaviorChecksum]` प्रारूप में होता है
 
    ### एलिमेंट प्रकार
    
    | एलिमेंट प्रकार | आईडी |
    |-------------|----|
    | `""` | 1 |
    | `text` | 2 |
    | `button` | 3 |
    | `submit` | 4 |
    | `checkbox` | 5 |
    | `email` | 6 |
    | `password` | 7 |
    | `select-one` | 8 |
    | `select-multiple` | 9 |
    | `radio` | 10 |
    | `textarea` | 11 |
    | `file` | 12 |
    | `tel` | 13 |
    | `number` | 14 |
    | `date` | 15 |
    | `reset` | 16 |
    | `range` | 17 |

    ### व्यवहार CheckSum एल्गोरिथम
    
    behaviorChecksum एक संक्षिप्त व्यवहारिक स्कोर है जो एकत्रित उपयोगकर्ता इंटरैक्शन डेटा से प्राप्त होता है।
 
    प्रत्येक इंटरैक्शन के लिए:
    - इंटरैक्शन इंडेक्स एक से बढ़ाया जाता है
    - टाइमस्टैम्प को समायोजित इंटरैक्शन इंडेक्स के साथ जोड़ा जाता है
    - एलिमेंट हैश को मॉड्यूलो ऑपरेशन का उपयोग करके घटाया जाता है
    - परिणाम एक चालू स्कोर में जमा किया जाता है
   
    ---

    ```javascript
    function computePressedElementsChecksum(pressedElementsArray) {
      let accumulator = 0;
    
      for (const [countTimestampPair, elementInfo] of zip(
        pressedElementsArray[0],
        pressedElementsArray[1],
      )) {
        const shiftedTimestamp = countTimestampPair[0] + 1;
        const baseValue = countTimestampPair[1] + shiftedTimestamp;
        const remainder = elementInfo[0] % baseValue;
        accumulator = remainder + accumulator;
      }
    
      const logTerm = Math.log(accumulator + 1) * 4;
      const modTerm = accumulator % 10;
      const behaviorChecksum = Math.floor(logTerm + modTerm);
    
      return JSON.stringify(pressedElementsArray);
    }

    function zip(a, b) {
      const length = Math.min(a.length, b.length);
      const result = [];
      for (let i = 0; i < length; i++) {
        result.push([a[i], b[i]]);
      }
      return result;
    }
    ```

    ### उदाहरण

    ```javascript
    const checksum = computePressedElementsChecksum([[[0,921],[1,2053]],[[235054,1,1,1],[164277,3,4,1]],2,39]);
    console.log(checksum); // → 39
    ```

- **Key 959** (`array`)
  - Value: `[[[0,0,979]],1,0]`
  - विवरण: पृष्ठ सत्र के दौरान एकत्रित स्क्रॉल गतिविधियाँ शामिल हैं
 
    ### आधार प्रारूप
    ```
    [ [ [ scrollX, scrollY, timestamp ] ], count, behaviorChecksum ]
    ```

- **Key 895** (`array`)
  - Value: `[[[1,0]]]`
  - विवरण: `VisibilityStateEntry` पृष्ठ दृश्यता स्थिति को ट्रैक करता है, यह दर्शाता है कि उपयोगकर्ता वर्तमान में पृष्ठ देख रहा है या दूसरी जगह चला गया है, प्रारूप `[[[isVisible, startTime]]]` में

- **Key 1092** (`array`)
  - Value: `[886,2300,262.2099999997952,392.7600000009595,2050.2399999993577]`
  - विवरण: reCAPTCHA प्रदर्शन, PerformanceNavigationTiming और PerformanceEventTiming, प्रारूप `[vmStart,vmEnd,domContentLoadedEventEnd,loadEventEnd,firstUserInteractionTime]` में

- **Key 41** (`array`)
  - Value: `[[[1123,0,0]]]`
  - विवरण: ClearTimeout

- **Key 43** (`array`)
  - Value: `[[[1123,0]]]`
  - विवरण: ClearTimeout

- **Key 549** (`array`)
  - Value: `[0,null,null,null,null,null,null]`
  - विवरण: KeyboardEvent, संगणित कुंजियाँ + टाइमस्टैम्प

- **Key 352** (`array`)
  - Value: `1,[[2050,125,633,266,[609,266,105,44],3,1,50,1,1]],[3,3,318],...`
  - विवरण:
    संरचना में शामिल है:

    - माउस गति समय
    - कर्सर निर्देशांक
    - क्लिक अवधि
    - दबाए गए एलिमेंट के आयाम
    - पॉइंटर प्रकार जानकारी
    - दबाव मेट्रिक्स
    - कर्सर यात्रा दूरी
    - व्यवहारिक समय आँकड़े

    ### आधार प्रारूप:
    ```
    [
      eventsCount,
      mouseEvents,
      [
        coalescedEventsCount,
        averageInterEventDelay,
        timingVarianceScore
      ],
      [
        totalPoints,
        clickSequenceScore,
        totalCursorDistance,
        totalPoints
      ],
      0,
      0,
      behaviorChecksum
    ]
    ```
    
    ### माउस इवेंट संरचना:
    
    mouseEvents के अंदर प्रत्येक प्रविष्टि इस संरचना का अनुसरण करती है:
    
    ```
    [
      timestamp,
      clickDuration,
      clientX,
      clientY,
      [
        elementLeft,
        elementTop,
        elementWidth,
        elementHeight
      ],
      elementTagType,
      trackedElementIndex,
      pressure,
      pointerTravelDistance,
      pointerArea
    ]
    ```

    | नाम | विवरण |
    |---|---|
    | `timestamp` | इवेंट प्रारंभ के सापेक्ष इवेंट टाइमस्टैम्प |
    | `clickDuration` | `pointerdown` और `pointerup` के बीच की अवधि |
    | `clientX` | ... |
    | `clientY` | ... |
    | `elementBounds` | इंटरैक्ट किए गए एलिमेंट का बाउंडिंग आयत |
    | `elementTagType` | इंटरैक्ट किए गए एलिमेंट का एन्कोडेड DOM टैग पहचानकर्ता |
    | `trackedElementIndex` | रनटाइम इंटरैक्शन मैप से इंटरैक्ट किए गए DOM एलिमेंट का आंतरिक पहचानकर्ता |
    | `pressure` | सामान्यीकृत पॉइंटर दबाव मान, `100` से गुणा |
    | `pointerTravelDistance` | `pointerdown` और `pointerup` के बीच तय की गई दूरी |
    | `pointerArea` | `width * height` के रूप में गणना किया गया संपर्क क्षेत्र |

    ### एलिमेंट टैग प्रकार

    यह reCAPTCHA VM के निष्पादन के दौरान आरंभ किया जाता है

    | प्रकार  | आईडी |
    |-----------|----|
    | `BODY`    | 1  |
    | `INPUT`   | 2  |
    | `BUTTON`  | 3  |
    | `SELECT`  | 4  |
    | `TEXTAREA`| 5  |
    | `FORM`    | 6  |
    | `A`       | 7  |
    | `AREA`    | 8  |
    | `AUDIO`   | 9  |
    | `VIDEO`   | 10 |
    | `IFRAME`  | 11 |
    | `DIV`     | 12 |
    | `SPAN`    | 13 |
    | `LABEL`   | 14 |

    ### उदाहरण
    ```
    [
      18342,
      91,
      742,
      381,
      [700, 320, 120, 38],
      3,
      1,
      50,
      1.4,
      16
    ]
    ```
    
    दर्शाता है:
    
    - इवेंट `18.342s` पर
    - क्लिक अवधि `91ms`
    - क्लिक `(742, 381)` पर
    - एक `BUTTON` के साथ इंटरैक्शन
    - पॉइंटर दबाव `0.5` (50)
    - क्लिक के दौरान हल्की कर्सर गति
    - पॉइंटर संपर्क क्षेत्र `16`
   
    ### व्यवहार CheckSum एल्गोरिथम
 
    प्रत्येक माउस इवेंट के लिए:

    - क्लिक अवधि को बढ़ाया जाता है
    - परिणाम को इवेंट टाइमस्टैम्प के साथ जोड़ा जाता है
    - कर्सर निर्देशांक और एलिमेंट आयामों को एक साथ मिलाया जाता है
    - एक भारित अनुपात की गणना की जाती है
    - अनुपात को पूर्णांकित कर जमा किया जाता है
    
    सभी इवेंट संसाधित होने के बाद:
    
    - संचित स्कोर को कुल कर्सर दूरी के साथ जोड़ा जाता है
    - परिणाम को एकत्रित बिंदुओं की संख्या का उपयोग करके सामान्यीकृत किया जाता है
    - एक लघुगणकीय परिवर्तन लागू किया जाता है
    - अतिरिक्त गति आँकड़े शामिल किए जाते हैं
    - अंतिम मान को मॉड्यूलो ऑपरेशन का उपयोग करके घटाया जाता है
    - परिणाम को एक छोटे पूर्णांक स्कोर में पूर्णांकित किया जाता है
    
    ---
    
    ```javascript
    function computeMouseBehaviorChecksum(mouseDataArray) {
      let totalSum = 0;
    
      for (let i = 0; i < mouseDataArray[1].length; i++) {
        const event = mouseDataArray[1][i];
    
        const scaledClickDuration = event[1] * 4;
        const xPlusScaledDuration = event[0] + scaledClickDuration;
        const combinedElementDims = event[2] + event[4][2] + event[4][1]; // clientY + elementWidth + elementTop
        const product = xPlusScaledDuration * combinedElementDims;
        const divisor = event[3] + event[4][3] + event[4][0] + 1; // elementTagType + elementHeight + elementLeft + 1
        const roundedValue = Math.round(product / divisor);
    
        console.log(roundedValue);
        totalSum += roundedValue;
      }
    
      const summaryArray = mouseDataArray[3]; // [totalPoints, clickSequenceScore, totalCursorDistance, totalPoints]
      const sumPlusCursorDistance = totalSum + summaryArray[2];
      const totalPointsPlusOne = summaryArray[0] + 1;
      const ratio = sumPlusCursorDistance / totalPointsPlusOne;
      const ratioPlusOne = ratio + 1;
      const logRatio = Math.log(ratioPlusOne);
      const scaledLog = logRatio * 4;
      const ratioPlusTotalPoints = ratio + summaryArray[0];
      const ratioPlusTotalPointsPlusScore = ratioPlusTotalPoints + summaryArray[1];
      const modResult = ratioPlusTotalPointsPlusScore % 11;
      const behaviorChecksum = Math.round(scaledLog + modResult);
      return JSON.stringify(mouseDataArray);
    }
    ```

    ### उदाहरण

    ```javascript
    const checksum = computeMouseChecksum([1,[[2050,125,633,266,[609,266,105,44],3,1,50,1,1]],[3,3,318],[28,777,858,28],0,0,25]);
    console.log(checksum); // → 25
    ```

- **Key 360** (`string`)
  - Value: `""`
  - विवरण: वेबसाइट मूल्य कुल $ का संग्रह, रेगेक्स ``(?i)total[\S\s]{0,20}?(?:(?:(?:USD|\$)\s*)?[\d\.,]+\s*(?:USD|\$)|(?:USD|\$)\s*[\d\.,]+)`` के साथ पार्सिंग, [Sample](https://github.com/elyelysiox/recaptcha/blob/main/websitePricesTotal.js)

- **Key 1278** (`integer`)
  - Value: `229.6`
  - विवरण: वर्तमान रनटाइम समय का 10 से विभाजन `Math.trunc(performance.now()) / 10`
    
- **Key 1422** (`boolean`)
  - Value: `false`
  - विवरण: जाँच करता है कि वेबसाइट पर OTP/2FA फ़ील्ड मौजूद हैं या नहीं, [Sample](https://github.com/elyelysiox/recaptcha/blob/main/parseOTPFields.js)

- **Key 614** (`array`)
  - Value: `[1,0,0,Infinity]`
  - विवरण: डिवाइस बैटरी जानकारी, प्रारूप `[level,isCharging,chargingTime,dischargingTime]` में

- **Key 2033** (`array`)
  - Value: `["0",-1,-1,999]`
  - विवरण: कुछ VM स्थिर मान और VM रनटाइम समय

- **Key 1313** (`array`)
  - Value: `["undefined",3]`
  - विवरण: Android, Chrome जाँच, `[typeof window.android, Object.keys(window.chrome).length]`

- **Key 1994** (`array`)
  - Value: `[2,4,53324367238]`
  - विवरण: `[navigator.hardwareConcurrency, navigator.deviceMemory, navigator.storage.estimate().qouta]`

- **Key 1310** (`array`)
  - Value: `["Google Inc. (Intel Inc.)","ANGLE (Intel Inc.,...`
  - विवरण: WebGL Renderer, Vendor और Total Extensions, [Sample](https://github.com/elyelysiox/recaptcha/blob/main/webglSignals.js)


- **Key 291** (`array`)
  - Value: `[1542343452,0,105002991,3556653,96784904,-731949068,-902263026,...`
  - विवरण: ब्राउज़र ऑब्जेक्ट्स के हैश किए गए विशिष्ट Prototypes, जैसे `SpeechSynthesisEvent`, `NetworkInformation`, `HTMLElement`, आदि, [Sample](https://github.com/elyelysiox/recaptcha/blob/main/hashBrowserProtos.js)

## Reload अनुरोध Payload

यह डेटा protobuf (Protocol Buffers) का उपयोग करके क्रमबद्ध किया जाता है, जो Google द्वारा विकसित संरचित डेटा को क्रमबद्ध करने की एक कुशल, तटस्थ विधि है।```javascript
[
  "rreq",
  "U5VsmTDhJM1iOJUyw4DEUTYv",
  "03AFcWeA5Els3SIQviW2OYCHYD4uDhKlFPG6A48z2nk74BC2vrXSRvtpP9uVkWW96kUKm7sHIr...",
  null,
  null,
  "-383788762",
  "q",
  "05APQrAobTCFGtbKVY3NwExv-K_G7oqmzGyUcTXi532CBKvSJUiT49tkRSgGD__OdfVRZtrI3i...",
  "submit",
  null,
  null,
  null,
  null,
  null,
  "6LcAbwIqAAAAAJvVAhSSJ8qzYsujc7kn1knmSgQX",
  null,
  "0XA4cHhALxgMF9_Kt6uze2ZTR08XAe2x8o3BrU1hbTouNf3o1cnRmYRxZW01IA0BCNC_qJykb...",
  null,
  null,
  null,
  "tbMywxNTQsODQ0XSxbMSwyOTksMTA4Nl1dLFtbMiw2MSwxMzIuNzM5OTk5OTk5ODQ2MzNdLF...",
  "0aAPQrAobqMEazjp9PGLYWTgxWGGcq9k5MJNI6LFBWfTh0UkDaVobdH-InwAYsTXtxs3rH_fI",
  "BDAAYAIAGEcAAUoYI4lDCKAsCJlcgB6AAJtgggoIEEOALSoQRZxSZyAJBHANCkAJQYhFJES...",
  null,
  null,
  "W1tbNTAwNiw0M10sWzY0NjA3LDFdLFs0NTQ2NCwxXSxbMzU4MzcsMV1dXQ==",
  null,
  null,
]

घटक

चैलेंज मोड

मान	विवरण
`q`	reCAPTCHA V3 चैलेंज
`fi`	reCAPTCHA V2/अदृश्य चैलेंज
`a`	ऑडियो चैलेंज

टेलीमेट्री पेलोड (`Idx 20`)

डिकोड करने के लिए:```javascript atob("W1tbMywwLDgyOV0sWzEs...") // → [[[3,0,829],[1,42,863]],[[2,727,1341.300000011921]...

पेलोड में शामिल हैं:

- रिसोर्स टाइमिंग जानकारी
- लंबे-कार्य प्रदर्शन समय
- reCAPTCHA VM निष्पादन डेल्टा
- वेबसाइट स्क्रिप्ट URL
- ब्राउज़र ऑब्जेक्ट संग्रह आँकड़े

### मूल संरचना```js
[
  [recaptchaResources],
  [tasksTiming],
  [
      null,
      null,
      null,
      idleTimeoutDelta,
      deltaTiming,
      0,
      0,
      0,
  ],
  websiteScriptsUrls,
  [collectionElapsed, browserObjectsLength]
]

लंबे कार्य टाइमिंग प्रारूप```js

[ PerformanceLongTaskTiming.name == "self" ? 2 : 4, PerformanceLongTaskTiming.duration, PerformanceLongTaskTiming.startTime ]

### reCAPTCHA Resource Timing प्रारूप```js
[
   resourceType,
   duration,
   startTime
]

Resource

इवेंट काउंटर (`Idx 25`)

यह फ़ील्ड निष्पादन के दौरान एकत्रित ब्राउज़र इंटरैक्शन इवेंट के लिए Base64-एन्कोडेड काउंटर रखता है

डिकोड किया गया उदाहरण:```js [ [ [5006, 43], [64607, 1], [45464, 1], [35837, 1] ] ]

### इवेंट काउंटर संरचना```js
[
  [
    [eventType, count]
  ]
]

ज्ञात इवेंट हैश

प्रतिक्रिया संरचना```js

[ "rresp", "", null, 120, [ "pmeta", [ "/m/013xlm", null, 3, 3, 3, null, "Tractor" ], null, [1] ], "", null, null, "", "", null, null, "", null, "", "", 0 ]

## फ़ील्ड विवरण

| इंडेक्स | नाम | विवरण |
|---|---|---|
| `0` | `rresp` | रीलोड एंडपॉइंट द्वारा लौटाया गया प्रतिक्रिया प्रकार पहचानकर्ता |
| `1` | `responseToken` | reCAPTCHA प्रतिक्रिया टोकन |
| `3` | `tokenExpiration` | समाप्ति से पहले टोकन का जीवनकाल (सेकंड में) |
| `4` | `pmeta` | चुनौती मेटाडेटा ब्लॉक जिसमें CAPTCHA प्रकार, श्रेणी और ग्रिड लेआउट के बारे में जानकारी होती है |
| `5` | `challengeType` | CAPTCHA चुनौती का प्रकार |
| `8` | `usagePatternToken` | उपयोग पैटर्न, `window.sessionStorage` में संग्रहीत होते हैं और भविष्य के `/reload` अनुरोधों में पुनः उपयोग किए जाते हैं |
| `9` | `challengeImageToken` | टोकन का उपयोग `/payload` एंडपॉइंट से CAPTCHA इमेज पेलोड प्राप्त करने के लिए किया जाता है |
| `12` | `humanVerificationToken` | Google reCAPTCHA स्थिति और ब्राउज़र कुकीज़ से संबंधित मानव पहचान टोकन |
| `14` | `captchaSessionToken` | आंतरिक सत्र टोकन |
| `15` | `bftToken` | ... |

---

### `pmeta` संरचना

उदाहरण:

``````js
[
    "pmeta",
    [
        "/m/013xlm",
        null,
        3,
        3,
        3,
        null,
        "Tractor"
    ],
    null,
    [1]
]

`pmeta[1]` मान

चुनौती प्रकार

चुनौती छवि प्राप्ति

Idx 9 (challengeImageToken) पर मौजूद मान CAPTCHA छवि प्राप्त करने के लिए उपयोग किया जाता है:```txt https://www.google.com/recaptcha//payload ?p= &k=

### श्रेणी पहचानकर्ता

| ID | श्रेणी |
|---|---|
| `/m/0pg52` | टैक्सी |
| `/m/01bjv` | बस |
| `/m/02yvhj` | स्कूल बस |
| `/m/04_sv` | मोटरसाइकिल |
| `/m/013xlm` | ट्रैक्टर |
| `/m/01jk_4` | चिमनी |
| `/m/014xcs` | पैदल यात्री क्रॉसिंग |
| `/m/015qff` | ट्रैफिक लाइट |
| `/m/0199g` | साइकिल |
| `/m/015qbp` | पार्किंग मीटर |
| `/m/0k4j` | कार |
| `/m/015kr` | पुल |
| `/m/019jd` | नाव |
| `/m/0cdl1` | ताड़ का पेड़ |
| `/m/09d_r` | पर्वत / पहाड़ी |
| `/m/01pns0` | फायर हाइड्रेंट |
| `/m/01lynh` | सीढ़ियाँ |

## UserVerify अनुरोध पेलोड
`/userverify` पेलोड उपयोगकर्ता द्वारा reCAPTCHA v2 इमेज चुनौती पूरी करने के बाद प्रस्तुत किया जाता है

# पेलोड संरचना```
v: hsFBb1u5wWWWkWP4in1ua2cQ
c: 03AFcWeA5RIHz5mI2COQqTcLjdrC7FiPpdfkX-hB-B2iFenI...
response: eyJyZXNwb25zZSI6WzMsMSw0LDksMCwxMSwxMCwxMywxNF0....
t: 24521
ct: 24521
ch: -4007845
oc: 0ZpqzzPgYKEEaN0xpfo3v_voeVUySZK3Ktf_fLVRdhnu3yeTy4BhO...
pm: 51bGwsbnVsbCxbbnVsbCxudWxsLG51bGwsWzEwLDQuMjcwMDAwMD....

घटक

`response` पेलोड

यह ग्रिड में उपयोगकर्ता द्वारा चयनित वर्गों के इंडेक्स/स्थितियों को दर्शाता है

पेलोड को सबमिशन से पहले JWT के रूप में एन्कोड किया जाता है

3×3 ग्रिड उदाहरण

grid33 ```txt 0 1 2 3 4 5 6 7 8

उदाहरण पेलोड:```json
{
  "response": [2, 3, 6]
}

4×4 MultiCaptcha ग्रिड उदाहरण

grid44 ```txt 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

उदाहरण पेलोड:```json
{
  "response": [2, 3, 6, 14]
}

`e` फ़ील्ड

response पेलोड में एक e फ़ील्ड भी शामिल हो सकती है:```json { "response": [2, 3, 6, 14], "e": "bxCoiXVt49I7CTS_tNlVbGg" }

इस फ़ील्ड में CAPTCHA बटन क्रियाओं से संबंधित एन्क्रिप्टेड इंटरैक्शन मेटाडेटा होता है, जैसे:

- `Verify`
- `Next`
- `Skip`

### `e` की आंतरिक संरचना

डिक्रिप्शन के बाद, संरचना कुछ इस प्रकार दिखती है:```txt
[[["9ffd9672"]]]

प्रत्येक मान rc-button-default बटन क्लास/कार्रवाई के लिए एक हैश्ड पहचानकर्ता दर्शाता है

हैश है:

SHA-256-आधारित
8 अक्षरों में छोटा किया गया

लंबी इंटरैक्शन अनुक्रम इस तरह दिख सकते हैं:```txt [ [ ["9ffd9672"], ["9ffd9672"], ["9ffd9672"], ["9ffd9672"] ] ]

### `oc` — एन्क्रिप्टेड VM सिग्नल

यह `/reload` अनुरोध पेलोड के `idx 16` फ़ील्ड के समान एन्क्रिप्शन एल्गोरिदम का उपयोग करता है, जिसमें एन्क्रिप्शन कुंजी एंकर (इंडेक्स 31) `1777752103288` में लोड की गई है।

### `pm` — टेलीमेट्री पेलोड

`pm` फ़ील्ड में एक Base64-एन्कोडेड टेलीमेट्री संरचना होती है जो `/reload` में उपयोग किए गए टेलीमेट्री पेलोड के समान होती है।

 
## एंटी-डीबगिंग/टैम्परिंग
- ***प्रतीक-आधारित अखंडता टैग***
    reCAPTCHA हर ऐरे और ऑब्जेक्ट पर एक Symbol कुंजी `Symbol(jas)` सेट करता है, जिसमें अखंडता जांच के रूप में उपयोग किया जाने वाला एक संख्यात्मक मान होता है। चूंकि Symbols गैर-गणनीय होते हैं और मानक क्लोनिंग ऑपरेशनों (जैसे JSON.stringify) के लिए अदृश्य होते हैं, इन संरचनाओं को बदलने या क्लोन करने का कोई भी प्रयास टैग खो देता है, जिसे reCAPTCHA टैम्परिंग के रूप में पहचानता है

    ![tamp](https://raw.githubusercontent.com/elyelysiox/recaptcha/main/photos/849230834092888898.png)

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

- ***टाइमिंग जाँच***
    reCAPTCHA में रनटाइम डीबगिंग पहचान तंत्र शामिल हैं। यदि यह पता लगाता है कि कोड का विश्लेषण किसी डीबगर द्वारा किया जा रहा है, तो यह डीबगिंग सत्र को पुनः आरंभ करता है, जिससे निष्पादन स्थिति और संदर्भ खो जाते हैं

- ***क्रैश सोर्स टैब***

    https://github.com/user-attachments/assets/4ae3bf68-5ae7-4adc-a0b9-36cc11b64998
  
    यह बग उन ब्राउज़रों में होता है जो Chromium का उपयोग करते हैं। ऐसे कई बग हैं जो ब्राउज़र या डेवलपर टूल को अप्रत्याशित रूप से बंद कर देते हैं, जैसा कि यहाँ दिखाया गया है:
    
    https://blog.castle.io/detect-and-crash-chromium-bots-with-one-weird-trick-bots-hate-it/ 
    https://issues.chromium.org/issues/340836884?ref=blog.castle.io
    
    इसलिए, टाइमआउट होने पर संभवतः इनमें से एक बग ट्रिगर होता है, क्योंकि यह शायद ऐसा कुछ नहीं है जो किसी वास्तविक उपयोगकर्ता के प्रवाह में घटित होगा

## reCAPTCHA Botguard

हालाँकि BotGuard को Google द्वारा हटा दिया गया था, मैं उन लोगों के लिए थोड़ा समझाऊँगा जो यह जानने में रुचि रखते हैं कि यह आंतरिक रूप से कैसे काम करता है, और यह अन्य प्रकार के botguard से कितना अलग है

पहले, टोकन निर्माण प्रक्रिया: VM निष्पादन के दौरान लगातार बनी रहने वाली त्रुटियों के लिए टोकन उत्पन्न करता है। ये त्रुटियाँ बाइटकोड ऑफ़सेट विचलन, लापता VM रजिस्टर, गलत VM स्थिति, और खराब कंट्रोल फ्लो अखंडता के कारण हो सकती हैं। इन त्रुटियों को डिस्पैचर द्वारा कैप्चर किया जाता है, जो टोकन के लिए बाइट्स लिखने वाले फ़ंक्शन को कॉल करता है।

VM ARX Cipher का उपयोग करता है, जो NSA द्वारा 2013 में बनाया गया एक एल्गोरिदम है, जो डेटा एन्क्रिप्ट करने के लिए Speck के समान है। यह सभी Google BotGuard में भी उपयोग किया जाता है। एल्गोरिदम प्रत्येक संस्करण के साथ बदलता है, जैसे कि स्थिरांक (3990), संचालन का क्रम और राउंड भी बदलते हैं। यह इस प्रकार दिखता है:```javascript
/*
D -> cipher state array
P -> seed
E -> byte index
*/
Vl = function(D, P, E, F, v) {
    F = D[3] | 0;
    D = D[2] | 0;
    for (v = 0; v < 14; v++) {
        E = E >>> 8 | E << 24;
        E += P | 0;
        E ^= D + 3990;
        P = P << 3 | P >>> 29;
        P ^= E;
        F = F >>> 8 | F << 24;
        F += D | 0;
        F ^= v + 3990;
        D = D << 3 | D >>> 29;
        D ^= F;
    }
    return [P >>> 24 & 255, P >>> 16 & 255, P >>> 8 & 255, P >>> 0 & 255, E >>> 24 & 255, E >>> 16 & 255, E >>> 8 & 255, E >>> 0 & 255];
}

Byte Writer और एन्क्रिप्शन

मुख्य एन्क्रिप्शन फ़ंक्शन के दो मोड हैं: एन्क्रिप्शन और कोई एन्क्रिप्शन नहीं। एन्क्रिप्शन मोड डेटा को एन्क्रिप्ट करने और उसे बफ़र में सेट करने के लिए ARX Cipher, Bitwise + XOR का उपयोग करता है। बफ़र के 4 प्रकार हैं:

Main buffer 180
Entropy Pad buffer 353
Error Buffer 304
PoE (Proof of Execution) buffer 243 (इस प्रकार के botguard में उपयोग नहीं किया जाता)।

नो-एन्क्रिप्शन मोड केवल पहले से एन्क्रिप्टेड बाइट्स को बफ़र में सेट करता है```javascript // (The sequence flatten messed up the statements a bit) /* Q -> cipher state array FQ(v, c) -> derive a seed c = (z << 3) - 4 -> index FQ(v, (c | 0) + 4) -> position */ t = function(D, P, E, F, v, Q) { if (E.O == E) { P = function(h, A, c, x, z) { A = v.length; // buffer length z = (A | 0) - 4 >> 3; if (v.Jw != z) { // vm.block_index != index v.Jw = z; // set new block index c = (z << 3) - 4; x = [0, 0, Q[1], Q[2]]; try { v.zB = Vl(x, FQ(v, c), FQ(v, (c | 0) + 4)); // call ARX Cipher to generate keyStream } catch (V) { throw V; } } v.push(v.zB[A & 7] ^ h); // sets A to bits 0-7, and obtains a byte from the keystream and applies xor with a byte of the data to be encrypted }; v = Z(P, E); // get buffer if (P == 180 || P == 243 || P == 353) { Q = Z(189, E); } else { // set encripted bytes to buffer P = function(h) { v.push(h); }; } F && P(F & 255); E = D.length; for (F = 0; F < E; F++) { P(D[F]); } } }

और यह वह फ़ंक्शन है जो त्रुटियों को संभालता है और बाइट राइटर को कॉल करता है```javascript
// (The sequence flatten messed up the statements a bit)

p = function(D, P, E, F, v, Q, h, A) {
    D = E[1];
    A = E[2];
    Q = Z(465, P) >> 3; 
    h.push(D, Q >> 8 & 255, Q & 255); // error code/header bytes
    E.message && (D += E.message);
    A = void 0;
    E && E[0] === U && (E = void 0);
    h = Z(244, P);
    h.length == 0 && (A != void 0 && h.push(A & 255));
    D = "";
    E && (E.stack && (D += ":" + E.stack));
    E = Z(0, P); // buffer size limit (2048)
    if (!P.TB && E[0] > 3) {
        D = D.slice(0, (E[0] | 0) - 3); 
        E[0] -= (D.length | 0) + 3;  // reduce size limit
        D = Pv(D);
        E = P.O;
        P.O = P;
        try {
            v = (v = Z(304, P)) && v[v.length - 1] || 95;
            if (P.n3) {
                // this path is never executed
                (F = Z(123, P)) && F[F.length - 1] == v || t([v & 255], 123, P);
            } else {
                t([95], 304, P); // set byte to error buffer
            }
            t(O(2, D.length).concat(D), 180, P, 9); // set bytes to main buffer
        } finally {
            P.O = E;
        }
    }
}

निष्पादन के अंत में, VM मुख्य फ़ंक्शन को कॉल करता है जो इन बफ़र्स के साथ पेलोड तैयार करता है और टोकन उत्पन्न करता है, जो एक हस्ताक्षर है। अन्य BotGuard VM के विपरीत, इस VM में फ़िंगरप्रिंटिंग सिस्टम नहीं है, न ही Google Botguard है, और न ही यह इन त्रुटि-उत्सर्जक + बाइट्स लिखने वाली क्रियाएँ करता है, और यह बहुत सरल और रिवर्स इंजीनियर करने में आसान है।

अस्वीकरण

यह रिपॉजिटरी विशेष रूप से शैक्षिक और शोध उद्देश्यों के लिए है। यहाँ प्रस्तुत कोड, तकनीकें और अवधारणाएँ शामिल विषयों के शैक्षणिक अध्ययन और समझ के लिए हैं।

`0`	`rreq`	अनुरोध प्रकार पहचानकर्ता
`1`	`U5VsmTDhJM1iO...`	reCAPTCHA संस्करण
`2`	`03AFcWeA5Els3...`	`/anchor` एंडपॉइंट से प्राप्त सत्यापन टोकन
`5`	`-383788762`	संपूर्ण क्रमबद्ध फिंगरप्रिंट पेलोड का हैश किया गया मान, नमूना
`6`	`q`	निष्पादित किए जा रहे चैलेंज या अनुरोध मोड को इंगित करता है
`7`	`05APQrAobTCFG...`	उपयोग पैटर्न, जिसमें उपयोग इतिहास और पहले हल किए गए चैलेंज पैटर्न शामिल हैं। मान्य होने पर स्कोर को काफी बढ़ा सकते हैं
`8`	`submit`	सत्यापन के समय उपयोगकर्ता पृष्ठ पर जो विशिष्ट साइट क्रिया कर रहा है (जैसे `signin`, `register`)
`14`	`6LcAbwIqAAAA...`	वेबसाइट कुंजी
`16`	`0XA4cHhALxgM...`	एंकर से प्राप्त एन्क्रिप्शन कुंजी (अनुक्रमांक 18) `1777669303203` के साथ संपूर्ण क्रमबद्ध फिंगरप्रिंट पेलोड को एन्क्रिप्ट किया गया
`20`	`tbMywxNTQsOD...`	Base64-एन्कोडेड टेलीमेट्री संरचना जिसमें VM टाइमिंग डेल्टा, संसाधन टाइमिंग, एकत्रित ब्राउज़र ऑब्जेक्ट आँकड़े और वेबसाइट स्क्रिप्ट URL शामिल हैं
`21`	`0aAPQrAobqME...`	पहले हल किए गए CAPTCHA से जुड़ा टोकन। सत्र निरंतरता और विश्वास सहसंबंध के लिए उपयोग किया जाता है
`22`	`BDAAYAIAGEcA...`	सभी ब्राउज़र ऑब्जेक्ट कुंजियों का हैश किया गया मान
`25`	`W1tbNTAwNiw...`	उपयोगकर्ता इंटरैक्शन ईवेंट (जैसे माउस गति, क्लिक, कीबोर्ड और फोकस परिवर्तन) के लिए Base64-एन्कोडेड काउंटर

`recaptcha/api.js`	`3`
`recaptcha/releases/<version>`	`1`
`https://www.google.com/recaptcha/api2/anchor`	`2`
`https://www.google.com/recaptcha/api2/bframe`	`4`

`5006`	`pointermove`
`64607`	`pointerdown`
`45464`	`pointerup`
`31617`	`keydown`
`37178`	`keyup`
`35837`	`focusin`

`0`	`/m/013xlm`	लक्ष्य ऑब्जेक्ट वर्ग के लिए आंतरिक श्रेणी पहचानकर्ता
`2`	`3`	ग्रिड कॉलम की संख्या
`3`	`3`	ग्रिड पंक्ति की संख्या
`5`	`null`	आरक्षित या वैकल्पिक मेटाडेटा फ़ील्ड
`6`	`"Tractor"`	टेक्स्ट लेबल

`imageselect`	मानक छवि चयन CAPTCHA
`tileselect`	टाइल-आधारित गतिशील छवि चुनौती
`dynamic`	गतिशील चुनौती जिसमें चयन के बाद टाइलें पुनः लोड होती हैं
`multicaptcha`	बहु-चरणीय CAPTCHA चुनौती
`audio`	ऑडियो-आधारित पहुँच चुनौती
`nocaptcha`	केवल चेकबॉक्स वाला सत्यापन प्रवाह
`doscaptcha`	दुरुपयोग होने पर CAPTCHA अस्वीकार करें

`v`	`recaptchaVersion`	reCAPTCHA संस्करण
`c`	`challengeToken`	चैलेंज स्टेट टोकन जो `/replaceimage` या पिछले `/userverify` अनुरोध से लौटाया गया है
`response`	एन्कोडेड पेलोड जिसमें चयनित टाइल इंडेक्स और अतिरिक्त इंटरैक्शन मेटाडेटा शामिल हैं
`t`	`challengeElapsed`	चैलेंज शुरू में लोड होने के बाद से बीता हुआ समय
`ct`	`completionTime`	उपयोगकर्ता द्वारा CAPTCHA हल करने और सबमिट करने में लिया गया कुल समय
`ch`	`ocHash`	संपूर्ण सीरियलाइज़्ड `oc` पेलोड का हैश, नमूना
`oc`	`encryptedVmSignals`	reCAPTCHA VM से एकत्रित एन्क्रिप्टेड सिग्नल, यहाँ देखें।
`pm`	`telemetryPayload`	Base64-एन्कोडेड टेलीमेट्री संरचना जिसमें VM टाइमिंग डेल्टा, रिसोर्स टाइमिंग, एकत्रित ब्राउज़र ऑब्जेक्ट आँकड़े, और वेबसाइट स्क्रिप्ट मेटाडेटा शामिल हैं

recaptcha

सबसे लोकप्रिय