@anonympins/fingerprint 0.2.1 → 0.2.3

package/library.js

@@ -1583,29 +1583,104 @@ Optimization.Operators.createFullSecurityConfigEvaluator = ({ trafficData }) =>
  * @returns {Array<{solution: object, objectives: number[]}>} Le front de Pareto des configurations optimales.
  */
 Optimization.Operators.solveFullSecurityTuning = (context, options = {}) => {
-    const fitnessFunction = Optimization.Operators.createFullSecurityConfigEvaluator(context); // eslint-disable-line
+    const fitnessFunction = Optimization.Operators.createFullSecurityConfigEvaluator(context);
 
     // Un "individu" est un objet de configuration complet
     const createIndividual = () => ({
         thresholds: {
-            low: 10 + Math.random() * 30, // 10-40
-            medium: 40 + Math.random() * 30, // 40-70
-            high: 70 + Math.random() * 25, // 70-95
+            low: 15 + Math.random() * 20, // 15-35
+            medium: 40 + Math.random() * 25, // 40-65
+            high: 70 + Math.random() * 20, // 70-90
         },
         weights: {
             historyScore: Math.random(),
             rotationScore: Math.random(),
             headerAnomalyScore: Math.random(),
-            requestPatternScore: Math.random(),
+            requestPatternScore: 0.5 + Math.random(), // Donner plus d'importance aux patterns
             inconsistencyScore: Math.random(),
             honeypotScore: 1.0, // Garder le honeypot à 1.0 est une bonne pratique
+            behaviorScore: Math.random(),
+            crossLayerInconsistencyScore: Math.random(),
+            timeInconsistencyScore: Math.random(),
         },
-        // On pourrait aussi faire muter les `patterns` ici
+        patterns: {
+            velocityThreshold: 100 + Math.random() * 400, // 100-500ms
+            velocityWeight: 10 + Math.random() * 40,
+            burstThreshold: 300 + Math.random() * 700, // 300-1000ms
+            burstWeight: 20 + Math.random() * 40,
+            scrapeThreshold: 500 + Math.random() * 1000, // 500-1500ms
+            scrapeWeight: 15 + Math.random() * 35,
+            sequenceLength: 3 + Math.floor(Math.random() * 3), // 3-5
+            sequenceWeight: 20 + Math.random() * 50,
+            regularityThreshold: 50 + Math.random() * 200, // 50-250ms
+            regularityWeight: 20 + Math.random() * 40,
+            decayFactor: 0.85 + Math.random() * 0.14, // 0.85-0.99
+            inactivityReset: 15000 + Math.random() * 45000, // 15s-60s
+        }
     });
 
     // Le crossover et la mutation doivent maintenant opérer sur des objets complexes
-    const crossover = (c1, c2) => { /* ... logique de croisement pour les objets de config ... */ return c1; }; // eslint-disable-line
-    const mutate = (c) => { /* ... logique de mutation pour les objets de config ... */ return c; }; // eslint-disable-line
+    const crossover = (c1, c2) => {
+        const child = JSON.parse(JSON.stringify(c1)); // Deep copy
+        // Croisement pour chaque groupe de paramètres
+        for (const key in child.thresholds) {
+            child.thresholds[key] = (c1.thresholds[key] + c2.thresholds[key]) / 2;
+        }
+        for (const key in child.weights) {
+            if (key !== 'honeypotScore') { // Ne pas croiser le poids du honeypot
+                child.weights[key] = (c1.weights[key] + c2.weights[key]) / 2;
+            }
+        }
+        for (const key in child.patterns) {
+            child.patterns[key] = (c1.patterns[key] + c2.patterns[key]) / 2;
+        }
+        return child;
+    };
+
+    const mutate = (c) => {
+        const newConfig = JSON.parse(JSON.stringify(c));
+
+        // --- NOUVELLE LOGIQUE : Sélection de section pondérée ---
+        // On donne plus de poids à la mutation des 'patterns' et des 'weights',
+        // car ils ont un impact plus direct sur la détection que les seuils.
+        const sections = [
+            { name: 'patterns', weight: 0.5 },   // 50% de chance
+            { name: 'weights', weight: 0.35 },   // 35% de chance
+            { name: 'thresholds', weight: 0.15 } // 15% de chance
+        ];
+        const rand = Math.random();
+        let cumulativeWeight = 0;
+        let sectionToMutate = 'patterns'; // Fallback
+        for (const section of sections) {
+            cumulativeWeight += section.weight;
+            if (rand < cumulativeWeight) {
+                sectionToMutate = section.name;
+                break;
+            }
+        }
+
+        const keys = Object.keys(newConfig[sectionToMutate]);
+        const keyToMutate = keys[Math.floor(Math.random() * keys.length)];
+
+        if (keyToMutate === 'honeypotScore') return newConfig; // Ne pas muter le poids du honeypot
+
+        // Appliquer une mutation avec une amplitude variable
+        const mutationAmount = (Math.random() - 0.5) * 0.4; // +/- 20%
+        newConfig[sectionToMutate][keyToMutate] *= (1 + mutationAmount);
+
+        // S'assurer que les valeurs restent dans des limites raisonnables
+        if (sectionToMutate === 'weights') {
+            newConfig[sectionToMutate][keyToMutate] = Math.max(0, Math.min(1.5, newConfig[sectionToMutate][keyToMutate]));
+        }
+        if (keyToMutate === 'decayFactor') {
+            newConfig.patterns.decayFactor = Math.max(0.8, Math.min(0.999, newConfig.patterns.decayFactor));
+        }
+        if (keyToMutate.includes('Threshold') || keyToMutate.includes('Reset')) {
+            newConfig.patterns[keyToMutate] = Math.max(50, newConfig.patterns[keyToMutate]);
+        }
+
+        return newConfig;
+    };
 
     return Optimization.geneticAlgorithmMultiObjective(
         createIndividual,

package/mongodb-store.js

@@ -1,53 +1,53 @@
-/**
- * @file Creates a store adapter for MongoDB.
- * This adapter uses a collection as a key-value store and leverages MongoDB's TTL indexes
- * for automatic expiration of documents.
- */
-
-/**
- * Creates a store adapter for a MongoDB collection.
- * It's recommended to pass the `db` object and let the adapter handle the collection.
- *
- * **Note:** For TTL to work, you must create a TTL index on the `expiresAt` field in your collection.
- * In the mongo shell, run:
- * `db.yourCollectionName.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 })`
- *
- * @param {import('mongodb').Db} db - An instance of a MongoDB Db object.
- * @param {string} [collectionName='fingerprint_store'] - The name of the collection to use.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createMongoDbStore(db, collectionName = 'fingerprint_store') {
-  const collection = db.collection(collectionName);
-
-  return {
-    async get(key) {
-      const doc = await collection.findOne({ _id: key });
-      // The TTL index automatically removes expired documents, so no need to check `expiresAt` here.
-      return doc ? doc.value : null;
-    },
-    async set(key, value, ttl) {
-      const doc = {
-        _id: key,
-        value: value,
-      };
-
-      if (ttl && ttl > 0) {
-        // Set the expiration date for the TTL index.
-        doc.expiresAt = new Date(Date.now() + ttl * 1000);
-      }
-
-      await collection.updateOne(
-        { _id: key },
-        { $set: doc },
-        { upsert: true }
-      );
-    },
-    async has(key) {
-      const count = await collection.countDocuments({ _id: key });
-      return count > 0;
-    },
-    async delete(key) {
-      await collection.deleteOne({ _id: key });
-    },
-  };
+/**
+ * @file Creates a store adapter for MongoDB.
+ * This adapter uses a collection as a key-value store and leverages MongoDB's TTL indexes
+ * for automatic expiration of documents.
+ */
+
+/**
+ * Creates a store adapter for a MongoDB collection.
+ * It's recommended to pass the `db` object and let the adapter handle the collection.
+ *
+ * **Note:** For TTL to work, you must create a TTL index on the `expiresAt` field in your collection.
+ * In the mongo shell, run:
+ * `db.yourCollectionName.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 })`
+ *
+ * @param {import('mongodb').Db} db - An instance of a MongoDB Db object.
+ * @param {string} [collectionName='fingerprint_store'] - The name of the collection to use.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createMongoDbStore(db, collectionName = 'fingerprint_store') {
+  const collection = db.collection(collectionName);
+
+  return {
+    async get(key) {
+      const doc = await collection.findOne({ _id: key });
+      // The TTL index automatically removes expired documents, so no need to check `expiresAt` here.
+      return doc ? doc.value : null;
+    },
+    async set(key, value, ttl) {
+      const doc = {
+        _id: key,
+        value: value,
+      };
+
+      if (ttl && ttl > 0) {
+        // Set the expiration date for the TTL index.
+        doc.expiresAt = new Date(Date.now() + ttl * 1000);
+      }
+
+      await collection.updateOne(
+        { _id: key },
+        { $set: doc },
+        { upsert: true }
+      );
+    },
+    async has(key) {
+      const count = await collection.countDocuments({ _id: key });
+      return count > 0;
+    },
+    async delete(key) {
+      await collection.deleteOne({ _id: key });
+    },
+  };
 }

package/package.json

@@ -1,79 +1,88 @@
-{
-  "name": "@anonympins/fingerprint",
-  "version": "0.2.1",
-  "description": "An HTTP(S) client mitigation and anti-bot protection library for Node.js/Express, based on digital fingerprinting and dynamic Proof-of-Work (PoW) challenges.",
-  "main": "fingerprint.js",
-  "type": "module",
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "scripts": {
-    "test": "vitest run --reporter=verbose"
-  },
-  "files": [
-    "fingerprint.js",
-    "fingerprint.client.js",
-    "fingerprint.builder.js",
-    "pow.solver.js",
-    "pow.worker.js",
-    "problem-manager.js",
-    "optimization.worker.js",
-    "library.js",
-    "redis-store.js",
-    "mongodb-store.js",
-    "sql-store.js",
-    "README.md",
-    "LICENSE"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anonympins/fingerprint.git"
-  },
-  "keywords": [
-    "fingerprint",
-    "bot",
-    "anti-bot",
-    "security",
-    "express",
-    "middleware",
-    "proof-of-work",
-    "pow",
-    "rate-limiting",
-    "mitigation",
-    "captcha",
-    "dns"
-  ],
-  "author": "anonympins",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/anonympins/fingerprint/issues"
-  },
-  "homepage": "https://github.com/anonympins/fingerprint#readme",
-  "devDependencies": {
-    "body-parser": "^1.20.2",
-    "cookie-parser": "^1.4.6",
-    "express": "^4.18.2",
-    "prom-client": "^15.1.2",
-    "vitest": "^4.1.11"
-  },
-  "peerDependencies": {
-    "ioredis": "^5.3.2",
-    "knex": ">=3.0.0",
-    "mongodb": "^6.3.0",
-    "sqlite3": "^5.1.7"
-  },
-  "peerDependenciesMeta": {
-    "ioredis": {
-      "optional": true
-    },
-    "mongodb": {
-      "optional": true
-    },
-    "knex": {
-      "optional": true
-    },
-    "sqlite3": {
-      "optional": true
-    }
-  }
-}
+{
+  "name": "@anonympins/fingerprint",
+  "version": "0.2.3",
+  "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": "fingerprint.js",
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "test": "vitest run --reporter=verbose"
+  },
+  "files": [
+    "fingerprint.js",
+    "fingerprint.client.js",
+    "fingerprint.builder.js",
+    "pow.solver.js",
+    "pow.worker.js",
+    "problem-manager.js",
+    "optimization.worker.js",
+    "library.js",
+    "redis-store.js",
+    "mongodb-store.js",
+    "sql-store.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anonympins/fingerprint.git"
+  },
+  "keywords": [
+    "anti-bot",
+    "bot-detection",
+    "security",
+    "middleware",
+    "express",
+    "nodejs",
+    "fingerprint",
+    "device-fingerprinting",
+    "ja3",
+    "tls-fingerprinting",
+    "proof-of-work",
+    "pow",
+    "useful-proof-of-work",
+    "upow",
+    "waf",
+    "scraping",
+    "scalping",
+    "mitigation",
+    "rate-limiting",
+    "honeypot",
+    "behavioral-analysis"
+  ],
+  "author": "anonympins",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/anonympins/fingerprint/issues"
+  },
+  "homepage": "https://github.com/anonympins/fingerprint#readme",
+  "devDependencies": {
+    "body-parser": "^1.20.2",
+    "cookie-parser": "^1.4.6",
+    "express": "^4.18.2",
+    "prom-client": "^15.1.2",
+    "vitest": "^4.1.11"
+  },
+  "peerDependencies": {
+    "ioredis": "^5.3.2",
+    "knex": ">=3.0.0",
+    "mongodb": "^6.3.0",
+    "sqlite3": "^5.1.7"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    },
+    "mongodb": {
+      "optional": true
+    },
+    "knex": {
+      "optional": true
+    },
+    "sqlite3": {
+      "optional": true
+    }
+  }
+}

package/pow.solver.js

@@ -293,6 +293,18 @@ async function solveUsefulWorkTask(task) {
             // On simule l'appel avec les arguments de base.
             // Note: `baseSolverArgs` peut contenir des options.
             return clientSolver(...baseSolverArgs);
+        
+        case 'multi_objective_genetic_algorithm': {
+            // C'est ici que la connexion se fait !
+            // On cherche le solveur demandé (ex: 'cpc.solve') dans notre registre client.
+            const solverFunction = ClientOptimizers[task.solverName];
+            if (!solverFunction) {
+                throw new Error(`Solver '${task.solverName}' not found on client.`);
+            }
+            // On appelle le solveur en lui passant le payload et les options.
+            // La fonction `solveOptimalCPC` attend le payload comme premier argument.
+            return solverFunction(task.payload, { generations: task.generations, initialFront: task.initialFront });
+        }
 
         default:
             throw new Error(`Unknown useful work type: ${task.type}`);
@@ -339,14 +351,50 @@ export async function solveOptimizationTask(initialPopulation, generations) {
     return population;
 }
 
+/**
+ * @class ChallengeSolution
+ * @description Encapsule une solution de challenge et fournit des méthodes pour la manipuler.
+ * @private
+ */
+class ChallengeSolution {
+    constructor(type, nonce, rawSolution) {
+        this.type = type;
+        this.nonce = nonce;
+        this.rawSolution = rawSolution;
+    }
+
+    /**
+     * Applique les paramètres de la solution à un objet URL.
+     * @param {URL} url - L'objet URL à modifier.
+     */
+    applyToUrl(url) {
+        url.searchParams.set('pow_type', this.type);
+        url.searchParams.set('pow_nonce', this.nonce);
+
+        // Logique de formatage spécifique à chaque type de challenge
+        if (this.type === 'cpu_mem' || this.type === 'cpu_mem_inline' || this.type === 'cpu_target') {
+            Object.entries(this.rawSolution).forEach(([key, value]) => {
+                url.searchParams.set(`pow_solution_${key}`, String(value));
+            });
+        } else if (this.type === 'useful_work_task') {
+            url.searchParams.set('pow_solution_work_result', JSON.stringify(this.rawSolution.work_result));
+            url.searchParams.set('pow_problem_id', this.rawSolution.problem_id);
+        } else {
+            // Pour les cas simples comme 'tsp' où la solution est une seule valeur
+            url.searchParams.set('pow_solution', JSON.stringify(this.rawSolution));
+        }
+    }
+}
+
 /**
  * Fonction principale qui reçoit un objet challenge et le résout.
  * @param {object} challenge - L'objet challenge reçu du serveur.
- * @returns {Promise<object>} Un objet contenant la ou les solutions.
+ * @param {string} [fingerprint=''] - L'empreinte de l'appareil qui résout le challenge.
+ * @returns {Promise<ChallengeSolution>} Un objet `ChallengeSolution` encapsulant le résultat.
  */
 export async function solveChallenge(challenge, fingerprint = '') { // The fingerprint is now passed from the client library
     const { type, nonce, clientSecret, cpuTarget, memDifficulty, cities, clientIp, targetMaxDistance, optimizationTask, usefulWorkTask } = challenge;
-    const solutions = {};
+    let rawSolution = {};
 
     switch (type) {
         case 'cpu_target':
@@ -357,7 +405,7 @@ export async function solveChallenge(challenge, fingerprint = '') { // The finge
             const target = cpuTarget; // Keep variable name for consistency below
             // Pour ce challenge simple, le baseBlock est juste le nonce.
             const baseBlockBytes = new TextEncoder().encode(nonce + ":");
-            solutions.cpu = await solveCpuTargetInline(baseBlockBytes, target, null);
+            rawSolution.cpu = await solveCpuTargetInline(baseBlockBytes, target, null);
             break;
         case 'cpu_mem':
             // Pour les appels API, le client IP n'est pas connu, on ne le met pas dans le message
@@ -371,8 +419,8 @@ export async function solveChallenge(challenge, fingerprint = '') { // The finge
                 })(),
                 solveMemory(memSeed, memDifficulty)
             ]);
-            solutions.cpu = cpuSol;
-            solutions.mem = memSol;
+            rawSolution.cpu = cpuSol;
+            rawSolution.mem = memSol;
             break;
         case 'cpu_mem_inline':
             // Version inline pour compatibilité HTML avec IP incluse
@@ -385,28 +433,28 @@ export async function solveChallenge(challenge, fingerprint = '') { // The finge
                 })(),
                 solveMemory(memSeedInline, memDifficulty)
             ]);
