### Response

La réponse contient :
- Conception de la fenêtre iframe CAPTCHA
- Jeton d'ancrage utilisé pour la validation de la charge utile (/reload)
- La configuration principale pour l'initialisation, exécutée dans la méthode `recaptcha.anchor.Main.init` pour la recevoir dans recaptcha_en.js

### Structure :

Note : Recaptcha BotGuard a été supprimé le `04/01/2026`, vous pouvez voir quelques exemples [ici](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
]

Cela représente :

- Ordre d'exécution
- Pipeline de collecte
- Séquence de génération de signaux

### Codes de signaux d'empreinte et dérivation de clé
Transforme les signaux d'empreinte en clés de chiffrement déterministes via un pipeline de dérivation en plusieurs étapes

Chaque valeur d'empreinte est :

- Normalisée
- Encodée en un code de signal compact
- Convertie en une clé de chiffrement numérique
- Chiffrée à l'aide de la clé dérivée

Le processus est déterministe, ce qui signifie que la même valeur d'entrée génère toujours le même code de signal et la même clé de chiffrement```
Raw Value
   ↓
Signal Code Derivation
   ↓
Compact Signal Code
   ↓
Numeric Key Derivation
   ↓
Encryption Key
   ↓
Value Encryption

***Étape 1 - Dériver le code de signal***```javascript
deriveSignalCode("BUTTON,195a81c9")
// → "wg"

Le code du signal est transformé en une clé de chiffrement numérique.

***Étape 3 — Chiffrer la valeur***```javascript
encryptValueWithKey(3792, "wgia1z9pwq")
// → "bYVbh6BUsE_5pLA"

**Final**```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"
]

Une fois la construction de l'empreinte terminée, elle est sérialisée en une chaîne et chiffrée à l'aide de la clé de chiffrement chargée depuis le champ d'ancrage (index 18). Le résultat chiffré est ensuite stocké dans le champ d'index `16` de la charge utile `/reload`.

## Signaux de la VM
Voici les valeurs du navigateur ​​obtenues par la VM interne de reCAPTCHA, ainsi que la clé de signal. Certaines valeurs ​​ne sont pas affichées dans l'empreinte exemple car la VM n'extrait que certaines valeurs ​​du bytecode de configuration. Par conséquent, d'autres valeurs ​​seront affichées. Pour plus de détails, voir [ici](https://github.com/elyelysiox/recaptcha-vm)

Format de signal de base :```
[
  null,
  collectorElapsed,
  encryptElapsed,
  value
]

- **Key 417** (`string`)
  - Value: `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...`
  - Description: User-Agent complet du navigateur

