@dollhousemcp/mcp-server/dist/security/encryption/PatternDecryptor.js

DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.

/**
 * Pattern Decryption Service with LLM Context Protection
 *
 * Part of Issue #1321 Phase 2: Memory Security Architecture
 *
 * PURPOSE:
 * Provides secure access to decrypt patterns while preventing
 * decryption in LLM request contexts. All decryption attempts
 * are audited for security monitoring.
 *
 * SECURITY:
 * - Prevents decryption in LLM contexts (blocks pattern leaks to LLM)
 * - Requires explicit authorization
 * - Audits all decryption attempts
 * - Uses ContextTracker to detect execution context
 *
 * REFACTOR NOTE:
 * Converted from static class to instance-based for DI architecture compatibility.
 * PatternDecryptor now requires PatternEncryptor and ContextTracker dependencies
 * to be injected via constructor for proper DI lifecycle management.
 *
 * @module PatternDecryptor
 */
import { logger } from '../../utils/logger.js';
/**
 * Decryption audit log
 * Maintains a record of all decryption attempts for security monitoring
 */
class DecryptionAuditLog {
    attempts = [];
    MAX_LOG_SIZE = 1000;
    /**
     * Log a decryption attempt
     *
     * @param attempt - Decryption attempt metadata
     */
    log(attempt) {
        this.attempts.push(attempt);
        // Trim log if it exceeds max size
        if (this.attempts.length > this.MAX_LOG_SIZE) {
            this.attempts = this.attempts.slice(-this.MAX_LOG_SIZE);
        }
        // Always log to system logger for persistence
        if (attempt.success) {
            logger.info('Pattern decrypted', {
                patternRef: attempt.patternRef,
                contextType: attempt.contextType,
                requestId: attempt.requestId,
            });
        }
        else {
            logger.warn('Pattern decryption denied', {
                patternRef: attempt.patternRef,
                contextType: attempt.contextType,
                reason: attempt.denialReason,
                error: attempt.error,
                requestId: attempt.requestId,
            });
        }
    }
    /**
     * Get all decryption attempts
     *
     * @returns Array of decryption attempts
     */
    getAttempts() {
        return [...this.attempts];
    }
    /**
     * Get recent decryption attempts
     *
     * @param limit - Maximum number of attempts to return
     * @returns Array of recent attempts
     */
    getRecentAttempts(limit = 100) {
        return this.attempts.slice(-limit);
    }
    /**
     * Clear the audit log (useful for testing)
     */
    clear() {
        this.attempts = [];
        logger.debug('Decryption audit log cleared');
    }
}
/**
 * PatternDecryptor service
 *
 * Provides controlled access to decrypt encrypted patterns with
 * LLM context protection and audit logging.
 *
 * DI-COMPATIBLE: Instance-based service for dependency injection.
 */
