@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/dist_ts/signing/openpgpframing.js

@@ -0,0 +1,93 @@
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertAsyncIterable, assertBytes, assertString, assertTimestamp } from '../shared/validation.js';
+import { singleChunk } from './signers.js';
+/**
+ * The OpenPGP framing the codec owns: only the bytes of the signature packet
+ * may vary; framing and armor are deterministic.
+ * Armor has no headers, 64-column base64 and a CRC-24 line.
+ */
+const BASE64_LINE = 64;
+/**
+ * Signs the concatenation of the chunks of `data` and returns the signer's
+ * binary packet unchanged (Arch `.sig`, RPM header tags). The signer reads
+ * `data` to its end exactly once.
+ */
+export async function createDetachedBinarySignature(inputArg) {
+    assertAsyncIterable(inputArg.data, 'data');
+    assertTimestamp(inputArg.timestamp);
+    const packet = await inputArg.signer.signBinary(inputArg.data, inputArg.timestamp);
+    assertSignatureBytes(packet);
+    return packet;
+}
+/** Signs `data` and returns an armored detached signature (`Release.gpg`, `repomd.xml.asc`). */
+export async function createDetachedArmoredSignature(inputArg) {
+    assertBytes(inputArg.data, 'data');
+    return armorSignature(await createDetachedBinarySignature({
+        data: singleChunk(inputArg.data),
+        signer: inputArg.signer,
+        timestamp: inputArg.timestamp,
+    }));
+}
+/**
+ * Cleartext-signs `text` (`InRelease`). The text must be canonical: no CR and
+ * no trailing spaces or tabs on any line. The signed text is `text` without
+ * its final line break; the output always ends the text with one line break
+ * before the signature block, as GnuPG and Go do. Lines starting with `-` are
+ * dash-escaped. The header is always `Hash: SHA256`.
+ */
+export async function createCleartextSignedMessage(inputArg) {
+    assertCanonicalText(inputArg.text);
+    assertTimestamp(inputArg.timestamp);
+    const signedText = inputArg.text.endsWith('\n') ? inputArg.text.slice(0, -1) : inputArg.text;
+    const packet = await inputArg.signer.signText(signedText, inputArg.timestamp);
+    assertSignatureBytes(packet);
+    const body = `${signedText}\n`.replace(/^-/gm, '- -');
+    return `-----BEGIN PGP SIGNED MESSAGE-----\nHash: SHA256\n\n${body}${armorSignature(packet)}`;
+}
+/** ASCII armor for one signature packet list. */
+export function armorSignature(packetArg) {
+    const base64 = Buffer.from(packetArg.buffer, packetArg.byteOffset, packetArg.byteLength).toString('base64');
+    const lines = [];
+    for (let offset = 0; offset < base64.length; offset += BASE64_LINE) {
+        lines.push(base64.slice(offset, offset + BASE64_LINE));
+    }
+    return [
+        '-----BEGIN PGP SIGNATURE-----',
+        '',
+        ...lines,
+        `=${crc24Base64(packetArg)}`,
+        '-----END PGP SIGNATURE-----',
+        '',
+    ].join('\n');
+}
+/** Refuses text that is not canonical cleartext input. */
+export function assertCanonicalText(textArg) {
+    assertString(textArg, 'text');
+    if (textArg.includes('\r')) {
+        throw new LinuxRepoError('invalid-input', 'cleartext must use LF line endings', { field: 'text' });
+    }
+    if (/[ \t]$/m.test(textArg)) {
+        throw new LinuxRepoError('invalid-input', 'cleartext lines must not end with spaces or tabs', { field: 'text' });
+    }
+}
+function assertSignatureBytes(packetArg) {
+    if (!(packetArg instanceof Uint8Array) || packetArg.length === 0) {
+        throw new LinuxRepoError('signing-failed', 'the signer returned no signature bytes', { field: 'signer' });
+    }
+}
+/** RFC 4880 section 6.1 CRC-24, base64-encoded. */
+function crc24Base64(bytesArg) {
+    let crc = 0xb704ce;
+    for (let i = 0; i < bytesArg.length; i++) {
+        crc ^= bytesArg[i] << 16;
+        for (let bit = 0; bit < 8; bit++) {
+            crc <<= 1;
+            if (crc & 0x1000000) {
+                crc ^= 0x1864cfb;
+            }
+        }
+    }
+    crc &= 0xffffff;
+    return Buffer.from([(crc >> 16) & 0xff, (crc >> 8) & 0xff, crc & 0xff]).toString('base64');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/signing/signers.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Signs Alpine indexes. Consumers may implement it; adding a required member
+ * later needs a major release.
+ */
+export interface IAlpineSigner {
+    /**
+     * The key name apk looks up in `/etc/apk/keys`; the index signature entry is
+     * `.SIGN.RSA.<keyName>`. Gitea's form is `<owner>@<sha256 hex of the SPKI
+     * DER public key>.rsa.pub` (see `giteaAlpineKeyName`).
+     */
+    readonly keyName: string;
+    /** RSASSA-PKCS1-v1_5 over SHA-1 of `data`; returns the raw signature bytes. */
+    sign(data: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Signs Debian, RPM and Arch documents. Consumers may implement it; adding a
+ * required member later needs a major release.
+ *
+ * Contract: each call returns exactly one binary OpenPGP v4 signature packet
+ * (packet header included, no armor), hashed with SHA-256, whose creation time
+ * is `timestamp` (whole seconds). The codec does all framing (armor, cleartext
+ * dash-escaping, the `Hash: SHA256` header) and treats the packet as opaque.
+ */
+export interface IOpenPgpSigner {
+    /**
+     * A signature of type 0x00 (binary document) over the concatenation of the
+     * chunks of `data`. The signer reads `data` to its end exactly once.
+     */
+    signBinary(data: AsyncIterable<Uint8Array>, timestamp: Date): Promise<Uint8Array>;
+    /**
+     * A signature of type 0x01 (canonical text document) over `text`. The codec
+     * passes canonical text only: LF line endings and no trailing spaces or tabs
+     * on any line; the signature hashes it with CRLF line endings.
+     */
+    signText(text: string, timestamp: Date): Promise<Uint8Array>;
+}
+/**
+ * Builds an Alpine signer from an unencrypted RSA private key in PEM form:
+ * PKCS#1 (`RSA PRIVATE KEY`, Gitea's stored form) or PKCS#8 (`PRIVATE KEY`).
+ * Anything else is `invalid-key`. Signatures are deterministic.
+ */
+export declare function createAlpineSigner(inputArg: {
+    privateKeyPem: string;
+    keyName: string;
+}): IAlpineSigner;
+/**
+ * Builds an OpenPGP signer from an armored private key: exactly one key,
+ * OpenPGP v4, not encrypted, able to sign. Anything else is `invalid-key`.
+ * Signatures are SHA-256 and keep openpgp.js's salt notation, so their bytes
+ * vary per call; the produced packet is checked against the signer contract.
+ *
+ * The factory makes one trial `signBinary` and refuses the key with
+ * `invalid-key` when it fails, so a key that cannot meet the contract at all
+ * (one whose curve makes openpgp.js choose a stronger hash than SHA-256) is
+ * refused here. The trial signs at the latest creation time of the key, its
+ * subkeys and their self-signatures; a failure that depends on the signing
+ * time stays `signing-failed` at signing time.
+ */
+export declare function createOpenPgpSigner(inputArg: {
+    privateKeyArmored: string;
+}): Promise<IOpenPgpSigner>;
+/** `bytesArg` as a one-chunk source, for callers that hold the whole document. */
+export declare function singleChunk(bytesArg: Uint8Array): AsyncGenerator<Uint8Array>;

package/dist_ts/signing/signers.js

@@ -0,0 +1,248 @@
+import * as plugins from '../plugins.js';
+import { concatBytes } from '../readers/bytes.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertAsyncIterable, assertBytes, assertSegmentName, assertString, assertTimestamp, } from '../shared/validation.js';
+const ALPINE_PRIVATE_KEY_LABELS = ['RSA PRIVATE KEY', 'PRIVATE KEY'];
+/**
+ * Builds an Alpine signer from an unencrypted RSA private key in PEM form:
+ * PKCS#1 (`RSA PRIVATE KEY`, Gitea's stored form) or PKCS#8 (`PRIVATE KEY`).
+ * Anything else is `invalid-key`. Signatures are deterministic.
+ */
+export function createAlpineSigner(inputArg) {
+    if (inputArg === null || typeof inputArg !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    assertString(inputArg.privateKeyPem, 'privateKeyPem');
+    assertSegmentName(inputArg.keyName, 'keyName');
+    const label = /-----BEGIN ([A-Z0-9 ]+)-----/.exec(inputArg.privateKeyPem)?.[1];
+    if (label === undefined || !ALPINE_PRIVATE_KEY_LABELS.includes(label)) {
+        throw new LinuxRepoError('invalid-key', 'the Alpine key must be an unencrypted PKCS#1 or PKCS#8 RSA private key PEM', {
+            field: 'privateKeyPem',
+        });
+    }
+    let key;
+    try {
+        key = plugins.crypto.createPrivateKey({ key: inputArg.privateKeyPem, format: 'pem' });
+    }
+    catch (error) {
+        throw new LinuxRepoError('invalid-key', 'the Alpine private key cannot be read', { field: 'privateKeyPem' }, {
+            cause: error,
+        });
+    }
+    if (key.asymmetricKeyType !== 'rsa') {
+        throw new LinuxRepoError('invalid-key', 'the Alpine key must be an RSA key', { field: 'privateKeyPem' });
+    }
+    const keyName = inputArg.keyName;
+    return {
+        keyName,
+        sign: async (data) => {
+            assertBytes(data, 'data');
+            try {
+                const signature = plugins.crypto.sign('sha1', data, {
+                    key,
+                    padding: plugins.crypto.constants.RSA_PKCS1_PADDING,
+                });
+                return new Uint8Array(signature.buffer, signature.byteOffset, signature.byteLength);
+            }
+            catch (error) {
+                throw new LinuxRepoError('signing-failed', 'RSA PKCS#1 v1.5 SHA-1 signing failed', { field: 'keyName' }, {
+                    cause: error,
+                });
+            }
+        },
+    };
+}
+/**
+ * Builds an OpenPGP signer from an armored private key: exactly one key,
+ * OpenPGP v4, not encrypted, able to sign. Anything else is `invalid-key`.
+ * Signatures are SHA-256 and keep openpgp.js's salt notation, so their bytes
+ * vary per call; the produced packet is checked against the signer contract.
+ *
+ * The factory makes one trial `signBinary` and refuses the key with
+ * `invalid-key` when it fails, so a key that cannot meet the contract at all
+ * (one whose curve makes openpgp.js choose a stronger hash than SHA-256) is
+ * refused here. The trial signs at the latest creation time of the key, its
+ * subkeys and their self-signatures; a failure that depends on the signing
+ * time stays `signing-failed` at signing time.
+ */
+export async function createOpenPgpSigner(inputArg) {
+    if (inputArg === null || typeof inputArg !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    assertString(inputArg.privateKeyArmored, 'privateKeyArmored');
+    // openpgp.js reads the first armor block and ignores anything after it
+    const armorBlocks = inputArg.privateKeyArmored.match(/^-----BEGIN PGP [A-Z ,/0-9]+-----\s*$/gm) ?? [];
+    if (armorBlocks.length > 1) {
+        throw new LinuxRepoError('invalid-key', `expected one armored OpenPGP private key block, got ${armorBlocks.length}`, {
+            field: 'privateKeyArmored',
+        });
+    }
+    let keys;
+    try {
+        keys = await plugins.openpgp.readPrivateKeys({ armoredKeys: inputArg.privateKeyArmored });
+    }
+    catch (error) {
+        throw new LinuxRepoError('invalid-key', 'the OpenPGP private key cannot be read', { field: 'privateKeyArmored' }, {
+            cause: error,
+        });
+    }
+    if (keys.length !== 1) {
+        throw new LinuxRepoError('invalid-key', `expected exactly one OpenPGP private key, got ${keys.length}`, {
+            field: 'privateKeyArmored',
+        });
+    }
+    const key = keys[0];
+    if (key.keyPacket.version !== 4) {
+        throw new LinuxRepoError('invalid-key', `only OpenPGP v4 keys are accepted, got v${key.keyPacket.version}`, {
+            field: 'privateKeyArmored',
+        });
+    }
+    if (!key.isDecrypted()) {
+        throw new LinuxRepoError('invalid-key', 'encrypted OpenPGP keys are not accepted', { field: 'privateKeyArmored' });
+    }
+    const sign = async (produceArg, timestampArg, signatureTypeArg, inputFailureArg = () => undefined) => {
+        let packet;
+        try {
+            packet = await produceArg();
+        }
+        catch (error) {
+            // an invalid chunk or the caller's own source error, not a signing failure
+            const inputFailure = inputFailureArg();
+            if (inputFailure !== undefined) {
+                throw inputFailure.error;
+            }
+            throw new LinuxRepoError('signing-failed', 'OpenPGP signing failed', { field: 'signingKey' }, { cause: error });
+        }
+        await assertSignaturePacket(packet, timestampArg, signatureTypeArg);
+        return packet;
+    };
+    const config = { preferredHashAlgorithm: plugins.openpgp.enums.hash.sha256 };
+    const signer = {
+        signBinary: async (data, timestamp) => {
+            assertAsyncIterable(data, 'data');
+            assertTimestamp(timestamp);
+            const source = new CheckedChunkSource(data);
+            return sign(async () => {
+                const signature = await plugins.openpgp.sign({
+                    message: await plugins.openpgp.createMessage({ binary: source.toReadableStream() }),
+                    signingKeys: key,
+                    detached: true,
+                    format: 'binary',
+                    date: timestamp,
+                    config,
+                });
+                const packet = await readAll(signature);
+                if (!source.ended) {
+                    throw new Error('openpgp.js returned a signature before reading the data to its end');
+                }
+                return packet;
+            }, timestamp, plugins.openpgp.enums.signature.binary, () => source.failure);
+        },
+        signText: async (text, timestamp) => {
+            assertString(text, 'text');
+            assertTimestamp(timestamp);
+            return sign(async () => plugins.openpgp.sign({
+                message: await plugins.openpgp.createMessage({ text }),
+                signingKeys: key,
+                detached: true,
+                format: 'binary',
+                date: timestamp,
+                config,
+            }), timestamp, plugins.openpgp.enums.signature.text);
+        },
+    };
+    try {
+        await signer.signBinary(singleChunk(new Uint8Array(0)), latestKeyTime(key));
+    }
+    catch (error) {
+        throw new LinuxRepoError('invalid-key', 'the OpenPGP key cannot sign a v4 SHA-256 signature', { field: 'privateKeyArmored' }, {
+            cause: error,
+        });
+    }
+    return signer;
+}
+/** `bytesArg` as a one-chunk source, for callers that hold the whole document. */
+export async function* singleChunk(bytesArg) {
+    yield bytesArg;
+}
+/**
+ * Pulls the caller's source with `next()` only (never `return()` or
+ * `throw()`, so a cancelled stream never cancels the source), refuses a chunk
+ * that is not a `Uint8Array` with `invalid-input`, and records the first
+ * error it raised or met so the signer can rethrow it unchanged.
+ */
+class CheckedChunkSource {
+    ended = false;
+    failure = undefined;
+    source;
+    constructor(sourceArg) {
+        this.source = sourceArg;
+    }
+    toReadableStream() {
+        const iterator = this.source[Symbol.asyncIterator]();
+        const next = async () => {
+            let result;
+            try {
+                result = await iterator.next();
+            }
+            catch (error) {
+                this.failure ??= { error };
+                throw error;
+            }
+            if (result.done === true) {
+                this.ended = true;
+                return { done: true, value: undefined };
+            }
+            if (!(result.value instanceof Uint8Array)) {
+                const error = new LinuxRepoError('invalid-input', 'every chunk of data must be a Uint8Array', { field: 'data' });
+                this.failure ??= { error };
+                throw error;
+            }
+            return { done: false, value: result.value };
+        };
+        return plugins.streamWeb.ReadableStream.from({ [Symbol.asyncIterator]: () => ({ next }) });
+    }
+}
+/** Reads openpgp.js's streamed output to its end. */
+async function readAll(streamArg) {
+    const reader = streamArg.getReader();
+    const chunks = [];
+    let total = 0;
+    for (let result = await reader.read(); !result.done; result = await reader.read()) {
+        chunks.push(result.value);
+        total += result.value.length;
+    }
+    return concatBytes(chunks, total);
+}
+/** The latest creation time of the key, its subkeys and their self-signatures: the key's current state applies. */
+function latestKeyTime(keyArg) {
+    const times = [keyArg.getCreationTime().getTime()];
+    for (const user of keyArg.users) {
+        for (const signature of user.selfCertifications) {
+            times.push(signature.created?.getTime() ?? 0);
+        }
+    }
+    for (const subkey of keyArg.subkeys) {
+        times.push(subkey.getCreationTime().getTime());
+        for (const signature of subkey.bindingSignatures) {
+            times.push(signature.created?.getTime() ?? 0);
+        }
+    }
+    return new Date(Math.max(...times));
+}
+/** Checks that openpgp.js produced exactly the packet the signer contract promises. */
+async function assertSignaturePacket(packetArg, timestampArg, signatureTypeArg) {
+    const signature = await plugins.openpgp.readSignature({ binarySignature: packetArg });
+    const packets = signature.packets;
+    const expectedSeconds = Math.floor(timestampArg.getTime() / 1000);
+    const ok = packets.length === 1 &&
+        packets[0].version === 4 &&
+        packets[0].signatureType === signatureTypeArg &&
+        packets[0].hashAlgorithm === plugins.openpgp.enums.hash.sha256 &&
+        packets[0].created !== null &&
+        Math.floor(packets[0].created.getTime() / 1000) === expectedSeconds;
+    if (!ok) {
+        throw new LinuxRepoError('signing-failed', 'the signing key cannot produce one v4 SHA-256 signature packet at the requested time', { field: 'signingKey' });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signers.js","sourceRoot":"","sources":["../../ts/signing/signers.ts"],"names":[],"mappings":"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"}

package/dist_ts/writers/gotar.d.ts

@@ -0,0 +1,43 @@
+export interface IGoTarFile {
+    name: string;
+    mode: number;
+    data: Uint8Array;
+}
+export interface IGoTarWriteOptions {
+    /**
+     * The two zero blocks Go `Writer.Close` writes. `false` for Gitea's Alpine
+     * signature member (`writeGzipStream` with `addTarEnd=false`). Gitea never
+     * calls `Close` there, so Go also leaves the last entry unpadded; the codec
+     * pads every entry to the block regardless (a difference from Gitea).
+     */
+    endOfArchive: boolean;
+}
+/**
+ * The subset of Go 1.27 `archive/tar` `Writer` that Gitea 28.2.0 uses for its
+ * index archives (Arch `services/packages/arch/repository.go:381-399`, Alpine
+ * `services/packages/alpine/repository.go:331-351`): regular files from
+ * `tar.Header{Name, Mode, Size}` with every other field zero, so the zero
+ * `ModTime` is written as 0, uid and gid are 0 and user and group names are
+ * empty.
+ *
+ * Format choice follows Go's `allowedFormats` and `WriteHeader`: USTAR when the
+ * name is ASCII and at most 100 bytes, USTAR with a prefix split when the name
+ * splits, else PAX with one `path` record (refused when the records exceed
+ * Go's 1 MiB `maxSpecialFileSize`, as Go returns `ErrFieldTooLong`).
+ *
+ * Refused with `invalid-input` where Go would not write a regular file in USTAR
+ * or PAX-`path` form:
+ * - a name with NUL (Go fails with an invalid PAX record) or ending with `/`
+ *   (Go refuses it for a regular file; Gitea's untyped header would become a
+ *   directory entry instead);
+ * - a mode outside 7 octal digits (Go falls back to the GNU format);
+ * - a size of 8 GiB or more (Go adds a PAX `size` record; the codec does not);
+ * - a string that is not well-formed UTF-16 (Go strings never carry one).
+ */
+export declare function writeGoTar(filesArg: readonly IGoTarFile[], optionsArg?: IGoTarWriteOptions): Uint8Array;
+/**
+ * The bytes Go `Writer.WriteHeader` writes for a regular file: the main
+ * header block, preceded by a PAX `x` header and its padded records when the
+ * name needs one.
+ */
+export declare function goTarHeader(nameArg: string, modeArg: number, sizeArg: number): Uint8Array;