@blamejs/pki 0.8.31 → 0.8.48

package/lib/schema-tsp.js

@@ -42,6 +42,7 @@ var oid = require("./oid");
 var smime = require("./schema-smime");
 var cms = require("./schema-cms");
 var frameworkError = require("./framework-error");
+var guard = require("./guard-all");
 
 var TspError = frameworkError.TspError;
 var PemError = frameworkError.PemError;
@@ -177,11 +178,11 @@ var PKI_STATUS_INFO = schema.seq([
       _assertMinimalNamedBits(bs.unusedBits, bs.bytes);
       failInfo = { unusedBits: bs.unusedBits, bytes: bs.bytes, bits: _namedBits(bs.bytes) };
     }
-    return {
+    return guard.verdict.of({
       status: Number(status),
       statusString: m.fields.statusString.present ? m.fields.statusString.value.items.map(function (it) { return it.value; }) : null,
       failInfo: failInfo,
-    };
+    });
   },
 });
 
@@ -213,14 +214,14 @@ var TIME_STAMP_RESP = schema.seq([
     if (granted && !present) throw NS.E("tsp/missing-token", "a granted TimeStampResp must carry a timeStampToken (RFC 3161 sec. 2.4.2)");
     if (!granted && present) throw NS.E("tsp/unexpected-token", "a non-granted TimeStampResp must not carry a timeStampToken (RFC 3161 sec. 2.4.2)");
     if (status.status !== 2 && status.failInfo) throw NS.E("tsp/unexpected-failinfo", "failInfo is present only when the status is rejection(2) (RFC 3161 sec. 2.4.2)");
-    return {
+    return guard.verdict.of({
       status: status.status,
       statusString: status.statusString,
       failInfo: status.failInfo,
       /** @internal The token is a second parse of bytes carried inside this one, so it takes the
        *  caps this door was given rather than the built-in ceilings. */
       timeStampToken: present ? parseToken(m.fields.timeStampToken.value.bytes, ctx ? ctx.caps : undefined) : null,
-    };
+    });
   },
 });
 
@@ -552,7 +553,7 @@ function signerCertificateDer(token) {
      * one key. Two that name two different certificates leave which of them signed the token
      * unsettled, so this answers with nothing and the caller says so, rather than taking one of
      * them. */
-    if (found !== null) return Buffer.compare(found, named) === 0 ? found : null;
+    if (found !== null) return guard.bytes.compare(found, named) === 0 ? found : null;
     found = named;
   }
   return found;
@@ -576,7 +577,7 @@ function _essNamedCertificate(token, attr) {
     var element = certs[j];
     if (!element || element.tagClass !== "universal" || !Buffer.isBuffer(element.bytes)) continue;
     var actual = digest().update(element.bytes).digest();
-    if (actual.length === want.length && Buffer.compare(actual, want) === 0) return element.bytes;
+    if (actual.length === want.length && guard.bytes.compare(actual, want) === 0) return element.bytes;
   }
   return null;
 }

package/lib/sign-scheme.js

@@ -5,7 +5,6 @@
 
 var asn1 = require("./asn1-der");
 var oid = require("./oid");
-var nodeCrypto = require("crypto");
 var pkcs8 = require("./schema-pkcs8");
 var pkix = require("./schema-pkix");
 var frameworkError = require("./framework-error");
@@ -14,6 +13,13 @@ var subtle = webcrypto.webcrypto.subtle;
 var validator = require("./validator-all");
 var guard = require("./guard-all");
 var intrinsic = require("./guard-intrinsic");
+/** @internal The signing and key-import operations, captured at load. The objects were held and their
+ * METHODS fetched per call, which leaves them replaceable: a `sign` returning bytes of its own choosing
+ * decides the signature that goes out on a certificate, a CRL or a request, and an `importKey` or an
+ * `adoptKey` returning a different private key makes the captured signer sign with that key instead. */
+var _subtleSign = intrinsic.uncurry(subtle.sign);
+var _subtleImportKey = intrinsic.uncurry(subtle.importKey);
+var _adoptKey = webcrypto.adoptKey;
 var compositeSig = require("./composite-sig");
 var b = asn1.build;
 function O(name) { return oid.byName(name); }
@@ -28,6 +34,10 @@ var _isBuffer = intrinsic.isBuffer;
 var _bufferFrom = intrinsic.bufferFrom;
 var _isU8 = intrinsic.types.isUint8Array;
 var _resolve = intrinsic.uncurry(intrinsic.promiseResolve);
+/** @internal The promise constructor, captured at load, for the reason `guard-intrinsic` gives: the
+ * resolve builds its promise from the receiver, and the bytes a signature is made of travel through
+ * these promises. */
+var _Promise = intrinsic.Promise;
 
 var HASH = intrinsic.assign(intrinsic.create(null), { sha256: "SHA-256", sha384: "SHA-384", sha512: "SHA-512" });
 var NODE_DIGEST = intrinsic.assign(intrinsic.create(null), { sha256: "sha256", sha384: "sha384", sha512: "sha512", shake128: "shake128", shake256: "shake256" });
