v1.0.0: An ASN.1 parser in 100 lines of Vanilla JavaScript, part of the BlueCrypt suite

README.md

@@ -0,0 +1,96 @@
+# BlueCrypt ASN.1 Parser
+
+An ASN.1 parser in less than 100 lines of Vanilla JavaScript,
+part of the BlueCrypt suite.
+<br>
+<small>(< 150 with newlines and comments)</small>
+
+| < 100 lines of code | 1.1k gzipped | 2.5k minified | 4.7k with comments |
+
+# Features
+
+* [x] Complete ASN.1 parser
+  * [x] Parses x.509 certificates
+  * [x] PEM (base64-encoded DER)
+* [x] VanillaJS, Zero Dependencies
+  * [x] Browsers (back to ES5.1)
+  * [ ] Node.js (built, publishing soon)
+  * [ ] Online Demo (built, publishing soon)
+
+![](https://i.imgur.com/gV7w7bM.png)
+
+<!--
+# Demo
+
+<https://coolaj86.com/demos/asn1-parser/>
+-->
+
+# Usage
+
+```html
+<script src="https://git.coolaj86.com/coolaj86/asn1-parser.js/raw/branch/master/asn1-parser.js"></script>
+```
+
+```js
+'use strict";
+
+var ASN1 = window.ASN1  // 62 lines
+var Enc = window.Enc    // 27 lines
+var PEM = window.PEM    //  6 lines
+
+var pem = [ '-----BEGIN EC PRIVATE KEY-----'
+          + 'MHcCAQEEIImMnaNu2jRjvQwVFnhhDw/KDYtS2Q6n8T5kJYniwY1UoAoGCCqGSM49'
+          + 'AwEHoUQDQgAEIT1SWLxsacPiE5Z16jkopAn8/+85rMjgyCokrnjDft6Y/YnA4A50'
+          + 'yZe7CnFsqeDcpnPbubP6cpYiVcnevNIYyg=='
+          + '-----END EC PRIVATE KEY-----'
+          ].join('\n');
+
+var der = PEM.parseBlock(pem).der;
+var json = ASN1.parse(der);
+
+console.log(json);
+```
+
+```json
+{ "type": 48 /*0x30*/, "lengthSize": 0, "length": 89
+, "children": [
+    { "type": 48 /*0x30*/, "lengthSize": 0, "length": 19
+		, "children": [
+        { "type": 6, "lengthSize": 0, "length": 7, "value": <0x2a8648ce3d0201> },
+        { "type": 6, "lengthSize": 0, "length": 8, "value": <0x2a8648ce3d030107> }
+      ]
+    },
+    { "type": 3, "lengthSize": 0, "length": 66,
+      "value": "<0x04213d5258bc6c69c3e2139675ea3928a409fcffef39acc8e0c82a24ae78c37ede98fd89c0e00e74c997bb0a716ca9e0dca673dbb9b3fa72962255c9debcd218ca>"
+    }
+  ]
+}
+```
+
+Note: `value` will be a `Uint8Array`, not a hex string.
+
+### Optimistic Parsing
+
+This is a dumbed-down, minimal ASN1 parser.
+
+Rather than incorporating knowledge of each possible x509 schema
+to know whether to traverse deeper into a value container,
+it always tries to dive in (and backs out when parsing fails).
+
+It is possible that it will produce false positives, but not likely
+in real-world scenarios (PEM, x509, CSR, etc).
+
+I'd be interested to hear if you encounter such a case.
+
+### Zero Dependencies
+
+> A little copying is better than a little dependency - Golang Proverbs by Rob Pike
+
+Rather than requiring hundreds (or thousands) of lines of dependencies,
+this library takes the approach of including from other libraries in its suite
+to produce a small, focused file that does exactly what it needs to do.
+
+# Legal
+
+[BlueCrypt VanillaJS ASN.1 Parser](https://git.coolaj86.com/coolaj86/asn1-parser.js) |
+MPL-2.0

asn1-parser.js

@@ -0,0 +1,142 @@
+;(function (exports) {
+'use strict';
+
+if (!exports.ASN1) { exports.ASN1 = {}; }
+if (!exports.Enc) { exports.Enc = {}; }
+if (!exports.PEM) { exports.PEM = {}; }
+
+var ASN1 = exports.ASN1;
+var Enc = exports.Enc;
+var PEM = exports.PEM;
+
+//
+// Parser
+//
+
+ASN1.ELOOP = "uASN1.js Error: iterated over 15+ elements (probably a malformed file)";
+ASN1.EDEEP = "uASN1.js Error: element nested 20+ layers deep (probably a malformed file)";
+// Container Types are Sequence 0x30, Octect String 0x04, Array? (0xA0, 0xA1)
+// Value Types are Integer 0x02, Bit String 0x03, Null 0x05, Object ID 0x06,
+// Sometimes Bit String is used as a container (RSA Pub Spki)
+ASN1.CTYPES = [ 0x30, 0x31, 0xa0, 0xa1 ];
+ASN1.parse = function parseAsn1(buf, depth, ws) {
+  if (!ws) { ws = ''; }
+  if (!depth) { depth = 0; }
+  if (depth >= 20) { throw new Error(ASN1.EDEEP); }
+
+  var index = 2; // we know, at minimum, data starts after type (0) and lengthSize (1)
+  var asn1 = { type: buf[0], lengthSize: 0, length: buf[1] };
+  var child;
+  var iters = 0;
+  var adjust = 0;
+  var adjustedLen;
+
+  // Determine how many bytes the length uses, and what it is
+  if (0x80 & asn1.length) {
+    asn1.lengthSize = 0x7f & asn1.length;
+    // I think that buf->hex->int solves the problem of Endianness... not sure
+    asn1.length = parseInt(Enc.bufToHex(buf.slice(index, index + asn1.lengthSize)), 16);
+    index += asn1.lengthSize;
+  }
+
+  // High-order bit Integers have a leading 0x00 to signify that they are positive.
+  // Bit Streams use the first byte to signify padding, which x.509 doesn't use.
+  if (0x00 === buf[index] && (0x02 === asn1.type || 0x03 === asn1.type)) {
+    // However, 0x00 on its own is a valid number
+    if (asn1.length > 1) {
+      index += 1;
+      adjust = -1;
+    }
+  }
+  adjustedLen = asn1.length + adjust;
+
+  //console.warn(ws + '0x' + Enc.numToHex(asn1.type), index, 'len:', asn1.length, asn1);
+
+  function parseChildren(eager) {
+    asn1.children = [];
+    //console.warn('1 len:', (2 + asn1.lengthSize + asn1.length), 'idx:', index, 'clen:', 0);
+    while (iters < 15 && index < (2 + asn1.length + asn1.lengthSize)) {
+      iters += 1;
+      child = ASN1.parse(buf.slice(index, index + adjustedLen), (depth || 0) + 1, ws + '  ');
+      // The numbers don't match up exactly and I don't remember why...
+      // probably something with adjustedLen or some such, but the tests pass
+      index += (2 + child.lengthSize + child.length);
+      //console.warn('2 len:', (2 + asn1.lengthSize + asn1.length), 'idx:', index, 'clen:', (2 + child.lengthSize + child.length));
+      if (index > (2 + asn1.lengthSize + asn1.length)) {
+        if (!eager) { console.error(JSON.stringify(asn1, ASN1._replacer, 2)); }
+        throw new Error("Parse error: child value length (" + child.length
+          + ") is greater than remaining parent length (" + (asn1.length - index)
+          + " = " + asn1.length + " - " + index + ")");
+      }
+      asn1.children.push(child);
+      //console.warn(ws + '0x' + Enc.numToHex(asn1.type), index, 'len:', asn1.length, asn1);
+    }
+    if (index !== (2 + asn1.lengthSize + asn1.length)) {
+      //console.warn('index:', index, 'length:', (2 + asn1.lengthSize + asn1.length));
+      throw new Error("premature end-of-file");
+    }
+    if (iters >= 15) { throw new Error(ASN1.ELOOP); }
+
+    delete asn1.value;
+    return asn1;
+  }
+
+  // We want to fail if we know for sure that it's bad
+  if (-1 !== ASN1.CTYPES.indexOf(asn1.type)) {
+    return parseChildren();
+  }
+
+  asn1.value = buf.slice(index, index + adjustedLen);
+  try {
+    return parseChildren(true);
+  } catch(e) {
+    // leaving iterable array as a matter of convenience
+    asn1.children = [];
+    return asn1;
+  }
+};
+ASN1._replacer = function (k, v) {
+  if ('type' === k) { return '0x' + Enc.numToHex(v); }
+  if ('value' === k) { return '0x' + Enc.bufToHex(v.data || v); }
+  return v;
+};
+
+// don't replace the full parseBlock, if it exists
+PEM.parseBlock = PEM.parseBlock || function (str) {
+  var der = str.split(/\n/).filter(function (line) {
+    return !/-----/.test(line);
+  }).join('');
+  return { der: Enc.base64ToBuf(der) };
+};
+
+Enc.base64ToBuf = function (b64) {
+  return Enc.binToBuf(atob(b64));
+};
+Enc.binToBuf = function (bin) {
+  var arr = bin.split('').map(function (ch) {
+    return ch.charCodeAt(0);
+  });
+  return 'undefined' !== typeof Uint8Array ? new Uint8Array(arr) : arr;
+};
+Enc.bufToHex = function (u8) {
+  var hex = [];
+  var i, h;
+  var len = (u8.byteLength || u8.length);
+
+  for (i = 0; i < len; i += 1) {
+    h = u8[i].toString(16);
+    if (h.length % 2) { h = '0' + h; }
+    hex.push(h);
+  }
+
+  return hex.join('').toLowerCase();
+};
+Enc.numToHex = function (d) {
+  d = d.toString(16);
+  if (d.length % 2) {
+    return '0' + d;
+  }
+  return d;
+};
+
+}('undefined' !== typeof window ? window : module.exports));

index.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>ASN.1 Parser - BlueCrypt</title>
+  <style>
+    textarea {
+      width: 42em;
+      height: 10em;
+    }
+  </style>
+</head>
+<body>
+  <h1>BlueCrypt ASN.1 Parser</h1>
+
+  <textarea class="js-input" placeholder="Paste a PEM here">-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEIT1SWLxsacPiE5Z16jkopAn8/+85
+rMjgyCokrnjDft6Y/YnA4A50yZe7CnFsqeDcpnPbubP6cpYiVcnevNIYyg==
+-----END PUBLIC KEY-----</textarea>
+
+  <pre><code class="js-hex"> </code></pre>
+
+  <pre><code class="js-json"> </code></pre>
+
+  <script src="./asn1-parser.js"></script>
+  <script>
+    var $input = document.querySelector('.js-input');
+
+    function convert() {
+      console.log('change');
+      var pem = PEM.parseBlock(document.querySelector('.js-input').value);
+      var hex = Enc.bufToHex(pem.der);
+      console.log(hex);
+      document.querySelector('.js-hex').innerText = hex
+        .match(/.{2}/g).join(' ').match(/.{1,24}/g).join(' ').match(/.{1,50}/g).join('\n');
+      var json = ASN1.parse(pem.der);
+      document.querySelector('.js-json').innerText = JSON.stringify(json, ASN1._replacer, 2);
+    }
+
+    $input.addEventListener('keyup', convert);
+    convert();
+  </script>
+</body>
+</html>

package.json

@@ -0,0 +1,26 @@
+{
+  "name": "asn1-parser",
+  "version": "1.0.0",
+  "description": "An ASN.1 parser in less than 100 lines of Vanilla JavaScript, part of the BlueCrypt suite.",
+  "homepage": "https://git.coolaj86.com/coolaj86/asn1-parser.js",
+  "main": "asn1-parser.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.coolaj86.com/coolaj86/asn1-parser.js"
+  },
+  "keywords": [
+    "zero-dependency",
+    "ASN.1",
+    "X.509",
+    "PEM",
+    "DER",
+    "asn1",
+    "x509",
+    "VanillaJS"
+  ],
+  "author": "AJ ONeal <coolaj86@gmail.com> (https://coolaj86.com/)",
+  "license": "MPL-2.0"
+}