@colophon-claims/verify 0.0.0 → 0.2.0

package/dist/profile/signing.js

@@ -0,0 +1,46 @@
+import { verify } from "node:crypto";
+import { dssePreAuthEncoding, parseDsseEnvelope } from "@jinn-network/trust-core";
+const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58(bytes) {
+    let zeros = 0;
+    while (zeros < bytes.length && bytes[zeros] === 0)
+        zeros += 1;
+    let value = 0n;
+    for (const byte of bytes)
+        value = (value << 8n) | BigInt(byte);
+    let out = "";
+    while (value > 0n) {
+        const remainder = value % 58n;
+        value /= 58n;
+        out = BASE58[Number(remainder)] + out;
+    }
+    return "1".repeat(zeros) + out;
+}
+/** Derives the public did:key identifier from an Ed25519 SPKI. */
+export function didKeyFromEd25519PublicKey(publicKey) {
+    const jwk = publicKey.export({ format: "jwk" });
+    if (typeof jwk.x !== "string")
+        throw new Error("Ed25519 public key JWK export is missing its x-coordinate");
+    const raw = Buffer.from(jwk.x, "base64url");
+    if (raw.length !== 32)
+        throw new Error(`Ed25519 public key raw bytes must be 32 bytes, got ${raw.length}`);
+    return `did:key:z${base58(new Uint8Array([0xed, 0x01, ...raw]))}`;
+}
+/** Fail-closed verification of the Report envelope against the bundle-carried author key. */
+export function verifyReportEnvelopeSignatures(envelopeBytes, key) {
+    try {
+        const envelope = parseDsseEnvelope(envelopeBytes);
+        const preAuth = Buffer.from(dssePreAuthEncoding(envelope.payloadType, envelope.payloadBytes));
+        return { validSignerKeyids: envelope.signatures.flatMap((signature) => {
+                try {
+                    return signature.keyid === key.keyId && verify(null, preAuth, key.publicKey, Buffer.from(signature.sig, "base64")) ? [key.keyId] : [];
+                }
+                catch {
+                    return [];
+                }
+            }) };
+    }
+    catch {
+        return { validSignerKeyids: [] };
+    }
+}

package/dist/profile/trust.d.ts

@@ -0,0 +1,13 @@
+import { type VerifyEnvelopeBindingDeps } from "@jinn-network/trust-core";
+export interface PublicReportTrustMaterial {
+    readonly author: string;
+    readonly keyId: string;
+    readonly didKey: string;
+    readonly algorithm: "ed25519";
+    readonly spkiDerBase64: string;
+    readonly validFrom: string;
+}
+export declare function buildPublicReportTrustDeps(input: {
+    readonly report: PublicReportTrustMaterial;
+    readonly bindingEnvelopeBytes: Uint8Array;
+}): VerifyEnvelopeBindingDeps;

package/dist/profile/trust.js

@@ -0,0 +1,35 @@
+import { createPublicKey } from "node:crypto";
+import { BENCHMARKING_REPORTS_SCOPE } from "@jinn-network/benchmarking-records";
+import { sha256Hex, TRUST_KEY_BINDING_FORMAT } from "@jinn-network/trust-core";
+import { verifyReportEnvelopeSignatures } from "./signing.js";
+export function buildPublicReportTrustDeps(input) {
+    const { report, bindingEnvelopeBytes } = input;
+    if (report.keyId !== report.didKey)
+        throw new Error("report trust keyId must equal didKey");
+    const spkiDer = Buffer.from(report.spkiDerBase64, "base64");
+    const publicKey = createPublicKey({ key: spkiDer, format: "der", type: "spki" });
+    const binding = {
+        binding: {
+            protocol: TRUST_KEY_BINDING_FORMAT,
+            agent: report.author,
+            key: { publicKey: report.spkiDerBase64, keyid: report.keyId, algorithm: report.algorithm, didKey: report.didKey },
+            voucher: { kind: "agentId", caip19: "eip155:1/erc721:0x0000000000000000000000000000000000000000/1" },
+            relationship: "controls",
+            scope: [BENCHMARKING_REPORTS_SCOPE],
+            validFrom: report.validFrom,
+            ceremony: { type: "agentId", digest: `sha256:${sha256Hex(spkiDer)}` },
+            strength: "strong",
+            anchors: [],
+        },
+        envelopeBytes: bindingEnvelopeBytes,
+        bindingDigest: `sha256:${sha256Hex(bindingEnvelopeBytes)}`,
+        effectiveStart: report.validFrom,
+        isGenesis: true,
+        revocations: [],
+    };
+    return {
+        dsseVerifier: (envelopeBytes) => verifyReportEnvelopeSignatures(envelopeBytes, { keyId: report.keyId, publicKey }),
+        bindingResolver: { async resolveBinding(query) { return query.key === report.keyId && query.agent === report.author ? binding : null; } },
+        witnessVerifier: { async verify1271Witness() { return { verified: false, reason: "no 1271 witnesses on the local venue" }; } },
+    };
+}

