content-security-toolkit 1.0.1 → 1.0.2

package/dist/strategies/DevToolsStrategy-simple.js

@@ -0,0 +1,366 @@
+import { isBrowser, getBrowser } from "../utils/detection";
+import { ProtectedContentManager } from "../utils/protectedContentManager";
+import { SecurityOverlayManager } from "../utils/securityOverlayManager";
+import { intervalManager } from "../utils/intervalManager";
+import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
+import { DebuggerDetector } from "../utils/detectors/debuggerDetector";
+import { TimingDetector } from "../utils/detectors/timingDetector";
+import { DateToStringDetector } from "../utils/detectors/dateToStringDetector";
+/**
+ * Strategy for detecting and responding to DevTools usage
+ */
+export class DevToolsStrategy extends AbstractStrategy {
+    /**
+     * Create a new DevToolsStrategy
+     * @param options Options for customizing the DevTools protection
+     * @param targetElement Element containing sensitive content
+     * @param customHandler Optional custom handler for DevTools detection
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(options, targetElement = null, customHandler, debugMode = false) {
+        super("DevToolsStrategy", debugMode);
+        this.intervalId = null;
+        this.taskId = null;
+        this.isDevToolsOpen = false;
+        this.targetElement = null;
+        this.contentManager = null;
+        // Detectors
+        this.debuggerDetector = null;
+        this.timingDetector = null;
+        this.dateToStringDetector = null;
+        this.activeDetector = null;
+        this.options = {
+            overlayOptions: {
+                title: "Developer Tools Detected",
+                message: "For security reasons, this content is not available while developer tools are open.",
+                secondaryMessage: "Please close developer tools to continue viewing this content.",
+                textColor: "white",
+                backgroundColor: "rgba(255, 0, 0, 0.7)",
+            },
+            showOverlay: true,
+            checkFrequency: 1000,
+            hideContent: false,
+            ...options,
+        };
+        this.targetElement = targetElement;
+        this.customHandler = customHandler;
+        this.browserInfo = getBrowser();
+        // Initialize content manager if target element is provided
+        if (targetElement) {
+            this.contentManager = new ProtectedContentManager(targetElement, debugMode);
+        }
+        // Initialize overlay manager
+        this.overlayManager = new SecurityOverlayManager(debugMode);
+        this.log("Initialized with checkFrequency:", this.options.checkFrequency);
+        this.log("Detected browser:", this.browserInfo.name, this.browserInfo.version);
+        // Initialize the appropriate detector based on browser
+        this.initDetectors();
+    }
+    /**
+     * Initialize the appropriate detector based on browser
+     */
+    initDetectors() {
+        return this.safeExecute("initDetectors", StrategyErrorType.INITIALIZATION, () => {
+            if (!isBrowser())
+                return;
+            try {
+                // Common callback for all detectors
+                const onDevToolsChange = (isOpen) => {
+                    this.handleDevToolsStateChange(isOpen);
+                };
+                // Initialize the debugger detector (for Chrome and Edge)
+                this.debuggerDetector = new DebuggerDetector({
+                    timeoutDuration: 50, // 50ms timeout for detection
+                    onDevToolsChange,
+                    debugMode: this.debugMode,
+                });
+                // Initialize the timing detector (for Firefox)
+                this.timingDetector = new TimingDetector({
+                    onDevToolsChange,
+                    debugMode: this.debugMode,
+                    thresholdMultiplier: 4, // Adjust sensitivity
+                });
+                // Initialize the date-to-string detector (for Safari and fallback)
+                if (DateToStringDetector.isSupported()) {
+                    this.dateToStringDetector = new DateToStringDetector({
+                        onDevToolsChange,
+                        debugMode: this.debugMode,
+                        threshold: 2, // Default threshold
+                    });
+                }
+                // Set the active detector based on browser
+                if (this.browserInfo.name === "firefox") {
+                    this.activeDetector = this.timingDetector;
+                    this.log("Using TimingDetector for Firefox");
+                }
+                else if (this.browserInfo.name === "safari") {
+                    if (this.dateToStringDetector) {
+                        this.activeDetector = this.dateToStringDetector;
+                        this.log("Using DateToStringDetector for Safari");
+                    }
+                    else {
+                        this.activeDetector = this.debuggerDetector;
+                        this.log("Using DebuggerDetector for Safari (fallback)");
+                    }
+                }
+                else {
+                    this.activeDetector = this.debuggerDetector;
+                    this.log("Using DebuggerDetector for", this.browserInfo.name);
+                }
+                this.log("Detectors initialized");
+            }
+            catch (error) {
+                this.handleError(StrategyErrorType.INITIALIZATION, "Failed to initialize detectors", error);
+                // Log more details about the error to help with troubleshooting
+                if (this.debugMode) {
+                    console.error("Detector initialization error details:", error);
+                }
+            }
+        });
+    }
+    /**
+     * Handle DevTools state changes from any detection method
+     */
+    handleDevToolsStateChange(isOpen) {
+        return this.safeExecute("handleDevToolsStateChange", StrategyErrorType.APPLICATION, () => {
+            // Only take action if state has changed
+            if (isOpen !== this.isDevToolsOpen) {
+                this.isDevToolsOpen = isOpen;
+                this.log(`DevTools state changed: ${isOpen ? "open" : "closed"}`);
+                if (isOpen) {
+                    this.applyDevToolsProtection();
+                }
+                else {
+                    this.removeDevToolsProtection();
+                }
+                // Call custom handler if provided
+                if (this.customHandler) {
+                    this.customHandler(isOpen);
+                }
+            }
+        });
+    }
+    /**
+     * Start monitoring for DevTools usage
+     */
+    startMonitoring() {
+        return this.safeExecute("startMonitoring", StrategyErrorType.APPLICATION, () => {
+            if (typeof window === "undefined")
+                return;
+            this.log("Starting DevTools monitoring");
+            // Register with IntervalManager for periodic checks
+            this.taskId = intervalManager.registerTask("devtools-detection", () => this.safeExecute("intervalTask", StrategyErrorType.APPLICATION, () => {
+                // Use the active detector
+                if (this.activeDetector) {
+                    this.activeDetector.checkDevTools();
+                }
+                // Always check overlay state if DevTools are open
+                if (this.isDevToolsOpen) {
+                    this.overlayManager.checkAndRestoreOverlay();
+                }
+            }), this.options.checkFrequency);
+            // Force initial check
+            if (this.activeDetector) {
+                this.activeDetector.checkDevTools();
+            }
+        });
+    }
+    /**
+     * Apply DevTools protection by creating overlay and event blocker
+     */
+    applyDevToolsProtection() {
+        return this.safeExecute("applyDevToolsProtection", StrategyErrorType.APPLICATION, () => {
+            if (!isBrowser())
+                return;
+            if (this.options.hideContent) {
+                // Hide sensitive content
+                this.hideSensitiveContent();
+            }
+            if (this.options.showOverlay) {
+                // Create overlay using the overlay manager
+                this.overlayManager.showOverlay({
+                    ...this.options.overlayOptions,
+                    blockEvents: true, // Block all events
+                    autoRestore: true, // Restore overlay if removed from DOM
+                });
+            }
+            this.log("DevTools protection applied");
+        });
+    }
+    /**
+     * Hide sensitive content when DevTools is open
+     */
+    hideSensitiveContent() {
+        return this.safeExecute("hideSensitiveContent", StrategyErrorType.APPLICATION, () => {
+            if (!this.targetElement || !this.contentManager)
+                return;
+            this.contentManager.hideContent({
+                title: this.options.overlayOptions?.title,
+                message: this.options.overlayOptions?.message,
+                secondaryMessage: this.options.overlayOptions?.secondaryMessage,
+                textColor: "black",
+                backgroundColor: "rgba(0, 0, 0, 0.05)",
+            });
+            this.log("Sensitive content hidden");
+        });
+    }
+    /**
+     * Restore sensitive content when DevTools is closed
+     */
+    restoreSensitiveContent() {
+        return this.safeExecute("restoreSensitiveContent", StrategyErrorType.REMOVAL, () => {
+            if (!this.contentManager)
+                return;
+            this.contentManager.restoreContent();
+            this.log("Sensitive content restored");
+        });
+    }
+    /**
+     * Remove DevTools protection
+     */
+    removeDevToolsProtection() {
+        return this.safeExecute("removeDevToolsProtection", StrategyErrorType.REMOVAL, () => {
+            if (typeof document === "undefined")
+                return;
+            if (this.options.hideContent) {
+                // Restore sensitive content
+                this.restoreSensitiveContent();
+            }
+            if (this.options.showOverlay) {
+                // Remove overlay using the overlay manager
+                this.overlayManager.removeOverlay();
+            }
+            this.log("DevTools protection removed");
+        });
+    }
+    /**
+     * Apply the protection strategy
+     */
+    apply() {
+        return this.safeExecute("apply", StrategyErrorType.APPLICATION, () => {
+            if (this.isAppliedFlag) {
+                this.log("Protection already applied");
+                return;
+            }
+            this.startMonitoring();
+            this.isAppliedFlag = true;
+            this.log("Protection applied");
+        });
+    }
+    /**
+     * Remove the protection strategy
+     * Override the base implementation to handle additional cleanup
+     */
+    remove() {
+        return this.safeExecute("remove", StrategyErrorType.REMOVAL, () => {
+            if (!this.isAppliedFlag) {
+                this.log("Protection not applied");
+                return;
+            }
+            // Clean up the detectors
+            if (this.debuggerDetector) {
+                this.debuggerDetector.dispose();
+                this.debuggerDetector = null;
+            }
+            if (this.timingDetector) {
+                this.timingDetector.dispose();
+                this.timingDetector = null;
+            }
+            if (this.dateToStringDetector) {
+                this.dateToStringDetector.dispose();
+                this.dateToStringDetector = null;
+            }
+            this.activeDetector = null;
+            // Clear interval via IntervalManager
+            if (this.taskId !== null) {
+                intervalManager.unregisterTask(this.taskId);
+                this.taskId = null;
+                this.log("Interval task unregistered");
+            }
+            // Also clear the old interval for backwards compatibility or if both are used
+            if (this.intervalId !== null && typeof window !== "undefined") {
+                window.clearInterval(this.intervalId);
+                this.intervalId = null;
+                this.log("Legacy interval cleared");
+            }
+            // Call the parent class remove method to handle event cleanup
+            super.remove();
+            // Remove protections
+            this.removeDevToolsProtection();
+            this.isAppliedFlag = false;
+            this.isDevToolsOpen = false;
+            this.log("Protection removed");
+        });
+    }
+    /**
+     * Update DevTools protection options
+     * @param options New options
+     */
+    updateOptions(options) {
+        return this.safeExecute("updateOptions", StrategyErrorType.OPTION_UPDATE, () => {
+            const typedOptions = options;
+            this.log("Updating options", typedOptions);
+            // Store previous options for comparison
+            const previousOptions = { ...this.options };
+            this.options = {
+                ...this.options,
+                ...typedOptions,
+            };
+            // If protection is already applied, update the overlay if needed
+            if (this.isAppliedFlag && this.isDevToolsOpen) {
+                // Check if any visual options changed
+                const visualOptionsChanged = previousOptions.overlayOptions?.title !== this.options.overlayOptions?.title ||
+                    previousOptions.overlayOptions?.message !== this.options.overlayOptions?.message ||
+                    previousOptions.overlayOptions?.secondaryMessage !== this.options.overlayOptions?.secondaryMessage ||
+                    previousOptions.overlayOptions?.backgroundColor !== this.options.overlayOptions?.backgroundColor ||
+                    previousOptions.overlayOptions?.textColor !== this.options.overlayOptions?.textColor;
+                if (visualOptionsChanged) {
+                    this.removeDevToolsProtection();
+                    this.applyDevToolsProtection();
+                    this.log("Reapplied protection with updated visual options");
+                }
+            }
+            // Update check frequency if it changed
+            if (typedOptions.checkFrequency &&
+                this.taskId !== null &&
+                previousOptions.checkFrequency !== typedOptions.checkFrequency) {
+                // Unregister and re-register with new frequency
+                intervalManager.unregisterTask(this.taskId);
+                this.taskId = intervalManager.registerTask("devtools-detection", () => this.safeExecute("intervalTask", StrategyErrorType.APPLICATION, () => {
+                    // Use active detector
+                    if (this.activeDetector) {
+                        this.activeDetector.checkDevTools();
+                    }
+                    if (this.isDevToolsOpen) {
+                        this.overlayManager.checkAndRestoreOverlay();
+                    }
+                }), this.options.checkFrequency);
+                this.log(`Check frequency updated to ${this.options.checkFrequency}ms`);
+            }
+        });
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        return this.safeExecute("setDebugMode", StrategyErrorType.OPTION_UPDATE, () => {
+            super.setDebugMode(enabled);
+            // Update debug mode for the detectors
+            if (this.debuggerDetector) {
+                this.debuggerDetector.setDebugMode(enabled);
+            }
+            if (this.timingDetector) {
+                this.timingDetector.setDebugMode(enabled);
+            }
+            if (this.dateToStringDetector) {
+                this.dateToStringDetector.setDebugMode(enabled);
+            }
+            // Also update debug mode for managers
+            if (this.contentManager && this.targetElement) {
+                this.contentManager = new ProtectedContentManager(this.targetElement, enabled);
+            }
+            this.overlayManager = new SecurityOverlayManager(enabled);
+        });
+    }
+}

