@dollhousemcp/mcp-server/dist/security/validation/PatternExtractor.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 Extraction for Memory Security
 *
 * Part of Issue #1314 Phase 1: Memory Security Architecture
 * Enhanced in Issue #1321 Phase 2: Pattern Encryption
 *
 * PURPOSE:
 * Identifies and extracts dangerous patterns from memory content for
 * sanitized display with AES-256-GCM encryption (Phase 2).
 *
 * PHASE 1 SCOPE:
 * - Identify pattern locations in content
 * - Generate pattern metadata (severity, description, location)
 * - Create sanitized content with pattern references
 * - Prepare structure for Phase 2 encryption
 *
 * PHASE 2 SCOPE:
 * - AES-256-GCM encryption of extracted patterns
 * - Key derivation from system secret
 * - Secure pattern storage and retrieval
 * - GCM authentication tags for integrity
 *
 * REFACTOR NOTE:
 * Converted from static class to instance-based for DI architecture compatibility.
 * PatternExtractor now requires PatternEncryptor dependency injected via constructor
 * for proper lifecycle management and testability.
 *
 * @module PatternExtractor
 */
import { logger } from '../../utils/logger.js';
/**
 * PatternExtractor service
 *
 * Extracts dangerous patterns from memory content and creates
 * sanitized versions suitable for display to LLMs.
 *
 * DI-COMPATIBLE: Instance-based service for dependency injection.
 */
