feat(releaseupdate): signed OCI distribution sources for releases and the catalogue (#1715)
Quality / check (push) Successful in 5m53s
deploy / gate (push) Canceled after 0s
deploy / archied-image (push) Canceled after 0s
deploy / agent-image (push) Canceled after 0s
deploy / dist-zip (push) Canceled after 0s

This commit is contained in:
sam committed 2026-10-31 18:18:43 +11:00
1 parent c87b0c31e1
commit 9d8f364af1
37 files changed
+1349 -656

No files matched your search

+30 -39
View File
@@ -373,45 +373,45 @@ jobs:
# rather than fail the release on its absence. # rather than fail the release on its absence.
[ -f README.md ] && cp README.md "$name/" [ -f README.md ] && cp README.md "$name/"
zip -r "$name.zip" "$name" zip -r "$name.zip" "$name"
sha256sum "$name.zip" > SHA256SUMS
echo "name=$name" >> "$GITHUB_OUTPUT" echo "name=$name" >> "$GITHUB_OUTPUT"
- name: Upload distribution zip - name: Upload distribution zip
uses: actions/upload-artifact@v4 uses: actions/upload-artifact@v4
with: with:
name: ${{ steps.zip.outputs.name }} name: ${{ steps.zip.outputs.name }}
path: | path: ${{ steps.zip.outputs.name }}.zip
${{ steps.zip.outputs.name }}.zip
SHA256SUMS
retention-days: 90 retention-days: 90
# A release is what an operator can actually download from; the # Installs and updates take a release from the signed artifact in the
# artifact above is reachable only from the run's page, behind a # registry, so this is what publishes it: the statement signed with
# login, and expires after 90 days. Until this step existed the # RELEASE_SIGNING_KEY and the zip, tagged v<version>, next, and stable
# zip was produced and then stranded. # unless it is a prerelease.
# - name: Log in to the Gitea registry
# The release lives on this repository, attached to the release's v* run: echo "${{ secrets.DEPLOY_TOKEN }}" | docker login git.catlow.cloud -u "${{ github.actor }}" --password-stdin
# tag, or the archied tag for a release cut before the single release
# stream. The body is the changelog section -- the release's own - name: Publish the signed release
# reviewed prose -- not generated notes: the tag/changelog gate above env:
# already guarantees it describes this version. ARCHIE_RELEASE_SEED: ${{ secrets.RELEASE_SIGNING_KEY }}
- name: Publish Gitea release with the distribution zip run: |
set -e
version="${{ steps.version.outputs.version }}"
prerelease=false
case "$version" in *-*) prerelease=true ;; esac
./dist/archied release publish -source git.catlow.cloud/sam/archie \
-version "$version" -prerelease="$prerelease" \
-zip "${{ steps.zip.outputs.name }}.zip" \
-agent-image "git.catlow.cloud/sam/archie-agent@${{ needs.agent-image.outputs.agent_digest }}" \
-changelog "https://git.catlow.cloud/sam/archie/releases/tag/v$version"
# The release page carries this version's changelog section, the
# release's own reviewed prose; the signed statement links to it.
- name: Publish the Gitea release notes
env: env:
# One PAT covers this step and the image jobs' registry login. It
# needs write:packages and write:repository scopes.
DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }} DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }}
run: | run: |
set -e set -e
tag="v${{ steps.version.outputs.version }}" tag="v${{ steps.version.outputs.version }}"
if ! git ls-remote --exit-code --tags origin "refs/tags/$tag" >/dev/null; then
tag="archied/v${{ steps.version.outputs.version }}"
fi
version="${{ steps.version.outputs.version }}" version="${{ steps.version.outputs.version }}"
# The release body is this version's changelog section, not the whole
# file: from its "## [x.y.z]" heading to the next "## [" heading.
# Extracting rather than inlining keeps the changelog the single
# source of truth, and the tag/changelog gate above has already
# proven that section exists.
notes="$(mktemp)" notes="$(mktemp)"
awk -v hdr="## [$version]" ' awk -v hdr="## [$version]" '
index($0, hdr) == 1 { printing = 1 } index($0, hdr) == 1 { printing = 1 }
@@ -425,19 +425,10 @@ jobs:
api="https://git.catlow.cloud/api/v1" api="https://git.catlow.cloud/api/v1"
repo="sam/archie" repo="sam/archie"
auth="Authorization: token $DEPLOY_TOKEN" auth="Authorization: token $DEPLOY_TOKEN"
# Idempotent: drop any release already on the tag and recreate it, # Idempotent: a re-run replaces the release on the tag.
# so a re-run of this job (a retried or superseded deploy) cannot
# fail on an existing release or duplicate the zip. Deleting a
# release leaves the tag itself alone.
curl -sf -X DELETE -H "$auth" "$api/repos/$repo/releases/tags/$tag" >/dev/null || true curl -sf -X DELETE -H "$auth" "$api/repos/$repo/releases/tags/$tag" >/dev/null || true
id="$(curl -sf -X POST -H "$auth" -H "Content-Type: application/json" \ curl -sf -X POST -H "$auth" -H "Content-Type: application/json" \
-d "$(jq -n --arg tag "$tag" --arg name "archied v$version" --arg body "$(cat "$notes")" \ -d "$(jq -n --arg tag "$tag" --arg name "Archie v$version" --arg body "$(cat "$notes")" \
'{tag_name: $tag, name: $name, body: $body, draft: false, prerelease: false}')" \ '{tag_name: $tag, name: $name, body: $body, draft: false, prerelease: false}')" \
"$api/repos/$repo/releases" | jq -r '.id')" "$api/repos/$repo/releases" >/dev/null
test -n "$id" echo "published release notes for $tag"
for asset in "${{ steps.zip.outputs.name }}.zip" SHA256SUMS install.sh; do
curl -sf -X POST -H "$auth" -H "Content-Type: application/octet-stream" \
--data-binary "@$asset" \
"$api/repos/$repo/releases/$id/assets?name=$(basename "$asset")" >/dev/null
done
echo "published $tag with ${{ steps.zip.outputs.name }}.zip"
+2
View File
@@ -7,6 +7,8 @@ release's per-component sections are labelled beneath its heading.
### archied ### archied
- Releases are signed. A release is an OCI artifact whose statement is signed with the release key; updates and `install.sh` refuse a release the key did not sign, a zip that is not the one signed, and a channel moved back to an older release. Releases now come from `git.catlow.cloud/sam/archie`, so a host on 1.55.0 or earlier finds this release only by running the new installer once: `curl -fsSL https://offloaded.dev/install.sh | bash`.
- Where releases and the extension catalogue come from is a setting: an OCI repository and the key it signs with, in the update settings and the extension settings, or `[distribution]` in `config.toml` for a new instance. `archied release keygen` and `archied release publish` make a key and publish signed releases to your own registry.
- Chat saves the workflow draft it writes with `workflow_draft` instead of handing over YAML to paste: the draft lands in the workflow editor for review, attributed to the signed-in account. - Chat saves the workflow draft it writes with `workflow_draft` instead of handing over YAML to paste: the draft lands in the workflow editor for review, attributed to the signed-in account.
## [1.55.0] - 2026-10-16 ## [1.55.0] - 2026-10-16
+1 -1
View File
@@ -101,7 +101,7 @@ or a hosted provider API key.
1. **Install.** 1. **Install.**
```bash ```bash
curl -fsSL https://raw.githubusercontent.com/samcharles93/archie-core/main/install.sh | bash curl -fsSL https://offloaded.dev/install.sh | bash
``` ```
It downloads the latest release, verifies its checksum, installs the five It downloads the latest release, verifies its checksum, installs the five
+7 -7
View File
@@ -58,14 +58,14 @@ task release:prepare VERSION=1.3.0 # write the section into CHANGELOG.md, un
# edit CHANGELOG.md -- generated notes are a starting point, not the release # edit CHANGELOG.md -- generated notes are a starting point, not the release
task release VERSION=1.3.0 # commit + annotated tag task release VERSION=1.3.0 # commit + annotated tag
git push --atomic origin main v1.3.0 # both refs or neither git push --atomic origin main v1.3.0 # both refs or neither
task release:publish VERSION=1.3.0 # images to GHCR, zip to archie-releases
``` ```
The source repository is private, so releases are published to the public Pushing the tag is the release. The deploy workflow builds the images and the
`samcharles93/archie-releases` repository, where `install.sh` and the zip, then `archied release publish` signs the release with the
updater find them. `release:publish` builds from a clean worktree of the tag `RELEASE_SIGNING_KEY` Actions secret and pushes it to
and needs `gh` and `docker` logged in with write access to that repository `git.catlow.cloud/sam/archie` as `v1.3.0`, `next`, and `stable` unless the
and to GHCR. version is a prerelease. `install.sh` and the updater install only what that
key signed.
`release:prepare` emits bare commit subjects; they are a starting point. Rewrite `release:prepare` emits bare commit subjects; they are a starting point. Rewrite
them to say what a reader gets, per "What the notes are for" above. them to say what a reader gets, per "What the notes are for" above.
@@ -106,7 +106,7 @@ Tagging one version produces, from a single `deploy` run:
rebuilt by the release, so runtime commits merged to `main` do not reach a rebuilt by the release, so runtime commits merged to `main` do not reach a
running sandbox until the host pulls the new image. The hand-run running sandbox until the host pulls the new image. The hand-run
`tools/publish.sh` publishes the same two images to `tools/publish.sh` publishes the same two images to
`ghcr.io/samcharles93` instead, which is the registry the binary's default `git.catlow.cloud/sam` instead, which is the registry the binary's default
`[containers].image` names. `[containers].image` names.
- **`:latest` names the newest release, not the newest commit.** A push to - **`:latest` names the newest release, not the newest commit.** A push to
`main` that is not a release publishes `archied:edge` (mutable, tracking `main` that is not a release publishes `archied:edge` (mutable, tracking
-7
View File
@@ -319,10 +319,3 @@ tasks:
- tools/release.sh --version {{.VERSION}} --tag - tools/release.sh --version {{.VERSION}} --tag
requires: requires:
vars: [VERSION] vars: [VERSION]
release:publish:
desc: Push the images and publish the pushed tag to the public releases repository (VERSION=1.2.0)
cmds:
- tools/publish.sh {{.VERSION}}
requires:
vars: [VERSION]
+3 -1
View File
@@ -12,7 +12,7 @@ import (
) )
const commandUsage = "usage: archied [flags] # run the daemon; archied -h lists the flags\n" + const commandUsage = "usage: archied [flags] # run the daemon; archied -h lists the flags\n" +
"subcommands: setup, update, status, prbench, playbooks" "subcommands: setup, update, release, status, prbench, playbooks"
func main() { func main() {
os.Exit(run(os.Args[1:])) os.Exit(run(os.Args[1:]))
@@ -29,6 +29,8 @@ func run(args []string) int {
switch args[0] { switch args[0] {
case "update": case "update":
return archied.RunUpdate(args[1:], os.Stdout, os.Stderr) return archied.RunUpdate(args[1:], os.Stdout, os.Stderr)
case "release":
return archied.RunRelease(args[1:], os.Stdout, os.Stderr)
case "status": case "status":
return archied.RunStatus(args[1:], os.Stdout, os.Stderr) return archied.RunStatus(args[1:], os.Stdout, os.Stderr)
case "prbench": case "prbench":
+9
View File
@@ -85,3 +85,12 @@ target = "127.0.0.1:9090"
# Store's sweep deletes it. Zero means 90 days. # Store's sweep deletes it. Zero means 90 days.
# [access] # [access]
# denial_retention = "2160h" # denial_retention = "2160h"
# Where releases and the extension catalogue come from on a new instance: an
# OCI repository and the base64 ed25519 key it signs with. Blank is the
# official source. Once stored, change them in the dashboard settings.
# [distribution]
# releases = "registry.example/owner/archie"
# releases_key = "base64 public key"
# catalogue = "registry.example/owner/archipelago/catalogue"
# catalogue_key = "base64 public key"
+8 -7
View File
@@ -23,7 +23,7 @@ of its own (`deployments/systemd-user-service.md`).
ships beside `archied` because a Kit run mounts it from that directory. The ships beside `archied` because a Kit run mounts it from that directory. The
agent image is a separate thing, pulled for the containers `archied` spawns agent image is a separate thing, pulled for the containers `archied` spawns
per task: `[containers].image` defaults to per task: `[containers].image` defaults to
`ghcr.io/samcharles93/archie-agent:latest`, while this archive's `release.json` `git.catlow.cloud/sam/archie-agent:latest`, while this archive's `release.json`
pins the digest the release published. Set `[containers].registry_auth` when pins the digest the release published. Set `[containers].registry_auth` when
that reference is on a registry that needs a login -- see that reference is on a registry that needs a login -- see
`deployments/systemd-user-service.md#6-pinning-the-archie-agent-image`. `deployments/systemd-user-service.md#6-pinning-the-archie-agent-image`.
@@ -32,7 +32,7 @@ that reference is on a registry that needs a login -- see
1. Pick a starting configuration. The full set of annotated templates lives 1. Pick a starting configuration. The full set of annotated templates lives
in this repository's `deployments/` directory on GitHub in this repository's `deployments/` directory on GitHub
(<https://github.com/samcharles93/archie-core/tree/main/deployments>) — (<https://offloaded.dev>) —
`standalone.toml` (no forge, the simplest start), `standalone.toml` (no forge, the simplest start),
`single-forge-github.toml` and `docker-nats-stack.toml` cover the common cases. Every one needs `single-forge-github.toml` and `docker-nats-stack.toml` cover the common cases. Every one needs
PostgreSQL 18 at `database_url`. Copy whichever fits to: PostgreSQL 18 at `database_url`. Copy whichever fits to:
@@ -65,7 +65,7 @@ that reference is on a registry that needs a login -- see
4. For a persistent, 24/7 deployment instead of a foreground run, follow the 4. For a persistent, 24/7 deployment instead of a foreground run, follow the
systemd user-unit runbook: systemd user-unit runbook:
<https://github.com/samcharles93/archie-core/blob/main/deployments/systemd-user-service.md>. <https://offloaded.dev>.
## Verifying an install ## Verifying an install
@@ -89,10 +89,11 @@ an install (or an upgrade across v1.30.0) needs its unit as well -- see
### Native self-update ### Native self-update
Install on Settings → Status runs `archied update install -version X`, which Install on Settings → Status runs `archied update install -version X` against
downloads the release's Linux/amd64 zip and verifies it against `SHA256SUMS` the release source in the update settings. It fetches release `vX`, refuses it
before unpacking it. Every host binary in the zip must report `X`. It then pulls unless the source's key signed its statement, and downloads the Linux/amd64 zip
the agent image `release.json` pins by digest, backs up the database to only if it hashes to the digest that statement names. Every host binary in the
zip must report `X`. It then pulls the agent image the statement pins by digest, backs up the database to
`db.pre-update.dump` in the state directory, stages the new binaries beside the `db.pre-update.dump` in the state directory, stages the new binaries beside the
live ones and hands the transaction to `archied update watchdog` in a process of live ones and hands the transaction to `archied update watchdog` in a process of
its own (a transient systemd user unit). Nothing that runs changes until the its own (a transient systemd user unit). Nothing that runs changes until the
+1 -1
View File
@@ -55,7 +55,7 @@ mode = "embedded"
# Pinned to a verified digest -- archie-agent has no published semver tag # Pinned to a verified digest -- archie-agent has no published semver tag
# yet (a release publishes :latest and :sha-<commit>). See # yet (a release publishes :latest and :sha-<commit>). See
# deployments/systemd-user-service.md#6-pinning-the-archie-agent-image. # deployments/systemd-user-service.md#6-pinning-the-archie-agent-image.
image = "ghcr.io/samcharles93/archie-agent@sha256:870f1b1357979cfea23fccacb24166ebeb9ab321708ef2c2b218a763ed99b090" image = "git.catlow.cloud/sam/archie-agent@sha256:<digest>"
pull_policy = "missing" pull_policy = "missing"
[budgets] [budgets]
+6 -6
View File
@@ -134,7 +134,7 @@ Compose service or host `archie-agent` binary is required.
Docker must be installed and reachable by the service user. With no explicit Docker must be installed and reachable by the service user. With no explicit
broker or container settings, Archie defaults `containers.image` to broker or container settings, Archie defaults `containers.image` to
`ghcr.io/samcharles93/archie-agent:latest`. `single-forge-github.toml` and `git.catlow.cloud/sam/archie-agent:latest`. `single-forge-github.toml` and
`docker-nats-stack.toml` override that default with a pinned reference `docker-nats-stack.toml` override that default with a pinned reference
(`standalone.toml` and `dev.toml` leave it) -- see (`standalone.toml` and `dev.toml` leave it) -- see
[Pinning the archie-agent image](#6-pinning-the-archie-agent-image) below. An [Pinning the archie-agent image](#6-pinning-the-archie-agent-image) below. An
@@ -145,7 +145,7 @@ explicit equivalent, pinned the same way, is:
mode = "embedded" mode = "embedded"
[containers] [containers]
image = "ghcr.io/samcharles93/archie-agent@sha256:870f1b1357979cfea23fccacb24166ebeb9ab321708ef2c2b218a763ed99b090" image = "git.catlow.cloud/sam/archie-agent@sha256:<digest>"
pull_policy = "missing" pull_policy = "missing"
``` ```
@@ -177,7 +177,7 @@ prior build. Two paths publish it, to different references:
as `:latest` and `:sha-<commit>` when the commit carries a release tag; an as `:latest` and `:sha-<commit>` when the commit carries a release tag; an
ordinary push to `main` publishes nothing for the agent image. ordinary push to `main` publishes nothing for the agent image.
- `tools/publish.sh`, run by hand for a release, publishes - `tools/publish.sh`, run by hand for a release, publishes
`ghcr.io/samcharles93/archie-agent` as `:latest` and `:sha-<commit>`, which is `git.catlow.cloud/sam/archie-agent` as `:latest` and `:sha-<commit>`, which is
the registry the shipped default above names. the registry the shipped default above names.
A distribution zip pins whichever one its own release published, by digest, in A distribution zip pins whichever one its own release published, by digest, in
@@ -192,19 +192,19 @@ explicitly:
```toml ```toml
[containers] [containers]
image = "ghcr.io/samcharles93/archie-agent@sha256:870f1b1357979cfea23fccacb24166ebeb9ab321708ef2c2b218a763ed99b090" image = "git.catlow.cloud/sam/archie-agent@sha256:<digest>"
``` ```
This is the digest `latest` resolved to on 2026-09-05. Digest pinning is the This is the digest `latest` resolved to on 2026-09-05. Digest pinning is the
strongest option for production: it is immutable and independently strongest option for production: it is immutable and independently
verifiable (`docker manifest inspect ghcr.io/samcharles93/archie-agent@sha256:...`), verifiable (`docker manifest inspect git.catlow.cloud/sam/archie-agent@sha256:...`),
at the cost of being opaque in a config file a human is meant to edit -- at the cost of being opaque in a config file a human is meant to edit --
resolve a fresh digest deliberately (`docker pull ...:latest` followed by resolve a fresh digest deliberately (`docker pull ...:latest` followed by
`docker inspect --format '{{index .RepoDigests 0}}'`) rather than editing this `docker inspect --format '{{index .RepoDigests 0}}'`) rather than editing this
one in place expecting it to track new releases. one in place expecting it to track new releases.
If/when CI starts publishing a semantic-version tag for `archie-agent` If/when CI starts publishing a semantic-version tag for `archie-agent`
(e.g. `ghcr.io/samcharles93/archie-agent:v1.21.0`), prefer that tag for (e.g. `git.catlow.cloud/sam/archie-agent:v1.21.0`), prefer that tag for
day-to-day config readability, and reserve digest pinning for deployments day-to-day config readability, and reserve digest pinning for deployments
that need byte-for-byte reproducibility guarantees a tag alone cannot give that need byte-for-byte reproducibility guarantees a tag alone cannot give
(tags are mutable pointers; a compromised or accidentally-overwritten tag (tags are mutable pointers; a compromised or accidentally-overwritten tag
+1 -1
View File
@@ -95,7 +95,7 @@ services:
# name by digest. The digest a task container actually runs is pinned in # name by digest. The digest a task container actually runs is pinned in
# the daemon's own [containers] image, so nothing here decides it. See # the daemon's own [containers] image, so nothing here decides it. See
# deployments/systemd-user-service.md#6-pinning-the-archie-agent-image. # deployments/systemd-user-service.md#6-pinning-the-archie-agent-image.
image: ghcr.io/samcharles93/archie-agent:latest image: git.catlow.cloud/sam/archie-agent:latest
# ── example agent profile image ───────────────────────────────────── # ── example agent profile image ─────────────────────────────────────
# The agent image plus network lookup tools, for a workflow that names # The agent image plus network lookup tools, for a workflow that names
+1 -1
View File
@@ -3,7 +3,7 @@
# the network-investigator profile package (archipelago: profiles/network-investigator). # the network-investigator profile package (archipelago: profiles/network-investigator).
# #
# Build: docker compose build agent-net # Build: docker compose build agent-net
ARG AGENT_IMAGE=ghcr.io/samcharles93/archie-agent:latest ARG AGENT_IMAGE=git.catlow.cloud/sam/archie-agent:latest
FROM ${AGENT_IMAGE} FROM ${AGENT_IMAGE}
RUN apt-get update && apt-get install -y --no-install-recommends \ RUN apt-get update && apt-get install -y --no-install-recommends \
+73 -27
View File
@@ -1,16 +1,25 @@
#!/usr/bin/env bash #!/usr/bin/env bash
# install.sh - installs Archie Core for the current user. # install.sh - installs Archie Core for the current user.
# #
# curl -fsSL https://raw.githubusercontent.com/samcharles93/archie-core/main/install.sh | bash # curl -fsSL https://offloaded.dev/install.sh | bash
# #
# Downloads the latest release, verifies it against SHA256SUMS, installs the # Downloads a release from its OCI registry, verifies the release key signed
# it and that the zip is the one signed, installs the
# five services to ${XDG_BIN_HOME:-~/.local/bin}, runs `archied setup`, starts # five services to ${XDG_BIN_HOME:-~/.local/bin}, runs `archied setup`, starts
# the bundled PostgreSQL and installs systemd user units. # the bundled PostgreSQL and installs systemd user units.
# Config: ${XDG_CONFIG_HOME:-~/.config}/archie Data: ${XDG_DATA_HOME:-~/.local/share}/archie # Config: ${XDG_CONFIG_HOME:-~/.config}/archie Data: ${XDG_DATA_HOME:-~/.local/share}/archie
set -euo pipefail set -euo pipefail
REPO="samcharles93/archie-releases" MODULE="github.com/samcharles93/archie-core"
SOURCE_GIT="https://git.catlow.cloud/sam/archie.git"
# Where releases come from: an OCI repository and the base64 ed25519 key that
# must have signed them. A self-hosted source sets both.
DEFAULT_RELEASES="git.catlow.cloud/sam/archie"
DEFAULT_RELEASE_KEY="gIBqoQMwy+8WXmGfiuHtnUa50W0IqfzkTR6iF5q3dSM="
ARCHIE_RELEASES="${ARCHIE_RELEASES:-${DEFAULT_RELEASES}}"
ARCHIE_RELEASE_KEY="${ARCHIE_RELEASE_KEY:-${DEFAULT_RELEASE_KEY}}"
ARCHIE_CHANNEL="${ARCHIE_CHANNEL:-stable}"
XDG_CONFIG_HOME="${XDG_CONFIG_HOME:-${HOME}/.config}" XDG_CONFIG_HOME="${XDG_CONFIG_HOME:-${HOME}/.config}"
XDG_DATA_HOME="${XDG_DATA_HOME:-${HOME}/.local/share}" XDG_DATA_HOME="${XDG_DATA_HOME:-${HOME}/.local/share}"
@@ -32,7 +41,12 @@ if (: </dev/tty) 2>/dev/null; then INTERACTIVE=true; fi
usage() { usage() {
cat <<EOF cat <<EOF
Usage: install.sh [options] Usage: install.sh [options]
or: curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | bash -s -- [options] or: curl -fsSL https://offloaded.dev/install.sh | bash -s -- [options]
Environment:
ARCHIE_RELEASES OCI repository to install from (default ${DEFAULT_RELEASES})
ARCHIE_RELEASE_KEY base64 ed25519 key that source signs with
ARCHIE_CHANNEL stable (default) or next
Options: Options:
--version X.Y.Z Install this release instead of the latest --version X.Y.Z Install this release instead of the latest
@@ -103,6 +117,50 @@ need() {
done done
} }
# install_release fetches the release on ARCHIE_CHANNEL (or VERSION) from
# ARCHIE_RELEASES and unpacks it into TMP: the statement must verify against
# ARCHIE_RELEASE_KEY and the zip must hash to the digest the statement names.
install_release() {
local registry="${ARCHIE_RELEASES%%/*}" repo="${ARCHIE_RELEASES#*/}" scheme=https tag="${ARCHIE_CHANNEL}"
case "${registry}" in localhost | localhost:* | 127.* | "[::1]"*) scheme=http ;; esac
[ -n "${VERSION}" ] && tag="v${VERSION#v}"
local base="${scheme}://${registry}/v2/${repo}" auth=()
# Registries hand anonymous readers a pull token named by the challenge.
local challenge
challenge="$(curl -fsS -o /dev/null -D - "${base}/manifests/${tag}" 2>/dev/null | tr -d '\r' | sed -n 's/^[Ww][Ww][Ww]-[Aa]uthenticate: *Bearer *//p')" || true
if [ -n "${challenge}" ]; then
local realm service token
realm="$(sed -n 's/.*realm="\([^"]*\)".*/\1/p' <<<"${challenge}")"
service="$(sed -n 's/.*service="\([^"]*\)".*/\1/p' <<<"${challenge}")"
token="$(curl -fsSL -G "${realm}" --data-urlencode "service=${service}" --data-urlencode "scope=repository:${repo}:pull" | jq -r '.token // .access_token')"
auth=(-H "Authorization: Bearer ${token}")
fi
echo "==> Fetching ${ARCHIE_RELEASES}:${tag}..."
curl -fsSL "${auth[@]}" -H "Accept: application/vnd.oci.image.manifest.v1+json" "${base}/manifests/${tag}" -o "${TMP}/manifest.json"
blob() { curl -fsSL "${auth[@]}" "${base}/blobs/$1" -o "$2" && [ "sha256:$(sha256sum "$2" | cut -d' ' -f1)" = "$1" ]; }
local statement_digest
statement_digest="$(jq -er '.layers[0].digest' "${TMP}/manifest.json")"
blob "${statement_digest}" "${TMP}/statement.json" || { echo "Error: the release statement does not match its digest." >&2; exit 1; }
jq -er '.annotations["dev.archie.release.signature.v1"]' "${TMP}/manifest.json" | base64 -d >"${TMP}/statement.sig"
# An ed25519 public key is its 32 bytes behind a fixed SubjectPublicKeyInfo header.
{ printf '\x30\x2a\x30\x05\x06\x03\x2b\x65\x70\x03\x21\x00'; base64 -d <<<"${ARCHIE_RELEASE_KEY}"; } >"${TMP}/key.der"
openssl pkeyutl -verify -pubin -inkey "${TMP}/key.der" -keyform DER -rawin \
-in "${TMP}/statement.json" -sigfile "${TMP}/statement.sig" >/dev/null 2>&1 ||
{ echo "Error: ${ARCHIE_RELEASES}:${tag} is not signed by the release key." >&2; exit 1; }
local zip_name zip_digest
VERSION="$(jq -er .version "${TMP}/statement.json")"
[ "$(jq -r .platform "${TMP}/statement.json")" = linux-amd64 ] || { echo "Error: the release is not built for linux-amd64." >&2; exit 1; }
[ -z "${VERSION}" ] || [ "${tag}" = "${ARCHIE_CHANNEL}" ] || [ "v${VERSION}" = "${tag}" ] ||
{ echo "Error: ${tag} carries the statement for ${VERSION}." >&2; exit 1; }
zip_name="$(jq -er .zip.name "${TMP}/statement.json")"
zip_digest="$(jq -er .zip.digest "${TMP}/statement.json")"
RELEASE_NAME="${zip_name%.zip}"
case "${RELEASE_NAME}" in archie-core-archied-v*-linux-amd64) ;; *) echo "Error: unexpected release zip ${zip_name}." >&2; exit 1 ;; esac
echo "==> Downloading Archie ${VERSION}..."
blob "${zip_digest}" "${TMP}/${zip_name}" || { echo "Error: ${zip_name} does not match the signed digest." >&2; exit 1; }
unzip -q "${TMP}/${zip_name}" -d "${TMP}"
}
# 1. Prerequisites # 1. Prerequisites
echo "==> Checking prerequisites..." echo "==> Checking prerequisites..."
# The installer depends on systemd user units and GNU tools. # The installer depends on systemd user units and GNU tools.
@@ -114,7 +172,7 @@ if [ "${FROM_SOURCE}" = true ]; then
need git go jq need git go jq
else else
[ "$(uname -m)" = x86_64 ] || { echo "Error: releases are built for x86_64 only; use --from-source." >&2; exit 1; } [ "$(uname -m)" = x86_64 ] || { echo "Error: releases are built for x86_64 only; use --from-source." >&2; exit 1; }
need curl unzip sha256sum need curl unzip sha256sum openssl jq base64
fi fi
if command -v docker &>/dev/null; then if command -v docker &>/dev/null; then
echo " [OK] $(docker --version)" echo " [OK] $(docker --version)"
@@ -131,11 +189,11 @@ trap 'rm -rf "${TMP}"' EXIT
if [ "${FROM_SOURCE}" = true ]; then if [ "${FROM_SOURCE}" = true ]; then
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)" SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
if [ -f "${SCRIPT_DIR}/go.mod" ] && grep -q "github.com/${REPO}" "${SCRIPT_DIR}/go.mod"; then if [ -f "${SCRIPT_DIR}/go.mod" ] && grep -q "${MODULE}" "${SCRIPT_DIR}/go.mod"; then
SRC_DIR="${SCRIPT_DIR}" SRC_DIR="${SCRIPT_DIR}"
else else
SRC_DIR="${TMP}/src" SRC_DIR="${TMP}/src"
git clone --quiet --depth=1 "https://github.com/${REPO}.git" "${SRC_DIR}" git clone --quiet --depth=1 "${SOURCE_GIT}" "${SRC_DIR}"
fi fi
echo "==> Building from ${SRC_DIR}..." echo "==> Building from ${SRC_DIR}..."
# Selects (and under the default GOTOOLCHAIN=auto, downloads) the toolchain # Selects (and under the default GOTOOLCHAIN=auto, downloads) the toolchain
@@ -150,30 +208,14 @@ if [ "${FROM_SOURCE}" = true ]; then
mkdir -p "${STAGE}" mkdir -p "${STAGE}"
# A source build is not a release: it says `dev`, and buildType=binary lets # A source build is not a release: it says `dev`, and buildType=binary lets
# it self-update. The agentworker stamp only lands in archie-agent. # it self-update. The agentworker stamp only lands in archie-agent.
LDFLAGS="-X github.com/${REPO}/internal/buildinfo.Version=dev -X github.com/${REPO}/internal/buildinfo.Runtime=dev -X github.com/${REPO}/internal/installtype.buildType=binary -X github.com/${REPO}/internal/app/agentworker.version=dev" LDFLAGS="-X ${MODULE}/internal/buildinfo.Version=dev -X ${MODULE}/internal/buildinfo.Runtime=dev -X ${MODULE}/internal/installtype.buildType=binary -X ${MODULE}/internal/app/agentworker.version=dev"
for cmd in $(jq -er '[.required_topology.units[], .required_topology.binaries[]?] | join(" ")' "${SRC_DIR}/release.json"); do for cmd in $(jq -er '[.required_topology.units[], .required_topology.binaries[]?] | join(" ")' "${SRC_DIR}/release.json"); do
(cd "${SRC_DIR}" && go build -ldflags "${LDFLAGS}" -o "${STAGE}/${cmd}" "./cmd/${cmd}") (cd "${SRC_DIR}" && go build -ldflags "${LDFLAGS}" -o "${STAGE}/${cmd}" "./cmd/${cmd}")
done done
cp "${SRC_DIR}/release.json" "${STAGE}/" cp "${SRC_DIR}/release.json" "${STAGE}/"
else else
if [ -z "${VERSION}" ]; then install_release
tag="$(curl -fsSL "https://api.github.com/repos/${REPO}/releases/latest" | sed -n 's/.*"tag_name": *"\([^"]*\)".*/\1/p')" STAGE="${TMP}/${RELEASE_NAME}"
[ -n "${tag}" ] || { echo "Error: could not find the latest release." >&2; exit 1; }
else
tag="v${VERSION}"
fi
VERSION="${tag##*v}"
name="archie-core-archied-v${VERSION}-linux-amd64"
echo "==> Downloading Archie ${VERSION}..."
base="https://github.com/${REPO}/releases/download/${tag}"
curl -fsSL "${base}/${name}.zip" -o "${TMP}/${name}.zip"
curl -fsSL "${base}/SHA256SUMS" -o "${TMP}/SHA256SUMS"
expected="$(awk -v n="${name}.zip" '$2 == n {print $1}' "${TMP}/SHA256SUMS")"
[[ "${expected}" =~ ^[a-f0-9]{64}$ ]] || { echo "Error: ${name}.zip is not in SHA256SUMS." >&2; exit 1; }
printf '%s %s\n' "${expected}" "${TMP}/${name}.zip" | sha256sum --check --status ||
{ echo "Error: checksum mismatch for ${name}.zip." >&2; exit 1; }
unzip -q "${TMP}/${name}.zip" -d "${TMP}"
STAGE="${TMP}/${name}"
fi fi
TOPOLOGY_UNITS="$(tr -d '\n' <"${STAGE}/release.json" | sed -n 's/.*"units": *\[\([^]]*\)\].*/\1/p' | tr -d '" ' | tr , ' ')" TOPOLOGY_UNITS="$(tr -d '\n' <"${STAGE}/release.json" | sed -n 's/.*"units": *\[\([^]]*\)\].*/\1/p' | tr -d '" ' | tr , ' ')"
@@ -202,6 +244,10 @@ if [ ! -f "${ARCHIE_CONFIG_DIR}/config.toml" ]; then
echo "ERROR: archied setup could not generate ${ARCHIE_CONFIG_DIR}/config.toml" >&2 echo "ERROR: archied setup could not generate ${ARCHIE_CONFIG_DIR}/config.toml" >&2
exit 1 exit 1
fi fi
if [ "${ARCHIE_RELEASES}" != "${DEFAULT_RELEASES}" ] || [ "${ARCHIE_RELEASE_KEY}" != "${DEFAULT_RELEASE_KEY}" ]; then
# The instance keeps updating from the source it was installed from.
printf '\n[distribution]\nreleases = "%s"\nreleases_key = "%s"\n' "${ARCHIE_RELEASES}" "${ARCHIE_RELEASE_KEY}" >>"${ARCHIE_CONFIG_DIR}/config.toml"
fi
if [ -n "${PORT_BASE}" ]; then if [ -n "${PORT_BASE}" ]; then
# The generated config names the default addresses; move them to this # The generated config names the default addresses; move them to this
# instance's ports and pin the services the template leaves commented. # instance's ports and pin the services the template leaves commented.
@@ -465,7 +511,7 @@ if [ "${SERVICE_INSTALLED}" = true ] && [ "${AUTO_START}" = true ]; then
echo " - Service status : systemctl --user status ${INSTANCE_UNITS}" echo " - Service status : systemctl --user status ${INSTANCE_UNITS}"
echo " - Restart daemon : systemctl --user restart ${U_DAEMON}" echo " - Restart daemon : systemctl --user restart ${U_DAEMON}"
else else
echo "Manual Startup: start the five services as in https://github.com/${REPO}/blob/main/deployments/README.md" echo "Manual Startup: start the five services as in https://offloaded.dev"
fi fi
echo "" echo ""
SETUP_HINT="archied setup" SETUP_HINT="archied setup"
+112
View File
@@ -0,0 +1,112 @@
package archied
import (
"context"
"crypto/ed25519"
"encoding/base64"
"flag"
"fmt"
"io"
"os"
"strings"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/releaseupdate"
)
const releaseUsage = `usage: archied release <command>
keygen -seed FILE write a new signing key's seed to FILE and print its public key
publish sign a release and push it to a release source`
// RunRelease is the publisher's side of a release source: it makes the key
// a source signs with and pushes signed releases to it.
func RunRelease(args []string, out, stderr io.Writer) int {
if len(args) == 0 {
fmt.Fprintln(stderr, releaseUsage)
return 2
}
switch args[0] {
case "keygen":
return runReleaseKeygen(args[1:], out, stderr)
case "publish":
return runReleasePublish(args[1:], out, stderr)
default:
fmt.Fprintln(stderr, releaseUsage)
return 2
}
}
// runReleaseKeygen writes the seed to a new file only, never to output, so
// the private half is not left in a terminal or CI log.
func runReleaseKeygen(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release keygen", flag.ContinueOnError)
flags.SetOutput(stderr)
seedPath := flags.String("seed", "", "file to create with the base64 private key seed")
if err := flags.Parse(args); err != nil {
return 2
}
if *seedPath == "" {
fmt.Fprintln(stderr, "release keygen: -seed is required")
return 2
}
public, private, err := ed25519.GenerateKey(nil)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
file, err := os.OpenFile(*seedPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
_, err = fmt.Fprintln(file, base64.StdEncoding.EncodeToString(private.Seed()))
if closeErr := file.Close(); err == nil {
err = closeErr
}
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
fmt.Fprintln(out, distribution.EncodeKey(public))
return 0
}
func runReleasePublish(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release publish", flag.ContinueOnError)
flags.SetOutput(stderr)
var req releaseupdate.PublishRequest
flags.StringVar(&req.Repository, "source", "", "OCI repository to publish to")
seedEnv := flags.String("seed-env", "ARCHIE_RELEASE_SEED", "environment variable holding the base64 private key seed")
flags.StringVar(&req.Version, "version", "", "release version")
flags.BoolVar(&req.Prerelease, "prerelease", false, "publish to next only")
flags.StringVar(&req.ZipPath, "zip", "", "distribution zip")
flags.StringVar(&req.AgentImage, "agent-image", "", "agent image pinned by digest")
flags.StringVar(&req.Changelog, "changelog", "", "URL of the release notes")
if err := flags.Parse(args); err != nil {
return 2
}
if req.Repository == "" || req.Version == "" || req.ZipPath == "" || req.AgentImage == "" {
fmt.Fprintln(stderr, "release publish: -source, -version, -zip and -agent-image are required")
return 2
}
seed, err := base64.StdEncoding.DecodeString(strings.TrimSpace(os.Getenv(*seedEnv)))
if err != nil || len(seed) != ed25519.SeedSize {
fmt.Fprintf(stderr, "release publish: %s must hold a base64 ed25519 seed\n", *seedEnv)
return 2
}
req.Signer = ed25519.NewKeyFromSeed(seed)
public := distribution.EncodeKey(ed25519.PublicKey(req.Signer[ed25519.SeedSize:]))
req.Channels = []string{"next"}
if !req.Prerelease {
req.Channels = append(req.Channels, "stable")
}
statement, err := releaseupdate.Publish(context.Background(), req)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
fmt.Fprintf(out, "published %s to %s (%s) with key %s\n", statement.Version, req.Repository,
strings.Join(req.Channels, ", "), public)
return 0
}
+18 -2
View File
@@ -20,6 +20,7 @@ import (
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
"github.com/samcharles93/archie-core/internal/app/servicekit" "github.com/samcharles93/archie-core/internal/app/servicekit"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration" "github.com/samcharles93/archie-core/internal/infrastructure/configuration"
"github.com/samcharles93/archie-core/internal/releaseupdate" "github.com/samcharles93/archie-core/internal/releaseupdate"
) )
@@ -95,7 +96,7 @@ func runUpdateInstall(args []string, out, stderr io.Writer) int {
flags.SetOutput(stderr) flags.SetOutput(stderr)
configPath := flags.String("config", configuration.DefaultConfigPath(), "bootstrap config file") configPath := flags.String("config", configuration.DefaultConfigPath(), "bootstrap config file")
version := flags.String("version", "", "release version to install") version := flags.String("version", "", "release version to install")
releaseURL := flags.String("release-url", releaseupdate.ReleaseURL, "base URL of the release downloads") releases := sourceFlags(flags)
var meta releaseupdate.InstallMeta var meta releaseupdate.InstallMeta
flags.StringVar(&meta.ReportPath, "report", "", "where the watchdog leaves the outcome") flags.StringVar(&meta.ReportPath, "report", "", "where the watchdog leaves the outcome")
flags.StringVar(&meta.Channel, "channel", "", "channel the outcome is reported on") flags.StringVar(&meta.Channel, "channel", "", "channel the outcome is reported on")
@@ -104,6 +105,11 @@ func runUpdateInstall(args []string, out, stderr io.Writer) int {
if err := flags.Parse(args); err != nil { if err := flags.Parse(args); err != nil {
return 2 return 2
} }
source, err := releases()
if err != nil {
fmt.Fprintln(stderr, err)
return 2
}
self, err := os.Executable() self, err := os.Executable()
if err != nil { if err != nil {
fmt.Fprintln(stderr, err) fmt.Fprintln(stderr, err)
@@ -116,7 +122,7 @@ func runUpdateInstall(args []string, out, stderr io.Writer) int {
return 1 return 1
} }
result, err := tx.Prepare(ctx, releaseupdate.PrepareRequest{ result, err := tx.Prepare(ctx, releaseupdate.PrepareRequest{
Version: *version, ReleaseURL: *releaseURL, Meta: meta, Version: *version, Source: source, Meta: meta,
CheckTopology: func(ctx context.Context, required releaseupdate.Topology, managed bool) error { CheckTopology: func(ctx context.Context, required releaseupdate.Topology, managed bool) error {
return checkUpdateTopology(ctx, *configPath, required, managed, out) return checkUpdateTopology(ctx, *configPath, required, managed, out)
}, },
@@ -380,3 +386,13 @@ func observedUnits(output []byte, err error) map[string]bool {
} }
return units return units
} }
// sourceFlags registers -source and -key, the release distribution source; a
// blank pair is the official releases.
func sourceFlags(flags *flag.FlagSet) func() (distribution.Source, error) {
reference := flags.String("source", "", "OCI repository releases are published to (default: the official releases)")
key := flags.String("key", "", "base64 ed25519 public key the source signs releases with")
return func() (distribution.Source, error) {
return distribution.Parse(*reference, *key, distribution.DefaultReleases())
}
}
+10 -1
View File
@@ -8,6 +8,7 @@ import (
"io" "io"
"os" "os"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/releaseupdate" "github.com/samcharles93/archie-core/internal/releaseupdate"
) )
@@ -18,10 +19,18 @@ func runUpdateCheck(args []string, out, stderr io.Writer) int {
flags.SetOutput(stderr) flags.SetOutput(stderr)
channel := flags.String("channel", envOr("ARCHIE_UPDATE_RELEASE_CHANNEL", "stable"), "stable, next, or exact-pin") channel := flags.String("channel", envOr("ARCHIE_UPDATE_RELEASE_CHANNEL", "stable"), "stable, next, or exact-pin")
pin := flags.String("pin", os.Getenv("ARCHIE_UPDATE_PIN"), "exact release version") pin := flags.String("pin", os.Getenv("ARCHIE_UPDATE_PIN"), "exact release version")
releases := sourceFlags(flags)
if err := flags.Parse(args); err != nil { if err := flags.Parse(args); err != nil {
return 2 return 2
} }
catalog := &releaseupdate.GitHubCatalog{Channel: func(context.Context) (string, string, error) { return *channel, *pin, nil }} source, err := releases()
if err != nil {
fmt.Fprintln(stderr, err)
return 2
}
catalog := &releaseupdate.RegistryCatalog{Settings: func(context.Context) (distribution.Source, string, string, error) {
return source, *channel, *pin, nil
}}
snapshot, err := catalog.Check(context.Background()) snapshot, err := catalog.Check(context.Background())
if err != nil { if err != nil {
fmt.Fprintln(stderr, err) fmt.Fprintln(stderr, err)
+51
View File
@@ -0,0 +1,51 @@
package statestore
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
domain "github.com/samcharles93/archie-core/internal/domain/storepkg"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanestore"
registry "github.com/samcharles93/archie-core/internal/infrastructure/storepkg"
)
// settingsCatalogue fetches the catalogue from the source the extension
// settings name, read on every fetch so an edit applies without a restart.
type settingsCatalogue struct {
resources auditRetentionResources
}
// liveCatalogue is the catalogue the dashboard lists; a store that cannot
// read resources lists the official catalogue.
func (b *server) liveCatalogue() domain.CatalogueSource {
resources, ok := b.st.(auditRetentionResources)
if !ok {
return registry.Catalogue(distribution.DefaultCatalogue())
}
return settingsCatalogue{resources: resources}
}
func (c settingsCatalogue) Fetch(ctx context.Context) (domain.Catalogue, error) {
var settings controlplanerpc.ExtensionSettings
resource, err := c.resources.Resource(ctx, storecontract.DefaultOrgID, controlplanestore.ExtensionSettingsKind)
switch {
case errors.Is(err, storecontract.ErrResourceNotFound):
case err != nil:
return domain.Catalogue{}, fmt.Errorf("read extension settings: %w", err)
}
if len(resource.Value) > 0 {
if err := json.Unmarshal(resource.Value, &settings); err != nil {
return domain.Catalogue{}, fmt.Errorf("decode extension settings: %w", err)
}
}
source, err := settings.Catalogue()
if err != nil {
return domain.Catalogue{}, err
}
return registry.Catalogue(source).Fetch(ctx)
}
+1 -1
View File
@@ -269,7 +269,7 @@ func (b *server) stateStoreDeps(grants *staterpc.TaskGrants) staterpc.Deps {
packages := storepkg.Service{ packages := storepkg.Service{
Registry: registry.OCIRegistry{}, Registry: registry.OCIRegistry{},
Store: postgres.NewInstalledPackages(b.pg), Store: postgres.NewInstalledPackages(b.pg),
Catalogue: registry.DefaultCatalogue(), Catalogue: b.liveCatalogue(),
} }
// A projection failure degrades the org resources a package would have // A projection failure degrades the org resources a package would have
// contributed to, the way a group above degrades: the State Store boots // contributed to, the way a group above degrades: the State Store boots
+16 -3
View File
@@ -414,8 +414,11 @@ type Config struct {
Containers ContainerConfig `toml:"containers" yaml:"containers"` Containers ContainerConfig `toml:"containers" yaml:"containers"`
Chat ChatConfig `toml:"chat" yaml:"chat"` Chat ChatConfig `toml:"chat" yaml:"chat"`
Capture CaptureConfig `toml:"capture" yaml:"capture"` Capture CaptureConfig `toml:"capture" yaml:"capture"`
Access AccessConfig `toml:"access" yaml:"access"` // Distribution seeds where releases and the extension catalogue come
Bindings BindingsConfig `toml:"bindings" yaml:"bindings"` // from; once stored, the dashboard's settings own them.
Distribution Distribution `toml:"distribution" yaml:"distribution"`
Access AccessConfig `toml:"access" yaml:"access"`
Bindings BindingsConfig `toml:"bindings" yaml:"bindings"`
// Memory holds memory provider configuration (from config.memory.yaml). // Memory holds memory provider configuration (from config.memory.yaml).
Memory MemoryConfig `toml:"memory" yaml:"memory"` Memory MemoryConfig `toml:"memory" yaml:"memory"`
@@ -690,7 +693,7 @@ type BindingsConfig struct {
// ContainerConfig configures Docker sandbox execution of archie-agent. // ContainerConfig configures Docker sandbox execution of archie-agent.
type ContainerConfig struct { type ContainerConfig struct {
// Image is the Docker image to run (e.g. "ghcr.io/sam/archie-agent:latest"). // Image is the Docker image to run (e.g. "git.catlow.cloud/sam/archie-agent:latest").
Image string `toml:"image" yaml:"image"` Image string `toml:"image" yaml:"image"`
// MaxConcurrency limits simultaneous daemon tasks and containers. // MaxConcurrency limits simultaneous daemon tasks and containers.
// Tasks from the same repository remain serialized. 0 = no limit. // Tasks from the same repository remain serialized. 0 = no limit.
@@ -1008,6 +1011,16 @@ func (h Health) URL() string {
return "http://" + net.JoinHostPort(host, port) return "http://" + net.JoinHostPort(host, port)
} }
// Distribution names the signed artifact sources a new instance starts with.
// Each source is an OCI repository with the base64 ed25519 key it signs
// with; blank pairs are the official sources.
type Distribution struct {
Releases string `toml:"releases" yaml:"releases"`
ReleasesKey string `toml:"releases_key" yaml:"releases_key"`
Catalogue string `toml:"catalogue" yaml:"catalogue"`
CatalogueKey string `toml:"catalogue_key" yaml:"catalogue_key"`
}
type Web struct { type Web struct {
// Listen is the dashboard address; "off" disables the web UI. // Listen is the dashboard address; "off" disables the web UI.
// Bind localhost (or a LAN/tailnet address) -- there is no auth. // Bind localhost (or a LAN/tailnet address) -- there is no auth.
+89
View File
@@ -0,0 +1,89 @@
// Package distribution names where an instance takes signed artifacts from:
// its releases and its extension catalogue.
package distribution
import (
"crypto/ed25519"
"encoding/base64"
"errors"
"fmt"
"strings"
)
// Source is an OCI repository and the public key that must have signed what
// it serves. The key, not the registry, is what makes an artifact trusted, so
// a source is never valid without one.
type Source struct {
Reference string
Key ed25519.PublicKey
}
// Parse builds a source from its stored form. A blank reference and key mean
// fallback; setting only one of them is refused, since a reference without
// its key, or a key for the default reference, is a misconfiguration.
func Parse(reference, key string, fallback Source) (Source, error) {
reference, key = strings.TrimSpace(reference), strings.TrimSpace(key)
if reference == "" && key == "" {
return fallback, nil
}
if reference == "" || key == "" {
return Source{}, errors.New("a distribution source needs both a reference and a key")
}
if !repository(reference) {
return Source{}, fmt.Errorf("distribution source %q must be an OCI repository such as registry.example/owner/name", reference)
}
decoded, err := ParseKey(key)
if err != nil {
return Source{}, err
}
return Source{Reference: reference, Key: decoded}, nil
}
// ParseKey decodes a base64 ed25519 public key.
func ParseKey(key string) (ed25519.PublicKey, error) {
decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(key))
if err != nil || len(decoded) != ed25519.PublicKeySize {
return nil, errors.New("distribution key must be a base64 ed25519 public key")
}
return decoded, nil
}
// EncodeKey is the stored form of a public key.
func EncodeKey(key ed25519.PublicKey) string {
return base64.StdEncoding.EncodeToString(key)
}
// repository accepts registry/path with an optional registry port and no tag
// or digest: a source names a repository, and its tags are the channels.
func repository(reference string) bool {
host, path, ok := strings.Cut(reference, "/")
return ok && host != "" && path != "" &&
strings.Count(host, ":") <= 1 && !strings.ContainsAny(path, ":@") &&
!strings.ContainsAny(reference, " \t\n") && !strings.Contains(reference, "//")
}
// mustKey decodes a built-in key; a malformed one is a build defect.
func mustKey(encoded string) ed25519.PublicKey {
key, err := ParseKey(encoded)
if err != nil {
panic("distribution: invalid built-in key")
}
return key
}
// DefaultCatalogue is the archipelago marketplace an instance trusts until an
// operator names another.
func DefaultCatalogue() Source {
return Source{
Reference: "git.catlow.cloud/sam/archipelago/catalogue",
Key: mustKey("YL4nvn07uq/5mXZOt9cEmLYu/kB6C2+MLTnbHyoX4Pw="),
}
}
// DefaultReleases is where Archie's own releases are published.
func DefaultReleases() Source {
return Source{
Reference: "git.catlow.cloud/sam/archie",
Key: mustKey("gIBqoQMwy+8WXmGfiuHtnUa50W0IqfzkTR6iF5q3dSM="),
}
}
@@ -24,7 +24,7 @@ const (
defaultContainerUptime = 5 * time.Hour defaultContainerUptime = 5 * time.Hour
defaultVolumeTTL = 72 * time.Hour defaultVolumeTTL = 72 * time.Hour
defaultPullPolicy = "missing" defaultPullPolicy = "missing"
defaultContainerImage = "ghcr.io/samcharles93/archie-agent:latest" defaultContainerImage = "git.catlow.cloud/sam/archie-agent:latest"
// defaultMaxResultChars bounds one tool result. // defaultMaxResultChars bounds one tool result.
defaultMaxResultChars = 50_000 defaultMaxResultChars = 50_000
@@ -1,12 +1,21 @@
package controlplanerpc package controlplanerpc
import "github.com/samcharles93/archie-core/internal/domain/distribution"
// ExtensionSettingsKind is the control-plane resource kind holding which // ExtensionSettingsKind is the control-plane resource kind holding which
// installed extensions are enabled and how each is configured. // installed extensions are enabled and how each is configured.
const ExtensionSettingsKind = "extension-settings" const ExtensionSettingsKind = "extension-settings"
// ExtensionSettings is the extension-settings resource document. // ExtensionSettings is the extension-settings resource document.
type ExtensionSettings struct { type ExtensionSettings struct {
Extensions []ExtensionSetting `json:"extensions"` Extensions []ExtensionSetting `json:"extensions"`
CatalogueSource string `json:"catalogue_source,omitempty" title:"Catalogue source" doc:"OCI repository the package catalogue is published to, read at its latest tag. Blank uses the official catalogue."`
CatalogueKey string `json:"catalogue_key,omitempty" title:"Catalogue signing key" doc:"Base64 ed25519 public key the catalogue source signs with. Required with a source."`
}
// Catalogue is the distribution source the settings name.
func (s ExtensionSettings) Catalogue() (distribution.Source, error) {
return distribution.Parse(s.CatalogueSource, s.CatalogueKey, distribution.DefaultCatalogue())
} }
// ExtensionSetting enables or disables one installed extension by package name. // ExtensionSetting enables or disables one installed extension by package name.
@@ -8,6 +8,7 @@ import (
"time" "time"
"github.com/samcharles93/archie-core/internal/config" "github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/installtype" "github.com/samcharles93/archie-core/internal/installtype"
"github.com/samcharles93/archie-core/internal/releaseupdate" "github.com/samcharles93/archie-core/internal/releaseupdate"
) )
@@ -118,28 +119,49 @@ const UpdateSettingsKind = "update-settings"
type UpdateSettings struct { type UpdateSettings struct {
Channel string `json:"channel" title:"Release channel" doc:"stable, next (includes prereleases) or exact-pin."` Channel string `json:"channel" title:"Release channel" doc:"stable, next (includes prereleases) or exact-pin."`
Pin string `json:"pin" title:"Pinned version" doc:"The version exact-pin installs."` Pin string `json:"pin" title:"Pinned version" doc:"The version exact-pin installs."`
Source string `json:"source,omitempty" title:"Release source" doc:"OCI repository releases are published to, such as registry.example/owner/archie. Blank uses the official releases."`
Key string `json:"key,omitempty" title:"Release signing key" doc:"Base64 ed25519 public key the release source signs with. Required with a source."`
} }
// UpdateService checks GitHub on the stored release channel and installs // Releases is the distribution source the settings name.
// through the archied beside this binary. statePath keeps each recipient's func (s UpdateSettings) Releases() (distribution.Source, error) {
// deferrals. return distribution.Parse(s.Source, s.Key, distribution.DefaultReleases())
}
// UpdateService checks the stored release source on the stored channel and
// installs through the archied beside this binary from the same source.
// statePath keeps each recipient's deferrals.
func UpdateService(reader ResourceReader, statePath string) *releaseupdate.Service { func UpdateService(reader ResourceReader, statePath string) *releaseupdate.Service {
settings := updateSettings(reader)
return &releaseupdate.Service{ return &releaseupdate.Service{
Catalog: &releaseupdate.GitHubCatalog{Channel: updateChannel(reader)}, Catalog: &releaseupdate.RegistryCatalog{Settings: func(ctx context.Context) (distribution.Source, string, string, error) {
Installer: releaseupdate.ArchiedInstaller{}, doc, err := settings(ctx)
if err != nil {
return distribution.Source{}, "", "", err
}
source, err := doc.Releases()
return source, doc.Channel, doc.Pin, err
}},
Installer: releaseupdate.ArchiedInstaller{Source: func(ctx context.Context) (distribution.Source, error) {
doc, err := settings(ctx)
if err != nil {
return distribution.Source{}, err
}
return doc.Releases()
}},
StatePath: statePath, StatePath: statePath,
InstallType: installtype.Type(), InstallType: installtype.Type(),
} }
} }
// updateChannel reads the update-settings resource. An unstored kind is the // updateSettings reads the update-settings resource. An unstored kind is the
// stable channel. // stable channel from the official releases.
func updateChannel(reader ResourceReader) func(context.Context) (string, string, error) { func updateSettings(reader ResourceReader) func(context.Context) (UpdateSettings, error) {
return func(ctx context.Context) (string, string, error) { return func(ctx context.Context) (UpdateSettings, error) {
settings := UpdateSettings{Channel: "stable"} settings := UpdateSettings{Channel: "stable"}
_, _, err := reader.Query(ctx, UpdateSettingsKind, func(value []byte) error { _, _, err := reader.Query(ctx, UpdateSettingsKind, func(value []byte) error {
return json.Unmarshal(value, &settings) return json.Unmarshal(value, &settings)
}) })
return settings.Channel, settings.Pin, err return settings, err
} }
} }
@@ -60,11 +60,15 @@ func operationalDefinitions() []Definition {
}, Validate: validatePluginSettings}, }, Validate: validatePluginSettings},
// Live: each process that supervises extensions re-reads this on its sync // Live: each process that supervises extensions re-reads this on its sync
// tick, then starts, restarts or stops what changed. // tick, then starts, restarts or stops what changed.
{Kind: ExtensionSettingsKind, Title: "Extension settings", ApplyMode: "live", Document: controlplanerpc.ExtensionSettings{}, Seed: func(config.Config) any { return controlplanerpc.ExtensionSettings{} }, Validate: validateExtensions}, {Kind: ExtensionSettingsKind, Title: "Extension settings", ApplyMode: "live", Document: controlplanerpc.ExtensionSettings{}, Seed: func(cfg config.Config) any {
return controlplanerpc.ExtensionSettings{CatalogueSource: cfg.Distribution.Catalogue, CatalogueKey: cfg.Distribution.CatalogueKey}
}, Validate: validateExtensions},
// Live: the container pool reads these on every acquire and the dispatcher // Live: the container pool reads these on every acquire and the dispatcher
// is resized on publish. // is resized on publish.
// Live: every check and install reads the channel afresh. // Live: every check and install reads the channel afresh.
{Kind: UpdateSettingsKind, Title: "Update settings", ApplyMode: "live", Document: controlplanerpc.UpdateSettings{}, Seed: func(config.Config) any { return controlplanerpc.UpdateSettings{Channel: "stable"} }, Validate: validateUpdateSettings}, {Kind: UpdateSettingsKind, Title: "Update settings", ApplyMode: "live", Document: controlplanerpc.UpdateSettings{}, Seed: func(cfg config.Config) any {
return controlplanerpc.UpdateSettings{Channel: "stable", Source: cfg.Distribution.Releases, Key: cfg.Distribution.ReleasesKey}
}, Validate: validateUpdateSettings},
{Kind: ContainerRuntimePoliciesKind, Title: "Container runtime policies", ApplyMode: "live", Document: containerRuntimePolicies{}, Seed: seedContainerPolicies, Validate: validateContainers, Normalize: normalizeContainerPolicies}, {Kind: ContainerRuntimePoliciesKind, Title: "Container runtime policies", ApplyMode: "live", Document: containerRuntimePolicies{}, Seed: seedContainerPolicies, Validate: validateContainers, Normalize: normalizeContainerPolicies},
// Live: the retention sweep reads the document on every tick, so a // Live: the retention sweep reads the document on every tick, so a
// change applies to the next sweep without a restart. // change applies to the next sweep without a restart.
@@ -89,7 +93,8 @@ func validateExtensions(input []byte) error {
} }
seen[setting.Name] = struct{}{} seen[setting.Name] = struct{}{}
} }
return nil _, err := doc.Catalogue()
return err
}) })
} }
@@ -176,6 +181,9 @@ func ApplyOrgScheduling(cfg config.Config, stored []byte) (config.Config, error)
// validateUpdateSettings refuses a channel the update scripts cannot select. // validateUpdateSettings refuses a channel the update scripts cannot select.
func validateUpdateSettings(input []byte) error { func validateUpdateSettings(input []byte) error {
return validateAs(input, func(doc controlplanerpc.UpdateSettings) error { return validateAs(input, func(doc controlplanerpc.UpdateSettings) error {
if _, err := doc.Releases(); err != nil {
return err
}
return releaseupdate.ValidateChannel(doc.Channel, doc.Pin) return releaseupdate.ValidateChannel(doc.Channel, doc.Pin)
}) })
} }
@@ -0,0 +1,86 @@
package signedoci
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io/fs"
"os"
"path/filepath"
"sync"
"time"
"github.com/samcharles93/archie-core/internal/fsutil"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
)
// FileFreshness is the durable freshness mark of accepted issue times, kept as one small JSON file
// written atomically so a crash never leaves a half-written mark. A missing
// file is no mark yet; a file that exists but does not parse is an error, so
// a corrupt mark fails closed instead of opening a replay window.
type FileFreshness struct {
Path string
mu sync.Mutex
}
func (f *FileFreshness) Newest(context.Context) (time.Time, error) {
f.mu.Lock()
defer f.mu.Unlock()
return f.read()
}
func (f *FileFreshness) Accept(_ context.Context, issuedAt time.Time) error {
f.mu.Lock()
defer f.mu.Unlock()
current, err := f.read()
if err != nil {
return err
}
if !issuedAt.After(current) {
return nil
}
encoded, err := json.Marshal(struct {
IssuedAt time.Time `json:"issued_at"`
}{IssuedAt: issuedAt.UTC()})
if err != nil {
return err
}
return fsutil.WriteFileAtomic(f.Path, encoded, 0o600)
}
// read returns the mark, or the zero time when nothing has been
// accepted yet.
func (f *FileFreshness) read() (time.Time, error) {
raw, err := os.ReadFile(f.Path)
if errors.Is(err, fs.ErrNotExist) {
return time.Time{}, nil
}
if err != nil {
return time.Time{}, err
}
var mark struct {
IssuedAt time.Time `json:"issued_at"`
}
if err := json.Unmarshal(raw, &mark); err != nil {
return time.Time{}, fmt.Errorf("freshness mark %s: %w", f.Path, err)
}
return mark.IssuedAt, nil
}
// MarkPath is where the freshness mark for one kind of artifact from one
// source lives: $XDG_STATE_HOME/<instance>/<kind>/<key>.json, the state home
// the update journal uses too. The key names the reference, so two sources
// never share a mark.
func MarkPath(kind, reference string) string {
dir := os.Getenv("XDG_STATE_HOME")
if dir == "" {
home, _ := os.UserHomeDir()
dir = filepath.Join(home, ".local", "state")
}
sum := sha256.Sum256([]byte(reference))
return filepath.Join(dir, configuration.InstanceName(), kind, hex.EncodeToString(sum[:8])+".json")
}
@@ -0,0 +1,47 @@
package signedoci
import (
"os"
"path/filepath"
"testing"
"time"
)
// The freshness mark never goes backwards, and a mark that exists but does
// not parse fails closed rather than opening a replay window.
func TestFileFreshness(t *testing.T) {
path := filepath.Join(t.TempDir(), "freshness.json")
mark := &FileFreshness{Path: path}
jan1 := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
jan2 := time.Date(2026, 1, 2, 0, 0, 0, 0, time.UTC)
newest, err := mark.Newest(t.Context())
if err != nil {
t.Fatalf("Newest with no file: %v", err)
}
if !newest.IsZero() {
t.Fatalf("Newest with no file = %s; want the zero time", newest.Format(time.RFC3339))
}
if err := mark.Accept(t.Context(), jan1); err != nil {
t.Fatalf("Accept jan1: %v", err)
}
if err := mark.Accept(t.Context(), jan2); err != nil {
t.Fatalf("Accept jan2: %v", err)
}
if err := mark.Accept(t.Context(), jan1); err != nil {
t.Fatalf("Accept jan1 again: %v", err)
}
if newest, err = mark.Newest(t.Context()); err != nil {
t.Fatalf("Newest: %v", err)
}
if !newest.Equal(jan2) {
t.Fatalf("Newest = %s; want %s", newest.Format(time.RFC3339), jan2.Format(time.RFC3339))
}
if err := os.WriteFile(path, []byte("{"), 0o600); err != nil {
t.Fatal(err)
}
if _, err := mark.Newest(t.Context()); err == nil {
t.Fatal("Newest over a corrupt mark: err = nil, want an error")
}
}
@@ -0,0 +1,154 @@
// Package signedoci fetches OCI artifacts whose first layer is a statement
// signed by a distribution source's key. The extension catalogue and releases
// are both published this way.
package signedoci
import (
"context"
"crypto/ed25519"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"strings"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"oras.land/oras-go/v2/registry/remote"
"github.com/samcharles93/archie-core/internal/domain/distribution"
)
const maxManifestBytes = 256 << 10
// Artifact is a fetched manifest whose statement layer verified against the
// source's key. Its other layers are read through Blob, which checks each
// against the digest the manifest names.
type Artifact struct {
Manifest ocispec.Manifest
Statement []byte
repository *remote.Repository
}
// Fetch resolves tag in the source's repository and verifies the statement
// layer: annotation on the manifest must be the key's signature over the
// statement bytes. maxStatement bounds the statement read.
func Fetch(ctx context.Context, source distribution.Source, tag, annotation string, maxStatement int) (Artifact, error) {
if len(source.Key) != ed25519.PublicKeySize {
return Artifact{}, errors.New("no valid signing key")
}
reference := source.Reference + ":" + tag
repository, err := remote.NewRepository(reference)
if err != nil {
return Artifact{}, err
}
repository.PlainHTTP = Loopback(reference)
_, stream, err := repository.FetchReference(ctx, reference)
if err != nil {
return Artifact{}, fmt.Errorf("%s: %w", reference, err)
}
raw, err := readBounded(stream, maxManifestBytes)
if err != nil {
return Artifact{}, err
}
var manifest ocispec.Manifest
if err := json.Unmarshal(raw, &manifest); err != nil {
return Artifact{}, fmt.Errorf("%s manifest: %w", reference, err)
}
if len(manifest.Layers) == 0 {
return Artifact{}, fmt.Errorf("%s has no statement layer", reference)
}
layer, err := repository.Fetch(ctx, manifest.Layers[0])
if err != nil {
return Artifact{}, fmt.Errorf("%s statement: %w", reference, err)
}
statement, err := readBounded(layer, maxStatement)
if err != nil {
return Artifact{}, err
}
if err := Verify(manifest, statement, source.Key, annotation); err != nil {
return Artifact{}, fmt.Errorf("%s: %w", reference, err)
}
return Artifact{Manifest: manifest, Statement: statement, repository: repository}, nil
}
// Verify checks statement is the first layer the manifest names and that key
// signed exactly those bytes under annotation.
func Verify(manifest ocispec.Manifest, statement []byte, key ed25519.PublicKey, annotation string) error {
if len(manifest.Layers) == 0 || Digest(statement) != manifest.Layers[0].Digest.String() {
return errors.New("statement does not match its manifest digest")
}
signature, err := base64.StdEncoding.DecodeString(manifest.Annotations[annotation])
if err != nil || !ed25519.Verify(key, statement, signature) {
return errors.New("signature does not verify")
}
return nil
}
// Blob copies the layer named digest to out, refusing one the manifest does
// not list or whose bytes do not hash to it.
func (a Artifact) Blob(ctx context.Context, digest string, out io.Writer, limit int64) error {
for _, layer := range a.Manifest.Layers {
if layer.Digest.String() != digest {
continue
}
if layer.Size > limit {
return fmt.Errorf("layer %s exceeds the size limit", digest)
}
stream, err := a.repository.Fetch(ctx, layer)
if err != nil {
return err
}
defer func() { _ = stream.Close() }()
hash := sha256.New()
n, err := io.Copy(io.MultiWriter(out, hash), io.LimitReader(stream, limit+1))
if err != nil {
return err
}
if n > limit {
return fmt.Errorf("layer %s exceeds the size limit", digest)
}
if "sha256:"+hex.EncodeToString(hash.Sum(nil)) != digest {
return fmt.Errorf("layer %s does not match its digest", digest)
}
return nil
}
return fmt.Errorf("artifact has no layer %s", digest)
}
// Digest is the OCI content digest of data.
func Digest(data []byte) string {
sum := sha256.Sum256(data)
return "sha256:" + hex.EncodeToString(sum[:])
}
// Loopback reports whether reference names a registry on this host, the
// only one reached over plain HTTP. The signature, not the transport, is
// what makes an artifact trustworthy.
func Loopback(reference string) bool {
host, _, ok := strings.Cut(reference, "/")
if !ok {
return false
}
if name, _, err := net.SplitHostPort(host); err == nil {
host = name
}
host = strings.Trim(host, "[]")
return host == "localhost" || net.ParseIP(host).IsLoopback()
}
func readBounded(stream io.ReadCloser, limit int) ([]byte, error) {
defer func() { _ = stream.Close() }()
data, err := io.ReadAll(io.LimitReader(stream, int64(limit)+1))
if err != nil {
return nil, err
}
if len(data) > limit {
return nil, errors.New("artifact content exceeds the size limit")
}
return data, nil
}
+25 -141
View File
@@ -4,24 +4,14 @@ import (
"bytes" "bytes"
"context" "context"
"crypto/ed25519" "crypto/ed25519"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json" "encoding/json"
"errors"
"fmt" "fmt"
"io/fs"
"os"
"path/filepath"
"sync"
"time"
ocispec "github.com/opencontainers/image-spec/specs-go/v1" ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"oras.land/oras-go/v2/registry/remote"
"github.com/samcharles93/archie-core/internal/domain/distribution"
domain "github.com/samcharles93/archie-core/internal/domain/storepkg" domain "github.com/samcharles93/archie-core/internal/domain/storepkg"
"github.com/samcharles93/archie-core/internal/fsutil" "github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
) )
// SignatureAnnotation carries the base64 ed25519 signature over the // SignatureAnnotation carries the base64 ed25519 signature over the
@@ -30,84 +20,48 @@ const SignatureAnnotation = "dev.archie.catalogue.signature.v1"
const maxCatalogueBytes = 1 << 20 const maxCatalogueBytes = 1 << 20
// DefaultCatalogue is the archipelago marketplace every instance trusts: its // catalogueTag is the tag a catalogue source publishes its current catalogue
// reference, the public half of the key that signs it, and the durable // under.
// freshness mark that refuses a replayed older catalogue. const catalogueTag = "latest"
func DefaultCatalogue() domain.CatalogueSource {
source := OCICatalogue{ // Catalogue fetches the catalogue a source publishes and refuses a replayed
Reference: "ghcr.io/samcharles93/archipelago/catalogue:latest", // older one, keeping the freshness mark per source.
Key: mustKey("YL4nvn07uq/5mXZOt9cEmLYu/kB6C2+MLTnbHyoX4Pw="), func Catalogue(source distribution.Source) domain.CatalogueSource {
}
return domain.FreshCatalogueSource{ return domain.FreshCatalogueSource{
Source: source, Source: OCICatalogue{Source: source},
Freshness: &FileFreshness{Path: defaultFreshnessPath(source.Reference)}, Freshness: &signedoci.FileFreshness{Path: signedoci.MarkPath("catalogue", source.Reference)},
} }
} }
func mustKey(encoded string) ed25519.PublicKey { // OCICatalogue fetches a catalogue artifact and verifies it against the
key, err := base64.StdEncoding.DecodeString(encoded) // source's key: an OCI manifest whose first layer is the catalogue JSON and
if err != nil || len(key) != ed25519.PublicKeySize { // whose annotation signs that layer. The tag is mutable; the signature is
panic("storepkg: invalid catalogue key") // what makes the list trustworthy.
}
return key
}
// OCICatalogue fetches a catalogue artifact and verifies it against Key: a
// one-layer OCI manifest whose layer is the catalogue JSON and whose
// annotation signs that layer. The reference may be a tag; the signature,
// not the tag, is what makes the list trustworthy.
type OCICatalogue struct { type OCICatalogue struct {
Reference string Source distribution.Source
Key ed25519.PublicKey
} }
var _ domain.CatalogueSource = OCICatalogue{} var _ domain.CatalogueSource = OCICatalogue{}
func (c OCICatalogue) Fetch(ctx context.Context) (domain.Catalogue, error) { func (c OCICatalogue) Fetch(ctx context.Context) (domain.Catalogue, error) {
if len(c.Key) != ed25519.PublicKeySize { artifact, err := signedoci.Fetch(ctx, c.Source, catalogueTag, SignatureAnnotation, maxCatalogueBytes)
return domain.Catalogue{}, errors.New("catalogue: no valid signing key")
}
repository, err := remote.NewRepository(c.Reference)
if err != nil {
return domain.Catalogue{}, err
}
repository.PlainHTTP = loopbackReference(c.Reference)
_, stream, err := repository.FetchReference(ctx, c.Reference)
if err != nil { if err != nil {
return domain.Catalogue{}, fmt.Errorf("catalogue: %w", err) return domain.Catalogue{}, fmt.Errorf("catalogue: %w", err)
} }
manifest, err := readBounded(stream, maxManifestBytes) return decodeCatalogue(artifact.Statement)
if err != nil {
return domain.Catalogue{}, err
}
var image ocispec.Manifest
if err := json.Unmarshal(manifest, &image); err != nil {
return domain.Catalogue{}, fmt.Errorf("catalogue manifest: %w", err)
}
if len(image.Layers) != 1 {
return domain.Catalogue{}, errors.New("catalogue must have one layer")
}
layerStream, err := repository.Fetch(ctx, image.Layers[0])
if err != nil {
return domain.Catalogue{}, fmt.Errorf("catalogue layer: %w", err)
}
layer, err := readBounded(layerStream, maxCatalogueBytes)
if err != nil {
return domain.Catalogue{}, err
}
return verifyCatalogue(image, layer, c.Key)
} }
// verifyCatalogue checks the layer is the one the manifest names and that the // verifyCatalogue checks the layer is the one the manifest names and that the
// key signed it, then decodes it. // key signed it, then decodes it.
func verifyCatalogue(image ocispec.Manifest, layer []byte, key ed25519.PublicKey) (domain.Catalogue, error) { func verifyCatalogue(image ocispec.Manifest, layer []byte, key ed25519.PublicKey) (domain.Catalogue, error) {
if contentDigest(layer) != image.Layers[0].Digest.String() { if err := signedoci.Verify(image, layer, key, SignatureAnnotation); err != nil {
return domain.Catalogue{}, errors.New("catalogue layer does not match its manifest digest") return domain.Catalogue{}, fmt.Errorf("catalogue: %w", err)
}
signature, err := base64.StdEncoding.DecodeString(image.Annotations[SignatureAnnotation])
if err != nil || !ed25519.Verify(key, layer, signature) {
return domain.Catalogue{}, errors.New("catalogue signature does not verify")
} }
return decodeCatalogue(layer)
}
// decodeCatalogue decodes a verified catalogue layer.
func decodeCatalogue(layer []byte) (domain.Catalogue, error) {
decoder := json.NewDecoder(bytes.NewReader(layer)) decoder := json.NewDecoder(bytes.NewReader(layer))
decoder.DisallowUnknownFields() decoder.DisallowUnknownFields()
var catalogue domain.Catalogue var catalogue domain.Catalogue
@@ -119,73 +73,3 @@ func verifyCatalogue(image ocispec.Manifest, layer []byte, key ed25519.PublicKey
} }
return catalogue, nil return catalogue, nil
} }
// FileFreshness is the durable Freshness mark, kept as one small JSON file
// written atomically so a crash never leaves a half-written mark. A missing
// file is no mark yet; a file that exists but does not parse is an error, so
// a corrupt mark fails closed instead of opening a replay window.
type FileFreshness struct {
Path string
mu sync.Mutex
}
var _ domain.Freshness = (*FileFreshness)(nil)
func (f *FileFreshness) Newest(context.Context) (time.Time, error) {
f.mu.Lock()
defer f.mu.Unlock()
return f.read()
}
func (f *FileFreshness) Accept(_ context.Context, issuedAt time.Time) error {
f.mu.Lock()
defer f.mu.Unlock()
current, err := f.read()
if err != nil {
return err
}
if !issuedAt.After(current) {
return nil
}
encoded, err := json.Marshal(struct {
IssuedAt time.Time `json:"issued_at"`
}{IssuedAt: issuedAt.UTC()})
if err != nil {
return err
}
return fsutil.WriteFileAtomic(f.Path, encoded, 0o600)
}
// read returns the mark, or the zero time when no catalogue has been
// accepted yet.
func (f *FileFreshness) read() (time.Time, error) {
raw, err := os.ReadFile(f.Path)
if errors.Is(err, fs.ErrNotExist) {
return time.Time{}, nil
}
if err != nil {
return time.Time{}, err
}
var mark struct {
IssuedAt time.Time `json:"issued_at"`
}
if err := json.Unmarshal(raw, &mark); err != nil {
return time.Time{}, fmt.Errorf("catalogue freshness mark %s: %w", f.Path, err)
}
return mark.IssuedAt, nil
}
// defaultFreshnessPath is where the default catalogue's freshness mark
// lives: $XDG_STATE_HOME/<instance>/catalogue/<key>.json, the state home the
// update journal uses too. The key names the catalogue reference, so two
// catalogues never share a mark.
func defaultFreshnessPath(reference string) string {
dir := os.Getenv("XDG_STATE_HOME")
if dir == "" {
home, _ := os.UserHomeDir()
dir = filepath.Join(home, ".local", "state")
}
sum := sha256.Sum256([]byte(reference))
return filepath.Join(dir, configuration.InstanceName(), "catalogue", hex.EncodeToString(sum[:8])+".json")
}
@@ -5,15 +5,14 @@ import (
"crypto/ed25519" "crypto/ed25519"
"encoding/base64" "encoding/base64"
"errors" "errors"
"os"
"path/filepath" "path/filepath"
"testing" "testing"
"time"
digest "github.com/opencontainers/go-digest" digest "github.com/opencontainers/go-digest"
ocispec "github.com/opencontainers/image-spec/specs-go/v1" ocispec "github.com/opencontainers/image-spec/specs-go/v1"
domain "github.com/samcharles93/archie-core/internal/domain/storepkg" domain "github.com/samcharles93/archie-core/internal/domain/storepkg"
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
) )
// A catalogue is trusted only when its layer is the one the manifest names // A catalogue is trusted only when its layer is the one the manifest names
@@ -87,7 +86,7 @@ func verifiedCatalogue(t *testing.T, key ed25519.PublicKey, signer ed25519.Priva
// refuses it survives a restart. // refuses it survives a restart.
func TestFetchRefusesReplayedCatalogue(t *testing.T) { func TestFetchRefusesReplayedCatalogue(t *testing.T) {
trusted, signer, _ := ed25519.GenerateKey(nil) trusted, signer, _ := ed25519.GenerateKey(nil)
mark := &FileFreshness{Path: filepath.Join(t.TempDir(), "catalogue", "freshness.json")} mark := &signedoci.FileFreshness{Path: filepath.Join(t.TempDir(), "catalogue", "freshness.json")}
newer := verifiedCatalogue(t, trusted, signer, "2026-01-02T00:00:00Z") newer := verifiedCatalogue(t, trusted, signer, "2026-01-02T00:00:00Z")
older := verifiedCatalogue(t, trusted, signer, "2026-01-01T00:00:00Z") older := verifiedCatalogue(t, trusted, signer, "2026-01-01T00:00:00Z")
@@ -104,52 +103,13 @@ func TestFetchRefusesReplayedCatalogue(t *testing.T) {
} }
// The mark is durable: a fresh reader over the same file, as after a // The mark is durable: a fresh reader over the same file, as after a
// restart, still refuses the older catalogue and still accepts the new. // restart, still refuses the older catalogue and still accepts the new.
restarted := domain.FreshCatalogueSource{Source: staticCatalogue{older}, Freshness: &FileFreshness{Path: mark.Path}} restarted := domain.FreshCatalogueSource{Source: staticCatalogue{older}, Freshness: &signedoci.FileFreshness{Path: mark.Path}}
if _, err := restarted.Fetch(t.Context()); !errors.Is(err, domain.ErrCatalogueStale) { if _, err := restarted.Fetch(t.Context()); !errors.Is(err, domain.ErrCatalogueStale) {
t.Fatalf("after restart: err = %v, want ErrCatalogueStale", err) t.Fatalf("after restart: err = %v, want ErrCatalogueStale", err)
} }
if _, err := (domain.FreshCatalogueSource{Source: staticCatalogue{newer}, Freshness: &FileFreshness{Path: mark.Path}}).Fetch(t.Context()); err != nil { if _, err := (domain.FreshCatalogueSource{Source: staticCatalogue{newer}, Freshness: &signedoci.FileFreshness{Path: mark.Path}}).Fetch(t.Context()); err != nil {
t.Fatalf("after restart, newest catalogue: %v", err) t.Fatalf("after restart, newest catalogue: %v", err)
} }
} }
// The freshness mark never goes backwards, and a mark that exists but does
// not parse fails closed rather than opening a replay window.
func TestFileFreshness(t *testing.T) {
path := filepath.Join(t.TempDir(), "freshness.json")
mark := &FileFreshness{Path: path}
jan1 := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
jan2 := time.Date(2026, 1, 2, 0, 0, 0, 0, time.UTC)
newest, err := mark.Newest(t.Context())
if err != nil {
t.Fatalf("Newest with no file: %v", err)
}
if !newest.IsZero() {
t.Fatalf("Newest with no file = %s; want the zero time", newest.Format(time.RFC3339))
}
if err := mark.Accept(t.Context(), jan1); err != nil {
t.Fatalf("Accept jan1: %v", err)
}
if err := mark.Accept(t.Context(), jan2); err != nil {
t.Fatalf("Accept jan2: %v", err)
}
if err := mark.Accept(t.Context(), jan1); err != nil {
t.Fatalf("Accept jan1 again: %v", err)
}
if newest, err = mark.Newest(t.Context()); err != nil {
t.Fatalf("Newest: %v", err)
}
if !newest.Equal(jan2) {
t.Fatalf("Newest = %s; want %s", newest.Format(time.RFC3339), jan2.Format(time.RFC3339))
}
if err := os.WriteFile(path, []byte("{"), 0o600); err != nil {
t.Fatal(err)
}
if _, err := mark.Newest(t.Context()); err == nil {
t.Fatal("Newest over a corrupt mark: err = nil, want an error")
}
}
const zeros = "0000000000000000000000000000000000000000000000000000000000000000" const zeros = "0000000000000000000000000000000000000000000000000000000000000000"
-227
View File
@@ -1,227 +0,0 @@
package releaseupdate
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"os"
"path/filepath"
"regexp"
"strings"
"sync"
"time"
"golang.org/x/mod/semver"
"github.com/samcharles93/archie-core/internal/buildinfo"
)
// ReleaseSlug is the public repository releases are published to. The source
// repository is private, so its releases are unreachable without credentials.
const ReleaseSlug = "samcharles93/archie-releases"
// changelogURL lists every release with its changelog section as notes.
const changelogURL = "https://github.com/" + ReleaseSlug + "/releases"
// buildSuffix is the git-describe tail of an untagged build (1.7.0-4-g0736708).
var buildSuffix = regexp.MustCompile(`-[0-9]+-g[0-9a-f]+$`)
// GitHubCatalog finds the newest release on the selected channel that ships a
// linux-amd64 zip, and reports it against this build. Only one version covers
// every component, so the daemon and agent are offered the same release.
type GitHubCatalog struct {
// Channel returns the release channel and pin in force.
Channel func(context.Context) (channel, pin string, err error)
// A found release is reused for checkTTL: unauthenticated GitHub API
// calls are limited to 60 an hour per address.
mu sync.Mutex
key string
at time.Time
release *release
}
const checkTTL = 10 * time.Minute
func (c *GitHubCatalog) Check(ctx context.Context) (Snapshot, error) {
channel, pin, err := c.Channel(ctx)
if err != nil {
return Snapshot{}, err
}
if channel == "" {
channel = "stable"
}
release, err := c.detect(ctx, channel, pin)
if err != nil {
return Snapshot{}, err
}
component := func(id, label, installed string) Component {
return Component{
ID: id, Label: label,
Installed: installed, Available: release.version,
Reference: release.asset, Changelog: changelogURL,
}
}
return Snapshot{Components: []Component{
component("daemon", "Gateway", ReleaseVersion(buildinfo.Version)),
component("agent", "Runtime", installedAgent(executableDir())),
}}, nil
}
func (c *GitHubCatalog) detect(ctx context.Context, channel, pin string) (*release, error) {
c.mu.Lock()
defer c.mu.Unlock()
key := channel + "\x00" + pin
if c.release != nil && c.key == key && time.Since(c.at) < checkTTL {
return c.release, nil
}
release, err := detectRelease(ctx, channel, pin)
if err != nil {
return nil, err
}
c.key, c.at, c.release = key, time.Now(), release
return release, nil
}
// release is one published version and the zip that installs it here.
type release struct {
version string
asset string
}
const releasesURL = "https://api.github.com/repos/" + ReleaseSlug + "/releases?per_page=100"
type githubRelease struct {
TagName string `json:"tag_name"`
Draft bool `json:"draft"`
Prerelease bool `json:"prerelease"`
Assets []struct {
Name string `json:"name"`
} `json:"assets"`
}
// detectRelease resolves channel to one published release. A release with no
// zip for this platform, or no SHA256SUMS to verify it against, is not
// installable, so it is never offered.
func detectRelease(ctx context.Context, channel, pin string) (*release, error) {
if err := ValidateChannel(channel, pin); err != nil {
return nil, err
}
releases, err := listReleases(ctx)
if err != nil {
return nil, fmt.Errorf("find releases: %w", err)
}
if found := pick(releases, channel, pin); found != nil {
return found, nil
}
return nil, errors.New("no published release with a linux-amd64 zip matches the channel")
}
func listReleases(ctx context.Context) ([]githubRelease, error) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, releasesURL, nil)
if err != nil {
return nil, err
}
req.Header.Set("Accept", "application/vnd.github+json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("GitHub answered %s", resp.Status)
}
var releases []githubRelease
if err := json.NewDecoder(resp.Body).Decode(&releases); err != nil {
return nil, fmt.Errorf("decode releases: %w", err)
}
return releases, nil
}
// pick returns the newest installable release on channel.
func pick(releases []githubRelease, channel, pin string) *release {
var best *release
for _, r := range releases {
if !onChannel(r, channel, pin) {
continue
}
asset := installable(r)
if asset == "" {
continue
}
if best == nil || semver.Compare(r.TagName, "v"+best.version) > 0 {
best = &release{version: strings.TrimPrefix(r.TagName, "v"), asset: asset}
}
}
return best
}
// onChannel: stable skips prereleases, next includes them, and exact-pin takes
// only the pinned tag.
func onChannel(r githubRelease, channel, pin string) bool {
if r.Draft || !semver.IsValid(r.TagName) {
return false
}
switch channel {
case "exact-pin":
return r.TagName == "v"+strings.TrimPrefix(pin, "v")
case "next":
return true
default:
return !r.Prerelease
}
}
// installable names the release's linux-amd64 zip, or "" when it has none or
// no SHA256SUMS to verify it against.
func installable(r githubRelease) string {
asset, sums := "", false
for _, a := range r.Assets {
switch {
case a.Name == "SHA256SUMS":
sums = true
case strings.HasSuffix(a.Name, "-linux-amd64.zip"):
asset = a.Name
}
}
if !sums {
return ""
}
return asset
}
// ReleaseVersion is the release a build was cut from: a git-describe build
// ("1.55.0-218-gabc123") is the same release as its tag. A build that names no
// release ("dev") has none, so nothing can be judged newer than it.
func ReleaseVersion(version string) string {
version = buildSuffix.ReplaceAllString(version, "")
if !semver.IsValid("v" + strings.TrimPrefix(version, "v")) {
return ""
}
return version
}
// installedAgent is the image the installer last switched to, recorded in a
// sidecar beside the binaries; without one it is the runtime this release was
// cut with. A malformed sidecar is unknown, not guessed.
func installedAgent(binDir string) string {
data, err := os.ReadFile(filepath.Join(binDir, agentVersionFile))
if binDir == "" || errors.Is(err, os.ErrNotExist) {
return ReleaseVersion(buildinfo.Runtime)
}
version := strings.TrimSpace(string(data))
if err != nil || strings.ContainsAny(version, " \n") || ValidateChannel("exact-pin", version) != nil {
return ""
}
return ReleaseVersion(version)
}
func executableDir() string {
exe, err := os.Executable()
if err != nil {
return ""
}
return filepath.Dir(exe)
}
+13 -2
View File
@@ -12,6 +12,8 @@ import (
"path/filepath" "path/filepath"
"strconv" "strconv"
"strings" "strings"
"github.com/samcharles93/archie-core/internal/domain/distribution"
) )
// ResultSentinel prefixes the one line `archied update install` prints to // ResultSentinel prefixes the one line `archied update install` prints to
@@ -23,8 +25,11 @@ const ResultSentinel = "ARCHIE_UPDATE_RESULT "
var ErrNotConfigured = errors.New("updates are not configured") var ErrNotConfigured = errors.New("updates are not configured")
// ArchiedInstaller runs `archied update install` from beside this binary, so // ArchiedInstaller runs `archied update install` from beside this binary, so
// every service installs through the daemon's one transaction. // every service installs through the daemon's one transaction. Source is the
type ArchiedInstaller struct{} // distribution source the release was found in, so it installs from the same.
type ArchiedInstaller struct {
Source func(context.Context) (distribution.Source, error)
}
func (ArchiedInstaller) path() string { func (ArchiedInstaller) path() string {
path := filepath.Join(executableDir(), WatchdogBinary) path := filepath.Join(executableDir(), WatchdogBinary)
@@ -47,8 +52,14 @@ func (i ArchiedInstaller) Install(ctx context.Context, snapshot Snapshot, meta I
if len(available) == 0 { if len(available) == 0 {
return Result{}, errors.New("nothing to install") return Result{}, errors.New("nothing to install")
} }
source, err := i.Source(ctx)
if err != nil {
return Result{}, err
}
cmd := exec.CommandContext(ctx, path, "update", "install", cmd := exec.CommandContext(ctx, path, "update", "install",
"-version", available[0].Available, "-version", available[0].Available,
"-source", source.Reference,
"-key", distribution.EncodeKey(source.Key),
"-report", meta.ReportPath, "-report", meta.ReportPath,
"-channel", meta.Channel, "-channel", meta.Channel,
"-chat", strconv.FormatInt(meta.ChatID, 10), "-chat", strconv.FormatInt(meta.ChatID, 10),
+26 -64
View File
@@ -2,16 +2,11 @@ package releaseupdate
import ( import (
"archive/zip" "archive/zip"
"bufio"
"bytes"
"context" "context"
"crypto/sha256"
"encoding/hex"
"encoding/json" "encoding/json"
"errors" "errors"
"fmt" "fmt"
"io" "io"
"net/http"
"os" "os"
"os/exec" "os/exec"
"path" "path"
@@ -23,11 +18,9 @@ import (
"time" "time"
"github.com/samcharles93/archie-core/internal/buildinfo" "github.com/samcharles93/archie-core/internal/buildinfo"
"github.com/samcharles93/archie-core/internal/domain/distribution"
) )
// ReleaseURL is where published release assets are downloaded from.
const ReleaseURL = "https://github.com/" + ReleaseSlug + "/releases/download"
var ( var (
releaseVersion = regexp.MustCompile(`^[0-9]+\.[0-9]+\.[0-9]+([+-][0-9A-Za-z.-]+)?$`) releaseVersion = regexp.MustCompile(`^[0-9]+\.[0-9]+\.[0-9]+([+-][0-9A-Za-z.-]+)?$`)
releaseUnit = regexp.MustCompile(`^archie[a-z0-9-]*$`) releaseUnit = regexp.MustCompile(`^archie[a-z0-9-]*$`)
@@ -37,22 +30,25 @@ var (
// PrepareRequest names the release to stage and who hears the outcome. // PrepareRequest names the release to stage and who hears the outcome.
type PrepareRequest struct { type PrepareRequest struct {
Version string Version string
// ReleaseURL is the base the release's zip and SHA256SUMS are under. // Source is the distribution source the release is fetched and verified
ReleaseURL string // from.
Meta InstallMeta Source distribution.Source
Meta InstallMeta
// CheckTopology refuses a host missing a unit or config section the // CheckTopology refuses a host missing a unit or config section the
// release requires. managed reports whether units are observable. // release requires. managed reports whether units are observable.
CheckTopology func(ctx context.Context, required Topology, managed bool) error CheckTopology func(ctx context.Context, required Topology, managed bool) error
} }
// Manifest is the release.json a release zip carries. // Manifest is the release.json a release zip carries, with the agent image
// taken from the signed statement rather than from the zip.
type Manifest struct { type Manifest struct {
Required Topology `json:"required_topology"` Required Topology `json:"required_topology"`
AgentImage string `json:"agent_image"` AgentImage string `json:"agent_image"`
} }
// Prepare verifies and stages a release without changing anything that runs: // Prepare verifies and stages a release without changing anything that runs:
// the zip is checked against SHA256SUMS, every binary must report the release, // the statement must verify against the source's key and the zip against the
// statement, every binary must report the release,
// the agent image is pulled by digest and the database is backed up before a // the agent image is pulled by digest and the database is backed up before a
// journal is published. The watchdog (Run) takes it from there. // journal is published. The watchdog (Run) takes it from there.
func (t *Transaction) Prepare(ctx context.Context, req PrepareRequest) (Result, error) { func (t *Transaction) Prepare(ctx context.Context, req PrepareRequest) (Result, error) {
@@ -117,11 +113,15 @@ func (t *Transaction) fetch(ctx context.Context, req PrepareRequest, work string
if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" { if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
return "", Manifest{}, fmt.Errorf("no published release for %s/%s", runtime.GOOS, runtime.GOARCH) return "", Manifest{}, fmt.Errorf("no published release for %s/%s", runtime.GOOS, runtime.GOARCH)
} }
name := fmt.Sprintf("archie-core-archied-v%s-linux-amd64", req.Version) verified, err := Fetch(ctx, req.Source, Tag("exact-pin", req.Version))
base := strings.TrimSuffix(req.ReleaseURL, "/") + "/v" + req.Version + "/" if err != nil {
t.say("downloading %s", name+".zip") return "", Manifest{}, err
archive := filepath.Join(work, name+".zip") }
if err := downloadVerified(ctx, base, name+".zip", archive); err != nil { zipName := verified.Statement.Zip.Name
name := strings.TrimSuffix(zipName, ".zip")
t.say("downloading %s", zipName)
archive := filepath.Join(work, zipName)
if err := writeBlob(ctx, verified, archive); err != nil {
return "", Manifest{}, err return "", Manifest{}, err
} }
if err := unpack(archive, name, work); err != nil { if err := unpack(archive, name, work); err != nil {
@@ -132,6 +132,7 @@ func (t *Transaction) fetch(ctx context.Context, req PrepareRequest, work string
if err != nil { if err != nil {
return "", Manifest{}, err return "", Manifest{}, err
} }
manifest.AgentImage = verified.Statement.AgentImage
for _, binary := range manifest.Required.apps() { for _, binary := range manifest.Required.apps() {
reported, err := reportedVersion(ctx, filepath.Join(release, binary), binary) reported, err := reportedVersion(ctx, filepath.Join(release, binary), binary)
if err != nil { if err != nil {
@@ -226,61 +227,25 @@ func (t *Transaction) stage(req PrepareRequest, release string, j journal) error
return syncDir(t.StateDir) return syncDir(t.StateDir)
} }
func downloadVerified(ctx context.Context, base, name, dst string) error { // writeBlob writes the release's zip to dst, checked against the digest the
var sums bytes.Buffer // signed statement names.
if err := download(ctx, base+"SHA256SUMS", &sums, 1<<20); err != nil { func writeBlob(ctx context.Context, release Release, dst string) error {
return err
}
expected := ""
scanner := bufio.NewScanner(&sums)
for scanner.Scan() {
if fields := strings.Fields(scanner.Text()); len(fields) == 2 && fields[1] == name {
if expected != "" {
return fmt.Errorf("SHA256SUMS lists %s twice", name)
}
expected = strings.ToLower(fields[0])
}
}
if len(expected) != sha256.Size*2 {
return fmt.Errorf("SHA256SUMS has no checksum for %s", name)
}
file, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600) file, err := os.OpenFile(dst, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
if err != nil { if err != nil {
return err return err
} }
hash := sha256.New() ctx, cancel := context.WithTimeout(ctx, 5*time.Minute)
err = download(ctx, base+name, io.MultiWriter(file, hash), 1<<30) defer cancel()
err = release.Artifact.Blob(ctx, release.Statement.Zip.Digest, file, 1<<30)
if closeErr := file.Close(); err == nil { if closeErr := file.Close(); err == nil {
err = closeErr err = closeErr
} }
if err != nil { if err != nil {
return err return fmt.Errorf("download %s: %w", release.Statement.Zip.Name, err)
}
if hex.EncodeToString(hash.Sum(nil)) != expected {
return fmt.Errorf("release checksum mismatch for %s", name)
} }
return nil return nil
} }
func download(ctx context.Context, url string, out io.Writer, limit int64) error {
ctx, cancel := context.WithTimeout(ctx, 5*time.Minute)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return fmt.Errorf("download %s: %w", url, err)
}
defer func() { _ = resp.Body.Close() }()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("download %s: %s", url, resp.Status)
}
_, err = io.Copy(out, io.LimitReader(resp.Body, limit))
return err
}
// unpack extracts the zip's single distribution directory, refusing any // unpack extracts the zip's single distribution directory, refusing any
// entry outside it and anything but regular files and directories. // entry outside it and anything but regular files and directories.
func unpack(archive, name, dst string) error { func unpack(archive, name, dst string) error {
@@ -350,9 +315,6 @@ func readManifest(path string) (Manifest, error) {
return Manifest{}, fmt.Errorf("invalid release unit %q", unit) return Manifest{}, fmt.Errorf("invalid release unit %q", unit)
} }
} }
if !pinnedImage.MatchString(manifest.AgentImage) {
return Manifest{}, errors.New("release has no digest-pinned agent image")
}
return manifest, nil return manifest, nil
} }
+133
View File
@@ -0,0 +1,133 @@
package releaseupdate
import (
"bytes"
"context"
"crypto/ed25519"
"encoding/base64"
"encoding/json"
"fmt"
"os"
"time"
digest "github.com/opencontainers/go-digest"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"oras.land/oras-go/v2/registry/remote"
"oras.land/oras-go/v2/registry/remote/auth"
"oras.land/oras-go/v2/registry/remote/credentials"
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
)
// PublishRequest is one release to sign and push.
type PublishRequest struct {
// Repository is the OCI repository the release is pushed to.
Repository string
Signer ed25519.PrivateKey
Version string
Prerelease bool
// ZipPath is the distribution zip, named ZipName(Version).
ZipPath string
AgentImage string
Changelog string
// Channels are the moving tags pointed at this release besides its own
// version tag.
Channels []string
}
// Publish signs a statement for the release and pushes it with the zip as
// one artifact, tagged with its version and each channel. Registry
// credentials come from the Docker config, as `docker login` left them.
func Publish(ctx context.Context, req PublishRequest) (Statement, error) {
archive, err := os.ReadFile(req.ZipPath)
if err != nil {
return Statement{}, err
}
statement := Statement{
Version: req.Version, Prerelease: req.Prerelease, IssuedAt: time.Now().UTC(), Platform: Platform,
Zip: Blob{Name: ZipName(req.Version), Digest: signedoci.Digest(archive), Size: int64(len(archive))},
AgentImage: req.AgentImage, Changelog: req.Changelog,
}
if err := statement.Validate(); err != nil {
return Statement{}, err
}
for _, channel := range req.Channels {
if channel != "stable" && channel != "next" {
return Statement{}, fmt.Errorf("unknown channel %q", channel)
}
}
encoded, err := json.Marshal(statement)
if err != nil {
return Statement{}, err
}
repository, err := pushRepository(req.Repository)
if err != nil {
return Statement{}, err
}
layers := []ocispec.Descriptor{
{MediaType: StatementMediaType, Digest: digest.FromBytes(encoded), Size: int64(len(encoded))},
{
MediaType: "application/zip", Digest: digest.FromBytes(archive), Size: int64(len(archive)),
Annotations: map[string]string{ocispec.AnnotationTitle: statement.Zip.Name},
},
}
for i, content := range [][]byte{ocispec.DescriptorEmptyJSON.Data, encoded, archive} {
desc := ocispec.DescriptorEmptyJSON
if i > 0 {
desc = layers[i-1]
}
if err := pushBlob(ctx, repository, desc, content); err != nil {
return Statement{}, err
}
}
manifest, err := json.Marshal(ocispec.Manifest{
SchemaVersion: 2, MediaType: ocispec.MediaTypeImageManifest,
ArtifactType: ArtifactType, Config: ocispec.DescriptorEmptyJSON, Layers: layers,
Annotations: map[string]string{
Annotation: base64.StdEncoding.EncodeToString(ed25519.Sign(req.Signer, encoded)),
ocispec.AnnotationCreated: statement.IssuedAt.Format(time.RFC3339),
},
})
if err != nil {
return Statement{}, err
}
desc := ocispec.Descriptor{MediaType: ocispec.MediaTypeImageManifest, Digest: digest.FromBytes(manifest), Size: int64(len(manifest))}
if err := repository.PushReference(ctx, desc, bytes.NewReader(manifest), Tag("exact-pin", req.Version)); err != nil {
return Statement{}, fmt.Errorf("push release manifest: %w", err)
}
for _, channel := range req.Channels {
if err := repository.Tag(ctx, desc, channel); err != nil {
return Statement{}, fmt.Errorf("tag %s: %w", channel, err)
}
}
return statement, nil
}
func pushRepository(reference string) (*remote.Repository, error) {
repository, err := remote.NewRepository(reference)
if err != nil {
return nil, err
}
repository.PlainHTTP = signedoci.Loopback(reference)
store, err := credentials.NewStoreFromDocker(credentials.StoreOptions{})
if err != nil {
return nil, fmt.Errorf("read registry credentials: %w", err)
}
repository.Client = &auth.Client{Credential: credentials.Credential(store)}
return repository, nil
}
// pushBlob uploads content unless the registry already holds it.
func pushBlob(ctx context.Context, repository *remote.Repository, desc ocispec.Descriptor, content []byte) error {
exists, err := repository.Exists(ctx, desc)
if err != nil {
return fmt.Errorf("check blob %s: %w", desc.Digest, err)
}
if exists {
return nil
}
if err := repository.Push(ctx, desc, bytes.NewReader(content)); err != nil {
return fmt.Errorf("push blob %s: %w", desc.Digest, err)
}
return nil
}
+226
View File
@@ -0,0 +1,226 @@
package releaseupdate
import (
"context"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"regexp"
"strings"
"sync"
"time"
"golang.org/x/mod/semver"
"github.com/samcharles93/archie-core/internal/buildinfo"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
)
// Annotation carries the source key's signature over a release statement.
const Annotation = "dev.archie.release.signature.v1"
// ArtifactType marks a release manifest.
const ArtifactType = "application/vnd.archie.release.v1"
// StatementMediaType is the release statement layer's media type.
const StatementMediaType = "application/vnd.archie.release.statement.v1+json"
// Platform is the only platform releases are built for.
const Platform = "linux-amd64"
const maxStatementBytes = 64 << 10
// buildSuffix is the git-describe tail of an untagged build (1.7.0-4-g0736708).
var buildSuffix = regexp.MustCompile(`-[0-9]+-g[0-9a-f]+$`)
// Statement is what a release's signature covers: the version, when it was
// issued, the zip that installs it and the agent image it runs. Everything an
// install trusts comes from here, never from the registry tag or the zip.
type Statement struct {
Version string `json:"version"`
Prerelease bool `json:"prerelease"`
IssuedAt time.Time `json:"issued_at"`
Platform string `json:"platform"`
Zip Blob `json:"zip"`
AgentImage string `json:"agent_image"`
Changelog string `json:"changelog,omitempty"`
}
// Blob names a release layer by its content digest.
type Blob struct {
Name string `json:"name"`
Digest string `json:"digest"`
Size int64 `json:"size"`
}
// Validate refuses a statement an install could not act on safely.
func (s Statement) Validate() error {
switch {
case !releaseVersion.MatchString(s.Version):
return fmt.Errorf("release statement version %q is not a release version", s.Version)
case s.IssuedAt.IsZero():
return errors.New("release statement has no issue time")
case s.Platform != Platform:
return fmt.Errorf("release statement is for %q, not %s", s.Platform, Platform)
case s.Zip.Name != ZipName(s.Version) || !strings.HasPrefix(s.Zip.Digest, "sha256:") || s.Zip.Size <= 0:
return errors.New("release statement does not name its zip by name, digest and size")
case !pinnedImage.MatchString(s.AgentImage):
return fmt.Errorf("release statement agent image %q is not pinned by digest", s.AgentImage)
}
return nil
}
// ZipName is the distribution zip a version is published as.
func ZipName(version string) string {
return fmt.Sprintf("archie-core-archied-v%s-%s.zip", version, Platform)
}
// Tag is the registry tag a channel resolves through: stable and next are
// moving tags, an exact pin is the version's own.
func Tag(channel, pin string) string {
if channel == "exact-pin" {
return "v" + strings.TrimPrefix(pin, "v")
}
return channel
}
// Release is a verified release and the artifact its zip is read from.
type Release struct {
Statement Statement
Artifact signedoci.Artifact
}
// Fetch resolves tag at source and verifies its statement. A statement on a
// moving channel tag issued before the newest one accepted from that tag is a
// replay and is refused; an exact pin may name an older release on purpose.
func Fetch(ctx context.Context, source distribution.Source, tag string) (Release, error) {
artifact, err := signedoci.Fetch(ctx, source, tag, Annotation, maxStatementBytes)
if err != nil {
return Release{}, fmt.Errorf("release: %w", err)
}
decoder := json.NewDecoder(strings.NewReader(string(artifact.Statement)))
decoder.DisallowUnknownFields()
var statement Statement
if err := decoder.Decode(&statement); err != nil {
return Release{}, fmt.Errorf("release statement: %w", err)
}
if err := statement.Validate(); err != nil {
return Release{}, err
}
if strings.HasPrefix(tag, "v") {
if "v"+statement.Version != tag {
return Release{}, fmt.Errorf("tag %s carries the statement for %s", tag, statement.Version)
}
return Release{Statement: statement, Artifact: artifact}, nil
}
mark := &signedoci.FileFreshness{Path: signedoci.MarkPath("releases", source.Reference+":"+tag)}
newest, err := mark.Newest(ctx)
if err != nil {
return Release{}, err
}
if !newest.IsZero() && statement.IssuedAt.Before(newest) {
return Release{}, fmt.Errorf("release on %s was issued %s, before the newest accepted %s",
tag, statement.IssuedAt.Format(time.RFC3339), newest.Format(time.RFC3339))
}
if err := mark.Accept(ctx, statement.IssuedAt); err != nil {
return Release{}, fmt.Errorf("record release freshness: %w", err)
}
return Release{Statement: statement, Artifact: artifact}, nil
}
// RegistryCatalog reports the release on the selected channel against this build.
// Only one version covers every component, so the daemon and agent are
// offered the same release.
type RegistryCatalog struct {
// Settings returns the source, channel and pin in force.
Settings func(context.Context) (source distribution.Source, channel, pin string, err error)
// A found release is reused for checkTTL so a dashboard that polls does
// not hit the registry on every view.
mu sync.Mutex
key string
at time.Time
statement Statement
}
const checkTTL = 10 * time.Minute
func (c *RegistryCatalog) Check(ctx context.Context) (Snapshot, error) {
source, channel, pin, err := c.Settings(ctx)
if err != nil {
return Snapshot{}, err
}
if channel == "" {
channel = "stable"
}
if err := ValidateChannel(channel, pin); err != nil {
return Snapshot{}, err
}
statement, err := c.detect(ctx, source, Tag(channel, pin))
if err != nil {
return Snapshot{}, err
}
component := func(id, label, installed string) Component {
return Component{
ID: id, Label: label,
Installed: installed, Available: statement.Version,
Reference: statement.Zip.Name, Changelog: statement.Changelog,
}
}
return Snapshot{Components: []Component{
component("daemon", "Gateway", ReleaseVersion(buildinfo.Version)),
component("agent", "Runtime", installedAgent(executableDir())),
}}, nil
}
func (c *RegistryCatalog) detect(ctx context.Context, source distribution.Source, tag string) (Statement, error) {
c.mu.Lock()
defer c.mu.Unlock()
key := source.Reference + "\x00" + distribution.EncodeKey(source.Key) + "\x00" + tag
if c.key == key && time.Since(c.at) < checkTTL {
return c.statement, nil
}
release, err := Fetch(ctx, source, tag)
if err != nil {
return Statement{}, err
}
c.key, c.at, c.statement = key, time.Now(), release.Statement
return release.Statement, nil
}
// ReleaseVersion is the release a build was cut from: a git-describe build
// ("1.55.0-218-gabc123") is the same release as its tag. A build that names no
// release ("dev") has none, so nothing can be judged newer than it.
func ReleaseVersion(version string) string {
version = buildSuffix.ReplaceAllString(version, "")
if !semver.IsValid("v" + strings.TrimPrefix(version, "v")) {
return ""
}
return version
}
// installedAgent is the image the installer last switched to, recorded in a
// sidecar beside the binaries; without one it is the runtime this release was
// cut with. A malformed sidecar is unknown, not guessed.
func installedAgent(binDir string) string {
data, err := os.ReadFile(filepath.Join(binDir, agentVersionFile))
if binDir == "" || errors.Is(err, os.ErrNotExist) {
return ReleaseVersion(buildinfo.Runtime)
}
version := strings.TrimSpace(string(data))
if err != nil || strings.ContainsAny(version, " \n") || ValidateChannel("exact-pin", version) != nil {
return ""
}
return ReleaseVersion(version)
}
func executableDir() string {
exe, err := os.Executable()
if err != nil {
return ""
}
return filepath.Dir(exe)
}
+74
View File
@@ -0,0 +1,74 @@
package releaseupdate
import (
"crypto/ed25519"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
)
// A release is trusted only when the source's key signed its statement, the
// tag it was found under agrees with it, and a moving channel tag never goes
// back to a release issued before one already accepted from it.
func TestFetchRelease(t *testing.T) {
trusted, signer, _ := ed25519.GenerateKey(nil)
stranger, _, _ := ed25519.GenerateKey(nil)
archive := []byte("zip")
statement := func(version string, issued time.Time) []byte {
data, err := json.Marshal(Statement{
Version: version, IssuedAt: issued, Platform: Platform, AgentImage: newImage,
Zip: Blob{Name: ZipName(version), Digest: signedoci.Digest(archive), Size: int64(len(archive))},
})
if err != nil {
t.Fatal(err)
}
return data
}
jan1, jan2 := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2026, 1, 2, 0, 0, 0, 0, time.UTC)
cases := []struct {
name string
accepted []byte // a statement already accepted from the same tag
statement []byte
tag string
key ed25519.PublicKey
want string // error substring, or "" to accept
}{
{name: "signed by the source key", statement: statement("2.0.0", jan1), tag: "stable", key: trusted},
{name: "signed by another key", statement: statement("2.0.0", jan1), tag: "stable", key: stranger, want: "signature"},
{name: "a version tag carrying another version", statement: statement("2.0.0", jan1), tag: "v3.0.0", key: trusted, want: "carries"},
{name: "a channel moved back to an older release", accepted: statement("2.1.0", jan2), statement: statement("2.0.0", jan1), tag: "stable", key: trusted, want: "before the newest"},
{name: "an exact pin to an older release", accepted: statement("2.1.0", jan2), statement: statement("2.0.0", jan1), tag: "v2.0.0", key: trusted},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Setenv("XDG_STATE_HOME", t.TempDir())
// One registry, so the freshness mark for the tag is shared; it
// serves the accepted statement first, then the one under test.
var current http.Handler
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { current.ServeHTTP(w, r) }))
defer server.Close()
source := distribution.Source{Reference: strings.TrimPrefix(server.URL, "http://") + "/archie", Key: tc.key}
if tc.accepted != nil {
current = fakeRegistry(t, "archie", "stable", signer, tc.accepted, archive, archive)
if _, err := Fetch(t.Context(), distribution.Source{Reference: source.Reference, Key: trusted}, "stable"); err != nil {
t.Fatalf("accept the newer release: %v", err)
}
}
current = fakeRegistry(t, "archie", tc.tag, signer, tc.statement, archive, archive)
_, err := Fetch(t.Context(), source, tc.tag)
switch {
case tc.want == "" && err != nil:
t.Fatalf("Fetch: %v", err)
case tc.want != "" && (err == nil || !strings.Contains(err.Error(), tc.want)):
t.Fatalf("Fetch error = %v, want %q", err, tc.want)
}
})
}
}
+68 -11
View File
@@ -4,7 +4,9 @@ import (
"archive/zip" "archive/zip"
"bytes" "bytes"
"context" "context"
"crypto/sha256" "crypto/ed25519"
"encoding/base64"
"encoding/json"
"errors" "errors"
"fmt" "fmt"
"net/http" "net/http"
@@ -15,6 +17,12 @@ import (
"strings" "strings"
"testing" "testing"
"time" "time"
digest "github.com/opencontainers/go-digest"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
) )
var testUnits = []string{"archie-state-store", "archie-gateway", "archied"} var testUnits = []string{"archie-state-store", "archie-gateway", "archied"}
@@ -152,7 +160,7 @@ func TestTransaction(t *testing.T) {
name string name string
host fakeHost host fakeHost
candidate string // version the release's archied reports candidate string // version the release's archied reports
corrupt bool // SHA256SUMS does not match the zip corrupt bool // the registry serves a zip other than the one signed
crashAt string // phase the watchdog dies in, then boot recovers crashAt string // phase the watchdog dies in, then boot recovers
prepare string // Prepare refusal prepare string // Prepare refusal
want outcome want outcome
@@ -162,7 +170,7 @@ func TestTransaction(t *testing.T) {
{name: "unhealthy migrated release restores the database", host: fakeHost{managed: true, unhealthy: true, migrates: true}, want: outcome{version: "1.0.0", image: oldImage, report: "failed", restoredDatabase: true}}, {name: "unhealthy migrated release restores the database", host: fakeHost{managed: true, unhealthy: true, migrates: true}, want: outcome{version: "1.0.0", image: oldImage, report: "failed", restoredDatabase: true}},
{name: "stuck image switch rolls back", host: fakeHost{managed: true, hangs: true}, want: old}, {name: "stuck image switch rolls back", host: fakeHost{managed: true, hangs: true}, want: old},
{name: "without systemd it installs without restarting", host: fakeHost{}, want: outcome{version: "2.0.0", image: newImage}}, {name: "without systemd it installs without restarting", host: fakeHost{}, want: outcome{version: "2.0.0", image: newImage}},
{name: "checksum mismatch is refused", host: fakeHost{managed: true}, corrupt: true, prepare: "checksum mismatch", want: outcome{version: "1.0.0", image: oldImage}}, {name: "a tampered zip is refused", host: fakeHost{managed: true}, corrupt: true, prepare: "digest", want: outcome{version: "1.0.0", image: oldImage}},
{name: "misreported candidate is refused", host: fakeHost{managed: true}, candidate: "1.9.0", prepare: "reports", want: outcome{version: "1.0.0", image: oldImage}}, {name: "misreported candidate is refused", host: fakeHost{managed: true}, candidate: "1.9.0", prepare: "reports", want: outcome{version: "1.0.0", image: oldImage}},
{name: "crash before the watchdog started is abandoned", host: fakeHost{managed: true}, crashAt: phasePrepared, want: old}, {name: "crash before the watchdog started is abandoned", host: fakeHost{managed: true}, crashAt: phasePrepared, want: old},
{name: "crash while switching rolls back", host: fakeHost{managed: true}, crashAt: phaseSwitching, want: old}, {name: "crash while switching rolls back", host: fakeHost{managed: true}, crashAt: phaseSwitching, want: old},
@@ -180,7 +188,8 @@ func TestTransaction(t *testing.T) {
if candidate == "" { if candidate == "" {
candidate = "2.0.0" candidate = "2.0.0"
} }
server := httptest.NewServer(releaseHandler(t, candidate, tt.corrupt)) handler, key := releaseHandler(t, candidate, tt.corrupt)
server := httptest.NewServer(handler)
defer server.Close() defer server.Close()
for _, unit := range testUnits { for _, unit := range testUnits {
writeTestFile(t, filepath.Join(host.bin, unit), versionScript(unit, "1.0.0")) writeTestFile(t, filepath.Join(host.bin, unit), versionScript(unit, "1.0.0"))
@@ -192,7 +201,7 @@ func TestTransaction(t *testing.T) {
HealthTimeout: 20 * time.Millisecond, Observe: 5 * time.Millisecond, Poll: time.Millisecond, HealthTimeout: 20 * time.Millisecond, Observe: 5 * time.Millisecond, Poll: time.Millisecond,
} }
_, err := tx.Prepare(t.Context(), PrepareRequest{Version: "2.0.0", ReleaseURL: server.URL, Meta: InstallMeta{Channel: "webui", ReportPath: report}}) _, err := tx.Prepare(t.Context(), PrepareRequest{Version: "2.0.0", Source: distribution.Source{Reference: strings.TrimPrefix(server.URL, "http://") + "/archie", Key: key}, Meta: InstallMeta{Channel: "webui", ReportPath: report}})
switch { switch {
case tt.prepare != "": case tt.prepare != "":
if err == nil || !strings.Contains(err.Error(), tt.prepare) { if err == nil || !strings.Contains(err.Error(), tt.prepare) {
@@ -254,7 +263,7 @@ func TestTransaction(t *testing.T) {
// releaseHandler serves one release's zip and SHA256SUMS the way GitHub // releaseHandler serves one release's zip and SHA256SUMS the way GitHub
// release downloads are laid out. // release downloads are laid out.
func releaseHandler(t *testing.T, candidate string, corrupt bool) http.Handler { func releaseHandler(t *testing.T, candidate string, corrupt bool) (http.Handler, ed25519.PublicKey) {
t.Helper() t.Helper()
name := "archie-core-archied-v2.0.0-linux-amd64" name := "archie-core-archied-v2.0.0-linux-amd64"
var archive bytes.Buffer var archive bytes.Buffer
@@ -277,17 +286,65 @@ func releaseHandler(t *testing.T, candidate string, corrupt bool) http.Handler {
} }
add(unit, versionScript(unit, version)) add(unit, versionScript(unit, version))
} }
add("release.json", fmt.Sprintf(`{"required_topology":{"units":["%s"]},"agent_image":%q}`, strings.Join(testUnits, `","`), newImage)) add("release.json", fmt.Sprintf(`{"required_topology":{"units":["%s"]}}`, strings.Join(testUnits, `","`)))
if err := writer.Close(); err != nil { if err := writer.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
sum := sha256.Sum256(archive.Bytes()) zipDigest := signedoci.Digest(archive.Bytes())
statement, err := json.Marshal(Statement{
Version: "2.0.0", IssuedAt: time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC), Platform: Platform,
Zip: Blob{Name: name + ".zip", Digest: zipDigest, Size: int64(archive.Len())},
AgentImage: newImage,
})
if err != nil {
t.Fatal(err)
}
public, private, err := ed25519.GenerateKey(nil)
if err != nil {
t.Fatal(err)
}
served := archive.Bytes()
if corrupt { if corrupt {
sum[0] ^= 0xff served = append([]byte(nil), served...)
served[len(served)/2] ^= 0xff
}
return fakeRegistry(t, "archie", "v2.0.0", private, statement, archive.Bytes(), served), public
}
// fakeRegistry serves one signed release artifact at repository:tag, the way
// an OCI registry answers oras: the manifest by tag, each layer by digest.
// served is the zip the registry returns, which a tampering registry swaps.
func fakeRegistry(t *testing.T, repository, tag string, signer ed25519.PrivateKey, statement, archive, served []byte) http.Handler {
t.Helper()
blobs := map[string][]byte{signedoci.Digest(statement): statement, signedoci.Digest(archive): served}
manifest, err := json.Marshal(ocispec.Manifest{
SchemaVersion: 2,
MediaType: ocispec.MediaTypeImageManifest,
ArtifactType: ArtifactType,
Config: ocispec.DescriptorEmptyJSON,
Layers: []ocispec.Descriptor{
{MediaType: StatementMediaType, Digest: digest.FromBytes(statement), Size: int64(len(statement))},
{MediaType: "application/zip", Digest: digest.FromBytes(archive), Size: int64(len(archive))},
},
Annotations: map[string]string{Annotation: base64.StdEncoding.EncodeToString(ed25519.Sign(signer, statement))},
})
if err != nil {
t.Fatal(err)
} }
mux := http.NewServeMux() mux := http.NewServeMux()
mux.HandleFunc("/v2.0.0/"+name+".zip", func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write(archive.Bytes()) }) mux.HandleFunc("/v2/"+repository+"/manifests/"+tag, func(w http.ResponseWriter, _ *http.Request) {
mux.HandleFunc("/v2.0.0/SHA256SUMS", func(w http.ResponseWriter, _ *http.Request) { fmt.Fprintf(w, "%x %s.zip\n", sum, name) }) w.Header().Set("Content-Type", ocispec.MediaTypeImageManifest)
w.Header().Set("Docker-Content-Digest", signedoci.Digest(manifest))
_, _ = w.Write(manifest)
})
mux.HandleFunc("/v2/"+repository+"/blobs/", func(w http.ResponseWriter, r *http.Request) {
blob, ok := blobs[strings.TrimPrefix(r.URL.Path, "/v2/"+repository+"/blobs/")]
if !ok {
http.NotFound(w, r)
return
}
_, _ = w.Write(blob)
})
return mux return mux
} }
-47
View File
@@ -1,47 +0,0 @@
#!/usr/bin/env bash
# Publishes a tagged release by hand: the agent and archied images to GHCR,
# then the linux-amd64 zip, SHA256SUMS and install.sh to the public releases
# repository, whose release notes are the version's changelog section.
# Builds from a clean worktree of the tag, so local edits never ship.
set -euo pipefail
version="${1:?usage: tools/publish.sh X.Y.Z}"
tag="v$version"
releases="samcharles93/archie-releases"
registry="ghcr.io/samcharles93"
root="$(git rev-parse --show-toplevel)"
work="$(mktemp -d)"
trap 'git -C "$root" worktree remove --force "$work/src" >/dev/null 2>&1 || true; rm -rf "$work"' EXIT
git -C "$root" worktree add -q --detach "$work/src" "$tag"
cd "$work/src"
sha="$(git rev-parse "$tag^{commit}")"
docker build -q -f Dockerfile --build-arg RUNTIME_VERSION="$version" \
-t "$registry/archie-agent:latest" -t "$registry/archie-agent:sha-$sha" . >/dev/null
docker push -q "$registry/archie-agent:latest"
docker push -q "$registry/archie-agent:sha-$sha"
digest="$(docker inspect --format '{{range .RepoDigests}}{{println .}}{{end}}' "$registry/archie-agent:latest" |
grep "^$registry/archie-agent@" | head -1 | cut -d@ -f2)"
test -n "$digest"
docker build -q -f Dockerfile.archied --build-arg GATEWAY_VERSION="$version" --build-arg RUNTIME_VERSION="$version" \
-t "$registry/archied:latest" -t "$registry/archied:edge" -t "$registry/archied:sha-$sha" . >/dev/null
for t in latest edge "sha-$sha"; do docker push -q "$registry/archied:$t"; done
ldflags="-X github.com/samcharles93/archie-core/internal/installtype.buildType=binary -X github.com/samcharles93/archie-core/internal/buildinfo.Version=$version -X github.com/samcharles93/archie-core/internal/buildinfo.Runtime=$version"
name="archie-core-archied-$tag-linux-amd64"
mkdir -p "$name"
for cmd in $(jq -r '.required_topology.units[]' release.json); do
GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$ldflags" -o "$name/$cmd" "./cmd/$cmd"
done
cp deployments/INSTRUCTIONS.md CHANGELOG.md "$name/"
jq --arg image "$registry/archie-agent@$digest" '. + {agent_image: $image}' release.json >"$name/release.json"
if [ -f README.md ]; then cp README.md "$name/"; fi
zip -qr "$name.zip" "$name"
sha256sum "$name.zip" >SHA256SUMS
awk -v hdr="## [$version]" 'index($0,hdr)==1{p=1} p&&/^## \[/&&index($0,hdr)!=1{exit} p{print}' CHANGELOG.md >notes.md
test -s notes.md
gh release create "$tag" -R "$releases" --title "archie $tag" --notes-file notes.md "$name.zip" SHA256SUMS install.sh
echo "published $tag to $releases (agent $digest)"