zapo-js 0.1.1 → 0.2.0

package/dist/esm/infra/perf/SharedExclusiveGate.js

@@ -0,0 +1,109 @@
+export class SharedExclusiveGate {
+    constructor() {
+        this.activeShared = 0;
+        this.pendingExclusive = 0;
+        this.exclusiveActive = false;
+        this.closed = false;
+        this.waiters = [];
+    }
+    runShared(task) {
+        if (this.closed) {
+            return Promise.reject(new Error('shared-exclusive gate is closed'));
+        }
+        if (!this.exclusiveActive && this.pendingExclusive === 0) {
+            this.activeShared += 1;
+            let current;
+            try {
+                current = task();
+            }
+            catch (error) {
+                current = Promise.reject(error);
+            }
+            return current.finally(() => {
+                this.activeShared -= 1;
+                this.notifyStateChange();
+            });
+        }
+        return this.runSharedSlow(task);
+    }
+    async runSharedSlow(task) {
+        await this.acquireShared();
+        try {
+            return await task();
+        }
+        finally {
+            this.activeShared -= 1;
+            this.notifyStateChange();
+        }
+    }
+    async runExclusive(task) {
+        await this.acquireExclusive();
+        try {
+            return await task();
+        }
+        finally {
+            this.exclusiveActive = false;
+            this.notifyStateChange();
+        }
+    }
+    async close() {
+        if (this.closed) {
+            while (this.activeShared > 0 || this.exclusiveActive || this.pendingExclusive > 0) {
+                await this.waitForStateChange();
+            }
+            return;
+        }
+        this.closed = true;
+        this.notifyStateChange();
+        while (this.activeShared > 0 || this.exclusiveActive || this.pendingExclusive > 0) {
+            await this.waitForStateChange();
+        }
+    }
+    async acquireShared() {
+        if (this.closed) {
+            throw new Error('shared-exclusive gate is closed');
+        }
+        while (this.exclusiveActive || this.pendingExclusive > 0) {
+            await this.waitForStateChange();
+            if (this.closed) {
+                throw new Error('shared-exclusive gate is closed');
+            }
+        }
+        this.activeShared += 1;
+    }
+    async acquireExclusive() {
+        if (this.closed) {
+            throw new Error('shared-exclusive gate is closed');
+        }
+        this.pendingExclusive += 1;
+        this.notifyStateChange();
+        try {
+            while (this.exclusiveActive || this.activeShared > 0) {
+                await this.waitForStateChange();
+                if (this.closed) {
+                    throw new Error('shared-exclusive gate is closed');
+                }
+            }
+            this.exclusiveActive = true;
+        }
+        finally {
+            this.pendingExclusive -= 1;
+            this.notifyStateChange();
+        }
+    }
+    notifyStateChange() {
+        if (this.waiters.length === 0) {
+            return;
+        }
+        const waiterCount = this.waiters.length;
+        for (let index = 0; index < waiterCount; index += 1) {
+            this.waiters[index]();
+        }
+        this.waiters.length = 0;
+    }
+    waitForStateChange() {
+        return new Promise((resolve) => {
+            this.waiters[this.waiters.length] = resolve;
+        });
+    }
+}

package/dist/esm/infra/perf/StoreLock.js

