@blamejs/blamejs-shop 0.4.56 → 0.4.58

package/lib/vendor/blamejs/lib/auth/jwt-external.js

@@ -117,7 +117,16 @@ function _b64urlDecode(s) {
 // supplied alg the key can't actually produce.
 var _EC_CURVE_ALG = { prime256v1: "ES256", secp384r1: "ES384", secp521r1: "ES512" };
 
-function _verifyParamsForAlg(alg) {
+// algParams — JOSE alg → node:crypto sign/verify parameters (hash + RSA
+// PKCS1 padding / RSASSA-PSS saltLength / ECDSA dsaEncoding). The classical-
+// JOSE table (RS/PS/ES per RFC 7518 §3, EdDSA per RFC 8037) lives HERE once,
+// in the classical-JOSE domain owner: dpop proofs, fido-mds3 MDS3 BLOBs,
+// oauth ID-token verify, and this module's own sign/verify all read the
+// identical mapping. Returns null for an unrecognised alg so every caller
+// throws its OWN typed error and keeps its OWN supported set — oauth omits
+// EdDSA, dpop layers the PQC ML-DSA-87 on top. The values are sign/verify-
+// symmetric (node:crypto uses the same params for both).
+function algParams(alg) {
   if (alg === "RS256") return { hash: "sha256", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
   if (alg === "RS384") return { hash: "sha384", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
   if (alg === "RS512") return { hash: "sha512", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
@@ -128,8 +137,16 @@ function _verifyParamsForAlg(alg) {
   if (alg === "ES384") return { hash: "sha384", dsaEncoding: "ieee-p1363" };
   if (alg === "ES512") return { hash: "sha512", dsaEncoding: "ieee-p1363" };
   if (alg === "EdDSA") return { hash: null };
-  throw new AuthError("auth-jwt-external/unsupported-alg",
-    "alg '" + alg + "' is not supported by verifyExternal");
+  return null;
+}
+
+function _verifyParamsForAlg(alg) {
+  var params = algParams(alg);
+  if (!params) {
+    throw new AuthError("auth-jwt-external/unsupported-alg",
+      "alg '" + alg + "' is not supported by verifyExternal");
+  }
+  return params;
 }
 
 // _toPrivateKey — import the operator's classical signing key from any of
@@ -231,11 +248,11 @@ function _signCompactJws(header, payload, privateKey, alg) {
 }
 
 function _jwkToKey(jwk) {
-  try { return nodeCrypto.createPublicKey({ key: jwk, format: "jwk" }); }
-  catch (e) {
-    throw new AuthError("auth-jwt-external/bad-jwk",
-      "could not import JWK (kid=" + (jwk && jwk.kid) + "): " + ((e && e.message) || String(e)));
-  }
+  return bCrypto.importPublicJwk(jwk, {
+    errorClass:    AuthError,
+    code:          "auth-jwt-external/bad-jwk",
+    messagePrefix: "could not import JWK (kid=" + (jwk && jwk.kid) + "): ",
+  });
 }
 
 // CVE-2026-22817 — RS256→HS256 alg-confusion + the broader alg/kty
@@ -725,6 +742,7 @@ module.exports = {
   REFUSED_ALGS:             REFUSED_ALGS,
   // Shared JOSE defenses — routed from oauth.verifyIdToken /
   // oid4vci proof verify / sd-jwt-vc.verify / openid-federation.
+  algParams:                algParams,
   _assertAlgKtyMatch:       _assertAlgKtyMatch,
   _issuerMatches:           _issuerMatches,
   // Classical-JWS signer internals — composed by oauth.js's attestation

package/lib/vendor/blamejs/lib/auth/jwt.js

@@ -78,6 +78,7 @@ var C = require("../constants");
 var bCrypto = require("../crypto");
 var safeJson = require("../safe-json");
 var validateOpts = require("../validate-opts");
+var nonceStore = require("../nonce-store");
 var { AuthError } = require("../framework-error");
 
 // Algorithm registry. The string keys are the JWT header `alg` values
@@ -92,11 +93,12 @@ var SUPPORTED_ALGORITHMS = Object.freeze(Object.keys(ALGORITHM_TO_NODE));
 
 function _b64urlEncode(buf) { return bCrypto.toBase64Url(buf); }
 
-function _b64urlDecode(s) {
-  if (typeof s !== "string") throw new AuthError("auth-jwt/malformed", "expected base64url string");
-  try { return bCrypto.fromBase64Url(s); }
-  catch (_e) { throw new AuthError("auth-jwt/malformed", "JWT segment is not valid base64url"); }
-}
+var _b64urlDecode = bCrypto.makeBase64UrlDecoder({
+  errorClass:  AuthError,
+  code:        "auth-jwt/malformed",
+  typeMessage: "expected base64url string",
+  badMessage:  "JWT segment is not valid base64url",
+});
 
 function _toKeyObject(pemOrKey, kind) {
   // kind is 'private' or 'public' — passes through if already a KeyObject;
@@ -409,16 +411,12 @@ async function verify(token, opts) {
     if (typeof p.exp === "number") {
       expireAtMs = p.exp * C.TIME.seconds(1);
     }
-    var inserted;
-    try { inserted = await opts.replayStore.checkAndInsert(p.jti, expireAtMs); }
-    catch (e) {
-      throw new AuthError("auth-jwt/replay-store-failed",
-        "replayStore.checkAndInsert threw: " + ((e && e.message) || String(e)));
-    }
-    if (inserted === false) {
-      throw new AuthError("auth-jwt/replay",
-        "token jti='" + p.jti + "' has been seen before — replay refused");
-    }
+    await nonceStore.enforceReplay(opts.replayStore, p.jti, expireAtMs, {
+      errorClass:      AuthError,
+      storeFailedCode: "auth-jwt/replay-store-failed",
+      replayCode:      "auth-jwt/replay",
+      tokenLabel:      "token",
+    });
   }
 
   return p;

package/lib/vendor/blamejs/lib/auth/lockout.js

@@ -200,32 +200,13 @@ function create(opts) {
 
   function _scopedKey(key) { return namespace + ":" + key; }
 
-  function _emitObs(name, labels) {
-    var sink = obsInst || _safeGlobalObs();
-    if (!sink) return;
-    try { sink.event(name, 1, labels); } catch (_e) { /* observability is best-effort */ }
-  }
-
-  // Fall back to the framework's global observability registry when the
-  // operator didn't pass their own. event() is a no-op when no registry
-  // is wired, so this is zero-cost in apps without observability.
-  function _safeGlobalObs() {
-    try { return observability(); } catch (_e) { return null; }
-  }
+  // Emit to the operator's configured observability instance, else the
+  // framework's global registry (a no-op when none is wired), drop-silent.
+  var _emitObs = observability().makeCounterEmitter(obsInst);
 
-  function _emitAudit(action, key, outcome, metadata, req) {
-    if (!auditInst) return;
-    try {
-      var event = {
-        action:   action,
-        outcome:  outcome,
-        resource: { kind: "auth.lockout", id: namespace + ":" + key },
-        metadata: metadata || {},
-      };
-      if (req) event.actor = requestHelpers.extractActorContext(req);
-      auditInst.safeEmit(event);
-    } catch (_e) { /* audit best-effort */ }
-  }
+  var _emitAudit = requestHelpers.makeResourceAuditEmitter(auditInst, "auth.lockout", function (key) {
+    return namespace + ":" + key;
+  });
 
   // Cache failures fail-OPEN by design (per the framework's
   // documented brute-force-lockout posture — rather than crash the

package/lib/vendor/blamejs/lib/auth/oauth.js

@@ -215,11 +215,8 @@ var DEFAULT_CLOCK_SKEW_MS      = C.TIME.minutes(1);
 // OAuth 2.0 Threat Model §4.4.1.8 / §4.4.1.13.
 var PKCE_VERIFIER_BYTES        = C.BYTES.bytes(32);
 var STATE_NONCE_BYTES          = C.BYTES.bytes(16);
-// JOSE PSS salt lengths (RFC 7518 §3.5) match the hash-output size:
-// PS256/SHA-256 → 32, PS384/SHA-384 → 48, PS512/SHA-512 → 64.
-var PSS_SALT_BYTES_SHA256      = C.BYTES.bytes(32);
-var PSS_SALT_BYTES_SHA384      = C.BYTES.bytes(48);
-var PSS_SALT_BYTES_SHA512      = C.BYTES.bytes(64);
+// JOSE PSS salt lengths (RFC 7518 §3.5) now live with the shared alg table
+// in jwtExternal.algParams; _verifyParamsForAlg here is a thin wrapper.
 
 // RFC 8628 §3.4 — device_code length cap. The spec doesn't fix a max
 // length but 8 KiB comfortably accommodates any legitimate base64url
@@ -253,11 +250,12 @@ var RFC_8693_TOKEN_TYPES = Object.freeze([
 
 function _b64urlEncode(buf) { return bCrypto.toBase64Url(buf); }
 
-function _b64urlDecode(s) {
-  if (typeof s !== "string") throw new OAuthError("auth-oauth/bad-base64", "expected base64url string");
-  try { return bCrypto.fromBase64Url(s); }
-  catch (_e) { throw new OAuthError("auth-oauth/bad-base64", "segment is not valid base64url"); }
-}
+var _b64urlDecode = bCrypto.makeBase64UrlDecoder({
+  errorClass:  OAuthError,
+  code:        "auth-oauth/bad-base64",
+  typeMessage: "expected base64url string",
+  badMessage:  "segment is not valid base64url",
+});
 
 function _generateRandomToken(bytes) {
   return _b64urlEncode(generateBytes(bytes));
@@ -329,29 +327,27 @@ function _validateUrl(url, allowHttp, label) {
 // ---- JOSE alg → node:crypto verify parameters ----
 
 function _verifyParamsForAlg(alg) {
-  // Returns { hash, padding, dsaEncoding } for node:crypto.verify.
-  if (alg === "RS256") return { hash: "sha256", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
-  if (alg === "RS384") return { hash: "sha384", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
-  if (alg === "RS512") return { hash: "sha512", padding: nodeCrypto.constants.RSA_PKCS1_PADDING };
-  if (alg === "PS256") return { hash: "sha256", padding: nodeCrypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: PSS_SALT_BYTES_SHA256 };
-  if (alg === "PS384") return { hash: "sha384", padding: nodeCrypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: PSS_SALT_BYTES_SHA384 };
-  if (alg === "PS512") return { hash: "sha512", padding: nodeCrypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: PSS_SALT_BYTES_SHA512 };
-  if (alg === "ES256") return { hash: "sha256", dsaEncoding: "ieee-p1363" };
-  if (alg === "ES384") return { hash: "sha384", dsaEncoding: "ieee-p1363" };
-  if (alg === "ES512") return { hash: "sha512", dsaEncoding: "ieee-p1363" };
-  throw new OAuthError("auth-oauth/unsupported-alg",
-    "alg '" + alg + "' is not supported for ID-token verification");
+  // Returns { hash, padding, dsaEncoding } for node:crypto.verify, from the
+  // shared classical-JOSE table (jwtExternal.algParams). ID-token verification
+  // deliberately does NOT accept EdDSA — most OIDC OPs sign with RS256/ES256
+  // and the framework keeps the ID-token verify surface to the RSA/ECDSA set.
+  var params = jwtExternal.algParams(alg);
+  if (!params || alg === "EdDSA") {
+    throw new OAuthError("auth-oauth/unsupported-alg",
+      "alg '" + alg + "' is not supported for ID-token verification");
+  }
+  return params;
 }
 
 // ---- JWKS → KeyObject ----
 
 function _jwkToKey(jwk) {
   // node's createPublicKey accepts JWK directly since Node 16.
-  try { return nodeCrypto.createPublicKey({ key: jwk, format: "jwk" }); }
-  catch (e) {
-    throw new OAuthError("auth-oauth/bad-jwk",
-      "could not import JWK (kid=" + (jwk && jwk.kid) + "): " + ((e && e.message) || String(e)));
-  }
+  return bCrypto.importPublicJwk(jwk, {
+    errorClass:    OAuthError,
+    code:          "auth-oauth/bad-jwk",
+    messagePrefix: "could not import JWK (kid=" + (jwk && jwk.kid) + "): ",
+  });
 }
 
 // ---- RFC 9396 Rich Authorization Requests (RAR) ----
@@ -657,6 +653,16 @@ function _publicCnfJwk(jwk, label) {
     label + ": instanceKeyJwk.kty='" + jwk.kty + "' is not an asymmetric public JWK");
 }
 
+// Config-time check for an OPTIONAL epoch-seconds override (iat / nbf): if
+// present it must be a finite number, so a typo is caught at build time
+// rather than silently ignored by the `typeof === "number"` body guard.
+function _optionalFiniteNumber(value, label, code) {
+  if (value === undefined || value === null) return;
+  if (typeof value !== "number" || !isFinite(value)) {
+    throw new OAuthError(code, label + " must be a finite number (epoch seconds)");
+  }
+}
+
 /**
  * @primitive b.auth.oauth.buildClientAttestation
  * @signature b.auth.oauth.buildClientAttestation(opts)
@@ -700,14 +706,23 @@ function _publicCnfJwk(jwk, label) {
  */
 function buildClientAttestation(aopts) {
   aopts = aopts || {};
-  validateOpts(aopts, [
-    "clientId", "attesterPrivateKey", "instanceKeyJwk", "algorithm",
-    "expiresInSec", "nbf", "iat", "extraClaims",
-  ], "auth.oauth.buildClientAttestation");
-  validateOpts.requireNonEmptyString(aopts.clientId,
-    "buildClientAttestation: clientId", OAuthError, "auth-oauth/attestation-no-client-id");
-  validateOpts.optionalPositiveInt(aopts.expiresInSec,
-    "buildClientAttestation: expiresInSec", OAuthError, "auth-oauth/attestation-bad-expiry");
+  validateOpts.shape(aopts, {
+    clientId:     { rule: "required-string",       code: "auth-oauth/attestation-no-client-id" },
+    // KeyObject | PEM string | JWK object — typed downstream by
+    // _toAttestationPrivateKey; the shape only enforces presence.
+    attesterPrivateKey: function (v, l) {
+      if (v === undefined || v === null) {
+        throw new OAuthError("auth-oauth/attestation-no-attester-key",
+          l + " (Attester signing key) is required");
+      }
+    },
+    instanceKeyJwk: { rule: "required-object",   code: "auth-oauth/attestation-bad-cnf" },
+    algorithm:      { rule: "optional-string",   code: "auth-oauth/attestation-bad-alg" },
+    nbf:            function (v, l) { _optionalFiniteNumber(v, l, "auth-oauth/attestation-bad-nbf"); },
+    iat:            function (v, l) { _optionalFiniteNumber(v, l, "auth-oauth/attestation-bad-iat"); },
+    extraClaims:    { rule: "optional-plain-object", code: "auth-oauth/attestation-bad-extra-claims" },
+    expiresInSec: { rule: "optional-positive-int", code: "auth-oauth/attestation-bad-expiry" },
+  }, "buildClientAttestation", OAuthError, "auth-oauth/attestation-no-client-id");
   var key = _toAttestationPrivateKey(aopts.attesterPrivateKey, "buildClientAttestation");
   var alg = _resolveAttestationAlg(aopts.algorithm, key, "buildClientAttestation");
   var cnfJwk = _publicCnfJwk(aopts.instanceKeyJwk, "buildClientAttestation");
@@ -769,16 +784,23 @@ function buildClientAttestation(aopts) {
  */
 function buildClientAttestationPop(popts) {
   popts = popts || {};
-  validateOpts(popts, [
-    "instancePrivateKey", "audience", "algorithm", "challenge",
-    "jti", "iat", "expiresInSec",
-  ], "auth.oauth.buildClientAttestationPop");
-  validateOpts.requireNonEmptyString(popts.audience,
-    "buildClientAttestationPop: audience (AS issuer)", OAuthError, "auth-oauth/attestation-pop-no-aud");
-  validateOpts.optionalNonEmptyString(popts.challenge,
-    "buildClientAttestationPop: challenge", OAuthError, "auth-oauth/attestation-pop-bad-challenge");
-  validateOpts.optionalPositiveInt(popts.expiresInSec,
-    "buildClientAttestationPop: expiresInSec", OAuthError, "auth-oauth/attestation-pop-bad-expiry");
+  validateOpts.shape(popts, {
+    audience:     { rule: "required-string",       code: "auth-oauth/attestation-pop-no-aud",
+                    label: "buildClientAttestationPop: audience (AS issuer)" },
+    // KeyObject | PEM string | JWK object — typed downstream by
+    // _toAttestationPrivateKey; the shape only enforces presence.
+    instancePrivateKey: function (v, l) {
+      if (v === undefined || v === null) {
+        throw new OAuthError("auth-oauth/attestation-pop-no-instance-key",
+          l + " (instance signing key matching cnf.jwk) is required");
+      }
+    },
+    algorithm:    { rule: "optional-string",       code: "auth-oauth/attestation-pop-bad-alg" },
+    jti:          { rule: "optional-string",       code: "auth-oauth/attestation-pop-bad-jti" },
+    iat:          function (v, l) { _optionalFiniteNumber(v, l, "auth-oauth/attestation-pop-bad-iat"); },
+    challenge:    { rule: "optional-string",       code: "auth-oauth/attestation-pop-bad-challenge" },
+    expiresInSec: { rule: "optional-positive-int", code: "auth-oauth/attestation-pop-bad-expiry" },
+  }, "buildClientAttestationPop", OAuthError, "auth-oauth/attestation-pop-no-aud");
   var key = _toAttestationPrivateKey(popts.instancePrivateKey, "buildClientAttestationPop");
   var alg = _resolveAttestationAlg(popts.algorithm, key, "buildClientAttestationPop");
   var iatSec = typeof popts.iat === "number" ? popts.iat : Math.floor(Date.now() / C.TIME.seconds(1));

package/lib/vendor/blamejs/lib/auth/oid4vci.js

@@ -54,7 +54,7 @@ var lazyRequire  = require("../lazy-require");
 var validateOpts = require("../validate-opts");
 var safeJson     = require("../safe-json");
 var nodeCrypto   = require("node:crypto");
-var { generateToken, sha3Hash, timingSafeEqual } = require("../crypto");
+var { generateToken, sha3Hash, timingSafeEqual, importPublicJwk } = require("../crypto");
 // Shared JOSE defenses (CVE-2026-22817 alg/kty cross-check). Top-of-
 // file per project convention §3; no circular load — jwt-external
 // requires nothing from oid4vci.
@@ -297,11 +297,11 @@ async function _verifyProofJwt(proofJwt, expectedAud, expectedCNonce, expectedCl
     // A resolver that returns an RSA key for a proof declaring an HMAC
     // alg would otherwise be verified as an HMAC secret.
     jwtExternal._assertAlgKtyMatch(header.alg, holderKeyJwk);
-    try { keyObj = nodeCrypto.createPublicKey({ key: holderKeyJwk, format: "jwk" }); }
-    catch (e) {
-      throw new AuthError("auth-oid4vci/bad-resolved-key",
-        "credential issuance: resolveKid-returned key is not importable as a public key: " + ((e && e.message) || String(e)));
-    }
+    keyObj = importPublicJwk(holderKeyJwk, {
+      errorClass:    AuthError,
+      code:          "auth-oid4vci/bad-resolved-key",
+      messagePrefix: "credential issuance: resolveKid-returned key is not importable as a public key: ",
+    });
   } else if (!holderKeyJwk && header.x5c) {
     // RFC 7515 §4.1.6 / OID4VCI §8.2.1.1 — the wallet ships a base64 DER
     // certificate chain; the LEAF (first) cert's SPKI is the holder key.
@@ -333,11 +333,11 @@ async function _verifyProofJwt(proofJwt, expectedAud, expectedCNonce, expectedCl
     // A leaf cert holding an RSA key against a proof declaring an HMAC
     // alg would otherwise be verified as an HMAC secret.
     jwtExternal._assertAlgKtyMatch(header.alg, holderKeyJwk);
-    try { keyObj = nodeCrypto.createPublicKey({ key: holderKeyJwk, format: "jwk" }); }
-    catch (e) {
-      throw new AuthError("auth-oid4vci/bad-x5c",
-        "credential issuance: proof JWT `x5c` leaf public key is not importable: " + ((e && e.message) || String(e)));
-    }
+    keyObj = importPublicJwk(holderKeyJwk, {
+      errorClass:    AuthError,
+      code:          "auth-oid4vci/bad-x5c",
+      messagePrefix: "credential issuance: proof JWT `x5c` leaf public key is not importable: ",
+    });
   } else {
     if (!holderKeyJwk) {
       throw new AuthError("auth-oid4vci/no-jwk-in-header",
@@ -349,11 +349,11 @@ async function _verifyProofJwt(proofJwt, expectedAud, expectedCNonce, expectedCl
     // key as an HMAC secret. Routed through the shared helper so every
     // JWT verifier in the framework enforces the same check.
     jwtExternal._assertAlgKtyMatch(header.alg, holderKeyJwk);
-    try { keyObj = nodeCrypto.createPublicKey({ key: holderKeyJwk, format: "jwk" }); }
-    catch (e) {
-      throw new AuthError("auth-oid4vci/bad-jwk",
-        "credential issuance: proof JWT jwk is not parseable: " + ((e && e.message) || String(e)));
-    }
+    keyObj = importPublicJwk(holderKeyJwk, {
+      errorClass:    AuthError,
+      code:          "auth-oid4vci/bad-jwk",
+      messagePrefix: "credential issuance: proof JWT jwk is not parseable: ",
+    });
   }
 
   var signingInput = parts[0] + "." + parts[1];
@@ -428,13 +428,36 @@ async function _verifyProofJwt(proofJwt, expectedAud, expectedCNonce, expectedCl
  *   });
  */
 function create(opts) {
+  // Preserve the original object-guard's exact label + default code
+  // (distinct from the per-field "issuer.create:" label prefix below).
   validateOpts.requireObject(opts, "auth.oid4vci.issuer.create", AuthError);
-  validateOpts.requireNonEmptyString(opts.credentialIssuerUrl,
-    "issuer.create: credentialIssuerUrl", AuthError, "auth-oid4vci/no-issuer-url");
-  validateOpts.requireNonEmptyString(opts.credentialEndpoint,
-    "issuer.create: credentialEndpoint", AuthError, "auth-oid4vci/no-credential-endpoint");
-  validateOpts.requireNonEmptyString(opts.tokenEndpoint,
-    "issuer.create: tokenEndpoint", AuthError, "auth-oid4vci/no-token-endpoint");
+  validateOpts.shape(opts, {
+    credentialIssuerUrl: { rule: "required-string", code: "auth-oid4vci/no-issuer-url" },
+    credentialEndpoint:  { rule: "required-string", code: "auth-oid4vci/no-credential-endpoint" },
+    tokenEndpoint:       { rule: "required-string", code: "auth-oid4vci/no-token-endpoint" },
+    // sdJwtIssuer + supportedCredentials carry distinct bespoke checks
+    // (instance shape / non-empty map / per-credential format+vct) below;
+    // declare them here so the exhaustive contract accepts the keys —
+    // required-object validates only that they are objects, which the
+    // bespoke checks then refine.
+    sdJwtIssuer:          "required-object",
+    supportedCredentials: "required-object",
+    proofAlgorithms:      "optional-string-array",
+    // resolveKid / validateX5c carry distinct per-field codes the inline
+    // config-time guards used; the descriptor form keeps the exact code +
+    // label inside the exhaustive shape.
+    resolveKid:           { rule: "optional-function", code: "auth-oid4vci/bad-resolve-kid" },
+    validateX5c:          { rule: "optional-function", code: "auth-oid4vci/bad-validate-x5c" },
+    preAuthCodeTtlMs:     "optional-positive-finite",
+    accessTokenTtlMs:     "optional-positive-finite",
+    cNonceTtlMs:          "optional-positive-finite",
+    proofMaxAgeMs:        "optional-positive-finite",
+    accessTokenSingleUse: "optional-boolean",
+    codeStore:            "optional-plain-object",
+    accessTokenStore:     "optional-plain-object",
+    cNonceStore:          "optional-plain-object",
+    authorizationServers: "optional-string-array",
+  }, "issuer.create", AuthError);
   if (!opts.sdJwtIssuer || typeof opts.sdJwtIssuer.issue !== "function") {
     throw new AuthError("auth-oid4vci/no-sd-jwt-issuer",
       "issuer.create: sdJwtIssuer must be a b.auth.sdJwtVc.issuer instance");
@@ -464,18 +487,18 @@ function create(opts) {
     ? opts.proofAlgorithms : ["ES256", "ES384", "EdDSA"];
 
   // Optional kid-resolver for kid-only proofs (EUDI-Wallet attested-key
-  // flow). Config-time throw if supplied but not a function. Absent →
-  // kid-only proofs keep the clear refusal (back-compat).
-  var resolveKid = validateOpts.optionalFunction(opts.resolveKid,
-    "issuer.create: resolveKid", AuthError, "auth-oid4vci/bad-resolve-kid");
+  // flow). Validated by the shape above (config-time throw if supplied
+  // but not a function). Absent → kid-only proofs keep the clear refusal
+  // (back-compat).
+  var resolveKid = opts.resolveKid;
 
   // Optional x5c chain-trust policy for x5c proofs (RFC 7515 §4.1.6 /
-  // OID4VCI §8.2.1.1). Config-time throw if supplied but not a function.
-  // Absent → the leaf-cert SPKI binds at the same self-asserted trust
-  // level as an inline `jwk` (the proof signature binds the key); chain
-  // anchoring beyond that is the operator's to enforce via this callback.
-  var validateX5c = validateOpts.optionalFunction(opts.validateX5c,
-    "issuer.create: validateX5c", AuthError, "auth-oid4vci/bad-validate-x5c");
+  // OID4VCI §8.2.1.1). Validated by the shape above (config-time throw if
+  // supplied but not a function). Absent → the leaf-cert SPKI binds at the
+  // same self-asserted trust level as an inline `jwk` (the proof signature
+  // binds the key); chain anchoring beyond that is the operator's to
+  // enforce via this callback.
+  var validateX5c = opts.validateX5c;
 
   var preAuthTtl = opts.preAuthCodeTtlMs || DEFAULT_PRE_AUTH_TTL_MS;
   var accessTokenTtl = opts.accessTokenTtlMs || DEFAULT_ACCESS_TOKEN_TTL;

package/lib/vendor/blamejs/lib/auth/oid4vp.js

@@ -52,6 +52,7 @@
 
 var lazyRequire  = require("../lazy-require");
 var validateOpts = require("../validate-opts");
+var boundedMap   = require("../bounded-map");
 var { generateToken } = require("../crypto");
 var { AuthError } = require("../framework-error");
 
@@ -90,10 +91,10 @@ function _validateDcql(dcql) {
       throw new AuthError("auth-oid4vp/no-credential-id",
         "DCQL: credentials[" + i + "].id is required");
     }
-    if (seenIds.has(cred.id)) {
+    boundedMap.requireAbsentMember(seenIds, cred.id, function () {
       throw new AuthError("auth-oid4vp/duplicate-id",
         "DCQL: credentials[" + i + "].id \"" + cred.id + "\" duplicated");
-    }
+    });
     seenIds.add(cred.id);
     if (typeof cred.format !== "string" || cred.format.length === 0) {
       throw new AuthError("auth-oid4vp/no-format",

package/lib/vendor/blamejs/lib/auth/openid-federation.js

@@ -58,6 +58,7 @@ var lazyRequire  = require("../lazy-require");
 var validateOpts = require("../validate-opts");
 var safeJson     = require("../safe-json");
 var nodeCrypto   = require("node:crypto");
+var bCrypto      = require("../crypto");
 var C            = require("../constants");
 // Shared JOSE defenses (CVE-2026-22817 alg/kty cross-check +
 // CVE-2026-23552 constant-time iss compare). Top-of-file per project
@@ -195,12 +196,11 @@ function verifyEntityStatement(jwt, jwks, vopts) {
   // same check.
   jwtExternal._assertAlgKtyMatch(parsed.header.alg, key);
 
-  var keyObj;
-  try { keyObj = nodeCrypto.createPublicKey({ key: key, format: "jwk" }); }
-  catch (e) {
-    throw new AuthError("auth-openid-federation/bad-jwk",
-      "verifyEntityStatement: JWK is not parseable: " + ((e && e.message) || String(e)));
-  }
+  var keyObj = bCrypto.importPublicJwk(key, {
+    errorClass:    AuthError,
+    code:          "auth-openid-federation/bad-jwk",
+    messagePrefix: "verifyEntityStatement: JWK is not parseable: ",
+  });
 
   var hash = _hashByAlg(parsed.header.alg);
   var verifyOpts = { key: keyObj };

package/lib/vendor/blamejs/lib/auth/passkey.js

@@ -325,7 +325,7 @@ function _b64urlExtInput(value, name, maxBytes) {
     }
     if (typeof maxBytes === "number") {
       var decoded = Buffer.from(value, "base64url");
-      if (decoded.length > maxBytes) {
+      if (safeBuffer.byteLengthOf(decoded) > maxBytes) {
         throw new AuthError("auth-passkey/extension-input-too-large",
           name + " decoded length " + decoded.length + " exceeds " + maxBytes + " bytes");
       }
@@ -333,14 +333,14 @@ function _b64urlExtInput(value, name, maxBytes) {
     return value;
   }
   if (Buffer.isBuffer(value)) {
-    if (typeof maxBytes === "number" && value.length > maxBytes) {
+    if (typeof maxBytes === "number" && safeBuffer.byteLengthOf(value) > maxBytes) {
       throw new AuthError("auth-passkey/extension-input-too-large",
         name + " length " + value.length + " exceeds " + maxBytes + " bytes");
     }
     return value.toString("base64url");
   }
   if (value instanceof Uint8Array) {
-    if (typeof maxBytes === "number" && value.length > maxBytes) {
+    if (typeof maxBytes === "number" && safeBuffer.byteLengthOf(value) > maxBytes) {
       throw new AuthError("auth-passkey/extension-input-too-large",
         name + " length " + value.length + " exceeds " + maxBytes + " bytes");
     }

package/lib/vendor/blamejs/lib/auth/password.js

@@ -421,7 +421,13 @@ function policy(opts) {
       var sha1Full = hibpSha1.sha1Hex(plaintext).toUpperCase();
       var prefix = sha1Full.slice(0, 5);
       var suffix = sha1Full.slice(5);
-      var url = p.hibpEndpoint.replace(/\/+$/, "") + "/range/" + prefix;
+      // Strip trailing slashes with a linear backward scan rather than
+      // /\/+$/ — the `$`-after-greedy-`+` regex is O(n^2) in V8 on a value
+      // that is a long run of '/' (the engine retries from every offset).
+      // Byte-identical result, unconditionally linear.
+      var endEp = p.hibpEndpoint.length;
+      while (endEp > 0 && p.hibpEndpoint.charCodeAt(endEp - 1) === 0x2f) { endEp -= 1; }
+      var url = p.hibpEndpoint.slice(0, endEp) + "/range/" + prefix;
       var resp;
       try {
         resp = await httpClient.request({

package/lib/vendor/blamejs/lib/auth/saml.js

@@ -332,13 +332,18 @@ function _verifyXmldsig(envelope, signatureNode, certPem) {
  *   });
  */
 function create(opts) {
-  validateOpts.requireObject(opts, "auth.saml.sp.create", AuthError);
-  validateOpts.requireNonEmptyString(opts.entityId, "entityId", AuthError, "auth-saml/no-entity-id");
-  validateOpts.requireNonEmptyString(opts.assertionConsumerServiceUrl, "assertionConsumerServiceUrl",
-    AuthError, "auth-saml/no-acs");
-  validateOpts.requireNonEmptyString(opts.idpEntityId, "idpEntityId", AuthError, "auth-saml/no-idp-entity-id");
-  validateOpts.requireNonEmptyString(opts.idpSsoUrl, "idpSsoUrl", AuthError, "auth-saml/no-idp-sso");
-  validateOpts.requireNonEmptyString(opts.idpCertPem, "idpCertPem", AuthError, "auth-saml/no-idp-cert");
+  validateOpts.shape(opts, {
+    entityId:                    { rule: "required-string", label: "entityId",                    code: "auth-saml/no-entity-id" },
+    assertionConsumerServiceUrl: { rule: "required-string", label: "assertionConsumerServiceUrl", code: "auth-saml/no-acs" },
+    idpEntityId:                 { rule: "required-string", label: "idpEntityId",                 code: "auth-saml/no-idp-entity-id" },
+    idpSsoUrl:                   { rule: "required-string", label: "idpSsoUrl",                    code: "auth-saml/no-idp-sso" },
+    idpCertPem:                  { rule: "required-string", label: "idpCertPem",                   code: "auth-saml/no-idp-cert" },
+    audience:                    "optional-string",
+    clockSkewSec:                "optional-non-negative",
+    nameIdFormat:                "optional-string",
+    singleLogoutServiceUrl:      "optional-string",
+    idpSloUrl:                   "optional-string",
+  }, "auth.saml.sp.create", AuthError);
 
   var audience = opts.audience || opts.entityId;
   var clockSkewSec = typeof opts.clockSkewSec === "number" ? opts.clockSkewSec : 60;             // allow:raw-time-literal — clock-skew default
@@ -973,6 +978,25 @@ function create(opts) {
    *     idpVerifyAlg: "ml-dsa-65",
    *   });
    */
+  // _extractRedirectSignature(queryString) — split a SAML HTTP-Redirect
+  // binding query string, pulling the URL-decoded `Signature=` value out and
+  // collecting the remaining (signed) portion in order. Shared by
+  // parseLogoutRequest / parseLogoutResponse so the two cannot drift on which
+  // bytes the signature covers — a drift would be a signature-bypass.
+  function _extractRedirectSignature(queryString) {
+    var parts = queryString.split("&");
+    var sigValue = null;
+    var signedPortion = [];
+    for (var i = 0; i < parts.length; i += 1) {
+      if (parts[i].indexOf("Signature=") === 0) {
+        sigValue = decodeURIComponent(parts[i].slice("Signature=".length));
+      } else {
+        signedPortion.push(parts[i]);
+      }
+    }
+    return { sigValue: sigValue, signedPortion: signedPortion };
+  }
+
   function parseLogoutRequest(samlRequestB64, vopts) {
     vopts = vopts || {};
     if (typeof samlRequestB64 !== "string" || samlRequestB64.length === 0) {
@@ -998,16 +1022,9 @@ function create(opts) {
         throw new AuthError("auth-saml/bad-verify-alg",
           "parseLogoutRequest: idpVerifyAlg must be 'ml-dsa-65' / 'ml-dsa-87' / 'ed25519'");
       }
-      var parts = vopts.queryString.split("&");
-      var sigValue = null;
-      var signedPortion = [];
-      for (var i = 0; i < parts.length; i += 1) {
-        if (parts[i].indexOf("Signature=") === 0) {
-          sigValue = decodeURIComponent(parts[i].slice("Signature=".length));
-        } else {
-          signedPortion.push(parts[i]);
-        }
-      }
+      var sig = _extractRedirectSignature(vopts.queryString);
+      var sigValue = sig.sigValue;
+      var signedPortion = sig.signedPortion;
       if (!sigValue) {
         throw new AuthError("auth-saml/no-signature",
           "parseLogoutRequest: queryString lacks Signature parameter");
@@ -1193,16 +1210,9 @@ function create(opts) {
         throw new AuthError("auth-saml/bad-verify-alg",
           "parseLogoutResponse: idpVerifyAlg must be 'ml-dsa-65' / 'ml-dsa-87' / 'ed25519'");
       }
-      var parts = vopts.queryString.split("&");
-      var sigValue = null;
-      var signedPortion = [];
-      for (var i = 0; i < parts.length; i += 1) {
-        if (parts[i].indexOf("Signature=") === 0) {
-          sigValue = decodeURIComponent(parts[i].slice("Signature=".length));
-        } else {
-          signedPortion.push(parts[i]);
-        }
-      }
+      var sig = _extractRedirectSignature(vopts.queryString);
+      var sigValue = sig.sigValue;
+      var signedPortion = sig.signedPortion;
       if (!sigValue) {
         throw new AuthError("auth-saml/no-signature",
           "parseLogoutResponse: queryString lacks Signature parameter");