@tindalabs/shield 0.1.0

package/dist/strategies/IFrameStrategy.js

@@ -0,0 +1,255 @@
+import { isBrowser } from "../utils/environment";
+import { intervalManager } from "../utils/intervalManager";
+import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
+import { ProtectionEventType } from "../core/mediator/protection-event";
+/**
+ * Strategy for preventing content from being embedded in external iframes
+ */
+export class FrameEmbeddingProtectionStrategy extends AbstractStrategy {
+    /**
+     * Create a new FrameEmbeddingProtectionStrategy
+     * @param options Configuration options
+     * @param targetElement Element containing sensitive content to protect
+     * @param customHandler Optional custom handler for frame embedding detection
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(options, targetElement = null, customHandler, debugMode = false) {
+        super("FrameEmbeddingProtectionStrategy", debugMode);
+        this.targetElement = null;
+        this.isEmbedded = false;
+        this.isExternalFrame = false;
+        this.intervalId = null;
+        this.taskId = null;
+        this.parentDomain = null;
+        this.options = {
+            showOverlay: true,
+            overlayOptions: {
+                title: "Embedding Not Allowed",
+                message: "This content cannot be displayed in an embedded frame.",
+                secondaryMessage: "Please visit the original website to view this content.",
+                textColor: "white",
+                backgroundColor: "rgba(220, 38, 38, 0.9)", // Red with opacity
+            },
+            hideContent: true,
+            allowedDomains: [],
+            blockAllFrames: false,
+            ...options,
+        };
+        this.targetElement = targetElement;
+        this.customHandler = customHandler;
+        this.log("Initialized with options:", {
+            allowedDomains: this.options.allowedDomains,
+            blockAllFrames: this.options.blockAllFrames,
+        });
+    }
+    /**
+     * Check if the page is embedded in an iframe
+     */
+    checkIfEmbedded() {
+        return (this.safeExecute("checkIfEmbedded", StrategyErrorType.APPLICATION, () => {
+            if (!isBrowser())
+                return false;
+            // Check if the page is in an iframe
+            this.isEmbedded = window.self !== window.top;
+            if (this.isEmbedded) {
+                // Check if it's an external iframe (cross-origin)
+                try {
+                    // If we can access parent.location.hostname, it's same-origin
+                    const parentHostname = window.parent.location.hostname;
+                    const currentHostname = window.location.hostname;
+                    this.parentDomain = parentHostname;
+                    this.isExternalFrame = parentHostname !== currentHostname;
+                    // Check if the parent domain is in the allowed domains list
+                    if (this.isExternalFrame && this.options.allowedDomains && this.options.allowedDomains.length > 0) {
+                        this.isExternalFrame = !this.options.allowedDomains.includes(parentHostname);
+                    }
+                    this.log(`Embedded in iframe. Parent: ${parentHostname}, Current: ${currentHostname}`);
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    // If we can't access parent.location, it's definitely cross-origin
+                    this.isExternalFrame = true;
+                    this.parentDomain = null;
+                    this.log("Embedded in cross-origin iframe (security exception)");
+                }
+                // If blockAllFrames is true, treat all frames as external
+                if (this.options.blockAllFrames) {
+                    this.isExternalFrame = true;
+                    this.log("Blocking all frames regardless of origin");
+                }
+            }
+            return this.isEmbedded && this.isExternalFrame;
+        }) || false);
+    }
+    /**
+     * Publish frame embedding detection event
+     */
+    publishFrameEmbeddingEvent() {
+        return this.safeExecute("publishFrameEmbeddingEvent", StrategyErrorType.APPLICATION, () => {
+            if (!isBrowser() || !this.mediator)
+                return;
+            // Publish frame embedding detected event
+            this.mediator.publish({
+                type: ProtectionEventType.FRAME_EMBEDDING_DETECTED,
+                source: this.STRATEGY_NAME,
+                timestamp: Date.now(),
+                data: {
+                    isEmbedded: this.isEmbedded,
+                    isExternalFrame: this.isExternalFrame,
+                    parentDomain: this.parentDomain || undefined,
+                    targetElement: this.targetElement,
+                    showOverlay: this.options.showOverlay,
+                    hideContent: this.options.hideContent,
+                    overlayOptions: this.options.overlayOptions,
+                },
+            });
+            this.log("Published FRAME_EMBEDDING_DETECTED event");
+            // Call custom handler if provided
+            if (this.customHandler) {
+                this.customHandler(this.isEmbedded, this.isExternalFrame);
+            }
+        });
+    }
+    /**
+     * Apply the protection strategy
+     */
+    apply() {
+        return this.safeExecute("apply", StrategyErrorType.APPLICATION, () => {
+            if (this.isAppliedFlag) {
+                this.log("Protection already applied");
+                return;
+            }
+            // Check if embedded in an external iframe
+            const isExternallyEmbedded = this.checkIfEmbedded();
+            if (isExternallyEmbedded) {
+                this.publishFrameEmbeddingEvent();
+            }
+            // Register with IntervalManager for periodic checks
+            try {
+                this.taskId = intervalManager.registerTask("iframe-protection", () => this.safeExecute("intervalTask", StrategyErrorType.APPLICATION, () => {
+                    const currentlyEmbedded = this.checkIfEmbedded();
+                    if (currentlyEmbedded) {
+                        // Publish event to check if we need to apply protection
+                        this.publishFrameEmbeddingEvent();
+                    }
+                }), 2000);
+                if (!this.taskId) {
+                    this.handleError(StrategyErrorType.APPLICATION, "Failed to register interval task", new Error("Task registration returned empty ID"));
+                }
+            }
+            catch (intervalError) {
+                this.handleError(StrategyErrorType.APPLICATION, "Error registering interval task", intervalError);
+                // Try to use a fallback interval method if IntervalManager fails
+                this.intervalId = window.setInterval(() => {
+                    this.safeExecute("fallbackInterval", StrategyErrorType.APPLICATION, () => {
+                        const currentlyEmbedded = this.checkIfEmbedded();
+                        if (currentlyEmbedded) {
+                            this.publishFrameEmbeddingEvent();
+                        }
+                    });
+                }, 2000);
+                this.log("Using fallback interval method after IntervalManager failure");
+            }
+            this.isAppliedFlag = true;
+            this.log("Protection applied");
+        });
+    }
+    /**
+     * Remove the protection strategy
+     */
+    remove() {
+        return this.safeExecute("remove", StrategyErrorType.REMOVAL, () => {
+            if (!this.isAppliedFlag) {
+                this.log("Protection not applied");
+                return;
+            }
+            // 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) {
+                window.clearInterval(this.intervalId);
+                this.intervalId = null;
+                this.log("Legacy interval cleared");
+            }
+            // Call parent class remove method to handle event cleanup
+            super.remove();
+            // Publish STRATEGY_REMOVED event
+            if (this.mediator) {
+                this.mediator.publish({
+                    type: ProtectionEventType.STRATEGY_REMOVED,
+                    source: this.STRATEGY_NAME,
+                    timestamp: Date.now(),
+                    data: {
+                        strategyName: this.STRATEGY_NAME,
+                        reason: "strategy_removed",
+                    },
+                });
+            }
+            // Remove meta tags if we added them
+            if (isBrowser()) {
+                const xfoMeta = document.querySelector('meta[http-equiv="X-Frame-Options"]');
+                if (xfoMeta && xfoMeta.parentNode) {
+                    xfoMeta.parentNode.removeChild(xfoMeta);
+                }
+                const cspMeta = document.querySelector('meta[http-equiv="Content-Security-Policy"]');
+                if (cspMeta && cspMeta.parentNode) {
+                    cspMeta.parentNode.removeChild(cspMeta);
+                }
+                this.log("Removed meta tags");
+            }
+            // Always reset state
+            this.isAppliedFlag = false;
+            this.isEmbedded = false;
+            this.isExternalFrame = false;
+            this.parentDomain = null;
+            this.log("Protection removed");
+        });
+    }
+    /**
+     * Update strategy options
+     * @param options Options to update
+     */
+    updateOptions(options) {
+        return this.safeExecute("updateOptions", StrategyErrorType.OPTION_UPDATE, () => {
+            if (!options) {
+                this.handleError(StrategyErrorType.OPTION_UPDATE, "Invalid options in updateOptions", new Error("Options is null or undefined"));
+                return;
+            }
+            const typedOptions = options;
+            this.log("Updating options", typedOptions);
+            // Store previous options for comparison
+            const previousOptions = { ...this.options };
+            this.options = {
+                ...this.options,
+                ...typedOptions,
+            };
+            // Check if any critical options changed that would require reapplying protection
+            const criticalOptionsChanged = previousOptions.blockAllFrames !== this.options.blockAllFrames ||
+                JSON.stringify(previousOptions.allowedDomains) !== JSON.stringify(this.options.allowedDomains);
+            if (this.isAppliedFlag &&
+                (criticalOptionsChanged ||
+                    typedOptions.overlayOptions?.title ||
+                    typedOptions.overlayOptions?.message ||
+                    typedOptions.overlayOptions?.backgroundColor)) {
+                // Re-check if we're embedded and update protection if needed
+                const isExternallyEmbedded = this.checkIfEmbedded();
+                if (isExternallyEmbedded) {
+                    // Publish updated event
+                    this.publishFrameEmbeddingEvent();
+                    this.log("Reapplied frame protection with updated options");
+                }
+            }
+        });
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        super.setDebugMode(enabled);
+    }
+}

