### Respuesta

La respuesta contiene:
- Diseño de la ventana del iframe de CAPTCHA
- Token de anclaje utilizado para la validación del payload (/reload)
- La configuración principal para la inicialización, ejecutada en el método `recaptcha.anchor.Main.init` para recibirla en recaptcha_en.js

### Estructura:

Nota: Recaptcha BotGuard fue eliminado el `04/01/2026`, puedes ver algunos ejemplos [aquí](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
]

Esto representa:

- Orden de Ejecución
- Pipeline de Recolección
- Secuencia de Generación de Señales

### Códigos de Señales de Huellas Dactilares y Derivación de Claves
Transforma las señales de huellas dactilares en claves de cifrado deterministas mediante un pipeline de derivación de múltiples etapas

Cada valor de huella dactilar es:

- Normalizado
- Codificado en un código de señal compacto
- Convertido en una clave de cifrado numérica
- Cifrado usando la clave derivada

El proceso es determinista, lo que significa que el mismo valor de entrada siempre genera el mismo código de señal y la misma clave de cifrado.```
Raw Value
   ↓
Signal Code Derivation
   ↓
Compact Signal Code
   ↓
Numeric Key Derivation
   ↓
Encryption Key
   ↓
Value Encryption

***Paso 1 - Derivar el Código de Señal***```javascript
deriveSignalCode("BUTTON,195a81c9")
// → "wg"

El código de señal se transforma en una clave de cifrado numérica.

***Paso 3 — Cifrar valor***```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"
]

Una vez completada la construcción de la huella, se serializa en una cadena y se cifra utilizando la clave de cifrado cargada desde el campo anchor (índice 18). El resultado cifrado se almacena entonces en el campo de índice `16` de la carga útil `/reload`.

## Señales de la VM

Los siguientes son los valores del navegador obtenidos por la VM interna de reCAPTCHA, junto con la clave de señal. Algunos valores no se muestran en la huella de muestra porque la VM solo extrae ciertos valores del bytecode de configuración. Por lo tanto, se mostrarán otros valores. Para más detalles, consulte [aquí](https://github.com/elyelysiox/recaptcha-vm)

Formato de Señal Base:```
[
  null,
  collectorElapsed,
  encryptElapsed,
  value
]

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

