node-opcua-crypto 4.9.4 → 4.11.0

package/dist/{chunk-WLW5XUML.mjs → chunk-2RCYFHGG.mjs}

@@ -17,24 +17,6 @@ var getFilename = () => fileURLToPath(import.meta.url);
 var getDirname = () => path.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
 
-// source/common.ts
-import __crypto from "crypto";
-var KeyObjectOrig = __crypto.KeyObject;
-var { createPrivateKey: createPrivateKeyFromNodeJSCrypto } = __crypto;
-function isKeyObject(mayBeKeyObject) {
-  if (KeyObjectOrig) {
-    return mayBeKeyObject instanceof KeyObjectOrig;
-  }
-  return typeof mayBeKeyObject === "object" && typeof mayBeKeyObject.type === "string";
-}
-var CertificatePurpose = /* @__PURE__ */ ((CertificatePurpose2) => {
-  CertificatePurpose2[CertificatePurpose2["NotSpecified"] = 0] = "NotSpecified";
-  CertificatePurpose2[CertificatePurpose2["ForCertificateAuthority"] = 1] = "ForCertificateAuthority";
-  CertificatePurpose2[CertificatePurpose2["ForApplication"] = 2] = "ForApplication";
-  CertificatePurpose2[CertificatePurpose2["ForUserAuthentication"] = 3] = "ForUserAuthentication";
-  return CertificatePurpose2;
-})(CertificatePurpose || {});
-
 // source/asn1.ts
 import assert from "assert";
 
@@ -102,6 +84,7 @@ var oid_map = {
   "1.3.6.1.4.1.311.2.1.22": { d: "1.3.6.1.4.1.311.2.1.22", c: "SPC_COMMERCIAL_SP_KEY_PURPOSE_OBJID" },
   "1.3.6.1.4.1.311.10.3.1": { d: "1.3.6.1.4.1.311.10.3.1", c: "Signer of CTLs -- szOID_KP_CTL_USAGE_SIGNING" },
   "1.3.6.1.4.1.311.10.3.4": { d: "1.3.6.1.4.1.311.10.3.4", c: "szOID_EFS_RECOVERY (Encryption File System)" },
+  "1.3.6.1.4.1.311.20.2.3": { d: "1.3.6.1.4.1.311.20.2.3", c: "id-on-personalData" },
   "1.3.6.1.5.5.7.3.17": { d: "1.3.6.1.5.5.7.3.17", c: "Internet Key Exchange (IKE)" },
   "1.3.6.1.5.5.7.3.1": { d: "serverAuth", c: "PKIX key purpose" },
   "1.3.6.1.5.5.7.3.2": { d: "clientAuth", c: "PKIX key purpose" },
@@ -361,12 +344,15 @@ var TagType = /* @__PURE__ */ ((TagType3) => {
   TagType3[TagType3["BMPString"] = 30] = "BMPString";
   TagType3[TagType3["SEQUENCE"] = 48] = "SEQUENCE";
   TagType3[TagType3["SET"] = 49] = "SET";
-  TagType3[TagType3["A3"] = 163] = "A3";
+  TagType3[TagType3["CONTEXT_SPECIFIC0"] = 160] = "CONTEXT_SPECIFIC0";
+  TagType3[TagType3["CONTEXT_SPECIFIC1"] = 161] = "CONTEXT_SPECIFIC1";
+  TagType3[TagType3["CONTEXT_SPECIFIC2"] = 162] = "CONTEXT_SPECIFIC2";
+  TagType3[TagType3["CONTEXT_SPECIFIC3"] = 163] = "CONTEXT_SPECIFIC3";
+  TagType3[TagType3["A4"] = 164] = "A4";
   return TagType3;
 })(TagType || {});
 function readTag(buf, pos) {
-  assert(buf instanceof Buffer);
-  assert(Number.isFinite(pos) && pos >= 0);
+  const start = pos;
   if (buf.length <= pos) {
     throw new Error("Invalid position : buf.length=" + buf.length + " pos =" + pos);
   }
@@ -382,9 +368,9 @@ function readTag(buf, pos) {
       pos += 1;
     }
   }
-  return { tag, position: pos, length };
+  return { start, tag, position: pos, length };
 }
