@byok-sdk/core 0.30.1 → 0.30.2

package/dist/sealed-payload/index.d.ts

@@ -10,7 +10,7 @@
 export { SEALED_CATEGORIES, SEALED_CONTENT_SUITE, SEALED_CONTENT_VERSION, SEALED_DIRECTIONS, SealedContentHeaderV1Schema, openSealedContent, sealContent, } from './sealed-content';
 export type { OpenSealedContentInput, SealContentInput, SealedBinding, SealedCategory, SealedContent, SealedContentHeaderV1, SealedContentOpenFailure, SealedContentOpenResult, SealedDirection, SealedScopePolicy, } from './sealed-content';
 export { deriveScopeKeyId, generateScopeKey, openScopeKeyPackage, sealScopeKeyPackage } from './scope-key';
-export type { OpenScopeKeyPackageInput, ScopeKeyPackageOpenResult, ScopeKeyPackageV1, SealScopeKeyPackageInput, } from './scope-key';
+export type { OpenScopeKeyPackageInput, ScopeKeyPackage, ScopeKeyPackageOpenResult, ScopeKeyPackageV1, ScopeKeyPackageV2, SealScopeKeyPackageInput, } from './scope-key';
 export { MEMBER_CHAIN_OPS, deriveMemberId, memberChainEntryHash, signMemberChainEntry, verifyMemberChainEntry, } from './member-chain';
 export type { MemberChainEntryV1, MemberChainEntryVerifyResult, MemberChainOp, UnsignedMemberChainEntryV1, } from './member-chain';
 export { MEMBER_KEY_BUNDLE_VERSION, createMemberKeyBundle, parseMemberKeyBundle, verifyMemberKem } from './member-bundle';

package/dist/sealed-payload/index.js

@@ -679,6 +679,87 @@ async function verifyMemberChainEntry(entry, signerPublicJwk) {
   }
   return { ok: true, entry: parsed.data, hash: `sha256:${hex(await sha256(input))}` };
 }
