@blamejs/pki 0.6.14 → 0.6.16

package/lib/framework-error.js

@@ -33,17 +33,15 @@ var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _String = intrinsic.String;
 var _defineProperty = intrinsic.defineProperty;
 
-// The frozen shape of every error code: a `domain/reason` string -- one or more lowercase alphanumerics or
-// dashes, a single "/", then one or more of the same. Decided by character scan (no regex).
 function _isCodeShape(c) {
   var n = c.length, i, ch, slash = -1;
-  if (n < 3) return false;                                             // shortest is "a/b"
+  if (n < 3) return false;
   for (i = 0; i < n; i += 1) {
     ch = _charCodeAt(c, i);
-    if (ch === 47) { if (slash !== -1) return false; slash = i; }       // "/" -- at most one
-    else if (!((ch >= 97 && ch <= 122) || (ch >= 48 && ch <= 57) || ch === 45)) return false;   // a-z 0-9 "-"
+    if (ch === 47) { if (slash !== -1) return false; slash = i; }
+    else if (!((ch >= 97 && ch <= 122) || (ch >= 48 && ch <= 57) || ch === 45)) return false;
   }
-  return slash > 0 && slash < n - 1;                                   // one slash, both sides non-empty
+  return slash > 0 && slash < n - 1;
 }
 
 /**
@@ -135,251 +133,75 @@ function defineClass(name, opts) {
   return GeneratedError;
 }
 
-// ---- Per-domain error classes ----
 
-// ConstantsError -- a bad scale argument to C.TIME.* / C.BYTES.* (an
-// authoring bug caught at config time).
 var ConstantsError = defineClass("ConstantsError");
 
-// Asn1Error -- malformed / non-canonical DER: truncated TLV, indefinite
-// length, non-minimal length or integer, leftover trailing bytes, depth
-// or size cap exceeded. DER is a canonical encoding, so anything the
-// decoder rejects is permanently invalid. withCause threads a raw byte-view
-// failure (a detached backing ArrayBuffer) as the cause rather than discarding it.
 var Asn1Error = defineClass("Asn1Error", { withCause: true });
 
-// CborError -- malformed / non-deterministic CBOR: a reserved or indefinite
-// additional-info value, a stray break, a non-minimal ("preferred") argument,
-// a non-shortest or non-canonical-NaN float, an out-of-order or duplicate map
-// key, a non-minimal / oversized bignum, bad UTF-8, a wrong-typed tag body,
-// leftover trailing bytes, or a depth / size cap exceeded. RFC 8949 core-
-// deterministic encoding (sec. 4.2.1) is canonical, so anything the decoder
-// rejects is permanently invalid. withCause threads a raw byte-view failure
-// (a detached backing ArrayBuffer) as the cause rather than discarding it.
 var CborError = defineClass("CborError", { withCause: true });
 
-// OidError -- a malformed object-identifier: fewer than two arcs, a first
-// arc outside 0..2, a second arc >= 40 under arcs 0/1, or a non-minimal
-// base-128 sub-identifier. withCause threads a raw byte-view failure (a detached
-// backing ArrayBuffer at fromDER) as the cause rather than discarding it.
 var OidError = defineClass("OidError", { withCause: true });
 
-// PemError -- a malformed PEM envelope: missing / mismatched BEGIN/END
-// markers, a bad label, or non-base64 body.
 var PemError = defineClass("PemError", { withCause: true });
 
-// CertificateError -- a byte sequence that is not a well-formed X.509
-// certificate (wrong outer structure, unparseable field, unsupported
-// version).
 var CertificateError = defineClass("CertificateError", { withCause: true });
 
-// CrlError -- a byte sequence that is not a well-formed X.509 CRL
-// (CertificateList / TBSCertList -- RFC 5280 sec. 5).
 var CrlError = defineClass("CrlError", { withCause: true });
 
-// SchemaError -- the schema-family orchestrator's own errors (input that matches
-// no registered format / does not decode). (code, message) shape like the rest.
 var SchemaError = defineClass("SchemaError", { withCause: true });
 
-// CsrError -- a byte sequence that is not a well-formed PKCS#10 CertificationRequest
-// (RFC 2986).
 var CsrError = defineClass("CsrError", { withCause: true });
 
-// Pkcs8Error -- a byte sequence that is not a well-formed PKCS#8 PrivateKeyInfo /
-// OneAsymmetricKey or EncryptedPrivateKeyInfo (RFC 5208 sec. 5, RFC 5958 sec. 2/sec. 3).
 var Pkcs8Error = defineClass("Pkcs8Error", { withCause: true });
 
-// CmsError -- a byte sequence that is not a well-formed CMS ContentInfo /
-// SignedData (RFC 5652). Carries the underlying leaf fault as `.cause`.
 var CmsError = defineClass("CmsError", { withCause: true });
 
-// OcspError -- a byte sequence that is not a well-formed OCSP request or response
-// (OCSPRequest / OCSPResponse -- RFC 6960 sec. 4). Carries the leaf fault as `.cause`.
 var OcspError = defineClass("OcspError", { withCause: true });
 
-// TspError -- a byte sequence that is not a well-formed RFC 3161 timestamp token,
-// TSTInfo, or TimeStampResp. Carries the underlying leaf fault as `.cause`.
 var TspError = defineClass("TspError", { withCause: true });
 
-// AttrCertError -- a byte sequence that is not a well-formed X.509 Attribute
-// Certificate (AttributeCertificate / AttributeCertificateInfo -- RFC 5755 sec. 4),
-// or a recognized-and-deferred legacy AttributeCertificateV1. Carries the
-// underlying leaf fault as `.cause`.
 var AttrCertError = defineClass("AttrCertError", { withCause: true });
 
-// CrmfError -- a byte sequence that is not a well-formed RFC 4211 CertReqMessages
-// / CertReqMsg / CertRequest / CertTemplate. Carries the underlying leaf fault as
-// `.cause`.
 var CrmfError = defineClass("CrmfError", { withCause: true });
 
-// Pkcs12Error -- a byte sequence that is not a well-formed RFC 7292 PFX
-// (AuthenticatedSafe / SafeContents / SafeBag), or a PFX violating a sec. 4
-// coherence rule (version, integrity mode, bag dispatch, MacData). Carries
-// the underlying leaf fault as `.cause`.
 var Pkcs12Error = defineClass("Pkcs12Error", { withCause: true });
 
-// CmpError -- a byte sequence that is not a well-formed RFC 9810 PKIMessage
-// (PKIHeader / PKIBody / protection / extraCerts), or one violating a sec. 5
-// coherence rule (protection<=>protectionAlg, certConf-hashAlg<=>pvno). Carries
-// the underlying leaf fault as `.cause`.
 var CmpError = defineClass("CmpError", { withCause: true });
 
-// PathError -- a certification path that fails RFC 5280 sec. 6 validation, or a
-// malformed input handed to the validator (an extension value that does not
-// decode, an empty path, an unsupported signature algorithm). Carries the
-// per-check reason in `.code` (`path/*`) and the underlying leaf fault as
-// `.cause`.
 var PathError = defineClass("PathError", { withCause: true });
 
-// SmimeError -- a byte sequence that is not a well-formed RFC 5035 ESS
-// signing-certificate attribute (SigningCertificate / SigningCertificateV2 /
-// ESSCertID(v2) / IssuerSerial) or RFC 8551 SMIMECapabilities, or a CMS
-// attribute violating a sec. 2.5 coherence rule (single-AttributeValue, certs
-// non-empty, non-canonical DEFAULT hashAlgorithm). Carries the underlying leaf
-// fault (e.g. the inner asn1/* decode error) as `.cause`.
 var SmimeError = defineClass("SmimeError", { withCause: true });
 
-// CtError -- a byte sequence that is not a well-formed RFC 6962 Certificate
-// Transparency SCT list: a malformed inner DER OCTET-STRING wrap, or a TLS
-// presentation-language framing violation (a lying vector length, a field read
-// past its bound, a truncated element). An SCT whose version this parser does
-// not define is NOT an error -- RFC 6962 sec. 3.3 makes unknown versions skippable,
-// so they are preserved opaque. Carries the underlying leaf fault (e.g. the
-// inner `asn1/*` decode error) as `.cause`.
 var CtError = defineClass("CtError", { withCause: true });
 
-// ScepError -- a byte sequence that is not a well-formed SCEP pkiMessage (RFC 8894): a
-// malformed CMS layering, a missing or mis-encoded transaction attribute, an unknown
-// messageType / pkiStatus / failInfo enumerant, a nonce mismatch, or a weak-algorithm
-// profile violation. Fail-closed: a malformed or off-profile message is a typed verdict.
 var ScepError = defineClass("ScepError", { withCause: true });
 
-// TlsError -- a byte sequence that is not a well-formed TLS handshake structure:
-// an RFC 8879 CompressedCertificate whose framing is violated (a lying vector
-// length, a field read past its bound, an empty compressed message), whose
-// compression algorithm this toolkit does not implement or the caller did not
-// offer, whose declared uncompressed length disagrees with what the stream
-// actually produces, or whose compressed body is a decompression bomb. Carries
-// the underlying leaf fault (the decompressor's own error) as `.cause`.
 var TlsError = defineClass("TlsError", { withCause: true });
 
-// C509Error -- a CBOR byte sequence that is not a well-formed C509 certificate
-// (draft-ietf-cose-cbor-encoded-cert): a root that is not the 11-element array, a
-// c509CertificateType outside {2,3}, a field encoded against its ~biguint/~time/~oid
-// contract, an algorithm/attribute/extension int with no registry row, or a type-3
-// cert that does not invert byte-for-byte to its original DER. Carries the underlying
-// leaf fault (the inner `cbor/*` or `asn1/*` decode error) as `.cause`.
 var C509Error = defineClass("C509Error", { withCause: true });
 
-// MerkleError -- a malformed input to the RFC 6962 / RFC 9162 Merkle-tree
-// proof-verification core: a tree coordinate that is not a non-negative integer
-// (or a Number above 2^53 where an exact BigInt is required), a leafIndex
-// outside its tree, an inverted consistency window, a hash chunk that is not 32
-// bytes, or a proof whose node count does not match the tree geometry. The final
-// root comparison is a constant-time boolean (root matched / did not), NOT an
-// error -- only a structurally malformed input throws. Carries an underlying
-// leaf fault as `.cause`.
 var MerkleError = defineClass("MerkleError", { withCause: true });
 
-// CsrattrsError -- a byte sequence that is not a well-formed RFC 8951 sec. 3.5
-// CsrAttrs (SEQUENCE OF AttrOrOID), or one violating an RFC 9908 semantic rule
-// (a repeated id-ExtensionReq, an extension-request values SET that is not
-// exactly one Extensions, a template version other than v1(0), a mixed
-// extension-request template). Carries the underlying leaf fault as `.cause`.
 var CsrattrsError = defineClass("CsrattrsError", { withCause: true });
 
-// EstError -- an RFC 7030 / 8951 / 9908 Enrollment-over-Secure-Transport
-// protocol fault: a payload that fails a per-operation validator (a non-certs-
-// only /cacerts response, a serverkeygen recipient-arm mismatch), a transfer /
-// multipart framing violation, or an HTTP response the classifier rejects.
-// Carries the underlying leaf / delegated fault (e.g. a cms/* or asn1/*) as
-// `.cause`.
 var EstError = defineClass("EstError", { withCause: true });
 
-// CmcError -- an RFC 5272 / 6402 Certificate Management over CMS message-layer
-// fault: a PKIData / PKIResponse whose structure, body-part identity, control
-// placement or status encoding is malformed, a control this side must act on
-// that cannot be decoded, or an exchange binding (transactionId / recipientNonce)
-// that does not match the request it answers. Distinct from EstError because the
-// CMC layer is the MESSAGE and EST is the TRANSPORT that carried it: an operator
-// needs to know whether the CA's answer was unreadable or the HTTP hop failed.
-// Carries the underlying cms/* or asn1/* leaf fault as `.cause`.
 var CmcError = defineClass("CmcError", { withCause: true });
 
-// TransportError -- a fault from the shared node:https transport (pki.transport):
-// a non-https / unparseable request URL, a missing trust anchor, a TLS handshake /
-// server-authentication failure, a negotiated protocol below the floor, a response
-// over the size cap, or a connect / read timeout. A protocol client (est / acme /
-// cmp) may parameterize the transport with its OWN error factory + code prefix so
-// the same choke point surfaces domain codes; this is the default identity when the
-// transport is used directly. Carries the underlying socket / TLS fault as `.cause`.
 var TransportError = defineClass("TransportError", { withCause: true });
 
-// JoseError -- a JOSE (RFC 7515 JWS / RFC 7518 JWA / RFC 7638 thumbprint)
-// fault: a non-canonical base64url field, a duplicate JSON member, a
-// bounds violation, a header that fails its profile (alg/nonce/url/jwk-kid),
-// an unknown or MAC algorithm on the outer profile, a signature of the wrong
-// length for its alg, or a verify failure. Carries the underlying leaf fault
-// (a webcrypto / asn1 error) as `.cause`.
 var JoseError = defineClass("JoseError", { withCause: true });
 
-// AcmeError -- an RFC 8555 / 8737 / 8738 / 9773 ACME message-layer fault: a
-// resource object that fails its spec (bad status enum, a missing
-// conditionally-required field, an immutable field mutated), an illegal state
-// transition, an identifier/token/nonce that fails validation, a CSR whose
-// identifiers or key do not match the order, or a renewal window inversion.
-// Carries the delegated jose/* or a DER leaf fault as `.cause`.
 var AcmeError = defineClass("AcmeError", { withCause: true });
 
-// TrustError -- a Mozilla/NSS certdata.txt or CCADB CSV root-store input that
-// fails ingestion: a malformed or oversized object block, a bad \ooo octal
-// escape, an unrecognized CK_TRUST value, a certificate/trust-object pairing
-// disagreement (metadata must never attach to the wrong root), an undecodable
-// distrust-after time, a CSV framing / required-column violation, a CKA_VALUE
-// or PEM cell that is not a well-formed certificate, or a purpose the entry is
-// not a trusted delegator for. Carries the underlying leaf fault (an x509/* or
-// asn1/* error) as `.cause`.
 var TrustError = defineClass("TrustError", { withCause: true });
 var ShbsError = defineClass("ShbsError", { withCause: true });
 var HpkeError = defineClass("HpkeError", { withCause: true });
-// KemError -- a malformed composite ML-KEM key or ciphertext, or an unsupported
-// composite algorithm (draft-ietf-lamps-pq-composite-kem). Raised by pki.kem.
 var KemError = defineClass("KemError", { withCause: true });
-// SigstoreError -- a Sigstore bundle (npm --provenance artifact) that is not a
-// well-formed / verifiable keyless signature: a malformed or oversize JSON
-// bundle, an unknown media type or content arm, a DSSE envelope missing a
-// required field or whose signature does not verify under the Fulcio leaf key, a
-// Rekor inclusion proof that does not reconstruct the signed tree root, an
-// unsigned/attacker-supplied root, an entry that does not bind this signature, a
-// Fulcio identity that fails the caller policy, or a payload that is not the
-// expected in-toto Statement. Carries the underlying leaf fault (an x509/*,
-// merkle/*, or asn1/* error) as `.cause`.
 var SigstoreError = defineClass("SigstoreError", { withCause: true });
-// InspectError -- a bad input to the human-readable inspector (pki.inspect): a
-// value that is neither a parsed structure, DER Buffer, nor PEM string, or a PEM
-// whose label does not decode. Rendering itself is best-effort and never throws on
-// a malformed field -- an undecodable extension falls back to a hex dump.
 var InspectError = defineClass("InspectError", { withCause: true });
-// WebauthnError -- a malformed or unverifiable WebAuthn attestation (pki.webauthn):
-// a non-well-formed attestation object / COSE key, an authenticatorData that fails
-// its bounded layout, an attestation-statement signature that does not verify, or a
-// trust path that does not reach the caller's anchor. Fail-closed, typed reason.
 var WebauthnError = defineClass("WebauthnError", { withCause: true });
-// LintError -- CONFIG-time misuse of the certificate linter (pki.lint) ONLY: an
-// unknown profile name, an out-of-range severity threshold, or an input that is
-// neither a parsed structure, DER Buffer, nor PEM string. This is the lint engine's
-// SOLE throw path: unlike every other toolkit entry, the lint DATA path never throws
-// on malformed input -- a linter surveys a corpus that includes malformed members,
-// so hostile bytes surface a `fatal` finding (lint/unparseable) and return a report.
 var LintError = defineClass("LintError", { withCause: true });
-// KeyError -- the pki.key key-material lifecycle domain: a bad export/import
-// input (not a CryptoKey / DER / PEM), an unsupported key or PBES2 algorithm, a
-// malformed EncryptedPrivateKeyInfo / PBES2 parameter set, an attacker-controlled
-// PBKDF2 salt or iteration count over its cap, a version<=>publicKey mismatch on a
-// produced OneAsymmetricKey, or a failed PBES2 decryption. A MAC-less PBES2-CBC
-// decrypt collapses every post-derivation failure (wrong password, valid pad but
-// not a PrivateKeyInfo) into ONE uniform key/decrypt-failed so it is not a padding
-// oracle; the structural pre-derivation faults stay distinct and typed.
 var KeyError = defineClass("KeyError", { withCause: true });
 
 module.exports = {

package/lib/guard-all.js

@@ -1,55 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (c) blamejs contributors
 "use strict";
-//
-// @internal -- no operator-facing namespace. This is lib composition only; the
-// documented surface is the primitives whose boundaries compose these guards.
-//
-// guard-all -- the guard-family orchestrator (schema-all's role for the guard
-// family). It assembles the per-shape fail-closed guards into one namespaced
-// surface every input boundary composes, so a boundary depends on the family
-// itself, with no guard re-implemented inline:
-//
-//   guard.bytes.view / .source        -- untrusted byte-source -> Buffer re-view
-//                                         (detached-buffer fail-open defense)
-//   guard.text.decode                 -- byte-source -> string, cap before copy
-//                                         (parser-DoS string-allocation defense)
-//   guard.limits.cap / .depthCap      -- config-time resource-cap validation
-//                                         (recursion / allocation DoS defense)
-//   guard.crypto.constantTimeEqual    -- length-checked constant-time compare
-//                                         (timing side-channel defense)
-//   guard.range.int / .uint31 / .positiveInt31
-//                                     -- bound a decoded integer before narrowing
-//                                        to Number (silent-narrowing defense)
-//   guard.time.assertValid / .within  -- validate a Date-instant before a temporal
-//                                        comparison (NaN-Date fail-open defense)
-//   guard.name.dnEqual / .rdnEqual / .assertNoControlBytes / .assertPrintableIa5
-//                                     -- canonical DN identity + name-string integrity
-//   guard.name.escapeControlBytes / .escapeDnValue
-//                                     -- render-side name safety: control-byte + RFC 4514 escaping
-//                                        (CVE-2009-2408 truncation / identity defense)
-//   guard.encoding.base64url / .base64 / .hex
-//                                     -- strict textual-encoding decode, canonical
-//                                        + capped (encoding-malleability defense)
-//   guard.identifier.assertCanonicalOid
-//                                     -- canonical dotted-decimal OID string form
-//                                        (canonicalization-divergence defense)
-//   guard.compress.bounded            -- decompress an untrusted stream under a hard
-//                                        output cap, whole-input (decompression-bomb +
-//                                        trailing-frame malleability defense)
-//   guard.header.assertField          -- emitted MIME/RFC 5322 header field name +
-//                                        value integrity (CR/LF/NUL header-injection
-//                                        defense, CWE-93)
-//   guard.parsed.accept               -- a CLAIMED-parsed structure carries every
-//                                        field the consuming code dereferences
-//                                        (type confusion / unverified provenance,
-//                                        CWE-843 / CWE-345)
-//
-// Each shape is enforced by a codebase-patterns detector: the characteristic
-// token of a guard (the Buffer.from(x.buffer, byteOffset) re-view, the
-// timingSafeEqual call, the MAX_DECODE_DEPTH_CEILING check) must appear only in
-// its guard module, so a new boundary cannot re-inline the shape and forget the
-// defense.
+// @internal
 
 var _freeze = require("./guard-intrinsic").freeze;
 var bytes  = require("./guard-bytes");
@@ -69,16 +21,7 @@ var compress = require("./guard-compress");
 var secret = require("./guard-secret");
 var parsed = require("./guard-parsed");
 var async_ = require("./guard-async");
-// guard-intrinsic is deliberately NOT re-exported here. Re-exporting it gave taking the captures a
-// second spelling, and the check that holds a module to the discipline could then be satisfied
-// around: a module reached them as `guard.intrinsic.<x>` and never entered scope, so its remaining
-// live reads were never named. With one spelling, a module's own require IS the fact, and the check
-// reads it off the loaded module graph rather than guessing at the text.
 
-// Frozen, like every module it gathers. A boundary reaches its guard as `guard.<family>.<fn>(...)`
-// at the call, and the registry hands every module this same object, so one property assignment
-// would replace a fail-closed check everywhere at once -- which is the substitution the family
-// exists to refuse. Nothing writes to it after load.
 module.exports = _freeze({
   bytes:  bytes,
   text:   text,

package/lib/guard-async.js

@@ -2,50 +2,15 @@
 // Copyright (c) blamejs contributors
 "use strict";
 
-// The two settle operations, taken at load and uncurried so the call sites read no property of
-// them. These are how a synchronous fault becomes the rejection this guard promises, so a replaced
-// `reject` returning a resolved promise turns a refusal into a pass at the one place the exit shape
-// is decided. See guard-intrinsic for the whole captured set.
 var _intrinsic = require("./guard-intrinsic");
 var _resolve = _intrinsic.uncurry(_intrinsic.promiseResolve);
 var _reject = _intrinsic.uncurry(_intrinsic.promiseReject);
 var _Promise = Promise;
-//
-// @internal -- no operator-facing namespace. The documented surface is every verb whose
-// @signature says `-> Promise<...>`; this is how each of them refuses.
-//
-// guard-async -- a verb documented as Promise-returning refuses by REJECTING, never by throwing.
-//
-// The failure is invisible at the call site, which is what makes it worth a choke point. An operator
-// reads `-> Promise<...>` in the reference and writes the documented shape:
-//
-//     pki.acme.newOrder(opts).catch(handleIt);
-//
-// A validation that runs before the promise is created throws straight past that `.catch`, so a
-// misspelled option or a malformed input becomes an uncaught exception in code that already handles
-// errors -- and nothing in the shape of the call tells the caller which verbs do that. Eleven verbs
-// across five modules had it (pki.cms.verify / sign / countersign, pki.ocsp.sign, pki.tsp.sign and
-// six pki.acme verbs), each having grown the same way: a cheap synchronous check added at the top of
-// a function that returns a promise further down.
-//
-// What this does not change is when the work happens. The body still runs synchronously, because
-// several of these verbs must resolve a caller's mutable options object before any turn passes --
-// reading a key, a nonce, or a request's bytes a turn later is a different value than the one that
-// was checked. Only the exit changes: a fault leaves as a rejection instead of a throw.
-//
+// @internal
 // @enforced-by behavioral -- the rule has no rename-proof code shape (it is the ABSENCE of a wrapper
-//   around a synchronous prefix, which no lexical pattern can see). The guard is the derived test
-//   test/layer-0-primitives/promise-contract.test.js, which reads every `-> Promise<` @signature out
-//   of lib/ and calls each verb to prove the refusal arrives as a rejection. A new verb is in
-//   scope the day it is documented, so no list here can go stale.
-// Both taken at load. These are how a synchronous fault becomes the rejection this guard promises,
-// so a replaced `reject` returning a resolved promise turns a refusal into a pass at the one place
-// the exit shape is decided. See guard-intrinsic for the whole captured set.
 function deferred(body) {
   try { return _resolve(_Promise, body()); }
   catch (e) { return _reject(_Promise, e); }
 }
 
-// Frozen for the reason the family header gives: a boundary reads its guard off this object at the
-// call, so a writable export would let a caller replace the check rather than pass it.
 module.exports = _intrinsic.freeze({ deferred: deferred });