Files
mesh/scripts/test_deployment_inputs.py
waozi 39a79ae85d Build the native server from its generated C without Ziran
native-release collects the native server's generated C and the SQLite
amalgamation from the locked source. build-native compiles them with cc,
links SQLite and liboqs statically and the origin's runtime libraries by
soname, and records a manifest with the C compiler and a digest of the
compiled sources. The binary built this way passes the native server
suite.
2026-11-22 18:13:56 -03:00

348 lines
16 KiB
Python

import importlib.util
import json
import re
from hashlib import sha256
from pathlib import Path
import subprocess
import tempfile
import unittest
from unittest import mock
import yaml
script_path = Path(__file__).with_name("verify_deployment_inputs.py")
spec = importlib.util.spec_from_file_location("deployment_inputs", script_path)
deployment_inputs = importlib.util.module_from_spec(spec)
spec.loader.exec_module(deployment_inputs)
class DeploymentInputTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
Path("build").mkdir(exist_ok=True)
def run_git(self, repository, *arguments):
subprocess.run(
["git", "-C", str(repository), *arguments],
check=True,
stdout=subprocess.DEVNULL,
)
def write_host_key(self, directory, name):
key_path = directory / name
subprocess.run(
[
"ssh-keygen",
"-q",
"-t",
"ed25519",
"-N",
"",
"-C",
name,
"-f",
str(key_path),
],
check=True,
)
return f"deployment.test {key_path.with_suffix('.pub').read_text().strip()}"
def test_pinned_source_rejects_a_wrong_revision(self):
with tempfile.TemporaryDirectory() as temporary:
repository = Path(temporary) / "repository"
source = repository / "vendor" / "liboqs"
source.mkdir(parents=True)
(source / "CMakeLists.txt").write_text("first\n")
self.run_git(source, "init")
self.run_git(source, "config", "user.name", "Fixture")
self.run_git(source, "config", "user.email", "[email protected]")
self.run_git(source, "add", ".")
self.run_git(source, "commit", "-m", "first")
self.run_git(repository, "init")
self.run_git(repository, "config", "user.name", "Fixture")
self.run_git(repository, "config", "user.email", "[email protected]")
self.run_git(
repository,
"update-index",
"--add",
"--cacheinfo",
"160000,d95fc734f5de9bdfc80c8c65d8166b30e9cff5cd,vendor/liboqs",
)
self.run_git(repository, "commit", "--allow-empty", "-m", "fixture")
with self.assertRaisesRegex(
deployment_inputs.VerificationError,
"gitlink is d95fc73.* but checkout is",
):
deployment_inputs.pinned_source(repository, "vendor/liboqs")
def test_source_verification_rejects_a_one_byte_difference(self):
with tempfile.TemporaryDirectory() as temporary:
source = Path(temporary)
(source / "input.txt").write_bytes(b"expected")
identity = deployment_inputs.source_identity(source)
deployment_inputs.verify_source(
source, "0" * 40, identity["digest"], identity["entries"]
)
(source / "input.txt").write_bytes(b"rejected")
with self.assertRaisesRegex(
deployment_inputs.VerificationError,
"liboqs source identity mismatch",
):
deployment_inputs.verify_source(
source, "0" * 40, identity["digest"], identity["entries"]
)
def test_stale_native_cache_is_rejected(self):
source = Path("vendor/liboqs")
with tempfile.TemporaryDirectory(
prefix="deployment-inputs-", dir="build"
) as temporary:
build = Path(temporary)
artifact = build / "install" / "lib" / "liboqs.a"
artifact.parent.mkdir(parents=True)
artifact.write_bytes(b"native artifact")
options = "-DOQS_MINIMAL_BUILD=SIG_ml_dsa_44"
deployment_inputs.validate_native_paths(source, build)
deployment_inputs.record_native_build(source, build, artifact, "cmake", options)
self.assertTrue(
deployment_inputs.check_native_build(source, build, artifact, "cmake", options)
)
self.assertFalse(
deployment_inputs.check_native_build(
source, build, artifact, "cmake", "-DOQS_MINIMAL_BUILD=wrong"
)
)
self.assertFalse(
deployment_inputs.check_native_build(
source, build, Path("/missing"), "cmake", options
)
)
artifact.write_bytes(b"changed native artifact")
self.assertFalse(
deployment_inputs.check_native_build(source, build, artifact, "cmake", options)
)
artifact.write_bytes(b"native artifact")
metadata_path = deployment_inputs.native_metadata_path(build)
recorded = json.loads(metadata_path.read_text())
recorded["identity"]["source"]["digest"] = "0" * 64
metadata_path.write_text(json.dumps(recorded))
self.assertFalse(
deployment_inputs.check_native_build(source, build, artifact, "cmake", options)
)
def test_artifact_manifest_binds_the_output_digest(self):
source = Path("vendor/liboqs")
with tempfile.TemporaryDirectory(
prefix="deployment-manifest-", dir="build"
) as temporary:
build = Path(temporary)
native_artifact = build / "liboqs.a"
native_artifact.write_bytes(b"native artifact")
native_metadata = build / "native.json"
output = build / "mesh"
output.write_bytes(b"deployment artifact")
manifest = build / "manifest.json"
native_identity = deployment_inputs.native_build_identity(
source, "cmake", "-DOQS_MINIMAL_BUILD=SIG_ml_dsa_44"
)
native_metadata.write_text(json.dumps(native_identity))
def fixture_command(arguments, error):
if len(arguments) == 2:
return "go1.26.10 fixture"
return "main BuildVersion=fixture"
with mock.patch.object(
deployment_inputs, "run_command", side_effect=fixture_command
):
provenance = deployment_inputs.record_artifact_manifest(
output,
manifest,
"a" * 40,
"b" * 40,
native_metadata,
)
self.assertEqual(
provenance["artifact"]["sha256"],
sha256(b"deployment artifact").hexdigest(),
)
deployment_inputs.verify_artifact_manifest(
output, manifest, "a" * 40, "b" * 40
)
recorded = json.loads(manifest.read_text())
self.assertIn("go.sum", recorded["source_inputs"])
self.assertIn("main BuildVersion=fixture", recorded["go"]["version_m"])
output.write_bytes(b"replaced artifact")
with self.assertRaisesRegex(
deployment_inputs.VerificationError,
"artifact digest mismatch",
):
deployment_inputs.verify_artifact_manifest(
output, manifest, "a" * 40, "b" * 40
)
def test_native_server_manifest_records_the_compiled_sources(self):
with tempfile.TemporaryDirectory(prefix="native-manifest-", dir="build") as temporary:
build = Path(temporary)
sources = build / "native-release"
(sources / "server").mkdir(parents=True)
(sources / "server" / "entry.c").write_bytes(b"int main(void) { return 0; }\n")
native_metadata = build / "native.json"
native_metadata.write_text(json.dumps(deployment_inputs.native_build_identity(
Path("vendor/liboqs"), "cmake", "-DOQS_MINIMAL_BUILD=SIG_ml_dsa_44")))
output = build / "mesh-native"
output.write_bytes(b"native server")
manifest = build / "manifest.json"
with mock.patch.object(deployment_inputs, "run_command", return_value="cc (Debian 14.2.0-19) 14.2.0\nCopyright"):
provenance = deployment_inputs.record_artifact_manifest(
output, manifest, "a" * 40, "b" * 40, native_metadata, "c", sources)
self.assertNotIn("go", provenance)
self.assertEqual(provenance["c"]["compiler"], "cc (Debian 14.2.0-19) 14.2.0")
self.assertEqual(provenance["c"]["sources"], 1)
first = provenance["c"]["sources_sha256"]
(sources / "server" / "entry.c").write_bytes(b"int main(void) { return 1; }\n")
self.assertNotEqual(deployment_inputs.source_tree_digest(sources)[0], first)
deployment_inputs.verify_artifact_manifest(output, manifest, "a" * 40, "b" * 40)
with self.assertRaisesRegex(deployment_inputs.VerificationError, "release sources are required"):
deployment_inputs.record_artifact_manifest(output, manifest, "a" * 40, "b" * 40, native_metadata, "c")
def test_native_cleanup_rejects_unsafe_paths(self):
with self.assertRaisesRegex(
deployment_inputs.VerificationError,
"native build directory must be inside build/",
):
deployment_inputs.validate_native_paths(
Path("vendor/liboqs"), Path("/temporary-mesh-build")
)
with self.assertRaisesRegex(
deployment_inputs.VerificationError,
"native source must be vendor/liboqs",
):
deployment_inputs.validate_native_paths(Path("vendor"), Path("build/liboqs"))
def test_missing_trusted_host_key_fails_closed(self):
with tempfile.TemporaryDirectory() as temporary:
ssh_directory = Path(temporary) / ".ssh"
with self.assertRaisesRegex(
deployment_inputs.VerificationError,
"trusted SSH host key is empty",
):
deployment_inputs.configure_ssh(
"deployment.test", "deploy", [], ssh_directory
)
self.assertFalse((ssh_directory / "known_hosts").exists())
def test_ssh_configuration_reuses_existing_key_directory(self):
with tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
trusted = self.write_host_key(root, "host")
ssh_directory = root / ".ssh"
ssh_directory.mkdir(mode=0o755)
identity = ssh_directory / "id_ed25519"
identity.write_text("existing deployment identity fixture")
identity.chmod(0o600)
for _ in range(2):
deployment_inputs.configure_ssh("deployment.test", "deploy", [trusted], ssh_directory)
self.assertEqual(identity.read_text(), "existing deployment identity fixture")
self.assertEqual(ssh_directory.stat().st_mode & 0o777, 0o700)
self.assertEqual((ssh_directory / "known_hosts").stat().st_mode & 0o777, 0o600)
self.assertIn("StrictHostKeyChecking yes", (ssh_directory / "config").read_text())
def test_custom_ssh_directory_keeps_identity_and_host_keys_local(self):
with tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
trusted = self.write_host_key(root, "host")
ssh_directory = root / "job ssh"
deployment_inputs.configure_ssh(
"deployment.test", "deploy", [trusted], ssh_directory
)
configuration = subprocess.check_output(
["ssh", "-G", "-F", str(ssh_directory / "config"), "mesh-origin"],
stderr=subprocess.DEVNULL,
text=True,
)
options = dict(row.split(" ", 1) for row in configuration.splitlines())
self.assertEqual(options["identityfile"], str(ssh_directory / "id_ed25519"))
self.assertEqual(options["userknownhostsfile"], str(ssh_directory / "known_hosts"))
self.assertEqual(options["stricthostkeychecking"], "true")
def test_presented_host_key_mismatch_is_rejected(self):
with tempfile.TemporaryDirectory() as temporary:
trusted = self.write_host_key(Path(temporary), "trusted")
presented = self.write_host_key(Path(temporary), "presented")
deployment_inputs.verify_presented_key(
"deployment.test", [trusted], [trusted]
)
with self.assertRaisesRegex(
deployment_inputs.VerificationError,
"presented SSH host key does not match",
):
deployment_inputs.verify_presented_key(
"deployment.test", [trusted], [presented]
)
def test_certificate_authority_host_entries_are_rejected(self):
with tempfile.TemporaryDirectory() as temporary:
trusted = self.write_host_key(Path(temporary), "trusted")
authority = f"@cert-authority {trusted}"
ssh_directory = Path(temporary) / ".ssh"
with self.assertRaisesRegex(
deployment_inputs.VerificationError,
"trusted SSH host key entries must be literal host keys",
):
deployment_inputs.configure_ssh(
"deployment.test", "deploy", [authority], ssh_directory
)
self.assertFalse((ssh_directory / "known_hosts").exists())
def test_workflow_uses_exact_native_source_and_strict_ssh(self):
workflow_path = Path(".github/workflows/deploy.yml")
workflow = yaml.safe_load(workflow_path.read_text())
workflow_text = workflow_path.read_text()
for job in workflow["jobs"].values():
for step in job.get("steps", []):
if "run" not in step:
continue
script = re.sub(r"\$\{\{.*?\}\}", "0" * 40, step["run"])
subprocess.run(
["bash", "-n"],
input=script,
text=True,
check=True,
)
deploy = workflow["jobs"]["deploy"]
checkouts = deploy["steps"]
deploy_checkout = next(
step for step in checkouts if "actions/checkout" in str(step.get("uses"))
)
self.assertEqual(deploy_checkout.get("with"), {"submodules": "recursive"})
self.assertNotIn("ssh-keyscan", workflow_text)
self.assertNotIn("--exclude='vendor/liboqs'", workflow_text)
for path in (workflow_path, Path(".gitea/workflows/ci.yml")):
package = path.read_text()
self.assertIn("git ls-files -z --recurse-submodules", package)
self.assertIn("tar --null --no-recursion --files-from=", package)
self.assertIn("*.node-key", Path(".dockerignore").read_text().splitlines())
self.assertNotIn('cp -a "/opt/mesh-src/$keep"', workflow_text)
step_names = [step.get("name") for step in checkouts]
self.assertLess(
step_names.index("Verify the pinned native source"),
step_names.index("Configure SSH"),
)
ssh_commands = [
line.strip()
for line in workflow_text.splitlines()
if line.strip().startswith("ssh ")
]
self.assertTrue(ssh_commands)
self.assertTrue(all("mesh-origin" in line for line in ssh_commands))
deployment = Path(__file__).resolve().parents[1] / "deploy"
self.assertEqual(workflow_text.count("sh /opt/mesh-src/deploy/rollback.sh"), 2)
self.assertIn("trap finish 0", (deployment / "install.sh").read_text())
self.assertIn("rm -f /opt/mesh/mesh.manifest.json", (deployment / "rollback.sh").read_text())
if __name__ == "__main__":
unittest.main()