@readium/navigator-html-injectables 2.2.4 → 2.3.0

package/src/modules/snapper/ScrollSnapper.ts

@@ -5,14 +5,27 @@ import { ModuleName } from "../ModuleLibrary";
 import { Snapper } from "./Snapper";
 import { rangeFromLocator } from "../../helpers/locator";
 import { forceWebkitRecalc } from "../../helpers/document";
+import { PatternAnalyzer } from "../../protection/PatternAnalyzer";
+import { SCROLL_PROTECTION_CONFIG } from "../../protection/config";
+import { BaseSuspiciousActivityEvent } from "../Peripherals";
 
 const SCROLL_SNAPPER_STYLE_ID = "readium-scroll-snapper-style";
 
+export interface SuspiciousScrollingEvent extends BaseSuspiciousActivityEvent {
+    type: "suspicious_scrolling";
+    scrollDelta: number;
+    scrollDirection: "up" | "down";
+    targetElement: { tagName: string } | null;
+}
+
 export class ScrollSnapper extends Snapper {
     static readonly moduleName: ModuleName = "scroll_snapper";
     private wnd!: ReadiumWindow;
     private comms!: Comms;
     private resizeObserver!: ResizeObserver;
+    private patternAnalyzer: PatternAnalyzer | null = null;
+    private lastScrollTime: number = 0;
+    private isScrollProtectionEnabled = false;
 
     private initialScrollHandled = false;
     private isScrolling = false;
@@ -41,7 +54,7 @@ export class ScrollSnapper extends Snapper {
         });
     }
 
