@calimero-network/mero-js 24.6.0 → 25.0.0

package/dist/sealed/index.d.ts

@@ -1,7 +1,7 @@
 export { HANDSHAKE_PATH, SEALED_CONTENT_TYPE, SEALED_PATH, SealedTransportError, StaleTransportKeyError, createAttestedSealedFetch, createSealedFetch, fetchAttestedTransportKey, transportKeyBinding, } from './sealed.js';
 export type { AttestedSealedFetchOptions, SealedFetchOptions, VerifyTransportQuote } from './sealed.js';
-export { createQuoteVerifier, trustedMeasurementsFromReleases } from './verify.js';
-export type { DcapCollateral, DcapVerifiedReport, DcapVerify, PublishedMrtds, QuoteVerifier, QuoteVerifierOptions, TrustedMeasurements, } from './verify.js';
+export { PRODUCTION_PROFILE, createQuoteVerifier, trustedMeasurementsFromReleases } from './verify.js';
+export type { DcapCollateral, DcapVerifiedReport, DcapVerify, PublishedMrtds, QuoteVerifier, QuoteVerifierOptions, TrustedMeasurements, TrustedProfileOptions, } from './verify.js';
 export { DEFAULT_RELEASE_MIRROR, NODE_RELEASE_SIGNER, cloudNodeReleaseUrl, createSignedReleaseSealedFetch, createSignedReleaseVerifier, fetchNodeRelease, fetchNodeReleaseVersion, nodeReleaseVersionFromImage, trustSignedRelease, verifySignedNodeRelease, } from './release.js';
 export type { SignedNodeRelease, SignedReleaseSealedFetchOptions, SignedReleaseVerifierOptions, TrustSignedReleaseOptions, VerifySignedNodeReleaseOptions, } from './release.js';
 export type { SignerIdentity } from './sigstore.js';

package/dist/sealed/index.js

@@ -1,3 +1,3 @@
 export { HANDSHAKE_PATH, SEALED_CONTENT_TYPE, SEALED_PATH, SealedTransportError, StaleTransportKeyError, createAttestedSealedFetch, createSealedFetch, fetchAttestedTransportKey, transportKeyBinding, } from './sealed.js';
-export { createQuoteVerifier, trustedMeasurementsFromReleases } from './verify.js';
+export { PRODUCTION_PROFILE, createQuoteVerifier, trustedMeasurementsFromReleases } from './verify.js';
 export { DEFAULT_RELEASE_MIRROR, NODE_RELEASE_SIGNER, cloudNodeReleaseUrl, createSignedReleaseSealedFetch, createSignedReleaseVerifier, fetchNodeRelease, fetchNodeReleaseVersion, nodeReleaseVersionFromImage, trustSignedRelease, verifySignedNodeRelease, } from './release.js';

package/dist/sealed/release.d.ts

@@ -27,7 +27,7 @@
  * another.
  */
 import { type SignerIdentity } from './sigstore.js';
-import { type DcapVerify, type PublishedMrtds, type QuoteVerifier, type QuoteVerifierOptions } from './verify.js';
+import { type DcapVerify, type PublishedMrtds, type QuoteVerifier, type QuoteVerifierOptions, type TrustedProfileOptions } from './verify.js';
 /** The workflow that signs every mero-tee node release, and the issuer of its identity. */
 export declare const NODE_RELEASE_SIGNER: Readonly<SignerIdentity>;
 /**
@@ -107,11 +107,9 @@ export declare function fetchNodeReleaseVersion(baseUrl: string, options?: {
 }): Promise<string>;
 /** Where the cloud at `cloudUrl` (e.g. `https://cloud.calimero.network`) mirrors node release `version`. */
 export declare function cloudNodeReleaseUrl(cloudUrl: string, version: string): string;
