@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.
137 lines • 16.4 kB
JavaScript
/**
* Utility functions for Memory element operations
*
* PERFORMANCE CONSIDERATIONS:
* - ID generation should be fast (<1ms)
* - Hash functions optimized for memory verification
* - Index operations designed for O(log n) complexity
*
* SECURITY CONSIDERATIONS:
* - Hash functions normalize Unicode to prevent bypass attempts
* - Content verification detects external modifications
* - Protects against manual editing and tampering
*/
import * as crypto from 'crypto';
import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
import { SecurityMonitor } from '../../security/securityMonitor.js';
import { MEMORY_SECURITY_EVENTS } from './constants.js';
/**
* Generate a unique ID for memory entries
* Format: mem_{timestamp}_{random}
*
* @returns Unique memory entry ID
* @example
* generateMemoryId() // "mem_1699234567890_x7k2n9p4m"
*/
export function generateMemoryId() {
const timestamp = Date.now();
const random = Math.random().toString(36).substr(2, 9);
return `mem_${timestamp}_${random}`;
}
/**
* Generate a content hash for memory integrity verification
* Uses SHA-256 for cryptographic strength with Unicode normalization
*
* SECURITY: Normalizes content to prevent Unicode-based bypass attempts
* where attackers use homographs or invisible characters to create
* content that appears identical but has a different hash
*
* @param content - The content to hash (will be normalized)
* @returns Hex-encoded hash string
*/
export function generateContentHash(content) {
// SECURITY FIX: Normalize Unicode to prevent homograph attacks
// This ensures consistent hashing regardless of Unicode representation
const normalized = UnicodeValidator.normalize(content);
if (!normalized.isValid && normalized.detectedIssues) {
// Log potential security issue but still generate hash
// We want to detect the tampering, not reject it silently
SecurityMonitor.logSecurityEvent({
type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,
severity: 'MEDIUM',
source: 'generateContentHash',
details: `Unicode security issues detected: ${normalized.detectedIssues.join(', ')}`
});
}
return crypto.createHash('sha256')
.update(normalized.normalizedContent)
.digest('hex');
}
/**
* Verify memory content integrity
*
* SECURITY: This function detects:
* - External tool modifications (didn't use our hash function)
* - Manual human editing of YAML files
* - Filesystem corruption
* - Tampering attempts (including Unicode tricks)
*
* @param content - The content to verify (will be normalized)
* @param expectedHash - The expected hash value
* @returns True if content matches hash after normalization
*/
export function verifyContentIntegrity(content, expectedHash) {
const actualHash = generateContentHash(content);
const isValid = actualHash === expectedHash;
if (!isValid) {
// SECURITY: Log integrity violation for audit trail
// This could indicate external modification or tampering
SecurityMonitor.logSecurityEvent({
type: MEMORY_SECURITY_EVENTS.MEMORY_INTEGRITY_VIOLATION,
severity: 'HIGH',
source: 'verifyContentIntegrity',
details: `Hash mismatch detected. Expected: ${expectedHash.substring(0, 8)}..., Got: ${actualHash.substring(0, 8)}...`
});
}
return isValid;
}
/**
* Calculate shard key for memory distribution
* Used for distributing memories across multiple files
*
* SECURITY: Normalizes input to ensure consistent sharding
* regardless of Unicode representation
*
* @param memoryId - The memory ID (will be normalized)
* @param shardCount - Number of shards (default 16)
* @returns Shard index (0 to shardCount-1)
*/
export function calculateShardKey(memoryId, shardCount = 16) {
// SECURITY FIX: Normalize memoryId to prevent Unicode-based attacks
// that could cause memories to be placed in unexpected shards
const normalized = UnicodeValidator.normalize(memoryId);
if (!normalized.isValid && normalized.detectedIssues) {
// Log but continue - we still need to calculate a shard
SecurityMonitor.logSecurityEvent({
type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,
severity: 'LOW',
source: 'calculateShardKey',
details: `Unicode issues in memory ID: ${normalized.detectedIssues.join(', ')}`
});
}
const hash = crypto.createHash('md5')
.update(normalized.normalizedContent)
.digest();
const hashInt = hash.readUInt32BE(0);
return hashInt % shardCount;
}
/**
* Parse memory ID to extract timestamp
*
* @param memoryId - The memory ID to parse
* @returns Timestamp or null if invalid format
*/
export function parseMemoryTimestamp(memoryId) {
const match = memoryId.match(/^mem_(\d+)_/);
if (match && match[1]) {
const timestamp = Number.parseInt(match[1], 10);
return Number.isNaN(timestamp) ? null : timestamp;
}
return null;
}
// TODO: Future index utilities
// - createMemoryIndex(): Create B-tree or similar structure for fast lookups
// - updateIndex(): Update index when memories are added/removed
// - searchIndex(): O(log n) search through indexed memories
// - mergeIndices(): Combine multiple index files for distributed search
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/elements/memories/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB;IAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACvD,OAAO,OAAO,SAAS,IAAI,MAAM,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,OAAe;IACjD,+DAA+D;IAC/D,uEAAuE;IACvE,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAEvD,IAAI,CAAC,UAAU,CAAC,OAAO,IAAI,UAAU,CAAC,cAAc,EAAE,CAAC;QACrD,uDAAuD;QACvD,0DAA0D;QAC1D,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,sBAAsB,CAAC,gCAAgC;YAC7D,QAAQ,EAAE,QAAQ;YAClB,MAAM,EAAE,qBAAqB;YAC7B,OAAO,EAAE,qCAAqC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;SACrF,CAAC,CAAC;IACL,CAAC;IAED,OAAO,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC;SAC/B,MAAM,CAAC,UAAU,CAAC,iBAAiB,CAAC;SACpC,MAAM,CAAC,KAAK,CAAC,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAe,EAAE,YAAoB;IAC1E,MAAM,UAAU,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAChD,MAAM,OAAO,GAAG,UAAU,KAAK,YAAY,CAAC;IAE5C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,oDAAoD;QACpD,yDAAyD;QACzD,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,sBAAsB,CAAC,0BAA0B;YACvD,QAAQ,EAAE,MAAM;YAChB,MAAM,EAAE,wBAAwB;YAChC,OAAO,EAAE,qCAAqC,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,aAAa,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK;SACvH,CAAC,CAAC;IACL,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAgB,EAAE,UAAU,GAAG,EAAE;IACjE,oEAAoE;IACpE,8DAA8D;IAC9D,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAExD,IAAI,CAAC,UAAU,CAAC,OAAO,IAAI,UAAU,CAAC,cAAc,EAAE,CAAC;QACrD,wDAAwD;QACxD,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,sBAAsB,CAAC,gCAAgC;YAC7D,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,mBAAmB;YAC3B,OAAO,EAAE,gCAAgC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;SAChF,CAAC,CAAC;IACL,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC;SAClC,MAAM,CAAC,UAAU,CAAC,iBAAiB,CAAC;SACpC,MAAM,EAAE,CAAC;IACZ,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IACrC,OAAO,OAAO,GAAG,UAAU,CAAC;AAC9B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgB;IACnD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IAC5C,IAAI,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QACtB,MAAM,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAChD,OAAO,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACpD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,+BAA+B;AAC/B,6EAA6E;AAC7E,gEAAgE;AAChE,4DAA4D;AAC5D,wEAAwE","sourcesContent":["/**\n * Utility functions for Memory element operations\n *\n * PERFORMANCE CONSIDERATIONS:\n * - ID generation should be fast (<1ms)\n * - Hash functions optimized for memory verification\n * - Index operations designed for O(log n) complexity\n *\n * SECURITY CONSIDERATIONS:\n * - Hash functions normalize Unicode to prevent bypass attempts\n * - Content verification detects external modifications\n * - Protects against manual editing and tampering\n */\n\nimport * as crypto from 'crypto';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { MEMORY_SECURITY_EVENTS } from './constants.js';\n\n/**\n * Generate a unique ID for memory entries\n * Format: mem_{timestamp}_{random}\n *\n * @returns Unique memory entry ID\n * @example\n * generateMemoryId() // \"mem_1699234567890_x7k2n9p4m\"\n */\nexport function generateMemoryId(): string {\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).substr(2, 9);\n  return `mem_${timestamp}_${random}`;\n}\n\n/**\n * Generate a content hash for memory integrity verification\n * Uses SHA-256 for cryptographic strength with Unicode normalization\n *\n * SECURITY: Normalizes content to prevent Unicode-based bypass attempts\n * where attackers use homographs or invisible characters to create\n * content that appears identical but has a different hash\n *\n * @param content - The content to hash (will be normalized)\n * @returns Hex-encoded hash string\n */\nexport function generateContentHash(content: string): string {\n  // SECURITY FIX: Normalize Unicode to prevent homograph attacks\n  // This ensures consistent hashing regardless of Unicode representation\n  const normalized = UnicodeValidator.normalize(content);\n\n  if (!normalized.isValid && normalized.detectedIssues) {\n    // Log potential security issue but still generate hash\n    // We want to detect the tampering, not reject it silently\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,\n      severity: 'MEDIUM',\n      source: 'generateContentHash',\n      details: `Unicode security issues detected: ${normalized.detectedIssues.join(', ')}`\n    });\n  }\n\n  return crypto.createHash('sha256')\n    .update(normalized.normalizedContent)\n    .digest('hex');\n}\n\n/**\n * Verify memory content integrity\n *\n * SECURITY: This function detects:\n * - External tool modifications (didn't use our hash function)\n * - Manual human editing of YAML files\n * - Filesystem corruption\n * - Tampering attempts (including Unicode tricks)\n *\n * @param content - The content to verify (will be normalized)\n * @param expectedHash - The expected hash value\n * @returns True if content matches hash after normalization\n */\nexport function verifyContentIntegrity(content: string, expectedHash: string): boolean {\n  const actualHash = generateContentHash(content);\n  const isValid = actualHash === expectedHash;\n\n  if (!isValid) {\n    // SECURITY: Log integrity violation for audit trail\n    // This could indicate external modification or tampering\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_INTEGRITY_VIOLATION,\n      severity: 'HIGH',\n      source: 'verifyContentIntegrity',\n      details: `Hash mismatch detected. Expected: ${expectedHash.substring(0, 8)}..., Got: ${actualHash.substring(0, 8)}...`\n    });\n  }\n\n  return isValid;\n}\n\n/**\n * Calculate shard key for memory distribution\n * Used for distributing memories across multiple files\n *\n * SECURITY: Normalizes input to ensure consistent sharding\n * regardless of Unicode representation\n *\n * @param memoryId - The memory ID (will be normalized)\n * @param shardCount - Number of shards (default 16)\n * @returns Shard index (0 to shardCount-1)\n */\nexport function calculateShardKey(memoryId: string, shardCount = 16): number {\n  // SECURITY FIX: Normalize memoryId to prevent Unicode-based attacks\n  // that could cause memories to be placed in unexpected shards\n  const normalized = UnicodeValidator.normalize(memoryId);\n\n  if (!normalized.isValid && normalized.detectedIssues) {\n    // Log but continue - we still need to calculate a shard\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,\n      severity: 'LOW',\n      source: 'calculateShardKey',\n      details: `Unicode issues in memory ID: ${normalized.detectedIssues.join(', ')}`\n    });\n  }\n\n  const hash = crypto.createHash('md5')\n    .update(normalized.normalizedContent)\n    .digest();\n  const hashInt = hash.readUInt32BE(0);\n  return hashInt % shardCount;\n}\n\n/**\n * Parse memory ID to extract timestamp\n *\n * @param memoryId - The memory ID to parse\n * @returns Timestamp or null if invalid format\n */\nexport function parseMemoryTimestamp(memoryId: string): number | null {\n  const match = memoryId.match(/^mem_(\\d+)_/);\n  if (match && match[1]) {\n    const timestamp = Number.parseInt(match[1], 10);\n    return Number.isNaN(timestamp) ? null : timestamp;\n  }\n  return null;\n}\n\n// TODO: Future index utilities\n// - createMemoryIndex(): Create B-tree or similar structure for fast lookups\n// - updateIndex(): Update index when memories are added/removed\n// - searchIndex(): O(log n) search through indexed memories\n// - mergeIndices(): Combine multiple index files for distributed search"]}