ooxml-core 1.12.2 → 1.14.0

package/dist/crypto/index.mjs

@@ -1,3 +1,5 @@
+import { DOMParser } from '@xmldom/xmldom';
+
 // ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/ole2-parser-types.js
 var OLE_MAGIC = new Uint8Array([208, 207, 17, 224, 161, 177, 26, 225]);
 var ENDOFCHAIN = 4294967294;
@@ -553,6 +555,14 @@ async function hmac(algorithm, key, data) {
   return new Uint8Array(result);
 }
 
+// digest/timing-safe.ts
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let difference = 0;
+  for (let i2 = 0; i2 < a.length; i2++) difference |= a[i2] ^ b[i2];
+  return difference === 0;
+}
+
 // crypto/aes-ecb.ts
 var BLOCK = 16;
 var BATCH = 4096;
@@ -2336,6 +2346,14 @@ function digestFunction(name) {
   return canonical && DIGESTS[canonical];
 }
 
+// digest/password-hash.ts
+var MAX_SPIN_COUNT = 1e7;
+var DEFAULT_MAX_SPIN_COUNT = 1e6;
+function isValidSpinCount(spinCount, maxSpinCount = DEFAULT_MAX_SPIN_COUNT) {
+  const limit = Math.min(maxSpinCount, MAX_SPIN_COUNT);
+  return spinCount === void 0 || Number.isInteger(spinCount) && spinCount >= 0 && spinCount <= limit;
+}
+
 // crypto/key-derivation.ts
 var BLOCK_KEYS = {
   verifierHashInput: new Uint8Array([254, 167, 210, 118, 59, 75, 158, 121]),
@@ -2344,9 +2362,9 @@ var BLOCK_KEYS = {
   dataIntegrityHmacKey: new Uint8Array([95, 178, 173, 1, 12, 185, 225, 246]),
   dataIntegrityHmacValue: new Uint8Array([160, 103, 127, 2, 178, 44, 132, 51])
 };
-var MAX_SPIN_COUNT = 1e7;
-async function spinPassword(password, salt, spinCount, hashAlgorithm) {
-  if (!Number.isInteger(spinCount) || spinCount < 0 || spinCount > MAX_SPIN_COUNT) {
+var SPIN_CHUNK = 1e5;
+async function spinPassword(password, salt, spinCount, hashAlgorithm, limits = {}) {
+  if (!isValidSpinCount(spinCount, limits.maxSpinCount)) {
     throw new Error(`Unsupported encryption spin count: ${spinCount}.`);
   }
   const passwordBytes = encodePasswordUtf16LE(password);
@@ -2359,6 +2377,9 @@ async function spinPassword(password, salt, spinCount, hashAlgorithm) {
       view.setUint32(0, i2, true);
       buffer.set(h3, 4);
       h3 = digest(buffer);
+      if (i2 % SPIN_CHUNK === SPIN_CHUNK - 1 && i2 + 1 < spinCount) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      }
     }
     return h3;
   }
@@ -2377,8 +2398,8 @@ async function extendKey(h2, hashAlgorithm, keyLength) {
   const x3 = concatArrays(await pad2(54), await pad2(92));
   return x3.subarray(0, keyLength);
 }
-function computeAgileKeyBase(password, salt, spinCount, hashAlgorithm) {
-  return spinPassword(password, salt, spinCount, hashAlgorithm);
+function computeAgileKeyBase(password, salt, spinCount, hashAlgorithm, limits = {}) {
+  return spinPassword(password, salt, spinCount, hashAlgorithm, limits);
 }
 async function deriveAgileKeyFromBase(base, hashAlgorithm, blockKey, keyBits, hashSize) {
   const h2 = await hash(hashAlgorithm, concatArrays(base, blockKey));
@@ -2409,10 +2430,82 @@ async function generateIV(hashAlgorithm, salt, blockKey, blockSize) {
   return padded;
 }
 
+// crypto/validate.ts
+var AGILE_DIGEST_LENGTH = {
+  "SHA-1": 20,
+  "SHA-256": 32,
+  "SHA-384": 48,
+  "SHA-512": 64
+};
+function agileDigestLength(hashAlgorithm) {
+  const name = normalizeDigestAlgorithmName(hashAlgorithm);
+  return name === void 0 ? void 0 : AGILE_DIGEST_LENGTH[name];
+}
+var KEY_BITS = /* @__PURE__ */ new Set([128, 192, 256]);
+function assertBlock(block, what) {
+  if (block.cipherAlgorithm !== "AES") {
+    throw new Error(`Unsupported ${what} cipherAlgorithm: ${block.cipherAlgorithm}.`);
+  }
+  if (block.cipherChaining !== "ChainingModeCBC") {
+    throw new Error(`Unsupported ${what} cipherChaining: ${block.cipherChaining}.`);
+  }
+  const digestLength = agileDigestLength(block.hashAlgorithm);
+  if (digestLength === void 0) {
+    throw new Error(`Unsupported ${what} hashAlgorithm: ${block.hashAlgorithm}.`);
+  }
+  if (block.hashSize !== digestLength) {
+    throw new Error(
+      `Invalid ${what} hashSize ${block.hashSize}: ${block.hashAlgorithm} produces ${digestLength} bytes.`
+    );
+  }
+  if (!KEY_BITS.has(block.keyBits)) throw new Error(`Invalid ${what} keyBits: ${block.keyBits}.`);
+  if (block.blockSize !== 16) throw new Error(`Invalid ${what} blockSize: ${block.blockSize}.`);
+  if (!Number.isInteger(block.saltSize) || block.saltSize <= 0 || block.saltSize > 64) {
+    throw new Error(`Invalid ${what} saltSize: ${block.saltSize}.`);
+  }
+  if (block.saltValue.length !== block.saltSize) {
+    throw new Error(`The ${what} saltValue does not match its saltSize.`);
+  }
+}
+function assertValidAgileEncryptionInfo(info) {
+  assertBlock(info.keyData, "keyData");
+  const pke = info.passwordKeyEncryptor;
+  assertBlock(pke, "password key encryptor");
+  if (!Number.isInteger(pke.spinCount) || pke.spinCount < 0) {
+    throw new Error(`Invalid spinCount: ${pke.spinCount}.`);
+  }
+  if (pke.saltSize > pke.hashSize) {
+    throw new Error(`Invalid password key encryptor saltSize: ${pke.saltSize}.`);
+  }
+}
+function assertValidStandardEncryptionInfo(info) {
+  if (!KEY_BITS.has(info.header.keySize)) {
+    throw new Error(`Invalid Standard encryption keySize: ${info.header.keySize}.`);
+  }
+  if (info.verifier.salt.length !== 16 || info.verifier.saltSize !== 16) {
+    throw new Error(`Invalid Standard encryption saltSize: ${info.verifier.saltSize}.`);
+  }
+  if (info.verifier.verifierHashSize !== 20) {
+    throw new Error(
+      `Invalid Standard encryption verifierHashSize: ${info.verifier.verifierHashSize}.`
+    );
+  }
+  if (info.verifier.encryptedVerifier.length !== 16 || info.verifier.encryptedVerifierHash.length < 20) {
+    throw new Error("The Standard encryption verifier is truncated.");
+  }
+}
+
 // crypto/decrypt.ts
-async function verifyAgilePassword(info, password) {
+async function verifyAgilePassword(info, password, limits = {}) {
+  assertValidAgileEncryptionInfo(info);
   const pke = info.passwordKeyEncryptor;
-  const base = await computeAgileKeyBase(password, pke.saltValue, pke.spinCount, pke.hashAlgorithm);
+  const base = await computeAgileKeyBase(
+    password,
+    pke.saltValue,
+    pke.spinCount,
+    pke.hashAlgorithm,
+    limits
+  );
   const blockKey = (block) => deriveAgileKeyFromBase(base, pke.hashAlgorithm, block, pke.keyBits, pke.hashSize);
   const verifierHashInput = await aesCbcDecryptRaw(
     await blockKey(BLOCK_KEYS.verifierHashInput),
@@ -2425,10 +2518,8 @@ async function verifyAgilePassword(info, password) {
     pke.encryptedVerifierHashValue
   );
   const computedHash = await hash(pke.hashAlgorithm, verifierHashInput.subarray(0, pke.saltSize));
-  if (computedHash.length < pke.hashSize || verifierHashValue.length < pke.hashSize) return null;
-  let difference = 0;
-  for (let i2 = 0; i2 < pke.hashSize; i2++) difference |= verifierHashValue[i2] ^ computedHash[i2];
-  if (difference !== 0) return null;
+  if (computedHash.length !== pke.hashSize || verifierHashValue.length < pke.hashSize) return null;
+  if (!timingSafeEqual(verifierHashValue.subarray(0, pke.hashSize), computedHash)) return null;
   const decryptedKey = await aesCbcDecryptRaw(
     await blockKey(BLOCK_KEYS.encryptedKeyValue),
     pke.saltValue,
@@ -2437,6 +2528,7 @@ async function verifyAgilePassword(info, password) {
   return decryptedKey.subarray(0, info.keyData.keyBits / 8);
 }
 async function verifyStandardPassword(info, password) {
+  assertValidStandardEncryptionInfo(info);
   const key = await deriveStandardKey(
     password,
     info.verifier.salt,
@@ -2446,20 +2538,16 @@ async function verifyStandardPassword(info, password) {
   const decryptedVerifier = await aesEcbDecrypt(key, info.verifier.encryptedVerifier);
   const decryptedHash = await aesEcbDecrypt(key, info.verifier.encryptedVerifierHash);
   const computedHash = await hash("SHA-1", decryptedVerifier);
-  const hashSize = info.verifier.verifierHashSize;
-  let match = true;
-  for (let i2 = 0; i2 < Math.min(hashSize, 20); i2++) {
-    if (computedHash[i2] !== decryptedHash[i2]) {
-      match = false;
-      break;
-    }
-  }
+  const match = timingSafeEqual(decryptedHash.subarray(0, 20), computedHash);
   return match ? key : null;
 }
-async function verifyAgileDataIntegrity(info, key, encryptedPackage) {
+async function verifyAgileDataIntegrity(info, key, encryptedPackage, options = {}) {
   const keyData = info.keyData;
   if (!info.dataIntegrity) {
-    return;
+    if (options.allowMissingIntegrity) return;
+    throw new DataIntegrityError(
+      "The encrypted package has no data integrity record, so it cannot be checked for tampering."
+    );
   }
   const hmacKeyIV = await generateIV(
     keyData.hashAlgorithm,
@@ -2486,28 +2574,26 @@ async function verifyAgileDataIntegrity(info, key, encryptedPackage) {
   );
   const expectedHmac = decryptedHmacValue.subarray(0, keyData.hashSize);
   const computedHmac = await hmac(keyData.hashAlgorithm, hmacKey, encryptedPackage);
-  let match = true;
-  if (computedHmac.length < keyData.hashSize) {
-    match = false;
-  } else {
-    for (let i2 = 0; i2 < keyData.hashSize; i2++) {
-      if (computedHmac[i2] !== expectedHmac[i2]) {
-        match = false;
-        break;
-      }
-    }
-  }
+  const match = timingSafeEqual(computedHmac, expectedHmac);
   if (!match) {
     throw new DataIntegrityError(
       "Data integrity check failed. The encrypted file may be corrupted or tampered with."
     );
   }
 }
+function readOriginalSize(encryptedPackage, wide) {
+  if (encryptedPackage.length < 8) throw new Error("The EncryptedPackage stream is truncated.");
+  const view = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
+  const high = view.getUint32(4, true);
+  return view.getUint32(0, true) + (wide ? high * 4294967296 : 0);
+}
 async function decryptAgilePackage(encryptedPackage, key, info) {
   const keyData = info.keyData;
-  const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
-  const originalSize = sizeView.getUint32(0, true) + sizeView.getUint32(4, true) * 4294967296;
+  const originalSize = readOriginalSize(encryptedPackage, true);
   const encryptedData = encryptedPackage.subarray(8);
+  if (originalSize > encryptedData.length) {
+    throw new Error("The declared package size exceeds the encrypted data.");
+  }
   const segmentSize = 4096;
   const result = new Uint8Array(originalSize);
   let resultOffset = 0;
@@ -2531,9 +2617,11 @@ async function decryptAgilePackage(encryptedPackage, key, info) {
   return result.buffer;
 }
 async function decryptStandardPackage(encryptedPackage, key) {
-  const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
-  const originalSize = sizeView.getUint32(0, true);
+  const originalSize = readOriginalSize(encryptedPackage, false);
   const encryptedData = encryptedPackage.subarray(8);
+  if (originalSize > encryptedData.length) {
+    throw new Error("The declared package size exceeds the encrypted data.");
+  }
   const decrypted = await aesEcbDecrypt(key, encryptedData);
   return decrypted.slice(0, originalSize).buffer;
 }
@@ -3116,6 +3204,52 @@ async function encryptStandard(packageData, password, options = {}) {
   );
   return container(encryptionInfo, await encryptStandardPackage(packageData, key));
 }
+var DEFAULT_XML_LIMITS = {
+  maxDepth: 512,
+  maxNodes: 5e6
+};
+var MARKUP_RE = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<(\/?)([^\s\/>]+)(?:\s+[^\s=\/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*\s*(\/?)>/g;
+function checkXmlLimits(xml, label, limits = {}) {
+  const maxDepth = limits.maxDepth ?? DEFAULT_XML_LIMITS.maxDepth;
+  const maxNodes = limits.maxNodes ?? DEFAULT_XML_LIMITS.maxNodes;
+  let depth = 0;
+  let nodes = 0;
+  for (const match of xml.matchAll(MARKUP_RE)) {
+    const [, closing, name, selfClosing] = match;
+    if (name === void 0) continue;
+    if (closing) {
+      depth--;
+      continue;
+    }
+    nodes++;
+    if (nodes > maxNodes) throw new Error(`${label} XML exceeds the limit of ${maxNodes} elements`);
+    if (!selfClosing && ++depth > maxDepth)
+      throw new Error(`${label} XML exceeds the nesting depth limit of ${maxDepth}`);
+  }
+}
+function parseXml(xml, options = {}) {
+  const label = options.label ?? "OOXML";
+  if (/<!DOCTYPE|<!ENTITY/i.test(xml))
+    throw new Error(`${label} XML with DTD or entity declarations is not supported`);
+  checkXmlLimits(xml, label, options.limits);
+  let parseError = "";
+  let parsed;
+  try {
+    parsed = new DOMParser({
+      onError: (level, message) => {
+        if (level !== "warning") parseError = message;
+      }
+    }).parseFromString(xml, "application/xml");
+  } catch (error) {
+    throw new Error(
+      `Invalid ${label} XML: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  if (parseError || !parsed.documentElement)
+    throw new Error(`Invalid ${label} XML: ${parseError || "missing root element"}`);
+  return parsed;
+}
 
 // crypto/encryption-info.ts
 var RC4_ALG_ID = 26625;
@@ -3178,53 +3312,87 @@ function parseStandardEncryptionInfo(data) {
     }
   };
 }
-function tagAttribute(xml, tag, attr) {
-  const tagMatch = xml.match(new RegExp(`<[^>]*${tag}[^>]*>`, "i"));
-  if (!tagMatch) return "";
-  const attrMatch = tagMatch[0].match(new RegExp(`\\b${attr}="([^"]*)"`, "i"));
-  return attrMatch?.[1] ?? "";
+var PASSWORD_KEY_ENCRYPTOR_URI = "http://schemas.microsoft.com/office/2006/keyEncryptor/password";
+function childrenNamed(parent, localName) {
+  const found = [];
+  for (let node = parent.firstChild; node; node = node.nextSibling) {
+    if (node.nodeType === 1 && node.localName === localName) {
+      found.push(node);
+    }
+  }
+  return found;
 }
-function parseAgileEncryptionInfo(data) {
-  const xml = new TextDecoder("utf-8").decode(data.subarray(8));
-  const keyData = (attr) => tagAttribute(xml, "keyData", attr);
-  const integrity = (attr) => tagAttribute(xml, "dataIntegrity", attr);
-  const pke = (attr) => tagAttribute(xml, "encryptedKey", attr);
-  const int = (value) => parseInt(value, 10);
-  const encryptedHmacKey = integrity("encryptedHmacKey");
+function singleChild(parent, localName, mustExist) {
+  const matches = childrenNamed(parent, localName);
+  if (matches.length > 1) throw new Error(`The EncryptionInfo has several ${localName} elements.`);
+  if (matches.length === 0 && mustExist) {
+    throw new Error(`The EncryptionInfo has no ${localName} element.`);
+  }
+  return matches[0];
+}
+function required(element, attr) {
+  const value = element.getAttribute(attr);
+  if (!value) throw new Error(`The EncryptionInfo ${element.localName} has no ${attr}.`);
+  return value;
+}
+function requiredInt(element, attr) {
+  const value = required(element, attr);
+  if (!/^\d{1,10}$/.test(value)) {
+    throw new Error(`The EncryptionInfo ${element.localName} ${attr} is not a number: ${value}.`);
+  }
+  return Number(value);
+}
+function parseKeyBlock(element) {
   return {
+    saltSize: requiredInt(element, "saltSize"),
+    blockSize: requiredInt(element, "blockSize"),
+    keyBits: requiredInt(element, "keyBits"),
+    hashSize: requiredInt(element, "hashSize"),
+    cipherAlgorithm: required(element, "cipherAlgorithm"),
+    cipherChaining: required(element, "cipherChaining"),
+    hashAlgorithm: required(element, "hashAlgorithm"),
+    saltValue: base64Decode(required(element, "saltValue"))
+  };
+}
+function parseAgileEncryptionInfo(data) {
+  const root = parseXml(new TextDecoder("utf-8").decode(data.subarray(8)), {
+    label: "EncryptionInfo"
+  }).documentElement;
+  if (root.localName !== "encryption") {
+    throw new Error("The EncryptionInfo root element is not <encryption>.");
+  }
+  const keyData = parseKeyBlock(singleChild(root, "keyData", true));
+  const integrity = singleChild(root, "dataIntegrity", false);
+  const encryptors = childrenNamed(singleChild(root, "keyEncryptors", true), "keyEncryptor");
+  const passwordEncryptors = encryptors.filter(
+    (encryptor) => encryptor.getAttribute("uri") === PASSWORD_KEY_ENCRYPTOR_URI
+  );
+  if (passwordEncryptors.length !== 1) {
+    throw new Error(
+      passwordEncryptors.length === 0 ? "The EncryptionInfo has no password key encryptor." : "The EncryptionInfo has several password key encryptors."
+    );
+  }
+  const pke = singleChild(passwordEncryptors[0], "encryptedKey", true);
+  const info = {
     version: { major: 4, minor: 4 },
     isAgile: true,
-    keyData: {
-      saltSize: int(keyData("saltSize")),
-      blockSize: int(keyData("blockSize")),
-      keyBits: int(keyData("keyBits")),
-      hashSize: int(keyData("hashSize")),
-      cipherAlgorithm: keyData("cipherAlgorithm"),
-      cipherChaining: keyData("cipherChaining"),
-      hashAlgorithm: keyData("hashAlgorithm"),
-      saltValue: base64Decode(keyData("saltValue"))
-    },
-    ...encryptedHmacKey ? {
+    keyData,
+    ...integrity ? {
       dataIntegrity: {
-        encryptedHmacKey: base64Decode(encryptedHmacKey),
-        encryptedHmacValue: base64Decode(integrity("encryptedHmacValue"))
+        encryptedHmacKey: base64Decode(required(integrity, "encryptedHmacKey")),
+        encryptedHmacValue: base64Decode(required(integrity, "encryptedHmacValue"))
       }
     } : {},
     passwordKeyEncryptor: {
-      saltSize: int(pke("saltSize")),
-      blockSize: int(pke("blockSize")),
-      keyBits: int(pke("keyBits")),
-      hashSize: int(pke("hashSize")),
-      cipherAlgorithm: pke("cipherAlgorithm"),
-      cipherChaining: pke("cipherChaining"),
-      hashAlgorithm: pke("hashAlgorithm"),
-      saltValue: base64Decode(pke("saltValue")),
-      spinCount: int(pke("spinCount")),
-      encryptedVerifierHashInput: base64Decode(pke("encryptedVerifierHashInput")),
-      encryptedVerifierHashValue: base64Decode(pke("encryptedVerifierHashValue")),
-      encryptedKeyValue: base64Decode(pke("encryptedKeyValue"))
+      ...parseKeyBlock(pke),
+      spinCount: requiredInt(pke, "spinCount"),
+      encryptedVerifierHashInput: base64Decode(required(pke, "encryptedVerifierHashInput")),
+      encryptedVerifierHashValue: base64Decode(required(pke, "encryptedVerifierHashValue")),
+      encryptedKeyValue: base64Decode(required(pke, "encryptedKeyValue"))
     }
   };
+  assertValidAgileEncryptionInfo(info);
+  return info;
 }
 
 // crypto/index.ts
@@ -3240,7 +3408,7 @@ function streams(bytes) {
   }
   throw new Error("EncryptedPackage stream not found. The file may be corrupted.");
 }
-async function decryptOoxmlPackage(input, password) {
+async function decryptOoxmlPackage(input, password, options = {}) {
   const { info: infoStream, data } = streams(toBytes(input));
   const info = parseEncryptionInfo(infoStream);
   if (isStandard(info)) {
@@ -3248,25 +3416,30 @@ async function decryptOoxmlPackage(input, password) {
     if (!key2) throw new IncorrectPasswordError();
     return new Uint8Array(await decryptStandardPackage(data, key2));
   }
-  const key = await verifyAgilePassword(info, password);
+  const key = await verifyAgilePassword(info, password, options);
   if (!key) throw new IncorrectPasswordError();
-  await verifyAgileDataIntegrity(info, key, data);
+  await verifyAgileDataIntegrity(info, key, data, options);
   return new Uint8Array(await decryptAgilePackage(data, key, info));
 }
+function inspectOoxmlEncryption(input) {
+  const info = parseEncryptionInfo(streams(toBytes(input)).info);
+  if (isStandard(info)) return { scheme: "standard", integrityProtected: false };
+  return { scheme: "agile", integrityProtected: info.dataIntegrity !== void 0 };
+}
 function encryptOoxmlPackage(input, password, options = {}) {
   const bytes = toBytes(input);
   return options.encryptionScheme === "standard" ? encryptStandard(bytes, password, options) : encryptAgile(bytes, password, options);
 }
-async function verifyOoxmlPackagePassword(input, password) {
+async function verifyOoxmlPackagePassword(input, password, options = {}) {
   try {
     const opened = openEncryptedPackage(input);
     if (!opened) return false;
     const info = parseEncryptionInfo(opened.encryptionInfo);
-    const key = isStandard(info) ? await verifyStandardPassword(info, password) : await verifyAgilePassword(info, password);
+    const key = isStandard(info) ? await verifyStandardPassword(info, password) : await verifyAgilePassword(info, password, options);
     return key !== null;
   } catch {
     return false;
   }
 }
 
-export { BLOCK_KEYS, DataIntegrityError, EncryptedFileError, IncorrectPasswordError, PasswordRequiredError, RC4_ALG_ID, buildAgileEncryptionInfoXml, buildEncryptionInfoStream, buildStandardEncryptionInfoStream, computeStandardKeyBase, createOfficeGuid, decryptAgilePackage, decryptOoxmlPackage, decryptStandardPackage, deriveAgileKey, deriveStandardKey, deriveStandardKeyFromBase, detectFileFormat, encryptAgilePackage, encryptOoxmlPackage, encryptStandardPackage, generateIV, isCompoundFile, isEncryptedOoxmlPackage, isOoxmlCryptoError, openEncryptedPackage, parseEncryptionInfo, verifyAgileDataIntegrity, verifyAgilePassword, verifyOoxmlPackagePassword, verifyStandardPassword };
+export { BLOCK_KEYS, DataIntegrityError, EncryptedFileError, IncorrectPasswordError, PasswordRequiredError, RC4_ALG_ID, buildAgileEncryptionInfoXml, buildEncryptionInfoStream, buildStandardEncryptionInfoStream, computeStandardKeyBase, createOfficeGuid, decryptAgilePackage, decryptOoxmlPackage, decryptStandardPackage, deriveAgileKey, deriveStandardKey, deriveStandardKeyFromBase, detectFileFormat, encryptAgilePackage, encryptOoxmlPackage, encryptStandardPackage, generateIV, inspectOoxmlEncryption, isCompoundFile, isEncryptedOoxmlPackage, isOoxmlCryptoError, openEncryptedPackage, parseEncryptionInfo, verifyAgileDataIntegrity, verifyAgilePassword, verifyOoxmlPackagePassword, verifyStandardPassword };

package/dist/crypto/key-derivation.d.ts

@@ -7,6 +7,7 @@
  *
  * Moved from `src/core/pptx/core/utils/ooxml-crypto-key-derivation.ts` (see PROVENANCE.md).
  */
+import { type SpinLimits } from '../digest/password-hash.js';
 /** Well-known block keys for agile encryption as defined in [MS-OFFCRYPTO]. */
 export declare const BLOCK_KEYS: {
     readonly verifierHashInput: Uint8Array<ArrayBuffer>;
@@ -15,13 +16,11 @@ export declare const BLOCK_KEYS: {
     readonly dataIntegrityHmacKey: Uint8Array<ArrayBuffer>;
     readonly dataIntegrityHmacValue: Uint8Array<ArrayBuffer>;
 };
-/** The largest spin count honoured; Office writes 100,000, far more is a hostile file. */
-export declare const MAX_SPIN_COUNT = 10000000;
 /**
  * The spun password hash for agile key derivation (the expensive part). Derive several block
  * keys from one base with {@link deriveAgileKeyFromBase} instead of spinning again for each.
  */
-export declare function computeAgileKeyBase(password: string, salt: Uint8Array, spinCount: number, hashAlgorithm: string): Promise<Uint8Array>;
+export declare function computeAgileKeyBase(password: string, salt: Uint8Array, spinCount: number, hashAlgorithm: string, limits?: SpinLimits): Promise<Uint8Array>;
 /** Finishes agile key derivation for one block key: Hfinal = H(base + blockKey), sized. */
 export declare function deriveAgileKeyFromBase(base: Uint8Array, hashAlgorithm: string, blockKey: Uint8Array, keyBits: number, hashSize: number): Promise<Uint8Array>;
 /**

package/dist/crypto/key-derivation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"key-derivation.d.ts","sourceRoot":"","sources":["../../crypto/key-derivation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAUH,+EAA+E;AAC/E,eAAO,MAAM,UAAU;aACtB,iBAAiB;aACjB,iBAAiB;aACjB,iBAAiB;aACjB,oBAAoB;aACpB,sBAAsB;CACb,CAAC;AAEX,0FAA0F;AAC1F,eAAO,MAAM,cAAc,WAAa,CAAC;AA+CzC;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GACnB,OAAO,CAAC,UAAU,CAAC,CAErB;AAED,2FAA2F;AAC3F,wBAAsB,sBAAsB,CAC3C,IAAI,EAAE,UAAU,EAChB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC,CAKrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAE9F;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC9C,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,WAAW,SAAI,GACb,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,WAAW,SAAI,GACb,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC/B,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,UAAU,EACpB,SAAS,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,CAAC,CAMrB"}
+{"version":3,"file":"key-derivation.d.ts","sourceRoot":"","sources":["../../crypto/key-derivation.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE5E,+EAA+E;AAC/E,eAAO,MAAM,UAAU;aACtB,iBAAiB;aACjB,iBAAiB;aACjB,iBAAiB;aACjB,oBAAoB;aACpB,sBAAsB;CACb,CAAC;AA2DX;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,MAAM,GAAE,UAAe,GACrB,OAAO,CAAC,UAAU,CAAC,CAErB;AAED,2FAA2F;AAC3F,wBAAsB,sBAAsB,CAC3C,IAAI,EAAE,UAAU,EAChB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC,CAKrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAE9F;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC9C,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,WAAW,SAAI,GACb,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,WAAW,SAAI,GACb,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC/B,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,UAAU,EACpB,SAAS,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,CAAC,CAMrB"}

package/dist/crypto/validate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Validation of untrusted EncryptionInfo parameters. The sizes in the stream drive buffer
+ * slicing and the verifier comparison, so a hostile value (NaN, 0, a size that does not match
+ * the digest) must be rejected rather than shortening or skipping the comparison.
+ */
+import type { EncryptionInfo, StandardEncryptionInfo } from './types.js';
+/** The digest length of an agile `hashAlgorithm` name, or undefined when it is not allowed. */
+export declare function agileDigestLength(hashAlgorithm: string): number | undefined;
+/**
+ * Rejects agile EncryptionInfo parameters that are not valid for the scheme.
+ *
+ * @throws Error naming the offending field.
+ */
+export declare function assertValidAgileEncryptionInfo(info: EncryptionInfo): void;
+/**
+ * Rejects Standard EncryptionInfo parameters that are not valid for the AES scheme (the verifier
+ * is a SHA-1 hash, 20 bytes).
+ *
+ * @throws Error naming the offending field.
+ */
+export declare function assertValidStandardEncryptionInfo(info: StandardEncryptionInfo): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/crypto/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../crypto/validate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAUtE,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3E;AAgCD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAWzE;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAkBpF"}

package/dist/diagram/engine/layout-def-parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout-def-parse.d.ts","sourceRoot":"","sources":["../../../diagram/engine/layout-def-parse.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAKX,YAAY,EAEZ,UAAU,EAKV,MAAM,oBAAoB,CAAC;AA6C5B,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU,CASvE;AA6JD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAc9E"}
+{"version":3,"file":"layout-def-parse.d.ts","sourceRoot":"","sources":["../../../diagram/engine/layout-def-parse.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAKX,YAAY,EAEZ,UAAU,EAKV,MAAM,oBAAoB,CAAC;AA6C5B,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU,CASvE;AA8JD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAc9E"}

package/dist/diagram/engine/pres-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pres-tree.d.ts","sourceRoot":"","sources":["../../../diagram/engine/pres-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EAGZ,MAAM,EACN,OAAO,EAEP,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,4DAA4D;IAC5D,KAAK,EAAE,SAAS,CAAC;IACjB,GAAG,EAAE,WAAW,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2DAA2D;IAC3D,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,8DAA8D;IAC9D,SAAS,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,YAAY,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC9B,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;CACd;AAED,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;CACvC;AA6ID,uDAAuD;AACvD,wBAAgB,qBAAqB,CACpC,GAAG,EAAE,YAAY,EACjB,GAAG,EAAE,SAAS,EACd,OAAO,GAAE,eAAoB,GAC3B,QAAQ,GAAG,SAAS,CAEtB;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAQ1D"}
+{"version":3,"file":"pres-tree.d.ts","sourceRoot":"","sources":["../../../diagram/engine/pres-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EAGZ,MAAM,EACN,OAAO,EAEP,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,4DAA4D;IAC5D,KAAK,EAAE,SAAS,CAAC;IACjB,GAAG,EAAE,WAAW,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2DAA2D;IAC3D,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,8DAA8D;IAC9D,SAAS,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,YAAY,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC9B,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;CACd;AAED,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;CACvC;AA2JD,uDAAuD;AACvD,wBAAgB,qBAAqB,CACpC,GAAG,EAAE,YAAY,EACjB,GAAG,EAAE,SAAS,EACd,OAAO,GAAE,eAAoB,GAC3B,QAAQ,GAAG,SAAS,CAEtB;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAQ1D"}