- **Key 727** (`array`)
  - Value: `[]`
  - Description: Blocs de prix de produits, contient les prix des produits commerciaux sur le site web, ceux-ci peuvent apparaître sur des sites de places de marché comme Amazon, eBay, AliExpress, etc, [Exemple](https://github.com/elyelysiox/recaptcha/blob/main/findProductPricesBlock.js)

- **Key 150** (`array`)
  - Value: `[\"Join And Get Free Trial!\",\"\",\"Captcha Solving Service\",\"Prod...`
  - Description: Liens extraits des éléments `<a>` du site web, la machine virtuelle extrait rarement ces valeurs

- **Key 545** (`boolean`)
  - Value: `false`
  - Description: `navigator.webdriver`

- **Key 370** (`integer`)
  - Value: `0`
  - Description: Nombre maximal de points de contact de l'appareil `navigator.maxTouchPoints`

- **Key 779** (`array`)
  - Value: `[null,null,null,null,"false"]`
  - Description: Extrait les données des champs d'expédition/facturation, [Exemple](https://github.com/elyelysiox/recaptcha/blob/main/formFieldScrape.js)
  
    `postal|postalcode|postalcode|postal_code|zip` → recherche le champ de code postal
    
    `ship|deliver` → section d'expédition
    
    `billing|payment|credit` → section de facturation
    
    `country` → sélecteur de pays
    
    `addr.*(match|equal)|(match|equal).*address` → case à cocher "même adresse"
    
    Lit le nom, l'id, l'autocomplete, le className de chaque élément
    Trois phases : saisies de texte, instructions SELECT, cases à cocher

- **Key 659** (`array`)
  - Value: `[[[0,921],[1,2053]],[[235054,1,1,1],[164277,3,4,1]],2,39]`
  - Description: Contient les données des éléments pressés sur la page au format `[[[count,timestamp]],[[hashedElem,tagType,type,autoComplete]],pressedCount,behaviorChecksum]`
 
    ### Type d'élément
    
    | Type d'élément | ID |
    |-------------|----|
    | `""` | 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 |

    ### Algorithme de somme de contrôle comportementale
    
    La behaviorChecksum est un score comportemental compact dérivé des données d'interactions utilisateur collectées.
 
    Pour chaque interaction :
    - L'indice d'interaction est incrémenté de un
    - L'horodatage est combiné avec l'indice d'interaction ajusté
    - Le hachage de l'élément est réduit à l'aide d'une opération modulo
    - Le résultat est accumulé dans un score courant
   
    ---

    ```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;
    }
    ```

    ### Exemple

    ```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]`
  - Description: Contient les mouvements de défilement collectés pendant la session de la page
 
    ### Format de base
    ```
    [ [ [ scrollX, scrollY, timestamp ] ], count, behaviorChecksum ]
    ```

- **Key 895** (`array`)
  - Value: `[[[1,0]]]`
  - Description:` VisibilityStateEntry` suit l'état de visibilité de la page, indiquant si l'utilisateur consulte actuellement la page ou a navigué ailleurs, au format `[[[isVisible, startTime]]]`

- **Key 1092** (`array`)
  - Value: `[886,2300,262.2099999997952,392.7600000009595,2050.2399999993577]`
  - Description: Performance reCAPTCHA, PerformanceNavigationTiming et PerformanceEventTiming, au format `[vmStart,vmEnd,domContentLoadedEventEnd,loadEventEnd,firstUserInteractionTime]`

- **Key 41** (`array`)
  - Value: `[[[1123,0,0]]]`
  - Description: ClearTimeout

- **Key 43** (`array`)
  - Value: `[[[1123,0]]]`
  - Description: ClearTimeout

- **Key 549** (`array`)
  - Value: `[0,null,null,null,null,null,null]`
  - Description: KeyboardEvent, touches calculées + horodatages

- **Key 352** (`array`)
  - Value: `1,[[2050,125,633,266,[609,266,105,44],3,1,50,1,1]],[3,3,318],...`
  - Description:
    La structure contient :

    - Temporisation des mouvements de souris
    - Coordonnées du curseur
    - Durées des clics
    - Dimensions des éléments pressés
    - Informations sur le type de pointeur
    - Métriques de pression
    - Distance parcourue par le curseur
    - Statistiques temporelles comportementales

    ### Format de base :
    ```
    [
      eventsCount,
      mouseEvents,
      [
        coalescedEventsCount,
        averageInterEventDelay,
        timingVarianceScore
      ],
      [
        totalPoints,
        clickSequenceScore,
        totalCursorDistance,
        totalPoints
      ],
      0,
      0,
      behaviorChecksum
    ]
    ```
    
    ### Structure des événements souris :
    
    Chaque entrée dans mouseEvents suit cette structure :
    
    ```
    [
      timestamp,
      clickDuration,
      clientX,
      clientY,
      [
        elementLeft,
        elementTop,
        elementWidth,
        elementHeight
      ],
      elementTagType,
      trackedElementIndex,
      pressure,
      pointerTravelDistance,
      pointerArea
    ]
    ```

    | Nom | Description |
    |---|---|
    | `timestamp` | Horodatage de l'événement relatif au début de l'événement |
    | `clickDuration` | Durée entre `pointerdown` et `pointerup` |
    | `clientX` | ... |
    | `clientY` | ... |
    | `elementBounds` | Rectangle englobant de l'élément interactif |
    | `elementTagType` | Identifiant de balise DOM encodé de l'élément interactif |
    | `trackedElementIndex` | Identifiant interne de l'élément DOM interactif provenant de la carte d'interaction d'exécution |
    | `pressure` | Valeur de pression de pointeur normalisée multipliée par `100` |
    | `pointerTravelDistance` | Distance parcourue entre `pointerdown` et `pointerup` |
    | `pointerArea` | Zone de contact calculée comme `largeur * hauteur` |

    ### Type de balise d'élément

    Ceci est initialisé lors de l'exécution de la VM reCAPTCHA

    | Type      | ID |
    |-----------|----|
    | `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 |

    ### Exemple
    ```
    [
      18342,
      91,
      742,
      381,
      [700, 320, 120, 38],
      3,
      1,
      50,
      1.4,
      16
    ]
    ```
    
    Représente :
    
    - événement à `18,342s`
    - durée du clic de `91ms`
    - clic à `(742, 381)`
    - interaction avec un `BOUTON`
    - pression du pointeur `0,5` (50)
    - léger mouvement du curseur pendant le clic
    - zone de contact du pointeur de `16`
   
    ### Algorithme de somme de contrôle comportementale
 
    Pour chaque événement souris :

    - La durée du clic est amplifiée
    - Le résultat est combiné avec l'horodatage de l'événement
    - Les coordonnées du curseur et les dimensions de l'élément sont mélangées
    - Un ratio pondéré est calculé
    - Le ratio est arrondi et accumulé
    
    Après le traitement de tous les événements :
    
    - Le score accumulé est combiné avec la distance totale du curseur
    - Le résultat est normalisé en utilisant le nombre de points collectés
    - Une transformation logarithmique est appliquée
    - Des statistiques de mouvement supplémentaires sont incorporées
    - La valeur finale est réduite à l'aide d'une opération modulo
    - Le résultat est arrondi en un petit score entier
    
    ---
    
    ```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);
    }
    ```

    ### Exemple

    ```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: `""`
  - Description: Analyse des prix totaux collectés du site web $ avec une expression régulière ``(?i)total[\S\s]{0,20}?(?:(?:(?:USD|\$)\s*)?[\d\.,]+\s*(?:USD|\$)|(?:USD|\$)\s*[\d\.,]+)``, [Exemple](https://github.com/elyelysiox/recaptcha/blob/main/websitePricesTotal.js)

- **Key 1278** (`integer`)
  - Value: `229.6`
  - Description: Division par 10 du temps d'exécution actuel `Math.trunc(performance.now()) / 10`
    
- **Key 1422** (`boolean`)
  - Value: `false`
  - Description: Analyse s'il y a des champs OTP/2FA sur le site web, [Exemple](https://github.com/elyelysiox/recaptcha/blob/main/parseOTPFields.js)

- **Key 614** (`array`)
  - Value: `[1,0,0,Infinity]`
  - Description: Informations sur la batterie de l'appareil, au format `[level,isCharging,chargingTime,dischargingTime]`

- **Key 2033** (`array`)
  - Value: `["0",-1,-1,999]`
  - Description: Certaines valeurs constantes de la VM et le timing d'exécution de la VM

- **Key 1313** (`array`)
  - Value: `["undefined",3]`
  - Description: Vérifications Android, Chrome, `[typeof window.android, Object.keys(window.chrome).length]`

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

- **Key 1310** (`array`)
  - Value: `["Google Inc. (Intel Inc.)","ANGLE (Intel Inc.,...`
  - Description: Rendu WebGL, Fournisseur et extensions totales, [Exemple](https://github.com/elyelysiox/recaptcha/blob/main/webglSignals.js)

- **Key 291** (`array`)
  - Value: `[1542343452,0,105002991,3556653,96784904,-731949068,-902263026,...`
  - Description: Clés de prototypes spécifiques hachées d'objets navigateur, comme `SpeechSynthesisEvent`, `NetworkInformation`, `HTMLElement`, etc, [Exemple](https://github.com/elyelysiox/recaptcha/blob/main/hashBrowserProtos.js)

## Charge utile de la requête de rechargement

Ces données sont sérialisées à l'aide de protobuf (Protocol Buffers), une méthode efficace et neutre pour sérialiser des données structurées, développée par 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,
]

Le payload contient :

- Informations de chronométrage des ressources
- Chronométrage des performances des tâches longues
- Deltas d'exécution VM de reCAPTCHA
- URLs des scripts du site web
- Statistiques de collecte d'objets du navigateur

### Structure de base```js
[
  [recaptchaResources],
  [tasksTiming],
  [
      null,
      null,
      null,
      idleTimeoutDelta,
      deltaTiming,
      0,
      0,
      0,
  ],
  websiteScriptsUrls,
  [collectionElapsed, browserObjectsLength]
]

### Format de Synchronisation des Ressources reCAPTCHA```js
[
   resourceType,
   duration,
   startTime
]

### Structure du compteur d'événements```js
[
  [
    [eventType, count]
  ]
]

## Descriptions des champs

| Index | Nom | Description |
|---|---|---|
| `0` | `rresp` | Identifiant du type de réponse retourné par le point de terminaison de rechargement |
| `1` | `responseToken` | Jeton de réponse reCAPTCHA |
| `3` | `tokenExpiration` | Durée de vie du jeton en secondes avant expiration |
| `4` | `pmeta` | Bloc de métadonnées du défi contenant des informations sur le type, la catégorie et la disposition de la grille du CAPTCHA |
| `5` | `challengeType` | Type de défi CAPTCHA |
| `8` | `usagePatternToken` | Modèles d'utilisation, stockés dans `window.sessionStorage` et réutilisés dans les futures requêtes `/reload` |
| `9` | `challengeImageToken` | Jeton utilisé pour récupérer la charge utile de l'image CAPTCHA depuis le point de terminaison `/payload` |
| `12` | `humanVerificationToken` | Jeton d'identification humaine associé à l'état Google reCAPTCHA et aux cookies du navigateur |
| `14` | `captchaSessionToken` | Jeton de session interne |
| `15` | `bftToken` | ... |

---

### Structure de `pmeta`

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

### Identifiants de catégorie

| ID | Catégorie |
|---|---|
| `/m/0pg52` | Taxi |
| `/m/01bjv` | Bus |
| `/m/02yvhj` | Autobus scolaire |
| `/m/04_sv` | Moto |
| `/m/013xlm` | Tracteur |
| `/m/01jk_4` | Cheminée |
| `/m/014xcs` | Passage piéton |
| `/m/015qff` | Feu de circulation |
| `/m/0199g` | Vélo |
| `/m/015qbp` | Parcomètre |
| `/m/0k4j` | Voiture |
| `/m/015kr` | Pont |
| `/m/019jd` | Bateau |
| `/m/0cdl1` | Palmier |
| `/m/09d_r` | Montagne / colline |
| `/m/01pns0` | Bouche d'incendie |
| `/m/01lynh` | Escaliers |

## Payload de la requête UserVerify
Le payload `/userverify` est soumis après que l'utilisateur ait terminé un défi d'image reCAPTCHA v2

# Structure du payload```
v: hsFBb1u5wWWWkWP4in1ua2cQ
c: 03AFcWeA5RIHz5mI2COQqTcLjdrC7FiPpdfkX-hB-B2iFenI...
response: eyJyZXNwb25zZSI6WzMsMSw0LDksMCwxMSwxMCwxMywxNF0....
t: 24521
ct: 24521
ch: -4007845
oc: 0ZpqzzPgYKEEaN0xpfo3v_voeVUySZK3Ktf_fLVRdhnu3yeTy4BhO...
pm: 51bGwsbnVsbCxbbnVsbCxudWxsLG51bGwsWzEwLDQuMjcwMDAwMD....

Exemple de charge utile :```json
{
  "response": [2, 3, 6]
}

Exemple de payload:```json
{
  "response": [2, 3, 6, 14]
}

Ce champ contient des métadonnées d'interaction chiffrées liées aux actions des boutons CAPTCHA telles que :

- `Vérifier`
- `Suivant`
- `Ignorer`

### Structure interne de `e`

Après déchiffrement, la structure ressemble à :```txt
[[["9ffd9672"]]]

### `oc` — Signaux VM chiffrés

Utilise le même algorithme de chiffrement que le champ `idx 16` de la charge utile de la requête `/reload`, avec la clé de chiffrement chargée dans l'ancre (index 31) `1777752103288`

### `pm` — Charge utile de télémétrie

Le champ `pm` contient une structure de télémétrie encodée en Base64, similaire à la charge utile de télémétrie utilisée dans `/reload`.

 
## Anti-débogage/Altération
- ***Étiquette d'intégrité basée sur les Symboles***
    reCAPTCHA attribue une clé Symbol `Symbol(jas)` à chaque tableau et objet avec une valeur numérique utilisée comme vérification d'intégrité. Étant donné que les Symboles ne sont pas énumérables et invisibles pour les opérations de clonage standard (comme JSON.stringify), toute tentative de remplacement ou de clonage de ces structures perd l'étiquette, ce que reCAPTCHA détecte comme une altération.

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

- ***Capture de variables de fermeture***
    Certaines valeurs sont intentionnellement définies dans la portée d'une fonction externe et consommées uniquement à l'intérieur de rappels ou de fermetures imbriqués ; la variable n'existe jamais dans la même portée que celle où elle est utilisée.

- ***Vérifications temporelles***
    reCAPTCHA intègre des mécanismes de détection de débogage en cours d'exécution. S'il détecte que le code est analysé par un débogueur, il redémarre la session de débogage, ce qui entraîne la perte de l'état d'exécution et du contexte.

- ***Onglet source de plantage***

    https://github.com/user-attachments/assets/4ae3bf68-5ae7-4adc-a0b9-36cc11b64998
  
    Ce bug se produit dans les navigateurs utilisant Chromium. Il existe plusieurs bugs qui provoquent la fermeture inattendue du navigateur ou des outils de développement, comme celui montré ici :
    
    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
    
    Par conséquent, l'un de ces bugs est très probablement déclenché lorsque le délai d'attente expire, car ce n'est probablement pas quelque chose qui se produirait dans le flux d'un véritable utilisateur.

## reCAPTCHA Botguard

Bien que BotGuard ait été supprimé par Google, je vais expliquer un peu comment il fonctionne en interne pour ceux qui s'intéressent à ce qu'il est et à quel point il diffère des autres types de botguard.

Premièrement, le processus de génération de token : la VM génère des tokens pour les erreurs persistantes lors de l'exécution. Ces erreurs peuvent être dues à des déviations de décalage de bytecode, des registres VM manquants, un état VM incorrect et une mauvaise intégrité du flux de contrôle. Ces erreurs sont capturées par le répartiteur, qui appelle une fonction qui écrit des octets pour le token.

La VM utilise ARX Cipher, un algorithme créé par la NSA en 2013, similaire à Speck pour chiffrer les données. Il est également utilisé dans tous les Google BotGuard. L'algorithme change à chaque version, tout comme la constante (3990), l'ordre des opérations et les tours. Il ressemble à ceci :```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];
}

Et voici la fonction qui gère les erreurs et appelle le rédacteur d'octets.```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;
        }
    }
}