@tokenoftrust/storefront-runner 4.10.1 → 4.11.1

package/apps/storefront/src/lib/customers/contactVault/envelope.ts

@@ -1,166 +0,0 @@
-/**
- * Contact vault envelope: AES-256-GCM under a per-tenant, per-purpose HKDF subkey of one keyring
- * key. The AAD binds tenant, stage, record id, key id and the immutable `notAfter`, so a row read
- * under any other binding fails its tag and reads as absent.
- *
- * The keyring is the `ORDER_CONTACT_VAULT_KEYRING` Worker secret: JSON
- * `{ active: <kid>, keys: { <kid>: <base64 of 32 bytes> } }`. Errors carry fixed codes only —
- * never a key, nonce, ciphertext or plaintext value.
- */
-
-export type VaultPurpose = "order-contact" | "contact-message";
-
-export interface VaultKeyring {
-  active: string;
-  keys: ReadonlyMap<string, Uint8Array>;
-}
-
-export interface VaultBinding {
-  purpose: VaultPurpose;
-  tenantId: string;
-  stage: string;
-  recordId: string;
-  notAfter: string;
-}
-
-export interface SealedEnvelope {
-  keyId: string;
-  nonce: string;
-  ciphertext: string;
-}
-
-export class VaultKeyUnavailableError extends Error {
-  readonly code = "vault-key-unavailable";
-  constructor() {
-    super("vault-key-unavailable");
-    this.name = "VaultKeyUnavailableError";
-  }
-}
-
-const KID = /^[A-Za-z0-9._-]{1,32}$/;
-const HKDF_SALT = new TextEncoder().encode("tot-contact-vault/v1");
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-function fromBase64(value: string): Uint8Array | null {
-  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(value)) return null;
-  let binary: string;
-  try {
-    binary = atob(value);
-  } catch (error) {
-    if (error instanceof DOMException && error.name === "InvalidCharacterError") return null;
-    throw error;
-  }
-  const out = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
-  return out;
-}
-
-function toBase64(bytes: Uint8Array): string {
-  let binary = "";
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary);
-}
-
-/** Parse the keyring secret, or null when it is absent or malformed in any way. */
-export function parseVaultKeyring(raw: string | undefined | null): VaultKeyring | null {
-  if (typeof raw !== "string" || raw.trim() === "") return null;
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    if (error instanceof SyntaxError) return null;
-    throw error;
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-  const { active, keys } = parsed as { active?: unknown; keys?: unknown };
-  if (typeof active !== "string" || !KID.test(active)) return null;
-  if (!keys || typeof keys !== "object" || Array.isArray(keys)) return null;
-  const map = new Map<string, Uint8Array>();
-  for (const [kid, value] of Object.entries(keys as Record<string, unknown>)) {
-    if (!KID.test(kid) || typeof value !== "string") return null;
-    const bytes = fromBase64(value);
-    if (!bytes || bytes.length !== 32) return null;
-    map.set(kid, bytes);
-  }
-  if (!map.has(active)) return null;
-  return { active, keys: map };
-}
-
-/** Canonical AAD bytes: fixed key order, so equal bindings always produce equal AAD. */
-export function vaultAad(binding: VaultBinding, keyId: string): Uint8Array {
-  return encoder.encode(JSON.stringify({
-    v: 1,
-    purpose: binding.purpose,
-    tenantId: binding.tenantId,
-    stage: binding.stage,
-    recordId: binding.recordId,
-    keyId,
-    notAfter: binding.notAfter,
-  }));
-}
-
-async function subkey(keyring: VaultKeyring, keyId: string, binding: VaultBinding): Promise<CryptoKey> {
-  const ikm = keyring.keys.get(keyId);
-  if (!ikm) throw new VaultKeyUnavailableError();
-  const base = await crypto.subtle.importKey("raw", ikm as BufferSource, "HKDF", false, ["deriveKey"]);
-  return crypto.subtle.deriveKey(
-    { name: "HKDF", hash: "SHA-256", salt: HKDF_SALT, info: encoder.encode(`${binding.purpose}|${binding.tenantId}`) },
-    base,
-    { name: "AES-GCM", length: 256 },
-    false,
-    ["encrypt", "decrypt"],
-  );
-}
-
-/** Seal a JSON value under the keyring's active key. */
-export async function sealVaultRecord(
-  keyring: VaultKeyring | null,
-  binding: VaultBinding,
-  value: unknown,
-): Promise<SealedEnvelope> {
-  if (!keyring) throw new VaultKeyUnavailableError();
-  const keyId = keyring.active;
-  const key = await subkey(keyring, keyId, binding);
-  const nonce = crypto.getRandomValues(new Uint8Array(12));
-  const sealed = await crypto.subtle.encrypt(
-    { name: "AES-GCM", iv: nonce, additionalData: vaultAad(binding, keyId) as BufferSource },
-    key,
-    encoder.encode(JSON.stringify(value)),
-  );
-  return { keyId, nonce: toBase64(nonce), ciphertext: toBase64(new Uint8Array(sealed)) };
-}
-
-/**
- * Open a sealed record. Null when the binding, nonce or ciphertext does not authenticate — callers
- * report that as not-found. A missing keyring or key id throws {@link VaultKeyUnavailableError}.
- */
-export async function openVaultRecord(
-  keyring: VaultKeyring | null,
-  binding: VaultBinding,
-  envelope: SealedEnvelope,
-): Promise<unknown | null> {
-  if (!keyring) throw new VaultKeyUnavailableError();
-  const key = await subkey(keyring, envelope.keyId, binding);
-  const nonce = fromBase64(envelope.nonce);
-  const ciphertext = fromBase64(envelope.ciphertext);
-  if (!nonce || nonce.length !== 12 || !ciphertext) return null;
-  let plain: ArrayBuffer;
-  try {
-    plain = await crypto.subtle.decrypt(
-      { name: "AES-GCM", iv: nonce as BufferSource, additionalData: vaultAad(binding, envelope.keyId) as BufferSource },
-      key,
-      ciphertext as BufferSource,
-    );
-  } catch (error) {
-    // AES-GCM reports a failed tag (wrong binding, key or bytes) as OperationError; anything else is a fault.
-    if (error instanceof DOMException && error.name === "OperationError") return null;
-    throw error;
-  }
-  try {
-    return JSON.parse(decoder.decode(plain));
-  } catch (error) {
-    if (error instanceof SyntaxError) return null;
-    throw error;
-  }
-}

package/apps/storefront/src/lib/orders/vault/keyringEnv.ts

@@ -1,7 +0,0 @@
-/** The Worker's contact vault keyring, from the declared `ORDER_CONTACT_VAULT_KEYRING` secret only. */
-import { readEnv } from "@/lib/publication/shared/env";
-import { parseVaultKeyring, type VaultKeyring } from "@/lib/customers/contactVault/envelope.js";
-
-export async function loadVaultKeyring(): Promise<VaultKeyring | null> {
-  return parseVaultKeyring(await readEnv("ORDER_CONTACT_VAULT_KEYRING"));
-}