@anonympins/fingerprint 0.4.4 → 0.4.6

package/CHANGELOG.md

@@ -1,3 +1,43 @@
+## Version 0.4.6
+
+### ✨ New Features
+
+- **Polymorphic WASM Modules**: Further enhances client-side WebAssembly modules by introducing polymorphic generation, making it even harder for bots to fingerprint and reverse-engineer the client-side logic.
+- **Proof-of-Space (PoSpace) Challenge**: Implemented a new Proof-of-Space challenge type. This challenge requires clients to allocate and prove access to a certain amount of storage space, adding another layer of bot detection.
+- **Enhanced TLS Tracking (HTTPS)**: Introduced new capabilities for tracking and analyzing TLS-related information, improving the accuracy of client identification and anomaly detection over HTTPS connections.
+
+### 🚀 Improvements
+
+- **Analog Cross-Layer Inconsistency Score**: Refined the `crossLayerInconsistencyScore` calculation to provide a more nuanced and "analog" assessment of inconsistencies between different layers of client data, leading to more precise bot identification.
+
+### 🐛 Bug Fixes
+
+- **Auto-Tuner Fix**: Addressed several issues within the auto-tuner, improving its stability, learning accuracy, and resilience against edge cases.
+
+---
+
+## Version 0.4.5
+
+### ✨ New Features
+
+- **Stateless PoW Ticket Validation**: Introduced cryptographically secure stateless Proof-of-Work (PoW) tickets. These tickets are encrypted and signed, allowing for tamper-proof validation without requiring server-side storage, improving scalability and resilience.
+- **TCP Anomaly Score**: Implemented a new `tcpAnomalyScore` based on passive TCP/IP fingerprinting (p0f-like analysis). This score detects inconsistencies between the client's TCP stack (TTL, window size, options) and its User-Agent, indicating potential spoofing or bot activity.
+- **Dynamic WebAssembly (WASM) Modules**: Introduced polymorphic WASM module generation. The client-side WASM solver now generates unique, randomized code for each request or session, significantly increasing the cost and difficulty for bots to fingerprint, reverse-engineer, and bypass.
+
+### 🚀 Improvements
+
+- **Enhanced Client Hints Inconsistency Detection**: Improved the `clientHintsInconsistencyScore` calculation for more precise detection of discrepancies between User-Agent and Client Hints headers, leading to more accurate bot identification.
+
+### 🛡️ Security Enhancements
+
+- **PHP DoS Prevention**: Implemented specific measures in the PHP engine to prevent Denial-of-Service (DoS) attacks, ensuring stability and resource protection under high load or malicious activity.
+
+### 📚 Documentation
+
+- **README Update**: Updated `README.md` to reflect the latest features and changes in the library.
+
+---
+
 ## Version 0.4.4
 
 ### 🧮 Pattern Score Ratios & Weighted Subscores

package/README.md

