@dollhousemcp/mcp-server 1.3.0

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

@@ -0,0 +1,80 @@
+/**
+ * Input validation and sanitization functions
+ */
+/**
+ * Enhanced input validation for MCP tools
+ */
+export declare class MCPInputValidator {
+    /**
+     * Validate a persona identifier (name or filename)
+     */
+    static validatePersonaIdentifier(identifier: string): string;
+    /**
+     * Validate search query for collection
+     */
+    static validateSearchQuery(query: string): string;
+    /**
+     * Validate collection path
+     */
+    static validateCollectionPath(path: string): string;
+    /**
+     * Validate URL for import operations
+     */
+    static validateImportUrl(url: string): string;
+    /**
+     * Validate expiry days for sharing
+     */
+    static validateExpiryDays(days: number): number;
+    /**
+     * Validate boolean confirmation parameters
+     */
+    static validateConfirmation(confirm: boolean, operationName: string): boolean;
+    /**
+     * Validate field name for edit operations
+     */
+    static validateEditField(field: string): string;
+    /**
+     * Check if hostname is a private IP address (IPv4 and IPv6)
+     */
+    private static isPrivateIP;
+    /**
+     * Check for encoded private IP addresses that could bypass basic detection
+     */
+    private static isEncodedPrivateIP;
+}
+/**
+ * Validate and sanitize a filename
+ */
+export declare function validateFilename(filename: string): string;
+/**
+ * Validate and sanitize a path
+ */
+export declare function validatePath(inputPath: string, baseDir?: string): string;
+/**
+ * Validate and sanitize a username
+ */
+export declare function validateUsername(username: string): string;
+/**
+ * Validate a category
+ */
+export declare function validateCategory(category: string): string;
+/**
+ * Validate content size
+ */
+export declare function validateContentSize(content: string, maxSize?: number): void;
+/**
+ * Comprehensive input validation before pattern matching
+ * Validates all content types with appropriate limits
+ */
+export interface ContentValidationOptions {
+    maxContentLength?: number;
+    maxYamlLength?: number;
+    maxMetadataFieldLength?: number;
+    maxFileSize?: number;
+}
+export declare function validateInputLengths(content: string, contentType: 'full' | 'yaml' | 'metadata' | 'field', options?: ContentValidationOptions): void;
+/**
+ * General input sanitization
+ */
+export declare function sanitizeInput(input: string, maxLength?: number): string;
+//# sourceMappingURL=InputValidator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InputValidator.d.ts","sourceRoot":"","sources":["../../../../src/security/InputValidator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAyBH;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,MAAM,CAAC,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAkB5D;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IA4BjD;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAoDnD;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IA8D7C;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAgB/C;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO;IAY7E;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAkB/C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAgD1B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;CA+BlC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiBzD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAwCxE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUzD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBzD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAA2C,GAAG,IAAI,CAS/G;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,EACnD,OAAO,GAAE,wBAA6B,GACrC,IAAI,CA2CN;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,GAAE,MAAa,GAAG,MAAM,CAa7E"}

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

