zapo-js 0.1.1 → 0.2.0

package/dist/infra/perf/StoreLock.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreLock = void 0;
+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);
+        }
+    }
+}
+exports.StoreLock = StoreLock;

package/dist/media/WaMediaCrypto.js

@@ -3,6 +3,10 @@ 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");
@@ -16,9 +20,7 @@ class WaMediaCrypto {
         return (0, random_1.randomBytesAsync)(32);
     }
     static async deriveKeys(mediaType, mediaKey) {
-        if (mediaKey.byteLength !== 32) {
-            throw new Error(`invalid media key length ${mediaKey.byteLength}, expected 32`);
-        }
+        (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 {
@@ -82,17 +84,22 @@ 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([
-            (0, bytes_1.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 = (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);
+            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);
@@ -114,6 +121,7 @@ async function pumpEncryption(plaintext, encrypted, keys) {
     const encHash = (0, node_crypto_1.createHash)('sha256');
     const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
     const cipher = (0, node_crypto_1.createCipheriv)('aes-256-cbc', keys.encKey, keys.iv);
+    let plaintextLength = 0;
     hmac.update(keys.iv);
     try {
         for await (const chunk of plaintext) {
@@ -121,6 +129,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) {
@@ -141,7 +150,8 @@ async function pumpEncryption(plaintext, encrypted, keys) {
         encrypted.end();
         return {
             fileSha256: (0, bytes_1.toBytesView)(plainHash.digest()),
-            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest())
+            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest()),
+            plaintextLength
         };
     }
     catch (error) {
@@ -150,6 +160,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 = (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 cipher = (0, node_crypto_1.createCipheriv)('aes-256-cbc', keys.encKey, keys.iv);
+    let plaintextLength = 0;
+    hmac.update(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 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, constants_1.HMAC_TRUNCATED_SIZE);
+        encHash.update(signature);
+        await writeChunkToWritable(output, signature);
+        await endWritable(output);
+        return {
+            fileSha256: (0, bytes_1.toBytesView)(plainHash.digest()),
+            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest()),
+            plaintextLength
+        };
+    }
+    catch (error) {
+        const normalized = (0, primitives_2.toError)(error);
+        output.destroy(normalized);
+        throw normalized;
+    }
+}
 async function pumpDecryption(encrypted, plaintext, keys, options) {
     const plainHash = (0, node_crypto_1.createHash)('sha256');
     const encHash = (0, node_crypto_1.createHash)('sha256');