simple-hpke 0.0.9 → 0.1.0

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  create: () => create2,
   decrypt: () => decrypt,
   encrypt: () => encrypt,
   open: () => open,
@@ -1306,8 +1307,7 @@ function toString2(array, encoding = "utf8") {
 }
 __name(toString2, "toString");
 
-// src/index.ts
-var subtle = globalThis.crypto.subtle;
+// src/constants.ts
 var KEM_ID = 32;
 var KDF_ID = 1;
 var AEAD_ID = 2;
@@ -1318,6 +1318,7 @@ var ENC_LENGTH = 32;
 var AEAD_TAG_LENGTH = 16;
 var MODE_BASE = 0;
 var HPKE_V1 = new TextEncoder().encode("HPKE-v1");
+var WRAPPED_LEN_PREFIX = 2;
 var KEM_SUITE_ID = concat2(
   new TextEncoder().encode("KEM"),
   i2osp(KEM_ID, 2)
@@ -1328,174 +1329,68 @@ var HPKE_SUITE_ID = concat2(
   i2osp(KDF_ID, 2),
   i2osp(AEAD_ID, 2)
 );
-async function seal(recipient, aesKey, opts) {
-  const info = normalizeInfo(opts?.info);
-  let keyBytes;
-  if (aesKey instanceof Uint8Array) {
-    validateRawKeyBytes(aesKey);
-    keyBytes = aesKey;
-  } else if (aesKey) {
-    keyBytes = await exportAesKeyBytes(aesKey);
-    validateRawKeyBytes(keyBytes);
-  } else {
-    const keysize = opts?.keysize ?? 256;
-    validateKeysize(keysize);
-    keyBytes = globalThis.crypto.getRandomValues(
-      new Uint8Array(keysize / 8)
-    );
-  }
-  const publicKey = await resolveRecipientPublicKey(recipient);
-  const { sharedSecret, enc } = await encap(publicKey);
-  const { key, baseNonce } = await keySchedule(sharedSecret, info);
-  const ciphertext = await aeadSeal(key, baseNonce, keyBytes);
-  const wrapped = concat2(enc, ciphertext);
-  const aesGcmKey = await importAesKey(keyBytes);
-  return { wrapped, key: aesGcmKey };
-}
-__name(seal, "seal");
-async function openBytes(keypair, wrapped, opts) {
-  const keyBytes = await openRawBytes(keypair, wrapped, opts);
-  return importAesKey(keyBytes);
-}
-__name(openBytes, "openBytes");
-async function openRawBytes(keypair, wrapped, opts) {
-  if (wrapped.byteLength < ENC_LENGTH + AEAD_TAG_LENGTH) {
-    throw new Error("malformed envelope: too short");
-  }
-  const info = normalizeInfo(opts?.info);
-  const enc = wrapped.slice(0, ENC_LENGTH);
-  const ciphertext = wrapped.slice(ENC_LENGTH);
-  const sharedSecret = await decap(enc, keypair);
-  const { key, baseNonce } = await keySchedule(sharedSecret, info);
-  return aeadOpen(key, baseNonce, ciphertext);
-}
-__name(openRawBytes, "openRawBytes");
-var open = Object.assign(openBytes, {
-  raw: openRawBytes
-});
-var WRAPPED_LEN_PREFIX = 2;
-var encrypt = Object.assign(encryptBytes, {
-  asString: encryptToString
-});
-var decrypt = Object.assign(decryptBytes, {
-  asString: decryptToString,
-  fromString: decryptFromString
-});
-async function decryptBytes(keypair, message, opts) {
-  if (message.byteLength < WRAPPED_LEN_PREFIX) {
-    throw new Error("malformed message: too short");
-  }
-  const wrappedLen = message[0] << 8 | message[1];
-  const ivStart = WRAPPED_LEN_PREFIX + wrappedLen;
-  const ctStart = ivStart + NN;
-  if (message.byteLength < ctStart + AEAD_TAG_LENGTH) {
-    throw new Error("malformed message: too short");
-  }
-  const wrapped = message.slice(WRAPPED_LEN_PREFIX, ivStart);
-  const iv = message.slice(ivStart, ctStart);
-  const ciphertext = message.slice(ctStart);
-  const keyBytes = await openRawBytes(
-    keypair,
-    wrapped,
-    opts?.info !== void 0 ? { info: opts.info } : void 0
-  );
-  const key = await importAesKeyDecryptOnly(keyBytes);
-  const pt = await subtle.decrypt(
-    { name: "AES-GCM", iv },
-    key,
-    ciphertext
-  );
-  return new Uint8Array(pt);
-}
-__name(decryptBytes, "decryptBytes");
-async function decryptToString(keypair, message, opts) {
-  const bytes = await decryptBytes(keypair, message, opts);
-  return new TextDecoder().decode(bytes);
-}
-__name(decryptToString, "decryptToString");
-async function decryptFromString(keypair, message, opts) {
-  const bytes = fromString2(message, "base64url");
-  const plaintext = await decryptBytes(
-    keypair,
-    bytes,
-    opts?.info !== void 0 ? { info: opts.info } : void 0
-  );
-  return opts?.buffer ? plaintext : new TextDecoder().decode(plaintext);
-}
-__name(decryptFromString, "decryptFromString");
-function validateKeysize(keysize) {
-  if (keysize !== 128 && keysize !== 256) {
-    throw new Error(
-      `invalid keysize: ${keysize} (expected 128 or 256)`
-    );
-  }
-}
-__name(validateKeysize, "validateKeysize");
-function validateRawKeyBytes(raw) {
-  if (raw.length !== 16 && raw.length !== 32) {
-    throw new Error(
-      `invalid aesKey length: ${raw.length} bytes (expected 16 or 32)`
-    );
-  }
-}
-__name(validateRawKeyBytes, "validateRawKeyBytes");
-function normalizeInfo(info) {
-  if (info === void 0 || info === null) return new Uint8Array(0);
-  if (typeof info === "string") return new TextEncoder().encode(info);
-  return info;
-}
-__name(normalizeInfo, "normalizeInfo");
-async function exportAesKeyBytes(key) {
-  if (!key.extractable) {
-    throw new Error(
-      "aesKey must be extractable: its raw bytes are what get sealed"
-    );
-  }
-  return new Uint8Array(await subtle.exportKey("raw", key));
-}
-__name(exportAesKeyBytes, "exportAesKeyBytes");
-async function importAesKey(raw) {
-  return subtle.importKey(
+
+// src/util.ts
+var subtle = globalThis.crypto.subtle;
+async function aeadSeal(key, nonce, plaintext) {
+  const k = await subtle.importKey(
     "raw",
-    raw,
+    key,
     { name: "AES-GCM" },
-    true,
-    ["encrypt", "decrypt"]
+    false,
+    ["encrypt"]
+  );
+  const ct = await subtle.encrypt(
+    { name: "AES-GCM", iv: nonce },
+    k,
+    plaintext
   );
+  return new Uint8Array(ct);
 }
-__name(importAesKey, "importAesKey");
-async function importAesKeyDecryptOnly(raw) {
-  return subtle.importKey(
+__name(aeadSeal, "aeadSeal");
+async function aeadOpen(key, nonce, ciphertext) {
+  const k = await subtle.importKey(
     "raw",
-    raw,
+    key,
     { name: "AES-GCM" },
     false,
     ["decrypt"]
   );
+  const pt = await subtle.decrypt(
+    { name: "AES-GCM", iv: nonce },
+    k,
+    ciphertext
+  );
+  return new Uint8Array(pt);
 }
-__name(importAesKeyDecryptOnly, "importAesKeyDecryptOnly");
-function i2osp(n, len) {
-  const out = new Uint8Array(len);
-  let v = n;
-  for (let i = len - 1; i >= 0; i--) {
-    out[i] = v & 255;
-    v = Math.floor(v / 256);
+__name(aeadOpen, "aeadOpen");
+async function encryptBytes(recipient, message, aesKey, opts) {
+  const plaintext = typeof message === "string" ? new TextEncoder().encode(message) : message;
+  let enc;
+  let key;
+  if (!aesKey) {
+    const keys = await create2(recipient, opts);
+    enc = keys.enc;
+    key = keys.key;
+  } else {
+    const keys = await seal(recipient, aesKey, opts);
+    enc = keys.enc;
+    key = keys.key;
   }
-  return out;
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(NN));
+  const ct = new Uint8Array(await subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    plaintext
+  ));
+  return concat2(i2osp(enc.length, WRAPPED_LEN_PREFIX), enc, iv, ct);
 }
-__name(i2osp, "i2osp");
-function concat2(...arrays) {
-  let total = 0;
-  for (const a of arrays) total += a.length;
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const a of arrays) {
-    out.set(a, offset);
-    offset += a.length;
-  }
-  return out;
+__name(encryptBytes, "encryptBytes");
+async function encryptToString(recipient, message, aesKey, opts) {
+  const envelope = await encryptBytes(recipient, message, aesKey, opts);
+  return toString2(envelope, opts?.encoding ?? "base64url");
 }
-__name(concat2, "concat");
+__name(encryptToString, "encryptToString");
 async function hmac(key, data) {
   const k = await subtle.importKey(
     "raw",
@@ -1664,6 +1559,144 @@ async function decap(enc, keypair) {
   return extractAndExpand(dhBytes, kemContext);
 }
 __name(decap, "decap");
+function i2osp(n, len) {
+  const out = new Uint8Array(len);
+  let v = n;
+  for (let i = len - 1; i >= 0; i--) {
+    out[i] = v & 255;
+    v = Math.floor(v / 256);
+  }
+  return out;
+}
+__name(i2osp, "i2osp");
+function concat2(...arrays) {
+  let total = 0;
+  for (const a of arrays) total += a.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
+  }
+  return out;
+}
+__name(concat2, "concat");
+
+// src/index.ts
+var subtle2 = globalThis.crypto.subtle;
+async function create2(recipient, opts) {
+  const { wrapped, key } = await encryptKey(recipient, null, opts);
+  return { enc: wrapped, key };
+}
+__name(create2, "create");
+async function seal(recipient, aesKey, opts) {
+  const { wrapped, key } = await encryptKey(recipient, aesKey, opts);
+  return { enc: wrapped, key };
+}
+__name(seal, "seal");
+var open = Object.assign(openBytes, {
+  raw: openRawBytes
+});
+var encrypt = Object.assign(encryptBytes, {
+  asString: encryptToString
+});
+var decrypt = Object.assign(decryptBytes, {
+  asString: decryptToString,
+  fromString: decryptFromString
+});
+async function decryptBytes(keypair, message, opts) {
+  if (message.byteLength < WRAPPED_LEN_PREFIX) {
+    throw new Error("malformed message: too short");
+  }
+  const wrappedLen = message[0] << 8 | message[1];
+  const ivStart = WRAPPED_LEN_PREFIX + wrappedLen;
+  const ctStart = ivStart + NN;
+  if (message.byteLength < ctStart + AEAD_TAG_LENGTH) {
+    throw new Error("malformed message: too short");
+  }
+  const wrapped = message.slice(WRAPPED_LEN_PREFIX, ivStart);
+  const iv = message.slice(ivStart, ctStart);
+  const ciphertext = message.slice(ctStart);
+  const keyBytes = await openRawBytes(
+    keypair,
+    wrapped,
+    opts?.info !== void 0 ? { info: opts.info } : void 0
+  );
+  const key = await importAesKeyDecryptOnly(keyBytes);
+  const pt = await subtle2.decrypt(
+    { name: "AES-GCM", iv },
+    key,
+    ciphertext
+  );
+  return new Uint8Array(pt);
+}
+__name(decryptBytes, "decryptBytes");
+async function decryptToString(keypair, message, opts) {
+  const bytes = await decryptBytes(keypair, message, opts);
+  return new TextDecoder().decode(bytes);
+}
+__name(decryptToString, "decryptToString");
+async function decryptFromString(keypair, message, opts) {
+  const bytes = fromString2(message, "base64url");
+  const plaintext = await decryptBytes(
+    keypair,
+    bytes,
+    opts?.info !== void 0 ? { info: opts.info } : void 0
+  );
+  return opts?.buffer ? plaintext : new TextDecoder().decode(plaintext);
+}
+__name(decryptFromString, "decryptFromString");
+function validateKeysize(keysize) {
+  if (keysize !== 128 && keysize !== 256) {
+    throw new Error(
+      `invalid keysize: ${keysize} (expected 128 or 256)`
+    );
+  }
+}
+__name(validateKeysize, "validateKeysize");
+function validateRawKeyBytes(raw) {
+  if (raw.length !== 16 && raw.length !== 32) {
+    throw new Error(
+      `invalid aesKey length: ${raw.length} bytes (expected 16 or 32)`
+    );
+  }
+}
+__name(validateRawKeyBytes, "validateRawKeyBytes");
+function normalizeInfo(info) {
+  if (info === void 0 || info === null) return new Uint8Array(0);
+  if (typeof info === "string") return new TextEncoder().encode(info);
+  return info;
+}
+__name(normalizeInfo, "normalizeInfo");
+async function exportAesKeyBytes(key) {
+  if (!key.extractable) {
+    throw new Error(
+      "aesKey must be extractable: its raw bytes are what get sealed"
+    );
+  }
+  return new Uint8Array(await subtle2.exportKey("raw", key));
+}
+__name(exportAesKeyBytes, "exportAesKeyBytes");
+async function importAesKey(raw) {
+  return subtle2.importKey(
+    "raw",
+    raw,
+    { name: "AES-GCM" },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+__name(importAesKey, "importAesKey");
+async function importAesKeyDecryptOnly(raw) {
+  return subtle2.importKey(
+    "raw",
+    raw,
+    { name: "AES-GCM" },
+    false,
+    ["decrypt"]
+  );
+}
+__name(importAesKeyDecryptOnly, "importAesKeyDecryptOnly");
 async function keySchedule(sharedSecret, info) {
   const empty2 = new Uint8Array(0);
   const pskIdHash = await labeledExtract(
@@ -1702,53 +1735,46 @@ async function keySchedule(sharedSecret, info) {
   return { key, baseNonce };
 }
 __name(keySchedule, "keySchedule");
-async function aeadSeal(key, nonce, plaintext) {
-  const k = await subtle.importKey(
-    "raw",
-    key,
-    { name: "AES-GCM" },
-    false,
-    ["encrypt"]
-  );
-  const ct = await subtle.encrypt(
-    { name: "AES-GCM", iv: nonce },
-    k,
-    plaintext
-  );
-  return new Uint8Array(ct);
-}
-__name(aeadSeal, "aeadSeal");
-async function aeadOpen(key, nonce, ciphertext) {
-  const k = await subtle.importKey(
-    "raw",
-    key,
-    { name: "AES-GCM" },
-    false,
-    ["decrypt"]
-  );
-  const pt = await subtle.decrypt(
-    { name: "AES-GCM", iv: nonce },
-    k,
-    ciphertext
-  );
-  return new Uint8Array(pt);
+async function openRawBytes(keypair, wrapped, opts) {
+  if (wrapped.byteLength < ENC_LENGTH + AEAD_TAG_LENGTH) {
+    throw new Error("malformed envelope: too short");
+  }
+  const info = normalizeInfo(opts?.info);
+  const enc = wrapped.slice(0, ENC_LENGTH);
+  const ciphertext = wrapped.slice(ENC_LENGTH);
+  const sharedSecret = await decap(enc, keypair);
+  const { key, baseNonce } = await keySchedule(sharedSecret, info);
+  return aeadOpen(key, baseNonce, ciphertext);
 }
-__name(aeadOpen, "aeadOpen");
-async function encryptBytes(recipient, message, aesKey, opts) {
-  const plaintext = typeof message === "string" ? new TextEncoder().encode(message) : message;
-  const { wrapped, key } = await seal(recipient, aesKey, opts);
-  const iv = globalThis.crypto.getRandomValues(new Uint8Array(NN));
-  const ct = new Uint8Array(await subtle.encrypt(
-    { name: "AES-GCM", iv },
-    key,
-    plaintext
-  ));
-  return concat2(i2osp(wrapped.length, WRAPPED_LEN_PREFIX), wrapped, iv, ct);
+__name(openRawBytes, "openRawBytes");
+async function openBytes(keypair, wrapped, opts) {
+  const keyBytes = await openRawBytes(keypair, wrapped, opts);
+  return importAesKey(keyBytes);
 }
-__name(encryptBytes, "encryptBytes");
-async function encryptToString(recipient, message, aesKey, opts) {
-  const envelope = await encryptBytes(recipient, message, aesKey, opts);
-  return toString2(envelope, opts?.encoding ?? "base64url");
+__name(openBytes, "openBytes");
+async function encryptKey(recipient, aesKey, opts) {
+  const info = normalizeInfo(opts?.info);
+  let keyBytes;
+  if (aesKey instanceof Uint8Array) {
+    validateRawKeyBytes(aesKey);
+    keyBytes = aesKey;
+  } else if (aesKey) {
+    keyBytes = await exportAesKeyBytes(aesKey);
+    validateRawKeyBytes(keyBytes);
+  } else {
+    const keysize = opts?.size ?? 256;
+    validateKeysize(keysize);
+    keyBytes = globalThis.crypto.getRandomValues(
+      new Uint8Array(keysize / 8)
+    );
+  }
+  const publicKey = await resolveRecipientPublicKey(recipient);
+  const { sharedSecret, enc } = await encap(publicKey);
+  const { key, baseNonce } = await keySchedule(sharedSecret, info);
+  const ciphertext = await aeadSeal(key, baseNonce, keyBytes);
+  const wrapped = concat2(enc, ciphertext);
+  const aesGcmKey = await importAesKey(keyBytes);
+  return { wrapped, key: aesGcmKey };
 }
-__name(encryptToString, "encryptToString");
+__name(encryptKey, "encryptKey");
 //# sourceMappingURL=index.cjs.map