diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml new file mode 100644 index 0000000..4c4ac00 --- /dev/null +++ b/.gitea/workflows/ci.yml @@ -0,0 +1,70 @@ +name: ci + +on: + push: + branches: ["**"] + pull_request: + +concurrency: + group: ci-${{ gitea.ref }} + cancel-in-progress: true + +env: + CARGO_TERM_COLOR: always + CARGO_INCREMENTAL: "0" + +jobs: + check: + # The runner is a shared host, so never run code from forks on it. + if: ${{ gitea.event_name != 'pull_request' || gitea.event.pull_request.head.repo.full_name == gitea.repository }} + runs-on: self-hosted + steps: + - uses: actions/checkout@v4 + + - name: Install system dependencies + run: | + # Self-hosted host: install packages only if we may; otherwise assume they are preinstalled. + if [ "$(id -u)" != 0 ] && ! sudo -n true 2>/dev/null; then + echo "::warning::no root/passwordless sudo on the runner, skipping apt (dependencies must be preinstalled)" + exit 0 + fi + SUDO=$(command -v sudo || true) + export DEBIAN_FRONTEND=noninteractive + $SUDO apt-get update + $SUDO apt-get install -y --no-install-recommends \ + build-essential curl ca-certificates pkg-config cmake protobuf-compiler \ + libasound2-dev libopus-dev libudev-dev \ + libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libgstreamer-plugins-bad1.0-dev \ + libssl-dev libxkbcommon-dev libwayland-dev libfontconfig1-dev libdbus-1-dev + + - name: Install Rust toolchain + run: | + if ! command -v rustup >/dev/null; then + curl -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal + fi + . "$HOME/.cargo/env" 2>/dev/null || true + rustup toolchain install stable --profile minimal -c rustfmt -c clippy + rustup default stable + echo "$HOME/.cargo/bin" >> "$GITHUB_PATH" + cargo --version + + - name: Cache cargo + uses: actions/cache@v4 + with: + path: | + ~/.cargo/registry/index + ~/.cargo/registry/cache + ~/.cargo/git/db + target + key: cargo-${{ runner.os }}-${{ hashFiles('Cargo.lock') }} + restore-keys: | + cargo-${{ runner.os }}- + + - name: Format + run: cargo fmt --check + + - name: Clippy + run: cargo clippy --all-targets -- -D warnings + + - name: Test + run: cargo test --workspace diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml new file mode 100644 index 0000000..7faa658 --- /dev/null +++ b/.gitea/workflows/release.yml @@ -0,0 +1,237 @@ +name: release + +on: + push: + tags: ["v*"] + +env: + CARGO_TERM_COLOR: always + CARGO_INCREMENTAL: "0" + +# Two jobs: `build` compiles untrusted-by-default code and has NO secrets and +# NO cache; `publish` holds the signing key and only handles built artifacts. +jobs: + build: + runs-on: self-hosted + env: + TAG: ${{ gitea.ref_name }} + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Preflight (tag, version, branch) + run: | + set -euo pipefail + # Only commits reachable from main may be released. + git fetch origin main + if ! git merge-base --is-ancestor "$GITHUB_SHA" origin/main; then + echo "::error::tagged commit is not on main, refusing to release" + exit 1 + fi + case "$TAG" in v[0-9]*) ;; *) echo "::error::tag '$TAG' is not vX.Y.Z"; exit 1;; esac + VERSION="${TAG#v}" + # The first top-level `version =` line in Cargo.toml belongs to [package]. + CARGO_VERSION=$(grep -m1 -E '^version[[:space:]]*=' Cargo.toml | cut -d'"' -f2) + if [ "$VERSION" != "$CARGO_VERSION" ]; then + echo "::error::tag version '$VERSION' differs from Cargo.toml version '$CARGO_VERSION'" + exit 1 + fi + case "$VERSION" in *-*) CHANNEL=beta;; *) CHANNEL=stable;; esac + echo "VERSION=$VERSION" >> "$GITHUB_ENV" + python3 scripts/release/extract_changelog.py "$VERSION" CHANGELOG.md > /dev/null + echo "releasing $VERSION on channel $CHANNEL" + + - name: Install system dependencies + run: | + # Self-hosted host: install packages only if we may; otherwise assume they are preinstalled. + if [ "$(id -u)" != 0 ] && ! sudo -n true 2>/dev/null; then + echo "::warning::no root/passwordless sudo, verifying preinstalled dependencies instead of installing" + for t in cmake protoc zip x86_64-w64-mingw32-gcc pkg-config; do + command -v "$t" >/dev/null || { echo "::error::missing required tool: $t"; exit 1; } + done + exit 0 + fi + SUDO=$(command -v sudo || true) + export DEBIAN_FRONTEND=noninteractive + $SUDO apt-get update + $SUDO apt-get install -y --no-install-recommends \ + build-essential curl ca-certificates pkg-config cmake protobuf-compiler zip \ + python3 \ + libasound2-dev libopus-dev libudev-dev \ + libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libgstreamer-plugins-bad1.0-dev \ + libssl-dev libxkbcommon-dev libwayland-dev libfontconfig1-dev libdbus-1-dev \ + mingw-w64 + # Posix threading model is required by the Rust windows-gnu target. + $SUDO update-alternatives --set x86_64-w64-mingw32-gcc /usr/bin/x86_64-w64-mingw32-gcc-posix || true + $SUDO update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix || true + + - name: Install pinned Rust toolchain into a throwaway home + run: | + set -euo pipefail + # Never reuse a persistent toolchain/config from the shared runner host. + export CARGO_HOME="$RUNNER_TEMP/cargo" RUSTUP_HOME="$RUNNER_TEMP/rustup" + mkdir -p "$CARGO_HOME" "$RUSTUP_HOME" + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o "$RUNNER_TEMP/rustup-init.sh" + sh "$RUNNER_TEMP/rustup-init.sh" -y --no-modify-path --profile minimal --default-toolchain stable + "$CARGO_HOME/bin/rustup" target add x86_64-pc-windows-gnu + echo "CARGO_HOME=$CARGO_HOME" >> "$GITHUB_ENV" + echo "RUSTUP_HOME=$RUSTUP_HOME" >> "$GITHUB_ENV" + echo "$CARGO_HOME/bin" >> "$GITHUB_PATH" + + - name: Build Linux x86_64 + run: cargo build --release --locked --bin vnox-client + + - name: Build Windows x86_64 (cross, windows-gnu) + # screen-capture is Linux only (its dependencies are cfg(target_os = "linux")), + # so it compiles to nothing on Windows. + run: cargo build --release --locked --target x86_64-pc-windows-gnu --bin vnox-client + + - name: Package + run: | + set -euo pipefail + OUT="$PWD/dist" + mkdir -p "$OUT" stage + LIN="vnox-client-${VERSION}-linux-x86_64" + WIN="vnox-client-${VERSION}-windows-x86_64" + + mkdir -p "stage/$LIN" + install -m 755 target/release/vnox-client "stage/$LIN/vnox-client" + cp LICENSE README.md "stage/$LIN/" + tar -C stage -czf "$OUT/$LIN.tar.gz" "$LIN" + + mkdir -p "stage/$WIN" + cp target/x86_64-pc-windows-gnu/release/vnox-client.exe "stage/$WIN/" + cp LICENSE README.md "stage/$WIN/" + (cd stage && zip -qr "$OUT/$WIN.zip" "$WIN") + + cd "$OUT" + sha256sum "$LIN.tar.gz" "$WIN.zip" > SHA256SUMS + cat SHA256SUMS + + - name: Upload build artifacts + uses: actions/upload-artifact@v3 + with: + name: dist + path: dist/ + if-no-files-found: error + + publish: + needs: build + runs-on: self-hosted + env: + MIN_VERSION: ${{ vars.VNOX_MIN_VERSION }} + TAG: ${{ gitea.ref_name }} + SERVER_URL: ${{ gitea.server_url }} + REPO: ${{ gitea.repository }} + steps: + - uses: actions/checkout@v4 + + - name: Derive version + run: | + set -euo pipefail + VERSION="${TAG#v}" + case "$VERSION" in *-*) CHANNEL=beta;; *) CHANNEL=stable;; esac + echo "VERSION=$VERSION" >> "$GITHUB_ENV" + echo "CHANNEL=$CHANNEL" >> "$GITHUB_ENV" + echo "LIN_ASSET=vnox-client-${VERSION}-linux-x86_64.tar.gz" >> "$GITHUB_ENV" + echo "WIN_ASSET=vnox-client-${VERSION}-windows-x86_64.zip" >> "$GITHUB_ENV" + python3 scripts/release/extract_changelog.py "$VERSION" CHANGELOG.md > "$RUNNER_TEMP/changelog.md" + + - name: Install signing dependencies + run: | + # Self-hosted host: install packages only if we may; otherwise assume they are preinstalled. + if [ "$(id -u)" != 0 ] && ! sudo -n true 2>/dev/null; then + python3 -I -c 'import cryptography' || { echo "::error::python3 cryptography is not installed and cannot be installed"; exit 1; } + exit 0 + fi + SUDO=$(command -v sudo || true) + $SUDO apt-get update + $SUDO apt-get install -y --no-install-recommends python3 python3-cryptography + + - name: Download build artifacts + uses: actions/download-artifact@v3 + with: + name: dist + path: dist/ + + - name: Verify artifacts match SHA256SUMS + run: cd dist && sha256sum -c SHA256SUMS + + - name: Build and sign manifest + env: + VNOX_RELEASE_SIGNING_KEY: ${{ secrets.VNOX_RELEASE_SIGNING_KEY }} + run: | + set -euo pipefail + if [ -z "${VNOX_RELEASE_SIGNING_KEY:-}" ]; then + echo "::error::secret VNOX_RELEASE_SIGNING_KEY is not set, refusing to publish an unsigned release" + exit 1 + fi + cd dist + python3 -I ../scripts/release/manifest.py build \ + --version "$VERSION" --channel "$CHANNEL" \ + --min-version "${MIN_VERSION:-0.0.0}" \ + --base-url "$SERVER_URL/$REPO/releases/download/$TAG" \ + --dir . --out manifest.json \ + "$LIN_ASSET=linux-x86_64" "$WIN_ASSET=windows-x86_64" + python3 -I ../scripts/release/manifest.py sign \ + --manifest manifest.json --out manifest.json.sig + ls -l + + - name: Create Gitea release and upload assets + env: + RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN || secrets.GITHUB_TOKEN }} + run: | + set -euo pipefail + if [ -z "${RELEASE_TOKEN:-}" ]; then + echo "::error::no API token available (RELEASE_TOKEN / GITHUB_TOKEN)"; exit 1 + fi + API="$SERVER_URL/api/v1/repos/$REPO" + AUTH="Authorization: token $RELEASE_TOKEN" + PRERELEASE=false + [ "$CHANNEL" = beta ] && PRERELEASE=true + + python3 - "$TAG" "$PRERELEASE" "$RUNNER_TEMP/changelog.md" > "$RUNNER_TEMP/release.json" <<'PY' + import json, sys + tag, pre, body = sys.argv[1], sys.argv[2] == "true", sys.argv[3] + print(json.dumps({ + "tag_name": tag, + "name": tag, + "body": open(body, encoding="utf-8").read(), + "draft": False, + "prerelease": pre, + })) + PY + + # Create as a draft first, publish only after every asset is uploaded. + python3 - "$RUNNER_TEMP/release.json" <<'PY' + import json, sys + p = sys.argv[1] + d = json.load(open(p)) + d["draft"] = True + json.dump(d, open(p, "w")) + PY + + HTTP=$(curl -sS -o "$RUNNER_TEMP/resp.json" -w '%{http_code}' -X POST "$API/releases" \ + -H "$AUTH" -H 'Content-Type: application/json' --data-binary "@$RUNNER_TEMP/release.json") + if [ "$HTTP" != 201 ]; then + echo "::error::release creation failed (HTTP $HTTP)"; cat "$RUNNER_TEMP/resp.json"; exit 1 + fi + ID=$(python3 -c 'import json,sys; print(json.load(open(sys.argv[1]))["id"])' "$RUNNER_TEMP/resp.json") + + for f in dist/*; do + name=$(basename "$f") + echo "uploading $name" + HTTP=$(curl -sS -o "$RUNNER_TEMP/up.json" -w '%{http_code}' -X POST \ + "$API/releases/$ID/assets?name=$name" -H "$AUTH" -F "attachment=@$f") + if [ "$HTTP" != 201 ]; then + echo "::error::upload of $name failed (HTTP $HTTP)"; cat "$RUNNER_TEMP/up.json"; exit 1 + fi + done + + HTTP=$(curl -sS -o "$RUNNER_TEMP/pub.json" -w '%{http_code}' -X PATCH "$API/releases/$ID" \ + -H "$AUTH" -H 'Content-Type: application/json' -d '{"draft": false}') + if [ "$HTTP" != 200 ]; then + echo "::error::publishing release failed (HTTP $HTTP)"; cat "$RUNNER_TEMP/pub.json"; exit 1 + fi + echo "release published: $SERVER_URL/$REPO/releases/tag/$TAG" diff --git a/docs/release.md b/docs/release.md new file mode 100644 index 0000000..513c380 --- /dev/null +++ b/docs/release.md @@ -0,0 +1,187 @@ +# Релизы и CI + +CI и релизы работают на Gitea Actions. Workflow-файлы лежат в `.gitea/workflows/` +(каталог `.github/workflows` не используется). + +| Файл | Когда запускается | Что делает | +| --- | --- | --- | +| `.gitea/workflows/ci.yml` | push, pull request | `cargo fmt --check`, `cargo clippy --all-targets -- -D warnings`, `cargo test --workspace` | +| `.gitea/workflows/release.yml` | push тега `v*` | сборка Linux и Windows, подпись манифеста, создание релиза в Gitea | + +## Регистрация act_runner + +Нужен хотя бы один runner с лейблом `self-hosted` (Docker на хосте runner'а обязателен). + +1. В Gitea откройте Site Administration, Actions, Runners (для всего инстанса) либо + Settings, Actions, Runners в репозитории или организации, и нажмите Create new runner. + Скопируйте registration token. +2. На хосте runner'а скачайте `act_runner` с . +3. Зарегистрируйте runner: + + ```sh + ./act_runner register --no-interactive \ + --instance https://git.wihuk.pro \ + --token \ + --name vnox-runner-1 \ + --labels "self-hosted:docker://catthehacker/ubuntu:act-22.04" + ``` + +4. Запустите демон: `./act_runner daemon` (рекомендуется systemd-юнит). +5. Убедитесь, что в UI runner отображается как Idle. + +Замечания: + +- В `app.ini` Gitea должен быть включён раздел `[actions] ENABLED = true`, а у репозитория + включены Actions (Settings, Repository, Enable Repository Actions). +- Первая сборка долгая (Slint, GStreamer-биндинги, opus из исходников). Кэш cargo + (`actions/cache`) ускоряет последующие. Для сборки нужно около 8 ГБ RAM и 10 ГБ диска. +- Workflow ставит зависимости через `apt-get`; образ `catthehacker/ubuntu` работает от root, + поэтому `sudo` не нужен (скрипты используют его, только если он есть). +- Шаги `actions/checkout` и `actions/cache` скачиваются с адреса, заданного в + `[actions] DEFAULT_ACTIONS_URL` (по умолчанию GitHub). Если исходящий доступ закрыт, + зеркалируйте эти actions в свой Gitea. +- Для `actions/cache` нужен cache server act_runner (включён по умолчанию, секция `cache` в + `config.yaml`). Без него шаг кэша завершается предупреждением, а сборка идёт дальше. + +## Секреты и переменные + +Settings, Actions, Secrets (репозиторий или организация): + +| Имя | Обязателен | Описание | +| --- | --- | --- | +| `VNOX_RELEASE_SIGNING_KEY` | да | Приватный ключ Ed25519: base64 от сырого 32-байтного seed. Без него релиз-джоба падает и ничего не публикует. | +| `RELEASE_TOKEN` | нет | Персональный токен Gitea со scope `write:repository`. Если не задан, используется встроенный `GITHUB_TOKEN`. Задайте, если у встроенного токена нет прав на создание релизов. | + +Settings, Actions, Variables: + +| Имя | Описание | +| --- | --- | +| `VNOX_MIN_VERSION` | Необязательно. Минимальная поддерживаемая версия клиента, попадает в `manifest.json` (`min_version`). По умолчанию `0.0.0`. | + +## Как выпустить релиз + +1. Поднимите `version` в `Cargo.toml` (например `0.2.0`) и обновите `Cargo.lock` + (`cargo check`). +2. В `CHANGELOG.md` переименуйте раздел `[Unreleased]` в `## [0.2.0] - ГГГГ-ММ-ДД` + (формат заголовка: `## [версия]`). Текст раздела станет описанием релиза; пустой или + отсутствующий раздел останавливает релиз. +3. Закоммитьте, дождитесь зелёного CI и поставьте тег: + + ```sh + git tag v0.2.0 + git push origin v0.2.0 + ``` + +4. Workflow `release` проверит, что: + - задан секрет `VNOX_RELEASE_SIGNING_KEY`; + - версия тега (без `v`) равна `version` в `Cargo.toml`, иначе релиз отклоняется; + - в `CHANGELOG.md` есть непустой раздел для этой версии. +5. Затем он соберёт артефакты, подпишет манифест и создаст релиз в Gitea (сначала как + черновик, публикуется после загрузки всех файлов). + +Теги с суффиксом (`v0.2.0-rc.1`) попадают в канал `beta` и помечаются как pre-release; +остальные идут в канал `stable`. + +### Артефакты релиза + +- `vnox-client-<версия>-linux-x86_64.tar.gz`: бинарник `vnox-client`, `LICENSE`, `README.md`; +- `vnox-client-<версия>-windows-x86_64.zip`: `vnox-client.exe`, `LICENSE`, `README.md` + (кросс-компиляция из Linux, target `x86_64-pc-windows-gnu`, mingw-w64); +- `SHA256SUMS`: хэши архивов (`sha256sum -c SHA256SUMS`); +- `manifest.json` и `manifest.json.sig`: подписанный манифест для апдейтера. + +Windows-сборка не включает `screen-capture`: его зависимости (zbus, GStreamer) объявлены +только для `target_os = "linux"`. + +## Манифест и подпись + +`manifest.json` записывается в канонической форме: UTF-8, ключи отсортированы, без +пробелов, без перевода строки в конце. `manifest.json.sig` содержит base64 от подписи +Ed25519 (64 байта) над точными байтами файла `manifest.json`. + +Поля манифеста: + +```json +{ + "schema": 1, + "product": "vnox-client", + "version": "0.2.0", + "channel": "stable", + "min_version": "0.0.0", + "published_at": "2026-11-01T14:44:21Z", + "artifacts": [ + {"platform": "linux-x86_64", "name": "...", "url": "...", "sha256": "...", "size": 123} + ] +} +``` + +Алгоритм проверки в апдейтере: + +1. Скачать `manifest.json` и `manifest.json.sig`. +2. Проверить подпись Ed25519 над сырыми байтами файла вшитым публичным ключом. Только + после успеха разбирать JSON. +3. Сравнить `version` с текущей, учесть `min_version` и `channel`. +4. Скачать артефакт для своей платформы, проверить `size` и `sha256`, и только потом применять. + +Публичный ключ нужно вшить в клиент как константу (например, в модуль апдейтера +`src/update/`), в виде 32 сырых байт. `scripts/release/keygen.py` печатает его и в base64, +и в виде готовой Rust-константы `RELEASE_PUBLIC_KEY: [u8; 32]`. + +## Скрипты `scripts/release/` + +Требуется Python 3 и пакет `cryptography` (`pip install cryptography`). + +- `keygen.py`: генерирует пару ключей; `--private-out FILE` пишет seed в файл с правами 0600. +- `manifest.py build|sign|verify`: сборка, подпись и проверка манифеста. +- `extract_changelog.py VERSION`: выводит раздел `CHANGELOG.md` для версии. + +Локальная проверка подписи (публичный ключ в base64): + +```sh +scripts/release/manifest.py verify --manifest manifest.json \ + --sig manifest.json.sig --public-key +``` + +## Генерация и ротация ключа + +Первичная генерация: + +```sh +python3 -m pip install cryptography +scripts/release/keygen.py --private-out vnox-release.key +``` + +1. Содержимое `vnox-release.key` сохраните в секрет `VNOX_RELEASE_SIGNING_KEY`. +2. Файл ключа уберите в менеджер паролей или офлайн-хранилище и удалите с рабочей машины. + Никогда не коммитьте его. +3. Публичный ключ (вывод скрипта) вшейте в клиент и выпустите релиз с ним. + +Ротация (плановая или при компрометации): + +1. Сгенерируйте новую пару ключей. +2. Плановая ротация: выпустите релиз, подписанный старым ключом, в который вшиты оба + публичных ключа (старый и новый; апдейтер принимает подпись любого из них). Когда + большинство пользователей обновилось, замените секрет `VNOX_RELEASE_SIGNING_KEY` на + новый ключ и выпускайте релизы уже им, затем удалите старый публичный ключ из клиента + в одном из следующих релизов. +3. Компрометация: сразу замените секрет, отзовите (удалите) релизы, подписанные + скомпрометированным ключом. Клиенты со старым ключом без нового публичного ключа + придётся обновлять вручную, поэтому держите в клиенте запасной публичный ключ заранее. +4. После смены секрета проверьте подпись следующего релиза скриптом `manifest.py verify`. + +## Безопасность пайплайна + +- Job `build` не имеет секретов и не использует кеш; он собирает артефакты и проверяет, что тег стоит на коммите из `main`. +- Job `publish` получает `VNOX_RELEASE_SIGNING_KEY` и токен только в тех шагах, где они нужны, проверяет `SHA256SUMS` и подписывает manifest. +- Рекомендуется включить защищённые теги `v*` в настройках репозитория Gitea (кто может создавать теги релиза). +- Gitea 1.22 поддерживает `actions/upload-artifact@v3`/`download-artifact@v3`, не v4. + +## Раннер + +Workflow используют метку `self-hosted` (раннер `pink-star-ci`, режим хоста). На хосте должны быть: Rust stable ≥ 1.94 (или rustup), Node.js для `actions/*`, и пакеты из шага «Install system dependencies» (apt пропускается, если нет root/sudo без пароля). + +### Риски self-hosted раннера + +Раннер работает на хосте без изоляции, поэтому: CI пропускает PR из форков; в настройках репозитория отключите workflow для форков и требуйте одобрения для первых участников; раннер не должен работать от root; секреты лежат только в репозитории и доступны лишь job `publish`. Лучшее решение — отдельные метки (`ci-ephemeral` для CI и `release-signing` для публикации) и контейнерный раннер для CI, когда появится второй хост. + +Сборка релиза использует одноразовые `CARGO_HOME`/`RUSTUP_HOME` в `$RUNNER_TEMP` (тулчейн ставится с нуля, постоянные настройки хоста игнорируются); подпись запускается как `python3 -I`; при отсутствии зависимостей job падает, а не продолжается. Остаточный риск: одна машина и для CI, и для подписи. Для полной изоляции нужны отдельные раннеры с метками `ci-untrusted` и `release-signing`. diff --git a/scripts/release/extract_changelog.py b/scripts/release/extract_changelog.py new file mode 100755 index 0000000..5b4549e --- /dev/null +++ b/scripts/release/extract_changelog.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Print the body of the CHANGELOG.md section for a version ("## [X.Y.Z] ..."). + +Exits non-zero if the section is missing or empty. +Usage: extract_changelog.py VERSION [CHANGELOG.md] +""" +import re +import sys + + +def main() -> int: + if len(sys.argv) < 2: + sys.exit(__doc__) + version = sys.argv[1].lstrip("v") + path = sys.argv[2] if len(sys.argv) > 2 else "CHANGELOG.md" + with open(path, encoding="utf-8") as f: + lines = f.read().splitlines() + head = re.compile(r"^## \[" + re.escape(version) + r"\]") + out, inside = [], False + for line in lines: + if inside and line.startswith("## "): + break + if inside: + out.append(line) + elif head.match(line): + inside = True + body = "\n".join(out).strip() + if not inside or not body: + sys.exit(f"CHANGELOG.md has no non-empty section for [{version}]") + print(body) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/release/keygen.py b/scripts/release/keygen.py new file mode 100755 index 0000000..2e35dbe --- /dev/null +++ b/scripts/release/keygen.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +"""Generate an Ed25519 release signing key pair for VNOX. + +The private key is a base64 encoded raw 32 byte seed. Store it ONLY in the +Gitea secret VNOX_RELEASE_SIGNING_KEY. The public key is printed as base64 (raw +32 bytes) and as a Rust byte array, to be embedded in the client updater. + +Usage: + scripts/release/keygen.py # print both keys to stdout + scripts/release/keygen.py --private-out key.b64 # write the seed to a 0600 file +""" +import argparse +import base64 +import os +import sys + +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey + + +def main() -> int: + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("--private-out", help="write the private seed to this file (mode 0600) instead of stdout") + args = ap.parse_args() + + key = Ed25519PrivateKey.generate() + seed = key.private_bytes( + serialization.Encoding.Raw, serialization.PrivateFormat.Raw, serialization.NoEncryption() + ) + pub = key.public_key().public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw) + seed_b64 = base64.b64encode(seed).decode() + pub_b64 = base64.b64encode(pub).decode() + + if args.private_out: + fd = os.open(args.private_out, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) + with os.fdopen(fd, "w") as f: + f.write(seed_b64 + "\n") + print(f"private seed written to {args.private_out} (mode 0600)") + else: + print(f"VNOX_RELEASE_SIGNING_KEY (private, secret, base64 seed):\n{seed_b64}\n") + print(f"public key (base64, raw 32 bytes):\n{pub_b64}\n") + rust = ", ".join(f"0x{b:02x}" for b in pub) + print("Rust constant for the updater:") + print(f"pub const RELEASE_PUBLIC_KEY: [u8; 32] = [{rust}];") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/release/manifest.py b/scripts/release/manifest.py new file mode 100755 index 0000000..6127aea --- /dev/null +++ b/scripts/release/manifest.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python3 +"""Build, sign and verify the VNOX release manifest. + +Canonical form: UTF-8 JSON, keys sorted, no whitespace (separators "," and ":"), +ensure_ascii=False, no trailing newline. manifest.json is written in exactly this +form, and manifest.json.sig is the base64 Ed25519 signature over those exact bytes. +A verifier checks the signature over the raw file bytes first, then parses. + +Subcommands: + build --version V --channel C --min-version M --base-url URL [--published-at TS] + --dir DIR --out manifest.json NAME=PLATFORM [NAME=PLATFORM ...] + sign --manifest manifest.json --out manifest.json.sig + (key from env VNOX_RELEASE_SIGNING_KEY: base64 raw 32 byte seed) + verify --manifest manifest.json --sig manifest.json.sig --public-key BASE64 +""" +import argparse +import base64 +import datetime +import hashlib +import json +import os +import sys + +from cryptography.exceptions import InvalidSignature +from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey + +SCHEMA = 1 + + +def canonical(obj) -> bytes: + return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8") + + +def sha256_file(path: str): + h = hashlib.sha256() + n = 0 + with open(path, "rb") as f: + for chunk in iter(lambda: f.read(1 << 20), b""): + h.update(chunk) + n += len(chunk) + return h.hexdigest(), n + + +def cmd_build(a) -> int: + artifacts = [] + for spec in a.artifacts: + name, _, platform = spec.partition("=") + if not name or not platform: + sys.exit(f"bad artifact spec {spec!r}, expected NAME=PLATFORM") + digest, size = sha256_file(os.path.join(a.dir, name)) + artifacts.append( + { + "name": name, + "platform": platform, + "sha256": digest, + "size": size, + "url": f"{a.base_url.rstrip('/')}/{name}", + } + ) + published = a.published_at or datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + manifest = { + "schema": SCHEMA, + "product": "vnox-client", + "version": a.version, + "channel": a.channel, + "min_version": a.min_version, + "published_at": published, + "artifacts": sorted(artifacts, key=lambda x: x["platform"]), + } + with open(a.out, "wb") as f: + f.write(canonical(manifest)) + print(f"wrote {a.out}") + return 0 + + +def load_private() -> Ed25519PrivateKey: + raw = os.environ.get("VNOX_RELEASE_SIGNING_KEY", "").strip() + if not raw: + sys.exit("VNOX_RELEASE_SIGNING_KEY is empty or unset, refusing to sign") + try: + seed = base64.b64decode(raw, validate=True) + except Exception: + sys.exit("VNOX_RELEASE_SIGNING_KEY is not valid base64") + if len(seed) != 32: + sys.exit(f"VNOX_RELEASE_SIGNING_KEY must decode to 32 bytes, got {len(seed)}") + return Ed25519PrivateKey.from_private_bytes(seed) + + +def cmd_sign(a) -> int: + with open(a.manifest, "rb") as f: + data = f.read() + # The signed bytes must be canonical, so that re-serialisation can never change them. + if canonical(json.loads(data)) != data: + sys.exit("manifest is not in canonical form, refusing to sign") + key = load_private() + sig = key.sign(data) + key.public_key().verify(sig, data) + with open(a.out, "w") as f: + f.write(base64.b64encode(sig).decode() + "\n") + print(f"wrote {a.out}") + return 0 + + +def cmd_verify(a) -> int: + with open(a.manifest, "rb") as f: + data = f.read() + with open(a.sig) as f: + sig = base64.b64decode(f.read().strip(), validate=True) + pub = Ed25519PublicKey.from_public_bytes(base64.b64decode(a.public_key, validate=True)) + try: + pub.verify(sig, data) + except InvalidSignature: + print("signature INVALID", file=sys.stderr) + return 1 + print("signature ok") + return 0 + + +def main() -> int: + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + sub = ap.add_subparsers(dest="cmd", required=True) + b = sub.add_parser("build") + b.add_argument("--version", required=True) + b.add_argument("--channel", required=True, choices=["stable", "beta"]) + b.add_argument("--min-version", default="0.0.0") + b.add_argument("--base-url", required=True) + b.add_argument("--published-at") + b.add_argument("--dir", default=".") + b.add_argument("--out", required=True) + b.add_argument("artifacts", nargs="+") + b.set_defaults(fn=cmd_build) + s = sub.add_parser("sign") + s.add_argument("--manifest", required=True) + s.add_argument("--out", required=True) + s.set_defaults(fn=cmd_sign) + v = sub.add_parser("verify") + v.add_argument("--manifest", required=True) + v.add_argument("--sig", required=True) + v.add_argument("--public-key", required=True) + v.set_defaults(fn=cmd_verify) + a = ap.parse_args() + return a.fn(a) + + +if __name__ == "__main__": + sys.exit(main())