package/dist/strategies/StrategyRegistry.d.ts

@@ -0,0 +1,133 @@
+import type { ProtectionStrategy } from "../types";
+import type { MediatorAware, ProtectionMediator } from "../core/mediator/types";
+/**
+ * Error types for strategy operations
+ */
+export declare enum StrategyErrorType {
+    REGISTRATION_ERROR = "registration_error",
+    UNREGISTRATION_ERROR = "unregistration_error",
+    APPLICATION_ERROR = "application_error",
+    REMOVAL_ERROR = "removal_error",
+    INVALID_STRATEGY = "invalid_strategy",
+    STRATEGY_NOT_FOUND = "strategy_not_found",
+    STRATEGY_ALREADY_REGISTERED = "strategy_already_registered"
+}
+/**
+ * Custom error class for strategy registry operations
+ */
+export declare class StrategyRegistryError extends Error {
+    readonly errorType: StrategyErrorType;
+    readonly strategyId?: string | undefined;
+    readonly originalError?: Error | undefined;
+    constructor(errorType: StrategyErrorType, message: string, strategyId?: string | undefined, originalError?: Error | undefined);
+}
+export interface StrategyRegistryOptions {
+    debugMode?: boolean;
+}
+/**
+ * Registry for managing protection strategies
+ * Provides centralized access and lifecycle management
+ */
+export declare class StrategyRegistry implements MediatorAware {
+    readonly COMPONENT_NAME = "StrategyRegistry";
+    private strategies;
+    private logger;
+    private mediator;
+    constructor(options?: StrategyRegistryOptions);
+    /**
+     * Set the mediator to communicate with other components
+     * @param mediator The protection mediator
+     */
+    setMediator(mediator: ProtectionMediator): void;
+    /**
+     * Register a strategy with the registry
+     * @param id Unique identifier for the strategy
+     * @param strategy Strategy instance
+     * @returns True if registration was successful
+     * @throws StrategyRegistryError if registration fails
+     */
+    register(id: string, strategy: ProtectionStrategy): boolean;
+    /**
+     * Unregister a strategy from the registry
+     * @param id Strategy ID to unregister
+     * @returns True if unregistration was successful
+     * @throws StrategyRegistryError if unregistration fails
+     */
+    unregister(id: string): boolean;
+    /**
+     * Get a strategy by ID
+     * @param id Strategy ID
+     * @returns The strategy instance or undefined if not found
+     */
+    getStrategy(id: string): ProtectionStrategy | undefined;
+    /**
+     * Check if a strategy is registered
+     * @param id Strategy ID
+     * @returns True if the strategy is registered
+     */
+    hasStrategy(id: string): boolean;
+    /**
+     * Apply a specific strategy
+     * @param id Strategy ID to apply
+     * @returns True if the strategy was applied successfully
+     * @throws StrategyRegistryError if application fails
+     */
+    applyStrategy(id: string): boolean;
+    /**
+     * Apply all registered strategies
+     * @returns Array of strategy IDs that failed to apply
+     */
+    applyAllStrategies(): string[];
+    /**
+     * Remove a specific strategy
+     * @param id Strategy ID to remove
+     * @returns True if removal was successful
+     * @throws StrategyRegistryError if removal fails
+     */
+    removeStrategy(id: string): boolean;
+    /**
+     * Remove all registered strategies
+     * @returns Array of strategy IDs that failed to remove
+     */
+    removeAllStrategies(): string[];
+    /**
+     * Get all registered strategy IDs
+     * @returns Array of strategy IDs
+     */
+    getStrategyIds(): string[];
+    /**
+     * Get all registered strategies
+     * @returns Map of strategy IDs to strategy instances
+     */
+    getAllStrategies(): Map<string, ProtectionStrategy>;
+    /**
+     * Get all applied strategies
+     * @returns Array of strategy IDs that are currently applied
+     */
+    getAppliedStrategies(): string[];
+    /**
+     * Set debug mode for all strategies that support it
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Clear the registry (remove all strategies first)
+     */
+    clear(): void;
+    /**
+     * Publish a strategy applied event through the mediator
+     * @param strategyId ID of the strategy that was applied
+     */
+    private publishStrategyAppliedEvent;
+    /**
+     * Publish a strategy removed event through the mediator
+     * @param strategyId ID of the strategy that was removed
+     */
+    private publishStrategyRemovedEvent;
+    /**
+     * Publish an error event through the mediator
+     * @param strategyId ID of the strategy that had an error
+     * @param error The error that occurred
+     */
+    private publishErrorEvent;
+}