@push.rocks/smartlinuxrepo 1.0.0 → 1.1.0

package/dist_ts/signing/openpgpframing.js

@@ -1,3 +1,4 @@
+import { decodeLatin1, decodeStrictUtf8 } from '../readers/text.js';
 import { LinuxRepoError } from '../shared/errors.js';
 import { assertAsyncIterable, assertBytes, assertString, assertTimestamp } from '../shared/validation.js';
 import { singleChunk } from './signers.js';
@@ -5,6 +6,10 @@ 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.
+ *
+ * The readers below are the strict inverses the verifier uses; openpgp.js's
+ * own dearmoring is never used (it skips text around the block, ignores the
+ * CRC-24 and strips trailing whitespace inside cleartext).
  */
 const BASE64_LINE = 64;
 /**
@@ -32,7 +37,7 @@ export async function createDetachedArmoredSignature(inputArg) {
  * 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
+ * before the signature block, as GnuPG does. Lines starting with `-` are
  * dash-escaped. The header is always `Hash: SHA256`.
  */
 export async function createCleartextSignedMessage(inputArg) {
@@ -75,6 +80,272 @@ function assertSignatureBytes(packetArg) {
         throw new LinuxRepoError('signing-failed', 'the signer returned no signature bytes', { field: 'signer' });
     }
 }