export class PatternExtractor {
    encryptor;
    patternCounter = 0;
    /**
     * Create a new PatternExtractor instance
     *
     * @param encryptor - PatternEncryptor instance for encrypting extracted patterns
     */
    constructor(encryptor) {
        this.encryptor = encryptor;
        logger.debug('PatternExtractor initialized');
    }
    /**
     * Extract patterns from content based on validation results
     *
     * @param content - Original content containing patterns
     * @param validationResult - Validation result with detected patterns
     * @returns Extraction result with sanitized content and pattern metadata
     */
    extractPatterns(content, validationResult) {
        logger.debug('Extracting patterns from content', {
            contentLength: content.length,
            detectedPatterns: validationResult.detectedPatterns?.length || 0,
        });
        // If no patterns detected, return content as-is
        if (!validationResult.detectedPatterns || validationResult.detectedPatterns.length === 0) {
            return {
                sanitizedContent: content,
                patterns: [],
                patternCount: 0,
            };
        }
        // Find all pattern matches in content
        const matches = this.findPatternMatches(content, validationResult);
        if (matches.length === 0) {
            logger.debug('No pattern matches found in content');
            return {
                sanitizedContent: content,
                patterns: [],
                patternCount: 0,
            };
        }
        logger.info('Found pattern matches', { count: matches.length });
        // Create sanitized patterns with references
        const sanitizedPatterns = matches.map((match) => this.createSanitizedPattern(match));
        // Create sanitized content by replacing patterns with references
        const sanitizedContent = this.createSanitizedContent(content, matches);
        return {
            sanitizedContent,
            patterns: sanitizedPatterns,
            patternCount: matches.length,
        };
    }
    /**
     * Find all pattern matches in content
     *
     * This uses heuristics to locate the detected patterns within the content.
     * The ContentValidator tells us what patterns were detected, but not where.
     * We need to search for them.
     */
    findPatternMatches(content, validationResult) {
        const matches = [];
        // Get detected patterns from validation
        const detectedPatterns = validationResult.detectedPatterns || [];
        for (const patternType of detectedPatterns) {
            // Use heuristics to find likely pattern locations
            // FIX: Provide default severity 'low' when undefined
            const severity = validationResult.severity || 'low';
            const patternMatches = this.searchForPattern(content, patternType, severity);
            matches.push(...patternMatches);
        }
        // Sort matches by position for proper replacement
        matches.sort((a, b) => a.startOffset - b.startOffset);
        return matches;
    }
    /**
     * Search for a specific pattern type in content
     *
     * Uses common patterns and heuristics to locate dangerous content
     */
    searchForPattern(content, patternType, severity) {
        const matches = [];
        // Common injection pattern markers
        const injectionMarkers = [
            // LLM prompt injection markers
            /(?:ignore|disregard|forget)[\s\S]{0,30}(?:previous|above|prior)\s+(?:instructions|prompts|commands)/gi,
            /system[\s\S]{0,10}prompt[\s\S]{0,10}[:=]/gi,
            /new\s+(?:instructions|task|role|mission)[\s\S]{0,10}:/gi,
            // Code execution patterns
            /eval\s*\(/gi,
            /exec\s*\(/gi,
            /subprocess\./gi,
            /shell_exec/gi,
            // SQL injection patterns (flexible matching with .* for content between keywords)
            /(?:union|select|insert|delete|update|drop)[\s\S]*?(?:table|from|into|database)/gi,
            /'\s*(?:or|and)\s+['"]?\d+['"]?\s*=\s*['"]?\d+/gi,
            // Path traversal
            /\.\.\/|\.\.\\|\.\.[/\\]/g,
            // XXE patterns
            /<!ENTITY/gi,
            /<!DOCTYPE[\s\S]+SYSTEM/gi,
        ];
        // Search for each marker pattern
        for (const marker of injectionMarkers) {
            let match;
            const regex = new RegExp(marker);
            while ((match = regex.exec(content)) !== null) {
                const matchText = match[0];
                matches.push({
                    pattern: matchText,
                    type: patternType,
                    severity: severity,
                    startOffset: match.index,
                    length: matchText.length,
                    description: this.getPatternDescription(patternType, matchText),
                });
                // Prevent infinite loops on zero-length matches
                if (regex.lastIndex === match.index) {
                    regex.lastIndex++;
                }
            }
        }
        return matches;
    }
    /**
     * Create a sanitized pattern object with metadata
     *
     * Phase 2: Now encrypts patterns using AES-256-GCM
     */
    createSanitizedPattern(match) {
        const patternId = `PATTERN_${String(++this.patternCounter).padStart(3, '0')}`;
        // Phase 2: Encrypt the pattern using AES-256-GCM
        let encrypted = null;
        try {
            if (this.encryptor.isEnabled()) {
                encrypted = this.encryptor.encrypt(match.pattern);
                logger.debug('Pattern encrypted successfully', {
                    patternId,
                    algorithm: encrypted.algorithm,
                });
            }
            else {
                logger.debug('Pattern encryption disabled, storing without encryption', {
                    patternId,
                });
            }
        }
        catch (error) {
            logger.error('Failed to encrypt pattern, storing without encryption', {
                patternId,
                error,
            });
            // Continue without encryption rather than failing
        }
        return {
            ref: patternId,
            description: match.description,
            severity: match.severity,
            location: `offset ${match.startOffset}, length ${match.length}`,
            safetyInstruction: this.getSafetyInstruction(match.severity),
            // Phase 2: Encryption fields (populated if encryption successful)
            encryptedPattern: encrypted?.encryptedData,
            algorithm: encrypted?.algorithm,
            iv: encrypted?.iv,
            authTag: encrypted?.authTag,
        };
    }
    /**
     * Create sanitized content by replacing patterns with references
     */
    createSanitizedContent(content, matches) {
        // Work backwards through matches to maintain correct offsets
        let sanitized = content;
        const sortedMatches = [...matches].sort((a, b) => b.startOffset - a.startOffset);
        let patternIndex = sortedMatches.length;
        for (const match of sortedMatches) {
            const patternRef = `[PATTERN_${String(patternIndex).padStart(3, '0')}]`;
            const beforePattern = sanitized.substring(0, match.startOffset);
            const afterPattern = sanitized.substring(match.startOffset + match.length);
            sanitized = beforePattern + patternRef + afterPattern;
            patternIndex--;
        }
        return sanitized;
    }
    /**
     * Get human-readable description for a pattern type
     */
    getPatternDescription(patternType, matchText) {
        const descriptions = {
            'prompt-injection': 'LLM prompt injection attempt',
            'sql-injection': 'SQL injection pattern',
            'code-injection': 'Code execution pattern',
            'path-traversal': 'Path traversal attempt',
            'xxe': 'XML External Entity (XXE) pattern',
            'xss': 'Cross-site scripting (XSS) pattern',
            'command-injection': 'Command injection pattern',
        };
        const description = descriptions[patternType] || `Security pattern: ${patternType}`;
        // Truncate match text if too long
        const truncatedMatch = matchText.length > 50
            ? matchText.substring(0, 47) + '...'
            : matchText;
        return `${description} - "${truncatedMatch}"`;
    }
    /**
     * Get safety instruction based on severity
     */
    getSafetyInstruction(severity) {
        switch (severity) {
            case 'critical':
                return 'CRITICAL - DO NOT EXECUTE - This pattern is malicious and must never be used in production code';
            case 'high':
                return 'HIGH RISK - DO NOT EXECUTE - This pattern should only be used in security testing contexts';
            case 'medium':
                return 'WARNING - This pattern may be dangerous if misused - Use only for security validation';
            case 'low':
                return 'CAUTION - Review before use - May have security implications in certain contexts';
            default:
                return 'This pattern has been extracted for security purposes - Review before use';
        }
    }
    /**
     * Reset the pattern counter (useful for testing)
     */
    resetCounter() {
        this.patternCounter = 0;
    }
    /**
     * Dispose of the extractor and clean up resources
     * Implements cleanup for proper DI lifecycle management
     */
    async dispose() {
        this.resetCounter();
        logger.debug('PatternExtractor disposed');
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PatternExtractor.js","sourceRoot":"","sources":["../../../src/security/validation/PatternExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pattern Extraction for Memory Security\n *\n * Part of Issue #1314 Phase 1: Memory Security Architecture\n * Enhanced in Issue #1321 Phase 2: Pattern Encryption\n *\n * PURPOSE:\n * Identifies and extracts dangerous patterns from memory content for\n * sanitized display with AES-256-GCM encryption (Phase 2).\n *\n * PHASE 1 SCOPE:\n * - Identify pattern locations in content\n * - Generate pattern metadata (severity, description, location)\n * - Create sanitized content with pattern references\n * - Prepare structure for Phase 2 encryption\n *\n * PHASE 2 SCOPE:\n * - AES-256-GCM encryption of extracted patterns\n * - Key derivation from system secret\n * - Secure pattern storage and retrieval\n * - GCM authentication tags for integrity\n *\n * REFACTOR NOTE:\n * Converted from static class to instance-based for DI architecture compatibility.\n * PatternExtractor now requires PatternEncryptor dependency injected via constructor\n * for proper lifecycle management and testability.\n *\n * @module PatternExtractor\n */\n\nimport { logger } from '../../utils/logger.js';\nimport type { ContentValidationResult } from '../contentValidator.js';\nimport type { SanitizedPattern } from './BackgroundValidator.js';\nimport { PatternEncryptor } from '../encryption/PatternEncryptor.js';\n\n/**\n * Pattern match information from validation\n */\nexport interface PatternMatch {\n  /** The actual pattern text that was matched */\n  pattern: string;\n\n  /** The type/category of pattern */\n  type: string;\n\n  /** Severity level */\n  severity: 'critical' | 'high' | 'medium' | 'low';\n\n  /** Start position in content */\n  startOffset: number;\n\n  /** Length of the pattern */\n  length: number;\n\n  /** Human-readable description */\n  description: string;\n}\n\n/**\n * Result of pattern extraction\n */\nexport interface ExtractionResult {\n  /** Sanitized content with pattern references */\n  sanitizedContent: string;\n\n  /** Extracted pattern metadata */\n  patterns: SanitizedPattern[];\n\n  /** Number of patterns extracted */\n  patternCount: number;\n}\n\n/**\n * PatternExtractor service\n *\n * Extracts dangerous patterns from memory content and creates\n * sanitized versions suitable for display to LLMs.\n *\n * DI-COMPATIBLE: Instance-based service for dependency injection.\n */\nexport class PatternExtractor {\n  private patternCounter: number = 0;\n\n  /**\n   * Create a new PatternExtractor instance\n   *\n   * @param encryptor - PatternEncryptor instance for encrypting extracted patterns\n   */\n  constructor(private readonly encryptor: PatternEncryptor) {\n    logger.debug('PatternExtractor initialized');\n  }\n\n  /**\n   * Extract patterns from content based on validation results\n   *\n   * @param content - Original content containing patterns\n   * @param validationResult - Validation result with detected patterns\n   * @returns Extraction result with sanitized content and pattern metadata\n   */\n  extractPatterns(\n    content: string,\n    validationResult: ContentValidationResult\n  ): ExtractionResult {\n    logger.debug('Extracting patterns from content', {\n      contentLength: content.length,\n      detectedPatterns: validationResult.detectedPatterns?.length || 0,\n    });\n\n    // If no patterns detected, return content as-is\n    if (!validationResult.detectedPatterns || validationResult.detectedPatterns.length === 0) {\n      return {\n        sanitizedContent: content,\n        patterns: [],\n        patternCount: 0,\n      };\n    }\n\n    // Find all pattern matches in content\n    const matches = this.findPatternMatches(content, validationResult);\n\n    if (matches.length === 0) {\n      logger.debug('No pattern matches found in content');\n      return {\n        sanitizedContent: content,\n        patterns: [],\n        patternCount: 0,\n      };\n    }\n\n    logger.info('Found pattern matches', { count: matches.length });\n\n    // Create sanitized patterns with references\n    const sanitizedPatterns = matches.map((match) =>\n      this.createSanitizedPattern(match)\n    );\n\n    // Create sanitized content by replacing patterns with references\n    const sanitizedContent = this.createSanitizedContent(content, matches);\n\n    return {\n      sanitizedContent,\n      patterns: sanitizedPatterns,\n      patternCount: matches.length,\n    };\n  }\n\n  /**\n   * Find all pattern matches in content\n   *\n   * This uses heuristics to locate the detected patterns within the content.\n   * The ContentValidator tells us what patterns were detected, but not where.\n   * We need to search for them.\n   */\n  private findPatternMatches(\n    content: string,\n    validationResult: ContentValidationResult\n  ): PatternMatch[] {\n    const matches: PatternMatch[] = [];\n\n    // Get detected patterns from validation\n    const detectedPatterns = validationResult.detectedPatterns || [];\n\n    for (const patternType of detectedPatterns) {\n      // Use heuristics to find likely pattern locations\n      // FIX: Provide default severity 'low' when undefined\n      const severity = validationResult.severity || 'low';\n      const patternMatches = this.searchForPattern(content, patternType, severity);\n\n      matches.push(...patternMatches);\n    }\n\n    // Sort matches by position for proper replacement\n    matches.sort((a, b) => a.startOffset - b.startOffset);\n\n    return matches;\n  }\n\n  /**\n   * Search for a specific pattern type in content\n   *\n   * Uses common patterns and heuristics to locate dangerous content\n   */\n  private searchForPattern(\n    content: string,\n    patternType: string,\n    severity: 'critical' | 'high' | 'medium' | 'low' | 'info'\n  ): PatternMatch[] {\n    const matches: PatternMatch[] = [];\n\n    // Common injection pattern markers\n    const injectionMarkers = [\n      // LLM prompt injection markers\n      /(?:ignore|disregard|forget)[\\s\\S]{0,30}(?:previous|above|prior)\\s+(?:instructions|prompts|commands)/gi,\n      /system[\\s\\S]{0,10}prompt[\\s\\S]{0,10}[:=]/gi,\n      /new\\s+(?:instructions|task|role|mission)[\\s\\S]{0,10}:/gi,\n\n      // Code execution patterns\n      /eval\\s*\\(/gi,\n      /exec\\s*\\(/gi,\n      /subprocess\\./gi,\n      /shell_exec/gi,\n\n      // SQL injection patterns (flexible matching with .* for content between keywords)\n      /(?:union|select|insert|delete|update|drop)[\\s\\S]*?(?:table|from|into|database)/gi,\n      /'\\s*(?:or|and)\\s+['\"]?\\d+['\"]?\\s*=\\s*['\"]?\\d+/gi,\n\n      // Path traversal\n      /\\.\\.\\/|\\.\\.\\\\|\\.\\.[/\\\\]/g,\n\n      // XXE patterns\n      /<!ENTITY/gi,\n      /<!DOCTYPE[\\s\\S]+SYSTEM/gi,\n    ];\n\n    // Search for each marker pattern\n    for (const marker of injectionMarkers) {\n      let match;\n      const regex = new RegExp(marker);\n\n      while ((match = regex.exec(content)) !== null) {\n        const matchText = match[0];\n\n        matches.push({\n          pattern: matchText,\n          type: patternType,\n          severity: severity as 'critical' | 'high' | 'medium' | 'low',\n          startOffset: match.index,\n          length: matchText.length,\n          description: this.getPatternDescription(patternType, matchText),\n        });\n\n        // Prevent infinite loops on zero-length matches\n        if (regex.lastIndex === match.index) {\n          regex.lastIndex++;\n        }\n      }\n    }\n\n    return matches;\n  }\n\n  /**\n   * Create a sanitized pattern object with metadata\n   *\n   * Phase 2: Now encrypts patterns using AES-256-GCM\n   */\n  private createSanitizedPattern(\n    match: PatternMatch\n  ): SanitizedPattern {\n    const patternId = `PATTERN_${String(++this.patternCounter).padStart(3, '0')}`;\n\n    // Phase 2: Encrypt the pattern using AES-256-GCM\n    let encrypted = null;\n    try {\n      if (this.encryptor.isEnabled()) {\n        encrypted = this.encryptor.encrypt(match.pattern);\n        logger.debug('Pattern encrypted successfully', {\n          patternId,\n          algorithm: encrypted.algorithm,\n        });\n      } else {\n        logger.debug('Pattern encryption disabled, storing without encryption', {\n          patternId,\n        });\n      }\n    } catch (error) {\n      logger.error('Failed to encrypt pattern, storing without encryption', {\n        patternId,\n        error,\n      });\n      // Continue without encryption rather than failing\n    }\n\n    return {\n      ref: patternId,\n      description: match.description,\n      severity: match.severity,\n      location: `offset ${match.startOffset}, length ${match.length}`,\n      safetyInstruction: this.getSafetyInstruction(match.severity),\n      // Phase 2: Encryption fields (populated if encryption successful)\n      encryptedPattern: encrypted?.encryptedData,\n      algorithm: encrypted?.algorithm,\n      iv: encrypted?.iv,\n      authTag: encrypted?.authTag,\n    };\n  }\n\n  /**\n   * Create sanitized content by replacing patterns with references\n   */\n  private createSanitizedContent(\n    content: string,\n    matches: PatternMatch[]\n  ): string {\n    // Work backwards through matches to maintain correct offsets\n    let sanitized = content;\n    const sortedMatches = [...matches].sort((a, b) => b.startOffset - a.startOffset);\n\n    let patternIndex = sortedMatches.length;\n\n    for (const match of sortedMatches) {\n      const patternRef = `[PATTERN_${String(patternIndex).padStart(3, '0')}]`;\n      const beforePattern = sanitized.substring(0, match.startOffset);\n      const afterPattern = sanitized.substring(match.startOffset + match.length);\n\n      sanitized = beforePattern + patternRef + afterPattern;\n      patternIndex--;\n    }\n\n    return sanitized;\n  }\n\n  /**\n   * Get human-readable description for a pattern type\n   */\n  private getPatternDescription(patternType: string, matchText: string): string {\n    const descriptions: Record<string, string> = {\n      'prompt-injection': 'LLM prompt injection attempt',\n      'sql-injection': 'SQL injection pattern',\n      'code-injection': 'Code execution pattern',\n      'path-traversal': 'Path traversal attempt',\n      'xxe': 'XML External Entity (XXE) pattern',\n      'xss': 'Cross-site scripting (XSS) pattern',\n      'command-injection': 'Command injection pattern',\n    };\n\n    const description = descriptions[patternType] || `Security pattern: ${patternType}`;\n\n    // Truncate match text if too long\n    const truncatedMatch = matchText.length > 50\n      ? matchText.substring(0, 47) + '...'\n      : matchText;\n\n    return `${description} - \"${truncatedMatch}\"`;\n  }\n\n  /**\n   * Get safety instruction based on severity\n   */\n  private getSafetyInstruction(severity: string): string {\n    switch (severity) {\n      case 'critical':\n        return 'CRITICAL - DO NOT EXECUTE - This pattern is malicious and must never be used in production code';\n      case 'high':\n        return 'HIGH RISK - DO NOT EXECUTE - This pattern should only be used in security testing contexts';\n      case 'medium':\n        return 'WARNING - This pattern may be dangerous if misused - Use only for security validation';\n      case 'low':\n        return 'CAUTION - Review before use - May have security implications in certain contexts';\n      default:\n        return 'This pattern has been extracted for security purposes - Review before use';\n    }\n  }\n\n  /**\n   * Reset the pattern counter (useful for testing)\n   */\n  resetCounter(): void {\n    this.patternCounter = 0;\n  }\n\n  /**\n   * Dispose of the extractor and clean up resources\n   * Implements cleanup for proper DI lifecycle management\n   */\n  async dispose(): Promise<void> {\n    this.resetCounter();\n    logger.debug('PatternExtractor disposed');\n  }\n}\n"]}