jumpy-lion 0.0.41 → 0.0.43

package/dist/fingerprinting/fingerprint-overrides/prototype-integrity.js

@@ -0,0 +1,355 @@
+/**
+ * Prototype Integrity Module
+ *
+ * Ensures all property overrides are undetectable by:
+ * - Making overridden properties appear native (configurable: false)
+ * - Hiding modified property descriptors from Object.getOwnPropertyDescriptor
+ * - Protecting prototype chains from Object.getPrototypeOf inspection
+ * - Masking shadow properties from enumeration
+ *
+ * This module MUST be injected FIRST, before any other fingerprint overrides.
+ */
+export const createPrototypeIntegrityScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Skip if already initialized
+    if (window.__PROTOTYPE_INTEGRITY_INITIALIZED__) return;
+    window.__PROTOTYPE_INTEGRITY_INITIALIZED__ = true;
+    
+    // ============================================
+    // PROTOTYPE INTEGRITY - Hide All Overrides
+    // ============================================
+    
+    // Shadow maps to track original descriptors and overrides
+    const originalDescriptors = new WeakMap(); // obj -> Map<prop, originalDescriptor>
+    const overriddenProperties = new WeakMap(); // obj -> Set<prop>
+    const fakeDescriptors = new WeakMap(); // obj -> Map<prop, fakeDescriptor>
+    
+    // Cache original functions BEFORE any modifications
+    const _Object = Object;
+    const _Reflect = Reflect;
+    const _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    const _getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+    const _getPrototypeOf = Object.getPrototypeOf;
+    const _defineProperty = Object.defineProperty;
+    const _getOwnPropertyNames = Object.getOwnPropertyNames;
+    const _keys = Object.keys;
+    const _hasOwnProperty = Object.prototype.hasOwnProperty;
+    const _ReflectGetOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor;
+    const _ReflectDefineProperty = Reflect.defineProperty;
+    const _ReflectOwnKeys = Reflect.ownKeys;
+    const _ReflectGet = Reflect.get;
+    const _ReflectHas = Reflect.has;
+    
+    /**
+     * Register a property as overridden and cache its original descriptor
+     */
+    const registerOverride = (obj, prop, originalDescriptor) => {
+        if (!originalDescriptors.has(obj)) {
+            originalDescriptors.set(obj, new Map());
+        }
+        if (!overriddenProperties.has(obj)) {
+            overriddenProperties.set(obj, new Set());
+        }
+        
+        const objDescriptors = originalDescriptors.get(obj);
+        const objOverrides = overriddenProperties.get(obj);
+        
+        // Only cache original if not already cached
+        if (!objDescriptors.has(prop) && originalDescriptor) {
+            objDescriptors.set(prop, originalDescriptor);
+        }
+        
+        objOverrides.add(prop);
+    };
+    
+    /**
+     * Check if a property has been overridden
+     */
+    const isOverridden = (obj, prop) => {
+        const objOverrides = overriddenProperties.get(obj);
+        return objOverrides ? objOverrides.has(prop) : false;
+    };
+    
+    /**
+     * Get the original descriptor for an overridden property
+     */
+    const getOriginalDescriptor = (obj, prop) => {
+        const objDescriptors = originalDescriptors.get(obj);
+        return objDescriptors ? objDescriptors.get(prop) : undefined;
+    };
+    
+    /**
+     * Create a native-like descriptor that hides the override
+     */
+    const createNativeDescriptor = (obj, prop, actualDescriptor) => {
+        const original = getOriginalDescriptor(obj, prop);
+        
+        if (original) {
+            // Return a descriptor that looks like the original
+            // but actually uses our getter/setter
+            return {
+                configurable: original.configurable !== undefined ? original.configurable : false,
+                enumerable: original.enumerable !== undefined ? original.enumerable : true,
+                get: actualDescriptor?.get,
+                set: actualDescriptor?.set,
+                value: actualDescriptor?.value,
+                writable: original.writable
+            };
+        }
+        
+        // Default: make it look like a native property
+        if (actualDescriptor?.get || actualDescriptor?.set) {
+            return {
+                configurable: false,
+                enumerable: true,
+                get: actualDescriptor.get,
+                set: actualDescriptor.set
+            };
+        }
+        
+        return {
+            configurable: false,
+            enumerable: true,
+            writable: false,
+            value: actualDescriptor?.value
+        };
+    };
+    
+    /**
+     * Set a fake descriptor to return for getOwnPropertyDescriptor
+     */
+    const setFakeDescriptor = (obj, prop, descriptor) => {
+        if (!fakeDescriptors.has(obj)) {
+            fakeDescriptors.set(obj, new Map());
+        }
+        fakeDescriptors.get(obj).set(prop, descriptor);
+    };
+    
+    /**
+     * Override a property with native-like appearance
+     * This is the main function other modules should use
+     */
+    const overridePropertyNative = (obj, prop, descriptor) => {
+        // Cache original descriptor first
+        const originalDescriptor = _getOwnPropertyDescriptor.call(_Object, obj, prop);
+        registerOverride(obj, prop, originalDescriptor);
+        
+        // Apply the actual override
+        try {
+            _defineProperty.call(_Object, obj, prop, {
+                ...descriptor,
+                configurable: true // We need this to work, but will fake it
+            });
+            
+            // Set up the fake descriptor to return
+            const fakeDesc = createNativeDescriptor(obj, prop, descriptor);
+            setFakeDescriptor(obj, prop, fakeDesc);
+            
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    /**
+     * Override Object.getOwnPropertyDescriptor to hide our modifications
+     */
+    const patchGetOwnPropertyDescriptor = () => {
+        _defineProperty.call(_Object, _Object, 'getOwnPropertyDescriptor', {
+            value: function(obj, prop) {
+                // Check if we have a fake descriptor for this property
+                const objFakes = fakeDescriptors.get(obj);
+                if (objFakes && objFakes.has(prop)) {
+                    const fake = objFakes.get(prop);
+                    // Return a copy to prevent modification
+                    return { ...fake };
+                }
+                
+                // Otherwise return the real descriptor
+                return _getOwnPropertyDescriptor.call(_Object, obj, prop);
+            },
+            writable: true,
+            configurable: true
+        });
+        
+        // Also patch Reflect.getOwnPropertyDescriptor
+        if (_Reflect && _ReflectGetOwnPropertyDescriptor) {
+            _defineProperty.call(_Object, _Reflect, 'getOwnPropertyDescriptor', {
+                value: function(obj, prop) {
+                    const objFakes = fakeDescriptors.get(obj);
+                    if (objFakes && objFakes.has(prop)) {
+                        return { ...objFakes.get(prop) };
+                    }
+                    return _ReflectGetOwnPropertyDescriptor.call(_Reflect, obj, prop);
+                },
+                writable: true,
+                configurable: true
+            });
+        }
+    };
+    
+    /**
+     * Override Object.getOwnPropertyDescriptors to use our patched version
+     */
+    const patchGetOwnPropertyDescriptors = () => {
+        _defineProperty.call(_Object, _Object, 'getOwnPropertyDescriptors', {
+            value: function(obj) {
+                const result = {};
+                const props = _getOwnPropertyNames.call(_Object, obj);
+                
+                for (const prop of props) {
+                    // Use our patched getOwnPropertyDescriptor
+                    const desc = _Object.getOwnPropertyDescriptor(obj, prop);
+                    if (desc) {
+                        result[prop] = desc;
+                    }
+                }
+                
+                // Also include symbol properties
+                const symbols = _Object.getOwnPropertySymbols ? _Object.getOwnPropertySymbols(obj) : [];
+                for (const sym of symbols) {
+                    const desc = _Object.getOwnPropertyDescriptor(obj, sym);
+                    if (desc) {
+                        result[sym] = desc;
+                    }
+                }
+                
+                return result;
+            },
+            writable: true,
+            configurable: true
+        });
+    };
+    
+    /**
+     * Protect prototype chain inspection
+     */
+    const patchGetPrototypeOf = () => {
+        // Store original prototypes before any modification
+        const originalPrototypes = new WeakMap();
+        
+        // We don't modify Object.getPrototypeOf because we want prototypes to look normal
+        // But we can use this to verify prototype chains are intact
+    };
+    
+    /**
+     * Patch Object.keys to filter automation properties
+     */
+    const patchObjectKeys = () => {
+        const automationProps = new Set([
+            'webdriver', '__webdriver_evaluate', '__selenium_evaluate',
+            '__driver_evaluate', '__webdriver_script_function',
+            '__webdriver_script_fn', '__fxdriver_evaluate',
+            '__webdriver_unwrapped', '$cdc_', 'cdc_'
+        ]);
+        
+        _defineProperty.call(_Object, _Object, 'keys', {
+            value: function(obj) {
+                const keys = _keys.call(_Object, obj);
+                return keys.filter(key => {
+                    const keyStr = String(key).toLowerCase();
+                    for (const autoProp of automationProps) {
+                        if (keyStr.includes(autoProp.toLowerCase())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            },
+            writable: true,
+            configurable: true
+        });
+    };
+    
+    /**
+     * Patch Object.getOwnPropertyNames to filter automation properties
+     */
+    const patchGetOwnPropertyNames = () => {
+        const automationProps = new Set([
+            'webdriver', '__webdriver_evaluate', '__selenium_evaluate',
+            '__driver_evaluate', '__webdriver_script_function',
+            '__webdriver_script_fn', '__fxdriver_evaluate',
+            '__webdriver_unwrapped', '$cdc_', 'cdc_', '__puppeteer',
+            '__playwright'
+        ]);
+        
+        _defineProperty.call(_Object, _Object, 'getOwnPropertyNames', {
+            value: function(obj) {
+                const names = _getOwnPropertyNames.call(_Object, obj);
+                return names.filter(name => {
+                    const nameStr = String(name).toLowerCase();
+                    for (const autoProp of automationProps) {
+                        if (nameStr.includes(autoProp.toLowerCase())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            },
+            writable: true,
+            configurable: true
+        });
+    };
+    
+    /**
+     * Patch Reflect.ownKeys to filter automation properties
+     */
+    const patchReflectOwnKeys = () => {
+        if (!_Reflect || !_ReflectOwnKeys) return;
+        
+        const automationProps = new Set([
+            'webdriver', '__webdriver', '__selenium', '__driver',
+            '__puppeteer', '__playwright', '$cdc_', 'cdc_'
+        ]);
+        
+        _defineProperty.call(_Object, _Reflect, 'ownKeys', {
+            value: function(obj) {
+                const keys = _ReflectOwnKeys.call(_Reflect, obj);
+                return keys.filter(key => {
+                    const keyStr = String(key).toLowerCase();
+                    for (const autoProp of automationProps) {
+                        if (keyStr.includes(autoProp.toLowerCase())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            },
+            writable: true,
+            configurable: true
+        });
+    };
+    
+    /**
+     * Initialize all prototype integrity patches
+     */
+    const initialize = () => {
+        patchGetOwnPropertyDescriptor();
+        patchGetOwnPropertyDescriptors();
+        patchGetPrototypeOf();
+        patchObjectKeys();
+        patchGetOwnPropertyNames();
+        patchReflectOwnKeys();
+    };
+    
+    // Initialize immediately
+    initialize();
+    
+    // Export utilities for use by other modules
+    window.__prototypeIntegrity__ = {
+        registerOverride,
+        isOverridden,
+        getOriginalDescriptor,
+        setFakeDescriptor,
+        overridePropertyNative,
+        createNativeDescriptor
+    };
+    
+    console.log('[CDP-FP-DEBUG] ✓ Prototype integrity initialized');
+})();
+`;
+};
+//# sourceMappingURL=prototype-integrity.js.map

package/dist/fingerprinting/fingerprint-overrides/prototype-integrity.js.map

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

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.d.ts

@@ -1,6 +1,15 @@
 /**
- * Runtime.enable Bypass
- * Prevents CDP detection through console.log(Error) technique
+ * Runtime.enable Bypass Script
+ * Prevents CDP detection through console.log(Error) technique and stack trace analysis.
+ *
+ * IMPORTANT: This is now a SCRIPT to be injected via addScriptToEvaluateOnNewDocument,
+ * NOT via Runtime.evaluate (which would defeat the purpose since Runtime.evaluate IS detectable!)
+ *
+ * Enhanced 2024-2025: Comprehensive stack trace sanitization that removes ALL CDP markers
  */
-export declare const setupRuntimeEnableBypass: (client: any) => Promise<void>;
+/**
+ * Creates the runtime enable bypass script that should be bundled with other stealth scripts.
+ * This script runs BEFORE page JavaScript and patches Error/console to hide CDP markers.
+ */
+export declare const createRuntimeEnableBypassScript: () => string;
 //# sourceMappingURL=runtime-enable-bypass.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-enable-bypass.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,wBAAwB,WAAkB,GAAG,KAAG,OAAO,CAAC,IAAI,CA8ExE,CAAC"}
+{"version":3,"file":"runtime-enable-bypass.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;GAGG;AACH,eAAO,MAAM,+BAA+B,QAAO,MAmQlD,CAAC"}