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:
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));
+ }
+ }
+}