-function _readStruct(buf, blockInfo) {
+function readStruct(buf, blockInfo) {
   const length = blockInfo.length;
   let cursor = blockInfo.position;
   const end = blockInfo.position + length;
@@ -446,9 +432,9 @@ function _readIntegerAsByteString(buffer, block) {
 }
 function _readListOfInteger(buffer) {
   const block = readTag(buffer, 0);
-  const inner_blocks = _readStruct(buffer, block);
-  return inner_blocks.map((bblock) => {
-    return _readIntegerAsByteString(buffer, bblock);
+  const inner_blocks = readStruct(buffer, block);
+  return inner_blocks.map((innerBlock) => {
+    return _readIntegerAsByteString(buffer, innerBlock);
   });
 }
 function parseOID(buffer, start, end) {
@@ -480,24 +466,24 @@ function _readObjectIdentifier(buffer, block) {
     name: oid_map[oid] ? oid_map[oid].d : oid
   };
 }
-function _readAlgorithmIdentifier(buffer, block) {
-  const inner_blocks = _readStruct(buffer, block);
+function readAlgorithmIdentifier(buffer, block) {
+  const inner_blocks = readStruct(buffer, block);
   return {
     identifier: _readObjectIdentifier(buffer, inner_blocks[0]).name
   };
 }
 function _readECCAlgorithmIdentifier(buffer, block) {
-  const inner_blocks = _readStruct(buffer, block);
+  const inner_blocks = readStruct(buffer, block);
   return {
     identifier: _readObjectIdentifier(buffer, inner_blocks[1]).name
     // difference with RSA as algorithm is second element of nested block
   };
 }
-function _readSignatureValueBin(buffer, block) {
+function readSignatureValueBin(buffer, block) {
   return _readBitString(buffer, block).data;
 }
-function _readSignatureValue(buffer, block) {
-  return _readSignatureValueBin(buffer, block).toString("hex");
+function readSignatureValue(buffer, block) {
+  return readSignatureValueBin(buffer, block).toString("hex");
 }
 function _readLongIntegerValue(buffer, block) {
   assert(block.tag === 2 /* INTEGER */, "expecting a INTEGER tag");
@@ -578,18 +564,15 @@ function _readValue(buffer, block) {
       throw new Error("Invalid tag 0x" + block.tag.toString(16));
   }
 }
-function compactDirectoryName(d) {
-  return JSON.stringify(d);
-}
 function _readDirectoryName(buffer, block) {
-  const set_blocks = _readStruct(buffer, block);
+  const set_blocks = readStruct(buffer, block);
   const names = {};
   for (const set_block of set_blocks) {
     assert(set_block.tag === 49);
-    const blocks = _readStruct(buffer, set_block);
+    const blocks = readStruct(buffer, set_block);
     assert(blocks.length === 1);
     assert(blocks[0].tag === 48);
-    const sequenceBlock = _readStruct(buffer, blocks[0]);
+    const sequenceBlock = readStruct(buffer, blocks[0]);
     assert(sequenceBlock.length === 2);
     const type = _readObjectIdentifier(buffer, sequenceBlock[0]);
     names[type.name] = _readValue(buffer, sequenceBlock[1]);
@@ -607,12 +590,9 @@ function _readTime(buffer, block) {
   return _readValue(buffer, block);
 }
 
-// source/crypto_explore_certificate.ts
-import assert3 from "assert";
-
 // source/crypto_utils.ts
 import constants from "constants";
-import assert2 from "assert";
+import assert3 from "assert";
 import {
   createHash,
   createSign,
@@ -627,194 +607,12 @@ var createFastUninitializedBuffer = Buffer.allocUnsafe ? Buffer.allocUnsafe : (s
   return new Buffer(size);
 };
 
-// source/crypto_utils.ts
-import jsrsasign from "jsrsasign";
-var { hexy } = pkg_hexy;
-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) {
-  if (rawKey instanceof Buffer) {
-    rawKey = rawKey.toString("utf8");
-  }
-  const match = PEM_TYPE_REGEX.exec(rawKey);
-  return !match ? void 0 : match[2];
-}
-function removeTrailingLF(str) {
-  const tmp = str.replace(/(\r|\n)+$/m, "").replace(/\r\n/gm, "\n");
-  return tmp;
-}
-function toPem(raw_key, pem) {
-  assert2(raw_key, "expecting a key");
-  assert2(typeof pem === "string");
-  let pemType = identifyPemType(raw_key);
-  if (pemType) {
-    return raw_key instanceof Buffer ? removeTrailingLF(raw_key.toString("utf8")) : removeTrailingLF(raw_key);
-  } else {
-    pemType = pem;
-    assert2(["CERTIFICATE REQUEST", "CERTIFICATE", "RSA PRIVATE KEY", "PUBLIC KEY", "X509 CRL"].indexOf(pemType) >= 0);
-    let b = raw_key.toString("base64");
-    let str = "-----BEGIN " + pemType + "-----\n";
-    while (b.length) {
-      str += b.substring(0, 64) + "\n";
-      b = b.substring(64);
-    }
-    str += "-----END " + pemType + "-----";
-    return str;
-  }
-}
-function convertPEMtoDER(raw_key) {
-  let match;
-  let pemType;
-  let base64str;
-  const parts = [];
-  PEM_REGEX.lastIndex = 0;
-  while ((match = PEM_REGEX.exec(raw_key)) !== null) {
-    pemType = match[2];
-    base64str = match[3];
-    base64str = base64str.replace(/\r?\n/g, "");
-    parts.push(Buffer.from(base64str, "base64"));
-  }
-  return combine_der(parts);
-}
-function hexDump(buffer, width) {
-  if (!buffer) {
-    return "<>";
-  }
-  width = width || 32;
-  if (buffer.length > 1024) {
-    return hexy(buffer.subarray(0, 1024), { width, format: "twos" }) + "\n .... ( " + buffer.length + ")";
-  } else {
-    return hexy(buffer, { width, format: "twos" });
-  }
-}
-function makeMessageChunkSignature(chunk, options) {
-  const signer = createSign(options.algorithm);
-  signer.update(chunk);
-  const signature = signer.sign(options.privateKey.hidden);
-  assert2(!options.signatureLength || signature.length === options.signatureLength);
-  return signature;
-}
-function verifyMessageChunkSignature(blockToVerify, signature, options) {
-  const verify = createVerify(options.algorithm);
-  verify.update(blockToVerify);
-  return verify.verify(options.publicKey, signature);
-}
-function makeSHA1Thumbprint(buffer) {
-  return createHash("sha1").update(buffer).digest();
-}
-var RSA_PKCS1_OAEP_PADDING = constants.RSA_PKCS1_OAEP_PADDING;
-var RSA_PKCS1_PADDING = constants.RSA_PKCS1_PADDING;
-var PaddingAlgorithm = /* @__PURE__ */ ((PaddingAlgorithm2) => {
-  PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_OAEP_PADDING"] = 4] = "RSA_PKCS1_OAEP_PADDING";
-  PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_PADDING"] = 1] = "RSA_PKCS1_PADDING";
-  return PaddingAlgorithm2;
-})(PaddingAlgorithm || {});
-assert2(4 /* RSA_PKCS1_OAEP_PADDING */ === constants.RSA_PKCS1_OAEP_PADDING);
-assert2(1 /* RSA_PKCS1_PADDING */ === constants.RSA_PKCS1_PADDING);
-function publicEncrypt_native(buffer, publicKey, algorithm) {
-  if (algorithm === void 0) {
-    algorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
-  }
-  return publicEncrypt1(
-    {
-      key: publicKey,
-      padding: algorithm
-    },
-    buffer
-  );
-}
-function privateDecrypt_native(buffer, privateKey, algorithm) {
-  if (algorithm === void 0) {
-    algorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
-  }
-  try {
-    return privateDecrypt1(
-      {
-        key: privateKey.hidden,
-        padding: algorithm
-      },
-      buffer
-    );
-  } catch (err) {
-    return Buffer.alloc(1);
-  }
-}
-var publicEncrypt = publicEncrypt_native;
-var privateDecrypt = privateDecrypt_native;
-function publicEncrypt_long(buffer, publicKey, blockSize, padding, paddingAlgorithm) {
-  if (paddingAlgorithm === void 0) {
-    paddingAlgorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
-  }
-  if (paddingAlgorithm === RSA_PKCS1_PADDING) {
-    padding = padding || 11;
-    if (padding !== 11) throw new Error("padding should be 11");
-  } else if (paddingAlgorithm === RSA_PKCS1_OAEP_PADDING) {
-    padding = padding || 42;
-    if (padding !== 42) throw new Error("padding should be 42");
-  } else {
-    throw new Error("Invalid padding algorithm " + paddingAlgorithm);
-  }
-  const chunk_size = blockSize - padding;
-  const nbBlocks = Math.ceil(buffer.length / chunk_size);
-  const outputBuffer = createFastUninitializedBuffer(nbBlocks * blockSize);
-  for (let i = 0; i < nbBlocks; i++) {
-    const currentBlock = buffer.subarray(chunk_size * i, chunk_size * (i + 1));
-    const encrypted_chunk = publicEncrypt(currentBlock, publicKey, paddingAlgorithm);
-    if (encrypted_chunk.length !== blockSize) {
-      throw new Error(`publicEncrypt_long unexpected chunk length ${encrypted_chunk.length}  expecting ${blockSize}`);
-    }
-    encrypted_chunk.copy(outputBuffer, i * blockSize);
-  }
-  return outputBuffer;
-}
-function privateDecrypt_long(buffer, privateKey, blockSize, paddingAlgorithm) {
-  paddingAlgorithm = paddingAlgorithm || RSA_PKCS1_OAEP_PADDING;
-  if (paddingAlgorithm !== RSA_PKCS1_PADDING && paddingAlgorithm !== RSA_PKCS1_OAEP_PADDING) {
-    throw new Error("Invalid padding algorithm " + paddingAlgorithm);
-  }
-  const nbBlocks = Math.ceil(buffer.length / blockSize);
-  const outputBuffer = createFastUninitializedBuffer(nbBlocks * blockSize);
-  let total_length = 0;
-  for (let i = 0; i < nbBlocks; i++) {
-    const currentBlock = buffer.subarray(blockSize * i, Math.min(blockSize * (i + 1), buffer.length));
-    const decrypted_buf = privateDecrypt(currentBlock, privateKey, paddingAlgorithm);
-    decrypted_buf.copy(outputBuffer, total_length);
-    total_length += decrypted_buf.length;
-  }
-  return outputBuffer.subarray(0, total_length);
-}
-function coerceCertificatePem(certificate) {
-  if (certificate instanceof Buffer) {
-    certificate = toPem(certificate, "CERTIFICATE");
-  }
-  assert2(typeof certificate === "string");
-  return certificate;
-}
-function extractPublicKeyFromCertificateSync(certificate) {
-  certificate = coerceCertificatePem(certificate);
-  const key = jsrsasign.KEYUTIL.getKey(certificate);
-  const publicKeyAsPem = jsrsasign.KEYUTIL.getPEM(key);
-  assert2(typeof publicKeyAsPem === "string");
-  return publicKeyAsPem;
-}
-function extractPublicKeyFromCertificate(certificate, callback) {
-  let err1 = null;
-  let keyPem;
-  try {
-    keyPem = extractPublicKeyFromCertificateSync(certificate);
-  } catch (err) {
-    err1 = err;
-  }
-  setImmediate(() => {
-    callback(err1, keyPem);
-  });
-}
-
 // source/crypto_explore_certificate.ts
+import assert2 from "assert";
 var doDebug = false;
 function _readAttributeTypeAndValue(buffer, block) {
-  let inner_blocks = _readStruct(buffer, block);
-  inner_blocks = _readStruct(buffer, inner_blocks[0]);
+  let inner_blocks = readStruct(buffer, block);
+  inner_blocks = readStruct(buffer, inner_blocks[0]);
   const data = {
     identifier: _readObjectIdentifier(buffer, inner_blocks[0]).name,
     value: _readValue(buffer, inner_blocks[1])
@@ -826,7 +624,7 @@ function _readAttributeTypeAndValue(buffer, block) {
   return result;
 }
 function _readRelativeDistinguishedName(buffer, block) {
-  const inner_blocks = _readStruct(buffer, block);
+  const inner_blocks = readStruct(buffer, block);
   const data = inner_blocks.map((block2) => _readAttributeTypeAndValue(buffer, block2));
   const result = {};
   for (const e of data) {
@@ -838,7 +636,7 @@ function _readName(buffer, block) {
   return _readRelativeDistinguishedName(buffer, block);
 }
 function _readValidity(buffer, block) {
-  const inner_blocks = _readStruct(buffer, block);
+  const inner_blocks = readStruct(buffer, block);
   return {
     notBefore: _readTime(buffer, inner_blocks[0]),
     notAfter: _readTime(buffer, inner_blocks[1])
@@ -846,27 +644,27 @@ function _readValidity(buffer, block) {
 }
 function _readAuthorityKeyIdentifier(buffer) {
   const block_info = readTag(buffer, 0);
-  const blocks = _readStruct(buffer, block_info);
+  const blocks = readStruct(buffer, block_info);
   const keyIdentifier_block = _findBlockAtIndex(blocks, 0);
   const authorityCertIssuer_block = _findBlockAtIndex(blocks, 1);
   const authorityCertSerialNumber_block = _findBlockAtIndex(blocks, 2);
   function _readAuthorityCertIssuer(block) {
-    const inner_blocks = _readStruct(buffer, block);
+    const inner_blocks = readStruct(buffer, block);
     const directoryName_block = _findBlockAtIndex(inner_blocks, 4);
     if (directoryName_block) {
-      const a = _readStruct(buffer, directoryName_block);
+      const a = readStruct(buffer, directoryName_block);
       return _readDirectoryName(buffer, a[0]);
     } else {
       throw new Error("Invalid _readAuthorityCertIssuer");
     }
   }
   function _readAuthorityCertIssuerFingerPrint(block) {
-    const inner_blocks = _readStruct(buffer, block);
+    const inner_blocks = readStruct(buffer, block);
     const directoryName_block = _findBlockAtIndex(inner_blocks, 4);
     if (!directoryName_block) {
       return "";
     }
-    const a = _readStruct(buffer, directoryName_block);
+    const a = readStruct(buffer, directoryName_block);
     if (a.length < 1) {
       return "";
     }
@@ -885,7 +683,7 @@ function _readAuthorityKeyIdentifier(buffer) {
 }
 function readBasicConstraint2_5_29_19(buffer, block) {
   const block_info = readTag(buffer, 0);
-  const inner_blocks = _readStruct(buffer, block_info).slice(0, 2);
+  const inner_blocks = readStruct(buffer, block_info).slice(0, 2);
   let cA = false;
   let pathLengthConstraint = 0;
   let breakControl = 0;
@@ -914,9 +712,10 @@ function _readGeneralNames(buffer, block) {
     5: { name: "ediPartyName", type: "EDIPartyName" },
     6: { name: "uniformResourceIdentifier", type: "IA5String" },
     7: { name: "iPAddress", type: "OCTET_STRING" },
-    8: { name: "registeredID", type: "OBJECT_IDENTIFIER" }
+    8: { name: "registeredID", type: "OBJECT_IDENTIFIER" },
+    32: { name: "otherName", type: "AnotherName" }
   };
-  const blocks = _readStruct(buffer, block);
+  const blocks = readStruct(buffer, block);
   function _readFromType(buffer2, block2, type) {
     switch (type) {
       case "IA5String":
@@ -927,14 +726,29 @@ function _readGeneralNames(buffer, block) {
   }
   const n = {};
   for (const block2 of blocks) {
-    assert3((block2.tag & 128) === 128);
-    const t = block2.tag & 127;
-    const type = _data[t];
+    assert2((block2.tag & 128) === 128);
+    const t2 = block2.tag & 127;
+    const type = _data[t2];
     if (!type) {
-      throw new Error(" INVALID TYPE => " + t + "0x" + t.toString(16));
+      console.log("_readGeneralNames: INVALID TYPE => " + t2 + " 0x" + t2.toString(16));
+      continue;
+    }
+    if (t2 == 32) {
+      n[type.name] = n[type.name] || [];
+      const blocks2 = readStruct(buffer, block2);
+      const name = _readObjectIdentifier(buffer, blocks2[0]).name;
+      const buf = _getBlock(buffer, blocks2[1]);
+      const b = readTag(buf, 0);
+      const nn = _readValue(buf, b);
+      const data = {
+        identifier: name,
+        value: nn
+      };
+      n[type.name].push(data.value);
+    } else {
+      n[type.name] = n[type.name] || [];
+      n[type.name].push(_readFromType(buffer, block2, type.type));
     }
-    n[type.name] = n[type.name] || [];
-    n[type.name].push(_readFromType(buffer, block2, type.type));
   }
   return n;
 }
@@ -972,9 +786,9 @@ function readKeyUsage(oid, buffer) {
   };
 }
 function readExtKeyUsage(oid, buffer) {
-  assert3(oid === "2.5.29.37");
+  assert2(oid === "2.5.29.37");
   const block_info = readTag(buffer, 0);
-  const inner_blocks = _readStruct(buffer, block_info);
+  const inner_blocks = readStruct(buffer, block_info);
   const extKeyUsage = {
     serverAuth: false,
     clientAuth: false,
@@ -994,15 +808,15 @@ function readExtKeyUsage(oid, buffer) {
 }
 function _readSubjectPublicKey(buffer) {
   const block_info = readTag(buffer, 0);
-  const blocks = _readStruct(buffer, block_info);
+  const blocks = readStruct(buffer, block_info);
   return {
     modulus: buffer.subarray(blocks[0].position + 1, blocks[0].position + blocks[0].length)
   };
 }
 function _readExtension(buffer, block) {
-  const inner_blocks = _readStruct(buffer, block);
+  const inner_blocks = readStruct(buffer, block);
   if (inner_blocks.length === 3) {
-    assert3(inner_blocks[1].tag === 1 /* BOOLEAN */);
+    assert2(inner_blocks[1].tag === 1 /* BOOLEAN */);
     inner_blocks[1] = inner_blocks[2];
   }
   const identifier = _readObjectIdentifier(buffer, inner_blocks[0]);
@@ -1039,9 +853,9 @@ function _readExtension(buffer, block) {
   };
 }
 function _readExtensions(buffer, block) {
-  assert3(block.tag === 163);
-  let inner_blocks = _readStruct(buffer, block);
-  inner_blocks = _readStruct(buffer, inner_blocks[0]);
+  assert2(block.tag === 163);
+  let inner_blocks = readStruct(buffer, block);
+  inner_blocks = readStruct(buffer, inner_blocks[0]);
   const extensions = inner_blocks.map((block2) => _readExtension(buffer, block2));
   const result = {};
   for (const e of extensions) {
@@ -1050,8 +864,8 @@ function _readExtensions(buffer, block) {
   return result;
 }
 function _readSubjectPublicKeyInfo(buffer, block) {
-  const inner_blocks = _readStruct(buffer, block);
-  const algorithm = _readAlgorithmIdentifier(buffer, inner_blocks[0]);
+  const inner_blocks = readStruct(buffer, block);
+  const algorithm = readAlgorithmIdentifier(buffer, inner_blocks[0]);
   const subjectPublicKey = _readBitString(buffer, inner_blocks[1]);
   const data = subjectPublicKey.data;
   const values = _readListOfInteger(data);
@@ -1064,7 +878,7 @@ function _readSubjectPublicKeyInfo(buffer, block) {
   };
 }
 function _readSubjectECCPublicKeyInfo(buffer, block) {
-  const inner_blocks = _readStruct(buffer, block);
+  const inner_blocks = readStruct(buffer, block);
   const algorithm = _readECCAlgorithmIdentifier(buffer, inner_blocks[0]);
   const subjectPublicKey = _readBitString(buffer, inner_blocks[1]);
   const data = subjectPublicKey.data;
@@ -1077,13 +891,13 @@ function _readSubjectECCPublicKeyInfo(buffer, block) {
   };
 }
 function readTbsCertificate(buffer, block) {
-  const blocks = _readStruct(buffer, block);
+  const blocks = readStruct(buffer, block);
   let version, serialNumber, signature, issuer, validity, subject, subjectFingerPrint, extensions;
   let subjectPublicKeyInfo;
   if (blocks.length === 6) {
     version = 1;
     serialNumber = formatBuffer2DigitHexWithColum(_readLongIntegerValue(buffer, blocks[0]));
-    signature = _readAlgorithmIdentifier(buffer, blocks[1]);
+    signature = readAlgorithmIdentifier(buffer, blocks[1]);
     issuer = _readName(buffer, blocks[2]);
     validity = _readValidity(buffer, blocks[3]);
     subject = _readName(buffer, blocks[4]);
@@ -1097,13 +911,13 @@ function readTbsCertificate(buffer, block) {
     }
     version = _readVersionValue(buffer, version_block) + 1;
     serialNumber = formatBuffer2DigitHexWithColum(_readLongIntegerValue(buffer, blocks[1]));
-    signature = _readAlgorithmIdentifier(buffer, blocks[2]);
+    signature = readAlgorithmIdentifier(buffer, blocks[2]);
     issuer = _readName(buffer, blocks[3]);
     validity = _readValidity(buffer, blocks[4]);
     subject = _readName(buffer, blocks[5]);
     subjectFingerPrint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(_getBlock(buffer, blocks[5])));
-    const inner_block = _readStruct(buffer, blocks[6]);
-    const what_type = _readAlgorithmIdentifier(buffer, inner_block[0]).identifier;
+    const inner_block = readStruct(buffer, blocks[6]);
+    const what_type = readAlgorithmIdentifier(buffer, inner_block[0]).identifier;
     switch (what_type) {
       case "rsaEncryption": {
         subjectPublicKeyInfo = _readSubjectPublicKeyInfo(buffer, blocks[6]);
@@ -1136,14 +950,14 @@ function readTbsCertificate(buffer, block) {
   };
 }
 function exploreCertificate(certificate) {
-  assert3(certificate instanceof Buffer);
+  assert2(certificate instanceof Buffer);
   if (!certificate._exploreCertificate_cache) {
     const block_info = readTag(certificate, 0);
-    const blocks = _readStruct(certificate, block_info);
+    const blocks = readStruct(certificate, block_info);
     certificate._exploreCertificate_cache = {
       tbsCertificate: readTbsCertificate(certificate, blocks[0]),
-      signatureAlgorithm: _readAlgorithmIdentifier(certificate, blocks[1]),
-      signatureValue: _readSignatureValue(certificate, blocks[2])
+      signatureAlgorithm: readAlgorithmIdentifier(certificate, blocks[1]),
+      signatureValue: readSignatureValue(certificate, blocks[2])
     };
   }
   return certificate._exploreCertificate_cache;
@@ -1165,51 +979,411 @@ function combine_der(certificates) {
     let sum = 0;
     b.forEach((block) => {
       const block_info = readTag(block, 0);
-      assert3(block_info.position + block_info.length === block.length);
+      assert2(block_info.position + block_info.length === block.length);
       sum += block.length;
     });
-    assert3(sum === cert.length);
+    assert2(sum === cert.length);
   }
   return Buffer.concat(certificates);
 }
 
-// source/explore_certificate.ts
-import assert4 from "assert";
-function coerceCertificate(certificate) {
-  if (typeof certificate === "string") {
-    certificate = convertPEMtoDER(certificate);
+// source/crypto_utils.ts
+import jsrsasign from "jsrsasign";
+var { hexy } = pkg_hexy;
+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) {
+  if (rawKey instanceof Buffer) {
+    rawKey = rawKey.toString("utf8");
   }
-  assert4(certificate instanceof Buffer);
-  return certificate;
+  const match = PEM_TYPE_REGEX.exec(rawKey);
+  return !match ? void 0 : match[2];
 }
-function exploreCertificateInfo(certificate) {
-  certificate = coerceCertificate(certificate);
-  const certInfo = exploreCertificate(certificate);
-  const data = {
-    publicKeyLength: certInfo.tbsCertificate.subjectPublicKeyInfo.keyLength,
-    notBefore: certInfo.tbsCertificate.validity.notBefore,
-    notAfter: certInfo.tbsCertificate.validity.notAfter,
-    publicKey: certInfo.tbsCertificate.subjectPublicKeyInfo.subjectPublicKey,
-    subject: certInfo.tbsCertificate.subject
-  };
-  if (!(data.publicKeyLength === 512 || data.publicKeyLength === 384 || data.publicKeyLength === 256 || data.publicKeyLength === 128)) {
-    throw new Error("Invalid public key length (expecting 128,256,384 or 512)" + data.publicKeyLength);
-  }
-  return data;
+function removeTrailingLF(str) {
+  const tmp = str.replace(/(\r|\n)+$/m, "").replace(/\r\n/gm, "\n");
+  return tmp;
 }
-
-// source/derived_keys.ts
-import assert5 from "assert";
-import { createCipheriv, createDecipheriv, createHmac } from "crypto";
-function HMAC_HASH(sha1or256, secret, message) {
-  return createHmac(sha1or256, secret).update(message).digest();
+function toPem(raw_key, pem) {
+  assert3(raw_key, "expecting a key");
+  assert3(typeof pem === "string");
+  let pemType = identifyPemType(raw_key);
+  if (pemType) {
+    return raw_key instanceof Buffer ? removeTrailingLF(raw_key.toString("utf8")) : removeTrailingLF(raw_key);
+  } else {
+    pemType = pem;
+    assert3(["CERTIFICATE REQUEST", "CERTIFICATE", "RSA PRIVATE KEY", "PUBLIC KEY", "X509 CRL"].indexOf(pemType) >= 0);
+    let b = raw_key.toString("base64");
+    let str = "-----BEGIN " + pemType + "-----\n";
+    while (b.length) {
+      str += b.substring(0, 64) + "\n";
+      b = b.substring(64);
+    }
+    str += "-----END " + pemType + "-----";
+    return str;
+  }
+}
+function convertPEMtoDER(raw_key) {
+  let match;
+  let pemType;
+  let base64str;
+  const parts = [];
+  PEM_REGEX.lastIndex = 0;
+  while ((match = PEM_REGEX.exec(raw_key)) !== null) {
+    pemType = match[2];
+    base64str = match[3];
+    base64str = base64str.replace(/\r?\n/g, "");
+    parts.push(Buffer.from(base64str, "base64"));
+  }
+  return combine_der(parts);
+}
+function hexDump(buffer, width) {
+  if (!buffer) {
+    return "<>";
+  }
+  width = width || 32;
+  if (buffer.length > 1024) {
+    return hexy(buffer.subarray(0, 1024), { width, format: "twos" }) + "\n .... ( " + buffer.length + ")";
+  } else {
+    return hexy(buffer, { width, format: "twos" });
+  }
+}
+function makeMessageChunkSignature(chunk, options) {
+  const signer = createSign(options.algorithm);
+  signer.update(chunk);
+  const signature = signer.sign(options.privateKey.hidden);
+  assert3(!options.signatureLength || signature.length === options.signatureLength);
+  return signature;
+}
+function verifyMessageChunkSignature(blockToVerify, signature, options) {
+  const verify = createVerify(options.algorithm);
+  verify.update(blockToVerify);
+  return verify.verify(options.publicKey, signature);
+}
+function makeSHA1Thumbprint(buffer) {
+  return createHash("sha1").update(buffer).digest();
+}
+var RSA_PKCS1_OAEP_PADDING = constants.RSA_PKCS1_OAEP_PADDING;
+var RSA_PKCS1_PADDING = constants.RSA_PKCS1_PADDING;
+var PaddingAlgorithm = /* @__PURE__ */ ((PaddingAlgorithm2) => {
+  PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_OAEP_PADDING"] = 4] = "RSA_PKCS1_OAEP_PADDING";
+  PaddingAlgorithm2[PaddingAlgorithm2["RSA_PKCS1_PADDING"] = 1] = "RSA_PKCS1_PADDING";
+  return PaddingAlgorithm2;
+})(PaddingAlgorithm || {});
+assert3(4 /* RSA_PKCS1_OAEP_PADDING */ === constants.RSA_PKCS1_OAEP_PADDING);
+assert3(1 /* RSA_PKCS1_PADDING */ === constants.RSA_PKCS1_PADDING);
+function publicEncrypt_native(buffer, publicKey, algorithm) {
+  if (algorithm === void 0) {
+    algorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
+  }
+  return publicEncrypt1(
+    {
+      key: publicKey,
+      padding: algorithm
+    },
+    buffer
+  );
+}
+function privateDecrypt_native(buffer, privateKey, algorithm) {
+  if (algorithm === void 0) {
+    algorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
+  }
+  try {
+    return privateDecrypt1(
+      {
+        key: privateKey.hidden,
+        padding: algorithm
+      },
+      buffer
+    );
+  } catch (err) {
+    return Buffer.alloc(1);
+  }
+}
+var publicEncrypt = publicEncrypt_native;
+var privateDecrypt = privateDecrypt_native;
+function publicEncrypt_long(buffer, publicKey, blockSize, padding, paddingAlgorithm) {
+  if (paddingAlgorithm === void 0) {
+    paddingAlgorithm = 4 /* RSA_PKCS1_OAEP_PADDING */;
+  }
+  if (paddingAlgorithm === RSA_PKCS1_PADDING) {
+    padding = padding || 11;
+    if (padding !== 11) throw new Error("padding should be 11");
+  } else if (paddingAlgorithm === RSA_PKCS1_OAEP_PADDING) {
+    padding = padding || 42;
+    if (padding !== 42) throw new Error("padding should be 42");
+  } else {
+    throw new Error("Invalid padding algorithm " + paddingAlgorithm);
+  }
+  const chunk_size = blockSize - padding;
+  const nbBlocks = Math.ceil(buffer.length / chunk_size);
+  const outputBuffer = createFastUninitializedBuffer(nbBlocks * blockSize);
+  for (let i = 0; i < nbBlocks; i++) {
+    const currentBlock = buffer.subarray(chunk_size * i, chunk_size * (i + 1));
+    const encrypted_chunk = publicEncrypt(currentBlock, publicKey, paddingAlgorithm);
+    if (encrypted_chunk.length !== blockSize) {
+      throw new Error(`publicEncrypt_long unexpected chunk length ${encrypted_chunk.length}  expecting ${blockSize}`);
+    }
+    encrypted_chunk.copy(outputBuffer, i * blockSize);
+  }
+  return outputBuffer;
+}
+function privateDecrypt_long(buffer, privateKey, blockSize, paddingAlgorithm) {
+  paddingAlgorithm = paddingAlgorithm || RSA_PKCS1_OAEP_PADDING;
+  if (paddingAlgorithm !== RSA_PKCS1_PADDING && paddingAlgorithm !== RSA_PKCS1_OAEP_PADDING) {
+    throw new Error("Invalid padding algorithm " + paddingAlgorithm);
+  }
+  const nbBlocks = Math.ceil(buffer.length / blockSize);
+  const outputBuffer = createFastUninitializedBuffer(nbBlocks * blockSize);
+  let total_length = 0;
+  for (let i = 0; i < nbBlocks; i++) {
+    const currentBlock = buffer.subarray(blockSize * i, Math.min(blockSize * (i + 1), buffer.length));
+    const decrypted_buf = privateDecrypt(currentBlock, privateKey, paddingAlgorithm);
+    decrypted_buf.copy(outputBuffer, total_length);
+    total_length += decrypted_buf.length;
+  }
+  return outputBuffer.subarray(0, total_length);
+}
+function coerceCertificatePem(certificate) {
+  if (certificate instanceof Buffer) {
+    certificate = toPem(certificate, "CERTIFICATE");
+  }
+  assert3(typeof certificate === "string");
+  return certificate;
+}
+function extractPublicKeyFromCertificateSync(certificate) {
+  certificate = coerceCertificatePem(certificate);
+  const key = jsrsasign.KEYUTIL.getKey(certificate);
+  const publicKeyAsPem = jsrsasign.KEYUTIL.getPEM(key);
+  assert3(typeof publicKeyAsPem === "string");
+  return publicKeyAsPem;
+}
+function extractPublicKeyFromCertificate(certificate, callback) {
+  let err1 = null;
+  let keyPem;
+  try {
+    keyPem = extractPublicKeyFromCertificateSync(certificate);
+  } catch (err) {
+    err1 = err;
+  }
+  setImmediate(() => {
+    callback(err1, keyPem);
+  });
+}
+
+// source/explore_private_key.ts
+function f(buffer, b) {
+  return buffer.subarray(b.position + 1, b.position + b.length);
+}
+var doDebug2 = !!process.env.DEBUG;
+function explorePrivateKey(privateKey2) {
+  const privateKey1 = privateKey2.hidden;
+  const privateKey = typeof privateKey1 === "string" ? convertPEMtoDER(privateKey1) : privateKey1.export({ format: "der", type: "pkcs1" });
+  const block_info = readTag(privateKey, 0);
+  const blocks = readStruct(privateKey, block_info);
+  if (blocks.length === 9) {
+    const version2 = f(privateKey, blocks[0]);
+    const modulus2 = f(privateKey, blocks[1]);
+    const publicExponent2 = f(privateKey, blocks[2]);
+    const privateExponent2 = f(privateKey, blocks[3]);
+    const prime12 = f(privateKey, blocks[4]);
+    const prime22 = f(privateKey, blocks[5]);
+    const exponent12 = f(privateKey, blocks[6]);
+    const exponent22 = f(privateKey, blocks[7]);
+    return {
+      version: version2,
+      modulus: modulus2,
+      publicExponent: publicExponent2,
+      privateExponent: privateExponent2,
+      prime1: prime12,
+      prime2: prime22,
+      exponent1: exponent12,
+      exponent2: exponent22
+    };
+  }
+  if (doDebug2) {
+    console.log("-------------------- private key:");
+    console.log(block_info);
+    console.log(
+      blocks.map((b2) => ({
+        tag: TagType[b2.tag] + " 0x" + b2.tag.toString(16),
+        l: b2.length,
+        p: b2.position,
+        buff: privateKey.subarray(b2.position, b2.position + b2.length).toString("hex")
+      }))
+    );
+  }
+  const b = blocks[2];
+  const bb = privateKey.subarray(b.position, b.position + b.length);
+  const block_info1 = readTag(bb, 0);
+  const blocks1 = readStruct(bb, block_info1);
+  if (doDebug2) {
+    console.log(
+      blocks1.map((b2) => ({
+        tag: TagType[b2.tag] + " 0x" + b2.tag.toString(16),
+        l: b2.length,
+        p: b2.position,
+        buff: bb.subarray(b2.position, b2.position + b2.length).toString("hex")
+      }))
+    );
+  }
+  const version = f(bb, blocks1[0]);
+  const modulus = f(bb, blocks1[1]);
+  const publicExponent = f(bb, blocks1[2]);
+  const privateExponent = f(bb, blocks1[3]);
+  const prime1 = f(bb, blocks1[4]);
+  const prime2 = f(bb, blocks1[5]);
+  const exponent1 = f(bb, blocks1[6]);
+  const exponent2 = f(bb, blocks1[7]);
+  return {
+    version,
+    modulus,
+    publicExponent,
+    privateExponent,
+    prime1,
+    prime2,
+    exponent1,
+    exponent2
+  };
+}
+
+// source/public_private_match.ts
+function publicKeyAndPrivateKeyMatches(certificate, privateKey) {
+  const i = exploreCertificate(certificate);
+  const j = explorePrivateKey(privateKey);
+  const modulus1 = i.tbsCertificate.subjectPublicKeyInfo.subjectPublicKey.modulus;
+  const modulus2 = j.modulus;
+  if (modulus1.length != modulus2.length) {
+    return false;
+  }
+  return modulus1.toString("hex") === modulus2.toString("hex");
+}
+function certificateMatchesPrivateKeyPEM(certificate, privateKey, blockSize) {
+  const initialBuffer = Buffer.from("Lorem Ipsum");
+  const encryptedBuffer = publicEncrypt_long(initialBuffer, certificate, blockSize);
+  const decryptedBuffer = privateDecrypt_long(encryptedBuffer, privateKey, blockSize);
+  const finalString = decryptedBuffer.toString("utf-8");
+  return initialBuffer.toString("utf-8") === finalString;
+}
+function certificateMatchesPrivateKey(certificate, privateKey) {
+  const e = explorePrivateKey(privateKey);
+  const blockSize = e.modulus.length;
+  const certificatePEM = toPem(certificate, "CERTIFICATE");
+  return certificateMatchesPrivateKeyPEM(certificatePEM, privateKey, blockSize);
+}
+
+// source/common.ts
+import __crypto from "crypto";
+var KeyObjectOrig = __crypto.KeyObject;
+var { createPrivateKey: createPrivateKeyFromNodeJSCrypto } = __crypto;
+function isKeyObject(mayBeKeyObject) {
+  if (KeyObjectOrig) {
+    return mayBeKeyObject instanceof KeyObjectOrig;
+  }
+  return typeof mayBeKeyObject === "object" && typeof mayBeKeyObject.type === "string";
+}
+var CertificatePurpose = /* @__PURE__ */ ((CertificatePurpose2) => {
+  CertificatePurpose2[CertificatePurpose2["NotSpecified"] = 0] = "NotSpecified";
+  CertificatePurpose2[CertificatePurpose2["ForCertificateAuthority"] = 1] = "ForCertificateAuthority";
+  CertificatePurpose2[CertificatePurpose2["ForApplication"] = 2] = "ForApplication";
+  CertificatePurpose2[CertificatePurpose2["ForUserAuthentication"] = 3] = "ForUserAuthentication";
+  return CertificatePurpose2;
+})(CertificatePurpose || {});
+
+// source/crypto_utils2.ts
+import assert4 from "assert";
+import jsrsasign2 from "jsrsasign";
+function rsaLengthPrivateKey(key) {
+  const keyPem = typeof key.hidden === "string" ? key.hidden : key.hidden.export({ type: "pkcs1", format: "pem" }).toString();
+  const a = jsrsasign2.KEYUTIL.getKey(keyPem);
+  return a.n.toString(16).length / 2;
+}
+function toPem2(raw_key, pem) {
+  if (raw_key.hidden) {
+    return toPem2(raw_key.hidden, pem);
+  }
+  assert4(raw_key, "expecting a key");
+  assert4(typeof pem === "string");
+  if (isKeyObject(raw_key)) {
+    const _raw_key = raw_key;
+    if (pem === "RSA PRIVATE KEY") {
+      return removeTrailingLF(_raw_key.export({ format: "pem", type: "pkcs1" }).toString());
+    } else if (pem === "PRIVATE KEY") {
+      return removeTrailingLF(_raw_key.export({ format: "pem", type: "pkcs8" }).toString());
+    } else {
+      throw new Error("Unsupported case!");
+    }
+  }
+  return toPem(raw_key, pem);
+}
+function coercePrivateKeyPem(privateKey) {
+  return toPem2(privateKey, "PRIVATE KEY");
+}
+function coercePublicKeyPem(publicKey) {
+  if (isKeyObject(publicKey)) {
+    return publicKey.export({ format: "pem", type: "spki" }).toString();
+  }
+  assert4(typeof publicKey === "string");
+  return publicKey;
+}
+function coerceRsaPublicKeyPem(publicKey) {
+  if (isKeyObject(publicKey)) {
+    return publicKey.export({ format: "pem", type: "spki" }).toString();
+  }
+  assert4(typeof publicKey === "string");
+  return publicKey;
+}
+function rsaLengthPublicKey(key) {
+  key = coercePublicKeyPem(key);
+  assert4(typeof key === "string");
+  const a = jsrsasign2.KEYUTIL.getKey(key);
+  return a.n.toString(16).length / 2;
+}
+function rsaLengthRsaPublicKey(key) {
+  key = coerceRsaPublicKeyPem(key);
+  assert4(typeof key === "string");
+  const a = jsrsasign2.KEYUTIL.getKey(key);
+  return a.n.toString(16).length / 2;
+}
+
+// source/derived_keys.ts
+import assert6 from "assert";
+import { createCipheriv, createDecipheriv, createHmac } from "crypto";
+
+// source/explore_certificate.ts
+import assert5 from "assert";
+function coerceCertificate(certificate) {
+  if (typeof certificate === "string") {
+    certificate = convertPEMtoDER(certificate);
+  }
+  assert5(certificate instanceof Buffer);
+  return certificate;
+}
+function exploreCertificateInfo(certificate) {
+  certificate = coerceCertificate(certificate);
+  const certInfo = exploreCertificate(certificate);
+  const data = {
+    publicKeyLength: certInfo.tbsCertificate.subjectPublicKeyInfo.keyLength,
+    notBefore: certInfo.tbsCertificate.validity.notBefore,
+    notAfter: certInfo.tbsCertificate.validity.notAfter,
+    publicKey: certInfo.tbsCertificate.subjectPublicKeyInfo.subjectPublicKey,
+    subject: certInfo.tbsCertificate.subject
+  };
+  if (!(data.publicKeyLength === 512 || data.publicKeyLength === 384 || data.publicKeyLength === 256 || data.publicKeyLength === 128)) {
+    throw new Error("Invalid public key length (expecting 128,256,384 or 512)" + data.publicKeyLength);
+  }
+  return data;
+}
+
+// source/derived_keys.ts
+function HMAC_HASH(sha1or256, secret, message) {
+  return createHmac(sha1or256, secret).update(message).digest();
 }
 function plus(buf1, buf2) {
   return Buffer.concat([buf1, buf2]);
 }
 function makePseudoRandomBuffer(secret, seed, minLength, sha1or256) {
-  assert5(seed instanceof Buffer);
-  assert5(sha1or256 === "SHA1" || sha1or256 === "SHA256");
+  assert6(seed instanceof Buffer);
+  assert6(sha1or256 === "SHA1" || sha1or256 === "SHA256");
   const a = [];
   a[0] = seed;
   let index = 1;
@@ -1222,12 +1396,12 @@ function makePseudoRandomBuffer(secret, seed, minLength, sha1or256) {
   return p_hash.subarray(0, minLength);
 }
 function computeDerivedKeys(secret, seed, options) {
-  assert5(Number.isFinite(options.signatureLength));
-  assert5(Number.isFinite(options.encryptingKeyLength));
-  assert5(Number.isFinite(options.encryptingBlockSize));
-  assert5(typeof options.algorithm === "string");
+  assert6(Number.isFinite(options.signatureLength));
+  assert6(Number.isFinite(options.encryptingKeyLength));
+  assert6(Number.isFinite(options.encryptingBlockSize));
+  assert6(typeof options.algorithm === "string");
   options.sha1or256 = options.sha1or256 || "SHA1";
-  assert5(typeof options.sha1or256 === "string");
+  assert6(typeof options.sha1or256 === "string");
   const offset1 = options.signingKeyLength;
   const offset2 = offset1 + options.encryptingKeyLength;
   const minLength = offset2 + options.encryptingBlockSize;
@@ -1252,7 +1426,7 @@ function removePadding(buffer) {
   return reduceLength(buffer, nbPaddingBytes);
 }
 function verifyChunkSignature(chunk, options) {
-  assert5(chunk instanceof Buffer);
+  assert6(chunk instanceof Buffer);
   let signatureLength = options.signatureLength || 0;
   if (signatureLength === 0) {
     const cert = exploreCertificateInfo(options.publicKey);
@@ -1263,16 +1437,16 @@ function verifyChunkSignature(chunk, options) {
   return verifyMessageChunkSignature(block_to_verify, signature, options);
 }
 function computePaddingFooter(buffer, derivedKeys) {
-  assert5(Object.prototype.hasOwnProperty.call(derivedKeys, "encryptingBlockSize"));
+  assert6(Object.prototype.hasOwnProperty.call(derivedKeys, "encryptingBlockSize"));
   const paddingSize = derivedKeys.encryptingBlockSize - (buffer.length + 1) % derivedKeys.encryptingBlockSize;
   const padding = createFastUninitializedBuffer(paddingSize + 1);
   padding.fill(paddingSize);
   return padding;
 }
 function derivedKeys_algorithm(derivedKeys) {
-  assert5(Object.prototype.hasOwnProperty.call(derivedKeys, "algorithm"));
+  assert6(Object.prototype.hasOwnProperty.call(derivedKeys, "algorithm"));
   const algorithm = derivedKeys.algorithm || "aes-128-cbc";
-  assert5(algorithm === "aes-128-cbc" || algorithm === "aes-256-cbc");
+  assert6(algorithm === "aes-128-cbc" || algorithm === "aes-256-cbc");
   return algorithm;
 }
 function encryptBufferWithDerivedKeys(buffer, derivedKeys) {
@@ -1286,153 +1460,58 @@ function encryptBufferWithDerivedKeys(buffer, derivedKeys) {
   encrypted_chunks.push(cipher.final());
   return Buffer.concat(encrypted_chunks);
 }
-function decryptBufferWithDerivedKeys(buffer, derivedKeys) {
-  const algorithm = derivedKeys_algorithm(derivedKeys);
-  const key = derivedKeys.encryptingKey;
-  const initVector = derivedKeys.initializationVector;
-  const cipher = createDecipheriv(algorithm, key, initVector);
-  cipher.setAutoPadding(false);
-  const decrypted_chunks = [];
-  decrypted_chunks.push(cipher.update(buffer));
-  decrypted_chunks.push(cipher.final());
-  return Buffer.concat(decrypted_chunks);
-}
-function makeMessageChunkSignatureWithDerivedKeys(message, derivedKeys) {
-  assert5(message instanceof Buffer);
-  assert5(derivedKeys.signingKey instanceof Buffer);
-  assert5(typeof derivedKeys.sha1or256 === "string");
-  assert5(derivedKeys.sha1or256 === "SHA1" || derivedKeys.sha1or256 === "SHA256");
-  const signature = createHmac(derivedKeys.sha1or256, derivedKeys.signingKey).update(message).digest();
-  assert5(signature.length === derivedKeys.signatureLength);
-  return signature;
-}
-function verifyChunkSignatureWithDerivedKeys(chunk, derivedKeys) {
-  const message = chunk.subarray(0, chunk.length - derivedKeys.signatureLength);
-  const expectedSignature = chunk.subarray(chunk.length - derivedKeys.signatureLength);
-  const computedSignature = makeMessageChunkSignatureWithDerivedKeys(message, derivedKeys);
-  return computedSignature.toString("hex") === expectedSignature.toString("hex");
-}
-
-// source/crypto_utils2.ts
-import assert6 from "assert";
-import jsrsasign2 from "jsrsasign";
-function rsaLengthPrivateKey(key) {
-  const keyPem = typeof key.hidden === "string" ? key.hidden : key.hidden.export({ type: "pkcs1", format: "pem" }).toString();
-  const a = jsrsasign2.KEYUTIL.getKey(keyPem);
-  return a.n.toString(16).length / 2;
-}
-function toPem2(raw_key, pem) {
-  if (raw_key.hidden) {
-    return toPem2(raw_key.hidden, pem);
-  }
-  assert6(raw_key, "expecting a key");
-  assert6(typeof pem === "string");
-  if (isKeyObject(raw_key)) {
-    const _raw_key = raw_key;
-    if (pem === "RSA PRIVATE KEY") {
-      return removeTrailingLF(_raw_key.export({ format: "pem", type: "pkcs1" }).toString());
-    } else if (pem === "PRIVATE KEY") {
-      return removeTrailingLF(_raw_key.export({ format: "pem", type: "pkcs8" }).toString());
-    } else {
-      throw new Error("Unsupported case!");
-    }
-  }
-  return toPem(raw_key, pem);
-}
-function coercePrivateKeyPem(privateKey) {
-  return toPem2(privateKey, "PRIVATE KEY");
-}
-function coercePublicKeyPem(publicKey) {
-  if (isKeyObject(publicKey)) {
-    return publicKey.export({ format: "pem", type: "spki" }).toString();
-  }
-  assert6(typeof publicKey === "string");
-  return publicKey;
-}
-function coerceRsaPublicKeyPem(publicKey) {
-  if (isKeyObject(publicKey)) {
-    return publicKey.export({ format: "pem", type: "spki" }).toString();
-  }
-  assert6(typeof publicKey === "string");
-  return publicKey;
-}
-function rsaLengthPublicKey(key) {
-  key = coercePublicKeyPem(key);
-  assert6(typeof key === "string");
-  const a = jsrsasign2.KEYUTIL.getKey(key);
-  return a.n.toString(16).length / 2;
-}
-function rsaLengthRsaPublicKey(key) {
-  key = coerceRsaPublicKeyPem(key);
-  assert6(typeof key === "string");
-  const a = jsrsasign2.KEYUTIL.getKey(key);
-  return a.n.toString(16).length / 2;
-}
-
-// source/verify_certificate_signature.ts
-import { createVerify as createVerify2 } from "crypto";
-function verifyCertificateOrClrSignature(certificateOrCrl, parentCertificate) {
-  const block_info = readTag(certificateOrCrl, 0);
-  const blocks = _readStruct(certificateOrCrl, block_info);
-  const bufferToBeSigned = certificateOrCrl.subarray(block_info.position, blocks[1].position - 2);
-  const signatureAlgorithm = _readAlgorithmIdentifier(certificateOrCrl, blocks[1]);
-  const signatureValue = _readSignatureValueBin(certificateOrCrl, blocks[2]);
-  const p = split_der(parentCertificate)[0];
-  const certPem = toPem(p, "CERTIFICATE");
-  const verify = createVerify2(signatureAlgorithm.identifier);
-  verify.update(bufferToBeSigned);
-  verify.end();
-  return verify.verify(certPem, signatureValue);
+function decryptBufferWithDerivedKeys(buffer, derivedKeys) {
+  const algorithm = derivedKeys_algorithm(derivedKeys);
+  const key = derivedKeys.encryptingKey;
+  const initVector = derivedKeys.initializationVector;
+  const cipher = createDecipheriv(algorithm, key, initVector);
+  cipher.setAutoPadding(false);
+  const decrypted_chunks = [];
+  decrypted_chunks.push(cipher.update(buffer));
+  decrypted_chunks.push(cipher.final());
+  return Buffer.concat(decrypted_chunks);
 }
-function verifyCertificateSignature(certificate, parentCertificate) {
-  return verifyCertificateOrClrSignature(certificate, parentCertificate);
+function makeMessageChunkSignatureWithDerivedKeys(message, derivedKeys) {
+  assert6(message instanceof Buffer);
+  assert6(derivedKeys.signingKey instanceof Buffer);
+  assert6(typeof derivedKeys.sha1or256 === "string");
+  assert6(derivedKeys.sha1or256 === "SHA1" || derivedKeys.sha1or256 === "SHA256");
+  const signature = createHmac(derivedKeys.sha1or256, derivedKeys.signingKey).update(message).digest();
+  assert6(signature.length === derivedKeys.signatureLength);
+  return signature;
 }
-function verifyCertificateRevocationListSignature(certificateRevocationList, parentCertificate) {
-  return verifyCertificateOrClrSignature(certificateRevocationList, parentCertificate);
+function verifyChunkSignatureWithDerivedKeys(chunk, derivedKeys) {
+  const message = chunk.subarray(0, chunk.length - derivedKeys.signatureLength);
+  const expectedSignature = chunk.subarray(chunk.length - derivedKeys.signatureLength);
+  const computedSignature = makeMessageChunkSignatureWithDerivedKeys(message, derivedKeys);
+  return computedSignature.toString("hex") === expectedSignature.toString("hex");
 }
-async function verifyCertificateChain(certificateChain) {
-  for (let index = 1; index < certificateChain.length; index++) {
-    const cert = certificateChain[index - 1];
-    const certParent = certificateChain[index];
-    const certParentInfo = exploreCertificate(certParent);
-    const keyUsage = certParentInfo.tbsCertificate.extensions.keyUsage;
-    if (!keyUsage.keyCertSign) {
-      return {
-        status: "BadCertificateIssuerUseNotAllowed",
-        reason: "One of the certificate in the chain has not keyUsage set for Certificate Signing"
-      };
-    }
-    const parentSignChild = verifyCertificateSignature(cert, certParent);
-    if (!parentSignChild) {
-      return {
-        status: "BadCertificateInvalid",
-        reason: "One of the certificate in the chain is not signing the previous certificate"
-      };
-    }
-    const certInfo = exploreCertificate(cert);
-    if (!certInfo.tbsCertificate.extensions) {
-      return {
-        status: "BadCertificateInvalid",
-        reason: "Cannot find X409 Extension 3 in certificate"
-      };
-    }
-    if (!certParentInfo.tbsCertificate.extensions || !certInfo.tbsCertificate.extensions.authorityKeyIdentifier) {
-      return {
-        status: "BadCertificateInvalid",
-        reason: "Cannot find X409 Extension 3 in certificate (parent)"
-      };
-    }
-    if (certParentInfo.tbsCertificate.extensions.subjectKeyIdentifier !== certInfo.tbsCertificate.extensions.authorityKeyIdentifier.keyIdentifier) {
-      return {
-        status: "BadCertificateInvalid",
-        reason: "subjectKeyIdentifier authorityKeyIdentifier in child certificate do not match subjectKeyIdentifier of parent certificate"
-      };
+
+// source/explore_asn1.ts
+function t(tag) {
+  return TagType[tag];
+}
+function bi(blockInfo, depth) {
+  const indent = "  ".repeat(depth);
+  const hl = blockInfo.position - blockInfo.start;
+  return `${blockInfo.start.toString().padStart(5, " ")}:d=${depth} hl=${hl.toString().padEnd(3, " ")}  l=${blockInfo.length.toString().padStart(6, " ")} ${blockInfo.tag.toString(16).padEnd(2, " ")} ${indent} ${t(blockInfo.tag)}`;
+}
+function exploreAsn1(buffer) {
+  console.log(hexDump(buffer));
+  function dump(offset, depth) {
+    const blockInfo = readTag(buffer, offset);
+    dumpBlock(blockInfo, depth);
+    function dumpBlock(blockInfo2, depth2) {
+      console.log(bi(blockInfo2, depth2));
+      if (blockInfo2.tag === 48 /* SEQUENCE */ || blockInfo2.tag === 49 /* SET */ || blockInfo2.tag >= 160 /* CONTEXT_SPECIFIC0 */) {
+        const blocks = readStruct(buffer, blockInfo2);
+        for (const block of blocks) {
+          dumpBlock(block, depth2 + 1);
+        }
+      }
     }
   }
-  return {
-    status: "Good",
-    reason: `certificate chain is valid(length = ${certificateChain.length})`
-  };
+  dump(0, 0);
 }
 
 // source/explore_certificate_revocation_list.ts
@@ -1440,20 +1519,20 @@ function readNameForCrl(buffer, block) {
   return _readDirectoryName(buffer, block);
 }
 function _readTbsCertList(buffer, blockInfo) {
-  const blocks = _readStruct(buffer, blockInfo);
+  const blocks = readStruct(buffer, blockInfo);
   const hasOptionalVersion = blocks[0].tag === 2 /* INTEGER */;
   if (hasOptionalVersion) {
     const version = _readIntegerValue(buffer, blocks[0]);
-    const signature = _readAlgorithmIdentifier(buffer, blocks[1]);
+    const signature = readAlgorithmIdentifier(buffer, blocks[1]);
     const issuer = readNameForCrl(buffer, blocks[2]);
     const issuerFingerprint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(_getBlock(buffer, blocks[2])));
     const thisUpdate = _readTime(buffer, blocks[3]);
     const nextUpdate = _readTime(buffer, blocks[4]);
     const revokedCertificates = [];
     if (blocks[5] && blocks[5].tag < 128) {
-      const list = _readStruct(buffer, blocks[5]);
+      const list = readStruct(buffer, blocks[5]);
       for (const r of list) {
-        const rr = _readStruct(buffer, r);
+        const rr = readStruct(buffer, r);
         const userCertificate = formatBuffer2DigitHexWithColum(_readLongIntegerValue(buffer, rr[0]));
         const revocationDate = _readTime(buffer, rr[1]);
         revokedCertificates.push({
@@ -1465,16 +1544,16 @@ function _readTbsCertList(buffer, blockInfo) {
     const ext0 = _findBlockAtIndex(blocks, 0);
     return { issuer, issuerFingerprint, thisUpdate, nextUpdate, signature, revokedCertificates };
   } else {
-    const signature = _readAlgorithmIdentifier(buffer, blocks[0]);
+    const signature = readAlgorithmIdentifier(buffer, blocks[0]);
     const issuer = readNameForCrl(buffer, blocks[1]);
     const issuerFingerprint = formatBuffer2DigitHexWithColum(makeSHA1Thumbprint(_getBlock(buffer, blocks[1])));
     const thisUpdate = _readTime(buffer, blocks[2]);
     const nextUpdate = _readTime(buffer, blocks[3]);
     const revokedCertificates = [];
     if (blocks[4] && blocks[4].tag < 128) {
-      const list = _readStruct(buffer, blocks[4]);
+      const list = readStruct(buffer, blocks[4]);
       for (const r of list) {
-        const rr = _readStruct(buffer, r);
+        const rr = readStruct(buffer, r);
         const userCertificate = formatBuffer2DigitHexWithColum(_readLongIntegerValue(buffer, rr[0]));
         const revocationDate = _readTime(buffer, rr[1]);
         revokedCertificates.push({
@@ -1488,17 +1567,17 @@ function _readTbsCertList(buffer, blockInfo) {
 }
 function exploreCertificateRevocationList(crl) {
   const blockInfo = readTag(crl, 0);
-  const blocks = _readStruct(crl, blockInfo);
+  const blocks = readStruct(crl, blockInfo);
   const tbsCertList = _readTbsCertList(crl, blocks[0]);
-  const signatureAlgorithm = _readAlgorithmIdentifier(crl, blocks[1]);
-  const signatureValue = _readSignatureValueBin(crl, blocks[2]);
+  const signatureAlgorithm = readAlgorithmIdentifier(crl, blocks[1]);
+  const signatureValue = readSignatureValueBin(crl, blocks[2]);
   return { tbsCertList, signatureAlgorithm, signatureValue };
 }
 
 // source/explore_certificate_signing_request.ts
 function _readExtensionRequest(buffer) {
   const block = readTag(buffer, 0);
-  const inner_blocks = _readStruct(buffer, block);
+  const inner_blocks = readStruct(buffer, block);
   const extensions = inner_blocks.map((block1) => _readExtension(buffer, block1));
   const result = {};
   for (const e of extensions) {
@@ -1508,204 +1587,39 @@ function _readExtensionRequest(buffer) {
   return { basicConstraints, keyUsage, subjectAltName };
 }
 function readCertificationRequestInfo(buffer, block) {
-  const blocks = _readStruct(buffer, block);
+  const blocks = readStruct(buffer, block);
   if (blocks.length === 4) {
     const extensionRequestBlock = _findBlockAtIndex(blocks, 0);
     if (!extensionRequestBlock) {
       throw new Error("cannot find extensionRequest block");
     }
-    const blocks1 = _readStruct(buffer, extensionRequestBlock);
-    const blocks2 = _readStruct(buffer, blocks1[0]);
+    const blocks1 = readStruct(buffer, extensionRequestBlock);
+    const blocks2 = readStruct(buffer, blocks1[0]);
     const identifier = _readObjectIdentifier(buffer, blocks2[0]);
     if (identifier.name !== "extensionRequest") {
       throw new Error(" Cannot find extension Request in ASN1 block");
     }
     const buf = _getBlock(buffer, blocks2[1]);
-    const extensionRequest = _readExtensionRequest(buf);
-    return { extensionRequest };
-  }
-  throw new Error("Invalid CSR or ");
-}
-function exploreCertificateSigningRequest(crl) {
-  const blockInfo = readTag(crl, 0);
-  const blocks = _readStruct(crl, blockInfo);
-  const csrInfo = readCertificationRequestInfo(crl, blocks[0]);
-  return csrInfo;
-}
-
-// source/explore_private_key.ts
-function f(buffer, b) {
-  return buffer.subarray(b.position + 1, b.position + b.length);
-}
-var doDebug2 = !!process.env.DEBUG;
-function explorePrivateKey(privateKey2) {
-  const privateKey1 = privateKey2.hidden;
-  const privateKey = typeof privateKey1 === "string" ? convertPEMtoDER(privateKey1) : privateKey1.export({ format: "der", type: "pkcs1" });
-  const block_info = readTag(privateKey, 0);
-  const blocks = _readStruct(privateKey, block_info);
-  if (blocks.length === 9) {
-    const version2 = f(privateKey, blocks[0]);
-    const modulus2 = f(privateKey, blocks[1]);
-    const publicExponent2 = f(privateKey, blocks[2]);
-    const privateExponent2 = f(privateKey, blocks[3]);
-    const prime12 = f(privateKey, blocks[4]);
-    const prime22 = f(privateKey, blocks[5]);
-    const exponent12 = f(privateKey, blocks[6]);
-    const exponent22 = f(privateKey, blocks[7]);
-    return {
-      version: version2,
-      modulus: modulus2,
-      publicExponent: publicExponent2,
-      privateExponent: privateExponent2,
-      prime1: prime12,
-      prime2: prime22,
-      exponent1: exponent12,
-      exponent2: exponent22
-    };
-  }
-  if (doDebug2) {
-    console.log("-------------------- private key:");
-    console.log(block_info);
-    console.log(
-      blocks.map((b2) => ({
-        tag: TagType[b2.tag] + " 0x" + b2.tag.toString(16),
-        l: b2.length,
-        p: b2.position,
-        buff: privateKey.subarray(b2.position, b2.position + b2.length).toString("hex")
-      }))
-    );
-  }
-  const b = blocks[2];
-  const bb = privateKey.subarray(b.position, b.position + b.length);
-  const block_info1 = readTag(bb, 0);
-  const blocks1 = _readStruct(bb, block_info1);
-  if (doDebug2) {
-    console.log(
-      blocks1.map((b2) => ({
-        tag: TagType[b2.tag] + " 0x" + b2.tag.toString(16),
-        l: b2.length,
-        p: b2.position,
-        buff: bb.subarray(b2.position, b2.position + b2.length).toString("hex")
-      }))
-    );
-  }
-  const version = f(bb, blocks1[0]);
-  const modulus = f(bb, blocks1[1]);
-  const publicExponent = f(bb, blocks1[2]);
-  const privateExponent = f(bb, blocks1[3]);
-  const prime1 = f(bb, blocks1[4]);
-  const prime2 = f(bb, blocks1[5]);
-  const exponent1 = f(bb, blocks1[6]);
-  const exponent2 = f(bb, blocks1[7]);
-  return {
-    version,
-    modulus,
-    publicExponent,
-    privateExponent,
-    prime1,
-    prime2,
-    exponent1,
-    exponent2
-  };
-}
-
-// source/public_private_match.ts
-function publicKeyAndPrivateKeyMatches(certificate, privateKey) {
-  const i = exploreCertificate(certificate);
-  const j = explorePrivateKey(privateKey);
-  const modulus1 = i.tbsCertificate.subjectPublicKeyInfo.subjectPublicKey.modulus;
-  const modulus2 = j.modulus;
-  if (modulus1.length != modulus2.length) {
-    return false;
-  }
-  return modulus1.toString("hex") === modulus2.toString("hex");
-}
-function certificateMatchesPrivateKeyPEM(certificate, privateKey, blockSize) {
-  const initialBuffer = Buffer.from("Lorem Ipsum");
-  const encryptedBuffer = publicEncrypt_long(initialBuffer, certificate, blockSize);
-  const decryptedBuffer = privateDecrypt_long(encryptedBuffer, privateKey, blockSize);
-  const finalString = decryptedBuffer.toString("utf-8");
-  return initialBuffer.toString("utf-8") === finalString;
-}
-function certificateMatchesPrivateKey(certificate, privateKey) {
-  const e = explorePrivateKey(privateKey);
-  const blockSize = e.modulus.length;
-  const certificatePEM = toPem(certificate, "CERTIFICATE");
-  return certificateMatchesPrivateKeyPEM(certificatePEM, privateKey, blockSize);
-}
-
-// source/x509/_crypto.ts
-import * as x509 from "@peculiar/x509";
-import { Crypto as PeculiarWebCrypto } from "@peculiar/webcrypto";
-import nativeCrypto from "crypto";
-import * as x5092 from "@peculiar/x509";
-var doDebug3 = false;
-var _crypto;
-var ignoreCrypto = process.env.IGNORE_SUBTLE_FROM_CRYPTO;
-if (typeof window === "undefined") {
-  _crypto = nativeCrypto;
-  if (!_crypto?.subtle || ignoreCrypto) {
-    _crypto = new PeculiarWebCrypto();
-    doDebug3 && console.warn("using @peculiar/webcrypto");
-  } else {
-    doDebug3 && console.warn("using nodejs crypto (native)");
-  }
-  x509.cryptoProvider.set(_crypto);
-} else {
-  doDebug3 && console.warn("using browser crypto (native)");
-  _crypto = crypto;
-  x509.cryptoProvider.set(crypto);
-}
-function getCrypto() {
-  return _crypto || crypto || __require("crypto");
-}
-
-// source/x509/create_key_pair.ts
-async function generateKeyPair(modulusLength = 2048) {
-  const crypto3 = getCrypto();
-  const alg = {
-    name: "RSASSA-PKCS1-v1_5",
-    hash: { name: "SHA-256" },
-    publicExponent: new Uint8Array([1, 0, 1]),
-    modulusLength
-  };
-  const keys = await crypto3.subtle.generateKey(alg, true, ["sign", "verify"]);
-  return keys;
-}
-async function generatePrivateKey(modulusLength = 2048) {
-  return (await generateKeyPair(modulusLength)).privateKey;
-}
-async function privateKeyToPEM(privateKey) {
-  const crypto3 = getCrypto();
-  const privDer = await crypto3.subtle.exportKey("pkcs8", privateKey);
-  const privPem = x5092.PemConverter.encode(privDer, "PRIVATE KEY");
-  return { privPem, privDer };
-}
-async function derToPrivateKey(privDer) {
-  const crypto3 = getCrypto();
-  return await crypto3.subtle.importKey(
-    "pkcs8",
-    privDer,
-    {
-      name: "RSASSA-PKCS1-v1_5",
-      hash: { name: "SHA-256" }
-    },
-    true,
-    [
-      "sign"
-      // "encrypt",
-      // "decrypt",
-      // "verify",
-      //    "wrapKey",
-      //    "unwrapKey",
-      //    "deriveKey",
-      //    "deriveBits"
-    ]
-  );
+    const extensionRequest = _readExtensionRequest(buf);
+    return { extensionRequest };
+  }
+  throw new Error("Invalid CSR or ");
 }
-async function pemToPrivateKey(pem) {
-  const privDer = x5092.PemConverter.decode(pem);
-  return derToPrivateKey(privDer[0]);
+function exploreCertificateSigningRequest(crl) {
+  const blockInfo = readTag(crl, 0);
+  const blocks = readStruct(crl, blockInfo);
+  const csrInfo = readCertificationRequestInfo(crl, blocks[0]);
+  return csrInfo;
+}
+
+// source/make_private_key_from_pem.ts
+function makePrivateKeyFromPem(privateKeyInPem) {
+  return { hidden: privateKeyInPem };
+}
+
+// source/make_private_key_thumbprint.ts
+function makePrivateKeyThumbPrint(privateKey) {
+  return Buffer.alloc(0);
 }
 
 // source/subject.ts
@@ -1790,11 +1704,180 @@ var Subject = class _Subject {
     return this.toStringInternal("/");
   }
   toString() {
-    const t = this.toStringForOPCUA();
-    return t ? "/" + t : t;
+    const t2 = this.toStringForOPCUA();
+    return t2 ? "/" + t2 : t2;
   }
 };
 
+// source/verify_certificate_signature.ts
+import { createVerify as createVerify2 } from "crypto";
+function verifyCertificateOrClrSignature(certificateOrCrl, parentCertificate) {
+  const block_info = readTag(certificateOrCrl, 0);
+  const blocks = readStruct(certificateOrCrl, block_info);
+  const bufferToBeSigned = certificateOrCrl.subarray(block_info.position, blocks[1].position - 2);
+  const signatureAlgorithm = readAlgorithmIdentifier(certificateOrCrl, blocks[1]);
+  const signatureValue = readSignatureValueBin(certificateOrCrl, blocks[2]);
+  const p = split_der(parentCertificate)[0];
+  const certPem = toPem(p, "CERTIFICATE");
+  const verify = createVerify2(signatureAlgorithm.identifier);
+  verify.update(bufferToBeSigned);
+  verify.end();
+  return verify.verify(certPem, signatureValue);
+}
+function verifyCertificateSignature(certificate, parentCertificate) {
+  return verifyCertificateOrClrSignature(certificate, parentCertificate);
+}
+function verifyCertificateRevocationListSignature(certificateRevocationList, parentCertificate) {
+  return verifyCertificateOrClrSignature(certificateRevocationList, parentCertificate);
+}
+async function verifyCertificateChain(certificateChain) {
+  for (let index = 1; index < certificateChain.length; index++) {
+    const cert = certificateChain[index - 1];
+    const certParent = certificateChain[index];
+    const certParentInfo = exploreCertificate(certParent);
+    const keyUsage = certParentInfo.tbsCertificate.extensions.keyUsage;
+    if (!keyUsage.keyCertSign) {
+      return {
+        status: "BadCertificateIssuerUseNotAllowed",
+        reason: "One of the certificate in the chain has not keyUsage set for Certificate Signing"
+      };
+    }
+    const parentSignChild = verifyCertificateSignature(cert, certParent);
+    if (!parentSignChild) {
+      return {
+        status: "BadCertificateInvalid",
+        reason: "One of the certificate in the chain is not signing the previous certificate"
+      };
+    }
+    const certInfo = exploreCertificate(cert);
+    if (!certInfo.tbsCertificate.extensions) {
+      return {
+        status: "BadCertificateInvalid",
+        reason: "Cannot find X409 Extension 3 in certificate"
+      };
+    }
+    if (!certParentInfo.tbsCertificate.extensions || !certInfo.tbsCertificate.extensions.authorityKeyIdentifier) {
+      return {
+        status: "BadCertificateInvalid",
+        reason: "Cannot find X409 Extension 3 in certificate (parent)"
+      };
+    }
+    if (certParentInfo.tbsCertificate.extensions.subjectKeyIdentifier !== certInfo.tbsCertificate.extensions.authorityKeyIdentifier.keyIdentifier) {
+      return {
+        status: "BadCertificateInvalid",
+        reason: "subjectKeyIdentifier authorityKeyIdentifier in child certificate do not match subjectKeyIdentifier of parent certificate"
+      };
+    }
+  }
+  return {
+    status: "Good",
+    reason: `certificate chain is valid(length = ${certificateChain.length})`
+  };
+}
+
+// source/x509/_crypto.ts
+import * as x509 from "@peculiar/x509";
+import { Crypto as PeculiarWebCrypto } from "@peculiar/webcrypto";
+import nativeCrypto from "crypto";
+import * as x5092 from "@peculiar/x509";
+var doDebug3 = false;
+var _crypto;
+var ignoreCrypto = process.env.IGNORE_SUBTLE_FROM_CRYPTO;
+if (typeof window === "undefined") {
+  _crypto = nativeCrypto;
+  if (!_crypto?.subtle || ignoreCrypto) {
+    _crypto = new PeculiarWebCrypto();
+    doDebug3 && console.warn("using @peculiar/webcrypto");
+  } else {
+    doDebug3 && console.warn("using nodejs crypto (native)");
+  }
+  x509.cryptoProvider.set(_crypto);
+} else {
+  doDebug3 && console.warn("using browser crypto (native)");
+  _crypto = crypto;
+  x509.cryptoProvider.set(crypto);
+}
+function getCrypto() {
+  return _crypto || crypto || __require("crypto");
+}
+
+// source/x509/create_key_pair.ts
+async function generateKeyPair(modulusLength = 2048) {
+  const crypto3 = getCrypto();
+  const alg = {
+    name: "RSASSA-PKCS1-v1_5",
+    hash: { name: "SHA-256" },
+    publicExponent: new Uint8Array([1, 0, 1]),
+    modulusLength
+  };
+  const keys = await crypto3.subtle.generateKey(alg, true, ["sign", "verify"]);
+  return keys;
+}
+async function generatePrivateKey(modulusLength = 2048) {
+  return (await generateKeyPair(modulusLength)).privateKey;
+}
+async function privateKeyToPEM(privateKey) {
+  const crypto3 = getCrypto();
+  const privDer = await crypto3.subtle.exportKey("pkcs8", privateKey);
+  const privPem = x5092.PemConverter.encode(privDer, "PRIVATE KEY");
+  return { privPem, privDer };
+}
+async function derToPrivateKey(privDer) {
+  const crypto3 = getCrypto();
+  return await crypto3.subtle.importKey(
+    "pkcs8",
+    privDer,
+    {
+      name: "RSASSA-PKCS1-v1_5",
+      hash: { name: "SHA-256" }
+    },
+    true,
+    [
+      "sign"
+      // "encrypt",
+      // "decrypt",
+      // "verify",
+      //    "wrapKey",
+      //    "unwrapKey",
+      //    "deriveKey",
+      //    "deriveBits"
+    ]
+  );
+}
+async function pemToPrivateKey(pem) {
+  const privDer = x5092.PemConverter.decode(pem);
+  return derToPrivateKey(privDer[0]);
+}
+
+// source/x509/coerce_private_key.ts
+var crypto2 = getCrypto();
+var doDebug4 = false;
+function coercePEMorDerToPrivateKey(privateKeyInDerOrPem) {
+  if (typeof privateKeyInDerOrPem === "string") {
+    const hidden = createPrivateKeyFromNodeJSCrypto(privateKeyInDerOrPem);
+    return { hidden };
+  }
+  throw new Error("not implemented");
+}
+async function _coercePrivateKey(privateKey) {
+  const KeyObject4 = crypto2.KeyObject;
+  if (privateKey instanceof Buffer) {
+    const privateKey1 = await derToPrivateKey(privateKey);
+    return KeyObject4.from(privateKey1);
+  } else if (typeof privateKey === "string") {
+    try {
+      const privateKey1 = await pemToPrivateKey(privateKey);
+      return KeyObject4.from(privateKey1);
+    } catch (err) {
+      doDebug4 && console.log(privateKey);
+      throw err;
+    }
+  } else if (privateKey instanceof KeyObject4) {
+    return privateKey;
+  }
+  throw new Error("Invalid privateKey");
+}
+
 // source/x509/_get_attributes.ts
 var keyUsageApplication = x5092.KeyUsageFlags.keyEncipherment | x5092.KeyUsageFlags.nonRepudiation | x5092.KeyUsageFlags.dataEncipherment | x5092.KeyUsageFlags.keyCertSign | x5092.KeyUsageFlags.digitalSignature;
 var keyUsageCA = x5092.KeyUsageFlags.keyCertSign | x5092.KeyUsageFlags.cRLSign;
@@ -6060,69 +6143,12 @@ async function createSelfSignedCertificate({
   return { cert: cert.toString("pem"), der: cert };
 }
 
-// source/x509/coerce_private_key.ts
-var crypto2 = getCrypto();
-var doDebug4 = false;
-function coercePEMorDerToPrivateKey(privateKeyInDerOrPem) {
-  if (typeof privateKeyInDerOrPem === "string") {
-    const hidden = createPrivateKeyFromNodeJSCrypto(privateKeyInDerOrPem);
-    return { hidden };
-  }
-  throw new Error("not implemented");
-}
-async function _coercePrivateKey(privateKey) {
-  const KeyObject4 = crypto2.KeyObject;
-  if (privateKey instanceof Buffer) {
-    const privateKey1 = await derToPrivateKey(privateKey);
-    return KeyObject4.from(privateKey1);
-  } else if (typeof privateKey === "string") {
-    try {
-      const privateKey1 = await pemToPrivateKey(privateKey);
-      return KeyObject4.from(privateKey1);
-    } catch (err) {
-      doDebug4 && console.log(privateKey);
-      throw err;
-    }
-  } else if (privateKey instanceof KeyObject4) {
-    return privateKey;
-  }
-  throw new Error("Invalid privateKey");
-}
-
-// source/make_private_key_from_pem.ts
-function makePrivateKeyFromPem(privateKeyInPem) {
-  return { hidden: privateKeyInPem };
-}
-
 export {
   __dirname,
-  createPrivateKeyFromNodeJSCrypto,
-  isKeyObject,
-  CertificatePurpose,
-  TagType,
   readTag,
-  _readStruct,
-  parseBitString,
-  _readBitString,
-  formatBuffer2DigitHexWithColum,
-  _readOctetString,
-  _getBlock,
-  _readIntegerAsByteString,
-  _readListOfInteger,
-  _readObjectIdentifier,
-  _readAlgorithmIdentifier,
-  _readECCAlgorithmIdentifier,
-  _readSignatureValueBin,
-  _readSignatureValue,
-  _readLongIntegerValue,
-  _readIntegerValue,
-  _readBooleanValue,
-  _readVersionValue,
-  _readValue,
-  compactDirectoryName,
-  _readDirectoryName,
-  _findBlockAtIndex,
-  _readTime,
+  readStruct,
+  readAlgorithmIdentifier,
+  readSignatureValueBin,
   _readExtension,
   readTbsCertificate,
   exploreCertificate,
@@ -6148,6 +6174,19 @@ export {
   coerceCertificatePem,
   extractPublicKeyFromCertificateSync,
   extractPublicKeyFromCertificate,
+  explorePrivateKey,
+  publicKeyAndPrivateKeyMatches,
+  certificateMatchesPrivateKey,
+  createPrivateKeyFromNodeJSCrypto,
+  isKeyObject,
+  CertificatePurpose,
+  rsaLengthPrivateKey,
+  toPem2,
+  coercePrivateKeyPem,
+  coercePublicKeyPem,
+  coerceRsaPublicKeyPem,
+  rsaLengthPublicKey,
+  rsaLengthRsaPublicKey,
   coerceCertificate,
   exploreCertificateInfo,
   makePseudoRandomBuffer,
@@ -6160,35 +6199,27 @@ export {
   decryptBufferWithDerivedKeys,
   makeMessageChunkSignatureWithDerivedKeys,
   verifyChunkSignatureWithDerivedKeys,
-  rsaLengthPrivateKey,
-  toPem2,
-  coercePrivateKeyPem,
-  coercePublicKeyPem,
-  coerceRsaPublicKeyPem,
-  rsaLengthPublicKey,
-  rsaLengthRsaPublicKey,
-  verifyCertificateOrClrSignature,
-  verifyCertificateSignature,
-  verifyCertificateRevocationListSignature,
-  verifyCertificateChain,
+  exploreAsn1,
   readNameForCrl,
   exploreCertificateRevocationList,
   readCertificationRequestInfo,
   exploreCertificateSigningRequest,
-  explorePrivateKey,
-  publicKeyAndPrivateKeyMatches,
-  certificateMatchesPrivateKey,
+  makePrivateKeyFromPem,
+  makePrivateKeyThumbPrint,
+  Subject,
+  verifyCertificateOrClrSignature,
+  verifyCertificateSignature,
+  verifyCertificateRevocationListSignature,
+  verifyCertificateChain,
   generateKeyPair,
   generatePrivateKey,
   privateKeyToPEM,
   derToPrivateKey,
   pemToPrivateKey,
-  Subject,
-  createCertificateSigningRequest,
-  createSelfSignedCertificate,
   coercePEMorDerToPrivateKey,
   _coercePrivateKey,
-  makePrivateKeyFromPem
+  createCertificateSigningRequest,
+  createSelfSignedCertificate
 };
 /*! Bundled license information:
 
@@ -6258,4 +6289,4 @@ asn1js/build/index.es.js:
    * 
    *)
 */
-//# sourceMappingURL=chunk-WLW5XUML.mjs.map
+//# sourceMappingURL=chunk-2RCYFHGG.mjs.map