@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/security/regexValidator.js

@@ -0,0 +1,214 @@
+/**
+ * RegexValidator - Provides protection against ReDoS attacks
+ *
+ * This module implements safe regex execution by:
+ * 1. Pre-validating content length based on pattern complexity
+ * 2. Analyzing patterns for known ReDoS vulnerabilities
+ * 3. Limiting execution based on calculated risk
+ */
+import { SecurityError } from './errors.js';
+import { SecurityMonitor } from './securityMonitor.js';
+export class RegexValidator {
+    // Default limits based on pattern complexity
+    static COMPLEXITY_LIMITS = {
+        low: 100000, // 100KB for simple patterns
+        medium: 10000, // 10KB for moderate patterns
+        high: 1000 // 1KB for complex patterns
+    };
+    /**
+     * Validates content against a pattern with ReDoS protection
+     *
+     * Protection strategy:
+     * 1. Analyze pattern complexity
+     * 2. Enforce content length limits based on complexity
+     * 3. Reject known dangerous patterns
+     * 4. Execute regex only if safe
+     */
+    static validate(content, pattern, options = {}) {
+        const { maxLength, rejectDangerousPatterns = true, logEvents = true } = options;
+        // Analyze pattern for ReDoS risks
+        const analysis = this.analyzePattern(pattern);
+        // Reject dangerous patterns if configured
+        if (rejectDangerousPatterns && !analysis.safe) {
+            if (logEvents) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'UPDATE_SECURITY_VIOLATION',
+                    severity: 'HIGH',
+                    source: 'RegexValidator',
+                    details: 'Dangerous regex pattern rejected',
+                    additionalData: {
+                        pattern: pattern.source,
+                        risks: analysis.risks
+                    }
+                });
+            }
+            throw new SecurityError(`Pattern rejected due to ReDoS risk: ${analysis.risks.join(', ')}`);
+        }
+        // Determine effective max length
+        const effectiveMaxLength = maxLength ?? analysis.maxSafeLength;
+        // Check content length
+        if (content.length > effectiveMaxLength) {
+            throw new SecurityError(`Content too large for validation: ${content.length} bytes (max: ${effectiveMaxLength} for ${analysis.complexity} complexity pattern)`);
+        }
+        // Create a copy of the regex to avoid modifying the original
+        const safeCopy = new RegExp(pattern.source, pattern.flags);
+        try {
+            // Track execution time for monitoring
+            const startTime = performance.now();
+            const result = safeCopy.test(content);
+            const elapsed = performance.now() - startTime;
+            // Log slow patterns
+            if (elapsed > 50 && logEvents) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'RATE_LIMIT_WARNING',
+                    severity: 'MEDIUM',
+                    source: 'RegexValidator',
+                    details: `Slow regex execution: ${elapsed.toFixed(2)}ms`,
+                    additionalData: {
+                        pattern: pattern.source,
+                        contentLength: content.length,
+                        elapsed
+                    }
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            // Handle any regex errors
+            if (logEvents) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'UPDATE_SECURITY_VIOLATION',
+                    severity: 'HIGH',
+                    source: 'RegexValidator',
+                    details: 'Regex execution error',
+                    additionalData: {
+                        error: error instanceof Error ? error.message : 'Unknown error'
+                    }
+                });
+            }
+            return false;
+        }
+    }
+    /**
+     * Validates multiple patterns with shared risk assessment
+     */
+    static validateAny(content, patterns, options = {}) {
+        for (const pattern of patterns) {
+            if (this.validate(content, pattern, options)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Validates all patterns must match
+     */
+    static validateAll(content, patterns, options = {}) {
+        for (const pattern of patterns) {
+            if (!this.validate(content, pattern, options)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Analyzes a regex pattern for potential ReDoS vulnerabilities
+     *
+     * Detects patterns known to cause exponential backtracking:
+     * - Nested quantifiers: (a+)+, (a*)*
+     * - Alternation with overlap: (a|a)*
+     * - Quantified groups with alternation: (a|b)+
+     * - Catastrophic patterns: (.+)+$
+     */
+    static analyzePattern(pattern) {
+        const source = pattern.source;
+        const risks = [];
+        // Nested quantifiers - extremely dangerous
+        if (/\([^)]+[+*]\)[+*]/.test(source) ||
+            /\([^)]+\{[^}]+\}\)[+*]/.test(source) ||
+            /\(\w+[+*]\)[+*]/.test(source)) {
+            risks.push('Nested quantifiers detected');
+        }
+        // Alternation with repetition
+        if (/\([^)]*\|[^)]*\)[+*]/.test(source)) {
+            risks.push('Quantified alternation detected');
+        }
+        // Alternation with overlap (e.g., (a|a)*)
+        const alternationMatch = source.match(/\(([^|)]+)\|([^)]+)\)/g);
+        if (alternationMatch) {
+            for (const match of alternationMatch) {
+                const parts = match.slice(1, -1).split('|');
+                if (parts.some((part, i) => parts.slice(i + 1).includes(part))) {
+                    risks.push('Overlapping alternation detected');
+                    break;
+                }
+            }
+        }
+        // Catastrophic backtracking patterns
+        // Check for patterns like (.+)+, (.*)+, etc. that can cause exponential backtracking
+        if (/\([^)]*\.\+[^)]*\)\+/.test(source) || /\([^)]*\.\*[^)]*\)\+/.test(source) || /\([^)]*\\w\+[^)]*\)\+/.test(source)) {
+            risks.push('Potential catastrophic backtracking');
+        }
+        // Unbounded lookahead/lookbehind with quantifiers
+        if (/\(\?[=!<].*[+*]/.test(source)) {
+            risks.push('Unbounded lookahead/lookbehind');
+        }
+        // Polynomial patterns (multiple quantifiers in sequence)
+        const quantifierCount = (source.match(/[+*?]|\{\d*,?\d*\}/g) || []).length;
+        if (quantifierCount > 3) {
+            risks.push('Multiple quantifiers detected');
+        }
+        // Determine complexity and safe content length
+        let complexity;
+        let maxSafeLength;
+        if (risks.length === 0) {
+            if (quantifierCount === 0) {
+                complexity = 'low';
+                maxSafeLength = this.COMPLEXITY_LIMITS.low;
+            }
+            else if (quantifierCount <= 3) {
+                complexity = 'medium';
+                maxSafeLength = this.COMPLEXITY_LIMITS.medium;
+            }
+            else {
+                complexity = 'high';
+                maxSafeLength = this.COMPLEXITY_LIMITS.high;
+            }
+        }
+        else if (risks.length === 1) {
+            complexity = 'high';
+            maxSafeLength = this.COMPLEXITY_LIMITS.high;
+        }
+        else {
+            complexity = 'high';
+            maxSafeLength = this.COMPLEXITY_LIMITS.high;
+        }
+        return {
+            safe: risks.length === 0,
+            risks,
+            complexity,
+            maxSafeLength
+        };
+    }
+    /**
+     * Creates a regex pattern with safety analysis
+     */
+    static createSafePattern(pattern, flags) {
+        const regex = new RegExp(pattern, flags);
+        const analysis = this.analyzePattern(regex);
+        if (!analysis.safe) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'UPDATE_SECURITY_VIOLATION',
+                severity: 'MEDIUM',
+                source: 'RegexValidator',
+                details: 'Potentially dangerous regex pattern created',
+                additionalData: {
+                    pattern,
+                    risks: analysis.risks
+                }
+            });
+        }
+        return regex;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"regexValidator.js","sourceRoot":"","sources":["../../../../src/security/regexValidator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RegexValidator - Provides protection against ReDoS attacks\n * \n * This module implements safe regex execution by:\n * 1. Pre-validating content length based on pattern complexity\n * 2. Analyzing patterns for known ReDoS vulnerabilities\n * 3. Limiting execution based on calculated risk\n */\n\nimport { SecurityError } from './errors.js';\nimport { SecurityMonitor } from './securityMonitor.js';\n\nexport interface RegexValidationOptions {\n  /** Maximum content length allowed */\n  maxLength?: number;\n  /** Reject patterns with high ReDoS risk */\n  rejectDangerousPatterns?: boolean;\n  /** Log security events */\n  logEvents?: boolean;\n}\n\ninterface PatternAnalysis {\n  safe: boolean;\n  risks: string[];\n  complexity: 'low' | 'medium' | 'high';\n  maxSafeLength: number;\n}\n\nexport class RegexValidator {\n  // Default limits based on pattern complexity\n  private static readonly COMPLEXITY_LIMITS = {\n    low: 100000,    // 100KB for simple patterns\n    medium: 10000,  // 10KB for moderate patterns\n    high: 1000      // 1KB for complex patterns\n  };\n\n  /**\n   * Validates content against a pattern with ReDoS protection\n   * \n   * Protection strategy:\n   * 1. Analyze pattern complexity\n   * 2. Enforce content length limits based on complexity\n   * 3. Reject known dangerous patterns\n   * 4. Execute regex only if safe\n   */\n  static validate(\n    content: string,\n    pattern: RegExp,\n    options: RegexValidationOptions = {}\n  ): boolean {\n    const {\n      maxLength,\n      rejectDangerousPatterns = true,\n      logEvents = true\n    } = options;\n\n    // Analyze pattern for ReDoS risks\n    const analysis = this.analyzePattern(pattern);\n    \n    // Reject dangerous patterns if configured\n    if (rejectDangerousPatterns && !analysis.safe) {\n      if (logEvents) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'UPDATE_SECURITY_VIOLATION',\n          severity: 'HIGH',\n          source: 'RegexValidator',\n          details: 'Dangerous regex pattern rejected',\n          additionalData: {\n            pattern: pattern.source,\n            risks: analysis.risks\n          }\n        });\n      }\n      throw new SecurityError(\n        `Pattern rejected due to ReDoS risk: ${analysis.risks.join(', ')}`\n      );\n    }\n\n    // Determine effective max length\n    const effectiveMaxLength = maxLength ?? analysis.maxSafeLength;\n    \n    // Check content length\n    if (content.length > effectiveMaxLength) {\n      throw new SecurityError(\n        `Content too large for validation: ${content.length} bytes (max: ${effectiveMaxLength} for ${analysis.complexity} complexity pattern)`\n      );\n    }\n\n    // Create a copy of the regex to avoid modifying the original\n    const safeCopy = new RegExp(pattern.source, pattern.flags);\n    \n    try {\n      // Track execution time for monitoring\n      const startTime = performance.now();\n      const result = safeCopy.test(content);\n      const elapsed = performance.now() - startTime;\n\n      // Log slow patterns\n      if (elapsed > 50 && logEvents) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'RATE_LIMIT_WARNING',\n          severity: 'MEDIUM',\n          source: 'RegexValidator',\n          details: `Slow regex execution: ${elapsed.toFixed(2)}ms`,\n          additionalData: {\n            pattern: pattern.source,\n            contentLength: content.length,\n            elapsed\n          }\n        });\n      }\n\n      return result;\n    } catch (error) {\n      // Handle any regex errors\n      if (logEvents) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'UPDATE_SECURITY_VIOLATION',\n          severity: 'HIGH',\n          source: 'RegexValidator',\n          details: 'Regex execution error',\n          additionalData: {\n            error: error instanceof Error ? error.message : 'Unknown error'\n          }\n        });\n      }\n      return false;\n    }\n  }\n\n  /**\n   * Validates multiple patterns with shared risk assessment\n   */\n  static validateAny(\n    content: string,\n    patterns: RegExp[],\n    options: RegexValidationOptions = {}\n  ): boolean {\n    for (const pattern of patterns) {\n      if (this.validate(content, pattern, options)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Validates all patterns must match\n   */\n  static validateAll(\n    content: string,\n    patterns: RegExp[],\n    options: RegexValidationOptions = {}\n  ): boolean {\n    for (const pattern of patterns) {\n      if (!this.validate(content, pattern, options)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Analyzes a regex pattern for potential ReDoS vulnerabilities\n   * \n   * Detects patterns known to cause exponential backtracking:\n   * - Nested quantifiers: (a+)+, (a*)*\n   * - Alternation with overlap: (a|a)*\n   * - Quantified groups with alternation: (a|b)+\n   * - Catastrophic patterns: (.+)+$\n   */\n  static analyzePattern(pattern: RegExp): PatternAnalysis {\n    const source = pattern.source;\n    const risks: string[] = [];\n    \n    // Nested quantifiers - extremely dangerous\n    if (/\\([^)]+[+*]\\)[+*]/.test(source) || \n        /\\([^)]+\\{[^}]+\\}\\)[+*]/.test(source) ||\n        /\\(\\w+[+*]\\)[+*]/.test(source)) {\n      risks.push('Nested quantifiers detected');\n    }\n\n    // Alternation with repetition\n    if (/\\([^)]*\\|[^)]*\\)[+*]/.test(source)) {\n      risks.push('Quantified alternation detected');\n    }\n\n    // Alternation with overlap (e.g., (a|a)*)\n    const alternationMatch = source.match(/\\(([^|)]+)\\|([^)]+)\\)/g);\n    if (alternationMatch) {\n      for (const match of alternationMatch) {\n        const parts = match.slice(1, -1).split('|');\n        if (parts.some((part, i) => parts.slice(i + 1).includes(part))) {\n          risks.push('Overlapping alternation detected');\n          break;\n        }\n      }\n    }\n\n    // Catastrophic backtracking patterns\n    // Check for patterns like (.+)+, (.*)+, etc. that can cause exponential backtracking\n    if (/\\([^)]*\\.\\+[^)]*\\)\\+/.test(source) || /\\([^)]*\\.\\*[^)]*\\)\\+/.test(source) || /\\([^)]*\\\\w\\+[^)]*\\)\\+/.test(source)) {\n      risks.push('Potential catastrophic backtracking');\n    }\n\n    // Unbounded lookahead/lookbehind with quantifiers\n    if (/\\(\\?[=!<].*[+*]/.test(source)) {\n      risks.push('Unbounded lookahead/lookbehind');\n    }\n\n    // Polynomial patterns (multiple quantifiers in sequence)\n    const quantifierCount = (source.match(/[+*?]|\\{\\d*,?\\d*\\}/g) || []).length;\n    if (quantifierCount > 3) {\n      risks.push('Multiple quantifiers detected');\n    }\n\n    // Determine complexity and safe content length\n    let complexity: 'low' | 'medium' | 'high';\n    let maxSafeLength: number;\n    \n    if (risks.length === 0) {\n      if (quantifierCount === 0) {\n        complexity = 'low';\n        maxSafeLength = this.COMPLEXITY_LIMITS.low;\n      } else if (quantifierCount <= 3) {\n        complexity = 'medium';\n        maxSafeLength = this.COMPLEXITY_LIMITS.medium;\n      } else {\n        complexity = 'high';\n        maxSafeLength = this.COMPLEXITY_LIMITS.high;\n      }\n    } else if (risks.length === 1) {\n      complexity = 'high';\n      maxSafeLength = this.COMPLEXITY_LIMITS.high;\n    } else {\n      complexity = 'high';\n      maxSafeLength = this.COMPLEXITY_LIMITS.high;\n    }\n\n    return {\n      safe: risks.length === 0,\n      risks,\n      complexity,\n      maxSafeLength\n    };\n  }\n\n  /**\n   * Creates a regex pattern with safety analysis\n   */\n  static createSafePattern(pattern: string, flags?: string): RegExp {\n    const regex = new RegExp(pattern, flags);\n    const analysis = this.analyzePattern(regex);\n    \n    if (!analysis.safe) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'UPDATE_SECURITY_VIOLATION',\n        severity: 'MEDIUM',\n        source: 'RegexValidator',\n        details: 'Potentially dangerous regex pattern created',\n        additionalData: {\n          pattern,\n          risks: analysis.risks\n        }\n      });\n    }\n    \n    return regex;\n  }\n}"]}

