Verify finite signed-time evidence on cloud Linux
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user