@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/dist_ts/readers/gzipmember.js

@@ -0,0 +1,176 @@
+import * as plugins from '../plugins.js';
+import { LinuxRepoError, limitExceeded, truncated } from '../shared/errors.js';
+import { concatBytes, READ_CHUNK_BYTES, readExact, readUpTo } from './bytes.js';
+const FLAG_HCRC = 0x02;
+const FLAG_EXTRA = 0x04;
+const FLAG_NAME = 0x08;
+const FLAG_COMMENT = 0x10;
+/**
+ * Reads exactly one gzip member (RFC 1952) from `inputArg` and leaves the
+ * reader positioned at the first byte after it, so concatenated members (an
+ * apk v2 package) can be read one at a time with their exact boundaries.
+ *
+ * The header is parsed here; the deflate data is inflated with
+ * `zlib.createInflateRaw()`, whose `bytesWritten` counts only the bytes the
+ * deflate stream consumed, and the bytes past the stream's end are pushed back
+ * with `unread`. The trailer's CRC-32 and ISIZE are checked. Returns `null`
+ * when the input ends exactly where a member would start.
+ */
+export async function readGzipMember(inputArg, optionsArg) {
+    const sha1 = plugins.crypto.createHash('sha1');
+    let memberBytes = 0;
+    const account = (bytesArg) => {
+        memberBytes += bytesArg.length;
+        if (memberBytes > optionsArg.maxMemberBytes) {
+            throw limitExceeded(optionsArg.memberLimit, optionsArg.maxMemberBytes, 'gzip member');
+        }
+        sha1.update(bytesArg);
+    };
+    // header
+    const fixed = await readUpTo(inputArg, 10);
+    if (fixed.length === 0) {
+        return null;
+    }
+    if (fixed[0] !== 0x1f || (fixed.length > 1 && fixed[1] !== 0x8b) || (fixed.length > 2 && fixed[2] !== 0x08)) {
+        throw new LinuxRepoError('malformed-archive', 'input is not a gzip member', { field: 'gzip header' });
+    }
+    if (fixed.length < 10) {
+        throw truncated('gzip header');
+    }
+    account(fixed);
+    let headerCrc = plugins.zlib.crc32(fixed);
+    const flags = fixed[3];
+    if ((flags & FLAG_EXTRA) !== 0) {
+        const lengthBytes = await readExact(inputArg, 2, 'gzip header');
+        account(lengthBytes);
+        headerCrc = plugins.zlib.crc32(lengthBytes, headerCrc);
+        const extra = await readExact(inputArg, lengthBytes[0] | (lengthBytes[1] << 8), 'gzip header');
+        account(extra);
+        headerCrc = plugins.zlib.crc32(extra, headerCrc);
+    }
+    for (const flag of [FLAG_NAME, FLAG_COMMENT]) {
+        if ((flags & flag) !== 0) {
+            const text = await readZeroTerminated(inputArg, optionsArg.maxHeaderBytes);
+            account(text);
+            headerCrc = plugins.zlib.crc32(text, headerCrc);
+        }
+    }
+    if ((flags & FLAG_HCRC) !== 0) {
+        const stored = await readExact(inputArg, 2, 'gzip header');
+        account(stored);
+        if ((stored[0] | (stored[1] << 8)) !== (headerCrc & 0xffff)) {
+            throw new LinuxRepoError('malformed-archive', 'gzip header CRC mismatch', { field: 'gzip header' });
+        }
+    }
+    // deflate data
+    const output = await inflateRawMember(inputArg, optionsArg, account);
+    // trailer
+    const trailer = await readExact(inputArg, 8, 'gzip trailer');
+    account(trailer);
+    const view = new DataView(trailer.buffer, trailer.byteOffset, trailer.byteLength);
+    if (view.getUint32(0, true) !== output.crc || view.getUint32(4, true) !== output.bytes.length % 0x1_0000_0000) {
+        throw new LinuxRepoError('malformed-archive', 'gzip trailer does not match the data', { field: 'gzip trailer' });
+    }
+    return { output: output.bytes, memberBytes, memberSha1: sha1.digest('hex') };
+}
+async function inflateRawMember(inputArg, optionsArg, accountArg) {
+    const inflate = plugins.zlib.createInflateRaw();
+    const chunks = [];
+    let outputBytes = 0;
+    let crc = 0;
+    let failure = null;
+    let streamError = null;
+    inflate.on('data', (chunk) => {
+        if (failure !== null) {
+            return;
+        }
+        outputBytes += chunk.length;
+        if (outputBytes > optionsArg.maxOutputBytes) {
+            failure = limitExceeded(optionsArg.outputLimit, optionsArg.maxOutputBytes, 'decompressed gzip member');
+            inflate.destroy();
+            return;
+        }
+        crc = plugins.zlib.crc32(chunk, crc);
+        chunks.push(chunk);
+    });
+    inflate.on('error', (error) => {
+        streamError ??= error;
+    });
+    try {
+        for (;;) {
+            const chunk = await inputArg.read(READ_CHUNK_BYTES);
+            if (chunk === null) {
+                throw truncated('gzip member');
+            }
+            const before = inflate.bytesWritten;
+            try {
+                await writeChunk(inflate, chunk);
+            }
+            catch (error) {
+                throw failure ?? mapInflateError(streamError ?? error);
+            }
+            if (failure !== null) {
+                throw failure;
+            }
+            const consumed = inflate.bytesWritten - before;
+            accountArg(chunk.subarray(0, consumed));
+            if (consumed < chunk.length) {
+                inputArg.unread(chunk.subarray(consumed));
+                break;
+            }
+        }
+        if (!inflate.readableEnded) {
+            await new Promise((resolve) => inflate.once('end', resolve));
+        }
+        if (failure !== null) {
+            throw failure;
+        }
+        return { bytes: concatBytes(chunks, outputBytes), crc };
+    }
+    finally {
+        inflate.destroy();
+    }
+}
+/** Writes one chunk and waits until the stream processed it, failing if the stream closes first. */
+function writeChunk(streamArg, chunkArg) {
+    return new Promise((resolve, reject) => {
+        const onClose = () => reject(new Error('inflate stream closed'));
+        streamArg.once('close', onClose);
+        streamArg.write(chunkArg, (error) => {
+            streamArg.off('close', onClose);
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+function mapInflateError(errorArg) {
+    return new LinuxRepoError('malformed-archive', 'gzip member has corrupt deflate data', { field: 'gzip member' }, {
+        cause: errorArg,
+    });
+}
+async function readZeroTerminated(inputArg, maxBytesArg) {
+    const parts = [];
+    let total = 0;
+    for (;;) {
+        const chunk = await inputArg.read(READ_CHUNK_BYTES);
+        if (chunk === null) {
+            throw truncated('gzip header');
+        }
+        const nul = chunk.indexOf(0);
+        const take = nul < 0 ? chunk : chunk.subarray(0, nul + 1);
+        total += take.length;
+        if (total > maxBytesArg) {
+            throw limitExceeded('maxHeaderBytes', maxBytesArg, 'gzip header string');
+        }
+        parts.push(take);
+        if (nul >= 0) {
+            inputArg.unread(chunk.subarray(nul + 1));
+            return concatBytes(parts, total);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gzipmember.js","sourceRoot":"","sources":["../../ts/readers/gzipmember.ts"],"names":[],"mappings":"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"}

package/dist_ts/readers/tar.d.ts

@@ -0,0 +1,85 @@
+import type { ILinuxPackageLimits } from '../shared/limits.js';
+import { LimitedReader, type IByteReader } from './bytes.js';
+export interface ITarEntry {
+    /**
+     * The final name: PAX `path`, else GNU long name, else USTAR prefix + name;
+     * a recognised PAX GNU sparse header's `GNU.sparse.name` wins. Bytes are
+     * decoded as Gitea's JSON stores a Go string (`decodeGoUtf8`). The name is
+     * reported as it stands: no normalisation of `./`, `..` or absolute paths.
+     */
+    name: string;
+    /** The link target; empty for `'g'`, as Go returns it. */
+    linkName: string;
+    /**
+     * The header's mode field as Go `archive/tar` parses it (octal or base-256;
+     * a field Go cannot parse fails the archive, as in Go); 0 for `'g'`, as Go
+     * returns it.
+     */
+    mode: bigint;
+    /**
+     * The type flag. Go's legacy `\0` becomes `'0'`, or `'5'` when the name ends
+     * with `/`. `'g'` is a PAX global header, returned as an entry as Go does.
+     */
+    typeflag: string;
+    /**
+     * Data bytes readable through `body` (0 for header-only types and `'g'`);
+     * for a sparse entry, the real size Go reports, any non-negative int64.
+     * Stored data above `Number.MAX_SAFE_INTEGER` bytes is refused.
+     */
+    size: bigint;
+    /**
+     * An old GNU (`'S'`) or PAX GNU 0.0, 0.1 or 1.0 sparse entry whose map Go
+     * accepts. The codec does not expand holes: reading its data (through
+     * `body` or `readTarEntryData`) is refused with `unsupported-package-format`,
+     * a known difference from Gitea; skipping it works.
+     */
+    sparse: boolean;
+    body: LimitedReader;
+}
+export interface ITarReaderOptions {
+    /** Entries returned per archive. */
+    maxEntries: number;
+    /**
+     * One header chain: header blocks, PAX records, GNU long names and old GNU
+     * sparse extension blocks. A PAX GNU 1.0 map, which heads the entry's data,
+     * is bounded by Go's 1 MiB cap only.
+     */
+    maxHeaderBytes: number;
+}
+/**
+ * A bounded ustar reader following Go `archive/tar` (Gitea's reader):
+ * USTAR, PAX (`x`, `g`), GNU long names (`L`, `K`), STAR prefixes, Go's
+ * pre-1.8 GNU prefix fallback, base-256 numbers and signed or unsigned
+ * checksums. A header Go refuses for an unparseable numeric field is refused. The archive ends at two zero
+ * blocks, at a clean end of input on a header boundary (apk segments have no
+ * end marker), or when the input ends inside the padding after an entry.
+ * Sparse maps (old GNU, PAX GNU 0.0, 0.1 and 1.0) are read and validated as
+ * Go does; the holes are not expanded, so a sparse entry's data can only be
+ * skipped.
+ */
+export declare class TarReader {
+    private readonly input;
+    private readonly options;
+    private done;
+    private current;
+    private pad;
+    private entries;
+    constructor(input: IByteReader, options: ITarReaderOptions);
+    next(): Promise<ITarEntry | null>;
+    /**
+     * Go `readOldGNUSparseMap` (reader.go:478-525) and the map check of
+     * `handleSparseFile`; returns the real size. The map fills the header's
+     * sparse array and extension blocks; Go gives up once its arrays reach
+     * 1 MiB (`errSparseTooLong`), whatever `maxHeaderBytes` allows.
+     */
+    private readOldGnuSparseMap;
+    private countEntry;
+    /** Reads the pending padding; false when the input ended inside it (a clean end, as in Go). */
+    private consumePadding;
+    private finish;
+}
+/**
+ * Reads a whole entry's data into memory, refusing entries larger than
+ * `maxBytesArg` before reading them, and sparse entries at all.
+ */
+export declare function readTarEntryData(entryArg: ITarEntry, maxBytesArg: number, limitArg: keyof ILinuxPackageLimits): Promise<Uint8Array>;