+/** A well-formed armor header line (`Key: Value`), as openpgp.js 6.3.2 checks it (`verifyHeaders$1`). */
+const ARMOR_HEADER_PATTERN = /^([^\s:]|[^\s:][^:]*[^\s:]): .+$/;
+const BASE64_LINE_PATTERN = /^[A-Za-z0-9+/]+={0,2}$/;
+const BASE64_PATTERN = /^[A-Za-z0-9+/]*={0,2}$/;
+const CRC_LINE_PATTERN = /^=[A-Za-z0-9+/]{4}$/;
+const CLEARTEXT_BEGIN = '-----BEGIN PGP SIGNED MESSAGE-----';
+const SIGNATURE_BEGIN = '-----BEGIN PGP SIGNATURE-----';
+/** RFC 9580 table 23 hash text names (the `Hash:` header) and their algorithm IDs. */
+const HASH_TEXT_NAMES = new Map([
+    ['MD5', 1],
+    ['SHA1', 2],
+    ['RIPEMD160', 3],
+    ['SHA256', 8],
+    ['SHA384', 9],
+    ['SHA512', 10],
+    ['SHA224', 11],
+    ['SHA3-256', 12],
+    ['SHA3-512', 14],
+]);
+function framingError(failureArg, messageArg) {
+    return new LinuxRepoError(failureArg.code, messageArg, { field: failureArg.field });
+}
+/** Bytes that must be ASCII armor, as text; any byte above 0x7F is refused. */
+export function decodeArmorBytes(bytesArg, failureArg) {
+    for (let i = 0; i < bytesArg.length; i++) {
+        if (bytesArg[i] > 0x7f) {
+            throw framingError(failureArg, 'ASCII armor must be ASCII');
+        }
+    }
+    return decodeLatin1(bytesArg);
+}
+/**
+ * Reads exactly one ASCII armor block labelled `labelArg` (RFC 9580 section
+ * 6.2) and returns its bytes; the inverse of `armorSignature`. Lines may end
+ * in LF or CRLF and carry trailing spaces or tabs, and blank lines may
+ * surround the block. Well-formed `Key: Value` headers are ignored; the
+ * CRC-24 line is optional and must match when present. Refused with
+ * `failureArg`: non-ASCII text, another label, a second block or any other
+ * text outside the block, a malformed header line, no blank line before the
+ * data, base64 that is not canonical, no data, and a CRC-24 that does not
+ * match.
+ */
+export function dearmor(textArg, labelArg, failureArg) {
+    const lines = textArg.split('\n').map(trimLineEnd);
+    let first = 0;
+    while (first < lines.length && lines[first] === '') {
+        first += 1;
+    }
+    let last = lines.length - 1;
+    while (last >= first && lines[last] === '') {
+        last -= 1;
+    }
+    return readArmorBlock(lines.slice(first, last + 1), labelArg, failureArg);
+}
+/** The line without trailing spaces, tabs and CRs; a loop, as a `+$` regex is quadratic on a long run of them. */
+function trimLineEnd(lineArg) {
+    let end = lineArg.length;
+    while (end > 0 && (lineArg[end - 1] === ' ' || lineArg[end - 1] === '\t' || lineArg[end - 1] === '\r')) {
+        end -= 1;
+    }
+    return lineArg.slice(0, end);
+}
+/** One armor block, from its BEGIN line to its END line, as exactly these lines; ASCII only. */
+function readArmorBlock(linesArg, labelArg, failureArg) {
+    if (linesArg.some((line) => !/^[\x00-\x7f]*$/.test(line))) {
+        throw framingError(failureArg, 'ASCII armor must be ASCII');
+    }
+    const begin = `-----BEGIN PGP ${labelArg}-----`;
+    const end = `-----END PGP ${labelArg}-----`;
+    if (linesArg[0] !== begin) {
+        throw framingError(failureArg, `expected exactly one ${begin} block and nothing else`);
+    }
+    const endIndex = linesArg.indexOf(end);
+    if (endIndex < 0 || endIndex !== linesArg.length - 1) {
+        throw framingError(failureArg, `expected exactly one ${begin} block ending in ${end} and nothing else`);
+    }
+    let index = 1;
+    for (; index < endIndex && linesArg[index] !== ''; index++) {
+        if (!ARMOR_HEADER_PATTERN.test(linesArg[index])) {
+            throw framingError(failureArg, 'malformed armor header line');
+        }
+    }
+    if (index >= endIndex) {
+        throw framingError(failureArg, 'the armor has no blank line before its data');
+    }
+    index += 1;
+    const dataLines = [];
+    let crcLine = null;
+    for (; index < endIndex; index++) {
+        const line = linesArg[index];
+        if (index === endIndex - 1 && line.startsWith('=')) {
+            crcLine = line;
+            break;
+        }
+        if (!BASE64_LINE_PATTERN.test(line)) {
+            throw framingError(failureArg, 'the armor data is not base64');
+        }
+        dataLines.push(line);
+    }
+    const base64 = dataLines.join('');
+    if (base64.length === 0 || base64.length % 4 !== 0 || !BASE64_PATTERN.test(base64)) {
+        throw framingError(failureArg, 'the armor data is not one base64 string');
+    }
+    const decoded = Buffer.from(base64, 'base64');
+    if (decoded.toString('base64') !== base64) {
+        throw framingError(failureArg, 'the armor data is not canonical base64');
+    }
+    const bytes = new Uint8Array(decoded.buffer, decoded.byteOffset, decoded.byteLength);
+    if (crcLine !== null && (!CRC_LINE_PATTERN.test(crcLine) || crcLine.slice(1) !== crc24Base64(bytes))) {
+        throw framingError(failureArg, 'the armor CRC-24 does not match its data');
+    }
+    return bytes;
+}
+/**
+ * The packet tags of a binary OpenPGP packet sequence, read from the packet
+ * headers alone (RFC 9580 section 4.2); no body is parsed. openpgp.js skips
+ * marker, trust and padding packets and unknown non-critical packet types
+ * without a trace (`PacketList.read`, `dist/node/openpgp.mjs:12320-12385`),
+ * so the verifier counts packets here. Refused with `failureArg`: a header
+ * without its high bit, a partial body length (no key or signature packet
+ * may use one), and input that ends inside a header or a body.
+ */
+export function readPacketTags(bytesArg, failureArg) {
+    const tags = [];
+    let offset = 0;
+    while (offset < bytesArg.length) {
+        const ctb = bytesArg[offset];
+        if ((ctb & 0x80) === 0) {
+            throw framingError(failureArg, `no OpenPGP packet header at byte ${offset}`);
+        }
+        let tag;
+        let headerLength;
+        let bodyLength;
+        if ((ctb & 0x40) !== 0) {
+            tag = ctb & 0x3f;
+            const first = bytesArg[offset + 1];
+            if (first === undefined) {
+                throw framingError(failureArg, 'the input ends inside a packet header');
+            }
+            if (first < 192) {
+                headerLength = 2;
+                bodyLength = first;
+            }
+            else if (first < 224) {
+                if (offset + 3 > bytesArg.length) {
+                    throw framingError(failureArg, 'the input ends inside a packet header');
+                }
+                headerLength = 3;
+                bodyLength = (first - 192) * 256 + bytesArg[offset + 2] + 192;
+            }
+            else if (first === 255) {
+                if (offset + 6 > bytesArg.length) {
+                    throw framingError(failureArg, 'the input ends inside a packet header');
+                }
+                headerLength = 6;
+                bodyLength = readUint32(bytesArg, offset + 2);
+            }
+            else {
+                throw framingError(failureArg, 'a partial body length is not allowed here');
+            }
+        }
+        else {
+            tag = (ctb >> 2) & 0x0f;
+            const lengthType = ctb & 0x03;
+            if (lengthType === 3) {
+                // indeterminate length: the packet runs to the end of the input
+                headerLength = 1;
+                bodyLength = bytesArg.length - offset - 1;
+            }
+            else {
+                const lengthBytes = 1 << lengthType;
+                if (offset + 1 + lengthBytes > bytesArg.length) {
+                    throw framingError(failureArg, 'the input ends inside a packet header');
+                }
+                headerLength = 1 + lengthBytes;
+                bodyLength = 0;
+                for (let i = 0; i < lengthBytes; i++) {
+                    bodyLength = bodyLength * 256 + bytesArg[offset + 1 + i];
+                }
+            }
+        }
+        const packetEnd = offset + headerLength + bodyLength;
+        if (packetEnd > bytesArg.length) {
+            throw framingError(failureArg, 'the input ends inside a packet');
+        }
+        tags.push(tag);
+        offset = packetEnd;
+    }
+    return tags;
+}
+function readUint32(bytesArg, offsetArg) {
+    return ((bytesArg[offsetArg] * 256 + bytesArg[offsetArg + 1]) * 256 + bytesArg[offsetArg + 2]) * 256 + bytesArg[offsetArg + 3];
+}
+/**
+ * Splits a cleartext-signed message (`InRelease`, RFC 9580 section 7); the
+ * inverse of `createCleartextSignedMessage`, and as strict as apt's own split
+ * (apt-pkg `SplitClearSignedFile`). The message is strict UTF-8 with LF line
+ * endings: the first line is `-----BEGIN PGP SIGNED MESSAGE-----`, then
+ * optional `Hash:` headers (comma-separated RFC 9580 text names), a blank
+ * line, the dash-escaped text and exactly one signature armor block, which
+ * may be followed by one line break and nothing else. Refused with
+ * `failureArg`: invalid UTF-8, a CR, a line ending in a space or tab, text
+ * before the message block or after the signature block, any other header, an
+ * unknown hash name, a text line starting with `-` but not `- `, and an empty
+ * text section. Armor headers inside the signature block are ignored as in
+ * `dearmor`.
+ */
+export function splitCleartextSignedMessage(bytesArg, failureArg) {
+    const text = decodeStrictUtf8(bytesArg);
+    if (text === null) {
+        throw framingError(failureArg, 'the cleartext-signed message is not valid UTF-8');
+    }
+    if (text.includes('\r')) {
+        throw framingError(failureArg, 'the cleartext-signed message must use LF line endings');
+    }
+    const lines = text.split('\n');
+    if (lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    if (lines.some((line) => /[ \t]$/.test(line))) {
+        throw framingError(failureArg, 'a line of the cleartext-signed message ends with a space or tab');
+    }
+    if (lines[0] !== CLEARTEXT_BEGIN) {
+        throw framingError(failureArg, `the message does not start with ${CLEARTEXT_BEGIN}`);
+    }
+    let index = 1;
+    const headerHashAlgorithms = [];
+    for (; index < lines.length && lines[index] !== ''; index++) {
+        const header = /^Hash: (.+)$/.exec(lines[index]);
+        if (header === null) {
+            throw framingError(failureArg, 'only Hash: headers are allowed in a cleartext-signed message');
+        }
+        for (const name of header[1].split(',')) {
+            const algorithm = HASH_TEXT_NAMES.get(name.trim());
+            if (algorithm === undefined) {
+                throw framingError(failureArg, `unknown hash name in the Hash: header: ${name.trim()}`);
+            }
+            headerHashAlgorithms.push(algorithm);
+        }
+    }
+    index += 1;
+    const textLines = [];
+    for (; index < lines.length && lines[index] !== SIGNATURE_BEGIN; index++) {
+        const line = lines[index];
+        if (line.startsWith('-')) {
+            if (!line.startsWith('- ')) {
+                throw framingError(failureArg, 'a text line starts with "-" without the "- " escape');
+            }
+            textLines.push(line.slice(2));
+        }
+        else {
+            textLines.push(line);
+        }
+    }
+    if (index >= lines.length) {
+        throw framingError(failureArg, `the message has no ${SIGNATURE_BEGIN} block`);
+    }
+    if (textLines.length === 0) {
+        throw framingError(failureArg, 'the message has no text section');
+    }
+    return {
+        signedText: textLines.join('\n'),
+        headerHashAlgorithms,
+        signature: readArmorBlock(lines.slice(index), 'SIGNATURE', failureArg),
+    };
+}
 /** RFC 4880 section 6.1 CRC-24, base64-encoded. */
 function crc24Base64(bytesArg) {
     let crc = 0xb704ce;
@@ -90,4 +361,4 @@ function crc24Base64(bytesArg) {
     crc &= 0xffffff;
     return Buffer.from([(crc >> 16) & 0xff, (crc >> 8) & 0xff, crc & 0xff]).toString('base64');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openpgpframing.js","sourceRoot":"","sources":["../../ts/signing/openpgpframing.ts"],"names":[],"mappings":"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"}

package/dist_ts/signing/verifiers.d.ts

@@ -0,0 +1,77 @@
+/** The hash algorithms the verifier accepts. */
+export type TOpenPgpHashAlgorithm = 'sha256' | 'sha384' | 'sha512';
+/** A signature that verified. */
+export interface IOpenPgpSignatureVerification {
+    /** The primary key or subkey that verified the signature, 40 uppercase hex digits. */
+    readonly signingKeyFingerprint: string;
+    /** The signature's creation time (whole seconds). */
+    readonly created: Date;
+    readonly hashAlgorithm: TOpenPgpHashAlgorithm;
+}
+/** A cleartext-signed message that verified. */
+export interface IOpenPgpCleartextVerification extends IOpenPgpSignatureVerification {
+    /**
+     * The signed text: dash-escaping removed, lines joined by LF, without the
+     * line break before the signature block (RFC 9580 section 7.1). For
+     * GnuPG's and the codec's `InRelease` this is `Release` without its final
+     * line break; for Gitea 28.2.0's (go-crypto) it is the whole `Release`.
+     */
+    readonly signedText: string;
+}
+/**
+ * Verifies OpenPGP signatures against one public key. Every method fails
+ * closed with a `LinuxRepoError` and never returns a verdict of failure:
+ * `malformed-signature`, `wrong-key`, `unusable-key` or `bad-signature`
+ * (bad arguments are `invalid-input`).
+ *
+ * A signature is valid when it is exactly one OpenPGP v4 signature packet,
+ * 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 or subkey that can sign both at the signature's creation time and at
+ * `date` (not expired, not revoked, sign flag set, valid binding and
+ * back-signature, openpgp.js's algorithm floor), and when it verifies
+ * cryptographically. `date` is required; the codec reads no clock.
+ */
+export interface IOpenPgpVerifier {
+    /** The primary key's v4 fingerprint, 40 uppercase hex digits (as `IOpenPgpKeyPair.fingerprint`). */
+    readonly fingerprint: string;
+    /**
+     * A binary detached signature of type 0x00 over `data`: the packet
+     * `IOpenPgpSigner.signBinary` returns, an Arch `.sig`.
+     */
+    verifyDetachedSignature(inputArg: {
+        data: Uint8Array;
+        signature: Uint8Array;
+        date: Date;
+    }): Promise<IOpenPgpSignatureVerification>;
+    /**
+     * An armored detached signature of type 0x00 over `data`: `Release.gpg`,
+     * `repomd.xml.asc`. The armor is ASCII.
+     */
+    verifyArmoredDetachedSignature(inputArg: {
+        data: Uint8Array;
+        signatureArmored: Uint8Array;
+        date: Date;
+    }): Promise<IOpenPgpSignatureVerification>;
+    /**
+     * A cleartext-signed message with a signature of type 0x01: `InRelease`.
+     * The message is strict UTF-8 with LF line endings; see
+     * `splitCleartextSignedMessage` for what its framing may hold.
+     */
+    verifyCleartextMessage(inputArg: {
+        message: Uint8Array;
+        date: Date;
+    }): Promise<IOpenPgpCleartextVerification>;
+}
+/**
+ * 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 declare function createOpenPgpVerifier(inputArg: {
+    publicKeyArmored: string;
+}): Promise<IOpenPgpVerifier>;