@anonympins/fingerprint 0.0.9 → 0.1.1

package/library.js

@@ -498,8 +498,8 @@ Optimization.geneticAlgorithmMultiObjective = function (
   options = {},
 ) {
   const {
-    generations = 100,
-    populationSize = 50,
+    generations = 150, // Augmenté pour une meilleure convergence
+    populationSize = 60, // Augmenté pour plus de diversité
     mutationRate = 0.1,
   } = options;
 
@@ -1152,8 +1152,8 @@ const BASE_CLICK_COST = 1;
  * @param {number} config.estimatedImpressions - Le nombre d'impressions quotidiennes estimées pour ce contexte.
  */
 Optimization.Operators.createOptimalCPCEvaluator = (context) => {
-  const { optimalBaseCommission, optimalBonusFactor } = platformParams;
-  const websiteQualityScore = (website?.relevanceScore || 50) / 100;
+  const { optimalBaseCommission, optimalBonusFactor } = context.platformParams;
+  const websiteQualityScore = (context.website?.relevanceScore || 50) / 100;
 
   // Le taux de commission effectif pour ce site
   const effectiveCommissionRate = Math.max(
@@ -1164,7 +1164,7 @@ Optimization.Operators.createOptimalCPCEvaluator = (context) => {
   // Modèle de la demande : combien de clics l'annonceur peut-il s'offrir ?
   const advertiserDemand = (cpc) => {
     if (cpc <= 0) return Infinity;
-    return (advertiser.credits || 0) / cpc;
+    return (context.advertiser.credits || 0) / cpc;
   };
 
   // --- SOLUTION : Utiliser l'offre réelle et la concurrence ---
@@ -1277,6 +1277,38 @@ Optimization.Operators.solveOptimalCPC = (context, options = {}) => {
   });
 };
 
+/**
+ * Crée un évaluateur multi-objectifs pour trouver le TTL (Time-To-Live) optimal pour un ticket de sécurité.
+ * @param {object} context - L'objet de configuration.
+ * @param {number} context.suspicionScore - Le score de suspicion de l'utilisateur (0-100).
+ * @returns {function(number): number[]} Une fonction de fitness qui prend un TTL (en ms) et retourne les scores des objectifs [risque, friction].
+ */
+Optimization.Operators.createOptimalTtlEvaluator = ({ suspicionScore }) => {
+  // On normalise le score pour qu'il soit plus impactant dans le calcul du risque.
+  const normalizedScore = Math.max(1, suspicionScore);
+
+  return function ttlFitness(ttl) {
+    // Contraintes : un TTL doit être dans une plage raisonnable (ex: 5min à 24h)
+    if (ttl < 300000 || ttl > 86400000) return [Infinity, Infinity];
+
+    // Objectif 1 : Minimiser le Risque.
+    // Le risque est le produit du score et de la durée de la session.
+    // Pour un score élevé, l'algo doit choisir un TTL faible pour minimiser ce produit.
+    const risk = normalizedScore * ttl;
+
+    // Objectif 2 : Minimiser la Friction UX.
+    // La friction est l'inverse du TTL. On la pénalise d'autant plus que le score est FAIBLE.
+    // (101 - score) assure que pour un score de 1, la pénalité d'un TTL court est maximale.
+    // Pour un score de 100, cette pénalité est quasi nulle.
+    const friction = (1 / ttl) * (101 - normalizedScore);
+
+    // On retourne 2 objectifs avec des facteurs de mise à l'échelle pour les équilibrer.
+    return [risk / 1e7, friction * 1e9];
+  };
+};
+
+
+
 /**
  * Crée un évaluateur multi-objectifs pour trouver les seuils de détection de fraude optimaux.
  * @param {object} config - L'objet de configuration.
@@ -1443,4 +1475,103 @@ Optimization.Operators.solveFraudDetection = (context, options = {}) => {
   );
 };
 
+/**
+ * Crée un évaluateur multi-objectifs pour l'auto-tuning complet de la configuration de sécurité.
+ * Optimise à la fois les seuils, les poids de suspicion et les paramètres de détection de patterns.
+ * @param {object} config - L'objet de configuration.
+ * @param {Array<object>} config.trafficData - Données de trafic collectées.
+ * @returns {function(object): number[]} Une fonction de fitness qui prend une configuration complète et retourne les scores [taux de faux positifs, taux de faux négatifs].
+ */
+Optimization.Operators.createFullSecurityConfigEvaluator = ({ trafficData }) => {
+  // Un "individu" est un objet de configuration complet
+  // { thresholds: { low, medium, high }, weights: { historyScore, ... }, patterns: { velocityThreshold, ... } }
+
+  return function fullConfigFitness(config) {
+    let falsePositives = 0; // Humains légitimes challengés ou bloqués
+    let falseNegatives = 0; // Bots qui sont passés
+    let totalHumans = 0;
+    let totalBots = 0;
+
+    // Simule le calcul du score pour chaque point de données avec la configuration testée
+    const calculateScore = (log) => {
+      // Cette fonction interne devrait répliquer la logique de `getSuspicionVector`
+      // en utilisant les poids et les paramètres de `config`.
+      // Pour cet exemple, nous utilisons une version simplifiée.
+      let score = 0;
+      for (const key in config.weights) {
+        score += (log.vector[key] || 0) * config.weights[key];
+      }
+      return score;
+    };
+
+    for (const log of trafficData) {
+      // On se base sur le comportement observé pour déterminer la nature "réelle" de la requête
+      const isLikelyBot = log.type === 'challenge_issued' || log.type === 'request_blocked';
+      const isLikelyHuman = log.type === 'request_passed' || log.type === 'challenge_solved';
+
+      if (isLikelyBot) {
+        totalBots++;
+        const score = calculateScore(log);
+        // Faux négatif : un bot qui aurait dû être challengé mais ne l'a pas été
+        if (score < config.thresholds.low) {
+          falseNegatives++;
+        }
+      } else if (isLikelyHuman) {
+        totalHumans++;
+        const score = calculateScore(log);
+        // Faux positif : un humain qui a été challengé inutilement
+        if (score >= config.thresholds.low) {
+          falsePositives++;
+        }
+      }
+    }
+
+    const falsePositiveRate = totalHumans > 0 ? falsePositives / totalHumans : 0;
+    const falseNegativeRate = totalBots > 0 ? falseNegatives / totalBots : 0;
+
+    // L'algorithme doit minimiser ces deux objectifs
+    return [falsePositiveRate, falseNegativeRate];
+  };
+};
+
+/**
+ * Résout le problème de l'auto-tuning complet de la configuration de sécurité.
+ * @param {object} context - Le contexte contenant les données de trafic.
+ * @param {object} [options] - Options pour l'algorithme génétique.
+ * @returns {Array<{solution: object, objectives: number[]}>} Le front de Pareto des configurations optimales.
+ */
+Optimization.Operators.solveFullSecurityTuning = (context, options = {}) => {
+    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
+        },
+        weights: {
+            historyScore: Math.random(),
+            rotationScore: Math.random(),
+            headerAnomalyScore: Math.random(),
+            requestPatternScore: Math.random(),
+            inconsistencyScore: Math.random(),
+            honeypotScore: 1.0, // Garder le honeypot à 1.0 est une bonne pratique
+        },
+        // On pourrait aussi faire muter les `patterns` ici
+    });
+
+    // 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; };
+    const mutate = (c) => { /* ... logique de mutation pour les objets de config ... */ return c; };
+
+    return Optimization.geneticAlgorithmMultiObjective(
+        createIndividual,
+        fitnessFunction,
+        crossover,
+        mutate,
+        { generations: 50, populationSize: 50, ...options }
+    );
+};
+
 export { Optimization };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anonympins/fingerprint",
