@anonympins/fingerprint 0.5.1 → 0.5.4

package/src/js/fingerprint.utils.js

@@ -19,6 +19,36 @@ export function verifyZkpProof(yStr, tStr, sStr) {
     }
 }
 
+export function safeJsonStringify(val) {
+    return JSON.stringify(val)
+        .replace(/</g, '\\u003c')
+        .replace(/>/g, '\\u003e')
+        .replace(/\u2028/g, '\\u2028')
+        .replace(/\u2029/g, '\\u2029');
+}
+
+export function sanitizeRedirectPath(p) {
+    if (typeof p !== 'string') return '/';
+    let sanitized = p.replace(/[^a-zA-Z0-9\/.\-_~%?&=:@+,;]/g, '');
+
+    // Prevent protocol-relative redirects (e.g. //evil.com)
+    if (sanitized.startsWith('//')) {
+        sanitized = '/' + sanitized.replace(/^\/+/g, '');
+    }
+    // Prevent absolute redirects (e.g. http://evil.com)
+    if (/^https?:\/\//i.test(sanitized)) {
+        try {
+            const parsed = new URL(sanitized);
+            sanitized = parsed.pathname + parsed.search + parsed.hash;
+        } catch (e) {
+            sanitized = '/';
+        }
+    }
+    if (!sanitized.startsWith('/')) {
+        sanitized = '/' + sanitized;
+    }
+    return sanitized.replace(/^\/+/g, '/');
+}
 export function decodePolymorphicFingerprint(fpString, mapping) {
     if (!fpString || !mapping || !mapping.keys) return fpString;
     const reverseKeys = {};

package/src/js/gpu_pow.solver.js

@@ -24,6 +24,7 @@ export class GpuPowSolver {
             }
         } catch (e) {
             console.warn('[GPU-PoW] WebGPU failed or disabled, falling back to WebGL2:', e);
+            // Fallthrough to WebGL2
         }
 
         // Fallback to WebGL2
@@ -35,7 +36,20 @@ export class GpuPowSolver {
                 duration: performance.now() - start
             };
         } catch (e) {
-            throw new Error(`[GPU-PoW] Both WebGPU and WebGL2 solvers failed: ${e.message}`);
+            console.warn('[GPU-PoW] WebGL2 failed or disabled, falling back to WebGL1:', e);
+            // Fallthrough to WebGL1
+        }
+
+        // Fallback to WebGL1
+        try {
+            const result = await this._solveWebGL1(numericSeed, iterations);
+            return {
+                solution: result,
+                platform: 'webgl1',
+                duration: performance.now() - start
+            };
+        } catch (e) {
+            throw new Error(`[GPU-PoW] All GPU solvers (WebGPU, WebGL2, WebGL1) failed: ${e.message}`);
         }
     }
 
@@ -200,6 +214,87 @@ export class GpuPowSolver {
         return result.map(v => v.toFixed(6)).join(',');
     }
 
