radrootsd

JSON-RPC bridge for Radroots event publishing
git clone https://radroots.dev/git/radrootsd.git
Log | Files | Refs | README | LICENSE

commit 3f8d2740bffa9e655d8e79a38e3befebae10df2d
parent 1ea264b0b0c9359351b8ca7aa9c93e55d72ee394
Author: triesap <tyson@radroots.org>
Date:   Thu, 15 Oct 2026 22:44:22 +0000

build: Qualify radrootsd on Rust 1.99.0 with the TLS patch

- Declare exact Rust 1.99.0 while preserving the selected public Lib identity.
- Update only Rustls to 0.23.46 and retain explicit vet review debt.
- Generate the lockfile digest through typed, bounded owning tooling.
- Verify native tests, producer cases, API, lint, docs and supply-chain policy.

Diffstat:
MAGENTS.md | 8++++++--
MCargo.lock | 7+++++--
MCargo.toml | 2+-
MREADME | 14++++++++++++++
Mradroots.lib.source-lock.v1.toml | 2+-
Mrust-toolchain.toml | 2+-
Mscripts/verify-boundaries.sh | 1+
Msupply-chain/config.toml | 2+-
Mtools/xtask/Cargo.toml | 5++++-
Mtools/xtask/src/main.rs | 9+++++++++
Atools/xtask/src/source_lock.rs | 279+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11 files changed, 322 insertions(+), 9 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md @@ -49,8 +49,12 @@ service state, fallback path searches, compatibility aliases, deprecated APIs or re-exports, dual wire encodings, or old/new behavior switches. Update affected callers directly. -- Use Rust `1.97.1`, edition `2024`, and resolver `3` as declared by the - repository. Use dependency versions and feature choices from `Cargo.toml`. +- Use exact stable Rust and MSRV `1.99.0`, edition `2024`, and resolver `3`. + Keep current package minimums, the stable selector and Cargo metadata aligned. + Preserve original compiler identities in frozen execution history and the + dedicated nightly API tooling. Compiler minimums alone do not qualify Nix + acquisition or a new release candidate. Use dependency versions and feature + choices from `Cargo.toml`. - Prefer typed models, explicit state transitions, deterministic behavior, narrow side effects, and precise error enums. Avoid hidden production panics. Avoid `unsafe`; if it is strictly necessary, document the invariant diff --git a/Cargo.lock b/Cargo.lock @@ -1775,8 +1775,11 @@ name = "radrootsd_xtask" version = "0.1.0" dependencies = [ "hex", + "serde", "serde_json", "sha2", + "tempfile", + "toml", ] [[package]] @@ -1916,9 +1919,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.23.37" +version = "0.23.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4" +checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf" dependencies = [ "once_cell", "ring", diff --git a/Cargo.toml b/Cargo.toml @@ -3,7 +3,7 @@ name = "radrootsd" version = "0.1.0" edition = "2024" authors = ["Radroots Authors"] -rust-version = "1.97.1" +rust-version = "1.99.0" license = "AGPL-3.0-or-later" description = "Radroots local runtime daemon for storage, sync, and relay publishing" diff --git a/README b/README @@ -32,6 +32,20 @@ rejects forbidden repository roots or credential material. The supply-chain command checks the locked dependency, license, advisory, and immutable public-source policy. +After an intentional dependency-lock update, refresh its digest through the +private owning tool, then check freshness (route these commands through +extbuild in an enabled checkout): + +```text +cargo run --locked --offline -p radrootsd_xtask -- source-lock refresh +cargo run --locked --offline -p radrootsd_xtask -- source-lock check +``` + +The producer verifies the existing typed source-lock schema and actual offline +public dependency graph before atomically replacing only the lockfile digest. +It preserves the selected Lib revision, archive, catalog and version identity; +it does not qualify a new Lib source archive or a release artifact. + The standalone flake exposes exactly one real `radrootsd` package, check, and application for `aarch64-darwin` and `x86_64-linux`. It exposes no checkout wrapper, development shell, NixOS module, OCI artifact, or other system. diff --git a/radroots.lib.source-lock.v1.toml b/radroots.lib.source-lock.v1.toml @@ -6,4 +6,4 @@ workspace_catalog_sha256 = "deca0c080deae187ff8186c0708903e42f41ea57f77c5f91581e version = "0.1.0-alpha" source_archive_sha256 = "2da62bd0112d43b634ba5e87dfc09d048f7ea1836ab89d2fd18fcfce5186ad6b" lockfile = "Cargo.lock" -lockfile_sha256 = "b9278c33ad53b93e02b68017e5f8b62616feac9c6779747f1d446fe69c642052" +lockfile_sha256 = "7b3b077f33a06a945c51975518c2cfaaca8d7c7a6451d3d30f6583b65919d011" diff --git a/rust-toolchain.toml b/rust-toolchain.toml @@ -1,2 +1,2 @@ [toolchain] -channel = "1.97.1" +channel = "1.99.0" diff --git a/scripts/verify-boundaries.sh b/scripts/verify-boundaries.sh @@ -4,6 +4,7 @@ set -euo pipefail repo_root="$(git rev-parse --show-toplevel)" cd "$repo_root" +cargo run --locked --offline -p radrootsd_xtask -- source-lock check cargo test --locked --offline --test source_lock for forbidden_root in docs .github .act; do diff --git a/supply-chain/config.toml b/supply-chain/config.toml @@ -737,7 +737,7 @@ version = "1.1.4" criteria = "safe-to-deploy" [[exemptions.rustls]] -version = "0.23.37" +version = "0.23.46" criteria = "safe-to-deploy" [[exemptions.rustls-pki-types]] diff --git a/tools/xtask/Cargo.toml b/tools/xtask/Cargo.toml @@ -2,10 +2,13 @@ name = "radrootsd_xtask" version = "0.1.0" edition = "2024" -rust-version = "1.97.1" +rust-version = "1.99.0" publish = false [dependencies] hex = "0.4" +serde = { version = "1", features = ["derive"] } serde_json = "1" sha2 = "0.10" +tempfile = "3" +toml = "0.9" diff --git a/tools/xtask/src/main.rs b/tools/xtask/src/main.rs @@ -2,8 +2,17 @@ mod rshr_202_step_303_gate; mod rshr_202_step_303_platform; +mod source_lock; fn main() { + if std::env::args().nth(1).as_deref() == Some("source-lock") { + let arguments = std::env::args().skip(2).collect::<Vec<_>>(); + if source_lock::run(&arguments).is_err() { + eprintln!("source_lock_failed"); + std::process::exit(1); + } + return; + } if run().is_err() { eprintln!("step_303_gate_failed"); std::process::exit(1); diff --git a/tools/xtask/src/source_lock.rs b/tools/xtask/src/source_lock.rs @@ -0,0 +1,279 @@ +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use sha2::{Digest, Sha256}; +use std::{fs, io::Write, path::Path, process::Command}; + +const LOCK: &str = "radroots.lib.source-lock.v1.toml"; + +#[derive(Debug, PartialEq)] +pub(super) enum Error { + Input, + Graph, + Stale, + Io, +} + +#[derive(Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct SourceLock { + schema: String, + repository: String, + revision: String, + architecture: String, + workspace_catalog_sha256: String, + version: String, + source_archive_sha256: String, + lockfile: String, + lockfile_sha256: String, +} + +pub(super) fn run(arguments: &[String]) -> Result<(), Error> { + let [action] = arguments else { + return Err(Error::Input); + }; + if !matches!(action.as_str(), "check" | "refresh") { + return Err(Error::Input); + } + let root = Path::new(env!("CARGO_MANIFEST_DIR")) + .parent() + .and_then(Path::parent) + .ok_or(Error::Input)?; + let source = read_bounded(&root.join(LOCK), 16 * 1024)?; + let cargo_lock = read_bounded(&root.join("Cargo.lock"), 32 * 1024 * 1024)?; + let output = Command::new("cargo") + .args(["metadata", "--locked", "--offline", "--format-version", "1"]) + .current_dir(root) + .output() + .map_err(|_| Error::Io)?; + if !output.status.success() || output.stdout.len() > 16 * 1024 * 1024 { + return Err(Error::Graph); + } + let metadata = serde_json::from_slice(&output.stdout).map_err(|_| Error::Graph)?; + let refreshed = render(&source, &cargo_lock, &metadata)?; + if action == "check" { + let original: SourceLock = + toml::from_str(std::str::from_utf8(&source).map_err(|_| Error::Input)?) + .map_err(|_| Error::Input)?; + if original.lockfile_sha256 != digest(&cargo_lock) { + return Err(Error::Stale); + } + println!("source lock current"); + return Ok(()); + } + let mut temporary = tempfile::NamedTempFile::new_in(root).map_err(|_| Error::Io)?; + temporary + .write_all(refreshed.as_bytes()) + .map_err(|_| Error::Io)?; + temporary.as_file().sync_all().map_err(|_| Error::Io)?; + if read_bounded(&root.join(LOCK), 16 * 1024)? != source + || read_bounded(&root.join("Cargo.lock"), 32 * 1024 * 1024)? != cargo_lock + { + return Err(Error::Stale); + } + let permissions = fs::metadata(root.join(LOCK)) + .map_err(|_| Error::Io)? + .permissions(); + temporary + .as_file() + .set_permissions(permissions) + .map_err(|_| Error::Io)?; + temporary.persist(root.join(LOCK)).map_err(|_| Error::Io)?; + println!("source lock refreshed"); + Ok(()) +} + +fn read_bounded(path: &Path, limit: u64) -> Result<Vec<u8>, Error> { + let metadata = fs::symlink_metadata(path).map_err(|_| Error::Io)?; + if !metadata.is_file() || metadata.len() > limit { + return Err(Error::Input); + } + let bytes = fs::read(path).map_err(|_| Error::Io)?; + if bytes.len() as u64 > limit { + return Err(Error::Input); + } + Ok(bytes) +} + +fn digest(bytes: &[u8]) -> String { + format!("{:x}", Sha256::digest(bytes)) +} + +fn render(source: &[u8], cargo_lock: &[u8], metadata: &Value) -> Result<String, Error> { + let mut lock: SourceLock = + toml::from_str(std::str::from_utf8(source).map_err(|_| Error::Input)?) + .map_err(|_| Error::Input)?; + if lock.schema != "radroots.lib.source-lock.v1" + || lock.repository != "https://github.com/radrootslabs/lib" + || lock.architecture != "radroots.crates.release.v2" + || lock.lockfile != "Cargo.lock" + || lock.version != "0.1.0-alpha" + { + return Err(Error::Input); + } + for (value, length) in [ + (&lock.revision, 40), + (&lock.workspace_catalog_sha256, 64), + (&lock.source_archive_sha256, 64), + (&lock.lockfile_sha256, 64), + ] { + if value.len() != length + || !value + .bytes() + .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) + { + return Err(Error::Input); + } + } + let source = format!( + "git+https://github.com/radrootslabs/lib.git?rev={}", + lock.revision + ); + let resolved = format!("{source}#{}", lock.revision); + let packages = metadata["packages"].as_array().ok_or(Error::Graph)?; + let daemon = packages + .iter() + .find(|package| package["name"] == "radrootsd") + .ok_or(Error::Graph)?; + let dependencies = daemon["dependencies"].as_array().ok_or(Error::Graph)?; + let mut direct = 0; + for dependency in dependencies { + let name = dependency["name"].as_str().ok_or(Error::Graph)?; + if name.starts_with("radroots_") { + if dependency["source"] != source + || dependency["req"] != format!("={}", lock.version) + || !dependency["rename"].is_null() + { + return Err(Error::Graph); + } + direct += 1; + } + } + let mut shared = 0; + for package in packages { + let name = package["name"].as_str().ok_or(Error::Graph)?; + if name == "radroots" || name.starts_with("radroots_") { + if package["source"] != resolved || package["version"] != lock.version { + return Err(Error::Graph); + } + shared += 1; + } + } + if direct == 0 || shared == 0 { + return Err(Error::Graph); + } + lock.lockfile_sha256 = digest(cargo_lock); + toml::to_string(&lock).map_err(|_| Error::Input) +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + fn fixture() -> (Vec<u8>, Value) { + let source = include_bytes!("../../../radroots.lib.source-lock.v1.toml").to_vec(); + let lock: SourceLock = + toml::from_str(std::str::from_utf8(&source).expect("UTF8")).expect("source lock"); + let git_source = format!( + "git+https://github.com/radrootslabs/lib.git?rev={}", + lock.revision + ); + let metadata = json!({"packages": [ + {"name": "radrootsd", "dependencies": [{"name": "radroots_protocol", "source": git_source, + "req": "=0.1.0-alpha", "rename": null}]}, + {"name": "radroots_protocol", "source": format!("{git_source}#{}", lock.revision), + "version": "0.1.0-alpha"} + ]}); + (source, metadata) + } + + #[test] + fn refresh_changes_only_actual_lock_digest_and_is_idempotent() { + let (source, metadata) = fixture(); + let before: toml::Value = + toml::from_str(std::str::from_utf8(&source).expect("UTF8")).expect("before"); + let refreshed = render(&source, b"new locked graph", &metadata).expect("refresh"); + let mut after: toml::Value = toml::from_str(&refreshed).expect("after"); + assert_eq!( + after["lockfile_sha256"].as_str(), + Some(digest(b"new locked graph").as_str()) + ); + after["lockfile_sha256"] = before["lockfile_sha256"].clone(); + assert_eq!(before, after); + assert_eq!( + render(refreshed.as_bytes(), b"new locked graph", &metadata).expect("replay"), + refreshed + ); + } + + #[test] + fn duplicate_unknown_and_malformed_authority_is_rejected() { + let (source, metadata) = fixture(); + for suffix in [ + "\nrevision = \"duplicate\"\n", + "\nunknown = true\n", + "\ninvalid = [", + ] { + let mut changed = source.clone(); + changed.extend_from_slice(suffix.as_bytes()); + assert_eq!(render(&changed, b"graph", &metadata), Err(Error::Input)); + } + let changed = String::from_utf8(source) + .expect("UTF8") + .replace("lockfile = \"Cargo.lock\"", "lockfile = \"../Cargo.lock\""); + assert_eq!( + render(changed.as_bytes(), b"graph", &metadata), + Err(Error::Input) + ); + } + + #[test] + fn direct_and_resolved_source_pin_version_or_alias_drift_is_rejected() { + let (source, metadata) = fixture(); + for (field, value) in [ + ("source", Value::Null), + ("req", json!("^0.1")), + ("rename", json!("alias")), + ] { + let mut changed = metadata.clone(); + changed["packages"][0]["dependencies"][0][field] = value; + assert_eq!(render(&source, b"graph", &changed), Err(Error::Graph)); + } + for (field, value) in [("source", Value::Null), ("version", json!("0.2.0"))] { + let mut changed = metadata.clone(); + changed["packages"][1][field] = value; + assert_eq!(render(&source, b"graph", &changed), Err(Error::Graph)); + } + assert_eq!( + render(&source, b"graph", &json!({"packages": []})), + Err(Error::Graph) + ); + } + + #[test] + fn oversized_or_non_regular_inputs_are_rejected() { + let directory = tempfile::tempdir().expect("directory"); + let file = directory.path().join("input"); + fs::write(&file, b"12345").expect("input"); + assert_eq!(read_bounded(&file, 5).expect("bounded file"), b"12345"); + assert_eq!(read_bounded(&file, 4), Err(Error::Input)); + assert_eq!(read_bounded(directory.path(), 1024), Err(Error::Input)); + #[cfg(unix)] + { + let link = directory.path().join("link"); + std::os::unix::fs::symlink(&file, &link).expect("symlink"); + assert_eq!(read_bounded(&link, 5), Err(Error::Input)); + } + } + + #[test] + fn unsupported_commands_fail_before_graph_or_file_access() { + for arguments in [ + vec![], + vec!["write".to_owned()], + vec!["refresh".to_owned(), "extra".to_owned()], + ] { + assert_eq!(run(&arguments), Err(Error::Input)); + } + } +}