//! Independent online time comparison, never a sync lease or execution permit. //! Nanoseconds are signed UTC Unix ns, intervals are unsigned ns. Callers must //! hold their own native clock observations and protected context/pins. use anyhow::{Result, ensure}; use ed25519_dalek::{Signature, Signer, SigningKey, VerifyingKey}; use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use std::collections::BTreeMap; use uuid::Uuid; pub const ENDPOINT: &str = "https://discovery.ease-technologies.de/agent/v1/time-attestation"; pub const MAX_RTT_NS: u64 = 1_000_000_000; pub const MAX_RECEIVED_AGE_NS: u64 = 100_000_000; pub const MAX_CAPTURE_ERROR_NS: u64 = 50_000_000; pub const MAX_SERVER_ERROR_NS: u64 = 500_000_000; pub const MAX_SYNC_AGE_NS: u64 = 3_600_000_000_000; const DOMAIN: &[u8] = b"RMM-TIME-ATTESTATION/v1\0"; const MAX_BYTES: usize = 8192; #[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)] #[serde(rename_all = "snake_case")] pub enum Role { Agent, SystemHelper, } #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] #[serde(deny_unknown_fields)] pub struct Context { pub tenant_id: Uuid, pub asset_id: Uuid, pub agent_id: Uuid, pub enrollment_generation: u64, pub assignment_generation: u64, pub connection_generation: u64, pub windows_boot_id: Uuid, pub verifier_incarnation: Uuid, pub role: Role, pub helper_image_sha256: Option, pub binding_schema: u32, } impl Context { pub fn validate(&self) -> Result<()> { ensure!( [ self.tenant_id, self.asset_id, self.agent_id, self.windows_boot_id, self.verifier_incarnation ] .iter() .all(|v| !v.is_nil()), "TIME_CONTEXT_ID" ); ensure!( self.enrollment_generation > 0 && self.assignment_generation > 0 && self.connection_generation > 0 && self.binding_schema == 1, "TIME_CONTEXT_GENERATION" ); match self.role { Role::Agent => ensure!( self.helper_image_sha256.is_none(), "TIME_AGENT_HELPER_IMAGE" ), Role::SystemHelper => { exact_hex(self.helper_image_sha256.as_deref().unwrap_or(""), 32)?; } } Ok(()) } } #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] #[serde(deny_unknown_fields)] pub struct Request { pub version: u32, pub endpoint: String, pub nonce: String, pub context: Context, } impl Request { pub fn validate(&self) -> Result<()> { ensure!( self.version == 1 && self.endpoint == ENDPOINT, "TIME_REQUEST_PROFILE" ); exact_hex(&self.nonce, 32)?; self.context.validate() } pub fn sha256(&self) -> Result { self.validate()?; Ok(hex::encode(Sha256::digest(serde_json::to_vec(self)?))) } } #[derive(Clone, Debug, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub struct Payload { pub version: u32, pub request_sha256: String, pub server_instance: Uuid, pub server_boot_id: Uuid, pub key_id: String, pub key_generation: u64, pub captured_utc_ns: i64, pub server_error_ns: u64, pub source_sync_age_ns: u64, } #[derive(Clone, Debug, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub struct SignedAttestation { /// Exact canonical JSON bytes (UTF-8); verification never normalizes input. pub payload: String, pub signature_hex: String, } fn exact_hex(value: &str, bytes: usize) -> Result<()> { ensure!( value.len() == bytes * 2 && value .bytes() .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)), "TIME_HEX_FORMAT" ); Ok(()) } fn validate_payload(p: &Payload) -> Result<()> { ensure!( p.version == 1 && !p.server_instance.is_nil() && !p.server_boot_id.is_nil(), "TIME_SERVER_CONTEXT" ); ensure!( !p.key_id.is_empty() && p.key_id.len() <= 64 && p.key_id .bytes() .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_') && p.key_generation > 0, "TIME_KEY_CONTEXT" ); exact_hex(&p.request_sha256, 32)?; ensure!( p.captured_utc_ns > 0 && p.server_error_ns <= MAX_SERVER_ERROR_NS && p.source_sync_age_ns <= MAX_SYNC_AGE_NS, "TIME_SERVER_QUALITY" ); Ok(()) } /// Only server code which has independently qualified the native source may /// construct/sign this payload. This codec is not a provider qualification. pub fn sign(payload: &Payload, key: &SigningKey) -> Result { validate_payload(payload)?; let raw = serde_json::to_string(payload)?; let mut message = DOMAIN.to_vec(); message.extend_from_slice(raw.as_bytes()); Ok(SignedAttestation { payload: raw, signature_hex: hex::encode(key.sign(&message).to_bytes()), }) } /// Loaded through the verifier's protected configuration, never an HTTP reply. pub struct Pins { generation: u64, server_instance: Uuid, keys: BTreeMap, } impl Pins { pub fn new( generation: u64, server_instance: Uuid, keys: BTreeMap, ) -> Result { ensure!( generation > 0 && !server_instance.is_nil() && !keys.is_empty() && keys.len() <= 8, "TIME_PINS" ); let keys = keys .into_iter() .map(|(id, raw)| Ok((id, VerifyingKey::from_bytes(&raw)?))) .collect::>()?; Ok(Self { generation, server_instance, keys, }) } } /// A native, locally captured observation; ns counters share one process's OS /// clock domains. capture_error_ns must come from platform qualification. #[derive(Clone, Copy, Debug)] pub struct Sample { pub wall_utc_ns: i64, pub interrupt_ns: u64, pub unbiased_ns: u64, pub capture_error_ns: u64, } impl Sample { fn validate(self) -> Result<()> { ensure!( self.wall_utc_ns > 0 && self.capture_error_ns <= MAX_CAPTURE_ERROR_NS, "TIME_LOCAL_SAMPLE" ); Ok(()) } } /// Opaque, noncloneable request authority: one attempt consumes it even when /// signature/quality checks fail. A transported Request alone is no authority. pub struct Challenge { request: Request, begin: Sample, epoch: u64, verifier_id: Uuid, } impl Challenge { pub fn request(&self) -> &Request { &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 { context: Context, pins: Pins, previous: Option, epoch: u64, pending_nonce: Option, verifier_id: Uuid, } impl Verifier { pub fn new(context: Context, pins: Pins) -> Result { context.validate()?; Ok(Self { context, pins, previous: None, epoch: 1, pending_nonce: None, verifier_id: Uuid::new_v4(), }) } pub fn invalidate(&mut self) { self.pending_nonce = None; self.epoch = if self.epoch == 0 { 0 } else { self.epoch.checked_add(1).unwrap_or(0) }; } pub fn observe(&mut self, sample: Sample) -> Result<()> { if let Err(error) = sample.validate() { self.invalidate(); return Err(error); } let continuous = self.previous.is_none_or(|p| { match ( sample.wall_utc_ns.checked_sub(p.wall_utc_ns), sample.interrupt_ns.checked_sub(p.interrupt_ns), sample.unbiased_ns.checked_sub(p.unbiased_ns), ) { (Some(w), Some(i), Some(u)) if w >= 0 => { (w as u64).abs_diff(i) <= MAX_RTT_NS && i.abs_diff(u) <= MAX_RTT_NS } _ => false, } }); self.previous = Some(sample); if !continuous { self.invalidate(); } ensure!(continuous, "TIME_DISCONTINUITY"); Ok(()) } pub fn begin(&mut self, sample: Sample) -> Result { self.observe(sample)?; ensure!( self.epoch > 0 && self.pending_nonce.is_none(), "TIME_CHALLENGE_OUTSTANDING_OR_EXHAUSTED" ); let nonce: [u8; 32] = rand::random(); let request = Request { version: 1, endpoint: ENDPOINT.into(), nonce: hex::encode(nonce), context: self.context.clone(), }; request.validate()?; self.pending_nonce = Some(request.nonce.clone()); Ok(Challenge { request, begin: sample, epoch: self.epoch, verifier_id: self.verifier_id, }) } pub fn finish( &mut self, challenge: Challenge, signed: &SignedAttestation, received: Sample, capture_checked: impl FnOnce() -> Result, ) -> Result { // 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, ) -> 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 && challenge.request.context == self.context; self.pending_nonce = None; ensure!(owned, "TIME_CHALLENGE_NOT_OWNED"); self.observe(received)?; ensure!(signed.payload.len() <= MAX_BYTES, "TIME_PAYLOAD_LIMIT"); let p: Payload = serde_json::from_str(&signed.payload)?; ensure!( serde_json::to_string(&p)? == signed.payload, "TIME_NONCANONICAL_PAYLOAD" ); validate_payload(&p)?; ensure!( p.request_sha256 == challenge.request.sha256()? && p.server_instance == self.pins.server_instance && p.key_generation == self.pins.generation, "TIME_BINDING" ); let key = self .pins .keys .get(&p.key_id) .ok_or_else(|| anyhow::anyhow!("TIME_KEY_NOT_PINNED"))?; exact_hex(&signed.signature_hex, 64)?; let signature = Signature::from_slice(&hex::decode(&signed.signature_hex)?)?; let mut message = DOMAIN.to_vec(); message.extend_from_slice(signed.payload.as_bytes()); 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 { 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 { let p = &evidence.payload; let elapsed = checked .interrupt_ns .checked_sub(evidence.begin.interrupt_ns) .ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?; let age = checked .interrupt_ns .checked_sub(evidence.received.interrupt_ns) .ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?; // Include every local capture/timer budget conservatively, never RTT/2. let delta = evidence .begin .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"); // Use the same full qualified uncertainty for freshness as for UTC-U. // The begin budget is deliberately overcounted for receive age: no // endpoint or timer-underread allowance can disappear at either gate. let upper_elapsed = elapsed .checked_add(delta) .ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?; let upper_age = age .checked_add(delta) .ok_or_else(|| anyhow::anyhow!("TIME_ERROR_OVERFLOW"))?; ensure!( upper_elapsed <= MAX_RTT_NS && upper_age <= MAX_RECEIVED_AGE_NS, "TIME_STALE_RESPONSE" ); ensure!( p.source_sync_age_ns .checked_add(elapsed) .and_then(|v| v.checked_add(delta)) .is_some_and(|v| v <= MAX_SYNC_AGE_NS), "TIME_SOURCE_AGE_AT_CHECK" ); let lower = i128::from(p.captured_utc_ns) - i128::from(p.server_error_ns); let upper = i128::from(p.captured_utc_ns) + i128::from(p.server_error_ns) + i128::from(elapsed) + i128::from(delta); let wall = i128::from(checked.wall_utc_ns); ensure!( (wall - lower).abs().max((wall - upper).abs()) <= 2_000_000_000, "TIME_LOCAL_WALL_OUTSIDE_BOUND" ); Ok(Interval { lower_utc_ns: lower.try_into()?, upper_utc_ns: upper.try_into()?, }) } } /// Fresh result only. Adapters must recapture/reverify for later use; this type /// carries no lease, serialization or execution authorization. #[derive(Debug)] pub struct Interval { lower_utc_ns: i64, upper_utc_ns: i64, } impl Interval { pub fn lower_utc_ns(&self) -> i64 { self.lower_utc_ns } pub fn upper_utc_ns(&self) -> i64 { self.upper_utc_ns } pub fn allows_start(&self, not_before_ns: i64, start_before_ns: i64) -> bool { self.lower_utc_ns >= not_before_ns && self.upper_utc_ns < start_before_ns } } #[cfg(test)] mod tests { use super::*; const T: i64 = 1_800_000_000_000_000_000; fn sample(elapsed: u64) -> Sample { Sample { wall_utc_ns: T + elapsed as i64, interrupt_ns: 10_000_000_000 + elapsed, unbiased_ns: 9_000_000_000 + elapsed, capture_error_ns: 1_000_000, } } fn context(role: Role) -> Context { Context { tenant_id: Uuid::new_v4(), asset_id: Uuid::new_v4(), agent_id: Uuid::new_v4(), enrollment_generation: 1, assignment_generation: 1, connection_generation: 2, windows_boot_id: Uuid::new_v4(), verifier_incarnation: Uuid::new_v4(), role, helper_image_sha256: (role == Role::SystemHelper).then(|| "ab".repeat(32)), binding_schema: 1, } } fn fixture(context: Context) -> (Verifier, SigningKey, Uuid) { let key = SigningKey::from_bytes(&rand::random()); let server = Uuid::new_v4(); let pins = Pins::new( 4, server, BTreeMap::from([("time1".into(), key.verifying_key().to_bytes())]), ) .unwrap(); (Verifier::new(context, pins).unwrap(), key, server) } fn reply(c: &Challenge, key: &SigningKey, server: Uuid) -> SignedAttestation { sign( &Payload { version: 1, request_sha256: c.request().sha256().unwrap(), server_instance: server, server_boot_id: Uuid::new_v4(), key_id: "time1".into(), key_generation: 4, captured_utc_ns: T + 20_000_000, server_error_ns: 10_000_000, source_sync_age_ns: 100_000_000_000, }, key, ) .unwrap() } #[test] fn signed_roundtrip_uses_entire_rtt_and_strict_deadline_interval() { let (mut v, key, server) = fixture(context(Role::SystemHelper)); let c = v.begin(sample(0)).unwrap(); let signed = reply(&c, &key, server); let result = v .finish(c, &signed, sample(70_000_000), || Ok(sample(80_000_000))) .unwrap(); assert_eq!(result.lower_utc_ns(), T + 10_000_000); assert_eq!(result.upper_utc_ns(), T + 113_000_000); assert!(result.allows_start(T, T + 114_000_000)); assert!(!result.allows_start(T, T + 113_000_000)); assert!(!result.allows_start(T + 11_000_000, T + 114_000_000)); } #[test] fn tampering_wrong_role_nonce_key_and_delays_never_open() { for mutation in 0..7 { let (mut v, key, server) = fixture(context(Role::Agent)); let c = v.begin(sample(0)).unwrap(); let mut signed = reply(&c, &key, server); let mut received = sample(70_000_000); let mut checked = sample(80_000_000); match mutation { 0 => { let mut bytes = hex::decode(&signed.signature_hex).unwrap(); bytes[0] ^= 1; signed.signature_hex = hex::encode(bytes); } 1 => { let mut p: Payload = serde_json::from_str(&signed.payload).unwrap(); p.request_sha256 = "cd".repeat(32); signed = sign(&p, &key).unwrap(); } 2 => { let other = SigningKey::from_bytes(&rand::random()); signed = reply(&c, &other, server); } 3 => checked = sample(MAX_RTT_NS + 1), 4 => { received = sample(10_000_000); checked = sample(110_000_001); } 5 => { let mut p: Payload = serde_json::from_str(&signed.payload).unwrap(); p.key_generation = 3; signed = sign(&p, &key).unwrap(); } _ => signed.payload.push(' '), } assert!( v.finish(c, &signed, received, || Ok(checked)).is_err(), "mutation {mutation}" ); assert!(v.pending_nonce.is_none()); } let ctx = context(Role::Agent); let (mut a, key, server) = fixture(ctx.clone()); let (mut b, _, _) = fixture(ctx); let ca = a.begin(sample(0)).unwrap(); let signed = reply(&ca, &key, server); let _cb = b.begin(sample(0)).unwrap(); assert!( b.finish(ca, &signed, sample(20_000_000), || Ok(sample(30_000_000))) .is_err() ); } #[test] fn foreign_reply_cannot_reenable_an_older_own_challenge() { let (mut a, key_a, server_a) = fixture(context(Role::Agent)); let (mut b, key_b, server_b) = fixture(context(Role::Agent)); let ca = a.begin(sample(0)).unwrap(); let reply_a = reply(&ca, &key_a, server_a); let old_b = b.begin(sample(0)).unwrap(); let old_reply_b = reply(&old_b, &key_b, server_b); assert!( b.finish(ca, &reply_a, sample(10_000_000), || Ok(sample(20_000_000))) .is_err() ); let _current_b = b.begin(sample(30_000_000)).unwrap(); assert!( b.finish(old_b, &old_reply_b, sample(40_000_000), || Ok(sample( 50_000_000 ))) .is_err() ); } #[test] fn discontinuity_invalidates_outstanding_and_requires_new_challenge() { let (mut v, key, server) = fixture(context(Role::SystemHelper)); let c = v.begin(sample(0)).unwrap(); let signed = reply(&c, &key, server); let mut resumed = sample(2_000_000_000); resumed.unbiased_ns = 9_000_000_000; assert!(v.observe(resumed).is_err()); assert!(v.finish(c, &signed, resumed, || Ok(resumed)).is_err()); // A new post-discontinuity challenge is permitted, no old nonce reuse. let c = v.begin(resumed).unwrap(); let mut p: Payload = serde_json::from_str(&reply(&c, &key, server).payload).unwrap(); p.captured_utc_ns = resumed.wall_utc_ns; 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(167_000_000)).is_ok()); assert!(v.check_evidence(&evidence, sample(167_000_001)).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_297_000_000)).is_ok()); assert!(v.check_evidence(&evidence, sample(1_297_000_001)).is_err()); } #[test] fn challenge_freshness_includes_all_capture_budgets_at_one_second() { // Unequal budgets make omission of any one endpoint observable. These // are fixture inputs, never installation calibration or measurements. let delta = 31_000_000; for excess in [0, 1] { let (mut v, key, server) = fixture(context(Role::Agent)); let mut begin = sample(0); begin.capture_error_ns = 7_000_000; let c = v.begin(begin).unwrap(); let signed = reply(&c, &key, server); let mut received = sample(MAX_RTT_NS - delta - 1_000_000); received.capture_error_ns = 11_000_000; let mut checked = sample(MAX_RTT_NS - delta + excess); checked.capture_error_ns = 13_000_000; let result = v.finish_evidence(c, &signed, received, || Ok(checked)); assert!(v.pending_nonce.is_none()); if excess == 0 { let (evidence, _) = result.unwrap(); assert!(v.check_evidence(&evidence, checked).is_ok()); let mut later = sample(MAX_RTT_NS - delta + 1); later.capture_error_ns = checked.capture_error_ns; assert!(v.check_evidence(&evidence, later).is_err()); } else { assert_eq!(result.err().unwrap().to_string(), "TIME_STALE_RESPONSE"); } } } #[test] fn receive_freshness_includes_all_capture_budgets_at_one_hundred_ms() { let delta = 31_000_000; for excess in [0, 1] { let (mut v, key, server) = fixture(context(Role::SystemHelper)); let mut begin = sample(0); begin.capture_error_ns = 7_000_000; let c = v.begin(begin).unwrap(); let signed = reply(&c, &key, server); let mut received = sample(50_000_000); received.capture_error_ns = 11_000_000; let mut checked = sample(50_000_000 + MAX_RECEIVED_AGE_NS - delta + excess); checked.capture_error_ns = 13_000_000; let result = v.finish_evidence(c, &signed, received, || Ok(checked)); assert!(v.pending_nonce.is_none()); if excess == 0 { let (evidence, _) = result.unwrap(); assert!(v.check_evidence(&evidence, checked).is_ok()); let mut later = sample(50_000_000 + MAX_RECEIVED_AGE_NS - delta + 1); later.capture_error_ns = checked.capture_error_ns; assert!(v.check_evidence(&evidence, later).is_err()); } else { assert_eq!(result.err().unwrap().to_string(), "TIME_STALE_RESPONSE"); } } } #[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()); } }