### Response

La risposta contiene:
- Design della finestra iframe del CAPTCHA
- Token anchor utilizzato per la convalida del payload (/reload)
- La configurazione principale per l'inizializzazione, eseguita nel metodo `recaptcha.anchor.Main.init` per riceverla in recaptcha_en.js

### Struttura:

Nota: Recaptcha BotGuard è stato rimosso il `04/01/2026`, puoi vedere alcuni esempi [qui](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
]

Questo rappresenta:

- Ordine di esecuzione
- Pipeline del collettore
- Sequenza di generazione del segnale

### Codici dei segnali delle impronte digitali e derivazione delle chiavi
Trasforma i segnali delle impronte digitali in chiavi di crittografia deterministiche attraverso una pipeline di derivazione a più stadi

Ogni valore dell'impronta digitale è:

- Normalizzato
- Codificato in un codice segnale compatto
- Convertito in una chiave di crittografia numerica
- Crittografato utilizzando la chiave derivata

Il processo è deterministico, il che significa che lo stesso valore di input genera sempre lo stesso codice segnale e la stessa chiave di crittografia```
Raw Value
   ↓
Signal Code Derivation
   ↓
Compact Signal Code
   ↓
Numeric Key Derivation
   ↓
Encryption Key
   ↓
Value Encryption

***Step 1 - Derivare il Codice del Segnale***```javascript
deriveSignalCode("BUTTON,195a81c9")
// → "wg"

Il codice del segnale viene trasformato in una chiave di crittografia numerica.

***Passaggio 3 — Crittografa il valore***```javascript
encryptValueWithKey(3792, "wgia1z9pwq")
// → "bYVbh6BUsE_5pLA"

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

Una volta completata la costruzione dell'impronta, viene serializzata in una stringa e crittografata utilizzando la chiave di crittografia caricata dal campo anchor (indice 18). Il risultato crittografato viene poi memorizzato nel campo dell'indice `16` del payload `/reload`.

## Segnali VM
I seguenti sono i valori del browser ​​ottenuti dalla VM interna di reCAPTCHA, insieme alla chiave del segnale. Alcuni valori ​​non sono mostrati nell'esempio di impronta perché la VM estrae solo determinati valori dal bytecode di configurazione. Pertanto, verranno visualizzati altri valori. Per maggiori dettagli, vedere [qui](https://github.com/elyelysiox/recaptcha-vm)

Formato base del segnale:```
[
  null,
  collectorElapsed,
  encryptElapsed,
  value
]

- **Key 417** (`string`)
  - Value: `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...`
  - Descrizione: User-Agent completo del browser

