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