package/dist/profile/venue.d.ts

@@ -0,0 +1,2 @@
+/** The evaluator identity requirement carried by evaluation Submissions. */
+export declare const EVALUATOR_REQUIREMENT_KEY = "jinn.benchmark-product/evaluator";

package/dist/profile/venue.js

@@ -0,0 +1,2 @@
+/** The evaluator identity requirement carried by evaluation Submissions. */
+export const EVALUATOR_REQUIREMENT_KEY = "jinn.benchmark-product/evaluator";

package/dist/profile/verdict.d.ts

@@ -0,0 +1,28 @@
+import { type KeyObject } from "node:crypto";
+export declare function verdictKeyIdFromEd25519PublicKey(publicKey: KeyObject): string;
+export interface VerdictStatementView {
+    readonly evaluatorId: string;
+    readonly verdict: "pass" | "fail" | "inconclusive";
+    readonly evaluationSpecificationSha256: string;
+    readonly measurements: Record<string, boolean | number | string>;
+    readonly evaluatedAt: string;
+    readonly evaluationMethod?: {
+        readonly name: string;
+        readonly sha256: string;
+    };
+    readonly evidence?: readonly {
+        readonly name: string;
+        readonly sha256: string;
+        readonly mediaType?: string;
+    }[];
+    readonly evaluatorExtensions?: Readonly<Record<string, unknown>>;
+    readonly limitations?: readonly string[];
+}
+export interface OrderedVerdictMeasurement {
+    readonly name: string;
+    readonly value: boolean | number | string;
+}
+/** Parses only the public Result Evaluation Statement projection needed by bundle verification. */
+export declare function readVerdictEnvelope(envelopeBytes: Uint8Array): VerdictStatementView;
+/** Lossless measurement view for contracts that pre-register order as well as names. */
+export declare function readOrderedVerdictMeasurements(envelopeBytes: Uint8Array): readonly OrderedVerdictMeasurement[];

