content-security-toolkit 1.0.0

package/dist/core/mediator/handlers/abstractEventHandler.js

@@ -0,0 +1,106 @@
+import { SimpleLoggingService } from "../../../utils/logging/simple/SimpleLoggingService";
+/**
+ * Abstract base class for all event handlers
+ */
+export class AbstractEventHandler {
+    /**
+     * Create a new event handler
+     * @param mediator The protection mediator
+     * @param componentName The name of the component
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator, componentName, debugMode = false) {
+        this.subscriptionIds = [];
+        this.mediator = mediator;
+        this.COMPONENT_NAME = componentName;
+        this.debugMode = debugMode;
+        // Create a logger instance for this component
+        this.logger = new SimpleLoggingService(componentName, debugMode);
+        this.initialize();
+        if (this.debugMode) {
+            this.log("Initialized and subscribed to events");
+        }
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+        this.logger.setDebugMode(enabled);
+        if (this.debugMode) {
+            this.log(`Debug mode ${enabled ? "enabled" : "disabled"}`);
+        }
+    }
+    /**
+     * Subscribe to an event and track the subscription ID
+     * @param eventType The event type to subscribe to
+     * @param handler The event handler function
+     * @param options Optional subscription options
+     * @returns The subscription ID
+     */
+    subscribe(eventType, handler, options) {
+        const subId = this.mediator.subscribe(eventType, handler, {
+            ...options,
+            context: options?.context || this.COMPONENT_NAME,
+        });
+        this.subscriptionIds.push(subId);
+        if (this.debugMode) {
+            this.log(`Subscribed to ${eventType} with ID ${subId}`);
+        }
+        return subId;
+    }
+    /**
+     * Log a debug message if debug mode is enabled
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(message, ...args) {
+        if (this.debugMode) {
+            this.logger.log(message, ...args);
+        }
+    }
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    warn(message, ...args) {
+        if (this.debugMode) {
+            this.logger.warn(message, ...args);
+        }
+        else {
+            // In non-debug mode, only log the message without args for brevity
+            console.warn(`${this.COMPONENT_NAME}: ${message}`);
+        }
+    }
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message, ...args) {
+        this.logger.error(message, ...args);
+    }
+    /**
+     * Unsubscribe from all events and clean up
+     */
+    dispose() {
+        if (this.debugMode) {
+            this.log(`Disposing handler, unsubscribing from ${this.subscriptionIds.length} events`);
+        }
+        // Unsubscribe from all events
+        for (const id of this.subscriptionIds) {
+            this.mediator.unsubscribe(id);
+        }
+        this.subscriptionIds = [];
+        this.onDispose();
+    }
+    /**
+     * Additional cleanup to be performed on disposal
+     * This method can be overridden by subclasses
+     */
+    onDispose() {
+        // Default implementation does nothing
+    }
+}

package/dist/core/mediator/handlers/baseEventHandler.d.ts

@@ -0,0 +1,65 @@
+import type { ProtectionMediator } from "../../mediator/types";
+import type { ProtectionEvent, ProtectionEventType } from "../../mediator/protection-event";
+/**
+ * Abstract base class for all event handlers
+ */
+export declare abstract class BaseEventHandler {
+    protected mediator: ProtectionMediator;
+    protected readonly COMPONENT_NAME: string;
+    protected debugMode: boolean;
+    protected subscriptionIds: string[];
+    /**
+     * Create a new event handler
+     * @param mediator The protection mediator
+     * @param componentName The name of the component
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator: ProtectionMediator, componentName: string, debugMode?: boolean);
+    /**
+     * Initialize the handler and subscribe to events
+     * This method should be implemented by subclasses
+     */
+    protected abstract initialize(): void;
+    /**
+     * Log a debug message
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    protected log(message: string, ...args: unknown[]): void;
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    protected warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    protected error(message: string, ...args: unknown[]): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Subscribe to an event and track the subscription ID
+     * @param eventType The event type to subscribe to
+     * @param handler The event handler function
+     * @param options Optional subscription options
+     * @returns The subscription ID
+     */
+    protected subscribe(eventType: ProtectionEventType, handler: (event: ProtectionEvent) => void, options?: {
+        context?: string;
+    }): string;
+    /**
+     * Unsubscribe from all events and clean up
+     */
+    dispose(): void;
+    /**
+     * Additional cleanup to be performed on disposal
+     * This method can be overridden by subclasses
+     */
+    protected onDispose(): void;
+}

package/dist/core/mediator/handlers/baseEventHandler.js

