@syncfusion/ej2-office-common 35.1.37

package/src/encryption/agile-encryption-info.js

@@ -0,0 +1,333 @@
+/*
+ * Parse EncryptionInfo stream for Agile encryption ([MS-OFFCRYPTO] §2.3.4.10).
+ *
+ * @remarks
+ * Binary header: VersionMajor, VersionMinor (2 bytes each LE), Reserved (4 bytes LE),
+ * then UTF-8 XML. Agile is **4.4** with Reserved **0x00000040**.
+ * Standard Encryption (minor version 2) is explicitly unsupported.
+ *
+ * @private
+ */
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+import { AGILE_ENCRYPTION_NS, AGILE_RESERVED, AGILE_VERSION_MAJOR, AGILE_VERSION_MINOR, MAX_SPIN_COUNT, PASSWORD_KEY_ENCRYPTOR_URI, STANDARD_ENCRYPTION_VERSION_MINOR, } from './agile-constants';
+import { assertAesKeyBits, assertSupportedCipher, resolveHashAlgorithm, } from './crypto-primitives';
+import { EncryptedPackageError, UnsupportedEncryptionError, } from './errors';
+import { parseEncryptionInfoXml } from './encryption-info-xml';
+function __gt() {
+    // Prefer Node global; fall back to browser window. Avoid @types/node.
+    var g = (function () {
+        try {
+            // eslint-disable-next-line no-new-func
+            return Function('return this')();
+        }
+        catch (e) {
+            return {};
+        }
+    })();
+    return g || {};
+}
+var HEADER_BYTES = 8;
+/**
+ * Parses EncryptionInfo stream bytes into an Agile model.
+ *
+ * @throws {UnsupportedEncryptionError} Standard Encryption or unknown version/alg.
+ * @throws {EncryptedPackageError} Truncated or missing required Agile fields.
+ */
+export function parseAgileEncryptionInfo(encryptionInfo, limits) {
+    if (encryptionInfo.byteLength < HEADER_BYTES + 1) {
+        throw new EncryptedPackageError('EncryptionInfo stream is truncated');
+    }
+    var view = new DataView(encryptionInfo.buffer, encryptionInfo.byteOffset, encryptionInfo.byteLength);
+    var versionMajor = view.getUint16(0, true);
+    var versionMinor = view.getUint16(2, true);
+    var reserved = view.getUint32(4, true);
+    // Standard Encryption: major 2|3|4, minor 2 ([MS-OFFCRYPTO] §2.3.4.5).
+    if (versionMinor === STANDARD_ENCRYPTION_VERSION_MINOR &&
+        (versionMajor === 2 || versionMajor === 3 || versionMajor === 4)) {
+        throw new UnsupportedEncryptionError('OFFCRYPTO Standard Encryption (EncryptionInfo minor version 2) is not supported; Agile (4.4) only');
+    }
+    if (versionMajor !== AGILE_VERSION_MAJOR || versionMinor !== AGILE_VERSION_MINOR) {
+        throw new UnsupportedEncryptionError("Unsupported EncryptionInfo version " + String(versionMajor) + "." + String(versionMinor));
+    }
+    if (reserved !== AGILE_RESERVED) {
+        throw new UnsupportedEncryptionError("Unsupported EncryptionInfo reserved field 0x" + reserved.toString(16));
+    }
+    var xmlBytes = encryptionInfo.subarray(HEADER_BYTES);
+    var xmlText = utf8Decode(xmlBytes);
+    var root;
+    try {
+        root = parseEncryptionInfoXml(xmlText, limits, 'EncryptionInfo');
+    }
+    catch (err) {
+        if (err instanceof EncryptedPackageError || err instanceof UnsupportedEncryptionError) {
+            throw err;
+        }
+        if (err instanceof Error && err.name === 'PackageLimitError') {
+            throw err;
+        }
+        var msg = err instanceof Error ? err.message : 'XML parse failed';
+        throw new EncryptedPackageError("EncryptionInfo XML is invalid: " + msg);
+    }
+    if (root.localName !== 'encryption' || root.namespaceUri !== AGILE_ENCRYPTION_NS) {
+        // Accept default-ns resolution failures only when localName matches and NS empty
+        // after serializers omit xmlns on root (rare); still require encryption localName.
+        if (root.localName !== 'encryption') {
+            throw new EncryptedPackageError('EncryptionInfo root element is not encryption');
+        }
+        if (root.namespaceUri !== '' && root.namespaceUri !== AGILE_ENCRYPTION_NS) {
+            throw new EncryptedPackageError('EncryptionInfo root element is not encryption');
+        }
+    }
+    var keyDataEl = findChild(root, AGILE_ENCRYPTION_NS, 'keyData');
+    var dataIntegrityEl = findChildOptional(root, AGILE_ENCRYPTION_NS, 'dataIntegrity');
+    var keyEncryptorsEl = findChild(root, AGILE_ENCRYPTION_NS, 'keyEncryptors');
+    var keyData = parseKeyData(keyDataEl);
+    var dataIntegrity = dataIntegrityEl === undefined ? undefined : parseDataIntegrity(dataIntegrityEl);
+    var passwordKeyEncryptor = parsePasswordKeyEncryptor(keyEncryptorsEl);
+    return { keyData: keyData, dataIntegrity: dataIntegrity, passwordKeyEncryptor: passwordKeyEncryptor };
+}
+function parseKeyData(el) {
+    var saltSize = requirePositiveIntAttr(el, 'saltSize');
+    var blockSize = requirePositiveIntAttr(el, 'blockSize');
+    var keyBits = requirePositiveIntAttr(el, 'keyBits');
+    var hashSize = requirePositiveIntAttr(el, 'hashSize');
+    var cipherAlgorithm = requireAttr(el, 'cipherAlgorithm');
+    var cipherChaining = requireAttr(el, 'cipherChaining');
+    var hashAlgorithmRaw = requireAttr(el, 'hashAlgorithm');
+    var saltValue = requireBase64Attr(el, 'saltValue');
+    assertSupportedCipher(cipherAlgorithm, cipherChaining);
+    assertAesKeyBits(keyBits);
+    var hashAlgorithm = resolveHashAlgorithm(hashAlgorithmRaw);
+    if (blockSize !== 16) {
+        throw new UnsupportedEncryptionError("Unsupported OFFCRYPTO blockSize: " + String(blockSize) + " (AES requires 16)");
+    }
+    if (saltValue.byteLength !== saltSize) {
+        throw new EncryptedPackageError('keyData saltValue length does not match saltSize');
+    }
+    return {
+        saltSize: saltSize,
+        blockSize: blockSize,
+        keyBits: keyBits,
+        hashSize: hashSize,
+        cipherAlgorithm: cipherAlgorithm,
+        cipherChaining: cipherChaining,
+        hashAlgorithm: hashAlgorithm,
+        saltValue: saltValue,
+    };
+}
+function parseDataIntegrity(el) {
+    return {
+        encryptedHmacKey: requireBase64Attr(el, 'encryptedHmacKey'),
+        encryptedHmacValue: requireBase64Attr(el, 'encryptedHmacValue'),
+    };
+}
+function parsePasswordKeyEncryptor(keyEncryptorsEl) {
+    var e_1, _a;
+    var encryptorEls = keyEncryptorsEl.children.filter(function (c) { return c.kind === 'element' && c.localName === 'keyEncryptor'; });
+    if (encryptorEls.length === 0) {
+        throw new EncryptedPackageError('EncryptionInfo has no keyEncryptor');
+    }
+    var passwordEl;
+    try {
+        for (var encryptorEls_1 = __values(encryptorEls), encryptorEls_1_1 = encryptorEls_1.next(); !encryptorEls_1_1.done; encryptorEls_1_1 = encryptorEls_1.next()) {
+            var ke = encryptorEls_1_1.value;
+            var uri = getAttr(ke, 'uri');
+            if (uri === PASSWORD_KEY_ENCRYPTOR_URI) {
+                passwordEl = findEncryptedKey(ke);
+                break;
+            }
+            if (uri !== undefined && uri.length > 0) {
+                throw new UnsupportedEncryptionError('OFFCRYPTO certificate (or non-password) keyEncryptor is not supported');
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (encryptorEls_1_1 && !encryptorEls_1_1.done && (_a = encryptorEls_1.return)) _a.call(encryptorEls_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (passwordEl === undefined) {
+        throw new UnsupportedEncryptionError('OFFCRYPTO EncryptionInfo has no password keyEncryptor');
+    }
+    var spinCount = requireNonNegativeIntAttr(passwordEl, 'spinCount');
+    if (spinCount > MAX_SPIN_COUNT) {
+        throw new EncryptedPackageError("OFFCRYPTO spinCount exceeds maximum allowed (" + String(MAX_SPIN_COUNT) + ")");
+    }
+    var saltSize = requirePositiveIntAttr(passwordEl, 'saltSize');
+    var blockSize = requirePositiveIntAttr(passwordEl, 'blockSize');
+    var keyBits = requirePositiveIntAttr(passwordEl, 'keyBits');
+    var hashSize = requirePositiveIntAttr(passwordEl, 'hashSize');
+    var cipherAlgorithm = requireAttr(passwordEl, 'cipherAlgorithm');
+    var cipherChaining = requireAttr(passwordEl, 'cipherChaining');
+    var hashAlgorithmRaw = requireAttr(passwordEl, 'hashAlgorithm');
+    var saltValue = requireBase64Attr(passwordEl, 'saltValue');
+    var encryptedVerifierHashInput = requireBase64Attr(passwordEl, 'encryptedVerifierHashInput');
+    var encryptedVerifierHashValue = requireBase64Attr(passwordEl, 'encryptedVerifierHashValue');
+    var encryptedKeyValue = requireBase64Attr(passwordEl, 'encryptedKeyValue');
+    assertSupportedCipher(cipherAlgorithm, cipherChaining);
+    assertAesKeyBits(keyBits);
+    var hashAlgorithm = resolveHashAlgorithm(hashAlgorithmRaw);
+    if (blockSize !== 16) {
+        throw new UnsupportedEncryptionError("Unsupported password keyEncryptor blockSize: " + String(blockSize));
+    }
+    if (saltValue.byteLength !== saltSize) {
+        throw new EncryptedPackageError('encryptedKey saltValue length does not match saltSize');
+    }
+    return {
+        spinCount: spinCount,
+        saltSize: saltSize,
+        blockSize: blockSize,
+        keyBits: keyBits,
+        hashSize: hashSize,
+        cipherAlgorithm: cipherAlgorithm,
+        cipherChaining: cipherChaining,
+        hashAlgorithm: hashAlgorithm,
+        saltValue: saltValue,
+        encryptedVerifierHashInput: encryptedVerifierHashInput,
+        encryptedVerifierHashValue: encryptedVerifierHashValue,
+        encryptedKeyValue: encryptedKeyValue,
+    };
+}
+function findEncryptedKey(keyEncryptor) {
+    var e_2, _a;
+    try {
+        for (var _b = __values(keyEncryptor.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind !== 'element') {
+                continue;
+            }
+            if (child.localName === 'encryptedKey') {
+                return child;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+function findChild(parent, ns, localName) {
+    var el = findChildOptional(parent, ns, localName);
+    if (el === undefined) {
+        throw new EncryptedPackageError("EncryptionInfo missing element " + localName);
+    }
+    return el;
+}
+function findChildOptional(parent, ns, localName) {
+    var e_3, _a, e_4, _b;
+    try {
+        for (var _c = __values(parent.children), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var child = _d.value;
+            if (child.kind !== 'element') {
+                continue;
+            }
+            if (child.localName === localName && (child.namespaceUri === ns || child.namespaceUri === '')) {
+                return child;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    try {
+        for (var _e = __values(parent.children), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var child = _f.value;
+            if (child.kind === 'element' && child.localName === localName) {
+                return child;
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return undefined;
+}
+function getAttr(el, localName) {
+    var e_5, _a;
+    try {
+        for (var _b = __values(el.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var a = _c.value;
+            if (a.localName === localName) {
+                return a.value;
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return undefined;
+}
+function requireAttr(el, localName) {
+    var v = getAttr(el, localName);
+    if (v === undefined || v.length === 0) {
+        throw new EncryptedPackageError("EncryptionInfo missing attribute " + localName);
+    }
+    return v;
+}
+function requirePositiveIntAttr(el, localName) {
+    var raw = requireAttr(el, localName);
+    var n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new EncryptedPackageError("EncryptionInfo attribute " + localName + " is invalid");
+    }
+    return n;
+}
+function requireNonNegativeIntAttr(el, localName) {
+    var raw = requireAttr(el, localName);
+    var n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 0) {
+        throw new EncryptedPackageError("EncryptionInfo attribute " + localName + " is invalid");
+    }
+    return n;
+}
+function requireBase64Attr(el, localName) {
+    var raw = requireAttr(el, localName);
+    try {
+        return base64Decode(raw);
+    }
+    catch (_a) {
+        throw new EncryptedPackageError("EncryptionInfo attribute " + localName + " is not valid base64");
+    }
+}
+function base64Decode(value) {
+    var normalized = value.replace(/\s+/g, '');
+    if (typeof __gt().atob === 'function') {
+        var bin = __gt().atob(normalized);
+        var out = new Uint8Array(bin.length);
+        for (var i = 0; i < bin.length; i++) {
+            out[i] = bin.charCodeAt(i);
+        }
+        return out;
+    }
+    return new Uint8Array(Buffer.from(normalized, 'base64'));
+}
+function utf8Decode(bytes) {
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+}

package/src/encryption/agile-password.d.ts

@@ -0,0 +1,8 @@
+import { AgilePasswordKeyEncryptor } from './agile-encryption-info';
+/**
+ * Verifies the password and returns the secret key used to decrypt EncryptedPackage
+ * (decrypted encryptedKeyValue, truncated to keyBits/8).
+ *
+ * @throws {InvalidPasswordError} When verifier hash does not match.
+ */
+export declare function unlockIntermediateKey(password: string, encryptor: AgilePasswordKeyEncryptor): Uint8Array;

package/src/encryption/agile-password.js

@@ -0,0 +1,58 @@
+/*
+ * Password key encryptor verifier and intermediate key ([MS-OFFCRYPTO] §2.3.4.13).
+ *
+ * @remarks
+ * 1. Derive key with blockKey `BLOCK_KEY_VERIFIER_INPUT`; decrypt encryptedVerifierHashInput.
+ * 2. Hash the decrypted verifier input; derive key with `BLOCK_KEY_VERIFIER_HASH`;
+ *    decrypt encryptedVerifierHashValue; compare first hashSize bytes → else InvalidPasswordError.
+ * 3. Derive key with `BLOCK_KEY_ENCRYPTED_KEY`; decrypt encryptedKeyValue → intermediate key
+ *    (truncated to keyBits/8).
+ *
+ * Integrity HMAC failure uses the same InvalidPasswordError (fail-closed; do not
+ * distinguish wrong password vs tampered package in the public message).
+ *
+ * @private
+ */
+import { InvalidPasswordError } from './errors';
+import { BLOCK_KEY_ENCRYPTOR_KEY, BLOCK_KEY_VERIFIER_HASH, BLOCK_KEY_VERIFIER_INPUT, } from './agile-constants';
+import { aesCbcDecrypt, deriveAgileIv, deriveAgileKey, encodePasswordUtf16Le, hashBytes, timingSafeEqual, } from './crypto-primitives';
+/**
+ * Verifies the password and returns the secret key used to decrypt EncryptedPackage
+ * (decrypted encryptedKeyValue, truncated to keyBits/8).
+ *
+ * @throws {InvalidPasswordError} When verifier hash does not match.
+ */
+export function unlockIntermediateKey(password, encryptor) {
+    var passwordBytes = encodePasswordUtf16Le(password);
+    var hashAlgorithm = encryptor.hashAlgorithm, saltValue = encryptor.saltValue, spinCount = encryptor.spinCount, keyBits = encryptor.keyBits, blockSize = encryptor.blockSize, hashSize = encryptor.hashSize;
+    // --- verifier hash input ---
+    var keyVerifierInput = deriveAgileKey(hashAlgorithm, saltValue, passwordBytes, spinCount, BLOCK_KEY_VERIFIER_INPUT, keyBits);
+    var ivVerifierInput = deriveAgileIv(hashAlgorithm, saltValue, undefined, blockSize);
+    var verifierInputPadded = aesCbcDecrypt(keyVerifierInput, ivVerifierInput, encryptor.encryptedVerifierHashInput);
+    // §2.3.4.13: verifier input is saltSize random bytes (zero-padded to blockSize on encrypt).
+    if (verifierInputPadded.byteLength < encryptor.saltSize) {
+        throw new InvalidPasswordError();
+    }
+    var verifierInput = verifierInputPadded.subarray(0, encryptor.saltSize);
+    var verifierHashComputed = hashBytes(hashAlgorithm, verifierInput);
+    // --- verifier hash value ---
+    var keyVerifierHash = deriveAgileKey(hashAlgorithm, saltValue, passwordBytes, spinCount, BLOCK_KEY_VERIFIER_HASH, keyBits);
+    var ivVerifierHash = deriveAgileIv(hashAlgorithm, saltValue, undefined, blockSize);
+    var verifierHashDecrypted = aesCbcDecrypt(keyVerifierHash, ivVerifierHash, encryptor.encryptedVerifierHashValue);
+    var expectedLen = Math.min(hashSize, verifierHashComputed.byteLength, verifierHashDecrypted.byteLength);
+    if (expectedLen <= 0) {
+        throw new InvalidPasswordError();
+    }
+    if (!timingSafeEqual(verifierHashComputed.subarray(0, expectedLen), verifierHashDecrypted.subarray(0, expectedLen))) {
+        throw new InvalidPasswordError();
+    }
+    // --- encrypted key value → intermediate / secret key ---
+    var keyEncryptedKey = deriveAgileKey(hashAlgorithm, saltValue, passwordBytes, spinCount, BLOCK_KEY_ENCRYPTOR_KEY, keyBits);
+    var ivEncryptedKey = deriveAgileIv(hashAlgorithm, saltValue, undefined, blockSize);
+    var decryptedKey = aesCbcDecrypt(keyEncryptedKey, ivEncryptedKey, encryptor.encryptedKeyValue);
+    var keyLen = keyBits / 8;
+    if (decryptedKey.byteLength < keyLen) {
+        throw new InvalidPasswordError();
+    }
+    return decryptedKey.subarray(0, keyLen);
+}

package/src/encryption/cfb-reader.d.ts

@@ -0,0 +1,11 @@
+export interface OffCryptoStreams {
+    readonly encryptionInfo: Uint8Array;
+    readonly encryptedPackage: Uint8Array;
+}
+/**
+ * Extracts `\EncryptionInfo` and `\EncryptedPackage` from an OFFCRYPTO CFB.
+ *
+ * @param input - Entire OLE compound-file bytes.
+ * @throws {EncryptedPackageError} When structure is incomplete or streams missing.
+ */
+export declare function readOffCryptoStreams(input: Uint8Array): OffCryptoStreams;