package/dist/test/src/security/secureYamlParser.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Secure YAML Parser for DollhouseMCP
+ *
+ * Provides safe YAML parsing that prevents deserialization attacks
+ * by using a restricted schema and pre-validation.
+ *
+ * Security: SEC-003 - YAML parsing vulnerability protection
+ */
+import matter from 'gray-matter';
+export interface SecureParseOptions {
+    maxYamlSize?: number;
+    maxContentSize?: number;
+    allowedKeys?: string[];
+    validateContent?: boolean;
+}
+export interface ParsedContent {
+    data: Record<string, any>;
+    content: string;
+    excerpt?: string;
+}
+export declare class SecureYamlParser {
+    private static readonly DEFAULT_OPTIONS;
+    private static readonly SAFE_SCHEMA;
+    private static readonly FIELD_VALIDATORS;
+    /**
+     * Securely parse content with YAML frontmatter
+     */
+    static parse(input: string, options?: SecureParseOptions): ParsedContent;
+    /**
+     * Create a secure gray-matter compatible parser
+     */
+    static createSecureMatterParser(): {
+        parse: (input: string) => {
+            data: Record<string, any>;
+            content: string;
+            excerpt: string | undefined;
+            orig: string;
+        };
+        stringify: (content: string, data: any) => string;
+    };
+    /**
+     * Safe wrapper for gray-matter with security validations
+     */
+    static safeMatter(input: string, options?: matter.GrayMatterOption<string, any>): matter.GrayMatterFile<string>;
+}
+//# sourceMappingURL=secureYamlParser.d.ts.map

