72 lines
2.5 KiB
TypeScript
72 lines
2.5 KiB
TypeScript
import { randomBytes, createCipheriv, createDecipheriv, timingSafeEqual } from 'node:crypto';
|
|
import { existsSync, readFileSync, writeFileSync, chmodSync, mkdirSync } from 'fs';
|
|
import { dirname } from 'path';
|
|
|
|
const ALGO = 'aes-256-gcm';
|
|
const IV_LEN = 12;
|
|
const TAG_LEN = 16;
|
|
const KEY_HEX_LEN = 64; // 32 bytes
|
|
|
|
const ENV_VAR = 'MCP_ENCRYPTION_KEY';
|
|
|
|
/**
|
|
* Read or auto-generate the MCP encryption key at `path`.
|
|
* If the file exists: reads it (must be 32 bytes) and sets MCP_ENCRYPTION_KEY env var.
|
|
* If the file does not exist: generates 32 random bytes, writes to file (mode 0600),
|
|
* then sets the env var. Uses the same pattern as initMasterKey in src/crypto/sessions.ts.
|
|
*/
|
|
export function initMcpKeyFromFile(path: string): void {
|
|
if (existsSync(path)) {
|
|
const buf = readFileSync(path);
|
|
if (buf.length !== 32) {
|
|
throw new Error(`MCP key at ${path} is not 32 bytes (got ${buf.length})`);
|
|
}
|
|
process.env[ENV_VAR] = buf.toString('hex');
|
|
return;
|
|
}
|
|
mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
|
|
const key = randomBytes(32);
|
|
writeFileSync(path, key, { mode: 0o600 });
|
|
chmodSync(path, 0o600);
|
|
process.env[ENV_VAR] = key.toString('hex');
|
|
}
|
|
|
|
export function isKeyConfigured(): boolean {
|
|
const raw = process.env[ENV_VAR];
|
|
return typeof raw === 'string' && /^[0-9a-fA-F]{64}$/.test(raw);
|
|
}
|
|
|
|
export function loadKeyFromEnv(): Buffer {
|
|
const raw = process.env[ENV_VAR];
|
|
if (!raw || !/^[0-9a-fA-F]{64}$/.test(raw)) {
|
|
throw new Error(
|
|
`${ENV_VAR} must be a 64-character hex string (32 bytes). MCP client features are disabled.`,
|
|
);
|
|
}
|
|
return Buffer.from(raw, 'hex');
|
|
}
|
|
|
|
// Layout: [IV (12)] [TAG (16)] [CIPHERTEXT (n)]
|
|
export function encrypt(plaintext: string, key: Buffer): Buffer {
|
|
const iv = randomBytes(IV_LEN);
|
|
const cipher = createCipheriv(ALGO, key, iv);
|
|
const ct = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
|
|
const tag = cipher.getAuthTag();
|
|
return Buffer.concat([iv, tag, ct]);
|
|
}
|
|
|
|
export function decrypt(blob: Buffer, key: Buffer): string {
|
|
if (blob.length < IV_LEN + TAG_LEN) throw new Error('ciphertext too short');
|
|
const iv = blob.subarray(0, IV_LEN);
|
|
const tag = blob.subarray(IV_LEN, IV_LEN + TAG_LEN);
|
|
const ct = blob.subarray(IV_LEN + TAG_LEN);
|
|
const decipher = createDecipheriv(ALGO, key, iv);
|
|
decipher.setAuthTag(tag);
|
|
return Buffer.concat([decipher.update(ct), decipher.final()]).toString('utf8');
|
|
}
|
|
|
|
export function safeEqual(a: Buffer, b: Buffer): boolean {
|
|
if (a.length !== b.length) return false;
|
|
return timingSafeEqual(a, b);
|
|
}
|