@@ -0,0 +1,436 @@
+/**
+ * Input validation and sanitization functions
+ */
+import * as path from 'path';
+import { SECURITY_LIMITS, VALIDATION_PATTERNS } from './constants.js';
+import { VALID_CATEGORIES } from '../config/constants.js';
+import { RegexValidator } from './regexValidator.js';
+// Pre-compiled regex patterns for better performance
+// These patterns are used repeatedly and benefit from pre-compilation
+const CONTROL_CHARS_REGEX = /[\x00-\x1F\x7F]/g;
+const HTML_DANGEROUS_REGEX = /[<>'"&]/g;
+const SHELL_METACHAR_REGEX = /[;&|`$()!\\~*?{}]/g;
+const RTL_ZEROWIDTH_REGEX = /[\u202E\uFEFF]/g;
+const COLLECTION_PATH_CHAR_REGEX = /[a-zA-Z0-9\/\-_.]/;
+const VALID_COLLECTION_PATH_REGEX = /^[a-zA-Z0-9\/\-_.]*$/;
+const IPV4_REGEX = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/;
+const DECIMAL_IP_REGEX = /^\d{8,10}$/;
+const HEX_IP_REGEX = /^0x[0-9a-f]{1,8}$/i;
+const OCTAL_IP_REGEX = /^0[0-7]{8,11}$/;
+const FILENAME_DANGEROUS_REGEX = /[\/\\:*?"<>|]/g;
+const FILENAME_LEADING_DOTS_REGEX = /^\.+/;
+const PATH_NORMALIZE_REGEX = /^\/{1,100}|\/{1,100}$/g;
+const PATH_MULTIPLE_SLASHES_REGEX = /\/{1,100}/g;
+const URL_PLUS_DECODE_REGEX = /\+/g;
+/**
+ * Enhanced input validation for MCP tools
+ */
+export class MCPInputValidator {
+    /**
+     * Validate a persona identifier (name or filename)
+     */
+    static validatePersonaIdentifier(identifier) {
+        if (!identifier || typeof identifier !== 'string') {
+            throw new Error('Persona identifier must be a non-empty string');
+        }
+        if (identifier.length > 100) {
+            throw new Error('Persona identifier too long (max 100 characters)');
+        }
+        // Allow persona names and filenames
+        const sanitized = sanitizeInput(identifier, 100);
+        if (!sanitized) {
+            throw new Error('Persona identifier contains only invalid characters');
+        }
+        return sanitized;
+    }
+    /**
+     * Validate search query for collection
+     */
+    static validateSearchQuery(query) {
+        if (!query || typeof query !== 'string') {
+            throw new Error('Search query must be a non-empty string');
+        }
+        if (query.length < 2) {
+            throw new Error('Search query too short (minimum 2 characters)');
+        }
+        if (query.length > 200) {
+            throw new Error('Search query too long (max 200 characters)');
+        }
+        // Sanitize but preserve spaces for search
+        const sanitized = query
+            .replace(CONTROL_CHARS_REGEX, '') // Remove control characters
+            .replace(HTML_DANGEROUS_REGEX, '') // Remove HTML-dangerous characters
+            .replace(SHELL_METACHAR_REGEX, '') // Remove shell metacharacters (expanded)
+            .replace(RTL_ZEROWIDTH_REGEX, '') // Remove RTL override and zero-width chars
+            .trim();
+        if (!sanitized) {
+            throw new Error('Search query contains only invalid characters');
+        }
+        return sanitized;
+    }
+    /**
+     * Validate collection path
+     */
+    static validateCollectionPath(path) {
+        if (!path || typeof path !== 'string') {
+            throw new Error('Collection path must be a non-empty string');
+        }
+        if (path.length > 500) {
+            throw new Error('Collection path too long (max 500 characters)');
+        }
+        // GitHub API paths should be safe filename patterns
+        // Use single regex test for better performance (avoids O(n) character-by-character check)
+        if (!VALID_COLLECTION_PATH_REGEX.test(path)) {
+            // Only do character-by-character check if validation fails, to provide detailed error message
+            for (let i = 0; i < path.length; i++) {
+                const char = path[i];
+                if (!COLLECTION_PATH_CHAR_REGEX.test(char)) {
+                    throw new Error(`Invalid character '${char}' in collection path at position ${i + 1}`);
+                }
+            }
+            // Fallback error if we somehow don't find the invalid character
+            throw new Error('Invalid characters in collection path');
+        }
+        // Prevent path traversal in GitHub paths (comprehensive check)
+        const pathLower = path.toLowerCase();
+        const encodedPath = decodeURIComponent(path.replace(URL_PLUS_DECODE_REGEX, ' ')); // Decode URL encoding
+        // Check for various path traversal patterns
+        const traversalPatterns = [
+            '..', // Basic traversal
+            './', // Current directory
+            '/../', // Directory traversal with slashes
+            '\\', // Backslash (Windows-style)
+            '%2e%2e', // URL-encoded ..
+            '%2e%2e%2f', // URL-encoded ../
+            '%2e%2e%5c', // URL-encoded ..\
+            '%252e%252e', // Double URL-encoded ..
+            '..%2f', // Mixed encoding
+            '..%5c', // Mixed encoding with backslash
+            '..../', // Dotdot bypass attempt
+            '..;/', // Semicolon bypass attempt
+        ];
+        for (const pattern of traversalPatterns) {
+            if (pathLower.includes(pattern) || encodedPath.toLowerCase().includes(pattern)) {
+                throw new Error('Path traversal not allowed in collection path');
+            }
+        }
+        return path;
+    }
+    /**
+     * Validate URL for import operations
+     */
+    static validateImportUrl(url) {
+        if (!url || typeof url !== 'string') {
+            throw new Error('URL must be a non-empty string');
+        }
+        if (url.length > 2000) {
+            throw new Error('URL too long (max 2000 characters)');
+        }
+        // Reject protocol-relative URLs that could bypass validation
+        if (url.startsWith('//')) {
+            throw new Error('Protocol-relative URLs are not allowed');
+        }
+        try {
+            // Decode URL to prevent encoding-based bypasses
+            let decodedUrl = url;
+            try {
+                decodedUrl = decodeURIComponent(url);
+            }
+            catch {
+                // If decoding fails, use original URL
+            }
+            const parsed = new URL(decodedUrl);
+            // Protocol validation
+            if (!['http:', 'https:'].includes(parsed.protocol)) {
+                throw new Error('Only HTTP(S) URLs are allowed');
+            }
+            // Enhanced SSRF protection with IDN normalization
+            let hostname = parsed.hostname.toLowerCase();
+            // Handle IDN (International Domain Names) by converting to ASCII
+            try {
+                const idnNormalized = new URL(`http://${hostname}`).hostname;
+                hostname = idnNormalized;
+            }
+            catch (idnError) {
+                // If IDN conversion fails, reject the URL for security
+                throw new Error('Invalid hostname: IDN conversion failed - potentially malicious domain name');
+            }
+            // Check for private IPs (now with IDN-normalized hostname)
+            if (this.isPrivateIP(hostname)) {
+                throw new Error('Private network URLs are not allowed');
+            }
+            // Additional SSRF checks for encoded IPs
+            if (this.isEncodedPrivateIP(hostname)) {
+                throw new Error('Encoded private network URLs are not allowed');
+            }
+            return url;
+        }
+        catch (error) {
+            if (error instanceof Error && (error.message.includes('Private network') || error.message.includes('Encoded private'))) {
+                throw error;
+            }
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Invalid URL format: ${errorMessage}`);
+        }
+    }
+    /**
+     * Validate expiry days for sharing
+     */
+    static validateExpiryDays(days) {
+        if (typeof days !== 'number') {
+            throw new Error('Expiry days must be a valid number');
+        }
+        if (isNaN(days) || !isFinite(days)) {
+            throw new Error('Expiry days must be a valid number');
+        }
+        if (days < 1 || days > 365) {
+            throw new Error('Expiry days must be between 1 and 365');
+        }
+        return Math.floor(days);
+    }
+    /**
+     * Validate boolean confirmation parameters
+     */
+    static validateConfirmation(confirm, operationName) {
+        if (typeof confirm !== 'boolean') {
+            throw new Error(`${operationName} confirmation must be a boolean value`);
+        }
+        if (!confirm) {
+            throw new Error(`${operationName} operation requires explicit confirmation (true)`);
+        }
+        return confirm;
+    }
+    /**
+     * Validate field name for edit operations
+     */
+    static validateEditField(field) {
+        if (!field || typeof field !== 'string') {
+            throw new Error('Field name must be a non-empty string');
+        }
+        const validFields = [
+            'name', 'description', 'category', 'instructions',
+            'triggers', 'version', 'author', 'tags'
+        ];
+        const normalizedField = field.toLowerCase().trim();
+        if (!validFields.includes(normalizedField)) {
+            throw new Error(`Invalid field name. Must be one of: ${validFields.join(', ')}`);
+        }
+        return normalizedField;
+    }
+    /**
+     * Check if hostname is a private IP address (IPv4 and IPv6)
+     */
+    static isPrivateIP(hostname) {
+        // Check for localhost variations
+        if (['localhost', '127.0.0.1', '::1'].includes(hostname)) {
+            return true;
+        }
+        // Check for private IPv4 ranges
+        const ipv4Match = hostname.match(IPV4_REGEX);
+        if (ipv4Match) {
+            const [, a, b, c, d] = ipv4Match.map(Number);
+            // 10.0.0.0/8
+            if (a === 10)
+                return true;
+            // 172.16.0.0/12
+            if (a === 172 && b >= 16 && b <= 31)
+                return true;
+            // 192.168.0.0/16
+            if (a === 192 && b === 168)
+                return true;
+            // 169.254.0.0/16 (link-local)
+            if (a === 169 && b === 254)
+                return true;
+        }
+        // Check for private IPv6 ranges
+        const ipv6Lower = hostname.toLowerCase();
+        // fc00::/7 - Unique Local Addresses (ULA)
+        if (ipv6Lower.startsWith('fc') || ipv6Lower.startsWith('fd')) {
+            return true;
+        }
+        // fe80::/10 - Link-Local Addresses
+        // IPv6 link-local addresses are fe80::/10, meaning the valid range is fe80 through febf
+        const fe80Range = parseInt(ipv6Lower.substring(0, 4), 16);
+        if (fe80Range >= 0xfe80 && fe80Range <= 0xfebf) {
+            return true;
+        }
+        // Additional IPv6 localhost formats
+        if (['::1', '0:0:0:0:0:0:0:1'].includes(ipv6Lower)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check for encoded private IP addresses that could bypass basic detection
+     */
+    static isEncodedPrivateIP(hostname) {
+        // Check for decimal encoded IPs (e.g., 2130706433 = 127.0.0.1)
+        if (DECIMAL_IP_REGEX.test(hostname)) {
+            const num = parseInt(hostname, 10);
+            if (num >= 0 && num <= 4294967295) { // Valid IPv4 range
+                // Convert to IP format and check if private
+                const ip = [(num >>> 24) & 255, (num >>> 16) & 255, (num >>> 8) & 255, num & 255].join('.');
+                return this.isPrivateIP(ip);
+            }
+        }
+        // Check for hex encoded IPs (e.g., 0x7f000001 = 127.0.0.1)
+        if (HEX_IP_REGEX.test(hostname)) {
+            const num = parseInt(hostname, 16);
+            if (num >= 0 && num <= 4294967295) {
+                const ip = [(num >>> 24) & 255, (num >>> 16) & 255, (num >>> 8) & 255, num & 255].join('.');
+                return this.isPrivateIP(ip);
+            }
+        }
+        // Check for octal encoded IPs (e.g., 017700000001 = 127.0.0.1)
+        if (OCTAL_IP_REGEX.test(hostname)) {
+            const num = parseInt(hostname, 8);
+            if (num >= 0 && num <= 4294967295) {
+                const ip = [(num >>> 24) & 255, (num >>> 16) & 255, (num >>> 8) & 255, num & 255].join('.');
+                return this.isPrivateIP(ip);
+            }
+        }
+        return false;
+    }
+}
+/**
+ * Validate and sanitize a filename
+ */
+export function validateFilename(filename) {
+    if (!filename || typeof filename !== 'string') {
+        throw new Error('Filename must be a non-empty string');
+    }
+    if (filename.length > SECURITY_LIMITS.MAX_FILENAME_LENGTH) {
+        throw new Error(`Filename too long (max ${SECURITY_LIMITS.MAX_FILENAME_LENGTH} characters)`);
+    }
+    // Remove any path separators and dangerous characters
+    const sanitized = filename.replace(FILENAME_DANGEROUS_REGEX, '').replace(FILENAME_LEADING_DOTS_REGEX, '');
+    if (!RegexValidator.validate(sanitized, VALIDATION_PATTERNS.SAFE_FILENAME, { maxLength: SECURITY_LIMITS.MAX_FILENAME_LENGTH })) {
+        throw new Error('Invalid filename format. Use alphanumeric characters, hyphens, underscores, and dots only.');
+    }
+    return sanitized;
+}
+/**
+ * Validate and sanitize a path
+ */
+export function validatePath(inputPath, baseDir) {
+    if (!inputPath || typeof inputPath !== 'string') {
+        throw new Error('Path must be a non-empty string');
+    }
+    // If baseDir is provided and inputPath is absolute, reject it
+    if (baseDir && path.isAbsolute(inputPath)) {
+        throw new Error('Absolute paths not allowed when base directory is specified');
+    }
+    // Remove leading/trailing slashes and normalize
+    // Length limits added to prevent ReDoS attacks
+    const normalized = inputPath.replace(PATH_NORMALIZE_REGEX, '').replace(PATH_MULTIPLE_SLASHES_REGEX, '/');
+    if (!VALIDATION_PATTERNS.SAFE_PATH.test(normalized)) {
+        throw new Error('Invalid path format. Use alphanumeric characters, hyphens, underscores, dots, and forward slashes only.');
+    }
+    // Check for path traversal attempts
+    if (normalized.includes('..') || normalized.includes('./') || normalized.includes('/.')) {
+        throw new Error('Path traversal not allowed');
+    }
+    // Validate path depth
+    const depth = normalized.split('/').length;
+    if (depth > SECURITY_LIMITS.MAX_PATH_DEPTH) {
+        throw new Error(`Path too deep (max ${SECURITY_LIMITS.MAX_PATH_DEPTH} levels)`);
+    }
+    // If baseDir provided, ensure path is within it
+    if (baseDir) {
+        const resolvedPath = path.resolve(baseDir, normalized);
+        const resolvedBase = path.resolve(baseDir);
+        if (!resolvedPath.startsWith(resolvedBase)) {
+            throw new Error('Path traversal attempt detected');
+        }
+    }
+    return normalized;
+}
+/**
+ * Validate and sanitize a username
+ */
+export function validateUsername(username) {
+    if (!username || typeof username !== 'string') {
+        throw new Error('Username must be a non-empty string');
+    }
+    if (!VALIDATION_PATTERNS.SAFE_USERNAME.test(username)) {
+        throw new Error('Invalid username format. Use alphanumeric characters, hyphens, underscores, and dots only.');
+    }
+    return username.toLowerCase();
+}
+/**
+ * Validate a category
+ */
+export function validateCategory(category) {
+    if (!category || typeof category !== 'string') {
+        throw new Error('Category must be a non-empty string');
+    }
+    if (!RegexValidator.validate(category, VALIDATION_PATTERNS.SAFE_CATEGORY, { maxLength: 50 })) {
+        throw new Error('Invalid category format. Use alphabetic characters, hyphens, and underscores only.');
+    }
+    const normalized = category.toLowerCase();
+    if (!VALID_CATEGORIES.includes(normalized)) {
+        throw new Error(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}`);
+    }
+    return normalized;
+}
+/**
+ * Validate content size
+ */
+export function validateContentSize(content, maxSize = SECURITY_LIMITS.MAX_CONTENT_LENGTH) {
+    if (!content || typeof content !== 'string') {
+        throw new Error('Content must be a non-empty string');
+    }
+    const sizeBytes = Buffer.byteLength(content, 'utf8');
+    if (sizeBytes > maxSize) {
+        throw new Error(`Content too large (${sizeBytes} bytes, max ${maxSize} bytes)`);
+    }
+}
+export function validateInputLengths(content, contentType, options = {}) {
+    const limits = {
+        maxContentLength: options.maxContentLength ?? SECURITY_LIMITS.MAX_CONTENT_LENGTH,
+        maxYamlLength: options.maxYamlLength ?? SECURITY_LIMITS.MAX_YAML_LENGTH,
+        maxMetadataFieldLength: options.maxMetadataFieldLength ?? SECURITY_LIMITS.MAX_METADATA_FIELD_LENGTH,
+        maxFileSize: options.maxFileSize ?? SECURITY_LIMITS.MAX_FILE_SIZE
+    };
+    // Validate based on content type
+    switch (contentType) {
+        case 'full':
+            if (content.length > limits.maxContentLength) {
+                throw new Error(`Content exceeds maximum length of ${limits.maxContentLength} characters (${content.length} provided)`);
+            }
+            break;
+        case 'yaml':
+            if (content.length > limits.maxYamlLength) {
+                throw new Error(`YAML content exceeds maximum length of ${limits.maxYamlLength} characters (${content.length} provided)`);
+            }
+            break;
+        case 'metadata':
+            // For metadata, check overall size
+            if (content.length > limits.maxYamlLength) {
+                throw new Error(`Metadata exceeds maximum length of ${limits.maxYamlLength} characters (${content.length} provided)`);
+            }
+            break;
+        case 'field':
+            if (content.length > limits.maxMetadataFieldLength) {
+                throw new Error(`Field exceeds maximum length of ${limits.maxMetadataFieldLength} characters (${content.length} provided)`);
+            }
+            break;
+    }
+}
+/**
+ * General input sanitization
+ */
+export function sanitizeInput(input, maxLength = 1000) {
+    if (!input || typeof input !== 'string') {
+        return '';
+    }
+    // Remove potentially dangerous characters and limit length
+    return input
+        .replace(CONTROL_CHARS_REGEX, '') // Remove control characters
+        .replace(HTML_DANGEROUS_REGEX, '') // Remove HTML-dangerous characters
+        .replace(SHELL_METACHAR_REGEX, '') // Remove shell metacharacters (expanded)
+        .replace(RTL_ZEROWIDTH_REGEX, '') // Remove RTL override and zero-width chars
+        .substring(0, maxLength)
+        .trim();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"InputValidator.js","sourceRoot":"","sources":["../../../../src/security/InputValidator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Input validation and sanitization functions\n */\n\nimport * as path from 'path';\nimport { SECURITY_LIMITS, VALIDATION_PATTERNS } from './constants.js';\nimport { VALID_CATEGORIES } from '../config/constants.js';\nimport { RegexValidator } from './regexValidator.js';\n\n// Pre-compiled regex patterns for better performance\n// These patterns are used repeatedly and benefit from pre-compilation\nconst CONTROL_CHARS_REGEX = /[\\x00-\\x1F\\x7F]/g;\nconst HTML_DANGEROUS_REGEX = /[<>'\"&]/g;\nconst SHELL_METACHAR_REGEX = /[;&|`$()!\\\\~*?{}]/g;\nconst RTL_ZEROWIDTH_REGEX = /[\\u202E\\uFEFF]/g;\nconst COLLECTION_PATH_CHAR_REGEX = /[a-zA-Z0-9\\/\\-_.]/;\nconst VALID_COLLECTION_PATH_REGEX = /^[a-zA-Z0-9\\/\\-_.]*$/;\nconst IPV4_REGEX = /^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$/;\nconst DECIMAL_IP_REGEX = /^\\d{8,10}$/;\nconst HEX_IP_REGEX = /^0x[0-9a-f]{1,8}$/i;\nconst OCTAL_IP_REGEX = /^0[0-7]{8,11}$/;\nconst FILENAME_DANGEROUS_REGEX = /[\\/\\\\:*?\"<>|]/g;\nconst FILENAME_LEADING_DOTS_REGEX = /^\\.+/;\nconst PATH_NORMALIZE_REGEX = /^\\/{1,100}|\\/{1,100}$/g;\nconst PATH_MULTIPLE_SLASHES_REGEX = /\\/{1,100}/g;\nconst URL_PLUS_DECODE_REGEX = /\\+/g;\n\n/**\n * Enhanced input validation for MCP tools\n */\nexport class MCPInputValidator {\n  /**\n   * Validate a persona identifier (name or filename)\n   */\n  static validatePersonaIdentifier(identifier: string): string {\n    if (!identifier || typeof identifier !== 'string') {\n      throw new Error('Persona identifier must be a non-empty string');\n    }\n\n    if (identifier.length > 100) {\n      throw new Error('Persona identifier too long (max 100 characters)');\n    }\n\n    // Allow persona names and filenames\n    const sanitized = sanitizeInput(identifier, 100);\n    if (!sanitized) {\n      throw new Error('Persona identifier contains only invalid characters');\n    }\n\n    return sanitized;\n  }\n\n  /**\n   * Validate search query for collection\n   */\n  static validateSearchQuery(query: string): string {\n    if (!query || typeof query !== 'string') {\n      throw new Error('Search query must be a non-empty string');\n    }\n\n    if (query.length < 2) {\n      throw new Error('Search query too short (minimum 2 characters)');\n    }\n\n    if (query.length > 200) {\n      throw new Error('Search query too long (max 200 characters)');\n    }\n\n    // Sanitize but preserve spaces for search\n    const sanitized = query\n      .replace(CONTROL_CHARS_REGEX, '') // Remove control characters\n      .replace(HTML_DANGEROUS_REGEX, '') // Remove HTML-dangerous characters\n      .replace(SHELL_METACHAR_REGEX, '') // Remove shell metacharacters (expanded)\n      .replace(RTL_ZEROWIDTH_REGEX, '') // Remove RTL override and zero-width chars\n      .trim();\n\n    if (!sanitized) {\n      throw new Error('Search query contains only invalid characters');\n    }\n\n    return sanitized;\n  }\n\n  /**\n   * Validate collection path\n   */\n  static validateCollectionPath(path: string): string {\n    if (!path || typeof path !== 'string') {\n      throw new Error('Collection path must be a non-empty string');\n    }\n\n    if (path.length > 500) {\n      throw new Error('Collection path too long (max 500 characters)');\n    }\n\n    // GitHub API paths should be safe filename patterns\n    // Use single regex test for better performance (avoids O(n) character-by-character check)\n    if (!VALID_COLLECTION_PATH_REGEX.test(path)) {\n      // Only do character-by-character check if validation fails, to provide detailed error message\n      for (let i = 0; i < path.length; i++) {\n        const char = path[i];\n        if (!COLLECTION_PATH_CHAR_REGEX.test(char)) {\n          throw new Error(`Invalid character '${char}' in collection path at position ${i + 1}`);\n        }\n      }\n      // Fallback error if we somehow don't find the invalid character\n      throw new Error('Invalid characters in collection path');\n    }\n\n    // Prevent path traversal in GitHub paths (comprehensive check)\n    const pathLower = path.toLowerCase();\n    const encodedPath = decodeURIComponent(path.replace(URL_PLUS_DECODE_REGEX, ' ')); // Decode URL encoding\n    \n    // Check for various path traversal patterns\n    const traversalPatterns = [\n      '..',          // Basic traversal\n      './',          // Current directory\n      '/../',        // Directory traversal with slashes\n      '\\\\',          // Backslash (Windows-style)\n      '%2e%2e',      // URL-encoded ..\n      '%2e%2e%2f',   // URL-encoded ../\n      '%2e%2e%5c',   // URL-encoded ..\\\n      '%252e%252e',  // Double URL-encoded ..\n      '..%2f',       // Mixed encoding\n      '..%5c',       // Mixed encoding with backslash\n      '..../',       // Dotdot bypass attempt\n      '..;/',        // Semicolon bypass attempt\n    ];\n    \n    for (const pattern of traversalPatterns) {\n      if (pathLower.includes(pattern) || encodedPath.toLowerCase().includes(pattern)) {\n        throw new Error('Path traversal not allowed in collection path');\n      }\n    }\n\n    return path;\n  }\n\n  /**\n   * Validate URL for import operations\n   */\n  static validateImportUrl(url: string): string {\n    if (!url || typeof url !== 'string') {\n      throw new Error('URL must be a non-empty string');\n    }\n\n    if (url.length > 2000) {\n      throw new Error('URL too long (max 2000 characters)');\n    }\n\n    // Reject protocol-relative URLs that could bypass validation\n    if (url.startsWith('//')) {\n      throw new Error('Protocol-relative URLs are not allowed');\n    }\n\n    try {\n      // Decode URL to prevent encoding-based bypasses\n      let decodedUrl = url;\n      try {\n        decodedUrl = decodeURIComponent(url);\n      } catch {\n        // If decoding fails, use original URL\n      }\n      \n      const parsed = new URL(decodedUrl);\n      \n      // Protocol validation\n      if (!['http:', 'https:'].includes(parsed.protocol)) {\n        throw new Error('Only HTTP(S) URLs are allowed');\n      }\n      \n      // Enhanced SSRF protection with IDN normalization\n      let hostname = parsed.hostname.toLowerCase();\n      \n      // Handle IDN (International Domain Names) by converting to ASCII\n      try {\n        const idnNormalized = new URL(`http://${hostname}`).hostname;\n        hostname = idnNormalized;\n      } catch (idnError) {\n        // If IDN conversion fails, reject the URL for security\n        throw new Error('Invalid hostname: IDN conversion failed - potentially malicious domain name');\n      }\n      \n      // Check for private IPs (now with IDN-normalized hostname)\n      if (this.isPrivateIP(hostname)) {\n        throw new Error('Private network URLs are not allowed');\n      }\n      \n      // Additional SSRF checks for encoded IPs\n      if (this.isEncodedPrivateIP(hostname)) {\n        throw new Error('Encoded private network URLs are not allowed');\n      }\n\n      return url;\n    } catch (error) {\n      if (error instanceof Error && (error.message.includes('Private network') || error.message.includes('Encoded private'))) {\n        throw error;\n      }\n      const errorMessage = error instanceof Error ? error.message : 'Unknown error';\n      throw new Error(`Invalid URL format: ${errorMessage}`);\n    }\n  }\n\n  /**\n   * Validate expiry days for sharing\n   */\n  static validateExpiryDays(days: number): number {\n    if (typeof days !== 'number') {\n      throw new Error('Expiry days must be a valid number');\n    }\n    \n    if (isNaN(days) || !isFinite(days)) {\n      throw new Error('Expiry days must be a valid number');\n    }\n\n    if (days < 1 || days > 365) {\n      throw new Error('Expiry days must be between 1 and 365');\n    }\n\n    return Math.floor(days);\n  }\n\n  /**\n   * Validate boolean confirmation parameters\n   */\n  static validateConfirmation(confirm: boolean, operationName: string): boolean {\n    if (typeof confirm !== 'boolean') {\n      throw new Error(`${operationName} confirmation must be a boolean value`);\n    }\n\n    if (!confirm) {\n      throw new Error(`${operationName} operation requires explicit confirmation (true)`);\n    }\n\n    return confirm;\n  }\n\n  /**\n   * Validate field name for edit operations\n   */\n  static validateEditField(field: string): string {\n    if (!field || typeof field !== 'string') {\n      throw new Error('Field name must be a non-empty string');\n    }\n\n    const validFields = [\n      'name', 'description', 'category', 'instructions', \n      'triggers', 'version', 'author', 'tags'\n    ];\n\n    const normalizedField = field.toLowerCase().trim();\n    if (!validFields.includes(normalizedField)) {\n      throw new Error(`Invalid field name. Must be one of: ${validFields.join(', ')}`);\n    }\n\n    return normalizedField;\n  }\n\n  /**\n   * Check if hostname is a private IP address (IPv4 and IPv6)\n   */\n  private static isPrivateIP(hostname: string): boolean {\n    // Check for localhost variations\n    if (['localhost', '127.0.0.1', '::1'].includes(hostname)) {\n      return true;\n    }\n\n    // Check for private IPv4 ranges\n    const ipv4Match = hostname.match(IPV4_REGEX);\n    \n    if (ipv4Match) {\n      const [, a, b, c, d] = ipv4Match.map(Number);\n      \n      // 10.0.0.0/8\n      if (a === 10) return true;\n      \n      // 172.16.0.0/12\n      if (a === 172 && b >= 16 && b <= 31) return true;\n      \n      // 192.168.0.0/16\n      if (a === 192 && b === 168) return true;\n      \n      // 169.254.0.0/16 (link-local)\n      if (a === 169 && b === 254) return true;\n    }\n\n    // Check for private IPv6 ranges\n    const ipv6Lower = hostname.toLowerCase();\n    \n    // fc00::/7 - Unique Local Addresses (ULA)\n    if (ipv6Lower.startsWith('fc') || ipv6Lower.startsWith('fd')) {\n      return true;\n    }\n    \n    // fe80::/10 - Link-Local Addresses\n    // IPv6 link-local addresses are fe80::/10, meaning the valid range is fe80 through febf\n    const fe80Range = parseInt(ipv6Lower.substring(0, 4), 16);\n    if (fe80Range >= 0xfe80 && fe80Range <= 0xfebf) {\n      return true;\n    }\n    \n    // Additional IPv6 localhost formats\n    if (['::1', '0:0:0:0:0:0:0:1'].includes(ipv6Lower)) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Check for encoded private IP addresses that could bypass basic detection\n   */\n  private static isEncodedPrivateIP(hostname: string): boolean {\n    // Check for decimal encoded IPs (e.g., 2130706433 = 127.0.0.1)\n    if (DECIMAL_IP_REGEX.test(hostname)) {\n      const num = parseInt(hostname, 10);\n      if (num >= 0 && num <= 4294967295) { // Valid IPv4 range\n        // Convert to IP format and check if private\n        const ip = [(num >>> 24) & 255, (num >>> 16) & 255, (num >>> 8) & 255, num & 255].join('.');\n        return this.isPrivateIP(ip);\n      }\n    }\n    \n    // Check for hex encoded IPs (e.g., 0x7f000001 = 127.0.0.1)\n    if (HEX_IP_REGEX.test(hostname)) {\n      const num = parseInt(hostname, 16);\n      if (num >= 0 && num <= 4294967295) {\n        const ip = [(num >>> 24) & 255, (num >>> 16) & 255, (num >>> 8) & 255, num & 255].join('.');\n        return this.isPrivateIP(ip);\n      }\n    }\n    \n    // Check for octal encoded IPs (e.g., 017700000001 = 127.0.0.1)\n    if (OCTAL_IP_REGEX.test(hostname)) {\n      const num = parseInt(hostname, 8);\n      if (num >= 0 && num <= 4294967295) {\n        const ip = [(num >>> 24) & 255, (num >>> 16) & 255, (num >>> 8) & 255, num & 255].join('.');\n        return this.isPrivateIP(ip);\n      }\n    }\n    \n    return false;\n  }\n}\n\n/**\n * Validate and sanitize a filename\n */\nexport function validateFilename(filename: string): string {\n  if (!filename || typeof filename !== 'string') {\n    throw new Error('Filename must be a non-empty string');\n  }\n  \n  if (filename.length > SECURITY_LIMITS.MAX_FILENAME_LENGTH) {\n    throw new Error(`Filename too long (max ${SECURITY_LIMITS.MAX_FILENAME_LENGTH} characters)`);\n  }\n  \n  // Remove any path separators and dangerous characters\n  const sanitized = filename.replace(FILENAME_DANGEROUS_REGEX, '').replace(FILENAME_LEADING_DOTS_REGEX, '');\n  \n  if (!RegexValidator.validate(sanitized, VALIDATION_PATTERNS.SAFE_FILENAME, { maxLength: SECURITY_LIMITS.MAX_FILENAME_LENGTH })) {\n    throw new Error('Invalid filename format. Use alphanumeric characters, hyphens, underscores, and dots only.');\n  }\n  \n  return sanitized;\n}\n\n/**\n * Validate and sanitize a path\n */\nexport function validatePath(inputPath: string, baseDir?: string): string {\n  if (!inputPath || typeof inputPath !== 'string') {\n    throw new Error('Path must be a non-empty string');\n  }\n  \n  // If baseDir is provided and inputPath is absolute, reject it\n  if (baseDir && path.isAbsolute(inputPath)) {\n    throw new Error('Absolute paths not allowed when base directory is specified');\n  }\n  \n  // Remove leading/trailing slashes and normalize\n  // Length limits added to prevent ReDoS attacks\n  const normalized = inputPath.replace(PATH_NORMALIZE_REGEX, '').replace(PATH_MULTIPLE_SLASHES_REGEX, '/');\n  \n  if (!VALIDATION_PATTERNS.SAFE_PATH.test(normalized)) {\n    throw new Error('Invalid path format. Use alphanumeric characters, hyphens, underscores, dots, and forward slashes only.');\n  }\n  \n  // Check for path traversal attempts\n  if (normalized.includes('..') || normalized.includes('./') || normalized.includes('/.')) {\n    throw new Error('Path traversal not allowed');\n  }\n  \n  // Validate path depth\n  const depth = normalized.split('/').length;\n  if (depth > SECURITY_LIMITS.MAX_PATH_DEPTH) {\n    throw new Error(`Path too deep (max ${SECURITY_LIMITS.MAX_PATH_DEPTH} levels)`);\n  }\n  \n  // If baseDir provided, ensure path is within it\n  if (baseDir) {\n    const resolvedPath = path.resolve(baseDir, normalized);\n    const resolvedBase = path.resolve(baseDir);\n    \n    if (!resolvedPath.startsWith(resolvedBase)) {\n      throw new Error('Path traversal attempt detected');\n    }\n  }\n  \n  return normalized;\n}\n\n/**\n * Validate and sanitize a username\n */\nexport function validateUsername(username: string): string {\n  if (!username || typeof username !== 'string') {\n    throw new Error('Username must be a non-empty string');\n  }\n  \n  if (!VALIDATION_PATTERNS.SAFE_USERNAME.test(username)) {\n    throw new Error('Invalid username format. Use alphanumeric characters, hyphens, underscores, and dots only.');\n  }\n  \n  return username.toLowerCase();\n}\n\n/**\n * Validate a category\n */\nexport function validateCategory(category: string): string {\n  if (!category || typeof category !== 'string') {\n    throw new Error('Category must be a non-empty string');\n  }\n  \n  if (!RegexValidator.validate(category, VALIDATION_PATTERNS.SAFE_CATEGORY, { maxLength: 50 })) {\n    throw new Error('Invalid category format. Use alphabetic characters, hyphens, and underscores only.');\n  }\n  \n  const normalized = category.toLowerCase();\n  \n  if (!VALID_CATEGORIES.includes(normalized)) {\n    throw new Error(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}`);\n  }\n  \n  return normalized;\n}\n\n/**\n * Validate content size\n */\nexport function validateContentSize(content: string, maxSize: number = SECURITY_LIMITS.MAX_CONTENT_LENGTH): void {\n  if (!content || typeof content !== 'string') {\n    throw new Error('Content must be a non-empty string');\n  }\n  \n  const sizeBytes = Buffer.byteLength(content, 'utf8');\n  if (sizeBytes > maxSize) {\n    throw new Error(`Content too large (${sizeBytes} bytes, max ${maxSize} bytes)`);\n  }\n}\n\n/**\n * Comprehensive input validation before pattern matching\n * Validates all content types with appropriate limits\n */\nexport interface ContentValidationOptions {\n  maxContentLength?: number;\n  maxYamlLength?: number;\n  maxMetadataFieldLength?: number;\n  maxFileSize?: number;\n}\n\nexport function validateInputLengths(\n  content: string,\n  contentType: 'full' | 'yaml' | 'metadata' | 'field',\n  options: ContentValidationOptions = {}\n): void {\n  const limits = {\n    maxContentLength: options.maxContentLength ?? SECURITY_LIMITS.MAX_CONTENT_LENGTH,\n    maxYamlLength: options.maxYamlLength ?? SECURITY_LIMITS.MAX_YAML_LENGTH,\n    maxMetadataFieldLength: options.maxMetadataFieldLength ?? SECURITY_LIMITS.MAX_METADATA_FIELD_LENGTH,\n    maxFileSize: options.maxFileSize ?? SECURITY_LIMITS.MAX_FILE_SIZE\n  };\n\n  // Validate based on content type\n  switch (contentType) {\n    case 'full':\n      if (content.length > limits.maxContentLength) {\n        throw new Error(\n          `Content exceeds maximum length of ${limits.maxContentLength} characters (${content.length} provided)`\n        );\n      }\n      break;\n    \n    case 'yaml':\n      if (content.length > limits.maxYamlLength) {\n        throw new Error(\n          `YAML content exceeds maximum length of ${limits.maxYamlLength} characters (${content.length} provided)`\n        );\n      }\n      break;\n    \n    case 'metadata':\n      // For metadata, check overall size\n      if (content.length > limits.maxYamlLength) {\n        throw new Error(\n          `Metadata exceeds maximum length of ${limits.maxYamlLength} characters (${content.length} provided)`\n        );\n      }\n      break;\n    \n    case 'field':\n      if (content.length > limits.maxMetadataFieldLength) {\n        throw new Error(\n          `Field exceeds maximum length of ${limits.maxMetadataFieldLength} characters (${content.length} provided)`\n        );\n      }\n      break;\n  }\n}\n\n/**\n * General input sanitization\n */\nexport function sanitizeInput(input: string, maxLength: number = 1000): string {\n  if (!input || typeof input !== 'string') {\n    return '';\n  }\n  \n  // Remove potentially dangerous characters and limit length\n  return input\n    .replace(CONTROL_CHARS_REGEX, '') // Remove control characters\n    .replace(HTML_DANGEROUS_REGEX, '') // Remove HTML-dangerous characters\n    .replace(SHELL_METACHAR_REGEX, '') // Remove shell metacharacters (expanded)\n    .replace(RTL_ZEROWIDTH_REGEX, '') // Remove RTL override and zero-width chars\n    .substring(0, maxLength)\n    .trim();\n}"]}

