### Antwort

Die Antwort enthält:
- CAPTCHA-Iframe-Fensterdesign
- Anchor-Token zur Payload-Validierung (/reload)
- Die Hauptkonfiguration für die Initialisierung, die in der Methode `recaptcha.anchor.Main.init` ausgeführt wird, um sie in recaptcha_en.js zu empfangen

### Struktur:

Hinweis: Recaptcha BotGuard wurde am `04/01/2026` entfernt. Einige Beispiele findest du [hier](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
]

Dies stellt dar:

- Ausführungsreihenfolge
- Collector Pipeline
- Signalerzeugungssequenz

### Fingerabdruck-Signalcodes & Schlüsselableitung
Wandelt Fingerabdruck-Signale durch eine mehrstufige Ableitungspipeline in deterministische Verschlüsselungsschlüssel um.

Jeder Fingerabdruckwert wird:

- Normalisiert
- In einen kompakten Signalcodes kodiert
- In einen numerischen Verschlüsselungsschlüssel umgewandelt
- Mit dem abgeleiteten Schlüssel verschlüsselt

Der Prozess ist deterministisch, d. h. derselbe Eingabewert erzeugt immer denselben Signalcodes und denselben Verschlüsselungsschlüssel.```
Raw Value
   ↓
Signal Code Derivation
   ↓
Compact Signal Code
   ↓
Numeric Key Derivation
   ↓
Encryption Key
   ↓
Value Encryption

***Schritt 1 - Signalcode ableiten***```javascript
deriveSignalCode("BUTTON,195a81c9")
// → "wg"

Der Signalcode wird in einen numerischen Verschlüsselungsschlüssel umgewandelt.

***Schritt 3 — Wert verschlüsseln***```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"
]

Once the fingerprint construction is complete, it is serialized into a string and encrypted using the encryption key loaded from the anchor field (index 18). The encrypted result is then stored in the index `16` field of the `/reload` payload.

## VM-Signale
Im Folgenden sind die Browserwerte ​​aufgeführt, die von der internen reCAPTCHA-VM zusammen mit dem Signalschlüssel ermittelt werden. Einige Werte ​​werden im Beispiel-Fingerprint nicht angezeigt, da die VM nur bestimmte Werte ​​aus dem Konfigurationsbytecode extrahiert. Daher werden andere Werte ​​angezeigt. Weitere Einzelheiten finden Sie [hier](https://github.com/elyelysiox/recaptcha-vm)

Basis-Signalformat:```
[
  null,
  collectorElapsed,
  encryptElapsed,
  value
]

- **Key 417** (`string`)
  - Wert: `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...`
  - Beschreibung: Vollständiger Browser-User-Agent

