Encrypted Vault

interface VaultState {
  unlocked: boolean;                           // Is vault currently unlocked?
  cryptoKey: CryptoKey | null;                 // Derived AES key (in-memory only)
  salt: string | null;                         // PBKDF2 salt (base64)
  autoLockTimer: ReturnType<typeof setTimeout> | null;
  autoLockMs: number;                          // Auto-lock after N ms (default: 30 min)
}

interface VaultEntry {
  key: string;           // Credential key (e.g., "ANTHROPIC_API_KEY")
  iv: string;            // Initialization vector (base64)
  ciphertext: string;    // Encrypted value (base64)
  tag: string;           // GCM authentication tag (base64)
  createdAt: number;     // Timestamp
  updatedAt: number;     // Timestamp
}

async function deriveKey(
  password: string,
  salt: Uint8Array,
): Promise<CryptoKey> {
  const encoder = new TextEncoder();
  const keyMaterial = await crypto.subtle.importKey(
    "raw",
    encoder.encode(password),
    "PBKDF2",
    false,
    ["deriveKey"],
  );

  return crypto.subtle.deriveKey(
    {
      name: "PBKDF2",
      salt: salt,
      iterations: 600_000,  // OWASP recommendation (2023)
      hash: "SHA-256",
    },
    keyMaterial,
    { name: "AES-GCM", length: 256 },
    false,
    ["encrypt", "decrypt"],
  );
}

async function encrypt(
  key: CryptoKey,
  plaintext: string,
): Promise<{ iv: string; ciphertext: string; tag: string }> {
  const encoder = new TextEncoder();
  const iv = crypto.getRandomValues(new Uint8Array(12));  // 96-bit nonce

  const encrypted = await crypto.subtle.encrypt(
    { name: "AES-GCM", iv, tagLength: 128 },  // 128-bit auth tag
    key,
    encoder.encode(plaintext),
  );

  const buf = new Uint8Array(encrypted);
  const ciphertext = buf.slice(0, buf.length - 16);
  const tag = buf.slice(buf.length - 16);

  return {
    iv: Buffer.from(iv).toString("base64"),
    ciphertext: Buffer.from(ciphertext).toString("base64"),
    tag: Buffer.from(tag).toString("base64"),
  };
}

async function decrypt(
  key: CryptoKey,
  entry: { iv: string; ciphertext: string; tag: string },
): Promise<string> {
  const iv = Buffer.from(entry.iv, "base64");
  const ciphertext = Buffer.from(entry.ciphertext, "base64");
  const tag = Buffer.from(entry.tag, "base64");

  // Combine ciphertext + tag for GCM
  const combined = new Uint8Array(ciphertext.length + tag.length);
  combined.set(ciphertext);
  combined.set(tag, ciphertext.length);

  const decrypted = await crypto.subtle.decrypt(
    { name: "AES-GCM", iv, tagLength: 128 },
    key,
    combined,
  );

  return new TextDecoder().decode(decrypted);
}

import { wrapZeroized, autoDispose } from "./security-zeroize.js";

const plaintext = await decrypt(vault.cryptoKey!, entry);

// Wrap in auto-zeroing buffer
const zb = wrapZeroized(plaintext);
autoDispose(zb, 30_000);  // Zero after 30 seconds

return {
  key,
  value: zb.toString(),  // Return before auto-zero
  createdAt: entry.createdAt,
  updatedAt: entry.updatedAt,
};

function resetAutoLock() {
  if (vault.autoLockTimer) clearTimeout(vault.autoLockTimer);
  
  vault.autoLockTimer = setTimeout(() => {
    vault.unlocked = false;
    vault.cryptoKey = null;  // Clear key from memory
    
    triggerVoid("security::audit", {
      type: "vault_auto_locked",
      detail: { after: vault.autoLockMs },
    });
  }, vault.autoLockMs);
}

// Reset timer on every vault operation
registerFunction({ id: "vault::get" }, async (req) => {
  assertUnlocked();
  resetAutoLock();  // Reset timer
  // ... decrypt and return secret
});

registerFunction({ id: "vault::rotate" }, async (req) => {
  const { currentPassword, newPassword } = req.body;
  assertUnlocked();

  // Derive old key
  const meta = await trigger("state::get", { scope: "vault", key: "__meta" });
  const oldSalt = Buffer.from(meta.salt, "base64");
  const oldKey = await deriveKey(currentPassword, oldSalt);

  // Fetch all encrypted entries
  const entries = await trigger("state::list", { scope: "vault" });
  const credentials = entries.filter((e) => e.key !== "__meta");

  // Backup before rotation
  for (const entry of credentials) {
    await trigger("state::set", {
      scope: "vault_backup",
      key: entry.key,
      value: entry.value,
    });
  }

  // Generate new salt and key
  const newSalt = crypto.getRandomValues(new Uint8Array(32));
  const newKey = await deriveKey(newPassword, newSalt);

  // Re-encrypt all credentials
  const updates = [];
  for (const entry of credentials) {
    const plaintext = await decrypt(oldKey, entry.value);
    const encrypted = await encrypt(newKey, plaintext);
    updates.push({
      key: entry.key,
      value: { ...entry.value, ...encrypted, updatedAt: Date.now() },
    });
  }

  // Atomically update all entries
  try {
    for (const { key, value } of updates) {
      await trigger("state::set", { scope: "vault", key, value });
    }
    await trigger("state::set", {
      scope: "vault",
      key: "__meta",
      value: {
        salt: Buffer.from(newSalt).toString("base64"),
        createdAt: meta.createdAt,
        rotatedAt: Date.now(),
      },
    });
  } catch (err) {
    // Rollback on failure
    // (restore from vault_backup scope)
    throw new Error(`Vault rotation failed, rolled back: ${err.message}`);
  }

  vault.cryptoKey = newKey;
  vault.salt = Buffer.from(newSalt).toString("base64");
  resetAutoLock();

  return { rotated: updates.length, success: true };
});