@anonympins/fingerprint 0.7.3 → 0.7.5

package/src/js/fingerprint.worker.js

@@ -0,0 +1,81 @@
+/**
+ * Service Worker for transparent network interception and credential enrichment.
+ * Leaves global window.fetch native and untouched to prevent tampering detection.
+ */
+
+let clientCredentials = {
+    fp: '',
+    behavior: 1,
+    targetDomains: []
+};
+
+self.addEventListener('install', () => {
+    self.skipWaiting();
+});
+
+self.addEventListener('activate', (event) => {
+    event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener('message', (event) => {
+    if (event.data && event.data.type === 'UPDATE_CREDENTIALS') {
+        if (typeof event.data.fp !== 'undefined') {
+            clientCredentials.fp = event.data.fp;
+        }
+        if (typeof event.data.behavior !== 'undefined') {
+            clientCredentials.behavior = event.data.behavior;
+        }
+        if (Array.isArray(event.data.targetDomains)) {
+            clientCredentials.targetDomains = event.data.targetDomains;
+        }
+    }
+});
+
+self.addEventListener('fetch', (event) => {
+    const url = new URL(event.request.url);
+
+    // Only process HTTP and HTTPS requests
+    if (!url.protocol.startsWith('http')) return;
+
+    // Scope filtering: same-origin or configured domains
+    const targets = clientCredentials.targetDomains;
+    const shouldProtect = (targets.length === 0 && url.origin === self.location.origin) ||
+                          (targets.length > 0 && targets.includes(url.hostname));
+
+    if (!shouldProtect) return;
+
+    event.respondWith((async () => {
+        const newHeaders = new Headers(event.request.headers);
+
+        if (clientCredentials.fp) {
+            newHeaders.set('X-Device-Fingerprint', clientCredentials.fp);
+        }
+        if (typeof clientCredentials.behavior !== 'undefined') {
+            newHeaders.set('X-Behavior-Metrics', String(clientCredentials.behavior));
+        }
+
+        const requestInit = {
+            method: event.request.method,
+            headers: newHeaders,
+            credentials: event.request.credentials,
+            cache: event.request.cache,
+            redirect: event.request.redirect,
+            referrer: event.request.referrer,
+            integrity: event.request.integrity
+        };
+
+        if (event.request.mode !== 'navigate') {
+            requestInit.mode = event.request.mode;
+        }
+
+        if (event.request.method !== 'GET' && event.request.method !== 'HEAD') {
+            try {
+                const bodyBlob = await event.request.clone().blob();
+                if (bodyBlob.size > 0) requestInit.body = bodyBlob;
+            } catch (e) {}
+        }
+
+        const modifiedRequest = new Request(event.request.url, requestInit);
+        return fetch(modifiedRequest);
+    })());
+});

package/src/js/library.js

@@ -1774,18 +1774,22 @@ Optimization.Operators.solveFullSecurityTuning = (context, options = {}) => {
       inconsistencyScore: 0.8,
       honeypotScore: 1.0,
       behaviorScore: 0.7,
+      botScore: 1.0,
+      cookieDroppingScore: 0.9,
       crossLayerInconsistencyScore: 0.4,
       timeInconsistencyScore: 0.9,
       tlsSpoofingScore: 0.8,
-      botScore: 1.0,
+      clientHintsInconsistencyScore: 0.7,
+      clickVarianceScore: 0.6,
       subnetScore: 0.4,
       ipReputationScore: 0.5,
       botnetClusterScore: 0.6,
       tcpAnomalyScore: 0.8,
       quicAnomalyScore: 0.8,
+      protocolAnomalyScore: 0.8,
       renderingAnomalyScore: 0.8,
       threatIntelScore: 1.0,
-      virtualizationScore: 0.8
+      virtualizationScore: 0.8,
     };
 
     // An "individual" is a complete security configuration object

package/src/js/pow.solver.js

@@ -398,7 +398,7 @@ export async function solveCpuTargetInline(baseBlock, target, progressCallback)
  * @returns {Promise<number>} Solution integer.
  */
 export async function solveCpuTarget(message, target) {
-    // Vérifie si les Web Workers sont supportés par le navigateur.
+    // Check if Web Workers are supported by the browser.
     if (typeof(Worker) === "undefined") {
         console.warn("Web Workers not supported. Falling back to main thread calculation (UI may freeze).");
         // An inline fallback implementation could be placed here if needed.
@@ -555,7 +555,7 @@ export async function solveTsp(cities, targetMaxDistance) {
         return totalDistance;
     }
 
-    // Solveur simple du TSP (heuristique du plus proche voisin)
+    // Simple TSP solver (nearest-neighbor heuristic)
     function solveTspNearestNeighbor(cities) {
         const numCities = cities.length;
         if (numCities === 0) return [];
@@ -1046,7 +1046,6 @@ async function solveUsefulWorkTask(task) {
             if (!solverFunction) {
                 throw new Error(`Solver '${task.solverName}' not found on client.`);
             }
-            // On appelle le solveur en lui passant le payload et les options.
             // Invoke solver with payload and options.
             return solverFunction(task.payload, { generations: task.generations, initialFront: task.initialFront });
         }