jumpy-lion 0.0.41 → 0.0.42

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

@@ -0,0 +1,438 @@
+/**
+ * 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 const createTimingConsistencyScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Timing Consistency for 2024-2025
+    const setupTimingConsistency = () => {
+        // Base timestamps for consistency
+        const pageLoadTime = Date.now();
+        const performanceOrigin = performance.timeOrigin || pageLoadTime;
+        
+        // Store original methods
+        const originalDateNow = Date.now;
+        const originalPerformanceNow = performance.now.bind(performance);
+        
+        // Generate session seed for consistent variations
+        const generateSeed = () => {
+            const ua = navigator.userAgent || '';
+            return ua.length * 17 + (screen.width || 0) * 31;
+        };
+        
+        const sessionSeed = generateSeed();
+        
+        // Seeded random for consistent values
+        const seededRandom = (seed) => {
+            const x = Math.sin(seed) * 10000;
+            return x - Math.floor(x);
+        };
+
+        // 1. Ensure Date.now() and performance.now() have consistent relationship
+        const ensureDatePerformanceConsistency = () => {
+            let lastDateNow = originalDateNow();
+            let lastPerformanceNow = originalPerformanceNow();
+            
+            // Ensure timing values don't expose automation
+            Date.now = function() {
+                const now = originalDateNow();
+                
+                // Ensure monotonic increase with minimum 1ms resolution
+                if (now <= lastDateNow) {
+                    lastDateNow += 1;
+                    return lastDateNow;
+                }
+                
+                lastDateNow = now;
+                return now;
+            };
+            
+            performance.now = function() {
+                const now = originalPerformanceNow();
+                
+                // Add subtle platform-specific jitter (Windows has ~1ms resolution)
+                const platform = navigator.platform || 'Win32';
+                let jitter = 0;
+                
+                if (platform === 'Win32') {
+                    // Windows timer resolution is typically 15.6ms or 1ms with high-res enabled
+                    jitter = (seededRandom(sessionSeed + now) - 0.5) * 0.1;
+                } else if (platform === 'MacIntel') {
+                    // macOS has high precision timing
+                    jitter = (seededRandom(sessionSeed + now) - 0.5) * 0.01;
+                }
+                
+                const adjustedNow = now + jitter;
+                
+                // Ensure monotonic increase
+                if (adjustedNow <= lastPerformanceNow) {
+                    lastPerformanceNow += 0.001;
+                    return lastPerformanceNow;
+                }
+                
+                lastPerformanceNow = adjustedNow;
+                return adjustedNow;
+            };
+        };
+
+        // 2. Protect PerformanceEntry timing values
+        const protectPerformanceEntries = () => {
+            const originalGetEntries = performance.getEntries.bind(performance);
+            const originalGetEntriesByName = performance.getEntriesByName.bind(performance);
+            const originalGetEntriesByType = performance.getEntriesByType.bind(performance);
+            
+            // Add consistent variations to timing entries
+            const adjustEntry = (entry) => {
+                if (!entry) return entry;
+                
+                const timingProps = [
+                    'startTime', 'duration', 'fetchStart', 'domainLookupStart',
+                    'domainLookupEnd', 'connectStart', 'secureConnectionStart',
+                    'connectEnd', 'requestStart', 'responseStart', 'responseEnd',
+                    'workerStart', 'redirectStart', 'redirectEnd', 'processingStart',
+                    'processingEnd', 'loadEventStart', 'loadEventEnd',
+                    'unloadEventStart', 'unloadEventEnd'
+                ];
+                
+                const adjusted = {};
+                
+                for (const key of Object.keys(entry)) {
+                    if (timingProps.includes(key) && typeof entry[key] === 'number' && entry[key] > 0) {
+                        // Add consistent micro-variation
+                        const variation = seededRandom(sessionSeed + entry[key]) * 0.001;
+                        adjusted[key] = entry[key] + variation;
+                    } else {
+                        adjusted[key] = entry[key];
+                    }
+                }
+                
+                // Preserve prototype
+                Object.setPrototypeOf(adjusted, Object.getPrototypeOf(entry));
+                
+                return adjusted;
+            };
+            
+            performance.getEntries = function() {
+                return originalGetEntries().map(adjustEntry);
+            };
+            
+            performance.getEntriesByName = function(name, type) {
+                return originalGetEntriesByName(name, type).map(adjustEntry);
+            };
+            
+            performance.getEntriesByType = function(type) {
+                return originalGetEntriesByType(type).map(adjustEntry);
+            };
+        };
+
+        // 3. Handle performance.measureUserAgentSpecificMemory()
+        const protectMemoryMeasurement = () => {
+            if (performance.measureUserAgentSpecificMemory) {
+                const originalMeasure = performance.measureUserAgentSpecificMemory.bind(performance);
+                
+                performance.measureUserAgentSpecificMemory = function() {
+                    return originalMeasure().then(result => {
+                        // Normalize memory values to be less fingerprintable
+                        const normalizedBytes = Math.round(result.bytes / (1024 * 1024)) * 1024 * 1024;
+                        
+                        return {
+                            bytes: normalizedBytes + Math.floor(seededRandom(sessionSeed) * 1024 * 100),
+                            breakdown: (result.breakdown || []).map(item => ({
+                                ...item,
+                                bytes: Math.round(item.bytes / 1024) * 1024
+                            }))
+                        };
+                    }).catch(() => {
+                        // Return a reasonable default if measurement fails
+                        return {
+                            bytes: 30 * 1024 * 1024 + Math.floor(seededRandom(sessionSeed) * 5 * 1024 * 1024),
+                            breakdown: []
+                        };
+                    });
+                };
+            }
+        };
+
+        // 4. Event timeStamp consistency
+        const ensureEventTimestampConsistency = () => {
+            // Override Event constructor to ensure consistent timestamps
+            const OriginalEvent = Event;
+            
+            window.Event = function(type, eventInitDict) {
+                const event = new OriginalEvent(type, eventInitDict);
+                
+                // Ensure timeStamp is consistent with performance.now()
+                const currentTime = performance.now();
+                
+                Object.defineProperty(event, 'timeStamp', {
+                    get: () => currentTime,
+                    configurable: false,
+                    enumerable: true
+                });
+                
+                return event;
+            };
+            
+            // Note: Don't assign to prototype - it may be frozen in modern Chrome
+            
+            // Also override CustomEvent
+            const OriginalCustomEvent = CustomEvent;
+            
+            window.CustomEvent = function(type, eventInitDict) {
+                const event = new OriginalCustomEvent(type, eventInitDict);
+                
+                const currentTime = performance.now();
+                
+                Object.defineProperty(event, 'timeStamp', {
+                    get: () => currentTime,
+                    configurable: false,
+                    enumerable: true
+                });
+                
+                return event;
+            };
+            
+            // Note: Don't assign to prototype - it may be frozen in modern Chrome
+        };
+
+        // 5. requestAnimationFrame timing patterns
+        const normalizeRAFTiming = () => {
+            const originalRAF = window.requestAnimationFrame;
+            let lastRAFTime = 0;
+            const targetFPS = 60;
+            const targetFrameTime = 1000 / targetFPS; // ~16.67ms
+            
+            window.requestAnimationFrame = function(callback) {
+                return originalRAF(function(timestamp) {
+                    // Ensure consistent frame timing (~60fps)
+                    let adjustedTimestamp = timestamp;
+                    
+                    if (lastRAFTime > 0) {
+                        const delta = timestamp - lastRAFTime;
+                        
+                        // If frame time is suspiciously consistent (automation), add variation
+                        if (Math.abs(delta - targetFrameTime) < 0.1) {
+                            adjustedTimestamp = lastRAFTime + targetFrameTime + 
+                                (seededRandom(sessionSeed + timestamp) - 0.5) * 2;
+                        }
+                    }
+                    
+                    lastRAFTime = adjustedTimestamp;
+                    
+                    return callback(adjustedTimestamp);
+                });
+            };
+        };
+
+        // 6. setTimeout/setInterval timing normalization
+        const normalizeTimerTiming = () => {
+            const originalSetTimeout = window.setTimeout;
+            const originalSetInterval = window.setInterval;
+            
+            window.setTimeout = function(callback, delay, ...args) {
+                // Add slight variation to delays to appear more natural
+                const variation = Math.floor(seededRandom(sessionSeed + (delay || 0)) * 2);
+                const adjustedDelay = Math.max(0, (delay || 0) + variation);
+                
+                return originalSetTimeout.call(this, callback, adjustedDelay, ...args);
+            };
+            
+            window.setInterval = function(callback, delay, ...args) {
+                // Add slight variation
+                const variation = Math.floor(seededRandom(sessionSeed + (delay || 0)) * 2);
+                const adjustedDelay = Math.max(1, (delay || 0) + variation);
+                
+                return originalSetInterval.call(this, callback, adjustedDelay, ...args);
+            };
+        };
+
+        // 7. Performance Observer timing protection
+        const protectPerformanceObserver = () => {
+            if (typeof PerformanceObserver !== 'undefined') {
+                const OriginalPerformanceObserver = PerformanceObserver;
+                
+                window.PerformanceObserver = class extends OriginalPerformanceObserver {
+                    constructor(callback) {
+                        super(function(list, observer) {
+                            const entries = list.getEntries();
+                            
+                            // Create modified list with adjusted entries
+                            const adjustedEntries = entries.map(entry => {
+                                const clone = {};
+                                
+                                for (const key of Object.keys(entry)) {
+                                    if (typeof entry[key] === 'number' && key.includes('Time') || key === 'duration' || key === 'startTime') {
+                                        clone[key] = entry[key] + seededRandom(sessionSeed + entry[key]) * 0.001;
+                                    } else {
+                                        clone[key] = entry[key];
+                                    }
+                                }
+                                
+                                Object.setPrototypeOf(clone, Object.getPrototypeOf(entry));
+                                return clone;
+                            });
+                            
+                            const modifiedList = {
+                                getEntries: () => adjustedEntries,
+                                getEntriesByType: (type) => adjustedEntries.filter(e => e.entryType === type),
+                                getEntriesByName: (name, type) => adjustedEntries.filter(e => 
+                                    e.name === name && (!type || e.entryType === type)
+                                )
+                            };
+                            
+                            return callback(modifiedList, observer);
+                        });
+                    }
+                };
+                
+                // supportedEntryTypes is a getter-only property, check if configurable first
+                try {
+                    const descriptor = Object.getOwnPropertyDescriptor(window.PerformanceObserver, 'supportedEntryTypes');
+                    if (!descriptor || descriptor.configurable !== false) {
+                        Object.defineProperty(window.PerformanceObserver, 'supportedEntryTypes', {
+                            get: () => OriginalPerformanceObserver.supportedEntryTypes,
+                            configurable: true,
+                            enumerable: true
+                        });
+                    } else {
+                        // Property is frozen, skip silently
+                        console.log('[CDP-FP-DEBUG] PerformanceObserver.supportedEntryTypes is frozen, using original');
+                    }
+                } catch (e) {
+                    // Property might already be defined or frozen
+                    console.log('[CDP-FP-DEBUG] Could not redefine supportedEntryTypes:', e.message);
+                }
+            }
+        };
+
+        // 8. Idle callback timing
+        const normalizeIdleCallback = () => {
+            if (window.requestIdleCallback) {
+                const originalRIC = window.requestIdleCallback;
+                
+                window.requestIdleCallback = function(callback, options) {
+                    return originalRIC(function(deadline) {
+                        // Wrap deadline to provide consistent behavior
+                        const wrappedDeadline = {
+                            didTimeout: deadline.didTimeout,
+                            timeRemaining: function() {
+                                const remaining = deadline.timeRemaining();
+                                // Add slight variation
+                                return Math.max(0, remaining + (seededRandom(sessionSeed + remaining) - 0.5) * 2);
+                            }
+                        };
+                        
+                        return callback(wrappedDeadline);
+                    }, options);
+                };
+            }
+        };
+
+        // 9. Navigation Timing API protection
+        const protectNavigationTiming = () => {
+            if (performance.timing) {
+                const originalTiming = performance.timing;
+                const timingProxy = {};
+                
+                const timingProps = [
+                    'navigationStart', 'unloadEventStart', 'unloadEventEnd',
+                    'redirectStart', 'redirectEnd', 'fetchStart',
+                    'domainLookupStart', 'domainLookupEnd', 'connectStart',
+                    'connectEnd', 'secureConnectionStart', 'requestStart',
+                    'responseStart', 'responseEnd', 'domLoading',
+                    'domInteractive', 'domContentLoadedEventStart',
+                    'domContentLoadedEventEnd', 'domComplete',
+                    'loadEventStart', 'loadEventEnd'
+                ];
+                
+                timingProps.forEach(prop => {
+                    const originalValue = originalTiming[prop];
+                    if (typeof originalValue === 'number' && originalValue > 0) {
+                        Object.defineProperty(timingProxy, prop, {
+                            get: () => originalValue + seededRandom(sessionSeed + originalValue) * 0.5,
+                            configurable: true,
+                            enumerable: true
+                        });
+                    } else {
+                        Object.defineProperty(timingProxy, prop, {
+                            get: () => originalValue,
+                            configurable: true,
+                            enumerable: true
+                        });
+                    }
+                });
+                
+                // Add toJSON method
+                timingProxy.toJSON = function() {
+                    const json = {};
+                    timingProps.forEach(prop => {
+                        json[prop] = this[prop];
+                    });
+                    return json;
+                };
+                
+                Object.setPrototypeOf(timingProxy, PerformanceTiming.prototype);
+                
+                Object.defineProperty(performance, 'timing', {
+                    get: () => timingProxy,
+                    configurable: true
+                });
+            }
+        };
+
+        // 10. High Resolution Time protection
+        const protectHighResolutionTime = () => {
+            // Ensure performance.timeOrigin is consistent
+            if (performance.timeOrigin) {
+                const originalOrigin = performance.timeOrigin;
+                const adjustedOrigin = originalOrigin + seededRandom(sessionSeed) * 0.1;
+                
+                Object.defineProperty(performance, 'timeOrigin', {
+                    get: () => adjustedOrigin,
+                    configurable: true
+                });
+            }
+        };
+
+        // Initialize all timing protections
+        try {
+            ensureDatePerformanceConsistency();
+            protectPerformanceEntries();
+            protectMemoryMeasurement();
+            ensureEventTimestampConsistency();
+            normalizeRAFTiming();
+            normalizeTimerTiming();
+            protectPerformanceObserver();
+            normalizeIdleCallback();
+            protectNavigationTiming();
+            protectHighResolutionTime();
+        } catch (e) {
+            console.error('[TIMING-CONSISTENCY] Failed to apply timing 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 timing consistency...');
+        setupTimingConsistency();
+        console.log(DEBUG_PREFIX, '✓ Timing consistency applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply timing consistency:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=timing-consistency.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timing-consistency.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/timing-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAW,EAAE;IACtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuaL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Stealth Utility Functions
+ *
+ * Similar to puppeteer-extra-plugin-stealth's utils.js
+ * Provides helper functions for overriding browser properties without detection.
+ */
+/**
+ * Creates a stealth utilities script that can be injected into the browser.
+ * This script provides helper functions for property overrides that hide their tracks.
+ */
+export declare const createStealthUtilsScript: () => string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAO,MA+S3C,CAAC"}