-export interface TrustSignedReleaseOptions {
+export interface TrustSignedReleaseOptions extends TrustedProfileOptions {
     /** The release, from any source; it is verified here. */
     release: SignedNodeRelease;
-    /** The image profile to trust, e.g. `locked-read-only`. */
-    profile: string;
     /**
      * The oldest release accepted, e.g. `2.3.87`. Required: every release ever
      * signed stays validly signed, so without a floor a relay could present an

package/dist/sealed/release.js

@@ -200,7 +200,10 @@ export async function trustSignedRelease(options) {
     if (compareReleaseVersions(version, minimum) < 0) {
         throw new Error(`Release ${version} is older than the minimum trusted, ${minimum}`);
     }
-    return trustedMeasurementsFromReleases([published], { profile: options.profile });
+    return trustedMeasurementsFromReleases([published], {
+        profile: options.profile,
+        allowDebugProfile: options.allowDebugProfile,
+    });
 }
 /**
  * A {@link createQuoteVerifier} whose trusted image is the signed release the
@@ -220,6 +223,7 @@ export function createSignedReleaseVerifier(options) {
         const trusted = await trustSignedRelease({
             release: await options.release(),
             profile: options.profile,
+            allowDebugProfile: options.allowDebugProfile,
             minReleaseVersion: options.minReleaseVersion,
             identity: options.identity,
             issuer: options.issuer,

package/dist/sealed/verify.d.ts

@@ -167,6 +167,20 @@ export interface PublishedMrtds {
  * (checked out of a release you verified) trusts that release; fetching it at
  * run time trusts whoever serves it.
  */
-export declare function trustedMeasurementsFromReleases(releases: PublishedMrtds[], { profile }: {
+/**
+ * The one image profile a release publishes for production. The `debug` and
+ * `debug-read-only` images are signed and published beside it, but run with
+ * SSH and the operator's tooling inside the TD, so trusting one trusts an
+ * image the operator can read.
+ */
+export declare const PRODUCTION_PROFILE = "locked-read-only";
+export interface TrustedProfileOptions {
+    /** The image profile to trust, e.g. `locked-read-only`. */
     profile: string;
-}): Required<Pick<QuoteVerifierOptions, 'allowedMeasurements' | 'allowedTcbStatuses'>>;
+    /**
+     * Trust a profile other than {@link PRODUCTION_PROFILE}, such as `debug`.
+     * Its image is readable by whoever operates the node, so only for testing.
+     */
+    allowDebugProfile?: boolean;
+}
+export declare function trustedMeasurementsFromReleases(releases: PublishedMrtds[], { profile, allowDebugProfile }: TrustedProfileOptions): Required<Pick<QuoteVerifierOptions, 'allowedMeasurements' | 'allowedTcbStatuses'>>;

package/dist/sealed/verify.js

@@ -90,6 +90,13 @@ export function createQuoteVerifier(options) {
             throw new Error(`The platform's TCB status is ${verified.status}, which is not accepted`);
         }
         const td = tdReport(verified.report);
+        // TUD bit 0. A debug TD's memory and registers are open to the host, so its
+        // measurements prove nothing about what runs in it. Checked here, not left
+        // to `dcapVerify`, which a caller may swap for one that allows debug; an
+        // attribute field that cannot be read counts as debug.
+        if (td.tdAttributes?.length !== 8 || (td.tdAttributes[0] & 0x01) !== 0) {
+            throw new Error('The quote is from a debug TD, or its TD attributes cannot be read');
+        }
         const measured = [td.mrTd, td.rtMr0, td.rtMr1, td.rtMr2, td.rtMr3].map((register) => hex(register));
         if (allowedImages.length > 0 && !allowedImages.includes(measured.join())) {
             throw new Error(`The measurements (MRTD ${measured[0]}, RTMR0-3 ${measured.slice(1).join(', ')}) are not an image this verifier trusts`);
@@ -166,7 +173,14 @@ const TCB_STATUSES = [
  * (checked out of a release you verified) trusts that release; fetching it at
  * run time trusts whoever serves it.
  */
-export function trustedMeasurementsFromReleases(releases, { profile }) {
+/**
+ * The one image profile a release publishes for production. The `debug` and
+ * `debug-read-only` images are signed and published beside it, but run with
+ * SSH and the operator's tooling inside the TD, so trusting one trusts an
+ * image the operator can read.
+ */
+export const PRODUCTION_PROFILE = 'locked-read-only';
+export function trustedMeasurementsFromReleases(releases, { profile, allowDebugProfile = false }) {
     if (releases.length === 0) {
         throw new Error('No release given, so no image would be trusted');
     }
@@ -181,6 +195,10 @@ export function trustedMeasurementsFromReleases(releases, { profile }) {
             const known = Object.keys(release?.profiles ?? {}).join(', ') || 'none';
             throw new Error(`${name} has no profile ${JSON.stringify(profile)} (it has: ${known})`);
         }
+        if (profile !== PRODUCTION_PROFILE && !allowDebugProfile) {
+            throw new Error(`${JSON.stringify(profile)} is not a production profile: its image is readable by whoever ` +
+                `operates the node. Trust ${JSON.stringify(PRODUCTION_PROFILE)}, or pass allowDebugProfile to test`);
+        }
         const accepted = (image.allowed_tcb_statuses ?? ['uptodate']).map((status) => tcbStatus(status, name));
         statuses = statuses === undefined ? accepted : statuses.filter((status) => accepted.includes(status));
         return {

package/dist/transport/mero-client.d.ts

@@ -82,6 +82,13 @@ export interface RelayTransportConfig {
      * would have that caller take the client apart to put it back together.
      */
     relay: RelayClient | RelayClientConfig;
+    /**
+     * Fetch for everything this client sends the relay: intents (unless `relay`
+     * names its own), admin reads, the observing login and events. Typically a
+     * sealed fetch (`createAttestedSealedFetch`), so none of it can be read where
+     * TLS ends. Defaults to global `fetch`.
+     */
+    fetch?: typeof fetch;
     /**
      * A session on the relay, if this client has one.
      *
@@ -156,6 +163,8 @@ export declare class MeroClient {
     private readonly proofAuthorizer;
     private readonly relayUrl;
     private proofEvents;
+    /** The relay transport's `fetch`, if one was given. */
+    private readonly relayFetch;
     private relayPresence;
     constructor(config: MeroClientConfig);
     /**

package/dist/transport/mero-client.js

@@ -88,7 +88,7 @@ function missingNodeKey(surface) {
  * authors is the device that observes, and taking a second copy from the caller
  * is how the two come to name different keys.
  */
-function buildObserver(relay, observe) {
+function buildObserver(relay, observe, fetchImpl) {
     const nodeKey = observe?.nodeKey;
     if (!nodeKey)
         return null;
@@ -100,7 +100,7 @@ function buildObserver(relay, observe) {
         signer: observe?.signer ? async () => observe.signer : () => relay.authorSigner(),
         clientName: observe?.clientName,
         ttlSeconds: observe?.ttlSeconds,
-        fetch: observe?.fetch,
+        fetch: observe?.fetch ?? fetchImpl,
         timeoutMs: observe?.timeoutMs,
     });
 }
@@ -128,12 +128,18 @@ export class MeroClient {
         this.proofAuthorizer = null;
         this.relayUrl = null;
         this.proofEvents = null;
+        /** The relay transport's `fetch`, if one was given. */
+        this.relayFetch = undefined;
         this.relayPresence = null;
         if (config.transport === 'relay') {
             this.transport = 'relay';
             this.nodeClient = null;
-            const relay = config.relay instanceof RelayClient ? config.relay : new RelayClient(config.relay);
-            this.relayObserver = buildObserver(relay, config.observe);
+            const fetchImpl = config.fetch;
+            this.relayFetch = fetchImpl;
+            const relay = config.relay instanceof RelayClient
+                ? config.relay
+                : new RelayClient({ ...config.relay, fetch: config.relay.fetch ?? fetchImpl });
+            this.relayObserver = buildObserver(relay, config.observe, fetchImpl);
             this.rpcTransport = new RelayTransport(relay, this.relayObserver);
             this.relayUrl = relay.relayUrl;
             if (config.proof) {
@@ -150,12 +156,13 @@ export class MeroClient {
                 this.relayAdmin = createAdminApiClient({
                     baseUrl: relay.relayUrl,
                     getAuthToken: typeof token === 'string' ? async () => token : token,
+                    fetch: fetchImpl,
                 });
             }
             else if (this.proofAuthorizer) {
                 const authorizeRequest = this.proofAuthorizer;
                 this.relayAdmin = createAdminApiClientFromHttpClient(createHttpClient({
-                    fetch: (url, init) => globalThis.fetch(url, init),
+                    fetch: (url, init) => fetchImpl ? fetchImpl(url, init) : globalThis.fetch(url, init),
                     baseUrl: relay.relayUrl,
                     authorizeRequest,
                 }), { baseUrl: relay.relayUrl });
@@ -281,6 +288,7 @@ export class MeroClient {
             this.proofEvents ?? (this.proofEvents = new SseClient({
                 baseUrl: this.relayUrl,
                 authorize: this.proofAuthorizer,
+                fetch: this.relayFetch,
             }));
             return this.proofEvents;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calimero-network/mero-js",
-  "version": "24.6.0",
+  "version": "25.0.0",
   "description": "Pure JavaScript SDK for Calimero",
   "type": "module",
   "exports": {