source_lock.rs (9930B)
1 use serde::{Deserialize, Serialize}; 2 use serde_json::Value; 3 use sha2::{Digest, Sha256}; 4 use std::{fs, io::Write, path::Path, process::Command}; 5 6 const LOCK: &str = "radroots.lib.source-lock.v1.toml"; 7 8 #[derive(Debug, PartialEq)] 9 pub(super) enum Error { 10 Input, 11 Graph, 12 Stale, 13 Io, 14 } 15 16 #[derive(Deserialize, Serialize)] 17 #[serde(deny_unknown_fields)] 18 struct SourceLock { 19 schema: String, 20 repository: String, 21 revision: String, 22 architecture: String, 23 workspace_catalog_sha256: String, 24 version: String, 25 source_archive_sha256: String, 26 lockfile: String, 27 lockfile_sha256: String, 28 } 29 30 pub(super) fn run(arguments: &[String]) -> Result<(), Error> { 31 let [action] = arguments else { 32 return Err(Error::Input); 33 }; 34 if !matches!(action.as_str(), "check" | "refresh") { 35 return Err(Error::Input); 36 } 37 let root = Path::new(env!("CARGO_MANIFEST_DIR")) 38 .parent() 39 .and_then(Path::parent) 40 .ok_or(Error::Input)?; 41 let source = read_bounded(&root.join(LOCK), 16 * 1024)?; 42 let cargo_lock = read_bounded(&root.join("Cargo.lock"), 32 * 1024 * 1024)?; 43 let output = Command::new("cargo") 44 .args(["metadata", "--locked", "--offline", "--format-version", "1"]) 45 .current_dir(root) 46 .output() 47 .map_err(|_| Error::Io)?; 48 if !output.status.success() || output.stdout.len() > 16 * 1024 * 1024 { 49 return Err(Error::Graph); 50 } 51 let metadata = serde_json::from_slice(&output.stdout).map_err(|_| Error::Graph)?; 52 let refreshed = render(&source, &cargo_lock, &metadata)?; 53 if action == "check" { 54 let original: SourceLock = 55 toml::from_str(std::str::from_utf8(&source).map_err(|_| Error::Input)?) 56 .map_err(|_| Error::Input)?; 57 if original.lockfile_sha256 != digest(&cargo_lock) { 58 return Err(Error::Stale); 59 } 60 println!("source lock current"); 61 return Ok(()); 62 } 63 let mut temporary = tempfile::NamedTempFile::new_in(root).map_err(|_| Error::Io)?; 64 temporary 65 .write_all(refreshed.as_bytes()) 66 .map_err(|_| Error::Io)?; 67 temporary.as_file().sync_all().map_err(|_| Error::Io)?; 68 if read_bounded(&root.join(LOCK), 16 * 1024)? != source 69 || read_bounded(&root.join("Cargo.lock"), 32 * 1024 * 1024)? != cargo_lock 70 { 71 return Err(Error::Stale); 72 } 73 let permissions = fs::metadata(root.join(LOCK)) 74 .map_err(|_| Error::Io)? 75 .permissions(); 76 temporary 77 .as_file() 78 .set_permissions(permissions) 79 .map_err(|_| Error::Io)?; 80 temporary.persist(root.join(LOCK)).map_err(|_| Error::Io)?; 81 println!("source lock refreshed"); 82 Ok(()) 83 } 84 85 fn read_bounded(path: &Path, limit: u64) -> Result<Vec<u8>, Error> { 86 let metadata = fs::symlink_metadata(path).map_err(|_| Error::Io)?; 87 if !metadata.is_file() || metadata.len() > limit { 88 return Err(Error::Input); 89 } 90 let bytes = fs::read(path).map_err(|_| Error::Io)?; 91 if bytes.len() as u64 > limit { 92 return Err(Error::Input); 93 } 94 Ok(bytes) 95 } 96 97 fn digest(bytes: &[u8]) -> String { 98 format!("{:x}", Sha256::digest(bytes)) 99 } 100 101 fn render(source: &[u8], cargo_lock: &[u8], metadata: &Value) -> Result<String, Error> { 102 let mut lock: SourceLock = 103 toml::from_str(std::str::from_utf8(source).map_err(|_| Error::Input)?) 104 .map_err(|_| Error::Input)?; 105 if lock.schema != "radroots.lib.source-lock.v1" 106 || lock.repository != "https://github.com/radrootslabs/lib" 107 || lock.architecture != "radroots.crates.release.v2" 108 || lock.lockfile != "Cargo.lock" 109 || lock.version != "0.1.0-alpha" 110 { 111 return Err(Error::Input); 112 } 113 for (value, length) in [ 114 (&lock.revision, 40), 115 (&lock.workspace_catalog_sha256, 64), 116 (&lock.source_archive_sha256, 64), 117 (&lock.lockfile_sha256, 64), 118 ] { 119 if value.len() != length 120 || !value 121 .bytes() 122 .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) 123 { 124 return Err(Error::Input); 125 } 126 } 127 let source = format!( 128 "git+https://github.com/radrootslabs/lib.git?rev={}", 129 lock.revision 130 ); 131 let resolved = format!("{source}#{}", lock.revision); 132 let packages = metadata["packages"].as_array().ok_or(Error::Graph)?; 133 let daemon = packages 134 .iter() 135 .find(|package| package["name"] == "radrootsd") 136 .ok_or(Error::Graph)?; 137 let dependencies = daemon["dependencies"].as_array().ok_or(Error::Graph)?; 138 let mut direct = 0; 139 for dependency in dependencies { 140 let name = dependency["name"].as_str().ok_or(Error::Graph)?; 141 if name.starts_with("radroots_") { 142 if dependency["source"] != source 143 || dependency["req"] != format!("={}", lock.version) 144 || !dependency["rename"].is_null() 145 { 146 return Err(Error::Graph); 147 } 148 direct += 1; 149 } 150 } 151 let mut shared = 0; 152 for package in packages { 153 let name = package["name"].as_str().ok_or(Error::Graph)?; 154 if name == "radroots" || name.starts_with("radroots_") { 155 if package["source"] != resolved || package["version"] != lock.version { 156 return Err(Error::Graph); 157 } 158 shared += 1; 159 } 160 } 161 if direct == 0 || shared == 0 { 162 return Err(Error::Graph); 163 } 164 lock.lockfile_sha256 = digest(cargo_lock); 165 toml::to_string(&lock).map_err(|_| Error::Input) 166 } 167 168 #[cfg(test)] 169 mod tests { 170 use super::*; 171 use serde_json::json; 172 173 fn fixture() -> (Vec<u8>, Value) { 174 let source = include_bytes!("../../../radroots.lib.source-lock.v1.toml").to_vec(); 175 let lock: SourceLock = 176 toml::from_str(std::str::from_utf8(&source).expect("UTF8")).expect("source lock"); 177 let git_source = format!( 178 "git+https://github.com/radrootslabs/lib.git?rev={}", 179 lock.revision 180 ); 181 let metadata = json!({"packages": [ 182 {"name": "radrootsd", "dependencies": [{"name": "radroots_protocol", "source": git_source, 183 "req": "=0.1.0-alpha", "rename": null}]}, 184 {"name": "radroots_protocol", "source": format!("{git_source}#{}", lock.revision), 185 "version": "0.1.0-alpha"} 186 ]}); 187 (source, metadata) 188 } 189 190 #[test] 191 fn refresh_changes_only_actual_lock_digest_and_is_idempotent() { 192 let (source, metadata) = fixture(); 193 let before: toml::Value = 194 toml::from_str(std::str::from_utf8(&source).expect("UTF8")).expect("before"); 195 let refreshed = render(&source, b"new locked graph", &metadata).expect("refresh"); 196 let mut after: toml::Value = toml::from_str(&refreshed).expect("after"); 197 assert_eq!( 198 after["lockfile_sha256"].as_str(), 199 Some(digest(b"new locked graph").as_str()) 200 ); 201 after["lockfile_sha256"] = before["lockfile_sha256"].clone(); 202 assert_eq!(before, after); 203 assert_eq!( 204 render(refreshed.as_bytes(), b"new locked graph", &metadata).expect("replay"), 205 refreshed 206 ); 207 } 208 209 #[test] 210 fn duplicate_unknown_and_malformed_authority_is_rejected() { 211 let (source, metadata) = fixture(); 212 for suffix in [ 213 "\nrevision = \"duplicate\"\n", 214 "\nunknown = true\n", 215 "\ninvalid = [", 216 ] { 217 let mut changed = source.clone(); 218 changed.extend_from_slice(suffix.as_bytes()); 219 assert_eq!(render(&changed, b"graph", &metadata), Err(Error::Input)); 220 } 221 let changed = String::from_utf8(source) 222 .expect("UTF8") 223 .replace("lockfile = \"Cargo.lock\"", "lockfile = \"../Cargo.lock\""); 224 assert_eq!( 225 render(changed.as_bytes(), b"graph", &metadata), 226 Err(Error::Input) 227 ); 228 } 229 230 #[test] 231 fn direct_and_resolved_source_pin_version_or_alias_drift_is_rejected() { 232 let (source, metadata) = fixture(); 233 for (field, value) in [ 234 ("source", Value::Null), 235 ("req", json!("^0.1")), 236 ("rename", json!("alias")), 237 ] { 238 let mut changed = metadata.clone(); 239 changed["packages"][0]["dependencies"][0][field] = value; 240 assert_eq!(render(&source, b"graph", &changed), Err(Error::Graph)); 241 } 242 for (field, value) in [("source", Value::Null), ("version", json!("0.2.0"))] { 243 let mut changed = metadata.clone(); 244 changed["packages"][1][field] = value; 245 assert_eq!(render(&source, b"graph", &changed), Err(Error::Graph)); 246 } 247 assert_eq!( 248 render(&source, b"graph", &json!({"packages": []})), 249 Err(Error::Graph) 250 ); 251 } 252 253 #[test] 254 fn oversized_or_non_regular_inputs_are_rejected() { 255 let directory = tempfile::tempdir().expect("directory"); 256 let file = directory.path().join("input"); 257 fs::write(&file, b"12345").expect("input"); 258 assert_eq!(read_bounded(&file, 5).expect("bounded file"), b"12345"); 259 assert_eq!(read_bounded(&file, 4), Err(Error::Input)); 260 assert_eq!(read_bounded(directory.path(), 1024), Err(Error::Input)); 261 #[cfg(unix)] 262 { 263 let link = directory.path().join("link"); 264 std::os::unix::fs::symlink(&file, &link).expect("symlink"); 265 assert_eq!(read_bounded(&link, 5), Err(Error::Input)); 266 } 267 } 268 269 #[test] 270 fn unsupported_commands_fail_before_graph_or_file_access() { 271 for arguments in [ 272 vec![], 273 vec!["write".to_owned()], 274 vec!["refresh".to_owned(), "extra".to_owned()], 275 ] { 276 assert_eq!(run(&arguments), Err(Error::Input)); 277 } 278 } 279 }