package/dist/profile/verdict.js

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { parseDsseEnvelope } from "@jinn-network/trust-core";
+import { VERDICT_DSSE_PAYLOAD_TYPE } from "@jinn-network/task-execution-profiles";
+import { refuse } from "./errors.js";
+const value = z.union([z.boolean(), z.number(), z.string()]);
+const statement = z.object({ predicate: z.object({ evaluator: z.looseObject({ id: z.string().min(1) }), verdict: z.enum(["pass", "fail", "inconclusive"]), evaluationSpecification: z.looseObject({ digest: z.looseObject({ sha256: z.string().regex(/^[a-f0-9]{64}$/) }) }), evaluationMethod: z.looseObject({ name: z.string().min(1), digest: z.looseObject({ sha256: z.string().regex(/^[a-f0-9]{64}$/) }) }).optional(), measurements: z.array(z.looseObject({ name: z.string().min(1), value })).optional(), evidence: z.array(z.looseObject({ name: z.string().min(1), digest: z.looseObject({ sha256: z.string().regex(/^[a-f0-9]{64}$/) }), mediaType: z.string().optional() })).optional(), evaluatedAt: z.string().min(1), limitations: z.array(z.string()).optional() }) });
+export function verdictKeyIdFromEd25519PublicKey(publicKey) {
+    return `benchmark-product-verdict-${createHash("sha256").update(publicKey.export({ type: "spki", format: "der" })).digest("hex").slice(0, 16)}`;
+}
+/** Parses only the public Result Evaluation Statement projection needed by bundle verification. */
+export function readVerdictEnvelope(envelopeBytes) {
+    const envelope = parseDsseEnvelope(envelopeBytes);
+    if (envelope.payloadType !== VERDICT_DSSE_PAYLOAD_TYPE)
+        refuse("execution", "payloadType", "verdict envelope payloadType is not the verdict DSSE payload type");
+    let json;
+    try {
+        json = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(envelope.payloadBytes));
+    }
+    catch {
+        refuse("execution", "verdict envelope payload", "verdict envelope payload is not valid JSON");
+    }
+    const parsed = statement.safeParse(json);
+    if (!parsed.success)
+        refuse("execution", "verdict envelope payload", "verdict envelope payload does not conform to the expected Result Evaluation Statement shape");
+    const { id: evaluatorId, ...extensions } = parsed.data.predicate.evaluator;
+    return { evaluatorId, verdict: parsed.data.predicate.verdict, evaluationSpecificationSha256: parsed.data.predicate.evaluationSpecification.digest.sha256, measurements: Object.fromEntries((parsed.data.predicate.measurements ?? []).map((measurement) => [measurement.name, measurement.value])), evaluatedAt: parsed.data.predicate.evaluatedAt, ...(parsed.data.predicate.evaluationMethod === undefined ? {} : { evaluationMethod: { name: parsed.data.predicate.evaluationMethod.name, sha256: parsed.data.predicate.evaluationMethod.digest.sha256 } }), ...(parsed.data.predicate.evidence === undefined ? {} : { evidence: parsed.data.predicate.evidence.map((entry) => ({ name: entry.name, sha256: entry.digest.sha256, ...(entry.mediaType === undefined ? {} : { mediaType: entry.mediaType }) })) }), ...(Object.keys(extensions).length === 0 ? {} : { evaluatorExtensions: extensions }), ...(parsed.data.predicate.limitations === undefined ? {} : { limitations: parsed.data.predicate.limitations }) };
+}
+/** Lossless measurement view for contracts that pre-register order as well as names. */
+export function readOrderedVerdictMeasurements(envelopeBytes) {
+    const envelope = parseDsseEnvelope(envelopeBytes);
+    if (envelope.payloadType !== VERDICT_DSSE_PAYLOAD_TYPE) {
+        refuse("execution", "payloadType", "verdict envelope payloadType is not the verdict DSSE payload type");
+    }
+    let json;
+    try {
+        json = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(envelope.payloadBytes));
+    }
+    catch {
+        refuse("execution", "verdict envelope payload", "verdict envelope payload is not valid JSON");
+    }
+    const parsed = statement.safeParse(json);
+    if (!parsed.success) {
+        refuse("execution", "verdict envelope payload", "verdict envelope payload does not conform to the expected Result Evaluation Statement shape");
+    }
+    const measurements = parsed.data.predicate.measurements ?? [];
+    if (new Set(measurements.map((measurement) => measurement.name)).size !== measurements.length) {
+        refuse("execution", "verdict envelope payload", "verdict envelope carries duplicate measurement names");
+    }
+    return measurements.map((measurement) => ({ name: measurement.name, value: measurement.value }));
+}

package/dist/reader-instructions.d.ts

@@ -0,0 +1,41 @@
+export declare const PUBLIC_BUNDLE_VERIFICATION_CHECKS: readonly ["manifest", "evidence-closure", "trust", "matrix-rederivation", "report-verification", "claim-consistency"];
+/** First public npm line. 0.x does not promise compatibility across minors. */
+export declare const PUBLIC_BUNDLE_VERIFIER_MAJOR: "0.1";
+export declare const PUBLIC_BUNDLE_V4_VERIFIER_MAJOR: "0.1";
+/** Exact producer-side verifier for byte-for-byte reproduction. */
+export declare const PUBLIC_BUNDLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+/** Compatible 0.1.x line for fixes that preserve this bundle-format contract. */
+export declare const PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1 <bundle-dir>";
+export declare const PUBLIC_BUNDLE_V4_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+export declare const PUBLIC_BUNDLE_V4_COMPATIBLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1 <bundle-dir>";
+export declare const PUBLIC_BUNDLE_V5_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+export declare const PUBLIC_BUNDLE_V5_COMPATIBLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1 <bundle-dir>";
+export declare const PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+export declare const PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND: "npx @colophon-claims/verify@0.1 <bundle-dir>";
+/**
+ * The anchored closure's check list (anchor-evidence design §8): the six frozen checks plus
+ * `integrity-anchors`, which is **always present** for this format — an anchored bundle whose
+ * anchors were stripped is a closure failure, not a shorter list. Stated as a per-format constant
+ * rather than as an append at the call site, the same way the evidence-native profile states
+ * `EVIDENCE_NATIVE_BUNDLE_V5_CHECKS`.
+ */
+export declare const PUBLIC_BUNDLE_V6_CHECKS: readonly ["manifest", "evidence-closure", "trust", "matrix-rederivation", "report-verification", "claim-consistency", "integrity-anchors"];
+/** Every current format stamps the same first public 0.1 line. */
+export declare const PUBLIC_BUNDLE_VERIFICATION_INSTRUCTIONS: {
+    readonly "benchmark-product-public-bundle/2": {
+        readonly command: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+        readonly compatibleCommand: "npx @colophon-claims/verify@0.1 <bundle-dir>";
+    };
+    readonly "benchmark-product-public-bundle/4": {
+        readonly command: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+        readonly compatibleCommand: "npx @colophon-claims/verify@0.1 <bundle-dir>";
+    };
+    readonly "benchmark-product-public-bundle/5": {
+        readonly command: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+        readonly compatibleCommand: "npx @colophon-claims/verify@0.1 <bundle-dir>";
+    };
+    readonly "benchmark-product-public-bundle/6": {
+        readonly command: "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+        readonly compatibleCommand: "npx @colophon-claims/verify@0.1 <bundle-dir>";
+    };
+};

