zapo-js 0.3.0 → 1.0.0

package/dist/media/WaMediaCrypto.js

@@ -1,503 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaMediaCrypto = void 0;
-const node_crypto_1 = require("node:crypto");
-const node_events_1 = require("node:events");
-const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
-const node_stream_1 = require("node:stream");
-const hkdf_1 = require("../crypto/core/hkdf");
-const primitives_1 = require("../crypto/core/primitives");
-const random_1 = require("../crypto/core/random");
-const constants_1 = require("./constants");
-const constants_2 = require("../protocol/constants");
-const bytes_1 = require("../util/bytes");
-const primitives_2 = require("../util/primitives");
-const AES_BLOCK_SIZE = 16;
-const PKCS7_FULL_BLOCK = new Uint8Array(AES_BLOCK_SIZE).fill(AES_BLOCK_SIZE);
-async function aesCbcEncryptChunk(key, iv, chunk, isFinal) {
-    const encrypted = await (0, primitives_1.aesCbcEncrypt)(key, iv, chunk);
-    if (isFinal) {
-        return {
-            ciphertext: encrypted,
-            nextIv: encrypted.subarray(encrypted.byteLength - AES_BLOCK_SIZE)
-        };
-    }
-    const ciphertext = encrypted.subarray(0, encrypted.byteLength - AES_BLOCK_SIZE);
-    return {
-        ciphertext,
-        nextIv: ciphertext.subarray(ciphertext.byteLength - AES_BLOCK_SIZE)
-    };
-}
-async function aesCbcDecryptChunk(key, iv, ciphertext, isFinal) {
-    const nextIv = (0, bytes_1.toBytesView)(ciphertext.subarray(ciphertext.byteLength - AES_BLOCK_SIZE));
-    if (isFinal) {
-        return { plaintext: await (0, primitives_1.aesCbcDecrypt)(key, iv, ciphertext), nextIv };
-    }
-    const padBlock = (await (0, primitives_1.aesCbcEncrypt)(key, nextIv, PKCS7_FULL_BLOCK)).subarray(0, AES_BLOCK_SIZE);
-    const withPad = (0, bytes_1.concatBytes)([ciphertext, padBlock]);
-    return { plaintext: await (0, primitives_1.aesCbcDecrypt)(key, iv, withPad), nextIv };
-}
-async function computeFirstFrameSidecar(macKey, ivCiphertext, firstFrameLength) {
-    const aligned = Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
-    const slice = ivCiphertext.subarray(0, constants_1.IV_SIZE + aligned);
-    const key = await (0, primitives_1.importHmacKey)(macKey);
-    const digest = await (0, primitives_1.hmacSign)(key, slice);
-    return digest.subarray(0, constants_1.SIDECAR_HMAC_SIZE);
-}
-class SidecarAccumulator {
-    constructor(macKey, estimatedSize = 0) {
-        this.resultOffset = 0;
-        this.totalPushed = 0;
-        this.windowOffset = 0;
-        this.nextChunkStart = 0;
-        this.macKey = macKey;
-        this.window = new Uint8Array(constants_1.IV_SIZE + constants_1.SIDECAR_CHUNK_SIZE);
-        const estimated = Math.max(Math.ceil(estimatedSize / constants_1.SIDECAR_CHUNK_SIZE) + 1, 16);
-        this.result = new Uint8Array(estimated * constants_1.SIDECAR_HMAC_SIZE);
-    }
-    push(data) {
-        let srcOffset = 0;
-        while (srcOffset < data.byteLength) {
-            const windowEnd = this.nextChunkStart + constants_1.IV_SIZE + constants_1.SIDECAR_CHUNK_SIZE;
-            const remaining = windowEnd - this.totalPushed;
-            const toCopy = Math.min(remaining, data.byteLength - srcOffset);
-            this.window.set(data.subarray(srcOffset, srcOffset + toCopy), this.windowOffset);
-            this.windowOffset += toCopy;
-            this.totalPushed += toCopy;
-            srcOffset += toCopy;
-            if (this.totalPushed === windowEnd) {
-                this.flushChunk();
-            }
-        }
-    }
-    finish() {
-        if (this.windowOffset > 0) {
-            this.flushChunk();
-        }
-        return this.result.subarray(0, this.resultOffset);
-    }
-    flushChunk() {
-        const digest = (0, node_crypto_1.createHmac)('sha256', this.macKey)
-            .update(this.window.subarray(0, this.windowOffset))
-            .digest();
-        if (this.resultOffset + constants_1.SIDECAR_HMAC_SIZE > this.result.byteLength) {
-            const grown = new Uint8Array(this.result.byteLength * 2);
-            grown.set(this.result);
-            this.result = grown;
-        }
-        this.result.set(digest.subarray(0, constants_1.SIDECAR_HMAC_SIZE), this.resultOffset);
-        this.resultOffset += constants_1.SIDECAR_HMAC_SIZE;
-        this.nextChunkStart += constants_1.SIDECAR_CHUNK_SIZE;
-        const overlapSrc = this.window.subarray(this.windowOffset - constants_1.IV_SIZE, this.windowOffset);
-        this.window.set(overlapSrc, 0);
-        this.windowOffset = constants_1.IV_SIZE;
-    }
-}
-class WaMediaCrypto {
-    static async generateMediaKey() {
-        return (0, random_1.randomBytesAsync)(32);
-    }
-    static async deriveKeys(mediaType, mediaKey) {
-        (0, bytes_1.assertByteLength)(mediaKey, 32, `invalid media key length ${mediaKey.byteLength}, expected 32`);
-        const info = mediaTypeToHkdfInfo(mediaType);
-        const expanded = await (0, hkdf_1.hkdf)(mediaKey, null, info, constants_1.MEDIA_HKDF_SIZE);
-        return {
-            iv: expanded.subarray(0, constants_1.IV_SIZE),
-            encKey: expanded.subarray(constants_1.ENC_KEY_START, constants_1.ENC_KEY_END),
-            macKey: expanded.subarray(constants_1.MAC_KEY_START, constants_1.MAC_KEY_END),
-            refKey: expanded.subarray(constants_1.MAC_KEY_END, constants_1.MEDIA_HKDF_SIZE)
-        };
-    }
-    static async encryptBytes(mediaType, mediaKey, plaintext, options) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const [aesKey, hmacKey] = await Promise.all([
-            (0, primitives_1.importAesCbcKey)(keys.encKey),
-            (0, primitives_1.importHmacKey)(keys.macKey)
-        ]);
-        const ciphertext = await (0, primitives_1.aesCbcEncrypt)(aesKey, keys.iv, plaintext);
-        const ivCiphertext = (0, bytes_1.concatBytes)([keys.iv, ciphertext]);
-        const mac = await (0, primitives_1.hmacSign)(hmacKey, ivCiphertext);
-        const signature = mac.subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
-        const ciphertextHmac = (0, bytes_1.concatBytes)([ciphertext, signature]);
-        let streamingSidecar;
-        if (options?.sidecar !== false) {
-            const acc = new SidecarAccumulator(keys.macKey);
-            acc.push(keys.iv);
-            acc.push(ciphertext);
-            acc.push(signature);
-            streamingSidecar = acc.finish();
-        }
-        const firstFrameSidecar = options?.firstFrameLength !== undefined
-            ? await computeFirstFrameSidecar(keys.macKey, ivCiphertext, options.firstFrameLength)
-            : undefined;
-        const [fileSha256, fileEncSha256] = await Promise.all([
-            (0, primitives_1.sha256)(plaintext),
-            (0, primitives_1.sha256)(ciphertextHmac)
-        ]);
-        return {
-            ciphertextHmac,
-            fileSha256,
-            fileEncSha256,
-            streamingSidecar,
-            firstFrameSidecar
-        };
-    }
-    static async decryptBytes(mediaType, mediaKey, ciphertextHmac, expectedFileSha256, expectedFileEncSha256, skipMacVerification = false) {
-        if (ciphertextHmac.byteLength < constants_1.HMAC_TRUNCATED_SIZE) {
-            throw new Error(`ciphertext too short: ${ciphertextHmac.byteLength}`);
-        }
-        if (expectedFileEncSha256) {
-            const computedEncHash = await (0, primitives_1.sha256)(ciphertextHmac);
-            if (!(0, bytes_1.uint8Equal)(computedEncHash, expectedFileEncSha256)) {
-                throw new Error('encrypted file hash mismatch');
-            }
-        }
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const [aesKey, hmacKey] = await Promise.all([
-            (0, primitives_1.importAesCbcKey)(keys.encKey),
-            (0, primitives_1.importHmacKey)(keys.macKey)
-        ]);
-        const ciphertext = ciphertextHmac.subarray(0, ciphertextHmac.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
-        const expectedMac = ciphertextHmac.subarray(ciphertextHmac.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
-        const ivCiphertext = (0, bytes_1.concatBytes)([keys.iv, ciphertext]);
-        if (!skipMacVerification) {
-            const mac = await (0, primitives_1.hmacSign)(hmacKey, ivCiphertext);
-            const signature = mac.subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
-            if (!(0, bytes_1.uint8TimingSafeEqual)(signature, expectedMac)) {
-                throw new Error('media MAC mismatch');
-            }
-        }
-        const plaintext = await (0, primitives_1.aesCbcDecrypt)(aesKey, keys.iv, ciphertext);
-        const fileSha256 = await (0, primitives_1.sha256)(plaintext);
-        if (expectedFileSha256 && !(0, bytes_1.uint8Equal)(fileSha256, expectedFileSha256)) {
-            throw new Error('plaintext file hash mismatch');
-        }
-        const fileEncSha256 = expectedFileEncSha256 ?? (await (0, primitives_1.sha256)(ciphertextHmac));
-        return { plaintext, fileSha256, fileEncSha256 };
-    }
-    static async encryptReadable(mediaType, mediaKey, plaintext, options) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const encrypted = new node_stream_1.PassThrough();
-        const metadata = pumpEncryption(plaintext, encrypted, keys, options?.sidecar !== false, options?.firstFrameLength);
-        return { encrypted, metadata };
-    }
-    static async encryptToFile(mediaType, mediaKey, plaintext, options) {
-        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
-        const filePath = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `zapo-enc-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        const output = (0, node_fs_1.createWriteStream)(filePath);
-        try {
-            const metadata = await pumpEncryptionToWritable(plaintext, output, keys, options?.sidecar !== false, options?.firstFrameLength);
-            const fileSize = (await (0, promises_1.stat)(filePath)).size;
-            return { filePath, fileSize, ...metadata };
-        }
-        catch (error) {
-            await (0, promises_1.unlink)(filePath).catch(() => undefined);
-            throw error;
-        }
-    }
-    static async cleanupEncryptedFile(filePath) {
-        await (0, promises_1.unlink)(filePath).catch(() => undefined);
-    }
-    static async decryptReadable(encrypted, options) {
-        const keys = await WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
-        const plaintext = new node_stream_1.PassThrough();
-        const metadata = pumpDecryption(encrypted, plaintext, keys, options);
-        return { plaintext, metadata };
-    }
-    static encryptedLength(plaintextLength) {
-        if (!Number.isFinite(plaintextLength) || plaintextLength < 0) {
-            throw new Error(`invalid plaintext length ${plaintextLength}`);
-        }
-        const paddedLength = Math.ceil((plaintextLength + 1) / 16) * 16;
-        return paddedLength + constants_1.HMAC_TRUNCATED_SIZE;
-    }
-}
-exports.WaMediaCrypto = WaMediaCrypto;
-async function pumpEncryption(plaintext, encrypted, keys, computeSidecar, firstFrameLength) {
-    const aesKey = await (0, primitives_1.importAesCbcKey)(keys.encKey);
-    const plainHash = (0, node_crypto_1.createHash)('sha256');
-    const encHash = (0, node_crypto_1.createHash)('sha256');
-    const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
-    const sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey) : null;
-    const ffTarget = firstFrameLength !== undefined
-        ? constants_1.IV_SIZE + Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE
-        : 0;
-    let ffCollected = 0;
-    const ffChunks = ffTarget > 0 ? [keys.iv] : [];
-    if (ffTarget > 0)
-        ffCollected = constants_1.IV_SIZE;
-    let plaintextLength = 0;
-    let currentIv = keys.iv;
-    let pending = bytes_1.EMPTY_BYTES;
-    hmac.update(keys.iv);
-    sidecar?.push(keys.iv);
-    try {
-        for await (const chunk of plaintext) {
-            const plainChunk = (0, bytes_1.toChunkBytes)(chunk);
-            if (plainChunk.byteLength === 0)
-                continue;
-            plaintextLength += plainChunk.byteLength;
-            plainHash.update(plainChunk);
-            const combined = pending.byteLength > 0
-                ? (0, bytes_1.concatBytes)([pending, plainChunk])
-                : (0, bytes_1.toBytesView)(plainChunk);
-            const aligned = combined.byteLength - (combined.byteLength % AES_BLOCK_SIZE);
-            if (aligned === 0) {
-                pending = combined;
-                continue;
-            }
-            const toEncrypt = (0, bytes_1.toBytesView)(combined.subarray(0, aligned));
-            pending = (0, bytes_1.toBytesView)(combined.subarray(aligned));
-            const { ciphertext, nextIv } = await aesCbcEncryptChunk(aesKey, currentIv, toEncrypt, false);
-            currentIv = nextIv;
-            hmac.update(ciphertext);
-            encHash.update(ciphertext);
-            sidecar?.push(ciphertext);
-            if (ffCollected < ffTarget) {
-                const need = ffTarget - ffCollected;
-                ffChunks.push(ciphertext.subarray(0, Math.min(need, ciphertext.byteLength)));
-                ffCollected += ciphertext.byteLength;
-            }
-            await writeChunk(encrypted, ciphertext);
-        }
-        const { ciphertext: finalCiphertext } = await aesCbcEncryptChunk(aesKey, currentIv, pending, true);
-        hmac.update(finalCiphertext);
-        encHash.update(finalCiphertext);
-        sidecar?.push(finalCiphertext);
-        if (ffCollected < ffTarget) {
-            const need = ffTarget - ffCollected;
-            ffChunks.push(finalCiphertext.subarray(0, Math.min(need, finalCiphertext.byteLength)));
-        }
-        await writeChunk(encrypted, finalCiphertext);
-        const signature = (0, bytes_1.toBytesView)(hmac.digest().subarray(0, constants_1.HMAC_TRUNCATED_SIZE));
-        encHash.update(signature);
-        sidecar?.push(signature);
-        await writeChunk(encrypted, signature);
-        encrypted.end();
-        let firstFrameSidecar;
-        if (ffTarget > 0) {
-            const ivCiphertextSlice = (0, bytes_1.concatBytes)(ffChunks);
-            const ffKey = await (0, primitives_1.importHmacKey)(keys.macKey);
-            const ffDigest = await (0, primitives_1.hmacSign)(ffKey, ivCiphertextSlice);
-            firstFrameSidecar = ffDigest.subarray(0, constants_1.SIDECAR_HMAC_SIZE);
-        }
-        return {
-            fileSha256: (0, bytes_1.toBytesView)(plainHash.digest()),
-            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest()),
-            plaintextLength,
-            streamingSidecar: sidecar?.finish(),
-            firstFrameSidecar
-        };
-    }
-    catch (error) {
-        const normalized = (0, primitives_2.toError)(error);
-        encrypted.destroy(normalized);
-        throw normalized;
-    }
-}
-async function writeChunkToWritable(stream, chunk) {
-    if (chunk.byteLength === 0) {
-        return;
-    }
-    if (stream.write(chunk)) {
-        return;
-    }
-    await new Promise((resolve, reject) => {
-        const onDrain = () => {
-            stream.off('error', onError);
-            resolve();
-        };
-        const onError = (err) => {
-            stream.off('drain', onDrain);
-            reject(err);
-        };
-        stream.once('drain', onDrain);
-        stream.once('error', onError);
-    });
-}
-async function endWritable(stream) {
-    return new Promise((resolve, reject) => {
-        stream.on('error', reject);
-        stream.end(() => resolve());
-    });
-}
-async function pumpEncryptionToWritable(plaintext, output, keys, computeSidecar, firstFrameLength) {
-    const aesKey = await (0, primitives_1.importAesCbcKey)(keys.encKey);
-    const plainHash = (0, node_crypto_1.createHash)('sha256');
-    const encHash = (0, node_crypto_1.createHash)('sha256');
-    const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
-    const sidecar = computeSidecar ? new SidecarAccumulator(keys.macKey) : null;
-    const ffTarget = firstFrameLength !== undefined
-        ? constants_1.IV_SIZE + Math.ceil(firstFrameLength / AES_BLOCK_SIZE) * AES_BLOCK_SIZE
-        : 0;
-    let ffCollected = 0;
-    const ffChunks = ffTarget > 0 ? [keys.iv] : [];
-    if (ffTarget > 0)
-        ffCollected = constants_1.IV_SIZE;
-    let plaintextLength = 0;
-    let currentIv = keys.iv;
-    let pending = bytes_1.EMPTY_BYTES;
-    hmac.update(keys.iv);
-    sidecar?.push(keys.iv);
-    try {
-        for await (const chunk of plaintext) {
-            const plainChunk = (0, bytes_1.toChunkBytes)(chunk);
-            if (plainChunk.byteLength === 0)
-                continue;
-            plaintextLength += plainChunk.byteLength;
-            plainHash.update(plainChunk);
-            const combined = pending.byteLength > 0
-                ? (0, bytes_1.concatBytes)([pending, plainChunk])
-                : (0, bytes_1.toBytesView)(plainChunk);
-            const aligned = combined.byteLength - (combined.byteLength % AES_BLOCK_SIZE);
-            if (aligned === 0) {
-                pending = combined;
-                continue;
-            }
-            const toEncrypt = (0, bytes_1.toBytesView)(combined.subarray(0, aligned));
-            pending = (0, bytes_1.toBytesView)(combined.subarray(aligned));
-            const { ciphertext, nextIv } = await aesCbcEncryptChunk(aesKey, currentIv, toEncrypt, false);
-            currentIv = nextIv;
-            hmac.update(ciphertext);
-            encHash.update(ciphertext);
-            sidecar?.push(ciphertext);
-            if (ffCollected < ffTarget) {
-                const need = ffTarget - ffCollected;
-                ffChunks.push(ciphertext.subarray(0, Math.min(need, ciphertext.byteLength)));
-                ffCollected += ciphertext.byteLength;
-            }
-            await writeChunkToWritable(output, ciphertext);
-        }
-        const { ciphertext: finalCiphertext } = await aesCbcEncryptChunk(aesKey, currentIv, pending, true);
-        hmac.update(finalCiphertext);
-        encHash.update(finalCiphertext);
-        sidecar?.push(finalCiphertext);
-        if (ffCollected < ffTarget) {
-            const need = ffTarget - ffCollected;
-            ffChunks.push(finalCiphertext.subarray(0, Math.min(need, finalCiphertext.byteLength)));
-        }
-        await writeChunkToWritable(output, finalCiphertext);
-        const signature = (0, bytes_1.toBytesView)(hmac.digest().subarray(0, constants_1.HMAC_TRUNCATED_SIZE));
-        encHash.update(signature);
-        sidecar?.push(signature);
-        await writeChunkToWritable(output, signature);
-        await endWritable(output);
-        let firstFrameSidecar;
-        if (ffTarget > 0) {
-            const ivCiphertextSlice = (0, bytes_1.concatBytes)(ffChunks);
-            const ffKey = await (0, primitives_1.importHmacKey)(keys.macKey);
-            const ffDigest = await (0, primitives_1.hmacSign)(ffKey, ivCiphertextSlice);
-            firstFrameSidecar = ffDigest.subarray(0, constants_1.SIDECAR_HMAC_SIZE);
-        }
-        return {
-            fileSha256: (0, bytes_1.toBytesView)(plainHash.digest()),
-            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest()),
-            plaintextLength,
-            streamingSidecar: sidecar?.finish(),
-            firstFrameSidecar
-        };
-    }
-    catch (error) {
-        const normalized = (0, primitives_2.toError)(error);
-        output.destroy(normalized);
-        throw normalized;
-    }
-}
-async function pumpDecryption(encrypted, plaintext, keys, options) {
-    const aesKey = await (0, primitives_1.importAesCbcKey)(keys.encKey);
-    const plainHash = (0, node_crypto_1.createHash)('sha256');
-    const encHash = (0, node_crypto_1.createHash)('sha256');
-    const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
-    let currentIv = keys.iv;
-    let pending = bytes_1.EMPTY_BYTES;
-    hmac.update(keys.iv);
-    try {
-        let trailing = bytes_1.EMPTY_BYTES;
-        for await (const chunk of encrypted) {
-            const bytes = (0, bytes_1.toChunkBytes)(chunk);
-            if (bytes.byteLength === 0) {
-                continue;
-            }
-            encHash.update(bytes);
-            const merged = trailing.byteLength === 0 ? bytes : (0, bytes_1.concatBytes)([trailing, bytes]);
-            if (merged.byteLength <= constants_1.HMAC_TRUNCATED_SIZE) {
-                trailing = merged;
-                continue;
-            }
-            const ciphertextChunk = merged.subarray(0, merged.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
-            trailing = merged.subarray(merged.byteLength - constants_1.HMAC_TRUNCATED_SIZE);
-            hmac.update(ciphertextChunk);
-            const combined = pending.byteLength > 0
-                ? (0, bytes_1.concatBytes)([pending, ciphertextChunk])
-                : (0, bytes_1.toBytesView)(ciphertextChunk);
-            const aligned = combined.byteLength - (combined.byteLength % AES_BLOCK_SIZE);
-            if (aligned > AES_BLOCK_SIZE) {
-                const toDecrypt = combined.subarray(0, aligned - AES_BLOCK_SIZE);
-                const { plaintext: plainChunk, nextIv } = await aesCbcDecryptChunk(aesKey, currentIv, toDecrypt, false);
-                currentIv = nextIv;
-                if (plainChunk.byteLength > 0) {
-                    plainHash.update(plainChunk);
-                    await writeChunk(plaintext, plainChunk);
-                }
-                pending = (0, bytes_1.toBytesView)(combined.subarray(aligned - AES_BLOCK_SIZE));
-            }
-            else {
-                pending = combined;
-            }
-        }
-        if (trailing.byteLength !== constants_1.HMAC_TRUNCATED_SIZE) {
-            throw new Error(`ciphertext too short: ${trailing.byteLength}`);
-        }
-        if (!options.skipMacVerification) {
-            const signature = hmac.digest().subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
-            if (!(0, bytes_1.uint8TimingSafeEqual)(signature, trailing)) {
-                throw new Error('media MAC mismatch');
-            }
-        }
-        if (pending.byteLength < AES_BLOCK_SIZE || pending.byteLength % AES_BLOCK_SIZE !== 0) {
-            throw new Error(`invalid ciphertext length: ${pending.byteLength}`);
-        }
-        const { plaintext: plainFinal } = await aesCbcDecryptChunk(aesKey, currentIv, pending, true);
-        if (plainFinal.byteLength > 0) {
-            plainHash.update(plainFinal);
-            await writeChunk(plaintext, plainFinal);
-        }
-        const fileSha256 = (0, bytes_1.toBytesView)(plainHash.digest());
-        const fileEncSha256 = (0, bytes_1.toBytesView)(encHash.digest());
-        if (options.expectedFileEncSha256 &&
-            !(0, bytes_1.uint8Equal)(fileEncSha256, options.expectedFileEncSha256)) {
-            throw new Error('encrypted file hash mismatch');
-        }
-        if (options.expectedFileSha256 && !(0, bytes_1.uint8Equal)(fileSha256, options.expectedFileSha256)) {
-            throw new Error('plaintext file hash mismatch');
-        }
-        plaintext.end();
-        return { fileSha256, fileEncSha256 };
-    }
-    catch (error) {
-        const normalized = (0, primitives_2.toError)(error);
-        plaintext.destroy(normalized);
-        throw normalized;
-    }
-}
-function mediaTypeToHkdfInfo(mediaType) {
-    if (mediaType === 'ptv') {
-        return (0, constants_2.getWaMediaHkdfInfo)('video');
-    }
-    if (mediaType === 'history') {
-        return (0, constants_2.getWaMediaHkdfInfo)(constants_2.WA_APP_STATE_KEY_TYPES.MD_MSG_HIST);
-    }
-    return (0, constants_2.getWaMediaHkdfInfo)(mediaType);
-}
-async function writeChunk(stream, chunk) {
-    if (chunk.byteLength === 0) {
-        return;
-    }
-    if (stream.write(chunk)) {
-        return;
-    }
-    await (0, node_events_1.once)(stream, 'drain');
-}

package/dist/message/phash.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computePhashV2 = computePhashV2;
-const core_1 = require("../crypto/core");
-const bytes_1 = require("../util/bytes");
-async function computePhashV2(participants) {
-    if (participants.length === 0) {
-        return '2:';
-    }
-    const canonical = new Array(participants.length);
-    for (let i = 0; i < participants.length; i += 1)
-        canonical[i] = toPhashCanonicalWid(participants[i]);
-    const joined = canonical.sort().join('');
-    const digest = await (0, core_1.sha256)(bytes_1.TEXT_ENCODER.encode(joined));
-    return `2:${(0, bytes_1.bytesToBase64)(digest.subarray(0, 6))}`;
-}
-function toPhashCanonicalWid(jid) {
-    const atIndex = jid.indexOf('@');
-    if (atIndex < 1 || atIndex >= jid.length - 1)
-        return jid;
-    const colonIndex = jid.indexOf(':', 0);
-    const userEnd = colonIndex >= 0 && colonIndex < atIndex ? colonIndex : atIndex;
-    const hasZeroAgent = userEnd >= 2 && jid.charCodeAt(userEnd - 2) === 46 && jid.charCodeAt(userEnd - 1) === 48;
-    const baseUserEnd = hasZeroAgent ? userEnd - 2 : userEnd;
-    const baseUser = jid.slice(0, baseUserEnd);
-    let device = 0;
-    if (colonIndex >= 0 && colonIndex < atIndex) {
-        for (let i = colonIndex + 1; i < atIndex; i += 1) {
-            const digit = jid.charCodeAt(i) - 48;
-            if (digit < 0 || digit > 9) {
-                device = 0;
-                break;
-            }
-            device = device * 10 + digit;
-            if (device > Number.MAX_SAFE_INTEGER) {
-                device = 0;
-                break;
-            }
-        }
-    }
-    const serverStart = atIndex + 1;
-    const serverLen = jid.length - serverStart;
-    const isCUs = serverLen === 4 &&
-        jid.charCodeAt(serverStart) === 99 &&
-        jid.charCodeAt(serverStart + 1) === 46 &&
-        jid.charCodeAt(serverStart + 2) === 117 &&
-        jid.charCodeAt(serverStart + 3) === 115;
-    const normalizedServer = isCUs ? 's.whatsapp.net' : jid.slice(serverStart);
-    return `${baseUser}.0:${device}@${normalizedServer}`;
-}

package/dist/store/locks/participants.lock.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withParticipantsLock = withParticipantsLock;
-const SharedExclusiveGate_1 = require("../../infra/perf/SharedExclusiveGate");
-const StoreLock_1 = require("../../infra/perf/StoreLock");
-const WA_PARTICIPANTS_CLEAR_KEY = 'participants:clear';
-const WA_PARTICIPANTS_CLEANUP_KEY = 'participants:cleanup';
-function withParticipantsLock(store) {
-    const lock = new StoreLock_1.StoreLock();
-    const gate = new SharedExclusiveGate_1.SharedExclusiveGate();
-    return {
-        destroy: async () => {
-            await gate.close();
-            await lock.shutdown();
-            await store.destroy?.();
-        },
-        upsertGroupParticipants: (snapshot) => gate.runShared(() => lock.run(`participants:group:${snapshot.groupJid}`, () => store.upsertGroupParticipants(snapshot))),
-        getGroupParticipants: (groupJid, nowMs) => gate.runShared(() => store.getGroupParticipants(groupJid, nowMs)),
-        deleteGroupParticipants: (groupJid) => gate.runShared(() => lock.run(`participants:group:${groupJid}`, () => store.deleteGroupParticipants(groupJid))),
-        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
-        clear: () => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEAR_KEY, () => store.clear()))
-    };
-}

package/dist/store/providers/memory/contact.store.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaContactMemoryStore = void 0;
-const coercion_1 = require("../../../util/coercion");
-const collections_1 = require("../../../util/collections");
-const DEFAULT_CONTACT_MEMORY_STORE_LIMITS = Object.freeze({
-    contacts: 20000
-});
-class WaContactMemoryStore {
-    constructor(options = {}) {
-        this.contacts = new Map();
-        this.maxContacts = (0, coercion_1.resolvePositive)(options.maxContacts, DEFAULT_CONTACT_MEMORY_STORE_LIMITS.contacts, 'WaContactMemoryStoreOptions.maxContacts');
-    }
-    async upsert(record) {
-        (0, collections_1.setBoundedMapEntry)(this.contacts, record.jid, record, this.maxContacts);
-    }
-    async upsertBatch(records) {
-        for (const record of records) {
-            (0, collections_1.setBoundedMapEntry)(this.contacts, record.jid, record, this.maxContacts);
-        }
-    }
-    async getByJid(jid) {
-        return this.contacts.get(jid) ?? null;
-    }
-    async deleteByJid(jid) {
-        return this.contacts.delete(jid) ? 1 : 0;
-    }
-    async clear() {
-        this.contacts.clear();
-    }
-}
-exports.WaContactMemoryStore = WaContactMemoryStore;

package/dist/store/providers/memory/device-list.store.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaDeviceListMemoryStore = void 0;
-const coercion_1 = require("../../../util/coercion");
-const collections_1 = require("../../../util/collections");
-const DEFAULTS = Object.freeze({
-    ttlMs: 5 * 60 * 1000,
-    maxUsers: 16384
-});
-class WaDeviceListMemoryStore {
-    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
-        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
-            throw new Error('device-list ttlMs must be a positive finite number');
-        }
-        this.records = new Map();
-        this.ttlMs = ttlMs;
-        this.maxUsers = (0, coercion_1.resolvePositive)(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
-        this.cleanupTimer = setInterval(() => {
-            void this.cleanupExpired(Date.now());
-        }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
-        this.cleanupTimer.unref();
-    }
-    async upsertUserDevicesBatch(snapshots) {
-        for (let index = 0; index < snapshots.length; index += 1) {
-            const snapshot = snapshots[index];
-            (0, collections_1.setBoundedMapEntry)(this.records, snapshot.userJid, {
-                ...snapshot,
-                expiresAtMs: snapshot.updatedAtMs + this.ttlMs
-            }, this.maxUsers);
-        }
-    }
-    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
-        const snapshots = new Array(userJids.length);
-        for (let index = 0; index < userJids.length; index += 1) {
-            const userJid = userJids[index];
-            const record = this.records.get(userJid);
-            if (!record) {
-                snapshots[index] = null;
-                continue;
-            }
-            if (record.expiresAtMs <= nowMs) {
-                this.records.delete(userJid);
-                snapshots[index] = null;
-                continue;
-            }
-            snapshots[index] = record;
-        }
-        return snapshots;
-    }
-    async deleteUserDevices(userJid) {
-        return this.records.delete(userJid) ? 1 : 0;
-    }
-    async cleanupExpired(nowMs) {
-        let removed = 0;
-        for (const [userJid, record] of this.records) {
-            if (record.expiresAtMs > nowMs)
-                continue;
-            this.records.delete(userJid);
-            removed += 1;
-        }
-        return removed;
-    }
-    async clear() {
-        this.records.clear();
-    }
-    async destroy() {
-        clearInterval(this.cleanupTimer);
-        await this.clear();
-    }
-}
-exports.WaDeviceListMemoryStore = WaDeviceListMemoryStore;