lib

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

service_source_lock_nix.rs (8907B)


      1 use std::collections::BTreeSet;
      2 
      3 use serde::Deserialize;
      4 use serde_json::Value;
      5 use sha2::{Digest as _, Sha256};
      6 
      7 use crate::service_source_lock::{
      8     NoDuplicateJsonValue, valid_nix_sha256, validate_deferred_nix_lock,
      9     validate_deferred_nix_material,
     10 };
     11 
     12 pub(crate) struct BoundNixMaterial {
     13     pub(crate) revision: String,
     14     pub(crate) lock_sha256: String,
     15 }
     16 
     17 pub(crate) fn validate_bound_nix_lock(bytes: &[u8]) -> Result<String, ()> {
     18     parse_lock(bytes).map(|(revision, _)| revision)
     19 }
     20 
     21 pub(crate) fn validate_bound_nix_material(
     22     expression: &[u8],
     23     lock: &[u8],
     24 ) -> Result<BoundNixMaterial, ()> {
     25     if expression.len() > 1_048_576 {
     26         return Err(());
     27     }
     28     let (revision, helpers) = parse_lock(lock)?;
     29     if helpers {
     30         let text = std::str::from_utf8(expression).map_err(|_| ())?;
     31         let lines = text
     32             .lines()
     33             .map(str::trim)
     34             .filter(|line| !line.is_empty() && !line.starts_with('#'))
     35             .collect::<Vec<_>>();
     36         let expected = format!("url = \"github:radrootslabs/lib/{revision}\";");
     37         let selectors = lines
     38             .iter()
     39             .filter(|line| line.contains("github:radrootslabs/lib"))
     40             .count();
     41         let blocks = lines
     42             .windows(4)
     43             .filter(|block| {
     44                 block[0] == "lib = {"
     45                     && lines.iter().filter(|line| **line == "inputs = {").count() == 1
     46                     && block[1] == expected
     47                     && block[2] == "inputs.crane.follows = \"crane\";"
     48                     && block[3] == "};"
     49             })
     50             .count();
     51         if selectors != 1 || blocks != 1 {
     52             return Err(());
     53         }
     54     } else {
     55         let evidence = validate_deferred_nix_material(expression, lock).map_err(|_| ())?;
     56         return Ok(BoundNixMaterial {
     57             revision: evidence.lib_revision().to_owned(),
     58             lock_sha256: evidence.flake_lock_sha256().to_owned(),
     59         });
     60     }
     61     Ok(BoundNixMaterial {
     62         revision,
     63         lock_sha256: hex::encode(Sha256::digest(lock)),
     64     })
     65 }
     66 
     67 fn parse_lock(bytes: &[u8]) -> Result<(String, bool), ()> {
     68     if bytes.len() > 4_194_304 {
     69         return Err(());
     70     }
     71     let mut decoder = serde_json::Deserializer::from_slice(bytes);
     72     let mut value = NoDuplicateJsonValue::deserialize(&mut decoder)
     73         .map_err(|_| ())?
     74         .0;
     75     decoder.end().map_err(|_| ())?;
     76     let root = value.get("root").and_then(Value::as_str).ok_or(())?;
     77     let nodes = value.get("nodes").and_then(Value::as_object).ok_or(())?;
     78     let root_inputs = nodes
     79         .get(root)
     80         .and_then(|node| node.get("inputs"))
     81         .and_then(Value::as_object)
     82         .ok_or(())?;
     83     let lib_name = root_inputs
     84         .get("lib")
     85         .and_then(Value::as_str)
     86         .ok_or(())?
     87         .to_owned();
     88     let lib = nodes.get(&lib_name).and_then(Value::as_object).ok_or(())?;
     89     let helpers = if let Some(inputs) = lib.get("inputs") {
     90         let inputs = inputs.as_object().ok_or(())?;
     91         if inputs.keys().map(String::as_str).collect::<BTreeSet<_>>()
     92             != BTreeSet::from([
     93                 "crane",
     94                 "flake-parts",
     95                 "nixpkgs",
     96                 "rust-overlay",
     97                 "treefmt-nix",
     98             ])
     99         {
    100             return Err(());
    101         }
    102         for (name, target) in inputs {
    103             let target = if name == "crane" {
    104                 if target != &serde_json::json!(["crane"]) {
    105                     return Err(());
    106                 }
    107                 root_inputs.get("crane").and_then(Value::as_str).ok_or(())?
    108             } else {
    109                 target.as_str().ok_or(())?
    110             };
    111             if target == lib_name || target == root {
    112                 return Err(());
    113             }
    114             let locked = nodes
    115                 .get(target)
    116                 .and_then(|node| node.get("locked"))
    117                 .ok_or(())?;
    118             let revision = locked.get("rev").and_then(Value::as_str).ok_or(())?;
    119             if locked.get("type").and_then(Value::as_str) != Some("github")
    120                 || revision.len() != 40
    121                 || !revision
    122                     .bytes()
    123                     .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
    124                 || !locked
    125                     .get("narHash")
    126                     .and_then(Value::as_str)
    127                     .is_some_and(valid_nix_sha256)
    128             {
    129                 return Err(());
    130             }
    131         }
    132         true
    133     } else {
    134         false
    135     };
    136     if helpers {
    137         value["nodes"][&lib_name]
    138             .as_object_mut()
    139             .ok_or(())?
    140             .remove("inputs");
    141     }
    142     let normalized = serde_json::to_vec(&value).map_err(|_| ())?;
    143     let revision = validate_deferred_nix_lock(&normalized).map_err(|_| ())?;
    144     Ok((revision, helpers))
    145 }
    146 
    147 #[cfg(test)]
    148 mod tests {
    149     use super::*;
    150     use serde_json::json;
    151 
    152     fn fixture() -> (String, Value) {
    153         let revision = "a".repeat(40);
    154         let mut lock = json!({
    155             "version": 7, "root": "root",
    156             "nodes": {
    157                 "root": {"inputs": {"lib": "lib", "crane": "crane"}},
    158                 "lib": {
    159                     "inputs": {"crane": ["crane"], "flake-parts": "parts", "nixpkgs": "pkgs", "rust-overlay": "rust", "treefmt-nix": "fmt"},
    160                     "locked": {"lastModified": 1, "narHash": format!("sha256-{}=", "A".repeat(43)), "owner": "radrootslabs", "repo": "lib", "rev": revision, "type": "github"},
    161                     "original": {"owner": "radrootslabs", "repo": "lib", "rev": revision, "type": "github"}
    162                 }
    163             }
    164         });
    165         for node in ["crane", "parts", "pkgs", "rust", "fmt"] {
    166             lock["nodes"][node] = json!({"locked": {"type": "github", "rev": "b".repeat(40), "narHash": format!("sha256-{}=", "A".repeat(43))}});
    167         }
    168         let expression = format!(
    169             "{{\n inputs = {{\n crane.url = \"github:owner/crane/{}\";\n lib = {{\n url = \"github:radrootslabs/lib/{revision}\";\n inputs.crane.follows = \"crane\";\n }};\n }};\n outputs = {{...}}: {{}};\n}}",
    170             "b".repeat(40)
    171         );
    172         (expression, lock)
    173     }
    174 
    175     #[test]
    176     fn actual_service_helper_shape_binds_exact_inputs_without_qualification() {
    177         let (expression, lock) = fixture();
    178         let bytes = serde_json::to_vec(&lock).unwrap();
    179         assert!(validate_deferred_nix_material(expression.as_bytes(), &bytes).is_err());
    180         let evidence = validate_bound_nix_material(expression.as_bytes(), &bytes).unwrap();
    181         assert_eq!(evidence.revision, "a".repeat(40));
    182         assert_eq!(evidence.lock_sha256, hex::encode(Sha256::digest(&bytes)));
    183         let direct = expression.replace("lib = {", "inputs.lib = {");
    184         assert!(validate_bound_nix_material(direct.as_bytes(), &bytes).is_err());
    185     }
    186 
    187     #[test]
    188     fn helper_graph_identity_and_source_drift_are_refused() {
    189         let (expression, lock) = fixture();
    190         for (pointer, value) in [
    191             ("/nodes/lib/original/rev", json!("c".repeat(40))),
    192             ("/nodes/lib/unexpected", json!(true)),
    193             ("/nodes/lib/inputs/extra", json!("pkgs")),
    194             ("/nodes/lib/inputs/crane", json!(["other"])),
    195             ("/nodes/lib/inputs/nixpkgs", json!("missing")),
    196             ("/nodes/lib/inputs/nixpkgs", json!("lib")),
    197             ("/nodes/pkgs/locked/rev", json!("stable")),
    198             ("/nodes/pkgs/locked/narHash", json!("invalid")),
    199         ] {
    200             let mut changed = lock.clone();
    201             if pointer.ends_with("unexpected") {
    202                 changed["nodes"]["lib"]["unexpected"] = value;
    203             } else if pointer.ends_with("extra") {
    204                 changed["nodes"]["lib"]["inputs"]["extra"] = value;
    205             } else {
    206                 *changed.pointer_mut(pointer).unwrap() = value;
    207             }
    208             assert!(
    209                 validate_bound_nix_material(
    210                     expression.as_bytes(),
    211                     &serde_json::to_vec(&changed).unwrap()
    212                 )
    213                 .is_err(),
    214                 "{pointer}"
    215             );
    216         }
    217         for source in [
    218             expression.replace(&"a".repeat(40), &"c".repeat(40)),
    219             expression.replace("inputs.crane.follows = \"crane\";", "flake = false;"),
    220             format!(
    221                 "{expression}\nurl = \"github:radrootslabs/lib/{}\";",
    222                 "a".repeat(40)
    223             ),
    224         ] {
    225             assert!(
    226                 validate_bound_nix_material(source.as_bytes(), &serde_json::to_vec(&lock).unwrap())
    227                     .is_err()
    228             );
    229         }
    230         let duplicate = serde_json::to_string(&lock).unwrap().replacen(
    231             "\"version\":7",
    232             "\"version\":7,\"version\":7",
    233             1,
    234         );
    235         assert!(validate_bound_nix_lock(duplicate.as_bytes()).is_err());
    236     }
    237 }