content-security-toolkit 1.0.0

package/dist/utils/detectors/debuggerDetector.d.ts

@@ -0,0 +1,51 @@
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+import type { DevToolsDetectorOptions } from "./detectorInterface";
+/**
+ * Utility class for detecting DevTools using a Web Worker
+ * This approach works across browsers and provides immediate feedback
+ */
+export interface DebuggerDetectorOptions extends DevToolsDetectorOptions {
+    /**
+     * Timeout duration in milliseconds
+     * If the worker doesn't respond within this time, DevTools is considered open
+     */
+    timeoutDuration?: number;
+}
+export declare class DebuggerDetector extends AbstractDevToolsDetector {
+    private worker;
+    private timeoutId;
+    private timeoutDuration;
+    private isInitialized;
+    private initializationAttempts;
+    private maxInitAttempts;
+    /**
+     * Create a new DebuggerDetector
+     * @param options Configuration options
+     */
+    constructor(options?: DebuggerDetectorOptions);
+    /**
+     * Initialize the worker for DevTools detection
+     */
+    private initWorker;
+    /**
+     * Perform a test check to ensure the worker is functioning correctly
+     */
+    private performTestCheck;
+    /**
+     * Check if DevTools is open
+     */
+    checkDevTools(): void;
+    /**
+     * Terminate the worker and clean up resources
+     */
+    private terminateWorker;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported(): boolean;
+}

package/dist/utils/detectors/debuggerDetector.js

