@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
167 lines • 21.5 kB
JavaScript
/**
* InputNormalizer - Industry-standard input normalization at the boundary
*
* Architecture Pattern: Defense in Depth - Normalize Once at Entry Point
*
* This utility enforces the principle of "normalize at the boundary" for security:
* - Recursively normalizes ALL string values in input objects
* - Uses UnicodeValidator.normalize() as the single normalization implementation
* - Returns normalized object + aggregated security issues
* - Validators receive clean, pre-normalized data
*
* Security Benefits:
* - Single normalization point (no scattered validateContent calls)
* - Can't forget to normalize a field
* - Separation of concerns (normalization vs validation)
* - Easier to audit and maintain
*
* Usage:
* ```typescript
* // At the validation boundary (GenericElementValidator)
* const normalized = InputNormalizer.normalize(data);
*
* if (normalized.hasHighOrCriticalIssues) {
* return ValidatorHelpers.fail(normalized.errors);
* }
*
* // Now validate the normalized data
* const result = await this.validateFields(normalized.data);
* ```
*
* @see UnicodeValidator.normalize() - Core normalization implementation
* @see GenericElementValidator - Uses this at the boundary
*/
import { UnicodeValidator } from './validators/unicodeValidator.js';
import { SecurityMonitor } from './securityMonitor.js';
import { escalateSeverity } from './constants.js';
/**
* InputNormalizer - Recursively normalizes all string values in an object
*
* This class provides a centralized, recursive normalization utility that:
* - Walks object/array structures recursively
* - Normalizes every string value using UnicodeValidator
* - Aggregates security issues across all fields
* - Preserves non-string values unchanged
* - Tracks normalization path for detailed error reporting
*/
export class InputNormalizer {
/**
* Normalize all string values in an object/array structure
*
* @param input - Input data to normalize (object, array, or primitive)
* @param path - Current path in object tree (for error tracking)
* @returns Normalization result with normalized data and detected issues
*
* @example
* ```typescript
* const input = {
* name: 'Test\u200BName', // Zero-width space
* description: 'Café', // Legitimate Unicode
* nested: {
* field: 'Val\u202Eue' // Direction override
* }
* };
*
* const result = InputNormalizer.normalize(input);
* console.log(result.data.name); // 'TestName' (cleaned)
* console.log(result.warnings); // ['name: Zero-width characters detected', ...]
* ```
*/
static normalize(input, path = '$') {
const errors = [];
const warnings = [];
const issuesByPath = new Map();
let maxSeverity;
// Recursive normalization implementation
const normalizeValue = (value, currentPath) => {
// Handle null/undefined
if (value === null || value === undefined) {
return value;
}
// Handle strings - this is where normalization happens
if (typeof value === 'string') {
const unicodeResult = UnicodeValidator.normalize(value);
// Track issues for this field
if (unicodeResult.detectedIssues && unicodeResult.detectedIssues.length > 0) {
const pathIssues = unicodeResult.detectedIssues.map(issue => `${currentPath}: ${issue}`);
issuesByPath.set(currentPath, unicodeResult.detectedIssues);
// Categorize by severity
if (unicodeResult.severity) {
maxSeverity = escalateSeverity(maxSeverity, unicodeResult.severity);
if (unicodeResult.severity === 'critical' || unicodeResult.severity === 'high') {
errors.push(...pathIssues);
}
else {
warnings.push(...pathIssues);
}
}
else {
warnings.push(...pathIssues);
}
}
return unicodeResult.normalizedContent;
}
// Handle arrays - recursively normalize each element
if (Array.isArray(value)) {
return value.map((item, index) => normalizeValue(item, `${currentPath}[${index}]`));
}
// Handle objects - recursively normalize each property
if (typeof value === 'object') {
const normalized = {};
for (const [key, val] of Object.entries(value)) {
normalized[key] = normalizeValue(val, `${currentPath}.${key}`);
}
return normalized;
}
// Preserve other types unchanged (numbers, booleans, etc.)
return value;
};
// Normalize the input
const normalizedData = normalizeValue(input, path);
// Calculate aggregate status (#1782-6: separate critical-only from high+critical)
const hasIssues = errors.length > 0 || warnings.length > 0;
const hasCriticalIssues = maxSeverity === 'critical';
const hasHighOrCriticalIssues = maxSeverity === 'critical' || maxSeverity === 'high';
// Log if high or critical issues detected
if (hasHighOrCriticalIssues) {
SecurityMonitor.logSecurityEvent({
type: 'UNICODE_VALIDATION_ERROR',
severity: maxSeverity === 'critical' ? 'CRITICAL' : 'HIGH',
source: 'InputNormalizer',
details: `Critical Unicode issues detected during normalization: ${errors.join('; ')}`
});
}
return {
data: normalizedData,
hasIssues,
hasCriticalIssues,
hasHighOrCriticalIssues,
errors,
warnings,
issuesByPath,
maxSeverity
};
}
/**
* Quick check if input needs normalization (has suspicious Unicode)
*
* This is an optimization - you can check if normalization is needed
* before doing expensive recursive normalization.
*
* @param input - Input data to check
* @returns True if input contains potentially dangerous Unicode
*/
static needsNormalization(input) {
if (typeof input === 'string') {
return UnicodeValidator.containsDangerousUnicode(input);
}
if (Array.isArray(input)) {
return input.some(item => this.needsNormalization(item));
}
if (input && typeof input === 'object') {
return Object.values(input).some(value => this.needsNormalization(value));
}
return false;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"InputNormalizer.js","sourceRoot":"","sources":["../../src/security/InputNormalizer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * InputNormalizer - Industry-standard input normalization at the boundary\n *\n * Architecture Pattern: Defense in Depth - Normalize Once at Entry Point\n *\n * This utility enforces the principle of \"normalize at the boundary\" for security:\n * - Recursively normalizes ALL string values in input objects\n * - Uses UnicodeValidator.normalize() as the single normalization implementation\n * - Returns normalized object + aggregated security issues\n * - Validators receive clean, pre-normalized data\n *\n * Security Benefits:\n * - Single normalization point (no scattered validateContent calls)\n * - Can't forget to normalize a field\n * - Separation of concerns (normalization vs validation)\n * - Easier to audit and maintain\n *\n * Usage:\n * ```typescript\n * // At the validation boundary (GenericElementValidator)\n * const normalized = InputNormalizer.normalize(data);\n *\n * if (normalized.hasHighOrCriticalIssues) {\n *   return ValidatorHelpers.fail(normalized.errors);\n * }\n *\n * // Now validate the normalized data\n * const result = await this.validateFields(normalized.data);\n * ```\n *\n * @see UnicodeValidator.normalize() - Core normalization implementation\n * @see GenericElementValidator - Uses this at the boundary\n */\n\nimport { UnicodeValidator } from './validators/unicodeValidator.js';\nimport { SecurityMonitor } from './securityMonitor.js';\nimport { escalateSeverity } from './constants.js';\n\n/**\n * Result from input normalization\n */\nexport interface NormalizationResult<T = unknown> {\n  /** The normalized data structure with all strings normalized */\n  data: T;\n  /** Whether normalization detected any issues */\n  hasIssues: boolean;\n  /** Whether critical-severity issues were detected */\n  hasCriticalIssues: boolean;\n  /** Whether high-or-critical issues were detected that should fail validation (#1782-6) */\n  hasHighOrCriticalIssues: boolean;\n  /** All errors detected during normalization (critical issues) */\n  errors: string[];\n  /** All warnings detected during normalization (non-critical issues) */\n  warnings: string[];\n  /** Detailed issues by path (for debugging) */\n  issuesByPath: Map<string, string[]>;\n  /** Highest severity level detected */\n  maxSeverity?: 'low' | 'medium' | 'high' | 'critical';\n}\n\n/**\n * InputNormalizer - Recursively normalizes all string values in an object\n *\n * This class provides a centralized, recursive normalization utility that:\n * - Walks object/array structures recursively\n * - Normalizes every string value using UnicodeValidator\n * - Aggregates security issues across all fields\n * - Preserves non-string values unchanged\n * - Tracks normalization path for detailed error reporting\n */\nexport class InputNormalizer {\n  /**\n   * Normalize all string values in an object/array structure\n   *\n   * @param input - Input data to normalize (object, array, or primitive)\n   * @param path - Current path in object tree (for error tracking)\n   * @returns Normalization result with normalized data and detected issues\n   *\n   * @example\n   * ```typescript\n   * const input = {\n   *   name: 'Test\\u200BName',  // Zero-width space\n   *   description: 'Café',      // Legitimate Unicode\n   *   nested: {\n   *     field: 'Val\\u202Eue'    // Direction override\n   *   }\n   * };\n   *\n   * const result = InputNormalizer.normalize(input);\n   * console.log(result.data.name);  // 'TestName' (cleaned)\n   * console.log(result.warnings);   // ['name: Zero-width characters detected', ...]\n   * ```\n   */\n  static normalize<T = unknown>(input: T, path: string = '$'): NormalizationResult<T> {\n    const errors: string[] = [];\n    const warnings: string[] = [];\n    const issuesByPath = new Map<string, string[]>();\n    let maxSeverity: 'low' | 'medium' | 'high' | 'critical' | undefined;\n\n    // Recursive normalization implementation\n    const normalizeValue = (value: unknown, currentPath: string): unknown => {\n      // Handle null/undefined\n      if (value === null || value === undefined) {\n        return value;\n      }\n\n      // Handle strings - this is where normalization happens\n      if (typeof value === 'string') {\n        const unicodeResult = UnicodeValidator.normalize(value);\n\n        // Track issues for this field\n        if (unicodeResult.detectedIssues && unicodeResult.detectedIssues.length > 0) {\n          const pathIssues = unicodeResult.detectedIssues.map(\n            issue => `${currentPath}: ${issue}`\n          );\n          issuesByPath.set(currentPath, unicodeResult.detectedIssues);\n\n          // Categorize by severity\n          if (unicodeResult.severity) {\n            maxSeverity = escalateSeverity(maxSeverity, unicodeResult.severity);\n\n            if (unicodeResult.severity === 'critical' || unicodeResult.severity === 'high') {\n              errors.push(...pathIssues);\n            } else {\n              warnings.push(...pathIssues);\n            }\n          } else {\n            warnings.push(...pathIssues);\n          }\n        }\n\n        return unicodeResult.normalizedContent;\n      }\n\n      // Handle arrays - recursively normalize each element\n      if (Array.isArray(value)) {\n        return value.map((item, index) =>\n          normalizeValue(item, `${currentPath}[${index}]`)\n        );\n      }\n\n      // Handle objects - recursively normalize each property\n      if (typeof value === 'object') {\n        const normalized: Record<string, unknown> = {};\n        for (const [key, val] of Object.entries(value as Record<string, unknown>)) {\n          normalized[key] = normalizeValue(val, `${currentPath}.${key}`);\n        }\n        return normalized;\n      }\n\n      // Preserve other types unchanged (numbers, booleans, etc.)\n      return value;\n    };\n\n    // Normalize the input\n    const normalizedData = normalizeValue(input, path) as T;\n\n    // Calculate aggregate status (#1782-6: separate critical-only from high+critical)\n    const hasIssues = errors.length > 0 || warnings.length > 0;\n    const hasCriticalIssues = maxSeverity === 'critical';\n    const hasHighOrCriticalIssues = maxSeverity === 'critical' || maxSeverity === 'high';\n\n    // Log if high or critical issues detected\n    if (hasHighOrCriticalIssues) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'UNICODE_VALIDATION_ERROR',\n        severity: maxSeverity === 'critical' ? 'CRITICAL' : 'HIGH',\n        source: 'InputNormalizer',\n        details: `Critical Unicode issues detected during normalization: ${errors.join('; ')}`\n      });\n    }\n\n    return {\n      data: normalizedData,\n      hasIssues,\n      hasCriticalIssues,\n      hasHighOrCriticalIssues,\n      errors,\n      warnings,\n      issuesByPath,\n      maxSeverity\n    };\n  }\n\n  /**\n   * Quick check if input needs normalization (has suspicious Unicode)\n   *\n   * This is an optimization - you can check if normalization is needed\n   * before doing expensive recursive normalization.\n   *\n   * @param input - Input data to check\n   * @returns True if input contains potentially dangerous Unicode\n   */\n  static needsNormalization(input: unknown): boolean {\n    if (typeof input === 'string') {\n      return UnicodeValidator.containsDangerousUnicode(input);\n    }\n\n    if (Array.isArray(input)) {\n      return input.some(item => this.needsNormalization(item));\n    }\n\n    if (input && typeof input === 'object') {\n      return Object.values(input as Record<string, unknown>).some(\n        value => this.needsNormalization(value)\n      );\n    }\n\n    return false;\n  }\n}\n"]}