- **Key 727** (`array`)
  - Value: `[]`
  - Description: Bloques de precios de productos, contiene precios de productos comerciales en el sitio web; estos pueden aparecer en sitios de mercado como Amazon, eBay, AliExpress, etc., [Muestra](https://github.com/elyelysiox/recaptcha/blob/main/findProductPricesBlock.js)

- **Key 150** (`array`)
  - Value: `[\"Join And Get Free Trial!\",\"\",\"Captcha Solving Service\",\"Prod...`
  - Description: Enlaces extraídos de los elementos `<a>` del sitio web; la VM raramente extrae estos valores

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

- **Key 370** (`integer`)
  - Value: `0`
  - Description: Máximo de puntos táctiles del dispositivo `navigator.maxTouchPoints`

- **Key 779** (`array`)
  - Value: `[null,null,null,null,"false"]`
  - Description: Extrae datos de los campos de envío/facturación, [Muestra](https://github.com/elyelysiox/recaptcha/blob/main/formFieldScrape.js)
  
    `postal|postalcode|postalcode|postal_code|zip` → busca el campo de código postal
    
    `ship|deliver` → sección de envío
    
    `billing|payment|credit` → sección de facturación
    
    `country` → selector de país
    
    `addr.*(match|equal)|(match|equal).*address` → casilla de verificación "misma dirección"
    
    Lee el nombre, id, autocomplete, className de cada elemento
    Tres fases: entradas de texto, sentencias SELECT, casillas de verificación

- **Key 659** (`array`)
  - Value: `[[[0,921],[1,2053]],[[235054,1,1,1],[164277,3,4,1]],2,39]`
  - Description: Contiene datos de los elementos presionados en la página en el formato `[[[count,timestamp]],[[hashedElem,tagType,type,autoComplete]],pressedCount,behaviorChecksum]`
 
    ### Tipo de Elemento
    
    | Tipo de 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 de Checksum de Comportamiento
    
    El behaviorChecksum es una puntuación de comportamiento compacta derivada de los datos de interacciones del usuario recopilados.
 
    Para cada interacción:
    - El índice de interacción se incrementa en uno
    - La marca de tiempo se combina con el índice de interacción ajustado
    - El hash del elemento se reduce mediante una operación de módulo
    - El resultado se acumula en una puntuación continua
   
    ---

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

    ### Ejemplo

    ```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: Contiene los movimientos de desplazamiento recopilados durante la sesión de la página
 
    ### Formato Base
    ```
    [ [ [ scrollX, scrollY, timestamp ] ], count, behaviorChecksum ]
    ```

- **Key 895** (`array`)
  - Value: `[[[1,0]]]`
  - Description:` VisibilityStateEntry` rastrea el estado de visibilidad de la página, indicando si el usuario está viendo actualmente la página o ha navegado fuera de ella, en el formato `[[[isVisible, startTime]]]`

- **Key 1092** (`array`)
  - Value: `[886,2300,262.2099999997952,392.7600000009595,2050.2399999993577]`
  - Description: Rendimiento de reCAPTCHA, PerformanceNavigationTiming y PerformanceEventTiming, en el formato `[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, teclas calculadas + marcas de tiempo

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

    - Tiempos de movimiento del ratón
    - Coordenadas del cursor
    - Duraciones de clic
    - Dimensiones del elemento presionado
    - Información del tipo de puntero
    - Métricas de presión
    - Distancia de recorrido del cursor
    - Estadísticas de tiempo de comportamiento

    ### Formato Base:
    ```
    [
      eventsCount,
      mouseEvents,
      [
        coalescedEventsCount,
        averageInterEventDelay,
        timingVarianceScore
      ],
      [
        totalPoints,
        clickSequenceScore,
        totalCursorDistance,
        totalPoints
      ],
      0,
      0,
      behaviorChecksum
    ]
    ```
    
    ### Estructura del Evento de Ratón:
    
    Cada entrada dentro de mouseEvents sigue esta estructura:
    
    ```
    [
      timestamp,
      clickDuration,
      clientX,
      clientY,
      [
        elementLeft,
        elementTop,
        elementWidth,
        elementHeight
      ],
      elementTagType,
      trackedElementIndex,
      pressure,
      pointerTravelDistance,
      pointerArea
    ]
    ```

    | Nombre | Descripción |
    |---|---|
    | `timestamp` | Marca de tiempo del evento relativa al inicio del evento |
    | `clickDuration` | Duración entre `pointerdown` y `pointerup` |
    | `clientX` | ... |
    | `clientY` | ... |
    | `elementBounds` | Rectángulo delimitador del elemento interactuado |
    | `elementTagType` | Identificador de etiqueta DOM codificado del elemento interactuado |
    | `trackedElementIndex` | Identificador interno del elemento DOM interactuado del mapa de interacción en tiempo de ejecución |
    | `pressure` | Valor de presión del puntero normalizado multiplicado por `100` |
    | `pointerTravelDistance` | Distancia recorrida entre `pointerdown` y `pointerup` |
    | `pointerArea` | Área de contacto calculada como `width * height` |

    ### Tipo de Etiqueta de Elemento

    Esto se inicializa durante la ejecución de la VM de 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 |

    ### Ejemplo
    ```
    [
      18342,
      91,
      742,
      381,
      [700, 320, 120, 38],
      3,
      1,
      50,
      1.4,
      16
    ]
    ```
    
    Representa:
    
    - evento en `18.342s`
    - duración de clic de `91ms`
    - clic en `(742, 381)`
    - interacción con un `BUTTON`
    - presión del puntero `0.5` (50)
    - ligero movimiento del cursor durante el clic
    - área de contacto del puntero de `16`
   
    ### Algoritmo de Checksum de Comportamiento
 
    Para cada evento de ratón:

    - La duración del clic se amplifica
    - El resultado se combina con la marca de tiempo del evento
    - Las coordenadas del cursor y las dimensiones del elemento se mezclan
    - Se calcula una proporción ponderada
    - La proporción se redondea y se acumula
    
    Después de procesar todos los eventos:
    
    - La puntuación acumulada se combina con la distancia total del cursor
    - El resultado se normaliza usando el número de puntos recopilados
    - Se aplica una transformación logarítmica
    - Se incorporan estadísticas de movimiento adicionales
    - El valor final se reduce mediante una operación de módulo
    - El resultado se redondea a una puntuación entera pequeña
    
    ---
    
    ```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);
    }
    ```

    ### Ejemplo

    ```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: Total de precios del sitio web recopilado en $, analizado con una expresión regular ``(?i)total[\S\s]{0,20}?(?:(?:(?:USD|\$)\s*)?[\d\.,]+\s*(?:USD|\$)|(?:USD|\$)\s*[\d\.,]+)``, [Muestra](https://github.com/elyelysiox/recaptcha/blob/main/websitePricesTotal.js)

- **Key 1278** (`integer`)
  - Value: `229.6`
  - Description: División entre 10 del tiempo de ejecución actual `Math.trunc(performance.now()) / 10`
    
- **Key 1422** (`boolean`)
  - Value: `false`
  - Description: Analiza si hay campos OTP/2FA en el sitio web, [Muestra](https://github.com/elyelysiox/recaptcha/blob/main/parseOTPFields.js)

- **Key 614** (`array`)
  - Value: `[1,0,0,Infinity]`
  - Description: Información de la batería del dispositivo, en el formato `[level,isCharging,chargingTime,dischargingTime]`

- **Key 2033** (`array`)
  - Value: `["0",-1,-1,999]`
  - Description: Algunos valores constantes de la VM y tiempo de ejecución de la VM

- **Key 1313** (`array`)
  - Value: `["undefined",3]`
  - Description: Comprobaciones de Android y 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: Renderizador WebGL, proveedor y extensiones totales, [Muestra](https://github.com/elyelysiox/recaptcha/blob/main/webglSignals.js)


- **Key 291** (`array`)
  - Value: `[1542343452,0,105002991,3556653,96784904,-731949068,-902263026,...`
  - Description: Claves hash de prototipos específicos de objetos del navegador, como `SpeechSynthesisEvent`, `NetworkInformation`, `HTMLElement`, etc., [Muestra](https://github.com/elyelysiox/recaptcha/blob/main/hashBrowserProtos.js)

## Carga útil de la solicitud de recarga

Estos datos se serializan mediante protobuf (Protocol Buffers), un método eficiente y neutral para serializar datos estructurados, desarrollado por 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,
]

El payload contiene:

- Información de temporización de recursos
- Temporización de rendimiento de tareas largas
- Deltas de ejecución de VM de reCAPTCHA
- URLs de scripts del sitio web
- Estadísticas de recopilación de objetos del navegador

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

### Formato de temporización de recursos de reCAPTCHA```js
[
   resourceType,
   duration,
   startTime
]

### Estructura del Contador de Eventos```js
[
  [
    [eventType, count]
  ]
]

## Descripciones de campos

| Índice | Nombre | Descripción |
|---|---|---|
| `0` | `rresp` | Identificador del tipo de respuesta devuelto por el endpoint de recarga |
| `1` | `responseToken` | Token de respuesta de reCAPTCHA |
| `3` | `tokenExpiration` | Vida útil del token en segundos antes de la expiración |
| `4` | `pmeta` | Bloque de metadatos del desafío que contiene información sobre el tipo de CAPTCHA, la categoría y la disposición de la cuadrícula |
| `5` | `challengeType` | Tipo de desafío CAPTCHA |
| `8` | `usagePatternToken` | Patrones de uso, almacenados en `window.sessionStorage` y reutilizados en futuras solicitudes `/reload` |
| `9` | `challengeImageToken` | Token utilizado para recuperar la carga útil de la imagen CAPTCHA del endpoint `/payload` |
| `12` | `humanVerificationToken` | Token de identificación humana asociado con el estado de Google reCAPTCHA y las cookies del navegador |
| `14` | `captchaSessionToken` | Token de sesión interno |
| `15` | `bftToken` | ... |

---

### Estructura de `pmeta`

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

### Identificadores de categoría

| ID | Categoría |
|---|---|
| `/m/0pg52` | Taxi |
| `/m/01bjv` | Autobús |
| `/m/02yvhj` | Autobús escolar |
| `/m/04_sv` | Motocicleta |
| `/m/013xlm` | Tractor |
| `/m/01jk_4` | Chimenea |
| `/m/014xcs` | Paso de peatones |
| `/m/015qff` | Semáforo |
| `/m/0199g` | Bicicleta |
| `/m/015qbp` | Parquímetro |
| `/m/0k4j` | Coche |
| `/m/015kr` | Puente |
| `/m/019jd` | Barco |
| `/m/0cdl1` | Palmera |
| `/m/09d_r` | Montaña / colina |
| `/m/01pns0` | Hidrante |
| `/m/01lynh` | Escaleras |

## Payload de solicitud UserVerify
El payload `/userverify` se envía después de que el usuario completa un desafío de imagen de reCAPTCHA v2

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

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

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

Este campo contiene metadatos de interacción cifrados relacionados con las acciones de los botones de CAPTCHA, tales como:

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

### Estructura interna de `e`

Después del descifrado, la estructura se asemeja a:```txt
[[["9ffd9672"]]]

### `oc` — Señales de VM cifradas

Usa el mismo algoritmo de cifrado que el campo `idx 16` del payload de la solicitud `/reload`, con la clave de cifrado cargada en el ancla (índice 31) `1777752103288`

### `pm` — Payload de telemetría

El campo `pm` contiene una estructura de telemetría codificada en Base64 similar al payload de telemetría utilizado en `/reload`.

 
## Anti-depuración/manipulación
- ***Etiqueta de integridad basada en Symbol***
    reCAPTCHA establece una clave Symbol `Symbol(jas)` en cada array y objeto con un valor numérico utilizado como comprobación de integridad. Dado que los Symbols no son enumerables e invisibles para las operaciones de clonación estándar (como JSON.stringify), cualquier intento de reemplazar o clonar estas estructuras pierde la etiqueta, lo que reCAPTCHA detecta como manipulación

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

- ***Captura de variables de cierre***
    Algunos valores se delimitan intencionalmente en una función externa y se consumen solo dentro de callbacks o cierres anidados; la variable nunca existe en el mismo ámbito donde se utiliza

- ***Comprobaciones de tiempo***
    reCAPTCHA incorpora mecanismos de detección de depuración en tiempo de ejecución. Si detecta que el código está siendo analizado por un depurador, reinicia la sesión de depuración, lo que provoca que se pierdan el estado y el contexto de ejecución

- ***Bloquear la pestaña de origen***

    https://github.com/user-attachments/assets/4ae3bf68-5ae7-4adc-a0b9-36cc11b64998
  
    Este error ocurre en navegadores que usan Chromium. Hay varios errores que provocan que el navegador o las herramientas de desarrollo se cierren inesperadamente, como el que se muestra aquí:
    
    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
    
    Por lo tanto, es muy probable que uno de estos errores se active cuando se produce el tiempo de espera, ya que probablemente no sea algo que ocurriría en el flujo de un usuario real

## reCAPTCHA Botguard

Aunque Google eliminó BotGuard, explicaré un poco cómo funciona internamente para aquellos interesados en cómo es y en lo diferente que resulta de otros tipos de botguard

Primero, el proceso de generación de tokens: la VM genera tokens para errores persistentes durante la ejecución. Estos errores pueden deberse a desviaciones en el offset del bytecode, registros de VM faltantes, estado incorrecto de la VM y una mala integridad del flujo de control. Estos errores son capturados por el dispatcher, que llama a una función que escribe los bytes del token.

La VM utiliza ARX Cipher, un algoritmo creado por la NSA en 2013, similar a Speck para cifrar datos. También se utiliza en todo Google BotGuard. El algoritmo cambia con cada versión, al igual que la constante (3990), el orden de las operaciones y las rondas. Tiene este aspecto:```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];
}

Y esta es la función que maneja los errores y llama al escritor de bytes.```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;
        }
    }
}