+var MEMBER_KEY_BUNDLE_VERSION = 1;
+var MEMBER_KEM_DOMAIN_PREFIX = "byok-member-kem-v1\n";
+var KemEpochSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var KemSigSchema = base64UrlBytes(64);
+var MemberKeyBundleV1Schema = z.strictObject({
+  v: z.literal(MEMBER_KEY_BUNDLE_VERSION),
+  memberId: z.string().regex(MEMBER_ID_PATTERN),
+  signingPublicJwk: P256PublicJwkSchema,
+  kemPublicJwk: P256PublicJwkSchema,
+  kemEpoch: KemEpochSchema,
+  kemSig: KemSigSchema,
+  deviceId: z.string().min(1).optional()
+});
+var CreateInputSchema = z.object({
+  signingPublicJwk: P256PublicJwkSchema,
+  signingPrivateKey: z.custom(),
+  kemPublicJwk: P256PublicJwkSchema,
+  kemEpoch: KemEpochSchema,
+  deviceId: z.string().min(1).optional()
+});
+var KemSignerSchema = z.object({ memberId: z.string().regex(MEMBER_ID_PATTERN), signingPublicJwk: P256PublicJwkSchema });
+var KemStatementSchema = z.object({ kemPublicJwk: P256PublicJwkSchema, kemEpoch: KemEpochSchema, kemSig: KemSigSchema });
+function memberKemSigningInput(memberId, kemPublicJwk, kemEpoch) {
+  return concat2(
+    utf82(MEMBER_KEM_DOMAIN_PREFIX),
+    canonicalizeJsonBytes({ memberId, kemPublicKey: { x: kemPublicJwk.x, y: kemPublicJwk.y }, kemEpoch })
+  );
+}
+async function createMemberKeyBundle(input) {
+  const parsed = safeParseTotal(CreateInputSchema, input);
+  if (!parsed.success) throw invalidInput("Member key bundle input is invalid");
+  const { signingPublicJwk, signingPrivateKey, kemPublicJwk, kemEpoch, deviceId } = parsed.data;
+  const memberId = await deriveMemberId(signingPublicJwk);
+  if (!await isValidMemberKemKey(kemPublicJwk, signingPublicJwk)) throw invalidInput("Member KEM key is invalid");
+  const kemSig = await ecdsaSign(signingPublicJwk, signingPrivateKey, memberKemSigningInput(memberId, kemPublicJwk, kemEpoch));
+  return {
+    v: MEMBER_KEY_BUNDLE_VERSION,
+    memberId,
+    signingPublicJwk,
+    kemPublicJwk,
+    kemEpoch,
+    kemSig,
+    ...deviceId === void 0 ? {} : { deviceId }
+  };
+}
+async function isValidMemberKemKey(kemPublicJwk, signingPublicJwk) {
+  if (kemPublicJwk.x === signingPublicJwk.x && kemPublicJwk.y === signingPublicJwk.y) return false;
+  try {
+    await p256PublicKeyBytes(kemPublicJwk);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function verifyMemberKem(member, kem) {
+  const signer = safeParseTotal(KemSignerSchema, member);
+  const statement = safeParseTotal(KemStatementSchema, kem);
+  if (!signer.success || !statement.success) return false;
+  const { memberId, signingPublicJwk } = signer.data;
+  const { kemPublicJwk, kemEpoch, kemSig } = statement.data;
+  if (!await isValidMemberKemKey(kemPublicJwk, signingPublicJwk)) return false;
+  try {
+    return await ecdsaVerify(signingPublicJwk, kemSig, memberKemSigningInput(memberId, kemPublicJwk, kemEpoch));
+  } catch {
+    return false;
+  }
+}
+async function parseMemberKeyBundle(value) {
+  const parsed = safeParseTotal(MemberKeyBundleV1Schema, value);
+  if (!parsed.success) return void 0;
+  const bundle = parsed.data;
+  try {
+    if (await deriveMemberId(bundle.signingPublicJwk) !== bundle.memberId) return void 0;
+  } catch {
+    return void 0;
+  }
+  if (!await verifyMemberKem(bundle, bundle)) return void 0;
+  return bundle;
+}
+
+// src/sealed-payload/scope-key.ts
 var SCOPE_KEY_BYTES = 32;
 var SCOPE_KEY_ID_PATTERN = /^[A-Za-z0-9_-]{22}$/u;
 var KEY_ID_MESSAGE = "byok-scope-key-id-v1";
@@ -688,6 +769,9 @@ var SEALED_SALT_BYTES = 32;
 var SCOPE_KEY_PACKAGE_VERSION = 1;
 var SCOPE_KEY_HPKE_INFO = "byok-sdk.scope-key.v1";
 var SCOPE_KEY_PACKAGE_DOMAIN_PREFIX = "byok-scope-key-package-v1\n";
+var SCOPE_KEY_PACKAGE_V2 = 2;
+var SCOPE_KEY_HPKE_INFO_V2 = "byok-sdk.scope-key.v2";
+var SCOPE_KEY_PACKAGE_V2_DOMAIN_PREFIX = "byok-scope-key-package-v2\n";
 var P256_POINT_BYTES = 65;
 var AEAD_TAG_BYTES = 16;
 function assertScopeKey(scopeKey) {
@@ -722,49 +806,35 @@ var ScopeKeyPackageV1Schema = z.strictObject({
   ciphertext: base64UrlBytes(SCOPE_KEY_BYTES + AEAD_TAG_BYTES),
   sig: base64UrlBytes(64)
 });
-function packageAad(identity) {
-  return canonicalizeJsonBytes({
-    v: identity.v,
-    tenantId: identity.tenantId,
-    scopeId: identity.scopeId,
-    epoch: identity.epoch,
-    keyId: identity.keyId,
-    recipient: identity.recipient,
-    sender: identity.sender
-  });
+var ScopeKeyPackageV2Schema = z.strictObject({
+  ...ScopeKeyPackageV1Schema.shape,
+  v: z.literal(SCOPE_KEY_PACKAGE_V2),
+  recipientKemEpoch: KemEpochSchema
+});
+var ScopeKeyPackageSchema = z.union([ScopeKeyPackageV1Schema, ScopeKeyPackageV2Schema]);
+function packageAad({ enc: _enc, ciphertext: _ciphertext, sig: _sig, ...identity }) {
+  return canonicalizeJsonBytes(identity);
 }
-function packageSigningInput(pkg) {
-  return concat2(
-    utf82(SCOPE_KEY_PACKAGE_DOMAIN_PREFIX),
-    canonicalizeJsonBytes({
-      v: pkg.v,
-      tenantId: pkg.tenantId,
-      scopeId: pkg.scopeId,
-      epoch: pkg.epoch,
-      keyId: pkg.keyId,
-      recipient: pkg.recipient,
-      sender: pkg.sender,
-      enc: pkg.enc,
-      ciphertext: pkg.ciphertext
-    })
-  );
+function packageSigningInput({ sig: _sig, ...pkg }) {
+  return concat2(utf82(pkg.v === SCOPE_KEY_PACKAGE_V2 ? SCOPE_KEY_PACKAGE_V2_DOMAIN_PREFIX : SCOPE_KEY_PACKAGE_DOMAIN_PREFIX), canonicalizeJsonBytes(pkg));
 }
-var PackageIdentitySchema = ScopeKeyPackageV1Schema.omit({ enc: true, ciphertext: true, sig: true });
+var PackageIdentitySchema = ScopeKeyPackageV2Schema.omit({ enc: true, ciphertext: true, sig: true });
 async function sealScopeKeyPackage(input) {
   const parsed = safeParseTotal(PackageIdentitySchema, {
-    v: SCOPE_KEY_PACKAGE_VERSION,
+    v: SCOPE_KEY_PACKAGE_V2,
     tenantId: input.tenantId,
     scopeId: input.scopeId,
     epoch: input.epoch,
     keyId: await deriveScopeKeyId(input.scopeKey),
     recipient: input.recipient.memberId,
+    recipientKemEpoch: input.recipient.kemEpoch,
     sender: await deriveMemberId(input.sender.signingPublicJwk)
   });
   if (!parsed.success) throw invalidInput("Scope key package input is invalid");
   const identity = parsed.data;
   const { enc, ciphertext } = await hpkeSealBase({
     recipientPublicKey: await p256PublicKeyBytes(input.recipient.kemPublicJwk),
-    info: utf82(SCOPE_KEY_HPKE_INFO),
+    info: utf82(SCOPE_KEY_HPKE_INFO_V2),
     aad: packageAad(identity),
     plaintext: input.scopeKey
   });
@@ -772,10 +842,10 @@ async function sealScopeKeyPackage(input) {
   return { ...unsigned, sig: await ecdsaSign(input.sender.signingPublicJwk, input.sender.signingPrivateKey, packageSigningInput(unsigned)) };
 }
 async function openScopeKeyPackage(input) {
-  const parsed = safeParseTotal(ScopeKeyPackageV1Schema, input.package);
+  const parsed = safeParseTotal(ScopeKeyPackageSchema, input.package);
   if (!parsed.success) return { ok: false, reason: "key_package_invalid" };
   const pkg = parsed.data;
-  if (pkg.recipient !== input.recipient.memberId || pkg.tenantId !== input.expected.tenantId || pkg.scopeId !== input.expected.scopeId || pkg.epoch !== input.expected.epoch || pkg.sender !== await deriveMemberId(input.senderSigningPublicJwk)) {
+  if (pkg.recipient !== input.recipient.memberId || pkg.v === SCOPE_KEY_PACKAGE_V2 && pkg.recipientKemEpoch !== input.recipient.kemEpoch || pkg.tenantId !== input.expected.tenantId || pkg.scopeId !== input.expected.scopeId || pkg.epoch !== input.expected.epoch || pkg.sender !== await deriveMemberId(input.senderSigningPublicJwk)) {
     return { ok: false, reason: "key_package_invalid" };
   }
   if (!await ecdsaVerify(input.senderSigningPublicJwk, pkg.sig, packageSigningInput(pkg))) {
@@ -787,7 +857,7 @@ async function openScopeKeyPackage(input) {
       recipientPrivateKey: input.recipient.kemPrivateKey,
       recipientPublicKey: await p256PublicKeyBytes(input.recipient.kemPublicJwk),
       enc: decodeBase64Url(pkg.enc, "enc"),
-      info: utf82(SCOPE_KEY_HPKE_INFO),
+      info: utf82(pkg.v === SCOPE_KEY_PACKAGE_V2 ? SCOPE_KEY_HPKE_INFO_V2 : SCOPE_KEY_HPKE_INFO),
       aad: packageAad(pkg),
       ciphertext: decodeBase64Url(pkg.ciphertext, "ciphertext")
     });
@@ -1086,85 +1156,6 @@ async function openSealedContent(input) {
     frame.fill(0);
   }
 }
-var MEMBER_KEY_BUNDLE_VERSION = 1;
-var MEMBER_KEM_DOMAIN_PREFIX = "byok-member-kem-v1\n";
-var KemEpochSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-var KemSigSchema = base64UrlBytes(64);
-var MemberKeyBundleV1Schema = z.strictObject({
-  v: z.literal(MEMBER_KEY_BUNDLE_VERSION),
-  memberId: z.string().regex(MEMBER_ID_PATTERN),
-  signingPublicJwk: P256PublicJwkSchema,
-  kemPublicJwk: P256PublicJwkSchema,
-  kemEpoch: KemEpochSchema,
-  kemSig: KemSigSchema,
-  deviceId: z.string().min(1).optional()
-});
-var CreateInputSchema = z.object({
-  signingPublicJwk: P256PublicJwkSchema,
-  signingPrivateKey: z.custom(),
-  kemPublicJwk: P256PublicJwkSchema,
-  kemEpoch: KemEpochSchema,
-  deviceId: z.string().min(1).optional()
-});
-var KemSignerSchema = z.object({ memberId: z.string().regex(MEMBER_ID_PATTERN), signingPublicJwk: P256PublicJwkSchema });
-var KemStatementSchema = z.object({ kemPublicJwk: P256PublicJwkSchema, kemEpoch: KemEpochSchema, kemSig: KemSigSchema });
-function memberKemSigningInput(memberId, kemPublicJwk, kemEpoch) {
-  return concat2(
-    utf82(MEMBER_KEM_DOMAIN_PREFIX),
-    canonicalizeJsonBytes({ memberId, kemPublicKey: { x: kemPublicJwk.x, y: kemPublicJwk.y }, kemEpoch })
-  );
-}
-async function createMemberKeyBundle(input) {
-  const parsed = safeParseTotal(CreateInputSchema, input);
-  if (!parsed.success) throw invalidInput("Member key bundle input is invalid");
-  const { signingPublicJwk, signingPrivateKey, kemPublicJwk, kemEpoch, deviceId } = parsed.data;
-  const memberId = await deriveMemberId(signingPublicJwk);
-  if (!await isValidMemberKemKey(kemPublicJwk, signingPublicJwk)) throw invalidInput("Member KEM key is invalid");
-  const kemSig = await ecdsaSign(signingPublicJwk, signingPrivateKey, memberKemSigningInput(memberId, kemPublicJwk, kemEpoch));
-  return {
-    v: MEMBER_KEY_BUNDLE_VERSION,
-    memberId,
-    signingPublicJwk,
-    kemPublicJwk,
-    kemEpoch,
-    kemSig,
-    ...deviceId === void 0 ? {} : { deviceId }
-  };
-}
-async function isValidMemberKemKey(kemPublicJwk, signingPublicJwk) {
-  if (kemPublicJwk.x === signingPublicJwk.x && kemPublicJwk.y === signingPublicJwk.y) return false;
-  try {
-    await p256PublicKeyBytes(kemPublicJwk);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function verifyMemberKem(member, kem) {
-  const signer = safeParseTotal(KemSignerSchema, member);
-  const statement = safeParseTotal(KemStatementSchema, kem);
-  if (!signer.success || !statement.success) return false;
-  const { memberId, signingPublicJwk } = signer.data;
-  const { kemPublicJwk, kemEpoch, kemSig } = statement.data;
-  if (!await isValidMemberKemKey(kemPublicJwk, signingPublicJwk)) return false;
-  try {
-    return await ecdsaVerify(signingPublicJwk, kemSig, memberKemSigningInput(memberId, kemPublicJwk, kemEpoch));
-  } catch {
-    return false;
-  }
-}
-async function parseMemberKeyBundle(value) {
-  const parsed = safeParseTotal(MemberKeyBundleV1Schema, value);
-  if (!parsed.success) return void 0;
-  const bundle = parsed.data;
-  try {
-    if (await deriveMemberId(bundle.signingPublicJwk) !== bundle.memberId) return void 0;
-  } catch {
-    return void 0;
-  }
-  if (!await verifyMemberKem(bundle, bundle)) return void 0;
-  return bundle;
-}
 var MEMBER_KEY_RECORD_VERSION = 1;
 var PrivateJwkSchema = z.strictObject({
   kty: z.literal("EC"),