@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.
320 lines • 39.8 kB
JavaScript
/**
* Pattern Encryption Service for Memory Security
*
* Part of Issue #1321 Phase 2: Memory Security Architecture
*
* PURPOSE:
* Encrypts dangerous patterns extracted from FLAGGED memories using AES-256-GCM.
* Ensures patterns are never stored in plain text while remaining accessible
* for authorized security research outside LLM contexts.
*
* ARCHITECTURE:
* - Uses AES-256-GCM for authenticated encryption
* - Derives keys from DOLLHOUSE_ENCRYPTION_SECRET via PBKDF2
* - Generates unique IV for each encryption operation
* - Provides GCM authentication tags for integrity verification
*
* SECURITY:
* - Patterns encrypted at rest
* - Decryption only outside LLM context
* - All decryption attempts logged
* - Key rotation supported
*
* REFACTOR NOTE:
* Converted from static class to instance-based for DI architecture compatibility.
*
* @module PatternEncryptor
*/
import { randomBytes, createCipheriv, createDecipheriv, pbkdf2 } from 'node:crypto';
import { logger } from '../../utils/logger.js';
import { env } from '../../config/env.js';
/**
* Default encryption configuration
*/
const DEFAULT_CONFIG = {
// Honor DOLLHOUSE_DISABLE_ENCRYPTION environment variable
// If explicitly disabled, respect that setting regardless of NODE_ENV
enabled: env.DOLLHOUSE_DISABLE_ENCRYPTION
? false
: env.NODE_ENV === 'production',
secret: env.DOLLHOUSE_ENCRYPTION_SECRET,
iterations: 100000,
// SECURITY FIX: Configurable salt to prevent rainbow table attacks (#1733)
// Falls back to default with startup warning if not configured
salt: env.DOLLHOUSE_ENCRYPTION_SALT || 'dollhouse-pattern-encryption-v1',
};
/**
* PatternEncryptor service
*
* Handles encryption and decryption of dangerous patterns using AES-256-GCM.
* Provides authenticated encryption with integrity protection via GCM mode.
*
* DI-COMPATIBLE: Instance-based service for dependency injection.
*/
export class PatternEncryptor {
ALGORITHM = 'aes-256-gcm';
KEY_LENGTH = 32; // 256 bits
IV_LENGTH = 16; // 128 bits
AUTH_TAG_LENGTH = 16; // 128 bits
config;
encryptionKey;
isInitialized = false;
/**
* Create a new PatternEncryptor instance
*
* @param config - Optional configuration overrides
*/
constructor(config) {
this.config = { ...DEFAULT_CONFIG, ...config };
}
/**
* Initialize encryption with configuration
*
* @param config - Optional configuration overrides
* @throws Error if encryption secret is not provided when enabled
*/
async initialize(config) {
if (config) {
this.config = { ...this.config, ...config };
}
if (!this.config.enabled) {
const reason = env.DOLLHOUSE_DISABLE_ENCRYPTION
? 'explicitly disabled via DOLLHOUSE_DISABLE_ENCRYPTION environment variable'
: `disabled (NODE_ENV=${env.NODE_ENV})`;
logger.info(`Pattern encryption ${reason}`);
this.isInitialized = true;
return;
}
if (!this.config.secret) {
throw new Error('DOLLHOUSE_ENCRYPTION_SECRET environment variable is required when encryption is enabled');
}
// SEC-05 (#1733): Warn if using the static default salt
if (!env.DOLLHOUSE_ENCRYPTION_SALT) {
logger.warn('⚠️ Pattern encryption using default salt. Set DOLLHOUSE_ENCRYPTION_SALT to a random 32+ character string ' +
'(e.g. `openssl rand -hex 32`) for stronger protection against rainbow table attacks.');
}
logger.info('Initializing pattern encryption', {
algorithm: this.ALGORITHM,
iterations: this.config.iterations,
});
// Derive encryption key from secret
this.encryptionKey = await this.deriveKey(this.config.secret, this.config.salt, this.config.iterations);
this.isInitialized = true;
logger.info('Pattern encryption initialized successfully');
}
/**
* Encrypt a pattern using AES-256-GCM
*
* @param pattern - Plain text pattern to encrypt
* @returns Encrypted pattern with metadata
* @throws Error if encryption not initialized or pattern is empty
*/
encrypt(pattern) {
if (!this.isInitialized) {
throw new Error('PatternEncryptor not initialized. Call initialize() first.');
}
if (!this.config.enabled) {
// Encryption disabled — return mock structure with MOCK: prefix (#1733)
// so it cannot be confused with real ciphertext
logger.debug('Encryption disabled, returning mock structure');
return {
encryptedData: `MOCK:${Buffer.from(pattern).toString('base64')}`,
algorithm: this.ALGORITHM,
iv: '',
authTag: '',
};
}
if (!pattern || pattern.length === 0) {
throw new Error('Cannot encrypt empty pattern');
}
if (!this.encryptionKey) {
throw new Error('Encryption key not available');
}
logger.debug('Encrypting pattern', {
patternLength: pattern.length,
});
try {
// Generate random IV for this encryption
const iv = randomBytes(this.IV_LENGTH);
// Create cipher with AES-256-GCM
const cipher = createCipheriv(this.ALGORITHM, this.encryptionKey, iv);
// Encrypt the pattern
let encrypted = cipher.update(pattern, 'utf8', 'base64');
encrypted += cipher.final('base64');
// Get authentication tag from GCM mode
const authTag = cipher.getAuthTag();
logger.debug('Pattern encrypted successfully', {
ivLength: iv.length,
authTagLength: authTag.length,
encryptedLength: encrypted.length,
});
return {
encryptedData: encrypted,
algorithm: this.ALGORITHM,
iv: iv.toString('base64'),
authTag: authTag.toString('base64'),
};
}
catch (error) {
logger.error('Failed to encrypt pattern', { error });
throw new Error(`Pattern encryption failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
}
}
/**
* Decrypt an encrypted pattern
*
* @param encrypted - Encrypted pattern structure
* @returns Decrypted plain text pattern
* @throws Error if decryption fails or authentication fails
*/
decrypt(encrypted) {
if (!this.isInitialized) {
throw new Error('PatternEncryptor not initialized. Call initialize() first.');
}
if (!this.config.enabled) {
// Encryption disabled — decode mock data, stripping MOCK: prefix (#1733)
logger.debug('Encryption disabled, decoding mock structure');
const data = encrypted.encryptedData.startsWith('MOCK:')
? encrypted.encryptedData.slice(5)
: encrypted.encryptedData;
return Buffer.from(data, 'base64').toString('utf8');
}
if (!this.encryptionKey) {
throw new Error('Encryption key not available');
}
if (!encrypted.encryptedData || !encrypted.iv || !encrypted.authTag) {
throw new Error('Invalid encrypted pattern: missing required fields');
}
logger.debug('Decrypting pattern', {
algorithm: encrypted.algorithm,
});
try {
// Decode base64 components
const iv = Buffer.from(encrypted.iv, 'base64');
const authTag = Buffer.from(encrypted.authTag, 'base64');
// Create decipher with AES-256-GCM
const decipher = createDecipheriv(this.ALGORITHM, this.encryptionKey, iv);
// Set authentication tag for verification
decipher.setAuthTag(authTag);
// Decrypt the pattern
let decrypted = decipher.update(encrypted.encryptedData, 'base64', 'utf8');
decrypted += decipher.final('utf8');
logger.debug('Pattern decrypted successfully', {
decryptedLength: decrypted.length,
});
return decrypted;
}
catch (error) {
logger.error('Failed to decrypt pattern', { error });
// Authentication failure means data was tampered with
// Check for various GCM authentication error messages
if (error instanceof Error) {
const errorMsg = error.message.toLowerCase();
if (errorMsg.includes('auth') ||
errorMsg.includes('decrypt') ||
errorMsg.includes('unsupported state') ||
errorMsg.includes('unable to authenticate')) {
throw new Error('Pattern decryption failed: Authentication tag mismatch (data may be corrupted or tampered)');
}
}
throw new Error(`Pattern decryption failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
}
}
/**
* Derive encryption key from secret using PBKDF2
*
* @param secret - Master secret from environment
* @param salt - Salt for key derivation
* @param iterations - Number of PBKDF2 iterations
* @returns Derived encryption key
*/
async deriveKey(secret, salt, iterations) {
return new Promise((resolve, reject) => {
pbkdf2(secret, salt, iterations, this.KEY_LENGTH, 'sha256', (err, derivedKey) => {
if (err) {
logger.error('Key derivation failed', { error: err });
reject(new Error(`Failed to derive encryption key: ${err.message}`));
}
else {
logger.debug('Encryption key derived successfully', {
keyLength: derivedKey.length,
iterations,
});
resolve(derivedKey);
}
});
});
}
/**
* Check if encryption is enabled
*
* @returns true if encryption is enabled and initialized
*/
isEnabled() {
return this.config.enabled && this.isInitialized;
}
/**
* Get encryption configuration status
*
* @returns Configuration status (without exposing secrets)
*/
getStatus() {
return {
enabled: this.config.enabled,
initialized: this.isInitialized,
algorithm: this.ALGORITHM,
keyLength: this.KEY_LENGTH,
iterations: this.config.iterations,
hasSecret: !!this.config.secret,
};
}
/**
* Securely clear encryption key from memory
* SECURITY FIX: Overwrites key buffer with zeros before releasing
*
* This prevents key recovery from memory dumps or process inspection.
* Should be called when encryption is no longer needed.
*/
secureKeyClear() {
if (this.encryptionKey) {
// Overwrite key material with zeros
this.encryptionKey.fill(0);
this.encryptionKey = undefined;
logger.debug('Encryption key securely cleared from memory');
}
}
/**
* Reset the encryptor (useful for testing)
* SECURITY FIX: Now performs secure key clearing
* WARNING: This will securely clear the encryption key from memory
*/
reset() {
this.secureKeyClear();
this.isInitialized = false;
this.config = { ...DEFAULT_CONFIG };
logger.debug('PatternEncryptor reset');
}
/**
* Securely reset the encryptor and clear all sensitive data
* SECURITY: Explicitly clears encryption keys from memory
*
* Use this when:
* - Shutting down the application
* - Rotating encryption keys
* - Responding to security incidents
*/
secureReset() {
this.secureKeyClear();
this.isInitialized = false;
this.config = { ...DEFAULT_CONFIG };
logger.info('PatternEncryptor securely reset - all sensitive data cleared');
}
/**
* Dispose of the encryptor and securely clear all data
* Implements cleanup for proper DI lifecycle management
*/
async dispose() {
this.secureReset();
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PatternEncryptor.js","sourceRoot":"","sources":["../../../src/security/encryption/PatternEncryptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pattern Encryption Service for Memory Security\n *\n * Part of Issue #1321 Phase 2: Memory Security Architecture\n *\n * PURPOSE:\n * Encrypts dangerous patterns extracted from FLAGGED memories using AES-256-GCM.\n * Ensures patterns are never stored in plain text while remaining accessible\n * for authorized security research outside LLM contexts.\n *\n * ARCHITECTURE:\n * - Uses AES-256-GCM for authenticated encryption\n * - Derives keys from DOLLHOUSE_ENCRYPTION_SECRET via PBKDF2\n * - Generates unique IV for each encryption operation\n * - Provides GCM authentication tags for integrity verification\n *\n * SECURITY:\n * - Patterns encrypted at rest\n * - Decryption only outside LLM context\n * - All decryption attempts logged\n * - Key rotation supported\n *\n * REFACTOR NOTE:\n * Converted from static class to instance-based for DI architecture compatibility.\n *\n * @module PatternEncryptor\n */\n\nimport { randomBytes, createCipheriv, createDecipheriv, pbkdf2 } from 'node:crypto';\nimport { logger } from '../../utils/logger.js';\nimport { env } from '../../config/env.js';\n\n/**\n * Encrypted pattern structure\n * Contains ciphertext, algorithm metadata, and authentication data\n */\nexport interface EncryptedPattern {\n  /** Base64-encoded encrypted data */\n  encryptedData: string;\n\n  /** Encryption algorithm (always 'aes-256-gcm') */\n  algorithm: 'aes-256-gcm';\n\n  /** Base64-encoded initialization vector */\n  iv: string;\n\n  /** Base64-encoded GCM authentication tag for integrity */\n  authTag: string;\n}\n\n/**\n * Configuration for pattern encryption\n */\nexport interface EncryptionConfig {\n  /** Enable encryption (default: true in production) */\n  enabled: boolean;\n\n  /** Encryption secret (from environment) */\n  secret?: string;\n\n  /** PBKDF2 iterations (default: 100000) */\n  iterations: number;\n\n  /** Salt for key derivation (default: 'dollhouse-pattern-encryption-v1') */\n  salt: string;\n}\n\n/**\n * Default encryption configuration\n */\nconst DEFAULT_CONFIG: EncryptionConfig = {\n  // Honor DOLLHOUSE_DISABLE_ENCRYPTION environment variable\n  // If explicitly disabled, respect that setting regardless of NODE_ENV\n  enabled: env.DOLLHOUSE_DISABLE_ENCRYPTION\n    ? false\n    : env.NODE_ENV === 'production',\n  secret: env.DOLLHOUSE_ENCRYPTION_SECRET,\n  iterations: 100000,\n  // SECURITY FIX: Configurable salt to prevent rainbow table attacks (#1733)\n  // Falls back to default with startup warning if not configured\n  salt: env.DOLLHOUSE_ENCRYPTION_SALT || 'dollhouse-pattern-encryption-v1',\n};\n\n/**\n * PatternEncryptor service\n *\n * Handles encryption and decryption of dangerous patterns using AES-256-GCM.\n * Provides authenticated encryption with integrity protection via GCM mode.\n *\n * DI-COMPATIBLE: Instance-based service for dependency injection.\n */\nexport class PatternEncryptor {\n  private readonly ALGORITHM = 'aes-256-gcm';\n  private readonly KEY_LENGTH = 32; // 256 bits\n  private readonly IV_LENGTH = 16; // 128 bits\n  private readonly AUTH_TAG_LENGTH = 16; // 128 bits\n\n  private config: EncryptionConfig;\n  private encryptionKey?: Buffer;\n  private isInitialized: boolean = false;\n\n  /**\n   * Create a new PatternEncryptor instance\n   *\n   * @param config - Optional configuration overrides\n   */\n  constructor(config?: Partial<EncryptionConfig>) {\n    this.config = { ...DEFAULT_CONFIG, ...config };\n  }\n\n  /**\n   * Initialize encryption with configuration\n   *\n   * @param config - Optional configuration overrides\n   * @throws Error if encryption secret is not provided when enabled\n   */\n  async initialize(config?: Partial<EncryptionConfig>): Promise<void> {\n    if (config) {\n      this.config = { ...this.config, ...config };\n    }\n\n    if (!this.config.enabled) {\n      const reason = env.DOLLHOUSE_DISABLE_ENCRYPTION\n        ? 'explicitly disabled via DOLLHOUSE_DISABLE_ENCRYPTION environment variable'\n        : `disabled (NODE_ENV=${env.NODE_ENV})`;\n      logger.info(`Pattern encryption ${reason}`);\n      this.isInitialized = true;\n      return;\n    }\n\n    if (!this.config.secret) {\n      throw new Error(\n        'DOLLHOUSE_ENCRYPTION_SECRET environment variable is required when encryption is enabled'\n      );\n    }\n\n    // SEC-05 (#1733): Warn if using the static default salt\n    if (!env.DOLLHOUSE_ENCRYPTION_SALT) {\n      logger.warn(\n        '⚠️  Pattern encryption using default salt. Set DOLLHOUSE_ENCRYPTION_SALT to a random 32+ character string ' +\n        '(e.g. `openssl rand -hex 32`) for stronger protection against rainbow table attacks.'\n      );\n    }\n\n    logger.info('Initializing pattern encryption', {\n      algorithm: this.ALGORITHM,\n      iterations: this.config.iterations,\n    });\n\n    // Derive encryption key from secret\n    this.encryptionKey = await this.deriveKey(\n      this.config.secret,\n      this.config.salt,\n      this.config.iterations\n    );\n\n    this.isInitialized = true;\n    logger.info('Pattern encryption initialized successfully');\n  }\n\n  /**\n   * Encrypt a pattern using AES-256-GCM\n   *\n   * @param pattern - Plain text pattern to encrypt\n   * @returns Encrypted pattern with metadata\n   * @throws Error if encryption not initialized or pattern is empty\n   */\n  encrypt(pattern: string): EncryptedPattern {\n    if (!this.isInitialized) {\n      throw new Error('PatternEncryptor not initialized. Call initialize() first.');\n    }\n\n    if (!this.config.enabled) {\n      // Encryption disabled — return mock structure with MOCK: prefix (#1733)\n      // so it cannot be confused with real ciphertext\n      logger.debug('Encryption disabled, returning mock structure');\n      return {\n        encryptedData: `MOCK:${Buffer.from(pattern).toString('base64')}`,\n        algorithm: this.ALGORITHM,\n        iv: '',\n        authTag: '',\n      };\n    }\n\n    if (!pattern || pattern.length === 0) {\n      throw new Error('Cannot encrypt empty pattern');\n    }\n\n    if (!this.encryptionKey) {\n      throw new Error('Encryption key not available');\n    }\n\n    logger.debug('Encrypting pattern', {\n      patternLength: pattern.length,\n    });\n\n    try {\n      // Generate random IV for this encryption\n      const iv = randomBytes(this.IV_LENGTH);\n\n      // Create cipher with AES-256-GCM\n      const cipher = createCipheriv(this.ALGORITHM, this.encryptionKey, iv);\n\n      // Encrypt the pattern\n      let encrypted = cipher.update(pattern, 'utf8', 'base64');\n      encrypted += cipher.final('base64');\n\n      // Get authentication tag from GCM mode\n      const authTag = cipher.getAuthTag();\n\n      logger.debug('Pattern encrypted successfully', {\n        ivLength: iv.length,\n        authTagLength: authTag.length,\n        encryptedLength: encrypted.length,\n      });\n\n      return {\n        encryptedData: encrypted,\n        algorithm: this.ALGORITHM,\n        iv: iv.toString('base64'),\n        authTag: authTag.toString('base64'),\n      };\n    } catch (error) {\n      logger.error('Failed to encrypt pattern', { error });\n      throw new Error(`Pattern encryption failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n    }\n  }\n\n  /**\n   * Decrypt an encrypted pattern\n   *\n   * @param encrypted - Encrypted pattern structure\n   * @returns Decrypted plain text pattern\n   * @throws Error if decryption fails or authentication fails\n   */\n  decrypt(encrypted: EncryptedPattern): string {\n    if (!this.isInitialized) {\n      throw new Error('PatternEncryptor not initialized. Call initialize() first.');\n    }\n\n    if (!this.config.enabled) {\n      // Encryption disabled — decode mock data, stripping MOCK: prefix (#1733)\n      logger.debug('Encryption disabled, decoding mock structure');\n      const data = encrypted.encryptedData.startsWith('MOCK:')\n        ? encrypted.encryptedData.slice(5)\n        : encrypted.encryptedData;\n      return Buffer.from(data, 'base64').toString('utf8');\n    }\n\n    if (!this.encryptionKey) {\n      throw new Error('Encryption key not available');\n    }\n\n    if (!encrypted.encryptedData || !encrypted.iv || !encrypted.authTag) {\n      throw new Error('Invalid encrypted pattern: missing required fields');\n    }\n\n    logger.debug('Decrypting pattern', {\n      algorithm: encrypted.algorithm,\n    });\n\n    try {\n      // Decode base64 components\n      const iv = Buffer.from(encrypted.iv, 'base64');\n      const authTag = Buffer.from(encrypted.authTag, 'base64');\n\n      // Create decipher with AES-256-GCM\n      const decipher = createDecipheriv(this.ALGORITHM, this.encryptionKey, iv);\n\n      // Set authentication tag for verification\n      decipher.setAuthTag(authTag);\n\n      // Decrypt the pattern\n      let decrypted = decipher.update(encrypted.encryptedData, 'base64', 'utf8');\n      decrypted += decipher.final('utf8');\n\n      logger.debug('Pattern decrypted successfully', {\n        decryptedLength: decrypted.length,\n      });\n\n      return decrypted;\n    } catch (error) {\n      logger.error('Failed to decrypt pattern', { error });\n\n      // Authentication failure means data was tampered with\n      // Check for various GCM authentication error messages\n      if (error instanceof Error) {\n        const errorMsg = error.message.toLowerCase();\n        if (\n          errorMsg.includes('auth') ||\n          errorMsg.includes('decrypt') ||\n          errorMsg.includes('unsupported state') ||\n          errorMsg.includes('unable to authenticate')\n        ) {\n          throw new Error('Pattern decryption failed: Authentication tag mismatch (data may be corrupted or tampered)');\n        }\n      }\n\n      throw new Error(`Pattern decryption failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n    }\n  }\n\n  /**\n   * Derive encryption key from secret using PBKDF2\n   *\n   * @param secret - Master secret from environment\n   * @param salt - Salt for key derivation\n   * @param iterations - Number of PBKDF2 iterations\n   * @returns Derived encryption key\n   */\n  private async deriveKey(\n    secret: string,\n    salt: string,\n    iterations: number\n  ): Promise<Buffer> {\n    return new Promise((resolve, reject) => {\n      pbkdf2(\n        secret,\n        salt,\n        iterations,\n        this.KEY_LENGTH,\n        'sha256',\n        (err, derivedKey) => {\n          if (err) {\n            logger.error('Key derivation failed', { error: err });\n            reject(new Error(`Failed to derive encryption key: ${err.message}`));\n          } else {\n            logger.debug('Encryption key derived successfully', {\n              keyLength: derivedKey.length,\n              iterations,\n            });\n            resolve(derivedKey);\n          }\n        }\n      );\n    });\n  }\n\n  /**\n   * Check if encryption is enabled\n   *\n   * @returns true if encryption is enabled and initialized\n   */\n  isEnabled(): boolean {\n    return this.config.enabled && this.isInitialized;\n  }\n\n  /**\n   * Get encryption configuration status\n   *\n   * @returns Configuration status (without exposing secrets)\n   */\n  getStatus() {\n    return {\n      enabled: this.config.enabled,\n      initialized: this.isInitialized,\n      algorithm: this.ALGORITHM,\n      keyLength: this.KEY_LENGTH,\n      iterations: this.config.iterations,\n      hasSecret: !!this.config.secret,\n    };\n  }\n\n  /**\n   * Securely clear encryption key from memory\n   * SECURITY FIX: Overwrites key buffer with zeros before releasing\n   *\n   * This prevents key recovery from memory dumps or process inspection.\n   * Should be called when encryption is no longer needed.\n   */\n  private secureKeyClear(): void {\n    if (this.encryptionKey) {\n      // Overwrite key material with zeros\n      this.encryptionKey.fill(0);\n      this.encryptionKey = undefined;\n      logger.debug('Encryption key securely cleared from memory');\n    }\n  }\n\n  /**\n   * Reset the encryptor (useful for testing)\n   * SECURITY FIX: Now performs secure key clearing\n   * WARNING: This will securely clear the encryption key from memory\n   */\n  reset(): void {\n    this.secureKeyClear();\n    this.isInitialized = false;\n    this.config = { ...DEFAULT_CONFIG };\n    logger.debug('PatternEncryptor reset');\n  }\n\n  /**\n   * Securely reset the encryptor and clear all sensitive data\n   * SECURITY: Explicitly clears encryption keys from memory\n   *\n   * Use this when:\n   * - Shutting down the application\n   * - Rotating encryption keys\n   * - Responding to security incidents\n   */\n  secureReset(): void {\n    this.secureKeyClear();\n    this.isInitialized = false;\n    this.config = { ...DEFAULT_CONFIG };\n    logger.info('PatternEncryptor securely reset - all sensitive data cleared');\n  }\n\n  /**\n   * Dispose of the encryptor and securely clear all data\n   * Implements cleanup for proper DI lifecycle management\n   */\n  async dispose(): Promise<void> {\n    this.secureReset();\n  }\n}\n"]}