burnledger 0.8.1 → 0.9.0

package/src/enclave-registration.ts

@@ -0,0 +1,390 @@
+/**
+ * The customer's side of ADR-025: verify the enclave, enrol a key group, rotate
+ * it, register a system under it.
+ *
+ * Request-building and response-checking for the BurnLedger client's methods of
+ * the same names, kept in a Node-only module the client imports lazily — the
+ * client is also the browser entry's, and these need node:crypto. Nothing here
+ * holds a private key: every signature comes from a {@link KeyGroupSigner} (see
+ * key-group.ts for why, and for what losing a key costs).
+ *
+ * WHAT THE CHECKS ON EACH RESPONSE ARE FOR. The API relays every byte, so the
+ * documents it returns are only worth what the client checks, and it checks two
+ * things. First, that the enclave signed them — under the signing key of an
+ * enclave the caller attested against its own pinned PCR0. Without that, a relay
+ * could hand the customer a forged enrolment and they would believe themselves
+ * registered when nothing was. The key set at /.well-known/burnledger-keys is not
+ * the anchor for this: the same API serves it, so a relay that forged a document
+ * could publish the forging key beside it. Second, that they are about what the
+ * caller asked for. ADR-025 §2 names the load-bearing comparison: the enrolment
+ * statement must name the key group the customer generated. A relay that enrolled
+ * its own group instead would hand back a genuine, enclave-signed statement
+ * naming a key the customer does not hold; this comparison is where that stops
+ * being invisible. The enrolment and the authorization must also be for the team
+ * the customer named, and the authorization must end exactly at the `not_after`
+ * the customer signed and not start in the future: a relay that replayed an
+ * older genuine answer, or another team's, would otherwise have the caller
+ * believe a fresh window exists. The registration must name this key, this
+ * system, this config digest and this connector, or it registered something
+ * else.
+ */
+
+import { createHash, webcrypto } from "node:crypto";
+import { nodeCrypto } from "./crypto-node.js";
+import {
+  buildKeyEnrollmentRequestPayload,
+  buildKeyRotationRequestPayload,
+  buildSystemRegistrationRequestPayload,
+  customerKeyId,
+  keyTime,
+  verifyKeyEnrollmentStatement,
+  verifySystemRegistration,
+  verifyTeamAuthorization,
+  type CustomerKeyGroup,
+} from "./customer-keys.js";
+import {
+  IDENTITY_NONCE_SIZE,
+  verifyEnclaveIdentity,
+  type EnclaveIdentity,
+  type SealOptions,
+} from "./enclave-seal.js";
+import { VerificationError } from "./errors.js";
+import { signWithGroup, type KeyGroupSigner } from "./key-group.js";
+import {
+  parseKeyEnrollmentResult,
+  parseSystemRegistrationCertificate,
+  type KeyEnrollmentResult,
+  type System,
+  type SystemRegistrationCertificate,
+} from "./models.js";
+import { formatTimestamp } from "./verify.js";
+
+type Raw = Record<string, unknown>;
+
+/** How to check the enclave: the PCR0 you pinned out of band, and optionally
+ * your own challenge (otherwise 32 bytes are drawn from the OS CSPRNG). */
+export interface EnclavePinOptions extends SealOptions {
+  nonce?: Uint8Array;
+}
+
+/** What `createRegisteredSystem` did, in order. */
+export interface RegisteredSystem {
+  /** The system, created with its config sealed so the API never read it. */
+  readonly system: System;
+  /** The enclave's registration of that system under your key group. */
+  readonly registration: SystemRegistrationCertificate;
+}
+
+/** Mirrors core.DefaultAuthorizationWindow, the longest window the enclave
+ * grants: a request that names no `notAfter` asks for all of it. */
+const DEFAULT_AUTHORIZATION_WINDOW_MS = 90 * 24 * 60 * 60 * 1000;
+
+/** How far ahead of this machine's clock an authorization may start: room for
+ * an enclave clock that runs a little ahead, as core's notAfterSkew leaves room
+ * for a customer clock that does. Not room for a document from the future. */
+const NOT_BEFORE_SKEW_MS = 5 * 60 * 1000;
+
+function toHex(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString("hex");
+}
+
+function sha256(bytes: Uint8Array): Uint8Array {
+  return new Uint8Array(createHash("sha256").update(bytes).digest());
+}
+
+function boundOf(notAfter: Date | undefined): Date {
+  return notAfter ?? new Date(Date.now() + DEFAULT_AUTHORIZATION_WINDOW_MS);
+}
+
+// --- ATTEST_IDENTITY ----------------------------------------------------------
+
+/**
+ * The challenge and the query string that carries it. A nonce the checked party
+ * chose — including one the API suggested — proves nothing about when the
+ * document was produced, so it is drawn here unless the caller brings its own.
+ */
+export function attestationParams(nonce?: Uint8Array): {
+  nonce: Uint8Array;
+  params: Record<string, string>;
+} {
+  const drawn = nonce ?? webcrypto.getRandomValues(new Uint8Array(IDENTITY_NONCE_SIZE));
+  return { nonce: drawn, params: { nonce: Buffer.from(drawn).toString("base64url") } };
+}
+
+/**
+ * Verify the document the API returned against this caller's own challenge. The
+ * `nonce` the API echoes beside the document is ignored: nothing signs it. The
+ * check is against the nonce inside the document, under AWS's signature.
+ */
+export async function identityFromResponse(
+  data: unknown,
+  options: SealOptions & { nonce: Uint8Array },
+): Promise<EnclaveIdentity> {
+  const raw = (data as Raw | null)?.nsm_attestation;
+  if (typeof raw !== "string") {
+    throw new VerificationError("the attestation response carries no nsm_attestation");
+  }
+  return verifyEnclaveIdentity(new Uint8Array(Buffer.from(raw, "base64")), options);
+}
+
+// --- ENROLL_KEY / ROTATE_KEY --------------------------------------------------
+
+function groupBody(group: CustomerKeyGroup, signatures: Record<string, string>): Raw {
+  return {
+    threshold: group.threshold,
+    member_keys: group.members.map(toHex),
+    signatures,
+  };
+}
+
+/**
+ * The ENROLL_KEY request, the key id it enrols and the `not_after` it signs.
+ * EVERY member signs.
+ */
+export async function enrollBody(opts: {
+  teamId: string;
+  group: CustomerKeyGroup;
+  signers: readonly KeyGroupSigner[];
+  notAfter?: Date;
+}): Promise<{ body: Raw; keyId: string; notAfter: string }> {
+  const keyId = await customerKeyId(nodeCrypto, opts.group);
+  const bound = boundOf(opts.notAfter);
+  const payload = buildKeyEnrollmentRequestPayload({
+    assertedTeamId: opts.teamId,
+    customerKeyId: keyId,
+    notAfter: bound,
+  });
+  const signatures = await signWithGroup(payload, opts.group, opts.signers, opts.group.members.length);
+  const notAfter = keyTime(bound);
+  return {
+    body: {
+      asserted_team_id: opts.teamId.toLowerCase(),
+      not_after: notAfter,
+      ...groupBody(opts.group, signatures),
+    },
+    keyId,
+    notAfter,
+  };
+}
+
+/**
+ * The ROTATE_KEY request. Both groups sign the same key_rotation_request.v2: the
+ * OUTGOING group at its threshold, to spend its authority, and EVERY incoming
+ * member, to prove it holds its key.
+ */
+export async function rotateBody(opts: {
+  teamId: string;
+  previousGroup: CustomerKeyGroup;
+  previousSigners: readonly KeyGroupSigner[];
+  nextGroup: CustomerKeyGroup;
+  nextSigners: readonly KeyGroupSigner[];
+  notAfter?: Date;
+}): Promise<{ body: Raw; prevKeyId: string; nextKeyId: string; notAfter: string }> {
+  const prevKeyId = await customerKeyId(nodeCrypto, opts.previousGroup);
+  const nextKeyId = await customerKeyId(nodeCrypto, opts.nextGroup);
+  const bound = boundOf(opts.notAfter);
+  const payload = buildKeyRotationRequestPayload({
+    assertedTeamId: opts.teamId,
+    prevKeyId,
+    nextKeyId,
+    notAfter: bound,
+  });
+  const signatures = await signWithGroup(
+    payload,
+    opts.previousGroup,
+    opts.previousSigners,
+    opts.previousGroup.threshold,
+  );
+  const nextSignatures = await signWithGroup(
+    payload,
+    opts.nextGroup,
+    opts.nextSigners,
+    opts.nextGroup.members.length,
+  );
+  const notAfter = keyTime(bound);
+  return {
+    body: {
+      asserted_team_id: opts.teamId.toLowerCase(),
+      prev_key_id: prevKeyId,
+      not_after: notAfter,
+      next_signatures: nextSignatures,
+      ...groupBody(opts.nextGroup, signatures),
+    },
+    prevKeyId,
+    nextKeyId,
+    notAfter,
+  };
+}
+
+/**
+ * Verify both documents ENROLL_KEY and ROTATE_KEY return under the attested
+ * enclave's signing key, then refuse them unless they name the group this caller
+ * holds and the team it asked for, link to the predecessor it expects, end
+ * exactly at the `notAfter` (whole-second UTC) it signed, and do not start in
+ * the future. `teamId` is the team the request asserted; the SDK always asserts
+ * one, so there is no request this check has no team for.
+ *
+ * The end must be EXACT. A protocol-12 enclave ends the grant at the signed
+ * bound, to the second, so any other end answers some other request -- which is
+ * what a relay replaying an older genuine response, or dropping a renewal,
+ * hands back.
+ */
+export async function checkEnrollment(
+  data: unknown,
+  opts: {
+    enclave: EnclaveIdentity;
+    keyId: string;
+    prevKeyId: string | undefined;
+    teamId: string;
+    notAfter: string;
+    /** The time to judge `not_before` against. Defaults to this machine's clock. */
+    now?: Date;
+  },
+): Promise<KeyEnrollmentResult> {
+  const raw = (data ?? {}) as Raw;
+  await verifyKeyEnrollmentStatement(nodeCrypto, raw.enrollment, opts.enclave.signingKey);
+  await verifyTeamAuthorization(nodeCrypto, raw.authorization, opts.enclave.signingKey);
+  const result = parseKeyEnrollmentResult(raw);
+  const { enrollment, authorization } = result;
+  // One comparison covers the members and threshold too: a key id is a hash
+  // over both, and a verified statement's id is the one its own group derives.
+  if (enrollment.customerKeyId !== opts.keyId || authorization.customerKeyId !== opts.keyId) {
+    throw new VerificationError(
+      `the enclave's statement names key ${JSON.stringify(enrollment.customerKeyId)} ` +
+        `(authorization ${JSON.stringify(authorization.customerKeyId)}), not the group you ` +
+        `enrolled (${JSON.stringify(opts.keyId)}). Do not use it: this is what a substituted key looks like.`,
+    );
+  }
+  if (authorization.prevKeyId !== opts.prevKeyId) {
+    throw new VerificationError(
+      `the authorization links to predecessor ${JSON.stringify(authorization.prevKeyId ?? null)}, ` +
+        `expected ${JSON.stringify(opts.prevKeyId ?? null)}`,
+    );
+  }
+  const team = opts.teamId.toLowerCase();
+  for (const [what, named] of [
+    ["enrolment statement", enrollment.assertedTeamId],
+    ["authorization", authorization.assertedTeamId],
+  ] as const) {
+    if (named.toLowerCase() !== team) {
+      throw new VerificationError(
+        `the ${what} is for team ${named}, not the team you asked for (${team}). ` +
+          "Do not use it: a relay replaying another team's answer would produce exactly this.",
+      );
+    }
+  }
+  // Compared as the whole-second strings both sides sign, not as parsed
+  // dates: a Date has milliseconds, and a fraction on the wire is nobody's.
+  const granted = formatTimestamp((raw.authorization as Raw).not_after, "authorization.not_after");
+  if (granted !== opts.notAfter) {
+    throw new VerificationError(
+      `the authorization ends at ${granted}, not at the not_after you signed (${opts.notAfter}). ` +
+        "The enclave ends the grant exactly there, so this answers some other request; " +
+        "a relay replaying an older response would produce exactly this.",
+    );
+  }
+  const now = opts.now ?? new Date();
+  if (!(now instanceof Date) || Number.isNaN(now.getTime())) {
+    throw new TypeError("now must be a valid Date");
+  }
+  if (authorization.notBefore.getTime() > now.getTime() + NOT_BEFORE_SKEW_MS) {
+    const starts = formatTimestamp((raw.authorization as Raw).not_before, "authorization.not_before");
+    throw new VerificationError(
+      `the authorization starts at ${starts}, more than five minutes after this machine's clock ` +
+        `(${keyTime(now)}): the answer to a request just made cannot start in the future`,
+    );
+  }
+  return result;
+}
+
+// --- REGISTER_SYSTEM ----------------------------------------------------------
+
+/** The exact bytes sealed, and therefore the bytes `config_digest` is over. */
+export function configBytes(config: Record<string, unknown>): Uint8Array {
+  return new TextEncoder().encode(JSON.stringify(config));
+}
+
+/**
+ * The REGISTER_SYSTEM request, its key id and the config digest it signs.
+ *
+ * `config` must be the EXACT bytes submitted when the system was created — the
+ * plaintext that was sealed, or the `connection_config` JSON text as sent. An
+ * object is refused: re-serializing it produces bytes that may differ by one
+ * space from what the enclave decrypts, and the refusal would be a 401 with no
+ * way to see why.
+ */
+export async function registrationBody(opts: {
+  teamId: string;
+  group: CustomerKeyGroup;
+  signers: readonly KeyGroupSigner[];
+  systemId: string;
+  config: Uint8Array | string;
+  queryTemplate: string;
+  connectorType: string;
+}): Promise<{ body: Raw; keyId: string; configDigest: Uint8Array }> {
+  const config =
+    typeof opts.config === "string" ? new TextEncoder().encode(opts.config) : opts.config;
+  if (!(config instanceof Uint8Array)) {
+    throw new TypeError(
+      "config must be the exact bytes (or text) submitted when the system was created, " +
+        "not a re-serializable object",
+    );
+  }
+  const keyId = await customerKeyId(nodeCrypto, opts.group);
+  const configDigest = sha256(config);
+  const payload = buildSystemRegistrationRequestPayload({
+    assertedTeamId: opts.teamId,
+    systemId: opts.systemId,
+    configDigest,
+    queryTemplateSha256: sha256(new TextEncoder().encode(opts.queryTemplate)),
+    connectorType: opts.connectorType,
+    customerKeyId: keyId,
+  });
+  const signatures = await signWithGroup(payload, opts.group, opts.signers, opts.group.threshold);
+  return {
+    body: {
+      asserted_team_id: opts.teamId.toLowerCase(),
+      system_id: opts.systemId.toLowerCase(),
+      query_template: opts.queryTemplate,
+      ...groupBody(opts.group, signatures),
+    },
+    keyId,
+    configDigest,
+  };
+}
+
+/** Verify the registration under the attested enclave's signing key, then
+ * refuse it unless it binds what this caller signed. */
+export async function checkRegistration(
+  data: unknown,
+  opts: {
+    enclave: EnclaveIdentity;
+    keyId: string;
+    systemId: string;
+    configDigest: Uint8Array;
+    connectorType: string;
+  },
+): Promise<SystemRegistrationCertificate> {
+  const raw = (data as Raw | null)?.registration;
+  await verifySystemRegistration(nodeCrypto, raw, opts.enclave.signingKey);
+  const registration = parseSystemRegistrationCertificate(raw as Raw);
+  const wrong: string[] = [];
+  if (registration.customerKeyId !== opts.keyId) {
+    wrong.push(`customer_key_id is ${JSON.stringify(registration.customerKeyId)}, expected ${JSON.stringify(opts.keyId)}`);
+  }
+  if (String(registration.systemId).toLowerCase() !== opts.systemId.toLowerCase()) {
+    wrong.push(`system_id is ${JSON.stringify(registration.systemId)}, expected ${JSON.stringify(opts.systemId)}`);
+  }
+  if (toHex(registration.configDigest) !== toHex(opts.configDigest)) {
+    wrong.push(`config_digest is ${toHex(registration.configDigest)}, expected ${toHex(opts.configDigest)}`);
+  }
+  if (registration.connectorType !== opts.connectorType) {
+    wrong.push(`connector_type is ${JSON.stringify(registration.connectorType)}, expected ${JSON.stringify(opts.connectorType)}`);
+  }
+  if (wrong.length > 0) {
+    throw new VerificationError(
+      `the enclave's registration does not bind what you signed: ${wrong.join(", ")}`,
+    );
+  }
+  return registration;
+}