+    static async _solveWebGL1(seed, iterations) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 8;
+        canvas.height = 8; // 64 pixels total matching WebGPU size
+        const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl'); // Get WebGL1 context with legacy fallback
+        if (!gl) throw new Error('WebGL1 context not supported.');
+
+        // WebGL1 Vertex Shader
+        const vs = `
+            attribute vec4 pos;
+            void main() {
+                gl_Position = pos;
+            }`;
+        // WebGL1 Fragment Shader
+        const fs = `
+            precision highp float; // highp float is an extension in WebGL1, but generally available
+            uniform float uSeed;
+            uniform int uIterations;
+            void main() {
+                float index = gl_FragCoord.x + (gl_FragCoord.y * 8.0);
+                float x = uSeed + (index * 0.015);
+                float r = 3.9999;
+                for(int i = 0; i < uIterations; i++) {
+                    x = r * x * (1.0 - x);
+                }
+                gl_FragColor = vec4(x, 0.0, 0.0, 1.0); // Use gl_FragColor for WebGL1
+            }`;
+
+        const program = this._createProgram(gl, vs, fs);
+        gl.useProgram(program);
+
+        const posAttr = gl.getAttribLocation(program, 'pos');
+        const buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1,-1, 1,-1, -1,1, -1,1, 1,-1, 1,1]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(posAttr);
+        gl.vertexAttribPointer(posAttr, 2, gl.FLOAT, false, 0, 0);
+
+        gl.uniform1f(gl.getUniformLocation(program, 'uSeed'), seed);
+        gl.uniform1i(gl.getUniformLocation(program, 'uIterations'), iterations);
+
+        // Check for OES_texture_float and WEBGL_color_buffer_float extensions for float textures and readPixels
+        const floatTextureExt = gl.getExtension('OES_texture_float');
+        const floatColorBufferExt = gl.getExtension('WEBGL_color_buffer_float');
+
+        if (!floatTextureExt || !floatColorBufferExt) {
+            throw new Error('WebGL1 float texture/color buffer extensions not supported. Cannot read float pixels.');
+        }
+
+        // Create a framebuffer to render to a float texture
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, canvas.width, canvas.height, 0, gl.RGBA, gl.FLOAT, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+
+        const fb = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+
+        const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
+        if (status !== gl.FRAMEBUFFER_COMPLETE) {
+            throw new Error('WebGL1 framebuffer not complete: ' + status);
+        }
+
+        gl.viewport(0, 0, canvas.width, canvas.height);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+
+        const pixels = new Float32Array(canvas.width * canvas.height * 4);
+        gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.FLOAT, pixels);
+
+        const result = [];
+        for (let i = 0; i < 64; i++) {
+            result.push(pixels[i * 4]); // Only take the R component
+        }
+
+        return result.map(v => v.toFixed(6)).join(',');
+    }
+
     static _createProgram(gl, vsSource, fsSource) {
         const vs = gl.createShader(gl.VERTEX_SHADER);
         gl.shaderSource(vs, vsSource);

package/src/js/library.js

@@ -521,8 +521,8 @@ Optimization.geneticAlgorithmMultiObjective = function (
     const offspring = [];
     for (let i = 0; i < populationSize; i++) {
       // Sélection simple pour l'exemple
-      const parent1 = population[Math.floor(secureRandom() * population.length)];
-      const parent2 = population[Math.floor(secureRandom() * population.length)];
+        const parent1 = population[crypto.randomInt(0, population.length)];
+        const parent2 = population[crypto.randomInt(0, population.length)];
       let childIndividual = crossover(parent1.individual, parent2.individual);
       if (secureRandom() < mutationRate) {
         childIndividual = mutate(childIndividual, currentConfig); // mutate doit maintenant utiliser currentConfig
@@ -749,7 +749,7 @@ Optimization.Operators.createTournamentSelection = (options = {}) => {
 
     for (let i = 0; i < tournamentSize; i++) {
       const individual =
-        population[Math.floor(secureRandom() * population.length)];
+        population[crypto.randomInt(0, population.length)];
       if (!best || individual.fitness < best.fitness) {
         best = individual;
       }
@@ -757,7 +757,7 @@ Optimization.Operators.createTournamentSelection = (options = {}) => {
     // Retourne le meilleur trouvé. Dans le pire des cas (tous les scores sont Infinity),
     // on retourne le premier candidat sélectionné au lieu de null.
     if (!best) {
-      return population[Math.floor(secureRandom() * population.length)];
+      return population[crypto.randomInt(0, population.length)];
     }
     return best;
   };
@@ -911,9 +911,12 @@ Optimization.Operators.solveTSP = (cities, options = {}) => {
   // Voisinage : génère un chemin voisin en inversant une sous-séquence (heuristique 2-opt).
   const pathNeighbor = (path) => {
     const newPath = [...path];
-    let i = Math.floor(secureRandom() * newPath.length);
-    let j = Math.floor(secureRandom() * newPath.length);
-    if (i === j) j = (j + 1) % newPath.length;
+    if (newPath.length <= 1) return newPath;
+    let i = crypto.randomInt(0, newPath.length);
+    let j = crypto.randomInt(0, newPath.length);
+    while (i === j) {
+      j = crypto.randomInt(0, newPath.length);
+    }
     const [start, end] = [Math.min(i, j), Math.max(i, j)];
 
     const segment = newPath.slice(start, end + 1).reverse();
@@ -971,7 +974,7 @@ Optimization.Operators.solvePortfolio = (
 
   const mutate = (p) => {
     const newP = [...p];
-    const i = Math.floor(secureRandom() * newP.length);
+      const i = crypto.randomInt(0, newP.length);
     newP[i] += (secureRandom() - 0.5) * 0.2; // Mutation douce
     newP[i] = Math.max(0, newP[i]); // Les poids ne peuvent être négatifs
     return newP;
@@ -1105,7 +1108,7 @@ Optimization.Operators.solveFacilityLocation = (
   // Voisinage : déplace légèrement une infrastructure au hasard.
   const facilityNeighbor = (facilities) => {
     const newFacilities = facilities.map((f) => ({ ...f }));
-    const i = Math.floor(secureRandom() * numFacilities);
+      const i = crypto.randomInt(0, numFacilities);
     const moveX = (secureRandom() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
     const moveY = (secureRandom() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
 
@@ -1326,16 +1329,32 @@ Optimization.Operators.benfordTest = (numbers) => {
         // Si l'entrée n'est pas un tableau, on ne peut pas l'analyser.
         return 0;
     }
-    const leadingDigits = numbers.map(n => String(n).trim().charAt(0))
-                                 .filter(d => d >= '1' && d <= '9'); // On ne garde que les chiffres de 1 à 9.
+    const counts = Array(10).fill(0);
+    let validCount = 0;
 
-    if (leadingDigits.length < 10) {
-        return 0; // Pas assez de données pour un test fiable
+    for (let i = 0; i < numbers.length; i++) {
+        let n = numbers[i];
+        if (typeof n === 'string') {
+            n = parseFloat(n);
+        }
+        if (typeof n !== 'number' || isNaN(n) || !isFinite(n)) {
+            continue;
+        }
+        const val = Math.abs(n);
+        if (val === 0) {
+            continue;
+        }
+        const log = Math.log10(val);
+        const factor = Math.pow(10, Math.floor(log));
+        let digit = Math.floor(val / factor);
+        if (digit >= 1 && digit <= 9) {
+            counts[digit]++;
+            validCount++;
+        }
     }
 
-    const counts = Array(10).fill(0);
-    for (let i = 0; i < leadingDigits.length; i++) {
-        counts[parseInt(leadingDigits[i], 10)]++;
+    if (validCount < 10) {
+        return 0; // Pas assez de données pour un test fiable
     }
 
     // Distribution attendue selon la loi de Benford pour le premier chiffre
@@ -1346,7 +1365,7 @@ Optimization.Operators.benfordTest = (numbers) => {
 
     let totalDeviation = 0;
     for (let i = 1; i <= 9; i++) {
-        const observedFrequency = (counts[i] / leadingDigits.length) * 100;
+        const observedFrequency = (counts[i] / validCount) * 100;
         const expectedFrequency = benfordDistribution[i];
         totalDeviation += Math.pow(observedFrequency - expectedFrequency, 2);
     }
@@ -1485,7 +1504,7 @@ Optimization.Operators.solveFraudDetection = (context, options = {}) => {
     const minTimeToClick = 100 + secureRandom() * 4900; // entre 100ms et 5s
     const maxClickVariance = 1 + secureRandom() * 9999; // entre 1 et 10000
     const minMouseEntropy = secureRandom() * 0.5; // entre 0 et 0.5
-    const minScrollEvents = Math.floor(secureRandom() * 10); // entre 0 et 10
+    const minScrollEvents = crypto.randomInt(0, 10); // entre 0 et 10
     return [minTimeToClick, maxClickVariance, minMouseEntropy, minScrollEvents];
   };
 
@@ -1502,7 +1521,7 @@ Optimization.Operators.solveFraudDetection = (context, options = {}) => {
   // Mutation : légère variation aléatoire d'un des seuils
   const mutate = (solution) => {
     const newSolution = [...solution];
-    const i = Math.floor(secureRandom() * 4);
+    const i = crypto.randomInt(0, 4);
     // Amplitudes de mutation différentes pour chaque seuil
     const mutationFactors = [500, 1000, 0.1, 2];
     const mutationFactor = mutationFactors[i];
@@ -1646,7 +1665,7 @@ Optimization.Operators.solveFullSecurityTuning = (context, options = {}) => {
             burstWeight: 20 + secureRandom() * 40,
             scrapeThreshold: 500 + secureRandom() * 1000,
             scrapeWeight: 15 + secureRandom() * 35,
-            sequenceLength: 3 + Math.floor(secureRandom() * 3),
+            sequenceLength: 3 + crypto.randomInt(0, 3),
             sequenceWeight: 20 + secureRandom() * 50,
             regularityThreshold: 50 + secureRandom() * 200,
             regularityWeight: 20 + secureRandom() * 40,
@@ -1696,7 +1715,7 @@ Optimization.Operators.solveFullSecurityTuning = (context, options = {}) => {
         }
 
         const keys = Object.keys(newConfig[sectionToMutate]);
-        const keyToMutate = keys[Math.floor(secureRandom() * keys.length)];
+        const keyToMutate = keys[crypto.randomInt(0, keys.length)];
 
         if (keyToMutate === 'honeypotScore') return newConfig; // Ne pas muter le poids du honeypot
 

package/src/js/mongodb-store.js

@@ -1,80 +1,166 @@
-/**
- * @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);
-  
-  // Custom replacer/reviver to handle Set serialization (identical to Redis/SQL stores)
-  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
-  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
-
-  return {
-    async get(key) {
-      const doc = await collection.findOne({ _id: key });
-      if (!doc) return null;
-
-      // Active expiration check to bypass eventual consistency of MongoDB's 60s TTL cleanup daemon
-      if (doc.expiresAt && new Date(doc.expiresAt) < new Date()) {
-        await this.delete(key);
-        return null;
-      }
-
-      try {
-        return JSON.parse(doc.value, reviver);
-      } catch (e) {
-        // Fallback for legacy un-serialized raw values
-        return doc.value;
-      }
-    },
-    async set(key, value, ttl) {
-      const stringValue = JSON.stringify(value, replacer);
-      const doc = {
-        _id: key,
-        value: stringValue,
-      };
-
-      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 doc = await collection.findOne({ _id: key }, { projection: { expiresAt: 1 } });
-      if (!doc) return false;
-
-      if (doc.expiresAt && new Date(doc.expiresAt) < new Date()) {
-        await this.delete(key);
-        return false;
-      }
-      return true;
-    },
-    async delete(key) {
-      await collection.deleteOne({ _id: key });
-    },
-    async init() {
-      // Automates index configuration
-      await collection.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 });
-    }
-  };
+/**
+ * @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);
+  
+  // Custom replacer/reviver to handle Set serialization (identical to Redis/SQL stores)
+  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
+  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
+
+  const localStore = new Map();
+  const localTimeouts = new Map();
+  let isDown = false;
+  let reconnecting = false;
+
+  const triggerFallback = () => {
+    if (!isDown) {
+      isDown = true;
+      attemptReconnection();
+    }
+  };
+
+  const attemptReconnection = () => {
+    if (reconnecting) return;
+    reconnecting = true;
+    const interval = setInterval(async () => {
+      try {
+        if (db.admin) {
+          await db.admin().ping();
+        } else {
+          await collection.findOne({}, { projection: { _id: 1 } });
+        }
+        isDown = false;
+        reconnecting = false;
+        clearInterval(interval);
+      } catch (err) {
+        // Toujours déconnecté
+      }
+    }, 5000);
+    if (interval.unref) interval.unref();
+  };
+
+  const setLocal = (key, value, ttl) => {
+    localStore.set(key, value);
+    if (localTimeouts.has(key)) {
+      clearTimeout(localTimeouts.get(key));
+    }
+    if (ttl && ttl > 0) {
+      const timeout = setTimeout(() => {
+        localStore.delete(key);
+        localTimeouts.delete(key);
+      }, ttl * 1000);
+      if (timeout.unref) timeout.unref();
+      localTimeouts.set(key, timeout);
+    }
+  };
+
+  return {
+    async get(key) {
+      if (isDown) {
+        return localStore.get(key) || null;
+      }
+      try {
+        const doc = await collection.findOne({ _id: key });
+        if (!doc) return null;
+
+        // Active expiration check to bypass eventual consistency of MongoDB's 60s TTL cleanup daemon
+        if (doc.expiresAt && new Date(doc.expiresAt) < new Date()) {
+          await this.delete(key);
+          return null;
+        }
+
+        try {
+          return JSON.parse(doc.value, reviver);
+        } catch (e) {
+          // Fallback for legacy un-serialized raw values
+          return doc.value;
+        }
+      } catch (e) {
+        triggerFallback();
+        return localStore.get(key) || null;
+      }
+    },
+    async set(key, value, ttl) {
+      if (isDown) {
+        setLocal(key, value, ttl);
+        return;
+      }
+      try {
+        const stringValue = JSON.stringify(value, replacer);
+        const doc = {
+          _id: key,
+          value: stringValue,
+        };
+
+        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 }
+        );
+      } catch (e) {
+        triggerFallback();
+        setLocal(key, value, ttl);
+      }
+    },
+    async has(key) {
+      if (isDown) {
+        return localStore.has(key);
+      }
+      try {
+        const doc = await collection.findOne({ _id: key }, { projection: { expiresAt: 1 } });
+        if (!doc) return false;
+
+        if (doc.expiresAt && new Date(doc.expiresAt) < new Date()) {
+          await this.delete(key);
+          return false;
+        }
+        return true;
+      } catch (e) {
+        triggerFallback();
+        return localStore.has(key);
+      }
+    },
+    async delete(key) {
+      if (localTimeouts.has(key)) {
+        clearTimeout(localTimeouts.get(key));
+        localTimeouts.delete(key);
+      }
+      localStore.delete(key);
+      if (isDown) return;
+      try {
+        await collection.deleteOne({ _id: key });
+      } catch (e) {
+        triggerFallback();
+      }
+    },
+    async init() {
+      try {
+        // Automates index configuration
+        await collection.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 });
+      } catch (e) {
+        triggerFallback();
+      }
+    }
+  };
 }