WIP: rsa-compat-style node v10 and v6 support

README.md

@@ -1,7 +1,7 @@
 [Eckles.js](https://git.coolaj86.com/coolaj86/eckles.js)
 =========
 
-Sponsored by [Root](https://therootcompany.com).
+A [Root](https://therootcompany.com) Project.
 Built for [ACME.js](https://git.coolaj86.com/coolaj86/acme.js)
 and [Greenlock.js](https://git.coolaj86.com/coolaj86/greenlock.js)
 
@@ -12,8 +12,10 @@ ECDSA (elliptic curve) tools. Lightweight. Zero Dependencies. Universal compatib
 * [x] Fast and Easy EC Key Generation
 * [x] PEM-to-JWK
 * [x] JWK-to-PEM
+* [x] JWK thumbprint
 * [x] SSH "pub" format
 * [x] CLI
+  * See [Eckles CLI](https://git.coolaj86.com/coolaj86/eckles-cli.js)
 * [ ] RSA
   * **Need RSA tools?** Check out [Rasha.js](https://git.coolaj86.com/coolaj86/rasha.js)
 
@@ -31,6 +33,8 @@ CLI:
 npm install -g eckles
 ```
 
+See [Eckles CLI](https://git.coolaj86.com/coolaj86/eckles-cli.js)
+
 ## Generate EC (ECDSA/ECDH) Key
 
 Achieves the *fastest possible key generation* using node's native EC bindings to OpenSSL,
@@ -61,17 +65,6 @@ Eckles.generate({ format: 'jwk' }).then(function (keypair) {
     * A) because they're a senseless waste
     * B) they have similar, but slightly different formats
 
-#### Generate EC Key CLI
-
-```bash
-# Generate a key in each format
-# eckles [format] [curve|encoding]
-eckles jwk
-eckles sec1 pem
-eckles pkcs8 der
-eckles ssh P-256
-```
-
 ## PEM-to-JWK
 
 * [x] SEC1/X9.62, PKCS#8, SPKI/PKIX
@@ -98,17 +91,6 @@ Eckles.import({ pem: pem }).then(function (jwk) {
 }
 ```
 
-#### EC PEM to JWK CLI
-
-```bash
-# Convert SEC1, PKCS8, SPKI, SSH to JWK
-# eckles [keyfile]
-eckles node_modules/eckles/fixtures/privkey-ec-p256.sec1.pem
-eckles node_modules/eckles/fixtures/privkey-ec-p384.pkcs8.pem
-eckles node_modules/eckles/fixtures/pub-ec-p256.spki.pem
-eckles node_modules/eckles/fixtures/pub-ec-p384.ssh.pub
-```
-
 ## JWK-to-PEM
 
 * [x] SEC1/X9.62, PKCS#8, SPKI/PKIX
@@ -133,17 +115,6 @@ yZe7CnFsqeDcpnPbubP6cpYiVcnevNIYyg==
 -----END EC PRIVATE KEY-----
 ```
 
-#### EC PEM to JWK CLI
-
-```bash
-# Convert JWK to SEC1, PKCS8, SPKI, SSH
-# eckles [keyfile] [format]
-eckles node_modules/eckles/fixtures/privkey-ec-p256.jwk.json sec1
-eckles node_modules/eckles/fixtures/privkey-ec-p384.jwk.json pkcs8
-eckles node_modules/eckles/fixtures/pub-ec-p256.jwk.json spki
-eckles node_modules/eckles/fixtures/pub-ec-p384.jwk.json ssh
-```
-
 ### Advanced Options
 
 `format: 'pkcs8'`:
@@ -206,6 +177,14 @@ rMjgyCokrnjDft6Y/YnA4A50yZe7CnFsqeDcpnPbubP6cpYiVcnevNIYyg==
 -----END PUBLIC KEY-----
 ```
 
+## JWK Thumbprint
+
+```js
+Eckles.thumbprint({ jwk: jwk }).then(function (thumbprint) {
+  console.log(thumbprint);
+});
+```
+
 Testing
 -------
 

bin/eckles.js

@@ -39,7 +39,16 @@ try {
   // ignore
 }
 
+var thumbprint = ('thumbprint' === format);
+if (thumbprint) {
+  format = 'public';
+}
+
 if ('string' === typeof key) {
+  if (thumbprint) {
+    Eckles.thumbprint({ pem: key }).then(console.log);
+    return;
+  }
   var pub = (-1 !== [ 'public', 'spki', 'pkix' ].indexOf(format));
   Eckles.import({ pem: key, public: (pub || format) }).then(function (jwk) {
     console.log(JSON.stringify(jwk, null, 2));
@@ -48,6 +57,10 @@ if ('string' === typeof key) {
     process.exit(1);
   });
 } else {
+  if (thumbprint) {
+    Eckles.thumbprint({ jwk: key }).then(console.log);
+    return;
+  }
   Eckles.export({ jwk: key, format: format }).then(function (pem) {
     console.log(pem);
   }).catch(function (err) {

lib/asn1.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var Enc = require('./encoding.js');
+
+//
+// A dumbed-down, minimal ASN.1 packer
+//
+
+// Almost every ASN.1 type that's important for CSR
+// can be represented generically with only a few rules.
+var ASN1 = module.exports = function ASN1(/*type, hexstrings...*/) {
+  var args = Array.prototype.slice.call(arguments);
+  var typ = args.shift();
+  var str = args.join('').replace(/\s+/g, '').toLowerCase();
+  var len = (str.length/2);
+  var lenlen = 0;
+  var hex = typ;
+
+  // We can't have an odd number of hex chars
+  if (len !== Math.round(len)) {
+    throw new Error("invalid hex");
+  }
+
+  // The first byte of any ASN.1 sequence is the type (Sequence, Integer, etc)
+  // The second byte is either the size of the value, or the size of its size
+
+  // 1. If the second byte is < 0x80 (128) it is considered the size
+  // 2. If it is > 0x80 then it describes the number of bytes of the size
+  //    ex: 0x82 means the next 2 bytes describe the size of the value
+  // 3. The special case of exactly 0x80 is "indefinite" length (to end-of-file)
+
+  if (len > 127) {
+    lenlen += 1;
+    while (len > 255) {
+      lenlen += 1;
+      len = len >> 8;
+    }
+  }
+
+  if (lenlen) { hex += Enc.numToHex(0x80 + lenlen); }
+  return hex + Enc.numToHex(str.length/2) + str;
+};
+
+// The Integer type has some special rules
+ASN1.UInt = function UINT() {
+  var str = Array.prototype.slice.call(arguments).join('');
+  var first = parseInt(str.slice(0, 2), 16);
+
+  // If the first byte is 0x80 or greater, the number is considered negative
+  // Therefore we add a '00' prefix if the 0x80 bit is set
+  if (0x80 & first) { str = '00' + str; }
+
+  return ASN1('02', str);
+};
+
+// The Bit String type also has a special rule
+ASN1.BitStr = function BITSTR() {
+  var str = Array.prototype.slice.call(arguments).join('');
+  // '00' is a mask of how many bits of the next byte to ignore
+  return ASN1('03', '00' + str);
+};

lib/eckles.js

@@ -3,8 +3,9 @@
 var EC = module.exports;
 
 var Enc = require('./encoding.js');
-var ASN1;
 var PEM = require('./pem.js');
+var SSH = require('./ssh.js');
+var x509 = require('./x509.js');
 
 // 1.2.840.10045.3.1.7
 // prime256v1 (ANSI X9.62 named elliptic curve)
@@ -13,150 +14,9 @@ var OBJ_ID_EC  = '06 08 2A8648CE3D030107'.replace(/\s+/g, '').toLowerCase();
 // secp384r1 (SECG (Certicom) named elliptic curve)
 var OBJ_ID_EC_384 = '06 05 2B81040022'.replace(/\s+/g, '').toLowerCase();
 
-// 1.2.840.10045.2.1
-// ecPublicKey (ANSI X9.62 public key type)
-var OBJ_ID_EC_PUB = '06 07 2A8648CE3D0201'.replace(/\s+/g, '').toLowerCase();
-
-                      // 19  e  c  d  s  a  -  s  h  a  2  -  n  i  s  t  p  2  5  6
-var SSH_EC_P256 = '00000013 65 63 64 73 61 2d 73 68 61 32 2d 6e 69 73 74 70 32 35 36'
-  .replace(/\s+/g, '').toLowerCase();
-
-                      // 19  e  c  d  s  a  -  s  h  a  2  -  n  i  s  t  p  3  8  4
-var SSH_EC_P384 = '00000013 65 63 64 73 61 2d 73 68 61 32 2d 6e 69 73 74 70 33 38 34'
-  .replace(/\s+/g, '').toLowerCase();
-
 // The one good thing that came from the b***kchain hysteria: good EC documentation
 // https://davidederosa.com/basic-blockchain-programming/elliptic-curve-keys/
 
-EC.parseSec1 = function parseEcOnlyPrivkey(u8, jwk) {
-  var index = 7;
-  var len = 32;
-  var olen = OBJ_ID_EC.length/2;
-
-  if ("P-384" === jwk.crv) {
-    olen = OBJ_ID_EC_384.length/2;
-    index = 8;
-    len = 48;
-  }
-  if (len !== u8[index - 1]) {
-    throw new Error("Unexpected bitlength " + len);
-  }
-
-  // private part is d
-  var d = u8.slice(index, index + len);
-  // compression bit index
-  var ci = index + len + 2 + olen + 2 + 3;
-  var c = u8[ci];
-  var x, y;
-
-  if (0x04 === c) {
-    y = u8.slice(ci + 1 + len, ci + 1 + len + len);
-  } else if (0x02 !== c) {
-    throw new Error("not a supported EC private key");
-  }
-  x = u8.slice(ci + 1, ci + 1 + len);
-
-  return {
-    kty: jwk.kty
-  , crv: jwk.crv
-  , d: Enc.bufToUrlBase64(d)
-  //, dh: Enc.bufToHex(d)
-  , x: Enc.bufToUrlBase64(x)
-  //, xh: Enc.bufToHex(x)
-  , y: Enc.bufToUrlBase64(y)
-  //, yh: Enc.bufToHex(y)
-  };
-};
-
-EC.parsePkcs8 = function parseEcPkcs8(u8, jwk) {
-  var index = 24 + (OBJ_ID_EC.length/2);
-  var len = 32;
-  if ("P-384" === jwk.crv) {
-    index = 24 + (OBJ_ID_EC_384.length/2) + 2;
-    len = 48;
-  }
-
-  //console.log(index, u8.slice(index));
-  if (0x04 !== u8[index]) {
-    //console.log(jwk);
-    throw new Error("privkey not found");
-  }
-  var d = u8.slice(index+2, index+2+len);
-  var ci = index+2+len+5;
-  var xi = ci+1;
-  var x = u8.slice(xi, xi + len);
-  var yi = xi+len;
-  var y;
-  if (0x04 === u8[ci]) {
-    y = u8.slice(yi, yi + len);
-  } else if (0x02 !== u8[ci]) {
-    throw new Error("invalid compression bit (expected 0x04 or 0x02)");
-  }
-
-  return {
-    kty: jwk.kty
-  , crv: jwk.crv
-  , d: Enc.bufToUrlBase64(d)
-  //, dh: Enc.bufToHex(d)
-  , x: Enc.bufToUrlBase64(x)
-  //, xh: Enc.bufToHex(x)
-  , y: Enc.bufToUrlBase64(y)
-  //, yh: Enc.bufToHex(y)
-  };
-};
-
-EC.parseSpki = function parsePem(u8, jwk) {
-  var ci = 16 + OBJ_ID_EC.length/2;
-  var len = 32;
-
-  if ("P-384" === jwk.crv) {
-    ci = 16 + OBJ_ID_EC_384.length/2;
-    len = 48;
-  }
-
-  var c = u8[ci];
-  var xi = ci + 1;
-  var x = u8.slice(xi, xi + len);
-  var yi = xi + len;
-  var y;
-  if (0x04 === c) {
-    y = u8.slice(yi, yi + len);
-  } else if (0x02 !== c) {
-    throw new Error("not a supported EC private key");
-  }
-
-  return {
-    kty: jwk.kty
-  , crv: jwk.crv
-  , x: Enc.bufToUrlBase64(x)
-  //, xh: Enc.bufToHex(x)
-  , y: Enc.bufToUrlBase64(y)
-  //, yh: Enc.bufToHex(y)
-  };
-};
-EC.parsePkix = EC.parseSpki;
-
-EC.parseSsh = function (pem) {
-  var jwk = { kty: 'EC', crv: null, x: null, y: null };
-  var b64 = pem.split(/\s+/g)[1];
-  var buf = Buffer.from(b64, 'base64');
-  var hex = Enc.bufToHex(buf);
-  var index = 40;
-  var len;
-  if (0 === hex.indexOf(SSH_EC_P256)) {
-    jwk.crv = 'P-256';
-    len = 32;
-  } else if (0 === hex.indexOf(SSH_EC_P384)) {
-    jwk.crv = 'P-384';
-    len = 48;
-  }
-  var x = buf.slice(index, index + len);
-  var y = buf.slice(index + len, index + len + len);
-  jwk.x = Enc.bufToUrlBase64(x);
-  jwk.y = Enc.bufToUrlBase64(y);
-  return jwk;
-};
-
 /*global Promise*/
 EC.generate = function (opts) {
   return Promise.resolve().then(function () {
@@ -240,10 +100,10 @@ EC.importSync = function importEcSync(opts) {
     throw new Error("must pass { pem: pem } as a string");
   }
   if (0 === opts.pem.indexOf('ecdsa-sha2-')) {
-    return EC.parseSsh(opts.pem);
+    return SSH.parseSsh(opts.pem);
   }
   var pem = opts.pem;
-  var u8 = PEM.parseBlock(pem).der;
+  var u8 = PEM.parseBlock(pem).bytes;
   var hex = Enc.bufToHex(u8);
   var jwk = { kty: 'EC', crv: null, x: null, y: null };
 
@@ -254,15 +114,15 @@ EC.importSync = function importEcSync(opts) {
     // PKCS8
     if (0x02 === u8[3] && 0x30 === u8[6] && 0x06 === u8[8]) {
       //console.log("PKCS8", u8[3].toString(16), u8[6].toString(16), u8[8].toString(16));
-      jwk = EC.parsePkcs8(u8, jwk);
+      jwk = x509.parsePkcs8(u8, jwk);
     // EC-only
     } else if (0x02 === u8[2] && 0x04 === u8[5] && 0xA0 === u8[39]) {
       //console.log("EC---", u8[2].toString(16), u8[5].toString(16), u8[39].toString(16));
-      jwk = EC.parseSec1(u8, jwk);
+      jwk = x509.parseSec1(u8, jwk);
     // SPKI/PKIK (Public)
     } else if (0x30 === u8[2] && 0x06 === u8[4] && 0x06 === u8[13]) {
       //console.log("SPKI-", u8[2].toString(16), u8[4].toString(16), u8[13].toString(16));
-      jwk = EC.parseSpki(u8, jwk);
+      jwk = x509.parseSpki(u8, jwk);
     // Error
     } else {
       //console.log("PKCS8", u8[3].toString(16), u8[6].toString(16), u8[8].toString(16));
@@ -276,15 +136,15 @@ EC.importSync = function importEcSync(opts) {
     // PKCS8
     if (0x02 === u8[3] && 0x30 === u8[6] && 0x06 === u8[8]) {
       //console.log("PKCS8", u8[3].toString(16), u8[6].toString(16), u8[8].toString(16));
-      jwk = EC.parsePkcs8(u8, jwk);
+      jwk = x509.parsePkcs8(u8, jwk);
     // EC-only
     } else if (0x02 === u8[3] && 0x04 === u8[6] && 0xA0 === u8[56]) {
       //console.log("EC---", u8[3].toString(16), u8[6].toString(16), u8[56].toString(16));
-      jwk = EC.parseSec1(u8, jwk);
+      jwk = x509.parseSec1(u8, jwk);
     // SPKI/PKIK (Public)
     } else if (0x30 === u8[2] && 0x06 === u8[4] && 0x06 === u8[13]) {
       //console.log("SPKI-", u8[2].toString(16), u8[4].toString(16), u8[13].toString(16));
-      jwk = EC.parseSpki(u8, jwk);
+      jwk = x509.parseSpki(u8, jwk);
     // Error
     } else {
       //console.log("PKCS8", u8[3].toString(16), u8[6].toString(16), u8[8].toString(16));
@@ -336,24 +196,24 @@ EC.exportSync = function (opts) {
     if (!format || 'sec1' === format) {
       format = 'sec1';
     } else if ('pkcs8' !== format) {
-      throw new Error("options.format must be 'sec1' or 'pkcs8' for private EC keys");
+      throw new Error("options.format must be 'sec1' or 'pkcs8' for private EC keys, not '" + format + "'");
     }
   }
   if (-1 === [ 'P-256', 'P-384' ].indexOf(jwk.crv)) {
-    throw new Error("options.jwk.crv must be either P-256 or P-384 for EC keys");
+    throw new Error("options.jwk.crv must be either P-256 or P-384 for EC keys, not '" + jwk.crv + "'");
   }
   if (!jwk.y) {
     throw new Error("options.jwk.y must be a urlsafe base64-encoded either P-256 or P-384");
   }
 
   if ('sec1' === format) {
-    return PEM.packBlock({ type: "EC PRIVATE KEY", bytes: EC.packSec1(jwk) });
+    return PEM.packBlock({ type: "EC PRIVATE KEY", bytes: x509.packSec1(jwk) });
   } else if ('pkcs8' === format) {
-    return PEM.packBlock({ type: "PRIVATE KEY", bytes: EC.packPkcs8(jwk) });
+    return PEM.packBlock({ type: "PRIVATE KEY", bytes: x509.packPkcs8(jwk) });
   } else if (-1 !== [ 'spki', 'pkix' ].indexOf(format)) {
-    return PEM.packBlock({ type: "PUBLIC KEY", bytes: EC.packSpki(jwk) });
+    return PEM.packBlock({ type: "PUBLIC KEY", bytes: x509.packSpki(jwk) });
   } else if (-1 !== [ 'ssh', 'rfc4716' ].indexOf(format)) {
-    return EC.packSsh(jwk);
+    return SSH.packSsh(jwk);
   } else {
     throw new Error("Sanity Error: reached unreachable code block with format: " + format);
   }
@@ -364,130 +224,27 @@ EC.pack = function (opts) {
   });
 };
 
-EC.packSec1 = function (jwk) {
-  var d = Enc.base64ToHex(jwk.d);
-  var x = Enc.base64ToHex(jwk.x);
-  var y = Enc.base64ToHex(jwk.y);
-  var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
-  return Enc.hexToUint8(
-    ASN1('30'
-    , ASN1.UInt('01')
-    , ASN1('04', d)
-    , ASN1('A0', objId)
-    , ASN1('A1', ASN1.BitStr('04' + x + y)))
-  );
+EC.__thumbprint = function (jwk) {
+  var buf = require('crypto').createHash('sha256')
+    // alphabetically sorted keys [ 'crv', 'kty', 'x', 'y' ]
+    .update('{"crv":"' + jwk.crv + '","kty":"EC","x":"' + jwk.x + '","y":"' + jwk.y + '"}')
+    .digest()
+  ;
+  return Enc.bufToUrlBase64(buf);
 };
-EC.packPkcs8 = function (jwk) {
-  var d = Enc.base64ToHex(jwk.d);
-  var x = Enc.base64ToHex(jwk.x);
-  var y = Enc.base64ToHex(jwk.y);
-  var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
-  return Enc.hexToUint8(
-    ASN1('30'
-    , ASN1.UInt('00')
-    , ASN1('30'
-      , OBJ_ID_EC_PUB
-      , objId
-      )
-    , ASN1('04'
-      , ASN1('30'
-        , ASN1.UInt('01')
-        , ASN1('04', d)
-        , ASN1('A1', ASN1.BitStr('04' + x + y)))))
-  );
-};
-EC.packSpki = function (jwk) {
-  var x = Enc.base64ToHex(jwk.x);
-  var y = Enc.base64ToHex(jwk.y);
-  var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
-  return Enc.hexToUint8(
-    ASN1('30'
-    , ASN1('30'
-      , OBJ_ID_EC_PUB
-      , objId
-      )
-    , ASN1.BitStr('04' + x + y))
-  );
-};
-EC.packPkix = EC.packSpki;
-EC.packSsh = function (jwk) {
-  // Custom SSH format
-  var typ = 'ecdsa-sha2-nistp256';
-	var a = '32 35 36';
-  var b = '41';
-  var comment = jwk.crv + '@localhost';
-  if ('P-256' !== jwk.crv) {
-    typ = 'ecdsa-sha2-nistp384';
-    a = '33 38 34';
-    b = '61';
+
+EC.thumbprint = function (opts) {
+  return Promise.resolve().then(function () {
+    var jwk;
+    if ('EC' === opts.kty) {
+      jwk = opts;
+    } else if (opts.jwk) {
+      jwk = opts.jwk;
+    } else {
+      jwk = EC.importSync(opts);
     }
-  var x = Enc.base64ToHex(jwk.x);
-  var y = Enc.base64ToHex(jwk.y);
-  var ssh = Enc.hexToUint8(
-    ('00 00 00 13 65 63 64 73 61 2d 73 68 61 32 2d 6e 69 73 74 70'
-    + a + '00 00 00 08 6e 69 73 74 70' + a + '00 00 00' + b
-    + '04' + x + y).replace(/\s+/g, '').toLowerCase()
-  );
-
-  return typ + ' ' + Enc.bufToBase64(ssh) + ' ' + comment;
-};
-
-//
-// A dumbed-down, minimal ASN.1 packer
-//
-
-// Almost every ASN.1 type that's important for CSR
-// can be represented generically with only a few rules.
-ASN1 = function ASN1(/*type, hexstrings...*/) {
-  var args = Array.prototype.slice.call(arguments);
-  var typ = args.shift();
-  var str = args.join('').replace(/\s+/g, '').toLowerCase();
-  var len = (str.length/2);
-  var lenlen = 0;
-  var hex = typ;
-
-  // We can't have an odd number of hex chars
-  if (len !== Math.round(len)) {
-    throw new Error("invalid hex");
-  }
-
-  // The first byte of any ASN.1 sequence is the type (Sequence, Integer, etc)
-  // The second byte is either the size of the value, or the size of its size
-
-  // 1. If the second byte is < 0x80 (128) it is considered the size
-  // 2. If it is > 0x80 then it describes the number of bytes of the size
-  //    ex: 0x82 means the next 2 bytes describe the size of the value
-  // 3. The special case of exactly 0x80 is "indefinite" length (to end-of-file)
-
-  if (len > 127) {
-    lenlen += 1;
-    while (len > 255) {
-      lenlen += 1;
-      len = len >> 8;
-    }
-  }
-
-  if (lenlen) { hex += Enc.numToHex(0x80 + lenlen); }
-  return hex + Enc.numToHex(str.length/2) + str;
-};
-
-// The Integer type has some special rules
-ASN1.UInt = function UINT() {
-  var str = Array.prototype.slice.call(arguments).join('');
-  var first = parseInt(str.slice(0, 2), 16);
-
-  // If the first byte is 0x80 or greater, the number is considered negative
-  // Therefore we add a '00' prefix if the 0x80 bit is set
-  if (0x80 & first) { str = '00' + str; }
-
-  return ASN1('02', str);
-};
-
-// The Bit String type also has a special rule
-ASN1.BitStr = function BITSTR() {
-  var str = Array.prototype.slice.call(arguments).join('');
-  // '00' is a mask of how many bits of the next byte to ignore
-  return ASN1('03', '00' + str);
+    return EC.__thumbprint(jwk);
+  });
 };
 
 EC.toPem = EC.export = EC.pack;

lib/encoding.js

@@ -2,26 +2,26 @@
 
 var Enc = module.exports;
 
-Enc.base64ToBuf = function base64ToBuf(str) {
+Enc.base64ToBuf = function (str) {
   // node handles both base64 and urlBase64 equally
   return Buffer.from(str, 'base64');
 };
 
-Enc.base64ToHex = function base64ToHex(b64) {
+Enc.base64ToHex = function (b64) {
   return Enc.bufToHex(Enc.base64ToBuf(b64));
 };
 
-Enc.bufToBase64 = function toHex(u8) {
+Enc.bufToBase64 = function (u8) {
   // Ensure a node buffer, even if TypedArray
   return Buffer.from(u8).toString('base64');
 };
 
-Enc.bufToHex = function bufToHex(u8) {
+Enc.bufToHex = function (u8) {
   // Ensure a node buffer, even if TypedArray
   return Buffer.from(u8).toString('hex');
 };
 
-Enc.bufToUrlBase64 = function bufToUrlBase64(u8) {
+Enc.bufToUrlBase64 = function (u8) {
   return Enc.bufToBase64(u8)
     .replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
 };
@@ -33,7 +33,7 @@ Enc.hexToUint8 = function (hex) {
   return new Uint8Array(ab);
 };
 
-Enc.numToHex = function numToHex(d) {
+Enc.numToHex = function (d) {
   d = d.toString(16);
   if (d.length % 2) {
     return '0' + d;

lib/generate-privkey-node-v6.js

@@ -0,0 +1,36 @@
+// Copyright 2016-2018 AJ ONeal. All rights reserved
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+var curves = {
+  "P-256": "prime256v1" // 65
+, "secp256r1": "prime256v1"
+, "P-384": "secp384r1" // 97
+, "P-521": "secp521r1" // 133
+};
+var crv = "P-256";
+var ecdh = require('crypto').createECDH(curves[crv] || crv);
+var keys = ecdh.generateKeys(null, 'uncompressed');
+console.log(keys.length);
+console.log(keys.toString('hex'));
+keys = keys.slice(1);
+var x = keys.slice(0, keys.byteLength / 2);
+var y = keys.slice(keys.byteLength / 2);
+while (0 === x[0]) { x = x.slice(1); }
+while (0 === y[0]) { y = y.slice(1); }
+console.log({
+  kty: "EC"
+, crv: "P-XXX"
+, x: _toUrlBase64(x)
+, y: _toUrlBase64(y)
+});
+
+function _toUrlBase64(buf) {
+  return buf.toString('base64')
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g,"")
+  ;
+}

lib/generate-privkey-node.js

@@ -0,0 +1,22 @@
+// Copyright 2016-2018 AJ ONeal. All rights reserved
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.exports = function (crv) {
+  var keypair = require('crypto').generateKeyPairSync(
+    'ec'
+  , { namedCurve: crv
+    , privateKeyEncoding: { type: 'sec1', format: 'pem' }
+    , publicKeyEncoding: { type: 'spki', format: 'pem' }
+    }
+  );
+  var result = { privateKeyPem: keypair.privateKey.trim() };
+  return result;
+};
+
+if (require.main === module) {
+  var keypair = module.exports('P-256');
+  console.info(keypair.privateKeyPem);
+}

lib/pem.js

@@ -3,52 +3,24 @@
 var PEM = module.exports;
 var Enc = require('./encoding.js');
 
-// TODO move object id hinting to x509.js
-
-// 1.2.840.10045.3.1.7
-// prime256v1 (ANSI X9.62 named elliptic curve)
-var OBJ_ID_EC  = '06 08 2A8648CE3D030107'.replace(/\s+/g, '').toLowerCase();
-// 1.3.132.0.34
-// secp384r1 (SECG (Certicom) named elliptic curve)
-var OBJ_ID_EC_384 = '06 05 2B81040022'.replace(/\s+/g, '').toLowerCase();
-
 PEM.parseBlock = function pemToDer(pem) {
-  var typ;
-  var pub;
-  var crv;
-  var der = Buffer.from(pem.split(/\n/).filter(function (line, i) {
-    if (0 === i) {
-      if (/ PUBLIC /.test(line)) {
-        pub = true;
-      } else if (/ PRIVATE /.test(line)) {
-        pub = false;
-      }
-      if (/ EC/.test(line)) {
-        typ = 'EC';
-      }
-    }
-    return !/---/.test(line);
-  }).join(''), 'base64');
+  var lines = pem.trim().split(/\n/);
+  var end = lines.length - 1;
+  var head = lines[0].match(/-----BEGIN (.*)-----/);
+  var foot = lines[end].match(/-----END (.*)-----/);
 
-  if (!typ || 'EC' === typ) {
-    var hex = Enc.bufToHex(der);
-    if (-1 !== hex.indexOf(OBJ_ID_EC)) {
-      typ = 'EC';
-      crv = 'P-256';
-    } else if (-1 !== hex.indexOf(OBJ_ID_EC_384)) {
-      typ = 'EC';
-      crv = 'P-384';
-    } else {
-      // TODO support P-384 as well (but probably nothing else)
-      console.warn("unsupported ec curve");
+  if (head) {
+    lines = lines.slice(1, end);
+    head = head[1];
+    if (head !== foot[1]) {
+      throw new Error("headers and footers do not match");
     }
   }
 
-  return { kty: typ, pub: pub, der: der, crv: crv };
+  return { type: head, bytes: Enc.base64ToBuf(lines.join('')) };
 };
 
 PEM.packBlock = function (opts) {
-  // TODO allow for headers?
   return '-----BEGIN ' + opts.type + '-----\n'
     + Enc.bufToBase64(opts.bytes).match(/.{1,64}/g).join('\n') + '\n'
     + '-----END ' + opts.type + '-----'

lib/ssh.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var SSH = module.exports;
+var Enc = require('./encoding.js');
+
+                      // 19  e  c  d  s  a  -  s  h  a  2  -  n  i  s  t  p  2  5  6
+var SSH_EC_P256 = '00000013 65 63 64 73 61 2d 73 68 61 32 2d 6e 69 73 74 70 32 35 36'
+  .replace(/\s+/g, '').toLowerCase();
+                      // 19  e  c  d  s  a  -  s  h  a  2  -  n  i  s  t  p  3  8  4
+var SSH_EC_P384 = '00000013 65 63 64 73 61 2d 73 68 61 32 2d 6e 69 73 74 70 33 38 34'
+  .replace(/\s+/g, '').toLowerCase();
+
+SSH.parseSsh = function (pem) {
+  var jwk = { kty: 'EC', crv: null, x: null, y: null };
+  var b64 = pem.split(/\s+/g)[1];
+  var buf = Buffer.from(b64, 'base64');
+  var hex = Enc.bufToHex(buf);
+  var index = 40;
+  var len;
+  if (0 === hex.indexOf(SSH_EC_P256)) {
+    jwk.crv = 'P-256';
+    len = 32;
+  } else if (0 === hex.indexOf(SSH_EC_P384)) {
+    jwk.crv = 'P-384';
+    len = 48;
+  }
+  var x = buf.slice(index, index + len);
+  var y = buf.slice(index + len, index + len + len);
+  jwk.x = Enc.bufToUrlBase64(x);
+  jwk.y = Enc.bufToUrlBase64(y);
+  return jwk;
+};
+
+
+SSH.packSsh = function (jwk) {
+  // Custom SSH format
+  var typ = 'ecdsa-sha2-nistp256';
+	var a = '32 35 36';
+  var b = '41';
+  var comment = jwk.crv + '@localhost';
+  if ('P-256' !== jwk.crv) {
+    typ = 'ecdsa-sha2-nistp384';
+    a = '33 38 34';
+    b = '61';
+  }
+  var x = Enc.base64ToHex(jwk.x);
+  var y = Enc.base64ToHex(jwk.y);
+  var ssh = Enc.hexToUint8(
+    ('00 00 00 13 65 63 64 73 61 2d 73 68 61 32 2d 6e 69 73 74 70'
+    + a + '00 00 00 08 6e 69 73 74 70' + a + '00 00 00' + b
+    + '04' + x + y).replace(/\s+/g, '').toLowerCase()
+  );
+
+  return typ + ' ' + Enc.bufToBase64(ssh) + ' ' + comment;
+};

lib/x509.js

@@ -0,0 +1,170 @@
+'use strict';
+
+var ASN1 = require('./asn1.js');
+var Enc = require('./encoding.js');
+var x509 = module.exports;
+
+// 1.2.840.10045.3.1.7
+// prime256v1 (ANSI X9.62 named elliptic curve)
+var OBJ_ID_EC  = '06 08 2A8648CE3D030107'.replace(/\s+/g, '').toLowerCase();
+// 1.3.132.0.34
+// secp384r1 (SECG (Certicom) named elliptic curve)
+var OBJ_ID_EC_384 = '06 05 2B81040022'.replace(/\s+/g, '').toLowerCase();
+// 1.2.840.10045.2.1
+// ecPublicKey (ANSI X9.62 public key type)
+var OBJ_ID_EC_PUB = '06 07 2A8648CE3D0201'.replace(/\s+/g, '').toLowerCase();
+
+x509.parseSec1 = function parseEcOnlyPrivkey(u8, jwk) {
+  var index = 7;
+  var len = 32;
+  var olen = OBJ_ID_EC.length/2;
+
+  if ("P-384" === jwk.crv) {
+    olen = OBJ_ID_EC_384.length/2;
+    index = 8;
+    len = 48;
+  }
+  if (len !== u8[index - 1]) {
+    throw new Error("Unexpected bitlength " + len);
+  }
+
+  // private part is d
+  var d = u8.slice(index, index + len);
+  // compression bit index
+  var ci = index + len + 2 + olen + 2 + 3;
+  var c = u8[ci];
+  var x, y;
+
+  if (0x04 === c) {
+    y = u8.slice(ci + 1 + len, ci + 1 + len + len);
+  } else if (0x02 !== c) {
+    throw new Error("not a supported EC private key");
+  }
+  x = u8.slice(ci + 1, ci + 1 + len);
+
+  return {
+    kty: jwk.kty
+  , crv: jwk.crv
+  , d: Enc.bufToUrlBase64(d)
+  //, dh: Enc.bufToHex(d)
+  , x: Enc.bufToUrlBase64(x)
+  //, xh: Enc.bufToHex(x)
+  , y: Enc.bufToUrlBase64(y)
+  //, yh: Enc.bufToHex(y)
+  };
+};
+
+x509.parsePkcs8 = function parseEcPkcs8(u8, jwk) {
+  var index = 24 + (OBJ_ID_EC.length/2);
+  var len = 32;
+  if ("P-384" === jwk.crv) {
+    index = 24 + (OBJ_ID_EC_384.length/2) + 2;
+    len = 48;
+  }
+
+  //console.log(index, u8.slice(index));
+  if (0x04 !== u8[index]) {
+    //console.log(jwk);
+    throw new Error("privkey not found");
+  }
+  var d = u8.slice(index+2, index+2+len);
+  var ci = index+2+len+5;
+  var xi = ci+1;
+  var x = u8.slice(xi, xi + len);
+  var yi = xi+len;
+  var y;
+  if (0x04 === u8[ci]) {
+    y = u8.slice(yi, yi + len);
+  } else if (0x02 !== u8[ci]) {
+    throw new Error("invalid compression bit (expected 0x04 or 0x02)");
+  }
+
+  return {
+    kty: jwk.kty
+  , crv: jwk.crv
+  , d: Enc.bufToUrlBase64(d)
+  //, dh: Enc.bufToHex(d)
+  , x: Enc.bufToUrlBase64(x)
+  //, xh: Enc.bufToHex(x)
+  , y: Enc.bufToUrlBase64(y)
+  //, yh: Enc.bufToHex(y)
+  };
+};
+
+x509.parseSpki = function parsePem(u8, jwk) {
+  var ci = 16 + OBJ_ID_EC.length/2;
+  var len = 32;
+
+  if ("P-384" === jwk.crv) {
+    ci = 16 + OBJ_ID_EC_384.length/2;
+    len = 48;
+  }
+
+  var c = u8[ci];
+  var xi = ci + 1;
+  var x = u8.slice(xi, xi + len);
+  var yi = xi + len;
+  var y;
+  if (0x04 === c) {
+    y = u8.slice(yi, yi + len);
+  } else if (0x02 !== c) {
+    throw new Error("not a supported EC private key");
+  }
+
+  return {
+    kty: jwk.kty
+  , crv: jwk.crv
+  , x: Enc.bufToUrlBase64(x)
+  //, xh: Enc.bufToHex(x)
+  , y: Enc.bufToUrlBase64(y)
+  //, yh: Enc.bufToHex(y)
+  };
+};
+x509.parsePkix = x509.parseSpki;
+
+x509.packSec1 = function (jwk) {
+  var d = Enc.base64ToHex(jwk.d);
+  var x = Enc.base64ToHex(jwk.x);
+  var y = Enc.base64ToHex(jwk.y);
+  var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
+  return Enc.hexToUint8(
+    ASN1('30'
+    , ASN1.UInt('01')
+    , ASN1('04', d)
+    , ASN1('A0', objId)
+    , ASN1('A1', ASN1.BitStr('04' + x + y)))
+  );
+};
+x509.packPkcs8 = function (jwk) {
+  var d = Enc.base64ToHex(jwk.d);
+  var x = Enc.base64ToHex(jwk.x);
+  var y = Enc.base64ToHex(jwk.y);
+  var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
+  return Enc.hexToUint8(
+    ASN1('30'
+    , ASN1.UInt('00')
+    , ASN1('30'
+      , OBJ_ID_EC_PUB
+      , objId
+      )
+    , ASN1('04'
+      , ASN1('30'
+        , ASN1.UInt('01')
+        , ASN1('04', d)
+        , ASN1('A1', ASN1.BitStr('04' + x + y)))))
+  );
+};
+x509.packSpki = function (jwk) {
+  var x = Enc.base64ToHex(jwk.x);
+  var y = Enc.base64ToHex(jwk.y);
+  var objId = ('P-256' === jwk.crv) ? OBJ_ID_EC : OBJ_ID_EC_384;
+  return Enc.hexToUint8(
+    ASN1('30'
+    , ASN1('30'
+      , OBJ_ID_EC_PUB
+      , objId
+      )
+    , ASN1.BitStr('04' + x + y))
+  );
+};
+x509.packPkix = x509.packSpki;

package.json

@@ -1,7 +1,7 @@
 {
   "name": "eckles",
-  "version": "1.2.1",
-  "description": "PEM-to-JWK and JWK-to-PEM (and SSH) for ECDSA keys in a lightweight, zero-dependency library focused on perfect universal compatibility.",
+  "version": "1.4.0",
+  "description": "💯 PEM-to-JWK and JWK-to-PEM (and SSH) for ECDSA keys in a lightweight, zero-dependency library focused on perfect universal compatibility.",
   "homepage": "https://git.coolaj86.com/coolaj86/eckles.js",
   "main": "index.js",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "scripts": {
     "postinstall": "node lib/telemetry.js event:install",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "bash test.sh"
   },
   "repository": {
     "type": "git",

test.sh

@@ -118,6 +118,12 @@ node bin/eckles.js pkcs8 > /dev/null
 node bin/eckles.js ssh #> /dev/null
 echo "PASS"
 
+echo ""
+echo "Testing Thumbprints"
+node bin/eckles.js ./fixtures/privkey-ec-p256.sec1.pem thumbprint
+node bin/eckles.js ./fixtures/pub-ec-p256.jwk.json thumbprint
+echo "PASS"
+
 rm *.2