diff --git a/debian-live-config/build.sh b/debian-live-config/build.sh index 0b5d7d1c..d217134b 100755 --- a/debian-live-config/build.sh +++ b/debian-live-config/build.sh @@ -107,6 +107,10 @@ rsync -a "${SCRIPT_DIR}/config" "${BUILD_DIR}/" # Write branch config for hook script. mkdir -p "${BUILD_DIR}/config/includes.chroot/opt/wrolpi-blobs" echo "${BRANCH}" > "${BUILD_DIR}/config/includes.chroot/opt/wrolpi-branch" +# The hook verifies its WROLPi clone with the verifier and key from this (build) checkout, not from the clone. +mkdir -p "${BUILD_DIR}/config/includes.chroot/opt/wrolpi-verify" +cp "${SCRIPT_DIR}/../wrolpi/scripts/verify_wrolpi_commit.sh" "${SCRIPT_DIR}/../wrolpi/roland@learningselfreliance.com.gpg" \ + "${BUILD_DIR}/config/includes.chroot/opt/wrolpi-verify/" # Cache directory for downloaded blobs (persists across builds). BLOB_CACHE="${SCRIPT_DIR}/files" diff --git a/debian-live-config/config/hooks/normal/9999-wrolpi.hook.chroot b/debian-live-config/config/hooks/normal/9999-wrolpi.hook.chroot index 9b86a2ef..e733b365 100644 --- a/debian-live-config/config/hooks/normal/9999-wrolpi.hook.chroot +++ b/debian-live-config/config/hooks/normal/9999-wrolpi.hook.chroot @@ -48,6 +48,8 @@ git --version WROLPI_BRANCH="release" [ -f /opt/wrolpi-branch ] && WROLPI_BRANCH=$(cat /opt/wrolpi-branch) git clone -b "${WROLPI_BRANCH}" https://github.com/lrnselfreliance/wrolpi.git /opt/wrolpi +bash /opt/wrolpi-verify/verify_wrolpi_commit.sh /opt/wrolpi HEAD /opt/wrolpi-verify/roland@learningselfreliance.com.gpg +rm -rf /opt/wrolpi-verify rm -f /opt/wrolpi-branch # Install webapp. diff --git a/install.sh b/install.sh index 384e16f8..baf2e56f 100755 --- a/install.sh +++ b/install.sh @@ -30,6 +30,25 @@ while getopts ":hb:" option; do esac done +# Verifies the WROLPi checkout before anything in it runs. This is a copy of wrolpi/scripts/verify_wrolpi_commit.sh +# (install.sh runs before any verified checkout exists); a test keeps the two the same. +verify_wrolpi_commit() { + local repo=$1 rev=$2 key=$3 + local fingerprint=${WROLPI_SIGNING_FINGERPRINT:-A74A9634A86C65F3C13949AD1BA620CE6C9A4680} + local gnupghome status rc=1 + # A short path: gpg's agent socket lives in GNUPGHOME and its path is limited to ~108 characters. + gnupghome=$(mktemp -d /tmp/wgpg.XXXXXX) || return 1 + if GNUPGHOME="${gnupghome}" gpg --batch --quiet --import "${key}" 2>/dev/null; then + # VALIDSIG ... + status=$(GNUPGHOME="${gnupghome}" git -C "${repo}" verify-commit --raw "${rev}" 2>&1) && + awk -v fpr="${fingerprint}" '$2 == "VALIDSIG" && ($3 == fpr || $NF == fpr) {found = 1} END {exit !found}' \ + <<<"${status}" && rc=0 + fi + rm -rf "${gnupghome}" + [ ${rc} -eq 0 ] || echo "ERROR: ${rev} in ${repo} is not signed by the WROLPi key ${fingerprint}" >&2 + return ${rc} +} + rpi=false if (grep 'Raspberry Pi' /proc/cpuinfo >/dev/null); then rpi=true @@ -60,12 +79,17 @@ set -e [ -d /opt/wrolpi ] && git config --global --add safe.directory /opt/wrolpi # Get the latest WROLPi code. Use the branch requested. -apt install -y git +apt install -y git gnupg git --version git clone https://github.com/lrnselfreliance/wrolpi.git /opt/wrolpi || : # Use `checkout -B origin/` so the ref can never be mistaken for a path. A tracked `release/` # directory otherwise collides with the `release` branch name, making a bare `git checkout release` ambiguous. (cd /opt/wrolpi && git fetch && git checkout -B "${BRANCH}" "origin/${BRANCH}" && git reset --hard origin/"${BRANCH}") || exit 4 +# The key comes from the clone, so it is only trusted because its fingerprint is pinned in verify_wrolpi_commit. +verify_wrolpi_commit /opt/wrolpi HEAD /opt/wrolpi/wrolpi/roland@learningselfreliance.com.gpg || { + echo "Refusing to install: the WROLPi code on ${BRANCH} is not signed by the WROLPi release key." + exit 5 +} if [ ${rpi} == true ]; then /opt/wrolpi/scripts/install_raspberrypios.sh 2>&1 | tee /opt/wrolpi/install.log diff --git a/pi-gen/build.sh b/pi-gen/build.sh index 851706d3..6bfd8b58 100755 --- a/pi-gen/build.sh +++ b/pi-gen/build.sh @@ -122,6 +122,9 @@ git init -q "${BUILD_DIR}" && cp "${SCRIPT_DIR}/config.txt" "${BUILD_DIR}/config.txt" echo "export WROLPI_BRANCH=${BRANCH}" >> "${BUILD_DIR}/config.txt" rsync -a "${SCRIPT_DIR}"/stage2/* "${BUILD_DIR}/stage2/" +# The chroot verifies its WROLPi clone with the verifier and key from this (build) checkout, not from the clone. +cp "${SCRIPT_DIR}/../wrolpi/scripts/verify_wrolpi_commit.sh" "${SCRIPT_DIR}/../wrolpi/roland@learningselfreliance.com.gpg" \ + "${BUILD_DIR}/stage2/04-wrolpi/files/" # We only need to build the Lite and Desktop images. rm -f "${BUILD_DIR}"/stage*/EXPORT* diff --git a/pi-gen/stage2/04-wrolpi/01-packages-nr b/pi-gen/stage2/04-wrolpi/01-packages-nr index 1348c0e6..8d1872e5 100644 --- a/pi-gen/stage2/04-wrolpi/01-packages-nr +++ b/pi-gen/stage2/04-wrolpi/01-packages-nr @@ -23,6 +23,7 @@ gcc-doc git git-doc gnome-disk-utility +gnupg gnupg-agent gpsd gpsd-tools diff --git a/pi-gen/stage2/04-wrolpi/03-run-chroot.sh b/pi-gen/stage2/04-wrolpi/03-run-chroot.sh index d7655b8f..6ee07ddf 100755 --- a/pi-gen/stage2/04-wrolpi/03-run-chroot.sh +++ b/pi-gen/stage2/04-wrolpi/03-run-chroot.sh @@ -36,6 +36,8 @@ deno --version # Put the latest WROLPi in /opt/wrolpi. git clone -b "${WROLPI_BRANCH:-release}" https://github.com/lrnselfreliance/wrolpi.git /opt/wrolpi +bash /opt/wrolpi-blobs/verify_wrolpi_commit.sh /opt/wrolpi HEAD /opt/wrolpi-blobs/roland@learningselfreliance.com.gpg +rm /opt/wrolpi-blobs/verify_wrolpi_commit.sh /opt/wrolpi-blobs/roland@learningselfreliance.com.gpg # `git config --global` needs HOME, which is empty when the build runs under # systemd (the release poller service has no HOME); set it to root's home. export HOME=/root diff --git a/wrolpi/scripts/verify_wrolpi_commit.sh b/wrolpi/scripts/verify_wrolpi_commit.sh new file mode 100755 index 00000000..4a2da5cc --- /dev/null +++ b/wrolpi/scripts/verify_wrolpi_commit.sh @@ -0,0 +1,30 @@ +#!/usr/bin/env bash +# Usage: verify_wrolpi_commit.sh REPO REV [KEY_FILE] +# +# Exits non-zero unless REV in the git checkout REPO is signed by the WROLPi release key. KEY_FILE defaults to the +# key committed beside this script; the image builds pass the key from the build checkout, never from the clone being +# verified. + +# The key is imported into a throwaway keyring, and the signature must come from the pinned fingerprint, so a key file +# swapped along with the code is rejected. install.sh carries an identical copy of this function because it runs +# before any verified checkout exists; a test keeps the two the same. +verify_wrolpi_commit() { + local repo=$1 rev=$2 key=$3 + local fingerprint=${WROLPI_SIGNING_FINGERPRINT:-A74A9634A86C65F3C13949AD1BA620CE6C9A4680} + local gnupghome status rc=1 + # A short path: gpg's agent socket lives in GNUPGHOME and its path is limited to ~108 characters. + gnupghome=$(mktemp -d /tmp/wgpg.XXXXXX) || return 1 + if GNUPGHOME="${gnupghome}" gpg --batch --quiet --import "${key}" 2>/dev/null; then + # VALIDSIG ... + status=$(GNUPGHOME="${gnupghome}" git -C "${repo}" verify-commit --raw "${rev}" 2>&1) && + awk -v fpr="${fingerprint}" '$2 == "VALIDSIG" && ($3 == fpr || $NF == fpr) {found = 1} END {exit !found}' \ + <<<"${status}" && rc=0 + fi + rm -rf "${gnupghome}" + [ ${rc} -eq 0 ] || echo "ERROR: ${rev} in ${repo} is not signed by the WROLPi key ${fingerprint}" >&2 + return ${rc} +} + +if [ "${BASH_SOURCE[0]}" = "$0" ]; then + verify_wrolpi_commit "$1" "$2" "${3:-$(dirname "$(realpath "$0")")/../roland@learningselfreliance.com.gpg}" +fi diff --git a/wrolpi/test/test_verify_wrolpi_commit.py b/wrolpi/test/test_verify_wrolpi_commit.py new file mode 100644 index 00000000..b9012c8d --- /dev/null +++ b/wrolpi/test/test_verify_wrolpi_commit.py @@ -0,0 +1,117 @@ +""" +Tests that every path which installs WROLPi checks the checkout is signed by the WROLPi release key. +""" +import os +import re +import subprocess + +import pytest + +from wrolpi.test.test_common import gpg_test_key # noqa: F401 (fixture) +from wrolpi.vars import PROJECT_DIR + +VERIFIER = PROJECT_DIR / 'wrolpi/scripts/verify_wrolpi_commit.sh' +WROLPI_KEY = PROJECT_DIR / 'wrolpi/roland@learningselfreliance.com.gpg' +INSTALL_SH = PROJECT_DIR / 'install.sh' +PI_GEN_CHROOT = PROJECT_DIR / 'pi-gen/stage2/04-wrolpi/03-run-chroot.sh' +ISO_HOOK = PROJECT_DIR / 'debian-live-config/config/hooks/normal/9999-wrolpi.hook.chroot' + + +def _fingerprint(key_path, env=None) -> str: + output = subprocess.run(['gpg', '--batch', '--show-keys', '--with-colons', str(key_path)], + env=env, capture_output=True, text=True, check=True).stdout + return next(line.split(':')[9] for line in output.splitlines() if line.startswith('fpr:')) + + +def _function(path) -> str: + """The text of `verify_wrolpi_commit() { ... }` in a script.""" + match = re.search(r'^verify_wrolpi_commit\(\) \{\n.*?^\}\n', path.read_text(), re.MULTILINE | re.DOTALL) + assert match, f'verify_wrolpi_commit is not defined in {path}' + return match.group(0) + + +@pytest.fixture +def signed_repo(tmp_path, gpg_test_key): + """A git repository whose `signed` commit is signed by the test key, and whose `unsigned` commit is not.""" + env, test_pubkey, _ = gpg_test_key + repo = tmp_path / 'repo' + repo.mkdir() + + def git(*args): + return subprocess.run(['git', '-C', str(repo), *args], env=env, capture_output=True, text=True, + check=True).stdout.strip() + + git('init', '-q') + git('config', 'user.email', 'test@test.com') + git('config', 'user.name', 'Test') + git('config', 'user.signingkey', 'test@test.com') + (repo / 'a.txt').write_text('a') + git('add', 'a.txt') + git('commit', '-q', '-S', '-m', 'signed') + git('tag', 'signed') + (repo / 'b.txt').write_text('b') + git('add', 'b.txt') + git('commit', '-q', '--no-gpg-sign', '-m', 'unsigned') + git('tag', 'unsigned') + yield repo, test_pubkey, _fingerprint(test_pubkey, env) + + +def _verify(repo, rev, key, fingerprint=None): + env = {k: v for k, v in os.environ.items() if k != 'GNUPGHOME'} + if fingerprint: + env['WROLPI_SIGNING_FINGERPRINT'] = fingerprint + return subprocess.run(['bash', str(VERIFIER), str(repo), rev, str(key)], env=env, capture_output=True, text=True) + + +def test_verify_signed_commit(signed_repo): + """A commit signed by the trusted key, from the pinned fingerprint, verifies.""" + repo, key, fingerprint = signed_repo + result = _verify(repo, 'signed', key, fingerprint) + assert result.returncode == 0, result.stdout + result.stderr + + +def test_verify_unsigned_commit(signed_repo): + repo, key, fingerprint = signed_repo + assert _verify(repo, 'unsigned', key, fingerprint).returncode != 0 + + +def test_verify_commit_signed_by_another_key(signed_repo, tmp_path): + """The signature must come from the key file given; the WROLPi key cannot vouch for the test signature.""" + repo, _, fingerprint = signed_repo + assert _verify(repo, 'signed', WROLPI_KEY, fingerprint).returncode != 0 + + +def test_verify_swapped_key_file(signed_repo): + """A key file swapped along with the code is rejected because its fingerprint is not the pinned one.""" + repo, key, _ = signed_repo + assert _verify(repo, 'signed', key).returncode != 0 + + +def test_pinned_fingerprint_is_the_wrolpi_key(): + """The fingerprint the verifier pins is the committed WROLPi key's.""" + fingerprint = _fingerprint(WROLPI_KEY) + assert f':-{fingerprint}}}' in _function(VERIFIER) + + +def test_install_sh_has_the_same_verifier(): + """install.sh runs before any verified checkout exists, so it carries a copy of the function; they must match.""" + assert _function(INSTALL_SH) == _function(VERIFIER) + + +def test_install_sh_verifies_before_running_the_checkout(): + text = INSTALL_SH.read_text() + verify = text.index('verify_wrolpi_commit /opt/wrolpi HEAD') + assert text.index('git reset --hard') < verify < text.index('scripts/install_debian.sh') + assert re.search(r'^apt install -y git gnupg$', text, re.MULTILINE) + + +@pytest.mark.parametrize('path', [PI_GEN_CHROOT, ISO_HOOK]) +def test_image_builds_verify_the_clone(path): + """Each image build verifies the clone with the key from the build checkout, before using it.""" + lines = path.read_text().splitlines() + clone = next(i for i, line in enumerate(lines) if 'git clone' in line and 'lrnselfreliance/wrolpi' in line) + verify = next(i for i, line in enumerate(lines) if 'verify_wrolpi_commit.sh /opt/wrolpi HEAD' in line) + assert clone < verify + # Nothing from the clone runs before it is verified. + assert not any('/opt/wrolpi/' in line and not line.lstrip().startswith('#') and 'verify' not in line + for line in lines[clone + 1:verify]), lines[clone + 1:verify]