@push.rocks/smartlinuxrepo 0.0.0-stage → 1.0.0

package/ts/signing/signers.ts

@@ -0,0 +1,315 @@
+import * as plugins from '../plugins.js';
+import { concatBytes } from '../readers/bytes.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import {
+  assertAsyncIterable,
+  assertBytes,
+  assertSegmentName,
+  assertString,
+  assertTimestamp,
+} from '../shared/validation.js';
+
+/**
+ * Signs Alpine indexes. Consumers may implement it; adding a required member
+ * later needs a major release.
+ */
+export interface IAlpineSigner {
+  /**
+   * The key name apk looks up in `/etc/apk/keys`; the index signature entry is
+   * `.SIGN.RSA.<keyName>`. Gitea's form is `<owner>@<sha256 hex of the SPKI
+   * DER public key>.rsa.pub` (see `giteaAlpineKeyName`).
+   */
+  readonly keyName: string;
+  /** RSASSA-PKCS1-v1_5 over SHA-1 of `data`; returns the raw signature bytes. */
+  sign(data: Uint8Array): Promise<Uint8Array>;
+}
+
+/**
+ * Signs Debian, RPM and Arch documents. Consumers may implement it; adding a
+ * required member later needs a major release.
+ *
+ * Contract: each call returns exactly one binary OpenPGP v4 signature packet
+ * (packet header included, no armor), hashed with SHA-256, whose creation time
+ * is `timestamp` (whole seconds). The codec does all framing (armor, cleartext
+ * dash-escaping, the `Hash: SHA256` header) and treats the packet as opaque.
+ */
+export interface IOpenPgpSigner {
+  /**
+   * A signature of type 0x00 (binary document) over the concatenation of the
+   * chunks of `data`. The signer reads `data` to its end exactly once.
+   */
+  signBinary(data: AsyncIterable<Uint8Array>, timestamp: Date): Promise<Uint8Array>;
+  /**
+   * A signature of type 0x01 (canonical text document) over `text`. The codec
+   * passes canonical text only: LF line endings and no trailing spaces or tabs
+   * on any line; the signature hashes it with CRLF line endings.
+   */
+  signText(text: string, timestamp: Date): Promise<Uint8Array>;
+}
+
+const ALPINE_PRIVATE_KEY_LABELS = ['RSA PRIVATE KEY', 'PRIVATE KEY'];
+
+/**
+ * Builds an Alpine signer from an unencrypted RSA private key in PEM form:
+ * PKCS#1 (`RSA PRIVATE KEY`, Gitea's stored form) or PKCS#8 (`PRIVATE KEY`).
+ * Anything else is `invalid-key`. Signatures are deterministic.
+ */
+export function createAlpineSigner(inputArg: { privateKeyPem: string; keyName: string }): IAlpineSigner {
+  if (inputArg === null || typeof inputArg !== 'object') {
+    throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+  }
+  assertString(inputArg.privateKeyPem, 'privateKeyPem');
+  assertSegmentName(inputArg.keyName, 'keyName');
+  const label = /-----BEGIN ([A-Z0-9 ]+)-----/.exec(inputArg.privateKeyPem)?.[1];
+  if (label === undefined || !ALPINE_PRIVATE_KEY_LABELS.includes(label)) {
+    throw new LinuxRepoError('invalid-key', 'the Alpine key must be an unencrypted PKCS#1 or PKCS#8 RSA private key PEM', {
+      field: 'privateKeyPem',
+    });
+  }
+  let key: plugins.crypto.KeyObject;
+  try {
+    key = plugins.crypto.createPrivateKey({ key: inputArg.privateKeyPem, format: 'pem' });
+  } catch (error) {
+    throw new LinuxRepoError('invalid-key', 'the Alpine private key cannot be read', { field: 'privateKeyPem' }, {
+      cause: error,
+    });
+  }
+  if (key.asymmetricKeyType !== 'rsa') {
+    throw new LinuxRepoError('invalid-key', 'the Alpine key must be an RSA key', { field: 'privateKeyPem' });
+  }
+  const keyName = inputArg.keyName;
+  return {
+    keyName,
+    sign: async (data: Uint8Array): Promise<Uint8Array> => {
+      assertBytes(data, 'data');
+      try {
+        const signature = plugins.crypto.sign('sha1', data, {
+          key,
+          padding: plugins.crypto.constants.RSA_PKCS1_PADDING,
+        });
+        return new Uint8Array(signature.buffer, signature.byteOffset, signature.byteLength);
+      } catch (error) {
+        throw new LinuxRepoError('signing-failed', 'RSA PKCS#1 v1.5 SHA-1 signing failed', { field: 'keyName' }, {
+          cause: error,
+        });
+      }
+    },
+  };
+}
+
+/**
+ * Builds an OpenPGP signer from an armored private key: exactly one key,
+ * OpenPGP v4, not encrypted, able to sign. Anything else is `invalid-key`.
+ * Signatures are SHA-256 and keep openpgp.js's salt notation, so their bytes
+ * vary per call; the produced packet is checked against the signer contract.
+ *
+ * The factory makes one trial `signBinary` and refuses the key with
+ * `invalid-key` when it fails, so a key that cannot meet the contract at all
+ * (one whose curve makes openpgp.js choose a stronger hash than SHA-256) is
+ * refused here. The trial signs at the latest creation time of the key, its
+ * subkeys and their self-signatures; a failure that depends on the signing
+ * time stays `signing-failed` at signing time.
+ */
+export async function createOpenPgpSigner(inputArg: { privateKeyArmored: string }): Promise<IOpenPgpSigner> {
+  if (inputArg === null || typeof inputArg !== 'object') {
+    throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+  }
+  assertString(inputArg.privateKeyArmored, 'privateKeyArmored');
+  // openpgp.js reads the first armor block and ignores anything after it
+  const armorBlocks = inputArg.privateKeyArmored.match(/^-----BEGIN PGP [A-Z ,/0-9]+-----\s*$/gm) ?? [];
+  if (armorBlocks.length > 1) {
+    throw new LinuxRepoError('invalid-key', `expected one armored OpenPGP private key block, got ${armorBlocks.length}`, {
+      field: 'privateKeyArmored',
+    });
+  }
+  let keys: plugins.openpgp.PrivateKey[];
+  try {
+    keys = await plugins.openpgp.readPrivateKeys({ armoredKeys: inputArg.privateKeyArmored });
+  } catch (error) {
+    throw new LinuxRepoError('invalid-key', 'the OpenPGP private key cannot be read', { field: 'privateKeyArmored' }, {
+      cause: error,
+    });
+  }
+  if (keys.length !== 1) {
+    throw new LinuxRepoError('invalid-key', `expected exactly one OpenPGP private key, got ${keys.length}`, {
+      field: 'privateKeyArmored',
+    });
+  }
+  const key = keys[0];
+  if (key.keyPacket.version !== 4) {
+    throw new LinuxRepoError('invalid-key', `only OpenPGP v4 keys are accepted, got v${key.keyPacket.version}`, {
+      field: 'privateKeyArmored',
+    });
+  }
+  if (!key.isDecrypted()) {
+    throw new LinuxRepoError('invalid-key', 'encrypted OpenPGP keys are not accepted', { field: 'privateKeyArmored' });
+  }
+  const sign = async (
+    produceArg: () => Promise<Uint8Array>,
+    timestampArg: Date,
+    signatureTypeArg: number,
+    inputFailureArg: () => { error: unknown } | undefined = () => undefined,
+  ): Promise<Uint8Array> => {
+    let packet: Uint8Array;
+    try {
+      packet = await produceArg();
+    } catch (error) {
+      // an invalid chunk or the caller's own source error, not a signing failure
+      const inputFailure = inputFailureArg();
+      if (inputFailure !== undefined) {
+        throw inputFailure.error;
+      }
+      throw new LinuxRepoError('signing-failed', 'OpenPGP signing failed', { field: 'signingKey' }, { cause: error });
+    }
+    await assertSignaturePacket(packet, timestampArg, signatureTypeArg);
+    return packet;
+  };
+  const config = { preferredHashAlgorithm: plugins.openpgp.enums.hash.sha256 };
+  const signer: IOpenPgpSigner = {
+    signBinary: async (data: AsyncIterable<Uint8Array>, timestamp: Date): Promise<Uint8Array> => {
+      assertAsyncIterable(data, 'data');
+      assertTimestamp(timestamp);
+      const source = new CheckedChunkSource(data);
+      return sign(
+        async () => {
+          const signature = await plugins.openpgp.sign({
+            message: await plugins.openpgp.createMessage({ binary: source.toReadableStream() }),
+            signingKeys: key,
+            detached: true,
+            format: 'binary',
+            date: timestamp,
+            config,
+          });
+          const packet = await readAll(signature);
+          if (!source.ended) {
+            throw new Error('openpgp.js returned a signature before reading the data to its end');
+          }
+          return packet;
+        },
+        timestamp,
+        plugins.openpgp.enums.signature.binary,
+        () => source.failure,
+      );
+    },
+    signText: async (text: string, timestamp: Date): Promise<Uint8Array> => {
+      assertString(text, 'text');
+      assertTimestamp(timestamp);
+      return sign(
+        async () =>
+          plugins.openpgp.sign({
+            message: await plugins.openpgp.createMessage({ text }),
+            signingKeys: key,
+            detached: true,
+            format: 'binary',
+            date: timestamp,
+            config,
+          }),
+        timestamp,
+        plugins.openpgp.enums.signature.text,
+      );
+    },
+  };
+  try {
+    await signer.signBinary(singleChunk(new Uint8Array(0)), latestKeyTime(key));
+  } catch (error) {
+    throw new LinuxRepoError('invalid-key', 'the OpenPGP key cannot sign a v4 SHA-256 signature', { field: 'privateKeyArmored' }, {
+      cause: error,
+    });
+  }
+  return signer;
+}
+
+/** `bytesArg` as a one-chunk source, for callers that hold the whole document. */
+export async function* singleChunk(bytesArg: Uint8Array): AsyncGenerator<Uint8Array> {
+  yield bytesArg;
+}
+
+/**
+ * Pulls the caller's source with `next()` only (never `return()` or
+ * `throw()`, so a cancelled stream never cancels the source), refuses a chunk
+ * that is not a `Uint8Array` with `invalid-input`, and records the first
+ * error it raised or met so the signer can rethrow it unchanged.
+ */
+class CheckedChunkSource {
+  public ended = false;
+  public failure: { error: unknown } | undefined = undefined;
+  private readonly source: AsyncIterable<unknown>;
+
+  constructor(sourceArg: AsyncIterable<unknown>) {
+    this.source = sourceArg;
+  }
+
+  public toReadableStream(): plugins.streamWeb.ReadableStream<Uint8Array> {
+    const iterator = this.source[Symbol.asyncIterator]();
+    const next = async (): Promise<IteratorResult<Uint8Array>> => {
+      let result: IteratorResult<unknown>;
+      try {
+        result = await iterator.next();
+      } catch (error) {
+        this.failure ??= { error };
+        throw error;
+      }
+      if (result.done === true) {
+        this.ended = true;
+        return { done: true, value: undefined };
+      }
+      if (!(result.value instanceof Uint8Array)) {
+        const error = new LinuxRepoError('invalid-input', 'every chunk of data must be a Uint8Array', { field: 'data' });
+        this.failure ??= { error };
+        throw error;
+      }
+      return { done: false, value: result.value };
+    };
+    return plugins.streamWeb.ReadableStream.from<Uint8Array>({ [Symbol.asyncIterator]: () => ({ next }) });
+  }
+}
+
+/** Reads openpgp.js's streamed output to its end. */
+async function readAll(streamArg: plugins.streamWeb.ReadableStream<Uint8Array>): Promise<Uint8Array> {
+  const reader = streamArg.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  for (let result = await reader.read(); !result.done; result = await reader.read()) {
+    chunks.push(result.value);
+    total += result.value.length;
+  }
+  return concatBytes(chunks, total);
+}
+
+/** The latest creation time of the key, its subkeys and their self-signatures: the key's current state applies. */
+function latestKeyTime(keyArg: plugins.openpgp.PrivateKey): Date {
+  const times = [keyArg.getCreationTime().getTime()];
+  for (const user of keyArg.users) {
+    for (const signature of user.selfCertifications) {
+      times.push(signature.created?.getTime() ?? 0);
+    }
+  }
+  for (const subkey of keyArg.subkeys) {
+    times.push(subkey.getCreationTime().getTime());
+    for (const signature of subkey.bindingSignatures) {
+      times.push(signature.created?.getTime() ?? 0);
+    }
+  }
+  return new Date(Math.max(...times));
+}
+
+/** Checks that openpgp.js produced exactly the packet the signer contract promises. */
+async function assertSignaturePacket(packetArg: Uint8Array, timestampArg: Date, signatureTypeArg: number): Promise<void> {
+  const signature = await plugins.openpgp.readSignature({ binarySignature: packetArg });
+  const packets = signature.packets;
+  const expectedSeconds = Math.floor(timestampArg.getTime() / 1000);
+  const ok =
+    packets.length === 1 &&
+    packets[0].version === 4 &&
+    packets[0].signatureType === signatureTypeArg &&
+    packets[0].hashAlgorithm === plugins.openpgp.enums.hash.sha256 &&
+    packets[0].created !== null &&
+    Math.floor(packets[0].created.getTime() / 1000) === expectedSeconds;
+  if (!ok) {
+    throw new LinuxRepoError(
+      'signing-failed',
+      'the signing key cannot produce one v4 SHA-256 signature packet at the requested time',
+      { field: 'signingKey' },
+    );
+  }
+}