@@ -6,7 +6,7 @@ NodeJS tests : [![Test NodeJS](https://img.shields.io/github/actions/workflow/st
 [![License](https://img.shields.io/github/license/anonympins/fingerprint)](https://github.com/anonympins/fingerprint/blob/main/LICENSE)
 ![GitHub commit activity](https://img.shields.io/github/commit-activity/w/anonympins/fingerprint)
 
-A multi-layered behavioral, cryptographic, and network analysis engine designed to identify and mitigate malicious requests (bots, scrapers, session hijacking) in real-time. Supports **Node.js**, **Python** and **PHP** environments.
+A multi-layered behavioral, cryptographic, and network analysis engine designed to identify and mitigate malicious requests (bots, scrapers, session hijacking, bot farms) in real-time. Supports **Node.js**, **Python** and **PHP** environments.
 
 ![illustration](https://i.ibb.co/fV1QT6Mf/image-c6e10859baae53bb595112ec08fc9e27.png)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anonympins/fingerprint",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Advanced anti-bot library for Node.js using multi-layer fingerprinting (JA3, client-side, headers), behavioral analysis, and adaptive Proof-of-Work (PoW) challenges to mitigate scraping, scalping, and automated threats.",
   "main": "index.js",
   "type": "module",

package/src/js/dynamic-wasm.js

@@ -0,0 +1,180 @@
+import crypto from "node:crypto";
+
+function encodeULEB128(val) {
+    const bytes = [];
+    let num = val >>> 0;
+    do {
+        let byte = num & 0x7f;
+        num >>>= 7;
+        if (num !== 0) byte |= 0x80;
+        bytes.push(byte);
+    } while (num !== 0);
+    return bytes;
+}
+
+function encodeSLEB128(val) {
+    const bytes = [];
+    let num = val | 0;
+    while (true) {
+        let byte = num & 0x7f;
+        num >>= 7;
+        if ((num === 0 && (byte & 0x40) === 0) || (num === -1 && (byte & 0x40) !== 0)) {
+            bytes.push(byte);
+            break;
+        }
+        bytes.push(byte | 0x80);
+    }
+    return bytes;
+}
+
+function generatePolymorphicInstructions() {
+    const ops = [0x6a, 0x6b, 0x6c, 0x73]; // add, sub, mul, xor
+    const insts = [];
+    const count = 3 + Math.floor(Math.random() * 5); // 3 to 7 instructions
+    
+    // Initialize dummy local 4
+    const initVal = Math.floor(Math.random() * 1000) - 500;
+    insts.push(0x41, ...encodeSLEB128(initVal), 0x21, 0x04);
+    
+    for (let i = 0; i < count; i++) {
+        const op = ops[Math.floor(Math.random() * ops.length)];
+        const randVal = Math.floor(Math.random() * 1000) - 500;
+        insts.push(0x20, 0x04, 0x41, ...encodeSLEB128(randVal), op, 0x21, 0x04);
+    }
+    return insts;
+}
+
+export class DynamicWasmGenerator {
+    /**
+     * Generates a unique polymorphic WebAssembly module containing a custom hash function
+     * with randomized constants and control flow variables.
+     * @param {object} constants - Custom seed, multiplier and adder.
+     * @returns {Buffer} Valid WebAssembly binary buffer.
+     */
+    static generate(constants) {
+        const { seed, multiplier, adder } = constants;
+
+        const preLoopPoly = generatePolymorphicInstructions();
+        const midLoopPoly = generatePolymorphicInstructions();
+
+        const inst = [
+            0x01, 0x05, 0x7f, // Locals: 1 entry of 5 locals of type i32
+            ...preLoopPoly,
+            // h = seed
+            0x41, ...encodeSLEB128(seed),
+            0x21, 0x03,
+            // i = 0
+            0x41, 0x00,
+            0x21, 0x02,
+
+            // block
+            0x02, 0x40,
+            // loop
+            0x03, 0x40,
+
+            // if i >= len break
+            0x20, 0x02,
+            0x20, 0x01,
+            0x4f,
+            0x0d, 0x01,
+
+            // byte = load8_u(ptr + i)
+            0x20, 0x00,
+            0x20, 0x02,
+            0x6a,
+            0x2d, 0x00, 0x00,
+
+            // h = h ^ byte
+            0x20, 0x03,
+            0x73,
+
+            // h = h * multiplier
+            0x41, ...encodeSLEB128(multiplier),
+            0x6c,
+
+            // h = h + adder
+            0x41, ...encodeSLEB128(adder),
+            0x6a,
+
+            // local.set 3
+            0x21, 0x03,
+            ...midLoopPoly,
+
+            // i = i + 1
+            0x20, 0x02,
+            0x41, 0x01,
+            0x6a,
+            0x21, 0x02,
+
+            // br 0
+            0x0c, 0x00,
+
+            0x0b, // end loop
+            0x0b, // end block
+
+            // return h
+            0x20, 0x03,
+            0x0b // end function
+        ];
+
+        const funcBody = [
+            ...encodeULEB128(inst.length),
+            ...inst
+        ];
+
+        const codeSectionPayload = [
+            ...encodeULEB128(1),
+            ...funcBody
+        ];
+
+        const codeSection = [
+            0x0a,
+            ...encodeULEB128(codeSectionPayload.length),
+            ...codeSectionPayload
+        ];
+
+        const typeSection = [
+            0x01, 0x07, 0x01, 0x60, 0x02, 0x7f, 0x7f, 0x01, 0x7f
+        ];
+
+        const funcSection = [
+            0x03, 0x02, 0x01, 0x00
+        ];
+
+        const memSection = [
+            0x05, 0x03, 0x01, 0x00, 0x01
+        ];
+
+        const exportSection = [
+            0x07, 0x11, 0x02, 0x04, 0x68, 0x61, 0x73, 0x68, 0x00, 0x00, 0x06, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x02, 0x00
+        ];
+
+        const wasm = [
+            0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,
+            ...typeSection,
+            ...funcSection,
+            ...memSection,
+            ...exportSection,
+            ...codeSection
+        ];
+
+        return Buffer.from(wasm);
+    }
+
+    /**
+     * Pure JavaScript fallback equivalent of the custom polymorphic hash.
+     * @param {string} str Input string.
+     * @param {object} constants Parameters.
+     * @returns {number} 32-bit unsigned integer hash.
+     */
+    static hashJs(str, constants) {
+        const { seed, multiplier, adder } = constants;
+        let h = seed | 0;
+        for (let i = 0; i < str.length; i++) {
+            const byte = str.charCodeAt(i) & 0xff;
+            h = h ^ byte;
+            h = Math.imul(h, multiplier) + adder;
+        }
+        return h >>> 0;
+    }
+}

package/src/js/fingerprint.client.js

@@ -671,6 +671,27 @@ const ClientLibrary = {
      */
     async initializeWasm(wasmPath) {
         try {
+            // Direct standalone polymorphic WebAssembly loading
+            if (wasmPath.endsWith('.wasm')) {
+                const response = await fetch(wasmPath);
+                const arrayBuffer = await response.arrayBuffer();
+                const module = await WebAssembly.compile(arrayBuffer);
+                const instance = await WebAssembly.instantiate(module, {});
+                const exports = instance.exports;
+                const memory = exports.memory;
+                activeCyrb53 = (str) => {
+                    const encoder = new TextEncoder();
+                    const bytes = encoder.encode(str);
+                    const view = new Uint8Array(memory.buffer, 0, bytes.length);
+                    view.set(bytes);
+                    return exports.hash(0, bytes.length);
+                };
+                console.log('[Fingerprint] Standalone polymorphic WASM loaded successfully. Using fast dynamic hashing.');
+                if (this._cachedBuilder) {
+                    this._cachedBuilder.addRaw('wasm', 'true');
+                }
+                return;
+            }
             // 1. Injecter le script qui charge le module WASM
             const script = document.createElement('script');
             script.src = wasmPath;