node-opcua-crypto 4.16.0 → 4.17.0

package/dist/source_nodejs/index.js

@@ -47,31 +47,24 @@ __export(source_nodejs_exports, {
 });
 module.exports = __toCommonJS(source_nodejs_exports);
 
-// source_nodejs/read.ts
-var import_assert5 = __toESM(require("assert"));
+// source_nodejs/generate_private_key_filename.ts
 var import_node_fs = __toESM(require("fs"));
-var import_node_path = __toESM(require("path"));
-var import_crypto = require("crypto");
-
-// source/crypto_utils.ts
-var import_constants = __toESM(require("constants"));
-var import_assert4 = __toESM(require("assert"));
-var import_hexy = __toESM(require("hexy"));
+var import_jsrsasign3 = __toESM(require("jsrsasign"));
 
-// source/buffer_utils.ts
-var createFastUninitializedBuffer = Buffer.allocUnsafe ? Buffer.allocUnsafe : (size) => {
-  return new Buffer(size);
-};
+// source/common.ts
+var import_node_crypto = __toESM(require("crypto"));
+var KeyObjectOrig = import_node_crypto.default.KeyObject;
+var { createPrivateKey: createPrivateKeyFromNodeJSCrypto } = import_node_crypto.default;
 
 // source/crypto_explore_certificate.ts
-var import_assert3 = __toESM(require("assert"));
+var import_node_assert4 = __toESM(require("assert"));
 
 // source/asn1.ts
