9f38e38f6a
Each installation generates a private Ed25519 key once (0600, under ~/.config/pipelines), signs version.json with a detached version.json.sig when publishing APK and desktop builds, and embeds its own and listed trusted public keys in app builds. The app verifies the feed signature before trusting the artifact sha256, refuses unsigned or foreign feeds when it has keys, and requires the sha256 and Android signer in signed feeds.
118 lines
5.4 KiB
Python
118 lines
5.4 KiB
Python
import base64
|
|
import importlib.util
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
|
|
def load(name):
|
|
spec = importlib.util.spec_from_file_location(name, Path(__file__).with_name(name + ".py"))
|
|
result = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(result)
|
|
return result
|
|
|
|
|
|
signing = load("update_signing")
|
|
FIXTURE = Path(__file__).resolve().parents[1] / "app/test/features/updates/fixtures/signed_feed"
|
|
|
|
|
|
def verify(tool, public, data, signature):
|
|
"""Independent check with `openssl pkeyutl -verify` against the raw key."""
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = Path(directory)
|
|
(root / "pub.der").write_bytes(signing.SPKI_PREFIX + base64.b64decode(public))
|
|
(root / "data").write_bytes(data)
|
|
(root / "sig").write_bytes(signature)
|
|
result = subprocess.run([tool, "pkeyutl", "-verify", "-pubin", "-keyform", "DER", "-inkey",
|
|
str(root / "pub.der"), "-rawin", "-in", str(root / "data"),
|
|
"-sigfile", str(root / "sig")], capture_output=True)
|
|
return result.returncode == 0
|
|
|
|
|
|
class UpdateSigningTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.home = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.home.cleanup)
|
|
patcher = patch.object(signing.Path, "home", return_value=Path(self.home.name))
|
|
patcher.start()
|
|
self.addCleanup(patcher.stop)
|
|
self.environ = {}
|
|
self.tool = signing.openssl(self.environ)
|
|
|
|
def test_key_is_generated_once_private_under_the_config_directory(self):
|
|
key = signing.ensure_key(self.environ)
|
|
self.assertEqual(key, Path(self.home.name) / ".config/pipelines/update-signing-key.pem")
|
|
self.assertEqual(key.stat().st_mode & 0o777, 0o600)
|
|
self.assertEqual(key.parent.stat().st_mode & 0o777, 0o700)
|
|
before = key.read_bytes()
|
|
self.assertEqual(signing.ensure_key(self.environ), key)
|
|
self.assertEqual(key.read_bytes(), before)
|
|
self.assertEqual([p.name for p in key.parent.iterdir()], [key.name])
|
|
|
|
def test_readable_or_symlinked_key_is_refused(self):
|
|
key = signing.ensure_key(self.environ)
|
|
os.chmod(key, 0o644)
|
|
with self.assertRaisesRegex(ValueError, "chmod 600"):
|
|
signing.ensure_key(self.environ)
|
|
os.chmod(key, 0o600)
|
|
link = key.with_name("link.pem")
|
|
link.symlink_to(key)
|
|
with self.assertRaisesRegex(ValueError, "regular file"):
|
|
signing.ensure_key({"PIPELINES_UPDATE_SIGNING_KEY": str(link)})
|
|
|
|
def test_openssl_without_ed25519_is_skipped_or_reported(self):
|
|
missing = {"PIPELINES_OPENSSL": "/nonexistent/openssl"}
|
|
self.assertEqual(signing.openssl(missing), self.tool)
|
|
with patch.object(signing, "CANDIDATES", ()), \
|
|
patch.object(signing.shutil, "which", return_value="/usr/bin/false"):
|
|
with self.assertRaisesRegex(ValueError, "OpenSSL 3"):
|
|
signing.openssl({})
|
|
|
|
def test_signature_verifies_and_tampering_does_not(self):
|
|
key = signing.ensure_key(self.environ)
|
|
data = b'{"versionCode": 7}\n'
|
|
document = json.loads(signing.signature_document(data, key, self.environ))
|
|
self.assertEqual(document["algorithm"], "ed25519")
|
|
public = document["publicKey"]
|
|
signature = base64.b64decode(document["signature"])
|
|
self.assertEqual((len(base64.b64decode(public)), len(signature)), (32, 64))
|
|
self.assertTrue(verify(self.tool, public, data, signature))
|
|
self.assertFalse(verify(self.tool, public, b'{"versionCode": 8}\n', signature))
|
|
|
|
def test_publish_writes_feed_and_detached_signature(self):
|
|
target = Path(self.home.name) / "updates"
|
|
target.mkdir()
|
|
data = signing.publish_feed(target, {"versionCode": 3}, signing.Signer(environ=self.environ))
|
|
self.assertEqual((target / "version.json").read_bytes(), data)
|
|
document = json.loads((target / "version.json.sig").read_text())
|
|
self.assertTrue(verify(self.tool, document["publicKey"], data, base64.b64decode(document["signature"])))
|
|
self.assertEqual((target / "version.json").stat().st_mode & 0o777, 0o644)
|
|
|
|
def test_build_embeds_own_key_first_then_listed_trusted_keys(self):
|
|
own = signing.public_key(signing.ensure_key(self.environ))
|
|
other = base64.b64encode(bytes(range(32))).decode()
|
|
listed = Path(self.home.name) / ".config/pipelines/update-trusted-keys"
|
|
listed.write_text(f"# tank\n{other}\n\n{own}\n")
|
|
self.assertEqual(signing.dart_defines(self.environ),
|
|
(f"--dart-define=PIPELINES_UPDATE_PUBLIC_KEY={own},{other}",))
|
|
listed.write_text("not-a-key\n")
|
|
with self.assertRaisesRegex(ValueError, "update-trusted-keys:1"):
|
|
signing.trusted_keys(self.environ)
|
|
|
|
def test_committed_dart_fixture_is_a_valid_python_signature(self):
|
|
# The Dart verifier test reads this fixture; publish_feed produced it
|
|
# with a throwaway key that was never kept.
|
|
public = (FIXTURE / "public_key.txt").read_text().strip()
|
|
document = json.loads((FIXTURE / "version.json.sig").read_text())
|
|
self.assertEqual(document["publicKey"], public)
|
|
self.assertTrue(verify(self.tool, public, (FIXTURE / "version.json").read_bytes(),
|
|
base64.b64decode(document["signature"])))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|