pptx-viewer-core 1.2.5 → 1.2.7

package/dist/signature-node/index.mjs

@@ -1,9 +1,9 @@
 import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
 import { SignedXml } from 'xml-crypto';
-import crypto from 'crypto';
+import crypto2 from 'crypto';
 import path from 'path';
 import tls from 'tls';
-import forge from 'node-forge';
+import forge3 from 'node-forge';
 import http from 'http';
 import https from 'https';
 import fs from 'fs/promises';
@@ -206,6 +206,89 @@ function canonicalizeSignedInfoXml(signedInfoXml) {
   }
   return canonicalizeNode(signedInfoDoc.documentElement, "http://www.w3.org/2001/10/xml-exc-c14n#");
 }
+
+// src/signature-node/pem-utils.ts
+function firstPemBlockForLabel(text, label) {
+  const begin = `-----BEGIN ${label}-----`;
+  const end = `-----END ${label}-----`;
+  const beginIndex = text.indexOf(begin);
+  if (beginIndex === -1) {
+    return void 0;
+  }
+  const endIndex = text.indexOf(end, beginIndex + begin.length);
+  if (endIndex === -1) {
+    return void 0;
+  }
+  return { index: beginIndex, block: text.slice(beginIndex, endIndex + end.length) };
+}
+function extractPemBlocks(text, label) {
+  const begin = `-----BEGIN ${label}-----`;
+  const end = `-----END ${label}-----`;
+  const blocks = [];
+  let searchFrom = 0;
+  for (; ; ) {
+    const beginIndex = text.indexOf(begin, searchFrom);
+    if (beginIndex === -1) {
+      break;
+    }
+    const contentStart = beginIndex + begin.length;
+    const endIndex = text.indexOf(end, contentStart);
+    if (endIndex === -1) {
+      break;
+    }
+    blocks.push(text.slice(beginIndex, endIndex + end.length));
+    searchFrom = endIndex + end.length;
+  }
+  return blocks;
+}
+function extractFirstPemBlock(text, labels) {
+  let best;
+  for (const label of labels) {
+    const found = firstPemBlockForLabel(text, label);
+    if (found && (!best || found.index < best.index)) {
+      best = found;
+    }
+  }
+  return best?.block;
+}
+
+// src/signature-node/timestamp-tag-scanner.ts
+var MAX_TAG_WINDOW = 256;
+var OPEN_TAG_PATTERN = /^<(?:[\w.-]+:)?(?:EncapsulatedTimeStamp|SignatureTimeStamp)\b[^>]*>/i;
+var CLOSE_TAG_PATTERN = /^<\/(?:[\w.-]+:)?(?:EncapsulatedTimeStamp|SignatureTimeStamp)>/i;
+function findCloseTagIndex(xml, fromIndex) {
+  let searchFrom = fromIndex;
+  for (; ; ) {
+    const ltIndex = xml.indexOf("<", searchFrom);
+    if (ltIndex === -1) {
+      return void 0;
+    }
+    const window = xml.slice(ltIndex, ltIndex + MAX_TAG_WINDOW);
+    if (CLOSE_TAG_PATTERN.test(window)) {
+      return ltIndex;
+    }
+    searchFrom = ltIndex + 1;
+  }
+}
+function findTimestampTagContent(xml) {
+  let searchFrom = 0;
+  for (; ; ) {
+    const ltIndex = xml.indexOf("<", searchFrom);
+    if (ltIndex === -1) {
+      return void 0;
+    }
+    const window = xml.slice(ltIndex, ltIndex + MAX_TAG_WINDOW);
+    const openMatch = OPEN_TAG_PATTERN.exec(window);
+    if (openMatch) {
+      const contentStart = ltIndex + openMatch[0].length;
+      const closeIndex = findCloseTagIndex(xml, contentStart);
+      return closeIndex === void 0 ? void 0 : xml.slice(contentStart, closeIndex);
+    }
+    searchFrom = ltIndex + 1;
+  }
+}
+
+// src/signature-node/pki-validation.ts
 function certPemFromBase64(certBase64) {
   try {
     const der = Buffer.from(certBase64, "base64");
@@ -226,7 +309,7 @@ ${lines.join("\n")}
 }
 function certFingerprintSha256(certPem) {
   try {
-    const cert = new crypto.X509Certificate(certPem);
+    const cert = new crypto2.X509Certificate(certPem);
     return cert.fingerprint256.replace(/:/g, "").toLowerCase();
   } catch {
     return void 0;
@@ -235,12 +318,173 @@ function certFingerprintSha256(certPem) {
 function asn1Child(node, index) {
   return Array.isArray(node.value) ? node.value[index] : void 0;
 }
+async function evaluateTimestampAuthority(signatureXml) {
+  try {
+    const content = findTimestampTagContent(signatureXml);
+    if (!content?.trim()) {
+      return { status: "not-present" };
+    }
+    const tokenBase64 = content.replace(/\s+/g, "");
+    const tokenDer = Buffer.from(tokenBase64, "base64");
+    if (tokenDer.length === 0) {
+      return { status: "invalid", error: "Empty timestamp token." };
+    }
+    const asn1 = forge3.asn1.fromDer(forge3.util.createBuffer(tokenDer.toString("binary")));
+    const contentType = asn1Child(asn1, 0);
+    if (!contentType) {
+      return {
+        status: "invalid",
+        error: "Malformed timestamp token structure."
+      };
+    }
+    return { status: "valid" };
+  } catch (err) {
+    return {
+      status: "error",
+      error: `Timestamp evaluation failed: ${String(err)}`
+    };
+  }
+}
+
+// src/signature-node/certificate-utils.ts
+var PRIVATE_KEY_PEM_LABELS = [
+  "RSA PRIVATE KEY",
+  "EC PRIVATE KEY",
+  "ENCRYPTED PRIVATE KEY",
+  "PRIVATE KEY"
+];
+function certificateInfoFromBase64(certBase64) {
+  try {
+    const certificate = new crypto2.X509Certificate(Buffer.from(certBase64, "base64"));
+    return {
+      subject: certificate.subject || void 0,
+      issuer: certificate.issuer || void 0,
+      serialNumber: certificate.serialNumber || void 0,
+      validFrom: certificate.validFrom || void 0,
+      validTo: certificate.validTo || void 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+function validateCertificateChain(certBase64List, additionalRootsPem) {
+  if (certBase64List.length === 0) {
+    return { status: "not-checked" };
+  }
+  try {
+    const chain = certBase64List.map((value) => {
+      const der = forge3.util.decode64(value);
+      return forge3.pki.certificateFromAsn1(forge3.asn1.fromDer(der));
+    });
+    const rootPem = [...tls.rootCertificates, ...additionalRootsPem];
+    const caStore = forge3.pki.createCaStore(rootPem);
+    const verified = forge3.pki.verifyCertificateChain(caStore, chain);
+    return verified ? { status: "trusted" } : {
+      status: "untrusted",
+      error: "Certificate chain is not trusted."
+    };
+  } catch (error) {
+    return {
+      status: "untrusted",
+      error: `Certificate trust validation failed: ${String(error)}`
+    };
+  }
+}
+function signatureAlgorithmToVerifyAlgorithm(signatureMethod) {
+  switch (signatureMethod) {
+    case "http://www.w3.org/2000/09/xmldsig#rsa-sha1":
+      return "RSA-SHA1";
+    case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256":
+      return "RSA-SHA256";
+    case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha384":
+      return "RSA-SHA384";
+    case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha512":
+      return "RSA-SHA512";
+    default:
+      return void 0;
+  }
+}
+function verifySignatureValue(signatureXml, certBase64List) {
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(signatureXml, "text/xml");
+    const signatureNode = doc.getElementsByTagNameNS(XMLDSIG_NS, "Signature")[0];
+    if (!signatureNode) {
+      return "not-checked";
+    }
+    const certPem = certBase64List.length > 0 ? certPemFromBase64(certBase64List[0]) : void 0;
+    if (!certPem) {
+      return "not-checked";
+    }
+    const signedInfoNode = doc.getElementsByTagNameNS(XMLDSIG_NS, "SignedInfo")[0];
+    const signatureValueNode = doc.getElementsByTagNameNS(XMLDSIG_NS, "SignatureValue")[0];
+    if (!signedInfoNode || !signatureValueNode) {
+      return "invalid";
+    }
+    const canonicalizationMethod = doc.getElementsByTagNameNS(XMLDSIG_NS, "CanonicalizationMethod").item(0)?.getAttribute("Algorithm") ?? "http://www.w3.org/2001/10/xml-exc-c14n#";
+    const signatureMethod = doc.getElementsByTagNameNS(XMLDSIG_NS, "SignatureMethod").item(0)?.getAttribute("Algorithm");
+    const verifyAlgorithm = signatureAlgorithmToVerifyAlgorithm(signatureMethod ?? void 0);
+    if (!verifyAlgorithm) {
+      return "invalid";
+    }
+    const canonicalSignedInfo = canonicalizeNode(signedInfoNode, canonicalizationMethod);
+    const signatureValueBase64 = signatureValueNode.textContent?.replace(/\s+/g, "").trim() ?? "";
+    if (signatureValueBase64.length === 0) {
+      return "invalid";
+    }
+    const verifier = crypto2.createVerify(verifyAlgorithm);
+    verifier.update(Buffer.from(canonicalSignedInfo, "utf8"));
+    verifier.end();
+    const isValid = verifier.verify(certPem, Buffer.from(signatureValueBase64, "base64"));
+    return isValid ? "verified" : "invalid";
+  } catch {
+    return "invalid";
+  }
+}
+function loadSigningMaterialFromBuffer(certificateBuffer, certificatePath, certificatePassword) {
+  const extension = path.extname(certificatePath).toLowerCase();
+  if (extension === ".pfx" || extension === ".p12") {
+    const p12Der = forge3.util.createBuffer(Buffer.from(certificateBuffer).toString("binary"));
+    const p12Asn1 = forge3.asn1.fromDer(p12Der);
+    const p12 = forge3.pkcs12.pkcs12FromAsn1(p12Asn1, certificatePassword || "");
+    const keyBag = p12.getBags({
+      bagType: forge3.pki.oids.pkcs8ShroudedKeyBag
+    })[forge3.pki.oids.pkcs8ShroudedKeyBag];
+    const certBag = p12.getBags({ bagType: forge3.pki.oids.certBag })[forge3.pki.oids.certBag];
+    if (!keyBag || keyBag.length === 0 || !keyBag[0]?.key) {
+      throw new Error("No private key found in PKCS#12 certificate.");
+    }
+    if (!certBag || certBag.length === 0 || !certBag[0]?.cert) {
+      throw new Error("No certificate found in PKCS#12 certificate.");
+    }
+    return {
+      privateKeyPem: forge3.pki.privateKeyToPem(keyBag[0].key),
+      certificatePem: forge3.pki.certificateToPem(certBag[0].cert)
+    };
+  }
+  const pem = Buffer.from(certificateBuffer).toString("utf8");
+  const privateKeyPem = extractFirstPemBlock(pem, PRIVATE_KEY_PEM_LABELS);
+  const certificatePem = extractFirstPemBlock(pem, ["CERTIFICATE"]);
+  if (!privateKeyPem || !certificatePem) {
+    throw new Error("PEM certificate must contain both private key and certificate.");
+  }
+  return {
+    privateKeyPem,
+    certificatePem
+  };
+}
+function pemCertificateToBase64(pem) {
+  return pem.replace(/-----BEGIN CERTIFICATE-----/g, "").replace(/-----END CERTIFICATE-----/g, "").replace(/\s+/g, "").trim();
+}
+function asn1Child2(node, index) {
+  return Array.isArray(node.value) ? node.value[index] : void 0;
+}
 function asn1Bytes(node) {
   return typeof node.value === "string" ? node.value : "";
 }
 function extractOcspUrls(certPem) {
   try {
-    const cert = new crypto.X509Certificate(certPem);
+    const cert = new crypto2.X509Certificate(certPem);
     const infoAccess = cert.infoAccess;
     if (!infoAccess) {
       return [];
@@ -303,45 +547,45 @@ function httpPost(url, body, contentType) {
 var SHA1_OID = "1.3.14.3.2.26";
 function buildOcspRequestDer(leafPem, issuerPem) {
   try {
-    const leaf = forge.pki.certificateFromPem(leafPem);
-    const issuer = forge.pki.certificateFromPem(issuerPem);
-    const issuerNameDer = forge.asn1.toDer(forge.pki.distinguishedNameToAsn1(issuer.subject)).getBytes();
-    const issuerNameHash = forge.md.sha1.create().update(issuerNameDer).digest().getBytes();
-    const pubKeyDer = forge.asn1.toDer(forge.pki.publicKeyToAsn1(issuer.publicKey)).getBytes();
-    const pubKeyAsn1 = forge.asn1.fromDer(pubKeyDer);
-    const bitString = asn1Child(pubKeyAsn1, 1);
+    const leaf = forge3.pki.certificateFromPem(leafPem);
+    const issuer = forge3.pki.certificateFromPem(issuerPem);
+    const issuerNameDer = forge3.asn1.toDer(forge3.pki.distinguishedNameToAsn1(issuer.subject)).getBytes();
+    const issuerNameHash = forge3.md.sha1.create().update(issuerNameDer).digest().getBytes();
+    const pubKeyDer = forge3.asn1.toDer(forge3.pki.publicKeyToAsn1(issuer.publicKey)).getBytes();
+    const pubKeyAsn1 = forge3.asn1.fromDer(pubKeyDer);
+    const bitString = asn1Child2(pubKeyAsn1, 1);
     const rawKey = bitString ? asn1Bytes(bitString).substring(1) : "";
-    const issuerKeyHash = forge.md.sha1.create().update(rawKey).digest().getBytes();
-    const serialBytes = forge.util.hexToBytes(leaf.serialNumber);
-    const request = forge.asn1.create(forge.asn1.Class.UNIVERSAL, forge.asn1.Type.SEQUENCE, true, [
-      forge.asn1.create(forge.asn1.Class.UNIVERSAL, forge.asn1.Type.SEQUENCE, true, [
-        forge.asn1.create(forge.asn1.Class.UNIVERSAL, forge.asn1.Type.SEQUENCE, true, [
-          forge.asn1.create(forge.asn1.Class.UNIVERSAL, forge.asn1.Type.SEQUENCE, true, [
-            forge.asn1.create(forge.asn1.Class.UNIVERSAL, forge.asn1.Type.SEQUENCE, true, [
-              forge.asn1.create(forge.asn1.Class.UNIVERSAL, forge.asn1.Type.SEQUENCE, true, [
-                forge.asn1.create(
-                  forge.asn1.Class.UNIVERSAL,
-                  forge.asn1.Type.OID,
+    const issuerKeyHash = forge3.md.sha1.create().update(rawKey).digest().getBytes();
+    const serialBytes = forge3.util.hexToBytes(leaf.serialNumber);
+    const request = forge3.asn1.create(forge3.asn1.Class.UNIVERSAL, forge3.asn1.Type.SEQUENCE, true, [
+      forge3.asn1.create(forge3.asn1.Class.UNIVERSAL, forge3.asn1.Type.SEQUENCE, true, [
+        forge3.asn1.create(forge3.asn1.Class.UNIVERSAL, forge3.asn1.Type.SEQUENCE, true, [
+          forge3.asn1.create(forge3.asn1.Class.UNIVERSAL, forge3.asn1.Type.SEQUENCE, true, [
+            forge3.asn1.create(forge3.asn1.Class.UNIVERSAL, forge3.asn1.Type.SEQUENCE, true, [
+              forge3.asn1.create(forge3.asn1.Class.UNIVERSAL, forge3.asn1.Type.SEQUENCE, true, [
+                forge3.asn1.create(
+                  forge3.asn1.Class.UNIVERSAL,
+                  forge3.asn1.Type.OID,
                   false,
-                  forge.asn1.oidToDer(SHA1_OID).getBytes()
+                  forge3.asn1.oidToDer(SHA1_OID).getBytes()
                 ),
-                forge.asn1.create(forge.asn1.Class.UNIVERSAL, forge.asn1.Type.NULL, false, "")
+                forge3.asn1.create(forge3.asn1.Class.UNIVERSAL, forge3.asn1.Type.NULL, false, "")
               ]),
-              forge.asn1.create(
-                forge.asn1.Class.UNIVERSAL,
-                forge.asn1.Type.OCTETSTRING,
+              forge3.asn1.create(
+                forge3.asn1.Class.UNIVERSAL,
+                forge3.asn1.Type.OCTETSTRING,
                 false,
                 issuerNameHash
               ),
-              forge.asn1.create(
-                forge.asn1.Class.UNIVERSAL,
-                forge.asn1.Type.OCTETSTRING,
+              forge3.asn1.create(
+                forge3.asn1.Class.UNIVERSAL,
+                forge3.asn1.Type.OCTETSTRING,
                 false,
                 issuerKeyHash
               ),
-              forge.asn1.create(
-                forge.asn1.Class.UNIVERSAL,
-                forge.asn1.Type.INTEGER,
+              forge3.asn1.create(
+                forge3.asn1.Class.UNIVERSAL,
+                forge3.asn1.Type.INTEGER,
                 false,
                 serialBytes
               )
@@ -350,50 +594,50 @@ function buildOcspRequestDer(leafPem, issuerPem) {
         ])
       ])
     ]);
-    return Buffer.from(forge.asn1.toDer(request).getBytes(), "binary");
+    return Buffer.from(forge3.asn1.toDer(request).getBytes(), "binary");
   } catch {
     return void 0;
   }
 }
 function parseOcspResponseStatus(data) {
   try {
-    const asn1 = forge.asn1.fromDer(forge.util.createBuffer(data.toString("binary")));
-    const statusNode = asn1Child(asn1, 0);
+    const asn1 = forge3.asn1.fromDer(forge3.util.createBuffer(data.toString("binary")));
+    const statusNode = asn1Child2(asn1, 0);
     if (!statusNode || asn1Bytes(statusNode) !== "\0") {
       return "error";
     }
-    const respBytesWrapper = asn1Child(asn1, 1);
+    const respBytesWrapper = asn1Child2(asn1, 1);
     if (!respBytesWrapper) {
       return "unknown";
     }
-    const respBytesSeq = asn1Child(respBytesWrapper, 0);
+    const respBytesSeq = asn1Child2(respBytesWrapper, 0);
     if (!respBytesSeq) {
       return "unknown";
     }
-    const respOctet = asn1Child(respBytesSeq, 1);
+    const respOctet = asn1Child2(respBytesSeq, 1);
     if (!respOctet) {
       return "unknown";
     }
-    const basicResp = forge.asn1.fromDer(forge.util.createBuffer(asn1Bytes(respOctet)));
-    const tbsData = asn1Child(basicResp, 0);
+    const basicResp = forge3.asn1.fromDer(forge3.util.createBuffer(asn1Bytes(respOctet)));
+    const tbsData = asn1Child2(basicResp, 0);
     if (!tbsData) {
       return "unknown";
     }
-    const first = asn1Child(tbsData, 0);
-    const responsesIdx = first?.tagClass === forge.asn1.Class.CONTEXT_SPECIFIC && first.type === 0 ? 3 : 2;
-    const responses = asn1Child(tbsData, responsesIdx);
+    const first = asn1Child2(tbsData, 0);
+    const responsesIdx = first?.tagClass === forge3.asn1.Class.CONTEXT_SPECIFIC && first.type === 0 ? 3 : 2;
+    const responses = asn1Child2(tbsData, responsesIdx);
     if (!responses) {
       return "unknown";
     }
-    const single = asn1Child(responses, 0);
+    const single = asn1Child2(responses, 0);
     if (!single) {
       return "unknown";
     }
-    const certStatus = asn1Child(single, 1);
+    const certStatus = asn1Child2(single, 1);
     if (!certStatus) {
       return "unknown";
     }
-    if (certStatus.tagClass === forge.asn1.Class.CONTEXT_SPECIFIC) {
+    if (certStatus.tagClass === forge3.asn1.Class.CONTEXT_SPECIFIC) {
       if (certStatus.type === 0) {
         return "good";
       }
@@ -436,164 +680,8 @@ async function evaluateCertificateRevocation(leafCertPem, issuerCertPem) {
     checkedCrlUrls
   };
 }
-var TIMESTAMP_TAG_REGEX = /<(?:[\w.-]+:)?(?:EncapsulatedTimeStamp|SignatureTimeStamp)[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?(?:EncapsulatedTimeStamp|SignatureTimeStamp)>/i;
-async function evaluateTimestampAuthority(signatureXml) {
-  try {
-    const match = TIMESTAMP_TAG_REGEX.exec(signatureXml);
-    if (!match?.[1]?.trim()) {
-      return { status: "not-present" };
-    }
-    const tokenBase64 = match[1].replace(/\s+/g, "");
-    const tokenDer = Buffer.from(tokenBase64, "base64");
-    if (tokenDer.length === 0) {
-      return { status: "invalid", error: "Empty timestamp token." };
-    }
-    const asn1 = forge.asn1.fromDer(forge.util.createBuffer(tokenDer.toString("binary")));
-    const contentType = asn1Child(asn1, 0);
-    if (!contentType) {
-      return {
-        status: "invalid",
-        error: "Malformed timestamp token structure."
-      };
-    }
-    return { status: "valid" };
-  } catch (err) {
-    return {
-      status: "error",
-      error: `Timestamp evaluation failed: ${String(err)}`
-    };
-  }
-}
-
-// src/signature-node/certificate-utils.ts
-function certificateInfoFromBase64(certBase64) {
-  try {
-    const certificate = new crypto.X509Certificate(Buffer.from(certBase64, "base64"));
-    return {
-      subject: certificate.subject || void 0,
-      issuer: certificate.issuer || void 0,
-      serialNumber: certificate.serialNumber || void 0,
-      validFrom: certificate.validFrom || void 0,
-      validTo: certificate.validTo || void 0
-    };
-  } catch {
-    return void 0;
-  }
-}
-function validateCertificateChain(certBase64List, additionalRootsPem) {
-  if (certBase64List.length === 0) {
-    return { status: "not-checked" };
-  }
-  try {
-    const chain = certBase64List.map((value) => {
-      const der = forge.util.decode64(value);
-      return forge.pki.certificateFromAsn1(forge.asn1.fromDer(der));
-    });
-    const rootPem = [...tls.rootCertificates, ...additionalRootsPem];
-    const caStore = forge.pki.createCaStore(rootPem);
-    const verified = forge.pki.verifyCertificateChain(caStore, chain);
-    return verified ? { status: "trusted" } : {
-      status: "untrusted",
-      error: "Certificate chain is not trusted."
-    };
-  } catch (error) {
-    return {
-      status: "untrusted",
-      error: `Certificate trust validation failed: ${String(error)}`
-    };
-  }
-}
-function signatureAlgorithmToVerifyAlgorithm(signatureMethod) {
-  switch (signatureMethod) {
-    case "http://www.w3.org/2000/09/xmldsig#rsa-sha1":
-      return "RSA-SHA1";
-    case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256":
-      return "RSA-SHA256";
-    case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha384":
-      return "RSA-SHA384";
-    case "http://www.w3.org/2001/04/xmldsig-more#rsa-sha512":
-      return "RSA-SHA512";
-    default:
-      return void 0;
-  }
-}
-function verifySignatureValue(signatureXml, certBase64List) {
-  try {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(signatureXml, "text/xml");
-    const signatureNode = doc.getElementsByTagNameNS(XMLDSIG_NS, "Signature")[0];
-    if (!signatureNode) {
-      return "not-checked";
-    }
-    const certPem = certBase64List.length > 0 ? certPemFromBase64(certBase64List[0]) : void 0;
-    if (!certPem) {
-      return "not-checked";
-    }
-    const signedInfoNode = doc.getElementsByTagNameNS(XMLDSIG_NS, "SignedInfo")[0];
-    const signatureValueNode = doc.getElementsByTagNameNS(XMLDSIG_NS, "SignatureValue")[0];
-    if (!signedInfoNode || !signatureValueNode) {
-      return "invalid";
-    }
-    const canonicalizationMethod = doc.getElementsByTagNameNS(XMLDSIG_NS, "CanonicalizationMethod").item(0)?.getAttribute("Algorithm") ?? "http://www.w3.org/2001/10/xml-exc-c14n#";
-    const signatureMethod = doc.getElementsByTagNameNS(XMLDSIG_NS, "SignatureMethod").item(0)?.getAttribute("Algorithm");
-    const verifyAlgorithm = signatureAlgorithmToVerifyAlgorithm(signatureMethod ?? void 0);
-    if (!verifyAlgorithm) {
-      return "invalid";
-    }
-    const canonicalSignedInfo = canonicalizeNode(signedInfoNode, canonicalizationMethod);
-    const signatureValueBase64 = signatureValueNode.textContent?.replace(/\s+/g, "").trim() ?? "";
-    if (signatureValueBase64.length === 0) {
-      return "invalid";
-    }
-    const verifier = crypto.createVerify(verifyAlgorithm);
-    verifier.update(Buffer.from(canonicalSignedInfo, "utf8"));
-    verifier.end();
-    const isValid = verifier.verify(certPem, Buffer.from(signatureValueBase64, "base64"));
-    return isValid ? "verified" : "invalid";
-  } catch {
-    return "invalid";
-  }
-}
-function loadSigningMaterialFromBuffer(certificateBuffer, certificatePath, certificatePassword) {
-  const extension = path.extname(certificatePath).toLowerCase();
-  if (extension === ".pfx" || extension === ".p12") {
-    const p12Der = forge.util.createBuffer(Buffer.from(certificateBuffer).toString("binary"));
-    const p12Asn1 = forge.asn1.fromDer(p12Der);
-    const p12 = forge.pkcs12.pkcs12FromAsn1(p12Asn1, certificatePassword || "");
-    const keyBag = p12.getBags({
-      bagType: forge.pki.oids.pkcs8ShroudedKeyBag
-    })[forge.pki.oids.pkcs8ShroudedKeyBag];
-    const certBag = p12.getBags({ bagType: forge.pki.oids.certBag })[forge.pki.oids.certBag];
-    if (!keyBag || keyBag.length === 0 || !keyBag[0]?.key) {
-      throw new Error("No private key found in PKCS#12 certificate.");
-    }
-    if (!certBag || certBag.length === 0 || !certBag[0]?.cert) {
-      throw new Error("No certificate found in PKCS#12 certificate.");
-    }
-    return {
-      privateKeyPem: forge.pki.privateKeyToPem(keyBag[0].key),
-      certificatePem: forge.pki.certificateToPem(certBag[0].cert)
-    };
-  }
-  const pem = Buffer.from(certificateBuffer).toString("utf8");
-  const privateKeyMatch = pem.match(
-    /-----BEGIN (?:RSA |EC |ENCRYPTED )?PRIVATE KEY-----[\s\S]+?-----END (?:RSA |EC |ENCRYPTED )?PRIVATE KEY-----/m
-  );
-  const certMatch = pem.match(/-----BEGIN CERTIFICATE-----[\s\S]+?-----END CERTIFICATE-----/m);
-  if (!privateKeyMatch || !certMatch) {
-    throw new Error("PEM certificate must contain both private key and certificate.");
-  }
-  return {
-    privateKeyPem: privateKeyMatch[0],
-    certificatePem: certMatch[0]
-  };
-}
-function pemCertificateToBase64(pem) {
-  return pem.replace(/-----BEGIN CERTIFICATE-----/g, "").replace(/-----END CERTIFICATE-----/g, "").replace(/\s+/g, "").trim();
-}
 function extractPemCertificatesFromText(text) {
-  const matches = text.match(/-----BEGIN CERTIFICATE-----[\s\S]*?-----END CERTIFICATE-----/g) ?? [];
-  return matches.map((value) => value.trim()).filter((value) => value.length > 0);
+  return extractPemBlocks(text, "CERTIFICATE").map((value) => value.trim()).filter((value) => value.length > 0);
 }
 function parseBooleanEnv(envValue) {
   if (!envValue) {
@@ -734,7 +822,7 @@ function computeDigestBase642(content, digestAlgorithmUri) {
   if (!hashName) {
     return void 0;
   }
-  return crypto.createHash(hashName).update(Buffer.from(content)).digest("base64");
+  return crypto2.createHash(hashName).update(Buffer.from(content)).digest("base64");
 }
 async function buildReferenceChecksFromSignatureXml(zip, signatureXml) {
   const parser = new DOMParser();
@@ -1067,7 +1155,7 @@ async function buildOfficeReferenceList(zip) {
       continue;
     }
     const entryBytes = await entry.async("uint8array");
-    const digestValue = crypto.createHash("sha256").update(Buffer.from(entryBytes)).digest("base64");
+    const digestValue = crypto2.createHash("sha256").update(Buffer.from(entryBytes)).digest("base64");
     references.push({
       uri: `/${normalizePartPath(entryPath)}`,
       digestMethod,
@@ -1083,7 +1171,7 @@ function buildOfficeSignatureXml(references, privateKeyPem, certificatePem) {
   ).join("");
   const signedInfoXml = `<SignedInfo xmlns="${XMLDSIG_NS}"><CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/><SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/>${signedInfoReferencesXml}</SignedInfo>`;
   const canonicalSignedInfo = canonicalizeSignedInfoXml(signedInfoXml);
-  const signer = crypto.createSign("RSA-SHA256");
+  const signer = crypto2.createSign("RSA-SHA256");
   signer.update(Buffer.from(canonicalSignedInfo, "utf8"));
   signer.end();
   const signatureValueBase64 = signer.sign(privateKeyPem).toString("base64");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pptx-viewer-core",
-	"version": "1.2.5",
+	"version": "1.2.7",
 	"description": "PowerPoint PPTX engine: parse, edit, serialize, and convert .pptx files. Framework-agnostic TypeScript SDK.",
 	"keywords": [
 		"angular",