@@ -211,7 +221,7 @@ function _importKey(key, imp, E) {
       throw E("bad-input", "the signing key is a WebCrypto CryptoKey of type " + _stringify(key.type) + "; a signing key must be a private key (type \"private\")");
     }
     _assertKeyMatchesScheme(key, imp, E);
-    return webcrypto.adoptKey(key, imp, ["sign"], E, "bad-input");
+    return _adoptKey(key, imp, ["sign"], E, "bad-input");
   }
   var der, owned = false;
   if (_isBuffer(key)) der = guard.bytes.view(key, E, "bad-input", "the signer private key");
@@ -224,7 +234,7 @@ function _importKey(key, imp, E) {
     throw E("bad-input", "a signer key must be a WebCrypto CryptoKey, a node:crypto KeyObject, a PKCS#8 DER Buffer, " +
       "a PKCS#8 PEM string, or a signer { algorithm, publicKey, sign }");
   }
-  var imported = subtle.importKey("pkcs8", der, imp, false, ["sign"]);
+  var imported = _subtleImportKey(subtle, "pkcs8", der, imp, false, ["sign"]);
   if (!owned) return imported;
   return imported.then(function (k) {
     guard.secret.zeroize(der, E, "bad-input", "the signer private-key copy");
@@ -315,11 +325,14 @@ function _signExternally(signer, scheme, signedBytes, E) {
    *  the rewritten artifact. `Buffer.from` is not enough: a small copy comes out of Node's shared
    *  pool, whose backing ArrayBuffer the callback could reach the original through. */
   var handed = new intrinsic.Uint8Array(signedBytes.length);
-  handed.set(signedBytes);
+  /** @internal The copy goes through the captured `set`. Read off the instance it dispatches through
+   *  `Uint8Array.prototype`, and a replacement there writes different bytes into the allocation the
+   *  callback is handed, so the signer signs a message this never assembled. */
+  intrinsic.typedArraySet(handed, signedBytes);
   var produced;
   try { produced = intrinsic.apply(signer.sign, signer.receiver, [handed]); }
   catch (e) { throw E("bad-input", "the signer sign() callback failed", e); }
-  return _resolve(Promise, produced).then(function (raw) {
+  return _resolve(_Promise, produced).then(function (raw) {
     var sig = guard.bytes.snapshotSource(raw, E, "bad-input", "the signature the signer returned");
     return _assertSignerSignature(sig, scheme, E);
   }, function (e) {
@@ -369,7 +382,7 @@ function _nodeSignOptions(key, scheme) {
   var name = scheme.sign.name;
   if (name === "ECDSA") return { key: key, dsaEncoding: "ieee-p1363" };
   if (name === "RSA-PSS") {
-    return { key: key, padding: nodeCrypto.constants.RSA_PKCS1_PSS_PADDING, saltLength: scheme.sign.saltLength };
+    return { key: key, padding: guard.crypto.padding.RSA_PKCS1_PSS, saltLength: scheme.sign.saltLength };
   }
   return key;
 }
@@ -393,7 +406,7 @@ function _signWithKeyObject(key, scheme, signedBytes, E) {
   }
   _assertKeyObjectMatchesScheme(key, scheme, E);
   try {
-    return _bufferFrom(nodeCrypto.sign(_nodeDigest(scheme), signedBytes, _nodeSignOptions(key, scheme)));
+    return _bufferFrom(guard.crypto.sign(_nodeDigest(scheme), signedBytes, _nodeSignOptions(key, scheme)));
   } catch (e) {
     throw E("bad-input", "the signer KeyObject could not produce a " + scheme.imp.name + " signature", e);
   }
@@ -402,7 +415,7 @@ function _signWithKeyObject(key, scheme, signedBytes, E) {
 function signOverTbs(scheme, key, signedBytes, E) {
   if (intrinsic.types.isKeyObject(key)) {
     var koSig = _signWithKeyObject(key, scheme, signedBytes, E);
-    return _resolve(Promise, scheme.ecdsaDer ? validator.sig.rawToEcdsaDer(koSig, scheme.coordLen) : koSig);
+    return _resolve(_Promise, scheme.ecdsaDer ? validator.sig.rawToEcdsaDer(koSig, scheme.coordLen) : koSig);
   }
   var signer = _snapshotSigner(key);
   if (signer) {
@@ -414,7 +427,7 @@ function signOverTbs(scheme, key, signedBytes, E) {
     return compositeSig.compositeSign(scheme.composite, _normCompositeKeys(key, scheme.composite, E), signedBytes).then(function (sig) { return _bufferFrom(sig); });
   }
   return _importKey(key, scheme.imp, E).then(function (priv) {
-    return subtle.sign(scheme.sign, priv, signedBytes).then(function (sigRaw) {
+    return _subtleSign(subtle, scheme.sign, priv, signedBytes).then(function (sigRaw) {
       var sig = _bufferFrom(sigRaw);
       if (scheme.ecdsaDer) sig = validator.sig.rawToEcdsaDer(sig, scheme.coordLen);
       return sig;