@metalabel/dfos-protocol 0.44.0 → 0.46.0

package/dist/chunk-VEJBAY3T.js

@@ -1,200 +0,0 @@
-import {
-  ED25519_PUB_MULTICODEC,
-  decodeMultikey,
-  encodeEd25519Multikey
-} from "./chunk-IDVYITX7.js";
-import {
-  base64urlDecode,
-  base64urlEncode,
-  importEd25519Keypair,
-  isValidEd25519Signature,
-  signPayloadEd25519
-} from "./chunk-4LG2GEB2.js";
-
-// src/key-proof/key-proof.ts
-var KEY_ADD_JWS_TYP = "did:dfos:key-add";
-var MAX_KEY_PROOF_SIZE = 4096;
-var DEFAULT_KEY_PROOF_SKEW_SECONDS = 300;
-var KeyProofVerifyError = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "KeyProofVerifyError";
-    this.reason = reason;
-  }
-};
-var invalid = (reason, message) => new KeyProofVerifyError(reason, `invalid key proof: ${message}`);
-var encoder = new TextEncoder();
-var KEY_PROOF_MEMBERS = ["nonce", "audience", "publicKeyMultibase", "timestamp"];
-var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
-var WHOLE_SECOND_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.000Z$/;
-var PROTOCOL_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
-var validateKeyProofPayload = (value) => {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw invalid("schema", "expected a JSON object");
-  }
-  const raw = value;
-  for (const member of Object.keys(raw)) {
-    if (!KEY_PROOF_MEMBERS.includes(member)) {
-      throw invalid("schema", `unknown member ${JSON.stringify(member)} \u2014 the payload is closed`);
-    }
-  }
-  for (const member of KEY_PROOF_MEMBERS) {
-    if (typeof raw[member] !== "string" || raw[member] === "") {
-      throw invalid("schema", `${member} must be a non-empty string`);
-    }
-    if (LONE_SURROGATE.test(raw[member])) {
-      throw invalid("schema", `${member} must be well-formed Unicode`);
-    }
-  }
-  const nonce = raw["nonce"];
-  const audience = raw["audience"];
-  const publicKeyMultibase = raw["publicKeyMultibase"];
-  const timestamp = raw["timestamp"];
-  if (audience !== audience.toLowerCase() || /[\s/\\?#]/.test(audience)) {
-    throw invalid("schema", "audience must be a lowercase authority, without a scheme or path");
-  }
-  const parsedMs = WHOLE_SECOND_TIMESTAMP.test(timestamp) ? Date.parse(timestamp) : Number.NaN;
-  if (!Number.isFinite(parsedMs) || new Date(parsedMs).toISOString() !== timestamp) {
-    throw invalid("schema", "timestamp must be ISO-8601 UTC whole-second .000Z");
-  }
-  return { nonce, audience, publicKeyMultibase, timestamp };
-};
-var keyProofSigningInput = (payload) => encoder.encode(JSON.stringify(keyProofPayloadObject(validateKeyProofPayload(payload))));
-var keyProofPayloadObject = (payload) => ({
-  nonce: payload.nonce,
-  audience: payload.audience,
-  publicKeyMultibase: payload.publicKeyMultibase,
-  timestamp: payload.timestamp
-});
-var bytesEqual = (a, b) => a.length === b.length && a.every((byte, index) => byte === b[index]);
-var normalizeTimestamp = (ms) => new Date(Math.floor(ms / 1e3) * 1e3).toISOString();
-var signKeyProof = async (input) => {
-  if (input.typ === "") {
-    throw new Error("invalid key proof: typ must be a registered purpose value");
-  }
-  const { publicKey } = importEd25519Keypair(input.privateKey);
-  let timestamp;
-  if (input.timestamp === void 0) {
-    timestamp = normalizeTimestamp(input.now ? input.now() : Date.now());
-  } else {
-    const ms = Date.parse(input.timestamp);
-    if (!PROTOCOL_TIMESTAMP.test(input.timestamp) || !Number.isFinite(ms) || new Date(ms).toISOString() !== input.timestamp) {
-      throw new Error(`invalid key proof: unparseable timestamp: ${input.timestamp}`);
-    }
-    timestamp = normalizeTimestamp(ms);
-  }
-  const payload = validateKeyProofPayload({
-    nonce: input.nonce,
-    audience: input.audience,
-    publicKeyMultibase: encodeEd25519Multikey(publicKey),
-    timestamp
-  });
-  const headerB64 = base64urlEncode(JSON.stringify({ alg: "EdDSA", typ: input.typ }));
-  const payloadB64 = base64urlEncode(keyProofSigningInput(payload));
-  const signingInput = `${headerB64}.${payloadB64}`;
-  const signature = signPayloadEd25519(encoder.encode(signingInput), input.privateKey);
-  const proof = `${signingInput}.${base64urlEncode(signature)}`;
-  if (proof.length > MAX_KEY_PROOF_SIZE) {
-    throw new Error(`key proof exceeds max size: ${proof.length} > ${MAX_KEY_PROOF_SIZE}`);
-  }
-  return { proof, payload };
-};
-var verifyKeyProof = (jws, options) => {
-  if (options.expectedTyp === "") {
-    throw new Error("invalid key proof verifier: expectedTyp must be a registered purpose value");
-  }
-  const maxSkew = options.maxSkewSeconds ?? DEFAULT_KEY_PROOF_SKEW_SECONDS;
-  if (!Number.isSafeInteger(maxSkew) || maxSkew < 0) {
-    throw new Error("invalid key proof verifier: maxSkewSeconds must be a non-negative integer");
-  }
-  if (jws.length > MAX_KEY_PROOF_SIZE) {
-    throw invalid("size", `envelope exceeds max size: ${jws.length} > ${MAX_KEY_PROOF_SIZE}`);
-  }
-  const parts = jws.split(".");
-  if (parts.length !== 3) throw invalid("header", "failed to decode JWS");
-  const [headerB64, payloadB64] = parts;
-  let header;
-  try {
-    const decoded = JSON.parse(
-      new TextDecoder("utf-8", { fatal: true }).decode(base64urlDecode(headerB64))
-    );
-    if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) {
-      throw new Error("protected header must be an object");
-    }
-    header = decoded;
-  } catch (err) {
-    throw invalid("header", err instanceof Error ? err.message : "failed to decode header");
-  }
-  if (header["alg"] !== "EdDSA") {
-    throw invalid("header", `unsupported algorithm: ${String(header["alg"])}`);
-  }
-  if ("crit" in header) throw invalid("header", "crit header is not supported");
-  for (const member of ["jwk", "jku", "x5c", "x5u"]) {
-    if (member in header) {
-      throw invalid("header", `${member} header is not allowed (the key rides in the payload)`);
-    }
-  }
-  if ("kid" in header) {
-    throw invalid("header", "kid must be absent \u2014 the candidate key is in no chain");
-  }
-  const typ = header["typ"];
-  if (typeof typ !== "string" || typ !== options.expectedTyp) {
-    throw invalid("header", `invalid typ: expected ${options.expectedTyp}, got ${String(typ)}`);
-  }
-  let payload;
-  try {
-    const payloadBytes = base64urlDecode(payloadB64);
-    const source = new TextDecoder("utf-8", { fatal: true }).decode(payloadBytes);
-    payload = validateKeyProofPayload(JSON.parse(source));
-    if (!bytesEqual(keyProofSigningInput(payload), payloadBytes)) {
-      throw invalid("schema", "payload is not the canonical signing input for its members");
-    }
-  } catch (err) {
-    if (err instanceof KeyProofVerifyError) throw err;
-    throw invalid("schema", err instanceof Error ? err.message : "payload is not valid UTF-8 JSON");
-  }
-  if (payload.audience !== options.expectedAudience) {
-    throw invalid("audience", "audience does not match this verifier authority");
-  }
-  const now = Math.floor((options.now ? options.now() : Date.now()) / 1e3);
-  const issued = Math.floor(Date.parse(payload.timestamp) / 1e3);
-  if (Math.abs(now - issued) > maxSkew) {
-    throw invalid("freshness", "timestamp is outside the acceptance window");
-  }
-  let keyBytes;
-  try {
-    const decoded = decodeMultikey(payload.publicKeyMultibase);
-    if (decoded.codec !== ED25519_PUB_MULTICODEC) {
-      throw new Error("publicKeyMultibase is not an Ed25519 public key");
-    }
-    keyBytes = decoded.keyBytes;
-  } catch (err) {
-    throw invalid(
-      "signature",
-      err instanceof Error ? err.message : "undecodable publicKeyMultibase"
-    );
-  }
-  let verified = false;
-  try {
-    verified = isValidEd25519Signature(
-      encoder.encode(`${headerB64}.${payloadB64}`),
-      base64urlDecode(parts[2]),
-      keyBytes
-    );
-  } catch {
-    verified = false;
-  }
-  if (!verified) throw invalid("signature", "signature does not verify against publicKeyMultibase");
-  return { payload, typ, now };
-};
-
-export {
-  KEY_ADD_JWS_TYP,
-  MAX_KEY_PROOF_SIZE,
-  DEFAULT_KEY_PROOF_SKEW_SECONDS,
-  KeyProofVerifyError,
-  keyProofSigningInput,
-  signKeyProof,
-  verifyKeyProof
-};