-  "version": "0.0.9",
+  "version": "0.1.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",
@@ -8,12 +8,13 @@
     "node": ">=20.0.0"
   },
   "scripts": {
-    "test": "vitest run"
+    "test": "vitest run --reporter=verbose"
   },
   "files": [
     "fingerprint.js",
     "fingerprint.client.js",
     "fingerprint.builder.js",
+    "pow.solver.js",
     "library.js",
     "redis-store.js",
     "mongodb-store.js",

package/pow.solver.js

@@ -0,0 +1,214 @@
+/**
+ * @file @/pow.solver.js
+ * @description Contient les fonctions côté client pour résoudre les différents types de challenges Proof-of-Work.
+ * Fichier compatible à la fois avec l'import de modules ES6 et l'injection directe dans un script HTML.
+ */
+
+'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.
+ * @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) {
+    const cpuTarget = BigInt(target);
+    let cpuSolution = 0;
+    while (true) {
+        const msg = clientSecret 
+            ? `${clientIp}:${nonce}:${cpuSolution}:${clientSecret}`
+            : `${clientIp}:${nonce}:${cpuSolution}`;
+        const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(msg));
+        const hashHex = Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+        if (BigInt('0x' + hashHex) < cpuTarget) break;
+        cpuSolution++;
+        if (cpuSolution % 100000 === 0) {
+            await new Promise(r => setTimeout(r, 0));
+            if (progressCallback) progressCallback(cpuSolution);
+        }
+    }
+    return cpuSolution;
+}
+
+/**
+ * Résout un challenge CPU basé sur une cible (version Web Worker).
+ * @param {string} message - Le message à hasher (ex: `ip:nonce:solution:secret`).
+ * @param {bigint} target - La cible à atteindre.
+ * @returns {Promise<number>} La solution (un nombre entier).
+ */
+export async function solveCpuTarget(message, target) {
+    // Vérifie si les Web Workers sont supportés par le navigateur.
+    if (typeof(Worker) === "undefined") {
+        console.warn("Web Workers not supported. Falling back to main thread calculation (UI may freeze).");
+        // Ici, on pourrait remettre l'ancienne implémentation comme solution de secours.
+        // Pour la clarté, nous supposons que les workers sont disponibles.
+        throw new Error("Web Worker support is required for CPU challenges.");
+    }
+
+    return new Promise((resolve, reject) => {
+        // Crée un worker à partir du script dédié. Le chemin doit être accessible publiquement.
+        // Assurez-vous que `pow.worker.js` est servi par votre serveur statique.
+        const worker = new Worker('./pow.worker.js');
+
+        worker.onmessage = (event) => {
+            resolve(event.data.solution);
+            worker.terminate(); // Nettoie le worker une fois le travail terminé.
+        };
+
+        worker.onerror = (error) => {
+            reject(error);
+            worker.terminate();
+        };
+
+        // Envoie les données du challenge au worker pour qu'il commence le calcul.
+        worker.postMessage({ message, target });
+    });
+}
+
+/**
+ * Résout un challenge basé sur la mémoire.
+ * @param {string} seed - La graine pour l'initialisation de la mémoire.
+ * @param {number} difficulty - La difficulté (en Mo).
+ * @returns {Promise<number>} La solution (nombre entier).
+ */
+export async function solveMemory(seed, difficulty) {
+    const size = difficulty * 1024 * 1024;
+    const buffer = new Uint32Array(size / 4);
+    let h = new TextEncoder().encode(seed).reduce((acc, v) => acc + v, 0);
+    for (let i = 0; i < buffer.length; i++) {
+        buffer[i] = (h = Math.imul(h ^ i, 1597334677));
+    }
+    let solution = 0;
+    const iterations = size / 16;
+    let addr = buffer.length > 0 ? buffer[0] % buffer.length : 0;
+    for (let i = 0; i < iterations; i++) {
+        addr = buffer[addr] % buffer.length;
+        solution ^= addr;
+    }
+    return solution;
+}
+
+/**
+ * Résout un challenge de type "Problème du Voyageur de Commerce" (TSP).
+ * NOTE: Ceci est une implémentation simple (heuristique du plus proche voisin) et n'est pas garantie
+ * de trouver la solution optimale, mais elle est suffisante pour un challenge.
+ * @param {Array<{x: number, y: number}>} cities - Les coordonnées des villes.
+ * @param {number} targetMaxDistance - La distance maximale acceptable.
+ * @returns {Promise<{path: number[], distance: number}>} Le chemin et la distance.
+ */
+export async function solveTsp(cities, targetMaxDistance) {
+    // Utility function to calculate the distance between two cities
+    function distance(city1, city2) {
+        return Math.sqrt(Math.pow(city1.x - city2.x, 2) + Math.pow(city1.y - city2.y, 2));
+    }
+
+    // Utility function to evaluate the total distance of a path
+    function evaluatePathDistance(cities, path) {
+        let totalDistance = 0;
+        for (let i = 0; i < path.length - 1; i++) {
+            totalDistance += distance(cities[path[i]], cities[path[i + 1]]);
+        }
+        totalDistance += distance(cities[path[path.length - 1]], cities[path[0]]); // Return to start
+        return totalDistance;
+    }
+
+    // Solveur simple du TSP (heuristique du plus proche voisin)
+    function solveTspNearestNeighbor(cities) {
+        const numCities = cities.length;
+        if (numCities === 0) return [];
+
+        let currentPath = [];
+        let visited = new Array(numCities).fill(false);
+
+        let currentCityIndex = 0; // Always start with the first city for reproducibility
+        currentPath.push(currentCityIndex);
+        visited[currentCityIndex] = true;
+
+        for (let i = 1; i < numCities; i++) {
+            let nearestCityIndex = -1;
+            let minDistance = Infinity;
+
+            for (let j = 0; j < numCities; j++) {
+                if (!visited[j]) {
+                    const dist = distance(cities[currentCityIndex], cities[j]);
+                    if (dist < minDistance) {
+                        minDistance = dist;
+                        nearestCityIndex = j;
+                    }
+                }
+            }
+            currentCityIndex = nearestCityIndex;
+            currentPath.push(currentCityIndex);
+            visited[currentCityIndex] = true;
+        }
+        return currentPath;
+    }
+
+    // To avoid freezing the browser, yield the thread from time to time
+    await new Promise(resolve => setTimeout(resolve, 10));
+    const solutionPath = solveTspNearestNeighbor(cities);
+    const solutionDistance = evaluatePathDistance(cities, solutionPath);
+
+    return { path: solutionPath, distance: solutionDistance };
+}
+
+/**
+ * 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.
+ */
+export async function solveChallenge(challenge) {
+    const { type, nonce, clientSecret, target, memDifficulty, cities, clientIp, targetMaxDistance } = challenge;
+    const solutions = {};
+
+    switch (type) {
+        case 'cpu_target':
+            const baseMessageCpu = `:${nonce}`; // L'IP est gérée côté serveur
+            solutions.cpu = await solveCpuTarget(baseMessageCpu, BigInt('0x' + target));
+            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 memSeed = `:${nonce}:${clientSecret}`;
+            const [cpuSol, memSol] = await Promise.all([
+                // On utilise une version de solveCpuTarget qui n'a pas besoin de l'IP
+                solveCpuTargetInline(null, nonce, target, clientSecret),
+                solveMemory(memSeed, memDifficulty)
+            ]);
+            solutions.cpu = cpuSol;
+            solutions.mem = memSol;
+            break;
+        case 'cpu_mem_inline':
+            // Version inline pour compatibilité HTML avec IP incluse
+            const memSeedInline = `${nonce}:${clientSecret}`;
+            const [cpuSolInline, memSolInline] = await Promise.all([
+                solveCpuTargetInline(clientIp, nonce, target, clientSecret),
+                solveMemory(memSeedInline, memDifficulty)
+            ]);
+            solutions.cpu = cpuSolInline;
+            solutions.mem = memSolInline;
+            break;
+        case 'tsp':
+            const tspResult = await solveTsp(cities, targetMaxDistance);
+            solutions.tsp = tspResult.path;
+            solutions.distance = tspResult.distance;
+            break;
+        default:
+            throw new Error(`Unknown challenge type: ${type}`);
+    }
+
+    return solutions;
+}
+
+// --- Compatibilité pour l'injection directe dans le HTML ---
+// Si le script est chargé dans un navigateur (window existe), on attache les fonctions nécessaires à window.
+if (typeof window !== 'undefined') {
+    window.solveCpuChallengeInline = solveCpuTargetInline;
+    window.solveMemoryChallenge = solveMemory;
+    window.solveTspChallenge = solveTsp;
+    window.solveChallenge = solveChallenge;
+}