content-security-toolkit 1.0.0

package/dist/strategies/ScreenshotStrategy.d.ts

@@ -0,0 +1,90 @@
+import type { CustomEventHandlers, ScreenshotOptions } from "../types";
+import { AbstractStrategy } from "./AbstractStrategy";
+/**
+ * Strategy for preventing screenshots and screen captures
+ */
+export declare class ScreenshotStrategy extends AbstractStrategy {
+    private keydownHandler;
+    private keyupHandler;
+    private blurHandler;
+    private focusHandler;
+    private visibilityHandler;
+    private printHandler;
+    private beforePrintHandler;
+    private fullscreenChangeHandler;
+    private lastKeyEvent;
+    private options;
+    private customHandler?;
+    private categories;
+    private targetElement;
+    private shortcutManager;
+    /**
+     * Create a new ScreenshotStrategy
+     * @param options Options for customizing the screenshot protection
+     * @param customHandler Optional custom handler for screenshot attempts
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(options?: ScreenshotOptions, targetElement?: HTMLElement | null, customHandler?: CustomEventHandlers["onScreenshotAttempt"], debugMode?: boolean);
+    /**
+     * Handle keydown events to detect screenshot attempts
+     */
+    private handleKeyDown;
+    /**
+     * Handle keyup events - specifically for PrintScreen which may only trigger on keyup
+     */
+    private handleKeyUp;
+    /**
+     * Handle window blur event - might indicate screenshot tool activation
+     */
+    private handleWindowBlur;
+    /**
+     * Handle window focus event - remove overlay when focus returns
+     */
+    private handleWindowFocus;
+    /**
+     * Handle visibility change event - might indicate screenshot tool activation
+     */
+    private handleVisibilityChange;
+    /**
+     * Handle print event - might be used for screenshots
+     */
+    private handlePrint;
+    /**
+     * Handle beforeprint event - prepare for print/screenshot
+     */
+    private handleBeforePrint;
+    /**
+     * Handle fullscreen change event - detect entering fullscreen
+     */
+    private handleFullscreenChange;
+    /**
+     * Exit fullscreen mode if currently in fullscreen
+     */
+    private exitFullscreen;
+    /**
+     * Show a notification that fullscreen mode is disabled
+     */
+    private showScreenshotNotification;
+    /**
+     * Show a notification that fullscreen mode is disabled
+     */
+    private showFullscreenNotification;
+    /**
+     * Apply screenshot protection
+     */
+    apply(): void;
+    /**
+     * Remove screenshot protection
+     */
+    remove(): void;
+    /**
+     * Update screenshot options
+     * @param options New screenshot options
+     */
+    updateOptions(options: Record<string, unknown>): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+}

package/dist/strategies/ScreenshotStrategy.js