@@ -0,0 +1,77 @@
+export class StoreLock {
+    constructor() {
+        this.chains = new Map();
+        this.closed = false;
+    }
+    run(key, task) {
+        return this.runInternal(key, task, true);
+    }
+    runInternal(key, task, rejectWhenClosed) {
+        if (this.closed) {
+            if (rejectWhenClosed) {
+                throw new Error('store lock is closed');
+            }
+        }
+        const previous = this.chains.get(key);
+        let current;
+        if (previous) {
+            current = previous.then(task);
+        }
+        else {
+            try {
+                current = task();
+            }
+            catch (error) {
+                current = Promise.reject(error);
+            }
+        }
+        const tracker = current.then(() => undefined, () => undefined);
+        this.chains.set(key, tracker);
+        void tracker.finally(() => {
+            if (this.chains.get(key) === tracker) {
+                this.chains.delete(key);
+            }
+        });
+        return current;
+    }
+    runMany(keys, task) {
+        if (this.closed) {
+            throw new Error('store lock is closed');
+        }
+        if (keys.length <= 1) {
+            return keys.length === 0 ? task() : this.runInternal(keys[0], task, false);
+        }
+        const ordered = new Array(keys.length);
+        for (let index = 0; index < keys.length; index += 1) {
+            ordered[index] = keys[index];
+        }
+        ordered.sort();
+        let uniqueCount = 1;
+        let previousKey = ordered[0];
+        for (let index = 1; index < ordered.length; index += 1) {
+            const key = ordered[index];
+            if (key === previousKey) {
+                continue;
+            }
+            ordered[uniqueCount] = key;
+            uniqueCount += 1;
+            previousKey = key;
+        }
+        const acquire = (index) => index >= uniqueCount
+            ? task()
+            : this.runInternal(ordered[index], () => Promise.resolve().then(() => acquire(index + 1)), false);
+        return acquire(0);
+    }
+    async shutdown() {
+        this.closed = true;
+        while (this.chains.size > 0) {
+            const pending = new Array(this.chains.size);
+            let pendingIndex = 0;
+            for (const chain of this.chains.values()) {
+                pending[pendingIndex] = chain;
+                pendingIndex += 1;
+            }
+            await Promise.allSettled(pending);
+        }
+    }
+}

package/dist/esm/media/WaMediaCrypto.js

@@ -1,21 +1,23 @@
 import { createCipheriv, createDecipheriv, createHash, createHmac } from 'node:crypto';
 import { once } from 'node:events';
