@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.
292 lines • 43.4 kB
JavaScript
import path from 'node:path';
import fs from 'node:fs/promises';
import { logger } from '../utils/logger.js';
import { RegexValidator } from './regexValidator.js';
import { SECURITY_LIMITS } from './constants.js';
export class PathValidator {
static ALLOWED_DIRECTORIES = [];
static ALLOWED_EXTENSIONS = ['.md', '.markdown', '.txt', '.yml', '.yaml'];
static resolvedAllowedDirs = null;
static initialize(personasDir, allowedExtensions) {
this.ALLOWED_DIRECTORIES = [
path.resolve(personasDir),
path.resolve('./personas'),
path.resolve('./custom-personas'),
path.resolve('./backups'),
path.resolve(process.env.PERSONAS_DIR || './personas')
];
if (allowedExtensions) {
this.ALLOWED_EXTENSIONS = allowedExtensions;
}
// Clear cached resolved directories when reinitializing
this.resolvedAllowedDirs = null;
}
/**
* Get allowed directories with symlinks resolved
* Caches the result to avoid repeated filesystem calls
*/
static async getResolvedAllowedDirectories() {
if (this.resolvedAllowedDirs) {
return this.resolvedAllowedDirs;
}
this.resolvedAllowedDirs = (async () => {
const allowedDirs = this.ALLOWED_DIRECTORIES.length === 0
? [path.resolve('./personas'), path.resolve(process.env.PERSONAS_DIR || './personas')]
: this.ALLOWED_DIRECTORIES;
// Resolve symlinks for each allowed directory
const resolved = await Promise.all(allowedDirs.map(async (dir) => {
try {
return await fs.realpath(dir);
}
catch {
// If directory doesn't exist yet, use the original path
return dir;
}
}));
return resolved;
})();
return this.resolvedAllowedDirs;
}
/**
* SECURITY FIX #1290: Resolve symlinks to prevent path traversal
* Helper function to resolve symlinks in paths
*/
static async resolveSymlinks(resolvedPath, userPath) {
try {
// Try to resolve symlinks in the full path
const realPath = await fs.realpath(resolvedPath);
// Log symlink resolution for security auditing
if (realPath !== resolvedPath) {
logger.warn('Symlink detected and resolved', {
requestedPath: userPath,
resolvedPath,
realPath
});
}
return realPath;
}
catch (err) {
// If path doesn't exist (e.g., creating new file), resolve parent directory
if (err.code === 'ENOENT') {
return this.resolveParentSymlink(resolvedPath, userPath);
}
throw err;
}
}
/**
* Helper to resolve symlinks in parent directory when target doesn't exist
*/
static async resolveParentSymlink(resolvedPath, userPath) {
const parentDir = path.dirname(resolvedPath);
try {
const realParent = await fs.realpath(parentDir);
// Log parent symlink resolution for security auditing
if (realParent !== parentDir) {
logger.warn('Parent directory symlink detected and resolved', {
requestedPath: userPath,
parentDir,
realParent
});
}
// Reconstruct path with resolved parent and original filename
return path.join(realParent, path.basename(resolvedPath));
}
catch {
// Parent directory doesn't exist - use resolved path
// (will fail later in file operations, but not a security issue)
return resolvedPath;
}
}
/**
* Validate that the real path is within allowed directories
* FIX: Now resolves symlinks in allowed directories to handle macOS /tmp -> /private/tmp
*/
static async validatePathIsAllowed(realPath, userPath) {
const allowedDirs = await this.getResolvedAllowedDirectories();
const isAllowed = allowedDirs.some(allowedDir => realPath.startsWith(allowedDir + path.sep) || realPath === allowedDir);
if (!isAllowed) {
// SECURITY FIX #206: Don't expose user paths in error messages
logger.error('Path access denied', { path: userPath, realPath, allowedDirs });
throw new Error('Path access denied');
}
}
/**
* Validate filename extension and format
*/
static validateFilename(realPath) {
if (!path.extname(realPath)) {
return; // Not a file, skip validation
}
const filename = path.basename(realPath);
const ext = path.extname(filename).toLowerCase();
// Check if extension is allowed
if (!this.ALLOWED_EXTENSIONS.includes(ext)) {
throw new Error(`File extension not allowed: ${ext}. Allowed: ${this.ALLOWED_EXTENSIONS.join(', ')}`);
}
// Validate filename format (alphanumeric, dash, underscore, dot)
if (!RegexValidator.validate(filename, /^[a-zA-Z0-9_.-]+$/, { maxLength: SECURITY_LIMITS.MAX_FILENAME_LENGTH })) {
throw new Error(`Invalid filename format: ${filename}`);
}
}
/**
* Validate element path WITHOUT resolving symlinks
* Used by BaseElementManager to validate paths while preserving the original path representation
*
* SECURITY: Rejects symlinks that point outside the allowed directory
*
* @param absolutePath - Absolute path to validate
* @param allowedDir - Base directory that the path must be within
* @throws Error if path is invalid, is a symlink pointing outside allowed directory, or outside allowed directory
*/
static async validateElementPathOnly(absolutePath, allowedDir) {
if (!absolutePath || typeof absolutePath !== 'string') {
throw new Error('Path must be a non-empty string');
}
if (!allowedDir || typeof allowedDir !== 'string') {
throw new Error('allowedDir must be a non-empty string');
}
// Remove any null bytes
// eslint-disable-next-line no-control-regex -- Intentionally removing null bytes for security
const cleanPath = absolutePath.replaceAll(/\u0000/g, ''); // NOSONAR - Removing null bytes for security
// Check for path traversal attempts in the normalized path
const normalizedPath = path.normalize(cleanPath);
if (normalizedPath.includes('..') || cleanPath.includes('..')) {
logger.warn('Path traversal attempt detected', { userPath: absolutePath });
throw new Error('Path traversal detected');
}
// Validate path is within allowed directory (without resolving symlinks)
const normalizedAllowedDir = path.normalize(allowedDir);
const pathWithSep = normalizedPath + path.sep;
const allowedDirWithSep = normalizedAllowedDir + path.sep;
if (!pathWithSep.startsWith(allowedDirWithSep) && normalizedPath !== normalizedAllowedDir) {
logger.error('Path access denied', { path: absolutePath, allowedDir: normalizedAllowedDir });
throw new Error('Path access denied');
}
// SECURITY FIX: Check if path is a symlink and if so, ensure it points within allowed directory
try {
const stats = await fs.lstat(normalizedPath); // lstat doesn't follow symlinks
if (stats.isSymbolicLink()) {
// Resolve the symlink target to check if it's within allowed directory
const realPath = await fs.realpath(normalizedPath);
const realPathWithSep = realPath + path.sep;
if (!realPathWithSep.startsWith(allowedDirWithSep) && realPath !== normalizedAllowedDir) {
logger.error('Symlink target outside allowed directory', {
path: absolutePath,
realPath,
allowedDir: normalizedAllowedDir
});
throw new Error('Path access denied');
}
}
}
catch (err) {
// If file doesn't exist, that's okay (might be creating a new file)
// Re-throw if it's NOT an ENOENT error
if (err.code !== 'ENOENT') {
throw err;
}
}
// Validate filename extension and format
this.validateFilename(normalizedPath);
}
/**
* Stateless element path validation (generic for all element types)
* Used by BaseElementManager for validating paths across all element types.
*
* @param userPath - User-provided path to validate
* @param allowedDir - Base directory that the path must be within
* @returns Validated absolute path with symlinks resolved
* @deprecated Use validateElementPathOnly() for path validation without resolution
*/
static async validateElementPath(userPath, allowedDir) {
if (!userPath || typeof userPath !== 'string') {
throw new Error('Path must be a non-empty string');
}
if (!allowedDir || typeof allowedDir !== 'string') {
throw new Error('allowedDir must be a non-empty string');
}
// Remove any null bytes
// eslint-disable-next-line no-control-regex -- Intentionally removing null bytes for security
const cleanPath = userPath.replaceAll(/\u0000/g, ''); // NOSONAR - Removing null bytes for security
// Normalize and resolve path
const normalizedPath = path.normalize(cleanPath);
const resolvedPath = path.resolve(normalizedPath);
// Check for path traversal attempts
if (normalizedPath.includes('..') || cleanPath.includes('..')) {
logger.warn('Path traversal attempt detected', { userPath });
throw new Error('Path traversal detected');
}
// Resolve symlinks to get real path
const realPath = await this.resolveSymlinks(resolvedPath, userPath);
// Validate path is within allowed directory
const resolvedAllowedDir = await fs.realpath(allowedDir).catch(() => allowedDir);
if (!realPath.startsWith(resolvedAllowedDir + path.sep) && realPath !== resolvedAllowedDir) {
logger.error('Path access denied', { path: userPath, realPath, allowedDir: resolvedAllowedDir });
throw new Error('Path access denied');
}
// Validate filename extension and format
this.validateFilename(realPath);
// Return the real path (with symlinks resolved) for safe file operations
return realPath;
}
/**
* @deprecated Use validateElementPath() instead. This method uses class-level state.
* Validate a persona path against pre-initialized allowed directories.
*
* @param userPath - User-provided path to validate
* @returns Validated absolute path with symlinks resolved
*/
static async validatePersonaPath(userPath) {
if (!userPath || typeof userPath !== 'string') {
throw new Error('Path must be a non-empty string');
}
// Remove any null bytes
// eslint-disable-next-line no-control-regex -- Intentionally removing null bytes for security
const cleanPath = userPath.replaceAll(/\u0000/g, ''); // NOSONAR - Removing null bytes for security
// Normalize and resolve path
const normalizedPath = path.normalize(cleanPath);
const resolvedPath = path.resolve(normalizedPath);
// Check for path traversal attempts
if (normalizedPath.includes('..') || cleanPath.includes('..')) {
logger.warn('Path traversal attempt detected', { userPath });
throw new Error('Path traversal detected');
}
// Resolve symlinks to get real path
const realPath = await this.resolveSymlinks(resolvedPath, userPath);
// Validate path is within allowed directories (now async to resolve symlinks in allowed dirs)
await this.validatePathIsAllowed(realPath, userPath);
// Validate filename extension and format
this.validateFilename(realPath);
// Return the real path (with symlinks resolved) for safe file operations
return realPath;
}
static async safeReadFile(filePath) {
const validatedPath = await this.validatePersonaPath(filePath);
// Check file exists and is not a directory
const stats = await fs.stat(validatedPath);
if (stats.isDirectory()) {
throw new Error('Path is a directory, not a file');
}
// Size check
if (stats.size > 500000) { // 500KB
throw new Error('File too large');
}
return fs.readFile(validatedPath, 'utf-8');
}
static async safeWriteFile(filePath, content) {
const validatedPath = await this.validatePersonaPath(filePath);
// Content validation
if (content.length > 500000) {
throw new Error('Content too large');
}
// Ensure directory exists before atomic write
const dirPath = path.dirname(validatedPath);
await fs.mkdir(dirPath, { recursive: true });
// Write to temp file first (atomic write)
const tempPath = `${validatedPath}.tmp`;
await fs.writeFile(tempPath, content, 'utf-8');
// Rename to final path (atomic on most filesystems)
await fs.rename(tempPath, validatedPath);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pathValidator.js","sourceRoot":"","sources":["../../src/security/pathValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport fs from 'node:fs/promises';\nimport { logger } from '../utils/logger.js';\nimport { RegexValidator } from './regexValidator.js';\nimport { SECURITY_LIMITS } from './constants.js';\n\nexport class PathValidator {\n  private static ALLOWED_DIRECTORIES: string[] = [];\n  private static ALLOWED_EXTENSIONS: string[] = ['.md', '.markdown', '.txt', '.yml', '.yaml'];\n  private static resolvedAllowedDirs: Promise<string[]> | null = null;\n\n  static initialize(personasDir: string, allowedExtensions?: string[]): void {\n    this.ALLOWED_DIRECTORIES = [\n      path.resolve(personasDir),\n      path.resolve('./personas'),\n      path.resolve('./custom-personas'),\n      path.resolve('./backups'),\n      path.resolve(process.env.PERSONAS_DIR || './personas')\n    ];\n\n    if (allowedExtensions) {\n      this.ALLOWED_EXTENSIONS = allowedExtensions;\n    }\n\n    // Clear cached resolved directories when reinitializing\n    this.resolvedAllowedDirs = null;\n  }\n\n  /**\n   * Get allowed directories with symlinks resolved\n   * Caches the result to avoid repeated filesystem calls\n   */\n  private static async getResolvedAllowedDirectories(): Promise<string[]> {\n    if (this.resolvedAllowedDirs) {\n      return this.resolvedAllowedDirs;\n    }\n\n    this.resolvedAllowedDirs = (async () => {\n      const allowedDirs = this.ALLOWED_DIRECTORIES.length === 0\n        ? [path.resolve('./personas'), path.resolve(process.env.PERSONAS_DIR || './personas')]\n        : this.ALLOWED_DIRECTORIES;\n\n      // Resolve symlinks for each allowed directory\n      const resolved = await Promise.all(\n        allowedDirs.map(async (dir) => {\n          try {\n            return await fs.realpath(dir);\n          } catch {\n            // If directory doesn't exist yet, use the original path\n            return dir;\n          }\n        })\n      );\n\n      return resolved;\n    })();\n\n    return this.resolvedAllowedDirs;\n  }\n\n  /**\n   * SECURITY FIX #1290: Resolve symlinks to prevent path traversal\n   * Helper function to resolve symlinks in paths\n   */\n  private static async resolveSymlinks(resolvedPath: string, userPath: string): Promise<string> {\n    try {\n      // Try to resolve symlinks in the full path\n      const realPath = await fs.realpath(resolvedPath);\n\n      // Log symlink resolution for security auditing\n      if (realPath !== resolvedPath) {\n        logger.warn('Symlink detected and resolved', {\n          requestedPath: userPath,\n          resolvedPath,\n          realPath\n        });\n      }\n      return realPath;\n    } catch (err) {\n      // If path doesn't exist (e.g., creating new file), resolve parent directory\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        return this.resolveParentSymlink(resolvedPath, userPath);\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Helper to resolve symlinks in parent directory when target doesn't exist\n   */\n  private static async resolveParentSymlink(resolvedPath: string, userPath: string): Promise<string> {\n    const parentDir = path.dirname(resolvedPath);\n    try {\n      const realParent = await fs.realpath(parentDir);\n\n      // Log parent symlink resolution for security auditing\n      if (realParent !== parentDir) {\n        logger.warn('Parent directory symlink detected and resolved', {\n          requestedPath: userPath,\n          parentDir,\n          realParent\n        });\n      }\n\n      // Reconstruct path with resolved parent and original filename\n      return path.join(realParent, path.basename(resolvedPath));\n    } catch {\n      // Parent directory doesn't exist - use resolved path\n      // (will fail later in file operations, but not a security issue)\n      return resolvedPath;\n    }\n  }\n\n  /**\n   * Validate that the real path is within allowed directories\n   * FIX: Now resolves symlinks in allowed directories to handle macOS /tmp -> /private/tmp\n   */\n  private static async validatePathIsAllowed(realPath: string, userPath: string): Promise<void> {\n    const allowedDirs = await this.getResolvedAllowedDirectories();\n\n    const isAllowed = allowedDirs.some(allowedDir =>\n      realPath.startsWith(allowedDir + path.sep) || realPath === allowedDir\n    );\n\n    if (!isAllowed) {\n      // SECURITY FIX #206: Don't expose user paths in error messages\n      logger.error('Path access denied', { path: userPath, realPath, allowedDirs });\n      throw new Error('Path access denied');\n    }\n  }\n\n  /**\n   * Validate filename extension and format\n   */\n  private static validateFilename(realPath: string): void {\n    if (!path.extname(realPath)) {\n      return; // Not a file, skip validation\n    }\n\n    const filename = path.basename(realPath);\n    const ext = path.extname(filename).toLowerCase();\n\n    // Check if extension is allowed\n    if (!this.ALLOWED_EXTENSIONS.includes(ext)) {\n      throw new Error(`File extension not allowed: ${ext}. Allowed: ${this.ALLOWED_EXTENSIONS.join(', ')}`);\n    }\n\n    // Validate filename format (alphanumeric, dash, underscore, dot)\n    if (!RegexValidator.validate(filename, /^[a-zA-Z0-9_.-]+$/, { maxLength: SECURITY_LIMITS.MAX_FILENAME_LENGTH })) {\n      throw new Error(`Invalid filename format: ${filename}`);\n    }\n  }\n\n  /**\n   * Validate element path WITHOUT resolving symlinks\n   * Used by BaseElementManager to validate paths while preserving the original path representation\n   *\n   * SECURITY: Rejects symlinks that point outside the allowed directory\n   *\n   * @param absolutePath - Absolute path to validate\n   * @param allowedDir - Base directory that the path must be within\n   * @throws Error if path is invalid, is a symlink pointing outside allowed directory, or outside allowed directory\n   */\n  static async validateElementPathOnly(absolutePath: string, allowedDir: string): Promise<void> {\n    if (!absolutePath || typeof absolutePath !== 'string') {\n      throw new Error('Path must be a non-empty string');\n    }\n\n    if (!allowedDir || typeof allowedDir !== 'string') {\n      throw new Error('allowedDir must be a non-empty string');\n    }\n\n    // Remove any null bytes\n    // eslint-disable-next-line no-control-regex -- Intentionally removing null bytes for security\n    const cleanPath = absolutePath.replaceAll(/\\u0000/g, ''); // NOSONAR - Removing null bytes for security\n\n    // Check for path traversal attempts in the normalized path\n    const normalizedPath = path.normalize(cleanPath);\n    if (normalizedPath.includes('..') || cleanPath.includes('..')) {\n      logger.warn('Path traversal attempt detected', { userPath: absolutePath });\n      throw new Error('Path traversal detected');\n    }\n\n    // Validate path is within allowed directory (without resolving symlinks)\n    const normalizedAllowedDir = path.normalize(allowedDir);\n    const pathWithSep = normalizedPath + path.sep;\n    const allowedDirWithSep = normalizedAllowedDir + path.sep;\n\n    if (!pathWithSep.startsWith(allowedDirWithSep) && normalizedPath !== normalizedAllowedDir) {\n      logger.error('Path access denied', { path: absolutePath, allowedDir: normalizedAllowedDir });\n      throw new Error('Path access denied');\n    }\n\n    // SECURITY FIX: Check if path is a symlink and if so, ensure it points within allowed directory\n    try {\n      const stats = await fs.lstat(normalizedPath); // lstat doesn't follow symlinks\n      if (stats.isSymbolicLink()) {\n        // Resolve the symlink target to check if it's within allowed directory\n        const realPath = await fs.realpath(normalizedPath);\n        const realPathWithSep = realPath + path.sep;\n\n        if (!realPathWithSep.startsWith(allowedDirWithSep) && realPath !== normalizedAllowedDir) {\n          logger.error('Symlink target outside allowed directory', {\n            path: absolutePath,\n            realPath,\n            allowedDir: normalizedAllowedDir\n          });\n          throw new Error('Path access denied');\n        }\n      }\n    } catch (err) {\n      // If file doesn't exist, that's okay (might be creating a new file)\n      // Re-throw if it's NOT an ENOENT error\n      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {\n        throw err;\n      }\n    }\n\n    // Validate filename extension and format\n    this.validateFilename(normalizedPath);\n  }\n\n  /**\n   * Stateless element path validation (generic for all element types)\n   * Used by BaseElementManager for validating paths across all element types.\n   *\n   * @param userPath - User-provided path to validate\n   * @param allowedDir - Base directory that the path must be within\n   * @returns Validated absolute path with symlinks resolved\n   * @deprecated Use validateElementPathOnly() for path validation without resolution\n   */\n  static async validateElementPath(userPath: string, allowedDir: string): Promise<string> {\n    if (!userPath || typeof userPath !== 'string') {\n      throw new Error('Path must be a non-empty string');\n    }\n\n    if (!allowedDir || typeof allowedDir !== 'string') {\n      throw new Error('allowedDir must be a non-empty string');\n    }\n\n    // Remove any null bytes\n    // eslint-disable-next-line no-control-regex -- Intentionally removing null bytes for security\n    const cleanPath = userPath.replaceAll(/\\u0000/g, ''); // NOSONAR - Removing null bytes for security\n\n    // Normalize and resolve path\n    const normalizedPath = path.normalize(cleanPath);\n    const resolvedPath = path.resolve(normalizedPath);\n\n    // Check for path traversal attempts\n    if (normalizedPath.includes('..') || cleanPath.includes('..')) {\n      logger.warn('Path traversal attempt detected', { userPath });\n      throw new Error('Path traversal detected');\n    }\n\n    // Resolve symlinks to get real path\n    const realPath = await this.resolveSymlinks(resolvedPath, userPath);\n\n    // Validate path is within allowed directory\n    const resolvedAllowedDir = await fs.realpath(allowedDir).catch(() => allowedDir);\n    if (!realPath.startsWith(resolvedAllowedDir + path.sep) && realPath !== resolvedAllowedDir) {\n      logger.error('Path access denied', { path: userPath, realPath, allowedDir: resolvedAllowedDir });\n      throw new Error('Path access denied');\n    }\n\n    // Validate filename extension and format\n    this.validateFilename(realPath);\n\n    // Return the real path (with symlinks resolved) for safe file operations\n    return realPath;\n  }\n\n  /**\n   * @deprecated Use validateElementPath() instead. This method uses class-level state.\n   * Validate a persona path against pre-initialized allowed directories.\n   *\n   * @param userPath - User-provided path to validate\n   * @returns Validated absolute path with symlinks resolved\n   */\n  static async validatePersonaPath(userPath: string): Promise<string> {\n    if (!userPath || typeof userPath !== 'string') {\n      throw new Error('Path must be a non-empty string');\n    }\n\n    // Remove any null bytes\n    // eslint-disable-next-line no-control-regex -- Intentionally removing null bytes for security\n    const cleanPath = userPath.replaceAll(/\\u0000/g, ''); // NOSONAR - Removing null bytes for security\n\n    // Normalize and resolve path\n    const normalizedPath = path.normalize(cleanPath);\n    const resolvedPath = path.resolve(normalizedPath);\n\n    // Check for path traversal attempts\n    if (normalizedPath.includes('..') || cleanPath.includes('..')) {\n      logger.warn('Path traversal attempt detected', { userPath });\n      throw new Error('Path traversal detected');\n    }\n\n    // Resolve symlinks to get real path\n    const realPath = await this.resolveSymlinks(resolvedPath, userPath);\n\n    // Validate path is within allowed directories (now async to resolve symlinks in allowed dirs)\n    await this.validatePathIsAllowed(realPath, userPath);\n\n    // Validate filename extension and format\n    this.validateFilename(realPath);\n\n    // Return the real path (with symlinks resolved) for safe file operations\n    return realPath;\n  }\n\n  static async safeReadFile(filePath: string): Promise<string> {\n    const validatedPath = await this.validatePersonaPath(filePath);\n    \n    // Check file exists and is not a directory\n    const stats = await fs.stat(validatedPath);\n    if (stats.isDirectory()) {\n      throw new Error('Path is a directory, not a file');\n    }\n    \n    // Size check\n    if (stats.size > 500000) { // 500KB\n      throw new Error('File too large');\n    }\n    \n    return fs.readFile(validatedPath, 'utf-8');\n  }\n\n  static async safeWriteFile(filePath: string, content: string): Promise<void> {\n    const validatedPath = await this.validatePersonaPath(filePath);\n    \n    // Content validation\n    if (content.length > 500000) {\n      throw new Error('Content too large');\n    }\n    \n    // Ensure directory exists before atomic write\n    const dirPath = path.dirname(validatedPath);\n    await fs.mkdir(dirPath, { recursive: true });\n    \n    // Write to temp file first (atomic write)\n    const tempPath = `${validatedPath}.tmp`;\n    await fs.writeFile(tempPath, content, 'utf-8');\n    \n    // Rename to final path (atomic on most filesystems)\n    await fs.rename(tempPath, validatedPath);\n  }\n}\n"]}