Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Verifying releases

Every release archive, each installer (shell and PowerShell) on both channels, and the Android APK (of a tagged release or the latest dev build), has a detached minisign signature next to it, <file>.minisig, made in CI with a key Fontaine owns. A release is published only after CI has downloaded the finished draft and verified every archive, and each installer, against the public key in this repository, so an unsigned or mis-signed archive or installer is never public.

The archives of a dev build live in the immutable dev-<n> prerelease. The long-lived dev prerelease holds only fontaine-installer.sh, fontaine-installer.ps1 and fontaine-android.apk with their .minisig files, replaced after every successful dev publish; each installer is the dist script rewritten to download from that run’s dev-<n>. The PowerShell installer is also patched, before it is signed, with a sha256 check of the archive, which dist’s own script lacks; the signature covers exactly the script you download.

Channels and keys

ChannelWhat it carriesSigned withPublic key
releasetagged releases (vX.Y.Z)the release keyrust/fontaine/keys/release.pub
devthe latest CI-passing build of main, published as the prerelease dev-<n>the dev keyrust/fontaine/keys/dev.pub

The two channels use different keys, so a compromised dev key cannot sign a release. The keys are checked in and compiled into Fontaine. fontaine update and the automatic background update verify every archive they download with the key of the channel the install came from, requires the signed channel, file name and version to match the release it was offered, and replaces nothing if any check fails (see Updating). To verify an archive you downloaded yourself, do it by hand, as below.

A release is verified against <channel>.signing.pub, the key CI signed with, read at that release’s tag (for dev, at its commit): release.signing.pub and dev.signing.pub. It differs from <channel>.pub only in a key-rotation release, where <channel>.pub already holds the next key.

Verify an archive by hand

Install minisign, then download an archive, its .minisig and the channel’s signing key from the release’s tag:

minisign -Vm fontaine-x86_64-unknown-linux-gnu.tar.xz -p release.signing.pub

Expected output includes Signature and comment signature verified, followed by the Trusted comment: line. The signature file must be named <archive>.minisig and sit next to the archive, or be given with -x.

The signed trusted comment binds the signature to one archive, or to one installer:

fontaine-signature v1 channel=<release|dev> file=<archive name> version=<version> commit=<git sha>

Read it from the third line of the signature file, or from the Trusted comment: line minisign prints. Check that channel is the channel you meant, file is the archive (or fontaine-installer.sh or fontaine-installer.ps1) you downloaded and version is the one you expected: a validly signed archive for another target fails this check.

Each archive also has a .sha256 file, and the release has a combined sha256.sum:

sha256sum -c fontaine-x86_64-unknown-linux-gnu.tar.xz.sha256
sha256sum -c --ignore-missing sha256.sum

The checksums catch a corrupted download; only the signature proves who made the archive.

Verify the installer by hand

Download fontaine-installer.sh (or fontaine-installer.ps1 for Windows) and its .minisig from the dev release and dev.signing.pub, then:

minisign -Vm fontaine-installer.sh -p dev.signing.pub
minisign -Vm fontaine-installer.ps1 -p dev.signing.pub

The trusted comment has channel=dev and file=fontaine-installer.sh (or .ps1); its version and commit name the build whose dev-<n> archives the script downloads. The installers do not verify this signature themselves; see Installing Fontaine and on Windows.

The installers attached to a tagged release are signed the same way: download one and its .minisig from that release and verify with release.signing.pub; the trusted comment has channel=release, the installer’s file, and the release’s version and commit.

Verify the Android app

The Android app is released as fontaine-android.apk with a fontaine-android.apk.minisig, on tagged releases and on the dev release (the latest dev build of main). Verify it like an archive, with the signing key of its channel:

minisign -Vm fontaine-android.apk -p release.signing.pub
minisign -Vm fontaine-android.apk -p dev.signing.pub

The trusted comment has channel=release (or channel=dev) and file=fontaine-android.apk, with the build’s version and commit. The APK also carries an Android signature made with a keystore that only the signing job of its channel can read; Android uses it to accept an install or an update, and it is not the trust anchor. The release and dev keystores are different keys, so Android refuses to install a dev APK over a release one, or the reverse; uninstall first. The APK has no .sha256 file.

What the signature does not cover

The first install is trusted through HTTPS: the public key you verify against comes from this repository over the same channel as the archive. The installers (fontaine-installer.sh and fontaine-installer.ps1) are signed on both channels but do not check the minisign signature themselves; they verify the archive’s sha256 only, which the shell installer does only when sha256sum is present and the PowerShell installer always does (see Installing Fontaine). To get a signature check, download the archive and verify it as above; fontaine update does this itself for the archive it installs. Once Fontaine’s archives enable GitHub artifact attestations, gh attestation verify will apply as a further check; the minisign key stays the root of trust.