@remnic/core 1.1.2 → 1.1.4

package/dist/chunk-A6XUJE5D.js

@@ -0,0 +1,126 @@
+// src/secure-store/cipher.ts
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+var ENVELOPE_VERSION = 1;
+var IV_LENGTH = 12;
+var AUTH_TAG_LENGTH = 16;
+var ENVELOPE_SALT_LENGTH = 16;
+var AES_KEY_LENGTH = 32;
+var ENVELOPE_LAYOUT = Object.freeze({
+  version: 0,
+  salt: 1,
+  iv: 1 + ENVELOPE_SALT_LENGTH,
+  authTag: 1 + ENVELOPE_SALT_LENGTH + IV_LENGTH,
+  ciphertext: 1 + ENVELOPE_SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH
+});
+var ENVELOPE_HEADER_SIZE = ENVELOPE_LAYOUT.ciphertext;
+function assertAesKey(key) {
+  if (!(key instanceof Uint8Array)) {
+    throw new Error("key must be a Uint8Array");
+  }
+  if (key.length !== AES_KEY_LENGTH) {
+    throw new Error(
+      `AES-256-GCM requires a ${AES_KEY_LENGTH}-byte key, got ${key.length}`
+    );
+  }
+}
+function seal(key, salt, plaintext, options = {}) {
+  assertAesKey(key);
+  if (!(salt instanceof Uint8Array) || salt.length !== ENVELOPE_SALT_LENGTH) {
+    throw new Error(
+      `salt must be ${ENVELOPE_SALT_LENGTH} bytes, got ${salt?.length ?? "non-buffer"}`
+    );
+  }
+  if (!(plaintext instanceof Uint8Array)) {
+    throw new Error("plaintext must be a Uint8Array");
+  }
+  let iv;
+  if (options.iv) {
+    if (options.iv.length !== IV_LENGTH) {
+      throw new Error(`iv must be ${IV_LENGTH} bytes, got ${options.iv.length}`);
+    }
+    iv = options.iv;
+  } else {
+    iv = randomBytes(IV_LENGTH);
+  }
+  const cipher = createCipheriv("aes-256-gcm", Buffer.from(key), Buffer.from(iv), {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const headerAad = buildHeaderAad(salt);
+  const finalAad = options.aad ? Buffer.concat([headerAad, Buffer.from(options.aad)]) : headerAad;
+  cipher.setAAD(finalAad);
+  const ciphertext = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  if (authTag.length !== AUTH_TAG_LENGTH) {
+    throw new Error(`unexpected auth tag length: ${authTag.length}`);
+  }
+  const envelope = Buffer.alloc(ENVELOPE_HEADER_SIZE + ciphertext.length);
+  envelope.writeUInt8(ENVELOPE_VERSION, ENVELOPE_LAYOUT.version);
+  Buffer.from(salt).copy(envelope, ENVELOPE_LAYOUT.salt);
+  Buffer.from(iv).copy(envelope, ENVELOPE_LAYOUT.iv);
+  authTag.copy(envelope, ENVELOPE_LAYOUT.authTag);
+  ciphertext.copy(envelope, ENVELOPE_LAYOUT.ciphertext);
+  return envelope;
+}
+function parseEnvelope(envelope) {
+  if (!(envelope instanceof Uint8Array)) {
+    throw new Error("envelope must be a Uint8Array");
+  }
+  if (envelope.length < ENVELOPE_HEADER_SIZE) {
+    throw new Error(
+      `envelope too short: need \u2265 ${ENVELOPE_HEADER_SIZE} bytes, got ${envelope.length}`
+    );
+  }
+  const buf = Buffer.from(envelope.buffer, envelope.byteOffset, envelope.byteLength);
+  const version = buf.readUInt8(ENVELOPE_LAYOUT.version);
+  if (version !== ENVELOPE_VERSION) {
+    throw new Error(
+      `unsupported envelope version: ${version} (this build supports ${ENVELOPE_VERSION})`
+    );
+  }
+  return {
+    version,
+    salt: buf.subarray(ENVELOPE_LAYOUT.salt, ENVELOPE_LAYOUT.salt + ENVELOPE_SALT_LENGTH),
+    iv: buf.subarray(ENVELOPE_LAYOUT.iv, ENVELOPE_LAYOUT.iv + IV_LENGTH),
+    authTag: buf.subarray(
+      ENVELOPE_LAYOUT.authTag,
+      ENVELOPE_LAYOUT.authTag + AUTH_TAG_LENGTH
+    ),
+    ciphertext: buf.subarray(ENVELOPE_LAYOUT.ciphertext)
+  };
+}
+function open(key, envelope, options = {}) {
+  assertAesKey(key);
+  const parsed = parseEnvelope(envelope);
+  const decipher = createDecipheriv("aes-256-gcm", Buffer.from(key), parsed.iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  decipher.setAuthTag(parsed.authTag);
+  const headerAad = buildHeaderAad(parsed.salt);
+  const finalAad = options.aad ? Buffer.concat([headerAad, Buffer.from(options.aad)]) : headerAad;
+  decipher.setAAD(finalAad);
+  return Buffer.concat([decipher.update(parsed.ciphertext), decipher.final()]);
+}
+function buildHeaderAad(salt) {
+  const out = Buffer.alloc(1 + ENVELOPE_SALT_LENGTH);
+  out.writeUInt8(ENVELOPE_VERSION, 0);
+  Buffer.from(salt).copy(out, 1);
+  return out;
+}
+function generateSalt() {
+  return randomBytes(ENVELOPE_SALT_LENGTH);
+}
+
+export {
+  ENVELOPE_VERSION,
+  IV_LENGTH,
+  AUTH_TAG_LENGTH,
+  ENVELOPE_SALT_LENGTH,
+  AES_KEY_LENGTH,
+  ENVELOPE_LAYOUT,
+  ENVELOPE_HEADER_SIZE,
+  seal,
+  parseEnvelope,
+  open,
+  generateSalt
+};
+//# sourceMappingURL=chunk-A6XUJE5D.js.map

package/dist/chunk-A6XUJE5D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/secure-store/cipher.ts"],"sourcesContent":["/**\n * AES-256-GCM encrypt / decrypt primitives for the secure-store\n * module.\n *\n * Issue #690 (PR 1/4) — pure primitives, no I/O.\n *\n * Sealed envelope format\n * ----------------------\n * A \"sealed\" buffer is the canonical on-disk shape for a single\n * encrypted blob. It contains the salt used to derive the key from\n * the user's passphrase, so a caller who has the passphrase + the\n * sealed buffer can decrypt without any external metadata.\n *\n *   [VERSION:1][SALT:16][IV:12][AUTHTAG:16][CIPHERTEXT:...]\n *\n *   - VERSION (1 byte): envelope format version. Currently 1. Future\n *     versions can change the layout (e.g. variable salt length, an\n *     algorithm identifier byte) by bumping this byte.\n *   - SALT (16 bytes): KDF salt. Persisted with the ciphertext so the\n *     same passphrase can re-derive the key on read.\n *   - IV (12 bytes): GCM nonce. Must be unique per (key, ciphertext)\n *     pair. We generate it fresh from `randomBytes` on every encrypt\n *     call. Reusing an IV with the same key destroys GCM's\n *     confidentiality and authenticity guarantees.\n *   - AUTHTAG (16 bytes): GCM authentication tag. Tampering with any\n *     byte of (salt | iv | tag | ciphertext) causes decryption to\n *     fail with an auth-tag mismatch.\n *   - CIPHERTEXT (variable): the encrypted payload.\n *\n * The salt is stored alongside the ciphertext (rather than only in a\n * separate metadata file) so an individual encrypted blob is\n * self-contained for diagnostics and recovery. The metadata file\n * (see `metadata.ts`) records the *canonical* salt + KDF params for a\n * store; the per-blob salt is expected to match the metadata salt in\n * normal operation, but the format does not require it — a future PR\n * could rotate per-blob salts if desired.\n *\n * AAD support\n * -----------\n * Callers can pass associated authenticated data (AAD) — typically a\n * file path or namespace tag — that is authenticated but not\n * encrypted. AAD must be supplied identically on encrypt and decrypt;\n * a mismatch causes auth-tag failure. AAD is NOT serialized into the\n * envelope; the caller is responsible for re-supplying it on decrypt.\n */\n\nimport { createCipheriv, createDecipheriv, randomBytes } from \"node:crypto\";\n\n/** Current envelope format version. */\nexport const ENVELOPE_VERSION = 1 as const;\n\n/** GCM nonce length. 96 bits is the NIST-recommended size for AES-GCM. */\nexport const IV_LENGTH = 12;\n\n/** GCM authentication tag length. 16 bytes (128 bits) — the maximum. */\nexport const AUTH_TAG_LENGTH = 16;\n\n/** Salt length carried in the envelope. Must match KDF_SALT_LENGTH. */\nexport const ENVELOPE_SALT_LENGTH = 16;\n\n/** Required key length for AES-256. */\nexport const AES_KEY_LENGTH = 32;\n\n/** Byte offsets of each envelope field (for clarity at call sites). */\nexport const ENVELOPE_LAYOUT = Object.freeze({\n  version: 0,\n  salt: 1,\n  iv: 1 + ENVELOPE_SALT_LENGTH,\n  authTag: 1 + ENVELOPE_SALT_LENGTH + IV_LENGTH,\n  ciphertext: 1 + ENVELOPE_SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH,\n});\n\n/** Minimum envelope size: header + zero-length ciphertext. */\nexport const ENVELOPE_HEADER_SIZE = ENVELOPE_LAYOUT.ciphertext;\n\nexport interface EncryptOptions {\n  /**\n   * Optional associated data — authenticated but not encrypted.\n   * Caller must supply the same value on decrypt.\n   */\n  aad?: Uint8Array;\n  /**\n   * Override the per-call IV. Strongly discouraged outside of tests:\n   * GCM is catastrophically broken if an IV is reused under the same\n   * key. Production callers should always let the cipher generate a\n   * fresh random IV.\n   */\n  iv?: Uint8Array;\n}\n\nexport interface DecryptOptions {\n  /** Same AAD that was supplied to `encrypt`. */\n  aad?: Uint8Array;\n}\n\n/**\n * Validate that a key is a 32-byte buffer suitable for AES-256.\n */\nfunction assertAesKey(key: Uint8Array): void {\n  if (!(key instanceof Uint8Array)) {\n    throw new Error(\"key must be a Uint8Array\");\n  }\n  if (key.length !== AES_KEY_LENGTH) {\n    throw new Error(\n      `AES-256-GCM requires a ${AES_KEY_LENGTH}-byte key, got ${key.length}`,\n    );\n  }\n}\n\n/**\n * Encrypt `plaintext` under `key` and return a sealed envelope buffer.\n *\n * @param key 32-byte AES-256 key (from `deriveKey`).\n * @param salt 16-byte KDF salt to embed in the envelope. The caller is\n *   responsible for using the same salt that was passed to the KDF.\n * @param plaintext the bytes to encrypt.\n * @param options optional `aad` / `iv` overrides.\n */\nexport function seal(\n  key: Uint8Array,\n  salt: Uint8Array,\n  plaintext: Uint8Array,\n  options: EncryptOptions = {},\n): Buffer {\n  assertAesKey(key);\n  if (!(salt instanceof Uint8Array) || salt.length !== ENVELOPE_SALT_LENGTH) {\n    throw new Error(\n      `salt must be ${ENVELOPE_SALT_LENGTH} bytes, got ${salt?.length ?? \"non-buffer\"}`,\n    );\n  }\n  if (!(plaintext instanceof Uint8Array)) {\n    throw new Error(\"plaintext must be a Uint8Array\");\n  }\n  let iv: Uint8Array;\n  if (options.iv) {\n    if (options.iv.length !== IV_LENGTH) {\n      throw new Error(`iv must be ${IV_LENGTH} bytes, got ${options.iv.length}`);\n    }\n    iv = options.iv;\n  } else {\n    iv = randomBytes(IV_LENGTH);\n  }\n\n  const cipher = createCipheriv(\"aes-256-gcm\", Buffer.from(key), Buffer.from(iv), {\n    authTagLength: AUTH_TAG_LENGTH,\n  });\n  // Codex P1: bind the envelope header (version + salt) into AAD so\n  // flipping the salt or version on a sealed envelope triggers an\n  // auth failure on open. Without this, callers using a metadata-\n  // derived store key would still decrypt successfully even after\n  // the per-blob salt was tampered with — silently desynchronizing\n  // per-blob salt from metadata/recovery logic. Caller-supplied AAD\n  // is appended after the header so existing AAD usage stays intact.\n  const headerAad = buildHeaderAad(salt);\n  const finalAad = options.aad\n    ? Buffer.concat([headerAad, Buffer.from(options.aad)])\n    : headerAad;\n  cipher.setAAD(finalAad);\n  const ciphertext = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()]);\n  const authTag = cipher.getAuthTag();\n  if (authTag.length !== AUTH_TAG_LENGTH) {\n    // Defensive: Node always produces 16 bytes when authTagLength is 16.\n    throw new Error(`unexpected auth tag length: ${authTag.length}`);\n  }\n\n  const envelope = Buffer.alloc(ENVELOPE_HEADER_SIZE + ciphertext.length);\n  envelope.writeUInt8(ENVELOPE_VERSION, ENVELOPE_LAYOUT.version);\n  Buffer.from(salt).copy(envelope, ENVELOPE_LAYOUT.salt);\n  Buffer.from(iv).copy(envelope, ENVELOPE_LAYOUT.iv);\n  authTag.copy(envelope, ENVELOPE_LAYOUT.authTag);\n  ciphertext.copy(envelope, ENVELOPE_LAYOUT.ciphertext);\n  return envelope;\n}\n\n/** Parsed view of a sealed envelope. Useful for inspection in tests. */\nexport interface ParsedEnvelope {\n  version: number;\n  salt: Buffer;\n  iv: Buffer;\n  authTag: Buffer;\n  ciphertext: Buffer;\n}\n\n/**\n * Parse a sealed envelope into its component fields without\n * decrypting. Throws on malformed input. The returned buffers are\n * sub-views (not copies) — do not mutate.\n */\nexport function parseEnvelope(envelope: Uint8Array): ParsedEnvelope {\n  if (!(envelope instanceof Uint8Array)) {\n    throw new Error(\"envelope must be a Uint8Array\");\n  }\n  if (envelope.length < ENVELOPE_HEADER_SIZE) {\n    throw new Error(\n      `envelope too short: need ≥ ${ENVELOPE_HEADER_SIZE} bytes, got ${envelope.length}`,\n    );\n  }\n  const buf = Buffer.from(envelope.buffer, envelope.byteOffset, envelope.byteLength);\n  const version = buf.readUInt8(ENVELOPE_LAYOUT.version);\n  if (version !== ENVELOPE_VERSION) {\n    throw new Error(\n      `unsupported envelope version: ${version} (this build supports ${ENVELOPE_VERSION})`,\n    );\n  }\n  return {\n    version,\n    salt: buf.subarray(ENVELOPE_LAYOUT.salt, ENVELOPE_LAYOUT.salt + ENVELOPE_SALT_LENGTH),\n    iv: buf.subarray(ENVELOPE_LAYOUT.iv, ENVELOPE_LAYOUT.iv + IV_LENGTH),\n    authTag: buf.subarray(\n      ENVELOPE_LAYOUT.authTag,\n      ENVELOPE_LAYOUT.authTag + AUTH_TAG_LENGTH,\n    ),\n    ciphertext: buf.subarray(ENVELOPE_LAYOUT.ciphertext),\n  };\n}\n\n/**\n * Decrypt a sealed envelope and return the plaintext.\n *\n * Throws on:\n *   - malformed envelope (wrong length, wrong version);\n *   - wrong key (auth-tag mismatch);\n *   - tampered ciphertext / iv / auth tag (auth-tag mismatch);\n *   - mismatched AAD (auth-tag mismatch).\n *\n * The same error class is intentional: from the caller's standpoint\n * \"wrong passphrase\" and \"tampered ciphertext\" should both be\n * non-recoverable failures.\n */\nexport function open(\n  key: Uint8Array,\n  envelope: Uint8Array,\n  options: DecryptOptions = {},\n): Buffer {\n  assertAesKey(key);\n  const parsed = parseEnvelope(envelope);\n  const decipher = createDecipheriv(\"aes-256-gcm\", Buffer.from(key), parsed.iv, {\n    authTagLength: AUTH_TAG_LENGTH,\n  });\n  decipher.setAuthTag(parsed.authTag);\n  // Codex P1: header (version + salt) is bound at seal time.\n  // Reconstruct it identically so a tampered salt fails auth.\n  const headerAad = buildHeaderAad(parsed.salt);\n  const finalAad = options.aad\n    ? Buffer.concat([headerAad, Buffer.from(options.aad)])\n    : headerAad;\n  decipher.setAAD(finalAad);\n  // `final()` throws if the auth tag doesn't validate.\n  return Buffer.concat([decipher.update(parsed.ciphertext), decipher.final()]);\n}\n\n/**\n * Build the canonical header AAD: a single byte version followed by\n * the per-blob salt. Binds the immutable envelope header into AES-GCM\n * authentication so tampering with either value triggers auth failure\n * on open (codex P1 on PR #718).\n */\nfunction buildHeaderAad(salt: Uint8Array): Buffer {\n  const out = Buffer.alloc(1 + ENVELOPE_SALT_LENGTH);\n  out.writeUInt8(ENVELOPE_VERSION, 0);\n  Buffer.from(salt).copy(out, 1);\n  return out;\n}\n\n/**\n * Generate a fresh random salt of the canonical envelope length.\n * Convenience wrapper so callers don't reach into `node:crypto`.\n */\nexport function generateSalt(): Buffer {\n  return randomBytes(ENVELOPE_SALT_LENGTH);\n}\n"],"mappings":"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","names":[]}