archive-codec 1.8.0 → 1.9.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&logoColor=white)](https://github.com/ExaDev/documents.js/tree/main/packages/archive-codec) [![npm](https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/archive-codec) [![npm version](https://img.shields.io/npm/v/archive-codec)](https://www.npmjs.com/package/archive-codec) [![CI](https://img.shields.io/github/actions/workflow/status/ExaDev/documents.js/ci.yml?branch=main)](https://github.com/ExaDev/documents.js/actions)
 
-> ZIP-in-ZIP recursive walking under depth and cumulative decompressed-size guards, classic OLE compound-file ([MS-CFB]) reading and writing, [MS-OLEPS] Property Set Stream reading and writing, and the RC4/MD5 primitives the legacy OLE-based binary formats share for their own password-to-open encryption — zero document-format knowledge, the archive and container utility package for the [documents.js family](../../README.md). Worker-isomorphic: the same code runs under Node and inside a Cloudflare Workers isolate.
+> ZIP-in-ZIP recursive walking under depth and cumulative decompressed-size guards, classic OLE compound-file ([MS-CFB]) reading and writing, [MS-OLEPS] Property Set Stream reading and writing, and the RC4/MD5/SHA-1 primitives the legacy OLE-based binary formats use for their own password-to-open encryption — zero document-format knowledge, the archive and container utility package for the [documents.js family](../../README.md). Worker-isomorphic: the same code runs under Node and inside a Cloudflare Workers isolate.
 
 Created for [documents.js#564](https://github.com/ExaDev/documents.js/issues/564): nothing in the ecosystem recursed into a nested archive. Most concretely, OOXML's embedded-object model — a docx/pptx carrying a genuinely separate ZIP blob at `word/embeddings/oleObject1.xlsx` — had no safe handling anywhere, and no package guarded against recursive-archive inputs at all (`byte-codec`'s 512 MiB per-stream inflate cap does not compose across recursion). A new sibling was chosen over extending `byte-codec` (whose charter is byte/image primitives, zero container-format knowledge) or doing it inline in `documents.js` (which would repeat the duplication `byte-codec`'s own extraction was meant to avoid). Its first family consumer is `ooxml.js`'s OLE embedded-object recovery — [documents.js#733](https://github.com/ExaDev/documents.js/issues/733) (pptx, `p:oleObj`) and [documents.js#734](https://github.com/ExaDev/documents.js/issues/734) (docx, `o:OLEObject`): an OLE payload part's bytes are checked through `isZipArchive` and, when they are a ZIP, decoded as a nested OOXML package behind this package's guarded walk — the bounded inflate that populates `document-schema.js`'s `ContentEmbeddedObject`/`ContentEmbeddedObjectBlock` (the same vocabulary odf.js embeds formula sub-documents through) with a genuinely recovered sub-document.
 
@@ -14,11 +14,13 @@ Created for [documents.js#564](https://github.com/ExaDev/documents.js/issues/564
 
 [documents.js#815](https://github.com/ExaDev/documents.js/issues/815), [#816](https://github.com/ExaDev/documents.js/issues/816), and [#817](https://github.com/ExaDev/documents.js/issues/817) also each named the same remaining gap: `doc-codec`, `xls-codec`, and `ppt-codec` all hard-coded document metadata (title, author, dates) to an empty object, because that metadata lives in a genuinely different structure from the one each format's own reader already parses -- a [MS-OLEPS] Property Set Stream, conventionally stored as a "\x05SummaryInformation" stream beside `WordDocument`/`Workbook`/`PowerPoint Document` in the identical [MS-CFB] container all three already read through this package. `oleps/read` and `oleps/write` are the generic property-set codec (the stream header, the PropertySet packet's dictionary, and VT_I2/VT_I4/VT_LPSTR/VT_LPWSTR/VT_FILETIME typed values), and `oleps/summary-information` is the SummaryInformation-specific mapping on top of it -- the same two-layer split `cfb/read.ts` and `cfb/ole-package.ts` already establish for the OLE Package stream, container structure below, one named stream's own field layout above.
 
-[documents.js#1108](https://github.com/ExaDev/documents.js/issues/1108) added the RC4/MD5 primitives `xls-codec` needs to decrypt a legacy-encrypted `.xls` workbook: the [MS-OFFCRYPTO] 2.3.6.1 "RC4 encryption header" scheme every BIFF8 `FilePass` record protected this way shares with the same header shape in `.doc` and `.ppt`. RC4 and MD5 are trivial and completely unavailable from any platform crypto API this package can portably reach (WebCrypto has never offered either; `node:crypto` dropped RC4 from its default provider with OpenSSL 3), so hand-writing them here — once, shared — is the only option that keeps `xls-codec`, `doc-codec`, and `ppt-codec` (already this package's only consumers) from each carrying their own copy. The newer "RC4 CryptoAPI encryption header" scheme (2.3.5.1, a different header shape and derivation) and the older XOR obfuscation scheme are explicitly out of scope for now — tracked separately in [documents.js#922](https://github.com/ExaDev/documents.js/issues/922).
+[documents.js#1108](https://github.com/ExaDev/documents.js/issues/1108) added the RC4/MD5 primitives `xls-codec` needs to decrypt a legacy-encrypted `.xls` workbook: the [MS-OFFCRYPTO] 2.3.6.1 "RC4 encryption header" scheme every BIFF8 `FilePass` record protected this way shares with the same header shape in `.doc`. RC4 and MD5 are trivial and completely unavailable from any platform crypto API this package can portably reach (WebCrypto has never offered either; `node:crypto` dropped RC4 from its default provider with OpenSSL 3), so hand-writing them here — once, shared — is the only option that keeps `xls-codec` and `doc-codec` from each carrying their own copy. `.ppt` turned out NOT to share this scheme at all (see [documents.js#1116](https://github.com/ExaDev/documents.js/issues/1116) below) — the older XOR obfuscation scheme remains out of scope, tracked in [documents.js#922](https://github.com/ExaDev/documents.js/issues/922).
 
-[documents.js#1113](https://github.com/ExaDev/documents.js/issues/1113) is the first of those two named future consumers to actually land: `doc-codec` decrypts an RC4-encrypted `.doc` given a password, wired against the same primitives `xls-codec` uses. The two codecs' own re-keying intervals genuinely differ (`OFFICE_RC4_BLOCK_SIZE` for `xls-codec`, `OFFICE_RC4_DOC_BLOCK_SIZE` for `doc-codec`), so `decryptOfficeRc4` gained a `blockSize` parameter rather than this package assuming one shared constant — see [Legacy Office encryption](#legacy-office-encryption).
+[documents.js#1113](https://github.com/ExaDev/documents.js/issues/1113) is the first of two named future consumers from #1108 to actually land: `doc-codec` decrypts an RC4-encrypted `.doc` given a password, wired against the same primitives `xls-codec` uses. The two codecs' own re-keying intervals genuinely differ (`OFFICE_RC4_BLOCK_SIZE` for `xls-codec`, `OFFICE_RC4_DOC_BLOCK_SIZE` for `doc-codec`), so `decryptOfficeRc4` gained a `blockSize` parameter rather than this package assuming one shared constant — see [Legacy Office encryption](#legacy-office-encryption).
 
-Scope: **ZIP containers** (read and write over [`fflate`](https://github.com/101arrowz/fflate), recursive walking of ZIP-in-ZIP entries), **classic OLE compound files** (bounded [MS-CFB] reading and conformant [MS-CFB] writing, plus OLE Package stream reading and writing), **[MS-OLEPS] Property Set Streams** (generic read/write of a single-property-set stream, plus SummaryInformation's own title/subject/author/keywords/comments/created/last-saved/last-printed fields), and the **RC4/MD5 primitives** the legacy OLE-based binary formats share for password-to-open encryption. **tar and gzip, DocumentSummaryInformation's extended and user-defined property sets, writing VT_LPSTR (ANSI-codepage) string properties, RC4 CryptoAPI encryption, and XOR obfuscation are explicitly out of scope.**
+[documents.js#1116](https://github.com/ExaDev/documents.js/issues/1116) is the second: `.ppt`'s own encryption turned out to be a genuinely different scheme, not `ppt-codec`'s eventual integration against #1108's own primitives as originally assumed. [MS-OFFCRYPTO] 2.3.5 "RC4 CryptoAPI Encryption" is SHA-1-based rather than MD5-based, derives its key with no intermediate-hash iteration, and re-keys per persist object rather than at a fixed byte interval — different enough that it needed its own primitives (`crypto/sha1`, `crypto/office-rc4-cryptoapi`) rather than a parameter on the existing ones. See [RC4 CryptoAPI encryption](#rc4-cryptoapi-encryption-ppt).
+
+Scope: **ZIP containers** (read and write over [`fflate`](https://github.com/101arrowz/fflate), recursive walking of ZIP-in-ZIP entries), **classic OLE compound files** (bounded [MS-CFB] reading and conformant [MS-CFB] writing, plus OLE Package stream reading and writing), **[MS-OLEPS] Property Set Streams** (generic read/write of a single-property-set stream, plus SummaryInformation's own title/subject/author/keywords/comments/created/last-saved/last-printed fields), and the **RC4/MD5/SHA-1 primitives** the legacy OLE-based binary formats use for password-to-open encryption — `.doc`/`.xls` share one MD5-based scheme, `.ppt` uses a genuinely different SHA-1-based one. **tar and gzip, DocumentSummaryInformation's extended and user-defined property sets, writing VT_LPSTR (ANSI-codepage) string properties, and XOR obfuscation are explicitly out of scope.**
 
 ## Getting started
 
@@ -48,22 +50,24 @@ import { walkArchive } from "archive-codec/zip/walk";
 
 The smoke suite (`test/smoke.test.mjs`) is the guard on that advertisement: it loads each module below from the built `dist/` in both module systems, so a build config that stops serving an advertised subpath fails the suite — neither publint nor `attw` catches a wildcard whose targets are missing.
 
-| Module                      | Exports                                                                                                                                                                                                                                                                                 |
-| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `zip/container`             | `zipPackage` (ordered-entries ZIP write with stored-uncompressed support), `unzipPackage`, `ZipEntry`                                                                                                                                                                                   |
-| `zip/detect`                | `detectArchiveFormat` (`'zip' \| 'cfb' \| 'unknown'`), `isZipArchive`, `ArchiveFormat`                                                                                                                                                                                                  |
-| `zip/walk`                  | `walkArchive` (recursive ZIP-in-ZIP walking), `ArchiveWalkEntry`, `ArchiveWalkLimitError`, `MAX_WALK_DEPTH`, `MAX_WALK_TOTAL_BYTES`, `WalkArchiveOptions`                                                                                                                               |
-| `cfb/detect`                | `isCompoundFile` (the `D0 CF 11 E0 …` magic-byte check)                                                                                                                                                                                                                                 |
-| `cfb/read`                  | `readCompoundFile` (bounded [MS-CFB] stream extraction), `CompoundFileStream`, `CompoundFileFormatError`, `MAX_CFB_TOTAL_STREAM_BYTES`, `ReadCompoundFileOptions`                                                                                                                       |
-| `cfb/write`                 | `writeCompoundFile` ([MS-CFB] container generation), `CompoundFileWriteError`, `WriteCompoundFileOptions` — takes the `CompoundFileStream` array `cfb/read` returns                                                                                                                     |
-| `cfb/ole-package`           | `readOlePackage` (OLE Package stream unwrapping), `writeOlePackage` (the mirror), `OlePackage`, `OlePackageFormatError`, `OlePackageWriteError`                                                                                                                                         |
-| `oleps/read`                | `readPropertySetStream` (generic [MS-OLEPS] property-set decoding), `PropertySetFormatError`                                                                                                                                                                                            |
-| `oleps/write`               | `writePropertySetStream` (generic [MS-OLEPS] property-set encoding), `PropertySetWriteError` — takes the `PropertySet` shape `oleps/read` returns                                                                                                                                       |
-| `oleps/summary-information` | `readSummaryInformation`, `writeSummaryInformationStream`, `SummaryInformationProperties`, `FMTID_SUMMARY_INFORMATION`                                                                                                                                                                  |
-| `oleps/layout-metadata`     | `summaryInformationToLayoutMetadata`, `layoutMetadataToSummaryInformation`, `hasSummaryInformationFields` — the `SummaryInformationProperties` <-> `document-schema.js`'s `LayoutMetadata` mapping, shared by `doc-codec`/`xls-codec`/`ppt-codec` (see [Property sets](#property-sets)) |
-| `crypto/md5`                | `md5` — RFC 1321 MD5, hand-written (see [Legacy Office encryption](#legacy-office-encryption))                                                                                                                                                                                          |
-| `crypto/rc4`                | `rc4` — the RC4 stream cipher, hand-written; symmetric, so also the decrypt operation                                                                                                                                                                                                   |
-| `crypto/office-rc4`         | `deriveOfficeRc4BaseHash`, `deriveOfficeRc4BlockKey`, `decryptOfficeRc4`, `OFFICE_RC4_VERIFIER_LENGTH`, `OFFICE_RC4_BLOCK_SIZE`, `OFFICE_RC4_DOC_BLOCK_SIZE` — [MS-OFFCRYPTO] 2.3.6.2's own key derivation and the block-keyed stream decryption built on it                            |
+| Module                        | Exports                                                                                                                                                                                                                                                                                 |
+| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `zip/container`               | `zipPackage` (ordered-entries ZIP write with stored-uncompressed support), `unzipPackage`, `ZipEntry`                                                                                                                                                                                   |
+| `zip/detect`                  | `detectArchiveFormat` (`'zip' \| 'cfb' \| 'unknown'`), `isZipArchive`, `ArchiveFormat`                                                                                                                                                                                                  |
+| `zip/walk`                    | `walkArchive` (recursive ZIP-in-ZIP walking), `ArchiveWalkEntry`, `ArchiveWalkLimitError`, `MAX_WALK_DEPTH`, `MAX_WALK_TOTAL_BYTES`, `WalkArchiveOptions`                                                                                                                               |
+| `cfb/detect`                  | `isCompoundFile` (the `D0 CF 11 E0 …` magic-byte check)                                                                                                                                                                                                                                 |
+| `cfb/read`                    | `readCompoundFile` (bounded [MS-CFB] stream extraction), `CompoundFileStream`, `CompoundFileFormatError`, `MAX_CFB_TOTAL_STREAM_BYTES`, `ReadCompoundFileOptions`                                                                                                                       |
+| `cfb/write`                   | `writeCompoundFile` ([MS-CFB] container generation), `CompoundFileWriteError`, `WriteCompoundFileOptions` — takes the `CompoundFileStream` array `cfb/read` returns                                                                                                                     |
+| `cfb/ole-package`             | `readOlePackage` (OLE Package stream unwrapping), `writeOlePackage` (the mirror), `OlePackage`, `OlePackageFormatError`, `OlePackageWriteError`                                                                                                                                         |
+| `oleps/read`                  | `readPropertySetStream` (generic [MS-OLEPS] property-set decoding), `PropertySetFormatError`                                                                                                                                                                                            |
+| `oleps/write`                 | `writePropertySetStream` (generic [MS-OLEPS] property-set encoding), `PropertySetWriteError` — takes the `PropertySet` shape `oleps/read` returns                                                                                                                                       |
+| `oleps/summary-information`   | `readSummaryInformation`, `writeSummaryInformationStream`, `SummaryInformationProperties`, `FMTID_SUMMARY_INFORMATION`                                                                                                                                                                  |
+| `oleps/layout-metadata`       | `summaryInformationToLayoutMetadata`, `layoutMetadataToSummaryInformation`, `hasSummaryInformationFields` — the `SummaryInformationProperties` <-> `document-schema.js`'s `LayoutMetadata` mapping, shared by `doc-codec`/`xls-codec`/`ppt-codec` (see [Property sets](#property-sets)) |
+| `crypto/md5`                  | `md5` — RFC 1321 MD5, hand-written (see [Legacy Office encryption](#legacy-office-encryption))                                                                                                                                                                                          |
+| `crypto/sha1`                 | `sha1` — RFC 3174/FIPS 180-1 SHA-1, hand-written (see [RC4 CryptoAPI encryption](#rc4-cryptoapi-encryption-ppt))                                                                                                                                                                        |
+| `crypto/rc4`                  | `rc4` — the RC4 stream cipher, hand-written; symmetric, so also the decrypt operation                                                                                                                                                                                                   |
+| `crypto/office-rc4`           | `deriveOfficeRc4BaseHash`, `deriveOfficeRc4BlockKey`, `decryptOfficeRc4`, `OFFICE_RC4_VERIFIER_LENGTH`, `OFFICE_RC4_BLOCK_SIZE`, `OFFICE_RC4_DOC_BLOCK_SIZE` — [MS-OFFCRYPTO] 2.3.6.2's own key derivation and the block-keyed stream decryption built on it                            |
+| `crypto/office-rc4-cryptoapi` | `deriveRc4CryptoApiBlockKey`, `verifyRc4CryptoApiPassword`, `RC4_CRYPTOAPI_SALT_LENGTH`, `RC4_CRYPTOAPI_VERIFIER_LENGTH`, `RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH`, `RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS` — [MS-OFFCRYPTO] 2.3.5.2's own key derivation, `.ppt`'s own encryption scheme     |
 
 ### Recursive walking
 
@@ -188,7 +192,37 @@ const plaintext = decryptOfficeRc4(baseHash, streamOffset, ciphertext);
 
 `deriveOfficeRc4BaseHash`/`deriveOfficeRc4BlockKey`/`decryptOfficeRc4` implement [MS-OFFCRYPTO] 2.3.6.1/2.3.6.2's RC4 encryption header scheme: a per-workbook base hash derived once from the password and the header's own salt, then a full 128-bit RC4 key re-derived from that base hash at every 1024-byte boundary of the underlying decrypted stream — despite [MS-OFFCRYPTO] 2.3.6.1's own field descriptions twice stating "encrypted using a 40-bit RC4 cipher", which is wrong; the real key is Hfinal in full, confirmed against Apache POI's `BinaryRC4Decryptor` and nolze/msoffcrypto-tool's own doctested test vectors, both cross-checked directly rather than trusted from the spec's own prose — see each constant's own doc comment for the full account, including the truncated-to-5-bytes implementation this package shipped briefly before the cross-check caught it. `decryptOfficeRc4` takes the byte offset a chunk starts at within the whole encrypted stream (not within the chunk itself), so a stream can be decrypted in arbitrary pieces, not only from its own start, and still land on the correct per-block key throughout. The 1024-byte re-keying interval is `decryptOfficeRc4`'s own default `blockSize`, since [MS-XLS]'s own FilePass scheme is this module's original consumer, but it is a real [MS-XLS]-specific value, not a property of the algorithm itself: [MS-DOC] 2.2.6.2's own RC4 encryption header (the identical [MS-OFFCRYPTO] 2.3.6.1 structure, confirmed against Apache POI's `EncryptionMode.binaryRC4` resolving both) re-keys every 512 bytes instead (`OFFICE_RC4_DOC_BLOCK_SIZE`), passed explicitly as `decryptOfficeRc4`'s fourth argument.
 
-This is exactly the piece `xls-codec`'s `FilePass`-record reader and `doc-codec`'s own `EncryptionHeader` reader (ExaDev/documents.js#1113) both need and nothing more: locating the header, reading its own fields, and verifying the password against `EncryptedVerifier`/`EncryptedVerifierHash` are each codec's own concern, not this package's — `archive-codec` carries only the format-agnostic cryptography, never a `.xls`- or `.doc`-specific byte layout. `decryptOfficeRc4`'s own `blockSize` parameter exists because the two codecs' re-keying intervals genuinely differ (`OFFICE_RC4_BLOCK_SIZE`, 1024, for `xls-codec`; `OFFICE_RC4_DOC_BLOCK_SIZE`, 512, for `doc-codec`) -- confirmed as real, independent values against Apache POI's own `Biff8DecryptingStream` and `BinaryRC4Decryptor` respectively, not one shared constant this package could have assumed. `md5`/`rc4` are exported individually too, for `ppt-codec`'s own eventual integration against the identical header scheme.
+This is exactly the piece `xls-codec`'s `FilePass`-record reader and `doc-codec`'s own `EncryptionHeader` reader (ExaDev/documents.js#1113) both need and nothing more: locating the header, reading its own fields, and verifying the password against `EncryptedVerifier`/`EncryptedVerifierHash` are each codec's own concern, not this package's — `archive-codec` carries only the format-agnostic cryptography, never a `.xls`- or `.doc`-specific byte layout. `decryptOfficeRc4`'s own `blockSize` parameter exists because the two codecs' re-keying intervals genuinely differ (`OFFICE_RC4_BLOCK_SIZE`, 1024, for `xls-codec`; `OFFICE_RC4_DOC_BLOCK_SIZE`, 512, for `doc-codec`) -- confirmed as real, independent values against Apache POI's own `Biff8DecryptingStream` and `BinaryRC4Decryptor` respectively, not one shared constant this package could have assumed. `md5`/`rc4` are exported individually too, for reuse by the RC4 CryptoAPI scheme below, which is symmetric enough to need `rc4` but not this module's own MD5-based key derivation.
+
+### RC4 CryptoAPI encryption (.ppt)
+
+```ts
+import {
+  deriveRc4CryptoApiBlockKey,
+  verifyRc4CryptoApiPassword,
+  rc4,
+} from "archive-codec";
+
+// salt, keySizeBits, and the encrypted verifier fields come from the caller's
+// own DocumentEncryptionAtom reading (ppt-codec's own [MS-PPT] 2.3.7 handling,
+// not this package's concern).
+if (
+  !verifyRc4CryptoApiPassword(
+    password,
+    salt,
+    keySizeBits,
+    encryptedVerifier,
+    encryptedVerifierHash,
+  )
+) {
+  throw new Error("wrong password");
+}
+// block is the persist object's own persist ID, not a byte offset -- see below.
+const key = deriveRc4CryptoApiBlockKey(password, salt, block, keySizeBits);
+const plaintext = rc4(key, ciphertext);
+```
+
+`deriveRc4CryptoApiBlockKey`/`verifyRc4CryptoApiPassword` implement [MS-OFFCRYPTO] 2.3.5.1/2.3.5.2's "RC4 CryptoAPI Encryption" scheme, `.ppt`'s own encryption ([documents.js#1116](https://github.com/ExaDev/documents.js/issues/1116)) -- genuinely different from the [Legacy Office encryption](#legacy-office-encryption) scheme above despite both ending in an RC4 keystream: SHA-1 rather than MD5, one hash of the salt and password folded with the block number rather than an intermediate 336-byte buffer, and (per the spec's own prose) explicitly not iterated. There is no `decryptOfficeRc4`-style entry point with its own block-boundary loop here, because RC4 CryptoAPI does not re-key at fixed byte intervals within one continuous stream the way the legacy scheme does: it re-keys per persist object, using that object's own persist ID as the "block number" -- a caller derives the one key its own object needs and applies this package's own `rc4` directly, exactly as `ppt-codec`'s `decryptPptDocumentStream` does. Cross-checked against Apache POI's `EncryptionInfo`/`StandardEncryptionHeader`/`CryptoAPIEncryptionHeader` and nolze/msoffcrypto-tool's `method/rc4_cryptoapi.py`, whose own `_makekey`/`verifypw` this module's derivation and verification mirror.
 
 ### ZIP container
 

package/dist/crypto/office-rc4-cryptoapi.cjs

@@ -0,0 +1,62 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_crypto_sha1 = require("./sha1.cjs");
+const require_crypto_rc4 = require("./rc4.cjs");
+const require_crypto_office_rc4 = require("./office-rc4.cjs");
+//#region src/crypto/office-rc4-cryptoapi.ts
+/** [MS-OFFCRYPTO] 2.3.5.1: "If set to 0x00000000, [keySize] MUST be interpreted as 0x00000028 bits" -- confirmed against Apache POI's `StandardEncryptionHeader` constructor, which special-cases exactly this value before calling `setKeySize`. */
+const RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS = 40;
+/** The salt length [MS-OFFCRYPTO] 2.3.4.6's EncryptionVerifier (shared by the CryptoAPI and Standard/AES schemes alike) fixes for every cipher: "the SaltSize field... MUST be 0x00000010" -- confirmed against Apache POI's `StandardEncryptionVerifier`, which throws if the on-disk saltSize field disagrees. */
+const RC4_CRYPTOAPI_SALT_LENGTH = 16;
+/** The EncryptedVerifier field's own fixed length, [MS-OFFCRYPTO] 2.3.4.6/2.3.4.9: "an array of 16 bytes." */
+const RC4_CRYPTOAPI_VERIFIER_LENGTH = 16;
+/** EncryptedVerifierHash's length for RC4 specifically (as opposed to AES's 32): [MS-OFFCRYPTO] 2.3.4.9 -- "If the encryption algorithm is RC4, the length MUST be 20 bytes" -- confirmed against Apache POI's `CipherAlgorithm.rc4.encryptedVerifierHashLength`. This module implements RC4 only, so this constant is unconditional here (a caller finding algId names AES instead has found a file outside this module's scope, per the top comment). */
+const RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH = 20;
+function keySizeBitsOf(keySizeBits) {
+	return keySizeBits === 0 ? 40 : keySizeBits;
+}
+function bytesEqual(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((byte, index) => byte === b[index]);
+}
+/** The per-persist-object RC4 key: SHA1(SHA1(salt + UTF-16LE password) + the block number as 4 little-endian bytes), truncated to `keySizeBits`. [MS-OFFCRYPTO] 2.3.5.1's own 40-bit special case is real, not a rounding artefact: a 40-bit key is still carried in a 16-byte buffer (the derived hash's own first 5 bytes, zero-padded to 16), confirmed directly against nolze/msoffcrypto-tool's `_makekey` (`key = hfinal[:5] + b"\x00" * 11`) -- the "effective" key strength is 40 bits, but the RC4 key schedule this package's own `rc4` runs still consumes all 16 bytes of it. */
+function deriveRc4CryptoApiBlockKey(password, salt, block, keySizeBits) {
+	const passwordBytes = require_crypto_office_rc4.passwordToUtf16LeBytes(password);
+	const saltAndPassword = new Uint8Array(salt.length + passwordBytes.length);
+	saltAndPassword.set(salt, 0);
+	saltAndPassword.set(passwordBytes, salt.length);
+	const h0 = require_crypto_sha1.sha1(saltAndPassword);
+	const blockBytes = /* @__PURE__ */ new Uint8Array(4);
+	blockBytes[0] = block & 255;
+	blockBytes[1] = block >>> 8 & 255;
+	blockBytes[2] = block >>> 16 & 255;
+	blockBytes[3] = block >>> 24 & 255;
+	const h0AndBlock = new Uint8Array(h0.length + blockBytes.length);
+	h0AndBlock.set(h0, 0);
+	h0AndBlock.set(blockBytes, h0.length);
+	const hfinal = require_crypto_sha1.sha1(h0AndBlock);
+	const effectiveKeySizeBits = keySizeBitsOf(keySizeBits);
+	if (effectiveKeySizeBits === 40) {
+		const key = /* @__PURE__ */ new Uint8Array(16);
+		key.set(hfinal.subarray(0, 5), 0);
+		return key;
+	}
+	return hfinal.subarray(0, effectiveKeySizeBits / 8);
+}
+/** Verifies a candidate password against a DocumentEncryptionAtom's own EncryptionVerifier fields ([MS-OFFCRYPTO] 2.3.4.9): the block-0 key decrypts `encryptedVerifier` immediately followed by `encryptedVerifierHash` as ONE continuous 36-byte RC4 keystream application -- not two independent decryptions, each of which would wrongly restart the keystream at its own start -- and the password is correct exactly when SHA1 of the decrypted 16-byte verifier equals the decrypted hash's own first 20 bytes. */
+function verifyRc4CryptoApiPassword(password, salt, keySizeBits, encryptedVerifier, encryptedVerifierHash) {
+	const key = deriveRc4CryptoApiBlockKey(password, salt, 0, keySizeBits);
+	const combined = new Uint8Array(encryptedVerifier.length + encryptedVerifierHash.length);
+	combined.set(encryptedVerifier, 0);
+	combined.set(encryptedVerifierHash, encryptedVerifier.length);
+	const decrypted = require_crypto_rc4.rc4(key, combined);
+	const verifier = decrypted.subarray(0, encryptedVerifier.length);
+	const hash = decrypted.subarray(encryptedVerifier.length, encryptedVerifier.length + 20);
+	return bytesEqual(require_crypto_sha1.sha1(verifier), hash);
+}
+//#endregion
+exports.RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS = RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS;
+exports.RC4_CRYPTOAPI_SALT_LENGTH = RC4_CRYPTOAPI_SALT_LENGTH;
+exports.RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH = RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH;
+exports.RC4_CRYPTOAPI_VERIFIER_LENGTH = RC4_CRYPTOAPI_VERIFIER_LENGTH;
+exports.deriveRc4CryptoApiBlockKey = deriveRc4CryptoApiBlockKey;
+exports.verifyRc4CryptoApiPassword = verifyRc4CryptoApiPassword;

package/dist/crypto/office-rc4-cryptoapi.d.cts

@@ -0,0 +1,15 @@
+//#region src/crypto/office-rc4-cryptoapi.d.ts
+/** [MS-OFFCRYPTO] 2.3.5.1: "If set to 0x00000000, [keySize] MUST be interpreted as 0x00000028 bits" -- confirmed against Apache POI's `StandardEncryptionHeader` constructor, which special-cases exactly this value before calling `setKeySize`. */
+declare const RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS = 40;
+/** The salt length [MS-OFFCRYPTO] 2.3.4.6's EncryptionVerifier (shared by the CryptoAPI and Standard/AES schemes alike) fixes for every cipher: "the SaltSize field... MUST be 0x00000010" -- confirmed against Apache POI's `StandardEncryptionVerifier`, which throws if the on-disk saltSize field disagrees. */
+declare const RC4_CRYPTOAPI_SALT_LENGTH = 16;
+/** The EncryptedVerifier field's own fixed length, [MS-OFFCRYPTO] 2.3.4.6/2.3.4.9: "an array of 16 bytes." */
+declare const RC4_CRYPTOAPI_VERIFIER_LENGTH = 16;
+/** EncryptedVerifierHash's length for RC4 specifically (as opposed to AES's 32): [MS-OFFCRYPTO] 2.3.4.9 -- "If the encryption algorithm is RC4, the length MUST be 20 bytes" -- confirmed against Apache POI's `CipherAlgorithm.rc4.encryptedVerifierHashLength`. This module implements RC4 only, so this constant is unconditional here (a caller finding algId names AES instead has found a file outside this module's scope, per the top comment). */
+declare const RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH = 20;
+/** The per-persist-object RC4 key: SHA1(SHA1(salt + UTF-16LE password) + the block number as 4 little-endian bytes), truncated to `keySizeBits`. [MS-OFFCRYPTO] 2.3.5.1's own 40-bit special case is real, not a rounding artefact: a 40-bit key is still carried in a 16-byte buffer (the derived hash's own first 5 bytes, zero-padded to 16), confirmed directly against nolze/msoffcrypto-tool's `_makekey` (`key = hfinal[:5] + b"\x00" * 11`) -- the "effective" key strength is 40 bits, but the RC4 key schedule this package's own `rc4` runs still consumes all 16 bytes of it. */
+declare function deriveRc4CryptoApiBlockKey(password: string, salt: Uint8Array<ArrayBuffer>, block: number, keySizeBits: number): Uint8Array<ArrayBuffer>;
+/** Verifies a candidate password against a DocumentEncryptionAtom's own EncryptionVerifier fields ([MS-OFFCRYPTO] 2.3.4.9): the block-0 key decrypts `encryptedVerifier` immediately followed by `encryptedVerifierHash` as ONE continuous 36-byte RC4 keystream application -- not two independent decryptions, each of which would wrongly restart the keystream at its own start -- and the password is correct exactly when SHA1 of the decrypted 16-byte verifier equals the decrypted hash's own first 20 bytes. */
+declare function verifyRc4CryptoApiPassword(password: string, salt: Uint8Array<ArrayBuffer>, keySizeBits: number, encryptedVerifier: Uint8Array<ArrayBuffer>, encryptedVerifierHash: Uint8Array<ArrayBuffer>): boolean;
+//#endregion
+export { RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, deriveRc4CryptoApiBlockKey, verifyRc4CryptoApiPassword };

package/dist/crypto/office-rc4-cryptoapi.d.ts

@@ -0,0 +1,15 @@
+//#region src/crypto/office-rc4-cryptoapi.d.ts
+/** [MS-OFFCRYPTO] 2.3.5.1: "If set to 0x00000000, [keySize] MUST be interpreted as 0x00000028 bits" -- confirmed against Apache POI's `StandardEncryptionHeader` constructor, which special-cases exactly this value before calling `setKeySize`. */
+declare const RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS = 40;
+/** The salt length [MS-OFFCRYPTO] 2.3.4.6's EncryptionVerifier (shared by the CryptoAPI and Standard/AES schemes alike) fixes for every cipher: "the SaltSize field... MUST be 0x00000010" -- confirmed against Apache POI's `StandardEncryptionVerifier`, which throws if the on-disk saltSize field disagrees. */
+declare const RC4_CRYPTOAPI_SALT_LENGTH = 16;
+/** The EncryptedVerifier field's own fixed length, [MS-OFFCRYPTO] 2.3.4.6/2.3.4.9: "an array of 16 bytes." */
+declare const RC4_CRYPTOAPI_VERIFIER_LENGTH = 16;
+/** EncryptedVerifierHash's length for RC4 specifically (as opposed to AES's 32): [MS-OFFCRYPTO] 2.3.4.9 -- "If the encryption algorithm is RC4, the length MUST be 20 bytes" -- confirmed against Apache POI's `CipherAlgorithm.rc4.encryptedVerifierHashLength`. This module implements RC4 only, so this constant is unconditional here (a caller finding algId names AES instead has found a file outside this module's scope, per the top comment). */
+declare const RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH = 20;
+/** The per-persist-object RC4 key: SHA1(SHA1(salt + UTF-16LE password) + the block number as 4 little-endian bytes), truncated to `keySizeBits`. [MS-OFFCRYPTO] 2.3.5.1's own 40-bit special case is real, not a rounding artefact: a 40-bit key is still carried in a 16-byte buffer (the derived hash's own first 5 bytes, zero-padded to 16), confirmed directly against nolze/msoffcrypto-tool's `_makekey` (`key = hfinal[:5] + b"\x00" * 11`) -- the "effective" key strength is 40 bits, but the RC4 key schedule this package's own `rc4` runs still consumes all 16 bytes of it. */
+declare function deriveRc4CryptoApiBlockKey(password: string, salt: Uint8Array<ArrayBuffer>, block: number, keySizeBits: number): Uint8Array<ArrayBuffer>;
+/** Verifies a candidate password against a DocumentEncryptionAtom's own EncryptionVerifier fields ([MS-OFFCRYPTO] 2.3.4.9): the block-0 key decrypts `encryptedVerifier` immediately followed by `encryptedVerifierHash` as ONE continuous 36-byte RC4 keystream application -- not two independent decryptions, each of which would wrongly restart the keystream at its own start -- and the password is correct exactly when SHA1 of the decrypted 16-byte verifier equals the decrypted hash's own first 20 bytes. */
+declare function verifyRc4CryptoApiPassword(password: string, salt: Uint8Array<ArrayBuffer>, keySizeBits: number, encryptedVerifier: Uint8Array<ArrayBuffer>, encryptedVerifierHash: Uint8Array<ArrayBuffer>): boolean;
+//#endregion
+export { RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, deriveRc4CryptoApiBlockKey, verifyRc4CryptoApiPassword };

package/dist/crypto/office-rc4-cryptoapi.js

@@ -0,0 +1,56 @@
+import { sha1 } from "./sha1.js";
+import { rc4 } from "./rc4.js";
+import { passwordToUtf16LeBytes } from "./office-rc4.js";
+//#region src/crypto/office-rc4-cryptoapi.ts
+/** [MS-OFFCRYPTO] 2.3.5.1: "If set to 0x00000000, [keySize] MUST be interpreted as 0x00000028 bits" -- confirmed against Apache POI's `StandardEncryptionHeader` constructor, which special-cases exactly this value before calling `setKeySize`. */
+const RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS = 40;
+/** The salt length [MS-OFFCRYPTO] 2.3.4.6's EncryptionVerifier (shared by the CryptoAPI and Standard/AES schemes alike) fixes for every cipher: "the SaltSize field... MUST be 0x00000010" -- confirmed against Apache POI's `StandardEncryptionVerifier`, which throws if the on-disk saltSize field disagrees. */
+const RC4_CRYPTOAPI_SALT_LENGTH = 16;
+/** The EncryptedVerifier field's own fixed length, [MS-OFFCRYPTO] 2.3.4.6/2.3.4.9: "an array of 16 bytes." */
+const RC4_CRYPTOAPI_VERIFIER_LENGTH = 16;
+/** EncryptedVerifierHash's length for RC4 specifically (as opposed to AES's 32): [MS-OFFCRYPTO] 2.3.4.9 -- "If the encryption algorithm is RC4, the length MUST be 20 bytes" -- confirmed against Apache POI's `CipherAlgorithm.rc4.encryptedVerifierHashLength`. This module implements RC4 only, so this constant is unconditional here (a caller finding algId names AES instead has found a file outside this module's scope, per the top comment). */
+const RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH = 20;
+function keySizeBitsOf(keySizeBits) {
+	return keySizeBits === 0 ? 40 : keySizeBits;
+}
+function bytesEqual(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((byte, index) => byte === b[index]);
+}
+/** The per-persist-object RC4 key: SHA1(SHA1(salt + UTF-16LE password) + the block number as 4 little-endian bytes), truncated to `keySizeBits`. [MS-OFFCRYPTO] 2.3.5.1's own 40-bit special case is real, not a rounding artefact: a 40-bit key is still carried in a 16-byte buffer (the derived hash's own first 5 bytes, zero-padded to 16), confirmed directly against nolze/msoffcrypto-tool's `_makekey` (`key = hfinal[:5] + b"\x00" * 11`) -- the "effective" key strength is 40 bits, but the RC4 key schedule this package's own `rc4` runs still consumes all 16 bytes of it. */
+function deriveRc4CryptoApiBlockKey(password, salt, block, keySizeBits) {
+	const passwordBytes = passwordToUtf16LeBytes(password);
+	const saltAndPassword = new Uint8Array(salt.length + passwordBytes.length);
+	saltAndPassword.set(salt, 0);
+	saltAndPassword.set(passwordBytes, salt.length);
+	const h0 = sha1(saltAndPassword);
+	const blockBytes = /* @__PURE__ */ new Uint8Array(4);
+	blockBytes[0] = block & 255;
+	blockBytes[1] = block >>> 8 & 255;
+	blockBytes[2] = block >>> 16 & 255;
+	blockBytes[3] = block >>> 24 & 255;
+	const h0AndBlock = new Uint8Array(h0.length + blockBytes.length);
+	h0AndBlock.set(h0, 0);
+	h0AndBlock.set(blockBytes, h0.length);
+	const hfinal = sha1(h0AndBlock);
+	const effectiveKeySizeBits = keySizeBitsOf(keySizeBits);
+	if (effectiveKeySizeBits === 40) {
+		const key = /* @__PURE__ */ new Uint8Array(16);
+		key.set(hfinal.subarray(0, 5), 0);
+		return key;
+	}
+	return hfinal.subarray(0, effectiveKeySizeBits / 8);
+}
+/** Verifies a candidate password against a DocumentEncryptionAtom's own EncryptionVerifier fields ([MS-OFFCRYPTO] 2.3.4.9): the block-0 key decrypts `encryptedVerifier` immediately followed by `encryptedVerifierHash` as ONE continuous 36-byte RC4 keystream application -- not two independent decryptions, each of which would wrongly restart the keystream at its own start -- and the password is correct exactly when SHA1 of the decrypted 16-byte verifier equals the decrypted hash's own first 20 bytes. */
+function verifyRc4CryptoApiPassword(password, salt, keySizeBits, encryptedVerifier, encryptedVerifierHash) {
+	const key = deriveRc4CryptoApiBlockKey(password, salt, 0, keySizeBits);
+	const combined = new Uint8Array(encryptedVerifier.length + encryptedVerifierHash.length);
+	combined.set(encryptedVerifier, 0);
+	combined.set(encryptedVerifierHash, encryptedVerifier.length);
+	const decrypted = rc4(key, combined);
+	const verifier = decrypted.subarray(0, encryptedVerifier.length);
+	const hash = decrypted.subarray(encryptedVerifier.length, encryptedVerifier.length + 20);
+	return bytesEqual(sha1(verifier), hash);
+}
+//#endregion
+export { RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, deriveRc4CryptoApiBlockKey, verifyRc4CryptoApiPassword };

package/dist/crypto/office-rc4.cjs

@@ -10,6 +10,7 @@ const OFFICE_RC4_BLOCK_SIZE = 1024;
 const OFFICE_RC4_DOC_BLOCK_SIZE = 512;
 /** The intermediate H0/H1 truncation [MS-OFFCRYPTO] 2.3.6.2 states explicitly ("H0's own first 5 bytes", "H1's own first 5 bytes") -- distinct from the FINAL per-block key length, which is Hfinal in full (see this file's own top comment) and is never truncated. */
 const INTERMEDIATE_HASH_LENGTH_BYTES = 5;
+/** UTF-16LE password encoding, shared with office-rc4-cryptoapi.ts: both [MS-OFFCRYPTO] key-derivation schemes this package implements hash a password in this same encoding, per their own respective specs (2.3.6.2 and 2.3.5.2). */
 function passwordToUtf16LeBytes(password) {
 	const bytes = new Uint8Array(password.length * 2);
 	for (let i = 0; i < password.length; i += 1) {
@@ -70,3 +71,4 @@ exports.OFFICE_RC4_VERIFIER_LENGTH = OFFICE_RC4_VERIFIER_LENGTH;
 exports.decryptOfficeRc4 = decryptOfficeRc4;
 exports.deriveOfficeRc4BaseHash = deriveOfficeRc4BaseHash;
 exports.deriveOfficeRc4BlockKey = deriveOfficeRc4BlockKey;
+exports.passwordToUtf16LeBytes = passwordToUtf16LeBytes;

package/dist/crypto/office-rc4.d.cts

@@ -5,6 +5,8 @@ declare const OFFICE_RC4_VERIFIER_LENGTH = 16;
 declare const OFFICE_RC4_BLOCK_SIZE = 1024;
 /** [MS-DOC] 2.2.6.2's own re-keying interval for its identical RC4 encryption header scheme -- stated directly in the spec's own prose ("encrypted in 512-byte blocks"), confirmed independently against Apache POI's BinaryRC4Decryptor (`chunkSize = 512`). Genuinely different from OFFICE_RC4_BLOCK_SIZE, not a duplicate of it -- pass this as decryptOfficeRc4's own `blockSize` argument when decrypting a .doc stream. */
 declare const OFFICE_RC4_DOC_BLOCK_SIZE = 512;
+/** UTF-16LE password encoding, shared with office-rc4-cryptoapi.ts: both [MS-OFFCRYPTO] key-derivation schemes this package implements hash a password in this same encoding, per their own respective specs (2.3.6.2 and 2.3.5.2). */
+declare function passwordToUtf16LeBytes(password: string): Uint8Array<ArrayBuffer>;
 /** The per-workbook intermediate hash (H1's own first 5 bytes) every block's key derives from -- computed once per password+salt pair, then reused across every block via deriveOfficeRc4BlockKey, since recomputing H0/H1 per block would be needless repeated work over the identical 336-byte buffer. */
 declare function deriveOfficeRc4BaseHash(password: string, salt: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 /** The real, block-specific RC4 key: MD5(baseHash + the block number as 4 little-endian bytes) in full -- all 16 bytes, never truncated (see this file's own top comment for why that matters). */
@@ -16,4 +18,4 @@ declare function deriveOfficeRc4BlockKey(baseHash: Uint8Array<ArrayBuffer>, bloc
  */
 declare function decryptOfficeRc4(baseHash: Uint8Array<ArrayBuffer>, streamOffset: number, data: Uint8Array<ArrayBuffer>, blockSize?: number): Uint8Array<ArrayBuffer>;
 //#endregion
-export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey };
+export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, passwordToUtf16LeBytes };

package/dist/crypto/office-rc4.d.ts

@@ -5,6 +5,8 @@ declare const OFFICE_RC4_VERIFIER_LENGTH = 16;
 declare const OFFICE_RC4_BLOCK_SIZE = 1024;
 /** [MS-DOC] 2.2.6.2's own re-keying interval for its identical RC4 encryption header scheme -- stated directly in the spec's own prose ("encrypted in 512-byte blocks"), confirmed independently against Apache POI's BinaryRC4Decryptor (`chunkSize = 512`). Genuinely different from OFFICE_RC4_BLOCK_SIZE, not a duplicate of it -- pass this as decryptOfficeRc4's own `blockSize` argument when decrypting a .doc stream. */
 declare const OFFICE_RC4_DOC_BLOCK_SIZE = 512;
+/** UTF-16LE password encoding, shared with office-rc4-cryptoapi.ts: both [MS-OFFCRYPTO] key-derivation schemes this package implements hash a password in this same encoding, per their own respective specs (2.3.6.2 and 2.3.5.2). */
+declare function passwordToUtf16LeBytes(password: string): Uint8Array<ArrayBuffer>;
 /** The per-workbook intermediate hash (H1's own first 5 bytes) every block's key derives from -- computed once per password+salt pair, then reused across every block via deriveOfficeRc4BlockKey, since recomputing H0/H1 per block would be needless repeated work over the identical 336-byte buffer. */
 declare function deriveOfficeRc4BaseHash(password: string, salt: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 /** The real, block-specific RC4 key: MD5(baseHash + the block number as 4 little-endian bytes) in full -- all 16 bytes, never truncated (see this file's own top comment for why that matters). */
@@ -16,4 +18,4 @@ declare function deriveOfficeRc4BlockKey(baseHash: Uint8Array<ArrayBuffer>, bloc
  */
 declare function decryptOfficeRc4(baseHash: Uint8Array<ArrayBuffer>, streamOffset: number, data: Uint8Array<ArrayBuffer>, blockSize?: number): Uint8Array<ArrayBuffer>;
 //#endregion
-export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey };
+export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, passwordToUtf16LeBytes };

package/dist/crypto/office-rc4.js

@@ -9,6 +9,7 @@ const OFFICE_RC4_BLOCK_SIZE = 1024;
 const OFFICE_RC4_DOC_BLOCK_SIZE = 512;
 /** The intermediate H0/H1 truncation [MS-OFFCRYPTO] 2.3.6.2 states explicitly ("H0's own first 5 bytes", "H1's own first 5 bytes") -- distinct from the FINAL per-block key length, which is Hfinal in full (see this file's own top comment) and is never truncated. */
 const INTERMEDIATE_HASH_LENGTH_BYTES = 5;
+/** UTF-16LE password encoding, shared with office-rc4-cryptoapi.ts: both [MS-OFFCRYPTO] key-derivation schemes this package implements hash a password in this same encoding, per their own respective specs (2.3.6.2 and 2.3.5.2). */
 function passwordToUtf16LeBytes(password) {
 	const bytes = new Uint8Array(password.length * 2);
 	for (let i = 0; i < password.length; i += 1) {
@@ -63,4 +64,4 @@ function decryptOfficeRc4(baseHash, streamOffset, data, blockSize = OFFICE_RC4_B
 	return out;
 }
 //#endregion
-export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey };
+export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, passwordToUtf16LeBytes };

package/dist/crypto/sha1.cjs

@@ -0,0 +1,89 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/crypto/sha1.ts
+const BLOCK_BYTES = 64;
+const DIGEST_BYTES = 20;
+const ROUNDS = 80;
+const WORDS_PER_BLOCK = 16;
+const H0_INIT = 1732584193;
+const H1_INIT = 4023233417;
+const H2_INIT = 2562383102;
+const H3_INIT = 271733878;
+const H4_INIT = 3285377520;
+function rotateLeft(value, bits) {
+	return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function pad(message) {
+	const bitLength = message.length * 8;
+	const paddedLength = Math.ceil((message.length + 9) / BLOCK_BYTES) * BLOCK_BYTES;
+	const buffer = new ArrayBuffer(paddedLength);
+	const view = new DataView(buffer);
+	new Uint8Array(buffer).set(message, 0);
+	view.setUint8(message.length, 128);
+	view.setUint32(paddedLength - 8, 0);
+	view.setUint32(paddedLength - 4, bitLength >>> 0);
+	return view;
+}
+function sha1(message) {
+	const padded = pad(message);
+	const blockCount = padded.byteLength / BLOCK_BYTES;
+	let h0 = H0_INIT;
+	let h1 = H1_INIT;
+	let h2 = H2_INIT;
+	let h3 = H3_INIT;
+	let h4 = H4_INIT;
+	const schedule = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(320));
+	for (let block = 0; block < blockCount; block += 1) {
+		const blockStart = block * BLOCK_BYTES;
+		for (let i = 0; i < WORDS_PER_BLOCK; i += 1) schedule.setUint32(i * 4, padded.getUint32(blockStart + i * 4));
+		for (let i = WORDS_PER_BLOCK; i < ROUNDS; i += 1) {
+			const w3 = schedule.getUint32((i - 3) * 4);
+			const w8 = schedule.getUint32((i - 8) * 4);
+			const w14 = schedule.getUint32((i - 14) * 4);
+			const w16 = schedule.getUint32((i - 16) * 4);
+			schedule.setUint32(i * 4, rotateLeft(w3 ^ w8 ^ w14 ^ w16, 1));
+		}
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		for (let i = 0; i < ROUNDS; i += 1) {
+			let f;
+			let k;
+			if (i < 20) {
+				f = b & c | ~b & d;
+				k = 1518500249;
+			} else if (i < 40) {
+				f = b ^ c ^ d;
+				k = 1859775393;
+			} else if (i < 60) {
+				f = b & c | b & d | c & d;
+				k = 2400959708;
+			} else {
+				f = b ^ c ^ d;
+				k = 3395469782;
+			}
+			const w = schedule.getUint32(i * 4);
+			const temp = rotateLeft(a, 5) + f + e + k + w >>> 0;
+			e = d;
+			d = c;
+			c = rotateLeft(b, 30);
+			b = a;
+			a = temp;
+		}
+		h0 = h0 + a >>> 0;
+		h1 = h1 + b >>> 0;
+		h2 = h2 + c >>> 0;
+		h3 = h3 + d >>> 0;
+		h4 = h4 + e >>> 0;
+	}
+	const digest = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(DIGEST_BYTES));
+	digest.setUint32(0, h0);
+	digest.setUint32(4, h1);
+	digest.setUint32(8, h2);
+	digest.setUint32(12, h3);
+	digest.setUint32(16, h4);
+	return new Uint8Array(digest.buffer);
+}
+//#endregion
+exports.sha1 = sha1;

package/dist/crypto/sha1.d.cts

@@ -0,0 +1,4 @@
+//#region src/crypto/sha1.d.ts
+declare function sha1(message: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { sha1 };

package/dist/crypto/sha1.d.ts

@@ -0,0 +1,4 @@
+//#region src/crypto/sha1.d.ts
+declare function sha1(message: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { sha1 };

package/dist/crypto/sha1.js

@@ -0,0 +1,88 @@
+//#region src/crypto/sha1.ts
+const BLOCK_BYTES = 64;
+const DIGEST_BYTES = 20;
+const ROUNDS = 80;
+const WORDS_PER_BLOCK = 16;
+const H0_INIT = 1732584193;
+const H1_INIT = 4023233417;
+const H2_INIT = 2562383102;
+const H3_INIT = 271733878;
+const H4_INIT = 3285377520;
+function rotateLeft(value, bits) {
+	return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function pad(message) {
+	const bitLength = message.length * 8;
+	const paddedLength = Math.ceil((message.length + 9) / BLOCK_BYTES) * BLOCK_BYTES;
+	const buffer = new ArrayBuffer(paddedLength);
+	const view = new DataView(buffer);
+	new Uint8Array(buffer).set(message, 0);
+	view.setUint8(message.length, 128);
+	view.setUint32(paddedLength - 8, 0);
+	view.setUint32(paddedLength - 4, bitLength >>> 0);
+	return view;
+}
+function sha1(message) {
+	const padded = pad(message);
+	const blockCount = padded.byteLength / BLOCK_BYTES;
+	let h0 = H0_INIT;
+	let h1 = H1_INIT;
+	let h2 = H2_INIT;
+	let h3 = H3_INIT;
+	let h4 = H4_INIT;
+	const schedule = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(320));
+	for (let block = 0; block < blockCount; block += 1) {
+		const blockStart = block * BLOCK_BYTES;
+		for (let i = 0; i < WORDS_PER_BLOCK; i += 1) schedule.setUint32(i * 4, padded.getUint32(blockStart + i * 4));
+		for (let i = WORDS_PER_BLOCK; i < ROUNDS; i += 1) {
+			const w3 = schedule.getUint32((i - 3) * 4);
+			const w8 = schedule.getUint32((i - 8) * 4);
+			const w14 = schedule.getUint32((i - 14) * 4);
+			const w16 = schedule.getUint32((i - 16) * 4);
+			schedule.setUint32(i * 4, rotateLeft(w3 ^ w8 ^ w14 ^ w16, 1));
+		}
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		for (let i = 0; i < ROUNDS; i += 1) {
+			let f;
+			let k;
+			if (i < 20) {
+				f = b & c | ~b & d;
+				k = 1518500249;
+			} else if (i < 40) {
+				f = b ^ c ^ d;
+				k = 1859775393;
+			} else if (i < 60) {
+				f = b & c | b & d | c & d;
+				k = 2400959708;
+			} else {
+				f = b ^ c ^ d;
+				k = 3395469782;
+			}
+			const w = schedule.getUint32(i * 4);
+			const temp = rotateLeft(a, 5) + f + e + k + w >>> 0;
+			e = d;
+			d = c;
+			c = rotateLeft(b, 30);
+			b = a;
+			a = temp;
+		}
+		h0 = h0 + a >>> 0;
+		h1 = h1 + b >>> 0;
+		h2 = h2 + c >>> 0;
+		h3 = h3 + d >>> 0;
+		h4 = h4 + e >>> 0;
+	}
+	const digest = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(DIGEST_BYTES));
+	digest.setUint32(0, h0);
+	digest.setUint32(4, h1);
+	digest.setUint32(8, h2);
+	digest.setUint32(12, h3);
+	digest.setUint32(16, h4);
+	return new Uint8Array(digest.buffer);
+}
+//#endregion
+export { sha1 };

package/dist/index.cjs

@@ -4,8 +4,10 @@ const require_cfb_ole_package = require("./cfb/ole-package.cjs");
 const require_cfb_read = require("./cfb/read.cjs");
 const require_cfb_write = require("./cfb/write.cjs");
 const require_crypto_md5 = require("./crypto/md5.cjs");
+const require_crypto_sha1 = require("./crypto/sha1.cjs");
 const require_crypto_rc4 = require("./crypto/rc4.cjs");
 const require_crypto_office_rc4 = require("./crypto/office-rc4.cjs");
+const require_crypto_office_rc4_cryptoapi = require("./crypto/office-rc4-cryptoapi.cjs");
 const require_oleps_layout_metadata = require("./oleps/layout-metadata.cjs");
 const require_oleps_read = require("./oleps/read.cjs");
 const require_oleps_write = require("./oleps/write.cjs");
@@ -27,22 +29,30 @@ exports.OlePackageFormatError = require_cfb_ole_package.OlePackageFormatError;
 exports.OlePackageWriteError = require_cfb_ole_package.OlePackageWriteError;
 exports.PropertySetFormatError = require_oleps_read.PropertySetFormatError;
 exports.PropertySetWriteError = require_oleps_write.PropertySetWriteError;
+exports.RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS = require_crypto_office_rc4_cryptoapi.RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS;
+exports.RC4_CRYPTOAPI_SALT_LENGTH = require_crypto_office_rc4_cryptoapi.RC4_CRYPTOAPI_SALT_LENGTH;
+exports.RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH = require_crypto_office_rc4_cryptoapi.RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH;
+exports.RC4_CRYPTOAPI_VERIFIER_LENGTH = require_crypto_office_rc4_cryptoapi.RC4_CRYPTOAPI_VERIFIER_LENGTH;
 exports.decryptOfficeRc4 = require_crypto_office_rc4.decryptOfficeRc4;
 exports.deriveOfficeRc4BaseHash = require_crypto_office_rc4.deriveOfficeRc4BaseHash;
 exports.deriveOfficeRc4BlockKey = require_crypto_office_rc4.deriveOfficeRc4BlockKey;
+exports.deriveRc4CryptoApiBlockKey = require_crypto_office_rc4_cryptoapi.deriveRc4CryptoApiBlockKey;
 exports.detectArchiveFormat = require_zip_detect.detectArchiveFormat;
 exports.hasSummaryInformationFields = require_oleps_layout_metadata.hasSummaryInformationFields;
 exports.isCompoundFile = require_cfb_detect.isCompoundFile;
 exports.isZipArchive = require_zip_detect.isZipArchive;
 exports.layoutMetadataToSummaryInformation = require_oleps_layout_metadata.layoutMetadataToSummaryInformation;
 exports.md5 = require_crypto_md5.md5;
+exports.passwordToUtf16LeBytes = require_crypto_office_rc4.passwordToUtf16LeBytes;
 exports.rc4 = require_crypto_rc4.rc4;
 exports.readCompoundFile = require_cfb_read.readCompoundFile;
 exports.readOlePackage = require_cfb_ole_package.readOlePackage;
 exports.readPropertySetStream = require_oleps_read.readPropertySetStream;
 exports.readSummaryInformation = require_oleps_summary_information.readSummaryInformation;
+exports.sha1 = require_crypto_sha1.sha1;
 exports.summaryInformationToLayoutMetadata = require_oleps_layout_metadata.summaryInformationToLayoutMetadata;
 exports.unzipPackage = require_zip_container.unzipPackage;
+exports.verifyRc4CryptoApiPassword = require_crypto_office_rc4_cryptoapi.verifyRc4CryptoApiPassword;
 exports.walkArchive = require_zip_walk.walkArchive;
 exports.writeCompoundFile = require_cfb_write.writeCompoundFile;
 exports.writeOlePackage = require_cfb_ole_package.writeOlePackage;

package/dist/index.d.cts

@@ -3,8 +3,10 @@ import { OlePackage, OlePackageFormatError, OlePackageWriteError, readOlePackage
 import { CompoundFileFormatError, CompoundFileStream, MAX_CFB_TOTAL_STREAM_BYTES, ReadCompoundFileOptions, readCompoundFile } from "./cfb/read.cjs";
 import { CompoundFileWriteError, WriteCompoundFileOptions, writeCompoundFile } from "./cfb/write.cjs";
 import { md5 } from "./crypto/md5.cjs";
-import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey } from "./crypto/office-rc4.cjs";
+import { RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, deriveRc4CryptoApiBlockKey, verifyRc4CryptoApiPassword } from "./crypto/office-rc4-cryptoapi.cjs";
+import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, passwordToUtf16LeBytes } from "./crypto/office-rc4.cjs";
 import { rc4 } from "./crypto/rc4.cjs";
+import { sha1 } from "./crypto/sha1.cjs";
 import { FMTID_SUMMARY_INFORMATION, SummaryInformationProperties, readSummaryInformation, writeSummaryInformationStream } from "./oleps/summary-information.cjs";
 import { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata } from "./oleps/layout-metadata.cjs";
 import { PropertySet, PropertyValue } from "./oleps/wire.cjs";
@@ -13,4 +15,4 @@ import { PropertySetWriteError, writePropertySetStream } from "./oleps/write.cjs
 import { ZipEntry, unzipPackage, zipPackage } from "./zip/container.cjs";
 import { ArchiveFormat, detectArchiveFormat, isZipArchive } from "./zip/detect.cjs";
 import { ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, WalkArchiveOptions, walkArchive } from "./zip/walk.cjs";
-export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackage, OlePackageFormatError, OlePackageWriteError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };
+export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackage, OlePackageFormatError, OlePackageWriteError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, deriveRc4CryptoApiBlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, passwordToUtf16LeBytes, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, sha1, summaryInformationToLayoutMetadata, unzipPackage, verifyRc4CryptoApiPassword, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/dist/index.d.ts

@@ -3,8 +3,10 @@ import { OlePackage, OlePackageFormatError, OlePackageWriteError, readOlePackage
 import { CompoundFileFormatError, CompoundFileStream, MAX_CFB_TOTAL_STREAM_BYTES, ReadCompoundFileOptions, readCompoundFile } from "./cfb/read.js";
 import { CompoundFileWriteError, WriteCompoundFileOptions, writeCompoundFile } from "./cfb/write.js";
 import { md5 } from "./crypto/md5.js";
-import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey } from "./crypto/office-rc4.js";
+import { RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, deriveRc4CryptoApiBlockKey, verifyRc4CryptoApiPassword } from "./crypto/office-rc4-cryptoapi.js";
+import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, passwordToUtf16LeBytes } from "./crypto/office-rc4.js";
 import { rc4 } from "./crypto/rc4.js";
+import { sha1 } from "./crypto/sha1.js";
 import { FMTID_SUMMARY_INFORMATION, SummaryInformationProperties, readSummaryInformation, writeSummaryInformationStream } from "./oleps/summary-information.js";
 import { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata } from "./oleps/layout-metadata.js";
 import { PropertySet, PropertyValue } from "./oleps/wire.js";
@@ -13,4 +15,4 @@ import { PropertySetWriteError, writePropertySetStream } from "./oleps/write.js"
 import { ZipEntry, unzipPackage, zipPackage } from "./zip/container.js";
 import { ArchiveFormat, detectArchiveFormat, isZipArchive } from "./zip/detect.js";
 import { ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, WalkArchiveOptions, walkArchive } from "./zip/walk.js";
-export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackage, OlePackageFormatError, OlePackageWriteError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };
+export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackage, OlePackageFormatError, OlePackageWriteError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, deriveRc4CryptoApiBlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, passwordToUtf16LeBytes, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, sha1, summaryInformationToLayoutMetadata, unzipPackage, verifyRc4CryptoApiPassword, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/dist/index.js

@@ -3,8 +3,10 @@ import { OlePackageFormatError, OlePackageWriteError, readOlePackage, writeOlePa
 import { CompoundFileFormatError, MAX_CFB_TOTAL_STREAM_BYTES, readCompoundFile } from "./cfb/read.js";
 import { CompoundFileWriteError, writeCompoundFile } from "./cfb/write.js";
 import { md5 } from "./crypto/md5.js";
+import { sha1 } from "./crypto/sha1.js";
 import { rc4 } from "./crypto/rc4.js";
-import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey } from "./crypto/office-rc4.js";
+import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, passwordToUtf16LeBytes } from "./crypto/office-rc4.js";
+import { RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, deriveRc4CryptoApiBlockKey, verifyRc4CryptoApiPassword } from "./crypto/office-rc4-cryptoapi.js";
 import { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata } from "./oleps/layout-metadata.js";
 import { PropertySetFormatError, readPropertySetStream } from "./oleps/read.js";
 import { PropertySetWriteError, writePropertySetStream } from "./oleps/write.js";
@@ -12,4 +14,4 @@ import { FMTID_SUMMARY_INFORMATION, readSummaryInformation, writeSummaryInformat
 import { unzipPackage, zipPackage } from "./zip/container.js";
 import { detectArchiveFormat, isZipArchive } from "./zip/detect.js";
 import { ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, walkArchive } from "./zip/walk.js";
-export { ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackageFormatError, OlePackageWriteError, PropertySetFormatError, PropertySetWriteError, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };
+export { ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackageFormatError, OlePackageWriteError, PropertySetFormatError, PropertySetWriteError, RC4_CRYPTOAPI_DEFAULT_KEY_SIZE_BITS, RC4_CRYPTOAPI_SALT_LENGTH, RC4_CRYPTOAPI_VERIFIER_HASH_LENGTH, RC4_CRYPTOAPI_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, deriveRc4CryptoApiBlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, passwordToUtf16LeBytes, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, sha1, summaryInformationToLayoutMetadata, unzipPackage, verifyRc4CryptoApiPassword, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archive-codec",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "ZIP-in-ZIP recursive walking with depth and cumulative decompressed-size guards, bounded classic OLE compound-file ([MS-CFB]) reading and writing, and [MS-OLEPS] Property Set Stream reading and writing - zero document-format knowledge, the archive and container utility package for the documents.js family.",
   "type": "module",
   "repository": {