-    private handleScroll = () => {
+    private handleScroll = (_e: Event) => {
         if (!this.comms.ready) return;
         
         // We have to filter scroll from resize events
@@ -68,6 +81,31 @@ export class ScrollSnapper extends Snapper {
                 const deltaY = currentScrollTop - this.lastScrollTop;
                 this.lastScrollTop = currentScrollTop;
 
+                if (this.isScrollProtectionEnabled && Math.abs(deltaY) > 5) { // Ignore tiny scrolls
+                    const now = Date.now();
+                    const timeDelta = now - (this.lastScrollTime || now);
+                    if (this.patternAnalyzer) {
+                        const isSuspicious = this.patternAnalyzer.analyze(
+                            deltaY > 0 ? "down" : "up",
+                            Math.abs(deltaY),
+                            timeDelta
+                        );
+                        if (isSuspicious) {
+                            const target = _e.target && "tagName" in _e.target ? 
+                                { tagName: (_e.target as Element).tagName } : null;
+                                
+                            this.comms?.send("content_protection", {
+                                type: "suspicious_scrolling",
+                                timestamp: Date.now(),
+                                scrollDelta: deltaY,
+                                scrollDirection: deltaY > 0 ? "down" : "up",
+                                targetElement: target
+                            } as SuspiciousScrollingEvent);
+                        }
+                    }
+                    this.lastScrollTime = now;
+                }
+
                 this.comms.send("scroll", deltaY);
             
                 this.isScrolling = false;
@@ -75,6 +113,14 @@ export class ScrollSnapper extends Snapper {
         }
     };
 
+    private enableScrollProtection() {
+        if (!this.patternAnalyzer) {
+            this.patternAnalyzer = new PatternAnalyzer(SCROLL_PROTECTION_CONFIG);
+            this.isScrollProtectionEnabled = true;
+            this.comms?.log("Scroll protection enabled");
+        }
+    }
+
     mount(wnd: ReadiumWindow, comms: Comms): boolean {
         this.wnd = wnd;
         this.comms = comms;
@@ -222,6 +268,11 @@ export class ScrollSnapper extends Snapper {
             ack(true);
         });
 
+        comms.register("scroll_protection", ScrollSnapper.moduleName, (_, ack) => {
+            this.enableScrollProtection();
+            ack(true);
+        });
+
         comms.register([
             "go_next",
             "go_prev",
@@ -247,6 +298,13 @@ export class ScrollSnapper extends Snapper {
         this.resizeObserver.disconnect();
         if (this.handleScroll) wnd.removeEventListener("scroll", this.handleScroll);
         wnd.document.getElementById(SCROLL_SNAPPER_STYLE_ID)?.remove();
+
+        if (this.patternAnalyzer) {
+            this.patternAnalyzer.clear();
+            this.patternAnalyzer = null;
+            this.isScrollProtectionEnabled = false;
+        }
+
         comms.log("ScrollSnapper Unmounted");
         return true;
     }

package/src/modules/snapper/WebPubSnapper.ts

@@ -5,6 +5,11 @@ import { ModuleName } from "../ModuleLibrary";
 import { Snapper } from "./Snapper";
 import { rangeFromLocator } from "../../helpers/locator";
 import { forceWebkitRecalc } from "../../helpers/document";
+import { PatternAnalyzer } from "../../protection/PatternAnalyzer";
+import { SCROLL_PROTECTION_CONFIG } from "../../protection/config";
+import { SuspiciousScrollingEvent } from "./ScrollSnapper";
+
+export type { SuspiciousScrollingEvent };
 
 export class WebPubSnapper extends Snapper {
     static readonly moduleName: ModuleName = "webpub_snapper";
@@ -12,6 +17,9 @@ export class WebPubSnapper extends Snapper {
     private wnd!: ReadiumWindow;
     private comms!: Comms;
     private resizeObserver!: ResizeObserver;
+    private patternAnalyzer: PatternAnalyzer | null = null;
+    private lastScrollTime: number = 0;
+    private isScrollProtectionEnabled = false;
 
     private initialScrollHandled = false;
     private isScrolling = false;
@@ -38,7 +46,7 @@ export class WebPubSnapper extends Snapper {
         });
     }
 
-    private handleScroll = () => {
+    private handleScroll = (_e: Event) => {
         if (!this.comms.ready) return;
 
         // Filter resize events
@@ -63,6 +71,32 @@ export class WebPubSnapper extends Snapper {
                 const deltaY = currentScrollTop - this.lastScrollTop;
                 this.lastScrollTop = currentScrollTop;
 
+                // Record scroll for pattern analysis if protection is enabled
+                if (this.isScrollProtectionEnabled && Math.abs(deltaY) > 5) { // Ignore tiny scrolls
+                    const now = Date.now();
+                    const timeDelta = now - (this.lastScrollTime || now);
+                    if (this.patternAnalyzer) {
+                        const isSuspicious = this.patternAnalyzer.analyze(
+                            deltaY > 0 ? "down" : "up",
+                            Math.abs(deltaY),
+                            timeDelta
+                        );
+                        if (isSuspicious) {
+                            const target = _e.target && "tagName" in _e.target ? 
+                                { tagName: (_e.target as Element).tagName } : null;
+                                
+                            this.comms?.send("content_protection", {
+                                type: "suspicious_scrolling",
+                                timestamp: Date.now(),
+                                scrollDelta: deltaY,
+                                scrollDirection: deltaY > 0 ? "down" : "up",
+                                targetElement: target
+                            } as SuspiciousScrollingEvent);
+                        }
+                    }
+                    this.lastScrollTime = now;
+                }
+
                 this.comms.send("scroll", deltaY);
 
                 this.isScrolling = false;
@@ -70,6 +104,14 @@ export class WebPubSnapper extends Snapper {
         }
     };
 
+    private enableScrollProtection() {
+        if (!this.patternAnalyzer) {
+            this.patternAnalyzer = new PatternAnalyzer(SCROLL_PROTECTION_CONFIG);
+            this.isScrollProtectionEnabled = true;
+            this.comms?.log("Scroll protection enabled");
+        }
+    }
+
     mount(wnd: ReadiumWindow, comms: Comms): boolean {
         this.wnd = wnd;
         this.comms = comms;
@@ -134,7 +176,7 @@ export class WebPubSnapper extends Snapper {
             });
         });
 
-        this.comms.register("go_id", WebPubSnapper.moduleName, (data, ack) => {
+        comms.register("go_id", WebPubSnapper.moduleName, (data, ack) => {
             const element = wnd.document.getElementById(data as string);
             if(!element) {
                 ack(false);
@@ -197,6 +239,11 @@ export class WebPubSnapper extends Snapper {
             ack(true);
         });
 
+        comms.register("scroll_protection", WebPubSnapper.moduleName, (_, ack) => {
+            this.enableScrollProtection();
+            ack(true);
+        });
+
         comms.register([
             "go_next",
             "go_prev",
@@ -220,7 +267,14 @@ export class WebPubSnapper extends Snapper {
         comms.unregisterAll(WebPubSnapper.moduleName);
         this.resizeObserver.disconnect();
         if (this.handleScroll) wnd.removeEventListener("scroll", this.handleScroll);
+        
+        if (this.patternAnalyzer) {
+            this.patternAnalyzer.clear();
+            this.patternAnalyzer = null;
+            this.isScrollProtectionEnabled = false;
+        }
+
         comms.log("WebPubSnapper Unmounted");
         return true;
     }
-}
+}

package/src/protection/BulkCopyProtector.ts

@@ -0,0 +1,134 @@
+import { ReadiumWindow } from "../helpers/dom";
+
+interface CopyAttempt {
+    timestamp: number;
+    length: number;
+    wasBlocked: boolean;
+}
+
+export interface BulkCopyProtectionOptions {
+    enabled: boolean;
+    maxSelectionPercent: number;
+    absoluteMaxChars: number;
+    minThreshold: number;
+    historySize: number;
+}
+
+export class BulkCopyProtector {
+    private options: BulkCopyProtectionOptions;
+    private copyHistory: CopyAttempt[] = [];
+    private lastSelectionLength = 0;
+    private lastSelectionTime = 0;
+
+    constructor(
+        private readonly window: ReadiumWindow,
+        options: BulkCopyProtectionOptions
+    ) {
+        this.options = options;
+    }
+
+    private cleanupOldHistory(now: number): void {
+        // Keep history for the last 10 seconds
+        const historyWindow = 10000; // 10 seconds
+        this.copyHistory = this.copyHistory.filter(
+            attempt => now - attempt.timestamp < historyWindow
+        );
+        
+        // Trim to max history size
+        if (this.copyHistory.length > this.options.historySize) {
+            this.copyHistory = this.copyHistory.slice(-this.options.historySize);
+        }
+    }
+
+    private isSuspiciousPattern(now: number): boolean {
+        if (this.copyHistory.length < 3) return false;
+        
+        // Check for rapid successive copy attempts
+        const recentAttempts = this.copyHistory.filter(
+            attempt => now - attempt.timestamp < 2000 // Last 2 seconds
+        );
+        
+        if (recentAttempts.length >= 3) {
+            // If multiple rapid copy attempts, it's suspicious
+            return true;
+        }
+        
+        // Check for increasing selection sizes (bulk copy pattern)
+        const increasingSelections = this.copyHistory
+            .slice()
+            .sort((a, b) => a.timestamp - b.timestamp)
+            .every((attempt, i, arr) => {
+                if (i === 0) return true;
+                return attempt.length > arr[i - 1].length * 1.5; // Each selection is significantly larger
+            });
+            
+        return increasingSelections;
+    }
+
+    public shouldAllowCopy(event: ClipboardEvent): boolean {
+        if (!this.options.enabled) return true;
+
+        const selection = this.window.getSelection();
+        if (!selection) return true;
+        
+        const selectedText = selection.toString();
+        const selectedLength = selectedText.length;
+        const docLength = this.window.document.body.innerText.length;
+        const now = Date.now();
+
+        // Clean up old history entries
+        this.cleanupOldHistory(now);
+
+        // Always allow small selections
+        if (selectedLength < this.options.minThreshold) {
+            this.copyHistory.push({
+                timestamp: now,
+                length: selectedLength,
+                wasBlocked: false
+            });
+            return true;
+        }
+
+        const timeSinceLastSelection = now - this.lastSelectionTime;
+        
+        // Check for rapid successive selections
+        const isRapidSelection = 
+            timeSinceLastSelection < 100 && 
+            selectedLength > this.lastSelectionLength * 1.5;
+            
+        const maxAllowedSelection = Math.min(
+            docLength * this.options.maxSelectionPercent,
+            this.options.absoluteMaxChars
+        );
+
+        // Check if this matches a suspicious pattern
+        const isSuspicious = this.isSuspiciousPattern(now);
+        
+        const shouldBlock = selectedLength > maxAllowedSelection || 
+                          isRapidSelection || 
+                          isSuspicious;
+
+        // Record this attempt in history
+        this.copyHistory.push({
+            timestamp: now,
+            length: selectedLength,
+            wasBlocked: shouldBlock
+        });
+
+        if (shouldBlock) {
+            event?.preventDefault();
+            return false;
+        }
+        
+        this.lastSelectionLength = selectedLength;
+        this.lastSelectionTime = now;
+        return true;
+    }
+
+    public destroy(): void {
+        this.lastSelectionLength = 0;
+        this.lastSelectionTime = 0;
+        this.copyHistory = [];
+        this.options.enabled = false;
+    }
+}

package/src/protection/KeyCombinationManager.ts

@@ -0,0 +1,139 @@
+import { KeyCombo, KeyboardPeripheral } from "./KeyboardCombinations";
+import { BaseKeyboardPeripheralEvent, KeyboardEventData, BasicTextSelection } from "../modules/Peripherals";
+import { ReadiumWindow } from "../helpers/dom";
+
+export type KeyHandler = (event: KeyboardEvent) => void;
+export type ActivityEventDispatcher = (event: KeyboardPeripheralEvent) => void;
+
+export interface KeyboardPeripheralEvent extends BaseKeyboardPeripheralEvent, KeyboardEventData {
+    type: string;
+}
+
+export interface KeyComboWithHandler extends KeyCombo {
+    handler?: (event: KeyboardEvent) => void;
+}
+
+export class KeyCombinationManager {
+    /**
+     * Checks if the given keyboard event matches any of the provided key combinations
+     */
+    public match(event: KeyboardEvent, combos: KeyCombo[]): boolean {
+        for (const combo of combos) {
+            const keyMatch = event.keyCode === combo.keyCode;
+            const ctrlMatch = combo.ctrl === undefined || event.ctrlKey === combo.ctrl;
+            const shiftMatch = combo.shift === undefined || event.shiftKey === combo.shift;
+            const altMatch = combo.alt === undefined || event.altKey === combo.alt;
+            const metaMatch = combo.meta === undefined || event.metaKey === combo.meta;
+            
+            if (keyMatch && ctrlMatch && shiftMatch && altMatch && metaMatch) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Creates an event handler that will call the provided handler when any of the key combinations match
+     */
+    public createKeyHandler(combos: KeyCombo[], handler: KeyHandler): (event: KeyboardEvent) => void {
+        return (event: KeyboardEvent) => {
+            if (this.match(event, combos)) {
+                event.preventDefault();
+                event.stopPropagation();
+                handler(event);
+            }
+        };
+    }
+
+    /**
+     * Creates a standardized activity event for keyboard shortcuts
+     */
+    private createActivityEvent(
+        event: KeyboardEvent, 
+        type: string,
+        targetFrameSrc: string,
+        wnd?: ReadiumWindow,
+    ): KeyboardPeripheralEvent {
+        // Capture selected text if window is available
+        let selectedText: Omit<BasicTextSelection, "targetFrameSrc"> | undefined;
+        if (wnd) {
+            const selection = wnd.getSelection();
+            const selectedTextStr = selection?.toString() || '';
+            const domRectList = (selectedTextStr && selection?.rangeCount) ? selection.getRangeAt(0)?.getClientRects() : null;
+            const rect = domRectList?.[0];
+            
+            if (rect && selectedTextStr) {
+                selectedText = {
+                    text: selectedTextStr,
+                    x: rect.x,
+                    y: rect.y,
+                    width: rect.width,
+                    height: rect.height
+                };
+            }
+        }
+
+        return {
+            type: type,
+            timestamp: Date.now(),
+            key: event.key,
+            code: event.code,
+            keyCode: event.keyCode,
+            ctrlKey: event.ctrlKey,
+            altKey: event.altKey,
+            shiftKey: event.shiftKey,
+            metaKey: event.metaKey,
+            targetFrameSrc: targetFrameSrc,
+            selectedText
+        };
+    }
+
+    /**
+     * Creates handlers for keyboard shortcuts with centralized activity event dispatch
+     */
+    public createKeyboardHandlers(
+        targetFrameSrc: string,
+        shortcuts: KeyboardPeripheral[],
+        dispatcher: ActivityEventDispatcher,
+        wnd?: ReadiumWindow,
+    ): KeyComboWithHandler[] {
+        const handlers: KeyComboWithHandler[] = [];
+
+        // Handle KeyboardPeripheral objects only
+        shortcuts.forEach(shortcut => {
+            handlers.push(...shortcut.keyCombos.map(combo => ({
+                ...combo,
+                handler: (event: KeyboardEvent) => {
+                    const eventType = shortcut.type;
+                    const activityEvent = this.createActivityEvent(event, eventType, targetFrameSrc, wnd);
+                    dispatcher(activityEvent);
+                }
+            })));
+        });
+
+        return handlers;
+    }
+
+    /**
+     * Creates a unified keyboard event handler that processes all shortcuts
+     */
+    public createUnifiedHandler(
+        targetFrameSrc: string,
+        shortcuts: KeyboardPeripheral[],
+        dispatcher: ActivityEventDispatcher,
+        wnd?: ReadiumWindow,
+    ): (event: KeyboardEvent) => void {
+        const handlers = this.createKeyboardHandlers(targetFrameSrc, shortcuts, dispatcher, wnd);
+        
+        return (event: KeyboardEvent) => {
+            for (const handlerConfig of handlers) {
+                if (this.match(event, [handlerConfig])) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    handlerConfig.handler!(event);
+                    return; // Stop after first match
+                }
+            }
+        };
+    }
+}

package/src/protection/KeyboardCombinations.ts

@@ -0,0 +1,60 @@
+export interface KeyCombo {
+    keyCode: number;  // Use stable keyCode that doesn't change across layouts
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+}
+
+export interface KeyboardPeripheral {
+    type: string;
+    keyCombos: KeyCombo[];
+}
+
+// Developer tools shortcuts as KeyboardPeripheral
+export const DEV_TOOLS: KeyboardPeripheral = {
+    type: "developer_tools",
+    keyCombos: [
+        { keyCode: 73, meta: true, alt: true },    // I key
+        { keyCode: 74, meta: true, alt: true },    // J key
+        { keyCode: 85, meta: true, alt: true },    // U key
+        { keyCode: 67, meta: true, alt: true },    // C key
+        { keyCode: 67, meta: true, shift: true },  // C key (Cmd+Shift+C)
+        { keyCode: 67, ctrl: true, shift: true },  // C key (Ctrl+Shift+C)
+        { keyCode: 123 },                          // F12
+        { keyCode: 123, shift: true },             // F12+Shift
+        { keyCode: 123, ctrl: true, shift: true }, // F12+Ctrl+Shift
+        { keyCode: 123, meta: true, alt: true },   // F12+Meta+Alt
+    ]
+};
+
+// Select all shortcuts as KeyboardPeripheral
+export const SELECT_ALL: KeyboardPeripheral = {
+    type: "select_all",
+    keyCombos: [
+        { keyCode: 65, meta: true },    // A key (Cmd+A)
+        { keyCode: 65, ctrl: true }     // A key (Ctrl+A)
+    ]
+};
+
+// Print shortcuts as KeyboardPeripheral
+export const PRINT: KeyboardPeripheral = {
+    type: "print",
+    keyCombos: [
+        { keyCode: 80, meta: true },                    // P key (Cmd+P)
+        { keyCode: 80, ctrl: true },                    // P key (Ctrl+P)
+        { keyCode: 80, meta: true, shift: true },       // P key (Cmd+Shift+P)
+        { keyCode: 80, ctrl: true, shift: true },       // P key (Ctrl+Shift+P)
+        { keyCode: 80, meta: true, alt: true },         // P key (Cmd+Alt+P)
+        { keyCode: 80, ctrl: true, alt: true }          // P key (Ctrl+Alt+P)
+    ]
+};
+
+// Save shortcuts as KeyboardPeripheral
+export const SAVE: KeyboardPeripheral = {
+    type: "save",
+    keyCombos: [
+        { keyCode: 83, meta: true },    // S key (Cmd+S)
+        { keyCode: 83, ctrl: true }     // S key (Ctrl+S)
+    ]
+};

package/src/protection/PatternAnalyzer.ts

@@ -0,0 +1,117 @@
+import { DEFAULT_PATTERN_ANALYZER_CONFIG } from "./config";
+
+type Direction = "left" | "right" | "up" | "down";
+
+export interface PatternAnalyzerOptions {
+    maxVelocity: number;          // pixels/ms
+    minVariance: number;          // 0-1
+    historySize?: number;         // Number of scroll events to keep in history
+    minDirectionChanges?: number; // Minimum ratio of direction changes to total events (0-1)
+    maxConsistentScrolls?: number; // Maximum number of consistent scrolls before flagging
+}
+
+// TODO: Improve for scroll protection, 
+// currently disabled because of false positives
+export class PatternAnalyzer {
+    private options: PatternAnalyzerOptions;
+    private history: Array<{
+        timestamp: number;
+        direction: Direction;
+        velocity: number;
+        distance: number;
+    }> = [];
+    
+    private consistentScrollCount = 0;
+    
+    constructor(
+        options: Partial<PatternAnalyzerOptions> = {}
+    ) {
+        // Merge provided options with default config
+        this.options = { ...DEFAULT_PATTERN_ANALYZER_CONFIG, ...options };
+    }
+
+    analyze(direction: Direction, distance: number, timeDelta: number): boolean {
+        if (timeDelta <= 0) return false;
+        
+        const velocity = Math.abs(distance) / timeDelta;
+        const now = Date.now();
+        
+        // Add new event
+        this.history.push({ 
+            timestamp: now, 
+            direction, 
+            velocity,
+            distance: Math.abs(distance)
+        });
+        
+        // Clean up old events (keep last 2 seconds of data or historySize, whichever is smaller)
+        this.history = this.history
+            .filter(h => now - h.timestamp < 2000)
+            .slice(-(this.options.historySize || 20));
+
+        // Need at least 3 events to start detecting patterns
+        if (this.history.length < 3) return false;
+
+        // 1. Check for excessive speed (unrealistically fast scrolling)
+        if (velocity > this.options.maxVelocity) {
+            this.resetAfterDetection();
+            return true;
+        }
+
+        // 2. Check for consistent scrolling patterns
+        const velocities = this.history.map(h => h.velocity);
+        const distances = this.history.map(h => h.distance);
+        
+        // Calculate mean and variance of velocities and distances
+        const meanVelocity = velocities.reduce((a, b) => a + b, 0) / velocities.length;
+        const meanDistance = distances.reduce((a, b) => a + b, 0) / distances.length;
+        
+        const velocityVariance = velocities.reduce((a, b) => a + Math.pow(b - meanVelocity, 2), 0) / velocities.length;
+        const distanceVariance = distances.reduce((a, b) => a + Math.pow(b - meanDistance, 2), 0) / distances.length;
+
+        // Check for suspiciously consistent scrolling (low variance in speed and distance)
+        if (velocityVariance < this.options.minVariance && 
+            distanceVariance < (meanDistance * 0.1)) { // Allow 10% variance in distance
+            this.consistentScrollCount++;
+            
+            // Only trigger if we've seen consistent scrolling for a while
+            if (this.consistentScrollCount >= (this.options.maxConsistentScrolls || 10)) {
+                this.resetAfterDetection();
+                return true;
+            }
+        } else {
+            // Reset counter if pattern breaks
+            this.consistentScrollCount = Math.max(0, this.consistentScrollCount - 1);
+        }
+
+        // 3. Check for rapid direction changes (unnatural back-and-forth scrolling)
+        let directionChanges = 0;
+        let lastDirection = this.history[0].direction;
+        
+        for (let i = 1; i < this.history.length; i++) {
+            if (this.history[i].direction !== lastDirection) {
+                directionChanges++;
+                lastDirection = this.history[i].direction;
+            }
+        }
+        
+        const directionChangeRatio = directionChanges / this.history.length;
+        if (directionChangeRatio > (this.options.minDirectionChanges || 0.3)) {
+            this.resetAfterDetection();
+            return true;
+        }
+
+        return false;
+    }
+
+    private resetAfterDetection(): void {
+        // Keep some history to prevent immediate re-triggering
+        this.history = this.history.slice(-3);
+        this.consistentScrollCount = 0;
+    }
+    
+    clear(): void {
+        this.history = [];
+        this.consistentScrollCount = 0;
+    }
+}