Merge branch 'codex/signed-clock'
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 01:52:43 +01:00
9 changed files with 1379 additions and 69 deletions
+139 -23
View File
@@ -80,10 +80,13 @@ impl Continuity {
"TIME_NATIVE_CONFIGURATION_GENERATION"
);
if let Some((current, hash)) = &self.configuration {
ensure!(
generation >= *current && (generation != *current || hash == sha256),
"TIME_NATIVE_CONFIGURATION_ROLLBACK_OR_FORK"
);
if generation < *current || (generation == *current && hash != sha256) {
// A constructor has positively observed a protected rollback
// or fork. Reject it without adopting its head, and retain the
// process-wide failure even if the original bytes are restored.
self.invalidate();
anyhow::bail!("TIME_NATIVE_CONFIGURATION_ROLLBACK_OR_FORK");
}
if generation > *current {
self.invalidate();
}
@@ -131,6 +134,13 @@ impl Continuity {
);
Ok(())
}
fn require_epoch(&self, epoch: u64) -> Result<()> {
ensure!(
!self.exhausted && self.epoch == epoch,
"TIME_NATIVE_EVIDENCE_INVALIDATED"
);
Ok(())
}
}
/// All three native clocks are read in one bracket. The qualified base error
@@ -396,7 +406,8 @@ mod installed {
use rmm_agent_core::auth::Binding;
use rmm_domain::jobs::hash;
use rmm_time_attestation::{
Challenge, Context, Interval, Pins, Request, Role, SignedAttestation, Verifier,
Challenge, Context, Interval, Pins, Request, Role, SignedAttestation, VerifiedEvidence,
Verifier,
};
use serde::{Deserialize, Serialize};
use std::{
@@ -467,6 +478,10 @@ mod installed {
epoch: u64,
challenge: Challenge,
}
struct HeldEvidence {
evidence: VerifiedEvidence,
epoch: u64,
}
/// Own-process role proof, protected held configuration, private challenge
/// and native timers. No constructor accepts agent-reported helper times.
pub struct SignedClock {
@@ -478,6 +493,7 @@ mod installed {
connection_generation: u64,
base_error_ns: u64,
pending: Option<Pending>,
latest: Option<HeldEvidence>,
}
impl SignedClock {
/// Connection generation is later confirmed by the independently
@@ -602,6 +618,7 @@ mod installed {
connection_generation,
base_error_ns,
pending: None,
latest: None,
};
value.recheck()?;
process()
@@ -612,16 +629,34 @@ mod installed {
Ok(value)
}
fn recheck(&mut self) -> Result<()> {
self.own_process.check()?;
for file in &mut self.files {
file.check()?;
let result = (|| {
self.own_process.check()?;
for file in &mut self.files {
file.check()?;
}
let config = self.files.last_mut().context("TIME_NATIVE_CONFIG_HELD")?;
ensure!(
config.sha256()? == self.config_sha256,
"TIME_NATIVE_CONFIG_CHANGED"
);
Ok(())
})();
if result.is_err() {
self.invalidate_observed_context();
}
result
}
fn invalidate_observed_context(&mut self) {
self.latest = None;
self.pending = None;
self.verifier.invalidate();
// A positively observed protected-context failure is shared by
// every object in this process, even if this object owns no nonce.
// Restoring old bytes must not revive any older same-generation
// evidence. Poisoned state already refuses all future access.
if let Ok(mut state) = process().lock() {
state.invalidate();
}
let config = self.files.last_mut().context("TIME_NATIVE_CONFIG_HELD")?;
ensure!(
config.sha256()? == self.config_sha256,
"TIME_NATIVE_CONFIG_CHANGED"
);
Ok(())
}
pub fn begin(&mut self, connection_generation: u64) -> Result<Request> {
if connection_generation != self.connection_generation {
@@ -675,9 +710,9 @@ mod installed {
let signed: SignedAttestation = serde_json::from_slice(bytes)?;
self.recheck()?;
let mut checked = None;
let interval =
let (evidence, interval) =
self.verifier
.finish(pending.challenge, &signed, received, || {
.finish_evidence(pending.challenge, &signed, received, || {
let (sample, epoch) = observed(self.boot_id, self.base_error_ns)?;
ensure!(epoch == pending.epoch, "TIME_NATIVE_CHALLENGE_INVALIDATED");
checked = Some(sample);
@@ -688,6 +723,10 @@ mod installed {
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
state.require_owner(pending.owner, pending.epoch)?;
state.active = None;
self.latest = Some(HeldEvidence {
evidence,
epoch: pending.epoch,
});
let comparison = Comparison {
interval,
wall_utc_ns: checked.context("TIME_NATIVE_FINAL_SAMPLE")?.wall_utc_ns,
@@ -696,6 +735,7 @@ mod installed {
consume(&comparison)
})();
if result.is_err() {
self.latest = None;
self.verifier.invalidate();
if let Ok(mut state) = process().lock()
&& state.active == Some(pending.owner)
@@ -705,13 +745,64 @@ mod installed {
}
result
}
/// No IO/IPC callback, reply, caller timestamp or ready flag is needed
/// for reads. Only a freshly recaptured own wall observation, bounded
/// by the original finite evidence, is exposed inside this callback.
pub fn with_current_comparison<T>(
&mut self,
consume: impl FnOnce(&Comparison) -> Result<T>,
) -> Result<T> {
// A first/next refresh may be pending. Absence/ordinary expiry of
// the old evidence must not consume that independent new nonce.
let epoch = self
.latest
.as_ref()
.context("TIME_NATIVE_NO_EVIDENCE")?
.epoch;
let checked = (|| {
self.recheck()?;
let (sample, current_epoch) = observed(self.boot_id, self.base_error_ns)?;
ensure!(epoch == current_epoch, "TIME_NATIVE_EVIDENCE_INVALIDATED");
let state = process()
.lock()
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
state.require_epoch(epoch)?;
state.require_connection(self.connection_generation)?;
Ok(sample)
})();
let checked = match checked {
Ok(value) => value,
Err(error) => {
self.close();
return Err(error);
}
};
let evidence = &self
.latest
.as_ref()
.context("TIME_NATIVE_NO_EVIDENCE")?
.evidence;
let interval = match self.verifier.check_evidence(evidence, checked) {
Ok(value) => value,
Err(error) => {
self.latest = None;
return Err(error);
}
};
consume(&Comparison {
interval,
wall_utc_ns: checked.wall_utc_ns,
})
}
pub fn close(&mut self) {
self.verifier.invalidate();
if let Some(pending) = self.pending.take()
&& let Ok(mut state) = process().lock()
&& state.active == Some(pending.owner)
{
state.invalidate();
let evidence_epoch = self.latest.take().map(|value| value.epoch);
let pending = self.pending.take();
if let Ok(mut state) = process().lock() {
let owns_pending = pending.is_some_and(|value| state.active == Some(value.owner));
if owns_pending || evidence_epoch == Some(state.epoch) {
state.invalidate();
}
}
}
}
@@ -721,7 +812,7 @@ mod installed {
}
}
/// Borrowed only inside the completion callback, never returned as a
/// Borrowed only inside a completion/current-comparison callback, never returned as a
/// storable clock/lease/permit. Runtime callers must retain all job gates.
pub struct Comparison {
interval: Interval,
@@ -836,25 +927,49 @@ mod tests {
let mut state = Continuity::default();
state.accept_configuration(4, "one-config").unwrap();
state.accept_connection(3).unwrap();
let before_rollback = state.epoch;
assert!(state.accept_configuration(3, "old-config").is_err());
assert!(state.accept_configuration(4, "different-config").is_err());
assert!(state.require_epoch(before_rollback).is_err());
assert_eq!(state.configuration, Some((4, "one-config".into())));
state.accept_configuration(4, "one-config").unwrap();
let before_fork = state.epoch;
assert!(state.accept_configuration(4, "different-config").is_err());
assert!(state.require_epoch(before_fork).is_err());
assert_eq!(state.configuration, Some((4, "one-config".into())));
state.accept_configuration(4, "one-config").unwrap();
assert!(state.require_epoch(before_rollback).is_err());
assert!(state.require_epoch(before_fork).is_err());
state.observe(boot, sample(0)).unwrap();
let first_clock_evidence = state.epoch;
let other_clock_evidence = state.epoch;
// recheck's observed-context failure fences the entire process even
// when no object currently owns a pending nonce. Same-generation
// restoration does not erase the observed failure or heal old proof.
state.invalidate();
state.accept_configuration(4, "one-config").unwrap();
assert!(state.require_epoch(first_clock_evidence).is_err());
assert!(state.require_epoch(other_clock_evidence).is_err());
let original_epoch = state.reserve(owner).unwrap();
assert!(original_epoch > first_clock_evidence);
// An outstanding refresh owns a nonce, not the older finite evidence.
state.require_epoch(original_epoch).unwrap();
assert!(state.reserve(Uuid::new_v4()).is_err());
let mut resumed = sample(2_000_000_000);
resumed.unbiased_ns = 9_000_000_000;
assert!(state.observe(boot, resumed).is_err());
assert!(state.require_owner(owner, original_epoch).is_err());
assert!(state.require_epoch(original_epoch).is_err());
// A caller reconstructing its verifier still sees this retained state.
state.observe(boot, resumed).unwrap();
let next = Uuid::new_v4();
let epoch = state.reserve(next).unwrap();
assert!(epoch > original_epoch);
state.require_owner(next, epoch).unwrap();
state.require_epoch(epoch).unwrap();
state.accept_connection(4).unwrap();
assert!(state.require_owner(next, epoch).is_err());
assert!(state.require_epoch(epoch).is_err());
assert!(state.require_connection(3).is_err());
assert!(state.accept_connection(3).is_err());
state.require_connection(4).unwrap();
@@ -863,6 +978,7 @@ mod tests {
state.epoch = u64::MAX;
state.invalidate();
assert!(state.exhausted);
assert!(state.require_epoch(state.epoch).is_err());
state.invalidate();
assert!(state.exhausted);
assert!(state.reserve(Uuid::new_v4()).is_err());
+125 -4
View File
@@ -218,6 +218,17 @@ impl Challenge {
&self.request
}
}
/// One verified response held only by its original verifier. Neither a lease
/// nor a transferable clock/permit: every use needs a fresh own observation.
/// There is no public constructor, Clone, serialization, or timestamp getter.
pub struct VerifiedEvidence {
payload: Payload,
begin: Sample,
received: Sample,
epoch: u64,
verifier_id: Uuid,
context: Context,
}
/// Lives with the verifier process; callers must not reconstruct it to clear a
/// discontinuity. Native adapters additionally preserve the process-wide fence.
pub struct Verifier {
@@ -301,6 +312,18 @@ impl Verifier {
received: Sample,
capture_checked: impl FnOnce() -> Result<Sample>,
) -> Result<Interval> {
// Preserve the original completion API and its exact final native
// capture; no second signature verification or invented current time.
let (_, interval) = self.finish_evidence(challenge, signed, received, capture_checked)?;
Ok(interval)
}
pub fn finish_evidence(
&mut self,
challenge: Challenge,
signed: &SignedAttestation,
received: Sample,
capture_checked: impl FnOnce() -> Result<Sample>,
) -> Result<(VerifiedEvidence, Interval)> {
let owned = challenge.verifier_id == self.verifier_id
&& self.pending_nonce.as_deref() == Some(challenge.request.nonce.as_str())
&& challenge.epoch == self.epoch
@@ -333,23 +356,54 @@ impl Verifier {
key.verify_strict(&message, &signature)?;
let checked = capture_checked()?;
self.observe(checked)?;
let evidence = VerifiedEvidence {
payload: p,
begin: challenge.begin,
received,
epoch: challenge.epoch,
verifier_id: challenge.verifier_id,
context: challenge.request.context,
};
let interval = self.evidence_interval(&evidence, checked)?;
Ok((evidence, interval))
}
/// Re-evaluate the original finite evidence with a fresh observation from
/// this verifier's native adapter. Pending refresh challenges do not alter
/// evidence authority; invalidation/expiry never renews its original time.
pub fn check_evidence(
&mut self,
evidence: &VerifiedEvidence,
current: Sample,
) -> Result<Interval> {
ensure!(
self.epoch > 0
&& evidence.verifier_id == self.verifier_id
&& evidence.epoch == self.epoch
&& evidence.context == self.context,
"TIME_EVIDENCE_NOT_OWNED"
);
self.observe(current)?;
self.evidence_interval(evidence, current)
}
fn evidence_interval(&self, evidence: &VerifiedEvidence, checked: Sample) -> Result<Interval> {
let p = &evidence.payload;
let elapsed = checked
.interrupt_ns
.checked_sub(challenge.begin.interrupt_ns)
.checked_sub(evidence.begin.interrupt_ns)
.ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?;
let age = checked
.interrupt_ns
.checked_sub(received.interrupt_ns)
.checked_sub(evidence.received.interrupt_ns)
.ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?;
ensure!(
elapsed <= MAX_RTT_NS && age <= MAX_RECEIVED_AGE_NS,
"TIME_STALE_RESPONSE"
);
// Include every local capture budget conservatively, never RTT/2.
let delta = challenge
let delta = evidence
.begin
.capture_error_ns
.checked_add(received.capture_error_ns)
.checked_add(evidence.received.capture_error_ns)
.and_then(|d| d.checked_add(checked.capture_error_ns))
.ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?;
ensure!(delta <= MAX_CAPTURE_ERROR_NS, "TIME_CAPTURE_BUDGET");
@@ -552,4 +606,71 @@ mod tests {
let signed = sign(&p, &key).unwrap();
assert!(v.finish(c, &signed, resumed, || Ok(resumed)).is_ok());
}
#[test]
fn held_evidence_expires_without_renewal_and_preserves_pending_refresh() {
let (mut v, key, server) = fixture(context(Role::SystemHelper));
let c = v.begin(sample(0)).unwrap();
let mut signed = reply(&c, &key, server);
let (evidence, initial) = v
.finish_evidence(c, &signed, sample(70_000_000), || Ok(sample(80_000_000)))
.unwrap();
// Evidence owns verified facts, not an aliased response or a stored
// signature to parse/verify again at each subsequent clock read.
signed.payload.clear();
signed.signature_hex.clear();
let next = v.begin(sample(100_000_000)).unwrap();
let next_reply = reply(&next, &key, server);
let later = v.check_evidence(&evidence, sample(110_000_000)).unwrap();
assert!(later.upper_utc_ns() > initial.upper_utc_ns());
assert!(v.check_evidence(&evidence, sample(170_000_000)).is_ok());
assert!(v.check_evidence(&evidence, sample(171_000_000)).is_err());
assert_eq!(
v.pending_nonce.as_deref(),
Some(next.request().nonce.as_str())
);
let (fresh, _) = v
.finish_evidence(next, &next_reply, sample(180_000_000), || {
Ok(sample(190_000_000))
})
.unwrap();
assert!(v.check_evidence(&fresh, sample(200_000_000)).is_ok());
assert!(v.check_evidence(&evidence, sample(201_000_000)).is_err());
// The one-second bound starts at the original challenge, even when
// the complete response itself was received less than100ms ago.
let c = v.begin(sample(300_000_000)).unwrap();
let signed = reply(&c, &key, server);
let (evidence, _) = v
.finish_evidence(c, &signed, sample(1_240_000_000), || {
Ok(sample(1_250_000_000))
})
.unwrap();
assert!(v.check_evidence(&evidence, sample(1_300_000_000)).is_ok());
assert!(v.check_evidence(&evidence, sample(1_300_000_001)).is_err());
}
#[test]
fn held_evidence_cannot_cross_verifier_epoch_or_discontinuity() {
let ctx = context(Role::Agent);
let (mut a, key, server) = fixture(ctx.clone());
let c = a.begin(sample(0)).unwrap();
let signed = reply(&c, &key, server);
let (evidence, _) = a
.finish_evidence(c, &signed, sample(70_000_000), || Ok(sample(80_000_000)))
.unwrap();
let (mut other, _, _) = fixture(ctx);
assert!(other.check_evidence(&evidence, sample(90_000_000)).is_err());
assert!(a.check_evidence(&evidence, sample(90_000_000)).is_ok());
a.invalidate();
assert!(a.check_evidence(&evidence, sample(100_000_000)).is_err());
let c = a.begin(sample(110_000_000)).unwrap();
let signed = reply(&c, &key, server);
let (evidence, _) = a
.finish_evidence(c, &signed, sample(120_000_000), || Ok(sample(130_000_000)))
.unwrap();
let mut backwards = sample(140_000_000);
backwards.unbiased_ns = 1;
assert!(a.check_evidence(&evidence, backwards).is_err());
assert!(a.check_evidence(&evidence, sample(150_000_000)).is_err());
}
}