package/dist/test/src/security/secureYamlParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secureYamlParser.d.ts","sourceRoot":"","sources":["../../../../src/security/secureYamlParser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,MAAM,MAAM,aAAa,CAAC;AAKjC,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAIrC;IAGF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAwB;IAG3D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAatC;IAEF;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,aAAa;IA8G5E;;OAEG;IACH,MAAM,CAAC,wBAAwB;uBAEZ,MAAM;;;;;;6BASA,MAAM,QAAQ,GAAG;;IAoB1C;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC;CAgChH"}

package/dist/test/src/security/secureYamlParser.js

@@ -0,0 +1,203 @@
+/**
+ * Secure YAML Parser for DollhouseMCP
+ *
+ * Provides safe YAML parsing that prevents deserialization attacks
+ * by using a restricted schema and pre-validation.
+ *
+ * Security: SEC-003 - YAML parsing vulnerability protection
+ */
+import * as yaml from 'js-yaml';
+import matter from 'gray-matter';
+import { SecurityError } from '../errors/SecurityError.js';
+import { ContentValidator } from './contentValidator.js';
+import { SecurityMonitor } from './securityMonitor.js';
+export class SecureYamlParser {
+    static DEFAULT_OPTIONS = {
+        maxYamlSize: 64 * 1024, // 64KB for YAML
+        maxContentSize: 1024 * 1024, // 1MB for content
+        validateContent: true
+    };
+    // Allowed YAML types - using FAILSAFE_SCHEMA as base
+    static SAFE_SCHEMA = yaml.FAILSAFE_SCHEMA;
+    // Additional validation for specific persona fields
+    static FIELD_VALIDATORS = {
+        name: (v) => typeof v === 'string' && v.length <= 100,
+        description: (v) => typeof v === 'string' && v.length <= 500,
+        author: (v) => typeof v === 'string' && v.length <= 100,
+        version: (v) => typeof v === 'string' && /^\d+\.\d+(\.\d+)?(-[a-zA-Z0-9.-]+)?$/.test(v),
+        category: (v) => typeof v === 'string' && v.length <= 50,
+        age_rating: (v) => ['all', '13+', '18+'].includes(v),
+        price: (v) => typeof v === 'string' && (v === 'free' || /^\$\d+\.\d{2}$/.test(v)),
+        ai_generated: (v) => typeof v === 'boolean' || v === 'true' || v === 'false',
+        generation_method: (v) => ['human', 'ChatGPT', 'Claude', 'hybrid'].includes(v),
+        created_date: (v) => typeof v === 'string' && !isNaN(Date.parse(v)),
+        triggers: (v) => Array.isArray(v) && v.every(t => typeof t === 'string' && t.length <= 50),
+        content_flags: (v) => Array.isArray(v) && v.every(f => typeof f === 'string' && f.length <= 50)
+    };
+    /**
+     * Securely parse content with YAML frontmatter
+     */
+    static parse(input, options = {}) {
+        const opts = { ...this.DEFAULT_OPTIONS, ...options };
+        // 1. Size validation
+        if (input.length > (opts.maxContentSize || this.DEFAULT_OPTIONS.maxContentSize)) {
+            throw new SecurityError('Content exceeds maximum allowed size', 'medium');
+        }
+        // 2. Extract frontmatter boundaries
+        const frontmatterMatch = input.match(/^---\n([\s\S]*?)\n---/);
+        if (!frontmatterMatch) {
+            // No frontmatter, return empty data
+            return {
+                data: {},
+                content: input
+            };
+        }
+        const yamlContent = frontmatterMatch[1];
+        const markdownContent = input.substring(frontmatterMatch[0].length);
+        // 3. Validate YAML size
+        if (yamlContent.length > (opts.maxYamlSize || this.DEFAULT_OPTIONS.maxYamlSize)) {
+            throw new SecurityError('YAML frontmatter exceeds maximum allowed size', 'medium');
+        }
+        // 4. Pre-parse security validation
+        if (!ContentValidator.validateYamlContent(yamlContent)) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'YAML_INJECTION_ATTEMPT',
+                severity: 'CRITICAL',
+                source: 'secure_yaml_parser',
+                details: 'Malicious YAML pattern detected during parsing'
+            });
+            throw new SecurityError('Malicious YAML content detected', 'critical');
+        }
+        // 5. Parse with safe schema
+        let data;
+        try {
+            data = yaml.load(yamlContent, {
+                schema: this.SAFE_SCHEMA,
+                json: false, // Don't allow JSON-specific types
+                onWarning: (warning) => {
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'YAML_PARSING_WARNING',
+                        severity: 'LOW',
+                        source: 'secure_yaml_parser',
+                        details: `YAML warning: ${warning.message}`
+                    });
+                }
+            });
+        }
+        catch (error) {
+            throw new SecurityError(`YAML parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'high');
+        }
+        // 6. Ensure data is an object
+        if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+            throw new SecurityError('YAML must contain an object at root level', 'medium');
+        }
+        // 7. Validate allowed keys if specified
+        if (opts.allowedKeys) {
+            const invalidKeys = Object.keys(data).filter(key => !opts.allowedKeys.includes(key));
+            if (invalidKeys.length > 0) {
+                throw new SecurityError(`Invalid YAML keys detected: ${invalidKeys.join(', ')}`, 'medium');
+            }
+        }
+        // 8. Validate field types and content
+        for (const [key, value] of Object.entries(data)) {
+            // Check field-specific validators
+            if (this.FIELD_VALIDATORS[key] && !this.FIELD_VALIDATORS[key](value)) {
+                throw new SecurityError(`Invalid value for field '${key}'`, 'medium');
+            }
+            // Validate string fields for injection patterns
+            if (typeof value === 'string' && opts.validateContent) {
+                const validation = ContentValidator.validateAndSanitize(value);
+                if (!validation.isValid && validation.severity === 'critical') {
+                    throw new SecurityError(`Security threat detected in field '${key}'`, 'critical');
+                }
+                // Replace with sanitized content
+                data[key] = validation.sanitizedContent;
+            }
+        }
+        // 9. Validate markdown content if requested
+        let finalContent = markdownContent;
+        if (opts.validateContent) {
+            const contentValidation = ContentValidator.validateAndSanitize(markdownContent);
+            if (!contentValidation.isValid && contentValidation.severity === 'critical') {
+                throw new SecurityError('Security threat detected in content', 'critical');
+            }
+            finalContent = contentValidation.sanitizedContent || markdownContent;
+        }
+        SecurityMonitor.logSecurityEvent({
+            type: 'YAML_PARSE_SUCCESS',
+            severity: 'LOW',
+            source: 'secure_yaml_parser',
+            details: `Successfully parsed YAML with ${Object.keys(data).length} fields`
+        });
+        return {
+            data,
+            content: finalContent
+        };
+    }
+    /**
+     * Create a secure gray-matter compatible parser
+     */
+    static createSecureMatterParser() {
+        return {
+            parse: (input) => {
+                const result = this.parse(input);
+                return {
+                    data: result.data,
+                    content: result.content,
+                    excerpt: result.excerpt,
+                    orig: input
+                };
+            },
+            stringify: (content, data) => {
+                // Validate data before stringifying
+                const validation = ContentValidator.validateMetadata(data);
+                if (!validation.isValid) {
+                    throw new SecurityError('Cannot stringify content with security threats', 'high');
+                }
+                // Use safe YAML dump
+                const yamlStr = yaml.dump(data, {
+                    schema: this.SAFE_SCHEMA,
+                    skipInvalid: true,
+                    noRefs: true,
+                    noCompatMode: true
+                });
+                return `---\n${yamlStr}---\n${content}`;
+            }
+        };
+    }
+    /**
+     * Safe wrapper for gray-matter with security validations
+     */
+    static safeMatter(input, options) {
+        // First, use our secure parser
+        const secureParsed = this.parse(input);
+        // Then use gray-matter with custom engines
+        return matter(input, {
+            ...options,
+            engines: {
+                yaml: {
+                    parse: (str) => {
+                        // Use our secure YAML parsing
+                        const parsed = yaml.load(str, {
+                            schema: this.SAFE_SCHEMA,
+                            json: false
+                        });
+                        // Ensure it's an object
+                        if (typeof parsed !== 'object' || parsed === null) {
+                            return {};
+                        }
+                        return parsed;
+                    },
+                    stringify: (obj) => {
+                        return yaml.dump(obj, {
+                            schema: this.SAFE_SCHEMA,
+                            skipInvalid: true,
+                            noRefs: true
+                        });
+                    }
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secureYamlParser.js","sourceRoot":"","sources":["../../../../src/security/secureYamlParser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Secure YAML Parser for DollhouseMCP\n * \n * Provides safe YAML parsing that prevents deserialization attacks\n * by using a restricted schema and pre-validation.\n * \n * Security: SEC-003 - YAML parsing vulnerability protection\n */\n\nimport * as yaml from 'js-yaml';\nimport matter from 'gray-matter';\nimport { SecurityError } from '../errors/SecurityError.js';\nimport { ContentValidator } from './contentValidator.js';\nimport { SecurityMonitor } from './securityMonitor.js';\n\nexport interface SecureParseOptions {\n  maxYamlSize?: number;\n  maxContentSize?: number;\n  allowedKeys?: string[];\n  validateContent?: boolean;\n}\n\nexport interface ParsedContent {\n  data: Record<string, any>;\n  content: string;\n  excerpt?: string;\n}\n\nexport class SecureYamlParser {\n  private static readonly DEFAULT_OPTIONS: SecureParseOptions = {\n    maxYamlSize: 64 * 1024,      // 64KB for YAML\n    maxContentSize: 1024 * 1024,  // 1MB for content\n    validateContent: true\n  };\n\n  // Allowed YAML types - using FAILSAFE_SCHEMA as base\n  private static readonly SAFE_SCHEMA = yaml.FAILSAFE_SCHEMA;\n\n  // Additional validation for specific persona fields\n  private static readonly FIELD_VALIDATORS: Record<string, (value: any) => boolean> = {\n    name: (v) => typeof v === 'string' && v.length <= 100,\n    description: (v) => typeof v === 'string' && v.length <= 500,\n    author: (v) => typeof v === 'string' && v.length <= 100,\n    version: (v) => typeof v === 'string' && /^\\d+\\.\\d+(\\.\\d+)?(-[a-zA-Z0-9.-]+)?$/.test(v),\n    category: (v) => typeof v === 'string' && v.length <= 50,\n    age_rating: (v) => ['all', '13+', '18+'].includes(v),\n    price: (v) => typeof v === 'string' && (v === 'free' || /^\\$\\d+\\.\\d{2}$/.test(v)),\n    ai_generated: (v) => typeof v === 'boolean' || v === 'true' || v === 'false',\n    generation_method: (v) => ['human', 'ChatGPT', 'Claude', 'hybrid'].includes(v),\n    created_date: (v) => typeof v === 'string' && !isNaN(Date.parse(v)),\n    triggers: (v) => Array.isArray(v) && v.every(t => typeof t === 'string' && t.length <= 50),\n    content_flags: (v) => Array.isArray(v) && v.every(f => typeof f === 'string' && f.length <= 50)\n  };\n\n  /**\n   * Securely parse content with YAML frontmatter\n   */\n  static parse(input: string, options: SecureParseOptions = {}): ParsedContent {\n    const opts = { ...this.DEFAULT_OPTIONS, ...options };\n\n    // 1. Size validation\n    if (input.length > (opts.maxContentSize || this.DEFAULT_OPTIONS.maxContentSize!)) {\n      throw new SecurityError('Content exceeds maximum allowed size', 'medium');\n    }\n\n    // 2. Extract frontmatter boundaries\n    const frontmatterMatch = input.match(/^---\\n([\\s\\S]*?)\\n---/);\n    if (!frontmatterMatch) {\n      // No frontmatter, return empty data\n      return {\n        data: {},\n        content: input\n      };\n    }\n\n    const yamlContent = frontmatterMatch[1];\n    const markdownContent = input.substring(frontmatterMatch[0].length);\n\n    // 3. Validate YAML size\n    if (yamlContent.length > (opts.maxYamlSize || this.DEFAULT_OPTIONS.maxYamlSize!)) {\n      throw new SecurityError('YAML frontmatter exceeds maximum allowed size', 'medium');\n    }\n\n    // 4. Pre-parse security validation\n    if (!ContentValidator.validateYamlContent(yamlContent)) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'YAML_INJECTION_ATTEMPT',\n        severity: 'CRITICAL',\n        source: 'secure_yaml_parser',\n        details: 'Malicious YAML pattern detected during parsing'\n      });\n      throw new SecurityError('Malicious YAML content detected', 'critical');\n    }\n\n    // 5. Parse with safe schema\n    let data: any;\n    try {\n      data = yaml.load(yamlContent, {\n        schema: this.SAFE_SCHEMA,\n        json: false,  // Don't allow JSON-specific types\n        onWarning: (warning) => {\n          SecurityMonitor.logSecurityEvent({\n            type: 'YAML_PARSING_WARNING',\n            severity: 'LOW',\n            source: 'secure_yaml_parser',\n            details: `YAML warning: ${warning.message}`\n          });\n        }\n      });\n    } catch (error) {\n      throw new SecurityError(`YAML parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'high');\n    }\n\n    // 6. Ensure data is an object\n    if (typeof data !== 'object' || data === null || Array.isArray(data)) {\n      throw new SecurityError('YAML must contain an object at root level', 'medium');\n    }\n\n    // 7. Validate allowed keys if specified\n    if (opts.allowedKeys) {\n      const invalidKeys = Object.keys(data).filter(key => !opts.allowedKeys!.includes(key));\n      if (invalidKeys.length > 0) {\n        throw new SecurityError(`Invalid YAML keys detected: ${invalidKeys.join(', ')}`, 'medium');\n      }\n    }\n\n    // 8. Validate field types and content\n    for (const [key, value] of Object.entries(data)) {\n      // Check field-specific validators\n      if (this.FIELD_VALIDATORS[key] && !this.FIELD_VALIDATORS[key](value)) {\n        throw new SecurityError(`Invalid value for field '${key}'`, 'medium');\n      }\n\n      // Validate string fields for injection patterns\n      if (typeof value === 'string' && opts.validateContent) {\n        const validation = ContentValidator.validateAndSanitize(value);\n        if (!validation.isValid && validation.severity === 'critical') {\n          throw new SecurityError(`Security threat detected in field '${key}'`, 'critical');\n        }\n        // Replace with sanitized content\n        data[key] = validation.sanitizedContent;\n      }\n    }\n\n    // 9. Validate markdown content if requested\n    let finalContent = markdownContent;\n    if (opts.validateContent) {\n      const contentValidation = ContentValidator.validateAndSanitize(markdownContent);\n      if (!contentValidation.isValid && contentValidation.severity === 'critical') {\n        throw new SecurityError('Security threat detected in content', 'critical');\n      }\n      finalContent = contentValidation.sanitizedContent || markdownContent;\n    }\n\n    SecurityMonitor.logSecurityEvent({\n      type: 'YAML_PARSE_SUCCESS',\n      severity: 'LOW',\n      source: 'secure_yaml_parser',\n      details: `Successfully parsed YAML with ${Object.keys(data).length} fields`\n    });\n\n    return {\n      data,\n      content: finalContent\n    };\n  }\n\n  /**\n   * Create a secure gray-matter compatible parser\n   */\n  static createSecureMatterParser() {\n    return {\n      parse: (input: string) => {\n        const result = this.parse(input);\n        return {\n          data: result.data,\n          content: result.content,\n          excerpt: result.excerpt,\n          orig: input\n        };\n      },\n      stringify: (content: string, data: any) => {\n        // Validate data before stringifying\n        const validation = ContentValidator.validateMetadata(data);\n        if (!validation.isValid) {\n          throw new SecurityError('Cannot stringify content with security threats', 'high');\n        }\n\n        // Use safe YAML dump\n        const yamlStr = yaml.dump(data, {\n          schema: this.SAFE_SCHEMA,\n          skipInvalid: true,\n          noRefs: true,\n          noCompatMode: true\n        });\n\n        return `---\\n${yamlStr}---\\n${content}`;\n      }\n    };\n  }\n\n  /**\n   * Safe wrapper for gray-matter with security validations\n   */\n  static safeMatter(input: string, options?: matter.GrayMatterOption<string, any>): matter.GrayMatterFile<string> {\n    // First, use our secure parser\n    const secureParsed = this.parse(input);\n\n    // Then use gray-matter with custom engines\n    return matter(input, {\n      ...options,\n      engines: {\n        yaml: {\n          parse: (str: string) => {\n            // Use our secure YAML parsing\n            const parsed = yaml.load(str, {\n              schema: this.SAFE_SCHEMA,\n              json: false\n            });\n            // Ensure it's an object\n            if (typeof parsed !== 'object' || parsed === null) {\n              return {};\n            }\n            return parsed as object;\n          },\n          stringify: (obj: any) => {\n            return yaml.dump(obj, {\n              schema: this.SAFE_SCHEMA,\n              skipInvalid: true,\n              noRefs: true\n            });\n          }\n        }\n      }\n    });\n  }\n}"]}