- **Key 727** (`array`)
  - Value: `[]`
  - Descrizione: Blocchi di prezzi dei prodotti, contiene prezzi per prodotti commerciali sul sito web, questi possono apparire su marketplace come Amazon, eBay, AliExpress, ecc., [Esempio](https://github.com/elyelysiox/recaptcha/blob/main/findProductPricesBlock.js)

- **Key 150** (`array`)
  - Value: `[\"Join And Get Free Trial!\",\"\",\"Captcha Solving Service\",\"Prod...`
  - Descrizione: Link estratti dagli elementi `<a>` del sito web, la VM raramente estrae questi valori

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

- **Key 370** (`integer`)
  - Value: `0`
  - Descrizione: Punti di contatto massimi del dispositivo `navigator.maxTouchPoints`

- **Key 779** (`array`)
  - Value: `[null,null,null,null,"false"]`
  - Descrizione: Estrae dati dai campi di spedizione/fatturazione, [Esempio](https://github.com/elyelysiox/recaptcha/blob/main/formFieldScrape.js)
  
    `postal|postalcode|postalcode|postal_code|zip` → cerca il campo del codice postale
    
    `ship|deliver` → sezione spedizione
    
    `billing|payment|credit` → sezione fatturazione
    
    `country` → selettore paese
    
    `addr.*(match|equal)|(match|equal).*address` → checkbox "stesso indirizzo"
    
    Legge name, id, autocomplete, className di ogni elemento
    Tre fasi: input di testo, istruzioni SELECT, checkbox

- **Key 659** (`array`)
  - Value: `[[[0,921],[1,2053]],[[235054,1,1,1],[164277,3,4,1]],2,39]`
  - Descrizione: Contiene i dati degli elementi premuti sulla pagina nel formato `[[[count,timestamp]],[[hashedElem,tagType,type,autoComplete]],pressedCount,behaviorChecksum]`
 
    ### Tipo di elemento
    
    | Tipo di elemento | 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 |

    ### Algoritmo Behavior CheckSum
    
    Il behaviorChecksum è un punteggio comportamentale compatto derivato dai dati di interazione dell'utente raccolti.
 
    Per ogni interazione:
    - L'indice di interazione viene incrementato di uno
    - Il timestamp viene combinato con l'indice di interazione aggiustato
    - L'hash dell'elemento viene ridotto usando un'operazione modulo
    - Il risultato viene accumulato in un punteggio progressivo
   
    ---

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

    ### Esempio

    ```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]`
  - Descrizione: Contiene i movimenti di scorrimento raccolti durante la sessione della pagina
 
    ### Formato base
    ```
    [ [ [ scrollX, scrollY, timestamp ] ], count, behaviorChecksum ]
    ```

- **Key 895** (`array`)
  - Value: `[[[1,0]]]`
  - Descrizione: `VisibilityStateEntry` tiene traccia dello stato di visibilità della pagina, indicando se l'utente sta visualizzando la pagina o se è uscito, nel formato `[[[isVisible, startTime]]]`

- **Key 1092** (`array`)
  - Value: `[886,2300,262.2099999997952,392.7600000009595,2050.2399999993577]`
  - Descrizione: reCAPTCHA Performance, PerformanceNavigationTiming e PerformanceEventTiming, nel formato `[vmStart,vmEnd,domContentLoadedEventEnd,loadEventEnd,firstUserInteractionTime]`

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

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

- **Key 549** (`array`)
  - Value: `[0,null,null,null,null,null,null]`
  - Descrizione: KeyboardEvent, tasti calcolati + timestamp

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

    - Tempi di movimento del mouse
    - Coordinate del cursore
    - Durate dei clic
    - Dimensioni dell'elemento premuto
    - Informazioni sul tipo di puntatore
    - Metriche di pressione
    - Distanza percorsa dal cursore
    - Statistiche temporali comportamentali

    ### Formato base:
    ```
    [
      eventsCount,
      mouseEvents,
      [
        coalescedEventsCount,
        averageInterEventDelay,
        timingVarianceScore
      ],
      [
        totalPoints,
        clickSequenceScore,
        totalCursorDistance,
        totalPoints
      ],
      0,
      0,
      behaviorChecksum
    ]
    ```
    
    ### Struttura dell'evento del mouse:
    
    Ogni voce all'interno di mouseEvents segue questa struttura:
    
    ```
    [
      timestamp,
      clickDuration,
      clientX,
      clientY,
      [
        elementLeft,
        elementTop,
        elementWidth,
        elementHeight
      ],
      elementTagType,
      trackedElementIndex,
      pressure,
      pointerTravelDistance,
      pointerArea
    ]
    ```

    | Nome | Descrizione |
    |---|---|
    | `timestamp` | Timestamp dell'evento relativo all'inizio dell'evento |
    | `clickDuration` | Durata tra `pointerdown` e `pointerup` |
    | `clientX` | ... |
    | `clientY` | ... |
    | `elementBounds` | Rettangolo di delimitazione dell'elemento interagito |
    | `elementTagType` | Identificatore codificato del tag DOM dell'elemento interagito |
    | `trackedElementIndex` | Identificatore interno dell'elemento DOM interagito dalla mappa di interazione runtime |
    | `pressure` | Valore di pressione del puntatore normalizzato moltiplicato per `100` |
    | `pointerTravelDistance` | Distanza percorsa tra `pointerdown` e `pointerup` |
    | `pointerArea` | Area di contatto calcolata come `width * height` |

    ### Tipo di elemento tag

    Viene inizializzato durante l'esecuzione della VM di reCAPTCHA

    | Tipo | 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 |

    ### Esempio
    ```
    [
      18342,
      91,
      742,
      381,
      [700, 320, 120, 38],
      3,
      1,
      50,
      1.4,
      16
    ]
    ```
    
    Rappresenta:
    
    - evento a `18.342s`
    - durata clic di `91ms`
    - clic a `(742, 381)`
    - interazione con un `BUTTON`
    - pressione del puntatore `0.5` (50)
    - leggero movimento del cursore durante il clic
    - area di contatto del puntatore di `16`
   
    ### Algoritmo Behavior CheckSum
 
    Per ogni evento del mouse:

    - La durata del clic viene amplificata
    - Il risultato viene combinato con il timestamp dell'evento
    - Le coordinate del cursore e le dimensioni dell'elemento vengono mescolate
    - Viene calcolato un rapporto ponderato
    - Il rapporto viene arrotondato e accumulato
    
    Dopo che tutti gli eventi sono stati elaborati:
    
    - Il punteggio accumulato viene combinato con la distanza totale del cursore
    - Il risultato viene normalizzato usando il numero di punti raccolti
    - Viene applicata una trasformazione logaritmica
    - Vengono incorporate statistiche di movimento aggiuntive
    - Il valore finale viene ridotto usando un'operazione modulo
    - Il risultato viene arrotondato a un piccolo punteggio intero
    
    ---
    
    ```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);
    }
    ```

    ### Esempio

    ```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: `""`
  - Descrizione: Parsing del totale dei prezzi del sito web raccolti con un regex ``(?i)total[\S\s]{0,20}?(?:(?:(?:USD|\$)\s*)?[\d\.,]+\s*(?:USD|\$)|(?:USD|\$)\s*[\d\.,]+)``, [Esempio](https://github.com/elyelysiox/recaptcha/blob/main/websitePricesTotal.js)

- **Key 1278** (`integer`)
  - Value: `229.6`
  - Descrizione: Divisione per 10 del timing di runtime corrente `Math.trunc(performance.now()) / 10`
    
- **Key 1422** (`boolean`)
  - Value: `false`
  - Descrizione: Analizza se ci sono campi OTP/2FA sul sito web, [Esempio](https://github.com/elyelysiox/recaptcha/blob/main/parseOTPFields.js)

- **Key 614** (`array`)
  - Value: `[1,0,0,Infinity]`
  - Descrizione: Informazioni sulla batteria del dispositivo, nel formato `[level,isCharging,chargingTime,dischargingTime]`

- **Key 2033** (`array`)
  - Value: `["0",-1,-1,999]`
  - Descrizione: Alcuni valori costanti della VM e timing di runtime della VM

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

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

- **Key 1310** (`array`)
  - Value: `["Google Inc. (Intel Inc.)","ANGLE (Intel Inc.,...`
  - Descrizione: Renderer WebGL, Vendor e Estensioni Totali, [Esempio](https://github.com/elyelysiox/recaptcha/blob/main/webglSignals.js)

- **Key 291** (`array`)
  - Value: `[1542343452,0,105002991,3556653,96784904,-731949068,-902263026,...`
  - Descrizione: Chiave hash di specifici prototipi di oggetti del browser, come `SpeechSynthesisEvent`, `NetworkInformation`, `HTMLElement`, ecc., [Esempio](https://github.com/elyelysiox/recaptcha/blob/main/hashBrowserProtos.js)

## Payload della Richiesta di Ricarica

Questo dato è serializzato usando protobuf (Protocol Buffers), un metodo efficiente e neutro per serializzare dati strutturati, sviluppato da 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,
]

Il payload contiene:

- Informazioni sui tempi delle risorse
- Tempistiche di performance dei long-task
- Delta di esecuzione della VM di reCAPTCHA
- URL degli script del sito web
- Statistiche di raccolta degli oggetti del browser

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

### reCAPTCHA Resource Timing Format```js
[
   resourceType,
   duration,
   startTime
]

### Struttura del Contatore di Eventi```js
[
  [
    [eventType, count]
  ]
]

## Descrizioni dei campi

| Indice | Nome | Descrizione |
|---|---|---|
| `0` | `rresp` | Identificatore del tipo di risposta restituito dall'endpoint di ricarica |
| `1` | `responseToken` | Token di risposta reCAPTCHA |
| `3` | `tokenExpiration` | Durata del token in secondi prima della scadenza |
| `4` | `pmeta` | Blocco di metadati della sfida contenente informazioni sul tipo di CAPTCHA, categoria e disposizione della griglia |
| `5` | `challengeType` | Tipo di sfida CAPTCHA |
| `8` | `usagePatternToken` | Pattern di utilizzo, memorizzati in `window.sessionStorage` e riutilizzati in future richieste `/reload` |
| `9` | `challengeImageToken` | Token utilizzato per recuperare il payload dell'immagine CAPTCHA dall'endpoint `/payload` |
| `12` | `humanVerificationToken` | Token di identificazione umana associato allo stato di Google reCAPTCHA e ai cookie del browser |
| `14` | `captchaSessionToken` | Token di sessione interno |
| `15` | `bftToken` | ... |

---

### `pmeta` Struttura

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

### Category Identifiers

| ID | Categoria |
|---|---|
| `/m/0pg52` | Taxi |
| `/m/01bjv` | Autobus |
| `/m/02yvhj` | Autobus scolastico |
| `/m/04_sv` | Motocicletta |
| `/m/013xlm` | Trattore |
| `/m/01jk_4` | Camino |
| `/m/014xcs` | Attraversamento pedonale |
| `/m/015qff` | Semaforo |
| `/m/0199g` | Bicicletta |
| `/m/015qbp` | Parcometro |
| `/m/0k4j` | Auto |
| `/m/015kr` | Ponte |
| `/m/019jd` | Barca |
| `/m/0cdl1` | Palma |
| `/m/09d_r` | Montagna / collina |
| `/m/01pns0` | Idrante antincendio |
| `/m/01lynh` | Scale |

## Payload della Richiesta UserVerify
Il payload `/userverify` viene inviato dopo che l'utente completa una sfida reCAPTCHA v2

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

Esempio di payload:```json
{
  "response": [2, 3, 6]
}

Esempio di payload:```json
{
  "response": [2, 3, 6, 14]
}

Questo campo contiene metadati di interazione crittografati relativi alle azioni dei pulsanti CAPTCHA come:

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

### Struttura interna di `e`

Dopo la decifratura, la struttura assomiglia a:```txt
[[["9ffd9672"]]]

### `oc` — Segnali VM crittografati

Utilizza lo stesso algoritmo di crittografia del campo `idx 16` del payload della richiesta `/reload`, con la chiave di crittografia caricata nell'ancora (indice 31) `1777752103288`

### `pm` — Payload di telemetria

Il campo `pm` contiene una struttura di telemetria codificata in Base64 simile al payload di telemetria utilizzato in `/reload`.

 
## Anti-debugging/Manomissione
- ***Tag di integrità basato su Symbol***
    reCAPTCHA imposta una chiave Symbol `Symbol(jas)` su ogni array e oggetto con un valore numerico utilizzato come controllo di integrità. Poiché i Symbol non sono enumerabili e invisibili alle operazioni di clonazione standard (come JSON.stringify), qualsiasi tentativo di sostituire o clonare queste strutture perde il tag, che reCAPTCHA rileva come manomissione

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

- ***Cattura di variabili closure***
    Alcuni valori ​​sono intenzionalmente inseriti nell'ambito di una funzione esterna e consumati solo all'interno di callback o closures annidate, la variabile non esiste mai nello stesso ambito in cui viene utilizzata

- ***Controlli di temporizzazione***
    reCAPTCHA incorpora meccanismi di rilevamento del debugging in fase di esecuzione. Se rileva che il codice viene analizzato da un debugger, riavvia la sessione di debugging, causando la perdita dello stato e del contesto di esecuzione

- ***Scheda di origine crash***

    https://github.com/user-attachments/assets/4ae3bf68-5ae7-4adc-a0b9-36cc11b64998
  
    Questo bug si verifica nei browser che utilizzano Chromium. Ci sono diversi bug che causano la chiusura imprevista del browser o degli strumenti di sviluppo, come quello mostrato qui:
    
    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
    
    Pertanto, è molto probabile che uno di questi bug venga attivato quando si verifica il timeout, poiché probabilmente non è qualcosa che accadrebbe nel flusso di un utente reale

## reCAPTCHA Botguard

Sebbene BotGuard sia stato rimosso da Google, spiegherò un po' come funziona internamente per chi è interessato a come è, e quanto sia diverso da altri tipi di botguard

Innanzitutto, il processo di generazione dei token: la VM genera token per errori persistenti durante l'esecuzione. Questi errori possono essere dovuti a deviazioni dell'offset del bytecode, registri VM mancanti, stato VM errato e scarsa integrità del flusso di controllo. Questi errori vengono catturati dal dispatcher, che chiama una funzione che scrive byte per il token.

La VM utilizza ARX Cipher, un algoritmo creato dalla NSA nel 2013, simile a Speck per crittografare i dati. Viene utilizzato anche in tutti i Google BotGuard. L'algoritmo cambia con ogni versione, così come la costante (3990), l'ordine delle operazioni e dei round. Si presenta così:```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];
}

E questa è la funzione che gestisce gli errori e chiama il byte writer```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;
        }
    }
}