myc

Self-custodial remote signer for Radroots apps
git clone https://radroots.dev/git/myc.git
Log | Files | Refs | README | LICENSE

services_hardening_native_release.rs (14507B)


      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.v2.json");
     11 const ACTIVE_CONTRACT: &str =
     12     include_str!("../contracts/services_hardening/native_release.v4.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 CARGO_CONFIG: &str = include_str!("../.cargo/config.toml");
     18 const SYSTEMD_UNIT: &str = include_str!("../packaging/systemd/myc@.service");
     19 
     20 const LIB_REVISION: &str = "e55c1749902811732167a2ce5c099e22e964624f";
     21 const LIB_REPOSITORY: &str = "https://github.com/radrootslabs/lib";
     22 
     23 #[test]
     24 fn native_release_contract_and_manifest_metadata_are_exact() {
     25     let contract: serde_json::Value = serde_json::from_str(CONTRACT).expect("release contract");
     26     assert_eq!(
     27         contract,
     28         json!({
     29             "schema": "radroots.myc.native-release",
     30             "schema_version": 2,
     31             "contract_version": 2,
     32             "predecessor": {
     33                 "schema_version": 1,
     34                 "filename": "native_release.v1.json",
     35                 "transition": "forward_only_replace"
     36             },
     37             "service": "myc",
     38             "package": {
     39                 "name": "myc",
     40                 "binary": "myc",
     41                 "version": "0.1.0",
     42                 "repository": "https://github.com/radrootslabs/myc",
     43                 "publish_to_crates_io": false
     44             },
     45             "generator": {
     46                 "command": "cargo xtask native-release",
     47                 "modes": ["check", "write"],
     48                 "required_arguments": [
     49                     "mode", "target", "binary", "output", "source_date_epoch"
     50                 ],
     51                 "source_date_epoch_range": "1..=4294967295",
     52                 "clean_exact_head": true,
     53                 "target_binary_validation": "executable_elf64_little_endian_exact_machine",
     54                 "canonical_json": "compact_utf8_json_with_one_final_lf",
     55                 "deterministic_archives": true,
     56                 "output_directory_mode": "0755",
     57                 "output_file_mode": "0644",
     58                 "durability": "sync_files_then_output_directory_then_parent"
     59             },
     60             "toolchain": {
     61                 "rust_version": "1.97.1",
     62                 "edition": "2024",
     63                 "resolver": "3",
     64                 "host_feature_profile": "service-host"
     65             },
     66             "release_profile": {
     67                 "lto": "thin",
     68                 "codegen_units": 1,
     69                 "overflow_checks": true,
     70                 "strip": "symbols",
     71                 "panic": "unwind"
     72             },
     73             "source_lock": {
     74                 "filename": "radroots.service.source-lock.v2.toml",
     75                 "schema": "radroots.service.source-lock.v2",
     76                 "lib_repository": LIB_REPOSITORY,
     77                 "architecture": "radroots.crates.release.v2"
     78             },
     79             "contract_versions": {
     80                 "config": 1,
     81                 "state": 12,
     82                 "admin": 1,
     83                 "status": 1,
     84                 "provider": 1
     85             },
     86             "native_targets": [
     87                 { "target": "aarch64-unknown-linux-gnu", "posture": "target" },
     88                 { "target": "x86_64-unknown-linux-gnu", "posture": "target" }
     89             ],
     90             "output_inventory": [
     91                 "LICENSE",
     92                 "SHA256SUMS",
     93                 "THIRD-PARTY-NOTICES.txt",
     94                 "artifact-manifest.v1.json",
     95                 "binary.tar.gz",
     96                 "config.example.toml",
     97                 "config.schema.json",
     98                 "provenance-input.v1.json",
     99                 "radroots.service.source-lock.v2.toml",
    100                 "sbom.cdx.json",
    101                 "service-source.tar.gz",
    102                 "systemd.service"
    103             ],
    104             "signing_inputs": [
    105                 "SHA256SUMS",
    106                 "artifact-manifest.v1.json",
    107                 "provenance-input.v1.json"
    108             ],
    109             "provenance_posture": "deterministic_unsigned_slsa_v1_input_external_keys_only",
    110             "sbom_format": "cyclonedx_json_1_5_locked_cargo_graph",
    111             "source_archive": "locked_offline_cargo_build_with_vendored_dependencies",
    112             "checksum_format": "sha256_lower_hex_two_spaces_path_lf_sorted_by_path",
    113             "protected_material_included": false,
    114             "maximums": {
    115                 "text_input_bytes": 1048576,
    116                 "generated_document_bytes": 16777216,
    117                 "cargo_metadata_bytes": 33554432,
    118                 "binary_bytes": 536870912,
    119                 "source_archive_bytes": 1073741824,
    120                 "packages": 8192,
    121                 "tracked_files": 4096
    122             },
    123             "deferred_through_rcld_rshr_170": [
    124                 "nix_evaluation",
    125                 "nix_build",
    126                 "nixos_module_qualification",
    127                 "oci_artifact"
    128             ],
    129             "forbidden": [
    130                 "nix_input",
    131                 "nixos_module_output",
    132                 "oci_input",
    133                 "oci_output",
    134                 "protected_material",
    135                 "parent_owned_human_docs",
    136                 "private_harness",
    137                 "local_or_path_lib_dependency",
    138                 "floating_or_branch_lib_dependency",
    139                 "mixed_lib_revision",
    140                 "crates_io_publication",
    141                 "signing",
    142                 "tagging",
    143                 "release_publication",
    144                 "deployment"
    145             ]
    146         })
    147     );
    148 
    149     let manifest: toml::Value = toml::from_str(MANIFEST).expect("Cargo manifest");
    150     let package = manifest["package"].as_table().expect("package");
    151     assert_eq!(
    152         package["repository"].as_str(),
    153         Some("https://github.com/radrootslabs/myc")
    154     );
    155     assert_eq!(package["readme"].as_str(), Some("README"));
    156     assert_eq!(package["publish"].as_bool(), Some(false));
    157 
    158     let metadata = &manifest["workspace"]["metadata"]["radroots"];
    159     assert_eq!(
    160         metadata["service_source_lock"],
    161         toml::Value::Table(toml::toml! {
    162             service = "myc"
    163             host_feature_profile = "service-host"
    164             nix_material = "bound"
    165             config_contract_version = 1
    166             state_contract_version = 12
    167             admin_contract_version = 1
    168             status_contract_version = 1
    169             provider_contract_version = 1
    170         })
    171     );
    172     assert_eq!(
    173         metadata["service_release"],
    174         toml::Value::Table(toml::toml! {
    175             service = "myc"
    176             service_package = "myc"
    177             binary_name = "myc"
    178             version = "0.1.0"
    179         })
    180     );
    181     assert_eq!(
    182         manifest["profile"]["release"],
    183         toml::Value::Table(toml::toml! {
    184             lto = "thin"
    185             codegen-units = 1
    186             overflow-checks = true
    187             strip = "symbols"
    188             panic = "unwind"
    189         })
    190     );
    191     assert_eq!(
    192         CARGO_CONFIG,
    193         "[alias]\nxtask = \"run --locked -p myc_xtask --\"\n"
    194     );
    195     for required in [
    196         "ExecStart=/usr/bin/myc --profile service-host --instance %i run",
    197         "ConfigurationDirectory=radroots/services/myc/%i",
    198         "StateDirectory=radroots/services/myc/%i",
    199         "RuntimeDirectory=radroots/services/myc/%i",
    200         "UMask=0077",
    201         "NoNewPrivileges=yes",
    202         "ProtectSystem=strict",
    203         "CapabilityBoundingSet=",
    204     ] {
    205         assert!(SYSTEMD_UNIT.contains(required), "missing `{required}`");
    206     }
    207 }
    208 
    209 #[test]
    210 fn every_radroots_dependency_is_exactly_source_locked() {
    211     let manifest: toml::Value = toml::from_str(MANIFEST).expect("Cargo manifest");
    212     let dependencies = manifest["dependencies"].as_table().expect("dependencies");
    213     let radroots = dependencies
    214         .iter()
    215         .filter(|(name, _)| name.starts_with("radroots_"))
    216         .collect::<Vec<_>>();
    217     assert_eq!(
    218         radroots
    219             .iter()
    220             .map(|(name, _)| name.as_str())
    221             .collect::<BTreeSet<_>>(),
    222         [
    223             "radroots_event_codec",
    224             "radroots_identity",
    225             "radroots_nostr",
    226             "radroots_nostr_connect",
    227             "radroots_runtime_paths",
    228             "radroots_secrets",
    229             "radroots_service_host",
    230             "radroots_service_sqlite",
    231             "radroots_storage",
    232             "radroots_transport",
    233             "radroots_transport_nostr",
    234             "radroots_transport_nostr_native",
    235         ]
    236         .into_iter()
    237         .collect()
    238     );
    239     for (name, dependency) in radroots {
    240         let dependency = dependency.as_table().expect("detailed dependency");
    241         assert_eq!(
    242             dependency.get("git").and_then(toml::Value::as_str),
    243             Some(LIB_REPOSITORY),
    244             "{name}"
    245         );
    246         assert_eq!(
    247             dependency.get("rev").and_then(toml::Value::as_str),
    248             Some(LIB_REVISION),
    249             "{name}"
    250         );
    251         assert_eq!(
    252             dependency.get("version").and_then(toml::Value::as_str),
    253             Some("=0.1.0-alpha"),
    254             "{name}"
    255         );
    256         for forbidden in ["path", "branch", "tag"] {
    257             assert!(
    258                 !dependency.contains_key(forbidden),
    259                 "{name} contains `{forbidden}`"
    260             );
    261         }
    262     }
    263     assert!(!MANIFEST.contains("[patch."));
    264 
    265     let sources = LOCK
    266         .lines()
    267         .filter_map(|line| line.strip_prefix("source = \"git+"))
    268         .filter_map(|line| line.strip_suffix('"'))
    269         .filter(|source| source.contains("radrootslabs/lib"))
    270         .collect::<BTreeSet<_>>();
    271     assert_eq!(sources.len(), 1);
    272     let source = sources.into_iter().next().expect("Lib source");
    273     assert!(source.contains(&format!("?rev={LIB_REVISION}#{LIB_REVISION}")));
    274 
    275     for required in [
    276         "lib = {",
    277         "url = \"github:radrootslabs/lib/e55c1749902811732167a2ce5c099e22e964624f\";",
    278         "inputs.crane.follows = \"crane\";",
    279         "systems = lib.lib.supportedSystems;",
    280         "nixosModules.default",
    281     ] {
    282         assert!(
    283             FLAKE.contains(required),
    284             "flake source data is missing `{required}`"
    285         );
    286     }
    287     let flake_lock: serde_json::Value =
    288         serde_json::from_str(FLAKE_LOCK).expect("flake source lock");
    289     assert_eq!(flake_lock["version"], 7);
    290     assert_eq!(flake_lock["root"], "root");
    291     assert_eq!(flake_lock["nodes"]["root"]["inputs"]["lib"], "lib");
    292     assert_eq!(
    293         flake_lock["nodes"]["lib"],
    294         json!({
    295             "inputs": {
    296                 "crane": ["crane"],
    297                 "flake-parts": "flake-parts",
    298                 "nixpkgs": "nixpkgs",
    299                 "rust-overlay": "rust-overlay",
    300                 "treefmt-nix": "treefmt-nix"
    301             },
    302             "locked": {
    303                 "lastModified": 1792821324_u64,
    304                 "narHash": "sha256-PF1VeqsoibuDRZ6gjBDGcFsFF4QiUoQOMox9Z82VtFA=",
    305                 "owner": "radrootslabs",
    306                 "repo": "lib",
    307                 "rev": LIB_REVISION,
    308                 "type": "github"
    309             },
    310             "original": {
    311                 "owner": "radrootslabs",
    312                 "repo": "lib",
    313                 "rev": LIB_REVISION,
    314                 "type": "github"
    315             }
    316         })
    317     );
    318 }
    319 
    320 #[test]
    321 fn native_release_surfaces_remain_generated_outside_the_source_tree() {
    322     let root = canonical_source::source_root(
    323         std::path::Path::new(env!("CARGO_MANIFEST_DIR")),
    324         option_env!("NIX_BUILD_TOP").map(std::path::Path::new),
    325         option_env!("src").map(std::path::Path::new),
    326         std::path::Path::new("/nix/store"),
    327         "myc",
    328         &[
    329             ("Cargo.toml", MANIFEST.as_bytes()),
    330             ("flake.lock", FLAKE_LOCK.as_bytes()),
    331             (
    332                 "tests/services_hardening_native_release.rs",
    333                 include_bytes!("services_hardening_native_release.rs"),
    334             ),
    335             (
    336                 "tests/support/canonical_source.rs",
    337                 include_bytes!("support/canonical_source.rs"),
    338             ),
    339         ],
    340     )
    341     .expect("native working tree or exact isolated Nix input");
    342     assert!(!root.join("radroots.lib.source-lock.v1.toml").exists());
    343     assert!(!root.join("radroots.service.source-lock.v1.toml").exists());
    344     assert!(!root.join("radroots.service.source-lock.v2.toml").exists());
    345     assert!(!root.join("radroots.service.source-lock.v3.toml").exists());
    346     assert!(root.join("radroots.service.source_lock.v4.toml").is_file());
    347     assert!(
    348         root.join("contracts/release/history/radroots.service.source-lock.v3.toml")
    349             .is_file()
    350     );
    351     assert!(
    352         !root
    353             .join("contracts/services_hardening/native_release.v1.json")
    354             .exists()
    355     );
    356     assert!(
    357         root.join("contracts/services_hardening/native_release.v2.json")
    358             .is_file()
    359     );
    360     assert!(
    361         root.join("contracts/services_hardening/native_release.v3.json")
    362             .is_file()
    363     );
    364     for forbidden in [
    365         ".github",
    366         "target",
    367         "result",
    368         "artifacts",
    369         "dist",
    370         "sbom.cdx.json",
    371         "provenance-input.v1.json",
    372         "oci-image.tar.gz",
    373     ] {
    374         assert!(
    375             !root.join(forbidden).exists(),
    376             "forbidden generated surface `{forbidden}` exists"
    377         );
    378     }
    379     assert!(!CONTRACT.contains("qualified"));
    380     assert!(!CONTRACT.contains("production_ready"));
    381     assert!(!CONTRACT.contains("oci-image"));
    382     assert!(!CONTRACT.contains("nixos-module"));
    383     let active: serde_json::Value =
    384         serde_json::from_str(ACTIVE_CONTRACT).expect("active release contract");
    385     assert_eq!(active["schema_version"], 4);
    386     assert_eq!(active["contract_version"], 4);
    387     assert_eq!(active["predecessor"]["filename"], "native_release.v3.json");
    388     assert_eq!(
    389         active["source_lock"]["filename"],
    390         "radroots.service.source_lock.v4.toml"
    391     );
    392     assert_eq!(active["source_lock"]["nix_material"], "bound");
    393     assert_eq!(active["toolchain"]["rust_version"], "1.99.0");
    394     assert_eq!(active["nix_qualified"], false);
    395     assert_eq!(active["maximums"]["source_lock_bytes"], 16_384);
    396     assert_eq!(active["nix_outputs"]["bundled_sqlite"], true);
    397     assert_eq!(active["nix_outputs"]["native_linkage_count"], 1);
    398 }