Add protected Windows time verifier with Linux-first guard evidence
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -0,0 +1,623 @@
|
||||
//! Independent signed time comparison for the Windows agent and SYSTEM helper.
|
||||
//! This module does not implement SyncClock, advertise a capability, start a job,
|
||||
//! change W32Time or replace the still-closed legacy NativeClock adapter.
|
||||
#![cfg(any(test, all(windows, feature = "system-helper")))]
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_time_attestation::Sample;
|
||||
use uuid::Uuid;
|
||||
|
||||
const SECOND_NS: u64 = 1_000_000_000;
|
||||
const MAX_BASE_ERROR_NS: u64 = 10_000_000;
|
||||
|
||||
fn independent_time_key(time_key_hex: &str, job_key_hex: &str) -> Result<[u8; 32]> {
|
||||
fn decode(value: &str) -> Result<[u8; 32]> {
|
||||
ensure!(
|
||||
value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit()),
|
||||
"TIME_NATIVE_PUBLIC_KEY"
|
||||
);
|
||||
let mut raw = [0u8; 32];
|
||||
for (index, byte) in raw.iter_mut().enumerate() {
|
||||
*byte = u8::from_str_radix(&value[index * 2..index * 2 + 2], 16)?;
|
||||
}
|
||||
Ok(raw)
|
||||
}
|
||||
let time = decode(time_key_hex)?;
|
||||
let job = decode(job_key_hex)?;
|
||||
ensure!(time != job, "TIME_NATIVE_KEY_ROLE_REUSE");
|
||||
Ok(time)
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Continuity {
|
||||
boot_id: Option<Uuid>,
|
||||
previous: Option<Sample>,
|
||||
epoch: u64,
|
||||
exhausted: bool,
|
||||
active: Option<Uuid>,
|
||||
configuration: Option<(u64, String)>,
|
||||
connection_generation: Option<u64>,
|
||||
}
|
||||
impl Continuity {
|
||||
fn invalidate(&mut self) {
|
||||
self.active = None;
|
||||
match self.epoch.checked_add(1) {
|
||||
Some(epoch) if !self.exhausted => self.epoch = epoch,
|
||||
_ => self.exhausted = true,
|
||||
}
|
||||
}
|
||||
fn observe(&mut self, boot_id: Uuid, sample: Sample) -> Result<()> {
|
||||
let valid = !boot_id.is_nil()
|
||||
&& !self.exhausted
|
||||
&& self.boot_id.is_none_or(|old| old == boot_id)
|
||||
&& sample.wall_utc_ns > 0
|
||||
&& sample.capture_error_ns <= rmm_time_attestation::MAX_CAPTURE_ERROR_NS
|
||||
&& self.previous.is_none_or(|old| {
|
||||
match (
|
||||
sample.wall_utc_ns.checked_sub(old.wall_utc_ns),
|
||||
sample.interrupt_ns.checked_sub(old.interrupt_ns),
|
||||
sample.unbiased_ns.checked_sub(old.unbiased_ns),
|
||||
) {
|
||||
(Some(wall), Some(interrupt), Some(unbiased)) if wall >= 0 => {
|
||||
(wall as u64).abs_diff(interrupt) <= SECOND_NS
|
||||
&& interrupt.abs_diff(unbiased) <= SECOND_NS
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
});
|
||||
// Never adopt a different boot in a surviving process. A new adapter
|
||||
// object cannot erase this process-wide identity/continuity history.
|
||||
self.boot_id.get_or_insert(boot_id);
|
||||
self.previous = Some(sample);
|
||||
if !valid {
|
||||
self.invalidate();
|
||||
}
|
||||
ensure!(valid, "TIME_NATIVE_DISCONTINUITY_OR_BOOT");
|
||||
Ok(())
|
||||
}
|
||||
fn accept_configuration(&mut self, generation: u64, sha256: &str) -> Result<()> {
|
||||
ensure!(
|
||||
generation > 0 && !self.exhausted,
|
||||
"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 {
|
||||
self.invalidate();
|
||||
}
|
||||
}
|
||||
self.configuration = Some((generation, sha256.into()));
|
||||
Ok(())
|
||||
}
|
||||
fn accept_connection(&mut self, generation: u64) -> Result<()> {
|
||||
ensure!(
|
||||
generation > 0
|
||||
&& !self.exhausted
|
||||
&& self
|
||||
.connection_generation
|
||||
.is_none_or(|old| generation >= old),
|
||||
"TIME_NATIVE_CONNECTION_ROLLBACK"
|
||||
);
|
||||
if self
|
||||
.connection_generation
|
||||
.is_some_and(|old| generation > old)
|
||||
{
|
||||
self.invalidate();
|
||||
}
|
||||
self.connection_generation = Some(generation);
|
||||
Ok(())
|
||||
}
|
||||
fn require_connection(&self, generation: u64) -> Result<()> {
|
||||
ensure!(
|
||||
!self.exhausted && self.connection_generation == Some(generation),
|
||||
"TIME_NATIVE_CONNECTION_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn reserve(&mut self, owner: Uuid) -> Result<u64> {
|
||||
ensure!(
|
||||
!self.exhausted && !owner.is_nil() && self.active.is_none(),
|
||||
"TIME_NATIVE_CHALLENGE_BUSY"
|
||||
);
|
||||
self.active = Some(owner);
|
||||
Ok(self.epoch)
|
||||
}
|
||||
fn require_owner(&self, owner: Uuid, epoch: u64) -> Result<()> {
|
||||
ensure!(
|
||||
!self.exhausted && self.active == Some(owner) && self.epoch == epoch,
|
||||
"TIME_NATIVE_CHALLENGE_INVALIDATED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// All three native clocks are read in one bracket. The qualified base error
|
||||
/// is a protected installation input, never inferred from 100ns resolution.
|
||||
fn bracket_sample(
|
||||
wall_filetime: u64,
|
||||
interrupt_before: u64,
|
||||
interrupt_after: u64,
|
||||
unbiased_before: u64,
|
||||
unbiased_after: u64,
|
||||
base_error_ns: u64,
|
||||
) -> Result<Sample> {
|
||||
const FILETIME_UNIX: u64 = 116_444_736_000_000_000;
|
||||
ensure!(
|
||||
base_error_ns > 0 && base_error_ns <= MAX_BASE_ERROR_NS,
|
||||
"TIME_NATIVE_CALIBRATION_REQUIRED"
|
||||
);
|
||||
let width = interrupt_after
|
||||
.checked_sub(interrupt_before)
|
||||
.and_then(|value| value.checked_mul(100))
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_COUNTER"))?;
|
||||
let unbiased_width = unbiased_after
|
||||
.checked_sub(unbiased_before)
|
||||
.and_then(|value| value.checked_mul(100))
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_COUNTER"))?;
|
||||
ensure!(
|
||||
width.abs_diff(unbiased_width) <= SECOND_NS,
|
||||
"TIME_NATIVE_CAPTURE_SUSPEND"
|
||||
);
|
||||
let capture_error_ns = width
|
||||
.checked_add(base_error_ns)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_OVERFLOW"))?;
|
||||
ensure!(
|
||||
capture_error_ns <= rmm_time_attestation::MAX_CAPTURE_ERROR_NS,
|
||||
"TIME_NATIVE_CAPTURE_BUDGET"
|
||||
);
|
||||
let wall_utc_ns = wall_filetime
|
||||
.checked_sub(FILETIME_UNIX)
|
||||
.and_then(|value| value.checked_mul(100))
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_WALL_RANGE"))?
|
||||
.try_into()?;
|
||||
Ok(Sample {
|
||||
wall_utc_ns,
|
||||
interrupt_ns: interrupt_after
|
||||
.checked_mul(100)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_COUNTER_RANGE"))?,
|
||||
unbiased_ns: unbiased_after
|
||||
.checked_mul(100)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_COUNTER_RANGE"))?,
|
||||
capture_error_ns,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod installed {
|
||||
use super::*;
|
||||
use crate::helper_ipc::{self as ipc, PeerProof, PinnedFile};
|
||||
use anyhow::Context as _;
|
||||
use rmm_agent_core::auth::Binding;
|
||||
use rmm_domain::jobs::hash;
|
||||
use rmm_time_attestation::{
|
||||
Challenge, Context, Interval, Pins, Request, Role, SignedAttestation, Verifier,
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
collections::BTreeMap,
|
||||
io::Read,
|
||||
path::Path,
|
||||
sync::{Mutex, OnceLock},
|
||||
};
|
||||
|
||||
pub const CONFIG_PATH: &str = r"C:\ProgramData\RustDiscoverySystem\time-attestation.json";
|
||||
const PUBLIC_ROOT: &str = r"C:\ProgramData\RustDiscoverySystem";
|
||||
const MAX_CONFIG_BYTES: usize = 16_384;
|
||||
const MAX_REPLY_BYTES: usize = 16_384;
|
||||
|
||||
/// Provision only after an independent qualification of these actual
|
||||
/// native APIs/platform/image. A file field is not a measured accuracy.
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Calibration {
|
||||
pub role: Role,
|
||||
pub binary_sha256: String,
|
||||
pub qualification_sha256: String,
|
||||
pub base_error_ns: u64,
|
||||
}
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Configuration {
|
||||
pub schema_version: u32,
|
||||
pub key_generation: u64,
|
||||
pub server_instance: Uuid,
|
||||
pub binding: Binding,
|
||||
pub public_keys_hex: BTreeMap<String, String>,
|
||||
pub calibrations: Vec<Calibration>,
|
||||
}
|
||||
fn digest(value: &str) -> bool {
|
||||
value.len() == 64
|
||||
&& value
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
|
||||
}
|
||||
static PROCESS: OnceLock<Mutex<Continuity>> = OnceLock::new();
|
||||
static INCARNATION: OnceLock<Uuid> = OnceLock::new();
|
||||
fn process() -> &'static Mutex<Continuity> {
|
||||
PROCESS.get_or_init(|| Mutex::new(Continuity::default()))
|
||||
}
|
||||
fn capture(base_error_ns: u64) -> Result<Sample> {
|
||||
#[link(name = "kernel32")]
|
||||
unsafe extern "system" {
|
||||
fn GetSystemTimePreciseAsFileTime(value: *mut u64);
|
||||
fn QueryInterruptTimePrecise(value: *mut u64);
|
||||
fn QueryUnbiasedInterruptTimePrecise(value: *mut u64);
|
||||
}
|
||||
let (mut ib, mut ia, mut ub, mut ua, mut wall) = (0, 0, 0, 0, 0);
|
||||
// SAFETY: documented VOID kernel getters with valid aligned u64
|
||||
// outputs. Windows 10+ is required; no optional API fallback exists.
|
||||
unsafe {
|
||||
QueryInterruptTimePrecise(&mut ib);
|
||||
QueryUnbiasedInterruptTimePrecise(&mut ub);
|
||||
GetSystemTimePreciseAsFileTime(&mut wall);
|
||||
QueryUnbiasedInterruptTimePrecise(&mut ua);
|
||||
QueryInterruptTimePrecise(&mut ia);
|
||||
}
|
||||
bracket_sample(wall, ib, ia, ub, ua, base_error_ns)
|
||||
}
|
||||
fn observed(boot: Uuid, base_error_ns: u64) -> Result<(Sample, u64)> {
|
||||
let mut state = process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
|
||||
let value = match capture(base_error_ns) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
state.invalidate();
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
state.observe(boot, value)?;
|
||||
Ok((value, state.epoch))
|
||||
}
|
||||
|
||||
struct Pending {
|
||||
owner: Uuid,
|
||||
epoch: u64,
|
||||
challenge: Challenge,
|
||||
}
|
||||
/// Own-process role proof, protected held configuration, private challenge
|
||||
/// and native timers. No constructor accepts agent-reported helper times.
|
||||
pub struct SignedClock {
|
||||
verifier: Verifier,
|
||||
own_process: PeerProof,
|
||||
files: Vec<PinnedFile>,
|
||||
config_sha256: String,
|
||||
boot_id: Uuid,
|
||||
connection_generation: u64,
|
||||
base_error_ns: u64,
|
||||
pending: Option<Pending>,
|
||||
}
|
||||
impl SignedClock {
|
||||
/// Connection generation is later confirmed by the independently
|
||||
/// signed server response. It is never itself a ready/sync flag.
|
||||
pub async fn open(role: Role, connection_generation: u64) -> Result<Self> {
|
||||
ensure!(connection_generation > 0, "TIME_NATIVE_CONNECTION");
|
||||
let (settings, mut files) = crate::helper_system::read_settings()?;
|
||||
let own_pin = match role {
|
||||
Role::Agent => &settings.agent,
|
||||
Role::SystemHelper => &settings.helper,
|
||||
};
|
||||
own_pin.validate(role == Role::SystemHelper)?;
|
||||
ipc::require_self(own_pin)?;
|
||||
let own_process = PeerProof::for_service(
|
||||
own_pin,
|
||||
// SAFETY: this getter takes no arguments and returns own PID.
|
||||
unsafe { windows_sys::Win32::System::Threading::GetCurrentProcessId() },
|
||||
)?;
|
||||
let readers = vec![
|
||||
settings.agent.service_sid.clone(),
|
||||
settings.helper.service_sid.clone(),
|
||||
];
|
||||
files.push(PinnedFile::open(
|
||||
Path::new(PUBLIC_ROOT),
|
||||
true,
|
||||
&readers,
|
||||
&[],
|
||||
false,
|
||||
)?);
|
||||
let mut config_file =
|
||||
PinnedFile::open(Path::new(CONFIG_PATH), false, &readers, &[], false)?;
|
||||
ensure!(
|
||||
config_file.file.metadata()?.len() <= MAX_CONFIG_BYTES as u64,
|
||||
"TIME_NATIVE_CONFIG_SIZE"
|
||||
);
|
||||
let mut raw = Vec::new();
|
||||
(&mut config_file.file)
|
||||
.take(MAX_CONFIG_BYTES as u64 + 1)
|
||||
.read_to_end(&mut raw)?;
|
||||
ensure!(raw.len() <= MAX_CONFIG_BYTES, "TIME_NATIVE_CONFIG_SIZE");
|
||||
let config: Configuration = serde_json::from_slice(&raw)?;
|
||||
ensure!(
|
||||
config.schema_version == 1
|
||||
&& config.key_generation > 0
|
||||
&& config.calibrations.len() == 2,
|
||||
"TIME_NATIVE_CONFIG_PROFILE"
|
||||
);
|
||||
ensure!(
|
||||
hash(&serde_json::to_vec(&config.binding)?)
|
||||
== hash(&serde_json::to_vec(&settings.binding)?),
|
||||
"TIME_NATIVE_DEVICE_BINDING"
|
||||
);
|
||||
for expected in [Role::Agent, Role::SystemHelper] {
|
||||
let mut values = config
|
||||
.calibrations
|
||||
.iter()
|
||||
.filter(|value| value.role == expected);
|
||||
let value = values.next().context("TIME_NATIVE_CALIBRATION_MISSING")?;
|
||||
ensure!(
|
||||
values.next().is_none()
|
||||
&& digest(&value.binary_sha256)
|
||||
&& digest(&value.qualification_sha256)
|
||||
&& value.base_error_ns > 0
|
||||
&& value.base_error_ns <= MAX_BASE_ERROR_NS,
|
||||
"TIME_NATIVE_CALIBRATION_PROFILE"
|
||||
);
|
||||
let pin = if expected == Role::Agent {
|
||||
&settings.agent
|
||||
} else {
|
||||
&settings.helper
|
||||
};
|
||||
ensure!(
|
||||
value.binary_sha256 == pin.binary_sha256,
|
||||
"TIME_NATIVE_CALIBRATION_IMAGE"
|
||||
);
|
||||
}
|
||||
let base_error_ns = config
|
||||
.calibrations
|
||||
.iter()
|
||||
.find(|value| value.role == role)
|
||||
.context("TIME_NATIVE_CALIBRATION_MISSING")?
|
||||
.base_error_ns;
|
||||
let keys = config
|
||||
.public_keys_hex
|
||||
.iter()
|
||||
.map(|(id, key)| {
|
||||
ensure!(digest(key), "TIME_NATIVE_PUBLIC_KEY");
|
||||
let raw = independent_time_key(key, &settings.binding.public_key_hex)?;
|
||||
Ok((id.clone(), raw))
|
||||
})
|
||||
.collect::<Result<BTreeMap<_, _>>>()?;
|
||||
let pins = Pins::new(config.key_generation, config.server_instance, keys)?;
|
||||
process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?
|
||||
.accept_configuration(config.key_generation, &hash(&raw))?;
|
||||
|
||||
// The existing fixed read-only native getter is independent in
|
||||
// each process. It finishes BEFORE challenge/RTT timing begins.
|
||||
let boot_id = Uuid::parse_str(&crate::native::boot_id().await?)?;
|
||||
let context = Context {
|
||||
tenant_id: settings.binding.tenant_id,
|
||||
asset_id: settings.binding.asset_id,
|
||||
agent_id: settings.binding.agent_id,
|
||||
enrollment_generation: settings.binding.enrollment_generation,
|
||||
assignment_generation: settings.binding.assignment_version,
|
||||
connection_generation,
|
||||
windows_boot_id: boot_id,
|
||||
verifier_incarnation: *INCARNATION.get_or_init(Uuid::new_v4),
|
||||
role,
|
||||
helper_image_sha256: (role == Role::SystemHelper)
|
||||
.then(|| own_pin.binary_sha256.clone()),
|
||||
binding_schema: 1,
|
||||
};
|
||||
files.push(config_file);
|
||||
let mut value = Self {
|
||||
verifier: Verifier::new(context, pins)?,
|
||||
own_process,
|
||||
files,
|
||||
config_sha256: hash(&raw),
|
||||
boot_id,
|
||||
connection_generation,
|
||||
base_error_ns,
|
||||
pending: None,
|
||||
};
|
||||
value.recheck()?;
|
||||
process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?
|
||||
.accept_connection(connection_generation)?;
|
||||
observed(boot_id, base_error_ns)?;
|
||||
Ok(value)
|
||||
}
|
||||
fn recheck(&mut self) -> 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(())
|
||||
}
|
||||
pub fn begin(&mut self, connection_generation: u64) -> Result<Request> {
|
||||
if connection_generation != self.connection_generation {
|
||||
self.close();
|
||||
anyhow::bail!("TIME_NATIVE_CONNECTION_CHANGED");
|
||||
}
|
||||
ensure!(self.pending.is_none(), "TIME_NATIVE_PENDING");
|
||||
self.recheck()?;
|
||||
let mut state = process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
|
||||
state.require_connection(connection_generation)?;
|
||||
let sample = match capture(self.base_error_ns) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
state.invalidate();
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
state.observe(self.boot_id, sample)?;
|
||||
let owner = Uuid::new_v4();
|
||||
let epoch = state.reserve(owner)?;
|
||||
let challenge = match self.verifier.begin(sample) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
state.invalidate();
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let request = challenge.request().clone();
|
||||
self.pending = Some(Pending {
|
||||
owner,
|
||||
epoch,
|
||||
challenge,
|
||||
});
|
||||
Ok(request)
|
||||
}
|
||||
/// Call immediately after this verifier receives the complete bounded
|
||||
/// response. The helper's caller supplies bytes only, never timestamps.
|
||||
/// All failures consume the original request; no transparent retry.
|
||||
pub fn complete<T>(
|
||||
&mut self,
|
||||
bytes: &[u8],
|
||||
consume: impl FnOnce(&Comparison) -> Result<T>,
|
||||
) -> Result<T> {
|
||||
let pending = self.pending.take().context("TIME_NATIVE_NO_CHALLENGE")?;
|
||||
let result = (|| {
|
||||
let (received, epoch) = observed(self.boot_id, self.base_error_ns)?;
|
||||
ensure!(epoch == pending.epoch, "TIME_NATIVE_CHALLENGE_INVALIDATED");
|
||||
ensure!(bytes.len() <= MAX_REPLY_BYTES, "TIME_NATIVE_REPLY_SIZE");
|
||||
let signed: SignedAttestation = serde_json::from_slice(bytes)?;
|
||||
self.recheck()?;
|
||||
let mut checked = None;
|
||||
let interval =
|
||||
self.verifier
|
||||
.finish(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);
|
||||
Ok(sample)
|
||||
})?;
|
||||
let mut state = process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
|
||||
state.require_owner(pending.owner, pending.epoch)?;
|
||||
state.active = None;
|
||||
let comparison = Comparison {
|
||||
interval,
|
||||
wall_utc_ns: checked.context("TIME_NATIVE_FINAL_SAMPLE")?.wall_utc_ns,
|
||||
};
|
||||
drop(state);
|
||||
consume(&comparison)
|
||||
})();
|
||||
if result.is_err() {
|
||||
self.verifier.invalidate();
|
||||
if let Ok(mut state) = process().lock()
|
||||
&& state.active == Some(pending.owner)
|
||||
{
|
||||
state.invalidate();
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Drop for SignedClock {
|
||||
fn drop(&mut self) {
|
||||
self.close();
|
||||
}
|
||||
}
|
||||
|
||||
/// Borrowed only inside the completion callback, never returned as a
|
||||
/// storable clock/lease/permit. Runtime callers must retain all job gates.
|
||||
pub struct Comparison {
|
||||
interval: Interval,
|
||||
wall_utc_ns: i64,
|
||||
}
|
||||
impl Comparison {
|
||||
pub fn interval(&self) -> &Interval {
|
||||
&self.interval
|
||||
}
|
||||
pub fn wall_utc_ns(&self) -> i64 {
|
||||
self.wall_utc_ns
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
pub use installed::{CONFIG_PATH, Calibration, Comparison, Configuration, SignedClock};
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
fn sample(ns: u64) -> Sample {
|
||||
Sample {
|
||||
wall_utc_ns: 1_800_000_000_000_000_000 + ns as i64,
|
||||
interrupt_ns: 10_000_000_000 + ns,
|
||||
unbiased_ns: 9_000_000_000 + ns,
|
||||
capture_error_ns: 1_000_000,
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case() {
|
||||
assert_eq!(
|
||||
independent_time_key(&"ab".repeat(32), &"AB".repeat(32))
|
||||
.unwrap_err()
|
||||
.to_string(),
|
||||
"TIME_NATIVE_KEY_ROLE_REUSE"
|
||||
);
|
||||
assert!(independent_time_key(&"ab".repeat(32), &"cd".repeat(32)).is_ok());
|
||||
assert!(independent_time_key(&"ab".repeat(32), "not-a-provisioned-job-key").is_err());
|
||||
}
|
||||
#[test]
|
||||
fn bracket_uses_actual_capture_width_and_refuses_unqualified_or_backward_counters() {
|
||||
let wall = 116_444_736_000_000_000 + 18_000_000_000_000_000;
|
||||
let result = bracket_sample(wall, 100, 120, 90, 110, 1_000_000).unwrap();
|
||||
assert_eq!(result.wall_utc_ns, 1_800_000_000_000_000_000);
|
||||
assert_eq!(result.capture_error_ns, 1_002_000);
|
||||
assert!(bracket_sample(wall, 100, 99, 90, 110, 1_000_000).is_err());
|
||||
assert!(bracket_sample(wall, 100, 120, 90, 89, 1_000_000).is_err());
|
||||
assert!(bracket_sample(wall, 100, 120, 90, 110, 0).is_err());
|
||||
assert!(bracket_sample(wall, 0, 500_000, 0, 500_000, 1_000_000).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn retained_process_fence_rejects_old_challenge_and_boot_substitution() {
|
||||
let boot = Uuid::new_v4();
|
||||
let owner = Uuid::new_v4();
|
||||
let mut state = Continuity::default();
|
||||
state.accept_configuration(4, "one-config").unwrap();
|
||||
state.accept_connection(3).unwrap();
|
||||
assert!(state.accept_configuration(3, "old-config").is_err());
|
||||
assert!(state.accept_configuration(4, "different-config").is_err());
|
||||
state.accept_configuration(4, "one-config").unwrap();
|
||||
|
||||
state.observe(boot, sample(0)).unwrap();
|
||||
let original_epoch = state.reserve(owner).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());
|
||||
// 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.accept_connection(4).unwrap();
|
||||
assert!(state.require_owner(next, epoch).is_err());
|
||||
assert!(state.require_connection(3).is_err());
|
||||
assert!(state.accept_connection(3).is_err());
|
||||
state.require_connection(4).unwrap();
|
||||
assert!(state.observe(Uuid::new_v4(), resumed).is_err());
|
||||
assert!(state.require_owner(next, epoch).is_err());
|
||||
state.epoch = u64::MAX;
|
||||
state.invalidate();
|
||||
assert!(state.exhausted);
|
||||
state.invalidate();
|
||||
assert!(state.exhausted);
|
||||
assert!(state.reserve(Uuid::new_v4()).is_err());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user