Implement independent signed time contract with native Linux evidence
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-14 23:20:45 +01:00
parent d08767ca43
commit 0023ca4c77
8 changed files with 985 additions and 1 deletions
Generated
+15
View File
@@ -2249,6 +2249,7 @@ dependencies = [
"rmm-agent-core",
"rmm-domain",
"rmm-protocol",
"rmm-time-attestation",
"rusqlite",
"rustls",
"rustls-pemfile",
@@ -2373,6 +2374,20 @@ dependencies = [
"uuid",
]
[[package]]
name = "rmm-time-attestation"
version = "0.1.0"
dependencies = [
"anyhow",
"ed25519-dalek",
"hex",
"rand 0.9.5",
"serde",
"serde_json",
"sha2 0.10.9",
"uuid",
]
[[package]]
name = "rmm-updater"
version = "0.1.0"
+1 -1
View File
@@ -1,7 +1,7 @@
[workspace]
resolver = "2"
exclude = ["crates/oidc-auth"]
members = ["crates/domain", "crates/protocol", "crates/persistence", "crates/server", "crates/agent-linux", "crates/agent-core", "crates/agent-windows", "crates/agent", "crates/privileged-helper", "crates/updater", "crates/updater-handoff", "crates/updater-linux", "crates/updater-worker"]
members = ["crates/domain", "crates/protocol", "crates/persistence", "crates/server", "crates/agent-linux", "crates/agent-core", "crates/agent-windows", "crates/agent", "crates/privileged-helper", "crates/updater", "crates/updater-handoff", "crates/updater-linux", "crates/updater-worker", "crates/time-attestation"]
[workspace.package]
version = "0.1.0"
+1
View File
@@ -31,6 +31,7 @@ uuid.workspace = true
rmm-domain = { path = "../domain" }
rmm-agent-core = { path = "../agent-core" }
rmm-protocol = { path = "../protocol" }
rmm-time-attestation = { path = "../time-attestation" }
rusqlite = { version = "0.32.1", features = ["bundled"] }
fs2 = "0.4.3"
rcgen = { version = "=0.14.10", default-features = false, features = ["crypto", "ring", "pem"] }
+15
View File
@@ -0,0 +1,15 @@
[package]
name = "rmm-time-attestation"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
anyhow.workspace = true
ed25519-dalek = "=2.2.0"
hex.workspace = true
rand.workspace = true
serde.workspace = true
serde_json.workspace = true
sha2.workspace = true
uuid.workspace = true
+555
View File
@@ -0,0 +1,555 @@
//! 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/api/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<String>,
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<String> {
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<SignedAttestation> {
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<String, VerifyingKey>,
}
impl Pins {
pub fn new(
generation: u64,
server_instance: Uuid,
keys: BTreeMap<String, [u8; 32]>,
) -> Result<Self> {
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::<Result<_>>()?;
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
}
}
/// 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<Sample>,
epoch: u64,
pending_nonce: Option<String>,
verifier_id: Uuid,
}
impl Verifier {
pub fn new(context: Context, pins: Pins) -> Result<Self> {
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<Challenge> {
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<Sample>,
) -> Result<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 elapsed = checked
.interrupt_ns
.checked_sub(challenge.begin.interrupt_ns)
.ok_or_else(|| anyhow::anyhow!("TIME_COUNTER"))?;
let age = checked
.interrupt_ns
.checked_sub(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
.begin
.capture_error_ns
.checked_add(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");
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());
}
}
+309
View File
@@ -0,0 +1,309 @@
#!/usr/bin/env python3
"""Frozen four Linux time-contract units only; no updater service or Apply.
Prepare copies the independently reviewed snapshot locally. Execute is one
root-only Cloud-VM fixture run. After any lost reply read the original case;
never execute it again or substitute another binary/source generation.
"""
import argparse
import base64
import hashlib
import inspect
import json
import os
from pathlib import Path
import stat
import uuid
import windows_msi_runtime_acceptance as support
ROOT = Path(__file__).resolve().parents[1]
ACCESS_ROOT = ROOT.parent / 'rust-discovery'
QUALIFICATION = ROOT / 'devstate/time-attestation-qualification/368c42aa-de32-41cd-85fe-c15637cd57a9'
STATE = ROOT / 'devstate/time-attestation-linux'
PROFILE = 'rmm.time-attestation.four-contract-units.v1'
RECEIPT_SHA = 'a50017a1a80042351a639ab2fa8f813435d7d40bd236331dd34f075e98cd09eb'
INPUTS_SHA = 'c01a21bfa09a77b7fa529b85931ac111d08f0dcce137e6aa86a9a22c2c35cf73'
BINARY_SHA = '0e06243dc6d9d502681fb62f755bf5267140a483f89ae61cd6a2e31201a85a13'
BINARY_BYTES = 1515200
TESTS = sorted(['tests::foreign_reply_cannot_reenable_an_older_own_challenge', 'tests::signed_roundtrip_uses_entire_rtt_and_strict_deadline_interval', 'tests::discontinuity_invalidates_outstanding_and_requires_new_challenge', 'tests::tampering_wrong_role_nonce_key_and_delays_never_open'])
AGENT_SHA = '0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f'
HELPER_SHA = '79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf'
def sha(raw):
return hashlib.sha256(raw).hexdigest()
def save_local(path, value):
support.save(path, value)
fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
try:
os.fsync(fd)
finally:
os.close(fd)
def copy_exact(source, destination, digest, size):
metadata = source.lstat()
support.require(stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1
and metadata.st_uid in (0, os.getuid()) and not metadata.st_mode & 0o002
and metadata.st_size == size and size <= 2 * 1024 * 1024, 'bounded regular frozen input')
raw = source.read_bytes()
support.require(sha(raw) == digest, 'frozen snapshot input hash')
destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
support.private(destination.parent, True)
fd = os.open(destination, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600)
with os.fdopen(fd, 'wb') as stream:
stream.write(raw); stream.flush(); os.fsync(stream.fileno())
fd = os.open(destination.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
try:
os.fsync(fd)
finally:
os.close(fd)
def verify_case(folder):
value = support.load(folder / 'manifest.json')
support.require(value['profile'] == PROFILE and value['tests'] == TESTS
and value['runner_sha256'] == sha(Path(__file__).read_bytes())
and value['receipt_sha256'] == RECEIPT_SHA and value['binary_sha256'] == BINARY_SHA
and value['binary_bytes'] == BINARY_BYTES, 'same original reviewed manifest')
support.require(sha((folder / 'receipt.json').read_bytes()) == RECEIPT_SHA
and sha((folder / 'inputs.json').read_bytes()) == INPUTS_SHA, 'original qualification provenance')
source = support.load(folder / 'inputs.json')
support.require(len(source) == 4 and source == value['source_files'], 'exact frozen four codec inputs')
for item in source:
path = Path(item['path'])
support.require(not path.is_absolute() and '..' not in path.parts, 'fixed snapshot relative path')
file = folder / 'source' / path
support.private(file)
support.require(file.stat().st_size == item['bytes'] and sha(file.read_bytes()) == item['sha256'], 'retained source freeze')
binary = folder / 'time-contract-tests'; support.private(binary)
support.require(binary.stat().st_size == BINARY_BYTES and sha(binary.read_bytes()) == BINARY_SHA, 'original qualified test bytes')
for path, digest in value['transport_sources'].items():
support.require(sha((ROOT / path).read_bytes()) == digest, 'original strict transport source')
return value
def remote(p):
import base64
import hashlib
import json
import os
from pathlib import Path
import selectors
import signal
import stat
import subprocess
import time
import uuid
def require(ok, message):
if not ok:
raise RuntimeError(message)
def enc(value):
return json.dumps(value, sort_keys=True, separators=(',', ':')).encode()
def create(path, raw, mode=0o600):
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode)
with os.fdopen(fd, 'wb') as stream:
stream.write(raw); stream.flush(); os.fsync(stream.fileno())
fd = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY | os.O_NOFOLLOW)
try:
os.fsync(fd)
finally:
os.close(fd)
def run(args, timeout=20):
# Keep the owned group leader unreaped until its entire group has been
# cleaned up. Its PID therefore cannot be recycled before killpg.
child = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, start_new_session=True,
env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C', 'HOME': '/nonexistent'})
selector = selectors.DefaultSelector()
buffers = {'stdout': bytearray(), 'stderr': bytearray()}
deadline = time.monotonic() + timeout
try:
for stream, name in ((child.stdout, 'stdout'), (child.stderr, 'stderr')):
os.set_blocking(stream.fileno(), False); selector.register(stream, selectors.EVENT_READ, name)
while True:
require(time.monotonic() < deadline, 'owned native command timeout; read original case only')
for key, _ in selector.select(0.02):
raw = os.read(key.fileobj.fileno(), 4096)
if raw:
buffers[key.data].extend(raw)
require(len(buffers[key.data]) <= 65536, 'bounded native output')
else:
selector.unregister(key.fileobj)
ended = os.waitid(os.P_PID, child.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT)
if ended is not None:
# Child remains a zombie until finally: no PID/group reuse.
os.killpg(child.pid, signal.SIGKILL)
for key in list(selector.get_map().values()):
while True:
try:
raw = os.read(key.fileobj.fileno(), 4096)
except BlockingIOError:
break
if not raw:
break
buffers[key.data].extend(raw)
require(len(buffers[key.data]) <= 65536, 'bounded native output')
code = ended.si_status if ended.si_code == os.CLD_EXITED else -ended.si_status
return code, bytes(buffers['stdout']), bytes(buffers['stderr'])
finally:
os.killpg(child.pid, signal.SIGKILL)
child.wait()
selector.close(); child.stdout.close(); child.stderr.close()
def metadata_identity(value):
return (value.st_dev, value.st_ino, value.st_uid, value.st_gid, value.st_mode,
value.st_nlink, value.st_size, value.st_mtime_ns, value.st_ctime_ns)
def hashed(path, maximum, process_image=False):
fd = os.open(path, os.O_RDONLY | os.O_CLOEXEC | (0 if process_image else os.O_NOFOLLOW))
with os.fdopen(fd, 'rb') as stream:
before = os.fstat(stream.fileno()); require(stat.S_ISREG(before.st_mode) and before.st_size <= maximum, 'bounded witness file')
digest = hashlib.sha256(); total = 0
while True:
raw = stream.read(32768)
if not raw:
break
total += len(raw); require(total <= maximum, 'bounded witness hash'); digest.update(raw)
after = os.fstat(stream.fileno())
require(metadata_identity(before) == metadata_identity(after) and total == before.st_size, 'stable witness hash')
return before, digest.hexdigest()
def witness():
out = {'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'services': {}, 'files': {}}
release = dict(line.split('=', 1) for line in Path('/etc/os-release').read_text().splitlines() if '=' in line)
require(release.get('ID', '').strip('"') == 'ubuntu' and release.get('VERSION_ID', '').strip('"') == '24.04', 'fixed native Ubuntu24.04')
out['os'] = {'id': 'ubuntu', 'version': '24.04', 'machine': os.uname().machine, 'kernel': os.uname().release}
for name, uid, binary in (
('rmm-agent-remote.service', 993, p['agent_sha256']),
('rmm-helper-cloud.service', 0, p['helper_sha256']),
('rmm-full-maintenance-helper.service', 0, p['helper_sha256'])):
code, stdout, _ = run(['/usr/bin/systemctl', 'show', name, '-p', 'ActiveState', '-p', 'MainPID', '-p', 'UnitFileState', '-p', 'InvocationID'])
require(code == 0, 'existing service read')
service = dict(line.split('=', 1) for line in stdout.decode().splitlines())
pid = int(service['MainPID']); require(service['ActiveState'] == 'active' and pid > 1, 'three existing services active')
proc = Path('/proc', str(pid)); birth = (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19]
ids = {line.split(':')[0]: line.split()[1:] for line in (proc / 'status').read_text().splitlines() if line.startswith(('Uid:', 'Gid:'))}
metadata, image = hashed(proc / 'exe', 256 * 1024 * 1024, process_image=True)
current = (proc / 'exe').stat()
require(ids['Uid'] == [str(uid)] * 4 and ids['Gid'] == ['984'] * 4 and image == binary
and (metadata.st_dev, metadata.st_ino) == (current.st_dev, current.st_ino)
and (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] == birth, 'current generation/account/image')
out['services'][name] = dict(service, birth=birth, image=image, ids=ids)
code, stdout, _ = run(['/usr/bin/systemctl', 'show', 'rmm-apt-helper.service', '-p', 'ActiveState', '-p', 'UnitFileState'])
apt = dict(line.split('=', 1) for line in stdout.decode().splitlines())
require(code == 0 and apt == {'ActiveState': 'inactive', 'UnitFileState': 'disabled'}, 'APT remains closed')
out['apt'] = apt
for name in ('/etc/rmm-remote/helper-general.json', '/etc/rmm-remote/helper-full-maintenance.json',
'/etc/rmm-remote/full-maintenance-helper-proof.json', '/etc/systemd/system/rmm-full-maintenance-helper.service'):
path = Path(name); metadata = path.lstat()
require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_uid == 0
and not metadata.st_mode & 0o022 and metadata.st_nlink == 1, 'protected known control')
current, digest = hashed(path, 65536)
require(metadata_identity(current) == metadata_identity(metadata), 'same known control file')
out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode,
metadata.st_size, metadata.st_mtime_ns, metadata.st_ctime_ns, digest]
for name in ('/var/lib/rmm-helper/consumption.sqlite', '/var/lib/rmm-helper/executor.lock',
'/var/lib/rmm-agent-remote/journal.sqlite', '/var/lib/rmm-agent-remote/consumption.sqlite'):
path = Path(name); metadata = path.lstat()
require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1, 'existing state identity')
out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode]
return out
require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux root contract fixtures')
ident = str(uuid.UUID(p['id'])); require(ident == p['id'], 'canonical original case')
folder = Path('/var/tmp') / ('rmm-time-attestation-tests-' + ident)
if p['action'] == 'read':
metadata = folder.lstat()
require(stat.S_ISDIR(metadata.st_mode) and not folder.is_symlink() and metadata.st_uid == 0
and stat.S_IMODE(metadata.st_mode) == 0o700, 'own original case only')
result = folder / 'result.json'
return {'read_only': True, 'id': ident, 'entered': (folder / 'entered.json').exists(),
'result': json.loads(result.read_bytes()) if result.exists() else None, 'current_witness': witness()}
require(p['action'] == 'execute', 'one fixed time contract action')
os.umask(0o077); folder.mkdir(mode=0o700)
create(folder / 'intent.json', enc({key: value for key, value in p.items() if key != 'binary_b64'}))
require(len(p['binary_b64']) == 2020268, 'bounded binary transfer')
raw = base64.b64decode(p['binary_b64'], validate=True)
require(len(raw) == 1515200 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed four-unit binary')
binary = folder / 'time-contract-tests'; create(binary, raw, 0o700)
before = witness(); create(folder / 'before.json', enc(before))
command = ['/usr/bin/setpriv', '--reuid=0', '--regid=0', '--clear-groups', '--no-new-privs', str(binary)]
code, stdout, stderr = run(command + ['--list', '--format', 'terse'])
create(folder / 'list.stdout', stdout); create(folder / 'list.stderr', stderr)
require(code == 0 and stderr == b'', 'native list succeeded')
lines = stdout.decode().splitlines()
require(len(lines) == 4 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['tests'], 'exact four tests before any run')
create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()}))
code, stdout, stderr = run(command + ['--test-threads=1', '--nocapture'])
create(folder / 'run.stdout', stdout); create(folder / 'run.stderr', stderr)
after = witness(); create(folder / 'after.json', enc(after))
require(before == after and code == 0 and stderr == b''
and b'4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' in stdout
and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'four native units and retained target state')
receipt = dict(id=ident, profile=p['profile'], passed=4, ignored=0, filtered=0, execution_uid=0, tests=p['tests'],
before=before, after=after, binary_sha256=p['binary_sha256'], source_receipt_sha256=p['receipt_sha256'],
source_manifest_sha256=p['manifest_sha256'], stdout_sha256=hashlib.sha256(stdout).hexdigest(),
no_rmm_jobs=True, no_apply=True, no_service_control=True)
create(folder / 'result.json', enc(receipt)); return receipt
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('prepare', 'execute', 'read')); parser.add_argument('--case')
args = parser.parse_args(); os.umask(0o077)
STATE.mkdir(mode=0o700, parents=True, exist_ok=True); support.private(STATE, True)
if args.action == 'prepare':
support.require(args.case is None, 'prepare one new local case')
receipt_path = QUALIFICATION / 'receipt.json'; support.private(receipt_path)
support.require(sha(receipt_path.read_bytes()) == RECEIPT_SHA, 'independently reviewed source receipt')
receipt = support.load(receipt_path); original = support.load(QUALIFICATION / 'inputs.json')
support.require(sha((QUALIFICATION / 'inputs.json').read_bytes()) == INPUTS_SHA
and receipt['inputs_sha256'] == INPUTS_SHA and len(original) == 4
and receipt['result'] == 'LOCAL_DEBUG_TIME4_PASS_RELEASE_LINKED' and receipt['tests'] == 4
and receipt['skips'] == 0 and receipt['filters'] == 0, 'reviewed four-test qualification')
ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700)
copy_exact(receipt_path, folder / 'receipt.json', RECEIPT_SHA, receipt_path.stat().st_size)
copy_exact(QUALIFICATION / 'inputs.json', folder / 'inputs.json', INPUTS_SHA, (QUALIFICATION / 'inputs.json').stat().st_size)
paths = set()
for item in original:
path = Path(item['path'])
support.require(not path.is_absolute() and '..' not in path.parts and str(path) not in paths, 'unique fixed frozen input')
paths.add(str(path)); copy_exact(QUALIFICATION / 'source' / path, folder / 'source' / path, item['sha256'], item['bytes'])
binary = QUALIFICATION / 'qualified-time-tests'
support.require(receipt['artifacts'][0] == dict(path='qualified-time-tests', bytes=BINARY_BYTES, sha256=BINARY_SHA), 'fixed original linked artifact')
copy_exact(binary, folder / 'time-contract-tests', BINARY_SHA, BINARY_BYTES)
transports = {path: sha((ROOT / path).read_bytes()) for path in ('deploy/windows_msi_runtime_acceptance.py', 'deploy/vm_access_check.py')}
save_local(folder / 'manifest.json', dict(id=ident, profile=PROFILE, runner_sha256=sha(Path(__file__).read_bytes()),
receipt_sha256=RECEIPT_SHA, binary_sha256=BINARY_SHA, binary_bytes=BINARY_BYTES,
source_files=original, tests=TESTS, transport_sources=transports))
verify_case(folder)
print(json.dumps({'id': ident, 'prepared_locally': True})); return
support.require(args.case is not None, 'original --case required')
ident = str(uuid.UUID(args.case)); support.require(ident == args.case, 'same canonical original case')
folder = STATE / ident; support.private(folder, True); verify_case(folder)
payload = dict(id=ident, action=args.action, profile=PROFILE, tests=TESTS, binary_sha256=BINARY_SHA,
receipt_sha256=RECEIPT_SHA, manifest_sha256=sha((folder / 'manifest.json').read_bytes()),
agent_sha256=AGENT_SHA, helper_sha256=HELPER_SHA)
if args.action == 'execute':
save_local(folder / 'execute-entered.json', {'once': True, 'no_retry': True})
payload['binary_b64'] = base64.b64encode((folder / 'time-contract-tests').read_bytes()).decode()
code = 'import json\n' + inspect.getsource(remote) + '\nprint(json.dumps(remote(' + repr(payload) + ')))\n'
response = support.transport(support.access_settings(ACCESS_ROOT, 'linux'), 'python3 -', code.encode(), folder)
save_local(folder / (args.action + '-' + str(uuid.uuid4()) + '.json'), response)
if args.action == 'read' and response['result'] is not None:
support.require(response['result']['source_manifest_sha256'] == sha((folder / 'manifest.json').read_bytes())
and response['current_witness'] == response['result']['after'], 'same-case retained native result')
print(json.dumps({'id': ident, 'action': args.action, 'passed': response.get('passed'),
'complete': response.get('result') is not None if args.action == 'read' else True, 'read_only': args.action == 'read'}))
if __name__ == '__main__':
main()
+8
View File
@@ -1,5 +1,13 @@
# Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt
**Signierter Zeitvergleich, erster tatsächlicher Linuxbeleg:** Gemeinsamer
Codec/Verifier nach Nonce-Replayfix im Originalfall2b282376 nativ4/4 bestanden,
separater Readback abgeschlossen, bekannte Runtimezeugen erhalten.
[Ergebnisse und klare Integrationsgrenzen](signed-time-contract-results.md).
Keine Server-/Windows-Zeitqualifikation oder Jobgateöffnung; Audiencepfad vor
Transportintegration noch an bestehenden /agent/v1-Vertrag angleichen.
**Userentscheidung1.22:** Signierter unabhängiger Windows-Zeitvergleich mit
festgelegtem Server ausdrücklich zur Umsetzung erlaubt; Agent und SYSTEM
prüfen separat, fehlende Qualität sperrt. Normativ Kapitel0/Projektentscheidungen,
+81
View File
@@ -0,0 +1,81 @@
# Signierter Zeitvergleich: gemeinsamer Prüfkern nativ auf Linux
2026-11-14, Spezifikation1.22. Neuer gemeinsamer Codec/Verifier implementiert;
noch kein vertrauenswürdiger produktiver Zeitadapter oder Windowsjobgate.
`rmm-time-attestation` bindet kanonische JSONbytes mit eigener Ed25519-Domäne,
geschützte Schlüsselgeneration/Serverinstanz, vollständigen Requesthash,
Geräte-/Boot-/Verbindungs-/Rollenbezug und eine pro Verifier gehaltene aktuelle
Nonce. Challenges sind nicht klonbar und werden auch bei Fehler verbraucht.
Der Verifier misst nach Signaturprüfung erneut über den nativen Caller.
Ganze RTT, drei Capturebudgets und Serverfehler gehen konservativ in die
UTCspanne ein; Startfristen müssen deren beide Grenzen erfüllen. Keine neue
Jobautorität, kein Synclease, kein Holdover und keine Uhrstellung.
Das unabhängige Review fand einen echten Replayfehler: Nach fremder
Fehlerantwort konnte ein alter eigener Challenge unter einem neuen offenen
Slot akzeptiert werden. Der Fix hält die exakte aktuelle Nonce zusätzlich zu
Verifier-ID/Epoch/Context; ein gezielter Gegenfall prüft die gesamte Sequenz.
Der erste lokale Signatur-Negativtest konnte durch Ersetzen mit00 zufällig
unverändert bleiben; jetzt verändert XOR1 garantiert ein Signaturbyte.
Diese ursprünglichen Fehler werden nicht als erfolgreiche Prüfungen geführt.
## Tatsächliche lokale und native Prüfungen
Lokal debug4/4, keine Skips/Filter. Finale eingefrorene Quelle separat Release
gebaut und gelinkt, Clippy-Dwarnings und Formatcheck bestanden, Offlinebuilder
9a76ad3744eb. Qualifikationsreceipt SHA256
`a50017a1a80042351a639ab2fa8f813435d7d40bd236331dd34f075e98cd09eb`.
Ein vorheriger Qualifikationsfall stoppte korrekt an `--locked`, als parallel
nur die neue Windows-Abhängigkeitskante ergänzt worden war. Nach deren enger
Lockdateiergänzung entstand ein neuer, vollständig bestandener lokaler Fall.
Keine alten Belege ersetzt, keine Abhängigkeitsversion geändert.
Vier eingefrorene Inputs: Workspace-/Crate-Manifeste, Cargo.lock und Codecquelle.
Inputmanifest SHA256
`c01a21bfa09a77b7fa529b85931ac111d08f0dcce137e6aa86a9a22c2c35cf73`.
Releaseexe1515200Byte, SHA256
`0e06243dc6d9d502681fb62f755bf5267140a483f89ae61cd6a2e31201a85a13`.
Nur der gemeinsame Prüfkern, keine übrigen Workspacequellen qualifiziert.
Der unabhängig geprüfte neue Runner
`deploy/time_attestation_linux_acceptance.py`, SHA256
`7572171fee75b5e994253e8190871778e439f8575691256d644a405e23cdaac6`,
verlangt die exakte native Viererliste vor einem einzigen Lauf. Originalfall
`2b282376-5002-4a75-91e2-8928fa8688cd` auf der Cloud-Linux-VM:
**4/4,0ignored/filtered, Exit0**, separater lesender Rückabruf vollständig.
Tatsächlich ausgeführte Originalbefehle:
```sh
python3 deploy/time_attestation_linux_acceptance.py prepare
python3 deploy/time_attestation_linux_acceptance.py execute --case 2b282376-5002-4a75-91e2-8928fa8688cd
python3 deploy/time_attestation_linux_acceptance.py read --case 2b282376-5002-4a75-91e2-8928fa8688cd
```
Fallmanifest SHA256
`60d306685fa8b37217cd973aa5ff19b3a520aaab9154eb3e77cc1450f802212c`;
Execute-Beleg SHA256
`282a597183ed02f4c767407aa7ed94975f8e3571d56eaa6835bb9bbe429e8fb0`;
Readback SHA256
`1156610d7b41d92b3f55932d3b39547c2e0f24ee906edf00fd43860419e952b5`.
Bekannte drei RMM-Prozessgenerationen, Boot, vier Kontrollbytebelege und
DB-/Lock-Dateiidentitäten blieben vor/nach sowie beim Readback gleich.
APT inaktiv/disabled, Full aktiv/Autostart disabled. Keine Dienststeuerung,
Produktzeitabfrage, RMM-Jobs, Dateitausche oder vollständige SQL-/PKI-Abnahme.
Die Tests erzeugen nur kurzlebige In-Memory-Signierschlüssel/Codecfixtures.
## Offene Integration
Der native Beleg prüft Codecbytes und Validatoren, keine Server-/Windows-
Zeitqualität oder komplette Runtime. Geschützte Pinprovisionierung, tatsächliche
Chrony-/Kernelquelle samt lokalem Signierbroker, mTLS-/SQL-Kontextprüfung,
unabhängiger Windows-Agent/SYSTEM-Timerbeleg und Jobintegration bleiben offen.
Der erste Codec bindet noch den provisorischen Audiencepfad
`/api/agent/v1/time-attestation`; vor Transportintegration muss er an den
bestehenden `/agent/v1/...`-Vertrag angeglichen und als neuer Quellenstand
geprüft werden. Keine zusätzliche öffentliche API-Wildcard vorsehen und den
ursprünglichen nativen Beleg dabei nicht nachträglich umetikettieren.
Die unverbundene Windows-Slice-/Providerentwicklung parallel dazu eröffnet
keine Capability. Das Windows-MVP und der Selbstupdater sind nicht abgeschlossen.