@byok-sdk/core 0.30.0 → 0.30.1

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

@@ -15,6 +15,8 @@ export { MEMBER_CHAIN_OPS, deriveMemberId, memberChainEntryHash, signMemberChain
 export type { MemberChainEntryV1, MemberChainEntryVerifyResult, MemberChainOp, UnsignedMemberChainEntryV1, } from './member-chain';
 export { MEMBER_KEY_BUNDLE_VERSION, createMemberKeyBundle, parseMemberKeyBundle, verifyMemberKem } from './member-bundle';
 export type { CreateMemberKeyBundleInput, MemberKeyBundleV1 } from './member-bundle';
+export { beginMemberKemRotation, finishMemberKemRotation, generateMemberKeyRecord, openMemberKeyRecord, } from './member-key-record';
+export type { MemberKemKey, MemberKeyBinding, MemberKeyStore, MemberKeys } from './member-key-record';
 export { MEMBER_FINGERPRINT_DOMAIN, memberApprovalCode, memberFingerprint } from './member-fingerprint';
 export type { MemberFingerprintInput } from './member-fingerprint';
 export { CLIENT_PAIRING_MAC_DOMAIN, DEVICE_PAIRING_MAC_DOMAIN, PAIRING_VERIFICATION_SECRET_BYTES, computeClientPairingMac, computeDevicePairingMac, decodePairingVerificationSecret, encodePairingVerificationSecret, formatPairingInput, generatePairingVerificationSecret, parsePairingInput, verifyClientPairingMac, verifyDevicePairingMac, } from './pairing-verification';

package/dist/sealed-payload/index.js

@@ -1165,6 +1165,115 @@ async function parseMemberKeyBundle(value) {
   if (!await verifyMemberKem(bundle, bundle)) return void 0;
   return bundle;
 }
+var MEMBER_KEY_RECORD_VERSION = 1;
+var PrivateJwkSchema = z.strictObject({
+  kty: z.literal("EC"),
+  crv: z.literal("P-256"),
+  x: base64UrlBytes(32),
+  y: base64UrlBytes(32),
+  d: base64UrlBytes(32)
+});
+var KemEpochSchema2 = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var MemberKeyRecordV1Schema = z.strictObject({
+  v: z.literal(MEMBER_KEY_RECORD_VERSION),
+  tenantId: z.string().min(1),
+  deviceId: z.string().min(1).optional(),
+  signingJwk: PrivateJwkSchema,
+  kemEpoch: KemEpochSchema2,
+  kemJwk: PrivateJwkSchema,
+  nextKem: z.strictObject({ epoch: KemEpochSchema2, jwk: PrivateJwkSchema }).optional()
+}).refine((record) => record.nextKem === void 0 || record.nextKem.epoch === record.kemEpoch + 1);
+var BindingSchema = z.object({ tenantId: z.string().min(1), deviceId: z.string().min(1).optional() });
+function keySubtle() {
+  return webCryptoSubtle();
+}
+var ECDSA_P2562 = { name: "ECDSA", namedCurve: "P-256" };
+var ECDSA_SHA2562 = { name: "ECDSA", hash: "SHA-256" };
+var ECDH_P256 = { name: "ECDH", namedCurve: "P-256" };
+async function generatePrivateJwk(algorithm, usages) {
+  const pair = await keySubtle().generateKey(algorithm, true, usages);
+  const { kty, crv, x, y, d } = await keySubtle().exportKey("jwk", pair.privateKey);
+  return PrivateJwkSchema.parse({ kty, crv, x, y, d });
+}
+async function generateMemberKeyRecord(binding) {
+  const parsed = safeParseTotal(BindingSchema, binding);
+  if (!parsed.success) throw invalidInput("Member key binding is invalid");
+  const { tenantId, deviceId } = parsed.data;
+  return canonicalizeJson({
+    v: MEMBER_KEY_RECORD_VERSION,
+    tenantId,
+    ...deviceId === void 0 ? {} : { deviceId },
+    signingJwk: await generatePrivateJwk(ECDSA_P2562, ["sign", "verify"]),
+    kemEpoch: 1,
+    kemJwk: await generatePrivateJwk(ECDH_P256, ["deriveBits"])
+  });
+}
+function publicJwkOf(jwk) {
+  return P256PublicJwkSchema.parse({ kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y });
+}
+function bytesEqual(left, right) {
+  const a = new Uint8Array(left);
+  const b = new Uint8Array(right);
+  return a.length === b.length && a.every((byte, index) => byte === b[index]);
+}
+async function importSigningKey(jwk) {
+  const subtle = keySubtle();
+  const publicJwk = publicJwkOf(jwk);
+  const privateKey = await subtle.importKey("jwk", { ...jwk, ext: false }, ECDSA_P2562, false, ["sign"]);
+  const publicKey = await subtle.importKey("jwk", publicJwk, ECDSA_P2562, true, ["verify"]);
+  const probe = randomBytes(32);
+  if (!await subtle.verify(ECDSA_SHA2562, publicKey, await subtle.sign(ECDSA_SHA2562, privateKey, probe), probe)) {
+    throw new TypeError("signing scalar does not match its public point");
+  }
+  return { publicJwk, privateKey };
+}
+async function importKemKey(jwk) {
+  const subtle = keySubtle();
+  const publicJwk = publicJwkOf(jwk);
+  const privateKey = await subtle.importKey("jwk", { ...jwk, ext: false }, ECDH_P256, false, ["deriveBits"]);
+  const publicKey = await subtle.importKey("jwk", publicJwk, ECDH_P256, true, []);
+  const probe = await subtle.generateKey(ECDH_P256, false, ["deriveBits"]);
+  const viaMember = await subtle.deriveBits({ name: "ECDH", public: probe.publicKey }, privateKey, 256);
+  const viaProbe = await subtle.deriveBits({ name: "ECDH", public: publicKey }, probe.privateKey, 256);
+  if (!bytesEqual(viaMember, viaProbe)) throw new TypeError("KEM scalar does not match its public point");
+  return { publicJwk, privateKey };
+}
+async function openMemberKeyRecord(text) {
+  const record = parseRecord(text);
+  if (record === void 0) return void 0;
+  try {
+    const signing = await importSigningKey(record.signingJwk);
+    const kem = { epoch: record.kemEpoch, ...await importKemKey(record.kemJwk) };
+    const binding = record.deviceId === void 0 ? { tenantId: record.tenantId } : { tenantId: record.tenantId, deviceId: record.deviceId };
+    if (record.nextKem === void 0) return { binding, signing, kem };
+    return { binding, signing, kem, nextKem: { epoch: record.nextKem.epoch, ...await importKemKey(record.nextKem.jwk) } };
+  } catch {
+    return void 0;
+  }
+}
+async function beginMemberKemRotation(text) {
+  const record = parseRecord(text);
+  if (record === void 0) throw invalidInput("Member key record is invalid");
+  if (record.nextKem !== void 0) return text;
+  return canonicalizeJson({ ...record, nextKem: { epoch: record.kemEpoch + 1, jwk: await generatePrivateJwk(ECDH_P256, ["deriveBits"]) } });
+}
+function finishMemberKemRotation(text, epoch) {
+  const record = parseRecord(text);
+  if (record === void 0) throw invalidInput("Member key record is invalid");
+  if (record.nextKem === void 0) return record.kemEpoch === epoch ? text : void 0;
+  if (record.nextKem.epoch !== epoch) return void 0;
+  const { nextKem, ...rest } = record;
+  return canonicalizeJson({ ...rest, kemEpoch: nextKem.epoch, kemJwk: nextKem.jwk });
+}
+function parseRecord(text) {
+  if (typeof text !== "string") return void 0;
+  try {
+    const parsed = safeParseTotal(MemberKeyRecordV1Schema, JSON.parse(text));
+    return parsed.success && canonicalizeJson(parsed.data) === text ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
 var MEMBER_FINGERPRINT_DOMAIN = "byok-member-fingerprint-v1\n";
 var FINGERPRINT_GROUPS = 5;
 var GROUP_BYTES = 5;
@@ -1481,6 +1590,6 @@ async function verifyMemberChainFromAnchor(input) {
   return { ok: true, state: outcome.state, anchorSeq: anchor.seq };
 }
 
-export { CLIENT_PAIRING_MAC_DOMAIN, DEVICE_PAIRING_MAC_DOMAIN, MEMBER_CHAIN_OPS, MEMBER_FINGERPRINT_DOMAIN, MEMBER_KEY_BUNDLE_VERSION, PAIRING_VERIFICATION_SECRET_BYTES, SEALED_CATEGORIES, SEALED_CONTENT_SUITE, SEALED_CONTENT_VERSION, SEALED_DIRECTIONS, SealedContentHeaderV1Schema, applyMemberChainEntries, computeClientPairingMac, computeDevicePairingMac, createMemberKeyBundle, decodePairingVerificationSecret, deriveMemberId, deriveScopeKeyId, emptyMemberChainState, encodePairingVerificationSecret, formatPairingInput, generatePairingVerificationSecret, generateScopeKey, memberApprovalCode, memberChainEntryHash, memberChainScopeRecipients, memberFingerprint, openScopeKeyPackage, openSealedContent, parseMemberKeyBundle, parsePairingInput, sealContent, sealScopeKeyPackage, signMemberChainEntry, verifyClientPairingMac, verifyDevicePairingMac, verifyMemberChainEntry, verifyMemberChainFromAnchor, verifyMemberKem };
+export { CLIENT_PAIRING_MAC_DOMAIN, DEVICE_PAIRING_MAC_DOMAIN, MEMBER_CHAIN_OPS, MEMBER_FINGERPRINT_DOMAIN, MEMBER_KEY_BUNDLE_VERSION, PAIRING_VERIFICATION_SECRET_BYTES, SEALED_CATEGORIES, SEALED_CONTENT_SUITE, SEALED_CONTENT_VERSION, SEALED_DIRECTIONS, SealedContentHeaderV1Schema, applyMemberChainEntries, beginMemberKemRotation, computeClientPairingMac, computeDevicePairingMac, createMemberKeyBundle, decodePairingVerificationSecret, deriveMemberId, deriveScopeKeyId, emptyMemberChainState, encodePairingVerificationSecret, finishMemberKemRotation, formatPairingInput, generateMemberKeyRecord, generatePairingVerificationSecret, generateScopeKey, memberApprovalCode, memberChainEntryHash, memberChainScopeRecipients, memberFingerprint, openMemberKeyRecord, openScopeKeyPackage, openSealedContent, parseMemberKeyBundle, parsePairingInput, sealContent, sealScopeKeyPackage, signMemberChainEntry, verifyClientPairingMac, verifyDevicePairingMac, verifyMemberChainEntry, verifyMemberChainFromAnchor, verifyMemberKem };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map