sealkeep 0.9.0 → 0.11.1

package/dist/packages/vaultline-crypto/src/chunk-access.js

@@ -1,93 +0,0 @@
-import { createHash } from "node:crypto";
-import { gunzipSync } from "node:zlib";
-import { aeadDecipher } from "./aead.js";
-import { chunkAad, TAG_BYTES } from "./format.js";
-import { CryptoError, unwrapArchiveKey, zeroize } from "./recipients.js";
-const sha256 = (input) => createHash("sha256").update(input).digest("hex");
-/** True when an envelope supports random access at all. */
-export function supportsChunkAccess(envelope) {
-    return envelope.manifest.compression === "gzip-chunk" && envelope.chunks.every((chunk) => typeof chunk.rawBytes === "number");
-}
-/**
- * Maps a raw (original-file) byte range to the chunk window that covers it.
- * Legacy whole-body-gzip archives cannot answer this — a slice of their stream
- * is undecodable alone — and the error says to restore whole instead.
- */
-export function chunkWindowForRange(envelope, rawStart, rawEnd) {
-    if (!supportsChunkAccess(envelope)) {
-        throw new CryptoError("envelope_malformed", "This archive predates chunk-independent compression; restore it whole instead of by range.");
-    }
-    const total = envelope.manifest.originalBytes ?? 0;
-    if (rawStart < 0 || rawEnd <= rawStart || rawStart >= Math.max(total, 1)) {
-        throw new CryptoError("invalid_range", `Range ${rawStart}..${rawEnd} is not a range of this ${total}-byte archive`);
-    }
-    const end = Math.min(rawEnd, total);
-    let rawCursor = 0;
-    let storedCursor = 0;
-    let firstIndex = -1;
-    let lastIndex = -1;
-    let storedOffset = 0;
-    let storedLength = 0;
-    let rawStartInWindow = 0;
-    for (const chunk of envelope.chunks) {
-        const rawFrom = rawCursor;
-        const rawTo = rawCursor + (chunk.rawBytes ?? 0);
-        const overlaps = rawTo > rawStart && rawFrom < end;
-        if (overlaps && firstIndex === -1) {
-            firstIndex = chunk.index;
-            storedOffset = storedCursor;
-            rawStartInWindow = rawStart - rawFrom;
-        }
-        if (overlaps) {
-            lastIndex = chunk.index;
-            storedLength += chunk.storedBytes;
-        }
-        rawCursor = rawTo;
-        storedCursor += chunk.storedBytes;
-    }
-    return { firstIndex, lastIndex, storedOffset, storedLength, rawStartInWindow, rawLengthInWindow: end - rawStart };
-}
-/**
- * Opens the chunks inside a fetched stored slice and returns exactly the raw
- * bytes the window was asked for. Every chunk is hash-checked and
- * authenticated before a byte of it is trusted — a ranged read keeps the
- * whole-archive guarantees, chunk by chunk.
- */
-export function openChunkWindow(envelope, window, storedSlice, unlock) {
-    if (storedSlice.length !== window.storedLength) {
-        throw new CryptoError("ciphertext_length_mismatch", `The fetched slice is ${storedSlice.length} bytes; the window needs ${window.storedLength}`);
-    }
-    const archiveKey = unwrapArchiveKey(envelope.wrappedKeys, envelope.suite, envelope.archiveId, unlock);
-    try {
-        const parts = [];
-        let offset = 0;
-        for (let index = window.firstIndex; index <= window.lastIndex; index += 1) {
-            const chunk = envelope.chunks[index];
-            const stored = storedSlice.subarray(offset, offset + chunk.storedBytes);
-            offset += chunk.storedBytes;
-            if (sha256(stored) !== chunk.sha256)
-                throw new CryptoError("chunk_hash_mismatch", `Chunk ${chunk.index} does not match its recorded hash`);
-            const decipher = aeadDecipher(envelope.suite, archiveKey, Buffer.from(chunk.nonce, "base64"));
-            decipher.setAAD(chunkAad({ archiveId: envelope.archiveId, suite: envelope.suite, index: chunk.index, totalChunks: envelope.chunks.length, plaintextBytes: chunk.plaintextBytes, final: chunk.final }));
-            decipher.setAuthTag(stored.subarray(stored.length - TAG_BYTES));
-            let packed;
-            try {
-                packed = Buffer.concat([decipher.update(stored.subarray(0, stored.length - TAG_BYTES)), decipher.final()]);
-            }
-            catch {
-                throw new CryptoError("chunk_auth_failed", `Chunk ${chunk.index} failed authentication`);
-            }
-            try {
-                parts.push(gunzipSync(packed));
-            }
-            catch {
-                throw new CryptoError("plaintext_hash_mismatch", `Chunk ${chunk.index} failed decompression after authentication`);
-            }
-        }
-        const raw = Buffer.concat(parts);
-        return raw.subarray(window.rawStartInWindow, window.rawStartInWindow + window.rawLengthInWindow);
-    }
-    finally {
-        zeroize(archiveKey);
-    }
-}