package/dist/reader-instructions.js

@@ -0,0 +1,52 @@
+export const PUBLIC_BUNDLE_VERIFICATION_CHECKS = [
+    "manifest",
+    "evidence-closure",
+    "trust",
+    "matrix-rederivation",
+    "report-verification",
+    "claim-consistency",
+];
+/** First public npm line. 0.x does not promise compatibility across minors. */
+export const PUBLIC_BUNDLE_VERIFIER_MAJOR = "0.1";
+export const PUBLIC_BUNDLE_V4_VERIFIER_MAJOR = "0.1";
+/** Exact producer-side verifier for byte-for-byte reproduction. */
+export const PUBLIC_BUNDLE_VERIFICATION_COMMAND = "npx @colophon-claims/verify@0.1.0 <bundle-dir>";
+/** Compatible 0.1.x line for fixes that preserve this bundle-format contract. */
+export const PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND = "npx @colophon-claims/verify@0.1 <bundle-dir>";
+export const PUBLIC_BUNDLE_V4_VERIFICATION_COMMAND = PUBLIC_BUNDLE_VERIFICATION_COMMAND;
+export const PUBLIC_BUNDLE_V4_COMPATIBLE_VERIFICATION_COMMAND = PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND;
+export const PUBLIC_BUNDLE_V5_VERIFICATION_COMMAND = PUBLIC_BUNDLE_VERIFICATION_COMMAND;
+export const PUBLIC_BUNDLE_V5_COMPATIBLE_VERIFICATION_COMMAND = PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND;
+export const PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND = PUBLIC_BUNDLE_VERIFICATION_COMMAND;
+export const PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND = PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND;
+/**
+ * The anchored closure's check list (anchor-evidence design §8): the six frozen checks plus
+ * `integrity-anchors`, which is **always present** for this format — an anchored bundle whose
+ * anchors were stripped is a closure failure, not a shorter list. Stated as a per-format constant
+ * rather than as an append at the call site, the same way the evidence-native profile states
+ * `EVIDENCE_NATIVE_BUNDLE_V5_CHECKS`.
+ */
+export const PUBLIC_BUNDLE_V6_CHECKS = [
+    ...PUBLIC_BUNDLE_VERIFICATION_CHECKS,
+    "integrity-anchors",
+];
+/** Every current format stamps the same first public 0.1 line. */
+export const PUBLIC_BUNDLE_VERIFICATION_INSTRUCTIONS = {
+    [BUNDLE_FORMAT]: {
+        command: PUBLIC_BUNDLE_VERIFICATION_COMMAND,
+        compatibleCommand: PUBLIC_BUNDLE_COMPATIBLE_VERIFICATION_COMMAND,
+    },
+    [BUNDLE_V4_FORMAT]: {
+        command: PUBLIC_BUNDLE_V4_VERIFICATION_COMMAND,
+        compatibleCommand: PUBLIC_BUNDLE_V4_COMPATIBLE_VERIFICATION_COMMAND,
+    },
+    [BUNDLE_V5_FORMAT]: {
+        command: PUBLIC_BUNDLE_V5_VERIFICATION_COMMAND,
+        compatibleCommand: PUBLIC_BUNDLE_V5_COMPATIBLE_VERIFICATION_COMMAND,
+    },
+    [BUNDLE_V6_FORMAT]: {
+        command: PUBLIC_BUNDLE_V6_VERIFICATION_COMMAND,
+        compatibleCommand: PUBLIC_BUNDLE_V6_COMPATIBLE_VERIFICATION_COMMAND,
+    },
+};
+import { BUNDLE_FORMAT, BUNDLE_V4_FORMAT, BUNDLE_V5_FORMAT, BUNDLE_V6_FORMAT } from "./manifest.js";