jumpy-lion 0.1.0 → 0.1.2

package/dist/fingerprinting/fingerprint-overrides/audio-spoofing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/audio-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,oCAAoC,QAAO,MAiHvD,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/audio-spoofing.js

@@ -0,0 +1,119 @@
+/**
+ * Audio Fingerprint Spoofing
+ * Adds controlled noise to audio processing to prevent fingerprinting
+ */
+export const createAudioFingerprintSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Audio Fingerprint Spoofing for 2025
+    const spoofAudioContext = () => {
+        const AudioContext = window.AudioContext || window.webkitAudioContext;
+        if (!AudioContext) return;
+
+        const OriginalAudioContext = AudioContext;
+        const OriginalOfflineAudioContext = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+
+        // Seeded PRNG (mulberry32) for deterministic noise
+        const createSeededRNG = (seed) => {
+            let s = seed | 0;
+            return () => {
+                s = s + 0x6D2B79F5 | 0;
+                let t = Math.imul(s ^ s >>> 15, 1 | s);
+                t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+                return ((t ^ t >>> 14) >>> 0) / 4294967296;
+            };
+        };
+        const sessionSeed = Date.now() ^ 0xB7E15162;
+        const seededRandom = createSeededRNG(sessionSeed);
+
+        // Add controlled per-sample noise to audio processing
+        const addNoise = (array) => {
+            if (!array || !array.length) return array;
+
+            for (let i = 0; i < array.length; i++) {
+                const noise = 0.00001 * (seededRandom() - 0.5);
+                array[i] = array[i] + noise;
+            }
+            return array;
+        };
+
+        // Override AudioContext
+        window.AudioContext = window.webkitAudioContext = new Proxy(OriginalAudioContext, {
+            construct(target, args) {
+                const context = Reflect.construct(target, args);
+
+                // Override createAnalyser
+                const originalCreateAnalyser = context.createAnalyser;
+                context.createAnalyser = function() {
+                    const analyser = originalCreateAnalyser.apply(this, arguments);
+
+                    const originalGetFloatFrequencyData = analyser.getFloatFrequencyData;
+                    analyser.getFloatFrequencyData = function(array) {
+                        originalGetFloatFrequencyData.apply(this, arguments);
+                        addNoise(array);
+                    };
+
+                    const originalGetByteFrequencyData = analyser.getByteFrequencyData;
+                    analyser.getByteFrequencyData = function(array) {
+                        originalGetByteFrequencyData.apply(this, arguments);
+                        for (let i = 0; i < array.length; i++) {
+                            array[i] = Math.min(255, Math.max(0, array[i] + Math.floor(seededRandom() * 3 - 1)));
+                        }
+                    };
+
+                    return analyser;
+                };
+
+                return context;
+            }
+        });
+
+        // Override OfflineAudioContext
+        if (OriginalOfflineAudioContext) {
+            window.OfflineAudioContext = window.webkitOfflineAudioContext = new Proxy(OriginalOfflineAudioContext, {
+                construct(target, args) {
+                    const context = Reflect.construct(target, args);
+
+                    const originalStartRendering = context.startRendering;
+                    context.startRendering = function() {
+                        return originalStartRendering.apply(this, arguments).then(buffer => {
+                            // Add noise to the rendered buffer
+                            for (let channel = 0; channel < buffer.numberOfChannels; channel++) {
+                                const channelData = buffer.getChannelData(channel);
+                                addNoise(channelData);
+                            }
+                            return buffer;
+                        });
+                    };
+
+                    return context;
+                }
+            });
+        }
+
+        // Register Proxy constructors with stealth utils for toString masking
+        const _s = typeof __stealth !== 'undefined' ? __stealth : null;
+        if (_s && _s.utils) {
+            _s.utils.registerNativeFunction(window.AudioContext, 'AudioContext');
+            if (window.OfflineAudioContext) {
+                _s.utils.registerNativeFunction(window.OfflineAudioContext, 'OfflineAudioContext');
+            }
+        }
+    };
+    
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting audio context spoofing...');
+        spoofAudioContext();
+        console.log(DEBUG_PREFIX, '✓ Audio context spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply audio context spoofing:', e);
+        throw e; // Rethrow to make errors visible
+    }
+})();`;
+};
+//# sourceMappingURL=audio-spoofing.js.map

package/dist/fingerprinting/fingerprint-overrides/audio-spoofing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/audio-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,oCAAoC,GAAG,GAAW,EAAE;IAC7D,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+GL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/canvas-protection.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Advanced Canvas Protection
+ * Adds deterministic noise to canvas operations to prevent fingerprinting
+ */
+export declare const createAdvancedCanvasProtectionScript: () => string;
+//# sourceMappingURL=canvas-protection.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/canvas-protection.d.ts.map

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

package/dist/fingerprinting/fingerprint-overrides/canvas-protection.js

@@ -0,0 +1,149 @@
+/**
+ * Advanced Canvas Protection
+ * Adds deterministic noise to canvas operations to prevent fingerprinting
+ */
+export const createAdvancedCanvasProtectionScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Advanced Canvas Protection for 2025
+    const protectCanvas = () => {
+        const noiseFactor = 0.0001;
+
+        // Seeded PRNG (mulberry32) for deterministic noise
+        const createSeededRNG = (seed) => {
+            let s = seed | 0;
+            return () => {
+                s = s + 0x6D2B79F5 | 0;
+                let t = Math.imul(s ^ s >>> 15, 1 | s);
+                t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+                return ((t ^ t >>> 14) >>> 0) / 4294967296;
+            };
+        };
+        const sessionSeed = Date.now() ^ (Math.random() * 0xFFFFFFFF >>> 0);
+        const seededRandom = createSeededRNG(sessionSeed);
+
+        // Helper to add deterministic noise to a cloned image data
+        const addNoiseToImageData = (imageData) => {
+            const data = imageData.data;
+            for (let i = 0; i < data.length; i += 4) {
+                // Add small deterministic noise to RGB channels, skip alpha
+                const noise = Math.floor((seededRandom() - 0.5) * 3);
+                data[i] = Math.min(255, Math.max(0, data[i] + noise));     // R
+                data[i+1] = Math.min(255, Math.max(0, data[i+1] + noise)); // G
+                data[i+2] = Math.min(255, Math.max(0, data[i+2] + noise)); // B
+            }
+            return imageData;
+        };
+
+        // Store originals before overriding
+        const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
+        const originalToBlob = HTMLCanvasElement.prototype.toBlob;
+        const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
+        const originalMeasureText = CanvasRenderingContext2D.prototype.measureText;
+
+        // Override toDataURL - use a copy canvas so the original is not modified
+        HTMLCanvasElement.prototype.toDataURL = function(...args) {
+            const context = this.getContext('2d');
+            if (context) {
+                const copyCanvas = document.createElement('canvas');
+                copyCanvas.width = this.width;
+                copyCanvas.height = this.height;
+                const copyCtx = copyCanvas.getContext('2d');
+                if (copyCtx) {
+                    const imageData = originalGetImageData.call(context, 0, 0, this.width, this.height);
+                    addNoiseToImageData(imageData);
+                    copyCtx.putImageData(imageData, 0, 0);
+                    return originalToDataURL.apply(copyCanvas, args);
+                }
+            }
+            return originalToDataURL.apply(this, args);
+        };
+        // Override toBlob - use a copy canvas so the original is not modified
+        HTMLCanvasElement.prototype.toBlob = function(callback, ...args) {
+            const context = this.getContext('2d');
+            if (context) {
+                const copyCanvas = document.createElement('canvas');
+                copyCanvas.width = this.width;
+                copyCanvas.height = this.height;
+                const copyCtx = copyCanvas.getContext('2d');
+                if (copyCtx) {
+                    const imageData = originalGetImageData.call(context, 0, 0, this.width, this.height);
+                    addNoiseToImageData(imageData);
+                    copyCtx.putImageData(imageData, 0, 0);
+                    return originalToBlob.call(copyCanvas, callback, ...args);
+                }
+            }
+            return originalToBlob.call(this, callback, ...args);
+        };
+
+        // Override getImageData - clone the data, add noise to clone, return clone
+        CanvasRenderingContext2D.prototype.getImageData = function(...args) {
+            const imageData = originalGetImageData.apply(this, args);
+            const cloned = new ImageData(
+                new Uint8ClampedArray(imageData.data),
+                imageData.width,
+                imageData.height
+            );
+            return addNoiseToImageData(cloned);
+        };
+
+        // Override readPixels for WebGL - use seeded PRNG
+        if (typeof WebGLRenderingContext !== 'undefined') {
+            const originalReadPixels = WebGLRenderingContext.prototype.readPixels;
+            WebGLRenderingContext.prototype.readPixels = function(x, y, width, height, format, type, pixels) {
+                originalReadPixels.apply(this, arguments);
+                if (pixels && pixels.length) {
+                    for (let i = 0; i < pixels.length; i++) {
+                        pixels[i] = Math.min(255, Math.max(0, pixels[i] + Math.floor(seededRandom() * 3 - 1)));
+                    }
+                }
+            };
+
+            if (typeof WebGL2RenderingContext !== 'undefined') {
+                WebGL2RenderingContext.prototype.readPixels = WebGLRenderingContext.prototype.readPixels;
+            }
+        }
+
+        // Override font measurements to add slight deterministic variations
+        CanvasRenderingContext2D.prototype.measureText = function(text) {
+            const metrics = originalMeasureText.apply(this, arguments);
+
+            // Add tiny deterministic variation to measurements
+            const variation = 1 + (seededRandom() - 0.5) * 0.001;
+
+            return new Proxy(metrics, {
+                get(target, prop) {
+                    if (typeof target[prop] === 'number') {
+                        return target[prop] * variation;
+                    }
+                    return target[prop];
+                }
+            });
+        };
+
+        // Register all overridden functions with stealth utils for toString masking
+        const _s = typeof __stealth !== 'undefined' ? __stealth : null;
+        if (_s && _s.utils) {
+            _s.utils.registerNativeFunction(HTMLCanvasElement.prototype.toDataURL, 'toDataURL');
+            _s.utils.registerNativeFunction(HTMLCanvasElement.prototype.toBlob, 'toBlob');
+            _s.utils.registerNativeFunction(CanvasRenderingContext2D.prototype.getImageData, 'getImageData');
+            _s.utils.registerNativeFunction(CanvasRenderingContext2D.prototype.measureText, 'measureText');
+        }
+    };
+
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+
+    try {
+        console.log(DEBUG_PREFIX, 'Starting canvas protection...');
+        protectCanvas();
+        console.log(DEBUG_PREFIX, '✓ Canvas protection applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply canvas protection:', e);
+        throw e; // Rethrow to make errors visible
+    }
+})();`;
+};
+//# sourceMappingURL=canvas-protection.js.map

package/dist/fingerprinting/fingerprint-overrides/canvas-protection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-protection.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/canvas-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,oCAAoC,GAAG,GAAW,EAAE;IAC7D,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6IL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/cdp-detection-bypass.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CDP Detection Bypass
+ * Comprehensive CDP and automation detection bypass for 2024-2025
+ *
+ * Handles:
+ * - Iframe contentWindow access hiding
+ * - Puppeteer/Playwright evaluation script traces
+ * - Error.captureStackTrace patching
+ * - Storage access API spoofing
+ * - SourceURL/SourceMap hiding
+ * - Chrome DevTools property removal
+ */
+export declare const createCDPDetectionBypassScript: () => string;
+//# sourceMappingURL=cdp-detection-bypass.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/cdp-detection-bypass.d.ts.map

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