package/src/enclave-seal.ts

@@ -34,7 +34,13 @@
  * point.
  */
 
-import { X509Certificate, verify as nodeVerify, webcrypto } from "node:crypto";
+import {
+  X509Certificate,
+  createHash,
+  timingSafeEqual,
+  verify as nodeVerify,
+  webcrypto,
+} from "node:crypto";
 
 /**
  * Envelope wire format (v1). Must match enclave/configsealkey.go byte for byte:
@@ -183,6 +189,103 @@ export async function verifyEnclaveConfigSealKey(
   attestationDocument: Uint8Array,
   options: SealOptions,
 ): Promise<Uint8Array> {
+  return configSealKeyOf(verifyDocument(attestationDocument, options));
+}
+
+/** Mirrors enclave.AttestIdentityNonceSize. */
+export const IDENTITY_NONCE_SIZE = 32;
+
+/**
+ * What an ATTEST_IDENTITY document establishes once verified: which keys, held
+ * by an enclave running which image, answering THIS caller's challenge.
+ */
+export interface EnclaveIdentity {
+  /** The X25519 key to seal connection configs to. */
+  readonly configSealKey: Uint8Array;
+  /** The enclave's Ed25519 signing key, read out of the signed document. */
+  readonly signingKey: Uint8Array;
+  /** `dp_k_` + hex(SHA-256(signingKey)) — the id /.well-known/burnledger-keys publishes. */
+  readonly signingKeyId: string;
+  /** The PCR0 the document reports, hex. Equal to the one pinned, or this would have thrown. */
+  readonly pcr0: string;
+}
+
+export interface IdentityOptions extends SealOptions {
+  /**
+   * The 32-byte challenge sent with the request. Draw it from your own entropy:
+   * a nonce the party being checked chose proves nothing about when the
+   * document was produced.
+   */
+  nonce: Uint8Array;
+}
+
+/**
+ * Verify an ATTEST_IDENTITY document (`GET /v1/enclave/attestation?nonce=`).
+ *
+ * Port of enclave.VerifyIdentityAttestation: everything
+ * {@link verifyEnclaveConfigSealKey} checks, and then that the document carries
+ * exactly the nonce this caller sent and binds a 32-byte Ed25519 signing key in
+ * `user_data`.
+ *
+ * THE NONCE CHECK IS THE POINT. The other checks pass for every document this
+ * enclave image has ever produced, including one captured months ago and
+ * replayed by a relay that has since swapped keys. Only a document carrying the
+ * challenge this caller drew, under AWS's signature, is a statement about now.
+ *
+ * What a pass means, and no more: these keys are held by an AWS Nitro Enclave
+ * running an image that measures to the pinned PCR0, and it answered this
+ * challenge within five minutes of `now`. It does not mean the image was built
+ * from any particular source.
+ */
+export async function verifyEnclaveIdentity(
+  attestationDocument: Uint8Array,
+  options: IdentityOptions,
+): Promise<EnclaveIdentity> {
+  const sent = options.nonce;
+  if (!(sent instanceof Uint8Array) || sent.length !== IDENTITY_NONCE_SIZE) {
+    throw new EnclaveAttestationError(
+      `challenge nonce is ${sent instanceof Uint8Array ? sent.length : 0} bytes, want exactly ` +
+        `${IDENTITY_NONCE_SIZE} (this is a bug in the caller, not a bad document)`,
+    );
+  }
+  const payload = verifyDocument(attestationDocument, options);
+  const carried = payload.get("nonce");
+  if (
+    !(carried instanceof Uint8Array) ||
+    carried.length !== sent.length ||
+    !timingSafeEqual(carried, sent)
+  ) {
+    throw new EnclaveAttestationError(
+      `the document answers a different challenge than the one sent (sent ${toHex(sent)}, ` +
+        `document carries ${carried instanceof Uint8Array ? toHex(carried) : "none"}) — a genuine ` +
+        "document replayed for someone else's nonce proves nothing about now",
+    );
+  }
+  const signingKey = payload.get("user_data");
+  if (!(signingKey instanceof Uint8Array) || signingKey.length !== 32) {
+    const got = signingKey instanceof Uint8Array ? signingKey.length : 0;
+    throw new EnclaveAttestationError(
+      `the document binds ${got} bytes where an Ed25519 public key belongs, want 32`,
+    );
+  }
+  const pcr0 = (payload.get("pcrs") as Map<unknown, unknown>).get(0) as Uint8Array;
+  return {
+    configSealKey: configSealKeyOf(payload),
+    signingKey,
+    signingKeyId: "dp_k_" + createHash("sha256").update(signingKey).digest("hex"),
+    pcr0: toHex(pcr0),
+  };
+}
+
+/**
+ * The checks every enclave document gets, whatever is read out of it after:
+ * COSE structure and algorithm, the chain to the pinned root, the signature, the
+ * AWS timestamp against `now`, and the pinned PCRs. Returns the verified payload.
+ */
+function verifyDocument(
+  attestationDocument: Uint8Array,
+  options: SealOptions,
+): Map<unknown, unknown> {
   if (!attestationDocument || attestationDocument.length === 0) {
     throw new EnclaveAttestationError(
       "no attestation document (nothing to verify — this is not a pass)",
@@ -218,7 +321,11 @@ export async function verifyEnclaveConfigSealKey(
   verifyCoseSignature(leaf, protectedBytes, payloadBytes, signature);
   checkClock(payload.get("timestamp"), now);
   matchPcrs(pcrs, expected);
+  return payload;
+}
 
+/** The 32-byte X25519 config-seal key a verified payload binds in `public_key`. */
+function configSealKeyOf(payload: Map<unknown, unknown>): Uint8Array {
   const publicKey = payload.get("public_key");
   if (!(publicKey instanceof Uint8Array) || publicKey.length !== KEY_SIZE) {
     const got = publicKey instanceof Uint8Array ? publicKey.length : 0;

package/src/errors.ts

@@ -125,6 +125,17 @@ export class VerificationError extends BurnLedgerError {
 /** {@link VerificationError.code} for a verified statement that says REVOKED. */
 export const CERTIFICATE_REVOKED = "CERTIFICATE_REVOKED";
 
+/**
+ * {@link VerificationError.code} when a record verified but does not meet the
+ * `requireAuthorization` policy the caller asked for: a system that is not
+ * `certified`, one certified under a key the caller does not accept, a required
+ * system the record does not cover, a format that predates registration, or a
+ * record from an enclave image that could say `certified` without the customer's
+ * signature (protocol 11 or earlier, or none named). A fact about the record,
+ * not a failure to read it.
+ */
+export const AUTHORIZATION_POLICY_FAILED = "AUTHORIZATION_POLICY_FAILED";
+
 /**
  * The record is in a format this SDK does not know how to read.
  *

package/src/index.browser.ts

@@ -69,17 +69,23 @@ import {
   verifyConsistency as _verifyConsistency,
   publicKeyFromHex as _publicKeyFromHex,
 } from "./verify.js";
-import type { PublicKeyInfo, PublicKeyOptions } from "./verify.js";
+import type { PublicKeyInfo, PublicKeyOptions, VerifyOptions } from "./verify.js";
 import type { VerificationResult, TransparencyResult } from "./models.js";
 
+export type { AuthorizationPolicy, VerifyOptions } from "./verify.js";
+
 type Cert = Record<string, unknown>;
 
-/** Verify all signatures on a deletion certificate offline. */
+/** Verify all signatures on a deletion certificate offline. Pass
+ * `{ requireAuthorization }` to refuse a record unless its systems are certified
+ * under a key id you name, by an enclave image that requires that key group's
+ * signature to register a system (ADR-025). */
 export function verifyCertificate(
   certificate: Cert,
   publicKeys: Map<string, PublicKeyInfo>,
+  options?: VerifyOptions,
 ): Promise<VerificationResult> {
-  return _verifyCertificate(browserCrypto, certificate, publicKeys);
+  return _verifyCertificate(browserCrypto, certificate, publicKeys, options);
 }
 
 /** Verify the transparency proof embedded in a certificate. */

package/src/index.ts

@@ -14,6 +14,7 @@ export {
   ServerError,
   TimeoutError,
   VerificationError,
+  AUTHORIZATION_POLICY_FAILED,
   CERTIFICATE_REVOKED,
   UNSUPPORTED_FORMAT_VERSION,
 } from "./errors.js";
@@ -21,7 +22,7 @@ export {
 export { Transport } from "./http.js";
 export type { TransportOptions } from "./http.js";
 
-export type { PublicKeyOptions } from "./verify.js";
+export type { AuthorizationPolicy, PublicKeyOptions, VerifyOptions } from "./verify.js";
 
 export type {
   ProofMode,
@@ -62,6 +63,10 @@ export type {
   PlanUsage,
   Profile,
   SystemHealth,
+  KeyEnrollmentStatement,
+  TeamAuthorizationCertificate,
+  SystemRegistrationCertificate,
+  KeyEnrollmentResult,
 } from "./models.js";
 
 // Raw-JSON → model parsers, for consumers that fetch API responses outside
@@ -82,17 +87,21 @@ import {
   verifyConsistency as _verifyConsistency,
   publicKeyFromHex as _publicKeyFromHex,
 } from "./verify.js";
-import type { PublicKeyInfo, PublicKeyOptions } from "./verify.js";
+import type { PublicKeyInfo, PublicKeyOptions, VerifyOptions } from "./verify.js";
 import type { VerificationResult, TransparencyResult } from "./models.js";
 
 type Cert = Record<string, unknown>;
 
-/** Verify all signatures on a deletion certificate offline. */
+/** Verify all signatures on a deletion certificate offline. Pass
+ * `{ requireAuthorization }` to refuse a record unless its systems are certified
+ * under a key id you name, by an enclave image that requires that key group's
+ * signature to register a system (ADR-025). */
 export function verifyCertificate(
   certificate: Cert,
   publicKeys: Map<string, PublicKeyInfo>,
+  options?: VerifyOptions,
 ): Promise<VerificationResult> {
-  return _verifyCertificate(nodeCrypto, certificate, publicKeys);
+  return _verifyCertificate(nodeCrypto, certificate, publicKeys, options);
 }
 
 /**
@@ -106,8 +115,9 @@ export function verifyCertificateWithStatus(
   publicKeys: Map<string, PublicKeyInfo>,
   status?: Record<string, unknown> | null,
   now?: Date,
+  options?: VerifyOptions,
 ): Promise<string> {
-  return _verifyCertificateWithStatus(nodeCrypto, certificate, publicKeys, status, now);
+  return _verifyCertificateWithStatus(nodeCrypto, certificate, publicKeys, status, now, options);
 }
 
 /** Verify the transparency proof embedded in a certificate. */
@@ -159,22 +169,41 @@ export {
   EnclaveAttestationError,
   ENVELOPE_MAGIC,
   HEADER_SIZE,
+  IDENTITY_NONCE_SIZE,
   NITRO_ROOT_G1_PEM,
   sealConnectionConfig,
   sealToKey,
   verifyEnclaveConfigSealKey,
+  verifyEnclaveIdentity,
 } from "./enclave-seal.js";
-export type { SealOptions } from "./enclave-seal.js";
+export type { EnclaveIdentity, IdentityOptions, SealOptions } from "./enclave-seal.js";
 
 export {
   CUSTOMER_KEY_ID_PREFIX,
   InvalidKeyGroupError,
   MAX_CUSTOMER_KEY_GROUP_MEMBERS,
+  PAYLOAD_TYPE_KEY_ENROLLMENT_REQUEST,
   PAYLOAD_TYPE_KEY_ROTATION_REQUEST,
+  PAYLOAD_TYPE_SYSTEM_REGISTRATION_REQUEST,
+  buildKeyEnrollmentRequestPayload,
   buildKeyRotationRequestPayload,
+  buildSystemRegistrationRequestPayload,
   customerKeyId,
   memberFingerprint,
   memberFingerprints,
   validateKeyGroup,
+  verifyKeyEnrollmentStatement,
+  verifySystemRegistration,
+  verifyTeamAuthorization,
 } from "./customer-keys.js";
 export type { CustomerKeyGroup } from "./customer-keys.js";
+
+/**
+ * Customer key group members as signers (ADR-025). Node only. The SDK never
+ * holds a private key: every signature comes from a KeyGroupSigner, and
+ * InMemorySigner is the convenience for keys kept on this machine. Read the
+ * custody note in key-group.ts before generating a group.
+ */
+export { InMemorySigner, generateKeyGroup, signWithGroup } from "./key-group.js";
+export type { GeneratedKeyGroup, KeyGroupSigner } from "./key-group.js";
+export type { EnclavePinOptions, RegisteredSystem } from "./enclave-registration.js";