@push.rocks/smartlinuxrepo 0.0.0-stage → 1.0.0

package/ts/shared/url.ts

@@ -0,0 +1,387 @@
+/**
+ * Gitea 28.2.0's URL check for package metadata (`validation.IsValidURL`,
+ * `modules/validation/helpers.go:42-50`): Go 1.27's `url.ParseRequestURI`
+ * succeeds, the scheme is `http` or `https` (case-insensitive), and the host's
+ * port part holds only digits (`portOnly`/`validPort`,
+ * `modules/validation/binding.go:131-152`; no range check, an empty port
+ * passes). Readers keep a URL field only when this returns true.
+ *
+ * The port follows Go's `net/url` byte for byte on the UTF-8 encoding of the
+ * value, including its quirks: `http:x` is an opaque URL and passes,
+ * `http://` (empty host) passes, a query or fragment is never validated, and a
+ * `#` before the first `/` is part of the host and fails. Only the parts of the
+ * parser that can change the result for `http`/`https` are ported. Expected
+ * values come from Go: `test/fixtures/url/isvalidurl.gitea.json`.
+ *
+ * Internal: not exported from the package entry.
+ */
+export function isValidUrl(valueArg: string): boolean {
+  if (typeof valueArg !== 'string') {
+    return false;
+  }
+  const raw = utf8.encode(valueArg);
+  // parse(): control characters anywhere, then the empty and `*` forms
+  if (raw.some((byte) => byte < 0x20 || byte === 0x7f) || raw.length === 0) {
+    return false;
+  }
+  const scheme = splitScheme(raw);
+  if (scheme === null) {
+    return false;
+  }
+  const schemeName = ascii(raw.subarray(0, scheme)).toLowerCase();
+  if (schemeName !== 'http' && schemeName !== 'https') {
+    return false;
+  }
+  let rest = raw.subarray(scheme + 1);
+  const questionMarks = count(rest, QUESTION);
+  if (questionMarks === 1 && rest[rest.length - 1] === QUESTION) {
+    rest = rest.subarray(0, rest.length - 1);
+  } else if (questionMarks > 0) {
+    rest = rest.subarray(0, rest.indexOf(QUESTION));
+  }
+  if (rest[0] !== SLASH) {
+    // a rootless path with a scheme is opaque and not validated further
+    return true;
+  }
+  let host: Uint8Array = new Uint8Array(0);
+  let path = rest;
+  if (rest[1] === SLASH) {
+    const slash = rest.indexOf(SLASH, 2);
+    const authority = slash < 0 ? rest.subarray(2) : rest.subarray(2, slash);
+    path = slash < 0 ? new Uint8Array(0) : rest.subarray(slash);
+    const parsedHost = parseAuthority(authority);
+    if (parsedHost === null) {
+      return false;
+    }
+    host = parsedHost;
+  }
+  if (unescape(path, 'other') === null) {
+    return false;
+  }
+  return isDigits(portOnly(host));
+}
+
+type TEscapeMode = 'host' | 'zone' | 'other';
+
+const utf8 = new TextEncoder();
+const SLASH = 0x2f;
+const QUESTION = 0x3f;
+const COLON = 0x3a;
+const PERCENT = 0x25;
+const AT = 0x40;
+const OPEN_BRACKET = 0x5b;
+const CLOSE_BRACKET = 0x5d;
+const DOT = 0x2e;
+
+/** Characters Go's `shouldEscape` leaves alone in a host besides alphanumerics and `-_.~`. */
+const HOST_SAFE = new Set([..."!$&'()*+,;=:[]<>\""].map((character) => character.charCodeAt(0)));
+/** Characters `validUserinfo` accepts besides alphanumerics. */
+const USERINFO_SAFE = new Set([..."-._:~!$&'()*+,;=%@"].map((character) => character.charCodeAt(0)));
+
+/** `getScheme`: the index of the scheme's colon, or `null` when there is no scheme or it is malformed. */
+function splitScheme(rawArg: Uint8Array): number | null {
+  for (let i = 0; i < rawArg.length; i++) {
+    const c = rawArg[i];
+    if (isAlpha(c)) {
+      continue;
+    }
+    if (isDigit(c) || c === 0x2b || c === 0x2d || c === DOT) {
+      if (i === 0) {
+        return null;
+      }
+      continue;
+    }
+    return c === COLON && i > 0 ? i : null;
+  }
+  return null;
+}
+
+/** `parseAuthority`: the unescaped host, or `null` on a parse error. */
+function parseAuthority(authorityArg: Uint8Array): Uint8Array | null {
+  const at = authorityArg.lastIndexOf(AT);
+  const host = parseHost(at < 0 ? authorityArg : authorityArg.subarray(at + 1));
+  if (host === null || at < 0) {
+    return host;
+  }
+  const userinfo = authorityArg.subarray(0, at);
+  // validUserinfo iterates runes: any byte >= 0x80 is a rune outside the allowed set
+  if (!userinfo.every((byte) => isAlpha(byte) || isDigit(byte) || USERINFO_SAFE.has(byte))) {
+    return null;
+  }
+  const colon = userinfo.indexOf(COLON);
+  const parts = colon < 0 ? [userinfo] : [userinfo.subarray(0, colon), userinfo.subarray(colon + 1)];
+  return parts.every((part) => unescape(part, 'other') !== null) ? host : null;
+}
+
+/** `parseHost` for `http`/`https` (strict colons, the Go 1.26+ default Gitea's go.mod selects). */
+function parseHost(hostArg: Uint8Array): Uint8Array | null {
+  const openBracket = hostArg.lastIndexOf(OPEN_BRACKET);
+  if (openBracket > 0) {
+    return null;
+  }
+  if (openBracket === 0) {
+    const closeBracket = hostArg.lastIndexOf(CLOSE_BRACKET);
+    if (closeBracket < 0) {
+      return null;
+    }
+    const colonPort = hostArg.subarray(closeBracket + 1);
+    if (!isOptionalPort(colonPort)) {
+      return null;
+    }
+    const hostname = hostArg.subarray(1, closeBracket);
+    const zone = indexOfZone(hostname);
+    let unescapedHostname: Uint8Array | null;
+    if (zone >= 0) {
+      const hostPart = unescape(hostname.subarray(0, zone), 'host');
+      const zonePart = unescape(hostname.subarray(zone), 'zone');
+      unescapedHostname = hostPart === null || zonePart === null ? null : concat(hostPart, zonePart);
+    } else {
+      unescapedHostname = unescape(hostname, 'host');
+    }
+    // only an IPv6 address may sit in brackets (netip.ParseAddr, then !Is4)
+    if (unescapedHostname === null || !isIpv6Address(unescapedHostname)) {
+      return null;
+    }
+    return concat(Uint8Array.of(OPEN_BRACKET), unescapedHostname, Uint8Array.of(CLOSE_BRACKET), colonPort);
+  }
+  const colon = hostArg.indexOf(COLON);
+  if (colon >= 0 && !isOptionalPort(hostArg.subarray(colon))) {
+    return null;
+  }
+  return unescape(hostArg, 'host');
+}
+
+/** Go's `unescape` for the path, userinfo, host and zone modes; `null` on an invalid escape or host byte. */
+function unescape(bytesArg: Uint8Array, modeArg: TEscapeMode): Uint8Array | null {
+  let escapes = 0;
+  for (let i = 0; i < bytesArg.length; ) {
+    const c = bytesArg[i];
+    if (c === PERCENT) {
+      escapes++;
+      if (i + 2 >= bytesArg.length || !isHex(bytesArg[i + 1]) || !isHex(bytesArg[i + 2])) {
+        return null;
+      }
+      const isPercentEscape = bytesArg[i + 1] === 0x32 && bytesArg[i + 2] === 0x35;
+      if (modeArg === 'host' && unhex(bytesArg[i + 1]) < 8 && !isPercentEscape) {
+        return null;
+      }
+      if (modeArg === 'zone') {
+        const value = (unhex(bytesArg[i + 1]) << 4) | unhex(bytesArg[i + 2]);
+        if (!isPercentEscape && value !== 0x20 && shouldEscapeInHost(value)) {
+          return null;
+        }
+      }
+      i += 3;
+      continue;
+    }
+    if (modeArg !== 'other' && c < 0x80 && shouldEscapeInHost(c)) {
+      return null;
+    }
+    i++;
+  }
+  if (escapes === 0) {
+    return bytesArg;
+  }
+  const result = new Uint8Array(bytesArg.length - 2 * escapes);
+  let length = 0;
+  for (let i = 0; i < bytesArg.length; i++) {
+    if (bytesArg[i] === PERCENT) {
+      result[length++] = (unhex(bytesArg[i + 1]) << 4) | unhex(bytesArg[i + 2]);
+      i += 2;
+    } else {
+      result[length++] = bytesArg[i];
+    }
+  }
+  return result;
+}
+
+/** Go's `shouldEscape(c, encodeHost)` (identical for `encodeZone`). */
+function shouldEscapeInHost(cArg: number): boolean {
+  if (isAlpha(cArg) || isDigit(cArg)) {
+    return false;
+  }
+  return !(HOST_SAFE.has(cArg) || cArg === 0x2d || cArg === 0x5f || cArg === DOT || cArg === 0x7e);
+}
+
+/** Index of the first `%25` (the RFC 6874 zone introducer), or -1. */
+function indexOfZone(bytesArg: Uint8Array): number {
+  for (let i = 0; i + 2 < bytesArg.length; i++) {
+    if (bytesArg[i] === PERCENT && bytesArg[i + 1] === 0x32 && bytesArg[i + 2] === 0x35) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Whether `netip.ParseAddr` parses the bytes as an IPv6 address (with an
+ * optional non-empty zone). An input whose first `.`, `:` or `%` is not `:` is
+ * an IPv4 address or an error, both refused in brackets.
+ */
+function isIpv6Address(bytesArg: Uint8Array): boolean {
+  const first = bytesArg.findIndex((byte) => byte === DOT || byte === COLON || byte === PERCENT);
+  if (first < 0 || bytesArg[first] !== COLON) {
+    return false;
+  }
+  let s = bytesArg;
+  const zone = s.indexOf(PERCENT);
+  if (zone >= 0) {
+    if (zone === s.length - 1) {
+      return false;
+    }
+    s = s.subarray(0, zone);
+  }
+  let ellipsis = -1;
+  if (s.length >= 2 && s[0] === COLON && s[1] === COLON) {
+    ellipsis = 0;
+    s = s.subarray(2);
+    if (s.length === 0) {
+      return true;
+    }
+  }
+  let i = 0;
+  while (i < 16) {
+    let off = 0;
+    let acc = 0;
+    for (; off < s.length; off++) {
+      const c = s[off];
+      if (!isHex(c)) {
+        break;
+      }
+      acc = acc * 16 + unhex(c);
+      if (off > 3 || acc > 0xffff) {
+        return false;
+      }
+    }
+    if (off === 0) {
+      return false;
+    }
+    if (off < s.length && s[off] === DOT) {
+      if ((ellipsis < 0 && i !== 12) || i + 4 > 16 || !isIpv4Fields(s)) {
+        return false;
+      }
+      s = s.subarray(s.length);
+      i += 4;
+      break;
+    }
+    i += 2;
+    s = s.subarray(off);
+    if (s.length === 0) {
+      break;
+    }
+    if (s[0] !== COLON || s.length === 1) {
+      return false;
+    }
+    s = s.subarray(1);
+    if (s[0] === COLON) {
+      if (ellipsis >= 0) {
+        return false;
+      }
+      ellipsis = i;
+      s = s.subarray(1);
+      if (s.length === 0) {
+        break;
+      }
+    }
+  }
+  if (s.length !== 0) {
+    return false;
+  }
+  return i < 16 ? ellipsis >= 0 : ellipsis < 0;
+}
+
+/** `parseIPv4Fields`: four decimal octets without leading zeros. */
+function isIpv4Fields(bytesArg: Uint8Array): boolean {
+  let value = 0;
+  let digits = 0;
+  let dots = 0;
+  for (let i = 0; i < bytesArg.length; i++) {
+    const c = bytesArg[i];
+    if (isDigit(c)) {
+      if (digits === 1 && value === 0) {
+        return false;
+      }
+      value = value * 10 + (c - 0x30);
+      digits++;
+      if (value > 255) {
+        return false;
+      }
+    } else if (c === DOT) {
+      if (i === 0 || i === bytesArg.length - 1 || bytesArg[i - 1] === DOT || dots === 3) {
+        return false;
+      }
+      dots++;
+      value = 0;
+      digits = 0;
+    } else {
+      return false;
+    }
+  }
+  return dots === 3;
+}
+
+/** `validOptionalPort`: empty, or `:` followed by digits only. */
+function isOptionalPort(bytesArg: Uint8Array): boolean {
+  return bytesArg.length === 0 || (bytesArg[0] === COLON && isDigits(bytesArg.subarray(1)));
+}
+
+/** Gitea's `portOnly` on the parsed host. */
+function portOnly(hostArg: Uint8Array): Uint8Array {
+  const colon = hostArg.indexOf(COLON);
+  if (colon < 0) {
+    return new Uint8Array(0);
+  }
+  for (let i = 0; i + 1 < hostArg.length; i++) {
+    if (hostArg[i] === CLOSE_BRACKET && hostArg[i + 1] === COLON) {
+      return hostArg.subarray(i + 2);
+    }
+  }
+  if (hostArg.includes(CLOSE_BRACKET)) {
+    return new Uint8Array(0);
+  }
+  return hostArg.subarray(colon + 1);
+}
+
+function isDigits(bytesArg: Uint8Array): boolean {
+  return bytesArg.every(isDigit);
+}
+
+function isDigit(cArg: number): boolean {
+  return cArg >= 0x30 && cArg <= 0x39;
+}
+
+function isAlpha(cArg: number): boolean {
+  return (cArg >= 0x41 && cArg <= 0x5a) || (cArg >= 0x61 && cArg <= 0x7a);
+}
+
+function isHex(cArg: number): boolean {
+  return isDigit(cArg) || (cArg >= 0x41 && cArg <= 0x46) || (cArg >= 0x61 && cArg <= 0x66);
+}
+
+function unhex(cArg: number): number {
+  return isDigit(cArg) ? cArg - 0x30 : (cArg | 0x20) - 0x61 + 10;
+}
+
+function count(bytesArg: Uint8Array, byteArg: number): number {
+  let total = 0;
+  for (const byte of bytesArg) {
+    if (byte === byteArg) {
+      total++;
+    }
+  }
+  return total;
+}
+
+function ascii(bytesArg: Uint8Array): string {
+  return String.fromCharCode(...bytesArg);
+}
+
+function concat(...partsArg: Uint8Array[]): Uint8Array {
+  const result = new Uint8Array(partsArg.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of partsArg) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}

package/ts/shared/validation.ts

@@ -0,0 +1,71 @@
+import { LinuxRepoError } from './errors.js';
+
+/** The largest creation time an OpenPGP v4 packet can carry (seconds since the epoch). */
+const MAX_OPENPGP_SECONDS = 0xffffffff;
+
+/**
+ * Refuses anything but a valid `Date` whose whole seconds fit an OpenPGP v4
+ * time field (1970-01-01 to 2106-02-07).
+ */
+export function assertTimestamp(valueArg: unknown, fieldArg = 'timestamp'): asserts valueArg is Date {
+  if (!(valueArg instanceof Date) || !Number.isFinite(valueArg.getTime())) {
+    throw new LinuxRepoError('invalid-input', `${fieldArg} must be a valid Date`, { field: fieldArg });
+  }
+  const seconds = Math.floor(valueArg.getTime() / 1000);
+  if (seconds < 0 || seconds > MAX_OPENPGP_SECONDS) {
+    throw new LinuxRepoError('invalid-input', `${fieldArg} is outside 1970-01-01..2106-02-07`, {
+      field: fieldArg,
+    });
+  }
+}
+
+export function assertBytes(valueArg: unknown, fieldArg: string): asserts valueArg is Uint8Array {
+  if (!(valueArg instanceof Uint8Array)) {
+    throw new LinuxRepoError('invalid-input', `${fieldArg} must be a Uint8Array`, { field: fieldArg });
+  }
+}
+
+/** Refuses anything that is not an object with a `Symbol.asyncIterator` method; the chunks are checked as they arrive. */
+export function assertAsyncIterable(valueArg: unknown, fieldArg: string): asserts valueArg is AsyncIterable<unknown> {
+  if (
+    valueArg === null ||
+    typeof valueArg !== 'object' ||
+    typeof (valueArg as Partial<AsyncIterable<unknown>>)[Symbol.asyncIterator] !== 'function'
+  ) {
+    throw new LinuxRepoError('invalid-input', `${fieldArg} must be an AsyncIterable<Uint8Array>`, { field: fieldArg });
+  }
+}
+
+export function assertString(valueArg: unknown, fieldArg: string): asserts valueArg is string {
+  if (typeof valueArg !== 'string') {
+    throw new LinuxRepoError('invalid-input', `${fieldArg} must be a string`, { field: fieldArg });
+  }
+}
+
+/** True when the text contains a C0 control character, DEL or a C1 control character. */
+export function hasControlCharacter(textArg: string): boolean {
+  return /\p{Cc}/u.test(textArg);
+}
+
+/**
+ * True when the text can name one path segment of a served file: non-empty,
+ * not `.` or `..`, no `/` and no control characters.
+ */
+export function isPathSegment(valueArg: string): boolean {
+  return valueArg !== '' && valueArg !== '.' && valueArg !== '..' && !valueArg.includes('/') && !hasControlCharacter(valueArg);
+}
+
+/**
+ * A name that becomes one path or tar-entry segment: non-empty, no `/`, no
+ * control characters.
+ */
+export function assertSegmentName(valueArg: unknown, fieldArg: string): asserts valueArg is string {
+  assertString(valueArg, fieldArg);
+  if (valueArg.length === 0 || valueArg.includes('/') || hasControlCharacter(valueArg)) {
+    throw new LinuxRepoError(
+      'invalid-input',
+      `${fieldArg} must be non-empty and contain no "/" or control characters`,
+      { field: fieldArg },
+    );
+  }
+}

package/ts/signing/keys.ts

@@ -0,0 +1,110 @@
+import * as plugins from '../plugins.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertSegmentName, assertString, assertTimestamp, hasControlCharacter } from '../shared/validation.js';
+
+/** An Alpine key pair in Gitea's stored forms. */
+export interface IAlpineKeyPair {
+  /** PKCS#1 PEM (`RSA PRIVATE KEY`). */
+  privateKeyPem: string;
+  /** PKIX/SPKI PEM (`PUBLIC KEY`). */
+  publicKeyPem: string;
+}
+
+/** An OpenPGP key pair, armored. */
+export interface IOpenPgpKeyPair {
+  privateKeyArmored: string;
+  publicKeyArmored: string;
+  /** The v4 fingerprint, 40 uppercase hex digits. */
+  fingerprint: string;
+}
+
+const RSA_BITS = 4096;
+
+/**
+ * Generates an RSA-4096 Alpine key pair in Gitea's forms (Gitea
+ * `util.GenerateKeyPair(4096)`: PKCS#1 private key, PKIX public key, e=65537).
+ * The codec stores nothing. A failure inside node:crypto propagates unchanged.
+ */
+export async function generateAlpineKeyPair(): Promise<IAlpineKeyPair> {
+  const { privateKey, publicKey } = await new Promise<{ privateKey: string; publicKey: string }>((resolve, reject) => {
+    plugins.crypto.generateKeyPair(
+      'rsa',
+      {
+        modulusLength: RSA_BITS,
+        publicExponent: 0x10001,
+        privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
+        publicKeyEncoding: { type: 'spki', format: 'pem' },
+      },
+      (error, publicKeyArg, privateKeyArg) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve({ privateKey: privateKeyArg, publicKey: publicKeyArg });
+        }
+      },
+    );
+  });
+  return { privateKeyPem: privateKey, publicKeyPem: publicKey };
+}
+
+/**
+ * Generates an RSA-4096 OpenPGP v4 key pair (primary key for certification and
+ * signing, RSA-4096 encryption subkey, no expiry) whose creation time is
+ * `timestamp` and whose single user ID is exactly `userId`. Bad input is
+ * `invalid-input`; a failure inside openpgp.js propagates unchanged.
+ */
+export async function generateOpenPgpKeyPair(inputArg: { userId: string; timestamp: Date }): Promise<IOpenPgpKeyPair> {
+  if (inputArg === null || typeof inputArg !== 'object') {
+    throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+  }
+  assertString(inputArg.userId, 'userId');
+  if (inputArg.userId.length === 0 || hasControlCharacter(inputArg.userId)) {
+    throw new LinuxRepoError('invalid-input', 'userId must be non-empty and contain no control characters', {
+      field: 'userId',
+    });
+  }
+  assertTimestamp(inputArg.timestamp);
+  const generated = await plugins.openpgp.generateKey({
+    type: 'rsa',
+    rsaBits: RSA_BITS,
+    userIDs: [{ name: inputArg.userId }],
+    date: inputArg.timestamp,
+    format: 'object',
+    config: { v6Keys: false },
+  });
+  return {
+    privateKeyArmored: generated.privateKey.armor(),
+    publicKeyArmored: generated.publicKey.armor(),
+    fingerprint: generated.privateKey.getFingerprint().toUpperCase(),
+  };
+}
+
+/**
+ * Gitea's Alpine key name: `<ownerLowerName>@<hex>.rsa.pub`, where `<hex>` is
+ * the lowercase hex SHA-256 of the PKIX (SPKI) DER of the RSA public key
+ * (Gitea `util.CreatePublicKeyFingerprint`). Pass the owner's lower-case name.
+ */
+export function giteaAlpineKeyName(ownerLowerName: string, publicKeyPem: string): string {
+  assertSegmentName(ownerLowerName, 'ownerLowerName');
+  assertString(publicKeyPem, 'publicKeyPem');
+  const label = /-----BEGIN ([A-Z0-9 ]+)-----/.exec(publicKeyPem)?.[1];
+  if (label !== 'PUBLIC KEY') {
+    throw new LinuxRepoError('invalid-key', 'the Alpine public key must be a PKIX "PUBLIC KEY" PEM', {
+      field: 'publicKeyPem',
+    });
+  }
+  let key: plugins.crypto.KeyObject;
+  try {
+    key = plugins.crypto.createPublicKey({ key: publicKeyPem, format: 'pem' });
+  } catch (error) {
+    throw new LinuxRepoError('invalid-key', 'the Alpine public key cannot be read', { field: 'publicKeyPem' }, {
+      cause: error,
+    });
+  }
+  if (key.asymmetricKeyType !== 'rsa') {
+    throw new LinuxRepoError('invalid-key', 'the Alpine public key must be an RSA key', { field: 'publicKeyPem' });
+  }
+  const der = key.export({ type: 'spki', format: 'der' });
+  const hex = plugins.crypto.createHash('sha256').update(der).digest('hex');
+  return `${ownerLowerName}@${hex}.rsa.pub`;
+}

package/ts/signing/openpgpframing.ts

@@ -0,0 +1,115 @@
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertAsyncIterable, assertBytes, assertString, assertTimestamp } from '../shared/validation.js';
+import { singleChunk, type IOpenPgpSigner } 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: {
+  data: AsyncIterable<Uint8Array>;
+  signer: IOpenPgpSigner;
+  timestamp: Date;
+}): Promise<Uint8Array> {
+  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: {
+  data: Uint8Array;
+  signer: IOpenPgpSigner;
+  timestamp: Date;
+}): Promise<string> {
+  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: {
+  text: string;
+  signer: IOpenPgpSigner;
+  timestamp: Date;
+}): Promise<string> {
+  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: Uint8Array): string {
+  const base64 = Buffer.from(packetArg.buffer, packetArg.byteOffset, packetArg.byteLength).toString('base64');
+  const lines: string[] = [];
+  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: unknown): asserts textArg is string {
+  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: unknown): asserts packetArg is Uint8Array {
+  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: Uint8Array): string {
+  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');
+}