-            solutions.cpu = cpuSolInline;
-            solutions.mem = memSolInline;
+            rawSolution.cpu = cpuSolInline;
+            rawSolution.mem = memSolInline;
             break;
         case 'tsp':
             const tspResult = await solveTsp(cities, targetMaxDistance);
-            solutions.tsp = tspResult.path;
-            solutions.distance = tspResult.distance;
+            // Pour ce challenge, la solution est juste le chemin.
+            rawSolution = tspResult.path;
             break;
         case 'optimization_task':
             const finalPopulation = await solveOptimizationTask(optimizationTask.population, optimizationTask.generations);
-            solutions.population = finalPopulation.map(p => p.chromosome); // On ne renvoie que les chromosomes
+            rawSolution = finalPopulation.map(p => p.chromosome); // On ne renvoie que les chromosomes
             break;
         case 'useful_work_task':
             const workResult = await solveUsefulWorkTask(usefulWorkTask.task);
-            solutions.work_result = workResult;
-            solutions.problem_id = usefulWorkTask.problemId;
+            rawSolution.work_result = workResult;
+            rawSolution.problem_id = usefulWorkTask.problemId;
             break;
         default:
             throw new Error(`Unknown challenge type: ${type}`);
     }
 
-    return solutions;
+    return new ChallengeSolution(type, nonce, rawSolution);
 }
 
 // --- Compatibilité pour l'injection directe dans le HTML ---

