@openeudi/openid4vp 0.7.0 → 0.8.1

package/README.md

@@ -338,6 +338,10 @@ This library implements the **verifier side** of OpenID4VP for SD-JWT VC and mDO
 
 EUDI Architecture Reference Framework (ARF) alignment: tracks OpenID4VP 1.0 final. Full ARF 1.4+ profile compliance will be added before a stable 1.0.
 
+## OIDF Conformance Testing
+
+Verifier-side conformance is automated against a self-hosted OpenID Foundation conformance suite. See `docs/manual-testing/oidf-interop.md` for both the CI orchestrator (`npm run oidf:ci -- --profile=happy-flow|full`) and the manual hosted-demo escape hatch.
+
 ## Related packages
 
 - **[@openeudi/core](https://www.npmjs.com/package/@openeudi/core)** -- Framework-agnostic EUDI Wallet verification protocol engine with session management and QR code generation.

package/dist/index.cjs

@@ -6382,6 +6382,33 @@ var init_es20152 = __esm({
     init_validity();
   }
 });
+function getSkiHex(cert) {
+  const ext = cert.getExtension(x509.SubjectKeyIdentifierExtension);
+  return ext ? ext.keyId.toLowerCase() : null;
+}
+function certificatesEqual(a, b) {
+  const ab = new Uint8Array(a.rawData);
+  const bb = new Uint8Array(b.rawData);
+  if (ab.length !== bb.length) return false;
+  for (let i = 0; i < ab.length; i++) {
+    if (ab[i] !== bb[i]) return false;
+  }
+  return true;
+}
+function getSkiBytes(cert) {
+  const ext = cert.getExtension(x509.SubjectKeyIdentifierExtension);
+  if (!ext) return null;
+  const hex = ext.keyId;
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+var init_x509_utils = __esm({
+  "src/trust/x509-utils.ts"() {
+  }
+});
 function mapX509AlgoToJwaName(cert) {
   const alg = cert.signatureAlgorithm;
   const name = alg?.name ?? "";
@@ -6391,8 +6418,11 @@ function mapX509AlgoToJwaName(cert) {
   if (name === "ECDSA" && hash === "SHA-512") return "ES512";
   if (name === "Ed25519" || name === "EdDSA") return "EdDSA";
   if (name === "RSASSA-PKCS1-v1_5" && hash === "SHA-256") return "RS256";
+  if (name === "RSASSA-PKCS1-v1_5" && hash === "SHA-384") return "RS384";
+  if (name === "RSASSA-PKCS1-v1_5" && hash === "SHA-512") return "RS512";
   if (name === "RSA-PSS" && hash === "SHA-256") return "PS256";
   if (name === "RSA-PSS" && hash === "SHA-384") return "PS384";
+  if (name === "RSA-PSS" && hash === "SHA-512") return "PS512";
   return `${name}-${hash}`;
 }
 function collectLeafNames(leaf) {
@@ -6485,8 +6515,20 @@ var init_ChainBuilder = __esm({
     init_es2015();
     init_es20152();
     init_errors();
+    init_x509_utils();
     NAME_CONSTRAINTS_OID = "2.5.29.30";
-    DEFAULT_ALGORITHMS = ["ES256", "ES384", "EdDSA", "RS256", "PS256"];
+    DEFAULT_ALGORITHMS = [
+      "ES256",
+      "ES384",
+      "ES512",
+      "EdDSA",
+      "RS256",
+      "RS384",
+      "RS512",
+      "PS256",
+      "PS384",
+      "PS512"
+    ];
     ChainBuilder = class {
       constructor(opts = {}) {
         this.opts = opts;
@@ -6545,6 +6587,12 @@ var init_ChainBuilder = __esm({
           current = issuer;
           nonLeafDepth += 1;
         }
+        if (!certificatesEqual(current, anchor)) {
+          throw new exports.CertificateChainError(
+            `certificate ${current.subject} shares the trust anchor's Subject DN but is not the anchor (no signature closure)`,
+            { reason: "signature" }
+          );
+        }
         this.checkNameConstraints(leaf, chain.slice(1));
         return chain;
       }
@@ -7785,7 +7833,10 @@ var init_RevocationChecker = __esm({
         if (hints.ocspUrl) {
           try {
             return await this.ocsp.checkCached(subjectCert, issuerCert, hints.ocspUrl, now);
-          } catch {
+          } catch (err) {
+            console.warn(
+              `[openid4vp] OCSP check failed for ${subjectCert.subject} via ${hints.ocspUrl}, falling back to CRL: ${err.message}`
+            );
           }
         }
         for (const url of hints.crlUrls) {
@@ -7813,6 +7864,9 @@ var init_RevocationChecker = __esm({
             return { status: "good", source: "crl", checkedAt: now };
           } catch (err) {
             if (err instanceof exports.RevocationCheckFailedError) throw err;
+            console.warn(
+              `[openid4vp] CRL check failed for ${subjectCert.subject} via ${url}: ${err.message}`
+            );
             continue;
           }
         }
@@ -7831,24 +7885,6 @@ var init_RevocationChecker = __esm({
     };
   }
 });
-function getSkiHex(cert) {
-  const ext = cert.getExtension(x509.SubjectKeyIdentifierExtension);
-  return ext ? ext.keyId.toLowerCase() : null;
-}
-function getSkiBytes(cert) {
-  const ext = cert.getExtension(x509.SubjectKeyIdentifierExtension);
-  if (!ext) return null;
-  const hex = ext.keyId;
-  const out = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-var init_x509_utils = __esm({
-  "src/trust/x509-utils.ts"() {
-  }
-});
 
 // src/trust/lotl-loa-mapping.ts
 function mapLoA(uris) {
@@ -8030,8 +8066,13 @@ var init_TrustEvaluator = __esm({
         );
         const terminusCert = chain[chain.length - 1];
         const anchor = anchors.find(
-          (a) => a.certificate.serialNumber === terminusCert.serialNumber
-        ) ?? anchors[0];
+          (a) => certificatesEqual(a.certificate, terminusCert)
+        );
+        if (!anchor) {
+          throw new exports.TrustAnchorNotFoundError(
+            `chain terminus ${terminusCert.subject} does not match any trust anchor certificate`
+          );
+        }
         const issuerForRevocation = chain.length > 1 ? chain[1] : terminusCert;
         const revocation = await this.revocationChecker.check(
           leaf,
@@ -8159,7 +8200,10 @@ async function createSignedAuthorizationRequest(input, query) {
     }
     const jwk = { ...input.encryptionKey.publicJwk, use: "enc" };
     clientMetadata.jwks = { keys: [jwk] };
-    clientMetadata.encrypted_response_enc_values_supported = enc ?? [...DEFAULT_SUPPORTED_ENC_VALUES];
+    const encValues = enc ?? [...DEFAULT_SUPPORTED_ENC_VALUES];
+    clientMetadata.encrypted_response_enc_values_supported = encValues;
+    clientMetadata.authorization_encrypted_response_alg = "ECDH-ES";
+    clientMetadata.authorization_encrypted_response_enc = encValues[0];
   }
   const payload = {
     iss: clientId,
@@ -8332,7 +8376,7 @@ function isHaipQuery(query) {
 
 // src/crypto/cose-sign1.ts
 init_errors();
-var decoder = new cborX.Encoder({ mapsAsObjects: false, useRecords: false });
+var decoder = new cborX.Encoder({ mapsAsObjects: false, useRecords: false, tagUint8Array: false });
 var HEADER_ALG = 1;
 var HEADER_X5CHAIN = 33;
 var COSE_ALG_TO_NAME = {
@@ -8418,7 +8462,7 @@ async function verifyCoseSign1(coseSign1, publicKey, allowedAlgorithms) {
     throw new exports.MalformedCredentialError(`no hash mapping for alg ${coseSign1.alg}`);
   }
   const sigStructure = ["Signature1", coseSign1.protectedHeaderBytes, new Uint8Array(0), coseSign1.payload];
-  const sigInput = decoder.encode(sigStructure);
+  const sigInput = new Uint8Array(decoder.encode(sigStructure));
   const ok = await crypto.subtle.verify(
     { name: "ECDSA", hash: hashAlg },
     publicKey,
@@ -8957,32 +9001,74 @@ var SdJwtParser = class {
       return invalidResult(`Unsupported algorithm: ${alg}`);
     }
     const x5cArray = header.x5c;
-    if (!Array.isArray(x5cArray) || x5cArray.length === 0 || typeof x5cArray[0] !== "string") {
-      throw new exports.MalformedCredentialError("Missing or invalid x5c in JWT header");
-    }
+    const hasX5c = Array.isArray(x5cArray) && x5cArray.length > 0 && typeof x5cArray[0] === "string";
     let issuerKey;
     let issuerCertBytes;
-    try {
-      issuerKey = await jose.importX509(derToPem2(x5cArray[0]), alg);
-      issuerCertBytes = base64ToBytes(x5cArray[0]);
-    } catch (err) {
-      if (err instanceof exports.MalformedCredentialError) throw err;
-      throw new exports.MalformedCredentialError("Failed to import issuer certificate");
+    if (hasX5c) {
+      try {
+        issuerKey = await jose.importX509(derToPem2(x5cArray[0]), alg);
+        issuerCertBytes = base64ToBytes(x5cArray[0]);
+      } catch (err) {
+        if (err instanceof exports.MalformedCredentialError) throw err;
+        throw new exports.MalformedCredentialError("Failed to import issuer certificate");
+      }
+    } else if (options.trustedIssuerJwks && options.trustedIssuerJwks.length > 0) {
+      issuerKey = void 0;
+    } else {
+      throw new exports.MalformedCredentialError("Missing or invalid x5c in JWT header");
     }
     let payload;
-    try {
-      const result2 = await jose.jwtVerify(parts.jwt, issuerKey, { algorithms: allowedAlgorithms });
-      payload = result2.payload;
-    } catch {
-      return invalidResult("Issuer JWT signature verification failed");
+    if (issuerKey) {
+      try {
+        const result2 = await jose.jwtVerify(parts.jwt, issuerKey, { algorithms: allowedAlgorithms });
+        payload = result2.payload;
+      } catch {
+        return invalidResult("Issuer JWT signature verification failed");
+      }
+    } else {
+      const jwks = options.trustedIssuerJwks;
+      const headerKid = header["kid"];
+      let candidates;
+      if (typeof headerKid === "string") {
+        const matched = jwks.find((k) => k["kid"] === headerKid);
+        if (!matched) {
+          return invalidResult(
+            `No matching JWK found in trustedIssuerJwks for kid=${headerKid}`
+          );
+        }
+        candidates = [matched];
+      } else {
+        candidates = jwks;
+      }
+      let verifiedPayload;
+      for (const jwk of candidates) {
+        let candidateKey;
+        try {
+          candidateKey = await jose.importJWK(jwk, alg);
+        } catch {
+          continue;
+        }
+        try {
+          const result2 = await jose.jwtVerify(parts.jwt, candidateKey, {
+            algorithms: allowedAlgorithms
+          });
+          verifiedPayload = result2.payload;
+          break;
+        } catch {
+        }
+      }
+      if (!verifiedPayload) {
+        return invalidResult("Issuer JWT signature verification failed");
+      }
+      payload = verifiedPayload;
     }
     const issuerString = typeof payload["iss"] === "string" ? payload["iss"] : "";
     const issuerInfo = {
-      certificate: issuerCertBytes,
+      certificate: issuerCertBytes ?? new Uint8Array(),
       country: extractCountryHint(issuerString)
     };
     let trustResult;
-    if (options.trustStore) {
+    if (issuerCertBytes === void 0) ; else if (options.trustStore) {
       const { TrustEvaluator: TrustEvaluator2 } = await Promise.resolve().then(() => (init_TrustEvaluator(), TrustEvaluator_exports));
       const evaluator = new TrustEvaluator2({
         trustStore: options.trustStore,
@@ -9002,24 +9088,56 @@ var SdJwtParser = class {
           );
         }
       } else {
-        const isTrusted = options.trustedCertificates.some((trusted) => bytesEqual4(trusted, issuerCertBytes));
+        const isTrusted = options.trustedCertificates.some(
+          (trusted) => bytesEqual4(trusted, issuerCertBytes)
+        );
         if (!isTrusted) {
           return invalidResult("Issuer certificate is not trusted");
         }
       }
     }
-    const sdArray = payload["_sd"];
     if (parts.disclosures.length > 0) {
-      if (!Array.isArray(sdArray) || sdArray.length === 0) {
-        return invalidResult("Disclosures present but no _sd array in issuer JWT");
-      }
+      const decodedDisclosures = [];
       for (const disclosure of parts.disclosures) {
+        let parsed;
+        try {
+          parsed = JSON.parse(new TextDecoder().decode(base64ToBytes(disclosure)));
+        } catch {
+          return invalidResult("Disclosure is not valid base64url-encoded JSON");
+        }
+        if (!Array.isArray(parsed) || parsed.length !== 2 && parsed.length !== 3) {
+          return invalidResult("Disclosure must be a 2- or 3-element array");
+        }
         const hashBytes = await sha256Hasher(disclosure);
-        const hashB64url = bytesToBase64url(hashBytes);
-        if (!sdArray.includes(hashB64url)) {
-          return invalidResult("Disclosure hash mismatch");
+        decodedDisclosures.push({
+          raw: disclosure,
+          hash: bytesToBase64url(hashBytes),
+          length: parsed.length,
+          value: parsed.length === 3 ? parsed[2] : parsed[1]
+        });
+      }
+      const seed = collectAnchorHashes(payload);
+      const kvHashes = seed.kvHashes;
+      const arrayElemHashes = seed.arrayElemHashes;
+      const remaining = [...decodedDisclosures];
+      for (; ; ) {
+        const anchored = [];
+        for (const d of remaining) {
+          const valid = d.length === 3 ? kvHashes.has(d.hash) : arrayElemHashes.has(d.hash);
+          if (valid) anchored.push(d);
+        }
+        if (anchored.length === 0) break;
+        for (const a of anchored) {
+          const sub = collectAnchorHashes(a.value);
+          for (const h of sub.kvHashes) kvHashes.add(h);
+          for (const h of sub.arrayElemHashes) arrayElemHashes.add(h);
+          const idx = remaining.indexOf(a);
+          if (idx >= 0) remaining.splice(idx, 1);
         }
       }
+      if (remaining.length > 0) {
+        return invalidResult("Disclosure hash mismatch");
+      }
     }
     if (parts.kbJwt) {
       const cnf = payload["cnf"];
@@ -9082,6 +9200,35 @@ var SdJwtParser = class {
     return result;
   }
 };
+function collectAnchorHashes(node) {
+  const kvHashes = /* @__PURE__ */ new Set();
+  const arrayElemHashes = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          const obj = item;
+          const keys = Object.keys(obj);
+          if (keys.length === 1 && keys[0] === "..." && typeof obj["..."] === "string") {
+            arrayElemHashes.add(obj["..."]);
+            continue;
+          }
+        }
+        visit(item);
+      }
+    } else if (value && typeof value === "object") {
+      for (const [k, v] of Object.entries(value)) {
+        if (k === "_sd" && Array.isArray(v)) {
+          for (const h of v) if (typeof h === "string") kvHashes.add(h);
+          continue;
+        }
+        visit(v);
+      }
+    }
+  };
+  visit(node);
+  return { kvHashes, arrayElemHashes };
+}
 
 // src/presentation.ts
 var parsers = [new SdJwtParser(), new MdocParser()];
@@ -9821,7 +9968,7 @@ function equalBytes(a, b) {
 
 // src/index.ts
 init_errors();
-var VERSION = "0.7.0";
+var VERSION = "0.8.0";
 /*! Bundled license information:
 
 pvtsutils/build/index.es.js: