jumpy-lion 0.0.41 → 0.0.43

package/dist/fingerprinting/fingerprint-overrides/stealth-script.js.map

@@ -1 +1 @@
-{"version":3,"file":"stealth-script.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/stealth-script.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAW,EAAE;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgbL,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"stealth-script.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/stealth-script.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAW,EAAE;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqlCL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Storage Consistency Spoofing
+ * Handles storage-related fingerprinting for 2024-2025
+ *
+ * Features:
+ * - navigator.storage.estimate() with realistic quota values
+ * - StorageManager.persist() behavior spoofing
+ * - IndexedDB database name consistency
+ * - localStorage/sessionStorage quota reporting
+ * - CacheStorage.keys() consistent cache names
+ */
+export declare const createStorageConsistencyScript: () => string;
+//# sourceMappingURL=storage-consistency.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-consistency.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/storage-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,8BAA8B,QAAO,MAmWjD,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.js

@@ -0,0 +1,368 @@
+/**
+ * Storage Consistency Spoofing
+ * Handles storage-related fingerprinting for 2024-2025
+ *
+ * Features:
+ * - navigator.storage.estimate() with realistic quota values
+ * - StorageManager.persist() behavior spoofing
+ * - IndexedDB database name consistency
+ * - localStorage/sessionStorage quota reporting
+ * - CacheStorage.keys() consistent cache names
+ */
+export const createStorageConsistencyScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Storage Consistency Spoofing for 2024-2025
+    const spoofStorageAPIs = () => {
+        const platform = navigator.platform || 'Win32';
+        
+        // Generate consistent seed for stable values
+        const generateSeed = () => {
+            const ua = navigator.userAgent || '';
+            const screen = window.screen;
+            return (ua.length * 17 + (screen.width || 0) * 31 + (screen.height || 0) * 13) % 1000000;
+        };
+        
+        const sessionSeed = generateSeed();
+        
+        // Seeded random for consistent values
+        const seededRandom = (seed, min = 0, max = 1) => {
+            const x = Math.sin(seed) * 10000;
+            const random = x - Math.floor(x);
+            return min + random * (max - min);
+        };
+
+        // 1. Override navigator.storage.estimate()
+        const spoofStorageEstimate = () => {
+            if (navigator.storage && navigator.storage.estimate) {
+                const originalEstimate = navigator.storage.estimate;
+                
+                navigator.storage.estimate = function() {
+                    // Realistic storage values for different platforms
+                    const storageConfigs = {
+                        'Win32': {
+                            quotaBase: 300 * 1024 * 1024 * 1024, // ~300GB typical Windows
+                            usageBase: 50 * 1024 * 1024, // ~50MB typical usage
+                            variance: 0.15
+                        },
+                        'MacIntel': {
+                            quotaBase: 250 * 1024 * 1024 * 1024, // ~250GB typical Mac
+                            usageBase: 45 * 1024 * 1024,
+                            variance: 0.12
+                        },
+                        'Linux x86_64': {
+                            quotaBase: 200 * 1024 * 1024 * 1024, // ~200GB typical Linux
+                            usageBase: 40 * 1024 * 1024,
+                            variance: 0.18
+                        }
+                    };
+                    
+                    const config = storageConfigs[platform] || storageConfigs['Win32'];
+                    
+                    // Calculate consistent but varied values
+                    const quotaVariance = seededRandom(sessionSeed, 1 - config.variance, 1 + config.variance);
+                    const usageVariance = seededRandom(sessionSeed + 1, 0.5, 2);
+                    
+                    const quota = Math.floor(config.quotaBase * quotaVariance);
+                    const usage = Math.floor(config.usageBase * usageVariance);
+                    
+                    return Promise.resolve({
+                        quota: quota,
+                        usage: usage,
+                        usageDetails: {
+                            indexedDB: Math.floor(usage * 0.6),
+                            caches: Math.floor(usage * 0.3),
+                            serviceWorkerRegistrations: Math.floor(usage * 0.1)
+                        }
+                    });
+                };
+            }
+        };
+
+        // 2. Override StorageManager.persist()
+        const spoofStoragePersist = () => {
+            if (navigator.storage && navigator.storage.persist) {
+                navigator.storage.persist = function() {
+                    // Most browsers return false unless explicitly granted
+                    return Promise.resolve(false);
+                };
+            }
+            
+            if (navigator.storage && navigator.storage.persisted) {
+                navigator.storage.persisted = function() {
+                    return Promise.resolve(false);
+                };
+            }
+        };
+
+        // 3. Protect IndexedDB from fingerprinting
+        const spoofIndexedDB = () => {
+            if (!window.indexedDB) return;
+            
+            const originalOpen = window.indexedDB.open;
+            const originalDatabases = window.indexedDB.databases;
+            
+            // Track opened databases for consistency
+            const openedDatabases = new Set();
+            
+            window.indexedDB.open = function(name, version) {
+                openedDatabases.add(name);
+                return originalOpen.call(this, name, version);
+            };
+            
+            // Override databases() to hide fingerprinting attempts
+            if (originalDatabases) {
+                window.indexedDB.databases = function() {
+                    // Return only databases that were opened in this session
+                    return originalDatabases.call(this).then(databases => {
+                        // Filter to only known databases or return empty for privacy
+                        return databases.filter(db => 
+                            openedDatabases.has(db.name) || 
+                            // Allow common legitimate databases
+                            db.name.startsWith('firebaseLocalStorage') ||
+                            db.name === 'localforage'
+                        );
+                    });
+                };
+            }
+        };
+
+        // 4. Override localStorage/sessionStorage quota reporting
+        const spoofStorageQuota = () => {
+            // Create consistent storage size reporting
+            const getStorageSize = (storage) => {
+                let totalSize = 0;
+                try {
+                    for (let i = 0; i < storage.length; i++) {
+                        const key = storage.key(i);
+                        if (key) {
+                            totalSize += key.length + (storage.getItem(key) || '').length;
+                        }
+                    }
+                } catch (e) {}
+                return totalSize;
+            };
+            
+            // Ensure storage appears normal
+            const originalLocalStorageLength = Object.getOwnPropertyDescriptor(Storage.prototype, 'length');
+            
+            if (originalLocalStorageLength) {
+                Object.defineProperty(Storage.prototype, 'length', {
+                    get() {
+                        // Return actual length but ensure it's reasonable
+                        const actualLength = originalLocalStorageLength.get.call(this);
+                        return actualLength;
+                    },
+                    configurable: true,
+                    enumerable: true
+                });
+            }
+        };
+
+        // 5. Override CacheStorage.keys()
+        const spoofCacheStorage = () => {
+            if ('caches' in window) {
+                const originalKeys = CacheStorage.prototype.keys;
+                const originalOpen = CacheStorage.prototype.open;
+                const originalHas = CacheStorage.prototype.has;
+                const originalDelete = CacheStorage.prototype.delete;
+                
+                // Track caches opened in this session
+                const sessionCaches = new Set();
+                
+                CacheStorage.prototype.open = function(cacheName) {
+                    sessionCaches.add(cacheName);
+                    return originalOpen.call(this, cacheName);
+                };
+                
+                CacheStorage.prototype.keys = function() {
+                    return originalKeys.call(this).then(keys => {
+                        // Filter to only return caches that are expected
+                        return keys.filter(key => 
+                            sessionCaches.has(key) ||
+                            // Allow common legitimate cache names
+                            key.includes('workbox') ||
+                            key.includes('runtime') ||
+                            key.includes('precache') ||
+                            key.includes('sw-') ||
+                            key.includes('v1') ||
+                            key.includes('v2')
+                        );
+                    });
+                };
+                
+                CacheStorage.prototype.has = function(cacheName) {
+                    // Be honest about caches that exist
+                    return originalHas.call(this, cacheName);
+                };
+            }
+        };
+
+        // 6. Protect FileSystem API
+        const spoofFileSystemAPI = () => {
+            // Protect requestFileSystem if available
+            if (window.requestFileSystem || window.webkitRequestFileSystem) {
+                const originalRequestFileSystem = window.requestFileSystem || window.webkitRequestFileSystem;
+                
+                window.requestFileSystem = window.webkitRequestFileSystem = function(type, size, successCallback, errorCallback) {
+                    // Allow the request but with controlled quota
+                    const maxSize = 50 * 1024 * 1024; // 50MB max
+                    const limitedSize = Math.min(size, maxSize);
+                    
+                    return originalRequestFileSystem.call(
+                        window,
+                        type,
+                        limitedSize,
+                        successCallback,
+                        errorCallback
+                    );
+                };
+            }
+            
+            // Protect StorageManager quota
+            if (navigator.storage && navigator.storage.estimate) {
+                // Already handled above
+            }
+        };
+
+        // 7. Cookie Store API protection
+        const spoofCookieStore = () => {
+            if ('cookieStore' in window) {
+                const originalGetAll = cookieStore.getAll;
+                const originalGet = cookieStore.get;
+                
+                // Filter sensitive or fingerprinting cookies
+                const filterCookies = (cookies) => {
+                    if (!Array.isArray(cookies)) return cookies;
+                    
+                    return cookies.filter(cookie => {
+                        // Allow legitimate cookies, filter suspicious ones
+                        const name = cookie.name || '';
+                        
+                        // Block known fingerprinting cookie patterns
+                        if (name.includes('__fingerprint') ||
+                            name.includes('_fp_') ||
+                            name.includes('deviceId') ||
+                            name.includes('browser_id')) {
+                            return false;
+                        }
+                        
+                        return true;
+                    });
+                };
+                
+                cookieStore.getAll = function(options) {
+                    return originalGetAll.call(this, options).then(filterCookies);
+                };
+                
+                cookieStore.get = function(options) {
+                    return originalGet.call(this, options).then(cookie => {
+                        if (!cookie) return cookie;
+                        const filtered = filterCookies([cookie]);
+                        return filtered.length > 0 ? filtered[0] : null;
+                    });
+                };
+            }
+        };
+
+        // 8. Web SQL Database protection (deprecated but still detected)
+        const spoofWebSQL = () => {
+            if (window.openDatabase) {
+                const originalOpenDatabase = window.openDatabase;
+                const openedDatabases = new Set();
+                
+                window.openDatabase = function(name, version, displayName, estimatedSize) {
+                    openedDatabases.add(name);
+                    
+                    // Limit estimated size to prevent fingerprinting through quota
+                    const limitedSize = Math.min(estimatedSize || 0, 5 * 1024 * 1024);
+                    
+                    try {
+                        return originalOpenDatabase.call(
+                            window,
+                            name,
+                            version,
+                            displayName,
+                            limitedSize
+                        );
+                    } catch (e) {
+                        // Web SQL is deprecated, return gracefully
+                        throw e;
+                    }
+                };
+            }
+        };
+
+        // 9. Broadcast Channel API protection
+        const spoofBroadcastChannel = () => {
+            if (typeof BroadcastChannel !== 'undefined') {
+                const OriginalBroadcastChannel = BroadcastChannel;
+                const channels = new Map();
+                
+                window.BroadcastChannel = function(name) {
+                    const channel = new OriginalBroadcastChannel(name);
+                    
+                    // Track channel usage
+                    if (!channels.has(name)) {
+                        channels.set(name, []);
+                    }
+                    channels.get(name).push(channel);
+                    
+                    return channel;
+                };
+                
+                // Note: Don't assign to prototype - it may be frozen in modern Chrome
+            }
+        };
+
+        // 10. SharedWorker storage protection
+        const spoofSharedWorker = () => {
+            if (typeof SharedWorker !== 'undefined') {
+                const OriginalSharedWorker = SharedWorker;
+                const workers = new Set();
+                
+                window.SharedWorker = function(scriptURL, options) {
+                    const urlString = typeof scriptURL === 'string' ? scriptURL : scriptURL.toString();
+                    workers.add(urlString);
+                    
+                    return new OriginalSharedWorker(scriptURL, options);
+                };
+                
+                // Note: Don't assign to prototype - it may be frozen in modern Chrome
+            }
+        };
+
+        // Initialize all storage protections
+        try {
+            spoofStorageEstimate();
+            spoofStoragePersist();
+            spoofIndexedDB();
+            spoofStorageQuota();
+            spoofCacheStorage();
+            spoofFileSystemAPI();
+            spoofCookieStore();
+            spoofWebSQL();
+            spoofBroadcastChannel();
+            spoofSharedWorker();
+        } catch (e) {
+            console.error('[STORAGE-CONSISTENCY] Failed to apply storage consistency:', e);
+            throw e; // Rethrow to make errors visible
+        }
+    };
+
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting storage consistency...');
+        spoofStorageAPIs();
+        console.log(DEBUG_PREFIX, '✓ Storage consistency applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply storage consistency:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=storage-consistency.js.map

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-consistency.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/storage-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACvD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiWL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/timing-consistency.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Timing Consistency Module
+ * Dedicated timing fingerprint protection for 2024-2025
+ *
+ * Features:
+ * - Consistent Date.now() and performance.now() relationship
+ * - PerformanceEntry timing value protection
+ * - performance.measureUserAgentSpecificMemory() handling
+ * - event.timeStamp consistency in dispatched events
+ * - requestAnimationFrame timing patterns
+ */
+export declare const createTimingConsistencyScript: () => string;
+//# sourceMappingURL=timing-consistency.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/timing-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing-consistency.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/timing-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,6BAA6B,QAAO,MAyahD,CAAC"}