@push.rocks/smartlinuxrepo 1.0.0 → 1.1.1

package/dist_ts/signing/verifiers.js

@@ -0,0 +1,263 @@
+import * as plugins from '../plugins.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertBytes, assertString, assertTimestamp } from '../shared/validation.js';
+import { dearmor, decodeArmorBytes, readPacketTags, splitCleartextSignedMessage, } from './openpgpframing.js';
+const HASH_ALGORITHMS = new Map([
+    [plugins.openpgp.enums.hash.sha256, 'sha256'],
+    [plugins.openpgp.enums.hash.sha384, 'sha384'],
+    [plugins.openpgp.enums.hash.sha512, 'sha512'],
+]);
+/** Subpacket types openpgp.js reads in the unhashed area (issuer, embedded signature, issuer fingerprint). */
+const UNHASHED_SUBPACKETS_READ = new Set([16, 32, 33]);
+/**
+ * The openpgp.js settings verification depends on, pinned instead of taken
+ * from the process-wide `openpgp.config`. The values are openpgp.js 6.3.2's
+ * defaults except `ignoreUnsupportedPackets`.
+ */
+const VERIFY_CONFIG = {
+    ...plugins.openpgp.config,
+    ignoreUnsupportedPackets: false,
+    ignoreMalformedPackets: false,
+    enableParsingV5Entities: false,
+    additionalAllowedPackets: [],
+    allowMissingKeyFlags: false,
+    allowInsecureVerificationWithReformattedKeys: false,
+    minRSABits: 2047,
+    knownNotations: [],
+    rejectHashAlgorithms: new Set([plugins.openpgp.enums.hash.md5, plugins.openpgp.enums.hash.ripemd]),
+    rejectMessageHashAlgorithms: new Set([
+        plugins.openpgp.enums.hash.md5,
+        plugins.openpgp.enums.hash.ripemd,
+        plugins.openpgp.enums.hash.sha1,
+    ]),
+    rejectPublicKeyAlgorithms: new Set([plugins.openpgp.enums.publicKey.elgamal, plugins.openpgp.enums.publicKey.dsa]),
+    rejectCurves: new Set([plugins.openpgp.enums.curve.secp256k1]),
+};
+/**
+ * Builds a verifier from one armored OpenPGP public key: exactly one
+ * transferable v4 public key (the primary key with its user IDs, subkeys and
+ * self-signatures, all v4) in exactly one `PUBLIC KEY BLOCK`. A private key
+ * block, several blocks or keys, a v6 key, text around the block, an armor
+ * CRC-24 that does not match or any other garbage is `invalid-key`
+ * (`detail.field` `publicKeyArmored`). Only the structure is checked here;
+ * whether a key can sign depends on time and is checked at verification.
+ */
+export async function createOpenPgpVerifier(inputArg) {
+    if (inputArg === null || typeof inputArg !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    assertString(inputArg.publicKeyArmored, 'publicKeyArmored');
+    const keyBytes = dearmor(inputArg.publicKeyArmored, 'PUBLIC KEY BLOCK', { code: 'invalid-key', field: 'publicKeyArmored' });
+    let keys;
+    try {
+        keys = await plugins.openpgp.readKeys({ binaryKeys: keyBytes, config: VERIFY_CONFIG });
+    }
+    catch (error) {
+        throw new LinuxRepoError('invalid-key', 'the OpenPGP public key cannot be read', { field: 'publicKeyArmored' }, {
+            cause: error,
+        });
+    }
+    if (keys.length !== 1) {
+        throw new LinuxRepoError('invalid-key', `expected exactly one OpenPGP public key, got ${keys.length}`, {
+            field: 'publicKeyArmored',
+        });
+    }
+    const key = keys[0];
+    if (key.isPrivate()) {
+        throw new LinuxRepoError('invalid-key', 'a private key is not accepted as the verification key', {
+            field: 'publicKeyArmored',
+        });
+    }
+    if (key.keyPacket.version !== 4 || key.subkeys.some((subkey) => subkey.keyPacket.version !== 4)) {
+        throw new LinuxRepoError('invalid-key', 'only OpenPGP v4 keys and subkeys are accepted', { field: 'publicKeyArmored' });
+    }
+    const publicKey = key;
+    return {
+        fingerprint: publicKey.getFingerprint().toUpperCase(),
+        verifyDetachedSignature: async (input) => {
+            assertInputObject(input);
+            assertBytes(input.data, 'data');
+            assertBytes(input.signature, 'signature');
+            assertTimestamp(input.date, 'date');
+            return verifySignature({
+                key: publicKey,
+                packets: input.signature,
+                content: { binary: input.data },
+                signatureType: plugins.openpgp.enums.signature.binary,
+                date: input.date,
+                field: 'signature',
+                headerHashAlgorithms: [],
+            });
+        },
+        verifyArmoredDetachedSignature: async (input) => {
+            assertInputObject(input);
+            assertBytes(input.data, 'data');
+            assertBytes(input.signatureArmored, 'signatureArmored');
+            assertTimestamp(input.date, 'date');
+            const failure = { code: 'malformed-signature', field: 'signatureArmored' };
+            return verifySignature({
+                key: publicKey,
+                packets: dearmor(decodeArmorBytes(input.signatureArmored, failure), 'SIGNATURE', failure),
+                content: { binary: input.data },
+                signatureType: plugins.openpgp.enums.signature.binary,
+                date: input.date,
+                field: 'signatureArmored',
+                headerHashAlgorithms: [],
+            });
+        },
+        verifyCleartextMessage: async (input) => {
+            assertInputObject(input);
+            assertBytes(input.message, 'message');
+            assertTimestamp(input.date, 'date');
+            const parts = splitCleartextSignedMessage(input.message, { code: 'malformed-signature', field: 'message' });
+            const verification = await verifySignature({
+                key: publicKey,
+                packets: parts.signature,
+                // a text signature hashes the text with CRLF line endings; the split refused trailing whitespace,
+                // so this equals the cleartext digest of RFC 9580 section 7.1
+                content: { text: parts.signedText },
+                signatureType: plugins.openpgp.enums.signature.text,
+                date: input.date,
+                field: 'message',
+                headerHashAlgorithms: parts.headerHashAlgorithms,
+            });
+            return { ...verification, signedText: parts.signedText };
+        },
+    };
+}
+function hexByte(valueArg) {
+    return valueArg === null ? 'none' : `0x${valueArg.toString(16).padStart(2, '0')}`;
+}
+function assertInputObject(inputArg) {
+    if (inputArg === null || typeof inputArg !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+}
+/**
+ * The verification steps, each with its own error code: structure
+ * (`malformed-signature`), issuer (`wrong-key`), the signature's own time
+ * rules (`bad-signature`), the issuing key's ability to sign at creation and
+ * at `date` (`unusable-key`), then the cryptographic check (`bad-signature`).
+ */
+async function verifySignature(inputArg) {
+    const { key, date, field } = inputArg;
+    const malformed = (messageArg, causeArg) => new LinuxRepoError('malformed-signature', messageArg, { field }, causeArg === undefined ? undefined : { cause: causeArg });
+    // 1. structure, before any cryptography
+    const tags = readPacketTags(inputArg.packets, { code: 'malformed-signature', field });
+    if (tags.length !== 1 || tags[0] !== plugins.openpgp.enums.packet.signature) {
+        throw malformed(`expected exactly one signature packet, got packet tags [${tags.join(', ')}]`);
+    }
+    let signature;
+    try {
+        signature = await plugins.openpgp.readSignature({ binarySignature: inputArg.packets, config: VERIFY_CONFIG });
+    }
+    catch (error) {
+        throw malformed('the signature packet cannot be read', error);
+    }
+    const packet = signature.packets[0];
+    if (signature.packets.length !== 1 || !(packet instanceof plugins.openpgp.SignaturePacket)) {
+        throw malformed('expected exactly one signature packet');
+    }
+    if (packet.version !== 4) {
+        throw malformed(`only v4 signatures are accepted, got v${packet.version}`);
+    }
+    if (packet.signatureType !== inputArg.signatureType) {
+        throw malformed(`expected signature type ${hexByte(inputArg.signatureType)}, got ${hexByte(packet.signatureType)}`);
+    }
+    const hashId = packet.hashAlgorithm;
+    const hashAlgorithm = hashId === null ? undefined : HASH_ALGORITHMS.get(hashId);
+    if (hashId === null || hashAlgorithm === undefined) {
+        throw malformed(`hash algorithm ${hashId} is not SHA-256, SHA-384 or SHA-512`);
+    }
+    if (inputArg.headerHashAlgorithms.length > 0 && !inputArg.headerHashAlgorithms.includes(hashId)) {
+        throw malformed('the Hash: header does not name the signature hash algorithm');
+    }
+    if (packet.created === null) {
+        throw malformed('the signature has no creation time');
+    }
+    const issuerKeyId = packet.issuerKeyID.toHex();
+    if (!/^[0-9a-f]{16}$/.test(issuerKeyId) || /^0+$/.test(issuerKeyId)) {
+        throw malformed('the signature names no issuer, or the wildcard issuer');
+    }
+    if (packet.unknownSubpackets.some((subpacket) => subpacket.critical)) {
+        throw malformed('the signature has an unknown critical subpacket');
+    }
+    if (packet.unhashedSubpackets.some((subpacket) => subpacket.critical && !UNHASHED_SUBPACKETS_READ.has(subpacket.type))) {
+        throw malformed('the signature has a critical unhashed subpacket the verifier does not read');
+    }
+    if (packet.rawNotations.some((notation) => notation.critical)) {
+        throw malformed('the signature has a critical notation');
+    }
+    // 2. issuer: the primary key or one of its subkeys, by key ID and, when present, by fingerprint
+    const issuerFingerprint = packet.issuerFingerprint === null ? null : Buffer.from(packet.issuerFingerprint).toString('hex');
+    const issuers = [key, ...key.subkeys].filter((candidate) => candidate.getKeyID().equals(packet.issuerKeyID) && (issuerFingerprint === null || candidate.getFingerprint() === issuerFingerprint));
+    if (issuers.length === 0) {
+        throw new LinuxRepoError('wrong-key', 'the signature was not issued by this key or one of its subkeys', {
+            field,
+            value: (issuerFingerprint ?? issuerKeyId).toUpperCase(),
+        });
+    }
+    // 3. the signature's own time rules
+    if (packet.isExpired(date)) {
+        const reason = packet.created.getTime() > date.getTime() ? 'was created after the verification date' : 'has expired at the verification date';
+        throw new LinuxRepoError('bad-signature', `the signature ${reason}`, { field });
+    }
+    // 4. the issuing key or subkey must be able to sign at the creation time and at `date`
+    const signingKeyAt = async (whenArg) => {
+        let signingKey;
+        try {
+            signingKey = await key.getSigningKey(packet.issuerKeyID, whenArg, undefined, VERIFY_CONFIG);
+        }
+        catch (error) {
+            throw new LinuxRepoError('unusable-key', `key ${issuerKeyId.toUpperCase()} cannot sign at ${whenArg.toISOString()}`, { field: 'publicKeyArmored', value: issuers[0].getFingerprint().toUpperCase() }, { cause: error });
+        }
+        if (!issuers.includes(signingKey)) {
+            throw new LinuxRepoError('unusable-key', `key ${issuerKeyId.toUpperCase()} cannot sign at ${whenArg.toISOString()}`, {
+                field: 'publicKeyArmored',
+                value: issuers[0].getFingerprint().toUpperCase(),
+            });
+        }
+        return signingKey;
+    };
+    const atCreation = await signingKeyAt(packet.created);
+    const atDate = await signingKeyAt(date);
+    if (atCreation !== atDate) {
+        throw new LinuxRepoError('unusable-key', `key ${issuerKeyId.toUpperCase()} is not the same signing key at creation and at the verification date`, {
+            field: 'publicKeyArmored',
+            value: issuers[0].getFingerprint().toUpperCase(),
+        });
+    }
+    // 5. cryptography
+    try {
+        const content = inputArg.content;
+        const { signatures } = 'text' in content
+            ? await plugins.openpgp.verify({
+                message: await plugins.openpgp.createMessage({ text: content.text }),
+                signature,
+                verificationKeys: key,
+                date,
+                config: VERIFY_CONFIG,
+            })
+            : await plugins.openpgp.verify({
+                message: await plugins.openpgp.createMessage({ binary: content.binary }),
+                signature,
+                verificationKeys: key,
+                date,
+                format: 'binary',
+                config: VERIFY_CONFIG,
+            });
+        if (signatures.length !== 1) {
+            throw new Error(`openpgp.js evaluated ${signatures.length} signatures, expected 1`);
+        }
+        await signatures[0].verified;
+    }
+    catch (error) {
+        throw new LinuxRepoError('bad-signature', 'the signature does not verify', { field }, { cause: error });
+    }
+    return {
+        signingKeyFingerprint: atDate.getFingerprint().toUpperCase(),
+        created: new Date(packet.created.getTime()),
+        hashAlgorithm,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"verifiers.js","sourceRoot":"","sources":["../../ts/signing/verifiers.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartlinuxrepo",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "private": false,
   "description": "A pure codec for Linux package repositories (Alpine apk, Debian apt, RPM dnf, Arch pacman): read packages into records, build index file sets and sign them.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -16,7 +16,7 @@ Node.js `^24.20.0 || >=26.6.0`: the releases whose `node:zlib` reports a truncat
 
 ## Status
 
-All four formats read, index and sign: `readAlpinePackage`, `readDebianPackage`, `readRpmPackage` and `readArchPackage` read packages into records; `buildAlpineIndex`, `buildDebianIndex`, `buildRpmIndex` and `buildArchIndex` build signed index file sets; `signRpmPackage` and `signArchPackage` sign packages at upload. Each format is checked against Gitea 28.2.0's own output and installed from with apk, apt, dnf and pacman. The built-in OpenPGP signer does not stream: openpgp.js 6.3.2 holds a detached-signed document in memory (see Signing).
+All four formats read, index and sign: `readAlpinePackage`, `readDebianPackage`, `readRpmPackage` and `readArchPackage` read packages into records; `buildAlpineIndex`, `buildDebianIndex`, `buildRpmIndex` and `buildArchIndex` build signed index file sets; `signRpmPackage` and `signArchPackage` sign packages at upload. Each format is checked against Gitea 28.2.0's own output and installed from with apk, apt, dnf and pacman. `createOpenPgpVerifier` verifies OpenPGP detached and cleartext signatures (see Verification). The built-in OpenPGP signer does not stream: openpgp.js 6.3.2 holds a detached-signed document in memory (see Signing).
 
 ## Records
 
@@ -36,7 +36,7 @@ Readers take `Partial<ILinuxPackageLimits>` per call over `DEFAULT_LINUX_PACKAGE
 | `maxFileListBytes` | 16 MiB | total Arch file-name bytes |
 | `maxHeaderBytes` | 4 MiB | one tar header chain or metadata line |
 
-Every failure is a `LinuxRepoError` with a stable `code` (`limit-exceeded`, `unsupported-compression`, `malformed-archive`, `malformed-header`, `missing-field`, `invalid-field`, `unsupported-package-format`, `truncated`, `digest-mismatch`, `invalid-input`, `invalid-key`, `signing-failed`) and a `detail` naming the field or limit. Errors from your own source or signer, and failures inside node:crypto or openpgp.js during key generation, are passed through unchanged.
+Every failure is a `LinuxRepoError` with a stable `code` (`limit-exceeded`, `unsupported-compression`, `malformed-archive`, `malformed-header`, `missing-field`, `invalid-field`, `unsupported-package-format`, `truncated`, `digest-mismatch`, `invalid-input`, `invalid-key`, `signing-failed`, and from the verifier `malformed-signature`, `wrong-key`, `unusable-key`, `bad-signature`) and a `detail` naming the field or limit. Errors from your own source or signer, and failures inside node:crypto or openpgp.js during key generation, are passed through unchanged. New codes arrive in minor releases (1.1.0 added the four verifier codes), each raised only by a new function: a `switch` over `code` needs a default branch.
 
 ## Signing
 
@@ -65,6 +65,37 @@ const pgpSigner = await createOpenPgpSigner({ privateKeyArmored: pgpKeys.private
 
 `isIndexableArchitecture(architecture)` tells whether an architecture can name an index path; builders refuse entries that fail it.
 
+## Verification
+
+```ts
+import { createOpenPgpVerifier } from '@push.rocks/smartlinuxrepo';
+
+const verifier = await createOpenPgpVerifier({ publicKeyArmored }); // invalid-key unless one v4 public key
+const now = new Date();
+const signature = await pgpSigner.signBinary((async function* () { yield data; })(), now); // a raw packet, as an Arch .sig
+await verifier.verifyDetachedSignature({ data, signature, date: now });
+await verifier.verifyArmoredDetachedSignature({ data: release, signatureArmored: releaseGpg, date: now }); // Release.gpg, repomd.xml.asc
+const { signedText } = await verifier.verifyCleartextMessage({ message: inRelease, date: now }); // InRelease
+```
+
+`createOpenPgpVerifier` reads exactly one transferable OpenPGP v4 public key (primary key, user IDs, subkeys, self-signatures) in exactly one `PUBLIC KEY BLOCK`. A private key, several blocks or keys, a v6 key, text around the block or an armor CRC-24 that does not match is `invalid-key`. Armor headers (`Comment:`, `Version:`) are ignored; a malformed header line is refused. Whether the key can sign is checked at verification, where the time is known.
+
+The three methods take the served bytes as `Uint8Array` and a required `date`; the codec reads no clock. `verifyDetachedSignature` takes a raw signature packet (what `signBinary` returns, an Arch `.sig`), `verifyArmoredDetachedSignature` an ASCII-armored one, and nothing is sniffed. A signature is valid when it is exactly one v4 signature packet (type 0x00 detached, 0x01 cleartext) hashed with SHA-256, SHA-384 or SHA-512, issued by the primary key or one of its subkeys, created at or before `date` and not expired at `date`, made by a key that can sign both at the signature's creation time and at `date` (not expired, not revoked, sign flag, valid binding, openpgp.js's algorithm floor), and when it verifies. A result names the key or subkey that verified (`signingKeyFingerprint`, 40 uppercase hex), the creation time and the hash algorithm. Every failure is a `LinuxRepoError`, never a boolean:
+
+| Code | Meaning |
+| --- | --- |
+| `malformed-signature` | armor, encoding or framing, not exactly one v4 signature packet, the wrong signature type, a hash outside SHA-256/384/512, a `Hash:` header without the signature's hash, no creation time, no or a wildcard issuer, an unknown critical subpacket or notation |
+| `wrong-key` | issued by neither the primary key nor a subkey, or the issuer fingerprint disagrees (`detail.value`: the issuer in hex) |
+| `unusable-key` | the issuing key or subkey cannot sign at the creation time or at `date`: expired, revoked, no sign flag, created after the signature, below the algorithm floor (`detail.value`: the fingerprint of the key or subkey that cannot sign) |
+| `bad-signature` | the cryptographic check failed, or the signature was created after `date` or has expired at `date` |
+| `invalid-input` | an argument that is not a `Uint8Array`, or an invalid `date` |
+
+A cleartext message is strict UTF-8 with LF line endings, as apt splits it: the `-----BEGIN PGP SIGNED MESSAGE-----` line first, optional `Hash:` headers and no others, the dash-escaped text, one signature block, then at most one line break. Text before or after, a CR, a line ending in a space or tab, or a line starting with `-` but not `- ` is `malformed-signature`. `signedText` is the text as signed: dash-escaping removed, without the line break before the signature block. For the codec's and GnuPG's `InRelease` that is `Release` without its final line break; Gitea 28.2.0's `InRelease` (go-crypto) signs that line break too, so its `signedText` is the whole `Release`.
+
+Two refusals depart from RFC 9580: an armor CRC-24 that does not match (§6.1; gpgv refuses it, sqv accepts it) and a `Hash:` header that does not name the signature's hash (§6.2.2.3).
+
+The verdicts match gpgv as apt reads it (`EXPKEYSIG` and `REVKEYSIG` are refusals). sqv, apt 3's verifier, checks the key only at the signature's creation time: it accepts a signature whose subkey expired, or whose key was soft-revoked, after signing, which the codec refuses at a later `date`.
+
 Every builder returns the complete file set for its input as `ILinuxIndexFile[]` (`path`, `bytes`, `sha256`, `mediaType`, `stage`, `aliases`); a previously written file that is not in the set is stale. Write every `content` file before any `pointer` file: the pointer files are the signed documents that name the content files.
 
 ## Alpine
@@ -107,9 +138,9 @@ const files = await buildDebianIndex({
 });
 ```
 
-`readDebianPackage` reads the `control.tar` member (plain, `.gz`, `.xz` or `.zst`) and hashes the rest of the file without decompressing it. The record keeps Gitea's derived values exactly, and its `fileName` is `<name>_<version>_<architecture>.deb`.
+`readDebianPackage` reads the `control.tar` member (plain, `.gz`, `.xz` or `.zst`) and hashes the rest of the file without decompressing it. The record keeps Gitea's derived values exactly, and its `fileName` is `<name>_<version>_<architecture>.deb`. Two departures from Gitea's control checks keep every record indexable. The version: a version that holds `/` or `?` is refused with `invalid-field` (`detail.field` `Version`), a departure from Gitea's version pattern, which admits both in the revision (its `+-~` class is the range 0x2B-0x7E); no pool file name can hold them, because `/` splits the path and apt sends `?` unescaped, so the server would read the rest as a query. The architecture: Gitea accepts any non-empty Architecture; the reader refuses one that is `.` or `..` or holds `/`, `#`, `?`, whitespace or a control character (`invalid-field`, `detail.field` `Architecture`), because the file name embeds it. `buildDebianIndex` applies the same rules to `record.architecture` and `record.fileName` (`invalid-input`), so every record the reader returns can be indexed.
 
-`buildDebianIndex` returns the complete set for one distribution. For every component and architecture with packages it writes `dists/<distribution>/<component>/binary-<architecture>/Packages`, `Packages.gz` and `Packages.xz` (`content` files). Packages of architecture `all` are listed only under `binary-all`, as in Gitea. Then it writes `dists/<distribution>/Release`, its armored detached signature `Release.gpg` and the cleartext-signed `InRelease` (`pointer` files). `distribution` and `component` must match `^[a-zA-Z0-9][a-zA-Z0-9.~+_-]*$`; `origin` and `label` are each one non-empty line without surrounding whitespace. Your route serves:
+`buildDebianIndex` returns the complete set for one distribution. For every component and architecture with packages it writes `dists/<distribution>/<component>/binary-<architecture>/Packages`, `Packages.gz` and `Packages.xz` (`content` files). Packages of architecture `all` are listed only under `binary-all`, as in Gitea. Then it writes `dists/<distribution>/Release`, its armored detached signature `Release.gpg` and the cleartext-signed `InRelease` (`pointer` files). `distribution` and `component` must match `^[a-zA-Z0-9][a-zA-Z0-9.~+_-]*$` (`isDebianSymbol`); `origin` and `label` are each one non-empty line without surrounding whitespace (`isDebianReleaseValue`). Both predicates are the builder's own rules, for checking configuration before a build. Entries are `IDebianIndexEntry` objects (`{ component, record }`). Your route serves:
 
 - every file at its `path` and at each of its `aliases`, `by-hash/MD5Sum`, `SHA1`, `SHA256` and `SHA512/<hex>` next to the `Packages` file. `Release` sets `Acquire-By-Hash: yes`, and apt 2.6 and 3.x fetch `Packages.xz` through `by-hash/SHA512/<hex>`;
 - each package file at `pool/<distribution>/<component>/<fileName>`, the `Filename:` its stanza names;

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartlinuxrepo',
-  version: '1.0.0',
+  version: '1.1.1',
   description: 'A pure codec for Linux package repositories (Alpine apk, Debian apt, RPM dnf, Arch pacman): read packages into records, build index file sets and sign them.'
 }

package/ts/debian/control.ts

@@ -1,7 +1,9 @@
+import { isIndexableArchitecture } from '../shared/architecture.js';
 import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
 import { isValidUrl } from '../shared/url.js';
 import type { IDebianPackageMetadata } from '../shared/types.js';
 import { fromByteString, goTrimSpace, toByteString } from './gostring.js';
+import { hasPoolFileNameRefusedCharacter } from './rules.js';
 import { parseMailAddress } from './mailaddress.js';
 
 /**
@@ -11,8 +13,6 @@ import { parseMailAddress } from './mailaddress.js';
  */
 const NAME_PATTERN = /^[a-z0-9][a-z0-9+-.]+$/;
 const VERSION_PATTERN = /^(?:(0|[1-9][0-9]*):)?[a-zA-Z0-9.+~]+(?:-[a-zA-Z0-9.+-~]+)?$/;
-/** Gitea's distribution and component rule (`metadata.go:67`, applied at upload). */
-export const DEBIAN_SYMBOL_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9.~+_-]*$/;
 
 export interface IDebianControl {
   name: string;
@@ -31,7 +31,13 @@ export interface IDebianControl {
  * verbatim, and the Depends text split on `,` (`['']` when there is none).
  *
  * Gitea's scanner refuses lines over 64 KiB; the codec accepts lines up to
- * `maxLineBytes` (`maxHeaderBytes`), which is at least that.
+ * `maxLineBytes` (`maxHeaderBytes`), which is at least that. A version that
+ * matches Gitea's pattern but holds `/` or `?` (both inside the revision's
+ * range) is refused with `invalid-field` (`Version`): no pool file name can
+ * hold it (`hasPoolFileNameRefusedCharacter`), where Gitea accepts the upload
+ * and then cannot serve it. An Architecture that fails `isIndexableArchitecture`
+ * or `hasPoolFileNameRefusedCharacter` (decoded) is refused with
+ * `invalid-field` (`Architecture`), where Gitea accepts any non-empty value.
  */
 export function parseDebianControlFile(bytesArg: Uint8Array, maxLineBytesArg: number): IDebianControl {
   const text = toByteString(bytesArg);
@@ -123,7 +129,10 @@ export function parseDebianControlFile(bytesArg: Uint8Array, maxLineBytesArg: nu
   if (version === '') {
     throw new LinuxRepoError('missing-field', 'the control file has no Version field', { field: 'Version' });
   }
-  if (!VERSION_PATTERN.test(version)) {
+  // a departure from Gitea's version pattern: the revision range admits
+  // `/` and `?`, which the pool file name cannot hold, so the version is
+  // refused here rather than by buildDebianIndex
+  if (!VERSION_PATTERN.test(version) || hasPoolFileNameRefusedCharacter(version)) {
     throw new LinuxRepoError('invalid-field', 'the package version is invalid', {
       field: 'Version',
       value: fromByteString(version),
@@ -134,11 +143,22 @@ export function parseDebianControlFile(bytesArg: Uint8Array, maxLineBytesArg: nu
       field: 'Architecture',
     });
   }
+  // a departure from Gitea, which accepts any non-empty Architecture: the
+  // file name embeds it, so it must pass the builder's rules; checked on the
+  // decoded text the record carries (on the byte string, `\s` and `\p{Cc}`
+  // would match the UTF-8 continuation bytes 0x85 and 0xA0)
+  const decodedArchitecture = fromByteString(architecture);
+  if (!isIndexableArchitecture(decodedArchitecture) || hasPoolFileNameRefusedCharacter(decodedArchitecture)) {
+    throw new LinuxRepoError('invalid-field', 'the package architecture cannot name an index path or pool file', {
+      field: 'Architecture',
+      value: decodedArchitecture,
+    });
+  }
 
   return {
     name,
     version,
-    architecture: fromByteString(architecture),
+    architecture: decodedArchitecture,
     metadata: {
       control: fromByteString(goTrimSpace(control)),
       maintainer: fromByteString(maintainer),

package/ts/debian/indexbuilder.ts

@@ -2,11 +2,11 @@ import * as plugins from '../plugins.js';
 import { isIndexableArchitecture } from '../shared/architecture.js';
 import { LinuxRepoError } from '../shared/errors.js';
 import type { IDebianPackageRecord, ILinuxIndexFile } from '../shared/types.js';
-import { assertSegmentName, assertString, assertTimestamp, hasControlCharacter } from '../shared/validation.js';
+import { assertString, assertTimestamp } from '../shared/validation.js';
 import type { IOpenPgpSigner } from '../signing/signers.js';
 import { createCleartextSignedMessage, createDetachedArmoredSignature } from '../signing/openpgpframing.js';
-import { DEBIAN_SYMBOL_PATTERN } from './control.js';
 import { compareUtf8, goTrimSpace, utf8ByteString } from './gostring.js';
+import { DEBIAN_SYMBOL_PATTERN, hasPoolFileNameRefusedCharacter, isDebianReleaseValue, isDebianSymbol } from './rules.js';
 
 /** The fields the `Packages` stanza writes itself; a control file's own copies are dropped. */
 const INDEX_OWNED_FIELDS = new Set(['filename', 'size', 'md5sum', 'sha1', 'sha256', 'sha512']);
@@ -29,6 +29,7 @@ const HASH_PATTERNS = {
   sha512: /^[0-9a-f]{128}$/,
 };
 
+/** One package of a distribution's index: the record and the component it is listed under. */
 export interface IDebianIndexEntry {
   component: string;
   record: IDebianPackageRecord;
@@ -52,7 +53,7 @@ export interface IDebianIndexEntry {
  */
 export async function buildDebianIndex(input: {
   distribution: string;
-  entries: Array<{ component: string; record: IDebianPackageRecord }>;
+  entries: IDebianIndexEntry[];
   origin: string;
   label: string;
   signer: IOpenPgpSigner;
@@ -233,7 +234,8 @@ export function renderDebianPackagesStanza(input: {
 
 /**
  * Refuses a record the index cannot list: wrong format, an architecture that
- * is not a path segment, a file name that is not one, digests that are not
+ * is not a path segment, a file name apt cannot fetch as one pool path
+ * segment (`hasPoolFileNameRefusedCharacter`), digests that are not
  * hex of the right length, or a control text that is not one stanza (empty,
  * or holding a blank line that would start another stanza).
  */
@@ -248,12 +250,13 @@ function assertRecord(recordArg: IDebianPackageRecord): void {
       { field: 'record.architecture', value: String(recordArg.fileName) },
     );
   }
-  assertSegmentName(recordArg.fileName, 'record.fileName');
-  if (/\s/.test(recordArg.fileName)) {
-    throw new LinuxRepoError('invalid-input', 'record.fileName must not contain whitespace', {
-      field: 'record.fileName',
-      value: recordArg.fileName,
-    });
+  assertString(recordArg.fileName, 'record.fileName');
+  if (recordArg.fileName === '' || hasPoolFileNameRefusedCharacter(recordArg.fileName)) {
+    throw new LinuxRepoError(
+      'invalid-input',
+      'record.fileName must be non-empty and contain no "/", "#", "?", whitespace or control characters',
+      { field: 'record.fileName', value: recordArg.fileName },
+    );
   }
   const digests = recordArg.digests;
   if (digests === null || typeof digests !== 'object' || !Number.isSafeInteger(digests.size) || digests.size < 0) {
@@ -282,7 +285,7 @@ function assertRecord(recordArg: IDebianPackageRecord): void {
 
 function assertSymbol(valueArg: unknown, fieldArg: string): asserts valueArg is string {
   assertString(valueArg, fieldArg);
-  if (!DEBIAN_SYMBOL_PATTERN.test(valueArg)) {
+  if (!isDebianSymbol(valueArg)) {
     throw new LinuxRepoError('invalid-input', `${fieldArg} must match ${DEBIAN_SYMBOL_PATTERN.source}`, {
       field: fieldArg,
       value: valueArg,
@@ -293,7 +296,7 @@ function assertSymbol(valueArg: unknown, fieldArg: string): asserts valueArg is
 /** A Release header value: one line, non-empty, no leading or trailing whitespace (canonical cleartext). */
 function assertReleaseValue(valueArg: unknown, fieldArg: string): asserts valueArg is string {
   assertString(valueArg, fieldArg);
-  if (valueArg === '' || hasControlCharacter(valueArg) || valueArg !== valueArg.trim()) {
+  if (!isDebianReleaseValue(valueArg)) {
     throw new LinuxRepoError(
       'invalid-input',
       `${fieldArg} must be non-empty, without control characters or surrounding whitespace`,

package/ts/debian/rules.ts

@@ -0,0 +1,44 @@
+import { hasControlCharacter } from '../shared/validation.js';
+
+/** Gitea's distribution and component rule (`modules/packages/debian/metadata.go:67`, applied at upload). */
+export const DEBIAN_SYMBOL_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9.~+_-]*$/;
+
+/**
+ * Whether a value is a distribution or component name `buildDebianIndex`
+ * accepts: Gitea's rule, `^[a-zA-Z0-9][a-zA-Z0-9.~+_-]*$`. A non-string is
+ * not one.
+ */
+export function isDebianSymbol(valueArg: string): boolean {
+  return typeof valueArg === 'string' && DEBIAN_SYMBOL_PATTERN.test(valueArg);
+}
+
+/**
+ * Whether a value can be a Release header value (`Origin`, `Label`) that
+ * `buildDebianIndex` accepts: non-empty, no control characters (so one line)
+ * and no leading or trailing whitespace (canonical cleartext). A non-string
+ * is not one.
+ */
+export function isDebianReleaseValue(valueArg: string): boolean {
+  return typeof valueArg === 'string' && valueArg !== '' && !hasControlCharacter(valueArg) && valueArg === valueArg.trim();
+}
+
+/**
+ * The characters a pool file name (`<name>_<version>_<architecture>.deb`,
+ * written as a `Packages` `Filename`) must not hold: `/`, which would make it
+ * more than one path segment; whitespace and control characters, which split
+ * or end the field; and `#` and `?`, which apt sends unescaped in the request
+ * path (apt 2.6.1 `pkgAcquire::URIEncode` escapes only `%`, `+`, `~`, space,
+ * control and non-ASCII bytes), so a server reads the rest as a fragment or a
+ * query and apt cannot fetch the file.
+ */
+const POOL_FILE_NAME_REFUSED_PATTERN = /[/#?\s\p{Cc}]/u;
+
+/**
+ * Whether a text holds a character a pool file name must not hold. The one
+ * rule both `buildDebianIndex` (on `record.fileName`) and `readDebianPackage`
+ * (on the version and the decoded architecture) apply, so the reader never
+ * returns a record the builder refuses for its file name.
+ */
+export function hasPoolFileNameRefusedCharacter(textArg: string): boolean {
+  return POOL_FILE_NAME_REFUSED_PATTERN.test(textArg);
+}

package/ts/index.ts

@@ -29,10 +29,19 @@ export type { TLinuxRepoErrorCode, ILinuxRepoErrorDetail } from './shared/errors
 export { isIndexableArchitecture } from './shared/architecture.js';
 export { createAlpineSigner, createOpenPgpSigner } from './signing/signers.js';
 export type { IAlpineSigner, IOpenPgpSigner } from './signing/signers.js';
+export { createOpenPgpVerifier } from './signing/verifiers.js';
+export type {
+  IOpenPgpCleartextVerification,
+  IOpenPgpSignatureVerification,
+  IOpenPgpVerifier,
+  TOpenPgpHashAlgorithm,
+} from './signing/verifiers.js';
 export { generateAlpineKeyPair, generateOpenPgpKeyPair, giteaAlpineKeyName } from './signing/keys.js';
 export type { IAlpineKeyPair, IOpenPgpKeyPair } from './signing/keys.js';
 export { readDebianPackage } from './debian/reader.js';
 export { buildDebianIndex } from './debian/indexbuilder.js';
+export type { IDebianIndexEntry } from './debian/indexbuilder.js';
+export { isDebianReleaseValue, isDebianSymbol } from './debian/rules.js';
 export { readRpmPackage } from './rpm/reader.js';
 export { signRpmPackage } from './rpm/sign.js';
 export { buildRpmIndex } from './rpm/builder.js';

package/ts/readers/text.ts

@@ -81,6 +81,15 @@ function decodeGoUtf8Slow(bytesArg: Uint8Array): string {
   return parts.join('');
 }
 
+/** Decodes strict UTF-8, keeping a leading BOM; `null` when any sequence is invalid. */
+export function decodeStrictUtf8(bytesArg: Uint8Array): string | null {
+  try {
+    return strictUtf8.decode(bytesArg);
+  } catch {
+    return null;
+  }
+}
+
 /** ASCII/Latin-1 view of header bytes (magic values, numeric fields). */
 export function decodeLatin1(bytesArg: Uint8Array): string {
   let text = '';

package/ts/shared/architecture.ts

@@ -2,7 +2,11 @@
  * Whether an architecture can name an index path segment. Readers record any
  * architecture a package states (Gitea accepts them); builders refuse an entry
  * whose architecture fails this rule with `invalid-input`, and never skip it
- * silently. Refused: the empty string, `.` and `..`, and any value containing
+ * silently. The exception is `readDebianPackage`: the record's file name
+ * (`<name>_<version>_<architecture>.deb`) embeds the architecture, so it
+ * refuses one that fails this rule or the pool file name rule with
+ * `invalid-field` (`Architecture`), and never returns a record
+ * `buildDebianIndex` refuses. Refused: the empty string, `.` and `..`, and any value containing
  * `/`, whitespace or a control character.
  */
 export function isIndexableArchitecture(architectureArg: string): boolean {