@@ -0,0 +1,211 @@
+import { getBrowser, isBrowser, isMobile } from "../environment";
+import { AbstractDevToolsDetector, DetectorErrorType } from "./AbstractDevToolsDetector";
+export class DebuggerDetector extends AbstractDevToolsDetector {
+    /**
+     * Create a new DebuggerDetector
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super("DebuggerDetector", options);
+        this.worker = null;
+        this.timeoutId = null;
+        this.isInitialized = false;
+        this.initializationAttempts = 0;
+        this.maxInitAttempts = 3;
+        this.timeoutDuration = options.timeoutDuration || 500;
+        // Delay worker initialization to avoid issues during page load
+        setTimeout(() => {
+            this.initWorker();
+        }, 100);
+        this.logger.log(`Initialized with timeout duration: ${this.timeoutDuration}ms`);
+    }
+    /**
+     * Initialize the worker for DevTools detection
+     */
+    initWorker() {
+        if (this.isInitialized || this.initializationAttempts >= this.maxInitAttempts)
+            return;
+        this.initializationAttempts++;
+        this.safeExecute("initWorker", DetectorErrorType.INITIALIZATION_ERROR, () => {
+            // Create a blob URL for the worker script instead of using a file URL
+            // This avoids MIME type issues with server responses
+            const workerScript = `
+      // Worker script for DevTools detection
+      self.onmessage = function(e) {
+        if (e.data === "checkDevTools") {
+          // Send immediate response (opening heartbeat)
+          self.postMessage("heartbeatStart");
+          
+          // This will pause execution if DevTools is open
+          debugger;
+
+          // If we reach here without significant delay, DevTools is closed
+          self.postMessage("heartbeatEnd");
+        }
+      };
+    `;
+            // Create a blob URL from the script
+            const blob = new Blob([workerScript], { type: "application/javascript" });
+            const workerUrl = URL.createObjectURL(blob);
+            // Create the worker using the blob URL
+            this.worker = new Worker(workerUrl);
+            this.worker.onmessage = (e) => {
+                if (e.data === "heartbeatStart") {
+                    // First heartbeat received, now waiting for second
+                    this.logger.log("Received opening heartbeat");
+                }
+                else if (e.data === "heartbeatEnd") {
+                    // Second heartbeat received, DevTools is closed
+                    if (this.timeoutId !== null) {
+                        clearTimeout(this.timeoutId);
+                        this.timeoutId = null;
+                    }
+                    this.isChecking = false;
+                    this.updateDevToolsState(false);
+                }
+            };
+            this.worker.onerror = (error) => {
+                this.logger.error("Worker error:", error);
+                this.isChecking = false;
+                // Try to recreate the worker
+                this.terminateWorker();
+                // Retry initialization with exponential backoff
+                setTimeout(() => {
+                    this.initWorker();
+                }, Math.min(1000 * Math.pow(2, this.initializationAttempts - 1), 10000));
+            };
+            // Mark as initialized
+            this.isInitialized = true;
+            // Perform a test check to ensure everything is working
+            setTimeout(() => {
+                this.performTestCheck();
+            }, 200);
+        });
+    }
+    /**
+     * Perform a test check to ensure the worker is functioning correctly
+     */
+    performTestCheck() {
+        if (!this.worker || !this.isInitialized)
+            return;
+        this.safeExecute("performTestCheck", DetectorErrorType.DETECTION_ERROR, () => {
+            let testTimeoutId = null;
+            let testCompleted = false;
+            // Send message to worker
+            this.worker.postMessage("checkDevTools");
+            // Set a short timeout
+            testTimeoutId = window.setTimeout(() => {
+                // If we reach here and test isn't completed, something might be wrong
+                if (!testCompleted) {
+                    this.logger.log("Test check timed out, worker might not be responding correctly");
+                }
+                testTimeoutId = null;
+            }, 100);
+            // Set up a one-time message handler for the test
+            const originalOnMessage = this.worker.onmessage;
+            this.worker.onmessage = (e) => {
+                if (e.data === "heartbeatEnd") {
+                    testCompleted = true;
+                    if (testTimeoutId !== null) {
+                        clearTimeout(testTimeoutId);
+                        testTimeoutId = null;
+                    }
+                    this.logger.log("Test check completed successfully");
+                    // Restore original handler
+                    this.worker.onmessage = originalOnMessage;
+                }
+                else {
+                    // Pass through to original handler
+                    if (originalOnMessage) {
+                        originalOnMessage.call(this.worker, e);
+                    }
+                }
+            };
+        });
+    }
+    /**
+     * Check if DevTools is open
+     */
+    checkDevTools() {
+        if (this.isChecking || !this.worker || !this.isInitialized)
+            return;
+        this.isChecking = true;
+        this.safeExecute("checkDevTools", DetectorErrorType.DETECTION_ERROR, () => {
+            // Send message to worker
+            this.worker.postMessage("checkDevTools");
+            // Set timeout for missing second heartbeat
+            this.timeoutId = window.setTimeout(() => {
+                // If we reach here, the worker is paused at debugger
+                // which means DevTools is open
+                this.isChecking = false;
+                this.updateDevToolsState(true);
+            }, this.timeoutDuration);
+        });
+    }
+    /**
+     * Terminate the worker and clean up resources
+     */
+    terminateWorker() {
+        this.safeExecute("terminateWorker", DetectorErrorType.DISPOSAL_ERROR, () => {
+            if (this.worker) {
+                this.worker.terminate();
+                this.worker = null;
+            }
+        });
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.safeExecute("dispose", DetectorErrorType.DISPOSAL_ERROR, () => {
+            if (this.timeoutId !== null) {
+                clearTimeout(this.timeoutId);
+                this.timeoutId = null;
+            }
+            this.terminateWorker();
+            this.isInitialized = false;
+            this.logger.log("Disposed");
+        });
+        super.dispose();
+    }
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported() {
+        if (!isBrowser())
+            return false;
+        // Check if Web Workers are supported
+        if (typeof Worker === "undefined") {
+            return false;
+        }
+        // Check if Blob URLs are supported (needed for creating worker scripts)
+        if (typeof Blob === "undefined" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
+            return false;
+        }
+        // Check if we can create a worker from a blob URL
+        // Some environments restrict this for security reasons
+        try {
+            const blob = new Blob([""], { type: "application/javascript" });
+            const url = URL.createObjectURL(blob);
+            const worker = new Worker(url);
+            worker.terminate();
+            URL.revokeObjectURL(url);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (error) {
+            // If we can't create a worker, this detector won't work
+            return false;
+        }
+        // Get browser info
+        const browser = getBrowser();
+        const isMobileDevice = isMobile();
+        // This detector works best in Chromium-based browsers
+        // It's generally reliable across most desktop browsers
+        // Some older iOS browsers have issues with the debugger statement
+        if (isMobileDevice && browser.name === "safari" && Number.parseInt(browser.version, 10) < 14) {
+            return false;
+        }
+        return true;
+    }
+}

package/dist/utils/detectors/defineGetterDetector.d.ts

@@ -0,0 +1,48 @@
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+import { DevToolsDetectorOptions } from "./detectorInterface";
+/**
+ * Options for the DefineGetterDetector
+ */
+export interface DefineGetterDetectorOptions extends DevToolsDetectorOptions {
+    /**
+     * Check interval in milliseconds
+     */
+    checkInterval?: number;
+}
+/**
+ * Detector that uses property getter access to detect DevTools
+ * This works by creating an element with a getter that triggers when DevTools inspects it
+ */
+export declare class DefineGetterDetector extends AbstractDevToolsDetector {
+    private checkInterval;
+    private div;
+    private detectionCount;
+    private lastDetectionTime;
+    /**
+     * Create a new DefineGetterDetector
+     * @param options Configuration options
+     */
+    constructor(options?: DefineGetterDetectorOptions);
+    /**
+     * Initialize the div element with custom getter for detection
+     */
+    private initDetectionElement;
+    /**
+     * Handle getter access - called when the 'id' property is accessed
+     */
+    private handleGetterAccess;
+    /**
+     * Check if DevTools is open by logging the div element
+     * When the element is logged, DevTools will access its properties including 'id'
+     */
+    checkDevTools(): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported(): boolean;
+}

package/dist/utils/detectors/defineGetterDetector.js

@@ -0,0 +1,150 @@
+import { isBrowser } from "../environment";
+import { AbstractDevToolsDetector, DetectorErrorType } from "./AbstractDevToolsDetector";
+/**
+ * Detector that uses property getter access to detect DevTools
+ * This works by creating an element with a getter that triggers when DevTools inspects it
+ */
+export class DefineGetterDetector extends AbstractDevToolsDetector {
+    /**
+     * Create a new DefineGetterDetector
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super("DefineGetterDetector", options);
+        this.div = null;
+        this.detectionCount = 0;
+        this.lastDetectionTime = 0;
+        this.checkInterval = options.checkInterval || 1000;
+        // Initialize the div element with custom getter
+        this.initDetectionElement();
+        this.logger.log("Initialized with interval:", this.checkInterval);
+    }
+    /**
+     * Initialize the div element with custom getter for detection
+     */
+    initDetectionElement() {
+        this.safeExecute("initDetectionElement", DetectorErrorType.INITIALIZATION_ERROR, () => {
+            if (!isBrowser())
+                return;
+            this.div = document.createElement("div");
+            // Define a getter for the 'id' property that will be triggered when DevTools inspects the element
+            // Using both __defineGetter__ (for older browsers) and Object.defineProperty
+            try {
+                // This is a non-standard method but works in some browsers
+                ;
+                this.div.__defineGetter__("id", () => {
+                    this.handleGetterAccess();
+                    return "";
+                });
+            }
+            catch (e) {
+                // Ignore errors for browsers that don't support __defineGetter__
+                this.logger.log("__defineGetter__ not supported, using Object.defineProperty", e);
+            }
+            // Standard way using Object.defineProperty
+            Object.defineProperty(this.div, "id", {
+                get: () => {
+                    this.handleGetterAccess();
+                    return "";
+                },
+                configurable: true,
+            });
+            this.logger.log("Detection element initialized");
+        });
+    }
+    /**
+     * Handle getter access - called when the 'id' property is accessed
+     */
+    handleGetterAccess() {
+        this.safeExecute("handleGetterAccess", DetectorErrorType.DETECTION_ERROR, () => {
+            const now = Date.now();
+            this.detectionCount++;
+            // Avoid triggering too many times in a short period
+            if (now - this.lastDetectionTime < 100) {
+                this.detectionCount++;
+            }
+            else {
+                this.detectionCount = 1;
+            }
+            this.lastDetectionTime = now;
+            // If the getter is accessed multiple times in a short period, DevTools is likely open
+            if (this.detectionCount >= 2 && !this.isDevToolsOpen) {
+                this.updateDevToolsState(true);
+                this.logger.log("DevTools opened (getter accessed multiple times)");
+            }
+        });
+    }
+    /**
+     * Check if DevTools is open by logging the div element
+     * When the element is logged, DevTools will access its properties including 'id'
+     */
+    checkDevTools() {
+        if (this.isChecking || !isBrowser() || !this.div)
+            return;
+        this.isChecking = true;
+        this.safeExecute("checkDevTools", DetectorErrorType.DETECTION_ERROR, () => {
+            // Log the div element - this will trigger property access in DevTools
+            console.log(this.div);
+            // Clear console to avoid clutter
+            if (!this.debugMode) {
+                console.clear();
+            }
+            // If no detection occurred within a short time after logging,
+            // DevTools is likely closed
+            setTimeout(() => {
+                this.safeExecute("checkDevToolsTimeout", DetectorErrorType.DETECTION_ERROR, () => {
+                    const now = Date.now();
+                    if (now - this.lastDetectionTime > 500 && this.isDevToolsOpen) {
+                        this.updateDevToolsState(false);
+                        this.logger.log("DevTools closed (no recent getter access)");
+                    }
+                    this.isChecking = false;
+                });
+            }, 100);
+        });
+        // Ensure isChecking is reset if an error occurs
+        if (this.isChecking) {
+            setTimeout(() => {
+                this.isChecking = false;
+            }, 200);
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.safeExecute("dispose", DetectorErrorType.DISPOSAL_ERROR, () => {
+            this.div = null;
+            this.logger.log("Disposed");
+        });
+        super.dispose();
+    }
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported() {
+        if (!isBrowser())
+            return false;
+        try {
+            // Test if we can define getters on an element
+            const testDiv = document.createElement("div");
+            let testValue = false;
+            Object.defineProperty(testDiv, "testProp", {
+                get: () => {
+                    testValue = true;
+                    return "";
+                },
+                configurable: true,
+            });
+            // Access the property to see if the getter works
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const value = testDiv.testProp;
+            return testValue;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}

package/dist/utils/detectors/detectorInterface.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Interface for all DevTools detector implementations
+ */
+export interface DevToolsDetector {
+    /**
+     * Check if DevTools is currently open
+     */
+    checkDevTools(): void;
+    /**
+     * Get the current DevTools state
+     * @returns True if DevTools is open
+     */
+    isOpen(): boolean;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+}
+/**
+ * Common options for all DevTools detectors
+ */
+export interface DevToolsDetectorOptions {
+    /**
+     * Callback function when DevTools state changes
+     */
+    onDevToolsChange?: (isOpen: boolean) => void;
+    /**
+     * Enable debug mode for troubleshooting
+     */
+    debugMode?: boolean;
+}

package/dist/utils/detectors/detectorInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/detectors/devToolsDetectorManager.d.ts

@@ -0,0 +1,88 @@
+import type { DevToolsDetectorOptions } from "./detectorInterface";
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+/**
+ * Type for detector types
+ */
+export type DetectorType = "debugger" | "timing" | "dateToString" | "funcToString" | "regToString" | "defineGetter" | "debugLib" | "size";
+/**
+ * Options for the DevTools detector manager
+ */
+export interface DetectorManagerOptions extends DevToolsDetectorOptions {
+    /**
+     * Enable specific detection methods
+     */
+    enabledDetectors?: DetectorType[];
+    /**
+     * Timeout duration for the debugger detector
+     */
+    debuggerTimeoutDuration?: number;
+    /**
+     * Check interval in milliseconds
+     */
+    checkInterval?: number;
+    /**
+     * Delay initial check to avoid false positives during page load
+     * @default true
+     */
+    delayInitialCheck?: boolean;
+    /**
+     * Initial check delay in milliseconds
+     * @default 1000
+     */
+    initialCheckDelay?: number;
+}
+/**
+ * Manager class that coordinates multiple DevTools detection methods
+ * **Chrome, Edge, Opera**: Primarily uses `DebuggerDetector` with `DefineGetterDetector` as backup
+ * **Firefox**: Uses `TimingDetector` and `RegToStringDetector` for reliable detection
+ * **Safari**: Primarily uses `DateToStringDetector` with `DefineGetterDetector` as backup
+ * **QQ Browser**: Uses `RegToStringDetector` which works particularly well for this browser
+ * **Mobile Browsers**: Always includes `DebugLibDetector` to catch third-party debugging tools
+ */
+export declare class DevToolsDetectorManager extends AbstractDevToolsDetector {
+    private detectors;
+    private activeDetectors;
+    private browserInfo;
+    private isMobileDevice;
+    private isInitialCheckDone;
+    private initialCheckTimeout;
+    private delayInitialCheck;
+    private initialCheckDelay;
+    private static readonly BROWSER_DETECTOR_MAP;
+    private static readonly MOBILE_DETECTOR_MAP;
+    /**
+     * Create a new DevToolsDetectorManager
+     * @param options Configuration options
+     */
+    constructor(options?: DetectorManagerOptions);
+    /**
+     * Initialize all available detectors
+     */
+    private initializeAllDetectors;
+    /**
+     * Select which detectors to activate based on browser
+     */
+    private selectActiveDetectors;
+    /**
+     * Handle state change from any detector
+     */
+    private handleDetectorChange;
+    /**
+     * Check if DevTools is open using all active detectors
+     */
+    checkDevTools(): void;
+    /**
+     * Get the current DevTools state
+     * @returns True if DevTools is open
+     */
+    isOpen(): boolean;
+    /**
+     * Clean up resources for all detectors
+     */
+    dispose(): void;
+    /**
+     * Set debug mode for all detectors
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+}