"""Ed25519 signing for the app update feed. Each installation owns one private key, generated once into a 0600 file under ~/.config/pipelines/ (never in the repository). App builds embed the public key (`--dart-define=PIPELINES_UPDATE_PUBLIC_KEY`, comma separated) together with any other servers' keys listed one per line in ~/.config/pipelines/update-trusted-keys. Publishing writes `version.json` and a detached `version.json.sig` over its exact bytes; the app verifies that signature with an embedded key before it trusts the artifact sha256 inside. The OpenSSL 3 command line does the cryptography (the system Python has no `cryptography` package and macOS's LibreSSL has no Ed25519), so the tool is looked up explicitly: PIPELINES_OPENSSL, Homebrew's openssl@3, then PATH. """ import base64 import json import os from pathlib import Path import shutil import subprocess import tempfile KEY_NAME = "update-signing-key.pem" TRUSTED_NAME = "update-trusted-keys" SIGNATURE_SUFFIX = ".sig" DEFINE = "PIPELINES_UPDATE_PUBLIC_KEY" CANDIDATES = ("/opt/homebrew/opt/openssl@3/bin/openssl", "/usr/local/opt/openssl@3/bin/openssl") # DER SubjectPublicKeyInfo for Ed25519 is this 12-byte prefix plus the raw key. SPKI_PREFIX = bytes.fromhex("302a300506032b6570032100") def config_dir(): return Path.home() / ".config/pipelines" def key_path(environ=None): environ = os.environ if environ is None else environ explicit = environ.get("PIPELINES_UPDATE_SIGNING_KEY") return Path(explicit).expanduser() if explicit else config_dir() / KEY_NAME def _supports_ed25519(tool): try: result = subprocess.run([tool, "genpkey", "-algorithm", "ed25519"], capture_output=True, timeout=30) except (OSError, subprocess.TimeoutExpired): return False return result.returncode == 0 and b"PRIVATE KEY" in result.stdout def openssl(environ=None): """An OpenSSL executable with Ed25519 support, or a clear error.""" environ = os.environ if environ is None else environ found = [environ.get("PIPELINES_OPENSSL"), *CANDIDATES, shutil.which("openssl")] for tool in dict.fromkeys(t for t in found if t): if _supports_ed25519(tool): return tool raise ValueError("Update signing needs OpenSSL 3 with Ed25519 (LibreSSL lacks it): " "install openssl@3 (brew install openssl@3) or set PIPELINES_OPENSSL") def _check_private(path): if path.is_symlink() or not path.is_file(): raise ValueError(f"Update signing key must be a regular file: {path}") if path.stat().st_mode & 0o077: raise ValueError(f"Update signing key must be private (chmod 600): {path}") def ensure_key(environ=None): """The installation's signing key, generated once (0600) when absent.""" path = key_path(environ) if path.exists() or path.is_symlink(): _check_private(path) return path tool = openssl(environ) path.parent.mkdir(mode=0o700, parents=True, exist_ok=True) descriptor, temporary = tempfile.mkstemp(prefix=".update-key-", dir=path.parent) os.close(descriptor) try: os.chmod(temporary, 0o600) result = subprocess.run([tool, "genpkey", "-algorithm", "ed25519", "-out", temporary], capture_output=True, text=True, timeout=30) if result.returncode: raise ValueError("Could not generate the update signing key: " + result.stderr.strip()) os.chmod(temporary, 0o600) # Never replace a key another process created meanwhile. os.link(temporary, path) finally: Path(temporary).unlink(missing_ok=True) _check_private(path) return path def public_key(key, environ=None): """The raw 32-byte public key, base64 encoded.""" result = subprocess.run([openssl(environ), "pkey", "-in", str(key), "-pubout", "-outform", "DER"], capture_output=True, timeout=30) der = result.stdout if result.returncode or len(der) != 44 or not der.startswith(SPKI_PREFIX): raise ValueError(f"Could not read the Ed25519 public key from {key}") return base64.b64encode(der[len(SPKI_PREFIX):]).decode() def valid_public_key(text): try: return len(base64.b64decode(text, validate=True)) == 32 except ValueError: return False def trusted_keys(environ=None): """This installation's key first, then other servers' keys it trusts.""" keys = [public_key(ensure_key(environ), environ)] listed = config_dir() / TRUSTED_NAME if listed.is_file(): for number, line in enumerate(listed.read_text().splitlines(), 1): line = line.split("#", 1)[0].strip() if not line: continue if not valid_public_key(line): raise ValueError(f"{listed}:{number} is not a base64 Ed25519 public key") keys.append(line) return list(dict.fromkeys(keys)) def dart_defines(environ=None): """The build argument embedding the trusted update keys.""" return (f"--dart-define={DEFINE}={','.join(trusted_keys(environ))}",) def sign(data, key, environ=None): """A raw 64-byte Ed25519 signature over [data].""" with tempfile.NamedTemporaryFile(prefix="pipelines-feed-") as message: message.write(data) message.flush() result = subprocess.run([openssl(environ), "pkeyutl", "-sign", "-rawin", "-inkey", str(key), "-in", message.name], capture_output=True, timeout=30) if result.returncode or len(result.stdout) != 64: raise ValueError("Could not sign the update feed: " + result.stderr.decode(errors="replace").strip()) return result.stdout def signature_document(data, key, environ=None): """The detached `version.json.sig` content for feed bytes [data].""" return (json.dumps({"algorithm": "ed25519", "publicKey": public_key(key, environ), "signature": base64.b64encode(sign(data, key, environ)).decode()}) + "\n").encode() class Signer: """Signs feeds with one key file; the installer's key unless given.""" def __init__(self, key=None, environ=None): self.environ = environ self.key = Path(key) if key else ensure_key(environ) _check_private(self.key) def __call__(self, data): return signature_document(data, self.key, self.environ) def write_atomic(path, content, mode=0o644): descriptor, temporary = tempfile.mkstemp(prefix=path.name + ".", dir=path.parent) try: with os.fdopen(descriptor, "wb") as output: output.write(content) output.flush() os.fsync(output.fileno()) os.chmod(temporary, mode) os.replace(temporary, path) finally: Path(temporary).unlink(missing_ok=True) def publish_feed(directory, metadata, signer): """Writes the signature, then the feed it covers, both atomically. A reader racing a publish may see a new signature with the old feed for a moment; that verification fails and the next check succeeds.""" data = (json.dumps(metadata) + "\n").encode() signature = signer(data) write_atomic(directory / ("version.json" + SIGNATURE_SUFFIX), signature) write_atomic(directory / "version.json", data) return data if __name__ == "__main__": # Prints this installation's public key, for another server's # update-trusted-keys file (generating the key on first use). print(public_key(ensure_key()))