@@ -0,0 +1,488 @@
+import { isBrowser, isPrintSupported, isBeforePrintSupported } from "../utils/environment";
+import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
+import { ShortcutCategory } from "../utils/keyboardShortcutManager/keyboardShortcuts";
+import { KeyboardShortcutManager } from "../utils/keyboardShortcutManager/keyboardShortcutManager";
+import { ProtectionEventType } from "../core/mediator/protection-event";
+import { timeoutManager } from "../utils/timeoutManager";
+/**
+ * Strategy for preventing screenshots and screen captures
+ */
+export class ScreenshotStrategy extends AbstractStrategy {
+    /**
+     * Create a new ScreenshotStrategy
+     * @param options Options for customizing the screenshot protection
+     * @param customHandler Optional custom handler for screenshot attempts
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(options, targetElement = null, customHandler, debugMode = false) {
+        super("ScreenshotStrategy", debugMode);
+        this.lastKeyEvent = 0;
+        this.categories = [ShortcutCategory.SCREENSHOT, ShortcutCategory.FULLSCREEN];
+        this.targetElement = null;
+        this.options = {
+            showOverlay: true,
+            overlayOptions: {
+                title: "SCREENSHOT PROTECTED",
+                textColor: "white",
+                backgroundColor: "rgba(255, 0, 0, 0.7)",
+                fontSize: "48px",
+                duration: 1000,
+            },
+            hideContent: true,
+            preventFullscreen: true,
+            fullscreenMessage: "Fullscreen mode is disabled for security reasons",
+            ...options,
+        };
+        this.customHandler = customHandler;
+        this.targetElement = targetElement;
+        this.keydownHandler = this.handleKeyDown.bind(this);
+        this.keyupHandler = this.handleKeyUp.bind(this);
+        this.blurHandler = this.handleWindowBlur.bind(this);
+        this.focusHandler = this.handleWindowFocus.bind(this);
+        this.visibilityHandler = this.handleVisibilityChange.bind(this);
+        this.printHandler = this.handlePrint.bind(this);
+        this.beforePrintHandler = this.handleBeforePrint.bind(this);
+        this.fullscreenChangeHandler = this.handleFullscreenChange.bind(this);
+        // Initialize shortcut manager
+        this.shortcutManager = KeyboardShortcutManager.getInstance();
+        // Set timeoutManager debug mode to match this strategy's debug mode
+        timeoutManager.setDebugMode(this.debugMode);
+        this.log("Initialized with options:", {
+            preventFullscreen: this.options.preventFullscreen,
+            duration: this.options.overlayOptions?.duration,
+            hideContent: this.options.hideContent,
+        });
+    }
+    /**
+     * Handle keydown events to detect screenshot attempts
+     */
+    handleKeyDown(e) {
+        return this.safeExecute("handleKeyDown", StrategyErrorType.EVENT_HANDLING, () => {
+            if (e.key === "F12") {
+                return; // Allow F12 to pass through
+            }
+            this.lastKeyEvent = Date.now();
+            // Use the shortcut manager to detect shortcuts
+            const shortcut = this.shortcutManager.matchesShortcut(e, this.categories);
+            if (shortcut) {
+                // Prevent the default action
+                e.preventDefault();
+                e.stopPropagation();
+                this.log(`Detected keyboard shortcut: ${shortcut.id} (${this.shortcutManager.getShortcutDescription(shortcut)})`);
+                // Handle based on category
+                if (shortcut.category === ShortcutCategory.SCREENSHOT) {
+                    // Publish screenshot attempt event
+                    if (this.mediator) {
+                        this.showScreenshotNotification();
+                    }
+                    // Call custom handler if provided
+                    if (this.customHandler) {
+                        this.customHandler(e);
+                    }
+                    return false;
+                }
+                else if (shortcut.category === ShortcutCategory.FULLSCREEN && this.options.preventFullscreen) {
+                    // Exit fullscreen if currently in fullscreen mode
+                    this.exitFullscreen();
+                    // Show anti-fullscreen notification
+                    this.showFullscreenNotification();
+                    // Call custom handler if provided
+                    if (this.customHandler) {
+                        this.customHandler(e);
+                    }
+                    return false;
+                }
+            }
+        });
+    }
+    /**
+     * Handle keyup events - specifically for PrintScreen which may only trigger on keyup
+     */
+    handleKeyUp(e) {
+        return this.safeExecute("handleKeyUp", StrategyErrorType.EVENT_HANDLING, () => {
+            // Check for PrintScreen key
+            const isPrintScreen = e.key === "PrintScreen" ||
+                e.key === "PrtScn" ||
+                e.key === "Print" ||
+                e.key === "PrtSc" ||
+                e.code === "PrintScreen" ||
+                e.keyCode === 44;
+            // Check for SysRq key
+            const isSysRq = e.key === "SysRq" || e.code === "SysRq";
+            if (isPrintScreen || isSysRq) {
+                this.log("PrintScreen/SysRq key detected on keyup");
+                e.preventDefault();
+                e.stopPropagation();
+                // Publish screenshot attempt event
+                if (this.mediator) {
+                    this.showScreenshotNotification();
+                }
+                // Call custom handler if provided
+                if (this.customHandler) {
+                    this.customHandler(e);
+                }
+                return false;
+            }
+        });
+    }
+    /**
+     * Handle window blur event - might indicate screenshot tool activation
+     */
+    handleWindowBlur() {
+        return this.safeExecute("handleWindowBlur", StrategyErrorType.EVENT_HANDLING, () => {
+            const timeSinceLastKey = Date.now() - this.lastKeyEvent;
+            // If window loses focus within 500ms of a key event, it might be a screenshot tool
+            if (timeSinceLastKey < 500) {
+                this.log("Window blur detected shortly after key event, possible screenshot attempt");
+                // Publish screenshot attempt event
+                if (this.mediator) {
+                    this.showScreenshotNotification();
+                }
+            }
+        });
+    }
+    /**
+     * Handle window focus event - remove overlay when focus returns
+     */
+    handleWindowFocus() {
+        return this.safeExecute("handleWindowFocus", StrategyErrorType.EVENT_HANDLING, () => {
+            // No need to do anything here - the handler will manage timeouts
+        });
+    }
+    /**
+     * Handle visibility change event - might indicate screenshot tool activation
+     */
+    handleVisibilityChange() {
+        return this.safeExecute("handleVisibilityChange", StrategyErrorType.EVENT_HANDLING, () => {
+            if (document.visibilityState === "hidden") {
+                const timeSinceLastKey = Date.now() - this.lastKeyEvent;
+                // If document becomes hidden within 500ms of a key event, it might be a screenshot tool
+                if (timeSinceLastKey < 500) {
+                    this.log("Visibility change detected shortly after key event, possible screenshot attempt");
+                    // Publish screenshot attempt event
+                    if (this.mediator) {
+                        this.showScreenshotNotification();
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Handle print event - might be used for screenshots
+     */
+    handlePrint() {
+        return this.safeExecute("handlePrint", StrategyErrorType.EVENT_HANDLING, () => {
+            this.log("Print event detected, possible screenshot attempt");
+            // Publish screenshot attempt event
+            if (this.mediator) {
+                this.showScreenshotNotification();
+            }
+        });
+    }
+    /**
+     * Handle beforeprint event - prepare for print/screenshot
+     */
+    handleBeforePrint() {
+        return this.safeExecute("handleBeforePrint", StrategyErrorType.EVENT_HANDLING, () => {
+            this.log("BeforePrint event detected, possible screenshot attempt");
+            // Publish screenshot attempt event
+            if (this.mediator) {
+                this.showScreenshotNotification();
+            }
+        });
+    }
+    /**
+     * Handle fullscreen change event - detect entering fullscreen
+     */
+    handleFullscreenChange() {
+        return this.safeExecute("handleFullscreenChange", StrategyErrorType.EVENT_HANDLING, () => {
+            if (!this.options.preventFullscreen)
+                return;
+            // Check if we're in fullscreen mode
+            const isInFullscreen = document.fullscreenElement ||
+                document.webkitFullscreenElement ||
+                document.mozFullScreenElement ||
+                document.msFullscreenElement;
+            if (isInFullscreen) {
+                this.log("Fullscreen mode detected, exiting fullscreen");
+                // Exit fullscreen mode
+                this.exitFullscreen();
+                // Show notification
+                this.showFullscreenNotification();
+                // Call custom handler if provided
+                if (this.customHandler) {
+                    this.customHandler(new Event("fullscreenchange"));
+                }
+            }
+        });
+    }
+    /**
+     * Exit fullscreen mode if currently in fullscreen
+     */
+    exitFullscreen() {
+        return this.safeExecute("exitFullscreen", StrategyErrorType.APPLICATION, () => {
+            if (!isBrowser())
+                return;
+            // Check if document is active and has a fullscreen element before attempting to exit
+            try {
+                // Only attempt to exit if we're actually in fullscreen mode
+                const isInFullscreen = document.fullscreenElement ||
+                    document.webkitFullscreenElement ||
+                    document.mozFullScreenElement ||
+                    document.msFullscreenElement;
+                if (isInFullscreen) {
+                    if (document.exitFullscreen) {
+                        document.exitFullscreen().catch((err) => {
+                            // Silently catch errors during exit fullscreen
+                            this.log("Error exiting fullscreen:", err.message);
+                        });
+                    }
+                    else if (document.webkitExitFullscreen) {
+                        document.webkitExitFullscreen();
+                    }
+                    else if (document.mozCancelFullScreen) {
+                        document.mozCancelFullScreen();
+                    }
+                    else if (document.msExitFullscreen) {
+                        document.msExitFullscreen();
+                    }
+                    this.log("Exited fullscreen mode");
+                }
+                else {
+                    this.log("Not in fullscreen mode, no need to exit");
+                }
+            }
+            catch (error) {
+                this.error("Error checking fullscreen state:", error);
+            }
+        });
+    }
+    /**
+     * Show a notification that fullscreen mode is disabled
+     */
+    showScreenshotNotification() {
+        return this.safeExecute("showScreenshotNotification", StrategyErrorType.APPLICATION, () => {
+            if (!isBrowser() || !this.mediator)
+                return;
+            // Publish overlay shown event through the mediator
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_SHOWN,
+                source: this.STRATEGY_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.STRATEGY_NAME,
+                    overlayType: "screenshot_notification",
+                    options: {
+                        ...this.options.overlayOptions,
+                        blockEvents: false, // Don't block events, just show a notification
+                        autoRestore: true,
+                    },
+                    priority: 5,
+                    duration: 3000, // Show for 3 seconds
+                },
+            });
+            this.log("Showed screenshot disabled notification");
+        });
+    }
+    /**
+     * Show a notification that fullscreen mode is disabled
+     */
+    showFullscreenNotification() {
+        return this.safeExecute("showFullscreenNotification", StrategyErrorType.APPLICATION, () => {
+            if (!isBrowser() || !this.mediator)
+                return;
+            // Publish overlay shown event through the mediator
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_SHOWN,
+                source: this.STRATEGY_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.STRATEGY_NAME,
+                    overlayType: "fullscreen_notification",
+                    options: {
+                        ...this.options.overlayOptions,
+                        title: "Fullscreen Disabled",
+                        message: this.options.fullscreenMessage || "Fullscreen mode is disabled for security reasons",
+                        blockEvents: false, // Don't block events, just show a notification
+                        autoRestore: true,
+                    },
+                    priority: 5,
+                    duration: 3000, // Show for 3 seconds
+                },
+            });
+            this.log("Showed fullscreen disabled notification");
+        });
+    }
+    /**
+     * Apply screenshot protection
+     */
+    apply() {
+        return this.safeExecute("apply", StrategyErrorType.APPLICATION, () => {
+            if (this.isAppliedFlag) {
+                this.log("Protection already applied");
+                return;
+            }
+            if (isBrowser()) {
+                // Use both keydown and keyup to ensure we catch all PrintScreen events
+                this.registerEvent(document, "keydown", this.keydownHandler, {
+                    capture: true,
+                    priority: 10,
+                });
+                this.registerEvent(document, "keyup", this.keyupHandler, {
+                    capture: true,
+                    priority: 10,
+                });
+                // Add window blur/focus detection
+                this.registerEvent(window, "blur", this.blurHandler, { priority: 10 });
+                this.registerEvent(window, "focus", this.focusHandler, { priority: 10 });
+                // Add visibility change detection
+                this.registerEvent(document, "visibilitychange", this.visibilityHandler, { priority: 10 });
+                // Add print event detection if supported
+                if (isPrintSupported()) {
+                    this.registerEvent(window, "afterprint", this.printHandler, { priority: 10 });
+                }
+                // Add beforeprint event detection if supported
+                if (isBeforePrintSupported()) {
+                    this.registerEvent(window, "beforeprint", this.beforePrintHandler, { priority: 10 });
+                }
+                // Add fullscreen change event listeners if preventing fullscreen
+                if (this.options.preventFullscreen) {
+                    this.registerEvent(document, "fullscreenchange", this.fullscreenChangeHandler, {
+                        priority: 10,
+                    });
+                    this.registerEvent(document, "webkitfullscreenchange", this.fullscreenChangeHandler, {
+                        priority: 10,
+                    });
+                    this.registerEvent(document, "mozfullscreenchange", this.fullscreenChangeHandler, {
+                        priority: 10,
+                    });
+                    this.registerEvent(document, "MSFullscreenChange", this.fullscreenChangeHandler, {
+                        priority: 10,
+                    });
+                    // Use a longer delay to ensure the document is fully active
+                    setTimeout(() => {
+                        // Use setTimeout to ensure the document is ready and active
+                        this.exitFullscreen();
+                    }, 500); // Increased from 0 to 500ms
+                }
+                this.isAppliedFlag = true;
+                this.log("Screenshot protection applied", {
+                    printSupported: isPrintSupported(),
+                    beforePrintSupported: isBeforePrintSupported(),
+                    preventFullscreen: this.options.preventFullscreen,
+                    registeredEvents: this.eventIds.length,
+                });
+            }
+        });
+    }
+    /**
+     * Remove screenshot protection
+     */
+    remove() {
+        return this.safeExecute("remove", StrategyErrorType.REMOVAL, () => {
+            if (!this.isAppliedFlag) {
+                this.log("Protection not applied");
+                return;
+            }
+            if (isBrowser()) {
+                // First attempt - remove by owner using the parent class method
+                this.removeEventsByOwner();
+                // Second attempt - try direct DOM removal as fallback
+                try {
+                    document.removeEventListener("keydown", this.keydownHandler, { capture: true });
+                    document.removeEventListener("keyup", this.keyupHandler, { capture: true });
+                    window.removeEventListener("blur", this.blurHandler);
+                    window.removeEventListener("focus", this.focusHandler);
+                    document.removeEventListener("visibilitychange", this.visibilityHandler);
+                    if (isPrintSupported()) {
+                        window.removeEventListener("afterprint", this.printHandler);
+                    }
+                    if (isBeforePrintSupported()) {
+                        window.removeEventListener("beforeprint", this.beforePrintHandler);
+                    }
+                    if (this.options.preventFullscreen) {
+                        document.removeEventListener("fullscreenchange", this.fullscreenChangeHandler);
+                        document.removeEventListener("webkitfullscreenchange", this.fullscreenChangeHandler);
+                        document.removeEventListener("mozfullscreenchange", this.fullscreenChangeHandler);
+                        document.removeEventListener("MSFullscreenChange", this.fullscreenChangeHandler);
+                    }
+                    this.log("Removed events via direct DOM API");
+                }
+                catch (domError) {
+                    // Ignore errors in direct DOM removal
+                    this.error("Error in fallback DOM removal:", domError);
+                }
+                // Clear any pending timeout using timeoutManager
+                timeoutManager.clearTimeout(`${this.STRATEGY_NAME}-overlay`);
+                // Clear tracked event IDs (parent class method will do this too, but being explicit)
+                this.eventIds = [];
+                this.isAppliedFlag = false;
+                this.log("Screenshot protection removed");
+            }
+        });
+    }
+    /**
+     * Update screenshot options
+     * @param options New screenshot options
+     */
+    updateOptions(options) {
+        return this.safeExecute("updateOptions", StrategyErrorType.OPTION_UPDATE, () => {
+            this.log("Updating options", options);
+            const typedOptions = options;
+            const wasPreventingFullscreen = this.options.preventFullscreen;
+            this.options = {
+                ...this.options,
+                ...typedOptions,
+            };
+            // If fullscreen prevention was toggled, we need to update event listeners
+            if (this.isAppliedFlag && wasPreventingFullscreen !== this.options.preventFullscreen) {
+                if (this.options.preventFullscreen) {
+                    // Add fullscreen event listeners
+                    this.registerEvent(document, "fullscreenchange", this.fullscreenChangeHandler, {
+                        priority: 10,
+                    });
+                    this.registerEvent(document, "webkitfullscreenchange", this.fullscreenChangeHandler, {
+                        priority: 10,
+                    });
+                    this.registerEvent(document, "mozfullscreenchange", this.fullscreenChangeHandler, {
+                        priority: 10,
+                    });
+                    this.registerEvent(document, "MSFullscreenChange", this.fullscreenChangeHandler, {
+                        priority: 10,
+                    });
+                    // Exit fullscreen if already in fullscreen mode
+                    this.exitFullscreen();
+                    this.log("Added fullscreen protection");
+                }
+                else {
+                    // If we're removing fullscreen prevention while protection is active,
+                    // it's safest to remove all event listeners and reapply the ones we still need
+                    const wasApplied = this.isAppliedFlag;
+                    this.remove();
+                    if (wasApplied) {
+                        this.apply();
+                    }
+                    this.log("Removed fullscreen protection and reapplied other protections");
+                }
+            }
+            // Handle categories if present
+            if (options.categories !== undefined && Array.isArray(options.categories)) {
+                this.categories = options.categories;
+                this.log("Updated shortcut categories:", this.categories);
+            }
+            // Update timeoutManager debug mode if our debug mode changed
+            if (options.debugMode !== undefined) {
+                timeoutManager.setDebugMode(!!options.debugMode);
+            }
+        });
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        super.setDebugMode(enabled);
+        // Update timeoutManager debug mode
+        timeoutManager.setDebugMode(enabled);
+    }
+}