export class PatternDecryptor {
    encryptor;
    contextTracker;
    auditLog;
    /**
     * Create a new PatternDecryptor instance
     *
     * @param encryptor - PatternEncryptor instance for decryption operations
     * @param contextTracker - ContextTracker instance for LLM context detection
     */
    constructor(encryptor, contextTracker) {
        this.encryptor = encryptor;
        this.contextTracker = contextTracker;
        this.auditLog = new DecryptionAuditLog();
    }
    /**
     * Decrypt a sanitized pattern with security checks
     *
     * This method:
     * 1. Checks if in LLM context (denies if true)
     * 2. Validates pattern structure
     * 3. Audits the decryption attempt
     * 4. Decrypts the pattern using PatternEncryptor
     *
     * @param pattern - Sanitized pattern to decrypt
     * @returns Decrypted pattern text
     * @throws Error if decryption is not allowed or fails
     */
    decryptPattern(pattern) {
        const context = this.contextTracker.getContext();
        const patternRef = pattern.ref;
        // Security check: Prevent decryption in LLM context
        if (this.contextTracker.isLLMContext()) {
            const attempt = {
                patternRef,
                success: false,
                timestamp: Date.now(),
                contextType: context?.type || 'unknown',
                requestId: context?.requestId,
                denialReason: 'Decryption not allowed in LLM request context',
            };
            this.auditLog.log(attempt);
            throw new Error('Pattern decryption blocked: Cannot decrypt patterns in LLM request context');
        }
        // Validate pattern structure
        if (!pattern.encryptedPattern || !pattern.iv || !pattern.authTag) {
            const attempt = {
                patternRef,
                success: false,
                timestamp: Date.now(),
                contextType: context?.type || 'unknown',
                requestId: context?.requestId,
                denialReason: 'Pattern not encrypted or missing required fields',
            };
            this.auditLog.log(attempt);
            throw new Error('Pattern decryption failed: Pattern is not encrypted or missing required fields');
        }
        try {
            // Build encrypted pattern structure
            const encryptedPattern = {
                encryptedData: pattern.encryptedPattern,
                algorithm: pattern.algorithm || 'aes-256-gcm',
                iv: pattern.iv,
                authTag: pattern.authTag,
            };
            // Decrypt using PatternEncryptor
            const decrypted = this.encryptor.decrypt(encryptedPattern);
            // Log successful decryption
            const attempt = {
                patternRef,
                success: true,
                timestamp: Date.now(),
                contextType: context?.type || 'unknown',
                requestId: context?.requestId,
            };
            this.auditLog.log(attempt);
            return decrypted;
        }
        catch (error) {
            // Log failed decryption
            const attempt = {
                patternRef,
                success: false,
                timestamp: Date.now(),
                contextType: context?.type || 'unknown',
                requestId: context?.requestId,
                error: error instanceof Error ? error.message : 'Unknown error',
            };
            this.auditLog.log(attempt);
            throw error;
        }
    }
    /**
     * Get decryption audit log
     *
     * @param limit - Maximum number of attempts to return
     * @returns Array of recent decryption attempts
     */
    getAuditLog(limit) {
        if (limit !== undefined) {
            return this.auditLog.getRecentAttempts(limit);
        }
        return this.auditLog.getAttempts();
    }
    /**
     * Clear the audit log (useful for testing)
     */
    clearAuditLog() {
        this.auditLog.clear();
    }
    /**
     * Dispose of the decryptor and clean up resources
     * Implements cleanup for proper DI lifecycle management
     */
    async dispose() {
        this.auditLog.clear();
        logger.debug('PatternDecryptor disposed');
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PatternDecryptor.js","sourceRoot":"","sources":["../../../src/security/encryption/PatternDecryptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pattern Decryption Service with LLM Context Protection\n *\n * Part of Issue #1321 Phase 2: Memory Security Architecture\n *\n * PURPOSE:\n * Provides secure access to decrypt patterns while preventing\n * decryption in LLM request contexts. All decryption attempts\n * are audited for security monitoring.\n *\n * SECURITY:\n * - Prevents decryption in LLM contexts (blocks pattern leaks to LLM)\n * - Requires explicit authorization\n * - Audits all decryption attempts\n * - Uses ContextTracker to detect execution context\n *\n * REFACTOR NOTE:\n * Converted from static class to instance-based for DI architecture compatibility.\n * PatternDecryptor now requires PatternEncryptor and ContextTracker dependencies\n * to be injected via constructor for proper DI lifecycle management.\n *\n * @module PatternDecryptor\n */\n\nimport { logger } from '../../utils/logger.js';\nimport { PatternEncryptor } from './PatternEncryptor.js';\nimport { ContextTracker } from './ContextTracker.js';\nimport type { SanitizedPattern } from '../validation/BackgroundValidator.js';\nimport type { EncryptedPattern } from './PatternEncryptor.js';\n\n/**\n * Decryption attempt metadata for audit logging\n */\nexport interface DecryptionAttempt {\n  /** Pattern reference ID */\n  patternRef: string;\n\n  /** Whether decryption was successful */\n  success: boolean;\n\n  /** Timestamp of the attempt */\n  timestamp: number;\n\n  /** Execution context type */\n  contextType: string;\n\n  /** Request ID for correlation */\n  requestId?: string;\n\n  /** Reason for denial (if unsuccessful) */\n  denialReason?: string;\n\n  /** Error message (if failed) */\n  error?: string;\n}\n\n/**\n * Decryption audit log\n * Maintains a record of all decryption attempts for security monitoring\n */\nclass DecryptionAuditLog {\n  private attempts: DecryptionAttempt[] = [];\n  private readonly MAX_LOG_SIZE = 1000;\n\n  /**\n   * Log a decryption attempt\n   *\n   * @param attempt - Decryption attempt metadata\n   */\n  log(attempt: DecryptionAttempt): void {\n    this.attempts.push(attempt);\n\n    // Trim log if it exceeds max size\n    if (this.attempts.length > this.MAX_LOG_SIZE) {\n      this.attempts = this.attempts.slice(-this.MAX_LOG_SIZE);\n    }\n\n    // Always log to system logger for persistence\n    if (attempt.success) {\n      logger.info('Pattern decrypted', {\n        patternRef: attempt.patternRef,\n        contextType: attempt.contextType,\n        requestId: attempt.requestId,\n      });\n    } else {\n      logger.warn('Pattern decryption denied', {\n        patternRef: attempt.patternRef,\n        contextType: attempt.contextType,\n        reason: attempt.denialReason,\n        error: attempt.error,\n        requestId: attempt.requestId,\n      });\n    }\n  }\n\n  /**\n   * Get all decryption attempts\n   *\n   * @returns Array of decryption attempts\n   */\n  getAttempts(): DecryptionAttempt[] {\n    return [...this.attempts];\n  }\n\n  /**\n   * Get recent decryption attempts\n   *\n   * @param limit - Maximum number of attempts to return\n   * @returns Array of recent attempts\n   */\n  getRecentAttempts(limit: number = 100): DecryptionAttempt[] {\n    return this.attempts.slice(-limit);\n  }\n\n  /**\n   * Clear the audit log (useful for testing)\n   */\n  clear(): void {\n    this.attempts = [];\n    logger.debug('Decryption audit log cleared');\n  }\n}\n\n/**\n * PatternDecryptor service\n *\n * Provides controlled access to decrypt encrypted patterns with\n * LLM context protection and audit logging.\n *\n * DI-COMPATIBLE: Instance-based service for dependency injection.\n */\nexport class PatternDecryptor {\n  private readonly auditLog: DecryptionAuditLog;\n\n  /**\n   * Create a new PatternDecryptor instance\n   *\n   * @param encryptor - PatternEncryptor instance for decryption operations\n   * @param contextTracker - ContextTracker instance for LLM context detection\n   */\n  constructor(\n    private readonly encryptor: PatternEncryptor,\n    private readonly contextTracker: ContextTracker\n  ) {\n    this.auditLog = new DecryptionAuditLog();\n  }\n\n  /**\n   * Decrypt a sanitized pattern with security checks\n   *\n   * This method:\n   * 1. Checks if in LLM context (denies if true)\n   * 2. Validates pattern structure\n   * 3. Audits the decryption attempt\n   * 4. Decrypts the pattern using PatternEncryptor\n   *\n   * @param pattern - Sanitized pattern to decrypt\n   * @returns Decrypted pattern text\n   * @throws Error if decryption is not allowed or fails\n   */\n  decryptPattern(pattern: SanitizedPattern): string {\n    const context = this.contextTracker.getContext();\n    const patternRef = pattern.ref;\n\n    // Security check: Prevent decryption in LLM context\n    if (this.contextTracker.isLLMContext()) {\n      const attempt: DecryptionAttempt = {\n        patternRef,\n        success: false,\n        timestamp: Date.now(),\n        contextType: context?.type || 'unknown',\n        requestId: context?.requestId,\n        denialReason: 'Decryption not allowed in LLM request context',\n      };\n\n      this.auditLog.log(attempt);\n\n      throw new Error(\n        'Pattern decryption blocked: Cannot decrypt patterns in LLM request context'\n      );\n    }\n\n    // Validate pattern structure\n    if (!pattern.encryptedPattern || !pattern.iv || !pattern.authTag) {\n      const attempt: DecryptionAttempt = {\n        patternRef,\n        success: false,\n        timestamp: Date.now(),\n        contextType: context?.type || 'unknown',\n        requestId: context?.requestId,\n        denialReason: 'Pattern not encrypted or missing required fields',\n      };\n\n      this.auditLog.log(attempt);\n\n      throw new Error(\n        'Pattern decryption failed: Pattern is not encrypted or missing required fields'\n      );\n    }\n\n    try {\n      // Build encrypted pattern structure\n      const encryptedPattern: EncryptedPattern = {\n        encryptedData: pattern.encryptedPattern,\n        algorithm: (pattern.algorithm as 'aes-256-gcm') || 'aes-256-gcm',\n        iv: pattern.iv,\n        authTag: pattern.authTag,\n      };\n\n      // Decrypt using PatternEncryptor\n      const decrypted = this.encryptor.decrypt(encryptedPattern);\n\n      // Log successful decryption\n      const attempt: DecryptionAttempt = {\n        patternRef,\n        success: true,\n        timestamp: Date.now(),\n        contextType: context?.type || 'unknown',\n        requestId: context?.requestId,\n      };\n\n      this.auditLog.log(attempt);\n\n      return decrypted;\n    } catch (error) {\n      // Log failed decryption\n      const attempt: DecryptionAttempt = {\n        patternRef,\n        success: false,\n        timestamp: Date.now(),\n        contextType: context?.type || 'unknown',\n        requestId: context?.requestId,\n        error: error instanceof Error ? error.message : 'Unknown error',\n      };\n\n      this.auditLog.log(attempt);\n\n      throw error;\n    }\n  }\n\n  /**\n   * Get decryption audit log\n   *\n   * @param limit - Maximum number of attempts to return\n   * @returns Array of recent decryption attempts\n   */\n  getAuditLog(limit?: number): DecryptionAttempt[] {\n    if (limit !== undefined) {\n      return this.auditLog.getRecentAttempts(limit);\n    }\n    return this.auditLog.getAttempts();\n  }\n\n  /**\n   * Clear the audit log (useful for testing)\n   */\n  clearAuditLog(): void {\n    this.auditLog.clear();\n  }\n\n  /**\n   * Dispose of the decryptor and clean up resources\n   * Implements cleanup for proper DI lifecycle management\n   */\n  async dispose(): Promise<void> {\n    this.auditLog.clear();\n    logger.debug('PatternDecryptor disposed');\n  }\n}\n"]}