@anonympins/fingerprint 0.2.0 → 0.2.2

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/optimization.worker.js

@@ -0,0 +1,28 @@
+/**
+ * @file @/optimization.worker.js
+ * @description Web Worker générique pour exécuter les algorithmes d'optimisation de la bibliothèque `Optimization`.
+ * Ce script s'exécute sur un thread séparé pour ne pas bloquer l'interface utilisateur.
+ */
+
+import { parentPort, workerData } from 'worker_threads';
+import { Optimization } from './library.js'; // Assurez-vous que le chemin est correct
+
+if (parentPort) {
+    parentPort.on('message', async () => { // Le message est vide, on utilise workerData
+        const { solverName, solverArgs } = workerData;
+
+        // Gérer les solveurs imbriqués (ex: 'Operators.solvePortfolio')
+        const solverFunction = solverName.split('.').reduce((obj, prop) => obj && obj[prop], Optimization);
+
+        if (typeof solverFunction === 'function') {
+            try {
+                const result = await solverFunction(...solverArgs);
+                parentPort.postMessage(result);
+            } catch (error) {
+                parentPort.postMessage({ error: error.message, stack: error.stack });
+            }
+        } else {
+            parentPort.postMessage({ error: `Solver '${solverName}' not found or is not a function in Optimization library.` });
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anonympins/fingerprint",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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",
@@ -15,6 +15,9 @@
     "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",

package/pow.solver.js

@@ -10,26 +10,42 @@
 'use strict';
 
 /**
- * Résout un challenge CPU basé sur une cible (version inline pour compatibilité HTML).
- * @param {string} clientIp - L'adresse IP du client.
- * @param {string} nonce - Le nonce du challenge.
+ * Résout un challenge CPU basé sur une cible en utilisant un bloc de base binaire.
+ * @param {Uint8Array} baseBlock - Le bloc de données initial (nonce, secret, fp) fourni par le serveur.
  * @param {bigint} target - La cible à atteindre.
- * @param {string} clientSecret - Le secret client (optionnel).
  * @param {Function} progressCallback - Callback pour les mises à jour de progression.
  * @returns {Promise<number>} La solution (un nombre entier).
  */
-export async function solveCpuTargetInline(clientIp, nonce, target, clientSecret = null, progressCallback) {
-    // Le 'target' est déjà un BigInt lorsqu'il est appelé depuis la page de challenge.
-    // On s'assure juste qu'il est bien de ce type.
+export async function solveCpuTargetInline(baseBlock, target, progressCallback) {
+    // --- FIX: Add validation for the target to prevent BigInt conversion errors ---
+    if (typeof target !== 'bigint' && (typeof target !== 'string' || !/^[0-9a-fA-F]+$/.test(target))) {
+        throw new TypeError(`Invalid target type: expected a BigInt or a hex string, but got ${typeof target} with value ${target}`);
+    }
+
     const cpuTarget = typeof target === 'bigint' ? target : BigInt('0x' + target);
+    // --- END FIX ---
+    const encoder = new TextEncoder();
     let cpuSolution = 0;
-    const ipPart = clientIp || ''; // Use empty string if IP is null/undefined
-    while (true) { // When a clientSecret is used, the IP is omitted from the hash to make it independent of the network.
-        const msg = clientSecret ?
-            `${nonce}:${cpuSolution}:${clientSecret}` :
-            `${ipPart}:${nonce}:${cpuSolution}`;
-        const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(msg));
+
+    while (true) {
+        const solutionBytes = encoder.encode(String(cpuSolution));
+        
+        // Concaténation binaire directe : c'est plus rapide et plus sûr.
+        const finalBlock = new Uint8Array(baseBlock.length + solutionBytes.length);
+        finalBlock.set(baseBlock);
+        finalBlock.set(solutionBytes, baseBlock.length);
+
+        if (cpuSolution === 0) {
+            const reconstructedMsg = new TextDecoder().decode(finalBlock);
+            console.log('[FP Solve Debug] Client will hash message:', reconstructedMsg);
+        }
+        const buf = await crypto.subtle.digest("SHA-256", finalBlock);
         const hashHex = Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+        // --- AJOUT DE LOGS POUR LE DÉBOGAGE CÔTÉ CLIENT ---
+        if (cpuSolution === 0) { // Log only the first attempt
+            console.log(`[FP Client Solve] Attempt 0 hash: "0x${hashHex}"`);
+        }
+        // --- FIN DES LOGS ---
         if (BigInt('0x' + hashHex) < cpuTarget) break;
         cpuSolution++;
         if (cpuSolution % 100000 === 0) {
@@ -323,70 +339,110 @@ 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) {
+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':
-            const baseMessageCpu = `:${nonce}`; // L'IP est gérée côté serveur
+            // Note: This case is not fully exercised by tests as it relies on Web Workers.
             if (!cpuTarget) {
                 throw new Error("Challenge data is missing 'cpuTarget' property.");
             }
             const target = cpuTarget; // Keep variable name for consistency below
-            solutions.cpu = await solveCpuTarget(baseMessageCpu, BigInt('0x' + target));
+            // Pour ce challenge simple, le baseBlock est juste le nonce.
+            const baseBlockBytes = new TextEncoder().encode(nonce + ":");
+            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
-            const baseMessageCombined = `${nonce}:${clientSecret}`;
+            const baseMessageCombined = `:${nonce}:${clientSecret}`;
             const memSeed = `:${nonce}:${clientSecret}`;
             const [cpuSol, memSol] = await Promise.all([
                 (async () => {
-                    if (!cpuTarget) throw new Error("Challenge data is missing 'cpuTarget' property.");
-                    return solveCpuTargetInline(null, nonce, cpuTarget, clientSecret);
+                    if (!cpuTarget) throw new Error("Challenge data is missing 'cpuTarget' property."); // Pass fingerprint to solver
+                    const baseBlock = new Uint8Array(challenge.baseBlock);
+                    return solveCpuTargetInline(baseBlock, cpuTarget, null);
                 })(),
                 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
-            const memSeedInline = `${nonce}:${clientSecret}`;
+            const memSeedInline = `:${nonce}:${clientSecret}`;
             const [cpuSolInline, memSolInline] = await Promise.all([
                 (async () => {
                     if (!cpuTarget) throw new Error("Challenge data is missing 'cpuTarget' property.");
-                    return solveCpuTargetInline(clientIp, nonce, cpuTarget, clientSecret);
+                    const baseBlock = new Uint8Array(challenge.baseBlock);
+                    return solveCpuTargetInline(baseBlock, cpuTarget, null);
                 })(),
                 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

@@ -0,0 +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++;
+    }
+};