@@ -0,0 +1,99 @@
+/**
+ * Abstract base class for all event handlers
+ */
+export class BaseEventHandler {
+    /**
+     * Create a new event handler
+     * @param mediator The protection mediator
+     * @param componentName The name of the component
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator, componentName, debugMode = false) {
+        this.subscriptionIds = [];
+        this.mediator = mediator;
+        this.COMPONENT_NAME = componentName;
+        this.debugMode = debugMode;
+        this.initialize();
+        if (this.debugMode) {
+            this.log("Initialized and subscribed to events");
+        }
+    }
+    /**
+     * Log a debug message
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(message, ...args) {
+        if (this.debugMode) {
+            console.log(`${this.COMPONENT_NAME}: ${message}`, ...args);
+        }
+    }
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    warn(message, ...args) {
+        if (this.debugMode) {
+            console.warn(`${this.COMPONENT_NAME}: ${message}`, ...args);
+        }
+        else {
+            // In non-debug mode, only log the message without args for brevity
+            console.warn(`${this.COMPONENT_NAME}: ${message}`);
+        }
+    }
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message, ...args) {
+        console.error(`${this.COMPONENT_NAME}: ${message}`, ...args);
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+        if (this.debugMode) {
+            this.log(`Debug mode ${enabled ? "enabled" : "disabled"}`);
+        }
+    }
+    /**
+     * Subscribe to an event and track the subscription ID
+     * @param eventType The event type to subscribe to
+     * @param handler The event handler function
+     * @param options Optional subscription options
+     * @returns The subscription ID
+     */
+    subscribe(eventType, handler, options) {
+        const subId = this.mediator.subscribe(eventType, handler, { ...options, context: options?.context || this.COMPONENT_NAME });
+        this.subscriptionIds.push(subId);
+        if (this.debugMode) {
+            this.log(`Subscribed to ${eventType} with ID ${subId}`);
+        }
+        return subId;
+    }
+    /**
+     * Unsubscribe from all events and clean up
+     */
+    dispose() {
+        if (this.debugMode) {
+            this.log(`Disposing handler, unsubscribing from ${this.subscriptionIds.length} events`);
+        }
+        // Unsubscribe from all events
+        for (const id of this.subscriptionIds) {
+            this.mediator.unsubscribe(id);
+        }
+        this.subscriptionIds = [];
+        this.onDispose();
+    }
+    /**
+     * Additional cleanup to be performed on disposal
+     * This method can be overridden by subclasses
+     */
+    onDispose() {
+        // Default implementation does nothing
+    }
+}

package/dist/core/mediator/handlers/devToolsEventHandler.d.ts

@@ -0,0 +1,9 @@
+import type { ProtectionMediator } from "../types";
+import { AbstractEventHandler } from "./abstractEventHandler";
+export declare class DevToolsEventHandler extends AbstractEventHandler {
+    constructor(mediator: ProtectionMediator, debugMode?: boolean);
+    protected initialize(): void;
+    private handleDevToolsStateChange;
+    private handleDevToolsOpened;
+    private handleDevToolsClosed;
+}

package/dist/core/mediator/handlers/devToolsEventHandler.js

@@ -0,0 +1,95 @@
+import { ProtectionEventType } from "../protection-event";
+import { isEventType } from "../eventDataTypes";
+import { AbstractEventHandler } from "./abstractEventHandler";
+export class DevToolsEventHandler extends AbstractEventHandler {
+    constructor(mediator, debugMode = false) {
+        super(mediator, "DevToolsEventHandler", debugMode);
+    }
+    initialize() {
+        this.subscribe(ProtectionEventType.DEVTOOLS_STATE_CHANGE, this.handleDevToolsStateChange.bind(this));
+    }
+    handleDevToolsStateChange(event) {
+        // Use type guard for type-safe access
+        if (!isEventType(event, ProtectionEventType.DEVTOOLS_STATE_CHANGE)) {
+            this.error("Received invalid event type");
+            return;
+        }
+        this.log(`Handling DevTools state change, isOpen=${event.data.isOpen}`);
+        if (event.data.isOpen) {
+            this.handleDevToolsOpened(event);
+        }
+        else {
+            this.handleDevToolsClosed(event);
+        }
+    }
+    handleDevToolsOpened(event) {
+        const { data } = event;
+        // Show overlay if showOverlay is enabled (defaults to true)
+        if (data.showOverlay !== false) {
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_SHOWN,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    overlayType: "devtools",
+                    options: {
+                        ...data.overlayOptions,
+                        blockEvents: true,
+                        autoRestore: true,
+                    },
+                    priority: 10,
+                },
+            });
+        }
+        // Only hide content if hideContent option is explicitly enabled
+        if (data.hideContent === true) {
+            this.mediator.publish({
+                type: ProtectionEventType.CONTENT_HIDDEN,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    reason: "devtools_opened",
+                    options: {
+                        title: data.overlayOptions?.title,
+                        message: data.overlayOptions?.message,
+                        secondaryMessage: data.overlayOptions?.secondaryMessage,
+                        textColor: 'black',
+                        backgroundColor: data.overlayOptions?.backgroundColor,
+                    },
+                    targetElement: data.target,
+                    priority: 10,
+                },
+            });
+        }
+    }
+    handleDevToolsClosed(event) {
+        const { data } = event;
+        // Remove overlay if showOverlay was enabled
+        if (data.showOverlay !== false) {
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_REMOVED,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    overlayType: "devtools",
+                    reason: "devtools_closed",
+                },
+            });
+        }
+        // Only restore content if hideContent was explicitly enabled
+        if (data.hideContent === true) {
+            this.mediator.publish({
+                type: ProtectionEventType.CONTENT_RESTORED,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    targetElement: data.target,
+                },
+            });
+        }
+    }
+}

