Implement independent signed time contract with native Linux evidence
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
Generated
+15
@@ -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
@@ -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"
|
||||
|
||||
@@ -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"] }
|
||||
|
||||
@@ -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
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
@@ -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,
|
||||
|
||||
@@ -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.
|
||||
Reference in New Issue
Block a user