package/pow.worker.js

@@ -1,27 +1,27 @@
-/**
- * @file @/pow.worker.js
- * @description Web Worker dédié à la résolution du challenge CPU.
- * Ce script s'exécute sur un thread séparé pour ne pas bloquer l'interface utilisateur.
- */
-
-self.onmessage = async (event) => {
-    const { message, target } = event.data;
-    let solution = 0;
-    const encoder = new TextEncoder();
-
-    // La boucle de calcul intensive est isolée dans ce worker.
-    while (true) {
-        const currentMessage = `${message}:${solution}`;
-        const data = encoder.encode(currentMessage);
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-        const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-
-        if (BigInt('0x' + hashHex) < target) {
-            // Une fois la solution trouvée, on la renvoie au thread principal.
-            self.postMessage({ solution });
-            return;
-        }
-        solution++;
-    }
+/**
+ * @file @/pow.worker.js
+ * @description Web Worker dédié à la résolution du challenge CPU.
+ * Ce script s'exécute sur un thread séparé pour ne pas bloquer l'interface utilisateur.
+ */
+
+self.onmessage = async (event) => {
+    const { message, target } = event.data;
+    let solution = 0;
+    const encoder = new TextEncoder();
+
+    // La boucle de calcul intensive est isolée dans ce worker.
+    while (true) {
+        const currentMessage = `${message}:${solution}`;
+        const data = encoder.encode(currentMessage);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+
+        if (BigInt('0x' + hashHex) < target) {
+            // Une fois la solution trouvée, on la renvoie au thread principal.
+            self.postMessage({ solution });
+            return;
+        }
+        solution++;
+    }
 };