package/dist/core/mediator/handlers/eventHandlerRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { ProtectionMediator } from "../types";
+export declare class HandlerRegistry {
+    private handlers;
+    private mediator;
+    private debugMode;
+    constructor(mediator: ProtectionMediator, debugMode?: boolean);
+    private initializeHandlers;
+    setDebugMode(enabled: boolean): void;
+}

package/dist/core/mediator/handlers/eventHandlerRegistry.js

@@ -0,0 +1,34 @@
+import { DevToolsEventHandler } from "./devToolsEventHandler";
+import { BrowserExtensionEventHandler } from "./extensionEventHandlers";
+import { FrameEmbeddingEventHandler } from "./iFrameEventHandlers";
+import { ScreenshotEventHandler } from "./screenShotEventHandlers";
+export class HandlerRegistry {
+    constructor(mediator, debugMode = false) {
+        this.handlers = {};
+        this.mediator = mediator;
+        this.debugMode = debugMode;
+        this.initializeHandlers();
+    }
+    initializeHandlers() {
+        // Initialize all handlers
+        this.handlers.devTools = new DevToolsEventHandler(this.mediator, this.debugMode);
+        this.handlers.extension = new BrowserExtensionEventHandler(this.mediator, this.debugMode);
+        this.handlers.screenshot = new ScreenshotEventHandler(this.mediator, this.debugMode);
+        this.handlers.iFrame = new FrameEmbeddingEventHandler(this.mediator, this.debugMode);
+        // Add more handlers as you implement them
+        // this.handlers.screenshot = new ScreenshotEventHandler(this.mediator, this.debugMode);
+        // this.handlers.frameEmbedding = new FrameEmbeddingEventHandler(this.mediator, this.debugMode);
+        if (this.debugMode) {
+            console.log("HandlerRegistry: Initialized all event handlers");
+        }
+    }
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+        // Update debug mode for all handlers
+        Object.values(this.handlers).forEach(handler => {
+            if (typeof handler.setDebugMode === 'function') {
+                handler.setDebugMode(enabled);
+            }
+        });
+    }
+}

package/dist/core/mediator/handlers/extensionEventHandlers.d.ts

@@ -0,0 +1,40 @@
+import type { ProtectionMediator } from "../types";
+import { ProtectionEvent, ProtectionEventType } from "../protection-event";
+import { TypedProtectionEvent } from "../eventDataTypes";
+import { AbstractEventHandler } from "./abstractEventHandler";
+type ExtensionDetectedEvent = TypedProtectionEvent<typeof ProtectionEventType.EXTENSION_DETECTED>;
+/**
+ * Handler for browser extension detection events
+ */
+export declare class BrowserExtensionEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new BrowserExtensionEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator: ProtectionMediator, debugMode?: boolean);
+    /**
+     * Initialize the handler and subscribe to events
+     */
+    protected initialize(): void;
+    /**
+     * Handle extension detection
+     * @param event the ProtectionEvent
+     */
+    handleExtensionDetected(event: ProtectionEvent): void;
+    /**
+     * Handle extension detection
+     * @param event the typed ExtensionDetectedEvent
+     */
+    applyExtensionProtection(event: ExtensionDetectedEvent): void;
+    /**
+     * Remove extension protection
+     * @param event The typed ExtensionDetectedEvent
+     */
+    removeExtensionProtection(event: ExtensionDetectedEvent): void;
+    /**
+     * Additional cleanup to be performed on disposal
+     */
+    protected onDispose(): void;
+}
+export {};

package/dist/core/mediator/handlers/extensionEventHandlers.js

