@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/dist_ts/shared/url.js

@@ -0,0 +1,371 @@
+/**
+ * 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) {
+    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 = 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));
+}
+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) {
+    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) {
+    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) {
+    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;
+        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, modeArg) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    return bytesArg.length === 0 || (bytesArg[0] === COLON && isDigits(bytesArg.subarray(1)));
+}
+/** Gitea's `portOnly` on the parsed host. */
+function portOnly(hostArg) {
+    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) {
+    return bytesArg.every(isDigit);
+}
+function isDigit(cArg) {
+    return cArg >= 0x30 && cArg <= 0x39;
+}
+function isAlpha(cArg) {
+    return (cArg >= 0x41 && cArg <= 0x5a) || (cArg >= 0x61 && cArg <= 0x7a);
+}
+function isHex(cArg) {
+    return isDigit(cArg) || (cArg >= 0x41 && cArg <= 0x46) || (cArg >= 0x61 && cArg <= 0x66);
+}
+function unhex(cArg) {
+    return isDigit(cArg) ? cArg - 0x30 : (cArg | 0x20) - 0x61 + 10;
+}
+function count(bytesArg, byteArg) {
+    let total = 0;
+    for (const byte of bytesArg) {
+        if (byte === byteArg) {
+            total++;
+        }
+    }
+    return total;
+}
+function ascii(bytesArg) {
+    return String.fromCharCode(...bytesArg);
+}
+function concat(...partsArg) {
+    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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"url.js","sourceRoot":"","sources":["../../ts/shared/url.ts"],"names":[],"mappings":"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"}

package/dist_ts/shared/validation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Refuses anything but a valid `Date` whose whole seconds fit an OpenPGP v4
+ * time field (1970-01-01 to 2106-02-07).
+ */
+export declare function assertTimestamp(valueArg: unknown, fieldArg?: string): asserts valueArg is Date;
+export declare function assertBytes(valueArg: unknown, fieldArg: string): asserts valueArg is Uint8Array;
+/** Refuses anything that is not an object with a `Symbol.asyncIterator` method; the chunks are checked as they arrive. */
+export declare function assertAsyncIterable(valueArg: unknown, fieldArg: string): asserts valueArg is AsyncIterable<unknown>;
+export declare function assertString(valueArg: unknown, fieldArg: string): asserts valueArg is string;
+/** True when the text contains a C0 control character, DEL or a C1 control character. */
+export declare function hasControlCharacter(textArg: string): boolean;
+/**
+ * True when the text can name one path segment of a served file: non-empty,
+ * not `.` or `..`, no `/` and no control characters.
+ */
+export declare function isPathSegment(valueArg: string): boolean;
+/**
+ * A name that becomes one path or tar-entry segment: non-empty, no `/`, no
+ * control characters.
+ */
+export declare function assertSegmentName(valueArg: unknown, fieldArg: string): asserts valueArg is string;

package/dist_ts/shared/validation.js

@@ -0,0 +1,58 @@
+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, fieldArg = 'timestamp') {
+    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, fieldArg) {
+    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, fieldArg) {
+    if (valueArg === null ||
+        typeof valueArg !== 'object' ||
+        typeof valueArg[Symbol.asyncIterator] !== 'function') {
+        throw new LinuxRepoError('invalid-input', `${fieldArg} must be an AsyncIterable<Uint8Array>`, { field: fieldArg });
+    }
+}
+export function assertString(valueArg, fieldArg) {
+    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) {
+    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) {
+    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, fieldArg) {
+    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 });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/signing/keys.d.ts

@@ -0,0 +1,36 @@
+/** 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;
+}
+/**
+ * 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 declare function generateAlpineKeyPair(): Promise<IAlpineKeyPair>;
+/**
+ * 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 declare function generateOpenPgpKeyPair(inputArg: {
+    userId: string;
+    timestamp: Date;
+}): Promise<IOpenPgpKeyPair>;
+/**
+ * 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 declare function giteaAlpineKeyName(ownerLowerName: string, publicKeyPem: string): string;

package/dist_ts/signing/keys.js

@@ -0,0 +1,89 @@
+import * as plugins from '../plugins.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertSegmentName, assertString, assertTimestamp, hasControlCharacter } from '../shared/validation.js';
+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() {
+    const { privateKey, publicKey } = await new Promise((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) {
+    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, publicKeyPem) {
+    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;
+    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`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/signing/openpgpframing.d.ts

@@ -0,0 +1,33 @@
+import { type IOpenPgpSigner } from './signers.js';
+/**
+ * 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 declare function createDetachedBinarySignature(inputArg: {
+    data: AsyncIterable<Uint8Array>;
+    signer: IOpenPgpSigner;
+    timestamp: Date;
+}): Promise<Uint8Array>;
+/** Signs `data` and returns an armored detached signature (`Release.gpg`, `repomd.xml.asc`). */
+export declare function createDetachedArmoredSignature(inputArg: {
+    data: Uint8Array;
+    signer: IOpenPgpSigner;
+    timestamp: Date;
+}): Promise<string>;
+/**
+ * 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 declare function createCleartextSignedMessage(inputArg: {
+    text: string;
+    signer: IOpenPgpSigner;
+    timestamp: Date;
+}): Promise<string>;
+/** ASCII armor for one signature packet list. */
+export declare function armorSignature(packetArg: Uint8Array): string;
+/** Refuses text that is not canonical cleartext input. */
+export declare function assertCanonicalText(textArg: unknown): asserts textArg is string;