package/dist/test/src/security/audit/SecurityAuditor.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Security Auditor - Core orchestrator for security scanning
+ * Implements automated security auditing for DollhouseMCP (Issue #53)
+ */
+import type { SecurityAuditConfig, ScanResult } from './types.js';
+export declare class SecurityAuditor {
+    private config;
+    private scanners;
+    private suppressions;
+    constructor(config: SecurityAuditConfig);
+    /**
+     * Initialize enabled scanners based on configuration
+     */
+    private initializeScanners;
+    /**
+     * Load suppression rules from configuration
+     */
+    private loadSuppressions;
+    /**
+     * Run security audit on the project
+     */
+    audit(projectRoot?: string): Promise<ScanResult>;
+    /**
+     * Filter out suppressed findings
+     */
+    private filterSuppressions;
+    /**
+     * Create scan result summary
+     */
+    private createScanResult;
+    /**
+     * Generate reports in configured formats
+     */
+    private generateReports;
+    /**
+     * Determine if the build should fail based on findings
+     */
+    private shouldFailBuild;
+    /**
+     * Get default configuration
+     */
+    static getDefaultConfig(): SecurityAuditConfig;
+}
+//# sourceMappingURL=SecurityAuditor.d.ts.map

package/dist/test/src/security/audit/SecurityAuditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityAuditor.d.ts","sourceRoot":"","sources":["../../../../../src/security/audit/SecurityAuditor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,mBAAmB,EAEnB,UAAU,EAIX,MAAM,YAAY,CAAC;AAWpB,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,QAAQ,CAAyB;IACzC,OAAO,CAAC,YAAY,CAAuC;gBAE/C,MAAM,EAAE,mBAAmB;IAMvC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACG,KAAK,CAAC,WAAW,GAAE,MAAsB,GAAG,OAAO,CAAC,UAAU,CAAC;IA6CrE;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAkE1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsCxB;;OAEG;YACW,eAAe;IA6B7B;;OAEG;IACH,OAAO,CAAC,eAAe;IAoBvB;;OAEG;IACH,MAAM,CAAC,gBAAgB,IAAI,mBAAmB;CAmC/C"}