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 }