Add protected Windows time verifier with Linux-first guard evidence
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -27,6 +27,7 @@ pub mod package;
|
||||
pub mod process;
|
||||
#[cfg(windows)]
|
||||
pub mod service;
|
||||
pub mod signed_clock;
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod system_script;
|
||||
|
||||
|
||||
@@ -0,0 +1,623 @@
|
||||
//! Independent signed time comparison for the Windows agent and SYSTEM helper.
|
||||
//! This module does not implement SyncClock, advertise a capability, start a job,
|
||||
//! change W32Time or replace the still-closed legacy NativeClock adapter.
|
||||
#![cfg(any(test, all(windows, feature = "system-helper")))]
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_time_attestation::Sample;
|
||||
use uuid::Uuid;
|
||||
|
||||
const SECOND_NS: u64 = 1_000_000_000;
|
||||
const MAX_BASE_ERROR_NS: u64 = 10_000_000;
|
||||
|
||||
fn independent_time_key(time_key_hex: &str, job_key_hex: &str) -> Result<[u8; 32]> {
|
||||
fn decode(value: &str) -> Result<[u8; 32]> {
|
||||
ensure!(
|
||||
value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit()),
|
||||
"TIME_NATIVE_PUBLIC_KEY"
|
||||
);
|
||||
let mut raw = [0u8; 32];
|
||||
for (index, byte) in raw.iter_mut().enumerate() {
|
||||
*byte = u8::from_str_radix(&value[index * 2..index * 2 + 2], 16)?;
|
||||
}
|
||||
Ok(raw)
|
||||
}
|
||||
let time = decode(time_key_hex)?;
|
||||
let job = decode(job_key_hex)?;
|
||||
ensure!(time != job, "TIME_NATIVE_KEY_ROLE_REUSE");
|
||||
Ok(time)
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Continuity {
|
||||
boot_id: Option<Uuid>,
|
||||
previous: Option<Sample>,
|
||||
epoch: u64,
|
||||
exhausted: bool,
|
||||
active: Option<Uuid>,
|
||||
configuration: Option<(u64, String)>,
|
||||
connection_generation: Option<u64>,
|
||||
}
|
||||
impl Continuity {
|
||||
fn invalidate(&mut self) {
|
||||
self.active = None;
|
||||
match self.epoch.checked_add(1) {
|
||||
Some(epoch) if !self.exhausted => self.epoch = epoch,
|
||||
_ => self.exhausted = true,
|
||||
}
|
||||
}
|
||||
fn observe(&mut self, boot_id: Uuid, sample: Sample) -> Result<()> {
|
||||
let valid = !boot_id.is_nil()
|
||||
&& !self.exhausted
|
||||
&& self.boot_id.is_none_or(|old| old == boot_id)
|
||||
&& sample.wall_utc_ns > 0
|
||||
&& sample.capture_error_ns <= rmm_time_attestation::MAX_CAPTURE_ERROR_NS
|
||||
&& self.previous.is_none_or(|old| {
|
||||
match (
|
||||
sample.wall_utc_ns.checked_sub(old.wall_utc_ns),
|
||||
sample.interrupt_ns.checked_sub(old.interrupt_ns),
|
||||
sample.unbiased_ns.checked_sub(old.unbiased_ns),
|
||||
) {
|
||||
(Some(wall), Some(interrupt), Some(unbiased)) if wall >= 0 => {
|
||||
(wall as u64).abs_diff(interrupt) <= SECOND_NS
|
||||
&& interrupt.abs_diff(unbiased) <= SECOND_NS
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
});
|
||||
// Never adopt a different boot in a surviving process. A new adapter
|
||||
// object cannot erase this process-wide identity/continuity history.
|
||||
self.boot_id.get_or_insert(boot_id);
|
||||
self.previous = Some(sample);
|
||||
if !valid {
|
||||
self.invalidate();
|
||||
}
|
||||
ensure!(valid, "TIME_NATIVE_DISCONTINUITY_OR_BOOT");
|
||||
Ok(())
|
||||
}
|
||||
fn accept_configuration(&mut self, generation: u64, sha256: &str) -> Result<()> {
|
||||
ensure!(
|
||||
generation > 0 && !self.exhausted,
|
||||
"TIME_NATIVE_CONFIGURATION_GENERATION"
|
||||
);
|
||||
if let Some((current, hash)) = &self.configuration {
|
||||
ensure!(
|
||||
generation >= *current && (generation != *current || hash == sha256),
|
||||
"TIME_NATIVE_CONFIGURATION_ROLLBACK_OR_FORK"
|
||||
);
|
||||
if generation > *current {
|
||||
self.invalidate();
|
||||
}
|
||||
}
|
||||
self.configuration = Some((generation, sha256.into()));
|
||||
Ok(())
|
||||
}
|
||||
fn accept_connection(&mut self, generation: u64) -> Result<()> {
|
||||
ensure!(
|
||||
generation > 0
|
||||
&& !self.exhausted
|
||||
&& self
|
||||
.connection_generation
|
||||
.is_none_or(|old| generation >= old),
|
||||
"TIME_NATIVE_CONNECTION_ROLLBACK"
|
||||
);
|
||||
if self
|
||||
.connection_generation
|
||||
.is_some_and(|old| generation > old)
|
||||
{
|
||||
self.invalidate();
|
||||
}
|
||||
self.connection_generation = Some(generation);
|
||||
Ok(())
|
||||
}
|
||||
fn require_connection(&self, generation: u64) -> Result<()> {
|
||||
ensure!(
|
||||
!self.exhausted && self.connection_generation == Some(generation),
|
||||
"TIME_NATIVE_CONNECTION_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn reserve(&mut self, owner: Uuid) -> Result<u64> {
|
||||
ensure!(
|
||||
!self.exhausted && !owner.is_nil() && self.active.is_none(),
|
||||
"TIME_NATIVE_CHALLENGE_BUSY"
|
||||
);
|
||||
self.active = Some(owner);
|
||||
Ok(self.epoch)
|
||||
}
|
||||
fn require_owner(&self, owner: Uuid, epoch: u64) -> Result<()> {
|
||||
ensure!(
|
||||
!self.exhausted && self.active == Some(owner) && self.epoch == epoch,
|
||||
"TIME_NATIVE_CHALLENGE_INVALIDATED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// All three native clocks are read in one bracket. The qualified base error
|
||||
/// is a protected installation input, never inferred from 100ns resolution.
|
||||
fn bracket_sample(
|
||||
wall_filetime: u64,
|
||||
interrupt_before: u64,
|
||||
interrupt_after: u64,
|
||||
unbiased_before: u64,
|
||||
unbiased_after: u64,
|
||||
base_error_ns: u64,
|
||||
) -> Result<Sample> {
|
||||
const FILETIME_UNIX: u64 = 116_444_736_000_000_000;
|
||||
ensure!(
|
||||
base_error_ns > 0 && base_error_ns <= MAX_BASE_ERROR_NS,
|
||||
"TIME_NATIVE_CALIBRATION_REQUIRED"
|
||||
);
|
||||
let width = interrupt_after
|
||||
.checked_sub(interrupt_before)
|
||||
.and_then(|value| value.checked_mul(100))
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_COUNTER"))?;
|
||||
let unbiased_width = unbiased_after
|
||||
.checked_sub(unbiased_before)
|
||||
.and_then(|value| value.checked_mul(100))
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_COUNTER"))?;
|
||||
ensure!(
|
||||
width.abs_diff(unbiased_width) <= SECOND_NS,
|
||||
"TIME_NATIVE_CAPTURE_SUSPEND"
|
||||
);
|
||||
let capture_error_ns = width
|
||||
.checked_add(base_error_ns)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_CAPTURE_OVERFLOW"))?;
|
||||
ensure!(
|
||||
capture_error_ns <= rmm_time_attestation::MAX_CAPTURE_ERROR_NS,
|
||||
"TIME_NATIVE_CAPTURE_BUDGET"
|
||||
);
|
||||
let wall_utc_ns = wall_filetime
|
||||
.checked_sub(FILETIME_UNIX)
|
||||
.and_then(|value| value.checked_mul(100))
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_WALL_RANGE"))?
|
||||
.try_into()?;
|
||||
Ok(Sample {
|
||||
wall_utc_ns,
|
||||
interrupt_ns: interrupt_after
|
||||
.checked_mul(100)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_COUNTER_RANGE"))?,
|
||||
unbiased_ns: unbiased_after
|
||||
.checked_mul(100)
|
||||
.ok_or_else(|| anyhow::anyhow!("TIME_NATIVE_COUNTER_RANGE"))?,
|
||||
capture_error_ns,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod installed {
|
||||
use super::*;
|
||||
use crate::helper_ipc::{self as ipc, PeerProof, PinnedFile};
|
||||
use anyhow::Context as _;
|
||||
use rmm_agent_core::auth::Binding;
|
||||
use rmm_domain::jobs::hash;
|
||||
use rmm_time_attestation::{
|
||||
Challenge, Context, Interval, Pins, Request, Role, SignedAttestation, Verifier,
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
collections::BTreeMap,
|
||||
io::Read,
|
||||
path::Path,
|
||||
sync::{Mutex, OnceLock},
|
||||
};
|
||||
|
||||
pub const CONFIG_PATH: &str = r"C:\ProgramData\RustDiscoverySystem\time-attestation.json";
|
||||
const PUBLIC_ROOT: &str = r"C:\ProgramData\RustDiscoverySystem";
|
||||
const MAX_CONFIG_BYTES: usize = 16_384;
|
||||
const MAX_REPLY_BYTES: usize = 16_384;
|
||||
|
||||
/// Provision only after an independent qualification of these actual
|
||||
/// native APIs/platform/image. A file field is not a measured accuracy.
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Calibration {
|
||||
pub role: Role,
|
||||
pub binary_sha256: String,
|
||||
pub qualification_sha256: String,
|
||||
pub base_error_ns: u64,
|
||||
}
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Configuration {
|
||||
pub schema_version: u32,
|
||||
pub key_generation: u64,
|
||||
pub server_instance: Uuid,
|
||||
pub binding: Binding,
|
||||
pub public_keys_hex: BTreeMap<String, String>,
|
||||
pub calibrations: Vec<Calibration>,
|
||||
}
|
||||
fn digest(value: &str) -> bool {
|
||||
value.len() == 64
|
||||
&& value
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
|
||||
}
|
||||
static PROCESS: OnceLock<Mutex<Continuity>> = OnceLock::new();
|
||||
static INCARNATION: OnceLock<Uuid> = OnceLock::new();
|
||||
fn process() -> &'static Mutex<Continuity> {
|
||||
PROCESS.get_or_init(|| Mutex::new(Continuity::default()))
|
||||
}
|
||||
fn capture(base_error_ns: u64) -> Result<Sample> {
|
||||
#[link(name = "kernel32")]
|
||||
unsafe extern "system" {
|
||||
fn GetSystemTimePreciseAsFileTime(value: *mut u64);
|
||||
fn QueryInterruptTimePrecise(value: *mut u64);
|
||||
fn QueryUnbiasedInterruptTimePrecise(value: *mut u64);
|
||||
}
|
||||
let (mut ib, mut ia, mut ub, mut ua, mut wall) = (0, 0, 0, 0, 0);
|
||||
// SAFETY: documented VOID kernel getters with valid aligned u64
|
||||
// outputs. Windows 10+ is required; no optional API fallback exists.
|
||||
unsafe {
|
||||
QueryInterruptTimePrecise(&mut ib);
|
||||
QueryUnbiasedInterruptTimePrecise(&mut ub);
|
||||
GetSystemTimePreciseAsFileTime(&mut wall);
|
||||
QueryUnbiasedInterruptTimePrecise(&mut ua);
|
||||
QueryInterruptTimePrecise(&mut ia);
|
||||
}
|
||||
bracket_sample(wall, ib, ia, ub, ua, base_error_ns)
|
||||
}
|
||||
fn observed(boot: Uuid, base_error_ns: u64) -> Result<(Sample, u64)> {
|
||||
let mut state = process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
|
||||
let value = match capture(base_error_ns) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
state.invalidate();
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
state.observe(boot, value)?;
|
||||
Ok((value, state.epoch))
|
||||
}
|
||||
|
||||
struct Pending {
|
||||
owner: Uuid,
|
||||
epoch: u64,
|
||||
challenge: Challenge,
|
||||
}
|
||||
/// Own-process role proof, protected held configuration, private challenge
|
||||
/// and native timers. No constructor accepts agent-reported helper times.
|
||||
pub struct SignedClock {
|
||||
verifier: Verifier,
|
||||
own_process: PeerProof,
|
||||
files: Vec<PinnedFile>,
|
||||
config_sha256: String,
|
||||
boot_id: Uuid,
|
||||
connection_generation: u64,
|
||||
base_error_ns: u64,
|
||||
pending: Option<Pending>,
|
||||
}
|
||||
impl SignedClock {
|
||||
/// Connection generation is later confirmed by the independently
|
||||
/// signed server response. It is never itself a ready/sync flag.
|
||||
pub async fn open(role: Role, connection_generation: u64) -> Result<Self> {
|
||||
ensure!(connection_generation > 0, "TIME_NATIVE_CONNECTION");
|
||||
let (settings, mut files) = crate::helper_system::read_settings()?;
|
||||
let own_pin = match role {
|
||||
Role::Agent => &settings.agent,
|
||||
Role::SystemHelper => &settings.helper,
|
||||
};
|
||||
own_pin.validate(role == Role::SystemHelper)?;
|
||||
ipc::require_self(own_pin)?;
|
||||
let own_process = PeerProof::for_service(
|
||||
own_pin,
|
||||
// SAFETY: this getter takes no arguments and returns own PID.
|
||||
unsafe { windows_sys::Win32::System::Threading::GetCurrentProcessId() },
|
||||
)?;
|
||||
let readers = vec![
|
||||
settings.agent.service_sid.clone(),
|
||||
settings.helper.service_sid.clone(),
|
||||
];
|
||||
files.push(PinnedFile::open(
|
||||
Path::new(PUBLIC_ROOT),
|
||||
true,
|
||||
&readers,
|
||||
&[],
|
||||
false,
|
||||
)?);
|
||||
let mut config_file =
|
||||
PinnedFile::open(Path::new(CONFIG_PATH), false, &readers, &[], false)?;
|
||||
ensure!(
|
||||
config_file.file.metadata()?.len() <= MAX_CONFIG_BYTES as u64,
|
||||
"TIME_NATIVE_CONFIG_SIZE"
|
||||
);
|
||||
let mut raw = Vec::new();
|
||||
(&mut config_file.file)
|
||||
.take(MAX_CONFIG_BYTES as u64 + 1)
|
||||
.read_to_end(&mut raw)?;
|
||||
ensure!(raw.len() <= MAX_CONFIG_BYTES, "TIME_NATIVE_CONFIG_SIZE");
|
||||
let config: Configuration = serde_json::from_slice(&raw)?;
|
||||
ensure!(
|
||||
config.schema_version == 1
|
||||
&& config.key_generation > 0
|
||||
&& config.calibrations.len() == 2,
|
||||
"TIME_NATIVE_CONFIG_PROFILE"
|
||||
);
|
||||
ensure!(
|
||||
hash(&serde_json::to_vec(&config.binding)?)
|
||||
== hash(&serde_json::to_vec(&settings.binding)?),
|
||||
"TIME_NATIVE_DEVICE_BINDING"
|
||||
);
|
||||
for expected in [Role::Agent, Role::SystemHelper] {
|
||||
let mut values = config
|
||||
.calibrations
|
||||
.iter()
|
||||
.filter(|value| value.role == expected);
|
||||
let value = values.next().context("TIME_NATIVE_CALIBRATION_MISSING")?;
|
||||
ensure!(
|
||||
values.next().is_none()
|
||||
&& digest(&value.binary_sha256)
|
||||
&& digest(&value.qualification_sha256)
|
||||
&& value.base_error_ns > 0
|
||||
&& value.base_error_ns <= MAX_BASE_ERROR_NS,
|
||||
"TIME_NATIVE_CALIBRATION_PROFILE"
|
||||
);
|
||||
let pin = if expected == Role::Agent {
|
||||
&settings.agent
|
||||
} else {
|
||||
&settings.helper
|
||||
};
|
||||
ensure!(
|
||||
value.binary_sha256 == pin.binary_sha256,
|
||||
"TIME_NATIVE_CALIBRATION_IMAGE"
|
||||
);
|
||||
}
|
||||
let base_error_ns = config
|
||||
.calibrations
|
||||
.iter()
|
||||
.find(|value| value.role == role)
|
||||
.context("TIME_NATIVE_CALIBRATION_MISSING")?
|
||||
.base_error_ns;
|
||||
let keys = config
|
||||
.public_keys_hex
|
||||
.iter()
|
||||
.map(|(id, key)| {
|
||||
ensure!(digest(key), "TIME_NATIVE_PUBLIC_KEY");
|
||||
let raw = independent_time_key(key, &settings.binding.public_key_hex)?;
|
||||
Ok((id.clone(), raw))
|
||||
})
|
||||
.collect::<Result<BTreeMap<_, _>>>()?;
|
||||
let pins = Pins::new(config.key_generation, config.server_instance, keys)?;
|
||||
process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?
|
||||
.accept_configuration(config.key_generation, &hash(&raw))?;
|
||||
|
||||
// The existing fixed read-only native getter is independent in
|
||||
// each process. It finishes BEFORE challenge/RTT timing begins.
|
||||
let boot_id = Uuid::parse_str(&crate::native::boot_id().await?)?;
|
||||
let context = Context {
|
||||
tenant_id: settings.binding.tenant_id,
|
||||
asset_id: settings.binding.asset_id,
|
||||
agent_id: settings.binding.agent_id,
|
||||
enrollment_generation: settings.binding.enrollment_generation,
|
||||
assignment_generation: settings.binding.assignment_version,
|
||||
connection_generation,
|
||||
windows_boot_id: boot_id,
|
||||
verifier_incarnation: *INCARNATION.get_or_init(Uuid::new_v4),
|
||||
role,
|
||||
helper_image_sha256: (role == Role::SystemHelper)
|
||||
.then(|| own_pin.binary_sha256.clone()),
|
||||
binding_schema: 1,
|
||||
};
|
||||
files.push(config_file);
|
||||
let mut value = Self {
|
||||
verifier: Verifier::new(context, pins)?,
|
||||
own_process,
|
||||
files,
|
||||
config_sha256: hash(&raw),
|
||||
boot_id,
|
||||
connection_generation,
|
||||
base_error_ns,
|
||||
pending: None,
|
||||
};
|
||||
value.recheck()?;
|
||||
process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?
|
||||
.accept_connection(connection_generation)?;
|
||||
observed(boot_id, base_error_ns)?;
|
||||
Ok(value)
|
||||
}
|
||||
fn recheck(&mut self) -> Result<()> {
|
||||
self.own_process.check()?;
|
||||
for file in &mut self.files {
|
||||
file.check()?;
|
||||
}
|
||||
let config = self.files.last_mut().context("TIME_NATIVE_CONFIG_HELD")?;
|
||||
ensure!(
|
||||
config.sha256()? == self.config_sha256,
|
||||
"TIME_NATIVE_CONFIG_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn begin(&mut self, connection_generation: u64) -> Result<Request> {
|
||||
if connection_generation != self.connection_generation {
|
||||
self.close();
|
||||
anyhow::bail!("TIME_NATIVE_CONNECTION_CHANGED");
|
||||
}
|
||||
ensure!(self.pending.is_none(), "TIME_NATIVE_PENDING");
|
||||
self.recheck()?;
|
||||
let mut state = process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
|
||||
state.require_connection(connection_generation)?;
|
||||
let sample = match capture(self.base_error_ns) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
state.invalidate();
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
state.observe(self.boot_id, sample)?;
|
||||
let owner = Uuid::new_v4();
|
||||
let epoch = state.reserve(owner)?;
|
||||
let challenge = match self.verifier.begin(sample) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
state.invalidate();
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let request = challenge.request().clone();
|
||||
self.pending = Some(Pending {
|
||||
owner,
|
||||
epoch,
|
||||
challenge,
|
||||
});
|
||||
Ok(request)
|
||||
}
|
||||
/// Call immediately after this verifier receives the complete bounded
|
||||
/// response. The helper's caller supplies bytes only, never timestamps.
|
||||
/// All failures consume the original request; no transparent retry.
|
||||
pub fn complete<T>(
|
||||
&mut self,
|
||||
bytes: &[u8],
|
||||
consume: impl FnOnce(&Comparison) -> Result<T>,
|
||||
) -> Result<T> {
|
||||
let pending = self.pending.take().context("TIME_NATIVE_NO_CHALLENGE")?;
|
||||
let result = (|| {
|
||||
let (received, epoch) = observed(self.boot_id, self.base_error_ns)?;
|
||||
ensure!(epoch == pending.epoch, "TIME_NATIVE_CHALLENGE_INVALIDATED");
|
||||
ensure!(bytes.len() <= MAX_REPLY_BYTES, "TIME_NATIVE_REPLY_SIZE");
|
||||
let signed: SignedAttestation = serde_json::from_slice(bytes)?;
|
||||
self.recheck()?;
|
||||
let mut checked = None;
|
||||
let interval =
|
||||
self.verifier
|
||||
.finish(pending.challenge, &signed, received, || {
|
||||
let (sample, epoch) = observed(self.boot_id, self.base_error_ns)?;
|
||||
ensure!(epoch == pending.epoch, "TIME_NATIVE_CHALLENGE_INVALIDATED");
|
||||
checked = Some(sample);
|
||||
Ok(sample)
|
||||
})?;
|
||||
let mut state = process()
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("TIME_NATIVE_STATE_POISONED"))?;
|
||||
state.require_owner(pending.owner, pending.epoch)?;
|
||||
state.active = None;
|
||||
let comparison = Comparison {
|
||||
interval,
|
||||
wall_utc_ns: checked.context("TIME_NATIVE_FINAL_SAMPLE")?.wall_utc_ns,
|
||||
};
|
||||
drop(state);
|
||||
consume(&comparison)
|
||||
})();
|
||||
if result.is_err() {
|
||||
self.verifier.invalidate();
|
||||
if let Ok(mut state) = process().lock()
|
||||
&& state.active == Some(pending.owner)
|
||||
{
|
||||
state.invalidate();
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
pub fn close(&mut self) {
|
||||
self.verifier.invalidate();
|
||||
if let Some(pending) = self.pending.take()
|
||||
&& let Ok(mut state) = process().lock()
|
||||
&& state.active == Some(pending.owner)
|
||||
{
|
||||
state.invalidate();
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Drop for SignedClock {
|
||||
fn drop(&mut self) {
|
||||
self.close();
|
||||
}
|
||||
}
|
||||
|
||||
/// Borrowed only inside the completion callback, never returned as a
|
||||
/// storable clock/lease/permit. Runtime callers must retain all job gates.
|
||||
pub struct Comparison {
|
||||
interval: Interval,
|
||||
wall_utc_ns: i64,
|
||||
}
|
||||
impl Comparison {
|
||||
pub fn interval(&self) -> &Interval {
|
||||
&self.interval
|
||||
}
|
||||
pub fn wall_utc_ns(&self) -> i64 {
|
||||
self.wall_utc_ns
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
pub use installed::{CONFIG_PATH, Calibration, Comparison, Configuration, SignedClock};
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
fn sample(ns: u64) -> Sample {
|
||||
Sample {
|
||||
wall_utc_ns: 1_800_000_000_000_000_000 + ns as i64,
|
||||
interrupt_ns: 10_000_000_000 + ns,
|
||||
unbiased_ns: 9_000_000_000 + ns,
|
||||
capture_error_ns: 1_000_000,
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case() {
|
||||
assert_eq!(
|
||||
independent_time_key(&"ab".repeat(32), &"AB".repeat(32))
|
||||
.unwrap_err()
|
||||
.to_string(),
|
||||
"TIME_NATIVE_KEY_ROLE_REUSE"
|
||||
);
|
||||
assert!(independent_time_key(&"ab".repeat(32), &"cd".repeat(32)).is_ok());
|
||||
assert!(independent_time_key(&"ab".repeat(32), "not-a-provisioned-job-key").is_err());
|
||||
}
|
||||
#[test]
|
||||
fn bracket_uses_actual_capture_width_and_refuses_unqualified_or_backward_counters() {
|
||||
let wall = 116_444_736_000_000_000 + 18_000_000_000_000_000;
|
||||
let result = bracket_sample(wall, 100, 120, 90, 110, 1_000_000).unwrap();
|
||||
assert_eq!(result.wall_utc_ns, 1_800_000_000_000_000_000);
|
||||
assert_eq!(result.capture_error_ns, 1_002_000);
|
||||
assert!(bracket_sample(wall, 100, 99, 90, 110, 1_000_000).is_err());
|
||||
assert!(bracket_sample(wall, 100, 120, 90, 89, 1_000_000).is_err());
|
||||
assert!(bracket_sample(wall, 100, 120, 90, 110, 0).is_err());
|
||||
assert!(bracket_sample(wall, 0, 500_000, 0, 500_000, 1_000_000).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn retained_process_fence_rejects_old_challenge_and_boot_substitution() {
|
||||
let boot = Uuid::new_v4();
|
||||
let owner = Uuid::new_v4();
|
||||
let mut state = Continuity::default();
|
||||
state.accept_configuration(4, "one-config").unwrap();
|
||||
state.accept_connection(3).unwrap();
|
||||
assert!(state.accept_configuration(3, "old-config").is_err());
|
||||
assert!(state.accept_configuration(4, "different-config").is_err());
|
||||
state.accept_configuration(4, "one-config").unwrap();
|
||||
|
||||
state.observe(boot, sample(0)).unwrap();
|
||||
let original_epoch = state.reserve(owner).unwrap();
|
||||
assert!(state.reserve(Uuid::new_v4()).is_err());
|
||||
let mut resumed = sample(2_000_000_000);
|
||||
resumed.unbiased_ns = 9_000_000_000;
|
||||
assert!(state.observe(boot, resumed).is_err());
|
||||
assert!(state.require_owner(owner, original_epoch).is_err());
|
||||
// A caller reconstructing its verifier still sees this retained state.
|
||||
state.observe(boot, resumed).unwrap();
|
||||
let next = Uuid::new_v4();
|
||||
let epoch = state.reserve(next).unwrap();
|
||||
assert!(epoch > original_epoch);
|
||||
state.require_owner(next, epoch).unwrap();
|
||||
state.accept_connection(4).unwrap();
|
||||
assert!(state.require_owner(next, epoch).is_err());
|
||||
assert!(state.require_connection(3).is_err());
|
||||
assert!(state.accept_connection(3).is_err());
|
||||
state.require_connection(4).unwrap();
|
||||
assert!(state.observe(Uuid::new_v4(), resumed).is_err());
|
||||
assert!(state.require_owner(next, epoch).is_err());
|
||||
state.epoch = u64::MAX;
|
||||
state.invalidate();
|
||||
assert!(state.exhausted);
|
||||
state.invalidate();
|
||||
assert!(state.exhausted);
|
||||
assert!(state.reserve(Uuid::new_v4()).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,312 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Frozen three Windows clock guards on Linux only; ten other cases filtered; 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/windows-signed-clock/qualification-763baf69-10b1-4307-9c99-6942c0f8945f'
|
||||
STATE = ROOT / 'devstate/windows-signed-clock-native-linux'
|
||||
PROFILE = 'rmm.windows-signed-clock.three-linux-guards.v1'
|
||||
RECEIPT_SHA = 'e013738caed2d8e02b98ffd1b41e47a80840c44d3dbf895e9a3952b4311ce927'
|
||||
INPUTS_SHA = 'eb4609c5fca6a32ddb8ebf364775efdb59cd89f99a24b3b731212da08eac6a6e'
|
||||
BINARY_SHA = '0896a3098f493b67b48e774de5cfe9bca682d2a19ff10971c62c9c7b9681ec14'
|
||||
BINARY_BYTES = 3374576
|
||||
TESTS = sorted(['signed_clock::tests::bracket_uses_actual_capture_width_and_refuses_unqualified_or_backward_counters', 'signed_clock::tests::job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case', 'signed_clock::tests::retained_process_fence_rejects_old_challenge_and_boot_substitution'])
|
||||
ALL_TESTS = sorted(['event_log::tests::job_mapping_is_only_fixed_unprivileged_live_logs_with_exact_limits', 'event_log::tests::only_fixed_source_window_and_finite_limits_are_queryable', 'event_log::tests::serialized_byte_budget_includes_xml_escaping_and_metadata', 'journal::tests::bounded_existing_journal_preserves_identity_sequence_and_unacked_bytes', 'journal::tests::durable_reopen_ack_identity_and_single_process', 'journal::tests::migrates_original_passive_schema_without_rewriting_pending_envelopes', 'journal::tests::unsupported_page_size_is_refused_without_mutating_existing_data', 'package::tests::exit_code_never_substitutes_for_independent_postconditions_or_reboot_authority', 'package::tests::late_exit_or_postcondition_cannot_retroactively_succeed_or_retry', 'package::tests::upgrade_and_noop_need_independent_exact_products_family_and_payload', 'signed_clock::tests::bracket_uses_actual_capture_width_and_refuses_unqualified_or_backward_counters', 'signed_clock::tests::job_key_cannot_be_reintroduced_as_a_time_key_with_different_hex_case', 'signed_clock::tests::retained_process_fence_rejects_old_challenge_and_boot_substitution'])
|
||||
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 <= 4 * 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['all_listed_tests'] == ALL_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) == 184 and source == value['source_files'], 'exact frozen 184 compiler 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 / 'windows-clock-guard-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-windows-clock-guards-linux-' + 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']) == 4499436, 'bounded binary transfer')
|
||||
raw = base64.b64decode(p['binary_b64'], validate=True)
|
||||
require(len(raw) == 3374576 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed three-guard library binary')
|
||||
binary = folder / 'windows-clock-guard-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) == 13 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['all_listed_tests'], 'exact full thirteen-test list before three targeted tests')
|
||||
create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()}))
|
||||
code, stdout, stderr = run(command + ['signed_clock::tests::', '--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'3 passed; 0 failed; 0 ignored; 0 measured; 10 filtered out' in stdout
|
||||
and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'three native guards with ten filtered and retained target state')
|
||||
receipt = dict(id=ident, profile=p['profile'], passed=3, ignored=0, filtered=10, listed=13, 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) == 184
|
||||
and receipt['kind'] == 'windows-signed-clock-source-qualification-v2'
|
||||
and receipt['all_source_inputs_preserved'] is True
|
||||
and receipt['independent_review']['source_sha256'] == '6b66612b7a53377c91bc8e41864ac8fb9393ad40b0a6a98aa6ce746fce091ddb'
|
||||
and next(x for x in receipt['results'] if x['name'] == 'linux-three-targeted') == dict(name='linux-three-targeted',exit_code=0,passed=3,failed=0,ignored=0,filtered_other_crate_tests=10,tests=TESTS), 'reviewed three-guard 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-linux-tests'
|
||||
support.require(receipt['artifacts'][0] == dict(name='qualified-linux-tests', platform='linux', bytes=BINARY_BYTES, sha256=BINARY_SHA), 'fixed original linked artifact')
|
||||
copy_exact(binary, folder / 'windows-clock-guard-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, all_listed_tests=ALL_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, all_listed_tests=ALL_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 / 'windows-clock-guard-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
|
||||
|
||||
**Windows-Zeitguards Linux-first bestanden:** Originalfall6ea36dec,
|
||||
volle13er-Liste geprüft, ausschließlich neue3Tests bestanden/10andere bewusst
|
||||
gefiltert; separater Readback vollständig, bekannte Runtimezeugen erhalten.
|
||||
Geschütztes Verifiermodul6b66612b unabhängig geprüft und lokal Windowsgelinkt;
|
||||
[Nachweise und Grenzen](windows-signed-clock-source.md).
|
||||
Keine Windowszeit-/Jobbereitschaft; Rohcapturequalifikation folgt separat.
|
||||
|
||||
|
||||
**Aktueller Zeitcodec-Endpunkt nativ geprüft:** Die Audiencekorrektur auf
|
||||
/agent/v1/time-attestation hat einen eigenen Linuxfall a22de8d2 mit4/4 und
|
||||
separatem vollständigem Readback; Originalfall2b282376 unverändert.
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
# Windows: unabhängiger signierter Zeitvergleich, erster Quellenschnitt
|
||||
|
||||
Stand2026-11-14, Spezifikation1.22. Der User hat diese alternative Trustsource
|
||||
ausdrücklich angenommen; [Vertrag](windows-clock-attestation-proposal.md).
|
||||
Dieser Schnitt implementiert den unabhängigen Windows-Verifier. Er ersetzt
|
||||
noch keinen laufenden Agent/Helper und öffnet keine Windows-Jobfähigkeit.
|
||||
|
||||
`crates/agent-windows/src/signed_clock.rs` ist additiv registriert. Sein
|
||||
installierter Adapter wird ausschließlich unter Windows mit dem vorhandenen
|
||||
`system-helper`-Feature gebaut; die zwei plattformneutralen Guardtests laufen
|
||||
auch unter Linux. Die bestehende RPC-Clock und `ADAPTER_QUALIFIED=false` bleiben
|
||||
unverändert. Kein neuer `SyncClock`, Cache, Netzwerkclient oder Jobpfad.
|
||||
|
||||
## Tatsächliche Bindung und enge API
|
||||
|
||||
Agent und SYSTEM-Helper öffnen jeweils selbst die geschützte bestehende
|
||||
Helperkonfiguration, prüfen ihre tatsächliche eigene SCM-Prozessgeneration,
|
||||
Token-/Dienstrolle und gehaltene Imageidentität mit dem vorhandenen PeerProof.
|
||||
Ein Agent kann die Helperrolle dadurch nicht nur im Request behaupten.
|
||||
Die vorhandene feste lesende CIM-Bootabfrage läuft unabhängig in jedem Prozess
|
||||
vor Beginn der Challenge. Ihre potenziell längere Laufzeit wird nicht aus einem
|
||||
bereits laufenden Einsekundenbudget versteckt.
|
||||
|
||||
Der zusätzliche feste öffentliche Pinpfad ist
|
||||
`C:\ProgramData\RustDiscoverySystem\time-attestation.json`, maximal16KiB.
|
||||
Seine Datei und das geschützte Elternverzeichnis werden mit bestehenden
|
||||
PinnedFiles und restriktiven ACL-/File-ID-/Reparseprüfungen gehalten.
|
||||
Alle ursprünglichen Helperkonfigurationshandles bleiben ebenfalls erhalten.
|
||||
Der Pin bindet die exakte bestehende Gerätebindung, Serverinstanz, Zeitkey-
|
||||
Generation, bis zu acht Publickeys und genau eine Kalibrierungsreferenz je
|
||||
Agent-/Helperimage. Nur SYSTEM/Administrators schreiben; die beiden
|
||||
Dienst-SIDs dürfen lesen. Keine Keys aus einer Serverantwort oder Workerdatei.
|
||||
|
||||
Ein anschließender enger Sourcefix verweigert zusätzlich jeden Zeitpublickey,
|
||||
der nach tatsächlicher Hexdekodierung dem vorhandenen Jobpublickey entspricht.
|
||||
Abweichende Groß-/Kleinschreibung umgeht die Rollentrennung nicht. Eine neue
|
||||
gezielte Negativprobe prüft diesen Fall. Dieser Fix ist noch nicht Teil des
|
||||
unten erhaltenen180-Input-Belegs; seine neue kohärente Qualifikation folgt nach
|
||||
dem neuen gemeinsamen Agentpfad-/Linuxnachweis im184-Input-Nachtrag unten.
|
||||
|
||||
Die Kalibrierung muss die tatsächliche Binary per SHA256 und einen separat
|
||||
gewonnenen Qualifikationsbeleg binden. Das positive Grundfehlerbudget liegt
|
||||
höchstens10ms je Capture. Dies ist **keine gemessene Genauigkeit**: Aktuell
|
||||
existiert aus diesem Schritt kein bereitgestellter Pin oder Kalibrierungsbeleg.
|
||||
Ein solches JSON darf nicht mit geratenen Werten als qualifiziert installiert
|
||||
werden. Der dauerhafte monotone Konfigurationsweg über Prozessneustarts bleibt
|
||||
vor Runtimeaktivierung gesondert zu provisionieren. Der Loader selbst sperrt
|
||||
innerhalb desselben Prozesses niedrigere Generationen und unterschiedliche
|
||||
Rawbytes bei gleicher Generation; er erzeugt kein neues Floorjournal.
|
||||
|
||||
Eine zufällige Prozessinkarnation sowie ein prozessweit gehaltener Continuity-
|
||||
Head bleiben unabhängig von Objektkonstruktoren erhalten. Höchstens eine
|
||||
Challenge ist pro Prozess offen. Bootwechsel, rückwärts laufende Zähler,
|
||||
Wallstep oder Schlafdifferenz über1s verwerfen sie. Überlauf erschöpft den Head
|
||||
dauerhaft; ein weiterer Aufruf öffnet ihn nicht wieder. Erst eine neu erzeugte
|
||||
Challenge nach einer beobachteten Diskontinuität ist verwendbar.
|
||||
|
||||
Im anschließenden Reviewfix hält derselbe globale Head auch die höchste
|
||||
Verbindungsgeneration: Ein neues Adapterobjekt mit höherer Generation
|
||||
invalidiert alte offene Challenges, alte Objekte können keine neue Anfrage
|
||||
unter ihrer niedrigeren Generation eröffnen. Ein Generationwechsel am
|
||||
vorhandenen `begin` schließt dessen eigene alte Anfrage. Die gezielte
|
||||
Continuityprobe ergänzt diese Negativfälle; auch dieser Fix gehört zum
|
||||
folgenden neuen Quellenbeleg, nicht zum ursprünglichen180-Input-Snapshot.
|
||||
|
||||
Der native Capture umfasst präzise Interruptzeit, Unbiasedzeit, Wallclock,
|
||||
nochmals Unbiasedzeit und Interruptzeit. Beide präzisen Interruptgetter sind
|
||||
gemäß Microsoft **VOID**-APIs; kein fingierter BOOL-Erfolg und keine optionale
|
||||
Fallbackquelle. Zeitwerte sind100ns-Einheiten. Der gesamte gemessene Bracket
|
||||
wird zusätzlich zum ausdrücklich qualifizierten Grundfehler konservativ
|
||||
berechnet. Auflösung wird nicht mit Genauigkeit gleichgesetzt.
|
||||
[Präzise Unbiasedzeit](https://learn.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryunbiasedinterrupttimeprecise),
|
||||
[präzise Interruptzeit](https://learn.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryinterrupttimeprecise).
|
||||
|
||||
`begin` liefert ausschließlich den gebundenen Transportrequest und hält die
|
||||
opaque Challenge selbst. `complete(bytes, callback)` nimmt nur begrenzte
|
||||
Antwortbytes entgegen, keine fremden Zeiten. Der Adapter erfasst Empfang
|
||||
selbst vor dem JSON-Decode und die Schlussmessung nach der vollständigen
|
||||
Signaturprüfung. Der gemeinsame Codec prüft Signatur, Originalrequest und
|
||||
Kontext, vollen RTT,100ms-Empfangsalter und die ganze UTCspanne. Am Ende müssen
|
||||
auch prozessweiter Owner und Epoch noch identisch sein.
|
||||
|
||||
Nur der unmittelbar aufgerufene Callback erhält eine geliehene Comparison mit
|
||||
der geprüften Spanne und der tatsächlich selbst beobachteten Windows-Wallclock.
|
||||
Keine gespeicherte Comparison, kein Midpoint als angebliche lokale Uhr, keine
|
||||
automatische neue Challenge nach einem Fehler. Abschluss/Abbruch konsumiert die
|
||||
ursprüngliche Anfrage. Runtimeintegration muss diese API an ihre tatsächlichen
|
||||
Start-/Syncgrenzen binden; sie wird hier nicht durch einen scalar `now()`-Stub
|
||||
vorgetäuscht. Die bestehenden zusätzlichen Job-/WebUI-/Ledgergates bleiben nötig.
|
||||
|
||||
## Tatsächlich lokal geprüft
|
||||
|
||||
Eingefrorener Sourcefall30bb330a-d285-4d15-ab8d-8ce36a760524,180 Inputs;
|
||||
Inputmanifest SHA256
|
||||
`7f56d21680a1345f514ac98fd187a3bea376414215ba1d5773f682690a8ae214`.
|
||||
Windowsmodul SHA256
|
||||
`f1fed304ebda3f48f38aba38f8ad5e1811c566abd740dffce318f4b07beac3ca`.
|
||||
Receipt SHA256
|
||||
`ad5e35ac1c63f0cbc8e3559c338b183ca5793e7219543a9f43794cc75542402b`.
|
||||
Der vollständige private Snapshot und Logs bleiben unter gitignoriertem
|
||||
`devstate/windows-signed-clock/qualification-30bb330a-d285-4d15-ab8d-8ce36a760524/`.
|
||||
|
||||
Tatsächlich bestanden, ausschließlich Offline-Docker auf dem Entwicklungsrechner:
|
||||
|
||||
- Zwei gezielte Linux-Guardtests: Bracketbudget/Counterfehler sowie erhaltener
|
||||
Prozessfence, Bootsubstitution, Generation/Fork und erschöpfter Epochcounter.
|
||||
2bestanden,0failed/ignored;10 übrige Cratetests ausdrücklich herausgefiltert.
|
||||
- Windows-GNU-Alltargetscheck sowie Clippy mit `-D warnings` für den
|
||||
`system-helper`-Build. Erster Clippylauf verweigerte drei verschachtelte
|
||||
if-Blöcke; diese wurden ohne Unterdrückung korrigiert und erneut geprüft.
|
||||
- Windows-Lib-Testbinary tatsächlich gelinkt,75326709Byte, SHA256
|
||||
`29c037f6ca13fc91806312a16dde0923fcaa1d5a0d16d057362bf112f3875da6`.
|
||||
**Nicht auf Windows ausgeführt**, kein nativer Testcount daraus abgeleitet.
|
||||
- Formatcheck ausschließlich der neuen Moduldatei bestanden.
|
||||
|
||||
Die relevanten Cargoaufrufe benutzen `--locked --offline`; Linux-Testfilter
|
||||
`signed_clock::tests`, Windows `--target x86_64-pc-windows-gnu --features
|
||||
system-helper --all-targets`. Das Linken verwendet `test --lib --no-run`.
|
||||
Der eingefrorene gemeinsame Codec enthält zu diesem Zeitpunkt noch die alte
|
||||
`/api/agent/v1/time-attestation`-Audience. Der geplante korrekte Agentpfad
|
||||
`/agent/v1/time-attestation` benötigt einen neuen gemeinsamen Quellenbeleg;
|
||||
dieser ursprüngliche Snapshot wird dafür nicht verändert.
|
||||
|
||||
## Offene reale Nachweise
|
||||
|
||||
Keine Cloud-Linux-Ausführung dieser beiden neuen Guardtests und keine native
|
||||
Windowsausführung in diesem Schritt. Keine tatsächliche Timerkalibrierung,
|
||||
Pinprovisionierung, Serverantwort im echten Geräte-mTLS-Kontext oder parallele
|
||||
Agent-/SYSTEM-Roundtrips. Keine Runtime-/IPC-/HTTP-Anbindung und keine Wirkung.
|
||||
Der Servercodec besitzt eigene getrennte Nachweise; diese qualifizieren nicht
|
||||
automatisch den Windowsadapter. Zuerst Linux-first, dann unabhängig auf dem
|
||||
Windowsgast prüfen. Erst danach kann eine gesonderte WebUI-genehmigte
|
||||
Windows-Skript-/SYSTEM-Abnahme folgen. W32Time-Konfiguration, Dienste,
|
||||
Geräteidentitäten, PKI und Journale wurden durch diese lokale Arbeit nicht
|
||||
angefasst.
|
||||
|
||||
## Aktueller kohärenter Nachtrag nach URI- und Reviewfix
|
||||
|
||||
Der neue separate Fall763baf69-10b1-4307-9c99-6942c0f8945f bindet184 Inputs
|
||||
einschließlich des gemeinsamen Codecs mit der korrigierten Audience
|
||||
`/agent/v1/time-attestation`. Der ursprüngliche180-Input-Snapshot bleibt
|
||||
unverändert. Der unabhängige Source-Review von updater_review meldete für das
|
||||
aktuelle Windowsmodul PASS; dies ist ausdrücklich kein nativer Rollennachweis.
|
||||
|
||||
Aktuelles Modul SHA256
|
||||
`6b66612b7a53377c91bc8e41864ac8fb9393ad40b0a6a98aa6ce746fce091ddb`,
|
||||
Inputmanifest SHA256
|
||||
`eb4609c5fca6a32ddb8ebf364775efdb59cd89f99a24b3b731212da08eac6a6e`,
|
||||
Receipt SHA256
|
||||
`e013738caed2d8e02b98ffd1b41e47a80840c44d3dbf895e9a3952b4311ce927`.
|
||||
Private Belege:
|
||||
`devstate/windows-signed-clock/qualification-763baf69-10b1-4307-9c99-6942c0f8945f/`.
|
||||
|
||||
Tatsächlich lokal auf den eingefrorenen Bytes bestanden:
|
||||
|
||||
- Release-Linux-Testbinary gebaut und dessen vollständige Liste von13 Tests
|
||||
und0 Benchmarks geprüft. Nur die drei neuen `signed_clock::tests` ausgeführt:
|
||||
**3bestanden,0failed/ignored,10 übrige Tests ausdrücklich herausgefiltert**.
|
||||
Hinzugekommen ist die konkrete Job-/Zeitkey-Rollentrennung auch bei anderer
|
||||
Hexschreibweise; der Fencetest prüft nun auch den Connectionhead.
|
||||
- Windows-GNU-Alltargetscheck und Alltargets-Clippy mit `-D warnings` bestanden.
|
||||
- Windows-Lib-Testbinary aus genau denselben184 Inputs tatsächlich gelinkt.
|
||||
- Formatcheck der neuen Moduldatei bestanden; keine Unterdrückungen ergänzt.
|
||||
|
||||
Der erste Windows-Linkversuch dieses Falls scheiterte ausschließlich lokal am
|
||||
Schreibschutz der früher qualifizierten Testexe im wiederverwendeten Target.
|
||||
Der frühere Pfad und SHA29c037f6 blieben erhalten. Der unveränderte neue
|
||||
Sourcesnapshot wurde danach in einem neuen eigenen Windowstarget erfolgreich
|
||||
gelinkt; der ursprüngliche Fehlerbericht bleibt101 und wird nicht überschrieben.
|
||||
Keine Lockerung des Readers oder der alten Artefaktrechte.
|
||||
|
||||
Die qualifizierte neue Linuxexe hat3374576Byte, SHA256
|
||||
`0896a3098f493b67b48e774de5cfe9bca682d2a19ff10971c62c9c7b9681ec14`.
|
||||
Der Native-Operator muss zunächst exakt die vollständige13er-Liste verlangen
|
||||
und anschließend ausschließlich die drei neuen Namen auswählen; kein erneutes
|
||||
Ausführen der zehn alten Fälle oder Verschweigen ihrer Filterung. Dies ist der
|
||||
vorbereitete Linux-first-Nachweis, **hier durch diesen Worker nicht auf der
|
||||
Cloud-VM ausgeführt**.
|
||||
|
||||
Die neue Windows-Testexe hat75360791Byte, SHA256
|
||||
`3421368eff990d197889da58aa09463e00eff40e1cfebfcfdf1e9b9382e10f03`.
|
||||
Sie wurde hier nicht auf Windows ausgeführt. Bauen, Linken und Source-Review
|
||||
eröffnen weiterhin keine Capability. Sämtliche zuvor genannten tatsächlichen
|
||||
Timer-, Rollen-, Provisionierungs-, Transport- und Runtimegates bleiben offen.
|
||||
|
||||
|
||||
## Tatsächlicher Linux-first-Nachweis der drei Guards
|
||||
|
||||
Root führte den unabhängig geprüften Runner
|
||||
`deploy/windows_signed_clock_linux_acceptance.py`, SHA256
|
||||
`70b029a441d27814f646a75cfb69ff9e5af356776027a7f836a252964a29aafd`,
|
||||
im Originalfall `6ea36dec-254e-4a82-8d1c-c72a1f959ed2` auf der Cloud-Linux-VM
|
||||
aus: **3bestanden,0ignored,10andere Tests gefiltert, Exit0**.
|
||||
Die vollständige13er-Liste musste zuvor exakt stimmen. Separater lesender
|
||||
Originalfall-Readback vollständig; bekannte drei RMM-Prozessgenerationen,
|
||||
Kontrollbytes, Boot und DB-/Lock-Dateiidentitäten erhalten. Kein RMM-Job,
|
||||
Produktzeitquery oder Dienststeuerung; Full weiter Autostart disabled.
|
||||
|
||||
Tatsächlich prepare, einmal execute und read mit obigem Originalfall ausgeführt.
|
||||
FallmanifestSHA256
|
||||
`cc83d7bc455dfaa2e0c7b0305b5713452a74ad0b60730c6058132a761aa5f157`;
|
||||
ExecuteSHA256
|
||||
`0a86c11133bce801c86d3af8bd7e1eadfeacdf49456f4ae17291e7281b8ade1f`;
|
||||
ReadbackSHA256
|
||||
`81138562175bf71bc14c0f5cf9ddc37b434c8d7751196b12c90140db5c29e9f1`.
|
||||
Private184Inputs und ursprüngliche Qualifikationsbelege bleiben unverändert.
|
||||
|
||||
Der veröffentlichte erste Modulstand entspricht exakt6b66612b. Die
|
||||
`lib.rs`-Modulregistrierung wurde danach ausschließlich alphabetisch gemäß
|
||||
rustfmt geordnet; die ursprünglichen Compilerinputs werden dadurch nicht
|
||||
nachträglich geändert. Kein erneuter Semantiktest für diese reine Formatierung.
|
||||
Nachfolgende Rohcapture-/Runtimeänderungen sind eigene Quellenstände und
|
||||
werden durch diesen nativen Dreierbeleg nicht mitqualifiziert. Native Windows-
|
||||
Timer und tatsächliche Zeitquelle bleiben weiter offen; Legacyclock bleibt zu.
|
||||
Reference in New Issue
Block a user