@anonympins/fingerprint 0.2.1 → 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/package.json

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

package/pow.solver.js

@@ -339,14 +339,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 +393,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 +407,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 +421,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++;
+    }
 };

package/problem-manager.js

@@ -169,6 +169,78 @@ class ProblemManager {
         }
         this.saveProblems();
     }
+
+    /**
+     * S'assure qu'un problème a une solution initiale. Si non, en génère une.
+     * @param {object} problem - L'objet problème.
+     * @private
+     */
+    _ensureInitialSolution(problem) {
+        if (problem.state.bestSolution) {
+            return; // Une solution existe déjà
+        }
+
+        console.log(`[ProblemManager] Génération d'une solution initiale pour le problème ${problem.id}...`);
+
+        // On se base sur le type de problème pour générer une solution de base.
+        // Pour l'instant, on gère le cas le plus commun (TSP/points)
+        // qui utilise le recuit simulé.
+        switch (problem.workUnit.type) {
+            case 'simulated_annealing_iterations': {
+                // Pour un TSP, une solution initiale est un ordre des points.
+                // On prend l'ordre initial des points du payload.
+                const initialSolution = problem.payload.points;
+                if (initialSolution && Array.isArray(initialSolution)) {
+                    // On calcule l'énergie (coût) de cette solution initiale.
+                    const energy = Optimization.tsp.calculateEnergy(initialSolution);
+                    problem.state.bestSolution = initialSolution;
+                    problem.state.bestEnergy = energy;
+                    problem.state.lastUpdate = new Date().toISOString();
+                    console.log(`[ProblemManager] Solution initiale pour ${problem.id} générée avec une énergie de ${energy.toFixed(2)}.`);
+                    this.saveProblems(); // On sauvegarde la nouvelle solution
+                }
+                break;
+            }
+            // D'autres types de problèmes (ex: algo génétique) pourraient être ajoutés ici.
+        }
+    }
+
+    /**
+     * Récupère la meilleure solution actuellement connue pour un ou plusieurs problèmes.
+     * @param {string} [problemId] - L'ID optionnel du problème à consulter.
+     * Si non fourni, retourne les meilleures solutions pour tous les problèmes.
+     * @returns {object|Array<object>|null}
+     * - Si un `problemId` est fourni, retourne un objet `{ id, solution, score }` ou `null` si non trouvé.
+     * - Si aucun `problemId` n'est fourni, retourne un tableau de ces objets.
+     */
+    getBestSolutions(problemId) {
+        const problemsToProcess = problemId
+            ? this.problems.filter(p => p.id === problemId)
+            : this.problems;
+
+        problemsToProcess.forEach(p => this._ensureInitialSolution(p));
+
+        const formatSolution = (p) => {
+            // Après _ensureInitialSolution, on peut supposer que p.state existe.
+            if (!p || !p.state) return null;
+            return {
+                id: p.id,
+                solution: p.state.bestSolution,
+                // Gère les deux types de scores : 'energy' (recuit simulé) et 'fitness' (algo génétique)
+                score: p.state.bestEnergy !== undefined ? p.state.bestEnergy : p.state.bestFitness,
+                lastUpdate: p.state.lastUpdate,
+            };
+        };
+
+        if (problemId) {
+            const problem = this.problems.find(p => p.id === problemId);
+            return problem ? formatSolution(problem) : null; // Le filtrage initial a déjà fait le travail
+        }
+
+        // Retourne un aperçu pour tous les problèmes
+        return this.problems.map(formatSolution).filter(s => s && s.solution);
+    }
+
 }
 
 export { ProblemManager }; // Export the class for testing

package/redis-store.js

@@ -1,43 +1,43 @@
-/**
- * @file Creates a store adapter for ioredis.
- * This adapter handles the serialization and deserialization of complex objects,
- * including the conversion of Set objects to arrays for storage in Redis.
- */
-
-/**
- * Creates a store adapter for an ioredis client.
- * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createRedisStore(redisClient) {
-  return {
-    async get(key) {
-      const value = await redisClient.get(key);
-      if (!value) return null;
-      // Use a reviver to convert arrays back to Sets for specific keys like 'ips'.
-      return JSON.parse(value, (k, v) => {
-        if (k === 'ips' && Array.isArray(v)) {
-          return new Set(v);
-        }
-        return v;
-      });
-    },
-    async set(key, value, ttl) {
-      // Use a replacer to convert Set objects into arrays before serialization.
-      const stringValue = JSON.stringify(value, (k, v) => {
-        if (v instanceof Set) {
-          return Array.from(v);
-        }
-        return v;
-      });
-
-      if (ttl && ttl > 0) {
-        await redisClient.set(key, stringValue, 'EX', ttl);
-      } else {
-        await redisClient.set(key, stringValue);
-      }
-    },
-    async has(key) { return (await redisClient.exists(key)) === 1; },
-    async delete(key) { await redisClient.del(key); },
-  };
+/**
+ * @file Creates a store adapter for ioredis.
+ * This adapter handles the serialization and deserialization of complex objects,
+ * including the conversion of Set objects to arrays for storage in Redis.
+ */
+
+/**
+ * Creates a store adapter for an ioredis client.
+ * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createRedisStore(redisClient) {
+  return {
+    async get(key) {
+      const value = await redisClient.get(key);
+      if (!value) return null;
+      // Use a reviver to convert arrays back to Sets for specific keys like 'ips'.
+      return JSON.parse(value, (k, v) => {
+        if (k === 'ips' && Array.isArray(v)) {
+          return new Set(v);
+        }
+        return v;
+      });
+    },
+    async set(key, value, ttl) {
+      // Use a replacer to convert Set objects into arrays before serialization.
+      const stringValue = JSON.stringify(value, (k, v) => {
+        if (v instanceof Set) {
+          return Array.from(v);
+        }
+        return v;
+      });
+
+      if (ttl && ttl > 0) {
+        await redisClient.set(key, stringValue, 'EX', ttl);
+      } else {
+        await redisClient.set(key, stringValue);
+      }
+    },
+    async has(key) { return (await redisClient.exists(key)) === 1; },
+    async delete(key) { await redisClient.del(key); },
+  };
 }