-var import_assert = __toESM(require("assert"));
+var import_node_assert = __toESM(require("assert"));
 function readTag(buf, pos) {
   const start = pos;
   if (buf.length <= pos) {
-    throw new Error("Invalid position : buf.length=" + buf.length + " pos =" + pos);
+    throw new Error(`Invalid position : buf.length=${buf.length} pos=${pos}`);
   }
   const tag = buf.readUInt8(pos);
   pos += 1;
@@ -88,38 +81,18 @@ function readTag(buf, pos) {
   return { start, tag, position: pos, length };
 }
 
-// source/directory_name.ts
-var import_assert2 = __toESM(require("assert"));
+// source/crypto_utils.ts
+var import_node_assert2 = __toESM(require("assert"));
+var import_node_constants = __toESM(require("constants"));
+var import_node_crypto2 = require("crypto");
+var import_jsrsasign = __toESM(require("jsrsasign"));
 
-// source/crypto_explore_certificate.ts
-function split_der(certificateChain) {
-  const certificate_chain = [];
-  do {
-    const block_info = readTag(certificateChain, 0);
-    const length = block_info.position + block_info.length;
-    const der_certificate = certificateChain.subarray(0, length);
-    certificate_chain.push(der_certificate);
-    certificateChain = certificateChain.subarray(length);
-  } while (certificateChain.length > 0);
-  return certificate_chain;
-}
-function combine_der(certificates) {
-  for (const cert of certificates) {
-    const b = split_der(cert);
-    let sum = 0;
-    b.forEach((block) => {
-      const block_info = readTag(block, 0);
-      (0, import_assert3.default)(block_info.position + block_info.length === block.length);
-      sum += block.length;
-    });
-    (0, import_assert3.default)(sum === cert.length);
-  }
-  return Buffer.concat(certificates);
-}
+// source/buffer_utils.ts
+var createFastUninitializedBuffer = Buffer.allocUnsafe ? Buffer.allocUnsafe : (size) => {
+  return new Buffer(size);
+};
 
 // source/crypto_utils.ts
-var import_jsrsasign = __toESM(require("jsrsasign"));
-var { hexy } = import_hexy.default;
 var PEM_REGEX = /^(-----BEGIN (.*)-----\r?\n([/+=a-zA-Z0-9\r\n]*)\r?\n-----END \2-----\r?\n?)/gm;
 var PEM_TYPE_REGEX = /^(-----BEGIN (.*)-----)/m;
 function identifyPemType(rawKey) {
@@ -134,192 +107,103 @@ function removeTrailingLF(str) {
   return tmp;
 }
 function toPem(raw_key, pem) {
-  (0, import_assert4.default)(raw_key, "expecting a key");
-  (0, import_assert4.default)(typeof pem === "string");
+  (0, import_node_assert2.default)(raw_key, "expecting a key");
+  (0, import_node_assert2.default)(typeof pem === "string");
   let pemType = identifyPemType(raw_key);
   if (pemType) {
     return Buffer.isBuffer(raw_key) ? removeTrailingLF(raw_key.toString("utf8")) : removeTrailingLF(raw_key);
   } else {
     pemType = pem;
-    (0, import_assert4.default)(["CERTIFICATE REQUEST", "CERTIFICATE", "RSA PRIVATE KEY", "PUBLIC KEY", "X509 CRL"].indexOf(pemType) >= 0);
+    (0, import_node_assert2.default)(["CERTIFICATE REQUEST", "CERTIFICATE", "RSA PRIVATE KEY", "PUBLIC KEY", "X509 CRL"].indexOf(pemType) >= 0);
     let b = raw_key.toString("base64");
-    let str = "-----BEGIN " + pemType + "-----\n";
+    let str = `-----BEGIN ${pemType}-----
+`;
     while (b.length) {
-      str += b.substring(0, 64) + "\n";
+      str += `${b.substring(0, 64)}
+`;
       b = b.substring(64);
     }
-    str += "-----END " + pemType + "-----";
+    str += `-----END ${pemType}-----`;
     return str;
   }
 }
 function convertPEMtoDER(raw_key) {
   let match;
-  let pemType;
+  let _pemType;
   let base64str;
   const parts = [];
   PEM_REGEX.lastIndex = 0;
-  while ((match = PEM_REGEX.exec(raw_key)) !== null) {
-    pemType = match[2];
+  match = PEM_REGEX.exec(raw_key);
+  while (match !== null) {
+    _pemType = match[2];
     base64str = match[3];
     base64str = base64str.replace(/\r?\n/g, "");
     parts.push(Buffer.from(base64str, "base64"));
+    match = PEM_REGEX.exec(raw_key);
   }
   return combine_der(parts);
 }
-var RSA_PKCS1_OAEP_PADDING = import_constants.default.RSA_PKCS1_OAEP_PADDING;
-var RSA_PKCS1_PADDING = import_constants.default.RSA_PKCS1_PADDING;
-(0, import_assert4.default)(4 /* RSA_PKCS1_OAEP_PADDING */ === import_constants.default.RSA_PKCS1_OAEP_PADDING);
-(0, import_assert4.default)(1 /* RSA_PKCS1_PADDING */ === import_constants.default.RSA_PKCS1_PADDING);
+var RSA_PKCS1_OAEP_PADDING = import_node_constants.default.RSA_PKCS1_OAEP_PADDING;
+var RSA_PKCS1_PADDING = import_node_constants.default.RSA_PKCS1_PADDING;
+(0, import_node_assert2.default)(4 /* RSA_PKCS1_OAEP_PADDING */ === import_node_constants.default.RSA_PKCS1_OAEP_PADDING);
+(0, import_node_assert2.default)(1 /* RSA_PKCS1_PADDING */ === import_node_constants.default.RSA_PKCS1_PADDING);
 
-// source_nodejs/read.ts
-var import_sshpk = __toESM(require("sshpk"));
-function _readPemFile(filename) {
-  (0, import_assert5.default)(typeof filename === "string");
-  return removeTrailingLF(import_node_fs.default.readFileSync(filename, "utf-8"));
-}
-function _readPemOrDerFileAsDER(filename) {
-  if (filename.match(/.*\.der/)) {
-    return import_node_fs.default.readFileSync(filename);
-  }
-  const raw_key = _readPemFile(filename);
-  return convertPEMtoDER(raw_key);
-}
-function readCertificate(filename) {
-  return _readPemOrDerFileAsDER(filename);
-}
-function readPublicKey(filename) {
-  if (filename.match(/.*\.der/)) {
-    const der = import_node_fs.default.readFileSync(filename);
-    return (0, import_crypto.createPublicKey)(der);
-  } else {
-    const raw_key = _readPemFile(filename);
-    return (0, import_crypto.createPublicKey)(raw_key);
-  }
-}
-function myCreatePrivateKey(rawKey) {
-  if (!import_crypto.createPrivateKey || process.env.NO_CREATE_PRIVATEKEY) {
-    if (Buffer.isBuffer(rawKey)) {
-      const pemKey = toPem(rawKey, "PRIVATE KEY");
-      (0, import_assert5.default)(["RSA PRIVATE KEY", "PRIVATE KEY"].indexOf(identifyPemType(pemKey)) >= 0);
-      return { hidden: pemKey };
-    }
-    return { hidden: ensureTrailingLF(rawKey) };
-  }
-  const backup = process.env.OPENSSL_CONF;
-  process.env.OPENSSL_CONF = "/dev/null";
-  const retValue = (0, import_crypto.createPrivateKey)(rawKey);
-  process.env.OPENSSL_CONF = backup;
-  return { hidden: retValue };
-}
-function ensureTrailingLF(str) {
-  return str.match(/\n$/) ? str : str + "\n";
-}
-function readPrivateKey(filename) {
-  if (filename.match(/.*\.der/)) {
-    const der = import_node_fs.default.readFileSync(filename);
-    return myCreatePrivateKey(der);
-  } else {
-    const raw_key = _readPemFile(filename);
-    return myCreatePrivateKey(raw_key);
-  }
-}
-function readCertificatePEM(filename) {
-  return _readPemFile(filename);
-}
-function readPublicKeyPEM(filename) {
-  return _readPemFile(filename);
-}
-function readPrivateKeyPEM(filename) {
-  return _readPemFile(filename);
-}
-var _g_certificate_store = "";
-function setCertificateStore(store) {
-  const old_store = _g_certificate_store;
-  _g_certificate_store = store;
-  return old_store;
-}
-function getCertificateStore() {
-  if (!_g_certificate_store) {
-    _g_certificate_store = import_node_path.default.join(__dirname, "../../certificates/");
-  }
-  return _g_certificate_store;
-}
-function readPrivateRsaKey(filename) {
-  if (!import_crypto.createPrivateKey) {
-    throw new Error("createPrivateKey is not supported in this environment");
-  }
-  if (filename.substring(0, 1) !== "." && !import_node_fs.default.existsSync(filename)) {
-    filename = import_node_path.default.join(getCertificateStore(), filename);
-  }
-  const content = import_node_fs.default.readFileSync(filename, "utf8");
-  const sshKey = import_sshpk.default.parsePrivateKey(content, "auto");
-  const key = sshKey.toString("pkcs1");
-  const hidden = (0, import_crypto.createPrivateKey)({ format: "pem", type: "pkcs1", key });
-  return { hidden };
-}
-function readPublicRsaKey(filename) {
-  if (filename.substring(0, 1) !== "." && !import_node_fs.default.existsSync(filename)) {
-    filename = import_node_path.default.join(getCertificateStore(), filename);
-  }
-  const content = import_node_fs.default.readFileSync(filename, "utf-8");
-  const sshKey = import_sshpk.default.parseKey(content, "ssh");
-  const key = sshKey.toString("pkcs1");
-  return (0, import_crypto.createPublicKey)({ format: "pem", type: "pkcs1", key });
-}
+// source/directory_name.ts
+var import_node_assert3 = __toESM(require("assert"));
 
-// source_nodejs/read_certificate_revocation_list.ts
-var import_node_fs2 = __toESM(require("fs"));
-async function readCertificateRevocationList(filename) {
-  const crl = await import_node_fs2.default.promises.readFile(filename);
-  if (crl[0] === 48 && crl[1] === 130) {
-    return crl;
-  }
-  const raw_crl = crl.toString();
-  return convertPEMtoDER(raw_crl);
+// source/crypto_explore_certificate.ts
+function split_der(certificateChain) {
+  const certificate_chain = [];
+  do {
+    const block_info = readTag(certificateChain, 0);
+    const length = block_info.position + block_info.length;
+    const der_certificate = certificateChain.subarray(0, length);
+    certificate_chain.push(der_certificate);
+    certificateChain = certificateChain.subarray(length);
+  } while (certificateChain.length > 0);
+  return certificate_chain;
 }
-
-// source_nodejs/read_certificate_signing_request.ts
-var import_node_fs3 = __toESM(require("fs"));
-async function readCertificateSigningRequest(filename) {
-  const csr = await import_node_fs3.default.promises.readFile(filename);
-  if (csr[0] === 48 && csr[1] === 130) {
-    return csr;
+function combine_der(certificates) {
+  for (const cert of certificates) {
+    const b = split_der(cert);
+    let sum = 0;
+    b.forEach((block) => {
+      const block_info = readTag(block, 0);
+      (0, import_node_assert4.default)(block_info.position + block_info.length === block.length);
+      sum += block.length;
+    });
+    (0, import_node_assert4.default)(sum === cert.length);
   }
-  const raw_crl = csr.toString();
-  return convertPEMtoDER(raw_crl);
+  return Buffer.concat(certificates);
 }
 
-// source_nodejs/generate_private_key_filename.ts
-var import_node_fs4 = __toESM(require("fs"));
-
-// source/explore_private_key.ts
-var doDebug = !!process.env.DEBUG;
-
-// source/common.ts
-var import_crypto2 = __toESM(require("crypto"));
-var KeyObjectOrig = import_crypto2.default.KeyObject;
-var { createPrivateKey: createPrivateKeyFromNodeJSCrypto } = import_crypto2.default;
-
 // source/crypto_utils2.ts
-var import_assert6 = __toESM(require("assert"));
+var import_node_assert5 = __toESM(require("assert"));
 var import_jsrsasign2 = __toESM(require("jsrsasign"));
 
 // source/derived_keys.ts
-var import_assert8 = __toESM(require("assert"));
+var import_node_assert7 = __toESM(require("assert"));
+var import_node_crypto3 = require("crypto");
 
 // source/explore_certificate.ts
-var import_assert7 = __toESM(require("assert"));
+var import_node_assert6 = __toESM(require("assert"));
+
+// source/explore_private_key.ts
+var doDebug = !!process.env.DEBUG;
+
+// source/verify_certificate_signature.ts
+var import_node_crypto4 = require("crypto");
 
 // source/x509/_crypto.ts
-var x509 = __toESM(require("@peculiar/x509"));
+var import_node_crypto5 = __toESM(require("crypto"));
 var import_webcrypto = require("@peculiar/webcrypto");
-var import_crypto3 = __toESM(require("crypto"));
+var x509 = __toESM(require("@peculiar/x509"));
 var x5092 = __toESM(require("@peculiar/x509"));
 var doDebug2 = false;
 var _crypto;
 var ignoreCrypto = process.env.IGNORE_SUBTLE_FROM_CRYPTO;
 if (typeof window === "undefined") {
-  _crypto = import_crypto3.default;
+  _crypto = import_node_crypto5.default;
   if (!_crypto?.subtle || ignoreCrypto) {
     _crypto = new import_webcrypto.Crypto();
     doDebug2 && console.warn("using @peculiar/webcrypto");
@@ -333,7 +217,7 @@ if (typeof window === "undefined") {
   x509.cryptoProvider.set(crypto);
 }
 function getCrypto() {
-  return _crypto || crypto || require("crypto");
+  return _crypto || crypto || import_node_crypto5.default;
 }
 
 // source/x509/create_key_pair.ts
@@ -494,7 +378,7 @@ var BufferSourceConverter = class _BufferSourceConverter {
   }
 };
 var STRING_TYPE = "string";
-var HEX_REGEX = /^[0-9a-f]+$/i;
+var HEX_REGEX = /^[0-9a-f\s]+$/i;
 var BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
 var BASE64URL_REGEX = /^[a-zA-Z0-9-_]+$/;
 var Utf8Converter = class {
@@ -942,19 +826,19 @@ var BIT_STRING_NAME = "BIT STRING";
 function HexBlock(BaseClass) {
   var _a2;
   return _a2 = class Some extends BaseClass {
-    constructor(...args) {
-      var _a3;
-      super(...args);
-      const params = args[0] || {};
-      this.isHexOnly = (_a3 = params.isHexOnly) !== null && _a3 !== void 0 ? _a3 : false;
-      this.valueHexView = params.valueHex ? BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
-    }
     get valueHex() {
       return this.valueHexView.slice().buffer;
     }
     set valueHex(value) {
       this.valueHexView = new Uint8Array(value);
     }
+    constructor(...args) {
+      var _b;
+      super(...args);
+      const params = args[0] || {};
+      this.isHexOnly = (_b = params.isHexOnly) !== null && _b !== void 0 ? _b : false;
+      this.valueHexView = params.valueHex ? BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
+    }
     fromBER(inputBuffer, inputOffset, inputLength) {
       const view = inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer;
       if (!checkBufferParams(this, view, inputOffset, inputLength)) {
@@ -989,12 +873,6 @@ function HexBlock(BaseClass) {
   }, _a2.NAME = "hexBlock", _a2;
 }
 var LocalBaseBlock = class {
-  constructor({ blockLength = 0, error = EMPTY_STRING, warnings = [], valueBeforeDecode = EMPTY_VIEW } = {}) {
-    this.blockLength = blockLength;
-    this.error = error;
-    this.warnings = warnings;
-    this.valueBeforeDecodeView = BufferSourceConverter.toUint8Array(valueBeforeDecode);
-  }
   static blockName() {
     return this.NAME;
   }
@@ -1004,6 +882,12 @@ var LocalBaseBlock = class {
   set valueBeforeDecode(value) {
     this.valueBeforeDecodeView = new Uint8Array(value);
   }
+  constructor({ blockLength = 0, error = EMPTY_STRING, warnings = [], valueBeforeDecode = EMPTY_VIEW } = {}) {
+    this.blockLength = blockLength;
+    this.error = error;
+    this.warnings = warnings;
+    this.valueBeforeDecodeView = BufferSourceConverter.toUint8Array(valueBeforeDecode);
+  }
   toJSON() {
     return {
       blockName: this.constructor.NAME,
@@ -1016,10 +900,10 @@ var LocalBaseBlock = class {
 };
 LocalBaseBlock.NAME = "baseBlock";
 var ValueBlock = class extends LocalBaseBlock {
-  fromBER(inputBuffer, inputOffset, inputLength) {
+  fromBER(_inputBuffer, _inputOffset, _inputLength) {
     throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
   }
-  toBER(sizeOnly, writer) {
+  toBER(_sizeOnly, _writer) {
     throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
   }
 };
@@ -1360,7 +1244,9 @@ var BaseBlock = class extends LocalBaseBlock {
     return Convert.ToHex(this.toBER());
   }
   onAsciiEncoding() {
-    return `${this.constructor.NAME} : ${Convert.ToHex(this.valueBlock.valueBeforeDecodeView)}`;
+    const name = this.constructor.NAME;
+    const value = Convert.ToHex(this.valueBlock.valueBeforeDecodeView);
+    return `${name} : ${value}`;
   }
   isEqual(other) {
     if (this === other) {
@@ -1376,6 +1262,7 @@ var BaseBlock = class extends LocalBaseBlock {
 };
 BaseBlock.NAME = "BaseBlock";
 function prepareIndefiniteForm(baseBlock) {
+  var _a2;
   if (baseBlock instanceof typeStore.Constructed) {
     for (const value of baseBlock.valueBlock.value) {
       if (prepareIndefiniteForm(value)) {
@@ -1383,21 +1270,21 @@ function prepareIndefiniteForm(baseBlock) {
       }
     }
   }
-  return !!baseBlock.lenBlock.isIndefiniteForm;
+  return !!((_a2 = baseBlock.lenBlock) === null || _a2 === void 0 ? void 0 : _a2.isIndefiniteForm);
 }
 var BaseStringBlock = class extends BaseBlock {
-  constructor({ value = EMPTY_STRING, ...parameters } = {}, stringValueBlockType) {
-    super(parameters, stringValueBlockType);
-    if (value) {
-      this.fromString(value);
-    }
-  }
   getValue() {
     return this.valueBlock.value;
   }
   setValue(value) {
     this.valueBlock.value = value;
   }
+  constructor({ value = EMPTY_STRING, ...parameters } = {}, stringValueBlockType) {
+    super(parameters, stringValueBlockType);
+    if (value) {
+      this.fromString(value);
+    }
+  }
   fromBER(inputBuffer, inputOffset, inputLength) {
     const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length);
     if (resultOffset === -1) {
@@ -1756,10 +1643,10 @@ _a$v = Constructed;
 })();
 Constructed.NAME = "CONSTRUCTED";
 var LocalEndOfContentValueBlock = class extends ValueBlock {
-  fromBER(inputBuffer, inputOffset, inputLength) {
+  fromBER(inputBuffer, inputOffset, _inputLength) {
     return inputOffset;
   }
-  toBER(sizeOnly) {
+  toBER(_sizeOnly) {
     return EMPTY_BUFFER;
   }
 };
@@ -1820,17 +1707,6 @@ _a$t = Null;
 })();
 Null.NAME = "NULL";
 var LocalBooleanValueBlock = class extends HexBlock(ValueBlock) {
-  constructor({ value, ...parameters } = {}) {
-    super(parameters);
-    if (parameters.valueHex) {
-      this.valueHexView = BufferSourceConverter.toUint8Array(parameters.valueHex);
-    } else {
-      this.valueHexView = new Uint8Array(1);
-    }
-    if (value) {
-      this.value = value;
-    }
-  }
   get value() {
     for (const octet of this.valueHexView) {
       if (octet > 0) {
@@ -1842,6 +1718,17 @@ var LocalBooleanValueBlock = class extends HexBlock(ValueBlock) {
   set value(value) {
     this.valueHexView[0] = value ? 255 : 0;
   }
+  constructor({ value, ...parameters } = {}) {
+    super(parameters);
+    if (parameters.valueHex) {
+      this.valueHexView = BufferSourceConverter.toUint8Array(parameters.valueHex);
+    } else {
+      this.valueHexView = new Uint8Array(1);
+    }
+    if (value) {
+      this.value = value;
+    }
+  }
   fromBER(inputBuffer, inputOffset, inputLength) {
     const inputView = BufferSourceConverter.toUint8Array(inputBuffer);
     if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
@@ -1868,17 +1755,17 @@ var LocalBooleanValueBlock = class extends HexBlock(ValueBlock) {
 LocalBooleanValueBlock.NAME = "BooleanValueBlock";
 var _a$s;
 var Boolean = class extends BaseBlock {
-  constructor(parameters = {}) {
-    super(parameters, LocalBooleanValueBlock);
-    this.idBlock.tagClass = 1;
-    this.idBlock.tagNumber = 1;
-  }
   getValue() {
     return this.valueBlock.value;
   }
   setValue(value) {
     this.valueBlock.value = value;
   }
+  constructor(parameters = {}) {
+    super(parameters, LocalBooleanValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 1;
+  }
   onAsciiEncoding() {
     return `${this.constructor.NAME} : ${this.getValue}`;
   }
@@ -1936,7 +1823,7 @@ var LocalOctetStringValueBlock = class extends HexBlock(LocalConstructedValueBlo
 };
 LocalOctetStringValueBlock.NAME = "OctetStringValueBlock";
 var _a$r;
-var OctetString = class _OctetString extends BaseBlock {
+var OctetString = class extends BaseBlock {
   constructor({ idBlock = {}, lenBlock = {}, ...parameters } = {}) {
     var _b, _c;
     (_b = parameters.isConstructed) !== null && _b !== void 0 ? _b : parameters.isConstructed = !!((_c = parameters.value) === null || _c === void 0 ? void 0 : _c.length);
@@ -1974,7 +1861,7 @@ var OctetString = class _OctetString extends BaseBlock {
             this.valueBlock.value = [asn.result];
           }
         }
-      } catch (e) {
+      } catch {
       }
     }
     return super.fromBER(inputBuffer, inputOffset, inputLength);
@@ -1983,7 +1870,9 @@ var OctetString = class _OctetString extends BaseBlock {
     if (this.valueBlock.isConstructed || this.valueBlock.value && this.valueBlock.value.length) {
       return Constructed.prototype.onAsciiEncoding.call(this);
     }
-    return `${this.constructor.NAME} : ${Convert.ToHex(this.valueBlock.valueHexView)}`;
+    const name = this.constructor.NAME;
+    const value = Convert.ToHex(this.valueBlock.valueHexView);
+    return `${name} : ${value}`;
   }
   getValue() {
     if (!this.idBlock.isConstructed) {
@@ -1991,7 +1880,7 @@ var OctetString = class _OctetString extends BaseBlock {
     }
     const array = [];
     for (const content of this.valueBlock.value) {
-      if (content instanceof _OctetString) {
+      if (content instanceof _a$r) {
         array.push(content.valueBlock.valueHexView);
       }
     }
@@ -2061,7 +1950,7 @@ var LocalBitStringValueBlock = class extends HexBlock(LocalConstructedValueBlock
             this.value = [asn.result];
           }
         }
-      } catch (e) {
+      } catch {
       }
     }
     this.valueHexView = intBuffer.subarray(1);
@@ -2076,7 +1965,9 @@ var LocalBitStringValueBlock = class extends HexBlock(LocalConstructedValueBlock
       return new ArrayBuffer(this.valueHexView.byteLength + 1);
     }
     if (!this.valueHexView.byteLength) {
-      return EMPTY_BUFFER;
+      const empty = new Uint8Array(1);
+      empty[0] = 0;
+      return empty.buffer;
     }
     const retView = new Uint8Array(this.valueHexView.length + 1);
     retView[0] = this.unusedBits;
@@ -2126,7 +2017,9 @@ var BitString = class extends BaseBlock {
         bits.push(byte.toString(2).padStart(8, "0"));
       }
       const bitsStr = bits.join("");
-      return `${this.constructor.NAME} : ${bitsStr.substring(0, bitsStr.length - this.valueBlock.unusedBits)}`;
+      const name = this.constructor.NAME;
+      const value = bitsStr.substring(0, bitsStr.length - this.valueBlock.unusedBits);
+      return `${name} : ${value}`;
     }
   }
 };
@@ -2223,16 +2116,6 @@ function viewSub(first, second) {
   return firstViewCopy.slice();
 }
 var LocalIntegerValueBlock = class extends HexBlock(ValueBlock) {
-  constructor({ value, ...parameters } = {}) {
-    super(parameters);
-    this._valueDec = 0;
-    if (parameters.valueHex) {
-      this.setValueHex();
-    }
-    if (value !== void 0) {
-      this.valueDec = value;
-    }
-  }
   setValueHex() {
     if (this.valueHexView.length >= 4) {
       this.warnings.push("Too big Integer for decoding, hex only");
@@ -2245,6 +2128,16 @@ var LocalIntegerValueBlock = class extends HexBlock(ValueBlock) {
       }
     }
   }
+  constructor({ value, ...parameters } = {}) {
+    super(parameters);
+    this._valueDec = 0;
+    if (parameters.valueHex) {
+      this.setValueHex();
+    }
+    if (value !== void 0) {
+      this.valueDec = value;
+    }
+  }
   set valueDec(v) {
     this._valueDec = v;
     this.isHexOnly = false;
@@ -2357,7 +2250,7 @@ LocalIntegerValueBlock.NAME = "IntegerValueBlock";
   });
 })();
 var _a$o;
-var Integer = class _Integer extends BaseBlock {
+var Integer = class extends BaseBlock {
   constructor(parameters = {}) {
     super(parameters, LocalIntegerValueBlock);
     this.idBlock.tagClass = 1;
@@ -2387,18 +2280,16 @@ var Integer = class _Integer extends BaseBlock {
       }
       writer.write(view);
     }
-    const res = new _Integer({
-      valueHex: writer.final()
-    });
+    const res = new _a$o({ valueHex: writer.final() });
     return res;
   }
   convertToDER() {
-    const integer = new _Integer({ valueHex: this.valueBlock.valueHexView });
+    const integer = new _a$o({ valueHex: this.valueBlock.valueHexView });
     integer.valueBlock.toDER();
     return integer;
   }
   convertFromDER() {
-    return new _Integer({
+    return new _a$o({
       valueHex: this.valueBlock.valueHexView[0] === 0 ? this.valueBlock.valueHexView.subarray(1) : this.valueBlock.valueHexView
     });
   }
@@ -2661,17 +2552,17 @@ var LocalObjectIdentifierValueBlock = class extends ValueBlock {
 LocalObjectIdentifierValueBlock.NAME = "ObjectIdentifierValueBlock";
 var _a$m;
 var ObjectIdentifier = class extends BaseBlock {
-  constructor(parameters = {}) {
-    super(parameters, LocalObjectIdentifierValueBlock);
-    this.idBlock.tagClass = 1;
-    this.idBlock.tagNumber = 6;
-  }
   getValue() {
     return this.valueBlock.toString();
   }
   setValue(value) {
     this.valueBlock.fromString(value);
   }
+  constructor(parameters = {}) {
+    super(parameters, LocalObjectIdentifierValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 6;
+  }
   onAsciiEncoding() {
     return `${this.constructor.NAME} : ${this.valueBlock.toString() || "empty"}`;
   }
@@ -2791,7 +2682,7 @@ var LocalRelativeObjectIdentifierValueBlock = class extends ValueBlock {
     }
     return resultOffset;
   }
-  toBER(sizeOnly, writer) {
+  toBER(sizeOnly, _writer) {
     const retBuffers = [];
     for (let i = 0; i < this.value.length; i++) {
       const valueBuf = this.value[i].toBER(sizeOnly);
@@ -2853,17 +2744,17 @@ var LocalRelativeObjectIdentifierValueBlock = class extends ValueBlock {
 LocalRelativeObjectIdentifierValueBlock.NAME = "RelativeObjectIdentifierValueBlock";
 var _a$l;
 var RelativeObjectIdentifier = class extends BaseBlock {
-  constructor(parameters = {}) {
-    super(parameters, LocalRelativeObjectIdentifierValueBlock);
-    this.idBlock.tagClass = 1;
-    this.idBlock.tagNumber = 13;
-  }
   getValue() {
     return this.valueBlock.toString();
   }
   setValue(value) {
     this.valueBlock.fromString(value);
   }
+  constructor(parameters = {}) {
+    super(parameters, LocalRelativeObjectIdentifierValueBlock);
+    this.idBlock.tagClass = 1;
+    this.idBlock.tagNumber = 13;
+  }
   onAsciiEncoding() {
     return `${this.constructor.NAME} : ${this.valueBlock.toString() || "empty"}`;
   }
@@ -3260,7 +3151,8 @@ var GeneralizedTime = class extends UTCTime {
     this.millisecond = inputDate.getUTCMilliseconds();
   }
   toDate() {
-    return new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond));
+    const utcDate = Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond);
+    return new Date(utcDate);
   }
   fromString(inputString) {
     let isUTC = false;
@@ -3509,28 +3401,28 @@ var Repeated = class extends Any {
   }
 };
 var RawData = class {
-  constructor({ data = EMPTY_VIEW } = {}) {
-    this.dataView = BufferSourceConverter.toUint8Array(data);
-  }
   get data() {
     return this.dataView.slice().buffer;
   }
   set data(value) {
     this.dataView = BufferSourceConverter.toUint8Array(value);
   }
+  constructor({ data = EMPTY_VIEW } = {}) {
+    this.dataView = BufferSourceConverter.toUint8Array(data);
+  }
   fromBER(inputBuffer, inputOffset, inputLength) {
     const endLength = inputOffset + inputLength;
     this.dataView = BufferSourceConverter.toUint8Array(inputBuffer).subarray(inputOffset, endLength);
     return endLength;
   }
-  toBER(sizeOnly) {
+  toBER(_sizeOnly) {
     return this.dataView.slice().buffer;
   }
 };
 function compareSchema(root, inputData, inputSchema) {
   if (inputSchema instanceof Choice) {
-    for (let j = 0; j < inputSchema.value.length; j++) {
-      const result = compareSchema(root, inputData, inputSchema.value[j]);
+    for (const element of inputSchema.value) {
+      const result = compareSchema(root, inputData, element);
       if (result.verified) {
         return {
           verified: true,
@@ -3541,9 +3433,7 @@ function compareSchema(root, inputData, inputSchema) {
     {
       const _result = {
         verified: false,
-        result: {
-          error: "Wrong values for Choice type"
-        }
+        result: { error: "Wrong values for Choice type" }
       };
       if (inputSchema.hasOwnProperty(NAME))
         _result.name = inputSchema.name;
@@ -3689,9 +3579,7 @@ function compareSchema(root, inputData, inputSchema) {
     let admission = 0;
     let result = {
       verified: false,
-      result: {
-        error: "Unknown error"
-      }
+      result: { error: "Unknown error" }
     };
     let maxLength = inputSchema.valueBlock.value.length;
     if (maxLength > 0) {
@@ -3940,10 +3828,7 @@ var AsnSchemaStorage = class {
     }
   }
   createDefault(target) {
-    const schema = {
-      type: AsnTypeTypes.Sequence,
-      items: {}
-    };
+    const schema = { type: AsnTypeTypes.Sequence, items: {} };
     const parentSchema = this.findParentSchema(target);
     if (parentSchema) {
       Object.assign(schema, parentSchema);
@@ -3985,26 +3870,14 @@ var AsnSchemaStorage = class {
         const Container = item.repeated === "set" ? Set : Sequence;
         asn1Item = new Container({
           name: "",
-          value: [
-            new Repeated({
-              name,
-              value: asn1Item
-            })
-          ]
+          value: [new Repeated({ name, value: asn1Item })]
         });
       }
       if (item.context !== null && item.context !== void 0) {
         if (item.implicit) {
           if (typeof item.type === "number" || isConvertible(item.type)) {
             const Container = item.repeated ? Constructed : Primitive;
-            asn1Value.push(new Container({
-              name,
-              optional,
-              idBlock: {
-                tagClass: 3,
-                tagNumber: item.context
-              }
-            }));
+            asn1Value.push(new Container({ name, optional, idBlock: { tagClass: 3, tagNumber: item.context } }));
           } else {
             this.cache(item.type);
             const isRepeated = !!item.repeated;
@@ -4013,20 +3886,14 @@ var AsnSchemaStorage = class {
             asn1Value.push(new Constructed({
               name: !isRepeated ? name : "",
               optional,
-              idBlock: {
-                tagClass: 3,
-                tagNumber: item.context
-              },
+              idBlock: { tagClass: 3, tagNumber: item.context },
               value
             }));
           }
         } else {
           asn1Value.push(new Constructed({
             optional,
-            idBlock: {
-              tagClass: 3,
-              tagNumber: item.context
-            },
+            idBlock: { tagClass: 3, tagNumber: item.context },
             value: [asn1Item]
           }));
         }
@@ -4064,20 +3931,142 @@ var AsnSchemaStorage = class {
 var schemaStorage = new AsnSchemaStorage();
 
 // source_nodejs/generate_private_key_filename.ts
-var import_jsrsasign3 = __toESM(require("jsrsasign"));
 async function generatePrivateKeyFile(privateKeyFilename, modulusLength) {
   const keys = await generateKeyPair(modulusLength);
   const privateKeyPem = await privateKeyToPEM(keys.privateKey);
-  await import_node_fs4.default.promises.writeFile(privateKeyFilename, privateKeyPem.privPem, "utf-8");
+  await import_node_fs.default.promises.writeFile(privateKeyFilename, privateKeyPem.privPem, "utf-8");
   privateKeyPem.privPem = "";
   privateKeyPem.privDer = new ArrayBuffer(0);
 }
 async function generatePrivateKeyFileAlternate(privateKeyFilename, modulusLength) {
   const kp = import_jsrsasign3.default.KEYUTIL.generateKeypair("RSA", modulusLength);
   const prv = kp.prvKeyObj;
-  const pub = kp.pubKeyObj;
+  const _pub = kp.pubKeyObj;
   const prvpem = import_jsrsasign3.default.KEYUTIL.getPEM(prv, "PKCS8PRV");
-  await import_node_fs4.default.promises.writeFile(privateKeyFilename, prvpem, "utf-8");
+  await import_node_fs.default.promises.writeFile(privateKeyFilename, prvpem, "utf-8");
+}
+
+// source_nodejs/read.ts
+var import_node_assert8 = __toESM(require("assert"));
+var import_node_crypto6 = require("crypto");
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_sshpk = __toESM(require("sshpk"));
+function _readPemFile(filename) {
+  (0, import_node_assert8.default)(typeof filename === "string");
+  return removeTrailingLF(import_node_fs2.default.readFileSync(filename, "utf-8"));
+}
+function _readPemOrDerFileAsDER(filename) {
+  if (filename.match(/.*\.der/)) {
+    return import_node_fs2.default.readFileSync(filename);
+  }
+  const raw_key = _readPemFile(filename);
+  return convertPEMtoDER(raw_key);
+}
+function readCertificate(filename) {
+  return _readPemOrDerFileAsDER(filename);
+}
+function readPublicKey(filename) {
+  if (filename.match(/.*\.der/)) {
+    const der = import_node_fs2.default.readFileSync(filename);
+    return (0, import_node_crypto6.createPublicKey)(der);
+  } else {
+    const raw_key = _readPemFile(filename);
+    return (0, import_node_crypto6.createPublicKey)(raw_key);
+  }
+}
+function myCreatePrivateKey(rawKey) {
+  if (!import_node_crypto6.createPrivateKey || process.env.NO_CREATE_PRIVATEKEY) {
+    if (Buffer.isBuffer(rawKey)) {
+      const pemKey = toPem(rawKey, "PRIVATE KEY");
+      (0, import_node_assert8.default)(["RSA PRIVATE KEY", "PRIVATE KEY"].indexOf(identifyPemType(pemKey)) >= 0);
+      return { hidden: pemKey };
+    }
+    return { hidden: ensureTrailingLF(rawKey) };
+  }
+  const backup = process.env.OPENSSL_CONF;
+  process.env.OPENSSL_CONF = "/dev/null";
+  const retValue = (0, import_node_crypto6.createPrivateKey)(rawKey);
+  process.env.OPENSSL_CONF = backup;
+  return { hidden: retValue };
+}
+function ensureTrailingLF(str) {
+  return str.match(/\n$/) ? str : `${str}
+`;
+}
+function readPrivateKey(filename) {
+  if (filename.match(/.*\.der/)) {
+    const der = import_node_fs2.default.readFileSync(filename);
+    return myCreatePrivateKey(der);
+  } else {
+    const raw_key = _readPemFile(filename);
+    return myCreatePrivateKey(raw_key);
+  }
+}
+function readCertificatePEM(filename) {
+  return _readPemFile(filename);
+}
+function readPublicKeyPEM(filename) {
+  return _readPemFile(filename);
+}
+function readPrivateKeyPEM(filename) {
+  return _readPemFile(filename);
+}
+var _g_certificate_store = "";
+function setCertificateStore(store) {
+  const old_store = _g_certificate_store;
+  _g_certificate_store = store;
+  return old_store;
+}
+function getCertificateStore() {
+  if (!_g_certificate_store) {
+    _g_certificate_store = import_node_path.default.join(__dirname, "../../certificates/");
+  }
+  return _g_certificate_store;
+}
+function readPrivateRsaKey(filename) {
+  if (!import_node_crypto6.createPrivateKey) {
+    throw new Error("createPrivateKey is not supported in this environment");
+  }
+  if (filename.substring(0, 1) !== "." && !import_node_fs2.default.existsSync(filename)) {
+    filename = import_node_path.default.join(getCertificateStore(), filename);
+  }
+  const content = import_node_fs2.default.readFileSync(filename, "utf8");
+  const sshKey = import_sshpk.default.parsePrivateKey(content, "auto");
+  const key = sshKey.toString("pkcs1");
+  const hidden = (0, import_node_crypto6.createPrivateKey)({ format: "pem", type: "pkcs1", key });
+  return { hidden };
+}
+function readPublicRsaKey(filename) {
+  if (filename.substring(0, 1) !== "." && !import_node_fs2.default.existsSync(filename)) {
+    filename = import_node_path.default.join(getCertificateStore(), filename);
+  }
+  const content = import_node_fs2.default.readFileSync(filename, "utf-8");
+  const sshKey = import_sshpk.default.parseKey(content, "ssh");
+  const key = sshKey.toString("pkcs1");
+  return (0, import_node_crypto6.createPublicKey)({ format: "pem", type: "pkcs1", key });
+}
+
+// source_nodejs/read_certificate_revocation_list.ts
+var import_node_fs3 = __toESM(require("fs"));
+async function readCertificateRevocationList(filename) {
+  const crl = await import_node_fs3.default.promises.readFile(filename);
+  if (crl[0] === 48 && crl[1] === 130) {
+    return crl;
+  }
+  const raw_crl = crl.toString();
+  return convertPEMtoDER(raw_crl);
+}
+
+// source_nodejs/read_certificate_signing_request.ts
+var import_node_fs4 = __toESM(require("fs"));
+async function readCertificateSigningRequest(filename) {
+  const csr = await import_node_fs4.default.promises.readFile(filename);
+  if (csr[0] === 48 && csr[1] === 130) {
+    return csr;
+  }
+  const raw_crl = csr.toString();
+  return convertPEMtoDER(raw_crl);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -4102,7 +4091,7 @@ pvtsutils/build/index.es.js:
   (*!
    * MIT License
    * 
-   * Copyright (c) 2017-2022 Peculiar Ventures, LLC
+   * Copyright (c) 2017-2024 Peculiar Ventures, LLC
    * 
    * Permission is hereby granted, free of charge, to any person obtaining a copy
    * of this software and associated documentation files (the "Software"), to deal