sello 0.1.1 → 0.1.2

package/dist/log/mock-log.js

@@ -0,0 +1,147 @@
+import { sha256, assertTokenRef, toHex } from "../crypto/identifiers.js";
+import { decodeProtectedHeader } from "../cose/protected-header.js";
+import { decodeReceiptEnvelope } from "../cose/sign1.js";
+import {
+                       
+  assertCanonicalLogUrl,
+  logUrlsEqual,
+} from "./canonical-url.js";
+export class MockTransparencyLog {
+           logUrl                 ;
+  #entries                 = [];
+  #tokenIndex = new Map                  ();
+
+  constructor(logUrl                 ) {
+    assertCanonicalLogUrl(logUrl, "logUrl");
+    this.logUrl = logUrl;
+  }
+
+  append(envelope            , integratedTime = nowUtcSeconds())               {
+    assertBytes(envelope, "envelope");
+    assertUtcTimestamp(integratedTime, "integratedTime");
+
+    const decodedEnvelope = decodeReceiptEnvelope(envelope);
+    const protectedHeader = decodeProtectedHeader(decodedEnvelope.protectedBytes);
+    if (!logUrlsEqual(protectedHeader.sello_log_url, this.logUrl)) {
+      throw new TypeError("envelope sello_log_url must match mock log URL");
+    }
+
+    const index = this.#entries.length;
+    const proof = buildProof(this.logUrl, index, integratedTime, envelope);
+    const entry = freezeEntry({
+      logUrl: this.logUrl,
+      index,
+      integratedTime,
+      envelope,
+      proof,
+    });
+
+    this.#entries.push(entry);
+
+    const tokenRefHex = toHex(protectedHeader.sello_token_ref);
+    const indexes = this.#tokenIndex.get(tokenRefHex) ?? [];
+    indexes.push(index);
+    this.#tokenIndex.set(tokenRefHex, indexes);
+
+    return cloneEntry(entry);
+  }
+
+  queryByTokenRef(tokenRef            )                     {
+    assertTokenRef(tokenRef, "tokenRef");
+    const indexes = this.#tokenIndex.get(toHex(tokenRef)) ?? [];
+
+    return {
+      completeness: "complete",
+      entries: indexes.map((index) => cloneEntry(this.#entries[index])),
+    };
+  }
+
+  verifyInclusionProof(entry              )          {
+    try {
+      assertCanonicalLogUrl(entry.logUrl, "entry.logUrl");
+      if (!logUrlsEqual(entry.logUrl, this.logUrl)) {
+        return false;
+      }
+
+      const expected = buildProof(
+        this.logUrl,
+        entry.index,
+        entry.integratedTime,
+        entry.envelope,
+      );
+
+      return (
+        entry.proof.logUrl === expected.logUrl &&
+        entry.proof.index === expected.index &&
+        entry.proof.integratedTime === expected.integratedTime &&
+        entry.proof.envelopeHash === expected.envelopeHash &&
+        entry.proof.proofHash === expected.proofHash
+      );
+    } catch {
+      return false;
+    }
+  }
+}
+
+function buildProof(
+  logUrl                 ,
+  index        ,
+  integratedTime        ,
+  envelope            ,
+)                     {
+  const envelopeHash = toHex(sha256(envelope));
+  const proofHash = toHex(
+    sha256(
+      new TextEncoder().encode(
+        `${logUrl}\n${index}\n${integratedTime}\n${envelopeHash}`,
+      ),
+    ),
+  );
+
+  return {
+    logUrl,
+    index,
+    integratedTime,
+    envelopeHash,
+    proofHash,
+  };
+}
+
+function freezeEntry(entry              )               {
+  return {
+    logUrl: entry.logUrl,
+    index: entry.index,
+    integratedTime: entry.integratedTime,
+    envelope: new Uint8Array(entry.envelope),
+    proof: { ...entry.proof },
+  };
+}
+
+function cloneEntry(entry              )               {
+  return {
+    logUrl: entry.logUrl,
+    index: entry.index,
+    integratedTime: entry.integratedTime,
+    envelope: new Uint8Array(entry.envelope),
+    proof: { ...entry.proof },
+  };
+}
+
+function nowUtcSeconds()         {
+  return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
+function assertUtcTimestamp(value        , name        )       {
+  if (
+    !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(value) ||
+    Number.isNaN(Date.parse(value))
+  ) {
+    throw new TypeError(`${name} must be an RFC 3339 UTC timestamp`);
+  }
+}
+
+function assertBytes(value         , name        )                              {
+  if (!(value instanceof Uint8Array)) {
+    throw new TypeError(`${name} must be a Uint8Array`);
+  }
+}

package/dist/log/rekor.js

@@ -0,0 +1,120 @@
+import { decodeProtectedHeader } from "../cose/protected-header.js";
+import { decodeReceiptEnvelope } from "../cose/sign1.js";
+import { assertTokenRef, toHex } from "../crypto/identifiers.js";
+import {
+                       
+  assertCanonicalLogUrl,
+  logUrlsEqual,
+} from "./canonical-url.js";
+export class RekorDiscoveryLog {
+           logUrl                 ;
+  #entries                 = [];
+  #verifyInclusionProof                    ;
+
+  constructor(input                        ) {
+    assertCanonicalLogUrl(input.logUrl, "logUrl");
+    this.logUrl = input.logUrl;
+    this.#verifyInclusionProof = input.verifyInclusionProof ?? (() => false);
+
+    for (const entry of input.entries ?? []) {
+      this.addDiscoveredEntry(entry);
+    }
+  }
+
+  addDiscoveredEntry(input                           )                       {
+    const entryLogUrl = input.logUrl ?? this.logUrl;
+    assertCanonicalLogUrl(entryLogUrl, "entry.logUrl");
+    assertUtcTimestamp(input.integratedTime, "integratedTime");
+    assertSafeIndex(input.index);
+    assertBytes(input.envelope, "envelope");
+
+    const tokenRefHex = input.tokenRef
+      ? tokenRefToHex(input.tokenRef)
+      : tokenRefFromEnvelope(input.envelope);
+
+    const entry = cloneEntry({
+      logUrl: entryLogUrl,
+      index: input.index,
+      integratedTime: input.integratedTime,
+      envelope: input.envelope,
+      proof: input.proof,
+    });
+
+    this.#entries.push({ tokenRefHex, entry });
+    return cloneEntry(entry);
+  }
+
+  queryByTokenRef(tokenRef            )                             {
+    const tokenRefHex = tokenRefToHex(tokenRef);
+
+    return {
+      completeness: "discovery-only",
+      entries: this.#entries
+        .filter((indexed) => indexed.tokenRefHex === tokenRefHex)
+        .map((indexed) => cloneEntry(indexed.entry)),
+    };
+  }
+
+  verifyInclusionProof(entry                      )          {
+    try {
+      assertCanonicalLogUrl(entry.logUrl, "entry.logUrl");
+      if (!logUrlsEqual(entry.logUrl, this.logUrl)) {
+        return false;
+      }
+
+      return this.#verifyInclusionProof(entry);
+    } catch {
+      return false;
+    }
+  }
+}
+
+function tokenRefFromEnvelope(envelope            )         {
+  const decodedEnvelope = decodeReceiptEnvelope(envelope);
+  const protectedHeader = decodeProtectedHeader(decodedEnvelope.protectedBytes);
+  return tokenRefToHex(protectedHeader.sello_token_ref);
+}
+
+function tokenRefToHex(tokenRef            )         {
+  assertTokenRef(tokenRef, "tokenRef");
+  return toHex(tokenRef);
+}
+
+function cloneEntry(entry                      )                       {
+  return {
+    logUrl: entry.logUrl,
+    index: entry.index,
+    integratedTime: entry.integratedTime,
+    envelope: new Uint8Array(entry.envelope),
+    proof: cloneProof(entry.proof),
+  };
+}
+
+function cloneProof(proof         )          {
+  if (proof === null || typeof proof !== "object") {
+    return proof;
+  }
+
+  return globalThis.structuredClone(proof);
+}
+
+function assertUtcTimestamp(value        , name        )       {
+  if (
+    !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(value) ||
+    Number.isNaN(Date.parse(value))
+  ) {
+    throw new TypeError(`${name} must be an RFC 3339 UTC timestamp`);
+  }
+}
+
+function assertSafeIndex(index        )       {
+  if (!Number.isSafeInteger(index) || index < 0) {
+    throw new TypeError("index must be a non-negative safe integer");
+  }
+}
+
+function assertBytes(value         , name        )                              {
+  if (!(value instanceof Uint8Array)) {
+    throw new TypeError(`${name} must be a Uint8Array`);
+  }
+}

package/dist/mcp/middleware.js

@@ -0,0 +1,162 @@
+import { createReceipt,                     } from "../service/create-receipt.js";
+import { verifySelloJwsToken } from "../token/jws-profile.js";
+export class SelloMcpDeniedError extends Error {
+           receipt                ;
+
+  constructor(receipt                ) {
+    super("MCP request denied by Sello middleware");
+    this.name = "SelloMcpDeniedError";
+    this.receipt = receipt;
+  }
+}
+
+export function createSelloMcpMiddleware                   (
+  input                                            ,
+)                                     {
+  return async (request         )                    => {
+    const authorizationToken = resolveValue(input.authorizationToken, request);
+    const verifiedToken = verifySelloJwsToken({
+      authorizationToken,
+      issuerPublicKey: input.tokenIssuerPublicKey,
+    });
+    const baseReceiptInput = {
+      authorizationTokenBytes: verifiedToken.authorizationTokenBytes,
+      ownerHpkePublicKey: verifiedToken.ownerHpkePublicKey,
+      selloLogs: verifiedToken.selloLogs ?? input.fallbackSelloLogs ?? [],
+      serviceKid: input.serviceKid,
+      servicePrivateKey: input.servicePrivateKey,
+      serviceIdentifier: input.serviceIdentifier,
+      log: input.log,
+      actionType: resolveActionType(input.actionType, request),
+      actionInputBytes: (input.canonicalizeInput ?? canonicalJsonBytes)(request),
+      timestamp: (input.now ?? nowUtcSeconds)(),
+    };
+
+    if (input.isDenied && (await input.isDenied(request))) {
+      const response = input.deniedResponse
+        ? await input.deniedResponse(request)
+        : undefined;
+      const receipt = createReceipt({
+        ...baseReceiptInput,
+        actionOutputBytes: new Uint8Array(),
+        resultStatus: "denied",
+      });
+      input.onReceipt?.({ resultStatus: "denied", receipt, response });
+
+      if (input.deniedResponse) {
+        return response            ;
+      }
+
+      throw new SelloMcpDeniedError(receipt);
+    }
+
+    let response          ;
+    try {
+      response = await input.handler(request);
+    } catch (error) {
+      const receipt = createReceipt({
+        ...baseReceiptInput,
+        actionOutputBytes: (input.canonicalizeError ?? canonicalErrorBytes)(
+          error,
+        ),
+        resultStatus: "error",
+      });
+      input.onReceipt?.({ resultStatus: "error", receipt, error });
+      throw error;
+    }
+
+    const receipt = createReceipt({
+      ...baseReceiptInput,
+      actionOutputBytes: (input.canonicalizeOutput ?? canonicalJsonBytes)(
+        response,
+      ),
+      resultStatus: "success",
+    });
+    input.onReceipt?.({ resultStatus: "success", receipt, response });
+    return response;
+  };
+}
+
+export function canonicalJsonBytes(value         )             {
+  return new TextEncoder().encode(canonicalJson(value));
+}
+
+function canonicalJson(value         )         {
+  if (value === null) {
+    return "null";
+  }
+
+  switch (typeof value) {
+    case "boolean":
+    case "number":
+    case "string":
+      return primitiveJson(value);
+    case "object":
+      if (Array.isArray(value)) {
+        return `[${value.map(canonicalJson).join(",")}]`;
+      }
+
+      return objectJson(value                           );
+    default:
+      throw new TypeError("value must be JSON-serializable");
+  }
+}
+
+function primitiveJson(value                           )         {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new TypeError("number must be finite");
+  }
+
+  return JSON.stringify(value);
+}
+
+function objectJson(value                         )         {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError("object must be a plain JSON object");
+  }
+
+  const entries = Object.entries(value);
+  entries.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+
+  return `{${entries
+    .map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`)
+    .join(",")}}`;
+}
+
+function canonicalErrorBytes(error         )             {
+  if (error instanceof Error) {
+    return canonicalJsonBytes({
+      name: error.name,
+      message: error.message,
+    });
+  }
+
+  return canonicalJsonBytes({ error: String(error) });
+}
+
+function resolveValue                (
+  value                                       ,
+  request         ,
+)        {
+  if (typeof value === "function") {
+    return (value                               )(request);
+  }
+
+  return value;
+}
+
+function resolveActionType         (
+  actionType                                                         ,
+  request         ,
+)         {
+  if (typeof actionType === "function") {
+    return actionType(request);
+  }
+
+  return actionType ?? "tools/call";
+}
+
+function nowUtcSeconds()         {
+  return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}

package/dist/owner/verify.js

@@ -0,0 +1,271 @@
+import { decodeProtectedHeader } from "../cose/protected-header.js";
+import { decodeReceiptEnvelope, verifyReceiptEnvelope } from "../cose/sign1.js";
+import { deriveTokenIdentifiers, toHex } from "../crypto/identifiers.js";
+import { openReceiptBody } from "../hpke/receipt.js";
+import {
+                       
+  logUrlsEqual,
+} from "../log/canonical-url.js";
+import { decodeReceiptBody,                  } from "../receipt/body.js";
+import {
+                            
+  assertKeyNotRevoked,
+  resolveServiceKey,
+} from "../registry/json-registry.js";
+
+                                       
+                      
+                   
+                            
+                        
+                 
+                 
+                           
+                      
+                           
+
+                                   
+                                      
+                                          
+                                 
+                              
+  
+
+                               
+                                
+                       
+                            
+                 
+                      
+                          
+                                   
+                         
+                       
+                              
+  
+
+                               
+                     
+                                  
+                  
+                           
+                          
+  
+
+                                    
+                              
+                              
+  
+
+export function verifyReceipts(input                     )                       {
+  const identifiers = deriveTokenIdentifiers(input.authorizationTokenBytes);
+  const trustedLogUrls = input.trustedLogs.map((log) => log.logUrl);
+  const receipts                    = [];
+  const rejected                    = [];
+  const exactDedup = new Map                ();
+  const sameSecond = new Map                ();
+
+  for (const log of input.trustedLogs) {
+    const result = log.queryByTokenRef(identifiers.sello_token_ref);
+
+    for (const entry of result.entries) {
+      const verified = verifyOneEntry({
+        entry,
+        log,
+        logCompleteness: result.completeness,
+        trustedLogUrls,
+        tokenRef: identifiers.sello_token_ref,
+        registry: input.registry,
+        ownerPrivateKey: input.ownerPrivateKey,
+      });
+
+      if (verified.status === "rejected") {
+        rejected.push(verified);
+        continue;
+      }
+
+      const exactKey = buildExactDedupKey(verified);
+      const existingIndex = exactDedup.get(exactKey);
+
+      if (existingIndex !== undefined) {
+        receipts.push({
+          ...verified,
+          status: "duplicate",
+          duplicateOf: existingIndex,
+        });
+        continue;
+      }
+
+      const sameSecondKey = buildSameSecondKey(verified);
+      const sameSecondIndex = sameSecond.get(sameSecondKey);
+
+      if (sameSecondIndex !== undefined) {
+        receipts[sameSecondIndex] = {
+          ...receipts[sameSecondIndex],
+          sameSecondActivity: true,
+        };
+        verified.sameSecondActivity = true;
+      } else {
+        sameSecond.set(sameSecondKey, receipts.length);
+      }
+
+      exactDedup.set(exactKey, receipts.length);
+      receipts.push(verified);
+    }
+  }
+
+  return { receipts, rejected };
+}
+
+                            
+                              
+                       
+                                   
+                                             
+                       
+                                 
+                              
+  
+
+function verifyOneEntry(input                     )                                    {
+  let protectedHeaderBytes            ;
+  let payload            ;
+  let protectedHeader                                          ;
+
+  try {
+    const envelope = decodeReceiptEnvelope(input.entry.envelope);
+    protectedHeaderBytes = envelope.protectedBytes;
+    payload = envelope.payload;
+    protectedHeader = decodeProtectedHeader(protectedHeaderBytes);
+  } catch (error) {
+    return reject("invalid_receipt_body", error, input.entry);
+  }
+
+  if (!logUrlsEqual(protectedHeader.sello_log_url, input.log.logUrl)) {
+    return reject(
+      "log_url_mismatch",
+      "receipt log URL does not match returning log",
+      input.entry,
+    );
+  }
+
+  if (!input.trustedLogUrls.some((logUrl) => logUrlsEqual(logUrl, input.log.logUrl))) {
+    return reject("untrusted_log", "returning log is not trusted", input.entry);
+  }
+
+  if (!bytesEqual(protectedHeader.sello_token_ref, input.tokenRef)) {
+    return reject(
+      "token_ref_mismatch",
+      "receipt token ref does not match requested token",
+      input.entry,
+    );
+  }
+
+  if (!input.log.verifyInclusionProof(input.entry)) {
+    return reject("inclusion_proof_failed", "inclusion proof failed", input.entry);
+  }
+
+  let service;
+  try {
+    service = resolveServiceKey(input.registry, protectedHeader.kid);
+  } catch (error) {
+    return reject("unknown_kid", error, input.entry);
+  }
+
+  try {
+    assertKeyNotRevoked(
+      input.registry,
+      protectedHeader.kid,
+      input.entry.integratedTime,
+    );
+  } catch (error) {
+    return reject("revoked_key", error, input.entry);
+  }
+
+  try {
+    verifyReceiptEnvelope({
+      envelope: input.entry.envelope,
+      servicePublicKey: service.publicKeyEd25519,
+    });
+  } catch (error) {
+    return reject("cose_signature_failed", error, input.entry);
+  }
+
+  let plaintext;
+  try {
+    plaintext = openReceiptBody({
+      payload,
+      ownerPrivateKey: input.ownerPrivateKey,
+      protectedHeaderBytes,
+      serviceIdentifier: service.serviceIdentifier,
+      selloTokenRef: protectedHeader.sello_token_ref,
+    });
+  } catch (error) {
+    return reject("hpke_open_failed", error, input.entry);
+  }
+
+  try {
+    return {
+      status: "valid",
+      receipt: decodeReceiptBody(plaintext),
+      serviceIdentifier: service.serviceIdentifier,
+      kidHex: toHex(protectedHeader.kid),
+      tokenRefHex: toHex(protectedHeader.sello_token_ref),
+      logUrl: input.log.logUrl,
+      logCompleteness: input.logCompleteness,
+      integratedTime: input.entry.integratedTime,
+      sameSecondActivity: false,
+    };
+  } catch (error) {
+    return reject("invalid_receipt_body", error, input.entry);
+  }
+}
+
+function buildExactDedupKey(record                 )         {
+  return [
+    buildSameSecondKey(record),
+    record.receipt["action-type"],
+    toHex(record.receipt["action-input-hash"]),
+    toHex(record.receipt["action-output-hash"]),
+  ].join("|");
+}
+
+function buildSameSecondKey(record                 )         {
+  return [
+    record.kidHex,
+    record.tokenRefHex,
+    truncateTimestampToSecond(record.receipt.timestamp),
+  ].join("|");
+}
+
+function truncateTimestampToSecond(timestamp        )         {
+  return timestamp.replace(/\.\d+Z$/, "Z");
+}
+
+function reject(
+  code                           ,
+  error         ,
+  entry                      ,
+)                  {
+  return {
+    status: "rejected",
+    code,
+    message: error instanceof Error ? error.message : String(error),
+    logUrl: entry.logUrl,
+    integratedTime: entry.integratedTime,
+  };
+}
+
+function bytesEqual(a            , b            )          {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+
+  for (let index = 0; index < a.byteLength; index += 1) {
+    if (a[index] !== b[index]) {
+      return false;
+    }
+  }
+
+  return true;
+}