lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

service_source_lock_v4_contract.rs (10694B)


      1 #![forbid(unsafe_code)]
      2 
      3 use serde_json::{Value, json};
      4 use sha2::{Digest, Sha256};
      5 
      6 const CONTRACT: &str = include_str!(
      7     "../../../contracts/architecture/decisions/services_hardening_source_lock.v4.json"
      8 );
      9 const PREDECESSOR: &[u8] = include_bytes!(
     10     "../../../contracts/architecture/decisions/services_hardening_source_lock.v3.json"
     11 );
     12 
     13 fn schema() -> Value {
     14     serde_json::from_str(CONTRACT).expect("source-lock contract must be valid JSON")
     15 }
     16 
     17 // Independent structural input, not a generated source lock or execution receipt.
     18 fn input(service: &str) -> Value {
     19     json!({
     20         "schema": "radroots.service.source_lock.v4",
     21         "contract_version": 4,
     22         "service": service,
     23         "repository": "https://github.com/radrootslabs/lib",
     24         "revision": "1111111111111111111111111111111111111111",
     25         "architecture": "radroots.crates.release.v2",
     26         "workspace_catalog_sha256": "2".repeat(64),
     27         "version": "0.1.0-alpha",
     28         "source_archive_sha256": "3".repeat(64),
     29         "source_archive_contract": {
     30             "binding": "sha256_of_canonical_exact_lib_revision_tree_archive",
     31             "format": "ustar",
     32             "compression": "none",
     33             "compression_timestamp": "not_applicable",
     34             "entry_order": "bytewise_git_path",
     35             "path_prefix": "none",
     36             "file_mode": "git_index_100644_or_100755",
     37             "uid": 0,
     38             "gid": 0,
     39             "uname": "",
     40             "gname": "",
     41             "mtime": "lib_revision_commit_timestamp",
     42             "pax_headers": "forbidden",
     43             "directory_entries": "omitted",
     44             "symlinks": "forbidden",
     45             "hardlinks": "forbidden",
     46             "submodules": "forbidden",
     47             "trailer": "two_zero_blocks"
     48         },
     49         "cargo_lock_sha256": "4".repeat(64),
     50         "rust_version": "1.99.0",
     51         "host_feature_profile": "service-host",
     52         "nix": {
     53             "material": "bound",
     54             "lib_revision": "1111111111111111111111111111111111111111",
     55             "supported_systems": ["aarch64-darwin", "x86_64-linux"],
     56             "public_input_lock": {
     57                 "path": "flake.lock",
     58                 "sha256": "5".repeat(64),
     59                 "binding": "exact_regular_file_bytes",
     60                 "mutable_reference": "forbidden",
     61                 "lib_input": "lib"
     62             },
     63             "parent_result": {
     64                 "embedded_in_public_input_lock": false,
     65                 "embedded_in_source_lock": false,
     66                 "storage": "separate_source_scoped_execution_evidence"
     67             }
     68         },
     69         "artifact_contract": {
     70             "path": format!("contracts/release/{service}-artifact-contract.v4.json"),
     71             "sha256": "6".repeat(64),
     72             "binding": "exact_regular_file_bytes_in_same_source_revision"
     73         },
     74         "sqlite": {
     75             "high_level_authority": "sqlx_only",
     76             "second_pool_connection_query_transaction_migration_authority": "forbidden",
     77             "incremental_backup_adapter": "sealed_native_sqlx_owned_locked_handle_only",
     78             "native_linkage_count": 1
     79         },
     80         "contract_versions": {"config": 1, "state": 2, "admin": 3, "status": 4, "provider": 5}
     81     })
     82 }
     83 
     84 #[test]
     85 fn both_services_accept_complete_current_input_bindings() {
     86     let schema = schema();
     87     assert_eq!(schema["$id"], "radroots.service.source_lock.v4");
     88     let validator = jsonschema::validator_for(&schema).expect("valid source-lock schema");
     89     for service in ["myc", "rhi"] {
     90         assert!(validator.is_valid(&input(service)), "{service}");
     91     }
     92 }
     93 
     94 #[test]
     95 fn compiler_identity_is_exact_stable_1_99_0() {
     96     let validator = jsonschema::validator_for(&schema()).expect("valid source-lock schema");
     97     for compiler in [
     98         "1.97.1", "1.98.0", "1.99", "1.99.1", "1.100.0", "stable", "nightly",
     99     ] {
    100         let mut value = input("myc");
    101         value["rust_version"] = json!(compiler);
    102         assert!(!validator.is_valid(&value), "{compiler}");
    103     }
    104 }
    105 
    106 #[test]
    107 fn required_bindings_cannot_be_omitted() {
    108     let validator = jsonschema::validator_for(&schema()).expect("valid source-lock schema");
    109     for (parent, fields) in [
    110         (
    111             "",
    112             &[
    113                 "schema",
    114                 "contract_version",
    115                 "service",
    116                 "repository",
    117                 "revision",
    118                 "architecture",
    119                 "workspace_catalog_sha256",
    120                 "version",
    121                 "source_archive_sha256",
    122                 "source_archive_contract",
    123                 "cargo_lock_sha256",
    124                 "rust_version",
    125                 "host_feature_profile",
    126                 "nix",
    127                 "artifact_contract",
    128                 "sqlite",
    129                 "contract_versions",
    130             ][..],
    131         ),
    132         (
    133             "/nix",
    134             &[
    135                 "material",
    136                 "lib_revision",
    137                 "supported_systems",
    138                 "public_input_lock",
    139                 "parent_result",
    140             ][..],
    141         ),
    142         (
    143             "/nix/public_input_lock",
    144             &[
    145                 "path",
    146                 "sha256",
    147                 "binding",
    148                 "mutable_reference",
    149                 "lib_input",
    150             ][..],
    151         ),
    152         ("/artifact_contract", &["path", "sha256", "binding"][..]),
    153         (
    154             "/contract_versions",
    155             &["config", "state", "admin", "status", "provider"][..],
    156         ),
    157     ] {
    158         for field in fields {
    159             let mut value = input("rhi");
    160             value
    161                 .pointer_mut(parent)
    162                 .expect("fixture parent")
    163                 .as_object_mut()
    164                 .expect("fixture object")
    165                 .remove(*field);
    166             assert!(!validator.is_valid(&value), "{parent}/{field}");
    167         }
    168     }
    169 }
    170 
    171 #[test]
    172 fn every_object_rejects_unknown_material() {
    173     let validator = jsonschema::validator_for(&schema()).expect("valid source-lock schema");
    174     for parent in [
    175         "",
    176         "/source_archive_contract",
    177         "/nix",
    178         "/nix/public_input_lock",
    179         "/nix/parent_result",
    180         "/artifact_contract",
    181         "/sqlite",
    182         "/contract_versions",
    183     ] {
    184         let mut value = input("myc");
    185         value
    186             .pointer_mut(parent)
    187             .expect("fixture object")
    188             .as_object_mut()
    189             .expect("fixture object")
    190             .insert("unrecognized_material".to_owned(), json!(true));
    191         assert!(!validator.is_valid(&value), "{parent}");
    192     }
    193 }
    194 
    195 #[test]
    196 fn identities_and_positive_contract_versions_are_bounded() {
    197     let validator = jsonschema::validator_for(&schema()).expect("valid source-lock schema");
    198     for (pointer, invalid) in [
    199         ("/revision", json!("main")),
    200         ("/revision", json!("A".repeat(40))),
    201         ("/workspace_catalog_sha256", json!("2".repeat(63))),
    202         ("/source_archive_sha256", json!("3".repeat(65))),
    203         ("/cargo_lock_sha256", json!("G".repeat(64))),
    204         ("/nix/lib_revision", json!("HEAD")),
    205         ("/nix/public_input_lock/sha256", json!(null)),
    206         ("/artifact_contract/sha256", json!("")),
    207         ("/repository", json!("https://example.invalid/lib")),
    208         ("/contract_versions/config", json!(0)),
    209         ("/contract_versions/state", json!(-1)),
    210         ("/contract_versions/admin", json!(4_294_967_296_u64)),
    211         ("/contract_versions/status", json!(1.5)),
    212         ("/contract_versions/provider", json!("1")),
    213     ] {
    214         let mut value = input("rhi");
    215         *value.pointer_mut(pointer).expect("fixture field") = invalid;
    216         assert!(!validator.is_valid(&value), "{pointer}");
    217     }
    218 }
    219 
    220 #[test]
    221 fn artifact_binding_belongs_to_the_declared_service_and_revision() {
    222     let validator = jsonschema::validator_for(&schema()).expect("valid source-lock schema");
    223     for (service, path) in [
    224         ("myc", "contracts/release/rhi-artifact-contract.v4.json"),
    225         ("rhi", "contracts/release/myc-artifact-contract.v4.json"),
    226         ("myc", "contracts/release/myc-artifact-contract.v3.json"),
    227         ("rhi", "../rhi-artifact-contract.v4.json"),
    228     ] {
    229         let mut value = input(service);
    230         value["artifact_contract"]["path"] = json!(path);
    231         assert!(!validator.is_valid(&value), "{service}: {path}");
    232     }
    233     let mut value = input("myc");
    234     value["artifact_contract"]["binding"] = json!("latest_available_contract");
    235     assert!(!validator.is_valid(&value));
    236 }
    237 
    238 #[test]
    239 fn source_binding_cannot_embed_or_assert_executed_qualification() {
    240     let validator = jsonschema::validator_for(&schema()).expect("valid source-lock schema");
    241     for (pointer, invalid) in [
    242         ("/nix/material", json!("qualified")),
    243         ("/nix/material", json!("absent")),
    244         ("/nix/material", json!("deferred")),
    245         ("/nix/public_input_lock/mutable_reference", json!("allowed")),
    246         (
    247             "/nix/parent_result/embedded_in_public_input_lock",
    248             json!(true),
    249         ),
    250         ("/nix/parent_result/embedded_in_source_lock", json!(true)),
    251         (
    252             "/nix/parent_result/storage",
    253             json!("separate_generation_scoped_evidence"),
    254         ),
    255     ] {
    256         let mut value = input("myc");
    257         *value.pointer_mut(pointer).expect("fixture field") = invalid;
    258         assert!(!validator.is_valid(&value), "{pointer}");
    259     }
    260 }
    261 
    262 #[test]
    263 fn archive_and_single_sqlite_authority_cannot_be_weakened() {
    264     let validator = jsonschema::validator_for(&schema()).expect("valid source-lock schema");
    265     for (pointer, invalid) in [
    266         ("/source_archive_contract/format", json!("pax")),
    267         ("/source_archive_contract/mtime", json!("wall_clock")),
    268         ("/source_archive_contract/symlinks", json!("allowed")),
    269         ("/sqlite/high_level_authority", json!("multiple")),
    270         ("/sqlite/native_linkage_count", json!(2)),
    271         (
    272             "/sqlite/incremental_backup_adapter",
    273             json!("independent_connection"),
    274         ),
    275     ] {
    276         let mut value = input("rhi");
    277         *value.pointer_mut(pointer).expect("fixture field") = invalid;
    278         assert!(!validator.is_valid(&value), "{pointer}");
    279     }
    280 }
    281 
    282 #[test]
    283 fn predecessor_contract_bytes_and_compiler_identity_remain_historical() {
    284     assert_eq!(
    285         hex::encode(Sha256::digest(PREDECESSOR)),
    286         "3bc32c8ca2cecb06c8f8239ab1fe1fcfba93fe3ef0d60e9b078390347d08f817"
    287     );
    288     let old: Value = serde_json::from_slice(PREDECESSOR).expect("historical schema");
    289     assert_eq!(old["properties"]["rust_version"]["const"], "1.97.1");
    290     assert_eq!(
    291         old["properties"]["nix"]["properties"]["material"]["const"],
    292         "qualified"
    293     );
    294 }