@blamejs/core 0.12.38 → 0.12.40

package/CHANGELOG.md

@@ -8,6 +8,10 @@ upgrading across more than a few patches at a time.
 
 ## v0.12.x
 
+- v0.12.40 (2026-05-24) — **`b.mdoc` — ISO 18013-5 mdoc / mDL issuer-data verification.** Verify the issuer-signed data of an ISO/IEC 18013-5 mdoc — the credential format behind mobile driving licences (mDL) and the ISO track of the EU Digital Identity Wallet. This is the relying-party side: confirm that the data elements a holder presents were signed by the issuer and have not been altered. An mdoc's IssuerSigned carries the disclosed data elements and an issuerAuth that is a COSE_Sign1 (b.cose) over a Mobile Security Object (MSO) holding a per-element digest. b.mdoc.verifyIssuerSigned verifies the COSE signature with the issuer certificate from the COSE x5chain header, parses the MSO, enforces its validityInfo window, and recomputes each disclosed element's digest (the full Tag-24 IssuerSignedItemBytes) to match it against the MSO constant-time — the integrity check that makes selective disclosure trustworthy. An absent or mismatched digest is refused. Signing algorithms follow b.cose verification (the classical ES256/384/512 + EdDSA that real mDL issuers use; the caller names the allowlist); opts.trustAnchorsPem additionally verifies the issuer certificate chain. This completes the credential trio alongside W3C VCDM (b.vc) and IETF SD-JWT VC (b.auth.sdJwtVc). Composes b.cose + b.cbor; no new runtime dependency. **Added:** *`b.mdoc.verifyIssuerSigned(issuerSigned, opts)`* — Takes the CBOR `IssuerSigned` map (the operator extracts it from the device response / QR) and returns `{ docType, version, digestAlgorithm, validityInfo, namespaces, signerCert, alg }`. Verifies the COSE_Sign1 `issuerAuth` against the mandatory `opts.algorithms` allowlist using the issuer certificate from its `x5chain` (label 33) header; parses the Tag-24 Mobile Security Object; enforces the MSO `validityInfo` window against `opts.at` (default now; must be a valid Date; malformed dates fail closed); and recomputes the digest of every disclosed `IssuerSignedItem` (over the full Tag-24 bytes, with the MSO `digestAlgorithm` — SHA-256/384/512) to match the MSO `valueDigests` constant-time — an absent or mismatched digest is refused with `mdoc/digest-mismatch`. `opts.expectedDocType` pins the document type; `opts.trustAnchorsPem` (a PEM string or array) additionally verifies the issuer certificate chain and validity at the asserted time. A malformed `x5chain` certificate is refused with a clean `mdoc/bad-cert`. The mdoc device-authentication half (the SessionTranscript-bound holder-binding proof) is a presentation-protocol concern and is not part of issuer-data verification.
+
+- v0.12.39 (2026-05-24) — **`b.vc` — W3C Verifiable Credentials 2.0 (issue / verify, JOSE + COSE securing).** Issue and verify W3C Verifiable Credentials (VC Data Model 2.0, a W3C Recommendation) secured per Securing Verifiable Credentials using JOSE and COSE (VC-JOSE-COSE, also a W3C Recommendation, May 2025). A verifiable credential is a tamper-evident, signed set of claims an issuer makes about a subject — a diploma, a membership, a license, an age assertion. Two securing mechanisms are supported, both signing the credential itself (no JWT/CWT claims wrapper): JOSE produces a compact JWS with the vc+jwt media type, signed with ES256/384/512 or EdDSA; COSE produces a COSE_Sign1 (application/vc+cose) over b.cose, which also accepts ML-DSA-87 for PQC-forward deployments. b.vc.verify auto-detects the form from the input, requires an algorithm allowlist, always refuses the JOSE none algorithm, re-checks the VCDM 2.0 structural rules, and enforces the validFrom / validUntil window. This is the W3C credential model, distinct from the IETF SD-JWT VC already at b.auth.sdJwtVc. Composes b.cose; no new runtime dependency. **Added:** *`b.vc.issue(credential, opts)` / `b.vc.verify(secured, opts)`* — `issue` validates the credential against the VCDM 2.0 structural rules (the `credentials/v2` context first, a `VerifiableCredential` type, an issuer, a credential subject) and signs it: `securing: "jose"` returns a compact JWS string (`typ` header `vc+jwt`), `securing: "cose"` returns COSE_Sign1 bytes (`typ` header `application/vc+cose`, content type `application/vc`) via `b.cose`. The credential is the exact signed payload — no JWT/CWT claims are injected. `verify` auto-detects the securing form from the input (compact-JWS string vs. COSE_Sign1 bytes), verifies the signature against the mandatory `opts.algorithms` allowlist (the JOSE `none` algorithm is always refused), re-checks the structural rules, enforces the `validFrom` / `validUntil` window against `opts.at` (default now; must be a valid Date), and optionally matches `opts.expectedIssuer` against the credential issuer id. Returns `{ credential, securing, alg, issuer }`.
+
 - v0.12.38 (2026-05-24) — **`b.tsa` — RFC 3161 trusted timestamping client (build / parse / verify).** A timestamp authority binds a hash of your data to a trusted time, producing a token that proves the data existed at that instant — timestamp a release artifact, an audit-log checkpoint, a b.scitt signed statement, or a contract. b.tsa is the requester/verifier side of RFC 3161: buildRequest produces the DER TimeStampReq (the message imprint plus an optional nonce and a cert request), parseResponse reads the TimeStampResp (PKIStatus, failure-info bits, and the token), and verifyToken checks a token against your data and returns the asserted time. Verification is done in full per §2.4.2 / §2.3: the token is a CMS SignedData (b.cms) whose eContentType must be id-ct-TSTInfo; the message imprint must equal the hash of your data (constant-time); a sent nonce must round-trip; the signer certificate's extendedKeyUsage must be a critical, sole id-kp-timeStamping; and the CMS signature over the signed attributes must verify after the messageDigest attribute is matched to the recomputed eContent digest. An optional trust-anchor set verifies the certificate chain and validity at the asserted time. The HTTP transport to the TSA is the operator's to make. Composes b.cms and the in-tree ASN.1 DER codec; no new runtime dependency. **Added:** *`b.tsa.buildRequest(data, opts?)` / `b.tsa.parseResponse(der)` / `b.tsa.verifyToken(token, opts)`* — `buildRequest` returns `{ der, nonce, hashAlg, messageImprint }`; the imprint hash defaults to SHA-512 and may be SHA-256/384/512 or SHA3-256/512, a random 64-bit nonce and a certificate request are included by default, and a pre-hashed input is accepted with `hashed: true`. `parseResponse` returns `{ granted, status, statusString, failInfo, token }`, decoding the PKIFailureInfo bits for a non-granted response rather than throwing. `verifyToken` enforces the imprint match (`opts.data` or `opts.hash`), the nonce round-trip, the critical/sole `id-kp-timeStamping` EKU, and the CMS signature, returning `{ genTime, policy, serialHex, accuracy, hashAlg, signerCertPem }`; pass `opts.trustAnchorsPem` to also verify the certificate chain and validity at the asserted time. Timestamp tokens are third-party artifacts, so verification accepts the classical RSA (PKCS#1 v1.5 and PSS) and ECDSA-over-SHA-2 signatures that public TSAs emit — the same consume-what-exists posture as `b.cose` verification, not a framework signing default.
 
 - v0.12.37 (2026-05-24) — **`b.scitt.signStatement` / `b.scitt.verifyStatement` — SCITT signed statements over COSE (RFC 9052 + RFC 9597).** A SCITT signed statement is a signed, attributable claim about an artifact — a signed SBOM, a build attestation, a release approval. It is a COSE_Sign1 (b.cose) whose integrity-protected CWT_Claims header (label 15, RFC 9597) binds the issuer (who makes the statement) and the subject (the artifact it is about); the artifact, or a hash/reference to it, is the payload. signStatement places iss/sub in the protected header and declares the payload media type; verifyStatement checks the COSE signature (the algorithm allowlist is mandatory) and refuses any statement that lacks the iss/sub binding, with optional expected-issuer/subject matching. Signing uses the same algorithms as b.cose — classical ES256/384/512 + EdDSA (final COSE ids, interoperable today) plus ML-DSA-87 (PQC-forward). This is the issuer side of SCITT, buildable today on finalized RFCs; the transparency receipt (an inclusion proof from a transparency service, the COSE Receipts draft) is not yet shipped — a statement produced here is the input a transparency service registers, and the receipt format is the part still in flux. It opts in when COSE Receipts publishes. **Added:** *`b.scitt.signStatement(payload, opts)` / `b.scitt.verifyStatement(statement, opts)`* — `signStatement` produces a COSE_Sign1 whose protected CWT_Claims header (label 15) carries `iss` (`opts.issuer`) and `sub` (`opts.subject`), with the payload media type declared via `opts.contentType` and extra CWT claims allowed by integer label (iss/sub cannot be overridden through `opts.claims`). `verifyStatement` verifies the signature through `b.cose.verify` (passing `opts.algorithms` as the mandatory allowlist), then requires a CWT_Claims header with both `iss` and `sub` — a bare COSE_Sign1 with no such binding is refused with `scitt/missing-cwt-claims` — and enforces `expectedIssuer` / `expectedSubject` when given. Returns `{ payload, issuer, subject, cwtClaims, alg, protectedHeaders, unprotectedHeaders }`. Because the identity binding lives in the integrity-protected header it is covered by the signature and cannot be substituted without detection. **Changed:** *`b.cose.sign` accepts `protectedHeaders` and a media-type-string `contentType`* — `opts.protectedHeaders` (a numeric-keyed object or Map) adds extra integrity-protected header parameters — the CWT_Claims map (label 15) is the SCITT case. Label 1 (alg) is reserved and managed via `opts.alg`; setting it through `protectedHeaders` is refused with `cose/reserved-header`. `opts.contentType` now accepts a media-type string (RFC 9052 §3.1 tstr form, e.g. `"application/spdx+json"`) in addition to a CoAP Content-Format uint; a string was previously dropped.

package/README.md

@@ -131,6 +131,8 @@ The framework bundles the surface a typical Node app reaches for. Every primitiv
 - **Entity Attestation Token** — `b.eat` EAT sign/verify (RFC 9711) over `b.cwt`: device + software attestation claims (ueid / oemid / hwmodel / measurements / submods) with verifier-nonce freshness binding, `dbgstat` debug-status policy, and `eat_profile` pinning
 - **SCITT signed statements** — `b.scitt` sign/verify a signed, attributable claim about an artifact (signed SBOM, build attestation, release approval) over `b.cose`: the issuer + subject bind in the integrity-protected CWT_Claims header (RFC 9597); verification refuses any statement missing the iss/sub binding. The issuer side, on finalized RFCs; the transparency receipt (COSE Receipts draft) opts in on publication
 - **Trusted timestamping** — `b.tsa` RFC 3161 timestamp client: `buildRequest` a TimeStampReq, `parseResponse`, and `verifyToken` against your data — the message imprint, sent nonce, critical/sole `id-kp-timeStamping` EKU, and CMS signature are all checked, with optional certificate-chain verification. Timestamp a release artifact, audit checkpoint, or signed statement against any RFC 3161 TSA. Composes `b.cms` + the in-tree ASN.1 DER codec
+- **Verifiable Credentials** — `b.vc` W3C Verifiable Credentials Data Model 2.0 (VC-JOSE-COSE): `issue` / `verify` a signed credential as a compact JWS (`vc+jwt`, ES256/384/512 + EdDSA) or a COSE_Sign1 (`vc+cose`, + ML-DSA-87) over `b.cose`. VCDM structural + `validFrom`/`validUntil` checks; the JOSE `none` algorithm is always refused. The W3C model, distinct from the IETF SD-JWT VC at `b.auth.sdJwtVc`
+- **Mobile credentials (mDL)** — `b.mdoc` ISO/IEC 18013-5 issuer-data verification: `verifyIssuerSigned` checks the COSE_Sign1 IssuerAuth (issuer cert from the `x5chain` header), the Mobile Security Object validity window, and every disclosed element's digest against the MSO `valueDigests` (the selective-disclosure integrity check), with optional issuer-chain verification. The ISO credential ecosystem alongside `b.vc` and `b.auth.sdJwtVc`. Composes `b.cose` + `b.cbor`
 - **Document parsers** — `b.parsers` (XML / TOML / YAML / .env); `b.config` (schema-validated env)
 - **File-type detection** — `b.fileType` magic-byte content classification with deny-on-upload categories (image / document / archive / executable / etc.)
 ### Content-safety gates

package/index.js

@@ -461,6 +461,8 @@ module.exports = {
   eat:              require("./lib/eat"),
   scitt:            require("./lib/scitt"),
   tsa:              require("./lib/tsa"),
+  vc:               require("./lib/vc"),
+  mdoc:             require("./lib/mdoc"),
   queue:            queue,
   logStream:        logStream,
   redact:           redact,

package/lib/mdoc.js

@@ -0,0 +1,305 @@
+"use strict";
+/**
+ * @module b.mdoc
+ * @nav    Crypto
+ * @title  ISO mdoc / mDL (ISO 18013-5)
+ *
+ * @intro
+ *   Verify the issuer-signed data of an ISO/IEC 18013-5 mdoc — the
+ *   credential format behind mobile driving licences (mDL) and the ISO
+ *   track of the EU Digital Identity Wallet. This is the relying-party
+ *   side: confirm that the data elements a holder presents were signed
+ *   by the issuer and have not been altered.
+ *
+ *   An mdoc's <code>IssuerSigned</code> structure carries the disclosed
+ *   data elements (<code>nameSpaces</code>) and an <code>issuerAuth</code>
+ *   that is a COSE_Sign1 (<code>b.cose</code>) over a Mobile Security
+ *   Object (MSO). The MSO holds, per namespace, a SHA-256/384/512 digest
+ *   of every issued element. <code>b.mdoc.verifyIssuerSigned</code>
+ *   verifies the COSE signature with the issuer certificate carried in
+ *   the COSE <code>x5chain</code> (label 33), parses the MSO, enforces
+ *   its <code>validityInfo</code> window, and — the integrity check that
+ *   makes selective disclosure trustworthy — recomputes the digest of
+ *   every disclosed element (the full Tag-24 <code>IssuerSignedItemBytes</code>)
+ *   and matches it against the MSO, constant-time. A disclosed element
+ *   whose digest is absent or mismatched is refused.
+ *
+ *   Signing algorithms follow <code>b.cose</code> verification: the
+ *   classical ES256 / 384 / 512 and EdDSA that real mDL issuers use are
+ *   accepted (consume-what-exists; the caller names the allowlist).
+ *   <code>opts.trustAnchorsPem</code> additionally verifies the issuer
+ *   certificate chain and its validity at the asserted time.
+ *
+ *   <strong>Scope.</strong> This is issuer-data authentication
+ *   (ISO 18013-5 §9.1.2.4) — the data is genuine and issuer-signed. The
+ *   mdoc <em>device authentication</em> half (DeviceSigned / the
+ *   SessionTranscript-bound holder-binding proof, §9.1.3) is deferred:
+ *   it needs the live session transcript a verifier negotiates, so it is
+ *   a presentation-protocol concern rather than a credential check.
+ *   Composes <code>b.cose</code> + <code>b.cbor</code>; no new runtime
+ *   dependency. Distinct from W3C VCDM (<code>b.vc</code>) and IETF
+ *   SD-JWT VC (<code>b.auth.sdJwtVc</code>) — the three credential
+ *   ecosystems.
+ *
+ * @card
+ *   ISO 18013-5 mdoc / mDL issuer-data verification — checks the
+ *   COSE_Sign1 IssuerAuth, the MSO validity window, and every disclosed
+ *   element's digest against the Mobile Security Object. Composes
+ *   b.cose + b.cbor; device-auth holder-binding deferred.
+ */
+
+var nodeCrypto = require("node:crypto");
+var C = require("./constants");
+var cbor = require("./cbor");
+var cose = require("./cose");
+var bCrypto = require("./crypto");
+var validateOpts = require("./validate-opts");
+var { defineClass } = require("./framework-error");
+
+var MdocError = defineClass("MdocError", { alwaysPermanent: true });
+
+var HDR_X5CHAIN = 33;                                  // allow:raw-byte-literal allow:raw-time-literal — x5chain COSE header label (RFC 9360 is a spec number, not a size/duration)
+var TAG_ENCODED_CBOR = 24;                             // allow:raw-byte-literal — RFC 8949 §3.4.5.1 embedded-CBOR tag
+// Tags ISO 18013-5 uses in issuer data: tdate(0), epoch(1), embedded
+// CBOR(24), full-date(1004, RFC 8943). Bounded — others are refused.
+var ALLOWED_TAGS = [0, 1, TAG_ENCODED_CBOR, 1004];
+var DIGEST_ALGS = { "SHA-256": "sha256", "SHA-384": "sha384", "SHA-512": "sha512" };
+
+function _bytes(x, what) {
+  if (Buffer.isBuffer(x)) return x;
+  if (x instanceof Uint8Array) return Buffer.from(x);
+  throw new MdocError("mdoc/bad-input", "mdoc: " + what + " must be a Buffer / Uint8Array of CBOR");
+}
+
+// validityInfo dates are tdate (Tag 0, an RFC 3339 string) or epoch
+// (Tag 1). Returns epoch-ms; fails closed on a malformed value.
+function _validityMs(v, name) {
+  var raw = (v instanceof cbor.Tag) ? v.value : v;
+  if (typeof raw === "string") {
+    var ms = Date.parse(raw);
+    if (!isFinite(ms)) throw new MdocError("mdoc/bad-validity", "mdoc: validityInfo." + name + " is not a valid date: " + raw);
+    return ms;
+  }
+  if (typeof raw === "number" && isFinite(raw)) return raw * C.TIME.seconds(1);    // epoch seconds → ms
+  throw new MdocError("mdoc/bad-validity", "mdoc: validityInfo." + name + " is missing or malformed");
+}
+
+function _mapGet(m, k) { return m instanceof Map ? m.get(k) : (m ? m[k] : undefined); }
+
+/**
+ * @primitive b.mdoc.verifyIssuerSigned
+ * @signature b.mdoc.verifyIssuerSigned(issuerSigned, opts)
+ * @since     0.12.40
+ * @status    experimental
+ * @compliance gdpr, soc2
+ * @related   b.cose.verify, b.vc.verify
+ *
+ * Verify the issuer-signed data of an ISO 18013-5 mdoc and return the
+ * disclosed elements. <code>issuerSigned</code> is the CBOR
+ * <code>IssuerSigned</code> map (the operator extracts it from the
+ * device response / QR). The COSE_Sign1 <code>issuerAuth</code> is
+ * verified with the issuer certificate from its <code>x5chain</code>
+ * header against the mandatory <code>opts.algorithms</code> allowlist;
+ * the MSO <code>validityInfo</code> window is enforced; and every
+ * disclosed element's digest is matched against the Mobile Security
+ * Object (a mismatch or absence is refused). Pass
+ * <code>opts.trustAnchorsPem</code> to also verify the issuer
+ * certificate chain.
+ *
+ * @opts
+ *   {
+ *     algorithms:      string[],  // required — accepted COSE alg names (ES256/384/512, EdDSA)
+ *     trustAnchorsPem: string|string[], // optional issuer roots — enables chain + validity verification
+ *     expectedDocType: string,    // require the MSO docType to match (e.g. "org.iso.18013.5.1.mDL")
+ *     at:              Date,      // validity instant (default now); must be a valid Date
+ *     maxBytes:        number,    // forwarded to b.cbor.decode
+ *     maxDepth:        number,
+ *   }
+ *
+ * @example
+ *   var out = await b.mdoc.verifyIssuerSigned(issuerSignedBytes, {
+ *     algorithms: ["ES256"], expectedDocType: "org.iso.18013.5.1.mDL",
+ *   });
+ *   // → { docType, validityInfo, namespaces: { "org.iso.18013.5.1": { family_name, age_over_18, … } }, signerCert, alg }
+ */
+async function verifyIssuerSigned(issuerSigned, opts) {
+  validateOpts.requireObject(opts, "mdoc.verifyIssuerSigned", MdocError);
+  validateOpts(opts, ["algorithms", "trustAnchorsPem", "expectedDocType", "at", "maxBytes", "maxDepth"], "mdoc.verifyIssuerSigned");
+  if (!Array.isArray(opts.algorithms) || opts.algorithms.length === 0) {
+    throw new MdocError("mdoc/algorithms-required", "mdoc.verifyIssuerSigned: opts.algorithms is required");
+  }
+  var at = new Date();
+  if (opts.at !== undefined && opts.at !== null) {
+    if (!(opts.at instanceof Date) || !isFinite(opts.at.getTime())) {
+      throw new MdocError("mdoc/bad-at", "mdoc.verifyIssuerSigned: opts.at must be a valid Date");
+    }
+    at = opts.at;
+  }
+  var decodeOpts = { allowedTags: ALLOWED_TAGS, maxBytes: opts.maxBytes, maxDepth: opts.maxDepth };
+
+  var top = cbor.decode(_bytes(issuerSigned, "issuerSigned"), decodeOpts);
+  var nameSpaces = _mapGet(top, "nameSpaces");
+  var issuerAuth = _mapGet(top, "issuerAuth");
+  if (!Array.isArray(issuerAuth) || issuerAuth.length !== 4) {
+    throw new MdocError("mdoc/malformed", "mdoc.verifyIssuerSigned: issuerAuth must be a COSE_Sign1 (4-element array)");
+  }
+
+  // The signer certificate rides in the COSE x5chain (label 33): a
+  // single cert bstr or an array of bstrs, leaf first.
+  var unprotected = issuerAuth[1];
+  var x5 = _mapGet(unprotected, HDR_X5CHAIN);
+  var chain = Array.isArray(x5) ? x5 : (x5 != null ? [x5] : []);
+  if (!chain.length || !Buffer.isBuffer(chain[0])) {
+    throw new MdocError("mdoc/no-cert", "mdoc.verifyIssuerSigned: issuerAuth has no x5chain certificate (label 33)");
+  }
+  // The x5chain certificate is attacker-controlled — a malformed DER
+  // must surface as a clean error, not a raw OpenSSL throw.
+  var signerCert;
+  try { signerCert = new nodeCrypto.X509Certificate(chain[0]); }
+  catch (e) {
+    throw new MdocError("mdoc/bad-cert", "mdoc.verifyIssuerSigned: x5chain certificate is not valid DER: " + ((e && e.message) || e));
+  }
+
+  // Verify the COSE_Sign1 signature with the embedded signer key.
+  var coseBytes = cbor.encode(issuerAuth);
+  var verified = await cose.verify(coseBytes, {
+    algorithms:  opts.algorithms,
+    keyResolver: function () { return signerCert.publicKey; },
+    maxBytes:    opts.maxBytes,
+    maxDepth:    opts.maxDepth,
+  });
+
+  // payload = Tag 24 ( bstr .cbor MSO ).
+  var payloadTag = cbor.decode(verified.payload, decodeOpts);
+  var msoBytes = (payloadTag instanceof cbor.Tag && payloadTag.tag === TAG_ENCODED_CBOR) ? payloadTag.value : null;
+  if (!Buffer.isBuffer(msoBytes)) {
+    throw new MdocError("mdoc/malformed", "mdoc.verifyIssuerSigned: issuerAuth payload is not a Tag-24 MobileSecurityObject");
+  }
+  var mso = cbor.decode(msoBytes, decodeOpts);
+
+  var digestAlgName = _mapGet(mso, "digestAlgorithm");
+  var digestNode = DIGEST_ALGS[digestAlgName];
+  if (!digestNode) {
+    throw new MdocError("mdoc/bad-digest-alg", "mdoc.verifyIssuerSigned: unsupported MSO digestAlgorithm '" + digestAlgName + "'");
+  }
+  var docType = _mapGet(mso, "docType");
+  if (opts.expectedDocType !== undefined && docType !== opts.expectedDocType) {
+    throw new MdocError("mdoc/doctype-mismatch", "mdoc.verifyIssuerSigned: MSO docType '" + docType + "' does not match expectedDocType");
+  }
+
+  // validityInfo window (fail closed on malformed dates).
+  var vi = _mapGet(mso, "validityInfo");
+  if (!(vi instanceof Map) && (!vi || typeof vi !== "object")) {
+    throw new MdocError("mdoc/malformed", "mdoc.verifyIssuerSigned: MSO has no validityInfo");
+  }
+  var nowMs = at.getTime();
+  var validFromMs = _validityMs(_mapGet(vi, "validFrom"), "validFrom");
+  var validUntilMs = _validityMs(_mapGet(vi, "validUntil"), "validUntil");
+  if (nowMs < validFromMs) throw new MdocError("mdoc/not-yet-valid", "mdoc.verifyIssuerSigned: credential not yet valid");
+  if (nowMs > validUntilMs) throw new MdocError("mdoc/expired", "mdoc.verifyIssuerSigned: credential validity has passed");
+
+  // Match every disclosed element's digest against the MSO. The digest
+  // covers the full Tag-24 IssuerSignedItemBytes (ISO 18013-5 §9.1.2.5).
+  var valueDigests = _mapGet(mso, "valueDigests");
+  var out = {};
+  if (nameSpaces instanceof Map) {
+    var nsNames = Array.from(nameSpaces.keys());
+    for (var ni = 0; ni < nsNames.length; ni += 1) {
+      var ns = nsNames[ni];
+      var items = nameSpaces.get(ns);
+      var nsDigests = _mapGet(valueDigests, ns);
+      if (!Array.isArray(items) || !(nsDigests instanceof Map)) {
+        throw new MdocError("mdoc/malformed", "mdoc.verifyIssuerSigned: namespace '" + ns + "' has no matching valueDigests");
+      }
+      out[ns] = {};
+      var seen = Object.create(null);                 // dup-elementIdentifier guard (proto-safe)
+      for (var ii = 0; ii < items.length; ii += 1) {
+        var item = items[ii];
+        if (!(item instanceof cbor.Tag) || item.tag !== TAG_ENCODED_CBOR || !Buffer.isBuffer(item.value)) {
+          throw new MdocError("mdoc/malformed", "mdoc.verifyIssuerSigned: IssuerSignedItem is not a Tag-24 byte string");
+        }
+        var itemBytes = cbor.encode(new cbor.Tag(TAG_ENCODED_CBOR, item.value));
+        var digest = nodeCrypto.createHash(digestNode).update(itemBytes).digest();
+        var inner = cbor.decode(item.value, decodeOpts);
+        var digestID = _mapGet(inner, "digestID");
+        var expected = nsDigests.get(digestID);
+        if (!Buffer.isBuffer(expected) || !bCrypto.timingSafeEqual(digest, expected)) {
+          throw new MdocError("mdoc/digest-mismatch",
+            "mdoc.verifyIssuerSigned: disclosed element (digestID " + digestID + ", namespace " + ns + ") does not match the MSO");
+        }
+        // Refuse a duplicate elementIdentifier within a namespace — two
+        // signed values for one element is ambiguous; fail closed rather
+        // than silently keep the last.
+        var elementId = _mapGet(inner, "elementIdentifier");
+        if (seen[elementId]) {
+          throw new MdocError("mdoc/duplicate-element",
+            "mdoc.verifyIssuerSigned: namespace '" + ns + "' has duplicate elementIdentifier '" + elementId + "'");
+        }
+        seen[elementId] = true;
+        out[ns][elementId] = _mapGet(inner, "elementValue");
+      }
+    }
+  }
+
+  // Optional issuer chain + validity at the asserted time.
+  if (opts.trustAnchorsPem !== undefined && opts.trustAnchorsPem !== null) {
+    var anchors = typeof opts.trustAnchorsPem === "string" ? [opts.trustAnchorsPem] : opts.trustAnchorsPem;
+    if (!Array.isArray(anchors) || anchors.length === 0 ||
+        !anchors.every(function (a) { return typeof a === "string" && a.length > 0; })) {
+      throw new MdocError("mdoc/bad-trust-anchors", "mdoc.verifyIssuerSigned: trustAnchorsPem must be a non-empty PEM string or array");
+    }
+    _verifyChain(chain, anchors, at);
+  }
+
+  return {
+    docType:      docType,
+    version:      _mapGet(mso, "version"),
+    digestAlgorithm: digestAlgName,
+    validityInfo: { validFrom: new Date(validFromMs), validUntil: new Date(validUntilMs) },
+    namespaces:   out,
+    signerCert:   signerCert.toString(),
+    alg:          verified.alg,
+  };
+}
+
+// Verify the leaf (chain[0]) chains to a supplied anchor and every cert
+// is valid at `at`. Intermediates in the x5chain are consulted.
+function _verifyChain(chainDer, anchorsPem, at) {
+  var anchors = anchorsPem.map(function (p) { return new nodeCrypto.X509Certificate(p); });
+  var pool = chainDer.map(function (d) { return new nodeCrypto.X509Certificate(d); });
+  var current = pool[0];
+  var atMs = at.getTime();
+  var steps = 0;
+  while (steps <= pool.length + 1) {
+    _assertValidAt(current, atMs);
+    for (var a = 0; a < anchors.length; a += 1) {
+      if (_issued(anchors[a], current)) { _assertValidAt(anchors[a], atMs); return; }
+      if (current.fingerprint256 === anchors[a].fingerprint256) return;
+    }
+    var parent = null;
+    for (var p = 0; p < pool.length; p += 1) {
+      if (pool[p].fingerprint256 !== current.fingerprint256 && _issued(pool[p], current)) { parent = pool[p]; break; }
+    }
+    if (!parent) {
+      throw new MdocError("mdoc/untrusted-chain", "mdoc.verifyIssuerSigned: issuer certificate does not chain to a supplied trust anchor");
+    }
+    current = parent;
+    steps += 1;
+  }
+  throw new MdocError("mdoc/chain-loop", "mdoc.verifyIssuerSigned: certificate chain did not terminate");
+}
+function _issued(issuer, subject) {
+  try { return subject.checkIssued(issuer) && subject.verify(issuer.publicKey); }
+  catch (_e) { return false; }
+}
+function _assertValidAt(cert, atMs) {
+  if (atMs < cert.validFromDate.getTime() || atMs > cert.validToDate.getTime()) {
+    throw new MdocError("mdoc/cert-expired", "mdoc.verifyIssuerSigned: certificate '" + cert.subject + "' is not valid at the asserted time");
+  }
+}
+
+module.exports = {
+  verifyIssuerSigned: verifyIssuerSigned,
+  DIGEST_ALGS:        DIGEST_ALGS,
+  MdocError:          MdocError,
+};

package/lib/vc.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * @module b.vc
+ * @nav    Crypto
+ * @title  Verifiable Credentials (W3C VCDM 2.0)
+ *
+ * @intro
+ *   Issue and verify W3C Verifiable Credentials (VC Data Model 2.0, a
+ *   W3C Recommendation) secured per "Securing Verifiable Credentials
+ *   using JOSE and COSE" (VC-JOSE-COSE, also a W3C Recommendation). A
+ *   verifiable credential is a tamper-evident, cryptographically-signed
+ *   set of claims an issuer makes about a subject — a diploma, a
+ *   membership, a license, an age assertion.
+ *
+ *   Two securing mechanisms are supported, both putting the credential
+ *   itself (not a JWT/CWT claims wrapper) as the signed payload:
+ *   <strong>JOSE</strong> produces a compact JWS with the <code>vc+jwt</code>
+ *   media type (<code>typ</code> header <code>"vc+jwt"</code>), signed
+ *   with the classical ES256 / 384 / 512 or EdDSA JOSE algorithms;
+ *   <strong>COSE</strong> produces a COSE_Sign1 (<code>application/vc+cose</code>)
+ *   over <code>b.cose</code>, adding ML-DSA-87 (PQC-forward) to that set.
+ *   <code>b.vc.verify</code> auto-detects the form from the input (a
+ *   compact-JWS string vs. COSE_Sign1 bytes).
+ *
+ *   <code>b.vc.issue(credential, opts)</code> validates the credential
+ *   against the VCDM 2.0 structural rules (the <code>credentials/v2</code>
+ *   context first, a <code>VerifiableCredential</code> type, an issuer,
+ *   a credential subject) and signs it. <code>b.vc.verify(secured, opts)</code>
+ *   verifies the signature (the algorithm allowlist is mandatory; the
+ *   JOSE <code>none</code> algorithm is always refused), re-checks the
+ *   structural rules, and enforces the <code>validFrom</code> /
+ *   <code>validUntil</code> validity window. This is the W3C model and
+ *   is distinct from the IETF SD-JWT VC at <code>b.auth.sdJwtVc</code>.
+ *
+ * @card
+ *   W3C Verifiable Credentials 2.0 (VC-JOSE-COSE) — issue / verify a
+ *   signed credential as a compact JWS (vc+jwt) or a COSE_Sign1
+ *   (vc+cose), with VCDM structural + validity-window checks. Composes
+ *   b.cose; the JOSE alg `none` is always refused.
+ */
+
+var nodeCrypto = require("node:crypto");
+var cose = require("./cose");
+var safeJson = require("./safe-json");
+var validateOpts = require("./validate-opts");
+var { defineClass } = require("./framework-error");
+
+var VcError = defineClass("VcError", { alwaysPermanent: true });
+
+var VCDM_V2_CONTEXT = "https://www.w3.org/ns/credentials/v2";
+var JOSE_TYP = "vc+jwt";
+var COSE_TYP = "application/vc+cose";
+var COSE_CONTENT_TYPE = "application/vc";
+var HDR_COSE_TYP = 16;                                 // allow:raw-byte-literal — COSE "typ" header label (RFC 9596)
+
+// JOSE signature algorithms (final RFC 7518 / 8037), mapped to node
+// verify parameters. ECDSA uses the IEEE-P1363 fixed-width encoding JOSE
+// mandates (not ASN.1 DER). There is no signing default — the caller
+// names the algorithm, mirroring b.cose.
+var JOSE_ALGS = {
+  "ES256": { nodeHash: "sha256", dsaEncoding: "ieee-p1363" },
+  "ES384": { nodeHash: "sha384", dsaEncoding: "ieee-p1363" },
+  "ES512": { nodeHash: "sha512", dsaEncoding: "ieee-p1363" },
+  "EdDSA": { nodeHash: null },
+};
+
+function _b64urlJson(obj) {
+  return Buffer.from(JSON.stringify(obj), "utf8").toString("base64url");
+}
+function _toKey(key, kind) {
+  if (key && typeof key === "object" && typeof key.asymmetricKeyType === "string") return key;
+  try {
+    return kind === "private" ? nodeCrypto.createPrivateKey(key) : nodeCrypto.createPublicKey(key);
+  } catch (e) {
+    throw new VcError("vc/bad-key", "vc: could not load " + kind + " key: " + ((e && e.message) || e));
+  }
+}
+
+function _issuerId(cred) {
+  if (typeof cred.issuer === "string") return cred.issuer;
+  if (cred.issuer && typeof cred.issuer === "object" && typeof cred.issuer.id === "string") return cred.issuer.id;
+  return undefined;
+}
+
+// VCDM 2.0 structural rules; temporal checks only on verify.
+function _validateVcdm(cred, opts) {
+  if (!cred || typeof cred !== "object" || Array.isArray(cred)) {
+    throw new VcError("vc/bad-credential", "vc: credential must be a JSON object");
+  }
+  var ctx = cred["@context"];
+  if (!Array.isArray(ctx) || ctx[0] !== VCDM_V2_CONTEXT) {
+    throw new VcError("vc/bad-context",
+      "vc: @context must be an array whose first element is '" + VCDM_V2_CONTEXT + "'");
+  }
+  var types = Array.isArray(cred.type) ? cred.type : [cred.type];
+  if (types.indexOf("VerifiableCredential") === -1) {
+    throw new VcError("vc/bad-type", "vc: type must include 'VerifiableCredential'");
+  }
+  if (_issuerId(cred) === undefined) {
+    throw new VcError("vc/no-issuer", "vc: issuer is required (a URL string or an object with an id)");
+  }
+  if (cred.credentialSubject === undefined || cred.credentialSubject === null) {
+    throw new VcError("vc/no-subject", "vc: credentialSubject is required");
+  }
+  // validFrom / validUntil, when present, MUST be valid XSD dateTimes
+  // (VCDM 2.0 §4.9). A malformed value fails closed at both issue and
+  // verify rather than silently skipping the window check.
+  var vf = _parseValidityField(cred, "validFrom");
+  var vu = _parseValidityField(cred, "validUntil");
+  if (opts && opts.temporal) {
+    var nowMs = opts.at.getTime();
+    if (vf !== null && nowMs < vf) {
+      throw new VcError("vc/not-yet-valid", "vc.verify: credential validFrom (" + cred.validFrom + ") is in the future");
+    }
+    if (vu !== null && nowMs > vu) {
+      throw new VcError("vc/expired", "vc.verify: credential validUntil (" + cred.validUntil + ") has passed");
+    }
+  }
+}
+
+function _parseValidityField(cred, name) {
+  if (cred[name] === undefined) return null;
+  if (typeof cred[name] !== "string") {
+    throw new VcError("vc/bad-validity", "vc: " + name + " must be an XSD dateTime string");
+  }
+  var ms = Date.parse(cred[name]);
+  if (!isFinite(ms)) {
+    throw new VcError("vc/bad-validity", "vc: " + name + " is not a valid dateTime: " + cred[name]);
+  }
+  return ms;
+}
+
+/**
+ * @primitive b.vc.issue
+ * @signature b.vc.issue(credential, opts)
+ * @since     0.12.39
+ * @status    experimental
+ * @compliance gdpr, soc2
+ * @related   b.vc.verify, b.cose.sign
+ *
+ * Validate a credential against the VCDM 2.0 structural rules and secure
+ * it. <code>securing: "jose"</code> returns a compact JWS string (media
+ * type <code>vc+jwt</code>) signed with an ES256/384/512 or EdDSA key;
+ * <code>securing: "cose"</code> returns COSE_Sign1 bytes (media type
+ * <code>application/vc+cose</code>) over <code>b.cose</code>, which also
+ * accepts <code>"ML-DSA-87"</code>. The credential itself is the signed
+ * payload — no JWT/CWT claims wrapper is added.
+ *
+ * @opts
+ *   {
+ *     securing:   string,   // "jose" (compact JWS) | "cose" (COSE_Sign1)
+ *     alg:        string,   // JOSE: ES256/384/512 | EdDSA. COSE: + ML-DSA-87
+ *     privateKey: object,   // matching KeyObject or PEM
+ *     kid:        string,   // optional key id (header)
+ *     cty:        string,   // optional JOSE cty (e.g. "vc")
+ *   }
+ *
+ * @example
+ *   var jws = await b.vc.issue(credential, { securing: "jose", alg: "ES256", privateKey: key });
+ *   // → a compact JWS string with typ "vc+jwt"
+ */
+async function issue(credential, opts) {
+  validateOpts.requireObject(opts, "vc.issue", VcError);
+  validateOpts(opts, ["securing", "alg", "privateKey", "kid", "cty"], "vc.issue");
+  _validateVcdm(credential, null);
+  if (!opts.privateKey) throw new VcError("vc/no-key", "vc.issue: opts.privateKey is required");
+
+  if (opts.securing === "cose") {
+    var protectedHeaders = {};
+    protectedHeaders[HDR_COSE_TYP] = COSE_TYP;
+    return cose.sign(Buffer.from(JSON.stringify(credential), "utf8"), {
+      alg:              opts.alg,
+      privateKey:       opts.privateKey,
+      kid:              opts.kid,
+      contentType:      COSE_CONTENT_TYPE,
+      protectedHeaders: protectedHeaders,
+    });
+  }
+  if (opts.securing === "jose") {
+    var params = JOSE_ALGS[opts.alg];
+    if (!params) {
+      throw new VcError("vc/bad-alg", "vc.issue: JOSE securing requires alg ES256/384/512 or EdDSA (got " + opts.alg + ")");
+    }
+    var key = _toKey(opts.privateKey, "private");
+    var header = { alg: opts.alg, typ: JOSE_TYP };
+    if (typeof opts.kid === "string") header.kid = opts.kid;
+    if (typeof opts.cty === "string") header.cty = opts.cty;
+    var signingInput = _b64urlJson(header) + "." + _b64urlJson(credential);
+    var sig = params.nodeHash === null
+      ? nodeCrypto.sign(null, Buffer.from(signingInput, "ascii"), key)
+      : nodeCrypto.sign(params.nodeHash, Buffer.from(signingInput, "ascii"), { key: key, dsaEncoding: params.dsaEncoding });
+    return signingInput + "." + sig.toString("base64url");
+  }
+  throw new VcError("vc/bad-securing", "vc.issue: securing must be 'jose' or 'cose'");
+}
+
+function _verifyJose(token, opts) {
+  var parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new VcError("vc/malformed", "vc.verify: not a compact JWS (expected three dot-separated segments)");
+  }
+  var header;
+  try { header = safeJson.parse(Buffer.from(parts[0], "base64url").toString("utf8")); }
+  catch (_e) { throw new VcError("vc/malformed", "vc.verify: JWS header is not valid base64url-JSON"); }
+  if (!header || header.typ !== JOSE_TYP) {
+    throw new VcError("vc/bad-typ", "vc.verify: JWS typ must be '" + JOSE_TYP + "'");
+  }
+  // crit-bypass defense (RFC 7515 §4.1.11): a `crit` header marks
+  // extensions the verifier MUST understand and process. This verifier
+  // implements no critical extensions, so any `crit` is refused rather
+  // than ignored — accepting it would mean honoring a credential under
+  // weaker semantics than the issuer marked mandatory.
+  if (header.crit !== undefined) {
+    throw new VcError("vc/crit-unsupported",
+      "vc.verify: JWS 'crit' header lists extensions this verifier does not support (RFC 7515 §4.1.11)");
+  }
+  if (header.alg === "none" || !JOSE_ALGS[header.alg]) {
+    throw new VcError("vc/bad-alg", "vc.verify: unsupported or unsecured JWS alg '" + header.alg + "'");
+  }
+  if (opts.algorithms.indexOf(header.alg) === -1) {
+    throw new VcError("vc/alg-not-allowed", "vc.verify: alg '" + header.alg + "' is not in the allowlist");
+  }
+  var params = JOSE_ALGS[header.alg];
+  var pub = opts.publicKey ? _toKey(opts.publicKey, "public") : _toKey(opts.keyResolver(header), "public");
+  var signingInput = parts[0] + "." + parts[1];
+  var sig = Buffer.from(parts[2], "base64url");
+  var ok = params.nodeHash === null
+    ? nodeCrypto.verify(null, Buffer.from(signingInput, "ascii"), pub, sig)
+    : nodeCrypto.verify(params.nodeHash, Buffer.from(signingInput, "ascii"), { key: pub, dsaEncoding: params.dsaEncoding }, sig);
+  if (!ok) throw new VcError("vc/bad-signature", "vc.verify: JWS signature did not verify");
+  var credential;
+  try { credential = safeJson.parse(Buffer.from(parts[1], "base64url").toString("utf8")); }
+  catch (_e) { throw new VcError("vc/malformed", "vc.verify: JWS payload is not valid base64url-JSON"); }
+  return { credential: credential, alg: header.alg };
+}
+
+async function _verifyCose(bytes, opts) {
+  var algorithms = opts.algorithms.filter(function (a) { return a in cose.ALGORITHMS; });
+  if (!algorithms.length) {
+    throw new VcError("vc/no-cose-alg", "vc.verify: opts.algorithms has no COSE algorithm for a vc+cose credential");
+  }
+  var out = await cose.verify(bytes, {
+    algorithms:  algorithms,
+    publicKey:   opts.publicKey,
+    keyResolver: opts.keyResolver,
+  });
+  var typ = out.protectedHeaders.get(HDR_COSE_TYP);
+  if (typ !== undefined && typ !== COSE_TYP) {
+    throw new VcError("vc/bad-typ", "vc.verify: COSE typ header is '" + typ + "', expected '" + COSE_TYP + "'");
+  }
+  var credential;
+  try { credential = safeJson.parse(out.payload.toString("utf8")); }
+  catch (_e) { throw new VcError("vc/malformed", "vc.verify: COSE payload is not valid JSON"); }
+  return { credential: credential, alg: out.alg };
+}
+
+/**
+ * @primitive b.vc.verify
+ * @signature b.vc.verify(secured, opts)
+ * @since     0.12.39
+ * @status    experimental
+ * @compliance gdpr, soc2
+ * @related   b.vc.issue, b.cose.verify
+ *
+ * Verify a secured verifiable credential and return the credential. The
+ * securing form is auto-detected (a compact-JWS string vs. COSE_Sign1
+ * bytes); the algorithm allowlist is mandatory and the JOSE
+ * <code>none</code> algorithm is always refused. After the signature,
+ * the VCDM 2.0 structural rules are re-checked and the
+ * <code>validFrom</code> / <code>validUntil</code> window is enforced
+ * against <code>opts.at</code> (default: now).
+ *
+ * @opts
+ *   {
+ *     algorithms:      string[],  // required — accepted alg names (allowlist)
+ *     publicKey:       object,    // verification key (KeyObject / PEM)
+ *     keyResolver:     function,  // (header) → key  (alternative to publicKey)
+ *     expectedIssuer:  string,    // require the credential issuer (id) to match
+ *     at:              Date,      // validity instant (default: now); must be a valid Date
+ *   }
+ *
+ * @example
+ *   var out = await b.vc.verify(jws, { algorithms: ["ES256"], publicKey: issuerPub, expectedIssuer: "did:example:123" });
+ *   // → { credential, securing: "jose", alg: "ES256", issuer: "did:example:123" }
+ */
+async function verify(secured, opts) {
+  validateOpts.requireObject(opts, "vc.verify", VcError);
+  validateOpts(opts, ["algorithms", "publicKey", "keyResolver", "expectedIssuer", "at"], "vc.verify");
+  if (!Array.isArray(opts.algorithms) || opts.algorithms.length === 0) {
+    throw new VcError("vc/algorithms-required", "vc.verify: opts.algorithms is required (name the accepted algorithms)");
+  }
+  if (!opts.publicKey && typeof opts.keyResolver !== "function") {
+    throw new VcError("vc/no-key", "vc.verify: pass publicKey or keyResolver");
+  }
+  var at = new Date();
+  if (opts.at !== undefined && opts.at !== null) {
+    if (!(opts.at instanceof Date) || !isFinite(opts.at.getTime())) {
+      throw new VcError("vc/bad-at", "vc.verify: opts.at must be a valid Date");
+    }
+    at = opts.at;
+  }
+
+  var securing, result;
+  if (typeof secured === "string") {
+    securing = "jose";
+    result = _verifyJose(secured, opts);
+  } else if (Buffer.isBuffer(secured) || secured instanceof Uint8Array) {
+    securing = "cose";
+    result = await _verifyCose(Buffer.from(secured), opts);
+  } else {
+    throw new VcError("vc/bad-input", "vc.verify: secured must be a compact-JWS string or COSE_Sign1 bytes");
+  }
+
+  _validateVcdm(result.credential, { temporal: true, at: at });
+  var issuer = _issuerId(result.credential);
+  if (opts.expectedIssuer !== undefined && issuer !== opts.expectedIssuer) {
+    throw new VcError("vc/issuer-mismatch", "vc.verify: credential issuer does not match expectedIssuer");
+  }
+  return { credential: result.credential, securing: securing, alg: result.alg, issuer: issuer };
+}
+
+module.exports = {
+  issue:          issue,
+  verify:         verify,
+  JOSE_ALGS:      JOSE_ALGS,
+  VCDM_V2_CONTEXT: VCDM_V2_CONTEXT,
+  VcError:        VcError,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.12.38",
+  "version": "0.12.40",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:5183e917-7caf-48d3-b87d-5efa87791e85",
+  "serialNumber": "urn:uuid:6a95f7d3-c5ac-4994-955e-1fb82f6bb11b",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-05-25T02:32:18.883Z",
+    "timestamp": "2026-05-25T04:51:15.499Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.12.38",
+      "bom-ref": "@blamejs/core@0.12.40",
       "type": "application",
       "name": "blamejs",
-      "version": "0.12.38",
+      "version": "0.12.40",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.12.38",
+      "purl": "pkg:npm/%40blamejs/core@0.12.40",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.12.38",
+      "ref": "@blamejs/core@0.12.40",
       "dependsOn": []
     }
   ]