package/dist/strategies/KeyboardStrategy.d.ts

@@ -0,0 +1,35 @@
+import type { CustomEventHandlers } from "../types";
+import { AbstractStrategy } from "./AbstractStrategy";
+/**
+ * Strategy for preventing keyboard shortcuts
+ */
+export declare class KeyboardStrategy extends AbstractStrategy {
+    private handler;
+    private customHandler?;
+    private eventId;
+    private shortcutManager;
+    private categories;
+    /**
+     * Create a new KeyboardStrategy
+     * @param customHandler Optional custom handler for blocked keyboard shortcuts
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(customHandler?: CustomEventHandlers["onKeyboardShortcutBlocked"], debugMode?: boolean);
+    /**
+     * Handle keydown events
+     */
+    private handleKeyDown;
+    /**
+     * Apply keyboard protection
+     */
+    apply(): void;
+    /**
+     * Remove keyboard protection
+     */
+    remove(): void;
+    /**
+     * Update strategy options
+     * @param options Options to update
+     */
+    updateOptions(options: Record<string, unknown>): void;
+}

package/dist/strategies/KeyboardStrategy.js

@@ -0,0 +1,130 @@
+import { isBrowser } from "../utils/environment";
+import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
+import { eventManager } from "../utils/eventManager";
+import { KeyboardShortcutManager } from "../utils/keyboardShortcutManager/keyboardShortcutManager";
+import { ShortcutCategory } from "../utils/keyboardShortcutManager/keyboardShortcuts";
+/**
+ * Strategy for preventing keyboard shortcuts
+ */
+export class KeyboardStrategy extends AbstractStrategy {
+    /**
+     * Create a new KeyboardStrategy
+     * @param customHandler Optional custom handler for blocked keyboard shortcuts
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(customHandler, debugMode = false) {
+        super("KeyboardStrategy", debugMode);
+        this.eventId = "";
+        this.categories = [
+            ShortcutCategory.COPY,
+            ShortcutCategory.SAVE,
+            ShortcutCategory.PRINT,
+            ShortcutCategory.VIEW_SOURCE,
+            ShortcutCategory.DEVTOOLS,
+        ];
+        this.customHandler = customHandler;
+        this.handler = this.handleKeyDown.bind(this);
+        this.shortcutManager = KeyboardShortcutManager.getInstance();
+        this.log("Initialized with shortcut categories:", this.categories);
+    }
+    /**
+     * Handle keydown events
+     */
+    handleKeyDown(e) {
+        return this.safeExecute("handleKeyDown", StrategyErrorType.EVENT_HANDLING, () => {
+            // Cast to KeyboardEvent
+            const keyEvent = e;
+            // Use the shortcut manager to detect shortcuts
+            const shortcut = this.shortcutManager.matchesShortcut(keyEvent, this.categories);
+            if (shortcut) {
+                // Prevent the default action
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                this.log(`Blocked keyboard shortcut: ${shortcut.id} (${this.shortcutManager.getShortcutDescription(shortcut)})`);
+                // Call custom handler if provided
+                if (this.customHandler) {
+                    this.customHandler(keyEvent);
+                }
+                return false;
+            }
+            return undefined;
+        });
+    }
+    /**
+     * Apply keyboard protection
+     */
+    apply() {
+        return this.safeExecute("apply", StrategyErrorType.APPLICATION, () => {
+            if (this.isAppliedFlag) {
+                this.log("Protection already applied");
+                return;
+            }
+            if (isBrowser()) {
+                // Register the keydown event using our registerEvent method from AbstractStrategy
+                this.eventId = this.registerEvent(document, "keydown", this.handler, {
+                    capture: true,
+                    priority: 10, // High priority to ensure it runs before other handlers
+                });
+                this.isAppliedFlag = true;
+                this.log("Keyboard protection applied", {
+                    hasCustomHandler: !!this.customHandler,
+                    eventId: this.eventId,
+                });
+            }
+            else {
+                this.log("Browser environment not available, protection not applied");
+            }
+        });
+    }
+    /**
+     * Remove keyboard protection
+     */
+    remove() {
+        return this.safeExecute("remove", StrategyErrorType.REMOVAL, () => {
+            if (!this.isAppliedFlag) {
+                this.log("Protection not applied");
+                return;
+            }
+            if (isBrowser()) {
+                // Try multiple removal strategies for robustness
+                // 1. Try removing by specific event ID if we have it
+                if (this.eventId) {
+                    const removed = eventManager.removeEventListener(document, this.eventId);
+                    this.log(`Removed event by ID ${this.eventId}: ${removed}`);
+                }
+                // 2. Remove all events for this owner using the parent class method
+                this.removeEventsByOwner();
+                // 3. Try direct DOM removal as a last resort
+                try {
+                    document.removeEventListener("keydown", this.handler, { capture: true });
+                    this.log("Removed event via direct DOM API");
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (domError) {
+                    // Ignore errors in direct DOM removal
+                }
+                this.eventId = "";
+                this.isAppliedFlag = false;
+                this.log("Keyboard protection removed");
+            }
+        });
+    }
+    /**
+     * Update strategy options
+     * @param options Options to update
+     */
+    updateOptions(options) {
+        return this.safeExecute("updateOptions", StrategyErrorType.OPTION_UPDATE, () => {
+            this.log("Updating options", options);
+            // Handle debug mode if present
+            if (options.debugMode !== undefined) {
+                this.setDebugMode(!!options.debugMode);
+            }
+            // Handle categories if present
+            if (options.categories !== undefined && Array.isArray(options.categories)) {
+                this.categories = options.categories;
+                this.log("Updated shortcut categories:", this.categories);
+            }
+        });
+    }
+}

package/dist/strategies/PrintStrategy.d.ts

@@ -0,0 +1,47 @@
+import type { CustomEventHandlers } from "../types";
+import { AbstractStrategy } from "./AbstractStrategy";
+/**
+ * Strategy for preventing printing
+ */
+export declare class PrintStrategy extends AbstractStrategy {
+    private beforePrintHandler;
+    private afterPrintHandler;
+    private styleElement;
+    private customHandler?;
+    /**
+     * Create a new PrintStrategy
+     * @param customHandler Optional custom handler for print attempts
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(customHandler?: CustomEventHandlers["onPrintAttempt"], debugMode?: boolean);
+    /**
+     * Handle beforeprint event
+     */
+    private handleBeforePrint;
+    /**
+     * Handle afterprint event
+     */
+    private handleAfterPrint;
+    /**
+     * Create and inject print-blocking CSS
+     */
+    private injectPrintStyles;
+    /**
+     * Remove print-blocking CSS
+     */
+    private removePrintStyles;
+    /**
+     * Apply print protection
+     */
+    apply(): void;
+    /**
+     * Remove print protection
+     * Override the base implementation to handle additional cleanup
+     */
+    remove(): void;
+    /**
+     * Update strategy options
+     * @param options Options to update
+     */
+    updateOptions(options: Record<string, unknown>): void;
+}

package/dist/strategies/PrintStrategy.js

@@ -0,0 +1,201 @@
+import { isBrowser, isPrintSupported, isBeforePrintSupported } from "../utils/environment";
+import { AbstractStrategy, StrategyErrorType } from "./AbstractStrategy";
+/**
+ * Strategy for preventing printing
+ */
+export class PrintStrategy extends AbstractStrategy {
+    /**
+     * Create a new PrintStrategy
+     * @param customHandler Optional custom handler for print attempts
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(customHandler, debugMode = false) {
+        super("PrintStrategy", debugMode);
+        this.styleElement = null;
+        this.customHandler = customHandler;
+        this.beforePrintHandler = this.handleBeforePrint.bind(this);
+        this.afterPrintHandler = this.handleAfterPrint.bind(this);
+        this.log("Initialized with print support:", {
+            printSupported: isPrintSupported(),
+            beforePrintSupported: isBeforePrintSupported(),
+        });
+    }
+    /**
+     * Handle beforeprint event
+     */
+    handleBeforePrint(e) {
+        return this.safeExecute("handleBeforePrint", StrategyErrorType.EVENT_HANDLING, () => {
+            this.log("Print attempt detected");
+            if (this.customHandler) {
+                this.customHandler(e);
+            }
+            // Stop printing
+            setTimeout(() => {
+                if (isBrowser()) {
+                    window.stop();
+                    this.log("Print operation stopped");
+                }
+            }, 0);
+        });
+    }
+    /**
+     * Handle afterprint event
+     */
+    handleAfterPrint(_e) {
+        return this.safeExecute("handleAfterPrint", StrategyErrorType.EVENT_HANDLING, () => {
+            this.log("Print operation completed or was cancelled");
+            // Cleanup if needed
+        });
+    }
+    /**
+     * Create and inject print-blocking CSS
+     */
+    injectPrintStyles() {
+        return this.safeExecute("injectPrintStyles", StrategyErrorType.APPLICATION, () => {
+            if (!isBrowser())
+                return;
+            this.styleElement = document.createElement("style");
+            this.styleElement.setAttribute("type", "text/css");
+            this.styleElement.setAttribute("data-content-security", "print-blocker");
+            const css = `
+        @media print {
+          body * {
+            display: none !important;
+          }
+          body:after {
+            content: "Printing is disabled for this content";
+            display: block !important;
+            font-size: 24px;
+            text-align: center;
+            margin: 100px auto;
+          }
+        }
+      `;
+            this.styleElement.textContent = css;
+            document.head.appendChild(this.styleElement);
+            this.log("Print-blocking CSS injected");
+        });
+    }
+    /**
+     * Remove print-blocking CSS
+     */
+    removePrintStyles() {
+        return this.safeExecute("removePrintStyles", StrategyErrorType.REMOVAL, () => {
+            if (!this.styleElement || !isBrowser())
+                return;
+            // First try to remove by reference
+            if (this.styleElement.parentNode) {
+                this.styleElement.parentNode.removeChild(this.styleElement);
+                this.styleElement = null;
+                this.log("Print-blocking CSS removed");
+            }
+            else {
+                // If reference is stale, try to find by attribute
+                const styles = document.querySelectorAll('style[data-content-security="print-blocker"]');
+                styles.forEach((style) => {
+                    if (style.parentNode) {
+                        style.parentNode.removeChild(style);
+                    }
+                });
+                this.styleElement = null;
+                if (styles.length > 0) {
+                    this.log(`Removed ${styles.length} print-blocking styles by selector`);
+                }
+            }
+        });
+    }
+    /**
+     * Apply print protection
+     */
+    apply() {
+        return this.safeExecute("apply", StrategyErrorType.APPLICATION, () => {
+            if (this.isAppliedFlag) {
+                this.log("Protection already applied");
+                return;
+            }
+            this.log("Applying print protection", {
+                hasCustomHandler: !!this.customHandler,
+                printSupported: isPrintSupported(),
+                beforePrintSupported: isBeforePrintSupported(),
+            });
+            if (isBrowser()) {
+                // Only add event listeners if the events are supported
+                if (isPrintSupported()) {
+                    // Use the registerEvent method from AbstractStrategy
+                    const afterPrintId = this.registerEvent(window, "afterprint", this.afterPrintHandler, { priority: 10 });
+                    if (afterPrintId) {
+                        this.log(`Registered afterprint event with ID ${afterPrintId}`);
+                    }
+                }
+                if (isBeforePrintSupported()) {
+                    // Use the registerEvent method from AbstractStrategy
+                    const beforePrintId = this.registerEvent(window, "beforeprint", this.beforePrintHandler, { priority: 10 });
+                    if (beforePrintId) {
+                        this.log(`Registered beforeprint event with ID ${beforePrintId}`);
+                    }
+                }
+                this.injectPrintStyles();
+                this.isAppliedFlag = true;
+                this.log(`Protection applied with ${this.eventIds.length} event handlers`);
+            }
+        });
+    }
+    /**
+     * Remove print protection
+     * Override the base implementation to handle additional cleanup
+     */
+    remove() {
+        return this.safeExecute("remove", StrategyErrorType.REMOVAL, () => {
+            if (!this.isAppliedFlag) {
+                this.log("Protection not applied");
+                return;
+            }
+            if (isBrowser()) {
+                // Remove all events for this owner using the parent class method
+                this.removeEventsByOwner();
+                // Try direct DOM removal as a fallback
+                try {
+                    if (isPrintSupported()) {
+                        window.removeEventListener("afterprint", this.afterPrintHandler);
+                    }
+                    if (isBeforePrintSupported()) {
+                        window.removeEventListener("beforeprint", this.beforePrintHandler);
+                    }
+                    this.log("Removed events via direct DOM API");
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    // Ignore errors in direct DOM removal
+                }
+                // Remove print styles
+                this.removePrintStyles();
+                // Clear the event IDs array (parent class method will do this too, but being explicit)
+                this.eventIds = [];
+                this.isAppliedFlag = false;
+                this.log("Print protection removed");
+            }
+        });
+    }
+    /**
+     * Update strategy options
+     * @param options Options to update
+     */
+    updateOptions(options) {
+        return this.safeExecute("updateOptions", StrategyErrorType.OPTION_UPDATE, () => {
+            this.log("Updating options", options);
+            // Handle debug mode if present
+            if (options.debugMode !== undefined) {
+                this.setDebugMode(!!options.debugMode);
+            }
+            // Handle blockMessage if present
+            if (options.blockMessage && typeof options.blockMessage === "string") {
+                // If we're already applied, we need to update the CSS
+                if (this.isAppliedFlag) {
+                    this.removePrintStyles();
+                    this.injectPrintStyles();
+                    this.log("Updated print styles with new message");
+                }
+            }
+        });
+    }
+}