@dollhousemcp/mcp-server 1.3.0

package/dist/security/validators/unicodeValidator.js

@@ -0,0 +1,312 @@
+/**
+ * Unicode Validator for DollhouseMCP
+ *
+ * Prevents Unicode-based bypass attacks including:
+ * - Homograph attacks (visually similar characters)
+ * - Direction override attacks (RLO/LRO)
+ * - Mixed script attacks
+ * - Zero-width character injection
+ * - Unicode normalization bypasses
+ *
+ * Security: SEC-001 - Unicode attack prevention
+ */
+import { SecurityMonitor } from '../securityMonitor.js';
+export class UnicodeValidator {
+    /**
+     * Unicode attack patterns and confusable characters
+     */
+    /**
+     * Direction override characters that can hide or reverse text display
+     * @see https://unicode.org/reports/tr9/#Directional_Formatting_Characters
+     * U+202A-U+202E: Left/Right embedding and override marks (LRE, RLE, PDF, LRO, RLO)
+     * U+2066-U+2069: Isolate formatting characters (LRI, RLI, FSI, PDI)
+     */
+    static DIRECTION_OVERRIDE_CHARS = /[\u202A-\u202E\u2066-\u2069]/g;
+    /**
+     * Zero-width and invisible formatting characters often used to hide payloads
+     * U+200B-U+200F: Zero-width spaces and directional marks
+     * U+2028-U+202F: Line/paragraph separators and formatting characters
+     * U+FEFF: Zero-width no-break space (Byte Order Mark)
+     */
+    static ZERO_WIDTH_CHARS = /[\u200B-\u200F\u2028-\u202F\uFEFF]/g;
+    /**
+     * Non-printable control characters that should not appear in normal text
+     * U+0000-U+0008, U+000B-U+000C, U+000E-U+001F: C0 control codes (except TAB, LF, CR)
+     * U+007F-U+009F: Delete and C1 control codes
+     * U+FFFE-U+FFFF: Non-characters that should never appear in valid text
+     */
+    static NON_PRINTABLE_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\uFFFE\uFFFF]/g;
+    /**
+     * Common homograph/confusable character mappings
+     * Maps visually similar Unicode characters to their ASCII equivalents
+     */
+    static CONFUSABLE_MAPPINGS = new Map([
+        // Cyrillic to Latin
+        ['а', 'a'], ['е', 'e'], ['о', 'o'], ['р', 'p'], ['с', 'c'], ['х', 'x'], ['у', 'y'],
+        ['А', 'A'], ['В', 'B'], ['Е', 'E'], ['К', 'K'], ['М', 'M'], ['Н', 'H'], ['О', 'O'],
+        ['Р', 'P'], ['С', 'C'], ['Т', 'T'], ['У', 'Y'], ['Х', 'X'],
+        // Greek to Latin
+        ['α', 'a'], ['β', 'b'], ['γ', 'g'], ['δ', 'd'], ['ε', 'e'], ['ζ', 'z'], ['η', 'h'],
+        ['θ', 'th'], ['ι', 'i'], ['κ', 'k'], ['λ', 'l'], ['μ', 'm'], ['ν', 'n'], ['ξ', 'x'],
+        ['ο', 'o'], ['π', 'p'], ['ρ', 'r'], ['σ', 's'], ['τ', 't'], ['υ', 'u'], ['φ', 'f'],
+        ['χ', 'ch'], ['ψ', 'ps'], ['ω', 'w'],
+        // Mathematical symbols to ASCII (various styles)
+        ['𝒂', 'a'], ['𝒃', 'b'], ['𝒄', 'c'], ['𝒅', 'd'], ['𝒆', 'e'], ['𝒇', 'f'], ['𝒈', 'g'], ['𝒉', 'h'], ['𝒊', 'i'], ['𝒋', 'j'], ['𝒌', 'k'], ['𝒍', 'l'], ['𝒎', 'm'], ['𝒏', 'n'], ['𝒐', 'o'], ['𝒑', 'p'], ['𝒒', 'q'], ['𝒓', 'r'], ['𝒔', 's'], ['𝒕', 't'], ['𝒖', 'u'], ['𝒗', 'v'], ['𝒘', 'w'], ['𝒙', 'x'], ['𝒚', 'y'], ['𝒛', 'z'],
+        ['𝐚', 'a'], ['𝐛', 'b'], ['𝐜', 'c'], ['𝐝', 'd'], ['𝐞', 'e'], ['𝐟', 'f'], ['𝐠', 'g'], ['𝐡', 'h'], ['𝐢', 'i'], ['𝐣', 'j'], ['𝐤', 'k'], ['𝐥', 'l'], ['𝐦', 'm'], ['𝐧', 'n'], ['𝐨', 'o'], ['𝐩', 'p'], ['𝐪', 'q'], ['𝐫', 'r'], ['𝐬', 's'], ['𝐭', 't'], ['𝐮', 'u'], ['𝐯', 'v'], ['𝐰', 'w'], ['𝐱', 'x'], ['𝐲', 'y'], ['𝐳', 'z'],
+        // Special i variants (Turkish, etc.)
+        ['ı', 'i'], ['İ', 'I'], ['і', 'i'], ['Ӏ', 'I'],
+        // Other common confusables
+        ['ǝ', 'e'], ['ɐ', 'a'], ['ɔ', 'o'], ['ʇ', 't'], ['ʌ', 'v'], ['ʍ', 'w'],
+        ['℃', 'C'], ['℉', 'F'], ['№', 'No'], ['™', 'TM'], ['®', 'R'],
+        // Fullwidth characters
+        ['Ａ', 'A'], ['Ｂ', 'B'], ['Ｃ', 'C'], ['Ｄ', 'D'], ['Ｅ', 'E'], ['Ｆ', 'F'], ['Ｇ', 'G'], ['Ｈ', 'H'], ['Ｉ', 'I'], ['Ｊ', 'J'], ['Ｋ', 'K'], ['Ｌ', 'L'], ['Ｍ', 'M'], ['Ｎ', 'N'], ['Ｏ', 'O'], ['Ｐ', 'P'], ['Ｑ', 'Q'], ['Ｒ', 'R'], ['Ｓ', 'S'], ['Ｔ', 'T'], ['Ｕ', 'U'], ['Ｖ', 'V'], ['Ｗ', 'W'], ['Ｘ', 'X'], ['Ｙ', 'Y'], ['Ｚ', 'Z'],
+        ['ａ', 'a'], ['ｂ', 'b'], ['ｃ', 'c'], ['ｄ', 'd'], ['ｅ', 'e'], ['ｆ', 'f'], ['ｇ', 'g'], ['ｈ', 'h'], ['ｉ', 'i'], ['ｊ', 'j'], ['ｋ', 'k'], ['ｌ', 'l'], ['ｍ', 'm'], ['ｎ', 'n'], ['ｏ', 'o'], ['ｐ', 'p'], ['ｑ', 'q'], ['ｒ', 'r'], ['ｓ', 's'], ['ｔ', 't'], ['ｕ', 'u'], ['ｖ', 'v'], ['ｗ', 'w'], ['ｘ', 'x'], ['ｙ', 'y'], ['ｚ', 'z'],
+        ['０', '0'], ['１', '1'], ['２', '2'], ['３', '3'], ['４', '4'], ['５', '5'], ['６', '6'], ['７', '7'], ['８', '8'], ['９', '9'],
+    ]);
+    /**
+     * Script mixing detection patterns
+     * Detects suspicious mixing of different Unicode scripts
+     */
+    static SCRIPT_PATTERNS = {
+        LATIN: /[\u0000-\u007F\u00A0-\u00FF\u0100-\u017F\u0180-\u024F]/,
+        CYRILLIC: /[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F]/,
+        GREEK: /[\u0370-\u03FF\u1F00-\u1FFF]/,
+        ARABIC: /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]/,
+        HEBREW: /[\u0590-\u05FF\uFB1D-\uFB4F]/,
+        CJK: /[\u2E80-\u2EFF\u2F00-\u2FDF\u3000-\u303F\u3040-\u309F\u30A0-\u30FF\u3100-\u312F\u3130-\u318F\u3190-\u319F\u31A0-\u31BF\u31C0-\u31EF\u31F0-\u31FF\u3200-\u32FF\u3300-\u33FF\u3400-\u4DBF\u4DC0-\u4DFF\u4E00-\u9FFF]/,
+    };
+    /**
+     * Normalize Unicode content to prevent bypass attacks
+     */
+    static normalize(content) {
+        const issues = [];
+        let normalized = content;
+        let severity = 'low';
+        try {
+            // 1. Detect and log suspicious Unicode patterns before normalization
+            const suspiciousPatterns = this.detectSuspiciousPatterns(content);
+            issues.push(...suspiciousPatterns.issues);
+            if (suspiciousPatterns.severity) {
+                severity = this.escalateSeverity(severity, suspiciousPatterns.severity);
+            }
+            // 2. Remove direction override characters (prevents RLO/LRO attacks)
+            if (this.DIRECTION_OVERRIDE_CHARS.test(normalized)) {
+                issues.push('Direction override characters detected');
+                severity = this.escalateSeverity(severity, 'high');
+                normalized = normalized.replace(this.DIRECTION_OVERRIDE_CHARS, '');
+                SecurityMonitor.logSecurityEvent({
+                    type: 'UNICODE_DIRECTION_OVERRIDE',
+                    severity: 'HIGH',
+                    source: 'unicode_validation',
+                    details: 'Direction override characters removed from content'
+                });
+            }
+            // 3. Remove zero-width and non-printable characters
+            if (this.ZERO_WIDTH_CHARS.test(normalized) || this.NON_PRINTABLE_CHARS.test(normalized)) {
+                issues.push('Zero-width or non-printable characters detected');
+                severity = this.escalateSeverity(severity, 'medium');
+                normalized = normalized
+                    .replace(this.ZERO_WIDTH_CHARS, '')
+                    .replace(this.NON_PRINTABLE_CHARS, '');
+            }
+            // 4. Apply Unicode normalization (NFC - Canonical Decomposition + Composition)
+            normalized = normalized.normalize('NFC');
+            // 5. Detect mixed script attacks BEFORE confusable replacement
+            const mixedScriptResult = this.detectMixedScripts(normalized);
+            if (mixedScriptResult.isSuspicious) {
+                issues.push(`Mixed script usage detected: ${mixedScriptResult.scripts.join(', ')}`);
+                severity = this.escalateSeverity(severity, 'high');
+                SecurityMonitor.logSecurityEvent({
+                    type: 'UNICODE_MIXED_SCRIPT',
+                    severity: 'HIGH',
+                    source: 'unicode_validation',
+                    details: `Mixed scripts detected: ${mixedScriptResult.scripts.join(', ')}`
+                });
+            }
+            // 6. Always replace confusable characters with ASCII equivalents for security
+            // This prevents homograph attacks regardless of script mixing
+            const confusableResult = this.replaceConfusables(normalized);
+            if (confusableResult.hasConfusables) {
+                normalized = confusableResult.normalized;
+                issues.push('Confusable Unicode characters detected and normalized');
+                severity = this.escalateSeverity(severity, 'medium');
+                // Log if this happens in legitimate multilingual context
+                if (!mixedScriptResult.isSuspicious) {
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'UNICODE_VALIDATION_ERROR',
+                        severity: 'LOW',
+                        source: 'unicode_validation',
+                        details: 'Confusable characters normalized in legitimate multilingual content'
+                    });
+                }
+            }
+            return {
+                isValid: issues.length === 0,
+                normalizedContent: normalized,
+                detectedIssues: issues.length > 0 ? issues : undefined,
+                severity: issues.length > 0 ? severity : undefined
+            };
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'UNICODE_VALIDATION_ERROR',
+                severity: 'HIGH',
+                source: 'unicode_validation',
+                details: `Unicode validation failed: ${error instanceof Error ? error.message : String(error)}`
+            });
+            // Fallback: return original content if normalization fails
+            return {
+                isValid: false,
+                normalizedContent: content,
+                detectedIssues: ['Unicode validation failed'],
+                severity: 'high'
+            };
+        }
+    }
+    /**
+     * Detect suspicious Unicode patterns that might indicate attacks
+     */
+    static detectSuspiciousPatterns(content) {
+        const issues = [];
+        let severity;
+        // Check for excessive Unicode escapes (possible encoding bypass)
+        /**
+         * Pattern to match Unicode escape sequences
+         * \\u: Literal backslash followed by 'u'
+         * [0-9a-fA-F]{4}: Exactly 4 hexadecimal digits
+         * Used to detect attempts to bypass filters using \u0061dmin style encoding
+         */
+        const unicodeEscapePattern = /\\u[0-9a-fA-F]{4}/g;
+        const unicodeEscapes = content.match(unicodeEscapePattern);
+        if (unicodeEscapes && unicodeEscapes.length > 10) {
+            issues.push(`Excessive Unicode escapes detected (${unicodeEscapes.length})`);
+            severity = 'high';
+        }
+        // Check for suspicious Unicode ranges that might hide content
+        const suspiciousRanges = [
+            { range: /[\uE000-\uF8FF]/g, name: 'Private Use Area' },
+            // Note: Properly paired surrogate pairs [\uD800-\uDFFF] are normal for emojis
+            { range: /[\uFDD0-\uFDEF]/g, name: 'Non-characters' },
+            { range: /[\uFFFE\uFFFF]/g, name: 'Non-characters' }
+        ];
+        for (const { range, name } of suspiciousRanges) {
+            if (range.test(content)) {
+                issues.push(`Suspicious Unicode range detected: ${name}`);
+                severity = this.escalateSeverity(severity, 'medium');
+            }
+        }
+        // Check for malformed surrogate pairs using safe character-by-character validation
+        // This avoids ReDoS vulnerabilities from complex regex patterns
+        if (this.hasMalformedSurrogates(content)) {
+            issues.push('Malformed surrogate pairs detected');
+            severity = this.escalateSeverity(severity, 'high');
+        }
+        return { issues, severity };
+    }
+    /**
+     * Replace confusable Unicode characters with ASCII equivalents
+     */
+    static replaceConfusables(content) {
+        let normalized = content;
+        let hasConfusables = false;
+        for (const [confusable, replacement] of this.CONFUSABLE_MAPPINGS) {
+            if (normalized.includes(confusable)) {
+                normalized = normalized.replace(new RegExp(this.escapeRegex(confusable), 'g'), replacement);
+                hasConfusables = true;
+            }
+        }
+        return { normalized, hasConfusables };
+    }
+    /**
+     * Detect suspicious mixing of different Unicode scripts
+     */
+    static detectMixedScripts(content) {
+        const detectedScripts = [];
+        for (const [scriptName, pattern] of Object.entries(this.SCRIPT_PATTERNS)) {
+            if (pattern.test(content)) {
+                detectedScripts.push(scriptName);
+            }
+        }
+        // Consider it suspicious if:
+        // 1. More than 3 scripts are mixed (legitimate text rarely mixes >3 scripts)
+        // 2. Content contains Latin + dangerous confusable scripts (Cyrillic/Greek - common attack pattern)
+        // Note: Latin + CJK is common and legitimate (e.g., Chinese with English)
+        const isSuspicious = detectedScripts.length > 3 ||
+            (detectedScripts.includes('LATIN') && detectedScripts.length > 1 &&
+                (detectedScripts.includes('CYRILLIC') || detectedScripts.includes('GREEK')));
+        return { isSuspicious, scripts: detectedScripts };
+    }
+    /**
+     * Escalate severity level (higher severity takes precedence)
+     */
+    static escalateSeverity(current, newSeverity) {
+        const severityLevels = { low: 1, medium: 2, high: 3, critical: 4 };
+        const currentLevel = current ? severityLevels[current] : 0;
+        const newLevel = severityLevels[newSeverity];
+        return newLevel > currentLevel ? newSeverity : (current || 'low');
+    }
+    /**
+     * Escape special regex characters for safe replacement
+     */
+    static escapeRegex(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Check if content contains potentially dangerous Unicode patterns
+     */
+    static containsDangerousUnicode(content) {
+        // Quick check for obviously dangerous patterns
+        return this.DIRECTION_OVERRIDE_CHARS.test(content) ||
+            this.ZERO_WIDTH_CHARS.test(content) ||
+            this.NON_PRINTABLE_CHARS.test(content) ||
+            this.hasExcessiveUnicodeEscapes(content);
+    }
+    /**
+     * Check if content has excessive Unicode escape sequences
+     * Prevents null pointer exception by safely checking match results
+     */
+    static hasExcessiveUnicodeEscapes(content) {
+        const matches = content.match(/\\u[0-9a-fA-F]{4}/g);
+        return matches !== null && matches.length > 10;
+    }
+    /**
+     * Safely check for malformed surrogate pairs without ReDoS vulnerability
+     * Uses character-by-character validation instead of complex regex
+     */
+    static hasMalformedSurrogates(content) {
+        for (let i = 0; i < content.length; i++) {
+            const char = content.charCodeAt(i);
+            // High surrogate (U+D800-U+DBFF)
+            if (char >= 0xD800 && char <= 0xDBFF) {
+                // Check if it's followed by a low surrogate
+                if (i + 1 >= content.length) {
+                    return true; // High surrogate at end of string
+                }
+                const nextChar = content.charCodeAt(i + 1);
+                if (nextChar < 0xDC00 || nextChar > 0xDFFF) {
+                    return true; // High surrogate not followed by low surrogate
+                }
+                i++; // Skip the valid low surrogate
+            }
+            // Low surrogate (U+DC00-U+DFFF) without preceding high surrogate
+            else if (char >= 0xDC00 && char <= 0xDFFF) {
+                return true; // Unpaired low surrogate
+            }
+        }
+        return false;
+    }
+    /**
+     * Get safe preview of Unicode content for logging
+     */
+    static getSafePreview(content, maxLength = 100) {
+        // Remove dangerous Unicode characters and truncate for safe logging
+        const cleaned = content
+            .replace(this.DIRECTION_OVERRIDE_CHARS, '[DIR]')
+            .replace(this.ZERO_WIDTH_CHARS, '[ZW]')
+            .replace(this.NON_PRINTABLE_CHARS, '[NP]');
+        return cleaned.length > maxLength ?
+            cleaned.substring(0, maxLength) + '...' :
+            cleaned;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unicodeValidator.js","sourceRoot":"","sources":["../../../src/security/validators/unicodeValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AASxD,MAAM,OAAO,gBAAgB;IAC3B;;OAEG;IAEH;;;;;OAKG;IACK,MAAM,CAAU,wBAAwB,GAAG,+BAA+B,CAAC;IAEnF;;;;;OAKG;IACK,MAAM,CAAU,gBAAgB,GAAG,qCAAqC,CAAC;IAEjF;;;;;OAKG;IACK,MAAM,CAAU,mBAAmB,GAAG,oEAAoE,CAAC;IAEnH;;;OAGG;IACK,MAAM,CAAU,mBAAmB,GAAwB,IAAI,GAAG,CAAC;QACzE,oBAAoB;QACpB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAClF,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAClF,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAE1D,iBAAiB;QACjB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAClF,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QACnF,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAClF,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAEpC,iDAAiD;QACjD,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;QAChV,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;QAEhV,qCAAqC;QACrC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAE9C,2BAA2B;QAC3B,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QACtE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QAE5D,uBAAuB;QACvB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;QACtT,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG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","sourcesContent":["/**\n * Unicode Validator for DollhouseMCP\n * \n * Prevents Unicode-based bypass attacks including:\n * - Homograph attacks (visually similar characters)\n * - Direction override attacks (RLO/LRO)\n * - Mixed script attacks\n * - Zero-width character injection\n * - Unicode normalization bypasses\n * \n * Security: SEC-001 - Unicode attack prevention\n */\n\nimport { SecurityError } from '../errors.js';\nimport { SecurityMonitor } from '../securityMonitor.js';\n\nexport interface UnicodeValidationResult {\n  isValid: boolean;\n  normalizedContent: string;\n  detectedIssues?: string[];\n  severity?: 'low' | 'medium' | 'high' | 'critical';\n}\n\nexport class UnicodeValidator {\n  /**\n   * Unicode attack patterns and confusable characters\n   */\n  \n  /**\n   * Direction override characters that can hide or reverse text display\n   * @see https://unicode.org/reports/tr9/#Directional_Formatting_Characters\n   * U+202A-U+202E: Left/Right embedding and override marks (LRE, RLE, PDF, LRO, RLO)\n   * U+2066-U+2069: Isolate formatting characters (LRI, RLI, FSI, PDI)\n   */\n  private static readonly DIRECTION_OVERRIDE_CHARS = /[\\u202A-\\u202E\\u2066-\\u2069]/g;\n  \n  /**\n   * Zero-width and invisible formatting characters often used to hide payloads\n   * U+200B-U+200F: Zero-width spaces and directional marks\n   * U+2028-U+202F: Line/paragraph separators and formatting characters\n   * U+FEFF: Zero-width no-break space (Byte Order Mark)\n   */\n  private static readonly ZERO_WIDTH_CHARS = /[\\u200B-\\u200F\\u2028-\\u202F\\uFEFF]/g;\n  \n  /**\n   * Non-printable control characters that should not appear in normal text\n   * U+0000-U+0008, U+000B-U+000C, U+000E-U+001F: C0 control codes (except TAB, LF, CR)\n   * U+007F-U+009F: Delete and C1 control codes\n   * U+FFFE-U+FFFF: Non-characters that should never appear in valid text\n   */\n  private static readonly NON_PRINTABLE_CHARS = /[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F\\u007F-\\u009F\\uFFFE\\uFFFF]/g;\n  \n  /**\n   * Common homograph/confusable character mappings\n   * Maps visually similar Unicode characters to their ASCII equivalents\n   */\n  private static readonly CONFUSABLE_MAPPINGS: Map<string, string> = new Map([\n    // Cyrillic to Latin\n    ['а', 'a'], ['е', 'e'], ['о', 'o'], ['р', 'p'], ['с', 'c'], ['х', 'x'], ['у', 'y'],\n    ['А', 'A'], ['В', 'B'], ['Е', 'E'], ['К', 'K'], ['М', 'M'], ['Н', 'H'], ['О', 'O'], \n    ['Р', 'P'], ['С', 'C'], ['Т', 'T'], ['У', 'Y'], ['Х', 'X'],\n    \n    // Greek to Latin\n    ['α', 'a'], ['β', 'b'], ['γ', 'g'], ['δ', 'd'], ['ε', 'e'], ['ζ', 'z'], ['η', 'h'],\n    ['θ', 'th'], ['ι', 'i'], ['κ', 'k'], ['λ', 'l'], ['μ', 'm'], ['ν', 'n'], ['ξ', 'x'],\n    ['ο', 'o'], ['π', 'p'], ['ρ', 'r'], ['σ', 's'], ['τ', 't'], ['υ', 'u'], ['φ', 'f'],\n    ['χ', 'ch'], ['ψ', 'ps'], ['ω', 'w'],\n    \n    // Mathematical symbols to ASCII (various styles)\n    ['𝒂', 'a'], ['𝒃', 'b'], ['𝒄', 'c'], ['𝒅', 'd'], ['𝒆', 'e'], ['𝒇', 'f'], ['𝒈', 'g'], ['𝒉', 'h'], ['𝒊', 'i'], ['𝒋', 'j'], ['𝒌', 'k'], ['𝒍', 'l'], ['𝒎', 'm'], ['𝒏', 'n'], ['𝒐', 'o'], ['𝒑', 'p'], ['𝒒', 'q'], ['𝒓', 'r'], ['𝒔', 's'], ['𝒕', 't'], ['𝒖', 'u'], ['𝒗', 'v'], ['𝒘', 'w'], ['𝒙', 'x'], ['𝒚', 'y'], ['𝒛', 'z'],\n    ['𝐚', 'a'], ['𝐛', 'b'], ['𝐜', 'c'], ['𝐝', 'd'], ['𝐞', 'e'], ['𝐟', 'f'], ['𝐠', 'g'], ['𝐡', 'h'], ['𝐢', 'i'], ['𝐣', 'j'], ['𝐤', 'k'], ['𝐥', 'l'], ['𝐦', 'm'], ['𝐧', 'n'], ['𝐨', 'o'], ['𝐩', 'p'], ['𝐪', 'q'], ['𝐫', 'r'], ['𝐬', 's'], ['𝐭', 't'], ['𝐮', 'u'], ['𝐯', 'v'], ['𝐰', 'w'], ['𝐱', 'x'], ['𝐲', 'y'], ['𝐳', 'z'],\n    \n    // Special i variants (Turkish, etc.)\n    ['ı', 'i'], ['İ', 'I'], ['і', 'i'], ['Ӏ', 'I'],\n    \n    // Other common confusables\n    ['ǝ', 'e'], ['ɐ', 'a'], ['ɔ', 'o'], ['ʇ', 't'], ['ʌ', 'v'], ['ʍ', 'w'],\n    ['℃', 'C'], ['℉', 'F'], ['№', 'No'], ['™', 'TM'], ['®', 'R'],\n    \n    // Fullwidth characters\n    ['Ａ', 'A'], ['Ｂ', 'B'], ['Ｃ', 'C'], ['Ｄ', 'D'], ['Ｅ', 'E'], ['Ｆ', 'F'], ['Ｇ', 'G'], ['Ｈ', 'H'], ['Ｉ', 'I'], ['Ｊ', 'J'], ['Ｋ', 'K'], ['Ｌ', 'L'], ['Ｍ', 'M'], ['Ｎ', 'N'], ['Ｏ', 'O'], ['Ｐ', 'P'], ['Ｑ', 'Q'], ['Ｒ', 'R'], ['Ｓ', 'S'], ['Ｔ', 'T'], ['Ｕ', 'U'], ['Ｖ', 'V'], ['Ｗ', 'W'], ['Ｘ', 'X'], ['Ｙ', 'Y'], ['Ｚ', 'Z'],\n    ['ａ', 'a'], ['ｂ', 'b'], ['ｃ', 'c'], ['ｄ', 'd'], ['ｅ', 'e'], ['ｆ', 'f'], ['ｇ', 'g'], ['ｈ', 'h'], ['ｉ', 'i'], ['ｊ', 'j'], ['ｋ', 'k'], ['ｌ', 'l'], ['ｍ', 'm'], ['ｎ', 'n'], ['ｏ', 'o'], ['ｐ', 'p'], ['ｑ', 'q'], ['ｒ', 'r'], ['ｓ', 's'], ['ｔ', 't'], ['ｕ', 'u'], ['ｖ', 'v'], ['ｗ', 'w'], ['ｘ', 'x'], ['ｙ', 'y'], ['ｚ', 'z'],\n    ['０', '0'], ['１', '1'], ['２', '2'], ['３', '3'], ['４', '4'], ['５', '5'], ['６', '6'], ['７', '7'], ['８', '8'], ['９', '9'],\n  ]);\n\n  /**\n   * Script mixing detection patterns\n   * Detects suspicious mixing of different Unicode scripts\n   */\n  private static readonly SCRIPT_PATTERNS = {\n    LATIN: /[\\u0000-\\u007F\\u00A0-\\u00FF\\u0100-\\u017F\\u0180-\\u024F]/,\n    CYRILLIC: /[\\u0400-\\u04FF\\u0500-\\u052F\\u2DE0-\\u2DFF\\uA640-\\uA69F]/,\n    GREEK: /[\\u0370-\\u03FF\\u1F00-\\u1FFF]/,\n    ARABIC: /[\\u0600-\\u06FF\\u0750-\\u077F\\u08A0-\\u08FF\\uFB50-\\uFDFF\\uFE70-\\uFEFF]/,\n    HEBREW: /[\\u0590-\\u05FF\\uFB1D-\\uFB4F]/,\n    CJK: /[\\u2E80-\\u2EFF\\u2F00-\\u2FDF\\u3000-\\u303F\\u3040-\\u309F\\u30A0-\\u30FF\\u3100-\\u312F\\u3130-\\u318F\\u3190-\\u319F\\u31A0-\\u31BF\\u31C0-\\u31EF\\u31F0-\\u31FF\\u3200-\\u32FF\\u3300-\\u33FF\\u3400-\\u4DBF\\u4DC0-\\u4DFF\\u4E00-\\u9FFF]/,\n  };\n\n  /**\n   * Normalize Unicode content to prevent bypass attacks\n   */\n  static normalize(content: string): UnicodeValidationResult {\n    const issues: string[] = [];\n    let normalized = content;\n    let severity: 'low' | 'medium' | 'high' | 'critical' = 'low';\n\n    try {\n      // 1. Detect and log suspicious Unicode patterns before normalization\n      const suspiciousPatterns = this.detectSuspiciousPatterns(content);\n      issues.push(...suspiciousPatterns.issues);\n      if (suspiciousPatterns.severity) {\n        severity = this.escalateSeverity(severity, suspiciousPatterns.severity);\n      }\n\n      // 2. Remove direction override characters (prevents RLO/LRO attacks)\n      if (this.DIRECTION_OVERRIDE_CHARS.test(normalized)) {\n        issues.push('Direction override characters detected');\n        severity = this.escalateSeverity(severity, 'high');\n        normalized = normalized.replace(this.DIRECTION_OVERRIDE_CHARS, '');\n        \n        SecurityMonitor.logSecurityEvent({\n          type: 'UNICODE_DIRECTION_OVERRIDE',\n          severity: 'HIGH',\n          source: 'unicode_validation',\n          details: 'Direction override characters removed from content'\n        });\n      }\n\n      // 3. Remove zero-width and non-printable characters\n      if (this.ZERO_WIDTH_CHARS.test(normalized) || this.NON_PRINTABLE_CHARS.test(normalized)) {\n        issues.push('Zero-width or non-printable characters detected');\n        severity = this.escalateSeverity(severity, 'medium');\n        normalized = normalized\n          .replace(this.ZERO_WIDTH_CHARS, '')\n          .replace(this.NON_PRINTABLE_CHARS, '');\n      }\n\n      // 4. Apply Unicode normalization (NFC - Canonical Decomposition + Composition)\n      normalized = normalized.normalize('NFC');\n\n      // 5. Detect mixed script attacks BEFORE confusable replacement\n      const mixedScriptResult = this.detectMixedScripts(normalized);\n      if (mixedScriptResult.isSuspicious) {\n        issues.push(`Mixed script usage detected: ${mixedScriptResult.scripts.join(', ')}`);\n        severity = this.escalateSeverity(severity, 'high');\n        \n        SecurityMonitor.logSecurityEvent({\n          type: 'UNICODE_MIXED_SCRIPT',\n          severity: 'HIGH',\n          source: 'unicode_validation',\n          details: `Mixed scripts detected: ${mixedScriptResult.scripts.join(', ')}`\n        });\n      }\n\n      // 6. Always replace confusable characters with ASCII equivalents for security\n      // This prevents homograph attacks regardless of script mixing\n      const confusableResult = this.replaceConfusables(normalized);\n      if (confusableResult.hasConfusables) {\n        normalized = confusableResult.normalized;\n        issues.push('Confusable Unicode characters detected and normalized');\n        severity = this.escalateSeverity(severity, 'medium');\n        \n        // Log if this happens in legitimate multilingual context\n        if (!mixedScriptResult.isSuspicious) {\n          SecurityMonitor.logSecurityEvent({\n            type: 'UNICODE_VALIDATION_ERROR',\n            severity: 'LOW',\n            source: 'unicode_validation',\n            details: 'Confusable characters normalized in legitimate multilingual content'\n          });\n        }\n      }\n\n      return {\n        isValid: issues.length === 0,\n        normalizedContent: normalized,\n        detectedIssues: issues.length > 0 ? issues : undefined,\n        severity: issues.length > 0 ? severity : undefined\n      };\n\n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'UNICODE_VALIDATION_ERROR',\n        severity: 'HIGH',\n        source: 'unicode_validation',\n        details: `Unicode validation failed: ${error instanceof Error ? error.message : String(error)}`\n      });\n\n      // Fallback: return original content if normalization fails\n      return {\n        isValid: false,\n        normalizedContent: content,\n        detectedIssues: ['Unicode validation failed'],\n        severity: 'high'\n      };\n    }\n  }\n\n  /**\n   * Detect suspicious Unicode patterns that might indicate attacks\n   */\n  private static detectSuspiciousPatterns(content: string): { issues: string[]; severity?: 'low' | 'medium' | 'high' | 'critical' } {\n    const issues: string[] = [];\n    let severity: 'low' | 'medium' | 'high' | 'critical' | undefined;\n\n    // Check for excessive Unicode escapes (possible encoding bypass)\n    /**\n     * Pattern to match Unicode escape sequences\n     * \\\\u: Literal backslash followed by 'u'\n     * [0-9a-fA-F]{4}: Exactly 4 hexadecimal digits\n     * Used to detect attempts to bypass filters using \\u0061dmin style encoding\n     */\n    const unicodeEscapePattern = /\\\\u[0-9a-fA-F]{4}/g;\n    const unicodeEscapes = content.match(unicodeEscapePattern);\n    if (unicodeEscapes && unicodeEscapes.length > 10) {\n      issues.push(`Excessive Unicode escapes detected (${unicodeEscapes.length})`);\n      severity = 'high';\n    }\n\n    // Check for suspicious Unicode ranges that might hide content\n    const suspiciousRanges = [\n      { range: /[\\uE000-\\uF8FF]/g, name: 'Private Use Area' },\n      // Note: Properly paired surrogate pairs [\\uD800-\\uDFFF] are normal for emojis\n      { range: /[\\uFDD0-\\uFDEF]/g, name: 'Non-characters' },\n      { range: /[\\uFFFE\\uFFFF]/g, name: 'Non-characters' }\n    ];\n\n    for (const { range, name } of suspiciousRanges) {\n      if (range.test(content)) {\n        issues.push(`Suspicious Unicode range detected: ${name}`);\n        severity = this.escalateSeverity(severity, 'medium');\n      }\n    }\n\n    // Check for malformed surrogate pairs using safe character-by-character validation\n    // This avoids ReDoS vulnerabilities from complex regex patterns\n    if (this.hasMalformedSurrogates(content)) {\n      issues.push('Malformed surrogate pairs detected');\n      severity = this.escalateSeverity(severity, 'high');\n    }\n\n    return { issues, severity };\n  }\n\n  /**\n   * Replace confusable Unicode characters with ASCII equivalents\n   */\n  private static replaceConfusables(content: string): { normalized: string; hasConfusables: boolean } {\n    let normalized = content;\n    let hasConfusables = false;\n\n    for (const [confusable, replacement] of this.CONFUSABLE_MAPPINGS) {\n      if (normalized.includes(confusable)) {\n        normalized = normalized.replace(new RegExp(this.escapeRegex(confusable), 'g'), replacement);\n        hasConfusables = true;\n      }\n    }\n\n    return { normalized, hasConfusables };\n  }\n\n  /**\n   * Detect suspicious mixing of different Unicode scripts\n   */\n  private static detectMixedScripts(content: string): { isSuspicious: boolean; scripts: string[] } {\n    const detectedScripts: string[] = [];\n\n    for (const [scriptName, pattern] of Object.entries(this.SCRIPT_PATTERNS)) {\n      if (pattern.test(content)) {\n        detectedScripts.push(scriptName);\n      }\n    }\n\n    // Consider it suspicious if:\n    // 1. More than 3 scripts are mixed (legitimate text rarely mixes >3 scripts)\n    // 2. Content contains Latin + dangerous confusable scripts (Cyrillic/Greek - common attack pattern)\n    // Note: Latin + CJK is common and legitimate (e.g., Chinese with English)\n    const isSuspicious = detectedScripts.length > 3 || \n      (detectedScripts.includes('LATIN') && detectedScripts.length > 1 && \n       (detectedScripts.includes('CYRILLIC') || detectedScripts.includes('GREEK')));\n\n    return { isSuspicious, scripts: detectedScripts };\n  }\n\n  /**\n   * Escalate severity level (higher severity takes precedence)\n   */\n  private static escalateSeverity(\n    current: 'low' | 'medium' | 'high' | 'critical' | undefined, \n    newSeverity: 'low' | 'medium' | 'high' | 'critical'\n  ): 'low' | 'medium' | 'high' | 'critical' {\n    const severityLevels = { low: 1, medium: 2, high: 3, critical: 4 };\n    const currentLevel = current ? severityLevels[current] : 0;\n    const newLevel = severityLevels[newSeverity];\n    \n    return newLevel > currentLevel ? newSeverity : (current || 'low');\n  }\n\n  /**\n   * Escape special regex characters for safe replacement\n   */\n  private static escapeRegex(string: string): string {\n    return string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  }\n\n  /**\n   * Check if content contains potentially dangerous Unicode patterns\n   */\n  static containsDangerousUnicode(content: string): boolean {\n    // Quick check for obviously dangerous patterns\n    return this.DIRECTION_OVERRIDE_CHARS.test(content) ||\n           this.ZERO_WIDTH_CHARS.test(content) ||\n           this.NON_PRINTABLE_CHARS.test(content) ||\n           this.hasExcessiveUnicodeEscapes(content);\n  }\n\n  /**\n   * Check if content has excessive Unicode escape sequences\n   * Prevents null pointer exception by safely checking match results\n   */\n  private static hasExcessiveUnicodeEscapes(content: string): boolean {\n    const matches = content.match(/\\\\u[0-9a-fA-F]{4}/g);\n    return matches !== null && matches.length > 10;\n  }\n\n  /**\n   * Safely check for malformed surrogate pairs without ReDoS vulnerability\n   * Uses character-by-character validation instead of complex regex\n   */\n  private static hasMalformedSurrogates(content: string): boolean {\n    for (let i = 0; i < content.length; i++) {\n      const char = content.charCodeAt(i);\n      \n      // High surrogate (U+D800-U+DBFF)\n      if (char >= 0xD800 && char <= 0xDBFF) {\n        // Check if it's followed by a low surrogate\n        if (i + 1 >= content.length) {\n          return true; // High surrogate at end of string\n        }\n        const nextChar = content.charCodeAt(i + 1);\n        if (nextChar < 0xDC00 || nextChar > 0xDFFF) {\n          return true; // High surrogate not followed by low surrogate\n        }\n        i++; // Skip the valid low surrogate\n      }\n      // Low surrogate (U+DC00-U+DFFF) without preceding high surrogate\n      else if (char >= 0xDC00 && char <= 0xDFFF) {\n        return true; // Unpaired low surrogate\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Get safe preview of Unicode content for logging\n   */\n  static getSafePreview(content: string, maxLength: number = 100): string {\n    // Remove dangerous Unicode characters and truncate for safe logging\n    const cleaned = content\n      .replace(this.DIRECTION_OVERRIDE_CHARS, '[DIR]')\n      .replace(this.ZERO_WIDTH_CHARS, '[ZW]')\n      .replace(this.NON_PRINTABLE_CHARS, '[NP]');\n    \n    return cleaned.length > maxLength ? \n      cleaned.substring(0, maxLength) + '...' : \n      cleaned;\n  }\n}"]}

package/dist/security/yamlValidator.d.ts

@@ -0,0 +1,21 @@
+export declare class YamlValidator {
+    private static readonly YAML_BOMB_LIMITS;
+    private static purifyWindow;
+    private static purify;
+    static parsePersonaMetadataSafely(yamlContent: string): any;
+    private static sanitizeMetadata;
+    /**
+     * Initialize DOMPurify instance if not already initialized
+     */
+    private static initializePurify;
+    /**
+     * Sanitize string input using DOMPurify to prevent XSS attacks
+     * This replaces the regex-based approach with a more robust solution
+     */
+    private static sanitizeString;
+    /**
+     * Reset static DOMPurify cache (useful for long-running processes)
+     */
+    static resetCache(): void;
+}
+//# sourceMappingURL=yamlValidator.d.ts.map

package/dist/security/yamlValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlValidator.d.ts","sourceRoot":"","sources":["../../src/security/yamlValidator.ts"],"names":[],"mappings":"AA4BA,qBAAa,aAAa;IAExB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAKtC;IAGF,OAAO,CAAC,MAAM,CAAC,YAAY,CAAa;IACxC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAkC;IAEvD,MAAM,CAAC,0BAA0B,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG;IAiE3D,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAmB/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAQ/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IA4C7B;;OAEG;WACW,UAAU,IAAI,IAAI;CAIjC"}

package/dist/security/yamlValidator.js

@@ -0,0 +1,164 @@
+import yaml from 'js-yaml';
+import { z } from 'zod';
+import { logger } from '../utils/logger.js';
+import DOMPurify from 'dompurify';
+import { JSDOM } from 'jsdom';
+import { SECURITY_LIMITS } from './constants.js';
+const PersonaMetadataSchema = z.object({
+    name: z.string().min(1).max(100),
+    description: z.string().min(1).max(1000),
+    unique_id: z.string().optional(),
+    author: z.string().max(50).optional(),
+    triggers: z.array(z.string().max(50)).max(20).optional(),
+    version: z.string().regex(/^\d+\.\d+\.\d+$/).optional(),
+    category: z.enum(['creative', 'professional', 'educational', 'gaming', 'personal']).optional(),
+    age_rating: z.enum(['all', '13+', '18+']).optional(),
+    content_flags: z.array(z.string()).optional(),
+    ai_generated: z.boolean().optional(),
+    generation_method: z.string().max(50).optional(),
+    price: z.string().max(20).optional(),
+    license: z.string().max(100).optional(),
+    created_date: z.string().optional()
+});
+export class YamlValidator {
+    // YAML bomb detection limits - extracted from Issue #164 review feedback
+    static YAML_BOMB_LIMITS = {
+        MAX_ANCHORS: 10, // Maximum allowed anchor definitions (&name)
+        MAX_ALIASES: 20, // Maximum allowed alias references (*name)
+        MAX_MERGE_KEYS: 5, // Maximum allowed merge key operations (<<:)
+        MAX_DOCUMENTS: 3 // Maximum allowed documents in a single YAML
+    };
+    // Static cache for DOMPurify to improve performance
+    static purifyWindow = null;
+    static purify = null;
+    static parsePersonaMetadataSafely(yamlContent) {
+        if (!yamlContent || typeof yamlContent !== 'string') {
+            throw new Error('YAML content must be a non-empty string');
+        }
+        // Size check
+        if (yamlContent.length > SECURITY_LIMITS.MAX_YAML_LENGTH) {
+            throw new Error(`YAML content too large: ${yamlContent.length} bytes (max: ${SECURITY_LIMITS.MAX_YAML_LENGTH})`);
+        }
+        // Check for dangerous tags - expanded from Issue #164
+        const dangerousTags = [
+            '!!js/', '!!python/', '!!ruby/', '!!perl/', '!!php/',
+            '!!java', '!!javax', '!!com.sun',
+            '!!exec', '!!eval', '!!new', '!!construct', '!!apply',
+            '!!call', '!!invoke', '!!binary', '!!merge'
+        ];
+        for (const tag of dangerousTags) {
+            if (yamlContent.includes(tag)) {
+                throw new Error(`Dangerous YAML tag detected: ${tag}`);
+            }
+        }
+        // Enhanced YAML bomb protection - Issue #164
+        const anchorCount = (yamlContent.match(/&\w+/g) || []).length;
+        const aliasCount = (yamlContent.match(/\*\w+/g) || []).length;
+        const mergeKeyCount = (yamlContent.match(/<<:/g) || []).length;
+        const documentCount = (yamlContent.match(/^---/gm) || []).length;
+        if (anchorCount > this.YAML_BOMB_LIMITS.MAX_ANCHORS ||
+            aliasCount > this.YAML_BOMB_LIMITS.MAX_ALIASES ||
+            mergeKeyCount > this.YAML_BOMB_LIMITS.MAX_MERGE_KEYS ||
+            documentCount > this.YAML_BOMB_LIMITS.MAX_DOCUMENTS) {
+            throw new Error(`Potential YAML bomb detected: anchors=${anchorCount}, aliases=${aliasCount}, merges=${mergeKeyCount}, documents=${documentCount}`);
+        }
+        // Check for nested tag combinations
+        const nestedTagPattern = /[&*]\w+\s*!!/;
+        if (nestedTagPattern.test(yamlContent)) {
+            throw new Error('Dangerous nested YAML tag combination detected');
+        }
+        try {
+            // Use safe load with restricted schema
+            const rawData = yaml.load(yamlContent, {
+                schema: yaml.CORE_SCHEMA, // No functions, only basic types
+                onWarning: (warning) => {
+                    logger.warn('YAML parsing warning:', warning);
+                }
+            });
+            // Validate against schema
+            const validatedData = PersonaMetadataSchema.parse(rawData);
+            // Additional sanitization
+            return this.sanitizeMetadata(validatedData);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'YAMLException') {
+                throw new Error(`Invalid YAML syntax: ${error.message}`);
+            }
+            throw new Error(`Invalid persona metadata: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    static sanitizeMetadata(data) {
+        const sanitized = { ...data };
+        // Sanitize string fields
+        const stringFields = ['name', 'description', 'author', 'unique_id'];
+        for (const field of stringFields) {
+            if (sanitized[field]) {
+                sanitized[field] = this.sanitizeString(sanitized[field]);
+            }
+        }
+        // Sanitize array fields
+        if (sanitized.triggers) {
+            sanitized.triggers = sanitized.triggers.map((t) => this.sanitizeString(t));
+        }
+        return sanitized;
+    }
+    /**
+     * Initialize DOMPurify instance if not already initialized
+     */
+    static initializePurify() {
+        if (!this.purifyWindow || !this.purify) {
+            const dom = new JSDOM('');
+            this.purifyWindow = dom.window;
+            this.purify = DOMPurify(this.purifyWindow);
+        }
+    }
+    /**
+     * Sanitize string input using DOMPurify to prevent XSS attacks
+     * This replaces the regex-based approach with a more robust solution
+     */
+    static sanitizeString(input) {
+        // Limit input length to prevent DoS
+        if (input.length > 10000) {
+            input = input.substring(0, 10000);
+        }
+        // Initialize DOMPurify if needed
+        this.initializePurify();
+        // Use DOMPurify with strict configuration
+        // ALLOWED_TAGS: [] strips all HTML tags
+        // ALLOWED_ATTR: [] strips all attributes
+        // FORBID_TAGS/FORBID_ATTR provide additional protection
+        let sanitized = this.purify.sanitize(input, {
+            ALLOWED_TAGS: [], // Strip all HTML tags
+            ALLOWED_ATTR: [], // Strip all attributes
+            FORBID_TAGS: ['style', 'script', 'iframe', 'object', 'embed', 'link'],
+            FORBID_ATTR: ['onerror', 'onload', 'onclick', 'onmouseover', 'style', 'href', 'src']
+        });
+        // Additional protection against command injection patterns
+        // These patterns might not be caught by DOMPurify
+        const commandInjectionPatterns = [
+            /`[^`]{0,1000}`/g, // Backtick expressions
+            /\$\([^)]{0,1000}\)/g, // Command substitution
+            /\$\{[^}]{0,1000}\}/g, // Variable expansion
+            /\\x[0-9a-fA-F]{2}/g, // Hex escapes
+            /\\u[0-9a-fA-F]{4}/g, // Unicode escapes
+            /\\[0-7]{1,3}/g // Octal escapes
+        ];
+        for (const pattern of commandInjectionPatterns) {
+            sanitized = sanitized.replace(pattern, '');
+        }
+        // Remove null bytes and normalize whitespace
+        sanitized = sanitized
+            .replace(/\x00/g, '') // Remove null bytes
+            .replace(/[\r\n]+/g, ' ') // Replace newlines with spaces
+            .trim();
+        return sanitized;
+    }
+    /**
+     * Reset static DOMPurify cache (useful for long-running processes)
+     */
+    static resetCache() {
+        this.purifyWindow = null;
+        this.purify = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yamlValidator.js","sourceRoot":"","sources":["../../src/security/yamlValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import yaml from 'js-yaml';\nimport { z } from 'zod';\nimport { logger } from '../utils/logger.js';\nimport DOMPurify from 'dompurify';\nimport { JSDOM } from 'jsdom';\nimport { RegexValidator } from './regexValidator.js';\nimport { SECURITY_LIMITS } from './constants.js';\n\nconst PersonaMetadataSchema = z.object({\n  name: z.string().min(1).max(100),\n  description: z.string().min(1).max(1000),\n  unique_id: z.string().optional(),\n  author: z.string().max(50).optional(),\n  triggers: z.array(z.string().max(50)).max(20).optional(),\n  version: z.string().regex(/^\\d+\\.\\d+\\.\\d+$/).optional(),\n  category: z.enum(['creative', 'professional', 'educational', 'gaming', 'personal']).optional(),\n  age_rating: z.enum(['all', '13+', '18+']).optional(),\n  content_flags: z.array(z.string()).optional(),\n  ai_generated: z.boolean().optional(),\n  generation_method: z.string().max(50).optional(),\n  price: z.string().max(20).optional(),\n  license: z.string().max(100).optional(),\n  created_date: z.string().optional()\n});\n\n// Type declarations for better type safety\ntype DOMPurifyInstance = ReturnType<typeof DOMPurify>;\n\nexport class YamlValidator {\n  // YAML bomb detection limits - extracted from Issue #164 review feedback\n  private static readonly YAML_BOMB_LIMITS = {\n    MAX_ANCHORS: 10,        // Maximum allowed anchor definitions (&name)\n    MAX_ALIASES: 20,        // Maximum allowed alias references (*name)\n    MAX_MERGE_KEYS: 5,      // Maximum allowed merge key operations (<<:)\n    MAX_DOCUMENTS: 3        // Maximum allowed documents in a single YAML\n  };\n\n  // Static cache for DOMPurify to improve performance\n  private static purifyWindow: any = null;\n  private static purify: DOMPurifyInstance | null = null;\n\n  static parsePersonaMetadataSafely(yamlContent: string): any {\n    if (!yamlContent || typeof yamlContent !== 'string') {\n      throw new Error('YAML content must be a non-empty string');\n    }\n    \n    // Size check\n    if (yamlContent.length > SECURITY_LIMITS.MAX_YAML_LENGTH) {\n      throw new Error(`YAML content too large: ${yamlContent.length} bytes (max: ${SECURITY_LIMITS.MAX_YAML_LENGTH})`);\n    }\n    \n    // Check for dangerous tags - expanded from Issue #164\n    const dangerousTags = [\n      '!!js/', '!!python/', '!!ruby/', '!!perl/', '!!php/',\n      '!!java', '!!javax', '!!com.sun',\n      '!!exec', '!!eval', '!!new', '!!construct', '!!apply',\n      '!!call', '!!invoke', '!!binary', '!!merge'\n    ];\n    \n    for (const tag of dangerousTags) {\n      if (yamlContent.includes(tag)) {\n        throw new Error(`Dangerous YAML tag detected: ${tag}`);\n      }\n    }\n    \n    // Enhanced YAML bomb protection - Issue #164\n    const anchorCount = (yamlContent.match(/&\\w+/g) || []).length;\n    const aliasCount = (yamlContent.match(/\\*\\w+/g) || []).length;\n    const mergeKeyCount = (yamlContent.match(/<<:/g) || []).length;\n    const documentCount = (yamlContent.match(/^---/gm) || []).length;\n    \n    if (anchorCount > this.YAML_BOMB_LIMITS.MAX_ANCHORS || \n        aliasCount > this.YAML_BOMB_LIMITS.MAX_ALIASES || \n        mergeKeyCount > this.YAML_BOMB_LIMITS.MAX_MERGE_KEYS || \n        documentCount > this.YAML_BOMB_LIMITS.MAX_DOCUMENTS) {\n      throw new Error(`Potential YAML bomb detected: anchors=${anchorCount}, aliases=${aliasCount}, merges=${mergeKeyCount}, documents=${documentCount}`);\n    }\n    \n    // Check for nested tag combinations\n    const nestedTagPattern = /[&*]\\w+\\s*!!/;\n    if (nestedTagPattern.test(yamlContent)) {\n      throw new Error('Dangerous nested YAML tag combination detected');\n    }\n    \n    try {\n      // Use safe load with restricted schema\n      const rawData = yaml.load(yamlContent, {\n        schema: yaml.CORE_SCHEMA, // No functions, only basic types\n        onWarning: (warning) => {\n          logger.warn('YAML parsing warning:', warning);\n        }\n      });\n      \n      // Validate against schema\n      const validatedData = PersonaMetadataSchema.parse(rawData);\n      \n      // Additional sanitization\n      return this.sanitizeMetadata(validatedData);\n    } catch (error) {\n      if (error instanceof Error && error.name === 'YAMLException') {\n        throw new Error(`Invalid YAML syntax: ${error.message}`);\n      }\n      throw new Error(`Invalid persona metadata: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  private static sanitizeMetadata(data: any): any {\n    const sanitized = { ...data };\n    \n    // Sanitize string fields\n    const stringFields = ['name', 'description', 'author', 'unique_id'];\n    for (const field of stringFields) {\n      if (sanitized[field]) {\n        sanitized[field] = this.sanitizeString(sanitized[field]);\n      }\n    }\n    \n    // Sanitize array fields\n    if (sanitized.triggers) {\n      sanitized.triggers = sanitized.triggers.map((t: string) => this.sanitizeString(t));\n    }\n    \n    return sanitized;\n  }\n\n  /**\n   * Initialize DOMPurify instance if not already initialized\n   */\n  private static initializePurify(): void {\n    if (!this.purifyWindow || !this.purify) {\n      const dom = new JSDOM('');\n      this.purifyWindow = dom.window;\n      this.purify = DOMPurify(this.purifyWindow);\n    }\n  }\n\n  /**\n   * Sanitize string input using DOMPurify to prevent XSS attacks\n   * This replaces the regex-based approach with a more robust solution\n   */\n  private static sanitizeString(input: string): string {\n    // Limit input length to prevent DoS\n    if (input.length > 10000) {\n      input = input.substring(0, 10000);\n    }\n    \n    // Initialize DOMPurify if needed\n    this.initializePurify();\n    \n    // Use DOMPurify with strict configuration\n    // ALLOWED_TAGS: [] strips all HTML tags\n    // ALLOWED_ATTR: [] strips all attributes\n    // FORBID_TAGS/FORBID_ATTR provide additional protection\n    let sanitized = this.purify!.sanitize(input, {\n      ALLOWED_TAGS: [],      // Strip all HTML tags\n      ALLOWED_ATTR: [],      // Strip all attributes\n      FORBID_TAGS: ['style', 'script', 'iframe', 'object', 'embed', 'link'],\n      FORBID_ATTR: ['onerror', 'onload', 'onclick', 'onmouseover', 'style', 'href', 'src']\n    });\n    \n    // Additional protection against command injection patterns\n    // These patterns might not be caught by DOMPurify\n    const commandInjectionPatterns = [\n      /`[^`]{0,1000}`/g,           // Backtick expressions\n      /\\$\\([^)]{0,1000}\\)/g,       // Command substitution\n      /\\$\\{[^}]{0,1000}\\}/g,       // Variable expansion\n      /\\\\x[0-9a-fA-F]{2}/g,        // Hex escapes\n      /\\\\u[0-9a-fA-F]{4}/g,        // Unicode escapes\n      /\\\\[0-7]{1,3}/g              // Octal escapes\n    ];\n    \n    for (const pattern of commandInjectionPatterns) {\n      sanitized = sanitized.replace(pattern, '');\n    }\n    \n    // Remove null bytes and normalize whitespace\n    sanitized = sanitized\n      .replace(/\\x00/g, '')          // Remove null bytes\n      .replace(/[\\r\\n]+/g, ' ')      // Replace newlines with spaces\n      .trim();\n    \n    return sanitized;\n  }\n  \n  /**\n   * Reset static DOMPurify cache (useful for long-running processes)\n   */\n  public static resetCache(): void {\n    this.purifyWindow = null;\n    this.purify = null;\n  }\n}"]}