Antibot solver blackbox testing fails after 200 runs ⇐ Python

[Anonymous]

Mein Team hat ein Antibot für ein Projekt entworfen und jetzt teste ich seine Schwachstellen. Ich habe einen Antibot -Löser -Bypass unter Verwendung von Python und JavaScript erstellt. Ich stoße in ein super-seltsames Problem der Laufzeitabhängigkeit, bei dem mein Solver nach 200-210 Versuchen immer fehlschlägt, aber es funktioniert wieder, wenn ich den Solver-Server zurücksetze. Wie es funktioniert: < /p>

[*] Antibot -Solver wird als Python Flask -Server gehostet. Es spielt keine Rolle, ob sie lokal gehostet oder Google Cloud ausgeführt haben. Ich bin Black -Box -Test, kann es nicht sehen. Ich habe viele Male viele Male ausprobiert und 200-220 ist der Schwellenwert, an dem es immer fehlschlägt. Wenn ich jedoch den Flask -Server ausschalten und neu starten kann, kann ich den Flask -Server erneut neu starten. Ich denke, etwas, das zur Laufzeit initiert wird, wie z. B. ein Uuid/Hash in einem Modul, wird durchgesickert und der Löser beginnt, ihn zu kennzeichnen. Oder vielleicht nach 200 Versuchen gibt es einen Speicherüberlauf im Heap und die Signaturberechnung wird schmutzig über Schreibvorgänge.

Code: Select all

main.py

(Flask Server)

[*]

Code: Select all

gen.py

(Antibot -Solver -Logik, importiert JS mit dem Python JavaScript -Modul)

Code: Select all

solve.js

(JavaScript -Code, das eine dekompilierte WASM hostet) - Ich gehe davon aus, dass er den Heap verwendet, indem ich einen Puffer erstellt. Speicher und Heap sehen ohne Überlauf gut aus. Es ist immer 1-2 MB verfügbar. /> < /li>
< /ul>
Neue Idee < /strong> < /p>

Ich möchte alle Python -Module mit Importlib < /code> jedes Mal neu laden. Jedes Mal, wenn der Server löst < /li>
< /ul>
< /> Das Problem. Module in einer gleichzeitigen Umgebung, in der Anfragen an den Solver -Server zu zufälligen Zeiten und hohem Volumen (derzeit bei 20 Threads getestet werden). Wie kann ich basierend auf meinem Design alle Module neu laden? Ich bin besonders daran interessiert, das JavaScript -Modul neu zu laden, da dies zum Importieren des JS-Solvers verwendet wird.

Code: Select all

from flask import Flask, request, jsonify
from google.oauth2 import service_account
from google.cloud import firestore
from gen import *

app = Flask(__name__)
creds = service_account.Credentials.from_service_account_file("service.json")
db = firestore.Client(credentials=creds)

@app.route('/recalculate', methods=['GET', 'POST'])
def recalculate():
try:
data = Calculate()

return jsonify(data), 200
except Exception as e:
return jsonify({"error": str(e)}), 500

if __name__ == '__main__':
port = int(os.environ.get('PORT', 8080))
app.run(host='0.0.0.0', port=port)
< /code>
gen.py
from javascript import require
import urllib.parse
import requests_go
import importlib
import hashlib
import random
import base64
import mmh3
import json
import math
import time
import gc

def Calculate(...):
try:
asyncFun = require("solve.js")
except Exception as e:
print(f"Failed to init js: {e}")
return "", ""

result = asyncFun['asyncSign'](...)

del asyncFun
gc.collect()

return result
< /code>
Solve.js
// some misc code

// Main start of wasm function
function asmFunc(imports) {
var buffer = new ArrayBuffer(16777216);
var HEAP8 = new Int8Array(buffer);
var HEAP16 = new Int16Array(buffer);
var HEAP32 = new Int32Array(buffer);
var HEAPU8 = new Uint8Array(buffer);
var HEAPU16 = new Uint16Array(buffer);
var HEAPU32 = new Uint32Array(buffer);
var HEAPF32 = new Float32Array(buffer);
var HEAPF64 = new Float64Array(buffer);
var Math_imul = Math.imul;
var Math_fround = Math.fround;
var Math_abs = Math.abs;
var Math_clz32 = Math.clz32;
var Math_min = Math.min;
var Math_max = Math.max;
var Math_floor = Math.floor;
var Math_ceil = Math.ceil;
var Math_trunc = Math.trunc;
var Math_sqrt = Math.sqrt;
var a = imports.a;

// ...
// 26k lines of decompiled wasm

// wasm function called like this:
var retasmFunc = asmFunc({
a: QoQoQ
});
module.exports = {
v: retasmFunc.v,
w: retasmFunc.w,
x: retasmFunc.x,
y: retasmFunc.y,
A: retasmFunc.A,
B: retasmFunc.B,
C: retasmFunc.C,
D: retasmFunc.D,
E: retasmFunc.E
};
var varXX = {};
varXX["hp"] = new Int8Array(retasmFunc.v["buffer"]);

// More JS logic

async function asyncSign() {
retasmFunc.A();

var0 = retasmFunc.y(var50["length"] + 1);
new Uint8Array(retasmFunc.v["buffer"], var0, var51["length"])["set"](var9);
}

module.exports = {
asyncSign: asyncSign,
};
< /code>
 Update < /strong>
Versuchen Sie, nach jedem Lösen von Speicher und aufzuräumen. Ich habe versucht, diese Funktion am Ende von AsyncSign 

aufzurufen, und es arbeitet, den Speicher in Umgebungen zu befreien, die nicht mit Multi-Threaded sind. Wenn es jedoch zu einer Parallelität besteht, bekomme ich Fehler, weil ich davon ausgeht, dass die JS -Engine die Speicher- /WASM -Instanz zwischen Threads freigibt, obwohl ich möchte, dass jeder Thread unabhängig ist. Außerdem wurde mir klar, dass der Python-Garbage-Sammler nicht frei von der JS/Knoten-Engine ist.function cleanupWasmMemory() {
if (varcv && varcv["hp"]) {
varcv["hp"] = null;
}

if (typeof module !== 'undefined' && module.exports) {
module.exports.v = null;
module.exports.w = null;
module.exports.x = null;
module.exports.y = null;
module.exports.A = null;
module.exports.B = null;
module.exports.C = null;
module.exports.D = null;
module.exports.E = null;
}

if (typeof retasmFunc !== 'undefined') {
retasmFunc = null;
}

if (typeof varcc !== 'undefined') {
varcc = null;
}

// Both ifs dont get called
if (typeof global !== 'undefined' && global.gc) {
global.gc();
} else if (typeof window !== 'undefined' && window.gc) {
window.gc();
}
}
< /code>
Ich möchte, dass jeweils eine unabhängige WASM löst. Es scheint, als würde jeder Thread Speicher teilen. Wie kann ich das beheben?