merge: gitea CI and release pipeline

This commit is contained in:
Loki 2026-11-01 16:32:42 +01:00
commit 7b691bed2a
Signed by: boba
GPG key ID: 253067914055423B
6 changed files with 724 additions and 0 deletions

70
.gitea/workflows/ci.yml Normal file
View file

@ -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

View file

@ -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"

187
docs/release.md Normal file
View file

@ -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` с <https://gitea.com/gitea/act_runner/releases>.
3. Зарегистрируйте runner:
```sh
./act_runner register --no-interactive \
--instance https://git.wihuk.pro \
--token <REGISTRATION_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 <PUBLIC_KEY_B64>
```
## Генерация и ротация ключа
Первичная генерация:
```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`.

View file

@ -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())

49
scripts/release/keygen.py Executable file
View file

@ -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())

146
scripts/release/manifest.py Executable file
View file

@ -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())