package/dist/test/src/security/securityMonitor.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Security Monitor for DollhouseMCP
+ *
+ * Centralized security event logging and monitoring system
+ * for tracking and alerting on security-related events.
+ */
+export interface SecurityEvent {
+    type: 'CONTENT_INJECTION_ATTEMPT' | 'YAML_INJECTION_ATTEMPT' | 'PATH_TRAVERSAL_ATTEMPT' | 'TOKEN_VALIDATION_FAILURE' | 'UPDATE_SECURITY_VIOLATION' | 'RATE_LIMIT_EXCEEDED' | 'YAML_PARSING_WARNING' | 'YAML_PARSE_SUCCESS' | 'TOKEN_VALIDATION_SUCCESS' | 'RATE_LIMIT_WARNING' | 'TOKEN_CACHE_CLEARED' | 'YAML_UNICODE_ATTACK' | 'UNICODE_DIRECTION_OVERRIDE' | 'UNICODE_MIXED_SCRIPT' | 'UNICODE_VALIDATION_ERROR' | 'CONTENT_SIZE_EXCEEDED' | 'INCLUDE_DEPTH_EXCEEDED' | 'TEMPLATE_RENDERED' | 'TEMPLATE_INCLUDE' | 'TEMPLATE_LOADED' | 'TEMPLATE_SAVED' | 'TEMPLATE_DELETED' | 'MEMORY_CREATED' | 'MEMORY_ADDED' | 'MEMORY_SEARCHED' | 'SENSITIVE_MEMORY_DELETED' | 'RETENTION_POLICY_ENFORCED' | 'MEMORY_CLEARED' | 'MEMORY_LOADED' | 'MEMORY_SAVED' | 'MEMORY_DELETED' | 'MEMORY_LOAD_FAILED' | 'MEMORY_SAVE_FAILED' | 'MEMORY_LIST_ITEM_FAILED' | 'MEMORY_IMPORT_FAILED' | 'MEMORY_DESERIALIZE_FAILED' | 'ELEMENT_CREATED' | 'ELEMENT_DELETED' | 'AGENT_DECISION' | 'RULE_ENGINE_CONFIG_UPDATE' | 'RULE_ENGINE_CONFIG_VALIDATION_ERROR' | 'GOAL_TEMPLATE_APPLIED' | 'GOAL_TEMPLATE_VALIDATION';
+    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+    source: string;
+    details: string;
+    userAgent?: string;
+    ip?: string;
+    additionalData?: Record<string, any>;
+}
+export interface SecurityLogEntry extends SecurityEvent {
+    timestamp: string;
+    id: string;
+}
+export declare class SecurityMonitor {
+    private static eventCount;
+    private static readonly events;
+    private static readonly MAX_EVENTS;
+    /**
+     * Logs a security event
+     */
+    static logSecurityEvent(event: SecurityEvent): void;
+    /**
+     * Sends security alerts for critical events
+     */
+    private static sendSecurityAlert;
+    /**
+     * Gets recent security events for analysis
+     */
+    static getRecentEvents(count?: number): SecurityLogEntry[];
+    /**
+     * Gets events by severity
+     */
+    static getEventsBySeverity(severity: SecurityEvent['severity']): SecurityLogEntry[];
+    /**
+     * Gets events by type
+     */
+    static getEventsByType(type: SecurityEvent['type']): SecurityLogEntry[];
+    /**
+     * Generates a security report
+     */
+    static generateSecurityReport(): {
+        totalEvents: number;
+        eventsBySeverity: Record<string, number>;
+        eventsByType: Record<string, number>;
+        recentCriticalEvents: SecurityLogEntry[];
+    };
+    /**
+     * Clears old events (for memory management)
+     */
+    static clearOldEvents(daysToKeep?: number): void;
+}
+//# sourceMappingURL=securityMonitor.d.ts.map