- **Key 727** (`array`)
  - Wert: `[]`
  - Beschreibung: Produktpreis-Blöcke, enthält Preise für kommerzielle Produkte auf der Website; diese können auf Marktplatz-Websites wie Amazon, eBay, AliExpress usw. erscheinen, [Beispiel](https://github.com/elyelysiox/recaptcha/blob/main/findProductPricesBlock.js)

- **Key 150** (`array`)
  - Wert: `[\"Join And Get Free Trial!\",\"\",\"Captcha Solving Service\",\"Prod...`
  - Beschreibung: Links, die aus den `<a>`-Elementen der Website extrahiert wurden; die VM extrahiert diese Werte selten

- **Key 545** (`boolean`)
  - Wert: `false`
  - Beschreibung: `navigator.webdriver`

- **Key 370** (`integer`)
  - Wert: `0`
  - Beschreibung: Maximale Geräte-Touchpoints `navigator.maxTouchPoints`

- **Key 779** (`array`)
  - Wert: `[null,null,null,null,"false"]`
  - Beschreibung: Extrahiert Daten aus Versand-/Abrechnungsfeldern, [Beispiel](https://github.com/elyelysiox/recaptcha/blob/main/formFieldScrape.js)
  
    `postal|postalcode|postalcode|postal_code|zip` → sucht nach Postleitzahlenfeld
    
    `ship|deliver` → Versandbereich
    
    `billing|payment|credit` → Abrechnungsbereich
    
    `country` → Länderauswahl
    
    `addr.*(match|equal)|(match|equal).*address` → Kontrollkästchen „gleiche Adresse"
    
    Liest Name, ID, Autocomplete, className jedes Elements
    Drei Phasen: Texteingaben, SELECT-Anweisungen, Kontrollkästchen

- **Key 659** (`array`)
  - Wert: `[[[0,921],[1,2053]],[[235054,1,1,1],[164277,3,4,1]],2,39]`
  - Beschreibung: Enthält Daten der gedrückten Elemente auf der Seite im Format `[[[count,timestamp]],[[hashedElem,tagType,type,autoComplete]],pressedCount,behaviorChecksum]`
 
    ### Elementtyp
    
    | Elementtyp | 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 |

    ### Verhaltens-Prüfsummen-Algorithmus
    
    Die behaviorChecksum ist eine kompakte Verhaltensbewertung, die aus den gesammelten Daten der Benutzerinteraktionen abgeleitet wird.
 
    Für jede Interaktion:
    - Der Interaktionsindex wird um eins erhöht
    - Der Zeitstempel wird mit dem angepassten Interaktionsindex kombiniert
    - Der Element-Hash wird mithilfe einer Modulo-Operation reduziert
    - Das Ergebnis wird zu einer laufenden Bewertung akkumuliert
   
    ---

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

    ### Beispiel

    ```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`)
  - Wert: `[[[0,0,979]],1,0]`
  - Beschreibung: Enthält während der Seitensitzung gesammelte Scrollbewegungen
 
    ### Basisformat
    ```
    [ [ [ scrollX, scrollY, timestamp ] ], count, behaviorChecksum ]
    ```

- **Key 895** (`array`)
  - Wert: `[[[1,0]]]`
  - Beschreibung: `VisibilityStateEntry` verfolgt den Sichtbarkeitsstatus der Seite und zeigt an, ob der Benutzer die Seite derzeit ansieht oder sie verlassen hat, im Format `[[[isVisible, startTime]]]`

- **Key 1092** (`array`)
  - Wert: `[886,2300,262.2099999997952,392.7600000009595,2050.2399999993577]`
  - Beschreibung: reCAPTCHA-Leistung, PerformanceNavigationTiming und PerformanceEventTiming, im Format `[vmStart,vmEnd,domContentLoadedEventEnd,loadEventEnd,firstUserInteractionTime]`

- **Key 41** (`array`)
  - Wert: `[[[1123,0,0]]]`
  - Beschreibung: ClearTimeout

- **Key 43** (`array`)
  - Wert: `[[[1123,0]]]`
  - Beschreibung: ClearTimeout

- **Key 549** (`array`)
  - Wert: `[0,null,null,null,null,null,null]`
  - Beschreibung: KeyboardEvent, berechnete Tasten + Zeitstempel

- **Key 352** (`array`)
  - Wert: `1,[[2050,125,633,266,[609,266,105,44],3,1,50,1,1]],[3,3,318],...`
  - Beschreibung:
    Die Struktur enthält:

    - Zeitsteuerung der Mausbewegungen
    - Cursor-Koordinaten
    - Klickdauern
    - Abmessungen der gedrückten Elemente
    - Zeigertyp-Informationen
    - Druckmetriken
    - Zurückgelegte Cursor-Distanz
    - Statistik zur Verhaltenszeitsteuerung

    ### Basisformat:
    ```
    [
      eventsCount,
      mouseEvents,
      [
        coalescedEventsCount,
        averageInterEventDelay,
        timingVarianceScore
      ],
      [
        totalPoints,
        clickSequenceScore,
        totalCursorDistance,
        totalPoints
      ],
      0,
      0,
      behaviorChecksum
    ]
    ```
    
    ### Mausereignis-Struktur:
    
    Jeder Eintrag in mouseEvents folgt dieser Struktur:
    
    ```
    [
      timestamp,
      clickDuration,
      clientX,
      clientY,
      [
        elementLeft,
        elementTop,
        elementWidth,
        elementHeight
      ],
      elementTagType,
      trackedElementIndex,
      pressure,
      pointerTravelDistance,
      pointerArea
    ]
    ```

    | Name | Beschreibung |
    |---|---|
    | `timestamp` | Ereigniszeitstempel relativ zum Ereignisstart |
    | `clickDuration` | Dauer zwischen `pointerdown` und `pointerup` |
    | `clientX` | ... |
    | `clientY` | ... |
    | `elementBounds` | Begrenzungsrechteck des interagierten Elements |
    | `elementTagType` | Kodierte DOM-Tag-Kennung des interagierten Elements |
    | `trackedElementIndex` | Interne Kennung des interagierten DOM-Elements aus der Laufzeit-Interaktionskarte |
    | `pressure` | Normalisierter Zeigerdruckwert multipliziert mit `100` |
    | `pointerTravelDistance` | Zurückgelegte Distanz zwischen `pointerdown` und `pointerup` |
    | `pointerArea` | Kontaktfläche, berechnet als `width * height` |

    ### Element-Tag-Typ

    Dies wird während der Ausführung der reCAPTCHA-VM initialisiert

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

    ### Beispiel
    ```
    [
      18342,
      91,
      742,
      381,
      [700, 320, 120, 38],
      3,
      1,
      50,
      1.4,
      16
    ]
    ```
    
    Stellt dar:
    
    - Ereignis bei `18.342s`
    - Klickdauer von `91ms`
    - Klick bei `(742, 381)`
    - Interaktion mit einem `BUTTON`
    - Zeigerdruck `0.5` (50)
    - leichte Cursor-Bewegung während des Klicks
    - Zeiger-Kontaktfläche von `16`
   
    ### Verhaltens-Prüfsummen-Algorithmus
 
    Für jedes Mausereignis:

    - Die Klickdauer wird verstärkt
    - Das Ergebnis wird mit dem Ereigniszeitstempel kombiniert
    - Cursor-Koordinaten und Elementabmessungen werden miteinander vermischt
    - Ein gewichtetes Verhältnis wird berechnet
    - Das Verhältnis wird gerundet und akkumuliert
    
    Nachdem alle Ereignisse verarbeitet wurden:
    
    - Die akkumulierte Bewertung wird mit der gesamten Cursor-Distanz kombiniert
    - Das Ergebnis wird mithilfe der Anzahl der gesammelten Punkte normalisiert
    - Eine logarithmische Transformation wird angewendet
    - Zusätzliche Bewegungsstatistiken werden einbezogen
    - Der Endwert wird mithilfe einer Modulo-Operation reduziert
    - Das Ergebnis wird zu einem kleinen ganzzahligen Wert gerundet
    
    ---
    
    ```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);
    }
    ```

    ### Beispiel

    ```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`)
  - Wert: `""`
  - Beschreibung: Parsen der gesammelten Gesamtpreise der Website in $ mit einem regulären Ausdruck `(?i)total[\S\s]{0,20}?(?:(?:(?:USD|\$)\s*)?[\d\.,]+\s*(?:USD|\$)|(?:USD|\$)\s*[\d\.,]+)`, [Beispiel](https://github.com/elyelysiox/recaptcha/blob/main/websitePricesTotal.js)

- **Key 1278** (`integer`)
  - Wert: `229.6`
  - Beschreibung: Division der aktuellen Laufzeitmessung durch 10 `Math.trunc(performance.now()) / 10`
    
- **Key 1422** (`boolean`)
  - Wert: `false`
  - Beschreibung: Analysiert, ob es OTP/2FA-Felder auf der Website gibt, [Beispiel](https://github.com/elyelysiox/recaptcha/blob/main/parseOTPFields.js)

- **Key 614** (`array`)
  - Wert: `[1,0,0,Infinity]`
  - Beschreibung: Gerätebatterieinformationen im Format `[level,isCharging,chargingTime,dischargingTime]`

- **Key 2033** (`array`)
  - Wert: `["0",-1,-1,999]`
  - Beschreibung: Einige VM-Konstantenwerte und VM-Laufzeitmessung

- **Key 1313** (`array`)
  - Wert: `["undefined",3]`
  - Beschreibung: Android-, Chrome-Prüfungen, `[typeof window.android, Object.keys(window.chrome).length]`

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

- **Key 1310** (`array`)
  - Wert: `["Google Inc. (Intel Inc.)","ANGLE (Intel Inc.,...`
  - Beschreibung: WebGL-Renderer, Hersteller und Gesamtzahl der Erweiterungen, [Beispiel](https://github.com/elyelysiox/recaptcha/blob/main/webglSignals.js)


- **Key 291** (`array`)
  - Wert: `[1542343452,0,105002991,3556653,96784904,-731949068,-902263026,...`
  - Beschreibung: Gehashte spezifische Prototyp-Schlüssel von Browserobjekten, wie `SpeechSynthesisEvent`, `NetworkInformation`, `HTMLElement` usw., [Beispiel](https://github.com/elyelysiox/recaptcha/blob/main/hashBrowserProtos.js)

## Reload-Request-Payload

Diese Daten werden mithilfe von protobuf (Protocol Buffers) serialisiert, einer effizienten, neutralen Methode zur Serialisierung strukturierter Daten, die von Google entwickelt wurde.```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,
]

Das Payload enthält:

- Informationen zum Ressourcen-Timing
- Performance-Timing langer Aufgaben
- Ausführungsdeltas der reCAPTCHA-VM
- Skript-URLs der Website
- Statistiken zur Sammlung von Browser-Objekten

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

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

### Ereigniszählerstruktur```js
[
  [
    [eventType, count]
  ]
]

## Feldbeschreibungen

| Index | Name | Beschreibung |
|---|---|---|
| `0` | `rresp` | Antworttyp-Kennung, die vom Reload-Endpunkt zurückgegeben wird |
| `1` | `responseToken` | reCAPTCHA-Antwort-Token |
| `3` | `tokenExpiration` | Token-Lebensdauer in Sekunden bis zum Ablauf |
| `4` | `pmeta` | Challenge-Metadatenblock, der Informationen über den CAPTCHA-Typ, die Kategorie und das Rasterlayout enthält |
| `5` | `challengeType` | Typ der CAPTCHA-Challenge |
| `8` | `usagePatternToken` | Nutzungsmuster, gespeichert in `window.sessionStorage` und bei zukünftigen `/reload`-Anfragen wiederverwendet |
| `9` | `challengeImageToken` | Token zum Abrufen der CAPTCHA-Bild-Payload vom `/payload`-Endpunkt |
| `12` | `humanVerificationToken` | Token zur menschlichen Identifikation, verknüpft mit dem Google-reCAPTCHA-Zustand und Browser-Cookies |
| `14` | `captchaSessionToken` | Internes Session-Token |
| `15` | `bftToken` | ... |

---

### `pmeta`-Struktur

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

### Kategorie-Kennungen

| ID | Kategorie |
|---|---|
| `/m/0pg52` | Taxi |
| `/m/01bjv` | Bus |
| `/m/02yvhj` | Schulbus |
| `/m/04_sv` | Motorrad |
| `/m/013xlm` | Traktor |
| `/m/01jk_4` | Schornstein |
| `/m/014xcs` | Zebrastreifen |
| `/m/015qff` | Ampel |
| `/m/0199g` | Fahrrad |
| `/m/015qbp` | Parkscheinautomat |
| `/m/0k4j` | Auto |
| `/m/015kr` | Brücke |
| `/m/019jd` | Boot |
| `/m/0cdl1` | Palme |
| `/m/09d_r` | Berg / Hügel |
| `/m/01pns0` | Hydrant |
| `/m/01lynh` | Treppe |

## UserVerify-Anfrage-Payload
Das `/userverify`-Payload wird übermittelt, nachdem der Nutzer eine reCAPTCHA-v2-Bild-Herausforderung abgeschlossen hat

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

Beispiel-Payload:```json
{
  "response": [2, 3, 6]
}

Beispiel-Payload:```json
{
  "response": [2, 3, 6, 14]
}

Dieses Feld enthält verschlüsselte Interaktionsmetadaten zu CAPTCHA-Button-Aktionen wie:

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

### Interne Struktur von `e`

Nach der Entschlüsselung sieht die Struktur wie folgt aus:```txt
[[["9ffd9672"]]]

### `oc` — Verschlüsselte VM-Signale

Verwendet denselben Verschlüsselungsalgorithmus wie das Feld `idx 16` der `/reload`-Anfragenutzlast, wobei der Verschlüsselungsschlüssel im Anker (Index 31) `1777752103288` geladen wird.

### `pm` — Telemetrie-Nutzlast

Das Feld `pm` enthält eine Base64-kodierte Telemetriestruktur, die der in `/reload` verwendeten Telemetrie-Nutzlast ähnelt.

 
## Anti-Debugging/Manipulationsschutz
- ***Symbolbasierte Integritätsmarkierung***
    reCAPTCHA setzt einen Symbol-Schlüssel `Symbol(jas)` auf jedes Array und Objekt mit einem numerischen Wert, der als Integritätsprüfung dient. Da Symbole nicht aufzählbar und für standardmäßige Klonoperationen (wie JSON.stringify) unsichtbar sind, verliert jeder Versuch, diese Strukturen zu ersetzen oder zu klonen, die Markierung, was reCAPTCHA als Manipulation erkennt

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

- ***Erfassung von Closure-Variablen***
    Einige Werte werden absichtlich in einer äußeren Funktion definiert und nur innerhalb verschachtelter Callbacks oder Closures konsumiert; die Variable existiert nie in demselben Gültigkeitsbereich, in dem sie verwendet wird

- ***Timing-Prüfungen***
    reCAPTCHA enthält Mechanismen zur Erkennung von Debugging zur Laufzeit. Wenn es erkennt, dass der Code von einem Debugger analysiert wird, startet es die Debugging-Sitzung neu, wodurch der Ausführungszustand und der Kontext verloren gehen

- ***Absturz des Quell-Tabs***

    https://github.com/user-attachments/assets/4ae3bf68-5ae7-4adc-a0b9-36cc11b64998
  
    Dieser Fehler tritt in Browsern auf, die Chromium verwenden. Es gibt mehrere Fehler, die dazu führen, dass der Browser oder die Entwicklertools unerwartet geschlossen werden, wie zum Beispiel der hier gezeigte:
    
    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
    
    Daher wird einer dieser Fehler höchstwahrscheinlich ausgelöst, wenn das Timeout eintritt, da es vermutlich nichts ist, was im Ablauf eines echten Benutzers passieren würde

## reCAPTCHA Botguard

Obwohl BotGuard von Google entfernt wurde, erkläre ich für alle, die sich dafür interessieren, wie es funktioniert und wie sehr es sich von anderen Arten von Botguard unterscheidet, ein wenig über seine interne Funktionsweise

Zunächst der Prozess der Token-Erzeugung: Die VM erzeugt Token für anhaltende Fehler während der Ausführung. Diese Fehler können auf Abweichungen im Bytecode-Offset, fehlende VM-Register, falschen VM-Zustand und schlechte Kontrollfluss-Integrität zurückzuführen sein. Diese Fehler werden vom Dispatcher erfasst, der eine Funktion aufruft, die Bytes für das Token schreibt.

Die VM verwendet ARX Cipher, einen Algorithmus, der 2013 von der NSA entwickelt wurde und Speck ähnelt, zur Verschlüsselung von Daten. Er wird auch in allen Google-BotGuard-Versionen verwendet. Der Algorithmus ändert sich mit jeder Version, ebenso wie die Konstante (3990), die Reihenfolge der Operationen und die Runden. Er sieht so aus:```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];
}

Und dies ist die Funktion, die Fehler behandelt und den Byte-Writer aufruft.```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;
        }
    }
}