pariatursit
Version:
ASN.1 encoding and decoding
1,087 lines (1,068 loc) • 116 kB
JavaScript
var asn1 =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 5);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return ASN1Error; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return ASN1NotImplementedError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return ASN1RecursionError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return ASN1TruncationError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return ASN1OverflowError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return ASN1SizeError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return ASN1PaddingError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return ASN1UndefinedError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ASN1CharactersError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return ASN1ConstructionError; });
class ASN1Error extends Error {
constructor(m) {
super(m);
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1NotImplementedError extends ASN1Error {
constructor() {
super("Not yet implemented.");
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1RecursionError extends ASN1Error {
constructor() {
super("Recursion was too deep.");
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1TruncationError extends ASN1Error {
constructor(m) {
super(m);
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1OverflowError extends ASN1Error {
constructor(m) {
super(m);
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1SizeError extends ASN1Error {
constructor(m) {
super(m);
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1PaddingError extends ASN1Error {
constructor(m) {
super(m);
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1UndefinedError extends ASN1Error {
constructor(m) {
super(m);
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1CharactersError extends ASN1Error {
constructor(m) {
super(m);
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
class ASN1ConstructionError extends ASN1Error {
constructor(m) {
super(m);
Object.setPrototypeOf(this, ASN1Error.prototype);
}
}
/***/ }),
/* 1 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return MAX_UINT_32; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return MIN_UINT_32; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return MAX_SINT_32; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return MIN_SINT_32; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return ASN1TagClass; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ASN1Construction; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return LengthEncodingPreference; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return ASN1SpecialRealValue; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return ASN1UniversalType; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return printableStringCharacters; });
const MAX_UINT_32 = 0x00FFFFFFFF;
const MIN_UINT_32 = 0x0000000000;
const MAX_SINT_32 = 0x7FFFFFFF;
const MIN_SINT_32 = -0x7FFFFFFF;
var ASN1TagClass;
(function (ASN1TagClass) {
ASN1TagClass[ASN1TagClass["universal"] = 0] = "universal";
ASN1TagClass[ASN1TagClass["application"] = 1] = "application";
ASN1TagClass[ASN1TagClass["context"] = 3] = "context";
ASN1TagClass[ASN1TagClass["private"] = 4] = "private";
})(ASN1TagClass || (ASN1TagClass = {}));
var ASN1Construction;
(function (ASN1Construction) {
ASN1Construction[ASN1Construction["primitive"] = 0] = "primitive";
ASN1Construction[ASN1Construction["constructed"] = 1] = "constructed";
})(ASN1Construction || (ASN1Construction = {}));
var LengthEncodingPreference;
(function (LengthEncodingPreference) {
LengthEncodingPreference[LengthEncodingPreference["definite"] = 0] = "definite";
LengthEncodingPreference[LengthEncodingPreference["indefinite"] = 1] = "indefinite";
})(LengthEncodingPreference || (LengthEncodingPreference = {}));
var ASN1SpecialRealValue;
(function (ASN1SpecialRealValue) {
ASN1SpecialRealValue[ASN1SpecialRealValue["plusInfinity"] = 64] = "plusInfinity";
ASN1SpecialRealValue[ASN1SpecialRealValue["minusInfinity"] = 65] = "minusInfinity";
ASN1SpecialRealValue[ASN1SpecialRealValue["notANumber"] = 66] = "notANumber";
ASN1SpecialRealValue[ASN1SpecialRealValue["minusZero"] = 67] = "minusZero";
})(ASN1SpecialRealValue || (ASN1SpecialRealValue = {}));
var ASN1UniversalType;
(function (ASN1UniversalType) {
ASN1UniversalType[ASN1UniversalType["endOfContent"] = 0] = "endOfContent";
ASN1UniversalType[ASN1UniversalType["boolean"] = 1] = "boolean";
ASN1UniversalType[ASN1UniversalType["integer"] = 2] = "integer";
ASN1UniversalType[ASN1UniversalType["bitString"] = 3] = "bitString";
ASN1UniversalType[ASN1UniversalType["octetString"] = 4] = "octetString";
ASN1UniversalType[ASN1UniversalType["nill"] = 5] = "nill";
ASN1UniversalType[ASN1UniversalType["objectIdentifier"] = 6] = "objectIdentifier";
ASN1UniversalType[ASN1UniversalType["objectDescriptor"] = 7] = "objectDescriptor";
ASN1UniversalType[ASN1UniversalType["external"] = 8] = "external";
ASN1UniversalType[ASN1UniversalType["realNumber"] = 9] = "realNumber";
ASN1UniversalType[ASN1UniversalType["enumerated"] = 10] = "enumerated";
ASN1UniversalType[ASN1UniversalType["embeddedPDV"] = 11] = "embeddedPDV";
ASN1UniversalType[ASN1UniversalType["utf8String"] = 12] = "utf8String";
ASN1UniversalType[ASN1UniversalType["relativeOID"] = 13] = "relativeOID";
ASN1UniversalType[ASN1UniversalType["reserved14"] = 14] = "reserved14";
ASN1UniversalType[ASN1UniversalType["reserved15"] = 15] = "reserved15";
ASN1UniversalType[ASN1UniversalType["sequence"] = 16] = "sequence";
ASN1UniversalType[ASN1UniversalType["set"] = 17] = "set";
ASN1UniversalType[ASN1UniversalType["numericString"] = 18] = "numericString";
ASN1UniversalType[ASN1UniversalType["printableString"] = 19] = "printableString";
ASN1UniversalType[ASN1UniversalType["teletexString"] = 20] = "teletexString";
ASN1UniversalType[ASN1UniversalType["videotexString"] = 21] = "videotexString";
ASN1UniversalType[ASN1UniversalType["ia5String"] = 22] = "ia5String";
ASN1UniversalType[ASN1UniversalType["utcTime"] = 23] = "utcTime";
ASN1UniversalType[ASN1UniversalType["generalizedTime"] = 24] = "generalizedTime";
ASN1UniversalType[ASN1UniversalType["graphicString"] = 25] = "graphicString";
ASN1UniversalType[ASN1UniversalType["visibleString"] = 26] = "visibleString";
ASN1UniversalType[ASN1UniversalType["generalString"] = 27] = "generalString";
ASN1UniversalType[ASN1UniversalType["universalString"] = 28] = "universalString";
ASN1UniversalType[ASN1UniversalType["characterString"] = 29] = "characterString";
ASN1UniversalType[ASN1UniversalType["bmpString"] = 30] = "bmpString";
})(ASN1UniversalType || (ASN1UniversalType = {}));
const printableStringCharacters = "etaoinsrhdlucmfywgpbvkxqjzETAOINSRHDLUCMFYWGPBVKXQJZ0123456789 '()+,-./:=?";
/***/ }),
/* 2 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ObjectIdentifier; });
class ObjectIdentifier {
constructor(nodes) {
if (nodes.length < 2)
throw new Error("Cannot construct an OID with less than two nodes!");
if (nodes.length >= 1 && !(nodes[0] in [0, 1, 2]))
throw new Error("OIDs first node must be 0, 1, or 2!");
if (((nodes[0] == 0 || nodes[0] == 1) && nodes[2] > 39) ||
(nodes[0] == 2 && nodes[0] > 175))
throw new Error("OID Node #2 cannot exceed 39 if node #1 is 0 or 1, and 175 if node #1 is 2!");
nodes.forEach(node => {
if (node < 0)
throw new Error("OID node numbers cannot be negative!");
if (node > Number.MAX_SAFE_INTEGER)
throw new Error("OID number was too big!");
});
this._nodes = nodes.slice(0);
}
get nodes() {
return this._nodes.slice(0);
}
get dotDelimitedNotation() {
return this._nodes.join(".");
}
toString() {
return this.dotDelimitedNotation;
}
}
/***/ }),
/* 3 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ASN1Element; });
/* harmony import */ var _values__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
class ASN1Element {
constructor() {
this.recursionCount = 0;
this.tagClass = _values__WEBPACK_IMPORTED_MODULE_0__[/* ASN1TagClass */ "c"].universal;
this.construction = _values__WEBPACK_IMPORTED_MODULE_0__[/* ASN1Construction */ "a"].primitive;
this.tagNumber = 0;
this.value = new Uint8Array(0);
}
length() {
return this.value.length;
}
}
ASN1Element.nestingRecursionLimit = 5;
/***/ }),
/* 4 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(Buffer) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return BERElement; });
/* harmony import */ var _asn1__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
/* harmony import */ var _values__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1);
/* harmony import */ var _types_objectidentifier__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2);
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(0);
class BERElement extends _asn1__WEBPACK_IMPORTED_MODULE_0__[/* ASN1Element */ "a"] {
constructor(tagClass = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1TagClass */ "c"].universal, construction = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].primitive, tagNumber = 0) {
super();
this.tagClass = tagClass;
this.construction = construction;
this.tagNumber = tagNumber;
this.value = new Uint8Array(0);
}
set boolean(value) {
this.value = new Uint8Array(1);
this.value[0] = (value ? 255 : 0);
}
get boolean() {
if (this.value.length !== 1)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1SizeError */ "h"]("BER-encoded BOOLEAN not one byte");
return (this.value[0] !== 0);
}
set integer(value) {
if (value < _values__WEBPACK_IMPORTED_MODULE_1__[/* MIN_SINT_32 */ "h"])
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1OverflowError */ "e"](`Number ${value} too small to be converted.`);
if (value > _values__WEBPACK_IMPORTED_MODULE_1__[/* MAX_SINT_32 */ "f"])
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1OverflowError */ "e"](`Number ${value} too big to be converted.`);
if (value <= 127 && value >= -128) {
this.value = new Uint8Array([
(value & 255)
]);
return;
}
else if (value <= 32767 && value >= -32768) {
this.value = new Uint8Array([
(value >> 8 & 255),
(value & 255)
]);
return;
}
else if (value <= 8388607 && value >= -8388608) {
this.value = new Uint8Array([
((value >> 16) & 255),
(value >> 8 & 255),
(value & 255)
]);
return;
}
else {
this.value = new Uint8Array([
((value >> 24) & 255),
((value >> 16) & 255),
(value >> 8 & 255),
(value & 255)
]);
return;
}
}
get integer() {
if (this.value.length === 0)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1SizeError */ "h"]("Number encoded on zero bytes!");
if (this.value.length > 4)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1OverflowError */ "e"]("Number too long to decode.");
if (this.value.length > 2 &&
((this.value[0] === 0xFF && this.value[1] >= 0b10000000) ||
(this.value[0] === 0x00 && this.value[1] < 0b10000000)))
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1PaddingError */ "f"]("Unnecessary padding bytes on INTEGER or ENUMERATED.");
let ret = (this.value[0] >= 128 ? Number.MAX_SAFE_INTEGER : 0);
this.value.forEach(byte => {
ret <<= 8;
ret += byte;
});
return ret;
}
set bitString(value) {
if (value.length === 0)
this.value = new Uint8Array(0);
let pre = [];
pre.length = ((value.length >>> 3) + ((value.length % 8) ? 1 : 0)) + 1;
for (let i = 0; i < value.length; i++) {
if (value[i] === false)
continue;
pre[((i >>> 3) + 1)] |= (0b10000000 >>> (i % 8));
}
pre[0] = (8 - (value.length % 8));
if (pre[0] === 8)
pre[0] = 0;
this.value = new Uint8Array(pre);
}
get bitString() {
if (this.construction === _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].primitive) {
if (this.value.length === 0)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1Error */ "c"]("ASN.1 BIT STRING cannot be encoded on zero bytes!");
if (this.value.length === 1 && this.value[0] !== 0)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1Error */ "c"]("ASN.1 BIT STRING encoded with deceptive first byte!");
if (this.value[0] > 7)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1Error */ "c"]("First byte of an ASN.1 BIT STRING must be <= 7!");
let ret = [];
for (let i = 1; i < this.value.length; i++) {
ret = ret.concat([
(this.value[i] & 0b10000000 ? true : false),
(this.value[i] & 0b01000000 ? true : false),
(this.value[i] & 0b00100000 ? true : false),
(this.value[i] & 0b00010000 ? true : false),
(this.value[i] & 0b00001000 ? true : false),
(this.value[i] & 0b00000100 ? true : false),
(this.value[i] & 0b00000010 ? true : false),
(this.value[i] & 0b00000001 ? true : false)
]);
}
ret.length -= this.value[0];
return ret;
}
else {
try {
if (this.recursionCount++ === BERElement.nestingRecursionLimit)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1RecursionError */ "g"]();
let appendy = [];
const substrings = this.sequence;
if (substrings.length === 0)
return [];
substrings.slice(0, (substrings.length - 1)).forEach(substring => {
if (substring.construction === _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].primitive &&
substring.value.length > 0 &&
substring.value[0] !== 0x00)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1Error */ "c"]("This exception was thrown because you attempted to " +
"decode a constructed BIT STRING that contained a " +
"substring whose first byte indicated a non-zero " +
"number of padding bits, despite not being the " +
"last substring of the constructed BIT STRING. " +
"Only the last substring may have padding bits. ");
});
substrings.forEach(substring => {
if (substring.tagClass !== this.tagClass)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1ConstructionError */ "b"]("Invalid tag class in recursively-encoded BIT STRING.");
if (substring.tagNumber !== this.tagNumber)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1ConstructionError */ "b"]("Invalid tag number in recursively-encoded BIT STRING.");
appendy = appendy.concat(substring.bitString);
});
return appendy;
}
finally {
}
}
}
set octetString(value) {
this.value = value.subarray(0);
}
get octetString() {
return this.deconstruct("OCTET STRING");
}
set objectIdentifier(value) {
const numbers = value.nodes;
let pre = [((numbers[0] * 40) + numbers[1])];
if (numbers.length > 2) {
for (let i = 2; i < numbers.length; i++) {
let number = numbers[i];
if (number < 128) {
pre.push(number);
continue;
}
let encodedOIDNode = [];
while (number !== 0) {
let numberBytes = [
(number & 255),
(number >>> 8 & 255),
((number >>> 16) & 255),
((number >>> 24) & 255),
];
if ((numberBytes[0] & 0x80) === 0)
numberBytes[0] |= 0x80;
encodedOIDNode.unshift(numberBytes[0]);
number >>= 7;
}
encodedOIDNode[encodedOIDNode.length - 1] &= 0x7F;
pre = pre.concat(encodedOIDNode);
}
}
this.value = new Uint8Array(pre);
}
get objectIdentifier() {
if (this.construction !== _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].primitive)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1ConstructionError */ "b"]("Construction cannot be constructed for an OBJECT IDENTIFIER!");
if (this.value.length === 0)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1TruncationError */ "i"]("Encoded value was too short to be an OBJECT IDENTIFIER!");
let numbers = [0, 0];
if (this.value[0] >= 0x50) {
numbers[0] = 2;
numbers[1] = (this.value[0] - 0x50);
}
else if (this.value[0] >= 0x28) {
numbers[0] = 1;
numbers[1] = (this.value[0] - 0x28);
}
else {
numbers[0] = 0;
numbers[1] = this.value[0];
}
if (this.value.length === 1)
return new _types_objectidentifier__WEBPACK_IMPORTED_MODULE_2__[/* ObjectIdentifier */ "a"](numbers);
if ((this.value[(this.value.length - 1)] & 0x80) === 0x80)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1TruncationError */ "i"]("OID truncated");
let components = 2;
const allButTheFirstByte = this.value.slice(1);
allButTheFirstByte.forEach(b => {
if (!(b & 0x80))
components++;
});
numbers.length = components;
let currentNumber = 2;
let bytesUsedInCurrentNumber = 0;
allButTheFirstByte.forEach(b => {
if (bytesUsedInCurrentNumber === 0 && b === 0x80)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1PaddingError */ "f"]("OID had invalid padding byte.");
if (numbers[currentNumber] > (Number.MAX_SAFE_INTEGER >>> 7))
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1OverflowError */ "e"]("OID node too big");
numbers[currentNumber] <<= 7;
numbers[currentNumber] |= (b & 0x7F);
if (!(b & 0x80)) {
currentNumber++;
bytesUsedInCurrentNumber = 0;
}
else {
bytesUsedInCurrentNumber++;
}
});
return new _types_objectidentifier__WEBPACK_IMPORTED_MODULE_2__[/* ObjectIdentifier */ "a"](numbers);
}
set objectDescriptor(value) {
this.graphicString = value;
}
get objectDescriptor() {
return this.graphicString;
}
set real(value) {
if (value === 0.0) {
this.value = new Uint8Array(0);
}
else if (isNaN(value)) {
this.value = new Uint8Array([_values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1SpecialRealValue */ "b"].notANumber]);
}
else if (value === -0.0) {
this.value = new Uint8Array([_values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1SpecialRealValue */ "b"].minusZero]);
}
else if (value === Infinity) {
this.value = new Uint8Array([_values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1SpecialRealValue */ "b"].plusInfinity]);
}
else if (value === -Infinity) {
this.value = new Uint8Array([_values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1SpecialRealValue */ "b"].minusInfinity]);
}
let valueString = value.toFixed(7);
valueString = (String.fromCharCode(0b00000011) + valueString);
this.value = (new TextEncoder()).encode(valueString);
}
get real() {
if (this.value.length === 0)
return 0.0;
switch (this.value[0] & 0b11000000) {
case (0b01000000): {
if (this.value[0] === _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1SpecialRealValue */ "b"].notANumber)
return NaN;
if (this.value[0] === _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1SpecialRealValue */ "b"].minusZero)
return -0.0;
if (this.value[0] === _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1SpecialRealValue */ "b"].plusInfinity)
return Infinity;
if (this.value[0] === _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1SpecialRealValue */ "b"].minusInfinity)
return -Infinity;
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1UndefinedError */ "j"]("Unrecognized special REAL value!");
}
case (0b00000000): {
return parseFloat((new TextDecoder()).decode(this.value.slice(1)));
}
case (0b10000000):
case (0b11000000): {
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1NotImplementedError */ "d"]();
}
}
}
set enumerated(value) {
this.integer = value;
}
get enumerated() {
return this.integer;
}
set utf8String(value) {
if (typeof TextEncoder !== "undefined") {
this.value = (new TextEncoder()).encode(value);
}
else if (typeof Buffer !== "undefined") {
this.value = Buffer.from(value, "utf-8");
}
}
get utf8String() {
const valueBytes = this.deconstruct("UTF8String");
let ret = "";
if (typeof TextEncoder !== "undefined") {
ret = (new TextDecoder("utf-8")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
ret = (new Buffer(this.value)).toString("utf-8");
}
return ret;
}
set relativeObjectIdentifier(value) {
let numbers = value;
let pre = [];
if (numbers.length > 0) {
for (let i = 0; i < numbers.length; i++) {
let number = numbers[i];
if (number < 128) {
pre.push(number);
continue;
}
let encodedOIDNode = [];
while (number !== 0) {
let numberBytes = [
(number & 255),
(number >>> 8 & 255),
((number >>> 16) & 255),
((number >>> 24) & 255),
];
if ((numberBytes[0] & 0b10000000) === 0)
numberBytes[0] |= 0b10000000;
encodedOIDNode.unshift(numberBytes[0]);
number >>= 7;
}
encodedOIDNode[encodedOIDNode.length - 1] &= 0x7F;
pre = pre.concat(encodedOIDNode);
}
}
this.value = new Uint8Array(pre);
}
get relativeObjectIdentifier() {
if (this.construction !== _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].primitive)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1ConstructionError */ "b"]("Construction cannot be constructed for an Relative OID!");
let numbers = [];
if (this.value.length === 1)
return numbers;
if ((this.value[(this.value.length - 1)] & 0b10000000) === 0b10000000)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1TruncationError */ "i"]("Relative OID truncated");
let components = 0;
this.value.forEach(b => {
if (!(b & 0b10000000))
components++;
});
numbers.length = components;
let currentNumber = 0;
let bytesUsedInCurrentNumber = 0;
this.value.forEach(b => {
if (bytesUsedInCurrentNumber === 0 && b === 0b10000000)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1PaddingError */ "f"]("Relative OID had invalid padding byte.");
if (numbers[currentNumber] > (Number.MAX_SAFE_INTEGER >>> 7))
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1OverflowError */ "e"]("Relative OID node too big");
numbers[currentNumber] <<= 7;
numbers[currentNumber] |= (b & 0x7F);
if (!(b & 0b10000000)) {
currentNumber++;
bytesUsedInCurrentNumber = 0;
}
else {
bytesUsedInCurrentNumber++;
}
});
return numbers;
}
set sequence(value) {
let encodedElements = [];
value.forEach(element => {
encodedElements.push(element.toBytes());
});
let totalLength = 0;
encodedElements.forEach(element => {
totalLength += element.length;
});
const newValue = new Uint8Array(totalLength);
let currentIndex = 0;
encodedElements.forEach(element => {
newValue.set(element, currentIndex);
currentIndex += element.length;
});
this.value = newValue;
this.construction = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].constructed;
}
get sequence() {
let encodedElements = [];
if (this.value.length === 0)
return [];
let i = 0;
while (i < this.value.length) {
const next = new BERElement();
i += next.fromBytes(this.value.slice(i));
encodedElements.push(next);
}
return encodedElements;
}
set set(value) {
let encodedElements = [];
value.forEach(element => {
encodedElements.push(element.toBytes());
});
let totalLength = 0;
encodedElements.forEach(element => {
totalLength += element.length;
});
const newValue = new Uint8Array(totalLength);
let currentIndex = 0;
encodedElements.forEach(element => {
newValue.set(element, currentIndex);
currentIndex += element.length;
});
this.value = newValue;
this.construction = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].constructed;
}
get set() {
let encodedElements = [];
if (this.value.length === 0)
return [];
let i = 0;
while (i < this.value.length) {
const next = new BERElement();
i += next.fromBytes(this.value.slice(i));
encodedElements.push(next);
}
return encodedElements;
}
set numericString(value) {
for (let i = 0; i < value.length; i++) {
const characterCode = value.charCodeAt(i);
if (!((characterCode >= 0x30 && characterCode <= 0x39) || characterCode === 0x20)) {
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1CharactersError */ "a"]("NumericString can only contain characters 0 - 9 and space.");
}
}
if (typeof TextEncoder !== "undefined") {
this.value = (new TextEncoder()).encode(value);
}
else if (typeof Buffer !== "undefined") {
this.value = Buffer.from(value, "utf-8");
}
}
get numericString() {
const valueBytes = this.deconstruct("NumericString");
let ret = "";
if (typeof TextEncoder !== "undefined") {
ret = (new TextDecoder("utf-8")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
ret = (new Buffer(this.value)).toString("utf-8");
}
for (let i = 0; i < ret.length; i++) {
const characterCode = ret.charCodeAt(i);
if (!((characterCode >= 0x30 && characterCode <= 0x39) || characterCode === 0x20)) {
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1CharactersError */ "a"]("NumericString can only contain characters 0 - 9 and space.");
}
}
return ret;
}
set printableString(value) {
for (let i = 0; i < value.length; i++) {
if (_values__WEBPACK_IMPORTED_MODULE_1__[/* printableStringCharacters */ "j"].indexOf(value.charAt(i)) === -1) {
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1CharactersError */ "a"](`PrintableString can only contain these characters: ${_values__WEBPACK_IMPORTED_MODULE_1__[/* printableStringCharacters */ "j"]}`);
}
}
if (typeof TextEncoder !== "undefined") {
this.value = (new TextEncoder()).encode(value);
}
else if (typeof Buffer !== "undefined") {
this.value = Buffer.from(value, "utf-8");
}
}
get printableString() {
const valueBytes = this.deconstruct("PrintableString");
let ret = "";
if (typeof TextEncoder !== "undefined") {
ret = (new TextDecoder("utf-8")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
ret = (new Buffer(this.value)).toString("utf-8");
}
for (let i = 0; i < ret.length; i++) {
if (_values__WEBPACK_IMPORTED_MODULE_1__[/* printableStringCharacters */ "j"].indexOf(ret.charAt(i)) === -1) {
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1CharactersError */ "a"](`PrintableString can only contain these characters: ${_values__WEBPACK_IMPORTED_MODULE_1__[/* printableStringCharacters */ "j"]}`);
}
}
return ret;
}
set teletexString(value) {
this.value = value.subarray(0);
}
get teletexString() {
return this.deconstruct("TeletexString");
}
set videotexString(value) {
this.value = value.subarray(0);
}
get videotexString() {
return this.deconstruct("VideotexString");
}
set ia5String(value) {
if (typeof TextEncoder !== "undefined") {
this.value = (new TextEncoder()).encode(value);
}
else if (typeof Buffer !== "undefined") {
this.value = Buffer.from(value, "utf-8");
}
}
get ia5String() {
const valueBytes = this.deconstruct("IA5String");
let ret = "";
if (typeof TextEncoder !== "undefined") {
ret = (new TextDecoder("utf-8")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
ret = (new Buffer(this.value)).toString("utf-8");
}
return ret;
}
set utcTime(value) {
let year = value.getUTCFullYear().toString();
year = (year.substring(year.length - 2, year.length));
const month = (value.getUTCMonth() < 10 ? `0${value.getUTCMonth()}` : `${value.getUTCMonth()}`);
const day = (value.getUTCDate() < 10 ? `0${value.getUTCDate()}` : `${value.getUTCDate()}`);
const hour = (value.getUTCHours() < 10 ? `0${value.getUTCHours()}` : `${value.getUTCHours()}`);
const minute = (value.getUTCMinutes() < 10 ? `0${value.getUTCMinutes()}` : `${value.getUTCMinutes()}`);
const second = (value.getUTCSeconds() < 10 ? `0${value.getUTCSeconds()}` : `${value.getUTCSeconds()}`);
const utcString = `${year}${month}${day}${hour}${minute}${second}Z`;
if (typeof TextEncoder !== "undefined") {
this.value = (new TextEncoder()).encode(utcString);
}
else if (typeof Buffer !== "undefined") {
this.value = Buffer.from(utcString, "utf-8");
}
}
get utcTime() {
const valueBytes = this.deconstruct("UTCTime");
let dateString = "";
if (typeof TextEncoder !== "undefined") {
dateString = (new TextDecoder("utf-8")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
dateString = (new Buffer(this.value)).toString("utf-8");
}
if (dateString.length !== 13 || !(/\d{12}Z/.test(dateString)))
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1Error */ "c"]("Malformed UTCTime string.");
const ret = new Date();
const year = Number(dateString.substring(0, 2));
ret.setUTCFullYear(year < 70 ? (2000 + year) : (1900 + year));
ret.setUTCMonth(Number(dateString.substring(2, 4)));
ret.setUTCDate(Number(dateString.substring(4, 6)));
ret.setUTCHours(Number(dateString.substring(6, 8)));
ret.setUTCMinutes(Number(dateString.substring(8, 10)));
ret.setUTCSeconds(Number(dateString.substring(10, 12)));
return ret;
}
set generalizedTime(value) {
const year = value.getUTCFullYear().toString();
const month = (value.getUTCMonth() < 10 ? `0${value.getUTCMonth()}` : `${value.getUTCMonth()}`);
const day = (value.getUTCDate() < 10 ? `0${value.getUTCDate()}` : `${value.getUTCDate()}`);
const hour = (value.getUTCHours() < 10 ? `0${value.getUTCHours()}` : `${value.getUTCHours()}`);
const minute = (value.getUTCMinutes() < 10 ? `0${value.getUTCMinutes()}` : `${value.getUTCMinutes()}`);
const second = (value.getUTCSeconds() < 10 ? `0${value.getUTCSeconds()}` : `${value.getUTCSeconds()}`);
const timeString = `${year}${month}${day}${hour}${minute}${second}Z`;
if (typeof TextEncoder !== "undefined") {
this.value = (new TextEncoder()).encode(timeString);
}
else if (typeof Buffer !== "undefined") {
this.value = Buffer.from(timeString, "utf-8");
}
}
get generalizedTime() {
const valueBytes = this.deconstruct("GeneralizedTime");
let dateString = "";
if (typeof TextEncoder !== "undefined") {
dateString = (new TextDecoder("utf-8")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
dateString = (new Buffer(this.value)).toString("utf-8");
}
if (dateString.length < 13 || !(/\d{14}(?:\.\d+)?Z/.test(dateString)))
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1Error */ "c"]("Malformed GeneralizedTime string.");
const ret = new Date();
ret.setUTCFullYear(Number(dateString.substring(0, 4)));
ret.setUTCMonth(Number(dateString.substring(4, 6)));
ret.setUTCDate(Number(dateString.substring(6, 8)));
ret.setUTCHours(Number(dateString.substring(8, 10)));
ret.setUTCMinutes(Number(dateString.substring(10, 12)));
ret.setUTCSeconds(Number(dateString.substring(12, 14)));
return ret;
}
set graphicString(value) {
for (let i = 0; i < value.length; i++) {
const characterCode = value.charCodeAt(i);
if (characterCode < 0x20 || characterCode > 0x7E)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1CharactersError */ "a"]("GraphicString, VisibleString, or ObjectDescriptor " +
"can only contain characters between 0x20 and 0x7E.");
}
if (typeof TextEncoder !== "undefined") {
this.value = (new TextEncoder()).encode(value);
}
else if (typeof Buffer !== "undefined") {
this.value = Buffer.from(value, "utf-8");
}
}
get graphicString() {
const valueBytes = this.deconstruct("GraphicString, VisibleString, or ObjectDescriptor");
let ret = "";
if (typeof TextEncoder !== "undefined") {
ret = (new TextDecoder("utf-8")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
ret = (new Buffer(this.value)).toString("utf-8");
}
for (let i = 0; i < ret.length; i++) {
const characterCode = ret.charCodeAt(i);
if (characterCode < 0x20 || characterCode > 0x7E) {
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1CharactersError */ "a"]("GraphicString, VisibleString, or ObjectDescriptor " +
"can only contain characters between 0x20 and 0x7E.");
}
}
return ret;
}
set visibleString(value) {
this.graphicString = value;
}
get visibleString() {
return this.graphicString;
}
set generalString(value) {
for (let i = 0; i < value.length; i++) {
if (value.charCodeAt(i) > 0x7F)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1CharactersError */ "a"]("GeneralString can only contain ASCII characters.");
}
if (typeof TextEncoder !== "undefined") {
this.value = (new TextEncoder()).encode(value);
}
else if (typeof Buffer !== "undefined") {
this.value = Buffer.from(value, "ascii");
}
}
get generalString() {
const valueBytes = this.deconstruct("GeneralString");
let ret = "";
if (typeof TextEncoder !== "undefined") {
ret = (new TextDecoder("windows-1252")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
ret = (new Buffer(this.value)).toString("ascii");
}
for (let i = 0; i < ret.length; i++) {
if (ret.charCodeAt(i) > 0x7F)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1CharactersError */ "a"]("GeneralString can only contain ASCII characters.");
}
return ret;
}
set universalString(value) {
const buf = new Uint8Array(value.length << 2);
for (let i = 0; i < value.length; i++) {
buf[(i << 2)] = value.charCodeAt(i) >>> 24;
buf[(i << 2) + 1] = value.charCodeAt(i) >>> 16;
buf[(i << 2) + 2] = value.charCodeAt(i) >>> 8;
buf[(i << 2) + 3] = value.charCodeAt(i);
}
this.value = buf;
}
get universalString() {
const valueBytes = this.deconstruct("UniversalString");
if (valueBytes.length % 4)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1Error */ "c"]("UniversalString encoded on non-mulitple of four bytes.");
let ret = "";
for (let i = 0; i < valueBytes.length; i += 4) {
ret += String.fromCharCode((valueBytes[i + 0] << 24) +
(valueBytes[i + 1] << 16) +
(valueBytes[i + 2] << 8) +
(valueBytes[i + 3] << 0));
}
return ret;
}
set bmpString(value) {
const buf = new Uint8Array(value.length << 1);
for (let i = 0, strLen = value.length; i < strLen; i++) {
buf[(i << 1)] = value.charCodeAt(i) >>> 8;
buf[(i << 1) + 1] = value.charCodeAt(i);
}
this.value = buf;
}
get bmpString() {
const valueBytes = this.deconstruct("BMPString");
if (valueBytes.length % 2)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1Error */ "c"]("BMPString encoded on non-mulitple of two bytes.");
let ret = "";
if (typeof TextEncoder !== "undefined") {
ret = (new TextDecoder("utf-16be")).decode(valueBytes.buffer);
}
else if (typeof Buffer !== "undefined") {
const swappedEndianness = new Uint8Array(valueBytes.length);
for (let i = 0; i < valueBytes.length; i += 2) {
swappedEndianness[i] = valueBytes[i + 1];
swappedEndianness[i + 1] = valueBytes[i];
}
ret = (new Buffer(swappedEndianness)).toString("utf-16le");
}
return ret;
}
fromBytes(bytes) {
if (bytes.length < 2)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1TruncationError */ "i"]("Tried to decode a BER element that is less than two bytes.");
if ((this.recursionCount + 1) > BERElement.nestingRecursionLimit)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1RecursionError */ "g"]();
let cursor = 0;
switch (bytes[cursor] & 0b11000000) {
case (0b00000000):
this.tagClass = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1TagClass */ "c"].universal;
break;
case (0b01000000):
this.tagClass = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1TagClass */ "c"].application;
break;
case (0b10000000):
this.tagClass = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1TagClass */ "c"].context;
break;
case (0b11000000):
this.tagClass = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1TagClass */ "c"].private;
break;
default: this.tagClass = _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1TagClass */ "c"].universal;
}
this.construction = ((bytes[cursor] & 0b00100000) ?
_values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].constructed : _values__WEBPACK_IMPORTED_MODULE_1__[/* ASN1Construction */ "a"].primitive);
this.tagNumber = (bytes[cursor] & 0b00011111);
cursor++;
if (this.tagNumber >= 31) {
if (bytes[cursor] === 0b10000000)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1PaddingError */ "f"]("Leading padding byte on long tag number encoding.");
this.tagNumber = 0;
const limit = (((bytes.length - 1) >= 4) ? 4 : (bytes.length - 1));
while (cursor < limit) {
if (!(bytes[cursor++] & 0b10000000))
break;
}
if (bytes[cursor - 1] & 0b10000000) {
if (limit === bytes.length - 1) {
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1TruncationError */ "i"]("ASN.1 tag number appears to have been truncated.");
}
else
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1OverflowError */ "e"]("ASN.1 tag number too large.");
}
for (let i = 1; i < cursor; i++) {
this.tagNumber <<= 7;
this.tagNumber |= (bytes[i] & 0x7F);
}
}
if ((bytes[cursor] & 0b10000000) === 0b10000000) {
const numberOfLengthOctets = (bytes[cursor] & 0x7F);
if (numberOfLengthOctets) {
if (numberOfLengthOctets === 0b01111111)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1UndefinedError */ "j"]("Length byte with undefined meaning encountered.");
if (numberOfLengthOctets > 4)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1OverflowError */ "e"]("Element length too long to decode to an integer.");
if (cursor + numberOfLengthOctets >= bytes.length)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1TruncationError */ "i"]("Element length bytes appear to have been truncated.");
cursor++;
const lengthNumberOctets = new Uint8Array(4);
for (let i = numberOfLengthOctets; i > 0; i--) {
lengthNumberOctets[(4 - i)] = bytes[(cursor + numberOfLengthOctets - i)];
}
let length = 0;
lengthNumberOctets.forEach(octet => {
length <<= 8;
length += octet;
});
if ((cursor + length) < cursor)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1OverflowError */ "e"]("ASN.1 element too large.");
cursor += (numberOfLengthOctets);
if ((cursor + length) > bytes.length)
throw new _errors__WEBPACK_IMPORTED_MODULE_3__[/* ASN1TruncationError */ "i"]("ASN.1 element truncated.");
this.value = bytes.slice(cursor, (cursor + length));
return (cursor + length);
}