rhi

Coordinated trade for connected markets
git clone https://radroots.dev/git/rhi.git
Log | Files | Refs | README | LICENSE

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 }