@blamejs/pki 0.8.55 → 0.8.56

package/lib/ocsp.js

@@ -40,7 +40,6 @@ var _promiseResolve = _ocspIntrinsic.uncurry(_ocspIntrinsic.promiseResolve);
 var _promiseReject = _ocspIntrinsic.uncurry(_ocspIntrinsic.promiseReject);
 /** @internal The CertID hashes bind a response to the certificate it answers for, and they are awaited
  *  as a pair, so a replaced `all` decides what that pair contains. */
-var _promiseAll = _ocspIntrinsic.uncurry(_ocspIntrinsic.promiseAll);
 var oid = require("./oid");
 var x509 = require("./schema-x509");
 var ocspSchema = require("./schema-ocsp");
@@ -77,7 +76,12 @@ var ENTRY_EXTENSION_CRITICALITY = crlSchema.entryExtensionCriticality(oid);
 var CERTIFICATE_HOLD = REASON_CODE.certificateHold, REMOVE_FROM_CRL = REASON_CODE.removeFromCRL;
 var OID_REASON_CODE = O("reasonCode");
 
-function _digest(wcHash, buf) { return subtle.digest(wcHash, buf).then(function (h) { return Buffer.from(h); }); }
+/** @internal Continued through the capture. Every CertID in a request and the key hash a responder
+ *  names itself by come out of this step, so a replacement settling it names another certificate's
+ *  identity, or another responder's key, in bytes that are then signed. */
+function _digest(wcHash, buf) {
+  return _ocspIntrinsic.chain(subtle.digest(wcHash, buf), function (h) { return Buffer.from(h); });
+}
 function _certOf(arg, what) {
   var label = what || "a certificate";
   return guard.parsed.acceptDerived(arg, "certificate", function (bytes) {
@@ -115,10 +119,14 @@ var REQUESTER_NONCE_FLOOR = 32, RESPONDER_NONCE_FLOOR = 1;
 function _buildCertID(cert, issuer, hashName) {
   var wc = HASH_WC[guard.text.keyOf(hashName)];
   if (!wc) throw _err("ocsp/bad-input", "unsupported CertID hashAlgorithm " + guard.text.showValue(hashName) + " (sha1 / sha256 / sha384 / sha512)");
-  return _promiseAll(_Promise, [
+  /** @internal The two hashes are awaited through the aggregate that consults nothing replaceable.
+   *  The static form reads `resolve` off the constructor at each call, and these two digests ARE the
+   *  CertID a responder answers about, so a replacement answering for either names another
+   *  certificate's identity in the request. */
+  return _ocspIntrinsic.chain(_ocspIntrinsic.allOf([
     _digest(wc, issuer.subject.bytes),
     _digest(wc, _keyValue(issuer.subjectPublicKeyInfo.bytes)),
-  ]).then(function (hashes) {
+  ]), function (hashes) {
     var hashAlgId = hashName === "sha1" ? b.sequence([b.oid(O(hashName)), b.nullValue()]) : b.sequence([b.oid(O(hashName))]);
     return b.sequence([
       hashAlgId,
@@ -204,13 +212,15 @@ function _buildRequest(query, opts) {
     requestorNameDer = signerCert.subject.bytes;
   }
 
-  return _promiseAll(_Promise, queries.map(function (q) {
+  /** @internal Each query's CertID is awaited through the aggregate that consults nothing
+   *  replaceable, for the reason at `_buildCertID`. */
+  var builtRequests = _ocspIntrinsic.allOf(_ocspIntrinsic.mapList(queries, function (q) {
     if (!q || typeof q !== "object") throw _err("ocsp/bad-input", "each query must be { cert, issuer }");
     guard.identifier.assertKnownKeys(q, _QUERY_KEYS, _err, "ocsp/bad-input", "unknown query field (a query is { cert, issuer, singleRequestExtensions? }): ");
     if (q.cert == null || q.issuer == null) throw _err("ocsp/bad-input", "each query must be { cert, issuer }");
     var cert = _certOf(q.cert, "the query certificate");
     var issuer = _certOf(q.issuer, "the issuer certificate");
-    return _buildCertID(cert, issuer, hashName).then(function (certID) {
+    return _ocspIntrinsic.chain(_buildCertID(cert, issuer, hashName), function (certID) {
       var reqChildren = [certID];
       if (q.singleRequestExtensions != null) {
         /** @internal Read through the same door the sibling lists in this module use, so a value that is
@@ -225,7 +235,8 @@ function _buildRequest(query, opts) {
       }
       return b.sequence(reqChildren);
     });
-  })).then(function (requests) {
+  }));
+  return _ocspIntrinsic.chain(builtRequests, function (requests) {
     var tbsChildren = [];
     if (requestorNameDer !== null) tbsChildren.push(b.explicit(1, b.contextConstructed(4, requestorNameDer)));
     tbsChildren.push(b.sequence(requests));
@@ -239,10 +250,12 @@ function _buildRequest(query, opts) {
     var tbsRequest = b.sequence(tbsChildren);
     if (signerCert === null) return _emitReq(b.sequence([tbsRequest]), opts);
     var scheme = signScheme.resolveSignScheme(signerCert, { combinedRsaSig: true }, true, _signE);
-    return signScheme.signOverTbs(scheme, opts.signer.key, tbsRequest, _signE).then(function (sig) {
+    return _ocspIntrinsic.chain(signScheme.signOverTbs(scheme, opts.signer.key, tbsRequest, _signE), function (sig) {
       /** @internal The request is held to the same proof a certificate is: the signature verifies
-       * against the public key the certificate it carries declares. */
-      return _promiseResolve(_Promise, _b.assertSignatureVerifies(tbsRequest, sig, signerCert.subjectPublicKeyInfo.bytes, scheme)).then(function () {
+       * against the public key the certificate it carries declares. Both continuations are captured,
+       * since the inner one runs only after that proof has been made. */
+      var selfChecked = _promiseResolve(_Promise, _b.assertSignatureVerifies(tbsRequest, sig, signerCert.subjectPublicKeyInfo.bytes, scheme));
+      return _ocspIntrinsic.chain(selfChecked, function () {
         var optionalSignature = b.sequence([scheme.sigAlgId, b.bitString(sig, 0), b.explicit(0, b.sequence([b.raw(signerCertDer)]))]);
         return _emitReq(b.sequence([tbsRequest, b.explicit(0, optionalSignature)]), opts);
       });
@@ -353,7 +366,8 @@ function _sign(responseData, responder, opts) {
   try {
     pending = _signResponse(responseData, responder, respCert, respCertDer, responderKey, opts);
   } catch (e) { _wipeOwnedKey(); throw e; }
-  return pending.then(function (out) { _wipeOwnedKey(); return out; },
+  /** @internal Captured: this continuation is what wipes a key this verb owns, on either outcome. */
+  return _ocspIntrinsic.chain(pending, function (out) { _wipeOwnedKey(); return out; },
     function (e) { _wipeOwnedKey(); throw e; });
 }
 
@@ -361,10 +375,12 @@ function _signResponse(responseData, responder, respCert, respCertDer, responder
   var responses = responseData.responses != null ? pkiBuild.reqDenseArray(responseData.responses, "responses", _err, "ocsp/bad-input") : [];
   if (!responses.length) throw _err("ocsp/bad-input", "a response MUST include at least one SingleResponse (RFC 6960 sec. 4.2.1)");
 
-  return _responderID(responseData.responderID, respCert).then(function (ridNode) {
-    return _promiseAll(_Promise, responses.map(function (r) { return _buildSingleResponse(r, opts); })).then(function (built) {
-      var srNodes = built.map(function (x) { return x.node; });
-      var anyNonIssued = built.some(function (x) { return x.nonIssued; });
+  return _ocspIntrinsic.chain(_responderID(responseData.responderID, respCert), function (ridNode) {
+    return _ocspIntrinsic.chain(_ocspIntrinsic.allOf(_ocspIntrinsic.mapList(responses, function (r) {
+      return _buildSingleResponse(r, opts);
+    })), function (built) {
+      var srNodes = _ocspIntrinsic.mapList(built, function (x) { return x.node; });
+      var anyNonIssued = _ocspIntrinsic.some(built, function (x) { return x.nonIssued; });
       /** @internal Sec. 2.2 and 4.4.8: a "revoked" answer for a non-issued certificate MUST carry the
        *  extended revoked definition in responseExtensions, so the shape itself places it there,
        *  and a caller declining it is refused rather than left with a response the section forbids. */
@@ -378,10 +394,12 @@ function _signResponse(responseData, responder, respCert, respCertDer, responder
       if (respExts.length) rdChildren.push(b.explicit(1, b.sequence(respExts)));
       var responseDataDer = b.sequence(rdChildren);
       var scheme = signScheme.resolveSignScheme(respCert, { combinedRsaSig: true }, true, _signE);
-      return signScheme.signOverTbs(scheme, responderKey, responseDataDer, _signE).then(function (sig) {
+      return _ocspIntrinsic.chain(signScheme.signOverTbs(scheme, responderKey, responseDataDer, _signE), function (sig) {
         /** @internal The response is held to the same proof a certificate is: the signature verifies
-         * against the public key the responder certificate declares. */
-        return _promiseResolve(_Promise, _b.assertSignatureVerifies(responseDataDer, sig, respCert.subjectPublicKeyInfo.bytes, scheme)).then(function () {
+         * against the public key the responder certificate declares. Both continuations are captured,
+         * since the inner one runs only after that proof has been made. */
+        var selfChecked = _promiseResolve(_Promise, _b.assertSignatureVerifies(responseDataDer, sig, respCert.subjectPublicKeyInfo.bytes, scheme));
+        return _ocspIntrinsic.chain(selfChecked, function () {
           var basicChildren = [responseDataDer, scheme.sigAlgId, b.bitString(sig, 0)];
           if (opts.embedCert !== false) basicChildren.push(b.explicit(0, b.sequence([b.raw(respCertDer)])));
           var responseBytes = b.sequence([b.oid(OID_OCSP_BASIC), b.octetString(b.sequence(basicChildren))]);
@@ -422,7 +440,10 @@ function _snapshotSignerKey(key, owned) {
 
 function _responderID(rid, respCert) {
   if (rid == null || rid === "byName") return _promiseResolve(_Promise, b.explicit(1, b.raw(respCert.subject.bytes)));
-  if (rid === "byKey") return _digest("SHA-1", _keyValue(respCert.subjectPublicKeyInfo.bytes)).then(function (kh) { return b.explicit(2, b.octetString(kh)); });
+  if (rid === "byKey") {
+    return _ocspIntrinsic.chain(_digest("SHA-1", _keyValue(respCert.subjectPublicKeyInfo.bytes)),
+      function (kh) { return b.explicit(2, b.octetString(kh)); });
+  }
   throw _err("ocsp/bad-input", "responderID must be \"byName\" or \"byKey\"");
 }
 function _buildSingleResponse(r, opts) {
@@ -438,7 +459,7 @@ function _buildSingleResponse(r, opts) {
    * map into Promise.all, so a synchronous throw here would abort the map before Promise.all
    * attached handlers, and an earlier entry's rejection would be orphaned: the caller catches
    * sign()'s failure and the process still sees an unhandled rejection. */
-  return certIdP.then(function (certID) {
+  return _ocspIntrinsic.chain(certIdP, function (certID) {
     var thisUpdate = _asEncodableDate(r.thisUpdate, "thisUpdate") || new Date();
     var nextUpdate = r.nextUpdate === null ? null : (_asEncodableDate(r.nextUpdate, "nextUpdate") || _defaultNextUpdate());
     /** @internal RFC 6960 sec. 4.2.2.1 makes thisUpdate and nextUpdate a validity interval, and says
@@ -687,8 +708,11 @@ function verify(response, opts) {
     try { reqNonce = guard.bytes.snapshotSource(reqNonce, OcspError, "ocsp/bad-input", "opts.requestNonce"); }
     catch (e) { return _promiseReject(_Promise, e); }
   }
-  return pathValidate.verifyOcspResponse(parsed, cert, issuerCert, time,
-    { historicalMode: opts.historicalMode === true, requestNonce: reqNonce }).then(function (verdict) {
+  /** @internal Captured: this continuation is where the response's status becomes the verdict a
+   * caller reads, so a settled value in place of it reports a status nothing evaluated. */
+  var evaluated = pathValidate.verifyOcspResponse(parsed, cert, issuerCert, time,
+    { historicalMode: opts.historicalMode === true, requestNonce: reqNonce });
+  return _ocspIntrinsic.chain(evaluated, function (verdict) {
     return guard.verdict.of(verdict, { valid: verdict.status === "good" });
   });
 }