pi-codex-auto-review 0.1.0

package/node_modules/node-forge/tests/unit/asn1.js

@@ -0,0 +1,1337 @@
+var ASSERT = require('assert');
+var ASN1 = require('../../lib/asn1');
+var UTIL = require('../../lib/util');
+
+(function() {
+  describe('asn1', function() {
+    // TODO: add more ASN.1 coverage
+
+    it('should convert an OID to DER', function() {
+      ASSERT.equal(ASN1.oidToDer('1.2.840.113549').toHex(), '2a864886f70d');
+    });
+
+    it('should convert a 32b OID to DER', function() {
+      ASSERT.equal(ASN1.oidToDer('1.2.4294967295').toHex(), '2a8fffffff7f');
+    });
+
+    it('should not convert a >32b OID to DER', function() {
+      ASSERT.throws(
+        function() {
+          ASN1.oidToDer('1.2.4294967296');
+        },
+        /OID value too large; max is 32-bits./
+      );
+    });
+
+    it('should convert an OID from DER', function() {
+      var der = UTIL.hexToBytes('2a864886f70d');
+      ASSERT.equal(ASN1.derToOid(der), '1.2.840.113549');
+    });
+
+    it('should convert a 32b OID from DER', function() {
+      var der = UTIL.hexToBytes('2a8fffffff7f');
+      ASSERT.equal(ASN1.derToOid(der), '1.2.4294967295');
+    });
+
+    it('should convert a >32b OID from DER', function() {
+      var der = UTIL.hexToBytes('2a9080808001');
+      ASSERT.equal(ASN1.derToOid(der), '1.2.4294967297');
+    });
+
+    it('should convert a max safe int OID from DER', function() {
+      var der = UTIL.hexToBytes('2a8fffffffffffff7f');
+      ASSERT.equal(ASN1.derToOid(der), '1.2.9007199254740991');
+    });
+
+    it('should not convert a >max safe int OID from DER', function() {
+      ASSERT.throws(
+        function() {
+          // '1.2.9007199254740992'
+          var der = UTIL.hexToBytes('2a9080808080808000');
+          console.log(ASN1.derToOid(der));
+        },
+        /OID value too large; max is 53-bits./
+      );
+    });
+
+    it('should convert INTEGER 0 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(0).toHex(), '00');
+    });
+
+    it('should convert INTEGER 1 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(1).toHex(), '01');
+    });
+
+    it('should convert INTEGER 127 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(127).toHex(), '7f');
+    });
+
+    it('should convert INTEGER 128 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(128).toHex(), '0080');
+    });
+
+    it('should convert INTEGER 256 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(256).toHex(), '0100');
+    });
+
+    it('should convert INTEGER -128 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(-128).toHex(), '80');
+    });
+
+    it('should convert INTEGER -129 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(-129).toHex(), 'ff7f');
+    });
+
+    it('should convert INTEGER 32768 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(32768).toHex(), '008000');
+    });
+
+    it('should convert INTEGER -32768 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(-32768).toHex(), '8000');
+    });
+
+    it('should convert INTEGER -32769 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(-32769).toHex(), 'ff7fff');
+    });
+
+    it('should convert INTEGER 8388608 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(8388608).toHex(), '00800000');
+    });
+
+    it('should convert INTEGER -8388608 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(-8388608).toHex(), '800000');
+    });
+
+    it('should convert INTEGER -8388609 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(-8388609).toHex(), 'ff7fffff');
+    });
+
+    it('should convert INTEGER 2147483647 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(2147483647).toHex(), '7fffffff');
+    });
+
+    it('should convert INTEGER -2147483648 to DER', function() {
+      ASSERT.equal(ASN1.integerToDer(-2147483648).toHex(), '80000000');
+    });
+
+    it('should convert INTEGER 0 from DER', function() {
+      var der = UTIL.hexToBytes('00');
+      ASSERT.equal(ASN1.derToInteger(der), 0);
+    });
+
+    it('should convert INTEGER 1 from DER', function() {
+      var der = UTIL.hexToBytes('01');
+      ASSERT.equal(ASN1.derToInteger(der), 1);
+    });
+
+    it('should convert INTEGER 127 from DER', function() {
+      var der = UTIL.hexToBytes('7f');
+      ASSERT.equal(ASN1.derToInteger(der), 127);
+    });
+
+    it('should convert INTEGER 128 from DER', function() {
+      var der = UTIL.hexToBytes('0080');
+      ASSERT.equal(ASN1.derToInteger(der), 128);
+    });
+
+    it('should convert INTEGER 256 from DER', function() {
+      var der = UTIL.hexToBytes('0100');
+      ASSERT.equal(ASN1.derToInteger(der), 256);
+    });
+
+    it('should convert INTEGER -128 from DER', function() {
+      var der = UTIL.hexToBytes('80');
+      ASSERT.equal(ASN1.derToInteger(der), -128);
+    });
+
+    it('should convert INTEGER -129 from DER', function() {
+      var der = UTIL.hexToBytes('ff7f');
+      ASSERT.equal(ASN1.derToInteger(der), -129);
+    });
+
+    it('should convert INTEGER 32768 from DER', function() {
+      var der = UTIL.hexToBytes('008000');
+      ASSERT.equal(ASN1.derToInteger(der), 32768);
+    });
+
+    it('should convert INTEGER -32768 from DER', function() {
+      var der = UTIL.hexToBytes('8000');
+      ASSERT.equal(ASN1.derToInteger(der), -32768);
+    });
+
+    it('should convert INTEGER -32769 from DER', function() {
+      var der = UTIL.hexToBytes('ff7fff');
+      ASSERT.equal(ASN1.derToInteger(der), -32769);
+    });
+
+    it('should convert INTEGER 8388608 from DER', function() {
+      var der = UTIL.hexToBytes('00800000');
+      ASSERT.equal(ASN1.derToInteger(der), 8388608);
+    });
+
+    it('should convert INTEGER -8388608 from DER', function() {
+      var der = UTIL.hexToBytes('800000');
+      ASSERT.equal(ASN1.derToInteger(der), -8388608);
+    });
+
+    it('should convert INTEGER -8388609 from DER', function() {
+      var der = UTIL.hexToBytes('ff7fffff');
+      ASSERT.equal(ASN1.derToInteger(der), -8388609);
+    });
+
+    it('should convert INTEGER 2147483647 from DER', function() {
+      var der = UTIL.hexToBytes('7fffffff');
+      ASSERT.equal(ASN1.derToInteger(der), 2147483647);
+    });
+
+    it('should convert INTEGER -2147483648 from DER', function() {
+      var der = UTIL.hexToBytes('80000000');
+      ASSERT.equal(ASN1.derToInteger(der), -2147483648);
+    });
+
+    (function() {
+      var tests = [{
+        in: '20110223123400',
+        out: 1298464440000
+      }, {
+        in: '20110223123400.1',
+        out: 1298464440100
+      }, {
+        in: '20110223123400.123',
+        out: 1298464440123
+      }];
+      tests.forEach(function(test) {
+        it('should convert local generalized time "' + test.in + '" to a Date', function() {
+          var d = ASN1.generalizedTimeToDate(test.in);
+          var localOffset = d.getTimezoneOffset() * 60000;
+          ASSERT.equal(d.getTime(), test.out + localOffset);
+        });
+      });
+    })();
+
+    (function() {
+      var tests = [{
+        in: '20110223123400Z', // Wed Feb 23 12:34:00.000 UTC 2011
+        out: 1298464440000
+      }, {
+        in: '20110223123400.1Z', // Wed Feb 23 12:34:00.100 UTC 2011
+        out: 1298464440100
+      }, {
+        in: '20110223123400.123Z', // Wed Feb 23 12:34:00.123 UTC 2011
+        out: 1298464440123
+      }, {
+        in: '20110223123400+0200', // Wed Feb 23 10:34:00.000 UTC 2011
+        out: 1298457240000
+      }, {
+        in: '20110223123400.1+0200', // Wed Feb 23 10:34:00.100 UTC 2011
+        out: 1298457240100
+      }, {
+        in: '20110223123400.123+0200', // Wed Feb 23 10:34:00.123 UTC 2011
+        out: 1298457240123
+      }, {
+        in: '20110223123400-0200', // Wed Feb 23 14:34:00.000 UTC 2011
+        out: 1298471640000
+      }, {
+        in: '20110223123400.1-0200', // Wed Feb 23 14:34:00.100 UTC 2011
+        out: 1298471640100
+      }, {
+        in: '20110223123400.123-0200', // Wed Feb 23 14:34:00.123 UTC 2011
+        out: 1298471640123
+      }];
+      tests.forEach(function(test) {
+        it('should convert utc generalized time "' + test.in + '" to a Date', function() {
+          var d = ASN1.generalizedTimeToDate(test.in);
+          ASSERT.equal(d.getTime(), test.out);
+        });
+      });
+    })();
+
+    (function() {
+      var tests = [{
+        in: 'Jan 1 1949 00:00:00 GMT',
+        out: '19490101000000Z'
+      }, {
+        in: 'Jan 1 2000 00:00:00 GMT',
+        out: '20000101000000Z'
+      }, {
+        in: 'Jan 1 2050 00:00:00 GMT',
+        out: '20500101000000Z'
+      }, {
+        in: 'Mar 1 2100 00:00:00 GMT',
+        out: '21000301000000Z'
+      }];
+      tests.forEach(function(test) {
+        it('should convert date "' + test.in + '" to generalized time', function() {
+          var d = ASN1.dateToGeneralizedTime(new Date(test.in));
+          ASSERT.equal(d, test.out);
+        });
+      });
+    })();
+
+    (function() {
+      var tests = [{
+        in: '1102231234Z', // Wed Feb 23 12:34:00 UTC 2011
+        out: 1298464440000
+      }, {
+        in: '1102231234+0200', // Wed Feb 23 10:34:00 UTC 2011
+        out: 1298457240000
+      }, {
+        in: '1102231234-0200', // Wed Feb 23 14:34:00 UTC 2011
+        out: 1298471640000
+      }, {
+        in: '110223123456Z', // Wed Feb 23 12:34:56 UTC 2011
+        out: 1298464496000
+      }, {
+        in: '110223123456+0200', // Wed Feb 23 10:34:56 UTC 2011
+        out: 1298457296000
+      }, {
+        in: '110223123456-0200', // Wed Feb 23 14:34:56 UTC 2011
+        out: 1298471696000
+      }, {
+        in: '500101000000Z',
+        out: -631152000000
+      }];
+      tests.forEach(function(test) {
+        it('should convert utc time "' + test.in + '" to a Date', function() {
+          var d = ASN1.utcTimeToDate(test.in);
+          ASSERT.equal(d.getTime(), test.out);
+        });
+      });
+    })();
+
+    (function() {
+      var tests = [{
+        in: 'Sat Dec 31 1949 19:00:00 GMT-0500',
+        out: '500101000000Z'
+      }];
+      tests.forEach(function(test) {
+        it('should convert date "' + test.in + '" to utc time', function() {
+          var d = ASN1.dateToUtcTime(new Date(test.in));
+          ASSERT.equal(d, test.out);
+        });
+      });
+    })();
+
+    (function() {
+      // use function to avoid calling apis during setup
+      function _asn1(str) {
+        return function() {
+          return ASN1.fromDer(UTIL.hexToBytes(str.replace(/ /g, '')));
+        };
+      }
+      var tests = [{
+        name: 'empty strings',
+        obj1: '',
+        obj2: '',
+        equal: true
+      }, {
+        name: 'simple strings',
+        obj1: '\u0001',
+        obj2: '\u0001',
+        equal: true
+      }, {
+        name: 'simple strings',
+        obj1: '\u0000',
+        obj2: '\u0001',
+        equal: false
+      }, {
+        name: 'simple arrays',
+        obj1: ['', ''],
+        obj2: ['', ''],
+        equal: true
+      }, {
+        name: 'simple arrays',
+        obj1: ['', ''],
+        obj2: [''],
+        equal: false
+      }, {
+        name: 'INTEGERs',
+        obj1: _asn1('02 01 00'),
+        obj2: _asn1('02 01 00'),
+        equal: true
+      }, {
+        name: 'BER INTEGERs',
+        obj1: _asn1('02 01 01'),
+        obj2: _asn1('02 02 00 01'),
+        equal: false
+      }, {
+        name: 'BIT STRINGs',
+        obj1: _asn1('03 02 00 01'),
+        obj2: _asn1('03 02 00 01'),
+        equal: true
+      }, {
+        name: 'BIT STRINGs',
+        obj1: _asn1('03 02 00 01'),
+        obj2: _asn1('03 02 00 02'),
+        equal: false
+      }, {
+        name: 'BIT STRINGs sub INTEGER',
+        obj1: _asn1('03 04 00 02 01 01'),
+        obj2: _asn1('03 04 00 02 01 01'),
+        equal: true
+      }, {
+        name: 'mutated BIT STRINGs',
+        obj1: _asn1('03 04 00 02 01 01'),
+        obj2: _asn1('03 04 00 02 01 01'),
+        mutate: function(obj1, obj2) {
+          obj2.value[0].value = '\u0002';
+        },
+        equal: false
+      }];
+      tests.forEach(function(test, index) {
+        var name = 'should check ASN.1 ' +
+          (test.equal ? '' : 'not ') + 'equal: ' +
+          (test.name || '#' + index);
+        it(name, function() {
+          var obj1 = typeof test.obj1 === 'function' ? test.obj1() : test.obj1;
+          var obj2 = typeof test.obj2 === 'function' ? test.obj2() : test.obj2;
+          if(test.mutate) {
+            test.mutate(obj1, obj2);
+          }
+          ASSERT.equal(ASN1.equals(obj1, obj2), test.equal);
+        });
+      });
+    })();
+
+    (function() {
+      // use function to avoid calling apis during setup
+      function _asn1(str) {
+        return function() {
+          return ASN1.fromDer(UTIL.hexToBytes(str.replace(/ /g, '')));
+        };
+      }
+      var tests = [{
+        name: 'empty string',
+        obj: ''
+      }, {
+        name: 'simple string',
+        obj: '\u0001'
+      }, {
+        name: 'simple array',
+        obj: ['', '']
+      }, {
+        name: 'INTEGER',
+        obj: _asn1('02 01 00')
+      }, {
+        name: 'BER INTEGER',
+        obj: _asn1('02 01 01')
+      }, {
+        name: 'BIT STRING',
+        obj: _asn1('03 02 00 01')
+      }, {
+        name: 'BIT STRING sub INTEGER',
+        obj: _asn1('03 04 00 02 01 01')
+      }];
+      tests.forEach(function(test, index) {
+        var name = 'should check ASN.1 copy: ' + (test.name || '#' + index);
+        it(name, function() {
+          var obj = typeof test.obj === 'function' ? test.obj() : test.obj;
+          ASSERT.equal(ASN1.equals(ASN1.copy(obj), obj), true);
+        });
+      });
+    })();
+
+    (function() {
+      function _h2b(str) {
+        return UTIL.hexToBytes(str.replace(/ /g, ''));
+      }
+      function _add(b, str) {
+        b.putBytes(_h2b(str));
+      }
+      function _asn1dump(asn1) {
+        console.log(ASN1.prettyPrint(asn1));
+        console.log(JSON.stringify(asn1, null, 2));
+      }
+      function _asn1TestOne(strict, throws, options) {
+        options = options || {};
+        if(!('decodeBitStrings' in options)) {
+          options.decodeBitStrings = true;
+        }
+        // buffer strict test
+        var b = UTIL.createBuffer();
+        // init
+        options.init(b);
+        // bytes for round-trip comparison
+        var bytes = b.copy().bytes();
+        // copy for non-strict test
+        var bns = b.copy();
+        // create strict and non-strict asn1
+        var asn1assert = throws ? ASSERT.throws : function(f) { f(); };
+        var asn1;
+        var der;
+        asn1assert(function() {
+          asn1 = ASN1.fromDer(b, {
+            strict: strict,
+            decodeBitStrings: options.decodeBitStrings
+          });
+        });
+        // debug
+        if(options.dump && asn1) {
+          console.log('=== ' + (strict ? 'Strict' : 'Non Strict') + ' ===');
+          _asn1dump(asn1);
+        }
+        // basic check
+        if(!throws) {
+          ASSERT.ok(asn1);
+        }
+
+        // round-trip(ish) check
+        if(!throws) {
+          der = ASN1.toDer(asn1);
+          if(options.roundtrip) {
+            // byte comparisons for round-trip testing can fail due to
+            // semantically safe changes such as changing the length encoding.
+            // test a roundtrip for data where it makes sense.
+            ASSERT.equal(
+              UTIL.bytesToHex(bytes),
+              UTIL.bytesToHex(der.bytes()));
+          }
+        }
+
+        // validator check
+        if(!throws && options.v) {
+          var capture = {};
+          var errors = [];
+          var asn1ok = ASN1.validate(asn1, options.v, capture, errors);
+          ASSERT.deepEqual(errors, []);
+          if(options.captured) {
+            ASSERT.deepEqual(capture, options.captured);
+          } else {
+            ASSERT.deepEqual(capture, {});
+          }
+          ASSERT.ok(asn1ok);
+        }
+
+        return {
+          asn1: asn1,
+          der: der
+        };
+      }
+      function _asn1Test(options) {
+        var s = _asn1TestOne(true, options.strictThrows, options);
+        var ns = _asn1TestOne(false, options.nonStrictThrows, options);
+
+        // check asn1 equality
+        if(s.asn1 && ns.asn1) {
+          ASSERT.deepEqual(s.asn1, ns.asn1);
+        }
+
+        // check der equality
+        if(s.der && ns.der) {
+          ASSERT.equal(
+            UTIL.bytesToHex(s.der.bytes()),
+            UTIL.bytesToHex(ns.der.bytes()));
+        }
+
+        if(options.done) {
+          options.done({
+            strict: s,
+            nonStrict: ns
+          });
+        }
+      }
+
+      it('should convert BIT STRING from DER (short,empty)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING value=none
+            _add(b, '03 00');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits'
+          },
+          captured: {
+            bits: ''
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (short,empty2)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING value=none
+            _add(b, '03 01 00');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bitsC',
+            captureBitStringValue: 'bitsV'
+          },
+          captured: {
+            bitsC: _h2b('00'),
+            bitsV: ''
+          }
+        });
+      });
+
+      it('should convert BIT STRING from BER (short,invalid)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING value=partial
+            // invalid in strict mode, non-strict will read 1 of 2 bytes
+            _add(b, '03 02 00');
+          },
+          dump: false,
+          roundtrip: false,
+          strictThrows: true,
+          nonStrictThrows: false,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits'
+          },
+          captured: {
+            // only for non-strict mode, truncated value
+            bits: _h2b('00')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (short)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING value=0110111001011101
+            _add(b, '03 03 00 6e 5d');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits'
+          },
+          captured: {
+            bits: _h2b('00 6e 5d')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (short2)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING value=0110111001011101
+            // contains an INTEGER=0x12
+            _add(b, '03 04 00 02 01 12');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            // note captureBitStringContents used to get all bytes
+            // 'capture' would get the value structure
+            // 'captureAsn1' would get the value and sub-value structures
+            captureBitStringContents: 'bits',
+            value: [{
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.INTEGER,
+              constructed: false,
+              capture: 'int0'
+            }]
+          },
+          captured: {
+            bits: _h2b('00 02 01 12'),
+            int0: _h2b('12')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (short,unused1z)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING value=01101110010111011010111, unused=0
+            _add(b, '03 04 01 6e 5d ae');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits'
+          },
+          captured: {
+            bits: _h2b('01 6e 5d ae')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (short,unused6z)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING short len, value=011011100101110111, unused=000000
+            _add(b, '03 04 06 6e 5d c0');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits'
+          },
+          captured: {
+            bits: _h2b('06 6e 5d c0')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from BER (short,unused6d)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING short len, value=011011100101110111, unused=100000
+            _add(b, '03 04 06 6e 5d e0');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits'
+          },
+          captured: {
+            bits: _h2b('06 6e 5d e0')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from BER (long,unused6z)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING long len, value=011011100101110111, unused=000000
+            _add(b, '03 81 04 06 6e 5d c0');
+          },
+          dump: false,
+          // length is compressed
+          roundtrip: false,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits'
+          },
+          captured: {
+            bits: _h2b('06 6e 5d c0')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from BER (unused6z)', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING constructed, value=0110111001011101+11, unused=000000
+            _add(b, '23 09');
+            _add(b, '03 03 00 6e 5d');
+            _add(b, '03 02 06 c0');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: true,
+            value: [{
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.BITSTRING,
+              constructed: false,
+              capture: 'bits0'
+            }, {
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.BITSTRING,
+              constructed: false,
+              capture: 'bits1'
+            }]
+          },
+          captured: {
+            bits0: _h2b('00 6e 5d'),
+            bits1: _h2b('06 c0')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from BER (decode)', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data that includes encapsulated
+            // data.  often used to store SEQUENCE of INTEGERs.
+            // add bit stream of bytes using long length
+            _add(b, '03 82 00 10');
+            // no padding
+            _add(b, '00');
+            // sequence of two ints
+            _add(b, '30 0D');
+            // add test int, long len
+            _add(b, '02 81 04 12 34 56 78');
+            // add test int, short len
+            _add(b, '02 04 87 65 43 21');
+          },
+          dump: false,
+          decodeBitStrings: true,
+          // long len will compress to short len
+          roundtrip: false,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits',
+            value: [{
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.SEQUENCE,
+              constructed: true,
+              value: [{
+                tagClass: ASN1.Class.UNIVERSAL,
+                type: ASN1.Type.INTEGER,
+                constructed: false,
+                capture: 'int0'
+              }, {
+                tagClass: ASN1.Class.UNIVERSAL,
+                type: ASN1.Type.INTEGER,
+                constructed: false,
+                capture: 'int1'
+              }]
+            }]
+          },
+          captured: {
+            bits: _h2b(
+              '00' +
+              '30 0D' +
+              '02 81 04 12 34 56 78' +
+              '02 04 87 65 43 21'),
+            int0: _h2b('12 34 56 78'),
+            int1: _h2b('87 65 43 21')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from BER (no decode)', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data that includes encapsulated
+            // data.  often used to store SEQUENCE of INTEGERs.
+            // add bit stream
+            _add(b, '03 82 00 10');
+            // no padding
+            _add(b, '00');
+            // sequence of two ints
+            _add(b, '30 0D');
+            // add test int, long len
+            _add(b, '02 81 04 12 34 56 78');
+            // add test int, short len
+            _add(b, '02 04 87 65 43 21');
+          },
+          dump: false,
+          decodeBitStrings: false,
+          // long length is compressed
+          roundtrip: false,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits'
+          },
+          captured: {
+            bits: _h2b(
+              '00' +
+              '30 0D' +
+              '02 81 04 12 34 56 78' +
+              '02 04 87 65 43 21')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (decode2)', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data that includes encapsulated
+            // data.  often used to store SEQUENCE of INTEGERs.
+            // bit stream
+            _add(b, '03 81 8D');
+            // no padding
+            _add(b, '00');
+            // sequence
+            _add(b, '30 81 89');
+            // int header and leading 0
+            _add(b, '02 81 81 00');
+            // 1024 bit int
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F0');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F1');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F2');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F3');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F4');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F5');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F6');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F7');
+            // int header and 3 byte int
+            _add(b, '02 03 01 00 01');
+          },
+          dump: false,
+          decodeBitStrings: true,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            value: [{
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.SEQUENCE,
+              constructed: true,
+              value: [{
+                tagClass: ASN1.Class.UNIVERSAL,
+                type: ASN1.Type.INTEGER,
+                constructed: false,
+                capture: 'int0'
+              }, {
+                tagClass: ASN1.Class.UNIVERSAL,
+                type: ASN1.Type.INTEGER,
+                constructed: false,
+                capture: 'int1'
+              }]
+            }]
+          },
+          captured: {
+            int0: _h2b('00' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F0' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F1' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F2' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F3' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F4' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F5' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F6' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F7'),
+            int1: _h2b('01 00 01')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (sig)', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data similar to a signature that
+            // could be interpreted incorrectly as encapsulated data.
+            // add bit stream of 257 bytes
+            _add(b, '03 82 01 01');
+            // no unused
+            _add(b, '00');
+            // signature bits
+            _add(b, '25 81 FD 6E D3 AB 34 45 DE AE F1 5B EC 6A FB 79');
+            _add(b, '14 CD 7B B2 8E 48 59 AE 89 B1 55 60 11 AB BC 7F');
+            _add(b, '6D 6D FE 16 22 42 AC 57 CC E9 C0 3A 8D 1E F3 C3');
+            _add(b, '97 C8 23 53 DE E0 34 C3 A9 43 8B 2B D9 C0 24 FF');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F4');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F5');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F6');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F7');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F8');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F9');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FA');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FB');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FC');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FD');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FE');
+            _add(b, 'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            // captureBitStringContents not used to check if valude decoded
+            capture: 'sig'
+          },
+          captured: {
+            sig: _h2b(
+              '00' +
+              '25 81 FD 6E D3 AB 34 45 DE AE F1 5B EC 6A FB 79' +
+              '14 CD 7B B2 8E 48 59 AE 89 B1 55 60 11 AB BC 7F' +
+              '6D 6D FE 16 22 42 AC 57 CC E9 C0 3A 8D 1E F3 C3' +
+              '97 C8 23 53 DE E0 34 C3 A9 43 8B 2B D9 C0 24 FF' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F4' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F5' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F6' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F7' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F8' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF F9' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FA' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FB' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FC' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FD' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FE' +
+              'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (sig2)', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data similar to a signature that
+            // could be interpreted incorrectly as encapsulated data.
+            // add bit stream of 257 bytes
+            _add(b, '03 82 01 01');
+            // no unused
+            _add(b, '00');
+            // signature bits
+            _add(b, '2B 05 9D 81 FB 07 2C CE 15 0A 39 CD D3 89 A7 83');
+            _add(b, '5C 99 5E B2 0D A4 E0 26 81 20 EF 5A 0F 23 46 E0');
+            _add(b, '46 4A 5D 7B 6A C9 4F B1 38 D5 FC 71 6A 32 06 6C');
+            _add(b, '68 15 9E F2 13 DB 2A 36 41 93 51 4C 98 EB 9F 32');
+            _add(b, '28 54 07 CE B2 05 92 A7 C8 DF 2F A1 E3 C9 9C 0A');
+            _add(b, 'E4 BE B3 88 17 CF 62 70 80 CD 10 B8 9B 08 E0 47');
+            _add(b, '61 24 12 16 C0 FC 70 D9 0A 4A 39 09 F4 51 F1 62');
+            _add(b, '0A 56 6B 46 C1 E2 0B FF 92 3E F5 A5 06 EE 55 0A');
+            _add(b, '6D FD DA 18 B9 C1 30 6E 98 CD 38 4D 9C C5 B5 6B');
+            _add(b, '81 19 B7 B1 19 52 5C F8 99 9D C2 EC A1 F5 96 A7');
+            _add(b, '66 79 A6 53 F8 17 67 64 52 F6 32 37 F4 CD 74 5A');
+            _add(b, '2F 59 35 06 90 6B CC F7 E6 7D 67 C4 FA 0C 7B 10');
+            _add(b, '05 85 E8 4F E2 0E EF A0 D4 F8 57 EB BF 2F 14 42');
+            _add(b, '62 01 09 08 35 5C 24 8C 0D 5D FD FA 52 58 D8 C9');
+            _add(b, '10 45 4F AE 15 B0 9A 82 B9 FB 17 CC E6 A0 BD BA');
+            _add(b, '76 BD 05 F1 70 69 43 9D 60 31 F9 F4 13 7A 8C 71');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            // captureBitStringContents not used to check if valude decoded
+            captureBitStringValue: 'bits'
+          },
+          captured: {
+            bits: _h2b(
+              '2B 05 9D 81 FB 07 2C CE 15 0A 39 CD D3 89 A7 83' +
+              '5C 99 5E B2 0D A4 E0 26 81 20 EF 5A 0F 23 46 E0' +
+              '46 4A 5D 7B 6A C9 4F B1 38 D5 FC 71 6A 32 06 6C' +
+              '68 15 9E F2 13 DB 2A 36 41 93 51 4C 98 EB 9F 32' +
+              '28 54 07 CE B2 05 92 A7 C8 DF 2F A1 E3 C9 9C 0A' +
+              'E4 BE B3 88 17 CF 62 70 80 CD 10 B8 9B 08 E0 47' +
+              '61 24 12 16 C0 FC 70 D9 0A 4A 39 09 F4 51 F1 62' +
+              '0A 56 6B 46 C1 E2 0B FF 92 3E F5 A5 06 EE 55 0A' +
+              '6D FD DA 18 B9 C1 30 6E 98 CD 38 4D 9C C5 B5 6B' +
+              '81 19 B7 B1 19 52 5C F8 99 9D C2 EC A1 F5 96 A7' +
+              '66 79 A6 53 F8 17 67 64 52 F6 32 37 F4 CD 74 5A' +
+              '2F 59 35 06 90 6B CC F7 E6 7D 67 C4 FA 0C 7B 10' +
+              '05 85 E8 4F E2 0E EF A0 D4 F8 57 EB BF 2F 14 42' +
+              '62 01 09 08 35 5C 24 8C 0D 5D FD FA 52 58 D8 C9' +
+              '10 45 4F AE 15 B0 9A 82 B9 FB 17 CC E6 A0 BD BA' +
+              '76 BD 05 F1 70 69 43 9D 60 31 F9 F4 13 7A 8C 71')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from DER (sig3)', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data similar to a signature that
+            // could be interpreted incorrectly as encapsulated data.
+            _add(b, '03 0B');
+            // no unused
+            _add(b, '00');
+            // signature bits with structure with bad type and length
+            _add(b, '2B 05 9D 05 F0 F1 F2 F3 F4 F5');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            // captureBitStringContents not used to check if value decoded
+            capture: 'sig'
+          },
+          captured: {
+            sig: _h2b(
+              '00' +
+              '2B 05 9D 05 F0 F1 F2 F3 F4 F5')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from BER (decodable sig)', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data similar to a signature that
+            // could be interpreted as encapsulated data. data is such that
+            // a round trip process could change the data due to INTEGER
+            // optimization (removal of leading bytes) or length structure
+            // compression (long to short).
+            // add a basic bit stream "signature" with test data
+            _add(b, '03 22');
+            // no unused
+            _add(b, '00');
+            // everything after this point might be important bits, not ASN.1
+            // SEQUENCE of tests
+            _add(b, '30 1E');
+            // signature bits
+            // '02 02' prefix will be cause parsing as an integer
+            // toDer will try to remove the extra 00.
+            // tests the BIT STRING content/value saving feature
+            _add(b, '02 02 00 7F');
+            // similar example for -1:
+            _add(b, '02 02 FF FF');
+            // could extend out to any structure size:
+            _add(b, '02 06 FF FF FF FF FF FF');
+            // the roundtrip issue can exist for long lengths that could
+            // compress to short lengths, this could be output as '02 02 01 23':
+            _add(b, '02 81 02 01 23');
+            // also an issue for indefinite length structures that will
+            // have a known length later:
+            _add(b, '30 80');
+            // a few INTEGERs
+            _add(b, '02 01 00');
+            _add(b, '02 01 01');
+            // done
+            _add(b, '00 00');
+            // other examples may exist
+          },
+          dump: false,
+          // NOTE: arbitrary data can be recompacted, check saved data worked
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringValue: 'sig'
+          },
+          captured: {
+            sig: _h2b(
+              '30 1E' +
+              '02 02 00 7F' +
+              '02 02 FF FF' +
+              '02 06 FF FF FF FF FF FF' +
+              '02 81 02 01 23' +
+              '30 80' +
+              '02 01 00' +
+              '02 01 01' +
+              '00 00')
+          }
+        });
+      });
+
+      it('should convert BIT STRING from strict DER', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data that includes encapsulated
+            // data.  include valid data that would only parse in strict
+            // mode.
+            _add(b, '03 06');
+            // no padding
+            _add(b, '00');
+            // sub-BIT STRING with valid length
+            _add(b, '03 03 00 01 02');
+          },
+          dump: false,
+          decodeBitStrings: true,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            // default capture value has structural data
+            // check contents and value
+            captureBitStringContents: 'bitsC',
+            captureBitStringValue: 'bitsV'
+          },
+          captured: {
+            bitsC: _h2b('00 03 03 00 01 02'),
+            bitsV: _h2b('03 03 00 01 02')
+          }
+        });
+      });
+      it('should convert BIT STRING from non-strict DER', function() {
+        _asn1Test({
+          init: function(b) {
+            // create crafted DER BIT STRING data that includes encapsulated
+            // data.  include invalid data that would only parse in non-strict
+            // mode.  ensure it is never parsed.
+            _add(b, '03 05');
+            // no padding
+            _add(b, '00');
+            // sub-BIT STRING with invalid length, missing a byte
+            _add(b, '03 03 00 01');
+          },
+          dump: false,
+          decodeBitStrings: true,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            // ensure default captures contents vs decoded structure
+            capture: 'bits0',
+            // check contents and value
+            captureBitStringContents: 'bitsC',
+            captureBitStringValue: 'bitsV'
+          },
+          captured: {
+            bits0: _h2b('00 03 03 00 01'),
+            bitsC: _h2b('00 03 03 00 01'),
+            bitsV: _h2b('03 03 00 01')
+          }
+        });
+      });
+
+      it('should convert indefinite length seq from BER', function() {
+        _asn1Test({
+          init: function(b) {
+            // SEQUENCE
+            _add(b, '30 80');
+            // a few INTEGERs
+            _add(b, '02 01 00');
+            _add(b, '02 01 01');
+            _add(b, '02 01 02');
+            // done
+            _add(b, '00 00');
+          },
+          dump: false,
+          // roundtrip will know the sequence length
+          roundtrip: false,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.SEQUENCE,
+            constructed: true,
+            value: [{
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.INTEGER,
+              constructed: false,
+              capture: 'int0'
+            }, {
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.INTEGER,
+              constructed: false,
+              capture: 'int1'
+            }, {
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.INTEGER,
+              constructed: false,
+              capture: 'int2'
+            }]
+          },
+          captured: {
+            int0: _h2b('00'),
+            int1: _h2b('01'),
+            int2: _h2b('02')
+          }
+        });
+      });
+
+      it('should handle ASN.1 mutations', function() {
+        _asn1Test({
+          init: function(b) {
+            // BIT STRING
+            _add(b, '03 09 00');
+            // SEQUENCE
+            _add(b, '30 06');
+            // a few INTEGERs
+            _add(b, '02 01 00');
+            _add(b, '02 01 01');
+          },
+          dump: false,
+          // roundtrip will know the sequence length
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BITSTRING,
+            constructed: false,
+            captureBitStringContents: 'bits',
+            value: [{
+              tagClass: ASN1.Class.UNIVERSAL,
+              type: ASN1.Type.SEQUENCE,
+              constructed: true,
+              value: [{
+                tagClass: ASN1.Class.UNIVERSAL,
+                type: ASN1.Type.INTEGER,
+                constructed: false,
+                capture: 'int0'
+              }, {
+                tagClass: ASN1.Class.UNIVERSAL,
+                type: ASN1.Type.INTEGER,
+                constructed: false,
+                capture: 'int1'
+              }]
+            }]
+          },
+          captured: {
+            bits: _h2b('00 30 06 02 01 00 02 01 01'),
+            int0: _h2b('00'),
+            int1: _h2b('01')
+          },
+          done: function(data) {
+            var asn1 = data.strict.asn1;
+            // mutate
+            asn1.value[0].value[0].value = _h2b('02');
+            asn1.value[0].value[1].value = _h2b('03');
+            // convert
+            // must use new data vs saved BIT STRING data
+            var der = ASN1.toDer(asn1);
+            var expect = _h2b('03 09 00 30 06 02 01 02 02 01 03');
+            // compare
+            ASSERT.equal(UTIL.bytesToHex(der), UTIL.bytesToHex(expect));
+          }
+        });
+      });
+
+      it('should convert BMP STRING from DER', function() {
+        _asn1Test({
+          init: function(b) {
+            // BPMSTRING
+            _add(b, '1e 08');
+            _add(b, '01 02 03 04 05 06 07 08');
+          },
+          dump: false,
+          roundtrip: true,
+          v: {
+            tagClass: ASN1.Class.UNIVERSAL,
+            type: ASN1.Type.BPMSTRING,
+            constructed: false,
+            capture: 'bits'
+          },
+          captured: {
+            bits: '\u0102\u0304\u0506\u0708'
+          }
+        });
+      });
+
+      // TODO: how minimal should INTEGERs be encoded?
+      // .. fromDer will create the full integer
+      // .. toDer will remove only first byte if possible
+      it('should minimally encode INTEGERs', function() {
+        function _test(hin, hout) {
+          var derIn = _h2b(hin);
+          var derOut = ASN1.toDer(ASN1.fromDer(derIn));
+          ASSERT.equal(
+            UTIL.bytesToHex(derOut),
+            UTIL.bytesToHex(_h2b(hout)));
+        }
+        // optimal
+        _test('02 01 01', '02 01 01');
+        _test('02 01 FF', '02 01 FF');
+        _test('02 02 00 FF', '02 02 00 FF');
+
+        // remove leading 00s before a 0b0xxxxxxx
+        _test('02 04 00 00 00 01', '02 03 00 00 01');
+        // this would be more optimal
+        //_test('02 04 00 00 00 01', '02 01 01');
+
+        // remove leading FFs before a 0b1xxxxxxx
+        _test('02 04 FF FF FF FF', '02 03 FF FF FF');
+        // this would be more optimal
+        //_test('02 04 FF FF FF FF', '02 01 FF');
+      });
+    })();
+  });
+})();