@@ -0,0 +1,140 @@
+import { ProtectionEventType } from "../protection-event";
+import { isEventType } from "../eventDataTypes";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for browser extension detection events
+ */
+export class BrowserExtensionEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new BrowserExtensionEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator, debugMode = false) {
+        super(mediator, "BrowserExtensionEventHandler", debugMode);
+    }
+    /**
+     * Initialize the handler and subscribe to events
+     */
+    initialize() {
+        this.subscribe(ProtectionEventType.EXTENSION_DETECTED, this.handleExtensionDetected.bind(this));
+    }
+    /**
+     * Handle extension detection
+     * @param event the ProtectionEvent
+     */
+    handleExtensionDetected(event) {
+        // Use type guard for type-safe access
+        if (!isEventType(event, ProtectionEventType.EXTENSION_DETECTED)) {
+            this.error("Received invalid event type");
+            return;
+        }
+        const { data } = event;
+        this.log(`Handling extension detection state change, name=${data.extension?.name || "unknown"}`);
+        if (data.extension) {
+            this.applyExtensionProtection(event);
+            this.log("Blocking interface due to extension detection");
+        }
+        else {
+            this.removeExtensionProtection(event);
+            this.log("Unlocking interface after extension removal");
+        }
+    }
+    /**
+     * Handle extension detection
+     * @param event the typed ExtensionDetectedEvent
+     */
+    applyExtensionProtection(event) {
+        const { data } = event;
+        if (data.hideContent) {
+            this.mediator.publish({
+                type: ProtectionEventType.CONTENT_HIDDEN,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    reason: "extension_detected",
+                    targetElement: data.target,
+                    options: {
+                        title: data.overlayOptions?.title,
+                        message: data.overlayOptions?.message,
+                        secondaryMessage: `"${data.extension?.name}" triggered this warning`,
+                        textColor: "black",
+                        backgroundColor: "rgba(0, 0, 0, 0.05)",
+                    },
+                    priority: 8,
+                },
+            });
+        }
+        if (data.showOverlay) {
+            const extensionConfig = data.extension;
+            const additionalContent = `
+        <p style="font-size: 18px; margin-top: 20px;">Detected: ${extensionConfig.name}</p>
+        <p style="font-size: 14px; margin-top: 10px;">Risk Level: ${extensionConfig.risk.toUpperCase()}</p>
+        <button id="extension-protection-close" style="margin-top: 20px; padding: 10px 20px; background-color: white; color: black; border: none; border-radius: 4px; cursor: pointer; pointer-events: auto;">
+          I've Disabled the Extension
+        </button>
+      `;
+            setTimeout(() => {
+                const closeButton = document.getElementById("extension-protection-close");
+                if (closeButton) {
+                    closeButton.addEventListener("click", () => {
+                        window.location.reload();
+                    });
+                }
+            }, 0);
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_SHOWN,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    overlayType: "extension",
+                    options: {
+                        ...data.overlayOptions,
+                        blockEvents: true,
+                        autoRestore: true,
+                        additionalContent,
+                    },
+                    priority: 8,
+                },
+            });
+        }
+    }
+    /**
+     * Remove extension protection
+     * @param event The typed ExtensionDetectedEvent
+     */
+    removeExtensionProtection(event) {
+        const { data } = event;
+        if (data.hideContent) {
+            this.mediator.publish({
+                type: ProtectionEventType.CONTENT_RESTORED,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    targetElement: data.target,
+                },
+            });
+        }
+        if (data.showOverlay) {
+            this.mediator.publish({
+                type: ProtectionEventType.OVERLAY_REMOVED,
+                source: this.COMPONENT_NAME,
+                timestamp: Date.now(),
+                data: {
+                    strategyName: this.COMPONENT_NAME,
+                    overlayType: "extension",
+                    reason: "extension_removed",
+                },
+            });
+        }
+    }
+    /**
+     * Additional cleanup to be performed on disposal
+     */
+    onDispose() {
+        // No additional cleanup needed for this handler
+    }
+}

package/dist/core/mediator/handlers/iFrameEventHandlers.d.ts

@@ -0,0 +1,27 @@
+import type { ProtectionMediator } from "../../mediator/types";
+import { type ProtectionEvent } from "../../mediator/protection-event";
+import { AbstractEventHandler } from "./abstractEventHandler";
+/**
+ * Handler for frame embedding events
+ */
+export declare class FrameEmbeddingEventHandler extends AbstractEventHandler {
+    /**
+     * Create a new FrameEmbeddingEventHandler
+     * @param mediator The protection mediator
+     * @param debugMode Enable debug mode for troubleshooting
+     */
+    constructor(mediator: ProtectionMediator, debugMode?: boolean);
+    /**
+     * Initialize the handler and set up event subscriptions
+     */
+    protected initialize(): void;
+    /**
+     * Handle frame embedding detection event
+     * @param event The protection event containing frame embedding data
+     */
+    handleFrameEmbeddingDetected(event: ProtectionEvent): void;
+    /**
+     * Clean up resources when the handler is disposed
+     */
+    protected onDispose(): void;
+}