package/dist/strategies/SelectionStrategy.d.ts

@@ -0,0 +1,49 @@
+import type { CustomEventHandlers } from "../types";
+import { AbstractStrategy } from "./AbstractStrategy";
+/**
+ * Strategy for preventing text selection
+ */
+export declare class SelectionStrategy extends AbstractStrategy {
+    private targetElement;
+    private styleElement;
+    private selectionHandler;
+    private dragHandler;
+    private customHandler?;
+    private preventDrag;
+    /**
+     * Create a new SelectionStrategy
+     * @param targetElement Element to protect (defaults to document.body)
+     * @param customHandler Optional custom handler for selection attempts
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(targetElement?: HTMLElement | null, customHandler?: CustomEventHandlers["onSelectionAttempt"], debugMode?: boolean);
+    /**
+     * Handle selection event
+     */
+    private handleSelection;
+    /**
+     * Handle drag event
+     */
+    private handleDrag;
+    /**
+     * Inject CSS to prevent selection
+     */
+    private injectSelectionStyles;
+    /**
+     * Remove selection-blocking CSS
+     */
+    private removeSelectionStyles;
+    /**
+     * Apply selection protection
+     */
+    apply(): void;
+    /**
+     * Remove selection protection
+     */
+    remove(): void;
+    /**
+     * Update selection protection options
+     * @param options New options for selection protection
+     */
+    updateOptions(options: Record<string, unknown>): void;
+}