services_hardening_native_release.rs (17471B)
1 #![forbid(unsafe_code)] 2 3 use std::collections::BTreeSet; 4 5 use serde_json::json; 6 7 #[path = "support/canonical_source.rs"] 8 mod canonical_source; 9 10 const CONTRACT: &str = include_str!("../contracts/services_hardening/native_release.v1.json"); 11 const ACTIVE_CONTRACT: &str = 12 include_str!("../contracts/services_hardening/native_release.v3.json"); 13 const MANIFEST: &str = include_str!("../Cargo.toml"); 14 const LOCK: &str = include_str!("../Cargo.lock"); 15 const FLAKE: &str = include_str!("../flake.nix"); 16 const FLAKE_LOCK: &str = include_str!("../flake.lock"); 17 const SOURCE_LOCK: &str = include_str!("../radroots.service.source_lock.v4.toml"); 18 const CARGO_CONFIG: &str = include_str!("../.cargo/config.toml"); 19 const SYSTEMD_UNIT: &str = include_str!("../packaging/systemd/rhi@.service"); 20 const RELEASE_ACCEPTANCE: &str = include_str!("../scripts/release-acceptance.sh"); 21 const XTASK_MANIFEST: &str = include_str!("../tools/xtask/Cargo.toml"); 22 23 const LIB_REVISION: &str = "e55c1749902811732167a2ce5c099e22e964624f"; 24 const LIB_REPOSITORY: &str = "https://github.com/radrootslabs/lib"; 25 26 #[test] 27 fn native_release_contract_and_manifest_metadata_are_exact() { 28 let contract: serde_json::Value = serde_json::from_str(CONTRACT).expect("release contract"); 29 assert_eq!( 30 contract, 31 json!({ 32 "schema": "radroots.rhi.native-release", 33 "schema_version": 1, 34 "contract_version": 1, 35 "service": "rhi", 36 "package": { 37 "name": "rhi", 38 "binary": "rhi", 39 "version": "0.1.0", 40 "repository": "https://github.com/radrootslabs/rhi", 41 "publish_to_crates_io": false 42 }, 43 "generator": { 44 "command": "cargo xtask native-release", 45 "modes": ["check", "write"], 46 "required_arguments": [ 47 "mode", "target", "binary", "output", "source_date_epoch" 48 ], 49 "source_date_epoch_range": "1..=4294967295", 50 "clean_exact_head": true, 51 "target_binary_validation": "executable_elf64_little_endian_exact_machine", 52 "canonical_json": "compact_utf8_json_with_one_final_lf", 53 "deterministic_archives": true, 54 "output_directory_mode": "0755", 55 "output_file_mode": "0644", 56 "durability": "sync_files_then_output_directory_then_parent" 57 }, 58 "toolchain": { 59 "rust_version": "1.97.1", 60 "edition": "2024", 61 "resolver": "3", 62 "host_feature_profile": "service-host" 63 }, 64 "release_profile": { 65 "lto": "thin", 66 "codegen_units": 1, 67 "overflow_checks": true, 68 "strip": "symbols", 69 "panic": "unwind" 70 }, 71 "source_lock": { 72 "filename": "radroots.service.source-lock.v2.toml", 73 "schema": "radroots.service.source-lock.v2", 74 "lib_repository": LIB_REPOSITORY, 75 "architecture": "radroots.crates.release.v2", 76 "nix_material": "absent" 77 }, 78 "contract_versions": { 79 "config": 1, 80 "state": 11, 81 "admin": 1, 82 "status": 1, 83 "provider": 1 84 }, 85 "native_targets": [ 86 { "target": "aarch64-unknown-linux-gnu", "posture": "target" }, 87 { "target": "x86_64-unknown-linux-gnu", "posture": "target" } 88 ], 89 "output_inventory": [ 90 "LICENSE", 91 "SHA256SUMS", 92 "THIRD-PARTY-NOTICES.txt", 93 "artifact-manifest.v1.json", 94 "binary.tar.gz", 95 "config.example.toml", 96 "config.schema.json", 97 "provenance-input.v1.json", 98 "radroots.service.source-lock.v2.toml", 99 "sbom.cdx.json", 100 "service-source.tar.gz", 101 "systemd.service" 102 ], 103 "signing_inputs": [ 104 "SHA256SUMS", 105 "artifact-manifest.v1.json", 106 "provenance-input.v1.json" 107 ], 108 "provenance_posture": "deterministic_unsigned_slsa_v1_input_external_keys_only", 109 "sbom_format": "cyclonedx_json_1_5_locked_cargo_graph", 110 "sbom_component_identity": "domain_separated_sha256_of_framed_name_version_source_checksum", 111 "protected_material_scan": "tracked_source_binary_copied_and_generated_material_fixed_patterns", 112 "source_archive": "locked_offline_cargo_build_with_vendored_dependencies", 113 "checksum_format": "sha256_lower_hex_two_spaces_path_lf_sorted_by_path", 114 "protected_material_included": false, 115 "maximums": { 116 "text_input_bytes": 1048576, 117 "generated_document_bytes": 16777216, 118 "cargo_metadata_bytes": 33554432, 119 "binary_bytes": 536870912, 120 "source_archive_bytes": 1073741824, 121 "packages": 8192, 122 "tracked_files": 4096 123 }, 124 "deferred_through_rcld_rshr_170": [ 125 "nix_evaluation", 126 "nix_build", 127 "nixos_module_qualification", 128 "oci_artifact" 129 ], 130 "forbidden": [ 131 "nix_input", 132 "nixos_module_output", 133 "oci_input", 134 "oci_output", 135 "protected_material", 136 "parent_owned_human_docs", 137 "private_harness", 138 "local_or_path_lib_dependency", 139 "floating_or_branch_lib_dependency", 140 "mixed_lib_revision", 141 "crates_io_publication", 142 "signing", 143 "tagging", 144 "release_publication", 145 "deployment" 146 ] 147 }) 148 ); 149 150 let manifest: toml::Value = toml::from_str(MANIFEST).expect("Cargo manifest"); 151 let package = manifest["package"].as_table().expect("package"); 152 assert_eq!( 153 package["repository"].as_str(), 154 Some("https://github.com/radrootslabs/rhi") 155 ); 156 assert_eq!(package["readme"].as_str(), Some("README")); 157 assert_eq!(package["publish"].as_bool(), Some(false)); 158 assert_eq!( 159 manifest["workspace"]["members"], 160 toml::Value::Array(vec![ 161 toml::Value::String(".".to_owned()), 162 toml::Value::String("tools/xtask".to_owned()) 163 ]) 164 ); 165 assert_eq!( 166 manifest["workspace"]["metadata"]["radroots"]["service_release"], 167 toml::Value::Table(toml::toml! { 168 service = "rhi" 169 service_package = "rhi" 170 binary_name = "rhi" 171 version = "0.1.0" 172 }) 173 ); 174 assert_eq!( 175 manifest["workspace"]["metadata"]["radroots"]["service_source_lock"]["nix_material"] 176 .as_str(), 177 Some("bound") 178 ); 179 let source_lock: toml::Value = toml::from_str(SOURCE_LOCK).expect("source lock"); 180 assert_eq!( 181 contract["contract_versions"]["state"].as_u64(), 182 source_lock["contract_versions"]["state"] 183 .as_integer() 184 .and_then(|value| u64::try_from(value).ok()) 185 ); 186 assert_eq!( 187 contract["contract_versions"]["state"].as_u64(), 188 manifest["workspace"]["metadata"]["radroots"]["service_source_lock"] 189 ["state_contract_version"] 190 .as_integer() 191 .and_then(|value| u64::try_from(value).ok()) 192 ); 193 assert_eq!( 194 manifest["profile"]["release"], 195 toml::Value::Table(toml::toml! { 196 lto = "thin" 197 codegen-units = 1 198 overflow-checks = true 199 strip = "symbols" 200 panic = "unwind" 201 }) 202 ); 203 assert_eq!( 204 CARGO_CONFIG, 205 "[alias]\nxtask = \"run --locked -p rhi_xtask --\"\n" 206 ); 207 for required in [ 208 "ExecStart=/usr/bin/rhi --profile service-host --instance %i run", 209 "ConfigurationDirectory=radroots/services/rhi/%i", 210 "StateDirectory=radroots/services/rhi/%i", 211 "CacheDirectory=radroots/services/rhi/%i", 212 "LogsDirectory=radroots/services/rhi/%i", 213 "RuntimeDirectory=radroots/services/rhi/%i", 214 "UMask=0077", 215 "NoNewPrivileges=yes", 216 "ProtectSystem=strict", 217 "CapabilityBoundingSet=", 218 ] { 219 assert!(SYSTEMD_UNIT.contains(required), "missing `{required}`"); 220 } 221 } 222 223 #[test] 224 fn every_radroots_dependency_is_exactly_source_locked() { 225 let manifest: toml::Value = toml::from_str(MANIFEST).expect("Cargo manifest"); 226 let dependencies = manifest["dependencies"].as_table().expect("dependencies"); 227 let radroots = dependencies 228 .iter() 229 .filter(|(name, _)| name.starts_with("radroots_")) 230 .collect::<Vec<_>>(); 231 assert_eq!( 232 radroots 233 .iter() 234 .map(|(name, _)| name.as_str()) 235 .collect::<BTreeSet<_>>(), 236 [ 237 "radroots_event", 238 "radroots_event_codec", 239 "radroots_nostr", 240 "radroots_protocol", 241 "radroots_runtime_paths", 242 "radroots_secrets", 243 "radroots_service_host", 244 "radroots_service_sqlite", 245 "radroots_storage", 246 "radroots_trade", 247 "radroots_transport", 248 "radroots_transport_nostr", 249 "radroots_transport_nostr_native", 250 ] 251 .into_iter() 252 .collect() 253 ); 254 for (name, dependency) in radroots { 255 let dependency = dependency.as_table().expect("detailed dependency"); 256 assert_eq!( 257 dependency.get("git").and_then(toml::Value::as_str), 258 Some(LIB_REPOSITORY), 259 "{name}" 260 ); 261 assert_eq!( 262 dependency.get("rev").and_then(toml::Value::as_str), 263 Some(LIB_REVISION), 264 "{name}" 265 ); 266 assert_eq!( 267 dependency.get("version").and_then(toml::Value::as_str), 268 Some("=0.1.0-alpha"), 269 "{name}" 270 ); 271 for forbidden in ["path", "branch", "tag"] { 272 assert!( 273 !dependency.contains_key(forbidden), 274 "{name} contains `{forbidden}`" 275 ); 276 } 277 } 278 assert!(!MANIFEST.contains("[patch.")); 279 280 let sources = LOCK 281 .lines() 282 .filter_map(|line| line.strip_prefix("source = \"git+")) 283 .filter_map(|line| line.strip_suffix('"')) 284 .filter(|source| source.contains("radrootslabs/lib")) 285 .collect::<BTreeSet<_>>(); 286 assert_eq!(sources.len(), 1); 287 let source = sources.into_iter().next().expect("Lib source"); 288 assert!(source.contains(&format!("?rev={LIB_REVISION}#{LIB_REVISION}"))); 289 290 for required in [ 291 "url = \"github:radrootslabs/lib/e55c1749902811732167a2ce5c099e22e964624f\";", 292 "systems = lib.lib.supportedSystems;", 293 "nixosModules.default", 294 ] { 295 assert!( 296 FLAKE.contains(required), 297 "flake source is missing `{required}`" 298 ); 299 } 300 let flake_lock: serde_json::Value = 301 serde_json::from_str(FLAKE_LOCK).expect("flake source lock"); 302 assert_eq!(flake_lock["version"], 7); 303 assert_eq!(flake_lock["root"], "root"); 304 assert_eq!(flake_lock["nodes"]["root"]["inputs"]["lib"], "lib"); 305 assert_eq!(flake_lock["nodes"]["lib"]["locked"]["rev"], LIB_REVISION); 306 assert_eq!(flake_lock["nodes"]["lib"]["original"]["rev"], LIB_REVISION); 307 } 308 309 #[test] 310 fn native_release_surfaces_remain_external_and_nix_bound() { 311 let root = canonical_source::source_root( 312 std::path::Path::new(env!("CARGO_MANIFEST_DIR")), 313 option_env!("NIX_BUILD_TOP").map(std::path::Path::new), 314 option_env!("src").map(std::path::Path::new), 315 std::path::Path::new("/nix/store"), 316 "rhi", 317 &[ 318 ("Cargo.toml", MANIFEST.as_bytes()), 319 ("flake.lock", FLAKE_LOCK.as_bytes()), 320 ( 321 "tests/services_hardening_native_release.rs", 322 include_bytes!("services_hardening_native_release.rs"), 323 ), 324 ( 325 "tests/support/canonical_source.rs", 326 include_bytes!("support/canonical_source.rs"), 327 ), 328 ], 329 ) 330 .expect("native working tree or exact isolated Nix input"); 331 for required in [ 332 ".cargo/config.toml", 333 "packaging/systemd/rhi@.service", 334 "radroots.service.source_lock.v4.toml", 335 "scripts/release-acceptance.sh", 336 "tools/xtask/Cargo.toml", 337 "tools/xtask/src/main.rs", 338 "contracts/services_hardening/native_release.v1.json", 339 "contracts/services_hardening/native_release.v2.json", 340 "contracts/release/rhi-artifact-contract.v3.json", 341 "flake.nix", 342 "flake.lock", 343 ] { 344 assert!(root.join(required).is_file(), "missing `{required}`"); 345 } 346 assert!(!root.join("radroots.service.source-lock.v2.toml").exists()); 347 for forbidden in [ 348 ".github", 349 ".act", 350 "target", 351 "result", 352 "artifacts", 353 "dist", 354 "sbom.cdx.json", 355 "provenance-input.v1.json", 356 "oci-image.tar.gz", 357 ] { 358 assert!( 359 !root.join(forbidden).exists(), 360 "forbidden generated or deferred surface `{forbidden}` exists" 361 ); 362 } 363 assert!(!CONTRACT.contains("qualified")); 364 assert!(!CONTRACT.contains("production_ready")); 365 assert!(!CONTRACT.contains("oci-image")); 366 assert!(!CONTRACT.contains("nixos-module")); 367 let active: serde_json::Value = 368 serde_json::from_str(ACTIVE_CONTRACT).expect("active release contract"); 369 assert_eq!(active["schema_version"], 3); 370 assert_eq!(active["contract_version"], 3); 371 assert_eq!(active["predecessor"]["filename"], "native_release.v2.json"); 372 assert_eq!( 373 active["source_lock"]["filename"], 374 "radroots.service.source_lock.v4.toml" 375 ); 376 assert_eq!(active["source_lock"]["nix_material"], "bound"); 377 assert_eq!(active["toolchain"]["rust_version"], "1.99.0"); 378 assert_eq!(active["nix_qualified"], false); 379 assert_eq!(active["maximums"]["source_lock_bytes"], 16_384); 380 assert_eq!(active["nix_outputs"]["bundled_sqlite"], true); 381 assert_eq!(active["nix_outputs"]["native_linkage_count"], 1); 382 } 383 384 #[test] 385 fn release_acceptance_is_standalone_and_has_no_deferred_toolchain() { 386 for required in [ 387 "cargo fmt --all --check", 388 "cargo metadata --locked --format-version 1 --no-deps", 389 "cargo check --locked --all-targets --no-default-features", 390 "cargo check --locked --all-targets --no-default-features --features service-host", 391 "cargo clippy --locked --all-targets -- -D warnings", 392 "cargo test --locked", 393 "cargo test --locked -p rhi_xtask", 394 "git diff --check", 395 ] { 396 assert!( 397 RELEASE_ACCEPTANCE.contains(required), 398 "release acceptance is missing `{required}`" 399 ); 400 } 401 for forbidden in [ 402 "nix ", 403 "nix-", 404 "docker ", 405 "podman ", 406 "cosign ", 407 "gh release", 408 ] { 409 assert!( 410 !RELEASE_ACCEPTANCE.contains(forbidden), 411 "release acceptance contains deferred or unauthorized command `{forbidden}`" 412 ); 413 } 414 } 415 416 #[test] 417 fn release_tool_dependency_and_file_mode_boundaries_are_exact() { 418 let manifest: toml::Value = toml::from_str(XTASK_MANIFEST).expect("xtask manifest"); 419 assert_eq!(manifest["package"]["name"].as_str(), Some("rhi_xtask")); 420 assert_eq!(manifest["package"]["publish"].as_bool(), Some(false)); 421 let dependencies = manifest["dependencies"] 422 .as_table() 423 .expect("xtask dependencies") 424 .keys() 425 .map(String::as_str) 426 .collect::<BTreeSet<_>>(); 427 assert_eq!( 428 dependencies, 429 BTreeSet::from([ 430 "flate2", 431 "hex", 432 "serde", 433 "serde_json", 434 "sha2", 435 "tar", 436 "tempfile", 437 "toml", 438 ]) 439 ); 440 assert_eq!( 441 manifest["target"]["cfg(unix)"]["dependencies"] 442 .as_table() 443 .expect("Unix dependencies") 444 .keys() 445 .map(String::as_str) 446 .collect::<BTreeSet<_>>(), 447 BTreeSet::from(["rustix"]) 448 ); 449 for forbidden in [ 450 "sqlx", "rusqlite", "reqwest", "tokio", "\nnix =", "nix::", "oci", "cosign", "path =", 451 "git =", 452 ] { 453 assert!( 454 !XTASK_MANIFEST.contains(forbidden), 455 "release tool contains unauthorized dependency or authority `{forbidden}`" 456 ); 457 } 458 459 #[cfg(unix)] 460 { 461 use std::os::unix::fs::PermissionsExt as _; 462 463 let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")); 464 assert_eq!( 465 std::fs::metadata(root.join("scripts/release-acceptance.sh")) 466 .expect("release script metadata") 467 .permissions() 468 .mode() 469 & 0o777, 470 0o755 471 ); 472 assert_eq!( 473 std::fs::metadata(root.join("packaging/systemd/rhi@.service")) 474 .expect("systemd unit metadata") 475 .permissions() 476 .mode() 477 & 0o777, 478 0o644 479 ); 480 } 481 }