Compare commits

..
Author SHA1 Message Date
kevin_janssen 715287a559 Record optimized Windows agent and helper build from the verified directory sharing fix
Rust development slice / linux (push) Failing after 6s
2026-11-15 17:17:42 +01:00
kevin_janssen e952698f5e Allow protected Windows profile publication while the public directory stays pinned
Rust development slice / linux (push) Failing after 6s
2026-11-15 17:10:54 +01:00
kevin_janssen aa36b178aa Record verified cloud receiver and automatic close time for the console window
Rust development slice / linux (push) Failing after 6s
2026-11-15 17:05:23 +01:00
kevin_janssen d37160ba41 Return fixed Windows maintenance results over a foreground loopback SSH forward
Rust development slice / linux (push) Failing after 7s
2026-11-15 17:03:38 +01:00
kevin_janssen 577132fb42 Expose the existing passive Windows console reader as a directly runnable script
Rust development slice / linux (push) Failing after 6s
2026-11-15 17:01:33 +01:00
kevin_janssen ca588abce4 Prepare guarded console completion for the verified Windows time profile
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:56:27 +01:00
kevin_janssen 53d17757ab Record operator verification of the retained Windows time profile candidate
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:53:58 +01:00
kevin_janssen 27bb6a1257 Merge commit 'cd80745'
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:45:46 +01:00
kevin_janssen cd80745d44 Add fixed read-only diagnostics for the original partial Windows time profile
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:45:24 +01:00
kevin_janssen 81d78aaf8f Merge branch 'codex/agent-update-observation-scope'
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:44:36 +01:00
kevin_janssen 0ecfb98204 Accept passive agent update observations with verified SQLx migration
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:44:24 +01:00
kevin_janssen cd44bdb735 Accept restored Windows heartbeats and separate cloud inventory through MCP
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:41:32 +01:00
kevin_janssen b0076d14be Verify API-only telemetry deployment against existing cloud runtime
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:41:11 +01:00
kevin_janssen e46f11d3f9 Record native Windows service change, profile blocker and ARM64 telemetry fix build
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:31:53 +01:00
kevin_janssen 895d107918 Merge commit 'b5c7292'
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:31:21 +01:00
kevin_janssen abdf392f31 Merge commit '54db5b7'
Rust development slice / linux (push) Failing after 6s
# Conflicts:
#	docs/windows-signed-clock-upgrade-plan.md
2026-11-15 16:29:40 +01:00
kevin_janssen 2812bdaf27 Keep passive update observations separate from device base inventory
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:26:37 +01:00
kevin_janssen 54db5b72a3 Record actual Windows passive pair replacement and independent preservation recovery
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:25:34 +01:00
kevin_janssen 03e5964474 Merge commit '7c643b0'
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:16:18 +01:00
kevin_janssen 5d3141f1df Merge commit '4ba2439' 2026-11-15 16:16:18 +01:00
kevin_janssen 4ba243998c Verify typed Windows maintenance controller and fresh original pair baseline
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:16:03 +01:00
kevin_janssen 7c643b0eeb Record independent typed SCM and profile source review
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:14:35 +01:00
kevin_janssen d3cd373d5e Merge commit '0c970dc'
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:14:23 +01:00
kevin_janssen b47677b3a5 Merge commit '99aedc1' 2026-11-15 16:14:23 +01:00
kevin_janssen 99aedc14b1 Normalize ETS-wrapped JSON scalars before Windows maintenance state comparison
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:14:01 +01:00
kevin_janssen 4c6874a92b Merge commit 'f6ebd0230877d2805ab7cd117d095f187e8305c7'
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:11:47 +01:00
kevin_janssen f6ebd02308 Record local PowerShell and interop checks for closeout reader
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:11:22 +01:00
kevin_janssen b5425fc152 Merge commit 'cdcdb36'
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:09:42 +01:00
kevin_janssen 8d1e6c99d7 Merge commit '2f9e453' 2026-11-15 16:09:42 +01:00
kevin_janssen cdcdb36c13 Preserve native timestamp precision in passive time closeout
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:09:21 +01:00
kevin_janssen 2f9e45302a Verify final Windows passive pair staging and fresh native baseline after reconnect
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:06:37 +01:00
kevin_janssen 3ec30d373d Verify resumed Windows maintenance window on the guest
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:04:57 +01:00
kevin_janssen 43e696ff3f Resume the interrupted foreground console window within its existing deadline
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:02:07 +01:00
kevin_janssen 16eb5f86cf Identify individual Windows maintenance preflight mismatches
Rust development slice / linux (push) Failing after 7s
2026-11-15 15:59:26 +01:00
kevin_janssen 4e55e04b97 Merge commit '8bee0ad'
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:54:07 +01:00
kevin_janssen 7f4066b337 Verify stored Windows telemetry reached MCP after notebook resume
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:53:07 +01:00
kevin_janssen 725cddd5b2 Merge commit '44f65c205b1db0849654bb4e38ff766d491e90b2'
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:52:04 +01:00
kevin_janssen 44f65c205b Prepare read-only passive Windows time closeout collector
Rust development slice / linux (push) Failing after 7s
2026-11-15 15:51:25 +01:00
kevin_janssen ef509b3eb2 Merge commit 'd9c1311'
Rust development slice / linux (push) Failing after 7s
# Conflicts:
#	docs/windows-signed-clock-upgrade-plan.md
2026-11-15 15:49:58 +01:00
kevin_janssen 0ef1959c07 Link the exact Windows release sources and current VM acceptance state
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:49:35 +01:00
kevin_janssen d9c1311332 Bind final passive Windows agent and record transport refusal without service effects
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:49:25 +01:00
kevin_janssen 64214fc41a Record Windows agent recovery and SSH banner timeout after host suspend
Rust development slice / linux (push) Failing after 7s
2026-11-15 15:48:27 +01:00
kevin_janssen 95bcd201fc Qualify the exact passive release source on the Windows VM
Rust development slice / linux (push) Failing after 6s
2026-11-15 14:47:50 +01:00
kevin_janssen 786efe65be Qualify the passive Windows release candidate on the Linux VM
Rust development slice / linux (push) Failing after 6s
2026-11-15 14:46:30 +01:00
kevin_janssen be2b0e36d7 Merge commit 'e6debe5'
Rust development slice / linux (push) Failing after 7s
2026-11-15 14:45:00 +01:00
kevin_janssen cc821246cc Record verified passive time samples for each Windows service role
Rust development slice / linux (push) Failing after 7s
2026-11-15 14:44:33 +01:00
kevin_janssen e6debe5ba6 Compare Windows maintenance state structurally and reject colliding object keys
Rust development slice / linux (push) Failing after 6s
2026-11-15 14:41:30 +01:00
kevin_janssen 456734000b Record Windows maintenance refusal before effects and prove JSON order mismatch
Rust development slice / linux (push) Failing after 6s
2026-11-15 14:39:18 +01:00
kevin_janssen 6e30a2a1fa Record nine native Windows signed time checks
Rust development slice / linux (push) Failing after 6s
2026-11-15 14:36:31 +01:00
kevin_janssen 656102bd25 Verify signed time independently of job admission for passive Windows clients
Rust development slice / linux (push) Failing after 7s
2026-11-15 14:35:22 +01:00
kevin_janssen 94b912df8d Merge commit 'a8757ed4168f631e0e4c596b03d0d4b146e3af84'
Rust development slice / linux (push) Failing after 7s
2026-11-15 14:34:22 +01:00
kevin_janssen a8757ed416 Record isolated native Windows protected key file acceptance
Rust development slice / linux (push) Failing after 7s
2026-11-15 14:33:52 +01:00
kevin_janssen 480e261c0c Verify fresh Windows passive pair staging and original native baseline
Rust development slice / linux (push) Failing after 6s
2026-11-15 14:30:50 +01:00
24 changed files with 1832 additions and 66 deletions
+33 -3
View File
@@ -53,7 +53,7 @@ impl Client {
ipc::service_sid(crate::SERVICE_NAME)?,
ipc::service_sid(ipc::HELPER_SERVICE)?,
];
let _root = ipc::PinnedFile::open(Path::new(PUBLIC_ROOT), true, &readers, &[], false)?;
let _root = ipc::PinnedFile::open_read_shared(Path::new(PUBLIC_ROOT), true, &readers, &[])?;
let mut file = ipc::PinnedFile::open(Path::new(PIN_PATH), false, &readers, &[], false)?;
ensure!(file.file.metadata()?.len() <= 16384, "HELPER_PIN_SIZE");
let mut bytes = Vec::new();
@@ -785,8 +785,38 @@ pub(crate) fn msi_test_job() -> JobPayload {
}
}
fn write_current_probe(state: &Path, value: &serde_json::Value) -> Result<()> {
write_report(state, PROBE_FILE, ".helper-probe.pending", value)
}
/// A historical observation by the agent. The helper lane calls this only after
/// the authenticated peer has acknowledged its own signature verification.
pub fn record_verified_time(
state: &Path,
request: &rmm_time_attestation::Request,
response_sha256: &str,
observed_at: chrono::DateTime<chrono::Utc>,
) -> Result<()> {
use sha2::{Digest, Sha256};
let (filename, pending) = match request.context.role {
rmm_time_attestation::Role::Agent => ("agent-time-sample.json", ".agent-time.pending"),
rmm_time_attestation::Role::SystemHelper => {
("helper-time-sample.json", ".helper-time.pending")
}
};
let value = json!({
"schema_version": 1, "agent_pid": std::process::id(), "observed_at": observed_at,
"role": request.context.role, "windows_boot_id": request.context.windows_boot_id,
"connection_generation": request.context.connection_generation,
"verifier_incarnation": request.context.verifier_incarnation,
"request_sha256": format!("{:x}", Sha256::digest(serde_json::to_vec(request)?)),
"response_sha256": response_sha256
});
write_report(state, filename, pending, &value)
}
fn write_report(state: &Path, name: &str, pending: &str, value: &serde_json::Value) -> Result<()> {
native::private_path(state, true)?;
let path = state.join(PROBE_FILE);
let path = state.join(name);
if path.try_exists()? {
native::private_path(&path, false)?;
}
@@ -794,7 +824,7 @@ fn write_current_probe(state: &Path, value: &serde_json::Value) -> Result<()> {
ensure!(bytes.len() <= 8192, "HELPER_PROBE_REPORT_LIMIT");
// One fixed create-only staging file bounds even interrupted-report state.
// A leftover from a killed process is refused; it is never overwritten.
let temporary = state.join(".helper-probe.pending");
let temporary = state.join(pending);
let mut file = std::fs::OpenOptions::new()
.write(true)
.create_new(true)
+3 -1
View File
@@ -216,7 +216,9 @@ pub fn read_settings() -> Result<(Settings, Vec<PinnedFile>)> {
let agent = ipc::service_sid(crate::SERVICE_NAME)?;
let helper = ipc::service_sid(ipc::HELPER_SERVICE)?;
let readers = vec![agent, helper];
let root = PinnedFile::open(Path::new(PUBLIC_ROOT), true, &readers, &[], false)?;
// A rename into PUBLIC_ROOT opens the directory with FILE_ADD_FILE.
// The handle stays read-only and denies deletion of the pinned directory.
let root = PinnedFile::open_read_shared(Path::new(PUBLIC_ROOT), true, &readers, &[])?;
let mut file = PinnedFile::open(Path::new(CONFIG_PATH), false, &readers, &[], false)?;
ensure!(file.file.metadata()?.len() <= 32768, "SYSTEM_CONFIG_SIZE");
use std::io::Read;
+79 -17
View File
@@ -177,6 +177,7 @@ struct TimeRefresh {
clock: rmm_agent_windows::signed_clock::RuntimeClock,
helper: Option<rmm_agent_windows::helper_runtime::Client>,
tasks: Vec<tokio::task::JoinHandle<()>>,
samples: Vec<Arc<std::sync::OnceLock<VerifiedTimeSample>>>,
}
#[cfg(feature = "system-helper")]
impl Drop for TimeRefresh {
@@ -189,6 +190,30 @@ impl Drop for TimeRefresh {
}
}
#[cfg(feature = "system-helper")]
struct VerifiedTimeSample {
request: rmm_time_attestation::Request,
response_hash: String,
observed_at: chrono::DateTime<Utc>,
}
#[cfg(feature = "system-helper")]
impl VerifiedTimeSample {
fn new(request: rmm_time_attestation::Request, response_hash: String) -> Self {
Self {
request,
response_hash,
observed_at: Utc::now(),
}
}
fn persist(&self, state: &Path) -> Result<()> {
rmm_agent_windows::helper_runtime::record_verified_time(
state,
&self.request,
&self.response_hash,
self.observed_at,
)
}
}
#[cfg(feature = "system-helper")]
async fn time_response(
client: &reqwest::Client,
address: std::net::SocketAddr,
@@ -458,9 +483,13 @@ impl Agent {
identity: &crate::certificate_rotation::DeviceIdentity,
) -> Result<()> {
ensure!(self.time_refresh.is_none(), "TIME_REFRESH_ALREADY_RUNNING");
if !self.config.enable_jobs {
use rmm_agent_windows::signed_clock::{CONFIG_PATH, SamplingMode};
// Presence opts into sampling only. Each role opens and verifies the
// protected profile and signed response itself before accepting time.
let Some(mode) = SamplingMode::configured(self.config.enable_jobs, Path::new(CONFIG_PATH))?
else {
return Ok(());
}
};
let client = crate::https_channel::mtls_client(
self.config.connect_address,
&self.ca,
@@ -480,6 +509,17 @@ impl Agent {
let own_stop = stop.clone();
let own_http = client.clone();
let address = self.config.connect_address;
// Only the connection owner publishes observations. Dropping it also
// discards unfinished samples, so an old worker cannot overwrite a newer report.
let sample_slot =
|| (mode == SamplingMode::Passive).then(|| Arc::new(std::sync::OnceLock::new()));
let own_receipt = sample_slot();
let helper_receipt = helper.as_ref().and_then(|_| sample_slot());
let samples = own_receipt
.iter()
.chain(helper_receipt.iter())
.cloned()
.collect();
tasks.push(tokio::spawn(async move {
while !own_stop.load(Ordering::SeqCst) {
let result = async {
@@ -489,18 +529,18 @@ impl Agent {
let request = own_clock.begin(generation)?;
let bytes = time_response(&own_http, address, &request).await?;
ensure!(!own_stop.load(Ordering::SeqCst), "TIME_CONNECTION_CLOSED");
own_clock.complete(generation, &bytes)
own_clock.complete(generation, &bytes)?;
if let Some(slot) = own_receipt.as_ref().filter(|s| s.get().is_none()) {
let hash = format!("{:x}", Sha256::digest(&bytes));
let _ = slot.set(VerifiedTimeSample::new(request, hash));
}
Ok::<(), anyhow::Error>(())
}
.await;
if result.is_err() {
let _ = own_clock.close_generation(generation);
}
tokio::time::sleep(if result.is_ok() {
Duration::from_millis(20)
} else {
Duration::from_millis(500)
})
.await;
tokio::time::sleep(mode.interval(result.is_ok())).await;
}
let _ = own_clock.close_generation(generation);
}));
@@ -515,18 +555,20 @@ impl Agent {
!helper_stop.load(Ordering::SeqCst),
"TIME_CONNECTION_CLOSED"
);
time_helper.time_complete(generation, bytes).await
let pending = helper_receipt.as_ref().filter(|s| s.get().is_none());
let report =
pending.map(|slot| (slot, format!("{:x}", Sha256::digest(&bytes))));
time_helper.time_complete(generation, bytes).await?;
if let Some((slot, hash)) = report {
let _ = slot.set(VerifiedTimeSample::new(request, hash));
}
Ok::<(), anyhow::Error>(())
}
.await;
if result.is_err() {
let _ = time_helper.time_close(generation).await;
}
tokio::time::sleep(if result.is_ok() {
Duration::from_millis(20)
} else {
Duration::from_millis(500)
})
.await;
tokio::time::sleep(mode.interval(result.is_ok())).await;
}
let _ = time_helper.time_close(generation).await;
}));
@@ -537,6 +579,7 @@ impl Agent {
clock,
helper,
tasks,
samples,
});
Ok(())
}
@@ -1554,7 +1597,9 @@ impl Agent {
);
self.clock = self.clock.for_generation(generation);
#[cfg(feature = "system-helper")]
self.start_time_refresh(generation, &identity)?;
if self.config.enable_jobs {
self.start_time_refresh(generation, &identity)?;
}
self.queue_inventory(generation)?;
self.queue_update_observation(generation)?;
self.replay(&channel, generation).await?;
@@ -1673,6 +1718,15 @@ impl Agent {
}
}
if heartbeat.elapsed() >= heartbeat_after {
#[cfg(feature = "system-helper")]
if !self.config.enable_jobs
&& self.time_refresh.is_none()
&& self.start_time_refresh(generation, &identity).is_err()
{
// An absent or unreadable profile must never take passive
// inventory offline. Retry setup at the next heartbeat.
eprintln!("PASSIVE_SIGNED_TIME_UNAVAILABLE");
}
let payload = Payload::Heartbeat(Heartbeat {
instance_id: self.instance.clone(),
uptime_seconds: self.started.elapsed().as_secs(),
@@ -1689,6 +1743,14 @@ impl Agent {
)?;
channel.poll(poll).await?;
}
#[cfg(feature = "system-helper")]
if let Some(refresh) = &mut self.time_refresh {
let state = &self.config.state_directory;
refresh.samples.retain(|slot| {
slot.get()
.is_none_or(|sample| sample.persist(state).is_err())
});
}
heartbeat = Instant::now();
heartbeat_after = Duration::from_millis(rand::random_range(27000..33000));
}
+48 -2
View File
@@ -10,6 +10,29 @@ use uuid::Uuid;
const SECOND_NS: u64 = 1_000_000_000;
const MAX_BASE_ERROR_NS: u64 = 10_000_000;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SamplingMode {
Passive,
Jobs,
}
impl SamplingMode {
pub fn configured(jobs: bool, profile: &std::path::Path) -> std::io::Result<Option<Self>> {
if jobs {
return Ok(Some(Self::Jobs));
}
Ok(profile.try_exists()?.then_some(Self::Passive))
}
pub fn interval(self, verified: bool) -> std::time::Duration {
use std::time::Duration;
match (self, verified) {
(Self::Passive, _) => Duration::from_secs(30),
(Self::Jobs, true) => Duration::from_millis(20),
(Self::Jobs, false) => Duration::from_millis(500),
}
}
}
fn independent_time_key(time_key_hex: &str, job_key_hex: &str) -> Result<[u8; 32]> {
fn decode(value: &str) -> Result<[u8; 32]> {
ensure!(
@@ -728,12 +751,11 @@ mod installed {
settings.agent.service_sid.clone(),
settings.helper.service_sid.clone(),
];
files.push(PinnedFile::open(
files.push(PinnedFile::open_read_shared(
Path::new(PUBLIC_ROOT),
true,
&readers,
&[],
false,
)?);
let mut config_file =
PinnedFile::open(Path::new(CONFIG_PATH), false, &readers, &[], false)?;
@@ -1137,6 +1159,30 @@ pub use installed::{BoundClock, CONFIG_PATH, Comparison, RuntimeClock, SignedClo
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn passive_sampling_requires_a_profile_and_uses_heartbeat_cadence() {
let dir = std::env::temp_dir().join(Uuid::new_v4().to_string());
std::fs::create_dir(&dir).unwrap();
let profile = dir.join("time-attestation.json");
assert_eq!(SamplingMode::configured(false, &profile).unwrap(), None);
assert_eq!(
SamplingMode::configured(true, &profile).unwrap(),
Some(SamplingMode::Jobs)
);
std::fs::write(&profile, b"{}").unwrap();
assert_eq!(
SamplingMode::configured(false, &profile).unwrap(),
Some(SamplingMode::Passive)
);
for verified in [false, true] {
assert_eq!(
SamplingMode::Passive.interval(verified),
std::time::Duration::from_secs(30)
);
}
std::fs::remove_dir_all(dir).unwrap();
}
fn sample(ns: u64) -> Sample {
Sample {
wall_utc_ns: 1_800_000_000_000_000_000 + ns as i64,
+1 -1
View File
@@ -128,7 +128,7 @@ async fn device_list(
.map_err(|e| e.0)?;
let mut page =
crate::pagination::Cursor::parse(state, &principal, "devices:agent_id:asc", query)?;
let rows = sqlx::query("SELECT a.agent_id,a.asset_id,a.revoked_at,a.last_contact_at,a.certificate_sha256,a.last_authenticated_certificate_sha256,a.last_authenticated_at,a.capabilities,a.enrollment_generation,a.assignment_version,o.observed_at,o.received_at,o.data,o.source_id FROM agent_installations a LEFT JOIN LATERAL (SELECT observed_at,received_at,data,source_id FROM observations WHERE tenant_id=a.tenant_id AND agent_id=a.agent_id AND received_at<=$2 ORDER BY observed_at DESC, received_at DESC LIMIT 1) o ON true WHERE ($1::uuid IS NULL OR a.asset_id=$1) AND a.agent_id>$3 AND a.created_at<=$2 ORDER BY a.agent_id LIMIT $4")
let rows = sqlx::query("SELECT a.agent_id,a.asset_id,a.revoked_at,a.last_contact_at,a.certificate_sha256,a.last_authenticated_certificate_sha256,a.last_authenticated_at,a.capabilities,a.enrollment_generation,a.assignment_version,o.observed_at,o.received_at,o.data,o.source_id FROM agent_installations a LEFT JOIN LATERAL (SELECT observed_at,received_at,data,source_id FROM observations WHERE tenant_id=a.tenant_id AND agent_id=a.agent_id AND source_id IN ('linux.base','windows.base') AND received_at<=$2 ORDER BY observed_at DESC, received_at DESC LIMIT 1) o ON true WHERE ($1::uuid IS NULL OR a.asset_id=$1) AND a.agent_id>$3 AND a.created_at<=$2 ORDER BY a.agent_id LIMIT $4")
.bind(asset)
.bind(page.as_of).bind(page.last).bind(i64::from(page.limit)+1)
.fetch_all(&mut *tx).await.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
@@ -0,0 +1,112 @@
#requires -Version 5.1
#requires -RunAsAdministrator
# Finish the single, console-verified public-file publication on the test VM.
# Run in a fresh Windows PowerShell process. No SSH or RMM job is involved.
$ErrorActionPreference = 'Stop'
$caseId = 'ad9fd154-b2be-4f5d-9e17-65abb721ceaf'
$controllerHash = 'd8b4fd4fd9ca5310cc1591ce3c2ccae5bd72a2ade43b21a8187cfdfb960b3427'
$configHash = '2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b'
$bootstrap = 'C:\ProgramData\RustDiscoveryBootstrap'
$casePath = Join-Path $bootstrap "time-profile-$caseId"
$original = Join-Path (Join-Path $bootstrap $controllerHash) 'InstallPublicTimeProfile.ps1'
$originalBytes = [IO.File]::ReadAllBytes($original)
$sha = [Security.Cryptography.SHA256]::Create()
try {
$digest = [BitConverter]::ToString($sha.ComputeHash($originalBytes)).Replace('-', '')
} finally { $sha.Dispose() }
if ($digest -ne $controllerHash) { throw 'Unexpected original controller' }
# Import the verified definitions (including native FileID/SCM checks) from the
# installed original. Its first top-level preflight and install body are excluded.
$source = [Text.Encoding]::UTF8.GetString($originalBytes)
$boundary = "`nCheckControl `$boot `$true`n"
$index = $source.IndexOf($boundary, [StringComparison]::Ordinal)
if ($index -lt 1 -or $index -ne $source.LastIndexOf($boundary, [StringComparison]::Ordinal)) {
throw 'Original controller definition boundary missing'
}
$intent = Get-Content -LiteralPath (Join-Path $casePath 'intent.json') -Raw | ConvertFrom-Json
if ($intent.id -cne $caseId -or $intent.request.id -cne $caseId -or
$intent.request.script_sha256 -cne $controllerHash -or $intent.request.config_sha256 -cne $configHash) {
throw 'Unexpected original intent'
}
$global:RmmTimeProfilePayload = $intent.request
. ([scriptblock]::Create($source.Substring(0, $index)))
CheckControl $boot $true
CheckControl $folder $true
foreach ($leaf in 'intent.json','publish-intent.json','directory-acl-intent.json','directory-acl-done.json') {
CheckControl (Join-Path $folder $leaf) $false
}
CheckControl $active $false
$activeRecord = Get-Content -LiteralPath $active -Raw | ConvertFrom-Json
if ($activeRecord.id -cne $caseId -or $activeRecord.script_sha256 -cne $controllerHash -or
$activeRecord.config_sha256 -cne $configHash -or $activeRecord.no_retry -ne $true) {
throw 'Unexpected active publication record'
}
$bytes = ConfigBytes
$publish = Get-Content -LiteralPath (Join-Path $folder 'publish-intent.json') -Raw | ConvertFrom-Json
$aclDone = Get-Content -LiteralPath (Join-Path $folder 'directory-acl-done.json') -Raw | ConvertFrom-Json
$staged = Join-Path $folder 'time-attestation.candidate.json'
$resultPath = Join-Path $folder 'result.json'
$reservation = Join-Path $folder 'console-finalization-intent.json'
foreach ($path in @($target,$resultPath,$reservation)) {
if (Test-Path -LiteralPath $path) { throw 'Existing target or finalization record: read original case' }
}
$null = ReadAcl $staged $false
$rootAcl = ReadAcl $helperRoot $true
$expected = @{
volume_serial = '9815088561147542064'
file_id = '6d990300000003000000000000000000'
bytes = 1177
acl_sha256 = '3a426f649cd6ff4e82bf70205c8ecc7d5b2c0775fa1e10fc30ce35de9bb12493'
sha256 = $configHash
}
if ($publish.create_once -ne $true -or $publish.config_sha256 -cne $configHash -or
!(JsonEqual $expected $publish.staged) -or !(JsonEqual $expected (FileIdentity $staged)) -or
(FileVolume $helperRoot) -cne $expected.volume_serial -or $rootAcl.Sddl -cne $aclDone.sddl -or
(AclHash $helperRoot) -cne '186d85132cf0e16cbb9623ad9636b7777741939a8cae3d689a2af1eb267a7f49') {
throw 'Original file identity or permissions changed'
}
if ($p.probe_sha256 -cne '727732fb4b38ac5431a330527bd52a3ab80af8f189ae75a7b48eceb1d4b69cac' -or
$p.system_probe_sha256 -cne '77a344912c61b7ac4a92152ae1b534ca7c36fe6f7dc4675783f20558c3a7f434') {
throw 'Unexpected native status probes'
}
$before = ActualState $true
SameLive $request.expected_native $before
SameLive $intent.before $before
if ($before.agent_kernel.creation_filetime -cne '134392294174782153' -or
$before.helper_kernel.creation_filetime -cne '134392294130218261') { throw 'Service generation changed' }
$heldAgent = [RmmPipeNative]::Open([int]$before.service.pid)
try {
$heldHelper = [RmmPipeNative]::Open([int]$before.helper_service.pid)
try {
$null = Kernel 'agent' $before.service $heldAgent
$null = Kernel 'helper' $before.helper_service $heldHelper
# WriteNew uses CreateNew. Concurrent or later invocations cannot republish.
WriteNew $reservation @{id=$caseId; config_sha256=$configHash; utc=[DateTime]::UtcNow.ToString('o')}
try {
[IO.File]::Move($staged, $target)
} catch {
$cause = $_.Exception.GetBaseException()
$failure = @{id=$caseId; phase='File.Move'; hresult=('0x{0:X8}' -f $cause.HResult); exception=$cause.GetType().FullName}
WriteNew (Join-Path $folder 'console-finalization-error.json') $failure
throw ("File.Move: {0} ({1})." -f $failure.exception, $failure.hresult)
}
$null = ReadAcl $target $false
$published = FileIdentity $target
if (!(JsonEqual $expected $published) -or (Test-Path -LiteralPath $staged)) { throw 'Publication postcheck failed' }
$after = ActualState $true
SameLive $before $after
$null = Kernel 'agent' $before.service $heldAgent
$null = Kernel 'helper' $before.helper_service $heldHelper
WriteNew $resultPath @{
id=$caseId; installed=$true; install_not_before=$intent.install_not_before
configuration=$published; native=$after; original_root_sddl=$intent.original_root_sddl
root_sddl=(Get-Acl -LiteralPath $helperRoot).Sddl; no_jobs=$true
clock_runtime_qualified=$false; services_changed=$false; private_key_read=$false
console_finalized=$true; original_move_failed=$true
}
'Zeitprofil veroeffentlicht; Dateiidentitaet und Dienstgenerationen geprueft.'
} finally { $heldHelper.Dispose() }
} finally { $heldAgent.Dispose() }
@@ -3,7 +3,8 @@
[CmdletBinding()]
param(
[Parameter(Mandatory)][DateTimeOffset]$PreviousExpiry,
[Parameter(Mandatory)][DateTimeOffset]$Until
[Parameter(Mandatory)][DateTimeOffset]$Until,
[switch]$ResumeInterrupted
)
$ErrorActionPreference = 'Stop'
$utcNow = [DateTimeOffset]::UtcNow
@@ -16,11 +17,25 @@ $raw = [IO.File]::ReadAllText($configPath)
$cfg = $raw | ConvertFrom-Json
$user = Get-LocalUser -Name 'rmm-dev'
$task = Get-ScheduledTask -TaskPath '\' -TaskName 'RmmDevReverseTunnel'
if ($task.State -ne 'Ready' -or !$user.Enabled -or !$user.AccountExpires -or
$user.AccountExpires.ToUniversalTime() -ne $PreviousExpiry.UtcDateTime -or
[DateTimeOffset]::Parse($cfg.expires_at) -ne $PreviousExpiry -or
$cfg.server -cne 'discovery.ease-technologies.de' -or (Get-Service sshd).Status -ne 'Running') {
throw 'Unexpected account, task, server or previous expiry.'
$expectedState = if ($ResumeInterrupted) { 'Disabled' } else { 'Ready' }
$expectedExpiry = if ($ResumeInterrupted) { $Until } else { $PreviousExpiry }
$mismatches = @(
if ($task.State -ne $expectedState) { "task state $($task.State) (expected $expectedState)" }
if (!$user.Enabled) { 'rmm-dev is disabled' }
if (!$user.AccountExpires) {
'rmm-dev has no account expiry'
} elseif ($user.AccountExpires.ToUniversalTime() -ne $expectedExpiry.UtcDateTime) {
"account expiry $($user.AccountExpires.ToUniversalTime().ToString('o')) (expected $($expectedExpiry.UtcDateTime.ToString('o')))"
}
if ([DateTimeOffset]::Parse($cfg.expires_at) -ne $expectedExpiry) {
"configuration expiry $($cfg.expires_at) (expected $($expectedExpiry.UtcDateTime.ToString('o')))"
}
if ($cfg.server -cne 'discovery.ease-technologies.de') { 'configured server differs' }
$sshdState = (Get-Service -Name sshd).Status
if ($sshdState -ne 'Running') { "sshd state $sshdState (expected Running)" }
)
if ($mismatches.Count -gt 0) {
throw ('Maintenance window preflight failed: ' + ($mismatches -join ', '))
}
$pinned = (Get-Content -LiteralPath (Join-Path $dir 'known_hosts') -Raw).Trim()
if ($pinned -cne ('discovery.ease-technologies.de ' + $cfg.server_host_key)) {
@@ -31,9 +46,27 @@ if ($listeners.Count -ne 1 -or $listeners[0].LocalAddress -ne '127.0.0.1') {
throw 'Expected only the original loopback SSH listener.'
}
$backup = Join-Path $dir ('console-window-' + [guid]::NewGuid().ToString() + '.bak')
$originalRaw = $raw
if ($ResumeInterrupted) {
$owners = @(Get-CimInstance Win32_Process -Filter "Name='powershell.exe' OR Name='pwsh.exe' OR Name='ssh.exe'" | Where-Object {
$_.ProcessId -ne $PID -and ($_.CommandLine -match '(?:rmm-window-[0-9a-f-]+|Open-ConsoleMaintenanceWindow)\.ps1' -or
($_.Name -eq 'ssh.exe' -and $_.CommandLine -match '127\.0\.0\.1:22240:127\.0\.0\.1:22222'))
})
if ($owners.Count) { throw 'An existing maintenance console or forwarding process is still active. End the original console with Ctrl+C first.' }
$copies = @(Get-ChildItem -LiteralPath $dir -Filter 'console-window-*.bak' -File -Force)
if ($copies.Count -ne 1 -or $copies[0].Name -notmatch '^console-window-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\.bak$' -or
($copies[0].Attributes -band [IO.FileAttributes]::ReparsePoint) -or $copies[0].Length -gt 32768) {
throw 'Expected one original maintenance-window backup.'
}
$backup = $copies[0].FullName
if (Test-Path -LiteralPath ($backup + '.closed')) { throw 'Backup already closed.' }
$originalRaw = [IO.File]::ReadAllText($backup)
$original = $originalRaw | ConvertFrom-Json
if ([DateTimeOffset]::Parse($original.expires_at) -ne $PreviousExpiry) { throw 'Backup expiry differs.' }
$original.expires_at = $Until.ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:sszzz')
if (($original | ConvertTo-Json -Compress) -cne $raw) { throw 'Backup does not reconstruct the current public configuration.' }
}
$candidate = $backup + '.new'
$cfg.expires_at = $Until.ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:sszzz')
[IO.File]::WriteAllText($candidate, ($cfg | ConvertTo-Json -Compress), (New-Object Text.UTF8Encoding($false)))
$sshArgs = @('-F','NUL','-N','-T','-o','BatchMode=yes','-o','IdentitiesOnly=yes',
'-o','ForwardAgent=no','-o','StrictHostKeyChecking=yes','-o','GlobalKnownHostsFile=NUL',
'-o',('UserKnownHostsFile=' + $dir + '\known_hosts'),'-o','ExitOnForwardFailure=yes',
@@ -44,12 +77,20 @@ $ssh = $null
$disabled = $false
$accountChanged = $false
try {
Disable-ScheduledTask -InputObject $task | Out-Null
$disabled = $true
if (!$ResumeInterrupted) {
$cfg.expires_at = $Until.ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:sszzz')
[IO.File]::WriteAllText($candidate, ($cfg | ConvertTo-Json -Compress), (New-Object Text.UTF8Encoding($false)))
Disable-ScheduledTask -InputObject $task | Out-Null
$disabled = $true
}
if ((Get-ScheduledTask -TaskPath '\' -TaskName $task.TaskName).State -ne 'Disabled' -or
[IO.File]::ReadAllText($configPath) -cne $raw) { throw 'Existing bootstrap changed.' }
[IO.File]::Replace($candidate, $configPath, $backup)
Set-LocalUser -SID $user.SID -AccountExpires $Until.LocalDateTime
if ($ResumeInterrupted) {
$disabled = $true
} else {
[IO.File]::Replace($candidate, $configPath, $backup)
Set-LocalUser -SID $user.SID -AccountExpires $Until.LocalDateTime
}
$accountChanged = $true
if ((Get-LocalUser -SID $user.SID).AccountExpires.ToUniversalTime() -ne $Until.UtcDateTime) {
throw 'Unexpected account expiry after renewal.'
@@ -65,7 +106,7 @@ try {
try { if (!$ssh.HasExited) { $ssh.Kill(); $ssh.WaitForExit() } } finally { $ssh.Dispose() }
}
if ($accountChanged) { Set-LocalUser -SID $user.SID -AccountExpires $PreviousExpiry.LocalDateTime }
if (Test-Path -LiteralPath $backup) { [IO.File]::Replace($backup, $configPath, ($backup + '.closed')) }
if ($disabled -and [IO.File]::ReadAllText($configPath) -ceq $raw) { Enable-ScheduledTask -InputObject $task | Out-Null }
if (Test-Path -LiteralPath $candidate) { Remove-Item -LiteralPath $candidate }
if ($disabled -and (Test-Path -LiteralPath $backup)) { [IO.File]::Replace($backup, $configPath, ($backup + '.closed')) }
if ($disabled -and [IO.File]::ReadAllText($configPath) -ceq $originalRaw) { Enable-ScheduledTask -InputObject $task | Out-Null }
if (!$ResumeInterrupted -and (Test-Path -LiteralPath $candidate)) { Remove-Item -LiteralPath $candidate }
}
@@ -0,0 +1,105 @@
#requires -Version 5.1
#requires -RunAsAdministrator
# The relay receives a fixed public receipt. There is no command reader.
$ErrorActionPreference = 'Stop'
$until = [DateTimeOffset]::Parse('2026-11-15T17:00:00+00:00')
$deadline = [DateTimeOffset]::UtcNow.AddMinutes(12)
if ($deadline -gt $until) { $deadline = $until }
if ($deadline -le [DateTimeOffset]::UtcNow) { throw 'Das Wartungsfenster ist abgelaufen.' }
$base = 'https://gitea.incoso.eu/kevin_janssen/rust-discovery/raw/commit/577132fb422bf854276b3afb5bafdb12d2c08427/deploy/windows'
$bootstrap = 'C:\ProgramData\RustDiscoveryBootstrap'
$caseId = 'ad9fd154-b2be-4f5d-9e17-65abb721ceaf'
$case = Join-Path $bootstrap "time-profile-$caseId"
$access = 'C:\ProgramData\RmmDevAccess'
$sshBin = Join-Path $env:WINDIR 'System32\OpenSSH'
$known = Join-Path $access 'known_hosts'
$key = Join-Path $access 'tunnel_ed25519'
$fp = & "$sshBin\ssh-keygen.exe" -lf $known
if ($LASTEXITCODE -ne 0 -or @($fp).Count -ne 1 -or
$fp.Split(' ')[1] -cne 'SHA256:+NEin4XJc3CbhjQi7/ZpMIgxOrXn8AT2tlpTaXW5quw') { throw 'Server-Hostpin stimmt nicht.' }
$session = [guid]::NewGuid().ToString()
$work = Join-Path $bootstrap "time-receipt-$session"
$null = New-Item -ItemType Directory -Path $work
$listener = $null
$ssh = $null
$scripts = [ordered]@{
'Complete-OriginalTimeProfile.ps1' = '5ad85ae7a3a513d3cc2f5f5dca3e48eb42fd863522c3384f9c64cdcf0273ef1a'
'Read-PassiveTimeSamples.ps1' = 'd9e2b9344c19af1296b86ec70ba754ef820f369ac5ec897979bd4233e0722d04'
}
try {
foreach ($name in $scripts.Keys) {
$path = Join-Path $work $name
Invoke-WebRequest -UseBasicParsing -Uri "$base/$name" -OutFile $path -TimeoutSec 30
if ((Get-FileHash -LiteralPath $path).Hash -ne $scripts[$name]) { throw "Downloadhash: $name" }
Unblock-File -LiteralPath $path
}
$listener = [Net.Sockets.TcpListener]::new([Net.IPAddress]::Loopback, 0)
$listener.Start(4)
$port = $listener.LocalEndpoint.Port
$options = @('-F','NUL','-N','-T','-o','BatchMode=yes','-o','IdentitiesOnly=yes',
'-o','ForwardAgent=no','-o','StrictHostKeyChecking=yes','-o','GlobalKnownHostsFile=NUL',
'-o',"UserKnownHostsFile=$known",'-o','ExitOnForwardFailure=yes','-o','ConnectTimeout=10',
'-o','ServerAliveInterval=15','-o','ServerAliveCountMax=2','-i',$key,
'-R',"127.0.0.1:22240:127.0.0.1:$port",'rmm-win-tunnel@discovery.ease-technologies.de')
$ssh = Start-Process -FilePath "$sshBin\ssh.exe" -ArgumentList $options -PassThru -NoNewWindow
if ($ssh.WaitForExit(1800)) { throw "SSH Exit $($ssh.ExitCode)" }
Write-Host 'Wartungsfenster aktiv. Dieses Fenster offen lassen. Strg+C beendet es.'
$receipt = [ordered]@{session=$session; case_id=$caseId; phase='preflight'; read_only_channel=$true}
$result = Join-Path $case 'result.json'
try {
if (!(Test-Path -LiteralPath $result)) {
$null = & (Join-Path $work 'Complete-OriginalTimeProfile.ps1')
}
$record = Get-Content -LiteralPath $result -Raw | ConvertFrom-Json
$actual = Get-FileHash -LiteralPath 'C:\ProgramData\RustDiscoverySystem\time-attestation.json'
if ($record.id -cne $caseId -or $record.installed -ne $true -or
$record.console_finalized -ne $true -or $record.clock_runtime_qualified -ne $false -or
$actual.Hash -ne '2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b') { throw 'Unexpected publication result' }
$marker = Get-Content -LiteralPath (Join-Path $case 'console-finalization-intent.json') -Raw | ConvertFrom-Json
if ($marker.id -cne $caseId -or $marker.config_sha256 -ne $actual.Hash) { throw 'Unexpected finalization intent' }
$receipt.phase = 'published'
$receipt.publication_since = $marker.utc
$receipt.result_sha256 = (Get-FileHash -LiteralPath $result).Hash
} catch {
$receipt.phase = 'finalization_failed'
$receipt.exception_type = $_.Exception.GetBaseException().GetType().FullName
$receipt.line = $_.InvocationInfo.ScriptLineNumber
$receipt.file = [IO.Path]::GetFileName($_.InvocationInfo.ScriptName)
Write-Warning $_.Exception.Message
$failurePath = Join-Path $case 'console-finalization-error.json'
if (Test-Path -LiteralPath $failurePath) {
$failure = Get-Content -LiteralPath $failurePath -Raw | ConvertFrom-Json
if ($failure.id -ceq $caseId -and $failure.hresult -cmatch '^0x[0-9A-Fa-f]{8}$') { $receipt.move_hresult = $failure.hresult }
}
}
$readScript = Join-Path $work 'Read-PassiveTimeSamples.ps1'
$readInput = @{id=$session; agent_sha256='0549d9ebea73cff996938f859b92192cc333de194128d7c6859a3f1d2e85893c'; helper_sha256='59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e'} | ConvertTo-Json -Compress
while ([DateTimeOffset]::UtcNow -lt $deadline -and !$ssh.HasExited) {
if (!$listener.Pending()) { Start-Sleep -Milliseconds 250; continue }
$client = $listener.AcceptTcpClient()
try {
if ($receipt.phase -eq 'published') {
$receipt.native = $null
try {
$json = $readInput | & "$env:WINDIR\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -ExecutionPolicy RemoteSigned -File $readScript
if ($LASTEXITCODE -eq 0) { $receipt.native = ($json -join "`n") | ConvertFrom-Json }
} catch { Write-Warning 'Passive Zeitbelege aktuell nicht lesbar.' }
}
$client.SendTimeout = 3000
$body = [Text.Encoding]::UTF8.GetBytes(($receipt | ConvertTo-Json -Depth 16 -Compress))
if ($body.Length -gt 65536) { throw 'Ergebnis zu gross.' }
$client.GetStream().Write($body,0,$body.Length)
} catch { Write-Warning $_.Exception.Message } finally { $client.Dispose() }
}
} finally {
if ($null -ne $ssh) {
try { if (!$ssh.HasExited) { $ssh.Kill(); $ssh.WaitForExit() } } finally { $ssh.Dispose() }
}
if ($null -ne $listener) { $listener.Stop() }
foreach ($name in $scripts.Keys) {
$path = Join-Path $work $name
if (Test-Path -LiteralPath $path) { Remove-Item -LiteralPath $path }
}
if ((Get-ChildItem -LiteralPath $work -Force | Measure-Object).Count -eq 0) { [IO.Directory]::Delete($work) }
}
@@ -0,0 +1,63 @@
$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
if((($p.PSObject.Properties.Name|Sort-Object)-join',')-cne'agent_sha256,helper_sha256,id'-or[guid]::ParseExact($p.id,'D').ToString()-cne$p.id-or$p.agent_sha256-cnotmatch'^[0-9a-f]{64}$'-or$p.helper_sha256-cnotmatch'^[0-9a-f]{64}$'){throw 'Fixed public sample read'}
$state='C:\ProgramData\RustDiscovery\state';$agent='RmmDiscoveryWindows';$helper='RmmDiscoverySystemHelper'
$agentSid=(New-Object Security.Principal.NTAccount('NT SERVICE',$agent)).Translate([Security.Principal.SecurityIdentifier]).Value
$allowed=@('S-1-5-18','S-1-5-32-544',$agentSid)
function Check($path,[bool]$directory){
$i=Get-Item -LiteralPath $path -Force
if($i.PSIsContainer-ne$directory-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Regular public report path'}
$ancestor=$i.Directory;if($directory){$ancestor=$i.Parent};while($null-ne$ancestor){if($ancestor.Attributes-band[IO.FileAttributes]::ReparsePoint){throw 'Public report reparse ancestry'};$ancestor=$ancestor.Parent}
$acl=Get-Acl -LiteralPath $path;$owner=$acl.GetOwner([Security.Principal.SecurityIdentifier]).Value
if($owner-cnotin$allowed-and!(!$directory-and$owner-ceq'S-1-5-19')){throw 'Public report owner'}
$rules=@($acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Public report empty DACL'}
foreach($r in $rules){if($r.AccessControlType-ne'Allow'-or$r.IdentityReference.Value-cnotin$allowed){throw 'Public report broad DACL'}}
if($directory-and!$acl.AreAccessRulesProtected){throw 'Protected public report directory'}
return @{owner_sid=$owner;sddl=$acl.Sddl;dacl_checked=$true}
}
Add-Type -TypeDefinition @'
using System; using System.Text; using System.Runtime.InteropServices; using Microsoft.Win32.SafeHandles;
public static class RmmPassiveTimeRead {
[StructLayout(LayoutKind.Sequential)] public struct Info {public uint Attr,CL,CH,AL,AH,WL,WH,Volume,SizeH,SizeL,Links,IndexH,IndexL;}
[DllImport("kernel32.dll",SetLastError=true)] public static extern bool GetFileInformationByHandle(SafeFileHandle h,out Info i);
[DllImport("kernel32.dll",SetLastError=true)] static extern IntPtr OpenProcess(uint access,bool inherit,int pid);
[DllImport("kernel32.dll",SetLastError=true,CharSet=CharSet.Unicode)] static extern bool QueryFullProcessImageName(IntPtr h,uint flags,StringBuilder text,ref uint size);
[DllImport("kernel32.dll",SetLastError=true)] static extern bool GetProcessTimes(IntPtr h,out long creation,out long exit,out long kernel,out long user);
[DllImport("kernel32.dll",SetLastError=true)] static extern bool GetExitCodeProcess(IntPtr h,out uint code);
[DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr h);
public static string[] Process(int pid){IntPtr h=OpenProcess(0x1000,false,pid);if(h==IntPtr.Zero)throw new InvalidOperationException("QUERY_PROCESS");try{long c,e,k,u;uint code,size=32768;StringBuilder image=new StringBuilder((int)size);if(!GetProcessTimes(h,out c,out e,out k,out u)||!QueryFullProcessImageName(h,0,image,ref size)||!GetExitCodeProcess(h,out code)||code!=259)throw new InvalidOperationException("LIVE_PROCESS");return new string[]{c.ToString(System.Globalization.CultureInfo.InvariantCulture),image.ToString()};}finally{CloseHandle(h);}}
}
'@
function Hash([byte[]]$bytes){$h=[Security.Cryptography.SHA256]::Create();try{return([BitConverter]::ToString($h.ComputeHash($bytes))).Replace('-','').ToLowerInvariant()}finally{$h.Dispose()}}
function Runtime($role){
$name=$agent;$image='C:\Program Files\RustDiscovery\rmm-agent-windows.exe';$owner='NT AUTHORITY\LocalService';$mode='Auto';$sha=$p.agent_sha256
if($role-ceq'helper'){$name=$helper;$image='C:\Program Files\RustDiscovery\rmm-helper-windows.exe';$owner='LocalSystem';$mode='Manual';$sha=$p.helper_sha256}
$s=Get-CimInstance Win32_Service -Filter ("Name='"+$name+"'") -OperationTimeoutSec 5
if(!$s-or$s.State-cne'Running'-or$s.StartName-cne$owner-or$s.StartMode-cne$mode-or$s.ProcessId-le0-or$s.ServiceType-cne'Own Process'){throw 'Current fixed service role'}
$expected='"'+$image+'" --service';if($role-ceq'agent'){$expected+=' --config "C:\ProgramData\RustDiscovery\config.json"'}
if($s.PathName-cne$expected){throw 'Current fixed service command'}
$native=[RmmPassiveTimeRead]::Process([int]$s.ProcessId)
if($native[1]-cne$image-or(Get-FileHash -LiteralPath $image -Algorithm SHA256).Hash.ToLowerInvariant()-cne$sha){throw 'Current fixed service image'}
return [ordered]@{pid=[uint32]$s.ProcessId;birth_filetime=$native[0];image=$native[1];sha256=$sha;start_name=$s.StartName;start_mode=$s.StartMode;command=$s.PathName}
}
function Boot{return (Get-CimInstance Win32_OperatingSystem -Property LastBootUpTime -OperationTimeoutSec 5).LastBootUpTime.ToUniversalTime().Ticks.ToString([Globalization.CultureInfo]::InvariantCulture)}
$null=Check 'C:\ProgramData\RustDiscovery' $true;$directory=Check $state $true
$boot=Boot;$before=[ordered]@{agent=(Runtime 'agent');helper=(Runtime 'helper')};$reports=[ordered]@{}
foreach($name in @('agent-time-sample.json','helper-time-sample.json')){
$path=Join-Path $state $name
if(!(Test-Path -LiteralPath $path)){$reports[$name]=$null;continue}
$stream=[IO.File]::Open($path,[IO.FileMode]::Open,[IO.FileAccess]::Read,[IO.FileShare]::Read)
try{
$meta=Check $path $false;$info=New-Object RmmPassiveTimeRead+Info
if(![RmmPassiveTimeRead]::GetFileInformationByHandle($stream.SafeFileHandle,[ref]$info)-or$info.Links-ne1-or($info.Attr-band0x410)-ne0-or$info.SizeH-ne0-or$info.SizeL-lt1-or$info.SizeL-gt8192-or$stream.Length-ne$info.SizeL){throw 'Single-link bounded public report'}
$raw=New-Object byte[] $info.SizeL;$offset=0;while($offset-lt$raw.Length){$count=$stream.Read($raw,$offset,$raw.Length-$offset);if($count-le0){throw 'Complete held public report'};$offset+=$count}
$after=New-Object RmmPassiveTimeRead+Info
if(![RmmPassiveTimeRead]::GetFileInformationByHandle($stream.SafeFileHandle,[ref]$after)-or$after.IndexH-ne$info.IndexH-or$after.IndexL-ne$info.IndexL-or$after.WH-ne$info.WH-or$after.WL-ne$info.WL-or$after.SizeL-ne$info.SizeL-or$after.Links-ne1){throw 'Stable held public report'}
$again=Check $path $false;if($again.sddl-cne$meta.sddl-or$again.owner_sid-cne$meta.owner_sid){throw 'Stable public report security'}
$meta['volume']=$info.Volume;$meta['index_high']=$info.IndexH;$meta['index_low']=$info.IndexL;$meta['last_write_filetime']=(([uint64]$info.WH-shl32)-bor$info.WL).ToString([Globalization.CultureInfo]::InvariantCulture)
$reports[$name]=@{raw_base64=[Convert]::ToBase64String($raw);sha256=(Hash $raw);metadata=$meta}
}finally{$stream.Dispose()}
}
$after=[ordered]@{agent=(Runtime 'agent');helper=(Runtime 'helper')}
$directoryAfter=Check $state $true
if(($before|ConvertTo-Json -Depth 8 -Compress)-cne($after|ConvertTo-Json -Depth 8 -Compress)-or(Boot)-cne$boot-or$directory.sddl-cne$directoryAfter.sddl){throw 'Stable process, directory and boot during public read'}
@{id=$p.id;read_only=$true;boot_ticks=$boot;runtime=$after;state_metadata=$directory;reports=$reports;observed_at=[DateTime]::UtcNow.ToString('o')}|ConvertTo-Json -Depth 12 -Compress
+188
View File
@@ -0,0 +1,188 @@
#!/usr/bin/env python3
"""Read two public service observations; never request time or alter the guest."""
import argparse
import base64
import datetime as dt
import hashlib
import json
import os
from pathlib import Path
import re
import sys
import time
import uuid
import system_pipe_upgrade as access_bridge
import time_route_context as context_reader
ROOT = Path(__file__).resolve().parents[2]
ACCESS_ROOT = ROOT.parent / 'rust-discovery'
STATE = ROOT / 'devstate/windows-passive-time-closeout'
FIELDS = {'schema_version', 'agent_pid', 'observed_at', 'role', 'windows_boot_id',
'connection_generation', 'verifier_incarnation', 'request_sha256', 'response_sha256'}
FILES = {'agent': 'agent-time-sample.json', 'system_helper': 'helper-time-sample.json'}
HEX = re.compile(r'[0-9a-f]{64}')
SECOND_NS = 1_000_000_000
# No report is requested from a service. The only content reads on the guest
# are these two public JSONs and public executable hashes. CIM/process queries
# obtain current boot/SCM/image/birth metadata without starting another binary.
SCRIPT = Path(__file__).with_name('Read-PassiveTimeSamples.ps1').read_text(encoding='utf-8')
def need(value, tag):
if not value:
raise ValueError(tag)
def strict(pairs):
value = {}
for key, item in pairs:
need(key not in value, 'DUPLICATE_PUBLIC_FIELD')
value[key] = item
return value
def stamp(value):
need(type(value) is str, 'UTC_TIMESTAMP_REQUIRED')
match = re.fullmatch(r'(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?Z', value)
need(match is not None, 'UTC_TIMESTAMP_REQUIRED')
base = dt.datetime.strptime(match[1], '%Y-%m-%dT%H:%M:%S').replace(tzinfo=dt.timezone.utc)
elapsed = base - dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc)
return (elapsed.days * 86400 + elapsed.seconds) * SECOND_NS + int((match[2] or '').ljust(9, '0'))
def utc_ns(value):
return stamp(value.astimezone(dt.timezone.utc).isoformat().replace('+00:00', 'Z'))
def canonical_uuid(value):
need(type(value) is str and str(uuid.UUID(value)) == value and uuid.UUID(value).int > 0, 'UUID_REQUIRED')
return value
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def save(folder, name, value):
fd = os.open(folder / name, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'w') as stream:
json.dump(value, stream, indent=2)
stream.flush()
os.fsync(stream.fileno())
def windows_boot(ticks):
need(type(ticks) is str and ticks.isascii() and ticks.isdigit() and 17 <= len(ticks) <= 19, 'BOOT_TICKS')
raw = bytearray(hashlib.sha256(('rmm.windows.boot.cim.ticks.v1:' + ticks).encode()).digest()[:16])
raw[6] = (raw[6] & 15) | 0x80
raw[8] = (raw[8] & 63) | 0x80
return str(uuid.UUID(bytes=bytes(raw)))
def filetime(value):
need(type(value) is str and value.isascii() and value.isdigit(), 'FILETIME_REQUIRED')
return (int(value) - 116444736000000000) * 100
def validate(native, server, since, observed_now):
need(native['read_only'] is True and server['sql_read_only'] is True and server['secrets_read'] is False, 'READ_ONLY_WITNESSES')
current = server['installation']
caps = current['capabilities']
need(type(caps) is list and len(caps) == 3 and set(caps) == {'windows.base/1', 'heartbeat/1', 'agent.update/1'}, 'PASSIVE_SERVER_CAPABILITIES')
boot = windows_boot(native['boot_ticks'])
need(current['windows_boot_id'] == boot, 'CURRENT_SERVER_WINDOWS_BOOT')
generation = current['connection_generation']
need(type(generation) is int and generation > 0, 'CURRENT_POSITIVE_GENERATION')
now = stamp(native['observed_at'])
need(abs(now - utc_ns(observed_now)) <= 10 * SECOND_NS, 'CURRENT_WINDOWS_UTC')
records = []
for role, filename in FILES.items():
wrapped = native['reports'][filename]
need(wrapped is not None, 'PUBLIC_SERVICE_SAMPLE_MISSING')
raw = base64.b64decode(wrapped['raw_base64'], validate=True)
need(len(raw) <= 8192 and hashlib.sha256(raw).hexdigest() == wrapped['sha256'], 'PUBLIC_SAMPLE_RAW_HASH')
record = json.loads(raw, object_pairs_hook=strict)
need(set(record) == FIELDS and type(record['schema_version']) is int and record['schema_version'] == 1, 'PUBLIC_SAMPLE_SCHEMA')
need(record['role'] == role and type(record['agent_pid']) is int and record['agent_pid'] == native['runtime']['agent']['pid'], 'SAMPLE_PROCESS_ROLE')
need(record['windows_boot_id'] == boot and type(record['connection_generation']) is int and record['connection_generation'] == generation, 'SAMPLE_BOOT_GENERATION')
canonical_uuid(record['verifier_incarnation'])
for field in ('request_sha256', 'response_sha256'):
need(type(record[field]) is str and HEX.fullmatch(record[field]) is not None, 'SAMPLE_HASH_FORMAT')
observed = stamp(record['observed_at'])
modified = filetime(wrapped['metadata']['last_write_filetime'])
birth = filetime(native['runtime']['agent']['birth_filetime'])
need(since <= observed <= now + 2 * SECOND_NS and birth <= observed, 'SAMPLE_CURRENT_INSTALL_WINDOW')
need(0 <= now - modified <= 180 * SECOND_NS and 0 <= now - observed <= 180 * SECOND_NS, 'SAMPLE_FILE_AGE')
need(-2 * SECOND_NS <= modified - observed <= 90 * SECOND_NS, 'SAMPLE_PUBLICATION_DELAY')
need(wrapped['metadata']['dacl_checked'] is True, 'SAMPLE_PROTECTED_METADATA')
records.append(record)
for field in ('verifier_incarnation', 'request_sha256', 'response_sha256'):
need(records[0][field] != records[1][field], 'INDEPENDENT_ROLE_' + field.upper())
return records
def collect(args):
need(HEX.fullmatch(args.agent_sha256) and HEX.fullmatch(args.helper_sha256), 'QUALIFIED_RUNTIME_HASHES_REQUIRED')
since = stamp(args.profile_after)
need(0 <= utc_ns(dt.datetime.now(dt.timezone.utc)) - since <= 600 * SECOND_NS, 'RECENT_PROFILE_INSTALL_WINDOW')
STATE.mkdir(parents=True, mode=0o700, exist_ok=True)
ident = str(uuid.uuid4())
folder = STATE / ident
folder.mkdir(mode=0o700)
save(folder, 'intent.json', dict(id=ident, operator_sha256=sha(__file__), source_commit='cc821246ccd98ee6d3dc5c1b12c7303d3010e8a7',
read_only=True, agent_sha256=args.agent_sha256, helper_sha256=args.helper_sha256, profile_after=args.profile_after,
wait_seconds=180, in_progress_read_budget_seconds=105, sample_max_age_seconds=180, no_requests_to_services=True))
access_bridge.STATE.mkdir(parents=True, mode=0o700, exist_ok=True)
access = access_bridge.Access(ACCESS_ROOT)
deadline = time.monotonic() + 180
attempt = 0
last = 'PUBLIC_SERVICE_SAMPLE_MISSING'
while time.monotonic() < deadline:
attempt += 1
before = context_reader.rpc(access, dict(id=ident, deployment_result_sha256=context_reader.DEPLOYMENT_RESULT_SHA, image=context_reader.IMAGE), folder)
native = access.powershell(SCRIPT, dict(id=ident, agent_sha256=args.agent_sha256, helper_sha256=args.helper_sha256), timeout=45)
save(folder, f'{attempt:02d}-native.json', native) # persist before assertions
after = context_reader.rpc(access, dict(id=ident, deployment_result_sha256=context_reader.DEPLOYMENT_RESULT_SHA, image=context_reader.IMAGE), folder)
save(folder, f'{attempt:02d}-server.json', dict(before=before, after=after))
try:
need(before == after, 'SERVER_CONTEXT_CHANGED_DURING_READ')
records = validate(native, after, since, dt.datetime.now(dt.timezone.utc))
except ValueError as error:
last = str(error)
save(folder, f'{attempt:02d}-not-accepted.json', dict(reason=last, read_only=True))
if last not in ('PUBLIC_SERVICE_SAMPLE_MISSING', 'SAMPLE_BOOT_GENERATION', 'SAMPLE_PROCESS_ROLE', 'SAMPLE_CURRENT_INSTALL_WINDOW', 'SAMPLE_FILE_AGE', 'SERVER_CONTEXT_CHANGED_DURING_READ'):
raise
time.sleep(min(5, max(0, deadline-time.monotonic())))
continue
links = {name: sha(folder/name) for name in ('intent.json', f'{attempt:02d}-native.json', f'{attempt:02d}-server.json')}
save(folder, 'receipt.json', dict(id=ident, operator_sha256=sha(__file__), verified=True, read_only=True,
historical_role_samples_only=True, current_job_clock_proven=False, records=records, links=links))
print(json.dumps(dict(id=ident, verified=True, read_only=True, receipt_sha256=sha(folder/'receipt.json'))))
return
save(folder, 'incomplete.json', dict(id=ident, verified=False, read_only=True, reason=last, no_diagnostic_triggered=True))
print(json.dumps(dict(id=ident, verified=False, reason=last, read_only=True)))
raise SystemExit(1)
def guards():
forbidden = ('Start-Service', 'Stop-Service', 'Restart-Service', 'Remove-Item', 'WriteAll', 'WriteNew', 'TimeBegin', 'TimeComplete', '--native-probe', 'Snapshot', 'Execute')
need(all(item not in SCRIPT for item in forbidden), 'READ_ONLY_SOURCE_ONLY')
need(all(name in SCRIPT for name in FILES.values()), 'TWO_FIXED_REPORT_NAMES')
print('PASS local source guards; no target call')
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('guards', 'collect'))
parser.add_argument('--agent-sha256')
parser.add_argument('--helper-sha256')
parser.add_argument('--profile-after')
args = parser.parse_args()
if args.action == 'guards':
guards()
else:
need(all((args.agent_sha256, args.helper_sha256, args.profile_after)), 'ROOT_ACTUAL_PROFILE_AND_RUNTIME_REQUIRED')
guards()
collect(args)
+47 -11
View File
@@ -32,10 +32,15 @@ RUNTIME_INDEX = 'e49231e72aff7b001189b8507200c6c701f73e47f77c29194116cf1da41ca0c
COMPONENT_INDEX = '005317e652f50de3e1277be3bc42717318226208015e7c8011e1b73469cc7562'
ORIGINAL_RESULT = 'd5c4996821911a5bdac5014e9f985c56bbb592b803f2e33411dd28bb986b8eed'
ORIGINAL_INTENT = '374adc97bec41bd798409f7c4f8c7716b085e20d2b6fb64b33f7ab675e6483e2'
CANDIDATE = ROOT / 'devstate/windows-signed-clock/trusted-os-candidate-link-542cbf43-afb2-4994-b141-06e003e5e2e8'
CANDIDATE_RECEIPT = '04ed34e6e850aca77c1fd4677ddb271f7ccd9492a97f5d4e00ead4c1f032f29d'
QUALIFICATION = '96b05fe13f4d459b4b3ef78292beea33827b1ea47293ffb5921c685940e82a4d'
NEW_AGENT = '26dc9d2f6928c5a41050ac9324e041c065e7a9ae52324416f3bb6222c002ae6b'
HELPER_CANDIDATE = ROOT / 'devstate/windows-signed-clock/trusted-os-candidate-link-542cbf43-afb2-4994-b141-06e003e5e2e8'
HELPER_RECEIPT = '04ed34e6e850aca77c1fd4677ddb271f7ccd9492a97f5d4e00ead4c1f032f29d'
HELPER_QUALIFICATION = '96b05fe13f4d459b4b3ef78292beea33827b1ea47293ffb5921c685940e82a4d'
CANDIDATE = MAIN / 'devstate/windows-client/operator-window-20261115/observed-agent-build'
# Closed until Root supplies the actual completed native qualification receipt.
CANDIDATE_RECEIPT = 'f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446'
QUALIFICATION = 'f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446'
SOURCE_INPUTS = '11717fab51bd1d6bf103b1821cc1e2a84699f46cac21f2cc614acf4b68381fa4'
NEW_AGENT = '0549d9ebea73cff996938f859b92192cc333de194128d7c6859a3f1d2e85893c'
NEW_HELPER = '59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e'
PROBE = '727732fb4b38ac5431a330527bd52a3ab80af8f189ae75a7b48eceb1d4b69cac'
SYSTEM_PROBE = '77a344912c61b7ac4a92152ae1b534ca7c36fe6f7dc4675783f20558c3a7f434'
@@ -70,6 +75,28 @@ def controller():
# calibration/public-time-pin file or changes the six-field passive config.
marker = 'function State([bool]$new){\n'
prefix = replace_once(prefix, marker, marker + " if(Test-Path -LiteralPath (Join-Path $helperRoot 'time-attestation.json')){throw 'Separate time-pin provisioning required; passive bootstrap does not adopt it'}\n")
# Compare JSON objects by their contents; serialized member order is not
# identity. Arrays retain exact order and empty/null values stay distinct.
prefix = replace_once(prefix,
"function JsonEqual($a,$b){return(($a|ConvertTo-Json -Depth 40 -Compress)-ceq($b|ConvertTo-Json -Depth 40 -Compress))}",
r'''function CanonicalStateValue($value,[int]$depth=0){
if($depth-gt40){throw 'Bounded state comparison depth'}
if($null-eq$value){return $null}
# ETS wrapping does not turn a CLR JSON scalar into a JSON object.
$base=$value.PSObject.BaseObject;$culture=[Globalization.CultureInfo]::InvariantCulture
if($base-is[string]){return [string]::new($base.ToCharArray())}
if($base-is[char]){return [string]::new([char[]]@($base))}
if($base-is[bool]){return [bool]::Parse($base.ToString())}
if($base-is[sbyte]-or$base-is[int16]-or$base-is[int32]-or$base-is[int64]){return [int64]::Parse($base.ToString($culture),$culture)}
if($base-is[byte]-or$base-is[uint16]-or$base-is[uint32]-or$base-is[uint64]){return [uint64]::Parse($base.ToString($culture),$culture)}
if($base-is[single]-or$base-is[double]){$number=[double]::Parse($base.ToString('R',$culture),$culture);if([double]::IsNaN($number)-or[double]::IsInfinity($number)){throw 'Finite JSON state number required'};return $number}
if($base-is[decimal]){return [decimal]::Parse($base.ToString($culture),$culture)}
if($value-is[Collections.IDictionary]){$result=[ordered]@{};foreach($key in @($value.Keys|Sort-Object -CaseSensitive)){if($key-isnot[string]-or$result.Contains($key)){throw 'Nonunique state object key'};$result[$key]=CanonicalStateValue $value[$key] ($depth+1)};return $result}
if($value-is[pscustomobject]){$result=[ordered]@{};foreach($property in @($value.PSObject.Properties|Sort-Object -Property Name -CaseSensitive)){if($property.Name-isnot[string]-or$result.Contains($property.Name)){throw 'Nonunique state object key'};$result[$property.Name]=CanonicalStateValue $property.Value ($depth+1)};return $result}
if($value-is[Collections.IEnumerable]-and$value-isnot[string]){$result=New-Object 'Collections.Generic.List[object]';foreach($item in $value){$result.Add((CanonicalStateValue $item ($depth+1)))};return ,$result.ToArray()}
return $value
}
function JsonEqual($a,$b){return((ConvertTo-Json -InputObject (CanonicalStateValue $a) -Depth 40 -Compress)-ceq(ConvertTo-Json -InputObject (CanonicalStateValue $b) -Depth 40 -Compress))}''')
native = prior.NATIVE.replace('RmmPipeNative', 'RmmSignedClockPairNative')
phases = prior.PHASES.replace('SystemPipeUpgrade.ps1', 'SignedClockPairUpgrade.ps1').replace('RmmPipeNative', 'RmmSignedClockPairNative')
# No implicit fallthrough may become an effect, even if a future caller
@@ -156,6 +183,7 @@ def write(path, raw):
def prepare(script):
require(type(CANDIDATE_RECEIPT) is str and len(CANDIDATE_RECEIPT)==64 and QUALIFICATION==CANDIDATE_RECEIPT,'actual final native agent qualification receipt not yet bound')
result, old_intent, settings, pin, policy = original()
grant = prior.cb.contract.protected_json(MAIN/'credentials/windows-dev-access.json')
expiry = grant.get('expires_at')
@@ -164,11 +192,18 @@ def prepare(script):
deadline = dt.datetime.fromisoformat(expiry.replace('Z','+00:00'))
require((deadline-dt.datetime.now(dt.timezone.utc)).total_seconds() >= 420,'current authorization window has insufficient total maintenance/readback budget')
receipt = protected(CANDIDATE/'receipt.json', CANDIDATE_RECEIPT)
require(receipt['source_receipt_sha256'] == QUALIFICATION and receipt['input_count'] == 202
and receipt['link_exit'] == 0 and receipt['target_called'] is False
and receipt['artifacts']['rmm-agent-windows.exe']['sha256'] == NEW_AGENT
and receipt['artifacts']['rmm-helper-windows.exe']['sha256'] == NEW_HELPER,
'actual new offline-linked freshness pair, no native qualification inferred')
helper_receipt = protected(HELPER_CANDIDATE/'receipt.json', HELPER_RECEIPT)
require(receipt['source_inputs_sha256']==SOURCE_INPUTS and receipt['source_verified_before_after'] is True
and receipt['link_exit']==0 and receipt['original_helper_sha256']==NEW_HELPER
and receipt['artifacts']['rmm-agent-windows.exe']['sha256']==NEW_AGENT,
'actual final source-verified locally linked and natively qualified passive agent')
require(helper_receipt['source_receipt_sha256']==HELPER_QUALIFICATION and helper_receipt['link_exit']==0
and helper_receipt['artifacts']['rmm-helper-windows.exe']['sha256']==NEW_HELPER,
'unchanged independently linked original helper')
artifact_sources={'rmm-agent-windows.exe':CANDIDATE/'rmm-agent-windows.exe',
'rmm-helper-windows.exe':HELPER_CANDIDATE/'rmm-helper-windows.exe'}
artifacts={'rmm-agent-windows.exe':receipt['artifacts']['rmm-agent-windows.exe'],
'rmm-helper-windows.exe':helper_receipt['artifacts']['rmm-helper-windows.exe']}
ident = str(uuid.uuid4()); folder = STATE/ident; folder.mkdir(mode=0o700,parents=True)
script_sha = raw_sha(script.encode())
draft = dict(id=ident,access_expiry_utc=expiry,old_agent=OLD_AGENT,old_helper=OLD_HELPER,old_policy=OLD_POLICY,old_pin=OLD_PIN,
@@ -183,7 +218,7 @@ def prepare(script):
for name,raw in items.items():
write(folder/name,raw);files[name]=dict(bytes=len(raw),sha256=raw_sha(raw))
for name,expected in [('rmm-agent-windows.exe',NEW_AGENT),('rmm-helper-windows.exe',NEW_HELPER)]:
source=CANDIDATE/name;metadata=source.lstat()
source=artifact_sources[name];metadata=source.lstat()
require(metadata.st_nlink == 1 and metadata.st_mode&0o777 == 0o500 and sha(source) == expected,
'exact private linked candidate artifact')
dependencies=prior.dependencies();dependencies[str(Path(prior.__file__).relative_to(ROOT))]=PRIOR_SOURCE
@@ -192,7 +227,8 @@ def prepare(script):
original_case=OLD_CASE,original_result_sha256=ORIGINAL_RESULT,original_intent_sha256=ORIGINAL_INTENT,
original_runtime_index_sha256=RUNTIME_INDEX,original_component_index_sha256=COMPONENT_INDEX,
candidate_receipt_sha256=CANDIDATE_RECEIPT,qualification_sha256=QUALIFICATION,
artifacts={name:receipt['artifacts'][name] for name in ('rmm-agent-windows.exe','rmm-helper-windows.exe')},
artifacts=artifacts,helper_receipt_sha256=HELPER_RECEIPT,helper_qualification_sha256=HELPER_QUALIFICATION,source_inputs_sha256=SOURCE_INPUTS,
linux_result_sha256=receipt['linux_result_sha256'],windows_result_sha256=receipt['windows_result_sha256'],
access_expiry_utc=expiry,access_expiry_source='protected current windows-dev-access.json public expires_at; exact VM account/bootstrap-public match before effects',
server_qualification_bound=True,enter_enabled=True,time_configuration_created=False,
calibration_created=False,target_called=False,main_indices_modified=False,
@@ -0,0 +1,64 @@
"""Local public-record binding fixtures; no SSH, file staging or clock query."""
import base64
import copy
import datetime as dt
import hashlib
import json
import unittest
import passive_time_closeout as c
class Binding(unittest.TestCase):
def setUp(self):
self.now = dt.datetime(2026,11,15,14,0,tzinfo=dt.timezone.utc)
self.since = c.utc_ns(self.now - dt.timedelta(seconds=50))
ticks='638987472000000000'
boot=c.windows_boot(ticks)
epoch=dt.datetime(1601,1,1,tzinfo=dt.timezone.utc)
ft=lambda value:str(int((value-epoch).total_seconds())*10000000)
self.native=dict(read_only=True,boot_ticks=ticks,observed_at=self.now.isoformat().replace('+00:00','Z'),runtime=dict(agent=dict(pid=1234,birth_filetime=ft(self.now-dt.timedelta(minutes=1)))),reports={})
self.server=dict(sql_read_only=True,secrets_read=False,installation=dict(windows_boot_id=boot,connection_generation=10,capabilities=['windows.base/1','heartbeat/1','agent.update/1']))
for i,(role,name) in enumerate(c.FILES.items()):
record=dict(schema_version=1,agent_pid=1234,observed_at=(self.now-dt.timedelta(seconds=20)).isoformat().replace('+00:00','Z'),role=role,windows_boot_id=boot,connection_generation=10,verifier_incarnation=f'11111111-1111-4111-8111-{i+1:012d}',request_sha256=str(i+1)*64,response_sha256=str(i+3)*64)
raw=json.dumps(record).encode()
self.native['reports'][name]=dict(raw_base64=base64.b64encode(raw).decode(),sha256=hashlib.sha256(raw).hexdigest(),metadata=dict(last_write_filetime=ft(self.now-dt.timedelta(seconds=2)),dacl_checked=True))
def modify(self,name,field,value):
wrapped=self.native['reports'][name]
record=json.loads(base64.b64decode(wrapped['raw_base64']))
record[field]=value
raw=json.dumps(record).encode()
wrapped.update(raw_base64=base64.b64encode(raw).decode(),sha256=hashlib.sha256(raw).hexdigest())
def test_current_independent_pair(self):
self.assertEqual(len(c.validate(self.native,self.server,self.since,self.now)),2)
def test_pid_boot_generation_and_expired_sample_are_denied(self):
good=copy.deepcopy(self.native)
for field,value in [('agent_pid',1233),('windows_boot_id','11111111-1111-4111-8111-111111111111'),('connection_generation',9),('observed_at','2026-11-15T13:00:00Z'),('role','system_helper')]:
self.native=copy.deepcopy(good);self.modify('agent-time-sample.json',field,value)
with self.assertRaises(ValueError):c.validate(self.native,self.server,self.since,self.now)
def test_same_verifier_request_or_response_is_denied(self):
good=copy.deepcopy(self.native)
first=json.loads(base64.b64decode(good['reports']['agent-time-sample.json']['raw_base64']))
for field in ['verifier_incarnation','request_sha256','response_sha256']:
self.native=copy.deepcopy(good);self.modify('helper-time-sample.json',field,first[field])
with self.assertRaises(ValueError):c.validate(self.native,self.server,self.since,self.now)
def test_duplicate_json_field_and_unprotected_metadata_are_denied(self):
wrapped=self.native['reports']['agent-time-sample.json'];raw=base64.b64decode(wrapped['raw_base64'])
changed=raw[:-1]+b',"schema_version":1}'
wrapped.update(raw_base64=base64.b64encode(changed).decode(),sha256=hashlib.sha256(changed).hexdigest())
with self.assertRaises(ValueError):c.validate(self.native,self.server,self.since,self.now)
self.setUp();self.native['reports']['agent-time-sample.json']['metadata']['dacl_checked']=False
with self.assertRaises(ValueError):c.validate(self.native,self.server,self.since,self.now)
def test_missing_sample_is_explicit(self):
self.native['reports']['helper-time-sample.json']=None
with self.assertRaisesRegex(ValueError,'PUBLIC_SERVICE_SAMPLE_MISSING'):c.validate(self.native,self.server,self.since,self.now)
def test_native_seven_and_chrono_nine_digits_keep_exact_install_boundary(self):
native='2026-11-15T13:59:40.1234567Z'
chrono='2026-11-15T13:59:40.123456701Z'
self.assertEqual(c.stamp(chrono)-c.stamp(native),1)
self.modify('agent-time-sample.json','observed_at',native)
self.modify('helper-time-sample.json','observed_at',chrono)
since=c.stamp(native)
self.assertEqual(len(c.validate(self.native,self.server,since,self.now)),2)
with self.assertRaisesRegex(ValueError,'SAMPLE_CURRENT_INSTALL_WINDOW'):
c.validate(self.native,self.server,since+1,self.now)
if __name__=='__main__':unittest.main()
@@ -99,5 +99,42 @@ class PublicProfileContract(unittest.TestCase):
with self.assertRaises(GuardError):t.read(path,limit=1)
class OriginalPartialDiagnosticContract(unittest.TestCase):
def test_closed_reader_cannot_publish_or_repair(self):
source=t.partial_reader()
self.assertIn('time-profile-'+t.PARTIAL_ID,source)
self.assertIn('time-attestation.candidate.json',source)
self.assertIn('old_move_hresult_unknown=$true',source)
for forbidden in ('[IO.File]::Move','Set-Acl','WriteBytes','WriteNew','Start-Service','Stop-Service','CreateDirectory'):
self.assertNotIn(forbidden,source)
def test_diagnostic_executes_bound_reader_without_legacy_load_or_target_success(self):
import datetime as dt
from unittest.mock import Mock
manifest={'id':t.PARTIAL_ID,'generator_sha256':t.PARTIAL_GENERATOR_SHA,
'script_sha256':t.PARTIAL_SCRIPT_SHA,'request':{'config_sha256':t.PARTIAL_CONFIG_SHA}}
result={'id':t.PARTIAL_ID,'read_only':True,'retry_authorized':False,
'installation_verified':False,'clock_runtime_qualified':False}
access=Mock();access.powershell.return_value=result
expiry=(dt.datetime.now(dt.timezone.utc)+dt.timedelta(hours=1)).isoformat()
with tempfile.TemporaryDirectory() as root,patch.object(t,'ROOT',Path(root)), \
patch.object(t,'read',side_effect=[(b'original',manifest),(b'staged',None)]), \
patch.object(t,'load_case',side_effect=AssertionError('original case must not adopt new generator')), \
patch.object(t.raw_capture,'CaptureAccess',return_value=access), \
patch.object(t.prior.cb.contract,'protected_json',return_value={'expires_at':expiry}):
t.diagnose_partial()
call=access.powershell.call_args
executed=base64.b64decode(call.args[1]['source_base64'])
self.assertIn(t.sha(executed),call.args[0])
cases=list((Path(root)/'devstate/windows-time-profile-diagnostics').iterdir())
self.assertEqual(len(cases),1)
intent=json.loads((cases[0]/'intent.json').read_bytes())
receipt=json.loads((cases[0]/'receipt.json').read_bytes())
self.assertEqual(intent['reader_sha256'],t.sha(executed))
self.assertEqual(receipt['reader_sha256'],t.sha(executed))
self.assertTrue(receipt['old_move_hresult_unknown'])
self.assertEqual((cases[0]/'reader.ps1').read_bytes(),executed)
if __name__ == '__main__':
unittest.main()
+83 -1
View File
@@ -524,8 +524,90 @@ def target(action,ident):
write(output,canonical(result))
print(json.dumps({'id':ident,'action':action,'reply_sha256':sha(canonical(result)),'clock_runtime_qualified':False}))
# Dedicated read-only path for the already attempted original case. It never
# passes through load_case(): changing the generator must not rewrite or adopt
# the original staged controller/intent hash binding.
PARTIAL_ID = 'ad9fd154-b2be-4f5d-9e17-65abb721ceaf'
PARTIAL_MANIFEST_SHA = '0c9a3ffeed490757f7bd8c63d7e2ec28156212945094621f511e20679ce0b3b0'
PARTIAL_GENERATOR_SHA = 'a8d55b60d413c1d68f568c173e6ea32727cef8645e61eb772d24f98e22b0b10a'
PARTIAL_SCRIPT_SHA = 'd8b4fd4fd9ca5310cc1591ce3c2ccae5bd72a2ade43b21a8187cfdfb960b3427'
PARTIAL_CONFIG_SHA = '2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b'
PARTIAL_CASE = ROOT.parent/'rust-discovery-agent-updater'/'devstate/windows-time-profile-config'/PARTIAL_ID
def partial_reader():
"""Fixed file/ACL/marker observation only; no service or publication code."""
require(sha(Path(prior.__file__).read_bytes())=='e466576673a0e5c332cfc1613ae88a62f5b526015ced76b1d22473e292a995e0'
and sha(Path(prior.u.__file__).read_bytes())=='f8dc1c8fbc064e253b1fbe130fb628afef58cf45c2bafb6837d6716125b42d38',
'exact original metadata-only primitive sources')
source = prior.u.SCRIPT
functions = []
for name in ('Check','BytesHash','Hash','AclHash','CheckControl'):
start=source.index('function '+name+'(');end=source.find('\nfunction ',start+1)
require(end>start,'closed original read-only function');functions.append(source[start:end])
native=prior.NATIVE.split('function FileIdentity(',1)[0]
identity='function FileIdentity('+prior.NATIVE.split('function FileIdentity(',1)[1].split('function Kernel(',1)[0]
header=r'''$ErrorActionPreference='Stop';$inputRecord=$global:RmmPartialReaderInput
if((($inputRecord.PSObject.Properties.Name|Sort-Object)-join',')-cne'kind'-or$inputRecord.kind-cne'original-public-time-profile-ad9-readonly'){throw 'Fixed original partial profile observation'}
$sys='S-1-5-18';$admin='S-1-5-32-544';$agentSid=(New-Object Security.Principal.NTAccount('NT SERVICE','RmmDiscoveryWindows')).Translate([Security.Principal.SecurityIdentifier]).Value;$helperSid=(New-Object Security.Principal.NTAccount('NT SERVICE','RmmDiscoverySystemHelper')).Translate([Security.Principal.SecurityIdentifier]).Value
$folder='C:\ProgramData\RustDiscoveryBootstrap\time-profile-ad9fd154-b2be-4f5d-9e17-65abb721ceaf';$root='C:\ProgramData\RustDiscoverySystem';$active='C:\ProgramData\RustDiscoveryBootstrap\time-profile-initial-active.json'
'''
body=r'''function ErrorNumber($errorRecord){$ex=$errorRecord.Exception.GetBaseException();$h=[int64]$ex.HResult-band0xffffffffL;$win32=$null;if(($h-band0xffff0000L)-eq0x80070000L){$win32=$h-band0xffffL};return @{exception_type=$ex.GetType().FullName;hresult_hex=('0x{0:x8}'-f$h);win32_code=$win32}}
function ObservePublic($path){
if(!(Test-Path -LiteralPath $path)){return @{present=$false}}
try{Check $path $false;$item=Get-Item -LiteralPath $path -Force;if($item.Length-gt16384){throw 'Bounded public profile only'};$identity=FileIdentity $path;return @{present=$true;identity=$identity;attributes=[int64]$item.Attributes;creation_filetime=$item.CreationTimeUtc.ToFileTimeUtc().ToString();last_write_filetime=$item.LastWriteTimeUtc.ToFileTimeUtc().ToString();expected_hash=($identity.sha256-ceq'2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b')}}catch{return @{present=$true;observation_failed=$true;error=(ErrorNumber $_)}}
}
CheckControl $folder $true;Check $root $true
$records=[ordered]@{};foreach($name in @('intent.json','directory-acl-intent.json','directory-acl-done.json','publish-intent.json','publish-failure.json','result.json')){$path=Join-Path $folder $name;if(!(Test-Path -LiteralPath $path)){$records[$name]=@{present=$false};continue};CheckControl $path $false;$item=Get-Item -LiteralPath $path -Force;if($item.Length-gt2097152){throw 'Bounded original marker'};$value=Get-Content -LiteralPath $path -Raw|ConvertFrom-Json
$record=@{present=$true;sha256=(Hash $path);bytes=$item.Length}
if($name-ceq'intent.json'){if($value.id-cne'ad9fd154-b2be-4f5d-9e17-65abb721ceaf'-or$value.request.config_sha256-cne'2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b'-or$value.request.script_sha256-cne'd8b4fd4fd9ca5310cc1591ce3c2ccae5bd72a2ade43b21a8187cfdfb960b3427'){throw 'Original intent binding'};$record.install_not_before=$value.install_not_before;$record.no_retry=$value.no_retry}
if($name-ceq'publish-intent.json'){if($value.config_sha256-cne'2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b'-or$value.create_once-ne$true){throw 'Original publication binding'};$record.staged=$value.staged}
if($name-ceq'directory-acl-intent.json'){$record.old_sddl=$value.old_sddl};if($name-ceq'directory-acl-done.json'){$record.sddl=$value.sddl}
if($name-ceq'publish-failure.json'){$record.failure=@{exception_type=$value.exception_type;hresult_hex=$value.hresult_hex;win32_code=$value.win32_code}}
$records[$name]=$record
}
$activeRecord=@{present=$false};if(Test-Path -LiteralPath $active){CheckControl $active $false;if((Get-Item -LiteralPath $active).Length-gt8192){throw 'Bounded active original marker'};$a=Get-Content -LiteralPath $active -Raw|ConvertFrom-Json;if($a.id-cne'ad9fd154-b2be-4f5d-9e17-65abb721ceaf'-or$a.config_sha256-cne'2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b'-or$a.script_sha256-cne'd8b4fd4fd9ca5310cc1591ce3c2ccae5bd72a2ade43b21a8187cfdfb960b3427'){throw 'Original active binding'};$activeRecord=@{present=$true;sha256=(Hash $active);id=$a.id;config_sha256=$a.config_sha256;script_sha256=$a.script_sha256}}
@{id='ad9fd154-b2be-4f5d-9e17-65abb721ceaf';read_only=$true;candidate=(ObservePublic (Join-Path $folder 'time-attestation.candidate.json'));target=(ObservePublic (Join-Path $root 'time-attestation.json'));records=$records;active=$activeRecord;root_sddl=(Get-Acl -LiteralPath $root).Sddl;old_move_hresult_unknown=$true;retry_authorized=$false;installation_verified=$false;clock_runtime_qualified=$false;private_key_read=$false;service_action=$false}|ConvertTo-Json -Depth 20 -Compress
'''
reader=header+'\n'+'\n'.join(functions)+'\n'+native+identity+'\n'+body
require(all(token not in reader for token in ('[IO.File]::Move','Set-Acl','WriteBytes','WriteNew','Start-Service','Stop-Service','CreateDirectory','function State','function Probe')),'read-only original partial observer')
return reader
def diagnose_partial():
# Only a future explicitly authorized maintenance window may call this.
# The original install/read code and original markers stay untouched.
import datetime as dt
import subprocess
raw,manifest=read(PARTIAL_CASE/'manifest.json',PARTIAL_MANIFEST_SHA)
require(manifest['id']==PARTIAL_ID and manifest['generator_sha256']==PARTIAL_GENERATOR_SHA
and manifest['script_sha256']==PARTIAL_SCRIPT_SHA
and manifest['request']['config_sha256']==PARTIAL_CONFIG_SHA,'fixed original failed installation only')
read(PARTIAL_CASE/'InstallPublicTimeProfile.ps1',PARTIAL_SCRIPT_SHA,decode=False)
access=raw_capture.CaptureAccess(MAIN)
grant=prior.cb.contract.protected_json(MAIN/'credentials/windows-dev-access.json')
expiry=dt.datetime.fromisoformat(grant['expires_at'].replace('Z','+00:00'))
require((expiry-dt.datetime.now(dt.timezone.utc)).total_seconds()>=60,'current confirmed access window required for read')
source=partial_reader();digest=sha(source.encode());root=ROOT/'devstate/windows-time-profile-diagnostics';root.mkdir(mode=0o700,parents=True,exist_ok=True)
folder=root/str(uuid.uuid4());folder.mkdir(mode=0o700)
write(folder/'intent.json',canonical({'id':folder.name,'original_case':PARTIAL_ID,'original_manifest_sha256':PARTIAL_MANIFEST_SHA,'reader_sha256':digest,'read_only':True,'no_retry':True}))
# A small launcher avoids Windows' command-line limit. The source hash is
# generated from this closed reader, never accepted from a caller.
launcher=r'''$ErrorActionPreference='Stop';$q=([Console]::In.ReadLine()|ConvertFrom-Json);$raw=[Convert]::FromBase64String($q.source_base64);$h=[Security.Cryptography.SHA256]::Create();try{$s=([BitConverter]::ToString($h.ComputeHash($raw))).Replace('-','').ToLowerInvariant()}finally{$h.Dispose()};if($s-cne'READER_SHA'){throw 'Exact original partial reader'};$global:RmmPartialReaderInput=$q.input_record;&([scriptblock]::Create([Text.Encoding]::UTF8.GetString($raw)))'''.replace('READER_SHA',digest)
write(folder/'reader.ps1',source.encode())
try:result=access.powershell(launcher,{'source_base64':base64.b64encode(source.encode()).decode(),'input_record':{'kind':'original-public-time-profile-ad9-readonly'}},timeout=45)
except subprocess.TimeoutExpired:
write(folder/'timeout.json',canonical({'read_only':True,'timeout_seconds':45,'old_move_hresult_unknown':True}));raise RuntimeError('original diagnostic read timed out; no publication attempted') from None
write(folder/'reply.json',canonical(result))
require(result['id']==PARTIAL_ID and result['read_only'] is True and result['retry_authorized'] is False
and result['installation_verified'] is False and result['clock_runtime_qualified'] is False,'diagnostic observation is no installation success or authority')
write(folder/'receipt.json',canonical({'id':folder.name,'original_case':PARTIAL_ID,'reader_sha256':digest,'original_manifest_sha256':PARTIAL_MANIFEST_SHA,'reply_sha256':sha(canonical(result)),'read_only':True,'old_move_hresult_unknown':True}))
print(json.dumps({'id':folder.name,'original_case':PARTIAL_ID,'read_only':True,'receipt_sha256':sha((folder/'receipt.json').read_bytes())}))
if __name__=='__main__':
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('guards','prepare','stage','install','read'));parser.add_argument('--case');arguments=parser.parse_args()
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('guards','prepare','stage','install','read','diagnose-partial'));parser.add_argument('--case');arguments=parser.parse_args()
if arguments.action=='guards': guards();print('PASS closed public-profile source guards; no target action')
elif arguments.action=='prepare': prepare()
elif arguments.action=='diagnose-partial':
require(arguments.case is None,'diagnostic is fixed to the original ad9 case');diagnose_partial()
else: target(arguments.action,arguments.case)
+89
View File
@@ -0,0 +1,89 @@
# Migration0016: passives Updateinventar annehmen
Am2026-11-15 ist Migration0016 tatsächlich auf dem permanenten Server mit dem
regulären SQLx-Migrationspfad ausgeführt und separat nachgelesen worden. Der
bisherige Check `observations_source_id_check` ließ nur `linux.base` und
`windows.base` zu. Die laufende Gatewayversion kannte bereits die passive
`agent.update`-Beobachtung; der Datenbankcheck verweigerte deren Speicherung.
Nach dem neuen Windowsagentenwechsel waren15 entsprechende Fehler beobachtet
worden. Diese verweigerten Nachrichten werden nicht nachträglich als gespeichert
ausgegeben.
Die additive Datei `migrations/0016_agent_update_observation_scope.sql` erweitert
ausschließlich diese feste Dreiermenge. Freie Scopes bleiben verboten. Im
normalen SQLx-Transactionrahmen wird der alte Check ersetzt und der neue Check
validiert; ein Fehler rollt die Transaktion zurück. `lock_timeout=3s` begrenzt
das Warten auf Tabellenlocks, `statement_timeout=15s` jedes DDL-Statement.
Keine DML-, RLS-, FK-, PK-, Tenant-/Geräte-/Zertifikats-, Job-, Grant- oder
Policyänderung gehört zur Migration.
Tatsächlicher Fall: `cc3ea56d-6186-425a-8ef3-90562212fb1b`. Verwendet wurde das
bereits vom Orchestrator nativ ARM64 gebaute Image
`sha256:6a76343bf65c126458244f5540d4cb740988144fc77877b409f790251e7ddcc7`.
Es enthält den vorhandenen `rmm-server migrate`-Entrypoint und die echte
SQLx-`migrate!`-Migrationseinbettung. Es wurde kein zusätzlicher Builderlauf
gestartet und keine SQLx-Tabellenzeile manuell angelegt oder geändert.
Ein eigenes privates Compose-Overlay wählte ausschließlich für den temporären
`migrate`-Container dieses bereits vorhandene Image (`pull_policy: never`,
read-only RootFS, CapDropALL, NoNewPrivileges). Die vorhandene Migration-URL
blieb im normalen Compose-/Prozesskontext; sie wurde nicht ausgegeben. Der
unterstützte `docker compose … run --no-deps … migrate` führte genau einen
wirklichen SQLx-Lauf aus, Exit0. Der eigene gestoppte Container wurde nach
seinem Exit-/Image-/Falllabelbeleg entfernt. Kein API-, Gateway- oder
PostgreSQLdienst wurde durch diesen Agenten ersetzt oder neu gestartet.
API-Filterung und API-only-Deployment sind ein eigener Orchestratorschnitt.
Die tatsächliche SQLx-Historie besitzt danach Versionen1–16 jeweils mit
`success=true`; die alten15 Checksums stimmen unverändert mit den Quellinputs
überein. Version16 heißt `agent update observation scope` und besitzt SHA384
`e66ec49233c210555b5107d20b925ca6715925871aa2bf94dfb86bd5cfb39c6dc769fdf0049b615fcad503332e1cd8fc`.
Die SQL-Datei hat SHA256
`fa0953262e3a8da7f3f0366db6f3fa77ad7976ec04327b126036739eea46eebb`.
Vor dem echten SQLx-Start wurden3127 bestehende Observationzeilen serverseitig
über ihre vollständige JSON-Zeilendarstellung gehasht; unmittelbar danach waren alle
unverändert. Der ursprüngliche Fallbaseline enthielt3123Zeilen. Deren
unveränderte Fingerprints und die vollständige RLS-/Owner-/ACL-/Policy-,
FK-/PK-/sonstige Check- und Job-/Plan-/Authorization-/Outbox-/Permit-/Receipt-
Zeugen wurden nochmals in einem getrennten Read-only-SQL-Aufruf bestätigt.
Neue passive Zeilen durften parallel regulär hinzukommen. Die neue Constraint
war tatsächlich `VALIDATED` und enthielt genau
`linux.base`, `windows.base`, `agent.update`. API und Gateway liefen während
dieser Migration unverändert mit Image422c2c28; PostgreSQL behielt seine
ursprüngliche Container-/Imageidentität.
Ein weiterer lesender Serverabgleich fand bereits drei angenommene
`agent.update`-Zeilen, zuletzt15:40:50UTC. Das beweist die normale Speicherung
dieses Scopes nach der Migration, keinen separat geprüften Windows-ACK,
keine neue Basisinventarabnahme und keine Zeit-/Jobbereitschaft.
Die Vorherarchive enthalten Katalog-/Migrations-/Policyzeugen und
Zeilenfingerprints; ein vollständiger **Vorher-`pg_dump` wurde nicht angelegt**.
Ein vollständiger privater Customformat-Dump wurde ausdrücklich **nach** der
Migration archiviert: `after-migration-0016.pg_dump`,49,455,447Bytes, SHA256
`b89e74eaaea7ec2faa17a44358acca3aead1db0fcf9ccf673e2c5808b3259398`.
Er bleibt ausschließlich im Root0700-Fall auf dem Server, Datei0600, und wurde
nicht heruntergeladen oder als Vorherbackup bezeichnet. Ein Restoretest wurde
hier nicht ausgeführt.
Zwei harmlose Vorbedingungen scheiterten vor dem eigentlichen SQLx-Lauf und
bleiben erhalten: zunächst die Annahme eines vollständigen Buildkontexts
statt des tatsächlichen Minimal-Kontexts; danach ein hier nicht unterstütztes
Compose-Flag `--no-build`. Für letzteren Fall waren Exit1, Ledger15 und die
Abwesenheit eines eigenen Containers belegt. Nach Roots konkreter Korrektur
wurde derselbe Originalfall mit einem neuen Create-only-Fortsetzungsintent
verwendet; alte Fehler-/Vorherdateien wurden nicht überschrieben. Ein weiterer
reiner Absenzmatcher wurde an die tatsächliche Kleinschreibung der Docker-
Fehlermeldung angepasst, ebenfalls vor jedem Container-/SQLx-Start. Keine
verlorene SQLx-Wirkung wurde blind wiederholt.
Geschütztes Serverarchiv:
`/opt/rust-discovery/devstate/observation-scope-migration-cc3ea56d-6186-425a-8ef3-90562212fb1b/`.
Lokaler Belegordner im eigenen Worktree:
`devstate/observation-scope-migration/cc3ea56d-6186-425a-8ef3-90562212fb1b/`.
Die separate lokale `receipt.json` bindet Originalintent, Fehler, tatsächlichen
SQLx-Erfolg, getrennten Read und Nachbackup; SHA256
`00ff8f8ffa689bf3917937ce14ae23457e464b921ae7793e9091eab9a83d76c7`.
Private Zugangsdaten und
Datenbankinhalte wurden weder veröffentlicht noch in Git aufgenommen.
+27 -7
View File
@@ -6,15 +6,35 @@ Mandant und eine alte Verbindung wurden abgewiesen. Die Cloud-Linux-VM und
der Windowsgast melden sich selbständig und sind über MCP abrufbar.
[Gateway](server-time-gateway-deploy.md) · [Windows-Protokolltest](windows-time-route-operator.md)
Die bestehende Windows-Dienstinstallation ist weiterhin passiv und online.
Der vorbereitete Dienstwechsel benötigt ein neues befristetes Wartungsfenster.
Danach folgen der Zeitabgleich in den beiden Dienstprozessen und der erste
in der WebUI genehmigte Windows-Skriptauftrag mit Ausgabe.
[Stand des Dienstwechsels](windows-signed-clock-upgrade-plan.md)
Am 15. November liefen auf dem Windowsgast nach dem einmaligen Dienstwechsel
der neue Agent unter LocalService und der neue Helper unter SYSTEM. Die
separate Nachprüfung bestätigte beide Prozessstarts, das Gerätezertifikat,
die Geräteidentität und die bisherigen Journalstrukturen. Der erste Online-Kontakt
nach dem Wechsel gelang. Danach wies PostgreSQL den passiven Updatestatus
`agent.update` zurück. Der letzte reguläre Kontakt vor der Störung lag um
16:17:32 Uhr MEZ. Für die Korrektur wurden auf dem permanenten Server die
gefilterte Basisinventarabfrage und Migration 16 aus dem zum laufenden
ARM64-Image passenden Builder offline gebaut. Docker meldete Exit 0 für
Image `6a76343bf65c` (Buildfall `5ad7c74c-67a1-40b8-8960-d3ba016565af`).
Die Migration lief anschließend erfolgreich. Die API arbeitet mit diesem
Image. MCP bestätigte zwei neue Windows-Heartbeats um **16:39:46 und
16:40:17 Uhr MEZ**, jeweils mit derselben Geräte- und Zertifikatsidentität wie
vor dem Dienstwechsel. Die Cloud-Linux-VM meldete sich weiterhin als online.
[Dienstwechsel und Telemetrienachweis](windows-signed-clock-upgrade-plan.md)
Die Zeitprofilinstallation scheiterte beim Veröffentlichen der Datei mit einer
`IOException`. Eine separate Abfrage auf der VM bestätigte, dass die Zieldatei
fehlte und die Dienste weiterliefen. Das SSH-Fenster endete um 16:30 Uhr MEZ.
Für die nächste Gastprüfung muss der bestehende Teilzustand berücksichtigt
werden. Die Zeitprüfung in beiden installierten Rollen und der erste über die
WebUI genehmigte PowerShell-Auftrag stehen aus.
[Zeitprofil und Originalbefund](windows-time-profile-config.md)
Die passive Zertifikatserneuerung ist implementiert. Fünf Wiederanlauf- und
Fehlerfälle mit Testidentitäten bestanden auch auf Windows. Die Erneuerung
durch den installierten LocalService-Dienst steht aus.
Fehlerfälle mit Testidentitäten bestanden auch auf Windows. Das Anlegen,
Schützen und Wiederöffnen einer separaten Testschlüsseldatei bestand auf
der Windows-VM unter dem Entwicklungskonto. Die Erneuerung durch den
installierten LocalService-Dienst steht aus.
[Zertifikatserneuerung](windows-certificate-renewal.md)
Der Linux-Agent kann einen signierten Releasekatalog über mTLS prüfen und das
+35 -7
View File
@@ -1,5 +1,28 @@
# Tatsächlicher Implementierungsstand
## Agent-Update-Telemetrie: Migration0016 tatsächlich angewendet — 2026-11-15
Der permanente Server akzeptiert nun zusätzlich den festen passiven Scope
`agent.update`. Regulärer SQLx-Runner aus dem vorhandenen ARM64-Kandidaten6a7634,
Exit0 und separate Read-only-Nachprüfung von Version16/Checksum/VALIDATED-Check
bestanden. Ursprüngliche Zeilen, RLS/FKs/PK/ACL und Corezeugen erhalten; keine
laufenden Dienste durch diesen Schnitt ersetzt. Erste drei regulär angenommene
Updatebeobachtungen belegt. API-Basisfilterung ist getrennt. Vorherfingerprints
und ausdrücklich erst nachher angelegter privater pg_dump sind dokumentiert;
kein vorgetäuschter Vorherbackup-/Restoretest. [Beleg](agent-update-observation-scope.md).
## Passiver Windows-Zeitabschluss vorbereitet — 2026-11-15
Ein kleiner rein lesender Collector für die beiden historischen Rollenbelege
aus cc82124 ist ausführbar vorbereitet. Er bindet öffentliche Dienstprozesse,
Boot, aktuelle Servergeneration, Rollen-/Hashtrennung und enge Datenalter;
keine Dienste, IPC, Zeitrequests oder Diagnoseprogramme werden ausgelöst.
Lokale Syntax-/Scopeguards und sechs Bindingfixtures bestanden. Der konkrete
lokale .NET-/Chrono-Fraktionsparserfehler ist mit exakter Nanosekundenrechnung
und +1ns-Grenzfall korrigiert. **Kein VM-Aufruf,
keine native Collector-/Rollenabnahme** vor Roots V2-Profil-/Readbacksignal.
[Umfang und genaue Grenzen](windows-passive-time-closeout.md).
## Passiver Windows-Zertifikatspfad — Quellenstand 2026-11-15
Eigener RotationStore mit geschützten CreateNew-Keydateien und atomarer
@@ -27,13 +50,18 @@ Nur portable Logik mit synthetischen KeyFiles, keine echte TLS-Rotation oder
LocalService-Keydateiabnahme. Originalfehler und genaue Grenzen bleiben im
verlinkten Bericht erhalten.
Zusätzlich vorbereitet, noch nicht nativ ausgeführt: eine ausdrücklich
auszuwählende Windows-Keydatei-Unit im bestehenden Lib-Testbinary. Sie prüft
geschütztes CreateNew/Flush/Reopen, öffentlichen Keyhash, Nichtüberschreiben,
breite DACL an leerer Fixture, gehaltenes Verzeichnis und Hardlinkablehnung.
Keine Dienste/Accounts/Tokenübernahme oder permanente Dateien betroffen.
Produktcode unverändert; ein Administratorlauf ersetzt keinen LocalService-
Nachweis. Default-`ignored` ist hier ein ausdrücklich offenes natives Gate.
Zusätzlich tatsächlich nativ Windows bestanden: eine ausdrücklich ausgewählte
Keydatei-Unit im bestehenden Lib-Testbinary (ein PASS/49andere gefiltert,
Exit0/0ignored). Geschütztes CreateNew/Flush/Reopen, öffentlicher Keyhash,
Nichtüberschreiben, breite DACL an leerer Fixture, gehaltenes Verzeichnis und
Hardlinkablehnung geprüft. Eigener Falle0590d96, Rohread-SHA
`68dd458a24c2455049b7799f57e30f1e858e323fa82c578e3b962f58282b5e49`.
Nach einem lokalen JSON-Formatfehler wurde nur das ursprüngliche beständige
Ergebnis nachgelesen, kein zweiter Start. Eigener temporärer Testkey entfernt;
keine Dienste/Accounts/Tokenübernahme oder permanente Dateien betroffen.
Produktcode unverändert; dieser Administratorlauf ersetzt keinen LocalService-
Nachweis und keine echte Renewalabnahme. Im Defaultlauf bleibt die gesonderte
Administratorfixture bewusst `ignored`.
## Windowsfortsetzung: Nichtstart-Kern nativ qualifiziert — 2026-11-14
+32 -1
View File
@@ -129,7 +129,8 @@ und [FlushFileBuffers](https://learn.microsoft.com/en-us/windows/win32/api/filea
der öffentliche Selektor übernimmt den vorhandenen
[SQLite-WAL/FULL-Vertrag](https://www.sqlite.org/pragma.html#pragma_synchronous).
Eine weitere enge native Datei-I/O-Unit ist **vorbereitet, nicht ausgeführt**:
Historischer Vorbereitungsstand45b5337: eine weitere enge native Datei-I/O-Unit
war **vorbereitet, nicht ausgeführt**:
`certificate_rotation::tests::protected_key_files_create_new_reopen_acl_and_hardlink_guards`.
Sie steckt im vorhandenen Lib-Testbinary; kein zusätzliches Diagnostikbinary,
keine Tokenübernahme, Impersonation, Dienste oder Accounts. Wegen ihrer
@@ -163,3 +164,33 @@ Filter, Windows-GNU-Lib `--no-run`, Windows-Alltargets-Clippy mit
`system-helper`/`-D warnings` und Workspacefmt bestanden. Noch kein neuer
Zielaufruf. Das vorbereitete Windows-Testbinary hat SHA256
`cd385c3b8696303220d8e601768d70ac96a6e4187a14cbac9d511162a57eee5a`.
Nach dem ausdrücklichen SSH-Readback-Signal des Orchestrators wurde genau diese
Unit tatsächlich einmal auf der Windows-VM ausgeführt. Eigener Fall
`e0590d96-7e62-4bdc-a0b1-f53e8a9a9972`, unverändertes Binary `cd385c3b…`,
Aufruf `--ignored --exact certificate_rotation::tests::protected_key_files_create_new_reopen_acl_and_hardlink_guards --test-threads=1`.
Ergebnis: **ein PASS, null Fehler, null ignored, 49 andere gefiltert**, Exit0,
gemeldete Unitlaufzeit0.09s. Der vorhandene Administratorprincipal wurde im
Test geprüft; keine Tokenübernahme oder Impersonation.
Damit sind der wirkliche geschützte Windows-KeyFiles-CreateNew-/Flush-/Reopen-
Pfad, bytegleiche private Wiederöffnung, öffentlicher P-256-Keyhashvergleich,
Nichtüberschreiben, breite leere DACL-Negativfixture, gehaltenes Verzeichnis
und Hardlinkablehnung für diesen Principal bestanden. Die Unit entfernte ihren
eigenen temporären Schlüssel, Hardlink und Testordner erfolgreich. Es gab keine
Änderung an Client, SCM, Accounts, SSH-Zugang oder dauerhafter Identität. Stagingbinary und
eigene öffentliche Ergebnisdateien bleiben geschützt im Bootstraparchiv.
Der private Aufrufwrapper gab das bereits auf der VM beständig gespeicherte
Ergebnis zunächst als PowerShell-Tabelle aus; dadurch schlug ausschließlich das
lokale JSON-Einlesen fehl. Es gab **keinen zweiten Teststart**. Ein anschließend
streng lesender Aufruf übernahm nur die ursprüngliche eigene `result.json`.
Geschützter lokaler Rohread:
`devstate/windows-keyfile-fixture/e0590d96-7e62-4bdc-a0b1-f53e8a9a9972/result-read.json`,
SHA256 `68dd458a24c2455049b7799f57e30f1e858e323fa82c578e3b962f58282b5e49`.
Die separate lokale Acceptancequittung `acceptance.json` bindet Intent,
Transfer, Start und diesen Originalread; SHA256
`268e3146acfcab55022f9534509e74c80caf7b8ca246bcc5eb3c30e08cfd1383`.
Dies bleibt eine Administrator-Fixtureabnahme; tatsächliches
LocalService-Keyfile-I/O, Prozessabbruch und echte Zertifikatserneuerung sind
weiter offen. Keine bestehende Plattform-/Jobqualifikation wird damit erweitert.
+49
View File
@@ -289,3 +289,52 @@ Autostarttask. Beide installierten Dienste liefen beim Readback mit ihren
bisherigen Prozess-IDs: Agent 5528 als LocalService, Helper 9464 als LocalSystem.
Danach wurde die Ablaufzeit im lokalen Zugangsdatensatz an die geprüfte
Gastfrist angepasst. Dies ist der Nachweis für den Entwicklungszugang.
### Unterbrechung nach Ruhezustand des Notebooks
Das Hostjournal belegt Suspend zwischen 14:48:24 und 15:39:01 Uhr MEZ.
Danach blieb die Windows-VM im KVM-Status `running`. Der Entwicklungszugang
lieferte bei der SSH-Begrüßung einen Timeout. Auch direkt am bestätigten
Loopback-Listener des Servers kam keine Begrüßung an. Um 15:47 Uhr wurde
nur die anhand von Konto, Prozess und Listener erneut identifizierte alte
Forwarding-Sitzung geschlossen. Schlüssel und vereinbarte Frist von
16:30 Uhr MEZ blieben erhalten. Zum erneuten Aufbau ist die VM-Konsole nötig.
Der Produktagent meldete sich nach dem Resume beim permanenten Server. MCP
lieferte bei der Abfrage um 15:48 Uhr MEZ für den Windows-Gast `online`,
Quelle `windows.base`, letzter Kontakt 15:47:51 Uhr MEZ. Beim Unterbruch war
der Dienstwechsel noch nicht in die Ausführungsphase gelangt.
Eine weitere reine MCP-Abfrage bestätigte das nach dem Aufwachen neu
eingegangene Windows-Inventar. Beobachtungszeit 15:39:13 Uhr MEZ, späterer
Kontakt 15:52:23 Uhr MEZ. Betriebssystem, Volumes, Hardware und Software
lagen jeweils als `valid/partial` vor. CPU-Anzahl, Verhältnis von freiem zu
gesamtem Speicher und die Volumenwerte bestanden die Plausibilitätsprüfung.
Windows-Inodes waren ausdrücklich `unsupported` mit leerem Zahlenwert.
Beleg-SHA-256 `cce907d4c5e4ca9b788bab4aad8aac1f082b59f6a2922484289f19be061a1162`.
Die Abfrage nutzte gespeicherte Telemetrie und erforderte keine SSH-Verbindung.
Beim erneuten Konsolenstart meldete der Gast die Sammelmeldung
`Unexpected account, task, server or previous expiry.`. Sie stammt aus der
Vorprüfung vor der ersten Änderung. Welcher Gastwert abweicht, steht bis zum
Konsolen-Readback offen. Die Serverfrist wurde zu diesem Zeitpunkt nochmals
mit 15:30 UTC bestätigt. Neuere Versionen des Konsolenskripts benennen die
abweichenden Felder einzeln. Drei lokal simulierte Vorprüfungen bestanden
(Ausgangszustand, drei abweichende Werte, alle sechs Bedingungen abweichend).
Der Konsolenreadback vom 15. November um 15:59:11 Uhr MEZ ergab
`Disabled`, aktives Konto, Konto und Konfiguration beide mit Frist 16:30 Uhr
MEZ, passender Servername, laufender sshd und genau eine ausstehende Sicherung.
Der Bediener kann diesen konkreten Zustand mit `-ResumeInterrupted` im selben
Zeitfenster übernehmen. Das Skript prüft die ursprüngliche Frist der Sicherung
und rekonstruiert daraus die aktuelle Konfiguration. Bereits laufende
Wartungsprozesse verhindern einen Doppelstart. Bei regulärem Ende verwendet
es die ursprüngliche Sicherung zur Rücksetzung. Lokaler Parser- und Fixturetest
für passende Sicherung, aktiven Prozess, Konfigurations- und Fristabweichungen
bestanden. Die Wiederaufnahme muss auf der Windows-Konsole erfolgen.
Um 16:04:25 Uhr MEZ war der Windows-Gast über die vom Bediener wieder
geöffnete Verbindung erreichbar. Der Gast bestätigte für Konto und Konfiguration
denselben Ablauf um 16:30 Uhr MEZ, den erwarteten Servernamen und den
deaktivierten Autostarttask. Agent und Helper liefen weiterhin mit ihren
ursprünglichen PIDs 5528 und 9464 als LocalService beziehungsweise LocalSystem.
+131
View File
@@ -0,0 +1,131 @@
# Lesender Abschluss zweier passiver Windows-Zeitbeobachtungen
Der Collector `deploy/windows/passive_time_closeout.py` ist lokal vorbereitet
und ausführbar. **Noch kein Zielaufruf oder nativer Abschlussnachweis.** Die
V2-Profileinrichtung und ihr ausdrücklich gemeldetes Zeitfenster stehen vor
dem Aufruf. Tunnel-/Zugangserneuerung, Profileinrichtung und Dienstwartung sind
keine Aktionen dieses Collectors.
Der unabhängige Quellreview von `cc821246ccd98ee6d3dc5c1b12c7303d3010e8a7`
fand im engen Veröffentlichungsdelta keine konkrete Regression. Der Agent hält
pro Verbindung den ersten Vergleich je Rolle erst nach erfolgreichem eigenen
`complete` bzw. authentifiziertem Helper-`TimeCompleted` fest. Nur der aktuelle
Verbindungsowner schreibt beim Heartbeat. Ein verworfener Worker erhält keinen
Publikationspfad. Die JSONs sind historische Beobachtungen, keine aktuellen
Clockleases, Jobfreigaben oder unabhängig erneut verifizierbare Signaturpakete.
Auf der Windows-VM liest der Collector ausschließlich die Inhalte von
`C:\ProgramData\RustDiscovery\state\agent-time-sample.json` und
`helper-time-sample.json`, jeweils höchstens8192Bytes, durch gehaltene Handles.
Singlelink, Nicht-Reparse, Dateigröße, native FileID/LastWrite und die
SYSTEM-/Administratoren-/Agent-Service-SID-DACL werden geprüft. Die
Verzeichnis-DACL und Dateisicherheit müssen während des Reads gleich bleiben.
Reparse-Vorfahren werden verweigert. Keine privaten Schlüssel-, Journal- oder
Konfigurationsinhalte werden gelesen. Kurze gehaltene Lesehandles können einen
gleichzeitigen atomaren Reporttausch vorübergehend verweigern; der bestehende
Publisher behält den Sample für einen späteren Heartbeat.
Vor und nach diesem Read werden ausschließlich öffentliche CIM-/SCM- und
native Prozessmetadaten geprüft: beide festen Dienste Running, richtige
Konten/Startarten/Kommandos, Agent-/Helper-PID und Geburt, tatsächlicher
Prozessimagepfad und erwartete öffentliche Binaryhashes. Der Boot wird aus
demselben festen CIM-LastBootUpTime-Vertrag wie im Agenten abgeleitet. Es wird
kein Agent-, Helper-, SQLite-/Statusprobeprogramm oder IPC aufgerufen. Die
vorhandenen streng gepinnten Bootstraptransporte werden nur lesend verwendet;
C#-Interop enthält lediglich Query-APIs.
Der bestehende `time_route_context` liest davor und danach ausschließlich den
öffentlichen registrierten Gerätekontext in einer Read-only-SQL-Transaktion
und die feste Gateway-/Serverbootbindung. Die beiden Serverzeugen müssen
identisch sein. Die Capabilitymenge muss exakt passiv bleiben. Beide Reports
brauchen dieselbe positive aktuelle Serververbindungsgeneration und denselben
aktuellen Windows-Boot; ihre Agent-PIDs müssen dem aktuellen Agentprozess
entsprechen. Rollen, Feldschema und Datentypen sind exakt; doppelte JSONkeys
werden bereits beim Rohparse verweigert. Verifier-UUID, Request- und
Response-SHA256 müssen zwischen den Rollen verschieden sein.
Die Beobachtung muss nach der von Root belegten V2-Einrichtung und nach der
aktuellen Agentgeburt liegen. Beobachtungs- und Dateialter sind höchstens180s;
Publikationsverzug höchstens90s bei2s Zukunftstoleranz. Der aktuelle Windows-
UTC-Read muss höchstens10s vom lokalen Operatorzeitpunkt abweichen. Dies sind
Akzeptanzgrenzen für historische Daten, keine behauptete native Zeitgenauigkeit.
Fehlende/stale Belege und ein Generationenwechsel erlauben nur neue Readversuche.
Das Wartefenster beträgt180s; ein bereits begonnener vollständiger Readsatz
hat zusätzlich höchstens105s Transportbudget. Ein Timeout erzeugt einen
unvollständigen eigenen Beleg, niemals eine erfolgreiche Abnahme.
Lokale private Fälle entstehen unter `devstate/windows-passive-time-closeout/`.
Rohantworten stehen vor ihrer Validierung auf dem lokalen Datenträger;
Acceptancereceipts binden die aktuellen Native-/Serverzeugen per SHA256. Die
Befehlsparameter für den späteren Aufruf sind die tatsächlich installierten,
qualifizierten Agent-/Helperhashes und Roots UTC-Untergrenze nach der
V2-Einrichtung. Keine frei wählbaren Guestpfade, Aktionen oder Abfrageprogramme.
**Geplant, nicht ausgeführt:**
```text
python3 deploy/windows/passive_time_closeout.py collect \
--agent-sha256 <tatsächlich-installierter-qualifizierter-SHA256> \
--helper-sha256 <tatsächlich-installierter-qualifizierter-SHA256> \
--profile-after <Roots-tatsächliche-V2-Einrichtung-UTC-mit-Z>
```
Tatsächlich lokal ausgeführt und bestanden:
```text
python3 -m py_compile deploy/windows/passive_time_closeout.py
python3 deploy/windows/passive_time_closeout.py guards
python3 -m unittest discover -s deploy/windows -p test_passive_time_closeout.py
```
Sechs lokale Fixtures prüfen aktuelle unabhängige Rollen, falsche PID/Boot/
Generation/Rolle/Beobachtungsfrist, gleiche Verifier-/Request-/Responsewerte,
doppelte JSONfelder, fehlende Sicherheitsprüfung und fehlenden Helperbeleg.
Der zusätzliche Grenzfall prüft die tatsächlichen sieben .NET- und neun
Chrono-Nachkommastellen. Python3.10s ursprüngliches `fromisoformat` verweigert
diese Formen; dieser konkrete lokale Fehler wurde vor jedem Zielaufruf
behoben. UTC- und FILETIME-Grenzen werden jetzt vollständig mit Ganzzahl-
Nanosekunden verglichen. Ein Sample genau an der Installationsuntergrenze wird
akzeptiert, eine um1ns spätere Untergrenze verweigert dasselbe Sample. Keine
Native- oder Testzeit wird hierfür erfunden.
Danach lokal mit vorhandenem `/tmp/rmm-powershell-parser/pwsh` tatsächlich
ausgeführt: vollständiger Reader-AST ohne Parserfehler und Kompilierung der
C#-Querydefinitionen ohne Methodenaufruf bestanden. `Info` besitzt die
erwartete52-Byte-Interopgröße. Lokale Quittung unter
`devstate/windows-passive-time-closeout-local/receipt.json`; kein nativer
Win32-Aufruf oder VM-Zugriff. Windows-PowerShell5.1-/tatsächliche Win32-Reads
und echte Rollenbelege bleiben offen; lokale Prüfungen ersetzen sie nicht.
Der konkrete Profileinsatz wurde zusätzlich unabhängig rein im Quellcode
geprüft (`time_profile_config.py`, SHA256
`36f0451a146ca8dc73d4c66b48f2e65fbaefde5c7643133993d1c136cc3318de`).
Kein konkreter Befund im geprüften Schnitt: getrennte öffentliche Source-/
Plattform-/Key-/Bindingketten, exakte neue Rollen mit PID/Geburt/Token-/Service-
SID/Image/FileID, SameLive-/Kernel-CAS vor und nach Veröffentlichung,
Intent-vor-ACL/Move, überschreibungsfreier gleichvolumiger Move und ausschließlich
ThisFolderOnly-Leserechte für die zwei Rollen. Die UTC-Untergrenze wird vor
dem ersten privaten Fallintent aufgezeichnet. Noch ungesetzte Paarbeleg-
Konstanten blockieren die Vorbereitung. Der konkrete spätere Rollen-/
Readbackbinding-Delta und die tatsächliche Veröffentlichung bleiben separat
nachzuweisen. Dieser Review ist keine Profileinrichtung oder native Abnahme.
Im laufenden Wartungsfenster folgte ein enger unabhängiger Quellreview des
konkreten SCM-ETS-Fixes (Clockoperator-SHA256
`90c2708c17903e4bc630f6655dba38ff6448251941abd53f5874e991042b0f2c`).
Die tatsächlich gelesenen Int32-SID-Typen trugen PowerShell-ETS-Metadaten und
wurden vom bisherigen `PSCustomObject`-Zweig als Objekt behandelt. Der Fix
behandelt die primitiven CLR-BaseObjects zuerst und rekonstruiert reine
JSONskalare. Stringcase und vollständige Integerwerte bleiben erhalten;
NaN/Infinity werden verweigert. Arrayreihenfolge, Null, Keykollisions-/Tiefe-
und Wirkungs-CAS bleiben unverändert. Keine weiteren konkreten Findings im
geprüften Schnitt. Derselbe vollständige Comparator wurde im Profiloperator
SHA256 `8588241eac3036e665b6010e4bf9fac1547be88d68f95b4c02cb24e425267c68`
per reinem AST-Literalvergleich bytegleich bestätigt. Das ist ausschließlich
Source-Review, kein Zielaufruf oder Beleg einer ausgeführten Wartung.
Falls Reports fehlen, können die bereits vorhandenen passiven Dateien
`helper-probe.json` und `pipe-last-error.json` getrennt nur lesend bei der
Pipeeingrenzung helfen. Sie enthalten keinen vollständigen Timeworkerfehler;
auch Metadaten vorhandener fester `.agent-time.pending`/`.helper-time.pending`
können eine unterbrochene Publikation erklären. Dieser Collector liest oder
ändert diese zusätzlichen Dateien nicht und löst keine Diagnose aus.
+300
View File
@@ -159,3 +159,303 @@ den Windowsgast weiterhin als `online`. Der Agent hatte den permanenten Server
am 15. November 2026 um 14:06:34 MEZ kontaktiert. Die Daten wurden ausschließlich
über `inventory.get_device` gelesen. Beleg
`003f000e16e53ce3ff8799694e7138e014689e741f69be6577519c616aee6bab`.
## Neues bestätigtes Fenster: Staging und Baseline tatsächlich bestanden
Nach erneuter ausdrücklicher Freigabe, tatsächlicher Konsolenbestätigung beider
ursprünglichen Dienst-PIDs und Konto-/Konfigurationsablauf15:30UTC entstand der
neue Fall5c627d08-aff0-42a1-a922-dcf7eebccb15. Der alte0406-Stagingversuch bleibt
unverändert als unvollständiger Versuch ohne Dienständerung erhalten.
Tatsächlich native Stagingprüfung bestanden: Helper5967… (bereits eigener
Bootstraphashpfad), Agent26dc… und fester Controller
`d808f47b5de8563e7e32d49dc5a0ad83c988c7de12cc286f1814b3a69e7e27a6`.
Danach vollständige native Baseline ohne Timeout: Config-/PKI-/Datei-/ACLbindung
und tatsächlicher Helper-DB-/Lock-/Intentzustand stimmen mit dem angenommenen
ursprünglichen14fb-Beleg überein. AgentRunning5528, HelperRunning9464.
BaselineSHA `cc876073b87086021ba449748deebff8309e06977438bb1854565f5d58cbba88`.
Geschlossene Serverflags und Job-/Outbox-/Permitzähler unverändert.
Bis zu diesem Beleg kein ServiceStop/Start/Swap, kein Job, kein Zeitprofil.
Die anschließende einmalige Enterphase ist ein gesonderter noch offener Schritt.
## Erste Enterphase vor jeder Wirkung verweigert; Ursache nachgewiesen
Im Fall5c627d08… wurde Enter genau einmal aufgerufen und mit
`Preserved identity config or ACL` verweigert. Kein erneuter Enteraufruf.
Die feste unabhängige Originalfallnachlese bestätigt: Fallordner absent,
active-intent absent, sämtliche Intent-/Stop-/Swap-/Startmarker absent;
ursprüngliche Dienste weiterhinRunning5528/9464. Es gab keine Dienständerung.
Der erste Versuch bleibt fehlgeschlagen und wird nicht nachträglich geheilt.
Eine frische vollständige native Baseline bestätigte alle betroffenen Werte
semantisch exakt identisch. Der konkrete Fehler lag im bisherigen PS-`JsonEqual`:
Er verglich JSON-Texte einschließlich Objektmemberreihenfolge. Die Python-
kanonisch sortierte gespeicherte Baseline und die native PS-Ordered-Ausgabe
ordnen `public_hashes`, `identity_acls` und `private_key_metadata` anders an.
Das war ein falscher Unterschied trotz unveränderter Werte, kein ACLwechsel.
Der enge Quellfix normalisiert nur Objektmember für den Inhaltsvergleich;
Arrayreihenfolge sowie Null gegenüber leeren Arrays bleiben unterschieden,
Tiefe bleibt auf40 begrenzt. Tatsächlich fünf native In-Memory-Gegenfälle
bestanden: umgeordnetes Objekt akzeptiert, Scalaränderung, umgekehrtes Array,
Null gegenüber leerem Array und Null-Element gegenüber leerem Array verweigert.
Keine Dienste, Produktdateien oder Jobs wurden vom Guard verändert. Unabhängiger
Quellenreview läuft getrennt; noch keine neue mutierende Controllerausführung.
Inzwischen behebt Main656102b die passive Zeitprüfung ohne Jobopt-in. Weil das
ursprüngliche Paar nachweislich noch unmutiert ist, wird26dc nicht mehr installiert:
Root qualifiziert zuerst das notwendige neue Agentimage; Helper5967 bleibt
unverändert. Danach neue feste Image-/Controllerbindung und neue Baseline vor
**einem** tatsächlichen Paarwechsel. Der fehlgeschlagene5c-Versuch wird dabei
weder wiederholt noch als Erfolg ausgegeben.
## JsonEqual-Korrektur eng geprüft und nativ belegt
Der unabhängige Quellenreview fand im ersten Normalisierer einen zusätzlichen
Randfehler: ein case-sensitives IDictionary mit `A` und `a` hätte beim Kopieren
in eine case-insensitive OrderedDictionary einen Wert verlieren können. Beide
Objektzweige verweigern nun vor dem Einfügen Nichtstringkeys oder bereits
vorhandene kollidierende Namen. Bestehende feste Native-State-DTOs erzeugen
solche Kollisionen nicht; der zusätzliche Pfad ist trotzdem geschlossen.
Unabhängiger enger Re-review der Quelle
`4ef8c6787fd3defdd8416401b3b40dd63be0e3afffc195736eed0ce350286201`
ohne weiteren konkreten Befund. Nativ anschließend sechs feste In-Memory-Guards
bestanden: ursprüngliche fünf Fälle plus case-kollidierendes
`Dictionary(StringComparer.Ordinal)` wird verweigert. ResultSHA
`2429b869792854ac799c403422e26561df2b2c5310b408e6a7287751129c2a94`
im erhaltenen5c-Fall, `comparison-collision-guard-result.json`.
Pythoncompile und bestehende Quellguards ebenfalls PASS. Kein Service-/Datei-/
Jobeffekt und weiterhin keine26dc-Installation. Der folgende Agentkandidat wird
separat durch Root qualifiziert; Controller-/Payloadbindung und neuer echter
Baselinebeleg werden erst mit dessen endgültigem Artefakt erzeugt.
## Ein Austausch mit passiver Zeitprüfung
Nach der Verweigerung vor dem ersten Dienststopp wurde der ursprüngliche
202-Dateien-Quellstand erneut gegen sein Manifest geprüft. Nur drei Quellen
haben sich für den Installationskandidaten geändert: Zeitabfrage im Agenten,
Auswahl des Abfrageintervalls und Schreiben der zwei historischen
Dienstbelege. Die Änderungen kommen aus den Commits `656102b` und `cc82124`.
Das Manifest dieser 202 Inputs hat den SHA-256-Wert
`11717fab51bd1d6bf103b1821cc1e2a84699f46cac21f2cc614acf4b68381fa4`.
Der isolierte Offline-Releasebuild für AMD64 ergab das Agentbild
`0549d9ebea73cff996938f859b92192cc333de194128d7c6859a3f1d2e85893c`.
Für den Helper wird das bereits qualifizierte Image `59675a3c…` verwendet.
Der Agent-Zwischenbuild `34b7458d…` wurde nicht installiert.
Die neun gezielten Zeitprüfungen aus diesem konkreten Quellstand bestanden auf
der Cloud-Linux-VM als UID 65534, Exit 0. SHA-256 der Ergebnisquittung
`333f8d2dba3b35dcd79faafd8faf5c88da321942c9672c0a80f1f2c8fceb24a3`.
Anschließend bestanden die gleichen neun Tests auf der Windows-VM aus dem
separat gebauten AMD64-Librarytestbinary desselben Release-Quellstands, Exit 0.
Die Ergebnisquittung hat SHA-256
`7700096145afdca74e7473e56c6dd2e65651252e889a696f84bb1fc2441ff513`.
Nach erneutem Abgleich aller 202 Quelldateien, des PE-Headers und des Helperhashs
wurde das Buildreceipt
`f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446`
für den einmaligen Dienstwechsel erstellt. Der Windows-Testprozess hat weder
einen Dienst ausgetauscht noch einen Agentjob ausgeführt.
Der exakt gebaute Quellstand für das neue Agentbild liegt in Gitea auf
`codex/windows-passive-time-candidate`, Commit
`c6c4037d072a96d62136264066d0257782c7a932`. Alle 202 Build-Inputs wurden
byteweise mit dem Release-Manifest abgeglichen. Der Ausgangsstand der
ursprünglichen Qualifikation entspricht für dieselben 202 Dateien
`b8ca8266bbb3b4806f4d20a3039f25196638804e`.
## Endgültiger passiver Agent und erneute Transportverweigerung
Root qualifizierte für genau den beobachtbaren passiven Stand cc82124 den
Agent0549d9ebea73cff996938f859b92192cc333de194128d7c6859a3f1d2e85893c.
Tatsächliche Linux9-/Windows9-Guards und Release-Link sind im Receipt
f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446 gebunden,
Sourceinputs11717fab51bd1d6bf103b1821cc1e2a84699f46cac21f2cc614acf4b68381fa4.
Helper5967… bleibt aus dem ursprünglichen04ed-Produktreceipt unverändert.
Der Generator bindet diese beiden getrennten tatsächlichen Artefaktquellen,
keinen nochmals eingebauten26dc-Agenten. Der öffentliche neue lokale Receipt
war zunächst0664; nur sein Modus wurde auf0600 gehärtet, Bytes/SHA unverändert.
Neuer unveränderlicher Fall570c7a86-6509-49e6-b95e-8f0df74b18bf,
Controller67d2fb1f9fdfec05b08f53a37be9a7df4cc3bb39f6cde8f950a226286474fd45,
bindet das bestätigte15:30UTC-Fenster. Sein allererster kleiner Stage-Read wurde
jedoch bereits beim SSHtransport verweigert: return255, stdout0, stderr89Bytes.
Ein einzelner begrenzter Statusversuch klassifizierte CONNECTION_TIMEOUT,
keinen Authentifizierungs-/Hostkeyfehler. Kein neuer Agenttransfer, kein Enter,
keine Dienständerung oder Wiederholung unklarer Wirkung durch diesen Fall.
Root belegte danach Notebook-System-Suspend13:48:24–14:39:01UTC und einen nicht
mehr antwortenden alten Forwardingkanal. Damals existierte weiterhin keine
V2-Konfiguration/Zeitauthorität; beide ursprünglichen Produktdienste waren passiv.
Root beendete ausschließlich den separat kernelgebundenen alten Bastionforwarder
und forderte kontrolliertes Neuöffnen desselben Fensters an. Dieser Wartungsagent
änderte weder Tunnel, Konto, Schlüssel noch SSHkonfiguration. Seit Roots Sperre
keine weiteren VM-Aufrufe bis bestätigtem Transportreadback.
Abschließender lokaler Check: Pythoncompile, bestehende Quellguards, exakte
saved-controller-/Generatorbytes, neues Agentimage, unverändertes Helperimage,
Source-/Native-Receipt und geschützte15:30-Payloadbindung PASS. Beleg
74ca4c2572872eb64cecc250aefd4bbffa5d8e4dc9b3729b5b83c19ac07a670f,
`final-local-check.json` im570c-Fall. Neue native Baseline, tatsächlicher
Paarwechsel und unabhängige Nachlese bleiben offen. Es wird kein Windowsabschluss
oder funktionierender installierter Zeitvergleich behauptet.
## Transport wieder bestätigt: endgültiger570c-Stand nativ bereit
Nach Roots tatsächlichem Konsolen-/Transportreadback15:04:25UTC wurde ausschließlich
der vorhandene570c-Fall fortgesetzt, unverändertes Ende15:30UTC. Tatsächliche
Stagebestätigung für Helper5967…, endgültigen Agent0549… und Controller67d2…
bestanden. Volle neue native Baseline bestätigt ursprüngliche Running-PIDs5528/9464,
unveränderte config/PKI/ACLs und vollständigen bisherigen Helper-DB-/Lock-/Intent-
zustand. BaselineSHA
b1a7928f89ad2bb9c63720dedea6f343d644c9882052877b5144dc200537f5e7.
Geschlossene Serverflags und Windows0-/Linux31/31/27-Zähler unverändert.
Noch keine Dienständerung bis zu diesem Baselinebeleg. Nächster Schritt ist die
genau einmalige, an diese neuen tatsächlichen Bytes gebundene Enterphase.
## ETS-Skalartypfehler vor erster Wirkung behoben
Die einmalige570c-Enterphase verweigerte `Original SCM invariant`. Die reine
Nachlese zeigt erneut eigenen Ordner/active-intent und alle Stopmarker absent;
Originaldienste laufen5528/9464. Keine Enterwiederholung und keine Dienstwirkung.
Isolierter Vergleich aller sechs SCM-Felder inklusive CLR-/Basistyp und Wrapping
belegt ausschließlich `sid_type`: Baseline und live beide System.Int32=1, aber
der ETS-wrapped Registrywert erfüllt zusätzlich `-is[pscustomobject]` und wurde
irrtümlich zu `{}` normalisiert. Die anderen fünf Felder stimmten exakt überein.
Der Vergleich rekonstruiert jetzt JSON-Skalare aus ihrem CLR-Basiswert vor dem
Objektpfad (primitive Strings/Bool/Integer/finite Double/Decimal), ohne ETS-Notes
als fachlichen Objektinhalt umzudeuten. Echte JSON-Objekte behalten alle Keys;
Casekollisionen/Arrayreihenfolge/Null/Tiefengrenze bleiben geschützt. Unabhängiger
enger Review der Quelle90c2708c… ohne weiteren konkreten Befund.
Tatsächlich anschließend auf derselben VM: vollständiges originales
`SameOriginal` gegen gespeicherte Baseline und frischen LiveState bestanden.
Zusätzlich native ETS-Add-Member-Fälle für Integer/String/Bool gleich,
Scalaränderung/Arrayumkehr/Null gegenüber leerem Array weiterhin verweigert.
Result82c4ebe75bff95005ebd946ae99e206ec69648bec93adb17cf683c46fc46212a,
`typed-full-pre-effect-comparison.json` im570c-Fall. Weiterhin keine Ordner/active-
Marker und keine Dienständerung. Neuer Controllerfall folgt getrennt;570c bleibt
als fehlgeschlagene Vorwirkungsphase erhalten.
## Neuer typkorrigierter Fall4887 nativ bereit
Fall4887940a-4c9c-4807-aaf2-6fbc94faad46 bindet unverändert Agent0549/Helper5967,
denselben echten Quell-/Linux9-/Windows9-Beleg und das unveränderte15:30-Fenster.
Controller66ca45e15e8f790c4614db74dd491137d5e28104e2d28ee658cc287debcd021f.
Alle festen Stagebytes erneut nativ bestätigt; volle frische Baseline einschließlich
ursprünglicher PIDs5528/9464, config/PKI/ACLs und Helper-DB/Lock/Intents bestanden.
Baseline00bf31bd5355dc77e0aadd73d2ab57ea32410956ef764f3f2aeb195bd218479e.
Geschlossene Servergates unverändert, bis hier weiterhin kein Serviceeffekt.
4887 besitzt noch keinen Enterversuch;570c bleibt getrennt vor Wirkung verweigert.
Nach dem tatsächlichen Dienstwechsel bestätigten SCM und MCP zunächst beide
laufenden Dienste und die bisherige Geräteidentität. Der letzte Kontakt blieb
dann bei 16:17:32 Uhr MEZ stehen. Um 16:21:38 Uhr authentifizierte der Agent
sich weiterhin erfolgreich. Die drei serverseitigen Sperren für Restore,
Sequenzregression und Sync-Recovery waren alle aus. Der neue Agent meldet
`agent.update/1` und sendet eine passive `not_configured`-Beobachtung. Auf
dem Server ließ der CHECK von `observations.source_id` ausschließlich
`linux.base` und `windows.base` zu. PostgreSQL protokollierte seit dem Wechsel
15 Verletzungen genau dieses CHECKs. Der erste Online-Status war damit kein
Nachweis für fortlaufende Heartbeats.
Die Geräteansicht selektiert im geänderten API-Quellstand gezielt den neuesten
Basisdatensatz. Die aus dem Produktcode extrahierte LATERAL-Abfrage lieferte in
einer lesenden PostgreSQL-Prüfung auf dem Server die erwarteten Windows- und
Linux-Werte sowie NULL für ein Gerät mit ausschließlich Updatebeobachtungen.
Auch Mandant und Seitenstichtag wurden im Datensatz gegengeprüft.
## Tatsächlicher einmaliger Paarwechsel, Abschluss nur lesend wiedergewonnen
4887 führte den tatsächlichen Paarwechsel genau einmal aus: beide ursprünglichen
Prozesse kontrolliert beendet, vier Originaldateien gesichert, Agent/Helper und
reziproke geschlossene Settings/Pins vollständig ersetzt, danach Helper und Agent
jeweils einmal gestartet. Neue tatsächlich laufende Kernel-/Serviceinstanzen:
Agent0549… PID4420, Helper5967… PID10264. Der ursprüngliche Enteraufruf meldete
allerdings beim abschließenden Schemaerhaltungscheck einen Fehler; er wurde
**nicht** erneut aufgerufen. Originalmarker belegen alle vier Replacements und
beide tatsächlichen Starts; `entered.json` wurde wegen des Nachprüfungsfehlers
nicht geschrieben. Der erste Postcheck bleibt fehlgeschlagen.
Der exakte Nachbefund: Telemetriedatei-ID, Creation und Geräteidentitätshash sind
identisch. Alle bisherigen Schemaeinträge/Trigger sind bytegleich erhalten;
ausschließlich `update_health_inventory` wurde additiv angelegt. Deren komplette
DDL entspricht der tatsächlich qualifizierten eingefrorenen Quelle
`agent-core/src/update_health_inventory.rs` (Sourceinputs11717fab…). Dies ist
keine globale Lockerung des Schemaerhalts: der Abschlussleser verlangt exakt
einen zusätzlichen Eintrag, exakt diesen Typ/Namen/DDL und unveränderte übrige
Einträge. Die neue Tabelle wurde nicht auf Zeileninhalt abgefragt; es wird keine
solche Prüfung behauptet. Bestehende Job-/Reconcilezähler bleiben vollständig0,
Serverjob-/Outbox-/Permitgates ebenfalls unverändert geschlossen.
Eine erste reine Abschlusslesung verweigerte fälschlich wegen PowerShell-
Pipelineflattening der Schema-Tupel; nach Beschränkung auf explizite Listen
bestand derselbe ausschließlich lesende Originalfallvergleich. Keine weitere
Service-/Datei-/Jobmutation war Teil dieser Recovery. Der Reader prüft zusätzlich
Originalintent/active-Bindung, vollständigen Config-/PKI-/Privatekeymetadaten-/
DB-/Lock-/Helperrowerhalt sowie exakte beiden gespeicherten einzelnen neuen
Service-/Kernelstarts. Native tatsächliche Zeitquelle/Clockfreigabe wird dadurch
nicht behauptet.
Anschließend unabhängiger zweiter Originalfallread: dieselben neuen Prozesse,
Images und Dateiidentitäten, sämtliche Erhaltungsbedingungen erneut bestanden.
Belege im4887-Fall:
- `completion-readback.json`:13448d833b32dedfb5e07cb4e76f046e666522488ffabbb3a38a57d2d485d1b8
- `independent-readback.json`:63e453fb915cadee028407a6aeaa8c7d209ae88ed12a6d4d4307d4fd25e4c539
- `intent.json`:40e9cd557225504429b51dcecd4322b32d7f0973bcbb8e2a2e52516917907b85
- `bound-payload.json`:074a13fd3e4cdefd85aedb5a9fc17d247994e0e515b71e4e0925f713d37774f7
- `result.json`:2898a72b4b0d84159cc11d80765cbfa4206faf7038d0e860429c8b1a57538ee2
Das Resultat kennzeichnet ausdrücklich `recovered_postcondition_read=true` und
`original_enter_postcheck_failed=true`. Es meldet keine erfundene erfolgreiche
ursprüngliche Enterantwort. Kein Jobmodus, Effektgate, VM-Reboot, Enrollment,
Gerätezertifikatswechsel oder Zeitprofil wurde durch diese Wartung aktiviert.
Getrennt offen: Parent bestätigte einmaligen korrekten neuen Hello/Identität und
unverändertes Gerätezertifikat/Enrollment/Assignment, jedoch noch keine zwei
fortlaufenden Heartbeats; gespeicherte Präsenz wurde später stale. Die zusätzliche
Capability `agent.update/1` stammt aus dem konkret installierten passiven
not_configured-Schema. Heartbeatkontinuität und installierte Clockautorität
bleiben im Resultat ausdrücklich **nicht bewiesen**. Windows-MVP damit nicht
vollständig abgenommen. Wichtige spätere Werkzeugverbesserung: erwartete additive
Schemaentwicklung vor Wartung aus dem qualifizierten Quellstand planen; hierfür
jetzt keinen allgemeinen Migrations-/Resumeframework bauen.
## Serverkorrektur für die passive Telemetrie am 15. November 2026
Nach SQLx-Migration 16 wurde um 16:39:24 Uhr MEZ ausschließlich der
API-Container auf dem permanenten Server neu gestartet. Sein ARM64-Image
`6a76343bf65c126458244f5540d4cb740988144fc77877b409f790251e7ddcc7`
enthält die Änderung an der Basisinventarabfrage und die Migration.
Gateway und PostgreSQL behielten Container-ID und Startzeit.
Der erste Nachvergleich schlug beim direkten Listenvergleich der
Containerkonfiguration fehl. Eine separate lesende Prüfung verglich die Mounts
nach Zielpfad. Docker lieferte sie in anderer Reihenfolge. Quelle, Ziel,
Modus und übrige Mountattribute stimmten vollständig mit dem vorherigen
Container überein. API-Umgebung und Startkonfiguration entsprachen Compose
und Image. Verifiziert wurden zudem die Loopback-Bindung, UID/GID 10001,
Read-only-Rootfs, CapDrop ALL und no-new-privileges. Es gab genau einen
API-Wechsel. Die weitere Prüfung erfolgte am laufenden Container.
### Erneute Abnahme über MCP
Zwei getrennte, nach Beginn der Prüfung eingegangene Kontakte des Windows-11-
Agenten wurden am 15. November um 16:39:46 und 16:40:17 Uhr MEZ aus
`inventory.get_device` gelesen. Beide hatten Präsenz `online`, dasselbe
Gerät, dieselbe Agent-ID, Zuordnung, Enrollmentgeneration und dasselbe
authentifizierte Zertifikat wie vor dem Paarwechsel. Der Agent meldet
`heartbeat/1`, `windows.base/1` und `agent.update/1`.
Beleg-SHA-256 `837c7580b9e7cd68de09533f50d91622272c2f2bc288da70d8b4624d2f6a747e`.
Die MCP-Geräteansicht lieferte das gespeicherte Windows-Basisinventar mit fünf
Bereichen und für die Cloud-Linux-VM den Datensatz `linux.base`. Das
Windows-Basisinventar stammte von 16:16:59 Uhr MEZ. Die Kontaktzeiten wurden
unabhängig davon aktualisiert. PostgreSQL speicherte die separaten
Updatemeldungen des Windowsagenten um 16:38:43, 16:39:45 und 16:40:50 Uhr MEZ.
Der zuletzt gelesene Updatezustand war `not_configured`. Die Windows-Jobtabelle
enthielt für dieses Gerät null Aufträge. Die Prüfung las gespeicherte
Telemetrie über den permanenten Server nach Ablauf des SSH-Fensters.
+197
View File
@@ -179,3 +179,200 @@ anschließend frische Heartbeats/ACKs sowie echte signierte Zeitbelege bleiben
getrennt zu prüfen. Eine spätere Fortsetzung benötigt zuerst eine lesende
Ursachenklärung und einen konkret geprüften Vertrag für den ursprünglichen
Teilfall; ein neuer Fall darf diesen Marker nicht umgehen.
## Sharing-Verletzung bei der Konsolenfinalisierung
Die VM meldete beim gesonderten Konsolenabschluss für `File.Move` den HRESULT
`0x80070020` (Win32 32, Sharing-Verletzung). Der Helper hielt seit seinem
Start einen Lesehandle auf `C:\ProgramData\RustDiscoverySystem`. Der Code
erlaubte ausschließlich `FILE_SHARE_READ`. Beim Verschieben des Kandidaten
aus dem Bootstrap-Verzeichnis öffnet Windows den **Zielordner** für
`FILE_ADD_FILE`. Dieser Zugriff kollidiert mit dem gehaltenen Handle. Die
native Fehlermeldung nennt keine Prozess-ID. Die Zuordnung folgt aus den
Öffnungsmodi des Helpers und der dokumentierten Windows-Rename-Operation.
[Windows-Rename](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-fsa/87f86c9b-6c2a-4803-84b7-131a74a434fa)
· [Windows-Sharingprüfung](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-fsa/8c0e3f4f-0729-49f4-a14d-7f7add593819)
Im korrigierten Quellstand öffnen der Helper, der Agent beim Laden des
Peer-Pins und die Zeitprüfung genau diesen öffentlichen Stamm über
`PinnedFile::open_read_shared`. Der Lesehandle lässt auch einen berechtigten
Schreibzugriff auf den Ordner zu. Weiterhin sperrt er das Löschen und
Umbenennen des Ordners. Über Kinddateien entscheiden deren eigene DACL und
gehaltene Datei-Pins. Einstellungen, Peer-Pin und Zeitprofildatei werden
weiterhin mit geteiltem Lesezugriff geöffnet. Die vorhandenen Prüfungen von
Owner, DACL, Reparse-Attributen und Dateiidentität laufen bei jedem Pin.
Workspace-Formatprüfung, Cargo-Check aller Windows-Ziele mit `system-helper`
und Clippy mit `-D warnings` bestanden im Windows-Clock-Builder offline.
Beide x86-64-PE-Debugprogramme wurden dort gelinkt. Agent-SHA-256
`b5fe5ea55c857415c979f06851e54a2d1fbe4cbfe2fe7ad1660e209aae3fa583`,
Helper-SHA-256 `c6b41b0867df23f2c04c2550a39678672ef66d35a4b41215769265924deaf8a1`.
Der erste Buildversuch endete in einem anderen Builder wegen fehlendem
`widl`. Die Windows-VM hat diese Änderungen bisher weder ausgeführt noch
durch erneute Profilveröffentlichung und zwei passive Rollenbelege bestätigt.
### Optimiertes Release-Paar für die nächste Windows-Abnahme
Am 15. November 2026 wurden Agent und Helper aus Commit
`e952698f5e2bab808e816858a727ef40347f6142` auf dem Entwicklungsrechner
gebaut. Der Quellstand kam aus einem schreibgeschützt eingebundenen Git-Archiv.
Der unabhängige Vergleich nach dem Build bestätigte alle 708 Quelldateien
gegen Git-Tree `708c88b4d6a92d9f9cbebc70146250062532f45f`.
Rust 1.99.1 und Cargo 1.99.1 liefen im vorhandenen Clock-Builder ohne Netzwerk.
Der ausgeführte Befehl war
```sh
cargo build --release --target x86_64-pc-windows-gnu --features system-helper --locked --offline -p rmm-agent-windows --bin rmm-agent-windows --bin rmm-helper-windows
```
| Datei | Bytes | SHA-256 |
| --- | ---: | --- |
| `rmm-agent-windows.exe` | 23 543 434 | `2dd64e743431ad4c8244e43bef30c4c1c2123ad26a094853811a418626bb87e7` |
| `rmm-helper-windows.exe` | 17 191 183 | `9c313c07a20c82797cbd8c8ca7c289c1d227b0bd6a4a686f38c4db3bbdded199` |
Beide Dateien haben einen ausführbaren PE32+-Header mit AMD64-Maschinenkennung
`0x8664`. Der private Originalbeleg `profile-share-release-e952698/receipt.json`
hat SHA-256 `1ec1ec472043e8673e5b92f9029fd809434451d9452e3b24bbd85b21f017017d`.
Das erste Prüfskript traf auf dem Notebook auf eine ältere Python-Hashlib ohne
`file_digest`. Die Nachprüfung lief mit SHA-256 über dieselben fertigen Bytes.
Die Installation dieses Paars und die native Profilveröffentlichung mit den
zu diesen Binaries passenden Zeitprofilbindungen stehen aus.
## Unabhängiger lokaler Review des Move-Fehlers und fester Diagnosepfad
Der nachfolgende Review liest ausschließlich Quellen und vorhandene öffentliche
Originalbelege auf dem Entwicklungsrechner. Kein Gast-/Serverzugriff, keine
Installation, kein Retry und keine Freigabe wurden dabei ausgeführt.
Belegt ist der Ablauf bis zum Publish-Intent mit Kandidathash
`2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b`,
1177Bytes, Volume9815088561147542064 und FileID6d990300000003000000000000000000.
Der spätere originale Read93143fc0… belegt das fehlende Ziel und fehlendes Resultat.
Er fragt jedoch die Kandidatdatei selbst nicht ab. Ihr aktueller Bestand ist
somit **nicht** nachgewiesen. Original-rootSDDL im Intent, ACL-done-SDDL und spätere
rootSDDL sind bytegleich: die ACL-Phase wurde ausgeführt, ohne effektive Rechte
zu ändern. Bestehende NoRetry-Marker bleiben bestehen.
Die genaue Ursache der IOException ist mit diesen Belegen nicht bestimmbar.
Der alte Fehlerbeleg enthält weder HRESULT noch nativen Fehlercode. Die statisch
geprüften WriteBytes-, FileIdentity- und FileVolume-Handles werden in `finally`
geschlossen; ein eigener Handleleak ist daraus nicht belegt. Das rechtfertigt
weder eine Sharing-Lockerung noch Dienststopp, ACL-Änderung, Antivirusausnahme,
Copy/Delete-Fallback oder erneuten Move. Microsoft beschreibt für
[File.Move](https://learn.microsoft.com/en-us/dotnet/api/system.io.file.move)
mehrere IOException-Ursachen; die Regeln für vorhandene Handles stehen getrennt
in [CreateFile](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew).
Sharing, Defender oder ein konkreter Win32-Code bleiben hier ausdrücklich
Hypothesen. Der ursprüngliche HRESULT darf aus späteren Lesefehlern nicht
rückwirkend abgeleitet werden.
Der bestehende Pythonoperator hat deshalb einen **separaten, ausschließlich
lesenden** Originalfallpfad `diagnose-partial` erhalten. Er bindet ausschließlich
Fallad9fd154-b2be-4f5d-9e17-65abb721ceaf, dessen Manifest0c9a3ffe…,
Originalgeneratora8d55b60…, Originalcontrollerd8b4fd4f… und Konfigurationshash2b4a….
Die vorhandenen Marker und Originaldateien werden nicht geändert. `load_case`
wird absichtlich nicht verwendet: dessen Generatorbindung darf nicht auf die
neue Quelle umgedeutet werden. Ebenso wird keine neue Skript-SHA als ursprüngliche
`request.script_sha256` ausgegeben. Der neue Reader hat eine eigene Source-SHA,
die der kleine In-Memory-Launcher vor der Ausführung prüft; genau ausgeführte
Readerbytes, Intent, rohe Antwort und separater Receipt werden ausschließlich
in einem neuen lokalen700/600-Diagnosefall gespeichert.
Geplanter Aufruf, **hier nicht ausgeführt**, erst nach erneut ausdrücklich
bestätigtem Zugang und dessen erfolgreichem Readback:
```sh
python3 /home/kevin/Schreibtisch/Coding/rust-discovery-signed-clock/deploy/windows/time_profile_config.py diagnose-partial
```
Kein `--case`: der Reader akzeptiert keine andere Fall-ID oder frei wählbare
Pfade. Die lokalen Originalbelege liegen weiterhin im Agent-Updater-Worktree.
Die geschützte aktuelle Zugangskonfiguration muss noch mindestens60s zulassen;
sonst erfolgt kein SSHaufruf. Native PowerShell-AST-/VM-Ausführung dieses neuen
Readers sind noch offen. Er enthält keine Publish-/ACL-/Serviceoperation und
fragt weder Uhrqualität noch Dienst-Snapshot ab.
Der Reader liefert nur aktuelle Kandidat-/Zielidentität, Größe, Hash, DACLhash,
Attribute und Zeiten sowie feste Originalmarker/active-Bindung und Root-SDDL.
Aktuelle Lesefehler werden mit Exceptiontyp/HRESULT und nur bei passender
HRESULT-Facility mit Win32-Code aufgezeichnet, ohne freien Fehlertext. Diese
Nummern gehören ausschließlich zum **neuen Leseversuch**. Er setzt immer
`old_move_hresult_unknown=true`, `retry_authorized=false`,
`installation_verified=false` und `clock_runtime_qualified=false`.
Das Ergebnis ist Grundlage einer späteren Entscheidung, keine Retryerlaubnis:
- Kandidat unverändert und Ziel fehlt: Veröffentlichung weiterhin nicht erfolgt;
im nächsten aktiven Wartungsfenster anhand des Originalzustands mit einem
überprüften Finalisierungsbefehl fertigstellen. Das MVP-/Profilvorhaben ist
bereits beauftragt; dafür keine pauschale zusätzliche Chatgenehmigung verlangen.
- Ziel vorhanden: weder Move noch Install erneut aufrufen; zuerst Ziel-/Kandidat-
FileID-/Hash-/ACLbindung und tatsächliche Laufzeitwirkung getrennt beurteilen.
- Fehlender/veränderter Kandidat, widersprüchliche Marker, andere Dateiidentität
oder Lesefehler: Teilzustand erhalten, keine automatische Rekonstruktion,
Löschung oder Rechte-/Dienständerung.
Lokal tatsächlich bestanden: Pythoncompile, bestehende Sourceguards und acht
Vertragsfälle, davon zwei neue für den geschlossenen Reader und seine exakte
Source-/Intent-/Receiptbindung ohne Legacy-Hashadoption. Der Transport ist dabei
vollständig gemockt; dies ist kein nativer Befund. Die Kontrollbelege des alten
fehlgeschlagenen Installationsfalls bleiben bytegleich erhalten. Ein konkreter
Publikationsfix wurde mangels belegter nativer Fehlerursache nicht erfunden.
## Nachlese durch die Bedienperson auf der Windows-VM
In der administrativen VM-Konsole konnte die Bedienperson den Kandidaten
`time-attestation.candidate.json` lesen. SHA-256 stimmte mit dem im
Publish-Intent hinterlegten Wert `2b4a8a7080770304b80e2a665fa5f5ee1ebbd9182e7c80b184e75b114575b42b`
überein. Für den festen Zielpfad unter `RustDiscoverySystem` meldete
PowerShell `ObjectNotFound`. Dieser Konsolenbefund ergänzt den früheren
Readback um den Inhalt des verbliebenen Kandidaten. FileID, DACL und
Dienstgeneration wurden bei dieser Konsolenabfrage nicht erfasst.
Für die Fortsetzung an derselben VM-Konsole liegt
[`Complete-OriginalTimeProfile.ps1`](../deploy/windows/Complete-OriginalTimeProfile.ps1)
bereit. Der Befehl übernimmt die Prüffunktionen aus den SHA-256-geprüften
Bytes des bereits installierten Controllers. Vor der Veröffentlichung prüft er
die ursprüngliche Datei-ID und das Volume, den Inhalt, die DACL, die
ursprünglichen Marker und beide laufenden Dienstgenerationen. Er hält die
beiden Prozesshandles während der Veröffentlichung offen. Ein exklusiv
erstellter zusätzlicher Marker verhindert eine doppelte Ausführung.
Nach der Verschiebung an den festen Zielpfad vergleicht das Skript die
Dateiidentität und die Dienstzustände erneut. Bei einem neuen Move-Fehler erfasst
es Fehlerklasse und HRESULT für diesen Aufruf. Ein erneuter Start trifft auf
den Abschlussmarker oder den vorhandenen Zielpfad und beendet sich. Das
Ergebnis einer erfolgreichen Veröffentlichung hält die separate
Laufzeitprüfung der beiden Dienstrollen ausdrücklich offen.
Lokal geprüft wurden die PowerShell-Syntax, die Bindung an die gespeicherten
Originalbelege und der Vergleich mit der tatsächlichen Kandidatenidentität.
Eine veränderte FileID wurde im lokalen Vergleich abgewiesen. Die Ausführung
des Abschlussbefehls auf der VM und die anschließende Zeitprüfung stehen aus.
## Ergebnis vom Konsolenschritt automatisch abholen
Für den vorbereiteten Profilabschluss steht `Open-TimeProfileReceiptWindow.ps1`
zur Verfügung. Die Bedienperson startet es auf der Windows-VM. Das Skript prüft
die beiden Downloads gegen feste SHA-256-Werte, öffnet den vorhandenen
Reverse-SSH-Transport und führt den festen Abschluss lokal aus. Die
Weiterleitung auf dem Server ist an `127.0.0.1:22240` gebunden. Auf der VM
endet sie an einem temporären Loopback-Port. Der Prozess sendet dort den
Abschlussstatus und die öffentlichen Belege der beiden Zeitdienstrollen.
Er liest keine Befehle vom Socket. Die Gast-Kontofrist und die Aufgabenplanung
werden nicht geändert. Strg+C oder zwölf Minuten beenden das Vordergrundfenster.
Die serverseitige Frist für den vorhandenen Transportschlüssel und der aktive
Abschalttimer wurden für den 15. November 2026, 18:00 Uhr MEZ, geprüft.
Beim Bereitstellen wurden der PowerShell-Parser, die Downloadhashes, die
bestehenden Quellprüfungen und die sechs lokalen Prüffälle für die Zeitbelege
ausgeführt. Ein Ergebnis von der VM liegt bei Bereitstellung noch nicht vor.
Der Ergebnisempfänger auf dem permanenten Server wurde anschließend gestartet.
Seine Anfangsprüfung des laufenden Gateways und der gespeicherten
Windows-Gerätebindung war erfolgreich. Der Server fragt den Loopback-Port
nur bei vorhandenem SSH-Listener ab und legt eingehende Belege im privaten
Fall `time-profile-receipt-f7f56e9f` ab. Für Zeitbelege verwendet er die
bestehende Rollen-, Boot-, Generations- und Altersprüfung mit je einer
Datenbanklesung vor und nach dem Empfang. Die Bereitstellung des Empfängers
belegt noch keine Profilveröffentlichung auf dem Gast.
+44
View File
@@ -104,3 +104,47 @@ und ersetzt diese Bindung nicht. Nach der getrennten passiven Paarwartung dürfe
die tatsächlichen neuen LocalService-/SYSTEM-Kernel-/Servicebelege mit vorhandenen
Source-, Rawcapture- und Plattformbelegen verbunden werden. Erst danach wird die
echte V2-Konfiguration erstellt; Runtimefrische und Genehmigungen folgen getrennt.
## Zeitprüfung bei ausgeschalteten Jobs am 15. November 2026
Die Konsole der laufenden VM bestätigte, dass weder der Jobschalter noch die
Jobbindung konfiguriert waren. Die Zeitprofildatei war noch nicht installiert.
Die bisherige Runtime übersprang bei ausgeschalteten Jobs auch den gesamten
signierten Zeitvergleich. Damit konnte die geplante Rollenprüfung über diesen
passiven Dienststand nicht beginnen.
Im neuen Quellstand prüft der Agent am Heartbeat, ob das geschützte Zeitprofil
vorliegt. Erst dann beginnen Agent und Helper den vorhandenen Vergleich mit
eigenen Challenges. Für den passiven Betrieb beträgt die Pause zwischen
Vergleichen pro Rolle 30 Sekunden. Die Datei allein belegt keine Zeitqualität.
Beide Rollen prüfen Pin, Gerätebindung, Signatur und Fristen. Der Jobschalter,
die JobClock und die Genehmigung bleiben getrennt. Ein Fehler beim Start des
passiven Vergleichs lässt Heartbeats und Inventar weiterlaufen.
Neun gezielte Prüfungen bestanden erst lokal und dann auf der Cloud-Linux-VM
als UID 65534 (Exit 0, 15 weitere Tests gefiltert, Ergebnis-SHA-256
`3424b0f916f0c9e68ed24d8ee0adeeb5feb5e8e834f63cfcbaadc5e45b06f840`).
Die neue Prüfung umfasst Profilauswahl und Abfrageintervall. Der Windows-Crossbuild
der Librarytests und Clippy mit allen Windows-Targets und `system-helper`
bestanden. Die installierten Dienstbinärdateien haben eigene Versionsnachweise.
Dieselben neun Tests liefen danach aus dem gebauten Windows-Testbinary auf der
Windows-11-VM. Die Namensliste der bestandenen Tests stimmte mit der auf der
Cloud-Linux-VM überein. Ergebnis: AMD64, Exit 0, neun bestanden, null
fehlgeschlagen oder übersprungen, 42 weitere gefiltert. Quittung
`39c76e698f5dd351096d1deed40cddbcc1a6677f93457b48ad4a4c3cedb36e88`.
Der native Testprozess prüfte die Logik mit Testdaten. Der signierte
Zeitvergleich in den beiden installierten Dienstprozessen ist eine eigene
offene Abnahme.
Für den Nachweis aus den laufenden Diensten hält der Agent je passiver Verbindung
den ersten vollständig geprüften Zeitvergleich pro Rolle fest. Im Agent-State
entstehen `agent-time-sample.json` und `helper-time-sample.json`. Die
SYSTEM-Beobachtung setzt die authentifizierte positive Antwort des Helpers auf
`TimeComplete` voraus. Beide Belege enthalten Rolle, Agent-PID, Windows-Boot,
Verbindungsgeneration, Verifier-Inkarnation, Beobachtungszeit und die SHA-256-Werte
der Anfrage und der empfangenen Antwort. Der Agent veröffentlicht sie beim
Heartbeat aus dem Zustand der jeweiligen Verbindung. Diese historischen Daten
werden bei der Jobfreigabe und der Prüfung der aktuellen Zeit nie eingelesen.
Der erweiterte Code bestand den Windows-Alltargets-Clippycheck. Die tatsächlichen
Belegdateien der installierten Rollen stehen noch aus.
@@ -0,0 +1,9 @@
-- Passive agent-update observations share the existing tenant/device-bound
-- ingest path. Preserve both base scopes and every existing row/RLS/FK.
-- SQLx applies this file transactionally and records its normal checksum.
SET LOCAL lock_timeout = '3s';
SET LOCAL statement_timeout = '15s';
ALTER TABLE observations DROP CONSTRAINT observations_source_id_check;
ALTER TABLE observations ADD CONSTRAINT observations_source_id_check
CHECK (source_id IN ('linux.base', 'windows.base', 'agent.update')) NOT VALID;
ALTER TABLE observations VALIDATE CONSTRAINT observations_source_id_check;