package/ts/writers/gotar.ts

@@ -0,0 +1,256 @@
+import { concatBytes } from '../readers/bytes.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { goPathJoin } from '../shared/gopath.js';
+
+export interface IGoTarFile {
+  name: string;
+  mode: number;
+  data: Uint8Array;
+}
+
+export interface IGoTarWriteOptions {
+  /**
+   * The two zero blocks Go `Writer.Close` writes. `false` for Gitea's Alpine
+   * signature member (`writeGzipStream` with `addTarEnd=false`). Gitea never
+   * calls `Close` there, so Go also leaves the last entry unpadded; the codec
+   * pads every entry to the block regardless (a difference from Gitea).
+   */
+  endOfArchive: boolean;
+}
+
+const BLOCK = 512;
+const NAME_SIZE = 100;
+const PREFIX_SIZE = 155;
+/** Go `maxSpecialFileSize`: the largest PAX record block Go writes or reads. */
+const MAX_SPECIAL_FILE_SIZE = 1 << 20;
+/** Go `fitsInOctal(8, x)` for the mode field: below 8^7. */
+const MODE_LIMIT = 8 ** 7;
+/** Go `fitsInOctal(12, x)` for the size field: below 8^11 (8 GiB). */
+const SIZE_LIMIT = 8 ** 11;
+const encoder = new TextEncoder();
+
+/**
+ * The subset of Go 1.27 `archive/tar` `Writer` that Gitea 28.2.0 uses for its
+ * index archives (Arch `services/packages/arch/repository.go:381-399`, Alpine
+ * `services/packages/alpine/repository.go:331-351`): regular files from
+ * `tar.Header{Name, Mode, Size}` with every other field zero, so the zero
+ * `ModTime` is written as 0, uid and gid are 0 and user and group names are
+ * empty.
+ *
+ * Format choice follows Go's `allowedFormats` and `WriteHeader`: USTAR when the
+ * name is ASCII and at most 100 bytes, USTAR with a prefix split when the name
+ * splits, else PAX with one `path` record (refused when the records exceed
+ * Go's 1 MiB `maxSpecialFileSize`, as Go returns `ErrFieldTooLong`).
+ *
+ * Refused with `invalid-input` where Go would not write a regular file in USTAR
+ * or PAX-`path` form:
+ * - a name with NUL (Go fails with an invalid PAX record) or ending with `/`
+ *   (Go refuses it for a regular file; Gitea's untyped header would become a
+ *   directory entry instead);
+ * - a mode outside 7 octal digits (Go falls back to the GNU format);
+ * - a size of 8 GiB or more (Go adds a PAX `size` record; the codec does not);
+ * - a string that is not well-formed UTF-16 (Go strings never carry one).
+ */
+export function writeGoTar(
+  filesArg: readonly IGoTarFile[],
+  optionsArg: IGoTarWriteOptions = { endOfArchive: true },
+): Uint8Array {
+  const parts: Uint8Array[] = [];
+  for (const file of filesArg) {
+    parts.push(goTarHeader(file.name, file.mode, file.data.length), file.data, new Uint8Array(padding(file.data.length)));
+  }
+  if (optionsArg.endOfArchive) {
+    parts.push(new Uint8Array(BLOCK * 2));
+  }
+  return concatBytes(parts);
+}
+
+/**
+ * The bytes Go `Writer.WriteHeader` writes for a regular file: the main
+ * header block, preceded by a PAX `x` header and its padded records when the
+ * name needs one.
+ */
+export function goTarHeader(nameArg: string, modeArg: number, sizeArg: number): Uint8Array {
+  if (!nameArg.isWellFormed()) {
+    throw new LinuxRepoError('invalid-input', 'a tar entry name is not well-formed UTF-16', { field: 'name' });
+  }
+  if (nameArg.includes('\0')) {
+    throw new LinuxRepoError('invalid-input', 'a tar entry name contains NUL', { field: 'name' });
+  }
+  if (nameArg.endsWith('/')) {
+    throw new LinuxRepoError('invalid-input', 'a regular tar entry name ends with /', { field: 'name' });
+  }
+  if (!Number.isSafeInteger(modeArg) || modeArg < 0 || modeArg >= MODE_LIMIT) {
+    throw new LinuxRepoError('invalid-input', 'a tar entry mode does not fit the USTAR mode field', {
+      field: 'mode',
+    });
+  }
+  if (!Number.isSafeInteger(sizeArg) || sizeArg < 0 || sizeArg >= SIZE_LIMIT) {
+    throw new LinuxRepoError('invalid-input', 'a tar entry size does not fit the USTAR size field', {
+      field: 'size',
+    });
+  }
+  const nameBytes = encoder.encode(nameArg);
+  if (isAscii(nameBytes) && nameBytes.length <= NAME_SIZE) {
+    return header({ name: nameBytes, prefix: null, size: sizeArg, mode: modeArg, typeflag: '0' });
+  }
+  const split = splitUstarPath(nameBytes);
+  if (split !== null) {
+    return header({ name: split.name, prefix: split.prefix, size: sizeArg, mode: modeArg, typeflag: '0' });
+  }
+  return paxHeader(nameArg, modeArg, sizeArg);
+}
+
+/** Go `splitUSTARPath` (`archive/tar/writer.go:454`). */
+function splitUstarPath(nameArg: Uint8Array): { prefix: Uint8Array; name: Uint8Array } | null {
+  let length = nameArg.length;
+  if (length <= NAME_SIZE || !isAscii(nameArg)) {
+    return null;
+  } else if (length > PREFIX_SIZE + 1) {
+    length = PREFIX_SIZE + 1;
+  } else if (nameArg[length - 1] === 0x2f) {
+    length--;
+  }
+  const i = nameArg.subarray(0, length).lastIndexOf(0x2f);
+  const nameLength = nameArg.length - i - 1;
+  const prefixLength = i;
+  if (i <= 0 || nameLength > NAME_SIZE || nameLength === 0 || prefixLength > PREFIX_SIZE) {
+    return null;
+  }
+  return { prefix: nameArg.subarray(0, i), name: nameArg.subarray(i + 1) };
+}
+
+/**
+ * Go `writePAXHeader` (`archive/tar/writer.go:131`) for one `path` record:
+ * the `x` header written by `writeRawFile`, the records, their padding, then
+ * the main header with the ASCII-folded name.
+ */
+function paxHeader(nameArg: string, modeArg: number, sizeArg: number): Uint8Array {
+  const records = paxRecord('path', nameArg);
+  if (records.length > MAX_SPECIAL_FILE_SIZE) {
+    throw new LinuxRepoError('invalid-input', 'a tar entry name is longer than Go archive/tar writes', {
+      field: 'name',
+    });
+  }
+  // path.Split, then path.Join(dir, "PaxHeaders.0", file); writeRawFile folds
+  // it to ASCII, cuts it to 100 bytes and trims trailing slashes
+  const slash = nameArg.lastIndexOf('/');
+  const dir = nameArg.slice(0, slash + 1);
+  const file = nameArg.slice(slash + 1);
+  let paxName = encoder.encode(toAscii(goPathJoin([dir, 'PaxHeaders.0', file])));
+  if (paxName.length > NAME_SIZE) {
+    paxName = paxName.subarray(0, NAME_SIZE);
+  }
+  let end = paxName.length;
+  while (end > 0 && paxName[end - 1] === 0x2f) {
+    end--;
+  }
+  return concatBytes([
+    header({ name: paxName.subarray(0, end), prefix: null, size: records.length, mode: 0, typeflag: 'x', raw: true }),
+    records,
+    new Uint8Array(padding(records.length)),
+    header({ name: encoder.encode(toAscii(nameArg)), prefix: null, size: sizeArg, mode: modeArg, typeflag: '0' }),
+  ]);
+}
+
+/** Go `formatPAXRecord` (`archive/tar/strconv.go:291`). */
+function paxRecord(keyArg: string, valueArg: string): Uint8Array {
+  const payload = encoder.encode(` ${keyArg}=${valueArg}\n`);
+  let size = payload.length;
+  size += String(size).length;
+  let record = concatBytes([encoder.encode(String(size)), payload]);
+  if (record.length !== size) {
+    size = record.length;
+    record = concatBytes([encoder.encode(String(size)), payload]);
+  }
+  return record;
+}
+
+interface IHeaderSpec {
+  name: Uint8Array;
+  prefix: Uint8Array | null;
+  size: number;
+  mode: number;
+  typeflag: '0' | 'x';
+  /** `writeRawFile` (`archive/tar/writer.go:353`): devmajor and devminor stay zero bytes. */
+  raw?: boolean;
+}
+
+/** Go `templateV7Plus` plus `setFormat` (`archive/tar/writer.go:323`, `format.go:205`). */
+function header(specArg: IHeaderSpec): Uint8Array {
+  const block = new Uint8Array(BLOCK);
+  formatString(block, 0, NAME_SIZE, specArg.name);
+  formatOctal(block, 100, 8, specArg.mode);
+  formatOctal(block, 108, 8, 0); // uid
+  formatOctal(block, 116, 8, 0); // gid
+  formatOctal(block, 124, 12, specArg.size);
+  formatOctal(block, 136, 12, 0); // mtime: the zero time.Time is written as 0
+  block[156] = specArg.typeflag.charCodeAt(0);
+  // linkname, uname and gname stay empty
+  if (!specArg.raw) {
+    formatOctal(block, 329, 8, 0); // devmajor
+    formatOctal(block, 337, 8, 0); // devminor
+  }
+  if (specArg.prefix !== null) {
+    formatString(block, 345, PREFIX_SIZE, specArg.prefix);
+  }
+  block.set(encoder.encode('ustar\0'), 257);
+  block.set(encoder.encode('00'), 263);
+  let sum = 0;
+  for (let i = 0; i < BLOCK; i++) {
+    sum += i >= 148 && i < 156 ? 0x20 : block[i];
+  }
+  formatOctal(block, 148, 7, sum);
+  block[155] = 0x20;
+  return block;
+}
+
+/** Go `formatter.formatString` (`archive/tar/strconv.go:63`): copy, NUL-terminate when shorter, cut when longer. */
+function formatString(blockArg: Uint8Array, offsetArg: number, lengthArg: number, valueArg: Uint8Array): void {
+  const field = blockArg.subarray(offsetArg, offsetArg + lengthArg);
+  field.set(valueArg.subarray(0, lengthArg));
+  if (valueArg.length < lengthArg) {
+    field[valueArg.length] = 0;
+  }
+  if (valueArg.length > lengthArg && field[lengthArg - 1] === 0x2f) {
+    let n = lengthArg - 1;
+    while (n > 0 && valueArg[n - 1] === 0x2f) {
+      n--;
+    }
+    field[n] = 0;
+  }
+}
+
+/**
+ * Go `formatter.formatOctal` (`archive/tar/strconv.go:176`): zero-padded octal
+ * leaving room for a NUL. Callers check the range first; Go would write 0.
+ */
+function formatOctal(blockArg: Uint8Array, offsetArg: number, lengthArg: number, valueArg: number): void {
+  const digits = valueArg.toString(8).padStart(lengthArg - 1, '0');
+  formatString(blockArg, offsetArg, lengthArg, encoder.encode(digits));
+}
+
+/** Go `toASCII` (`archive/tar/strconv.go:32`): drops every non-ASCII rune (NUL is refused earlier). */
+function toAscii(valueArg: string): string {
+  let result = '';
+  for (const char of valueArg) {
+    if (char.codePointAt(0)! < 0x80) {
+      result += char;
+    }
+  }
+  return result;
+}
+
+/** Go `isASCII` (`archive/tar/strconv.go:21`) for a name without NUL. */
+function isAscii(bytesArg: Uint8Array): boolean {
+  for (let i = 0; i < bytesArg.length; i++) {
+    if (bytesArg[i] >= 0x80) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function padding(sizeArg: number): number {
+  return (BLOCK - (sizeArg % BLOCK)) % BLOCK;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.