Beschreibung

Dieses Repository enthält eine technische Analyse von Googles Antibot-System (reCAPTCHA), mit Schwerpunkt auf:

Payload-Aufbau und -Werte
Fingerprinting-Techniken
Verschleierungstechniken
Anti-Debugging-/Manipulationstechniken
Virtuelle Maschinen

Kontakt

Discord: @g_recaptcha
Telegram: @lyxlobyx

Verschleierungstechniken

reCAPTCHA ist eines der Antibot-Systeme mit den ausgefeiltesten Verschleierungstechniken. Es verwendet eine Reihe von Transformationen, die den Code weniger lesbar machen und das Reverse Engineering erschweren. Die meisten Verschleierungen lassen sich mithilfe des Abstract Syntax Tree (AST) einfach manipulieren, aber einige werden zur Laufzeit verarbeitet, wodurch der AST in diesem Fall nutzlos wird. Auf den Code wird außerdem Polymorphismus angewendet, um seine Struktur in jeder Version des Skripts zu verändern. Beispielsweise führt der Code die Aktion nicht direkt aus. Stattdessen verwendet er Objekte oder Funktionen, die ihre Form ändern.

Sequenzausdrücke Der Code wird abgeflacht, indem jede Blockanweisung in einen fortlaufenden, durch Kommas getrennten Ausdruck umgewandelt wird. Dies kann in if-Anweisungen, Funktionsargumenten und sogar innerhalb von Objekten vorkommen.
Gemischte Boolesche Arithmetik Verwebt arithmetische Operationen (Addition, Subtraktion, Multiplikation) mit bitweisen Operationen (AND, OR, XOR, NOT), um die ursprüngliche Logik zu verbergen, zum Beispiel -2 * ~(h & H) + -2 + (h ^ H)
Indirekte Funktionstabelle Jede Funktion wird in einer Tabelle abgelegt und über ihren Index aufgerufen, wie functions[index](https://github.com/elyelysiox/recaptcha/blob/main/args)

Inline-Konstanten-Array Ein lokales Array-Literal wird inline mitten im Ausdruck zugewiesen. Das Array bündelt Konstanten (Zahlen, Strings), die über den gesamten Funktionskörper hinweg per Indexzugriff wiederverwendet werden.

// b = [14, 1, "call"] assigned inline inside a sequence expression
function(Y, Q, c, l, G, X, W, J, b, P) {
    (Y & 94) == Y && (b = [14, 1, "call"], ...)
    W[b[2]](J, G)   // W.call(J, G)
    Y >> b[1] & b[0]  // Y >> 1 & 14
}

Funktions-Multiplexing Mehrere logisch unterschiedliche Funktionen werden zu einer einzigen zusammengeführt, wobei ein numerischer Parameter als Blockauswahl dient. Der aktive Block wird bestimmt, indem der Parameter gegen bitweise Bedingungen ausgewertet wird. Aufrufer übergeben einen numerischen Literalwert als Selektor.

function(N, y, U, Y, h, H, m, C, u) {
    C = [26, 47, 6];

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

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

    return u;
}

Verzweigung über logische Operatoren Ersetzt if-Anweisungen und if/else-Blöcke durch Kurzschlussauswertung logischer Operatoren und wandelt den Kontrollfluss in Ausdrücke um. In Kombination mit Sequenzausdrücken erscheinen mehrere Verzweigungen als ein einziger fortlaufender, durch Kommas getrennter Ausdruck.

// if (a) { block }
a && (block)

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

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

// combined with CFF and sequence expressions:
(Y | 1) & 14 || (c = Q.O, J = c.O.length + c.g.length),
(Y ^ 59) >> 3 == 3 && (Q.classList
    ? Q.classList.add(c)
    : Z[31](31, Q, c) || (l = f[0](84, "string", "", Q), ...)),

Gebundene native Methodenkonstanten Bindet native Browser-Methoden an ihre ursprünglichen Empfänger und speichert sie als Konstanten, um Manipulationen zu verhindern.

LO = (Tw = self) == null ? void 0 :
 (K9 = Tw.Math) == null ? void 0 :
 (v4 = K9.floor) == null ? void 0 :
 (mF = v4.bind) == null ? void 0 :
 mF.call(v4, Math)  // Math.floor.bind(Math)

LO(x)           // Math.floor(x)
U4()            // Math.random()
Ge(obj, prop)   // Object.defineProperty(obj, prop)

Toter Code Unzugängliche oder ungenutzte Codeblöcke werden in der gesamten Datei eingefügt, wodurch deren Größe auf über 60.000 Zeilen anwächst. Dies erschwert statische Analyse und LLM-basiertes Reverse Engineering.
Kontrollfluss-Abflachung Transformiert jeden Teil des Codes (Deklarationen und Schleifen) in eine flache Zustandsmaschine. Es verbirgt die ursprüngliche Ausführungslogik, indem alle Codeblöcke über einen zentralen „Dispatcher“-Block geleitet werden.

Dispatcher können ihre Form ändern; einige haben 2–3 Zustandsvariablen, und der Schleifen-/Bedingungstyp ändert sich. Sie sehen wie folgt aus.

Dies ist ein CFF mit 2 Zustandsvariablen, eine verwaltet den catch-Block und die andere den try-Block.
Verschlüsselter String-Pool Alle String-Literale (DOM-APIs, Browser-Eigenschaften, CSS-Werte, Fehlermeldungen usw.) werden in einem einzigen massiven String-Pool verschlüsselt. Eine Entschlüsselungsfunktion verwendet einen Seed und eine auf LCG basierende XOR-Chiffre, um jeden String zur Laufzeit zu extrahieren.

Über 1990 Aufrufstellen sind über den Code verteilt. Die Entschlüsselungsfunktion verwendet einen laufenden Schlüssel, der dekodierte Codepunkte akkumuliert, sodass jedes Zeichen von allen vorherigen abhängt.
```
X = function(J, b, P, F, U) {
    U = ["codePointAt", 127, "char encrypted pool"];
    for (F = (P = 0, b = "", l); P < Q; P++)
        J = (U[2][U[0]](c + P) ^ F) & U[1],  // XOR with running key
        b += String.fromCodePoint(J),
        F += J; // accumulate key
    return G = b;
}

// call sites pass a seed to locate and decrypt each string
Z[23](64, 4, 54961, 103)()  // → "lang"
Z[23](66, 4, 54961, 103)()  // → "addEventListener"
Z[23](32, 12, 20287, 852)() // → "inline-block"
```
Zustandsbehafteter Wert-Iterator reCAPTCHA verwendet eine zustandsbehaftete Funktion, die eine Sequenz von Laufzeitobjekten und -werten (wie window, document.body, numerische Konstanten) in fester Reihenfolge zurückgibt. Jeder Aufruf bewegt einen internen Cursor weiter. Ein Aufruf außerhalb der Reihenfolge oder zu häufig korrumpiert alle nachfolgenden Lesezugriffe. Ein Timeout-Mechanismus invalidiert den Zustand nach einem festen Intervall und gibt für verspätete Lesezugriffe null zurück.
```
// sequential calls return different values:
c()  // → window
c()  // → document.body
c()  // → 123
c()  // → null (timeout expired)

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

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

c().querySelectorAll(a[X[2]](98, X[1], X[1]))
// ↑ document.body  
```
Berechnete Funktionstabelle Dies ähnelt der Indirect Function Table, aber hier wird der Index der zu erhaltenden Funktion zur Laufzeit mit einem Seed mithilfe von XOR und Modulo berechnet.

recaptcha

Beliebteste

Beschreibung

Kontakt

Verschleierungstechniken