+import { createWriteStream } from 'node:fs';
+import { stat, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { PassThrough } from 'node:stream';
 import { hkdf } from '../crypto/core/hkdf.js';
 import { aesCbcDecrypt, aesCbcEncrypt, hmacSign, importAesCbcKey, importHmacKey, sha256 } from '../crypto/core/primitives.js';
 import { randomBytesAsync } from '../crypto/core/random.js';
 import { ENC_KEY_END, ENC_KEY_START, HMAC_TRUNCATED_SIZE, IV_SIZE, MAC_KEY_END, MAC_KEY_START, MEDIA_HKDF_SIZE } from './constants.js';
 import { WA_APP_STATE_KEY_TYPES, getWaMediaHkdfInfo } from '../protocol/constants.js';
-import { concatBytes, EMPTY_BYTES, readAllBytes, toChunkBytes, toBytesView, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
+import { assertByteLength, concatBytes, EMPTY_BYTES, toChunkBytes, toBytesView, uint8Equal, uint8TimingSafeEqual } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 export class WaMediaCrypto {
     static async generateMediaKey() {
         return randomBytesAsync(32);
     }
     static async deriveKeys(mediaType, mediaKey) {
-        if (mediaKey.byteLength !== 32) {
-            throw new Error(`invalid media key length ${mediaKey.byteLength}, expected 32`);
-        }
+        assertByteLength(mediaKey, 32, `invalid media key length ${mediaKey.byteLength}, expected 32`);
         const info = mediaTypeToHkdfInfo(mediaType);
         const expanded = await hkdf(mediaKey, null, info, MEDIA_HKDF_SIZE);
         return {
@@ -79,17 +81,22 @@ export class WaMediaCrypto {
         const metadata = pumpEncryption(plaintext, encrypted, keys);
         return { encrypted, metadata };
     }
-    static async decryptReadableToBytes(encrypted, options) {
-        const decrypted = await WaMediaCrypto.decryptReadable(encrypted, options);
-        const [plaintext, metadata] = await Promise.all([
-            readAllBytes(decrypted.plaintext),
-            decrypted.metadata
-        ]);
-        return {
-            plaintext,
-            fileSha256: metadata.fileSha256,
-            fileEncSha256: metadata.fileEncSha256
-        };
+    static async encryptToFile(mediaType, mediaKey, plaintext) {
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const filePath = join(tmpdir(), `zapo-enc-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        const output = createWriteStream(filePath);
+        try {
+            const metadata = await pumpEncryptionToWritable(plaintext, output, keys);
+            const fileSize = (await stat(filePath)).size;
+            return { filePath, fileSize, ...metadata };
+        }
+        catch (error) {
+            await unlink(filePath).catch(() => undefined);
+            throw error;
+        }
+    }
+    static async cleanupEncryptedFile(filePath) {
+        await unlink(filePath).catch(() => undefined);
     }
     static async decryptReadable(encrypted, options) {
         const keys = await WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
@@ -110,6 +117,7 @@ async function pumpEncryption(plaintext, encrypted, keys) {
     const encHash = createHash('sha256');
     const hmac = createHmac('sha256', keys.macKey);
     const cipher = createCipheriv('aes-256-cbc', keys.encKey, keys.iv);
+    let plaintextLength = 0;
     hmac.update(keys.iv);
     try {
         for await (const chunk of plaintext) {
@@ -117,6 +125,7 @@ async function pumpEncryption(plaintext, encrypted, keys) {
             if (plainChunk.byteLength === 0) {
                 continue;
             }
+            plaintextLength += plainChunk.byteLength;
             plainHash.update(plainChunk);
             const encryptedChunk = cipher.update(plainChunk);
             if (encryptedChunk.byteLength > 0) {
@@ -137,7 +146,8 @@ async function pumpEncryption(plaintext, encrypted, keys) {
         encrypted.end();
         return {
             fileSha256: toBytesView(plainHash.digest()),
-            fileEncSha256: toBytesView(encHash.digest())
+            fileEncSha256: toBytesView(encHash.digest()),
+            plaintextLength
         };
     }
     catch (error) {
@@ -146,6 +156,76 @@ async function pumpEncryption(plaintext, encrypted, keys) {
         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) {
+    const plainHash = createHash('sha256');
+    const encHash = createHash('sha256');
+    const hmac = createHmac('sha256', keys.macKey);
+    const cipher = createCipheriv('aes-256-cbc', keys.encKey, keys.iv);
+    let plaintextLength = 0;
+    hmac.update(keys.iv);
+    try {
+        for await (const chunk of plaintext) {
+            const plainChunk = toChunkBytes(chunk);
+            if (plainChunk.byteLength === 0) {
+                continue;
+            }
+            plaintextLength += plainChunk.byteLength;
+            plainHash.update(plainChunk);
+            const encryptedChunk = cipher.update(plainChunk);
+            if (encryptedChunk.byteLength > 0) {
+                hmac.update(encryptedChunk);
+                encHash.update(encryptedChunk);
+                await writeChunkToWritable(output, encryptedChunk);
+            }
+        }
+        const encryptedFinal = cipher.final();
+        if (encryptedFinal.byteLength > 0) {
+            hmac.update(encryptedFinal);
+            encHash.update(encryptedFinal);
+            await writeChunkToWritable(output, encryptedFinal);
+        }
+        const signature = hmac.digest().subarray(0, HMAC_TRUNCATED_SIZE);
+        encHash.update(signature);
+        await writeChunkToWritable(output, signature);
+        await endWritable(output);
+        return {
+            fileSha256: toBytesView(plainHash.digest()),
+            fileEncSha256: toBytesView(encHash.digest()),
+            plaintextLength
+        };
+    }
+    catch (error) {
+        const normalized = toError(error);
+        output.destroy(normalized);
+        throw normalized;
+    }
+}
 async function pumpDecryption(encrypted, plaintext, keys, options) {
     const plainHash = createHash('sha256');
     const encHash = createHash('sha256');