Fence restored Windows clock contexts with real Linux evidence
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -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());
|
||||
|
||||
Reference in New Issue
Block a user