@blamejs/pki 0.6.14 → 0.6.16

package/lib/schema-pkcs8.js

@@ -41,22 +41,13 @@ var frameworkError = require("./framework-error");
 var Pkcs8Error = frameworkError.Pkcs8Error;
 var PemError = frameworkError.PemError;
 
-// The pkcs8 error namespace the schema engine walks under.
 var NS = pkix.makeNS("pkcs8", Pkcs8Error, oid);
 
 var ALGORITHM_IDENTIFIER = pkix.algorithmIdentifier(NS);
 var ATTRIBUTE = pkix.attribute(NS);
 
-// version ::= INTEGER { v1(0), v2(1) }, where 0 and 1 are both legal (the divergence
-// from every other reader; cert/CRL reject 0, CSR accepts only 0). Surface as the
-// RFC's vN number.
 var PKCS8_VERSION = pkix.versionReader(NS, { "0": 1, "1": 2 });
 
-// PrivateKeyInfo ::= SEQUENCE { version, privateKeyAlgorithm AlgorithmIdentifier,
-//   privateKey OCTET STRING, attributes [0] IMPLICIT SET OF Attribute OPTIONAL,
-//   publicKey [1] IMPLICIT BIT STRING OPTIONAL (v2 only) }. The two trailing
-// context fields are modeled with `trailing` so they must appear in ascending tag
-// order and an unknown trailing context tag is rejected (not bled into a field).
 var PRIVATE_KEY_INFO = schema.seq([
   schema.field("version", PKCS8_VERSION),
   schema.field("privateKeyAlgorithm", ALGORITHM_IDENTIFIER),
@@ -68,24 +59,20 @@ var PRIVATE_KEY_INFO = schema.seq([
 ], {
   assert: "sequence", arity: { min: 3 }, code: "pkcs8/not-a-private-key-info", what: "PrivateKeyInfo",
   build: function (m) {
-    var version = m.fields.version.value;              // 1 (v1) | 2 (v2)
+    var version = m.fields.version.value;
     var hasPublicKey = m.fields.publicKey.present;
-    // RFC 5958 sec. 2 -- publicKey present <=> version is v2. Enforce both directions.
     if (hasPublicKey && version !== 2) throw NS.E("pkcs8/bad-version", "a [1] publicKey is permitted only in a v2 OneAsymmetricKey");
     if (!hasPublicKey && version === 2) throw NS.E("pkcs8/bad-version", "a v2 OneAsymmetricKey must carry a [1] publicKey");
     return {
       version: version,
       privateKeyAlgorithm: m.fields.privateKeyAlgorithm.value.result,
-      privateKey: m.fields.privateKey.value,           // raw OCTET STRING content (the inner key DER)
+      privateKey: m.fields.privateKey.value,
       attributes: m.fields.attributes.present ? m.fields.attributes.value.items.map(function (it) { return it.value.result; }) : [],
       publicKey: hasPublicKey ? m.fields.publicKey.value : null,
     };
   },
 });
 
-// EncryptedPrivateKeyInfo ::= SEQUENCE { encryptionAlgorithm AlgorithmIdentifier,
-//   encryptedData OCTET STRING } (RFC 5958 sec. 3). Recognized and surfaced; the raw
-// ciphertext is kept for a later decryption layer (PBES2/PBKDF2 + a passphrase).
 var ENCRYPTED_PRIVATE_KEY_INFO = schema.seq([
   schema.field("encryptionAlgorithm", ALGORITHM_IDENTIFIER),
   schema.field("encryptedData", schema.octetString()),
@@ -94,7 +81,7 @@ var ENCRYPTED_PRIVATE_KEY_INFO = schema.seq([
   build: function (m) {
     return {
       encryptionAlgorithm: m.fields.encryptionAlgorithm.value.result,
-      encryptedData: m.fields.encryptedData.value,     // raw ciphertext
+      encryptedData: m.fields.encryptedData.value,
     };
   },
 });
@@ -180,12 +167,6 @@ function pemDecode(text, label) { return pkix.pemDecode(text, label || "PRIVATE
  */
 function pemEncode(der, label) { return pkix.pemEncode(der, label || "PRIVATE KEY", PemError); }
 
-// A PKCS#8 PrivateKeyInfo root is a SEQUENCE whose first child is a universal
-// INTEGER (version) and third child a universal OCTET STRING (privateKey) -- a
-// shape the signed-envelope trio (whose children[0] is a SEQUENCE and children[2]
-// a BIT STRING) can never present, so the detectors are mutually exclusive
-// regardless of registry order. Trailing context fields are [0]/[1] in ascending
-// order.
 function matches(root) {
   var TAGS = asn1.TAGS;
   var k = pkix.rootSequenceChildren(root, 3, 5);
@@ -201,20 +182,7 @@ function matches(root) {
   return true;
 }
 
-// NOTE: there is intentionally no `matchesEncrypted` detector. An
-// EncryptedPrivateKeyInfo is a SEQUENCE { SEQUENCE, OCTET STRING } -- a shape it
-// shares with a PKCS#1 DigestInfo and other AlgorithmIdentifier-plus-octets
-// structures -- so it cannot be classified from structure alone. The orchestrator
-// does not auto-route it; an operator who knows a key is encrypted (e.g. from an
-// 'ENCRYPTED PRIVATE KEY' PEM label) calls parseEncrypted directly. A structural
-// auto-route can return once a validated encryption-algorithm discriminator (the
-// PBES layer) exists.
 
-// Validate a bare, already-decoded PrivateKeyInfo / EncryptedPrivateKeyInfo
-// node -- for a composer that holds a decoded node and must not re-parse its
-// bytes (an RFC 7292 PFX key bag, whose wire encoding may be BER that the
-// strict `parse` entry would refuse). Same contract as the CMS walkers: the
-// node is the bare structure, typed pkcs8/* on rejection.
 function walkPrivateKeyInfo(node) { return schema.walk(PRIVATE_KEY_INFO, node, NS).result; }
 function walkEncryptedPrivateKeyInfo(node) { return schema.walk(ENCRYPTED_PRIVATE_KEY_INFO, node, NS).result; }