package/dist/test/src/security/securityMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"securityMonitor.d.ts","sourceRoot":"","sources":["../../../../src/security/securityMonitor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,2BAA2B,GAAG,wBAAwB,GAAG,wBAAwB,GACjF,0BAA0B,GAAG,2BAA2B,GAAG,qBAAqB,GAChF,sBAAsB,GAAG,oBAAoB,GAAG,0BAA0B,GAC1E,oBAAoB,GAAG,qBAAqB,GAAG,qBAAqB,GACpE,4BAA4B,GAAG,sBAAsB,GAAG,0BAA0B,GAClF,uBAAuB,GAAG,wBAAwB,GAAG,mBAAmB,GACxE,kBAAkB,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,kBAAkB,GAC9E,gBAAgB,GAAG,cAAc,GAAG,iBAAiB,GAAG,0BAA0B,GAClF,2BAA2B,GAAG,gBAAgB,GAAG,eAAe,GAAG,cAAc,GACjF,gBAAgB,GAAG,oBAAoB,GAAG,oBAAoB,GAAG,yBAAyB,GAC1F,sBAAsB,GAAG,2BAA2B,GAAG,iBAAiB,GAAG,iBAAiB,GAC5F,gBAAgB,GAAG,2BAA2B,GAAG,qCAAqC,GACtF,uBAAuB,GAAG,0BAA0B,CAAC;IAC3D,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAK;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACxD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAQ;IAE1C;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAsBnD;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAsBhC;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,GAAE,MAAY,GAAG,gBAAgB,EAAE;IAI/D;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,gBAAgB,EAAE;IAInF;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,gBAAgB,EAAE;IAIvE;;OAEG;IACH,MAAM,CAAC,sBAAsB,IAAI;QAC/B,WAAW,EAAE,MAAM,CAAC;QACpB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACzC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACrC,oBAAoB,EAAE,gBAAgB,EAAE,CAAC;KAC1C;IAuBD;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,UAAU,GAAE,MAAU,GAAG,IAAI;CAUpD"}