Compare commits

..
Author SHA1 Message Date
kevin_janssen ae82b2783f Record 79 native Windows MSI contract tests after Linux-first qualification
Rust development slice / linux (push) Failing after 6s
2026-11-14 13:29:37 +01:00
kevin_janssen 4a2fbef9ac Verify MSI common authorization and journal contracts on cloud Linux
Rust development slice / linux (push) Failing after 6s
2026-11-14 12:36:12 +01:00
kevin_janssen 8caa9a0478 Show immutable MSI plans in WebUI using actual Rust codec golden fixtures
Rust development slice / linux (push) Failing after 6s
2026-11-14 12:29:01 +01:00
kevin_janssen 9d98d0c603 Integrate strict Windows MSI manifests tenant catalog and SYSTEM package policy
Rust development slice / linux (push) Failing after 7s
2026-11-14 12:04:36 +01:00
kevin_janssen 9ddb18d9e0 Remove MSI builder trailing whitespace with unchanged parser tokens 2026-11-14 11:22:52 +01:00
kevin_janssen c393b6bdd2 Prepare fixed MSI 1.1 major upgrade with honest timeout and noop outcomes 2026-11-14 11:18:21 +01:00
kevin_janssen eb38b4b209 Record Linux-first native Windows Event Log contract acceptance
Rust development slice / linux (push) Failing after 6s
2026-11-14 10:49:10 +01:00
kevin_janssen 5656431ebf Implement bounded Windows Event Log jobs and verify contracts on cloud Linux
Rust development slice / linux (push) Failing after 7s
2026-11-14 10:48:05 +01:00
kevin_janssen d532ff0ffd Record native Windows process-profile contract acceptance 2026-11-14 10:48:05 +01:00
kevin_janssen abea4eb4d9 Bind approved Windows PowerShell process policy and prove Linux-first contracts
Rust development slice / linux (push) Failing after 6s
2026-11-14 10:06:10 +01:00
52 changed files with 5897 additions and 214 deletions
+51 -1
View File
@@ -1,6 +1,6 @@
# Rust RMM: Architektur und Implementierungsspezifikation
Version 1.18 · 2026-11-14 · Sprache: Deutsch
Version 1.19 · 2026-11-14 · Sprache: Deutsch
**Zweck:** Vollständige, eigenständig nutzbare Grundlage für die Implementierung einer mandantenfähigen Plattform zur Inventarisierung, Überwachung und Fernadministration von Kundengeräten durch eine Coding-KI und ein Entwicklungsteam.
@@ -15,6 +15,12 @@ Version 1.18 · 2026-11-14 · Sprache: Deutsch
lokaler Helperpolicy präzisiert. Keine Vererbung von Linux-Rootrechten, keine
Windowsfähigkeit aus einer bloßen Quellen-/Build-/Linux-Unitqualifikation.
1.18 → 1.19 (2026-11-14): Nächster Windows-M4-Schnitt als ausdrücklicher
Opt-in für zwei eigene feste MSI-Rezepte (1.0 und1.0→1.1) präzisiert:
unveränderlicher Tenantkatalog, exakte automatische Job-/Artefaktbindung,
getrennte SYSTEM-Paketerlaubnis und unabhängige Nachbedingungen. Kein freier
Installer, kein automatisches Update/Repair, keine implizite EXE-/Rebootfreigabe.
1.17 → 1.18 (2026-11-14): Ausdrückliche Userfreigabe für die feste, vor der
WebUI-Genehmigung sichtbare RemoteSigned-Option je Windows-PowerShell5.1-
Jobprozess, gezieltes Starten des bestehenden W32Time ohne Konfigurationsänderung
@@ -141,6 +147,50 @@ keinen Rebootjob-Abnahmenachweis. Dokumentierte Freigaben sind keine bereits
ausgeführten Schritte. Neue Capabilities werden erst nach ihrer getrennten
nativen Qualifikation eröffnet.
**Technische Präzisierung Version1.19 — enger Windows-M4-MSI-Schnitt:**
Nach dem getrennten SCM-Vertrag wird `ensure_package` ausschließlich für die
eigenen festen Machine-/x64-MSI-Rezepte1.0 und1.0→1.1 erweitert. Keine freie
SYSTEM-Shell, URL, Transformdatei, Propertyliste oder Ableitung von Linux-Root.
Ein optionales, bei Vorhandensein streng typisiertes `windows_msi_manifest`
bindet das vollständige kanonische Rezept samt Hash in der Action; fehlend bleibt
bei alten Linuxjobs ausgelassen. APT- und Windowsmanifest schließen einander aus.
Äußere Paket-/Versions-/Kontextfelder, Plattform und SYSTEM-Identität müssen
exakt zum Rezept passen. Sämtliche historischen Linux-Codecbytes bleiben erhalten.
Der Windowskatalog ist eigenständig, unveränderlich und mandantengetrennt; seine
Artefaktreferenz benötigt denselben Tenant. Pro konkretem Job/Versuch entsteht
automatisch genau die eine Referenz aus dem genehmigten Rezept: Artefakt-ID,
SHA256 und Länge. Freie zusätzliche Artefakt-IDs sind im MSI-Pfad verweigert.
Fehlende, zusätzliche oder doppelte Referenzen verweigern Revalidation,
Startgrant und Download. Der bestehende geräte-mTLS-/Job-/Versuch-gebundene
Artefaktendpoint bleibt maßgeblich; Bootstrap-SFTP ist keine Paketabnahme.
Zentrale und lokale SYSTEM-Policy erweitern ihre bisherige SCM-Erlaubnis nur
ausdrücklich versioniert um exakte MSI-Rezepthashes und eigene Paketrechte/
Capabilities. Alte SCM-only-Profile erteilen keine Paketerlaubnis. Vor WebUI-
Genehmigung stehen SYSTEM/Machine/x64, Rezept-/Artefakthashes, Produkt-/Upgrade-
und beim1.1-Rezept PackageCode, feste Version/Nutzdatei, Vorgänger, feste Argumente und
No-Reboot-Vertrag sichtbar aus den unveränderlichen Planbytes fest. Clock,
signierter unabhängiger Helpersync, Plan/Grant und dauerhafter Einmalverbrauch
bleiben vor Installerwirkung zwingend. Der Helper kopiert ausschließlich gegen
das signierte Rezept geprüfte Bytes in seinen geschützten Cache; keine vom
Netzwerkagenten frei gewählten Pfade/Programme oder allgemeinen Schreiboperationen.
Der getrennte Nichtdispatch-/Abandon-/RawMirror-Vertrag gilt additiv auch für
diese konkrete typisierte Action, ohne Cache-/Provider-/Installerwirkung durch
Abandon. Nach möglicher Übergabe gibt es keinen Execute-Retry. MSI0/3010 ist
nur mit unabhängiger innerhalb des ursprünglichen Budgets beobachteter
Nachbedingung erfolgreich;3010 meldet Neustartbedarf ohne Neustartstart.
1641 bleibt Unknown,1618 bekannter Konflikt ohne Retry. Unklarer Timeout/Abbruch
bleibt Unknown; kein globales Beenden von Windows Installer. Auch Noop benötigt
gültige Clock/Fence, Abbruchprüfung und rechtzeitigen unabhängigen Beleg.
Upgrade1.1 setzt genau den bekannten1.0-Vorgänger voraus; danach1.1 installiert,
1.0 entfernt und Nutzdatei exakt. Derselbe1.1-Rezept-/PackageCode erlaubt einen
separat genehmigten echten Noop, kein implizites Repair/Downgrade/Fresh1.1.
Quellen, Builds und Units eröffnen keine Capability oder Policy. Native
Installation/Upgrade/Noop erfolgen jeweils ausschließlich nach tatsächlicher
WebUI-Genehmigung auf der Windows-VM; Linux-first-Vertragsnachweise zuerst.
**Technische Präzisierung Version 1.17 — Nichtstart vor SYSTEM-Delegation:**
Vor jeder Socketübergabe bindet ein dauerhafter Intent die unveränderten
Originalrequest-/Job-/Grant-/Signaturbytes, Plan/Autorisierung, Gerät und
+3 -4
View File
@@ -33,8 +33,8 @@ impl Binding {
);
ensure!(
j.action.validate()
&& (1..=3600).contains(&j.max_runtime_seconds)
&& (1..=262144).contains(&j.max_output_bytes)
&& j.action
.valid_job_limits(j.max_runtime_seconds, j.max_output_bytes)
&& j.not_before < j.start_before,
"INVALID_JOB"
);
@@ -72,8 +72,7 @@ impl Binding {
ensure!(permit_window(&job, &permit), "PERMIT_TIME");
ensure!(
job.execution_identity == identity.as_str()
&& matches!(&job.action, rmm_domain::jobs::Action::SetServiceState { state, .. }
if matches!(state.as_str(), "running" | "stopped")),
&& job.action.valid_helper_denial_shape(identity.as_str()),
"DENIAL_HELPER_SCOPE"
);
Ok(VerifiedHistoricalDenial {
+157
View File
@@ -40,6 +40,7 @@ fn fixture() -> (Binding, Request, ExecutionPermitPayload, DateTime<Utc>) {
script_utf8: "printf 'Hello\\n'\n".into(),
arguments: vec![],
expected_stdout: Some("Hello\n".into()),
windows_execution_profile: None,
},
execution_identity: "agent_service".into(),
not_before: now - Duration::minutes(1),
@@ -170,6 +171,69 @@ fn exact_permit_bytes_time_and_all_identity_hash_bindings_are_required() {
let mut changed = request;
changed.signature.truncate(63);
assert!(binding.verify(&changed, now).is_err());
// Changing only the process policy is a payload mutation, even with the
// same script/attempt and a still valid original signature.
let (_, mut request, mut permit, _) = fixture();
let mut job: JobPayload = serde_json::from_slice(&request.job_bytes).unwrap();
job.action = Action::RunScript {
interpreter: "powershell".into(),
script_utf8: "Write-Output 'Hello'\r\n".into(),
arguments: vec![],
expected_stdout: Some("Hello\r\n".into()),
windows_execution_profile: None,
};
request.job_bytes = encode(&job).unwrap();
permit.job_payload_hash = hash(&request.job_bytes);
request.permit_bytes = encode(&permit).unwrap();
request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec();
binding.verify(&request, now).unwrap();
if let Action::RunScript {
windows_execution_profile,
..
} = &mut job.action
{
*windows_execution_profile =
Some(rmm_domain::jobs::WindowsExecutionProfile::PowerShell51RemoteSigned);
}
request.job_bytes = encode(&job).unwrap();
assert!(binding.verify(&request, now).is_err());
permit.job_payload_hash = hash(&request.job_bytes);
request.permit_bytes = encode(&permit).unwrap();
request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec();
binding.verify(&request, now).unwrap();
// The exact fixed Event Log source/window/limits are original signed bytes.
job.action = Action::QueryLogs {
unit: rmm_domain::jobs::WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
since: now - chrono::Duration::hours(1),
until: now,
max_lines: 1000,
};
request.job_bytes = encode(&job).unwrap();
permit.action = job.action.name().into();
permit.job_payload_hash = hash(&request.job_bytes);
request.permit_bytes = encode(&permit).unwrap();
request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec();
binding.verify(&request, now).unwrap();
let mut wrong_source = job.clone();
if let Action::QueryLogs { unit, .. } = &mut wrong_source.action {
*unit = "Security".into();
}
let mut changed = request.clone();
changed.job_bytes = encode(&wrong_source).unwrap();
assert!(binding.verify(&changed, now).is_err());
for (runtime, bytes) in [(9, 4096), (121, 4096), (10, 1023), (10, 65537)] {
let mut changed_job = job.clone();
changed_job.max_runtime_seconds = runtime;
changed_job.max_output_bytes = bytes;
let mut changed_permit = permit.clone();
changed_permit.max_runtime_seconds = runtime;
let mut changed = request.clone();
changed.job_bytes = encode(&changed_job).unwrap();
changed_permit.job_payload_hash = hash(&changed.job_bytes);
changed.permit_bytes = encode(&changed_permit).unwrap();
changed.signature = key.sign(&changed.permit_bytes).to_bytes().to_vec();
assert!(binding.verify(&changed, now).is_err());
}
}
#[cfg(unix)]
@@ -416,3 +480,96 @@ fn completion_cas_preserves_original_bytes_and_recovers_only_verified_bound_evid
.is_err()
);
}
#[test]
fn historical_msi_nonstart_keeps_full_signature_binding_and_never_becomes_root_authority() {
use rmm_agent_core::auth::HelperIdentity;
use rmm_domain::windows_execution::*;
let (binding, mut request, mut permit, now) = fixture();
let mut job: JobPayload = serde_json::from_slice(&request.job_bytes).unwrap();
let recipe = WindowsMsiRecipe {
schema_version: 1,
recipe_id: MSI_RECIPE_ID.into(),
recipe_version: "1".into(),
platform: "windows".into(),
upgrade_code: MSI_UPGRADE_CODE.into(),
architecture: Architecture::X64,
context: InstallContext::Machine,
command_profile: MsiCommandProfile::FixtureQuietNoRebootV1,
artifact: MsiArtifact {
artifact_id: Uuid::from_u128(19),
sha256: "ab".repeat(32),
bytes: 32,
},
postcondition: MsiPostcondition {
product_code: MSI_PRODUCT_CODE.into(),
product_version: MSI_VERSION.into(),
payload_path: MSI_PAYLOAD.into(),
payload_sha256: MSI_PAYLOAD_10_SHA256.into(),
payload_bytes: MSI_PAYLOAD_BYTES,
},
no_reboot: true,
package_code: None,
predecessor: None,
};
let manifest = ResolvedWindowsMsi {
recipe_sha256: recipe.sha256().unwrap(),
recipe,
};
job.action = Action::EnsurePackage {
provider: "msi".into(),
package: MSI_PACKAGE_ID.into(),
version: MSI_VERSION.into(),
architecture: "x64".into(),
recipe_version: "1".into(),
installation_context: "machine".into(),
recipe_id: Some(MSI_RECIPE_ID.into()),
apt_manifest: None,
windows_msi_manifest: Some(Box::new(manifest)),
};
job.execution_identity = "system".into();
request.job_bytes = encode(&job).unwrap();
permit.action = "ensure_package".into();
permit.execution_identity = "system".into();
permit.job_payload_hash = hash(&request.job_bytes);
request.permit_bytes = encode(&permit).unwrap();
request.signature = SigningKey::from_bytes(&[9; 32])
.sign(&request.permit_bytes)
.to_bytes()
.to_vec();
binding
.verify_historical_for_denial_with(
&request,
HelperIdentity::System,
&rmm_agent_core::crypto::DalekVerifier,
)
.unwrap();
assert!(
binding
.verify_historical_for_denial_with(
&request,
HelperIdentity::Root,
&rmm_agent_core::crypto::DalekVerifier
)
.is_err()
);
assert!(binding.verify(&request, now + Duration::hours(1)).is_err()); // historical denial is never live authorization
if let Action::EnsurePackage {
windows_msi_manifest: Some(m),
..
} = &mut job.action
{
m.recipe.artifact.bytes += 1;
m.recipe_sha256 = m.recipe.sha256().unwrap();
}
request.job_bytes = encode(&job).unwrap();
assert!(
binding
.verify_historical_for_denial_with(
&request,
HelperIdentity::System,
&rmm_agent_core::crypto::DalekVerifier
)
.is_err()
);
}
@@ -867,6 +867,7 @@ fn script() -> Action {
script_utf8: "printf hello".into(),
arguments: vec![],
expected_stdout: Some("hello".into()),
windows_execution_profile: None,
}
}
fn success() -> ReconciledOutcome {
+1
View File
@@ -605,6 +605,7 @@ fn script() -> Action {
script_utf8: "printf hello".into(),
arguments: vec![],
expected_stdout: Some("hello".into()),
windows_execution_profile: None,
}
}
fn success() -> ReconciledOutcome {
+1 -1
View File
@@ -39,4 +39,4 @@ rcgen = { version = "=0.14.10", default-features = false, features = ["crypto",
cc = "=1.11.1"
[target.'cfg(windows)'.dependencies]
windows-sys = { version = "0.61.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_JobObjects", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_System_Registry", "Win32_System_Memory", "Win32_System_Services", "Win32_System_Threading"] }
windows-sys = { version = "0.61.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_EventLog", "Win32_System_Diagnostics_ToolHelp", "Win32_System_JobObjects", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_System_Registry", "Win32_System_Memory", "Win32_System_Services", "Win32_System_Threading"] }
+178 -13
View File
@@ -2,7 +2,7 @@
//! consumption are supplied by the shared core and the runtime, never bypassed.
use anyhow::{Result, ensure};
use rmm_agent_core::auth::Outcome;
use rmm_domain::jobs::{Action, JobPayload, hash};
use rmm_domain::jobs::{Action, JobPayload, WindowsExecutionProfile, hash};
use std::{
ffi::OsString,
fs::{File, OpenOptions},
@@ -11,6 +11,41 @@ use std::{
path::{Path, PathBuf},
sync::atomic::AtomicBool,
};
/// Implemented contract name only. Runtime publication still requires its own
/// native clock/boot/job qualification; this constant grants no capability.
pub const REMOTE_SIGNED_PROFILE_CAPABILITY: &str = "script.powershell.process_remote_signed/1";
fn script_arguments(job: &JobPayload, path: &Path) -> Result<Vec<OsString>> {
let Action::RunScript {
interpreter,
arguments,
windows_execution_profile,
..
} = &job.action
else {
anyhow::bail!("SCRIPT_REQUIRED")
};
ensure!(
job.execution_identity == "agent_service"
&& interpreter == "powershell"
&& job.action.validate(),
"WINDOWS_SCRIPT_PROFILE_BINDING"
);
let mut args: Vec<OsString> = ["-NoLogo", "-NoProfile", "-NonInteractive"]
.into_iter()
.map(OsString::from)
.collect();
if let Some(WindowsExecutionProfile::PowerShell51RemoteSigned) = windows_execution_profile {
args.extend([
OsString::from("-ExecutionPolicy"),
OsString::from("RemoteSigned"),
]);
}
args.push(OsString::from("-File"));
args.push(path.as_os_str().into());
args.extend(arguments.iter().map(OsString::from));
Ok(args)
}
use windows_sys::Win32::{
Storage::FileSystem::{
FILE_ATTRIBUTE_REPARSE_POINT, FILE_FLAG_OPEN_REPARSE_POINT, FILE_SHARE_READ,
@@ -36,10 +71,45 @@ pub fn supported(job: &JobPayload) -> bool {
interpreter == "powershell" && powershell().is_ok()
}
Action::RefreshInventory { scope } => scope == "windows.base",
Action::QueryLogs { .. } => crate::event_log::for_job(job).is_ok(),
_ => false,
}
}
/// Each prepared operation retains its own typed binding; no non-script action
/// can fall through to inventory or borrow the PowerShell execution profile.
pub enum PreparedAction {
Script(Script),
Inventory,
EventLog(crate::event_log_job::Prepared),
}
impl PreparedAction {
pub fn prepare(
job: &JobPayload,
directory: &Path,
grant: uuid::Uuid,
request: &rmm_agent_core::auth::Request,
boot: uuid::Uuid,
) -> Result<Self> {
ensure!(supported(job), "UNSUPPORTED_CAPABILITY");
match &job.action {
Action::RunScript { .. } => Ok(Self::Script(Script::prepare(job, directory, grant)?)),
Action::RefreshInventory { scope } if scope == "windows.base" => Ok(Self::Inventory),
Action::QueryLogs { .. } => Ok(Self::EventLog(
crate::event_log_job::Prepared::prepare(job, directory, request, grant, boot)?,
)),
_ => anyhow::bail!("UNSUPPORTED_CAPABILITY"),
}
}
pub fn run(self, job: &JobPayload, cancel: &AtomicBool) -> Result<Outcome> {
match self {
Self::Script(script) => script.run(job, cancel),
Self::Inventory => inventory(job),
Self::EventLog(log) => log.run(job, cancel),
}
}
}
pub struct Script {
executable: PathBuf,
path: PathBuf,
@@ -47,6 +117,7 @@ pub struct Script {
_file: File,
cwd: PathBuf,
arguments: Vec<OsString>,
profile: Option<WindowsExecutionProfile>,
}
impl Script {
/// Preparation creates only a protected copy of approved bytes, no child.
@@ -56,7 +127,7 @@ impl Script {
let Action::RunScript {
interpreter,
script_utf8,
arguments,
windows_execution_profile,
..
} = &job.action
else {
@@ -95,18 +166,14 @@ impl Script {
hash(&std::fs::read(&path)?) == hash(script_utf8.as_bytes()),
"SCRIPT_BYTES_CHANGED"
);
let mut args: Vec<OsString> = ["-NoLogo", "-NoProfile", "-NonInteractive", "-File"]
.into_iter()
.map(OsString::from)
.collect();
args.push(path.clone().into_os_string());
args.extend(arguments.iter().map(OsString::from));
let args = script_arguments(job, &path)?;
Ok(Self {
executable: powershell()?,
path,
_file: file,
cwd: directory.to_path_buf(),
arguments: args,
profile: *windows_execution_profile,
})
}
pub fn run(self, job: &JobPayload, cancel: &AtomicBool) -> Result<Outcome> {
@@ -115,6 +182,7 @@ impl Script {
let Action::RunScript {
script_utf8,
expected_stdout,
windows_execution_profile,
..
} = &job.action
else {
@@ -124,6 +192,11 @@ impl Script {
std::fs::read(&self.path)? == script_utf8.as_bytes(),
"SCRIPT_BYTES_CHANGED"
);
ensure!(
self.profile == *windows_execution_profile
&& self.arguments == script_arguments(job, &self.path)?,
"WINDOWS_SCRIPT_PROFILE_CHANGED"
);
let output = crate::process::run(
&self.executable,
&self.arguments,
@@ -159,6 +232,17 @@ impl Script {
} else {
""
};
let mut evidence = serde_json::json!({"postconditions_passed":success,"interpreter":"powershell",
"script_sha256":hash(script_utf8.as_bytes()),"execution_sid":"S-1-5-19",
"output_encoding":"raw_native_bytes","comparison":"exact_utf8_bytes",
"execution_policy":"inherited","process_tree_bounded":true,
"cancel_requested":output.cancelled,"termination_does_not_prove_absence_of_effects":output.interrupted});
if self.profile.is_some() {
evidence["windows_execution_profile"] = serde_json::to_value(self.profile)?;
evidence["execution_policy"] = serde_json::json!("process_remote_signed_requested");
evidence["execution_policy_requested"] = serde_json::json!("RemoteSigned");
evidence["execution_policy_scope"] = serde_json::json!("process");
}
Ok(Outcome {
state: state.into(),
stdout: output.stdout,
@@ -167,11 +251,7 @@ impl Script {
output_truncated: output.truncated,
reboot_required: false,
error_code: code.into(),
evidence: serde_json::json!({"postconditions_passed":success,"interpreter":"powershell",
"script_sha256":hash(script_utf8.as_bytes()),"execution_sid":"S-1-5-19",
"output_encoding":"raw_native_bytes","comparison":"exact_utf8_bytes",
"execution_policy":"inherited","process_tree_bounded":true,
"cancel_requested":output.cancelled,"termination_does_not_prove_absence_of_effects":output.interrupted}),
evidence,
})
}
}
@@ -200,3 +280,88 @@ pub fn inventory(job: &JobPayload) -> Result<Outcome> {
"observed_at":chrono::Utc::now(),"completeness":"partial","execution_sid":"S-1-5-19"}),
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn powershell_policy_is_an_exact_job_profile_before_file_not_a_mutable_default() {
let id = uuid::Uuid::new_v4();
let now = chrono::Utc::now();
let mut job = JobPayload {
schema_version: 1,
tenant_id: id,
asset_id: id,
agent_id: id,
enrollment_generation: 1,
assignment_version: 1,
job_id: id,
attempt_id: id,
action: Action::RunScript {
interpreter: "powershell".into(),
script_utf8: "Write-Output 'fixed'\r\n".into(),
arguments: vec!["-ExecutionPolicy".into(), "Bypass".into()],
expected_stdout: None,
windows_execution_profile: None,
},
execution_identity: "agent_service".into(),
not_before: now,
start_before: now + chrono::Duration::seconds(60),
max_runtime_seconds: 30,
max_output_bytes: 4096,
};
let path = Path::new(r"C:\fixed state\approved.ps1");
let inherited = script_arguments(&job, path).unwrap();
assert_eq!(
inherited,
vec![
"-NoLogo",
"-NoProfile",
"-NonInteractive",
"-File",
r"C:\fixed state\approved.ps1",
"-ExecutionPolicy",
"Bypass"
]
.into_iter()
.map(OsString::from)
.collect::<Vec<_>>()
);
if let Action::RunScript {
windows_execution_profile,
..
} = &mut job.action
{
*windows_execution_profile = Some(WindowsExecutionProfile::PowerShell51RemoteSigned);
}
let args = script_arguments(&job, path).unwrap();
assert_eq!(
args[..6],
[
"-NoLogo",
"-NoProfile",
"-NonInteractive",
"-ExecutionPolicy",
"RemoteSigned",
"-File"
]
.map(OsString::from)
);
assert_eq!(args[6], path.as_os_str()); // approved arguments remain AFTER -File
assert_ne!(inherited, args);
let mut unknown = serde_json::to_value(&job.action).unwrap();
unknown["windows_execution_profile"] = serde_json::json!("Bypass");
assert!(serde_json::from_value::<Action>(unknown).is_err());
for identity in ["root", "system"] {
job.execution_identity = identity.into();
assert!(script_arguments(&job, path).is_err());
}
job.execution_identity = "agent_service".into();
for other in ["posix_sh", "bash", "pwsh"] {
if let Action::RunScript { interpreter, .. } = &mut job.action {
*interpreter = other.into();
}
assert!(script_arguments(&job, path).is_err());
}
}
}
+88 -4
View File
@@ -1,4 +1,5 @@
//! Bounded, local, fixture-only live Event Log query; not wired into any job.
//! Bounded, local, fixture-only Event Log provider. Only the authorized native
//! job worker may call the Windows provider; this module confers no authority.
//!
//! EvtQuery/EvtRender have no per-call timeout. The monotonic deadline below is
//! cooperative between Win32 calls; the eventual executor must also supervise
@@ -12,8 +13,9 @@ use chrono::{DateTime, SecondsFormat, Utc};
use serde::{Deserialize, Serialize};
use std::sync::atomic::AtomicBool;
pub const CHANNEL: &str = "Application";
pub const PROVIDER: &str = "RustDiscovery-MVP-Test";
pub use rmm_domain::jobs::{
WINDOWS_EVENT_LOG_FIXTURE_CHANNEL as CHANNEL, WINDOWS_EVENT_LOG_FIXTURE_PROVIDER as PROVIDER,
};
const MAX_BYTES: usize = 256 * 1024;
#[cfg(any(windows, test))]
const REPORT_RESERVE: usize = 256;
@@ -57,7 +59,42 @@ impl Query {
}
}
#[derive(Debug, Serialize)]
/// Pure job-to-provider binding. Never opens a channel or touches a bookmark.
pub fn for_job(job: &rmm_domain::jobs::JobPayload) -> Result<Query> {
use rmm_domain::jobs::{Action, WINDOWS_EVENT_LOG_FIXTURE_SOURCE};
let Action::QueryLogs {
unit,
since,
until,
max_lines,
} = &job.action
else {
anyhow::bail!("EVENT_LOG_ACTION_REQUIRED")
};
ensure!(
job.execution_identity == "agent_service"
&& unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE
&& job.action.validate()
&& job
.action
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes),
"EVENT_LOG_JOB_BINDING"
);
let q = Query {
channel: CHANNEL.into(),
provider: PROVIDER.into(),
start_utc: *since,
end_utc: *until,
max_events: *max_lines,
max_output_bytes: job.max_output_bytes,
timeout_ms: 5000,
};
q.xpath()?;
Ok(q)
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Event {
pub channel: String,
pub provider: String,
@@ -501,6 +538,53 @@ mod tests {
}
}
#[test]
fn job_mapping_is_only_fixed_unprivileged_live_logs_with_exact_limits() {
use rmm_domain::jobs::{Action, JobPayload, WINDOWS_EVENT_LOG_FIXTURE_SOURCE};
let id = uuid::Uuid::new_v4();
let now = DateTime::from_timestamp(1_700_000_000, 0).unwrap();
let mut job = JobPayload {
schema_version: 1,
tenant_id: id,
asset_id: id,
agent_id: id,
enrollment_generation: 1,
assignment_version: 1,
job_id: id,
attempt_id: id,
action: Action::QueryLogs {
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
since: now,
until: now + chrono::Duration::hours(24),
max_lines: 1000,
},
execution_identity: "agent_service".into(),
not_before: now,
start_before: now + chrono::Duration::seconds(60),
max_runtime_seconds: 10,
max_output_bytes: 65536,
};
let q = for_job(&job).unwrap();
assert_eq!(
(q.channel.as_str(), q.provider.as_str()),
(CHANNEL, PROVIDER)
);
assert_eq!(q.max_output_bytes, 65536);
for identity in ["root", "system"] {
job.execution_identity = identity.into();
assert!(for_job(&job).is_err());
}
job.execution_identity = "agent_service".into();
for bytes in [1023, 65537] {
job.max_output_bytes = bytes;
assert!(for_job(&job).is_err());
}
job.max_output_bytes = 65536;
if let Action::QueryLogs { until, .. } = &mut job.action {
*until += chrono::Duration::nanoseconds(1);
}
assert!(for_job(&job).is_err());
}
#[test]
fn serialized_byte_budget_includes_xml_escaping_and_metadata() {
let q = request();
let mut report = Report::new(&q);
+778
View File
@@ -0,0 +1,778 @@
//! Fixed, authorized Event Log subprocess. A command-line mode is not a live
//! query API: the child authenticates its real SCM parent, original signed
//! request, protected public trust, and an already committed consumption/start.
//! Request/grant bytes remain in a private, create-once job file, never argv.
use crate::{event_log, native};
use anyhow::{Context, Result, ensure};
use chrono::{DateTime, Utc};
use rmm_agent_core::auth::{Binding, Outcome, Request};
use rmm_domain::jobs::{ExecutionPermitPayload, JobPayload, hash};
use serde::{Deserialize, Serialize};
use std::{
fs::{File, OpenOptions},
io::{Read, Write},
mem::{size_of, size_of_val, zeroed},
os::windows::{
fs::OpenOptionsExt,
io::{AsRawHandle, FromRawHandle, OwnedHandle},
},
path::{Path, PathBuf},
ptr,
sync::atomic::AtomicBool,
time::Duration,
};
use uuid::Uuid;
use windows_sys::Win32::{
Foundation::*,
Security::{self, *},
Storage::FileSystem::*,
System::{Diagnostics::ToolHelp::*, Services::*, Threading::*},
};
pub const MODE: &str = "--eventlog-worker";
const CONFIG: &str = r"C:\ProgramData\RustDiscovery\config.json";
const TICKET_LIMIT: u64 = 128 * 1024;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct FileId {
volume: u64,
id: [u8; 16],
}
fn file_id(handle: HANDLE) -> Result<FileId> {
let mut info: FILE_ID_INFO = unsafe { zeroed() };
ensure!(
unsafe {
GetFileInformationByHandleEx(
handle,
FileIdInfo,
(&mut info as *mut FILE_ID_INFO).cast(),
size_of::<FILE_ID_INFO>() as u32,
)
} != 0,
"EVENT_LOG_FILE_ID"
);
Ok(FileId {
volume: info.VolumeSerialNumber,
id: info.FileId.Identifier,
})
}
fn owned(handle: HANDLE) -> Result<OwnedHandle> {
ensure!(
!handle.is_null() && handle != INVALID_HANDLE_VALUE,
"EVENT_LOG_HANDLE"
);
Ok(unsafe { OwnedHandle::from_raw_handle(handle) })
}
fn birth(handle: HANDLE) -> Result<u64> {
let (mut c, mut e, mut k, mut u) = unsafe { (zeroed(), zeroed(), zeroed(), zeroed()) };
ensure!(
unsafe { GetProcessTimes(handle, &mut c, &mut e, &mut k, &mut u) } != 0,
"EVENT_LOG_PROCESS_TIME"
);
Ok((u64::from(c.dwHighDateTime) << 32) | u64::from(c.dwLowDateTime))
}
fn text(value: *const u16) -> Result<String> {
ensure!(!value.is_null(), "EVENT_LOG_NATIVE_STRING");
let mut length = 0;
while length < 32768 && unsafe { *value.add(length) } != 0 {
length += 1;
}
ensure!(length < 32768, "EVENT_LOG_NATIVE_STRING_SIZE");
Ok(String::from_utf16(unsafe {
std::slice::from_raw_parts(value, length)
})?)
}
fn process_image(handle: HANDLE) -> Result<PathBuf> {
let mut buffer = vec![0u16; 32768];
let mut len = buffer.len() as u32;
ensure!(
unsafe { QueryFullProcessImageNameW(handle, 0, buffer.as_mut_ptr(), &mut len) } != 0,
"EVENT_LOG_PARENT_IMAGE"
);
Ok(String::from_utf16(&buffer[..len as usize])?.into())
}
struct Service(SC_HANDLE);
impl Drop for Service {
fn drop(&mut self) {
unsafe {
CloseServiceHandle(self.0);
}
}
}
fn agent_pid(image: &Path) -> Result<u32> {
let manager = Service(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
ensure!(!manager.0.is_null(), "EVENT_LOG_SCM");
let service = Service(unsafe {
OpenServiceW(
manager.0,
native::wide(crate::SERVICE_NAME).as_ptr(),
SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS,
)
});
ensure!(!service.0.is_null(), "EVENT_LOG_AGENT_SERVICE");
let mut bytes = 0;
unsafe {
QueryServiceConfigW(service.0, ptr::null_mut(), 0, &mut bytes);
}
ensure!((1..=32768).contains(&bytes), "EVENT_LOG_AGENT_CONFIG_SIZE");
let mut storage = vec![0usize; (bytes as usize).div_ceil(size_of::<usize>())];
ensure!(
unsafe { QueryServiceConfigW(service.0, storage.as_mut_ptr().cast(), bytes, &mut bytes) }
!= 0,
"EVENT_LOG_AGENT_CONFIG"
);
let config = unsafe { &*storage.as_ptr().cast::<QUERY_SERVICE_CONFIGW>() };
ensure!(
config.dwServiceType == SERVICE_WIN32_OWN_PROCESS
&& text(config.lpBinaryPathName)?
== format!("\"{}\" --service --config \"{CONFIG}\"", image.display())
&& text(config.lpServiceStartName)?.eq_ignore_ascii_case(r"NT AUTHORITY\LocalService"),
"EVENT_LOG_AGENT_CONFIG_BINDING"
);
let mut status: SERVICE_STATUS_PROCESS = unsafe { zeroed() };
ensure!(
unsafe {
QueryServiceStatusEx(
service.0,
SC_STATUS_PROCESS_INFO,
(&mut status as *mut SERVICE_STATUS_PROCESS).cast(),
size_of::<SERVICE_STATUS_PROCESS>() as u32,
&mut bytes,
)
} != 0
&& status.dwCurrentState == SERVICE_RUNNING
&& status.dwProcessId > 0,
"EVENT_LOG_AGENT_NOT_RUNNING"
);
Ok(status.dwProcessId)
}
fn token_info(token: HANDLE, class: TOKEN_INFORMATION_CLASS) -> Result<Vec<usize>> {
let mut bytes = 0;
unsafe {
GetTokenInformation(token, class, ptr::null_mut(), 0, &mut bytes);
}
ensure!((1..=65536).contains(&bytes), "EVENT_LOG_TOKEN_SIZE");
let mut data = vec![0usize; (bytes as usize).div_ceil(size_of::<usize>())];
ensure!(
unsafe { GetTokenInformation(token, class, data.as_mut_ptr().cast(), bytes, &mut bytes) }
!= 0,
"EVENT_LOG_TOKEN"
);
Ok(data)
}
fn service_token(process: HANDLE) -> Result<()> {
let mut token = ptr::null_mut();
ensure!(
unsafe { OpenProcessToken(process, TOKEN_QUERY, &mut token) } != 0,
"EVENT_LOG_TOKEN_OPEN"
);
let token = owned(token)?;
let user = token_info(token.as_raw_handle(), TokenUser)?;
let mut service_sid = ptr::null_mut();
ensure!(
unsafe {
Security::Authorization::ConvertStringSidToSidW(
native::wide(native::service_sid()?).as_ptr(),
&mut service_sid,
)
} != 0,
"EVENT_LOG_SERVICE_SID"
);
struct Sid(PSID);
impl Drop for Sid {
fn drop(&mut self) {
unsafe {
LocalFree(self.0);
}
}
}
let service_sid = Sid(service_sid);
let mut ls = [0usize; 16];
let mut size = size_of_val(&ls) as u32;
ensure!(
unsafe {
CreateWellKnownSid(
WinLocalServiceSid,
ptr::null_mut(),
ls.as_mut_ptr().cast(),
&mut size,
)
} != 0
&& unsafe {
EqualSid(
(*user.as_ptr().cast::<TOKEN_USER>()).User.Sid,
ls.as_ptr().cast_mut().cast(),
)
} != 0,
"EVENT_LOG_LOCAL_SERVICE_REQUIRED"
);
let groups = token_info(token.as_raw_handle(), TokenGroups)?;
let g = unsafe { &*groups.as_ptr().cast::<TOKEN_GROUPS>() };
let offset = std::mem::offset_of!(TOKEN_GROUPS, Groups);
ensure!(
g.GroupCount <= 1024
&& offset + g.GroupCount as usize * size_of::<SID_AND_ATTRIBUTES>()
<= groups.len() * size_of::<usize>(),
"EVENT_LOG_TOKEN_GROUPS_SIZE"
);
let entries = unsafe { std::slice::from_raw_parts(g.Groups.as_ptr(), g.GroupCount as usize) };
let mut admins = [0usize; 16];
let mut admin_bytes = size_of_val(&admins) as u32;
ensure!(
unsafe {
CreateWellKnownSid(
WinBuiltinAdministratorsSid,
ptr::null_mut(),
admins.as_mut_ptr().cast(),
&mut admin_bytes,
)
} != 0,
"EVENT_LOG_ADMIN_SID"
);
ensure!(
!entries
.iter()
.any(|entry| entry.Attributes & 0x0000_0004 != 0
&& unsafe { EqualSid(entry.Sid, admins.as_ptr().cast_mut().cast()) } != 0),
"EVENT_LOG_ADMINISTRATOR_FORBIDDEN"
);
// TOKEN_GROUPS enabled/deny-only bits from winnt.h, as in the pipe peer proof.
ensure!(
entries
.iter()
.any(|entry| entry.Attributes & 0x0000_0004 != 0
&& entry.Attributes & 0x0000_0010 == 0
&& unsafe { EqualSid(entry.Sid, service_sid.0) } != 0),
"EVENT_LOG_AGENT_SID_REQUIRED"
);
Ok(())
}
fn parent_pid() -> Result<u32> {
let snapshot = owned(unsafe { CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) })?;
let mut entry: PROCESSENTRY32W = unsafe { zeroed() };
entry.dwSize = size_of::<PROCESSENTRY32W>() as u32;
let mut ok = unsafe { Process32FirstW(snapshot.as_raw_handle(), &mut entry) };
while ok != 0 {
if entry.th32ProcessID == std::process::id() {
return Ok(entry.th32ParentProcessID);
}
ok = unsafe { Process32NextW(snapshot.as_raw_handle(), &mut entry) };
}
anyhow::bail!("EVENT_LOG_PARENT_UNVERIFIED")
}
fn open_private(path: &Path, share_write: bool) -> Result<File> {
ensure!(
path.is_absolute() && !path.to_string_lossy().starts_with(r"\\"),
"EVENT_LOG_LOCAL_PATH"
);
for parent in path.ancestors().skip(1) {
use std::os::windows::fs::MetadataExt;
ensure!(
std::fs::symlink_metadata(parent)?.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT
== 0,
"EVENT_LOG_REPARSE_ANCESTOR"
);
}
native::private_path(path, false)?;
let file = OpenOptions::new()
.read(true)
.share_mode(FILE_SHARE_READ | if share_write { FILE_SHARE_WRITE } else { 0 })
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
.open(path)?;
use std::os::windows::fs::MetadataExt;
ensure!(
file.metadata()?.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT == 0,
"EVENT_LOG_REPARSE_FILE"
);
Ok(file)
}
fn read(file: &mut File, limit: u64) -> Result<Vec<u8>> {
ensure!(
file.metadata()?.len() <= limit,
"EVENT_LOG_PRIVATE_FILE_LIMIT"
);
let mut value = Vec::new();
file.take(limit + 1).read_to_end(&mut value)?;
ensure!(value.len() as u64 <= limit, "EVENT_LOG_PRIVATE_FILE_LIMIT");
Ok(value)
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct Ticket {
request: Request,
parent_pid: u32,
parent_birth: u64,
boot: Uuid,
ledger: FileId,
}
#[derive(Deserialize)]
struct WorkerConfig {
state_directory: PathBuf,
job_binding_file: PathBuf,
enable_jobs: bool,
}
fn ticket_name(permit: &ExecutionPermitPayload) -> String {
format!("eventlog-{}.json", hash(permit.grant_id.as_bytes()))
}
/// Prepared data only. No query, worker or Evt handle exists before run.
pub struct Prepared {
path: PathBuf,
_file: File,
ticket_hash: String,
job_bytes: Vec<u8>,
}
impl Prepared {
pub fn prepare(
job: &JobPayload,
directory: &Path,
request: &Request,
grant: Uuid,
boot: Uuid,
) -> Result<Self> {
event_log::for_job(job)?;
native::require_local_service()?;
service_token(unsafe { GetCurrentProcess() })?;
let image = std::env::current_exe()?;
ensure!(
agent_pid(&image)? == std::process::id(),
"EVENT_LOG_REAL_AGENT_REQUIRED"
);
let permit: ExecutionPermitPayload = serde_json::from_slice(&request.permit_bytes)?;
ensure!(
permit.grant_id == grant && !boot.is_nil(),
"EVENT_LOG_GRANT_BINDING"
);
native::private_path(directory, true)?;
let ledger = open_private(
&directory
.parent()
.context("EVENT_LOG_STATE_DIRECTORY")?
.join("consumption.sqlite"),
true,
)?;
let ticket = Ticket {
request: request.clone(),
parent_pid: std::process::id(),
parent_birth: birth(unsafe { GetCurrentProcess() })?,
boot,
ledger: file_id(ledger.as_raw_handle())?,
};
let bytes = serde_json::to_vec(&ticket)?;
ensure!(bytes.len() as u64 <= TICKET_LIMIT, "EVENT_LOG_TICKET_LIMIT");
let path = directory.join(ticket_name(&permit));
let mut writer = OpenOptions::new()
.create_new(true)
.write(true)
.share_mode(0)
.open(&path)?;
writer.write_all(&bytes)?;
writer.sync_all()?;
drop(writer);
let mut file = open_private(&path, false)?;
ensure!(
read(&mut file, TICKET_LIMIT)? == bytes,
"EVENT_LOG_TICKET_CHANGED"
);
Ok(Self {
path,
_file: file,
ticket_hash: hash(&bytes),
job_bytes: request.job_bytes.clone(),
})
}
pub fn run(self, job: &JobPayload, cancel: &AtomicBool) -> Result<Outcome> {
event_log::for_job(job)?;
ensure!(
serde_json::from_slice::<serde_json::Value>(&self.job_bytes)?
== serde_json::to_value(job)?,
"EVENT_LOG_JOB_CHANGED"
);
let mut file = open_private(&self.path, false)?;
ensure!(
hash(&read(&mut file, TICKET_LIMIT)?) == self.ticket_hash,
"EVENT_LOG_TICKET_CHANGED"
);
let output = crate::process::run(
&std::env::current_exe()?,
&[MODE.into(), self.path.as_os_str().into()],
self.path.parent().context("EVENT_LOG_JOB_DIRECTORY")?,
job.max_runtime_seconds,
job.max_output_bytes as usize,
cancel,
)?;
if output.interrupted {
return Ok(Outcome::unknown(if output.cancelled {
"EVENT_LOG_CANCELLED_RESULT_UNKNOWN"
} else {
"EVENT_LOG_TIMEOUT_RESULT_UNKNOWN"
}));
}
ensure!(
output.exit_code == Some(0) && !output.truncated && output.stderr.is_empty(),
"EVENT_LOG_WORKER_RESULT_UNVERIFIED"
);
outcome(job, output.stdout)
}
}
fn consumed(
db: &rusqlite::Connection,
binding: &Binding,
ticket: &Ticket,
permit: &ExecutionPermitPayload,
) -> Result<()> {
let length: u64 = db.query_row("SELECT length(e.start) FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1", [permit.grant_id.to_string()], |r| r.get(0))?;
ensure!(length <= TICKET_LIMIT, "EVENT_LOG_START_SIZE");
type Row = (String, u64, String, String, bool, Vec<u8>, bool);
let row: Row = db.query_row("SELECT c.agent,c.generation,c.job,c.attempt,c.result IS NULL,e.start,e.outcome IS NULL FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=?1",
[permit.grant_id.to_string()], |r| Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,r.get(5)?,r.get(6)?)))?;
ensure!(
row.0 == binding.agent_id.to_string()
&& row.1 == binding.enrollment_generation
&& row.2 == permit.job_id.to_string()
&& row.3 == permit.attempt_id.to_string()
&& row.4
&& row.6,
"EVENT_LOG_CONSUMPTION_BINDING"
);
let start: serde_json::Value = serde_json::from_slice(&row.5)?;
ensure!(
start["previous_boot_id"] == ticket.boot.to_string()
&& serde_json::to_vec(&serde_json::from_value::<Request>(
start["request"].clone()
)?)? == serde_json::to_vec(&ticket.request)?,
"EVENT_LOG_ORIGINAL_START_BINDING"
);
let identity: String = db.query_row(
"SELECT identity FROM windows_binding WHERE length(identity)<=512",
[],
|r| r.get(0),
)?;
ensure!(
identity
== format!(
"{}:{}:{}:{}:{}",
binding.tenant_id,
binding.asset_id,
binding.agent_id,
binding.enrollment_generation,
binding.assignment_version
),
"EVENT_LOG_LEDGER_BINDING"
);
Ok(())
}
fn validate_ticket_path(path: &Path, directory: &Path) -> Result<()> {
let name = path
.file_name()
.and_then(|s| s.to_str())
.context("EVENT_LOG_TICKET_NAME")?;
let hash_name = name
.strip_prefix("eventlog-")
.and_then(|s| s.strip_suffix(".json"))
.context("EVENT_LOG_TICKET_NAME")?;
ensure!(
path.parent() == Some(directory)
&& hash_name.len() == 64
&& hash_name
.bytes()
.all(|c| c.is_ascii_digit() || (b'a'..=b'f').contains(&c)),
"EVENT_LOG_TICKET_PATH_BINDING"
);
Ok(())
}
/// Internal mode admission. Failure emits only the main executable's fixed
/// initialization error; no request, query XML or private Win32 error is logged.
pub fn worker(path: &Path) -> Result<()> {
native::require_local_service()?;
service_token(unsafe { GetCurrentProcess() })?;
let image = std::env::current_exe()?;
let actual_parent = parent_pid()?;
ensure!(
agent_pid(&image)? == actual_parent,
"EVENT_LOG_REAL_PARENT_REQUIRED"
);
let parent = owned(unsafe {
OpenProcess(
PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE,
0,
actual_parent,
)
})?;
let parent_birth = birth(parent.as_raw_handle())?;
ensure!(
process_image(parent.as_raw_handle())? == image
&& unsafe { WaitForSingleObject(parent.as_raw_handle(), 0) } == WAIT_TIMEOUT,
"EVENT_LOG_PARENT_INSTANCE"
);
service_token(parent.as_raw_handle())?;
crate::job_binding::check_admin_readonly(Path::new(CONFIG))?;
let mut config_file = open_private(Path::new(CONFIG), false)?;
let config: WorkerConfig = serde_json::from_slice(&read(&mut config_file, 32768)?)?;
ensure!(
config.enable_jobs && config.state_directory.is_absolute(),
"EVENT_LOG_JOBS_NOT_ENABLED"
);
let directory = config.state_directory.join("jobs");
native::private_path(&directory, true)?;
validate_ticket_path(path, &directory)?;
// Only the exact jobs leaf is read; PKI/keys and arbitrary private files
// cannot be passed to this mode, even by another LocalService process.
let mut ticket_file = open_private(path, false)?;
let ticket: Ticket = serde_json::from_slice(&read(&mut ticket_file, TICKET_LIMIT)?)?;
ensure!(
ticket.parent_pid == actual_parent && ticket.parent_birth == parent_birth,
"EVENT_LOG_PARENT_INSTANCE"
);
let binding = crate::job_binding::readonly_binding(&config.job_binding_file)?;
let clock = crate::clock::NativeClock::new();
let now = clock.now()?;
let (job, permit) = binding.verify(&ticket.request, now - chrono::Duration::seconds(2))?;
binding.verify(&ticket.request, now + chrono::Duration::seconds(2))?;
let query = event_log::for_job(&job)?;
let expected = config
.state_directory
.join("jobs")
.join(ticket_name(&permit));
ensure!(path == expected, "EVENT_LOG_TICKET_PATH_BINDING");
let runtime = tokio::runtime::Runtime::new()?;
ensure!(
Uuid::parse_str(&runtime.block_on(native::boot_id())?)? == ticket.boot,
"EVENT_LOG_ORIGINAL_BOOT_REQUIRED"
);
let ledger_path = config.state_directory.join("consumption.sqlite");
let ledger_file = open_private(&ledger_path, true)?;
ensure!(
file_id(ledger_file.as_raw_handle())? == ticket.ledger,
"EVENT_LOG_LEDGER_FILE_CHANGED"
);
let db = rusqlite::Connection::open_with_flags(
&ledger_path,
rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
)?;
db.busy_timeout(Duration::from_millis(100))?;
let mut sqlite_handle: HANDLE = ptr::null_mut();
ensure!(
unsafe {
rusqlite::ffi::sqlite3_file_control(
db.handle(),
c"main".as_ptr(),
rusqlite::ffi::SQLITE_FCNTL_WIN32_GET_HANDLE,
(&mut sqlite_handle as *mut HANDLE).cast(),
)
} == rusqlite::ffi::SQLITE_OK
&& file_id(sqlite_handle)? == ticket.ledger,
"EVENT_LOG_CONNECTED_LEDGER_FILE"
);
db.execute_batch("PRAGMA query_only=ON; BEGIN;")?;
consumed(&db, &binding, &ticket, &permit)?;
// Per-grant durable CAS prevents worker re-entry after a lost child reply.
let marker = path.with_extension("started");
let mut once = OpenOptions::new()
.create_new(true)
.write(true)
.share_mode(0)
.open(&marker)?;
once.write_all(b"event-log-dispatch-v1\n")?;
once.sync_all()?;
native::private_path(&marker, false)?;
// File I/O, CIM and child scheduling cannot extend the signed start window.
let now = clock.now()?;
binding.verify(&ticket.request, now - chrono::Duration::seconds(2))?;
binding.verify(&ticket.request, now + chrono::Duration::seconds(2))?;
ensure!(
agent_pid(&image)? == actual_parent
&& birth(parent.as_raw_handle())? == ticket.parent_birth
&& unsafe { WaitForSingleObject(parent.as_raw_handle(), 0) } == WAIT_TIMEOUT,
"EVENT_LOG_PARENT_CHANGED"
);
consumed(&db, &binding, &ticket, &permit)?;
let report = event_log::query(&query, &AtomicBool::new(false))?;
let bytes = serde_json::to_vec(&report)?;
ensure!(
bytes.len() <= job.max_output_bytes as usize,
"EVENT_LOG_OUTPUT_LIMIT"
);
std::io::stdout().lock().write_all(&bytes)?;
Ok(())
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct WireReport {
channel: String,
provider: String,
start_utc: DateTime<Utc>,
end_utc: DateTime<Utc>,
quality: String,
completeness: String,
truncated: bool,
error_code: Option<String>,
win32_error: Option<u32>,
events: Vec<event_log::Event>,
bookmark_updated: bool,
deadline_enforcement: String,
}
fn outcome(job: &JobPayload, bytes: Vec<u8>) -> Result<Outcome> {
let q = event_log::for_job(job)?;
ensure!(
bytes.len() <= q.max_output_bytes as usize,
"EVENT_LOG_OUTPUT_LIMIT"
);
let report: WireReport = serde_json::from_slice(&bytes)?;
ensure!(
report.channel == q.channel
&& report.provider == q.provider
&& report.start_utc == q.start_utc
&& report.end_utc == q.end_utc
&& !report.bookmark_updated
&& report.events.len() <= q.max_events as usize
&& report.deadline_enforcement == "cooperative_between_win32_calls",
"EVENT_LOG_REPORT_BINDING"
);
let mut ids = std::collections::BTreeSet::new();
for event in &report.events {
ensure!(
event.channel == q.channel
&& event.provider == q.provider
&& event.record_id > 0
&& ids.insert(event.record_id)
&& event.created_utc >= q.start_utc
&& event.created_utc < q.end_utc
&& event.xml.len() <= 64 * 1024
&& !event.xml.contains('\0'),
"EVENT_LOG_EVENT_BINDING"
);
}
let complete =
report.completeness == "complete" && !report.truncated && report.error_code.is_none();
let partial = report.completeness == "partial"
&& report.truncated
&& matches!(
report.error_code.as_deref(),
Some("EVENT_LOG_EVENT_LIMIT" | "EVENT_LOG_BYTE_LIMIT" | "EVENT_LOG_EVENT_SIZE_LIMIT")
);
let success =
report.quality == "valid" && report.win32_error.is_none() && (complete || partial);
let error =
report
.error_code
.as_deref()
.unwrap_or(if success { "" } else { "EVENT_LOG_INCOMPLETE" });
Ok(Outcome {
state: if success { "succeeded" } else { "failed" }.into(),
stdout: bytes,
stderr: vec![],
exit_code: None,
output_truncated: report.truncated,
reboot_required: false,
error_code: if success { String::new() } else { error.into() },
evidence: serde_json::json!({"postconditions_passed":success,
"source_id":rmm_domain::jobs::WINDOWS_EVENT_LOG_FIXTURE_SOURCE,
"channel":q.channel,"provider":q.provider,"start_utc":q.start_utc,"end_utc":q.end_utc,
"max_events":q.max_events,"max_output_bytes":q.max_output_bytes,
"quality":report.quality,"completeness":report.completeness,"truncated":report.truncated,
"error_code":report.error_code,"win32_error":report.win32_error,
"bookmark_updated":false,"execution_sid":"S-1-5-19","process_tree_bounded":true,
"cursor_status":"not_advanced_no_ack_contract","observed_at":Utc::now()}),
})
}
#[cfg(test)]
mod tests {
use super::*;
fn job() -> JobPayload {
let id = Uuid::new_v4();
let now = DateTime::from_timestamp(1_700_000_000, 0).unwrap();
JobPayload {
schema_version: 1,
tenant_id: id,
asset_id: id,
agent_id: id,
enrollment_generation: 1,
assignment_version: 1,
job_id: id,
attempt_id: id,
action: rmm_domain::jobs::Action::QueryLogs {
unit: rmm_domain::jobs::WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
since: now,
until: now + chrono::Duration::minutes(5),
max_lines: 2,
},
execution_identity: "agent_service".into(),
not_before: now,
start_before: now + chrono::Duration::seconds(60),
max_runtime_seconds: 10,
max_output_bytes: 4096,
}
}
#[test]
fn ticket_pre_read_boundary_excludes_keys_siblings_and_noncanonical_leaves() {
let directory = Path::new(r"C:\ProgramData\RustDiscovery\state\jobs");
let leaf = format!("eventlog-{}.json", "a".repeat(64));
assert!(validate_ticket_path(&directory.join(&leaf), directory).is_ok());
for path in [
PathBuf::from(r"C:\ProgramData\RustDiscovery\state\device-key.pem"),
directory.join("..\\jobs").join(&leaf),
directory.join(format!("eventlog-{}.json", "A".repeat(64))),
directory.join(format!("eventlog-{}.json", "a".repeat(63))),
directory.join(format!("eventlog-{}.json:stream", "a".repeat(64))),
directory.join("other.json"),
] {
assert!(
validate_ticket_path(&path, directory).is_err(),
"{}",
path.display()
);
}
}
#[test]
fn event_log_outcome_never_equates_valid_quality_with_complete_or_authorized_success() {
let job = job();
let q = event_log::for_job(&job).unwrap();
let mut report = serde_json::json!({"channel":q.channel,"provider":q.provider,
"start_utc":q.start_utc,"end_utc":q.end_utc,"quality":"valid",
"completeness":"complete","truncated":false,"error_code":null,"win32_error":null,
"events":[],"bookmark_updated":false,"deadline_enforcement":"cooperative_between_win32_calls"});
assert_eq!(
outcome(&job, serde_json::to_vec(&report).unwrap())
.unwrap()
.state,
"succeeded"
);
for code in [
"EVENT_LOG_TIME_LIMIT",
"EVENT_LOG_CANCELLED",
"EVENT_LOG_API_ERROR",
] {
let mut partial = report.clone();
partial["truncated"] = true.into();
partial["completeness"] = "unknown".into();
partial["error_code"] = code.into();
assert_eq!(
outcome(&job, serde_json::to_vec(&partial).unwrap())
.unwrap()
.state,
"failed"
);
}
report["truncated"] = true.into();
report["completeness"] = "partial".into();
report["error_code"] = "EVENT_LOG_BYTE_LIMIT".into();
let bounded = outcome(&job, serde_json::to_vec(&report).unwrap()).unwrap();
assert_eq!(bounded.state, "succeeded");
assert!(bounded.output_truncated);
report["quality"] = "permission_denied".into();
report["win32_error"] = 5.into();
assert_eq!(
outcome(&job, serde_json::to_vec(&report).unwrap())
.unwrap()
.state,
"failed"
);
report["provider"] = "another-provider".into();
assert!(outcome(&job, serde_json::to_vec(&report).unwrap()).is_err());
}
}
+122
View File
@@ -0,0 +1,122 @@
//! Shared protected public signing binding; never learns trust from a worker ticket.
use crate::native;
use anyhow::{Context, Result, ensure};
use rmm_agent_core::auth::Binding;
use std::path::Path;
fn read_private(path: &Path, limit: u64) -> Result<Vec<u8>> {
use std::{fs::OpenOptions, io::Read, os::windows::fs::OpenOptionsExt};
use windows_sys::Win32::Storage::FileSystem::{FILE_FLAG_OPEN_REPARSE_POINT, FILE_SHARE_READ};
native::private_path(path, false)?;
let mut file = OpenOptions::new()
.read(true)
.share_mode(FILE_SHARE_READ)
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
.open(path)?;
ensure!(file.metadata()?.len() <= limit, "BINDING_SIZE");
let mut bytes = Vec::new();
(&mut file).take(limit + 1).read_to_end(&mut bytes)?;
ensure!(bytes.len() as u64 <= limit, "BINDING_SIZE");
Ok(bytes)
}
pub fn check_admin_readonly(path: &Path) -> Result<()> {
use std::ptr;
use windows_sys::Win32::{
Foundation::LocalFree,
Security::{
self, ACCESS_ALLOWED_ACE, ACL,
Authorization::{ConvertSidToStringSidW, GetNamedSecurityInfoW, SE_FILE_OBJECT},
DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION,
},
};
unsafe fn sid(sid: Security::PSID) -> Result<String> {
let mut raw = ptr::null_mut();
ensure!(
unsafe { ConvertSidToStringSidW(sid, &mut raw) } != 0,
"BINDING_SID"
);
let mut len = 0;
while unsafe { *raw.add(len) } != 0 {
len += 1;
ensure!(len < 256, "BINDING_SID_LIMIT");
}
let value = String::from_utf16(unsafe { std::slice::from_raw_parts(raw, len) })?;
unsafe {
LocalFree(raw.cast());
}
Ok(value)
}
ensure!(path.is_absolute(), "ABSOLUTE_JOB_BINDING_REQUIRED");
// The immediate configuration directory must also deny agent replacement.
for (item, directory) in [
(path, false),
(path.parent().context("BINDING_PARENT")?, true),
] {
native::private_path(item, directory)?;
let mut owner = ptr::null_mut();
let mut dacl: *mut ACL = ptr::null_mut();
let mut descriptor = ptr::null_mut();
let status = unsafe {
GetNamedSecurityInfoW(
native::wide(item).as_ptr(),
SE_FILE_OBJECT,
OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
&mut owner,
ptr::null_mut(),
&mut dacl,
ptr::null_mut(),
&mut descriptor,
)
};
ensure!(status == 0, "BINDING_SECURITY");
let check = (|| -> Result<()> {
ensure!(!owner.is_null() && !dacl.is_null(), "BINDING_NULL_SECURITY");
ensure!(
matches!(unsafe { sid(owner) }?.as_str(), "S-1-5-18" | "S-1-5-32-544"),
"BINDING_ADMIN_OWNER_REQUIRED"
);
for index in 0..unsafe { (*dacl).AceCount } {
let mut raw = ptr::null_mut();
ensure!(
unsafe { Security::GetAce(dacl, u32::from(index), &mut raw) } != 0,
"BINDING_ACE"
);
let ace = unsafe { &*raw.cast::<ACCESS_ALLOWED_ACE>() };
ensure!(
ace.Header.AceType == 0
&& usize::from(ace.Header.AceSize)
>= std::mem::size_of::<ACCESS_ALLOWED_ACE>(),
"BINDING_ACE_TYPE"
);
let who = unsafe { sid(ptr::addr_of!(ace.SidStart).cast_mut().cast()) }?;
if !matches!(who.as_str(), "S-1-5-18" | "S-1-5-32-544") {
// Generic write/all, owner/DACL/delete and all file/directory mutation bits.
ensure!(ace.Mask & 0x500d_0156 == 0, "BINDING_AGENT_WRITE_FORBIDDEN");
}
}
Ok(())
})();
unsafe {
LocalFree(descriptor.cast());
}
check?;
}
Ok(())
}
pub fn readonly_binding(path: &Path) -> Result<Binding> {
check_admin_readonly(path)?;
let binding: Binding = serde_json::from_slice(&read_private(path, 8192)?)?;
ensure!(
!binding.tenant_id.is_nil()
&& !binding.agent_id.is_nil()
&& !binding.asset_id.is_nil()
&& binding.enrollment_generation > 0
&& binding.assignment_version > 0
&& binding.public_key_hex.len() == 64
&& binding
.public_key_hex
.bytes()
.all(|b| b.is_ascii_hexdigit()),
"JOB_BINDING_PROFILE"
);
Ok(binding)
}
+5
View File
@@ -4,6 +4,9 @@
pub mod actions;
#[cfg(windows)]
pub mod clock;
pub mod event_log;
#[cfg(windows)]
pub mod event_log_job;
#[cfg(all(windows, feature = "system-helper"))]
pub mod helper_ipc;
#[cfg(all(windows, feature = "system-helper"))]
@@ -12,6 +15,8 @@ pub mod helper_runtime;
pub mod helper_system;
#[cfg(windows)]
pub mod inventory;
#[cfg(windows)]
pub mod job_binding;
pub mod journal;
#[cfg(windows)]
pub mod native;
+26 -114
View File
@@ -7,7 +7,7 @@ use rmm_agent_core::{
jobs, ledger,
reconcile::{self, SyncClock},
};
use rmm_agent_windows::{CAPABILITIES, journal::Journal, native};
use rmm_agent_windows::{CAPABILITIES, job_binding::readonly_binding, journal::Journal, native};
use rmm_domain::jobs::{Action, ExecutionPermitPayload};
use rmm_protocol::*;
use rusqlite::{Connection, OptionalExtension};
@@ -216,104 +216,6 @@ fn verified_window(
binding.verify(request, now + chrono::Duration::seconds(2))?;
Ok(result)
}
fn readonly_binding(path: &Path) -> Result<Binding> {
use std::ptr;
use windows_sys::Win32::{
Foundation::LocalFree,
Security::{
self, ACCESS_ALLOWED_ACE, ACL,
Authorization::{ConvertSidToStringSidW, GetNamedSecurityInfoW, SE_FILE_OBJECT},
DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION,
},
};
unsafe fn sid(sid: Security::PSID) -> Result<String> {
let mut raw = ptr::null_mut();
ensure!(
unsafe { ConvertSidToStringSidW(sid, &mut raw) } != 0,
"BINDING_SID"
);
let mut len = 0;
while unsafe { *raw.add(len) } != 0 {
len += 1;
ensure!(len < 256, "BINDING_SID_LIMIT");
}
let value = String::from_utf16(unsafe { std::slice::from_raw_parts(raw, len) })?;
unsafe {
LocalFree(raw.cast());
}
Ok(value)
}
ensure!(path.is_absolute(), "ABSOLUTE_JOB_BINDING_REQUIRED");
// The immediate configuration directory must also deny agent replacement.
for (item, directory) in [
(path, false),
(path.parent().context("BINDING_PARENT")?, true),
] {
native::private_path(item, directory)?;
let mut owner = ptr::null_mut();
let mut dacl: *mut ACL = ptr::null_mut();
let mut descriptor = ptr::null_mut();
let status = unsafe {
GetNamedSecurityInfoW(
native::wide(item).as_ptr(),
SE_FILE_OBJECT,
OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
&mut owner,
ptr::null_mut(),
&mut dacl,
ptr::null_mut(),
&mut descriptor,
)
};
ensure!(status == 0, "BINDING_SECURITY");
let check = (|| -> Result<()> {
ensure!(!owner.is_null() && !dacl.is_null(), "BINDING_NULL_SECURITY");
ensure!(
matches!(unsafe { sid(owner) }?.as_str(), "S-1-5-18" | "S-1-5-32-544"),
"BINDING_ADMIN_OWNER_REQUIRED"
);
for index in 0..unsafe { (*dacl).AceCount } {
let mut raw = ptr::null_mut();
ensure!(
unsafe { Security::GetAce(dacl, u32::from(index), &mut raw) } != 0,
"BINDING_ACE"
);
let ace = unsafe { &*raw.cast::<ACCESS_ALLOWED_ACE>() };
ensure!(
ace.Header.AceType == 0
&& usize::from(ace.Header.AceSize)
>= std::mem::size_of::<ACCESS_ALLOWED_ACE>(),
"BINDING_ACE_TYPE"
);
let who = unsafe { sid(ptr::addr_of!(ace.SidStart).cast_mut().cast()) }?;
if !matches!(who.as_str(), "S-1-5-18" | "S-1-5-32-544") {
// Generic write/all, owner/DACL/delete and all file/directory mutation bits.
ensure!(ace.Mask & 0x500d_0156 == 0, "BINDING_AGENT_WRITE_FORBIDDEN");
}
}
Ok(())
})();
unsafe {
LocalFree(descriptor.cast());
}
check?;
}
let binding: Binding = serde_json::from_slice(&protected_read(path, 8192)?)?;
ensure!(
!binding.tenant_id.is_nil()
&& !binding.agent_id.is_nil()
&& !binding.asset_id.is_nil()
&& binding.enrollment_generation > 0
&& binding.assignment_version > 0
&& binding.public_key_hex.len() == 64
&& binding
.public_key_hex
.bytes()
.all(|b| b.is_ascii_hexdigit()),
"JOB_BINDING_PROFILE"
);
Ok(binding)
}
fn import_legacy_inventory(journal: &mut Journal) -> Result<()> {
let original = {
let mut q = journal
@@ -684,6 +586,8 @@ impl Agent {
{
caps.extend(["rmm.sync.v1", "refresh_inventory"].map(str::to_string));
if rmm_agent_windows::actions::powershell().is_ok() {
// The process_remote_signed profile is implemented but remains
// unpublished until its separate native qualification passes.
caps.extend(["run_script", "script.powershell/1"].map(str::to_string));
}
}
@@ -1162,6 +1066,7 @@ impl Agent {
let directory = self.config.state_directory.join("jobs");
let work_offer = offer.clone();
let work_grant = grant.clone();
let original_boot = Uuid::parse_str(&self.boot)?;
let worker = tokio::task::spawn_blocking(move || {
let outcome = (|| -> Result<Outcome> {
if !fence.allows(generation, &clock)
@@ -1172,17 +1077,24 @@ impl Agent {
"START_WINDOW_OR_CLOCK_INVALID_BEFORE_EFFECT",
));
}
let script = if matches!(job.action, Action::RunScript { .. }) {
match rmm_agent_windows::actions::Script::prepare(
&job,
&directory,
work_grant.grant_id,
) {
Ok(script) => Some(script),
Err(_) => return Ok(jobs::no_start("failed", "SCRIPT_PREPARATION_FAILED")),
let prepared = match rmm_agent_windows::actions::PreparedAction::prepare(
&job,
&directory,
work_grant.grant_id,
&request,
original_boot,
) {
Ok(prepared) => prepared,
Err(_) => {
return Ok(jobs::no_start(
"failed",
if matches!(job.action, Action::RunScript { .. }) {
"SCRIPT_PREPARATION_FAILED"
} else {
"ACTION_PREPARATION_FAILED"
},
));
}
} else {
None
};
// File creation, pool scheduling and fsync never extend a start window.
if worker_cancel.load(Ordering::SeqCst) {
@@ -1196,11 +1108,7 @@ impl Agent {
"START_WINDOW_OR_CLOCK_INVALID_BEFORE_EFFECT",
));
}
if let Some(script) = script {
script.run(&job, &worker_cancel)
} else {
rmm_agent_windows::actions::inventory(&job)
}
prepared.run(&job, &worker_cancel)
})()
.unwrap_or_else(|_| Outcome::unknown("WINDOWS_EXECUTOR_EFFECT_UNKNOWN"));
let _ = completed.blocking_send((work_offer, work_grant, outcome));
@@ -1547,6 +1455,10 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
}
pub fn main() -> Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
if args.first().map(String::as_str) == Some(rmm_agent_windows::event_log_job::MODE) {
ensure!(args.len() == 2, "EVENT_LOG_WORKER_ARGUMENTS");
return rmm_agent_windows::event_log_job::worker(Path::new(&args[1]));
}
if args == ["--help"] {
println!(
"Development Windows service. --service --config ABSOLUTE_PATH. Jobs disabled by default; require qualified clock, provisioned signing binding, signed Sync and WebUI-authorized grant. No approval bypass."
+1
View File
@@ -353,6 +353,7 @@ mod tests {
script_utf8: "true".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
},
execution_identity: "root".into(),
not_before: now,
+1
View File
@@ -50,6 +50,7 @@ fn new_process_persists_interruption_before_helper_io_without_unlock_or_repeat()
script_utf8: "printf 'fixture only; never executed\\n'".into(),
arguments: vec![],
expected_stdout: Some("fixture only; never executed\n".into()),
windows_execution_profile: None,
},
execution_identity: "root".into(),
not_before: now,
+1
View File
@@ -594,6 +594,7 @@ fn script() -> Action {
script_utf8: "printf hello".into(),
arguments: vec![],
expected_stdout: Some("hello".into()),
windows_execution_profile: None,
}
}
fn success() -> ReconciledOutcome {
+336 -6
View File
@@ -1,5 +1,6 @@
//! Version 1 codec: UTF-8 compact serde JSON of these structs, declaration field
//! order, explicit null options, ordered vectors, UTC RFC3339 timestamps. Hash the
//! order, explicit null legacy options (new opt-in fields omit None), ordered vectors,
//! UTC RFC3339 timestamps. Hash the
//! stored bytes, never a reconstructed API view. No floating point/map payloads.
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
@@ -13,6 +14,51 @@ pub fn encode<T: Serialize>(value: &T) -> Result<Vec<u8>, serde_json::Error> {
serde_json::to_vec(value)
}
/// One explicitly qualified Event Log source, not an arbitrary channel/XPath.
pub const WINDOWS_EVENT_LOG_FIXTURE_SOURCE: &str =
"windows.eventlog.application.rustdiscovery-mvp-test";
pub const WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY: &str = "logs.windows.eventlog.fixture/1";
pub const WINDOWS_EVENT_LOG_FIXTURE_CHANNEL: &str = "Application";
pub const WINDOWS_EVENT_LOG_FIXTURE_PROVIDER: &str = "RustDiscovery-MVP-Test";
/// Fixed per-job Windows PowerShell 5.1 option, never a machine/GPO policy.
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
pub enum WindowsExecutionProfile {
#[serde(rename = "powershell_51_remote_signed")]
PowerShell51RemoteSigned,
}
/// A missing field uses serde's default None. A present field must be the exact
/// string: null and serde's externally-tagged enum object form are not profiles.
pub fn deserialize_windows_execution_profile<'de, D>(
deserializer: D,
) -> Result<Option<WindowsExecutionProfile>, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
match value.as_str() {
"powershell_51_remote_signed" => {
Ok(Some(WindowsExecutionProfile::PowerShell51RemoteSigned))
}
_ => Err(serde::de::Error::unknown_variant(
&value,
&["powershell_51_remote_signed"],
)),
}
}
/// Missing preserves Linux codecs; explicit null/nonobject is never a manifest.
pub fn deserialize_windows_msi_manifest<'de, D>(
deserializer: D,
) -> Result<Option<Box<crate::windows_execution::ResolvedWindowsMsi>>, D::Error>
where
D: serde::Deserializer<'de>,
{
crate::windows_execution::ResolvedWindowsMsi::deserialize(deserializer)
.map(|m| Some(Box::new(m)))
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
pub enum Action {
@@ -21,6 +67,13 @@ pub enum Action {
script_utf8: String,
arguments: Vec<String>,
expected_stdout: Option<String>,
#[serde(
default,
deserialize_with = "deserialize_windows_execution_profile",
skip_serializing_if = "Option::is_none"
)]
#[schemars(with = "WindowsExecutionProfile")]
windows_execution_profile: Option<WindowsExecutionProfile>,
},
RefreshInventory {
scope: String,
@@ -46,6 +99,13 @@ pub enum Action {
recipe_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
apt_manifest: Option<crate::apt_transaction::AptExecutionManifest>,
#[serde(
default,
deserialize_with = "deserialize_windows_msi_manifest",
skip_serializing_if = "Option::is_none"
)]
#[schemars(with = "crate::windows_execution::ResolvedWindowsMsi")]
windows_msi_manifest: Option<Box<crate::windows_execution::ResolvedWindowsMsi>>,
},
ApplyUpdates {
provider: String,
@@ -99,8 +159,10 @@ impl Action {
script_utf8,
arguments,
expected_stdout,
windows_execution_profile,
} => {
matches!(interpreter.as_str(), "posix_sh" | "bash" | "powershell")
&& (windows_execution_profile.is_none() || interpreter == "powershell")
&& (interpreter != "powershell"
|| script_utf8.is_ascii()
|| script_utf8.starts_with('\u{feff}'))
@@ -124,7 +186,8 @@ impl Action {
} => {
unit(u)
&& since < until
&& (*until - *since).num_hours() <= 24
&& *until - *since <= chrono::Duration::hours(24)
&& (u != WINDOWS_EVENT_LOG_FIXTURE_SOURCE || since.timestamp() >= 0)
&& *max_lines > 0
&& *max_lines <= 1000
}
@@ -140,6 +203,28 @@ impl Action {
installation_context,
recipe_id,
apt_manifest,
windows_msi_manifest: Some(m),
} => {
m.validate()
&& provider == "msi"
&& package == crate::windows_execution::MSI_PACKAGE_ID
&& version == &m.recipe.postcondition.product_version
&& architecture == "x64"
&& installation_context == "machine"
&& recipe_version == &m.recipe.recipe_version
&& recipe_id.as_ref() == Some(&m.recipe.recipe_id)
&& apt_manifest.is_none()
}
Self::EnsurePackage {
provider,
package,
version,
architecture,
recipe_version,
installation_context,
recipe_id,
apt_manifest,
windows_msi_manifest: None,
} => {
provider == "apt"
&& unit(package)
@@ -198,6 +283,35 @@ impl Action {
}
}
}
pub fn windows_msi(&self) -> Option<&crate::windows_execution::ResolvedWindowsMsi> {
match self {
Self::EnsurePackage {
windows_msi_manifest: Some(m),
..
} => Some(m.as_ref()),
_ => None,
}
}
pub fn valid_helper_denial_shape(&self, identity: &str) -> bool {
(matches!(self,Self::SetServiceState{state,..} if matches!(state.as_str(),"running"|"stopped"))
&& self.validate())
|| (identity == "system" && self.windows_msi().is_some() && self.validate())
}
pub fn is_windows_event_log_fixture(&self) -> bool {
matches!(self, Self::QueryLogs { unit, .. } if unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE)
}
/// The outer process budget includes authenticated worker startup/cleanup;
/// its inner Event Log calls retain their own cooperative <=5s deadline.
pub fn valid_job_limits(&self, runtime_seconds: u32, output_bytes: u32) -> bool {
(1..=3600).contains(&runtime_seconds)
&& (self.windows_msi().is_none()
|| ((10..=120).contains(&runtime_seconds)
&& (1024..=65536).contains(&output_bytes)))
&& (1..=262144).contains(&output_bytes)
&& (!self.is_windows_event_log_fixture()
|| ((10..=120).contains(&runtime_seconds)
&& (1024..=65536).contains(&output_bytes)))
}
/// Interpreter identity is part of the immutable action, never inferred at execution.
pub fn script_platform(&self) -> Option<&'static str> {
match self {
@@ -211,7 +325,7 @@ impl Action {
}
/// Shared plan/revalidation/start gate. Passive Windows never implies job support.
pub fn available_for(&self, identity: &str, capabilities: &[String]) -> bool {
if identity == "system" && !matches!(self, Self::SetServiceState { .. }) {
if identity == "system" && !self.valid_helper_denial_shape(identity) {
return false;
}
let has = |cap: &str| capabilities.iter().any(|c| c == cap);
@@ -219,15 +333,25 @@ impl Action {
return false;
}
match self {
Self::RunScript { interpreter, .. } if interpreter == "powershell" => {
Self::RunScript {
interpreter,
windows_execution_profile,
..
} if interpreter == "powershell" => {
identity == "agent_service"
&& has("windows.base/1")
&& !has("linux.base/1")
&& has("rmm.sync.v1")
&& has("script.powershell/1")
&& (windows_execution_profile.is_none()
|| has("script.powershell.process_remote_signed/1"))
}
Self::RunScript { .. } => {
self.script_platform() == Some("linux")
Self::RunScript {
windows_execution_profile,
..
} => {
windows_execution_profile.is_none()
&& self.script_platform() == Some("linux")
&& has("linux.base/1")
&& !has("windows.base/1")
}
@@ -237,6 +361,27 @@ impl Action {
&& !(has("linux.base/1") && has("windows.base/1"))
&& (scope != "windows.base" || has("rmm.sync.v1"))
}
Self::EnsurePackage { .. } if self.windows_msi().is_some() || has("windows.base/1") => {
self.windows_msi().is_some()
&& self.validate()
&& identity == "system"
&& has("windows.base/1")
&& !has("linux.base/1")
&& has("rmm.sync.v1")
&& has("helper.system.v1")
&& has("system:ensure_package")
&& has(crate::windows_execution::MSI_CAPABILITY)
}
Self::QueryLogs { unit, .. }
if unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE || has("windows.base/1") =>
{
identity == "agent_service"
&& unit == WINDOWS_EVENT_LOG_FIXTURE_SOURCE
&& has("windows.base/1")
&& !has("linux.base/1")
&& has("rmm.sync.v1")
&& has(WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY)
}
Self::SetServiceState { state, .. }
if identity == "system" || has("windows.base/1") =>
{
@@ -272,6 +417,7 @@ impl Action {
installation_context,
recipe_id: None,
apt_manifest: None,
windows_msi_manifest: None,
} => {
provider == "apt"
&& !package.is_empty()
@@ -496,6 +642,7 @@ mod tests {
script_utf8: "Write-Output 'hi'\r\n".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
};
let mut all = caps;
all.extend(["run_script".into(), "script.powershell/1".into()]);
@@ -505,6 +652,7 @@ mod tests {
script_utf8: "printf hi\n".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
};
let reboot = Action::Reboot {
reason: "fixed test".into(),
@@ -526,6 +674,7 @@ mod tests {
script_utf8: "Write-Output 'Hello'\r\n".into(),
arguments: vec![],
expected_stdout: Some("Hello\r\n".into()),
windows_execution_profile: None,
};
let caps: Vec<String> = [
"windows.base/1",
@@ -601,6 +750,7 @@ mod tests {
script_utf8: "echo hi\n".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
};
assert_eq!(
String::from_utf8(encode(&a).unwrap()).unwrap(),
@@ -613,6 +763,186 @@ mod tests {
);
}
#[test]
fn windows_remote_signed_profile_is_optional_exact_and_capability_bound() {
let schema = schemars::schema_for!(Action).to_value();
let script_schema = schema["oneOf"]
.as_array()
.unwrap()
.iter()
.find(|variant| {
variant["properties"]
.get("windows_execution_profile")
.is_some()
})
.unwrap();
assert_eq!(
script_schema["properties"]["windows_execution_profile"],
serde_json::json!({"$ref":"#/$defs/WindowsExecutionProfile"})
);
assert!(
!script_schema["required"]
.as_array()
.unwrap()
.contains(&serde_json::json!("windows_execution_profile"))
);
assert_eq!(schema["$defs"]["WindowsExecutionProfile"]["type"], "string");
let legacy = br#"{"action":"run_script","interpreter":"powershell","script_utf8":"Write-Output 'hi'\r\n","arguments":[],"expected_stdout":null}"#;
let mut action: Action = serde_json::from_slice(legacy).unwrap();
assert_eq!(encode(&action).unwrap(), legacy);
let inherited_hash = hash(legacy);
if let Action::RunScript {
windows_execution_profile,
..
} = &mut action
{
*windows_execution_profile = Some(WindowsExecutionProfile::PowerShell51RemoteSigned);
}
let encoded = encode(&action).unwrap();
assert_eq!(
String::from_utf8(encoded.clone()).unwrap(),
String::from_utf8(legacy[..legacy.len() - 1].to_vec()).unwrap()
+ r#","windows_execution_profile":"powershell_51_remote_signed"}"#
);
assert_ne!(hash(&encoded), inherited_hash);
assert_eq!(serde_json::from_slice::<Action>(&encoded).unwrap(), action);
let caps: Vec<String> = [
"windows.base/1",
"rmm.sync.v1",
"run_script",
"script.powershell/1",
"script.powershell.process_remote_signed/1",
]
.into_iter()
.map(str::to_string)
.collect();
assert!(action.validate());
assert!(action.available_for("agent_service", &caps));
for missing in 0..caps.len() {
let mut short = caps.clone();
short.remove(missing);
assert!(!action.available_for("agent_service", &short));
}
for identity in ["root", "system", "SYSTEM"] {
assert!(!action.available_for(identity, &caps));
}
let mut mixed = caps.clone();
mixed.push("linux.base/1".into());
assert!(!action.available_for("agent_service", &mixed));
for interpreter in ["posix_sh", "bash", "pwsh"] {
let mut invalid = action.clone();
if let Action::RunScript { interpreter: i, .. } = &mut invalid {
*i = interpreter.into();
}
assert!(!invalid.validate());
assert!(!invalid.available_for("agent_service", &caps));
assert!(!invalid.available_for("root", &["linux.base/1".into(), "run_script".into()]));
}
for profile in [
serde_json::Value::Null,
serde_json::json!(false),
serde_json::json!(1),
serde_json::json!([]),
serde_json::json!({}),
serde_json::json!({"powershell_51_remote_signed": null}),
serde_json::json!("bypass"),
serde_json::json!("RemoteSigned"),
serde_json::json!("powershell_7_remote_signed"),
] {
let mut bad = serde_json::to_value(&action).unwrap();
bad["windows_execution_profile"] = profile.clone();
assert!(serde_json::from_value::<Action>(bad).is_err(), "{profile}");
// An opt-in profile is also never metadata on another action.
assert!(
serde_json::from_value::<Action>(serde_json::json!({
"action":"refresh_inventory", "scope":"windows.base",
"windows_execution_profile":profile
}))
.is_err()
);
}
}
#[test]
fn windows_event_log_fixture_scope_limits_and_exact_24h_preserve_linux_bytes() {
let since = DateTime::parse_from_rfc3339("2026-11-14T00:00:00Z")
.unwrap()
.with_timezone(&Utc);
let mut action = Action::QueryLogs {
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
since,
until: since + chrono::Duration::hours(24),
max_lines: 1000,
};
let caps: Vec<String> = [
"windows.base/1",
"rmm.sync.v1",
"query_logs",
WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY,
]
.into_iter()
.map(str::to_string)
.collect();
assert!(action.validate());
assert!(action.available_for("agent_service", &caps));
assert!(action.valid_job_limits(10, 1024));
assert!(action.valid_job_limits(120, 65536));
for (runtime, bytes) in [(9, 1024), (121, 1024), (10, 1023), (10, 65537)] {
assert!(!action.valid_job_limits(runtime, bytes));
}
for i in 0..caps.len() {
let mut short = caps.clone();
short.remove(i);
assert!(!action.available_for("agent_service", &short));
}
for identity in ["root", "system", "SYSTEM"] {
assert!(!action.available_for(identity, &caps));
}
let mut mixed = caps.clone();
mixed.push("linux.base/1".into());
assert!(!action.available_for("agent_service", &mixed));
assert!(!action.available_for("root", &["linux.base/1".into(), "query_logs".into()]));
for unit in [
"Application",
"Security",
"windows.eventlog.application.other",
] {
let mut wrong = action.clone();
if let Action::QueryLogs { unit: u, .. } = &mut wrong {
*u = unit.into();
}
assert!(!wrong.available_for("agent_service", &caps));
}
if let Action::QueryLogs { until, .. } = &mut action {
*until += chrono::Duration::nanoseconds(1);
}
assert!(!action.validate());
let linux = Action::QueryLogs {
unit: "rmm-test.service".into(),
since,
until: since + chrono::Duration::hours(24),
max_lines: 1000,
};
assert_eq!(
String::from_utf8(encode(&linux).unwrap()).unwrap(),
r#"{"action":"query_logs","unit":"rmm-test.service","since":"2026-11-14T00:00:00Z","until":"2026-11-15T00:00:00Z","max_lines":1000}"#
);
assert!(linux.validate());
for identity in ["root", "agent_service"] {
assert!(linux.available_for(identity, &["linux.base/1".into(), "query_logs".into()]));
}
let mut too_long = linux;
if let Action::QueryLogs { until, .. } = &mut too_long {
*until += chrono::Duration::minutes(59);
}
assert!(!too_long.validate());
let pre_epoch = Action::QueryLogs {
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
since: DateTime::from_timestamp(-1, 0).unwrap(),
until: DateTime::from_timestamp(0, 0).unwrap(),
max_lines: 1,
};
assert!(!pre_epoch.validate());
}
#[test]
fn no_terminal_replay_or_unknown_restart() {
assert!(!JobState::Succeeded.allows(JobState::Running));
assert!(!JobState::Unknown.allows(JobState::Running));
+1
View File
@@ -4,6 +4,7 @@ pub mod checkpoint_repair;
pub mod inventory_document;
pub mod jobs;
pub mod reconciliation;
pub mod windows_execution;
pub const TENANT_A: &str = "11111111-1111-4111-8111-111111111111";
pub const TENANT_B: &str = "22222222-2222-4222-8222-222222222222";
+144 -8
View File
@@ -1,10 +1,12 @@
//! Unexported Windows MSI fixture contract. No legacy Linux codec is changed.
//! Windows MSI fixture contract. No legacy Linux codec is changed.
//! Fixed1.0 first installation/noop and separate1.0→1.1 major-upgrade/noop
//! recipes only. No implicit REINSTALL, repair, downgrade or fresh1.1 mode.
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use uuid::Uuid;
pub const MSI_PACKAGE_ID: &str = "rmm-windows-msi-fixture";
pub const MSI_CAPABILITY: &str = "package.msi.fixture/1";
pub const MSI_RECIPE_ID: &str = "rmm-windows-msi-fixture-install-1.0";
pub const MSI_PRODUCT_CODE: &str = "{3F070B4B-9C08-4D65-BD41-13D81B884AEC}";
pub const MSI_UPGRADE_CODE: &str = "{C9BF1FB8-E31D-4BD7-BA0D-AB46539BBBAA}";
@@ -21,29 +23,62 @@ pub const MSI_PAYLOAD_11_SHA256: &str =
pub const MSI_OLD_PRODUCTS: &str = "RMM_OLD_PRODUCTS";
pub const MSI_ALL_PRODUCTS: &str = "RMM_ALL_PRODUCTS";
pub const MSI_UPGRADE_CONDITION: &str = "Installed OR (RMM_OLD_PRODUCTS = \"{3F070B4B-9C08-4D65-BD41-13D81B884AEC}\" AND RMM_ALL_PRODUCTS = \"{3F070B4B-9C08-4D65-BD41-13D81B884AEC}\")";
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, schemars::JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum Architecture {
X64,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, schemars::JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum InstallContext {
Machine,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, schemars::JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum MsiCommandProfile {
FixtureQuietNoRebootV1,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
impl<'de> Deserialize<'de> for Architecture {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = String::deserialize(deserializer)?;
if value == "x64" {
Ok(Self::X64)
} else {
Err(serde::de::Error::unknown_variant(&value, &["x64"]))
}
}
}
impl<'de> Deserialize<'de> for InstallContext {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = String::deserialize(deserializer)?;
if value == "machine" {
Ok(Self::Machine)
} else {
Err(serde::de::Error::unknown_variant(&value, &["machine"]))
}
}
}
impl<'de> Deserialize<'de> for MsiCommandProfile {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = String::deserialize(deserializer)?;
if value == "fixture_quiet_no_reboot_v1" {
Ok(Self::FixtureQuietNoRebootV1)
} else {
Err(serde::de::Error::unknown_variant(
&value,
&["fixture_quiet_no_reboot_v1"],
))
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct MsiArtifact {
pub artifact_id: Uuid,
pub sha256: String,
pub bytes: u64,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct MsiPostcondition {
pub product_code: String,
@@ -52,7 +87,7 @@ pub struct MsiPostcondition {
pub payload_sha256: String,
pub payload_bytes: u64,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct WindowsMsiRecipe {
pub schema_version: u32,
@@ -72,7 +107,7 @@ pub struct WindowsMsiRecipe {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub predecessor: Option<MsiPostcondition>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct ResolvedWindowsMsi {
pub recipe: WindowsMsiRecipe,
@@ -174,6 +209,107 @@ mod tests {
}
}
#[test]
fn ensure_msi_action_is_strict_opt_in_and_system_windows_only_without_linux_byte_changes() {
use crate::jobs::{Action, encode};
let old=br#"{"action":"ensure_package","provider":"apt","package":"rmm-test","version":"1.0","architecture":"amd64","recipe_version":"1","installation_context":"system"}"#;
let legacy: Action = serde_json::from_slice(old).unwrap();
assert!(legacy.validate_plan_shape());
assert!(legacy.windows_msi().is_none());
assert_eq!(encode(&legacy).unwrap(), old);
let recipe = recipe();
let m = ResolvedWindowsMsi {
recipe_sha256: recipe.sha256().unwrap(),
recipe,
};
let action = Action::EnsurePackage {
provider: "msi".into(),
package: MSI_PACKAGE_ID.into(),
version: MSI_VERSION.into(),
architecture: "x64".into(),
recipe_version: "1".into(),
installation_context: "machine".into(),
recipe_id: Some(MSI_RECIPE_ID.into()),
apt_manifest: None,
windows_msi_manifest: Some(Box::new(m)),
};
assert!(action.validate());
assert!(action.valid_helper_denial_shape("system"));
assert!(!action.valid_helper_denial_shape("root"));
let caps: Vec<String> = [
"ensure_package",
"windows.base/1",
"rmm.sync.v1",
"helper.system.v1",
"system:ensure_package",
MSI_CAPABILITY,
]
.into_iter()
.map(str::to_owned)
.collect();
assert!(action.available_for("system", &caps));
for identity in ["root", "agent_service"] {
assert!(!action.available_for(identity, &caps));
}
for i in 0..caps.len() {
let mut short = caps.clone();
short.remove(i);
assert!(!action.available_for("system", &short));
}
let mut mixed = caps;
mixed.push("linux.base/1".into());
assert!(!action.available_for("system", &mixed));
for (key, value) in [
("provider", serde_json::json!("apt")),
("architecture", serde_json::json!("amd64")),
("installation_context", serde_json::json!("system")),
("version", serde_json::json!("1.1.0")),
] {
let mut bad = serde_json::to_value(&action).unwrap();
bad[key] = value;
assert!(!serde_json::from_value::<Action>(bad).unwrap().validate());
}
for value in [
serde_json::Value::Null,
serde_json::json!(false),
serde_json::json!(1),
serde_json::json!([]),
serde_json::json!({}),
] {
let mut bad = serde_json::to_value(&action).unwrap();
bad["windows_msi_manifest"] = value;
assert!(serde_json::from_value::<Action>(bad).is_err());
}
for (key, value) in [
("architecture", "x64"),
("context", "machine"),
("command_profile", "fixture_quiet_no_reboot_v1"),
] {
let mut bad = serde_json::to_value(&action).unwrap();
bad["windows_msi_manifest"]["recipe"][key] = serde_json::json!({value:null});
assert!(serde_json::from_value::<Action>(bad).is_err());
}
for (runtime, bytes) in [(9, 4096), (121, 4096), (10, 1023), (10, 65537)] {
assert!(!action.valid_job_limits(runtime, bytes));
}
let schema = schemars::schema_for!(Action).to_value();
let pkg = schema["oneOf"]
.as_array()
.unwrap()
.iter()
.find(|v| v["properties"].get("windows_msi_manifest").is_some())
.unwrap();
assert_eq!(
pkg["properties"]["windows_msi_manifest"],
serde_json::json!({"$ref":"#/$defs/ResolvedWindowsMsi"})
);
assert!(
!pkg["required"]
.as_array()
.unwrap()
.contains(&serde_json::json!("windows_msi_manifest"))
);
}
#[test]
fn major_upgrade_requires_explicit_exact_predecessor_new_package_and_same_family() {
let old = recipe();
let old_bytes = serde_json::to_vec(&old).unwrap();
@@ -481,6 +481,7 @@ fn signed_request() -> (
script_utf8: "true".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
},
execution_identity: "root".into(),
not_before: now - chrono::Duration::seconds(1),
+1
View File
@@ -130,6 +130,7 @@ pub fn script(job: &JobPayload) -> Result<Outcome> {
script_utf8,
arguments,
expected_stdout,
windows_execution_profile: None,
} = &job.action
else {
anyhow::bail!("NOT_SCRIPT")
+1
View File
@@ -750,6 +750,7 @@ mod tests {
script_utf8: "true".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
},
execution_identity: "agent_service".into(),
not_before: now,
+1
View File
@@ -33,6 +33,7 @@ fn fixture() -> (
script_utf8: "printf 'Hello World\\n'".into(),
arguments: vec![],
expected_stdout: Some("Hello World\n".into()),
windows_execution_profile: None,
},
execution_identity: "agent_service".into(),
not_before: now - chrono::Duration::seconds(60),
@@ -432,6 +432,7 @@ fn script() -> Action {
script_utf8: "printf hello".into(),
arguments: vec![],
expected_stdout: Some("hello".into()),
windows_execution_profile: None,
}
}
fn success() -> ReconciledOutcome {
+8 -1
View File
@@ -36,13 +36,20 @@ pub async fn download(
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"));
}
let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?;
let row=sqlx::query("SELECT j.payload,p.payload AS plan_payload,p.plan_hash,i.asset_id,i.enrollment_generation,i.assignment_version FROM jobs j JOIN operations o ON o.tenant_id=j.tenant_id AND o.operation_id=j.operation_id JOIN authorizations z ON z.tenant_id=o.tenant_id AND z.authorization_id=o.authorization_id JOIN approval_requests r ON r.tenant_id=j.tenant_id AND r.operation_id=j.operation_id JOIN operation_plans p ON p.tenant_id=r.tenant_id AND p.plan_id=r.plan_id JOIN agent_installations i ON i.tenant_id=j.tenant_id AND i.agent_id=j.agent_id WHERE j.agent_id=$1 AND j.job_id=$2 AND j.attempt_id=$3 AND j.state IN ('queued','accepted','running','verifying','awaiting_reboot') AND r.approval_state='approved' AND z.revoked_at IS NULL AND p.expires_at>now() AND i.revoked_at IS NULL").bind(a).bind(q.job_id).bind(q.attempt_id).fetch_optional(&mut *tx).await?.ok_or(Error(StatusCode::NOT_FOUND,"NOT_FOUND"))?;
let row=sqlx::query("SELECT j.payload,p.payload AS plan_payload,p.plan_hash,z.principal AS approver,i.asset_id,i.enrollment_generation,i.assignment_version FROM jobs j JOIN operations o ON o.tenant_id=j.tenant_id AND o.operation_id=j.operation_id JOIN authorizations z ON z.tenant_id=o.tenant_id AND z.authorization_id=o.authorization_id JOIN approval_requests r ON r.tenant_id=j.tenant_id AND r.operation_id=j.operation_id JOIN operation_plans p ON p.tenant_id=r.tenant_id AND p.plan_id=r.plan_id JOIN agent_installations i ON i.tenant_id=j.tenant_id AND i.agent_id=j.agent_id WHERE j.agent_id=$1 AND j.job_id=$2 AND j.attempt_id=$3 AND j.state IN ('queued','accepted','running','verifying','awaiting_reboot') AND r.approval_state='approved' AND z.revoked_at IS NULL AND p.expires_at>now() AND i.revoked_at IS NULL").bind(a).bind(q.job_id).bind(q.attempt_id).fetch_optional(&mut *tx).await?.ok_or(Error(StatusCode::NOT_FOUND,"NOT_FOUND"))?;
let job: JobPayload = serde_json::from_slice(&row.get::<Vec<u8>, _>("payload"))?;
let plan_bytes: Vec<u8> = row.get("plan_payload");
if rmm_domain::jobs::hash(&plan_bytes) != row.get::<String, _>("plan_hash") {
return Err(Error(StatusCode::CONFLICT, "PLAN_HASH_MISMATCH"));
}
let plan: PlanPayload = serde_json::from_slice(&plan_bytes)?;
if job.action.windows_msi().is_some() {
crate::windows_msi_catalog::validate_job_binding(&plan, &job)?;
crate::catalog::check(&mut tx, &job.action).await?;
crate::root_policy::authorize(&mut tx, &plan.principal, &job).await?;
crate::root_policy::authorize(&mut tx, &row.get::<String, _>("approver"), &job).await?;
}
if job.asset_id != row.get::<Uuid, _>("asset_id")
|| job.enrollment_generation != row.get::<i64, _>("enrollment_generation") as u64
|| job.assignment_version != row.get::<i64, _>("assignment_version") as u64
+15 -1
View File
@@ -24,6 +24,10 @@ pub struct AptRecipe {
}
pub fn routes(r: Router<crate::State>) -> Router<crate::State> {
r.route(
"/api/v1/tenants/{tenant}/windows-msi-recipes",
get(crate::windows_msi_catalog::list).post(crate::windows_msi_catalog::import),
)
.route(
"/api/v1/tenants/{tenant}/package-recipes",
get(list).post(import),
)
@@ -43,6 +47,15 @@ pub async fn references(
tx: &mut Transaction<'_, Postgres>,
action: &rmm_domain::jobs::Action,
) -> Result<Vec<rmm_domain::jobs::RecipeReference>, Error> {
if let Some(manifest) = action.windows_msi() {
if !action.validate() {
return Err(Error(
StatusCode::BAD_REQUEST,
"INVALID_WINDOWS_MSI_MANIFEST",
));
}
return crate::windows_msi_catalog::references(tx, manifest).await;
}
let manifest = match action {
rmm_domain::jobs::Action::EnsurePackage {
apt_manifest: Some(m),
@@ -138,7 +151,7 @@ pub async fn references(
references.dedup();
Ok(references)
}
async fn context<'a>(
pub(crate) async fn context<'a>(
s: &'a crate::State,
h: &HeaderMap,
t: Uuid,
@@ -182,6 +195,7 @@ pub async fn import(
installation_context: recipe.installation_context.clone(),
recipe_id: None,
apt_manifest: None,
windows_msi_manifest: None,
};
if recipe.schema_version != 1
|| recipe.reboot_policy != "never"
+1
View File
@@ -518,6 +518,7 @@ mod tests {
script_utf8: "printf hello\\n".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
},
execution_identity: "agent_service".into(),
not_before: c.issued_at,
+248
View File
@@ -191,6 +191,8 @@ pub async fn event(
ensure!(r.stdout == expected.as_bytes(), "expected output mismatch");
}
}
script_profile_evidence(&payload.action, &evidence)?;
windows_event_log_success_evidence(&payload, r, &evidence)?;
if matches!(payload.action, Action::Reboot { .. }) {
crate::synchronization::verify_reboot_success(
tx, tenant, agent, e, &payload, r, &evidence,
@@ -224,6 +226,226 @@ pub async fn event(
.await?;
Ok(())
}
fn windows_event_log_success_evidence(
job: &JobPayload,
result: &JobResult,
evidence: &Value,
) -> Result<()> {
if !job.action.is_windows_event_log_fixture() {
return Ok(());
}
let Action::QueryLogs {
unit,
since,
until,
max_lines,
} = &job.action
else {
anyhow::bail!("fixed event log action required")
};
let observed_since: chrono::DateTime<Utc> = serde_json::from_value(
evidence
.get("start_utc")
.cloned()
.context("event log start missing")?,
)?;
let observed_until: chrono::DateTime<Utc> = serde_json::from_value(
evidence
.get("end_utc")
.cloned()
.context("event log end missing")?,
)?;
let complete = evidence.get("completeness") == Some(&json!("complete"))
&& evidence.get("truncated") == Some(&json!(false))
&& evidence.get("error_code") == Some(&Value::Null);
let partial = evidence.get("completeness") == Some(&json!("partial"))
&& evidence.get("truncated") == Some(&json!(true))
&& matches!(
evidence.get("error_code").and_then(Value::as_str),
Some("EVENT_LOG_EVENT_LIMIT" | "EVENT_LOG_BYTE_LIMIT" | "EVENT_LOG_EVENT_SIZE_LIMIT")
);
ensure!(
!result.reboot_required
&& evidence.get("truncated") == Some(&json!(result.output_truncated))
&& job.execution_identity == "agent_service"
&& job.action.validate()
&& job
.action
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes)
&& evidence.get("source_id") == Some(&json!(unit))
&& evidence.get("channel") == Some(&json!(WINDOWS_EVENT_LOG_FIXTURE_CHANNEL))
&& evidence.get("provider") == Some(&json!(WINDOWS_EVENT_LOG_FIXTURE_PROVIDER))
&& observed_since == *since
&& observed_until == *until
&& evidence.get("max_events") == Some(&json!(max_lines))
&& evidence.get("max_output_bytes") == Some(&json!(job.max_output_bytes))
&& evidence.get("quality") == Some(&json!("valid"))
&& evidence.get("win32_error") == Some(&Value::Null)
&& evidence.get("bookmark_updated") == Some(&json!(false))
&& evidence.get("process_tree_bounded") == Some(&json!(true))
&& evidence.get("execution_sid") == Some(&json!("S-1-5-19"))
&& (complete || partial),
"fixed Windows Event Log evidence mismatch"
);
Ok(())
}
// The profile records the requested process option, never an effective GPO policy.
fn script_profile_evidence(action: &Action, evidence: &Value) -> Result<()> {
if let Action::RunScript {
script_utf8,
windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned),
..
} = action
{
ensure!(
evidence.get("windows_execution_profile")
== Some(&json!("powershell_51_remote_signed"))
&& evidence.get("execution_policy")
== Some(&json!("process_remote_signed_requested"))
&& evidence.get("execution_policy_requested") == Some(&json!("RemoteSigned"))
&& evidence.get("execution_policy_scope") == Some(&json!("process"))
&& evidence.get("script_sha256") == Some(&json!(hash(script_utf8.as_bytes()))),
"requested Windows process profile evidence mismatch"
);
}
Ok(())
}
#[cfg(test)]
mod script_profile_tests {
use super::*;
#[test]
fn windows_event_log_success_binds_request_and_keeps_limit_partial_honest() {
let id = Uuid::new_v4();
let now = Utc::now();
let job = JobPayload {
schema_version: 1,
tenant_id: id,
asset_id: id,
agent_id: id,
enrollment_generation: 1,
assignment_version: 1,
job_id: id,
attempt_id: id,
action: Action::QueryLogs {
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
since: now - Duration::hours(1),
until: now,
max_lines: 1000,
},
execution_identity: "agent_service".into(),
not_before: now,
start_before: now + Duration::minutes(1),
max_runtime_seconds: 30,
max_output_bytes: 4096,
};
let evidence = json!({"source_id":WINDOWS_EVENT_LOG_FIXTURE_SOURCE,"channel":"Application","provider":"RustDiscovery-MVP-Test","start_utc":now-Duration::hours(1),"end_utc":now,"max_events":1000,"max_output_bytes":4096,"quality":"valid","completeness":"complete","truncated":false,"error_code":null,"win32_error":null,"bookmark_updated":false,"process_tree_bounded":true,"execution_sid":"S-1-5-19"});
let result = JobResult::default();
windows_event_log_success_evidence(&job, &result, &evidence).unwrap();
for conflicting in [
JobResult {
reboot_required: true,
..Default::default()
},
JobResult {
output_truncated: true,
..Default::default()
},
] {
assert!(windows_event_log_success_evidence(&job, &conflicting, &evidence).is_err());
}
for field in [
"source_id",
"channel",
"provider",
"start_utc",
"end_utc",
"max_events",
"max_output_bytes",
"quality",
"win32_error",
"bookmark_updated",
"process_tree_bounded",
"execution_sid",
] {
let mut bad = evidence.clone();
bad[field] = json!("different");
assert!(
windows_event_log_success_evidence(&job, &result, &bad).is_err(),
"{field}"
);
}
for code in [
"EVENT_LOG_EVENT_LIMIT",
"EVENT_LOG_BYTE_LIMIT",
"EVENT_LOG_EVENT_SIZE_LIMIT",
] {
let mut partial = evidence.clone();
partial["completeness"] = json!("partial");
partial["truncated"] = json!(true);
partial["error_code"] = json!(code);
let partial_result = JobResult {
output_truncated: true,
..Default::default()
};
windows_event_log_success_evidence(&job, &partial_result, &partial).unwrap();
assert!(windows_event_log_success_evidence(&job, &result, &partial).is_err());
partial["error_code"] = json!("EVENT_LOG_TIMEOUT");
assert!(windows_event_log_success_evidence(&job, &partial_result, &partial).is_err());
partial["quality"] = json!("permission_denied");
assert!(windows_event_log_success_evidence(&job, &partial_result, &partial).is_err());
}
let mut permission_denied = evidence.clone();
permission_denied["win32_error"] = json!(5);
assert!(windows_event_log_success_evidence(&job, &result, &permission_denied).is_err());
let mut false_complete = evidence.clone();
false_complete["truncated"] = json!(true);
assert!(windows_event_log_success_evidence(&job, &result, &false_complete).is_err());
}
#[test]
fn requested_profile_success_evidence_is_exact_without_effective_policy_claim() {
let mut action = Action::RunScript {
interpreter: "powershell".into(),
script_utf8: "Write-Output 'hi'\r\n".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned),
};
let evidence = json!({"windows_execution_profile":"powershell_51_remote_signed",
"execution_policy":"process_remote_signed_requested", "execution_policy_requested":"RemoteSigned",
"execution_policy_scope":"process", "script_sha256":hash(b"Write-Output 'hi'\r\n")});
script_profile_evidence(&action, &evidence).unwrap();
for field in [
"windows_execution_profile",
"execution_policy",
"execution_policy_requested",
"execution_policy_scope",
"script_sha256",
] {
let mut changed = evidence.clone();
changed.as_object_mut().unwrap().remove(field);
assert!(
script_profile_evidence(&action, &changed).is_err(),
"{field}"
);
changed[field] = json!("different");
assert!(
script_profile_evidence(&action, &changed).is_err(),
"{field}"
);
}
if let Action::RunScript {
windows_execution_profile,
..
} = &mut action
{
*windows_execution_profile = None;
}
script_profile_evidence(&action, &json!({})).unwrap();
}
}
async fn locked_job(
tx: &mut Transaction<'_, Postgres>,
agent: Uuid,
@@ -269,6 +491,9 @@ pub async fn permit(
let payload: JobPayload = serde_json::from_slice(&row.get::<Vec<u8>, _>("payload"))?;
let plan: PlanPayload = serde_json::from_slice(&row.get::<Vec<u8>, _>("plan_payload"))?;
let capabilities: Vec<String> = serde_json::from_value(row.get("capabilities"))?;
if crate::windows_msi_catalog::validate_job_binding(&plan, &payload).is_err() {
return Ok(denied("WINDOWS_MSI_BINDING_MISMATCH"));
}
if row.get::<Uuid, _>("bound_asset") != payload.asset_id
|| !payload
.action
@@ -314,6 +539,12 @@ pub async fn permit(
return Ok(denied("BINDING_MISMATCH"));
}
let now = Utc::now();
if !payload
.action
.valid_job_limits(payload.max_runtime_seconds, payload.max_output_bytes)
{
return Ok(denied("INVALID_JOB_LIMITS"));
}
if !payload.action.validate() {
return Ok(denied("APT_MANIFEST_REQUIRED"));
}
@@ -508,9 +739,26 @@ pub async fn next(
};
let payload: JobPayload = serde_json::from_slice(&row.get::<Vec<u8>, _>("payload"))?;
let caps: Vec<String> = serde_json::from_value(row.get("capabilities"))?;
if payload.action.windows_msi().is_some() {
let raw: Vec<u8> = row.get("plan_payload");
let plan: PlanPayload = serde_json::from_slice(&raw)?;
if hash(&raw) != row.get::<String, _>("plan_hash")
|| crate::windows_msi_catalog::validate_job_binding(&plan, &payload).is_err()
|| crate::catalog::check(&mut tx, &payload.action)
.await
.is_err()
{
tx.commit().await?;
return Ok(None);
}
}
if !payload
.action
.available_for(&payload.execution_identity, &caps)
|| !payload
.action
.valid_job_limits(payload.max_runtime_seconds, payload.max_output_bytes)
{
tx.commit().await?;
return Ok(None);
+521 -2
View File
@@ -151,6 +151,13 @@ pub struct Variant {
interpreter: String,
encoding: String,
script_utf8: String,
#[serde(
default,
deserialize_with = "rmm_domain::jobs::deserialize_windows_execution_profile",
skip_serializing_if = "Option::is_none"
)]
#[schemars(with = "WindowsExecutionProfile")]
windows_execution_profile: Option<WindowsExecutionProfile>,
}
#[derive(Clone, Deserialize, Serialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
@@ -174,6 +181,12 @@ struct WebParameters {
recipe_version: Option<String>,
recipe_id: Option<String>,
apt_manifest: Option<rmm_domain::apt_transaction::AptExecutionManifest>,
#[serde(
default,
deserialize_with = "rmm_domain::jobs::deserialize_windows_msi_manifest"
)]
#[schemars(with = "rmm_domain::windows_execution::ResolvedWindowsMsi")]
windows_msi_manifest: Option<Box<rmm_domain::windows_execution::ResolvedWindowsMsi>>,
installation_context: Option<String>,
packages: Option<Vec<String>>,
reboot_policy: Option<String>,
@@ -198,6 +211,9 @@ impl PlanRequest {
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"));
}
let p = w.parameters;
if p.windows_msi_manifest.is_some() && w.action != "ensure_package" {
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"));
}
let required =
|value: Option<String>| value.ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"));
let action = match w.action.as_str() {
@@ -213,6 +229,7 @@ impl PlanRequest {
script_utf8: v.script_utf8.clone(),
arguments: p.arguments.clone().unwrap_or_default(),
expected_stdout: p.expected_stdout.clone(),
windows_execution_profile: v.windows_execution_profile,
}
}
"refresh_inventory" => Action::RefreshInventory {
@@ -243,6 +260,7 @@ impl PlanRequest {
installation_context: required(p.installation_context)?,
recipe_id: p.recipe_id,
apt_manifest: p.apt_manifest,
windows_msi_manifest: p.windows_msi_manifest,
},
"apply_updates" => Action::ApplyUpdates {
provider: required(p.provider)?,
@@ -310,6 +328,7 @@ fn validate_variants(variants: &[Variant]) -> Result<()> {
script_utf8: v.script_utf8.clone(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: v.windows_execution_profile,
};
if v.encoding != "utf-8"
|| action.script_platform() != Some(v.os_family.as_str())
@@ -336,12 +355,21 @@ fn target_action(input: &PlanInput, caps: &[String]) -> Result<Action> {
script_utf8,
arguments,
expected_stdout,
windows_execution_profile,
} = &input.action
else {
return Err(fail("VALIDATION_ERROR"));
};
let first = &input.script_variants[0];
if interpreter != &first.interpreter || script_utf8 != &first.script_utf8 {
if interpreter != &first.interpreter
|| script_utf8 != &first.script_utf8
|| windows_execution_profile != &first.windows_execution_profile
|| (input.execution_identity != "agent_service"
&& input
.script_variants
.iter()
.any(|v| v.windows_execution_profile.is_some()))
{
return Err(fail("VALIDATION_ERROR"));
}
let platform = match (
@@ -362,6 +390,7 @@ fn target_action(input: &PlanInput, caps: &[String]) -> Result<Action> {
script_utf8: v.script_utf8.clone(),
arguments: arguments.clone(),
expected_stdout: expected_stdout.clone(),
windows_execution_profile: v.windows_execution_profile,
})
}
async fn policy(tx: &mut Transaction<'_, Postgres>) -> Result<()> {
@@ -416,6 +445,14 @@ pub async fn plan(
{
return Err(Error(StatusCode::FORBIDDEN, "ROOT_IDENTITY_REQUIRED"));
}
if input.action.windows_msi().is_some()
&& (input.execution_identity != "system" || !input.artifact_ids.is_empty())
{
return Err(Error(
StatusCode::BAD_REQUEST,
"WINDOWS_MSI_EXACT_ARTIFACT_REQUIRED",
));
}
// Conservative policy: reboot is always serial, no provider-triggered reboot.
if matches!(input.action, Action::Reboot { .. }) && input.rollout.max_parallel != 1 {
return Err(fail("POLICY_DENIED"));
@@ -439,7 +476,11 @@ pub async fn plan(
crate::permissions::require_principal(&mut tx, p, "logs:read").await?;
}
let recipe_references = crate::catalog::references(&mut tx, &input.action).await?;
let artifacts = crate::catalog::resolve_artifacts(&mut tx, tenant, &input.artifact_ids).await?;
let artifacts = if input.action.windows_msi().is_some() {
crate::windows_msi_catalog::automatic_artifacts(&mut tx, tenant, &input.action).await?
} else {
crate::catalog::resolve_artifacts(&mut tx, tenant, &input.artifact_ids).await?
};
let mut jobs = Vec::new();
for asset in ids {
let rows=sqlx::query("SELECT agent_id,enrollment_generation,assignment_version,capabilities FROM agent_installations WHERE asset_id=$1 AND revoked_at IS NULL ORDER BY agent_id FOR SHARE").bind(asset).fetch_all(&mut *tx).await?;
@@ -453,6 +494,9 @@ pub async fn plan(
let row = &rows[0];
let caps = capabilities(row.get("capabilities"))?;
let action = target_action(&input, &caps)?;
if !action.valid_job_limits(input.max_runtime_seconds, input.max_output_bytes) {
return Err(fail("VALIDATION_ERROR"));
}
if !action.available_for(&input.execution_identity, &caps) {
return Err(fail("UNSUPPORTED_CAPABILITY"));
}
@@ -509,6 +553,7 @@ pub async fn plan(
recipe_references,
artifact_references,
};
crate::windows_msi_catalog::validate_plan_bindings(&payload)?;
let bytes = encode(&payload)?;
let plan_hash = hash(&bytes);
sqlx::query("INSERT INTO operation_plans(tenant_id,plan_id,principal,payload,plan_hash,expires_at) VALUES($1,$2,$3,$4,$5,$6)").bind(tenant).bind(payload.plan_id).bind(&p.name).bind(&bytes).bind(&plan_hash).bind(input.schedule.start_before).execute(&mut *tx).await?;
@@ -543,6 +588,7 @@ async fn load_plan(
Ok((serde_json::from_slice(&bytes)?, h, bytes))
}
async fn recheck(tx: &mut Transaction<'_, Postgres>, plan: &PlanPayload) -> Result<()> {
crate::windows_msi_catalog::validate_plan_bindings(plan)?;
policy(tx).await?;
let current_artifacts = crate::catalog::resolve_artifacts(
tx,
@@ -580,6 +626,12 @@ async fn recheck(tx: &mut Transaction<'_, Postgres>, plan: &PlanPayload) -> Resu
}
let mut references = Vec::new();
for job in &plan.jobs {
if !job.payload.action.valid_job_limits(
job.payload.max_runtime_seconds,
job.payload.max_output_bytes,
) {
return Err(fail("VALIDATION_ERROR"));
}
if !job.payload.action.validate() {
return Err(Error(StatusCode::CONFLICT, "APT_MANIFEST_REQUIRED"));
}
@@ -1004,6 +1056,7 @@ async fn operations_http(
#[cfg(test)]
mod windows_contract_tests {
use super::*;
use chrono::Duration;
fn input() -> PlanInput {
let tenant = Uuid::new_v4();
let now = Utc::now();
@@ -1035,6 +1088,111 @@ mod windows_contract_tests {
i.script_variants.remove(1);
assert!(target_action(&i, &["windows.base/1".into()]).is_err());
}
#[test]
fn fixed_windows_log_web_contract_denies_extra_source_parameters() {
let tenant = Uuid::new_v4();
let now = Utc::now();
let value = json!({"tenant_id":tenant,"action":"query_logs","targets":{"asset_ids":[Uuid::new_v4()]},"parameters":{"execution_identity":"agent_service","timeout_seconds":30,"max_output_bytes":4096,"unit":WINDOWS_EVENT_LOG_FIXTURE_SOURCE,"since":now-Duration::hours(1),"until":now,"max_lines":1000},"schedule":{"not_before":now,"start_before":now+Duration::minutes(10),"offline_policy":"wait_until_deadline"},"rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"fixed source"});
let input = serde_json::from_value::<PlanRequest>(value.clone())
.unwrap()
.resolve(tenant)
.unwrap();
assert!(input.action.is_windows_event_log_fixture());
assert!(input.action.validate());
assert!(
input
.action
.valid_job_limits(input.max_runtime_seconds, input.max_output_bytes)
);
assert!(input.script_variants.is_empty());
for field in ["channel", "provider", "xpath", "bookmark"] {
let mut bad = value.clone();
bad["parameters"][field] = json!("arbitrary");
assert!(
serde_json::from_value::<PlanRequest>(bad)
.map(|request| request.resolve(tenant).is_err())
.unwrap_or(true)
);
}
}
#[test]
fn remote_signed_fixed_variants_bind_profile_without_linux_inheritance() {
let mut i = input();
let legacy_linux = encode(&i.action).unwrap();
i.script_variants[1].windows_execution_profile =
Some(WindowsExecutionProfile::PowerShell51RemoteSigned);
assert_eq!(
encode(&target_action(&i, &["linux.base/1".into()]).unwrap()).unwrap(),
legacy_linux
);
let windows = target_action(&i, &["windows.base/1".into()]).unwrap();
assert!(matches!(
windows,
Action::RunScript {
windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned),
..
}
));
assert!(!windows.available_for(
"agent_service",
&[
"windows.base/1".into(),
"rmm.sync.v1".into(),
"run_script".into(),
"script.powershell/1".into()
]
));
for identity in ["root", "system"] {
i.execution_identity = identity.into();
assert!(target_action(&i, &["linux.base/1".into()]).is_err());
}
i.execution_identity = "agent_service".into();
// Even the first Action must match the optional profile byte-for-byte.
i.script_variants.reverse();
i.action = windows;
assert!(target_action(&i, &["windows.base/1".into()]).is_ok());
if let Action::RunScript {
windows_execution_profile,
..
} = &mut i.action
{
*windows_execution_profile = None;
}
assert!(target_action(&i, &["windows.base/1".into()]).is_err());
i.script_variants[1].windows_execution_profile =
Some(WindowsExecutionProfile::PowerShell51RemoteSigned);
assert!(validate_variants(&i.script_variants).is_err());
let schema = schemars::schema_for!(Variant).to_value();
assert_eq!(
schema["properties"]["windows_execution_profile"],
json!({"$ref":"#/$defs/WindowsExecutionProfile"})
);
assert!(
!schema["required"]
.as_array()
.unwrap()
.contains(&json!("windows_execution_profile"))
);
assert_eq!(schema["$defs"]["WindowsExecutionProfile"]["type"], "string");
let legacy = json!({"os_family":"windows", "interpreter":"powershell", "encoding":"utf-8", "script_utf8":"hi"});
let inherited: Variant = serde_json::from_value(legacy.clone()).unwrap();
assert!(inherited.windows_execution_profile.is_none());
assert_eq!(serde_json::to_value(inherited).unwrap(), legacy);
for profile in [
Value::Null,
json!(false),
json!(1),
json!([]),
json!({}),
json!({"powershell_51_remote_signed":null}),
json!("bypass"),
json!("powershell_7_remote_signed"),
] {
assert!(serde_json::from_value::<Variant>(json!({"os_family":"windows", "interpreter":"powershell", "encoding":"utf-8", "script_utf8":"hi", "windows_execution_profile":profile})).is_err());
assert!(serde_json::from_value::<WebParameters>(json!({"execution_identity":"agent_service", "timeout_seconds":60, "max_output_bytes":4096, "windows_execution_profile":profile})).is_err());
}
assert!(serde_json::from_value::<WebParameters>(json!({"execution_identity":"agent_service", "timeout_seconds":60, "max_output_bytes":4096, "windows_execution_profile":"powershell_51_remote_signed"})).is_err());
}
#[tokio::test]
#[ignore = "requires dedicated isolated PostgreSQL; tests/windows_plan_database.py"]
async fn windows_plan_caps_persisted_database() {
@@ -1175,6 +1333,75 @@ mod windows_contract_tests {
"PLAN_HASH_MISMATCH"
);
tx.rollback().await.unwrap();
// A process-profile plan needs the additional current capability. Its
// presence is rechecked at submit/approval just like interpreter support.
let mut profiled = request.clone();
profiled.script_variants[1].windows_execution_profile =
Some(WindowsExecutionProfile::PowerShell51RemoteSigned);
assert_eq!(
plan(&state, &principal, tenant, profiled.clone())
.await
.unwrap_err()
.1,
"UNSUPPORTED_CAPABILITY"
);
let mut profile_caps = windows_caps.as_array().unwrap().clone();
profile_caps.push(json!("script.powershell.process_remote_signed/1"));
sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1")
.bind(agents[1])
.bind(json!(profile_caps))
.execute(&admin)
.await
.unwrap();
let view = plan(&state, &principal, tenant, profiled).await.unwrap();
let profile_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap();
let bytes: Vec<u8> =
sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1")
.bind(profile_id)
.fetch_one(&admin)
.await
.unwrap();
let profile_bound: PlanPayload = serde_json::from_slice(&bytes).unwrap();
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
recheck(&mut tx, &profile_bound).await.unwrap();
tx.rollback().await.unwrap();
let mut changed = profile_bound.clone();
let windows_job = changed
.jobs
.iter_mut()
.find(|j| j.payload.asset_id == assets[1])
.unwrap();
if let Action::RunScript {
windows_execution_profile,
..
} = &mut windows_job.payload.action
{
*windows_execution_profile = None;
}
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
assert_eq!(
recheck(&mut tx, &changed).await.unwrap_err().1,
"PLAN_HASH_MISMATCH"
);
tx.rollback().await.unwrap();
sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1")
.bind(agents[1])
.bind(&windows_caps)
.execute(&admin)
.await
.unwrap();
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
assert_eq!(
recheck(&mut tx, &profile_bound).await.unwrap_err().1,
"UNSUPPORTED_CAPABILITY"
);
tx.rollback().await.unwrap();
request.script_variants.clear();
assert_eq!(
plan(&state, &principal, tenant, request.clone())
@@ -1198,6 +1425,298 @@ mod windows_contract_tests {
.unwrap()
.is_none()
);
let now = Utc::now();
let mut logs = input();
logs.targets.asset_ids = vec![assets[1]];
logs.script_variants.clear();
logs.max_runtime_seconds = 30;
logs.action = Action::QueryLogs {
unit: WINDOWS_EVENT_LOG_FIXTURE_SOURCE.into(),
since: now - Duration::hours(1),
until: now,
max_lines: 1000,
};
assert_eq!(
plan(&state, &principal, tenant, logs.clone())
.await
.unwrap_err()
.1,
"FORBIDDEN"
);
sqlx::query("UPDATE memberships SET permissions=array_append(permissions,'logs:read') WHERE principal=$1").bind(&principal.name).execute(&admin).await.unwrap();
assert_eq!(
plan(&state, &principal, tenant, logs.clone())
.await
.unwrap_err()
.1,
"UNSUPPORTED_CAPABILITY"
);
let mut log_caps = windows_caps.as_array().unwrap().clone();
log_caps.extend([
json!("query_logs"),
json!(WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY),
]);
sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1")
.bind(agents[1])
.bind(json!(log_caps))
.execute(&admin)
.await
.unwrap();
let view = plan(&state, &principal, tenant, logs).await.unwrap();
let log_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap();
let bytes: Vec<u8> =
sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1")
.bind(log_id)
.fetch_one(&admin)
.await
.unwrap();
let log_bound: PlanPayload = serde_json::from_slice(&bytes).unwrap();
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
recheck(&mut tx, &log_bound).await.unwrap();
tx.rollback().await.unwrap();
let pending = submit(
&state,
&principal,
tenant,
log_id,
Submit {
idempotency_key: "fixed-event-log".into(),
},
)
.await
.unwrap();
assert_eq!(pending["approval_state"], "pending_approval");
assert_eq!(pending["job_count"], 0);
let mut changed = log_bound.clone();
if let Action::QueryLogs { max_lines, .. } = &mut changed.jobs[0].payload.action {
*max_lines = 999;
}
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
assert_eq!(
recheck(&mut tx, &changed).await.unwrap_err().1,
"PLAN_HASH_MISMATCH"
);
tx.rollback().await.unwrap();
let mut changed = log_bound.clone();
changed.jobs[0].payload.max_output_bytes = 65537;
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
assert_eq!(
recheck(&mut tx, &changed).await.unwrap_err().1,
"VALIDATION_ERROR"
);
tx.rollback().await.unwrap();
log_caps.retain(|cap| cap != WINDOWS_EVENT_LOG_FIXTURE_CAPABILITY);
sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1")
.bind(agents[1])
.bind(json!(log_caps))
.execute(&admin)
.await
.unwrap();
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
assert_eq!(
recheck(&mut tx, &log_bound).await.unwrap_err().1,
"UNSUPPORTED_CAPABILITY"
);
tx.rollback().await.unwrap();
sqlx::query("UPDATE memberships SET permissions=array_remove(permissions,'logs:read') WHERE principal=$1").bind(&principal.name).execute(&admin).await.unwrap();
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
assert_eq!(
recheck(&mut tx, &log_bound).await.unwrap_err().1,
"FORBIDDEN"
);
tx.rollback().await.unwrap();
// MSI metadata only: real migration/RLS/FKs and pending-only planning.
// This ignored test runs alone in the dedicated isolated PostgreSQL process.
// Opaque bytes deliberately are NOT an authored/installed MSI fixture.
use crate::artifact_store::ArtifactStore;
use std::os::unix::fs::PermissionsExt;
let key_path = temp.join("key.pem");
let policy_path = temp.join("system-msi.json");
let settings = [
("RMM_PROFILE", "development".to_string()),
("RMM_JOB_KEY_FILE", key_path.display().to_string()),
("RMM_DEV_SYSTEM_ENABLED", "true".to_string()),
(
"RMM_DEV_SYSTEM_POLICY_FILE",
policy_path.display().to_string(),
),
];
let previous = settings
.iter()
.map(|(key, _)| (*key, std::env::var_os(key)))
.collect::<Vec<_>>();
for (key, value) in &settings {
unsafe {
std::env::set_var(key, value);
}
}
let artifact_id = Uuid::new_v4();
let opaque = b"metadata-contract-not-an-executable-msi";
let artifact_sha = crate::catalog::store()
.unwrap()
.put(tenant, opaque)
.unwrap();
let manifest = crate::windows_msi_catalog::test_manifest(
artifact_id,
&artifact_sha,
opaque.len() as u64,
);
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
sqlx::query("INSERT INTO artifacts(tenant_id,artifact_id,sha256,size_bytes,media_type) VALUES($1,$2,$3,$4,'application/octet-stream')")
.bind(tenant).bind(artifact_id).bind(&artifact_sha).bind(opaque.len() as i64).execute(&mut *tx).await.unwrap();
let catalog_id = crate::windows_msi_catalog::store_recipe(&mut tx, tenant, &manifest)
.await
.unwrap();
tx.commit().await.unwrap();
let other = Uuid::new_v4();
sqlx::query("INSERT INTO tenants(tenant_id,name) VALUES($1,'other MSI tenant')")
.bind(other)
.execute(&admin)
.await
.unwrap();
let mut foreign = rmm_persistence::tenant_tx(&state.pool, other)
.await
.unwrap();
let count: i64 = sqlx::query_scalar("SELECT count(*) FROM windows_msi_recipes")
.fetch_one(&mut *foreign)
.await
.unwrap();
assert_eq!(count, 0);
assert!(
crate::windows_msi_catalog::references(&mut foreign, &manifest)
.await
.is_err()
);
foreign.rollback().await.unwrap();
let row=sqlx::query("INSERT INTO windows_msi_recipes(tenant_id,catalog_id,recipe_id,recipe_version,recipe_sha256,artifact_id,artifact_sha256,artifact_bytes,payload) VALUES($1,$2,$3,'1',$4,$5,$6,$7,$8)")
.bind(other).bind(Uuid::new_v4()).bind(&manifest.recipe.recipe_id).bind(&manifest.recipe_sha256)
.bind(artifact_id).bind(&artifact_sha).bind(opaque.len() as i64).bind(encode(&manifest.recipe).unwrap()).execute(&admin).await;
assert!(row.is_err()); // database-level composite tenant/artifact FK
assert!(
sqlx::query("UPDATE windows_msi_recipes SET recipe_sha256=$2 WHERE catalog_id=$1")
.bind(catalog_id)
.bind("cd".repeat(32))
.execute(&admin)
.await
.is_err()
);
assert!(
sqlx::query("DELETE FROM windows_msi_recipes WHERE catalog_id=$1")
.bind(catalog_id)
.execute(&admin)
.await
.is_err()
);
sqlx::query("UPDATE memberships SET permissions=array_append(permissions,'system:execute') WHERE tenant_id=$1 AND principal=$2").bind(tenant).bind(&principal.name).execute(&admin).await.unwrap();
let caps = json!([
"windows.base/1",
"rmm.sync.v1",
"helper.system.v1",
"ensure_package",
"system:ensure_package",
rmm_domain::windows_execution::MSI_CAPABILITY,
format!("helper.policy.sha256:{}", "ab".repeat(32)),
format!("helper.binary.sha256:{}", "cd".repeat(32))
]);
sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1")
.bind(agents[1])
.bind(&caps)
.execute(&admin)
.await
.unwrap();
let system = json!({"schema_version":2,"profile":"development","expires_at":Utc::now()+Duration::minutes(10),"scopes":[{
"tenant_id":tenant,"asset_id":assets[1],"agent_id":agents[1],"enrollment_generation":1,"assignment_version":1,
"principals":[principal.name],"helper_policy_sha256":"ab".repeat(32),"helper_binary_sha256":"cd".repeat(32),
"acceptance_evidence_id":Uuid::new_v4(),"allowed_services":[],"max_runtime_seconds":120,"allowed_msi_recipe_sha256":[manifest.recipe_sha256]}]});
std::fs::write(&policy_path, encode(&system).unwrap()).unwrap();
std::fs::set_permissions(&policy_path, std::fs::Permissions::from_mode(0o600)).unwrap();
let mut package = input();
package.targets.asset_ids = vec![assets[1]];
package.script_variants.clear();
package.execution_identity = "system".into();
package.action = crate::windows_msi_catalog::test_action(manifest.clone());
package.max_runtime_seconds = 30;
package.max_output_bytes = 4096;
let mut extra = package.clone();
extra.artifact_ids = vec![artifact_id];
assert_eq!(
plan(&state, &principal, tenant, extra).await.unwrap_err().1,
"WINDOWS_MSI_EXACT_ARTIFACT_REQUIRED"
);
let view = plan(&state, &principal, tenant, package).await.unwrap();
let package_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap();
let raw: Vec<u8> =
sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1")
.bind(package_id)
.fetch_one(&admin)
.await
.unwrap();
let fixed: PlanPayload = serde_json::from_slice(&raw).unwrap();
assert_eq!(fixed.artifact_references.len(), 1);
assert_eq!(
fixed.artifact_references[0].artifact.artifact_id,
artifact_id
);
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
recheck(&mut tx, &fixed).await.unwrap();
tx.rollback().await.unwrap();
for case in 0..4 {
let mut bad = fixed.clone();
match case {
0 => bad.artifact_references.clear(),
1 => bad
.artifact_references
.push(bad.artifact_references[0].clone()),
2 => bad.artifact_references[0].artifact.size_bytes += 1,
_ => bad.artifact_references[0].artifact.artifact_id = Uuid::new_v4(),
};
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
assert!(recheck(&mut tx, &bad).await.is_err());
tx.rollback().await.unwrap();
}
let pending = submit(
&state,
&principal,
tenant,
package_id,
Submit {
idempotency_key: "fixed-msi-metadata".into(),
},
)
.await
.unwrap();
assert_eq!(pending["approval_state"], "pending_approval");
assert_eq!(pending["job_count"], 0);
sqlx::query("UPDATE memberships SET permissions=array_remove(permissions,'system:execute') WHERE tenant_id=$1 AND principal=$2").bind(tenant).bind(&principal.name).execute(&admin).await.unwrap();
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.unwrap();
assert_eq!(recheck(&mut tx, &fixed).await.unwrap_err().1, "FORBIDDEN");
tx.rollback().await.unwrap();
for (key, value) in previous {
unsafe {
match value {
Some(value) => std::env::set_var(key, value),
None => std::env::remove_var(key),
}
}
}
let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM jobs WHERE tenant_id=$1),(SELECT count(*) FROM outbox WHERE tenant_id=$1),(SELECT count(*) FROM execution_permits WHERE tenant_id=$1)").bind(tenant).fetch_one(&admin).await.unwrap();
assert_eq!(counts, (0, 0, 0));
let after: Vec<u8> =
+1
View File
@@ -21,6 +21,7 @@ mod root_policy;
mod scheduler;
mod synchronization;
mod tls;
mod windows_msi_catalog;
mod windows_policy;
use anyhow::{Context, Result, ensure};
+1
View File
@@ -356,6 +356,7 @@ mod tests {
script_utf8: "true\n".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
},
execution_identity: "root".into(),
not_before: now,
+380
View File
@@ -0,0 +1,380 @@
//! Immutable tenant MSI recipe/one-artifact binding. Catalog import is metadata,
//! never job approval, helper provisioning, an installer, or a capability grant.
use crate::{jobs::Error, pagination};
use axum::{
Json,
extract::{Path, Query, State},
http::{HeaderMap, StatusCode},
};
use rmm_domain::{
jobs::{Action, ArtifactReference, JobPayload, PlanPayload, RecipeReference, encode, hash},
windows_execution::{MSI_PACKAGE_ID, ResolvedWindowsMsi, WindowsMsiRecipe},
};
use serde_json::{Value, json};
use sqlx::{Postgres, Row, Transaction};
use uuid::Uuid;
fn conflict() -> Error {
Error(StatusCode::CONFLICT, "WINDOWS_MSI_BINDING_MISMATCH")
}
fn reference(m: &ResolvedWindowsMsi) -> RecipeReference {
RecipeReference {
package: MSI_PACKAGE_ID.into(),
version: m.recipe.postcondition.product_version.clone(),
architecture: "x64".into(),
recipe_version: m.recipe.recipe_version.clone(),
sha256: m.recipe_sha256.clone(),
}
}
fn artifact(m: &ResolvedWindowsMsi) -> ArtifactReference {
ArtifactReference {
artifact_id: m.recipe.artifact.artifact_id,
sha256: m.recipe.artifact.sha256.clone(),
size_bytes: m.recipe.artifact.bytes,
}
}
async fn checked(
tx: &mut Transaction<'_, Postgres>,
m: &ResolvedWindowsMsi,
) -> Result<(Uuid, ArtifactReference), Error> {
if !m.validate() {
return Err(Error(
StatusCode::BAD_REQUEST,
"INVALID_WINDOWS_MSI_MANIFEST",
));
}
// Catalog rows cannot be updated/deleted. Avoid a row lock here: PostgreSQL
// requires UPDATE privilege for FOR SHARE, which this immutable reader lacks.
let row=sqlx::query("SELECT tenant_id,payload,recipe_sha256,artifact_id,artifact_sha256,artifact_bytes FROM windows_msi_recipes WHERE recipe_id=$1 AND recipe_version=$2")
.bind(&m.recipe.recipe_id).bind(&m.recipe.recipe_version).fetch_optional(&mut **tx).await?
.ok_or(Error(StatusCode::CONFLICT,"WINDOWS_MSI_RECIPE_NOT_CONFIGURED"))?;
let bytes: Vec<u8> = row.get("payload");
let a = artifact(m);
if encode(&m.recipe)? != bytes
|| hash(&bytes) != m.recipe_sha256
|| row.get::<String, _>("recipe_sha256") != m.recipe_sha256
|| row.get::<Uuid, _>("artifact_id") != a.artifact_id
|| row.get::<String, _>("artifact_sha256") != a.sha256
|| row.get::<i64, _>("artifact_bytes") as u64 != a.size_bytes
{
return Err(conflict());
}
let tenant: Uuid = row.get("tenant_id");
let actual = crate::catalog::resolve_artifacts(tx, tenant, &[a.artifact_id]).await?;
if actual != [a.clone()] {
return Err(conflict());
}
Ok((tenant, a))
}
pub async fn references(
tx: &mut Transaction<'_, Postgres>,
m: &ResolvedWindowsMsi,
) -> Result<Vec<RecipeReference>, Error> {
checked(tx, m).await?;
Ok(vec![reference(m)])
}
pub async fn automatic_artifacts(
tx: &mut Transaction<'_, Postgres>,
tenant: Uuid,
action: &Action,
) -> Result<Vec<ArtifactReference>, Error> {
let m = action.windows_msi().ok_or_else(conflict)?;
if !action.validate() {
return Err(conflict());
}
let (actual, a) = checked(tx, m).await?;
if actual != tenant {
return Err(conflict());
}
Ok(vec![a])
}
/// Set equality/count checks are deliberate. contains()/dedup() would accept
/// missing, additional, or duplicate per-attempt Windows artifact authorizations.
pub fn validate_plan_bindings(plan: &PlanPayload) -> Result<(), Error> {
let mut has_msi = false;
let mut recipes = Vec::new();
for job in &plan.jobs {
let Some(m) = job.payload.action.windows_msi() else {
continue;
};
has_msi = true;
recipes.push(reference(m));
if !job.payload.action.validate()
|| job.payload.execution_identity != "system"
|| !job.payload.action.valid_job_limits(
job.payload.max_runtime_seconds,
job.payload.max_output_bytes,
)
|| plan.tenant_id != job.payload.tenant_id
|| plan
.jobs
.iter()
.filter(|other| {
other.payload.job_id == job.payload.job_id
&& other.payload.attempt_id == job.payload.attempt_id
})
.count()
!= 1
{
return Err(conflict());
}
let refs = plan
.artifact_references
.iter()
.filter(|r| r.job_id == job.payload.job_id && r.attempt_id == job.payload.attempt_id)
.collect::<Vec<_>>();
if refs.len() != 1
|| refs[0].artifact != artifact(m)
|| plan
.recipe_references
.iter()
.filter(|r| **r == reference(m))
.count()
!= 1
{
return Err(conflict());
}
}
if has_msi {
recipes.sort();
recipes.dedup();
// A package plan resolves one common MSI action for all its targets.
// Never accept extra recipe authority or a mixed-action plan at a later
// delivery/permit/download boundary merely because contains() succeeds.
if recipes != plan.recipe_references
|| plan
.jobs
.iter()
.any(|j| j.payload.action.windows_msi().is_none())
|| plan.artifact_references.iter().any(|r| {
!plan
.jobs
.iter()
.any(|j| j.payload.job_id == r.job_id && j.payload.attempt_id == r.attempt_id)
})
{
return Err(conflict());
}
}
Ok(())
}
pub fn validate_job_binding(plan: &PlanPayload, job: &JobPayload) -> Result<(), Error> {
if job.action.windows_msi().is_none() {
return Ok(());
}
validate_plan_bindings(plan)?;
let bytes = encode(job)?;
let matches = plan
.jobs
.iter()
.filter(|j| j.payload.job_id == job.job_id && j.payload.attempt_id == job.attempt_id)
.collect::<Vec<_>>();
if matches.len() != 1
|| matches[0].job_payload_hash != hash(&bytes)
|| encode(&matches[0].payload)? != bytes
{
return Err(conflict());
}
Ok(())
}
pub(crate) async fn store_recipe(
tx: &mut Transaction<'_, Postgres>,
t: Uuid,
m: &ResolvedWindowsMsi,
) -> Result<Uuid, Error> {
if !m.validate() {
return Err(Error(
StatusCode::BAD_REQUEST,
"INVALID_WINDOWS_MSI_MANIFEST",
));
}
let actual = crate::catalog::resolve_artifacts(tx, t, &[m.recipe.artifact.artifact_id]).await?;
if actual != [artifact(m)] {
return Err(conflict());
}
let bytes = encode(&m.recipe)?;
if bytes.len() > 65536 {
return Err(Error(StatusCode::PAYLOAD_TOO_LARGE, "QUOTA_EXCEEDED"));
}
let id = Uuid::new_v4();
sqlx::query("INSERT INTO windows_msi_recipes(tenant_id,catalog_id,recipe_id,recipe_version,recipe_sha256,artifact_id,artifact_sha256,artifact_bytes,payload) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9)")
.bind(t).bind(id).bind(&m.recipe.recipe_id).bind(&m.recipe.recipe_version).bind(&m.recipe_sha256)
.bind(m.recipe.artifact.artifact_id).bind(&m.recipe.artifact.sha256).bind(m.recipe.artifact.bytes as i64).bind(bytes).execute(&mut **tx).await?;
Ok(id)
}
pub async fn import(
State(s): State<crate::State>,
h: HeaderMap,
Path(t): Path<Uuid>,
Json(m): Json<ResolvedWindowsMsi>,
) -> Result<Json<Value>, Error> {
let (p, mut tx) = crate::catalog::context(&s, &h, t, true).await?;
let id = store_recipe(&mut tx, t, &m).await?;
sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'windows_msi_recipe_imported',$4,now())")
.bind(t)
.bind(Uuid::new_v4())
.bind(p.name)
.bind(
json!({"catalog_id":id,"recipe_id":m.recipe.recipe_id,"recipe_sha256":m.recipe_sha256,
"artifact_id":m.recipe.artifact.artifact_id,"testsimulation":p.testsimulation}),
)
.execute(&mut *tx)
.await?;
tx.commit().await?;
Ok(Json(
json!({"catalog_id":id,"recipe_id":m.recipe.recipe_id,"sha256":m.recipe_sha256,"manifest":m}),
))
}
pub async fn list(
State(s): State<crate::State>,
h: HeaderMap,
Path(t): Path<Uuid>,
Query(query): Query<pagination::PageQuery>,
) -> Result<Json<Value>, Error> {
let (p, mut tx) = crate::catalog::context(&s, &h, t, false).await?;
let mut page = pagination::Cursor::parse(&s, &p, "catalog:windows-msi:catalog_id:asc", query)
.map_err(|status| Error(status, "VALIDATION_ERROR"))?;
let rows=sqlx::query("SELECT catalog_id,payload,recipe_sha256 FROM windows_msi_recipes WHERE catalog_id>$1 AND created_at<=$2 ORDER BY catalog_id LIMIT $3")
.bind(page.last).bind(page.as_of).bind(i64::from(page.limit)+1).fetch_all(&mut *tx).await?;
let truncated = rows.len() > usize::from(page.limit);
let next = if truncated {
Some(
page.next(&s, rows[usize::from(page.limit) - 1].get("catalog_id"))
.map_err(|status| Error(status, "VALIDATION_ERROR"))?,
)
} else {
None
};
let mut items = Vec::new();
for row in rows.iter().take(usize::from(page.limit)) {
let bytes: Vec<u8> = row.get("payload");
let m = ResolvedWindowsMsi {
recipe: serde_json::from_slice::<WindowsMsiRecipe>(&bytes)?,
recipe_sha256: row.get("recipe_sha256"),
};
if !m.validate() || encode(&m.recipe)? != bytes {
return Err(conflict());
}
items.push(json!({"catalog_id":row.get::<Uuid,_>("catalog_id"),"recipe_id":m.recipe.recipe_id,"sha256":m.recipe_sha256,"manifest":m}));
}
tx.commit().await?;
Ok(Json(
json!({"items":items,"next_cursor":next,"completeness":if truncated{"partial"}else{"complete"},"truncated":truncated,"as_of":page.as_of}),
))
}
#[cfg(test)]
pub(crate) fn test_manifest(id: Uuid, sha: &str, bytes: u64) -> ResolvedWindowsMsi {
use rmm_domain::windows_execution::*;
let recipe = WindowsMsiRecipe {
schema_version: 1,
recipe_id: MSI_RECIPE_ID.into(),
recipe_version: "1".into(),
platform: "windows".into(),
upgrade_code: MSI_UPGRADE_CODE.into(),
architecture: Architecture::X64,
context: InstallContext::Machine,
command_profile: MsiCommandProfile::FixtureQuietNoRebootV1,
artifact: MsiArtifact {
artifact_id: id,
sha256: sha.into(),
bytes,
},
postcondition: MsiPostcondition {
product_code: MSI_PRODUCT_CODE.into(),
product_version: MSI_VERSION.into(),
payload_path: MSI_PAYLOAD.into(),
payload_sha256: MSI_PAYLOAD_10_SHA256.into(),
payload_bytes: MSI_PAYLOAD_BYTES,
},
no_reboot: true,
package_code: None,
predecessor: None,
};
ResolvedWindowsMsi {
recipe_sha256: recipe.sha256().unwrap(),
recipe,
}
}
#[cfg(test)]
pub(crate) fn test_action(m: ResolvedWindowsMsi) -> Action {
Action::EnsurePackage {
provider: "msi".into(),
package: MSI_PACKAGE_ID.into(),
version: m.recipe.postcondition.product_version.clone(),
architecture: "x64".into(),
recipe_version: m.recipe.recipe_version.clone(),
installation_context: "machine".into(),
recipe_id: Some(m.recipe.recipe_id.clone()),
apt_manifest: None,
windows_msi_manifest: Some(Box::new(m)),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn exact_per_attempt_artifact_set_never_deduplicates_missing_extra_or_foreign_authority() {
use rmm_domain::jobs::{JobArtifactReference, PlannedJob};
let id = Uuid::new_v4();
let now = chrono::Utc::now();
let m = test_manifest(Uuid::new_v4(), &"ab".repeat(32), 32);
let job = JobPayload {
schema_version: 1,
tenant_id: id,
asset_id: id,
agent_id: id,
enrollment_generation: 1,
assignment_version: 1,
job_id: Uuid::new_v4(),
attempt_id: Uuid::new_v4(),
action: test_action(m.clone()),
execution_identity: "system".into(),
not_before: now,
start_before: now + chrono::Duration::minutes(1),
max_runtime_seconds: 30,
max_output_bytes: 4096,
};
let plan = PlanPayload {
schema_version: 1,
plan_id: Uuid::new_v4(),
tenant_id: id,
principal: "test".into(),
reason: "metadata only".into(),
jobs: vec![PlannedJob {
job_payload_hash: hash(&encode(&job).unwrap()),
payload: job.clone(),
script_sha256: None,
}],
max_parallel: 1,
halt_after_failures: 1,
recipe_references: vec![reference(&m)],
artifact_references: vec![JobArtifactReference {
job_id: job.job_id,
attempt_id: job.attempt_id,
artifact: artifact(&m),
}],
};
validate_job_binding(&plan, &job).unwrap();
for case in 0..9 {
let mut bad = plan.clone();
match case {
0 => bad.artifact_references.clear(),
1 => bad
.artifact_references
.push(bad.artifact_references[0].clone()),
2 => bad.artifact_references[0].artifact.artifact_id = Uuid::new_v4(),
3 => bad.artifact_references[0].artifact.size_bytes += 1,
4 => bad.artifact_references[0].attempt_id = Uuid::new_v4(),
5 => bad.jobs[0].payload.max_output_bytes += 1,
6 => bad.recipe_references.clear(),
7 => bad.recipe_references.push(bad.recipe_references[0].clone()),
_ => {
let mut extra = bad.recipe_references[0].clone();
extra.sha256 = "ef".repeat(32);
bad.recipe_references.push(extra);
}
}
assert!(validate_job_binding(&bad, &job).is_err());
}
}
}
+80 -7
View File
@@ -37,8 +37,16 @@ struct SystemScope {
// Administrative evidence pin, never an approval or authorization ID.
acceptance_evidence_id: Uuid,
allowed_services: Vec<String>,
#[serde(default, deserialize_with = "strict_optional_hashes")]
allowed_msi_recipe_sha256: Option<Vec<String>>,
max_runtime_seconds: u32,
}
fn strict_optional_hashes<'de, D>(deserializer: D) -> Result<Option<Vec<String>>, D::Error>
where
D: serde::Deserializer<'de>,
{
Vec::<String>::deserialize(deserializer).map(Some)
}
fn digest(value: &str) -> bool {
value.len() == 64
&& value
@@ -86,9 +94,27 @@ impl SystemScope {
.collect::<std::collections::BTreeSet<_>>()
.len()
== self.allowed_services.len()
&& self
.allowed_msi_recipe_sha256
.as_ref()
.is_none_or(|hashes| {
hashes.len() <= 2
&& hashes.iter().all(|h| digest(h))
&& hashes
.iter()
.collect::<std::collections::BTreeSet<_>>()
.len()
== hashes.len()
})
&& (1..=120).contains(&self.max_runtime_seconds)
}
fn permits(&self, principal: &str, job: &JobPayload, capabilities: &[String]) -> bool {
fn permits(
&self,
principal: &str,
job: &JobPayload,
capabilities: &[String],
allow_msi: bool,
) -> bool {
let has = |cap: &str| capabilities.iter().any(|c| c == cap);
self.valid()
&& job.execution_identity == "system"
@@ -110,17 +136,40 @@ impl SystemScope {
"helper.binary.sha256:{}",
self.helper_binary_sha256
))
&& has("system:set_service_state")
&& has("set_service_state")
&& (1..=self.max_runtime_seconds).contains(&job.max_runtime_seconds)
&& (1..=65536).contains(&job.max_output_bytes)
&& matches!(&job.action,Action::SetServiceState{unit,state}
if self.allowed_services.contains(unit) && matches!(state.as_str(),"running"|"stopped"))
&& match &job.action {
Action::SetServiceState { unit, state } => {
self.allowed_services.contains(unit)
&& matches!(state.as_str(), "running" | "stopped")
&& has("system:set_service_state")
&& has("set_service_state")
}
_ if allow_msi => job.action.windows_msi().is_some_and(|m| {
job.action.validate()
&& job
.action
.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes)
&& self
.allowed_msi_recipe_sha256
.as_ref()
.is_some_and(|hashes| hashes.contains(&m.recipe_sha256))
&& has("ensure_package")
&& has("system:ensure_package")
&& has(rmm_domain::windows_execution::MSI_CAPABILITY)
}),
_ => false,
}
}
}
impl SystemPolicy {
fn valid(&self, now: DateTime<Utc>) -> bool {
self.schema_version == 1
matches!(self.schema_version, 1 | 2)
&& (self.schema_version == 2
|| self
.scopes
.iter()
.all(|scope| scope.allowed_msi_recipe_sha256.is_none()))
&& self.profile == "development"
&& self.expires_at > now
&& !self.scopes.is_empty()
@@ -138,7 +187,7 @@ impl SystemPolicy {
&& self
.scopes
.iter()
.any(|scope| scope.permits(principal, job, capabilities))
.any(|scope| scope.permits(principal, job, capabilities, self.schema_version == 2))
}
}
fn disabled() -> Error {
@@ -393,6 +442,7 @@ mod tests {
script_utf8: "Write-Output 'hello'".into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
};
assert!(!policy.permits("selected", &job, &caps, now));
job.action = Action::SetServiceState {
@@ -409,6 +459,29 @@ mod tests {
assert!(serde_json::from_value::<SystemPolicy>(invalid).is_err());
}
#[test]
fn only_explicit_v2_hash_scope_and_package_caps_allow_fixed_msi() {
let (mut policy, mut job, mut caps) = fixture();
let m = crate::windows_msi_catalog::test_manifest(Uuid::new_v4(), &"ab".repeat(32), 32);
job.action = crate::windows_msi_catalog::test_action(m.clone());
caps.extend([
"ensure_package".into(),
"system:ensure_package".into(),
rmm_domain::windows_execution::MSI_CAPABILITY.into(),
]);
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
policy.scopes[0].allowed_msi_recipe_sha256 = Some(vec![m.recipe_sha256.clone()]);
assert!(!policy.permits("selected", &job, &caps, Utc::now())); // v1 remains SCM-only
policy.schema_version = 2;
assert!(policy.permits("selected", &job, &caps, Utc::now()));
for index in caps.len() - 3..caps.len() {
let mut short = caps.clone();
short.remove(index);
assert!(!policy.permits("selected", &job, &short, Utc::now()));
}
policy.scopes[0].allowed_msi_recipe_sha256 = Some(vec!["cd".repeat(32)]);
assert!(!policy.permits("selected", &job, &caps, Utc::now()));
}
#[test]
fn policy_file_refuses_symlinks_public_mode_wrong_owner_and_writable_parent() {
use std::os::unix::fs::symlink;
let directory = std::env::temp_dir().join(format!("rmm-windows-policy-{}", Uuid::new_v4()));
+503
View File
@@ -0,0 +1,503 @@
#!/usr/bin/env python3
"""M3 Event Log pure contracts: Linux VM FIRST, then Windows VM.
Only two fixed test executables run in separate bootstrap scratch directories.
No RMM job, daemon, live database, PKI, policy, enrollment or capability change.
Native execution is explicit; any lost reply permits same-case readback only.
"""
import argparse
import base64
import datetime as dt
import hashlib
import inspect
import json
import os
from pathlib import Path
import re
import shlex
import shutil
import stat
import subprocess
import uuid
import vm_access_check as access
ROOT = Path(__file__).resolve().parents[1]
STATE = ROOT / 'devstate/windows-eventlog-contracts'
IMAGE = 'rust-discovery-durable-final-build:local'
PROFILE = 'windows-eventlog-contracts-v1'
LINUX_REMOTE = '/var/lib/rmm-windows-eventlog-contracts'
KINDS = ('domain', 'contracts')
REVIEWED_M3 = {'crates/agent-core/src/auth.rs': '360e6af153d7d5b31717e0f8fbc0e988850c7fa032eaa3a657962187f5a657e4',
'crates/agent-core/tests/contracts.rs': '2482928f45e3236ae079329668849f5ccd2e01503e56cd3b8e37579af3f21e9c',
'crates/agent-windows/Cargo.toml': '886f0ee1bc8b02133325bc1f1c4db76db3f0194435fba151eb1f3ca42e0660dc',
'crates/agent-windows/src/actions.rs': 'a13e3746ee05619b993b6828e9c7b103fa5d3f9d47f1b52de595da3c57910180',
'crates/agent-windows/src/event_log.rs': '00756bc178c5e67eca0de64fe55f6a1b3865e27d33f3e1c87fa575b5be81706d',
'crates/agent-windows/src/event_log_job.rs': '08798cf194c405e93cd5874517857a06649aa47a0cc8c933fbd924018670113e',
'crates/agent-windows/src/job_binding.rs': '488bab9f74b84023cf5b8f35f6f624903d98a82e886ef78d7ab93c8d99281e26',
'crates/agent-windows/src/lib.rs': '391764708bfd6a8ab5546ef299d40f54dc4eefa02d4334dead7a16e46a22cd66',
'crates/agent-windows/src/runtime.rs': '21c09cbc2a0b4caf5a4e273a20eac63dc870bb942a3683fb5b7ba6f7b36b4674',
'crates/domain/src/jobs.rs': 'b9950270fc77086d06b3f7aa177aba2ad13155c10653b3ee73a2be436365cf1f',
'crates/server/src/job_gateway.rs': '234542f4783c95cfcfd567495bfb7233f2c05a1b88dd87fb85a916d32eae5fc5',
'crates/server/src/jobs.rs': '5bff6fe61fce601cd03721cebd82bca05b5af83d3640bf862ba6d603ceb7e3e9'}
COUNTS = {'linux': {'domain': 17, 'contracts': 7}, 'windows': {'domain': 17, 'contracts': 6}}
DOMAIN_NAMES = sorted(('apt_transaction::tests::closure_bytes_archives_and_code_are_bound',
'apt_transaction::tests::helper_schema_two_roundtrip_and_strict_action_binding',
'inventory_document::tests::additive_metadata_and_bounds',
'inventory_document::tests::exact_linux_recovery_scope_does_not_admit_other_hyphens_or_windows',
'inventory_document::tests::windows_scope_does_not_weaken_linux_or_accept_platform_spoofing',
'jobs::tests::additive_recipe_refs_preserve_legacy_plan_bytes', 'jobs::tests::codec_golden_and_exact_script_bytes',
'jobs::tests::no_terminal_replay_or_unknown_restart', 'jobs::tests::permit_codec_golden_all_bindings',
'jobs::tests::updates_require_exact_versions_and_never_implicit_reboot',
'jobs::tests::windows_event_log_fixture_scope_limits_and_exact_24h_preserve_linux_bytes',
'jobs::tests::windows_interpreter_and_capability_contract',
'jobs::tests::windows_remote_signed_profile_is_optional_exact_and_capability_bound',
'jobs::tests::windows_system_scm_is_explicit_and_preserves_linux_service_bytes',
'reconciliation::tests::outcome_codec_keeps_raw_output_and_sorts_evidence',
'reconciliation::tests::reconciliation_cannot_be_a_permit_or_unbounded_ticket',
'tests::production_never_accepts_development_auth'))
CONTRACT_NAMES = sorted(('atomic_begin_execution_rolls_back_both_rows_on_missing_witness_or_start_insert_failure',
'completion_cas_preserves_original_bytes_and_recovers_only_verified_bound_evidence',
'consumed_attempt_and_unknown_lock_survive_reopen_without_reexecution',
'exact_permit_bytes_time_and_all_identity_hash_bindings_are_required',
'historical_request_and_binding_codecs_keep_field_order_arrays_and_strictness',
'openssl_and_portable_ed25519_agree_on_current_keys_bytes_and_tampering',
'portable_acceptance_requires_platform_capability_and_exact_redelivery'))
UNIX_ONLY = 'openssl_and_portable_ed25519_agree_on_current_keys_bytes_and_tampering'
EXPECTED = {'linux': {'domain': DOMAIN_NAMES, 'contracts': CONTRACT_NAMES},
'windows': {'domain': DOMAIN_NAMES, 'contracts': [x for x in CONTRACT_NAMES if x != UNIX_ONLY]}}
def require(value, code):
if not value:
raise RuntimeError(code)
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def object_pairs(items):
value = {}
for key, item in items:
require(key not in value, 'duplicate JSON field')
value[key] = item
return value
def private(path, directory=False):
item = Path(path).lstat()
require(not stat.S_ISLNK(item.st_mode) and item.st_uid == os.getuid()
and stat.S_IMODE(item.st_mode) == (0o700 if directory else 0o600)
and (stat.S_ISDIR(item.st_mode) if directory else stat.S_ISREG(item.st_mode) and item.st_nlink == 1),
'private owned regular path')
def load(path):
private(path)
require(Path(path).stat().st_size <= 2 * 1024 * 1024, 'bounded private JSON')
return json.loads(Path(path).read_bytes(), object_pairs_hook=object_pairs)
def save(path, value):
private(Path(path).parent, True)
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600)
with os.fdopen(fd, 'w') as stream:
json.dump(value, stream, indent=2); stream.write('\n'); stream.flush(); os.fsync(stream.fileno())
def setup_state():
os.umask(0o077)
STATE.parent.mkdir(mode=0o700, exist_ok=True)
metadata = STATE.parent.lstat()
require(stat.S_ISDIR(metadata.st_mode) and metadata.st_uid == os.getuid() and not metadata.st_mode & 0o002,
'owned non-world-writable devstate parent')
STATE.mkdir(mode=0o700, exist_ok=True)
private(STATE, True)
def source_files():
paths = [ROOT / p for p in ('Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml',
'deploy/windows_eventlog_acceptance.py', 'deploy/remote_client_bootstrap.py',
'deploy/vm_access_check.py', 'deploy/vm_mvp_acceptance.py', 'deploy/windows/client_bootstrap.py')]
paths += list((ROOT / 'crates').rglob('Cargo.toml'))
for name in ('domain', 'agent-core', 'protocol', 'server', 'agent-windows'):
paths += [p for p in (ROOT / 'crates' / name).rglob('*') if p.is_file()]
paths += [p for p in (ROOT / 'proto').rglob('*') if p.is_file()]
for path in paths:
require(not path.is_symlink() and path.is_file(), 'regular source inputs only')
value = {str(p.relative_to(ROOT)): sha(p) for p in sorted(set(paths))}
require(all(value[name] == digest for name, digest in REVIEWED_M3.items()), 'exact frozen reviewed M3 sources')
return value
def names(raw):
return sorted(re.findall(r'^([A-Za-z0-9_:]+): test\r?$', raw, re.M))
def check_list(raw, expected):
require(names(raw) == expected and len(set(expected)) == len(expected), 'all exact test names before execution')
require(all(not line.strip() or re.fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in raw.splitlines()),
'terse list contains only exact tests, no benchmarks or extra entries')
def check_output(raw, count):
require(re.search(rb'^test result: ok\. ' + str(count).encode()
+ rb' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;[^\r\n]*\r?$', raw, re.M),
'all tests passed without skipped or filtered tests')
def command(args, folder, timeout=300):
index = len(list(folder.glob('command-*.json')))
try:
done = subprocess.run(args, capture_output=True, timeout=timeout)
save(folder / ('command-%03d.json' % index), dict(returncode=done.returncode,
stdout_b64=base64.b64encode(done.stdout).decode(), stderr_b64=base64.b64encode(done.stderr).decode()))
require(done.returncode == 0, 'local qualification command failed; private output retained')
return done.stdout
except subprocess.TimeoutExpired as error:
save(folder / ('command-%03d.json' % index), dict(timed_out=True,
stdout_b64=base64.b64encode(error.stdout or b'').decode(), stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('local qualification timed out; no automatic retry') from None
def scripts():
return {'linux_case_sha256': hashlib.sha256(inspect.getsource(linux_case).encode()).hexdigest(),
'windows_script_sha256': hashlib.sha256(WINDOWS.encode()).hexdigest()}
def build():
setup_state()
folder = STATE / ('build-' + str(uuid.uuid4())); folder.mkdir(mode=0o700)
before = source_files(); save(folder / 'source-before.json', before)
image = command(['docker', 'image', 'inspect', '--format', '{{.Id}}', IMAGE], folder).decode().strip()
require(re.fullmatch(r'sha256:[a-f0-9]{64}', image), 'immutable local build image')
target = STATE / 'target'; target.mkdir(mode=0o700, exist_ok=True); private(target, True)
common = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=512m',
'-v', str(ROOT) + ':/src:ro', '-v', str(target) + ':/target', '-e', 'CARGO_TARGET_DIR=/target', '--entrypoint', 'cargo', image]
artifacts = {'linux': {}, 'windows': {}}
for platform, triple in [('linux', 'x86_64-unknown-linux-gnu'), ('windows', 'x86_64-pc-windows-gnu')]:
for kind in KINDS:
package, selection = ('rmm-domain', ['--lib']) if kind == 'domain' else ('rmm-agent-core', ['--test', 'contracts'])
options = ['--manifest-path', '/src/Cargo.toml', '--locked', '--offline', '--target', triple, '-p', package]
command(common + ['clippy'] + options + selection + ['--', '-D', 'warnings'], folder)
raw = command(common + ['test'] + options + selection + ['--release', '--no-run', '--message-format=json'], folder)
linked = []
for line in raw.splitlines():
try: item = json.loads(line)
except ValueError: continue
expected_name = 'rmm_domain' if kind == 'domain' else 'contracts'
if item.get('reason') == 'compiler-artifact' and item.get('executable') and item.get('profile', {}).get('test') and item['target']['name'] == expected_name:
linked.append(target / Path(item['executable']).relative_to('/target'))
require(len(linked) == 1, 'exact selected unit executable')
destination = folder / platform; destination.mkdir(mode=0o700, exist_ok=True)
original = destination / (kind + '.linked')
delivery = destination / (kind + ('.exe' if platform == 'windows' else ''))
for path in (original, delivery): shutil.copyfile(linked[0], path); path.chmod(0o600)
linked_sha = sha(original)
tool = 'x86_64-w64-mingw32-strip' if platform == 'windows' else 'strip'
command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', str(destination) + ':/artifacts',
'--entrypoint', tool, image, '--strip-debug', '/artifacts/' + delivery.name], folder)
require(sha(linked[0]) == sha(original) == linked_sha, 'unstripped original link preserved')
data = delivery.read_bytes()
if platform == 'linux':
require(data[:6] == b'\x7fELF\x02\x01' and data[18:20] == b'\x3e\0', 'Linux x64 ELF')
else:
offset = int.from_bytes(data[60:64], 'little')
require(data[:2] == b'MZ' and data[offset:offset + 6] == b'PE\0\0\x64\x86', 'Windows x64 PE')
artifacts[platform][kind] = dict(path=str(delivery.resolve()), sha256=sha(delivery), bytes=len(data),
original_link_path=str(original.resolve()), original_link_sha256=linked_sha, debug_stripped_delivery=True)
# Run exactly the deliverable Linux bytes in an offline disposable container.
for kind, item in artifacts['linux'].items():
invoke = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,exec,size=128m',
'-v', item['path'] + ':/unit:ro', '--entrypoint', 'python3', image, '-c']
for mode in ('list', 'run'):
args = ['--list', '--format', 'terse'] if mode == 'list' else ['--test-threads=1']
script = 'import shutil,os,subprocess;shutil.copyfile("/unit","/tmp/unit");os.chmod("/tmp/unit",0o500);subprocess.run(["/tmp/unit"]+' + repr(args) + ',check=True,cwd="/tmp",env={"PATH":"/usr/bin:/bin","LANG":"C.UTF-8","TMPDIR":"/tmp","RUST_BACKTRACE":"0"})'
raw = command(invoke + [script], folder)
save(folder / ('local-linux-' + kind + '-' + mode + '.json'), dict(stdout_b64=base64.b64encode(raw).decode()))
if mode == 'list': check_list(raw.decode(), EXPECTED['linux'][kind])
else: check_output(raw, COUNTS['linux'][kind])
dynamic = command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', item['path'] + ':/unit:ro',
'--entrypoint', 'readelf', image, '-d', '/unit'], folder).decode()
versions = command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', item['path'] + ':/unit:ro',
'--entrypoint', 'readelf', image, '--version-info', '/unit'], folder).decode()
glibc = sorted(set(re.findall(r'GLIBC_(\d+\.\d+)', versions)), key=lambda x: tuple(map(int, x.split('.'))))
require(glibc and tuple(map(int, glibc[-1].split('.'))) <= (2, 39), 'VM-compatible glibc requirement')
item['glibc_max'] = glibc[-1]; item['needed'] = sorted(re.findall(r'Shared library: \[([^\]]+)\]', dynamic))
require(source_files() == before, 'source and runner unchanged through qualification')
manifest = dict(schema_version=1, profile=PROFILE, source_files=before, source_before_after_equal=True,
reviewed_m3_source_pins=REVIEWED_M3, m3_adapter_sources_hash_bound_only=True, live_eventlog_query=False,
runner_sha256=sha(__file__), scripts=scripts(), test_names=EXPECTED, test_counts=COUNTS, artifacts=artifacts,
build_image_id=image, both_targets_clippy_D_warnings=True, linux_lists_actual=True,
windows_lists_expected_until_native=True, local_linux_tests_passed=24, native_linux_executed=False,
native_windows_executed=False, product_state_writes=False, rmm_jobs=False)
save(folder / 'manifest.json', manifest)
print(json.dumps(dict(manifest=str((folder / 'manifest.json').resolve()), manifest_sha256=sha(folder / 'manifest.json'),
linux_tests=24, windows_tests_expected=23, native_executed=False)))
def verified(path, new_run):
path = path.absolute(); private(path.parent, True)
require(path.name == 'manifest.json' and path.parent.parent == STATE and re.fullmatch(r'build-[0-9a-f-]{36}', path.parent.name), 'fixed build manifest path')
value = load(path)
require(value['schema_version'] == 1 and value['profile'] == PROFILE and value['runner_sha256'] == sha(__file__)
and value['scripts'] == scripts() and value['test_names'] == EXPECTED and value['test_counts'] == COUNTS
and value['source_before_after_equal'] is True and value['both_targets_clippy_D_warnings'] is True
and value['reviewed_m3_source_pins'] == REVIEWED_M3 and value['m3_adapter_sources_hash_bound_only'] is True
and value['live_eventlog_query'] is False,
'original manifest/runner/remote scripts/profile binding')
if new_run: require(value['source_files'] == source_files(), 'new execution requires same current qualified source')
for platform in COUNTS:
require(set(value['artifacts'][platform]) == set(KINDS), 'exact two artifacts')
for kind, item in value['artifacts'][platform].items():
suffix = '.exe' if platform == 'windows' else ''
require(Path(item['path']) == path.parent / platform / (kind + suffix)
and Path(item['original_link_path']) == path.parent / platform / (kind + '.linked'), 'fixed private artifact paths')
for field, digest in [('path', item['sha256']), ('original_link_path', item['original_link_sha256'])]:
private(item[field]); require(sha(item[field]) == digest, 'immutable original/delivery bytes')
require(Path(item['path']).stat().st_size == item['bytes'], 'artifact size unchanged')
return value
def access_settings(root, platform):
"""Read strictly parsed existing access only when the parent executes native."""
require(root is not None and not root.is_symlink(), 'explicit real access-root required')
root = root.absolute(); require(root.is_dir() and root.resolve() == root, 'canonical access-root')
if platform == 'linux':
cfg = access.load_config(root / 'credentials/linux-vm.conf')
require(cfg['address'] == '116.203.20.85' and cfg['username'] == 'root' and cfg.get('port', '22') == '22'
and cfg.get('ssh_key_path'), 'fixed Cloud Linux bootstrap target')
prefix = ['ssh', '-F', '/dev/null', '-T', '-p', '22', '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', '-i', str(Path(cfg['ssh_key_path']).expanduser()), 'root@116.203.20.85']
else:
cfg = access.load_config(root / 'credentials/server.conf')
require(cfg['address'] == '88.99.80.202' and cfg['username'] == 'root' and cfg.get('port', '22') == '22'
and cfg.get('ssh_key_path'), 'fixed server reverse-jump only')
credentials = root / 'credentials'; private(credentials, True)
record = load(credentials / 'windows-dev-access.json')
require(set(record) == {'ssh_prefix', 'expires_at'}, 'known Windows access schema')
expires = dt.datetime.fromisoformat(record['expires_at'])
require(expires.utcoffset() is not None and dt.datetime.now(dt.timezone.utc) < expires, 'existing dev access still valid')
key = str(Path(cfg['ssh_key_path']).expanduser())
jump = ['ssh', '-F', '/dev/null', '-T', '-p', '22', '-i', key, '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'ForwardAgent=no', '-o', 'IdentitiesOnly=yes', '-W', '127.0.0.1:22240', 'root@88.99.80.202']
prefix = ['ssh', '-F', '/dev/null', '-T', '-i', key, '-o', 'ProxyCommand=' + shlex.join(jump),
'-o', 'HostKeyAlias=rmm-windows-dev', '-o', 'UserKnownHostsFile=' + str(credentials / 'windows-dev.known_hosts'),
'-o', 'GlobalKnownHostsFile=/dev/null', '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', 'rmm-dev@127.0.0.1']
require(record['ssh_prefix'] == prefix, 'exact registered pinned reverse SSH prefix')
private(credentials / 'windows-dev.known_hosts')
return prefix
def transport(prefix, command_text, data, folder, timeout=60):
"""No stdout/stderr escapes the private case directory on transport failure."""
try:
result = subprocess.run(prefix + [command_text], input=data, capture_output=True, timeout=timeout)
save(folder / ('transport-' + str(uuid.uuid4()) + '.json'), dict(returncode=result.returncode,
stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode()))
require(result.returncode == 0, 'native transport incomplete; same-case readback only')
value = json.loads(result.stdout.decode('utf-8-sig'), object_pairs_hook=object_pairs)
require(isinstance(value, dict) and 'bootstrap_error' not in value, 'native bootstrap incomplete; private receipt retained')
return value
except subprocess.TimeoutExpired as error:
save(folder / ('transport-timeout-' + str(uuid.uuid4()) + '.json'), dict(timed_out=True,
stdout_b64=base64.b64encode(error.stdout or b'').decode(), stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('native reply lost; read original case only') from None
def linux_rpc(prefix, payload, folder):
code = 'import os,json,subprocess,base64,hashlib,uuid\nfrom pathlib import Path\n' + inspect.getsource(require) + '\n' + inspect.getsource(linux_case)
code += '\ntry:\n print(json.dumps(linux_case(' + repr(payload) + ')))\nexcept Exception as e:\n print(json.dumps(dict(bootstrap_error=True,error_class=type(e).__name__)))\n'
return transport(prefix, 'python3 -', code.encode(), folder)
def windows_rpc(prefix, payload, folder):
script = 'try {\n' + WINDOWS + '\n} catch {[pscustomobject]@{bootstrap_error=$true;error_id=$_.FullyQualifiedErrorId;line=$_.InvocationInfo.ScriptLineNumber}|ConvertTo-Json -Compress;exit 1}'
command_text = 'powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand ' + base64.b64encode(script.encode('utf-16le')).decode()
return transport(prefix, command_text, (json.dumps(payload) + '\n').encode(), folder)
def upload(prefix, item, destination, folder, kind):
args = ['sftp'] + [part for part in prefix[1:-1] if part != '-T'] + ['-b', '-', prefix[-1]]
# Linux sftp uses uppercase -P; Windows prefix has no -p option.
if '-p' in args: args[args.index('-p')] = '-P'
batch = ('put ' + json.dumps(item['path']) + ' ' + json.dumps(destination) + '\n').encode()
save(folder / ('transfer-' + kind + '-intent.json'), dict(sha256=item['sha256'], bytes=item['bytes']))
try:
result = subprocess.run(args, input=batch, capture_output=True, timeout=60)
save(folder / ('transfer-' + kind + '-result.json'), dict(returncode=result.returncode,
stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode()))
require(result.returncode == 0, 'fixed artifact transfer failed; no retry')
except subprocess.TimeoutExpired as error:
save(folder / ('transfer-' + kind + '-timeout.json'), dict(timed_out=True,
stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('artifact transfer incomplete; no retry') from None
def linux_case(p):
import resource
import stat
ident = str(uuid.UUID(p['id']))
require(ident == p['id'] and p['action'] in ('prepare', 'run', 'read') and p['profile'] == 'windows-eventlog-contracts-v1', 'fixed unit case')
require(os.geteuid() == 0 and os.uname().machine == 'x86_64' and set(p['artifacts']) == {'domain', 'contracts'}, 'fixed Linux root qualification')
root = Path('/var/lib/rmm-windows-eventlog-contracts')
def safe(path, directory):
s = path.lstat()
require(s.st_uid == 0 and stat.S_IMODE(s.st_mode) == (0o700 if directory else 0o600)
and (stat.S_ISDIR(s.st_mode) if directory else stat.S_ISREG(s.st_mode) and s.st_nlink == 1), 'private fixed unit path')
def write(path, value):
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'w') as out: json.dump(value, out); out.flush(); os.fsync(out.fileno())
os.umask(0o077)
case = root / ident
if p['action'] == 'read' and not case.exists(): return dict(id=ident, status='remote_case_absent')
if p['action'] == 'prepare':
if not root.exists(): root.mkdir(mode=0o700)
safe(root, True); case.mkdir(mode=0o700); write(case / 'intent.json', p)
return dict(id=ident, prepared=True)
safe(root, True); safe(case, True); safe(case / 'intent.json', False)
original = json.loads((case / 'intent.json').read_bytes())
require({k: v for k, v in p.items() if k != 'action'} == {k: v for k, v in original.items() if k != 'action'}, 'original complete unit intent')
if p['action'] == 'read':
if not (case / 'result.json').exists(): return dict(id=ident, status='started_without_result' if (case / 'started.json').exists() else 'prepared_without_start')
safe(case / 'result.json', False); return json.loads((case / 'result.json').read_bytes())
write(case / 'started.json', dict(manifest_sha256=p['manifest_sha256'], execute_once=True))
temp = case / 'tmp'; temp.mkdir(mode=0o700)
env = {'PATH': '/usr/bin:/bin', 'LANG': 'C.UTF-8', 'LC_ALL': 'C.UTF-8', 'TMPDIR': str(temp), 'RUST_BACKTRACE': '0'}
def limits():
resource.setrlimit(resource.RLIMIT_CORE, (0, 0)); resource.setrlimit(resource.RLIMIT_CPU, (15, 15)); resource.setrlimit(resource.RLIMIT_FSIZE, (1048576, 1048576))
require(subprocess.run(['/usr/bin/unshare', '--net', '--', '/usr/bin/true'], env=env, capture_output=True, timeout=3).returncode == 0, 'network namespace required')
listings = {}
for kind in ('domain', 'contracts'):
binary = case / kind; safe(binary, False)
require(hashlib.sha256(binary.read_bytes()).hexdigest() == p['artifacts'][kind]['sha256'], 'exact Linux delivery')
binary.chmod(0o500)
listed = subprocess.run(['/usr/bin/unshare', '--net', '--', str(binary), '--list', '--format', 'terse'], cwd=case, env=env, capture_output=True, timeout=5, preexec_fn=limits)
require(listed.returncode == 0 and len(listed.stdout) <= 65536 and len(listed.stderr) <= 65536, 'bounded actual listing')
actual = sorted(line[:-6] for line in listed.stdout.decode().splitlines() if line.endswith(': test'))
require(all(not line.strip() or __import__('re').fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in listed.stdout.decode().splitlines())
and actual == p['names'][kind] and len(actual) == {'domain': 17, 'contracts': 7}[kind], 'exact native test names before ANY test execution')
listings[kind] = actual
reports = {}
for kind in ('domain', 'contracts'):
with (case / (kind + '-stdout.bin')).open('xb') as out, (case / (kind + '-stderr.bin')).open('xb') as err:
timed = False
try: code = subprocess.run(['/usr/bin/unshare', '--net', '--', str(case / kind), '--test-threads=1'], cwd=case, env=env,
stdin=subprocess.DEVNULL, stdout=out, stderr=err, timeout=18, preexec_fn=limits).returncode
except subprocess.TimeoutExpired: timed = True; code = None
out.flush(); err.flush(); os.fsync(out.fileno()); os.fsync(err.fileno())
raw, errors = [(case / (kind + '-' + stream + '.bin')).read_bytes() for stream in ('stdout', 'stderr')]
require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded native output')
reports[kind] = dict(sha256=p['artifacts'][kind]['sha256'], names=listings[kind], exit_code=code, timed_out=timed,
stdout_b64=base64.b64encode(raw).decode(), stderr_b64=base64.b64encode(errors).decode())
write(case / (kind + '-result.json'), reports[kind])
value = dict(id=ident, platform='linux', profile=p['profile'], manifest_sha256=p['manifest_sha256'], runner_sha256=p['runner_sha256'],
scripts=p['scripts'], reports=reports, network_namespace=True, environment_cleared=True, product_state_writes=False, rmm_jobs=False)
write(case / 'result.json', value); return value
WINDOWS = r'''
$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
if([string]([guid]$p.id)-cne$p.id-or$p.action-notin@('prepare','run','read')-or$p.profile-cne'windows-eventlog-contracts-v1'-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'-or$p.linux_proof_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed Linux-first profile case'}
$root='C:\ProgramData\RustDiscoveryBootstrap';$case=Join-Path $root ('windows-eventlog-contracts-'+$p.id)
function Safe($path,$dir){$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Unit path type'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Private unit owner'};$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty private ACL'};foreach($e in $rules){if($e.AccessControlType-ne'Allow'-or$e.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')-or($e.PropagationFlags-band[Security.AccessControl.PropagationFlags]::InheritOnly)){throw 'Broad private unit ACL'}}}
function WriteNew($path,$value){$f=[IO.File]::Open($path,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read);try{$b=[Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 16 -Compress));$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
function MatchIntent($old){if($old.id-cne$p.id-or$old.profile-cne$p.profile-or$old.manifest_sha256-cne$p.manifest_sha256-or$old.runner_sha256-cne$p.runner_sha256-or$old.linux_proof_sha256-cne$p.linux_proof_sha256-or$old.scripts.linux_case_sha256-cne$p.scripts.linux_case_sha256-or$old.scripts.windows_script_sha256-cne$p.scripts.windows_script_sha256){throw 'Original profile intent'};foreach($kind in @('domain','contracts')){if($old.artifacts.$kind.sha256-cne$p.artifacts.$kind.sha256-or$old.artifacts.$kind.bytes-ne$p.artifacts.$kind.bytes-or(@($old.names.$kind)-join"`n")-cne(@($p.names.$kind)-join"`n")){throw 'Original artifact/test tuple'}}}
if($p.action-eq'read'-and!(Test-Path -LiteralPath $case)){@{id=$p.id;status='remote_case_absent'}|ConvertTo-Json -Compress;exit 0}
Safe $root $true
if($p.action-eq'prepare'){if(Test-Path -LiteralPath $case){throw 'Existing case retained'};New-Item -ItemType Directory -Path $case|Out-Null;Safe $case $true;WriteNew (Join-Path $case 'intent.json') $p;@{id=$p.id;prepared=$true}|ConvertTo-Json -Compress;exit 0}
Safe $case $true;$intent=Join-Path $case 'intent.json';Safe $intent $false;MatchIntent (Get-Content -LiteralPath $intent -Raw|ConvertFrom-Json)
if($p.action-eq'read'){$result=Join-Path $case 'result.json';if(!(Test-Path -LiteralPath $result)){$status=if(Test-Path -LiteralPath (Join-Path $case 'started.json')){'started_without_result'}else{'prepared_without_start'};@{id=$p.id;status=$status}|ConvertTo-Json -Compress;exit 0};Safe $result $false;Get-Content -LiteralPath $result -Raw;exit 0}
function RunUnit($exe,[string]$arguments){$s=New-Object Diagnostics.ProcessStartInfo;$s.FileName=$exe;$s.Arguments=$arguments;$s.UseShellExecute=$false;$s.CreateNoWindow=$true;$s.WorkingDirectory=$case;$s.RedirectStandardOutput=$true;$s.RedirectStandardError=$true;$systemRoot=$env:WINDIR;$s.EnvironmentVariables.Clear();$s.EnvironmentVariables['SystemRoot']=$systemRoot;$s.EnvironmentVariables['WINDIR']=$systemRoot;$s.EnvironmentVariables['PATH']=$systemRoot+'\System32';$s.EnvironmentVariables['TEMP']=$script:temp;$s.EnvironmentVariables['TMP']=$script:temp;$s.EnvironmentVariables['RUST_BACKTRACE']='0';$c=New-Object Diagnostics.Process;$c.StartInfo=$s;if(!$c.Start()){throw 'Unit start'};try{$o=$c.StandardOutput.ReadToEndAsync();$e=$c.StandardError.ReadToEndAsync();$timed=$false;if(!$c.WaitForExit(18000)){$timed=$true;$c.Kill();if(!$c.WaitForExit(2000)){throw 'Own unit process did not exit'}};if(!$o.Wait(2000)-or!$e.Wait(2000)-or$o.Result.Length-gt1048576-or$e.Result.Length-gt1048576){throw 'Bounded unit output'};return @{exit_code=$c.ExitCode;timed_out=$timed;stdout_b64=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($o.Result));stderr_b64=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($e.Result))}}finally{$c.Dispose()}}
WriteNew (Join-Path $case 'started.json') @{execute_once=$true;manifest_sha256=$p.manifest_sha256};$script:temp=Join-Path $case 'tmp';New-Item -ItemType Directory -Path $script:temp|Out-Null;Safe $script:temp $true
$lists=@{};$executables=@{}
foreach($kind in @('domain','contracts')){$item=$p.artifacts.$kind;if($item.sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed unit hash'};$exe=Join-Path $case ($kind+'.exe');Safe $exe $false;if((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()-cne$item.sha256-or(Get-Item -LiteralPath $exe).Length-ne$item.bytes){throw 'Exact unit bytes'};$list=RunUnit $exe '--list --format terse';if($list.exit_code-ne0-or$list.timed_out){throw 'Actual Windows listing'};$text=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($list.stdout_b64));$unexpected=@($text-split'\r?\n'|Where-Object{$_.Trim()-and$_-notmatch'^[A-Za-z0-9_:]+: test$'});if($unexpected.Count){throw 'Only exact terse test entries'};$actual=@($text-split'\r?\n'|Where-Object{$_-match': test$'}|ForEach-Object{$_-replace': test$',''}|Sort-Object);$count=if($kind-eq'domain'){17}else{6};if($actual.Count-ne$count-or($actual-join"`n")-cne(@($p.names.$kind)-join"`n")){throw 'All exact names BEFORE any tests'};$lists[$kind]=$actual;$executables[$kind]=$exe}
$reports=@{};foreach($kind in @('domain','contracts')){$value=RunUnit $executables[$kind] '--test-threads=1';$value.sha256=$p.artifacts.$kind.sha256;$value.names=$lists[$kind];WriteNew (Join-Path $case ($kind+'-result.json')) $value;$reports[$kind]=$value}
$value=@{id=$p.id;platform='windows';profile=$p.profile;manifest_sha256=$p.manifest_sha256;runner_sha256=$p.runner_sha256;scripts=$p.scripts;linux_proof_sha256=$p.linux_proof_sha256;reports=$reports;bootstrap_administrator_units=$true;local_service_proof=$false;environment_cleared=$true;product_state_writes=$false;rmm_jobs=$false};WriteNew (Join-Path $case 'result.json') $value;$value|ConvertTo-Json -Depth 16 -Compress
'''
def check_result(manifest, platform, value, payload):
require(value.get('id') == payload['id'] and value.get('platform') == platform and value.get('profile') == PROFILE
and value.get('manifest_sha256') == payload['manifest_sha256'] and value.get('runner_sha256') == manifest['runner_sha256']
and value.get('scripts') == manifest['scripts'] and value.get('product_state_writes') is False and value.get('rmm_jobs') is False
and value.get('environment_cleared') is True and set(value['reports']) == set(KINDS), 'complete native original binding')
if platform == 'linux': require(value.get('network_namespace') is True, 'actual Linux netns proof')
else: require(value.get('linux_proof_sha256') == payload['linux_proof_sha256'] and value.get('local_service_proof') is False, 'original Linux proof and honest account scope')
for kind, item in value['reports'].items():
require(item['names'] == EXPECTED[platform][kind] and item['sha256'] == manifest['artifacts'][platform][kind]['sha256']
and item['exit_code'] == 0 and item['timed_out'] is False, 'all native exact test names/artifacts/exits')
raw = base64.b64decode(item['stdout_b64'], validate=True); errors = base64.b64decode(item['stderr_b64'], validate=True)
require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded native outputs')
check_output(raw, COUNTS[platform][kind])
def execute(path, platform, access_root, case_id=None):
setup_state(); path = path.absolute(); manifest = verified(path, new_run=case_id is None)
prefix = access_settings(access_root, platform)
if case_id is None:
case_id = str(uuid.uuid4()); folder = STATE / case_id; folder.mkdir(mode=0o700)
payload = dict(id=case_id, profile=PROFILE, manifest_sha256=sha(path), runner_sha256=manifest['runner_sha256'], scripts=manifest['scripts'],
artifacts={kind: {k: manifest['artifacts'][platform][kind][k] for k in ('sha256', 'bytes')} for kind in KINDS}, names=EXPECTED[platform])
if platform == 'windows':
proof_path = path.parent / 'linux-passed.json'; proof = load(proof_path)
require(proof['verified'] is True and proof['manifest_sha256'] == sha(path), 'same-manifest real Linux proof FIRST')
linux_payload = dict(payload, id=proof['case_id'], artifacts={kind: {k: manifest['artifacts']['linux'][kind][k] for k in ('sha256', 'bytes')} for kind in KINDS}, names=EXPECTED['linux'])
check_result(manifest, 'linux', proof['native'], linux_payload)
payload['linux_proof_sha256'] = sha(proof_path)
intent = dict(id=case_id, platform=platform, manifest_path=str(path), manifest_sha256=sha(path), runner_sha256=sha(__file__),
scripts=scripts(), access_root_sha256=hashlib.sha256(str(access_root.absolute()).encode()).hexdigest(), payload=payload)
save(folder / 'intent.json', intent)
save(folder / 'started-local.json', dict(create_once=True, no_retry=True))
run_read = False
else:
require(str(uuid.UUID(case_id)) == case_id, 'original canonical case id')
folder = STATE / case_id; private(folder, True); intent = load(folder / 'intent.json'); load(folder / 'started-local.json')
require(intent['id'] == case_id and intent['platform'] == platform and intent['manifest_path'] == str(path)
and intent['manifest_sha256'] == sha(path) and intent['runner_sha256'] == sha(__file__) and intent['scripts'] == scripts()
and intent['access_root_sha256'] == hashlib.sha256(str(access_root.absolute()).encode()).hexdigest(), 'immutable same-case readback')
payload = intent['payload']; run_read = True
rpc = linux_rpc if platform == 'linux' else windows_rpc
if not run_read:
result = rpc(prefix, dict(payload, action='prepare'), folder)
save(folder / 'prepared-remote.json', result); require(result == dict(id=case_id, prepared=True), 'fresh fixed case prepared')
for kind in KINDS:
destination = LINUX_REMOTE + '/' + case_id + '/' + kind if platform == 'linux' else '/C:/ProgramData/RustDiscoveryBootstrap/windows-eventlog-contracts-' + case_id + '/' + kind + '.exe'
upload(prefix, manifest['artifacts'][platform][kind], destination, folder, kind)
result = rpc(prefix, dict(payload, action='read' if run_read else 'run'), folder)
save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), result)
if result.get('status'):
require(run_read and result.get('id') == case_id and result['status'] in ('remote_case_absent', 'prepared_without_start', 'started_without_result'), 'fixed read-only incomplete status')
print(json.dumps(dict(verified=False, platform=platform, case_id=case_id, status=result['status'], retry_allowed=False))); return
check_result(manifest, platform, result, payload)
proof = dict(verified=True, case_id=case_id, platform=platform, manifest_sha256=sha(path), runner_sha256=manifest['runner_sha256'], native=result)
destination = path.parent / (platform + '-passed.json')
if destination.exists(): require(load(destination) == proof, 'preserve identical native proof')
else: save(destination, proof)
save(folder / 'verified.json', dict(verified=True, proof_sha256=sha(destination))) if not (folder / 'verified.json').exists() else require(load(folder / 'verified.json') == dict(verified=True, proof_sha256=sha(destination)), 'same verified receipt')
print(json.dumps(dict(verified=True, platform=platform, case_id=case_id, tests=sum(COUNTS[platform].values()),
manifest_sha256=sha(path), proof_sha256=sha(destination))))
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('build-local', 'linux', 'windows', 'readback-linux', 'readback-windows'))
parser.add_argument('--manifest', type=Path); parser.add_argument('--case'); parser.add_argument('--access-root', type=Path)
parser.add_argument('--execute-native-tests', action='store_true'); args = parser.parse_args()
if args.action == 'build-local':
require(not (args.manifest or args.case or args.access_root or args.execute_native_tests), 'local build only'); build()
elif args.action.startswith('readback-'):
require(args.manifest and args.case and args.access_root and not args.execute_native_tests, 'original case readback only')
execute(args.manifest, args.action.removeprefix('readback-'), args.access_root, args.case)
else:
require(args.manifest and args.access_root and args.execute_native_tests and not args.case, 'explicit new native platform run')
execute(args.manifest, args.action, args.access_root)
if __name__ == '__main__':
try: main()
except Exception as error:
print(json.dumps(dict(error='WINDOWS_EVENTLOG_CONTRACT_QUALIFICATION_INCOMPLETE', error_class=type(error).__name__, details_suppressed=True)))
raise SystemExit(2) from None
+692
View File
@@ -0,0 +1,692 @@
#!/usr/bin/env python3
"""M4 MSI pure common contracts: Linux VM FIRST, then Windows VM.
Only fixed common test executables run in separate bootstrap scratch directories.
No RMM job, daemon, live database, PKI, policy, enrollment or capability change.
Native execution is explicit; any lost reply permits same-case readback only.
"""
import argparse
import base64
import datetime as dt
import hashlib
import inspect
import json
import os
from pathlib import Path
import re
import shlex
import shutil
import stat
import subprocess
import uuid
import vm_access_check as access
ROOT = Path(__file__).resolve().parents[1]
STATE = ROOT / 'devstate/windows-msi-contracts'
IMAGE = 'rust-discovery-durable-final-build:local'
PROFILE = 'windows-msi-contracts-v1'
LINUX_REMOTE = '/var/lib/rmm-windows-msi-contracts'
ACCESS_ROOT = Path('/home/kevin/Schreibtisch/Coding/rust-discovery')
BACKEND = ROOT / 'devstate/windows-msi-integration/local-qualification.json'
BACKEND_SHA = 'b7bced0a341ffb88af8b584cbe8355ff1021add541004347f609f6136a684b74'
# Actual local Linux RELEASE --list was obtained before fixing these lists.
# Windows lists remain EXPECTED until the native Windows process emits them.
REVIEWED_BACKEND = {'crates/domain/src/lib.rs': '7919c099a8b568259b9b197d1742cdc11844523c64654325b6c142ae437dda1f',
'crates/domain/src/jobs.rs': 'ff7f086a28e5e17832fa4afc974ce8395c7887360c3291d27d1cc7ae12bab117',
'crates/domain/src/windows_execution.rs': 'aa2c5916c9d6c9d9ab8e9bd0d1051920fcb2ae9ecf4c18cf6ee89c4668b9b460',
'crates/agent-core/src/auth.rs': '86cda2e10321bcb3591013880f11e53a8bcb01c53521bbcc28d38d6b1f5402bd',
'crates/agent-core/tests/contracts.rs': 'f57fe9b938b8e563229b9da7c77b6df7b419f0ba41ef05abb1f7f9e3ff2e61e9',
'crates/server/src/agent_artifacts.rs': '5f68ea4a26de529d814b7365b85f978ced7715c7da8fa2a435021e3e953b506e',
'crates/server/src/catalog.rs': 'c4c293271a36aba80fac00b72e2936ed2c11bccf49e511d7003bd95574fb0e04',
'crates/server/src/job_gateway.rs': '421672d7a283fcda5bc00854b53eb86c4236621336d5cf6b72c43d288fad74de',
'crates/server/src/jobs.rs': '725a2f9c61180c4d938bcf7383ee78c5d50b83b703665195502548140126fce6',
'crates/server/src/main.rs': 'c8ddc2a1a7cd29122f5590902f25c2711eef6e2f5488e2e7869c034ddf27394e',
'crates/server/src/windows_policy.rs': 'd0ffd67f4f2c56a681c44617962b3834f02cbbc6ba076461b856f4e87ce6c222',
'crates/server/src/windows_msi_catalog.rs': 'dcb704b02a5d5d5bfff5b8e34a712cf5a0b9c32cb21af242252976d0c0b0ad84',
'migrations/0014_windows_msi_catalog.sql': '893440fc75914d4e7e3a62055f693562c6a093924eab77a20f6b5428f63d20d0'}
EXPECTED = {'linux': {'domain': ['apt_transaction::tests::closure_bytes_archives_and_code_are_bound',
'apt_transaction::tests::helper_schema_two_roundtrip_and_strict_action_binding',
'inventory_document::tests::additive_metadata_and_bounds',
'inventory_document::tests::exact_linux_recovery_scope_does_not_admit_other_hyphens_or_windows',
'inventory_document::tests::windows_scope_does_not_weaken_linux_or_accept_platform_spoofing',
'jobs::tests::additive_recipe_refs_preserve_legacy_plan_bytes',
'jobs::tests::codec_golden_and_exact_script_bytes',
'jobs::tests::no_terminal_replay_or_unknown_restart',
'jobs::tests::permit_codec_golden_all_bindings',
'jobs::tests::updates_require_exact_versions_and_never_implicit_reboot',
'jobs::tests::windows_event_log_fixture_scope_limits_and_exact_24h_preserve_linux_bytes',
'jobs::tests::windows_interpreter_and_capability_contract',
'jobs::tests::windows_remote_signed_profile_is_optional_exact_and_capability_bound',
'jobs::tests::windows_system_scm_is_explicit_and_preserves_linux_service_bytes',
'reconciliation::tests::outcome_codec_keeps_raw_output_and_sorts_evidence',
'reconciliation::tests::reconciliation_cannot_be_a_permit_or_unbounded_ticket',
'tests::production_never_accepts_development_auth',
'windows_execution::tests::ensure_msi_action_is_strict_opt_in_and_system_windows_only_without_linux_byte_changes',
'windows_execution::tests::immutable_fixture_recipe_rejects_reboot_url_transform_and_implicit_upgrade',
'windows_execution::tests::major_upgrade_requires_explicit_exact_predecessor_new_package_and_same_family'],
'contracts': ['atomic_begin_execution_rolls_back_both_rows_on_missing_witness_or_start_insert_failure',
'completion_cas_preserves_original_bytes_and_recovers_only_verified_bound_evidence',
'consumed_attempt_and_unknown_lock_survive_reopen_without_reexecution',
'exact_permit_bytes_time_and_all_identity_hash_bindings_are_required',
'historical_msi_nonstart_keeps_full_signature_binding_and_never_becomes_root_authority',
'historical_request_and_binding_codecs_keep_field_order_arrays_and_strictness',
'openssl_and_portable_ed25519_agree_on_current_keys_bytes_and_tampering',
'portable_acceptance_requires_platform_capability_and_exact_redelivery'],
'helper-reconcile': ['abandon_after_expiry_records_deny_only_evidence_and_requires_normal_signed_unlock',
'abandon_preserves_existing_known_unknown_missing_start_and_foreign_request_rows',
'abandon_rejects_wrong_signature_scope_clock_boot_lineage_instance_and_dispatch_proof',
'abandon_storage_failure_rolls_back_consumption_start_and_outcome_together',
'both_live_profiles_apply_one_signature_and_checkpoint_without_inheriting_readiness',
'checkpoint_repair_verifies_complete_signed_history_and_detects_removed_predecessor',
'checkpoint_rollback_is_sticky_and_cannot_be_fixed_by_omission',
'clean_ready_shared_lock_and_reopen_start_closed',
'definitive_unlock_is_transactional_idempotent_and_keeps_tombstones',
'exact_signatures_fake_key_wrong_domain_and_all_identity_bindings',
'false_clock_expiry_and_invalid_independent_key_stay_closed',
'general_and_apt_instances_share_fencing_but_never_inherit_a_process_gate',
'independently_remembered_agent_journal_cannot_be_replaced_by_server_ready',
'malformed_original_protobuf_or_digest_does_not_open_gate',
'missing_signed_checkpoint_history_closes_the_live_gate_stickily',
'mutated_root_ledger_after_capture_is_not_the_signed_snapshot',
'old_process_response_fails_after_fresh_capture_even_inside_ttl',
'omitted_unknown_root_row_is_sticky_despite_signed_ready',
'real_local_boot_must_match_signed_reboot_completion',
'root_and_system_are_distinct_explicit_helper_domains',
'shared_database_only_and_missing_local_start_fail_closed',
'signed_noncanonical_outcome_bytes_do_not_unlock_root_consumption',
'stale_process_connection_does_not_poison_a_new_fenced_process',
'targeted_final_unlock_does_not_release_an_unrelated_unknown',
'unknown_code_or_no_result_never_unlocks_even_signed_ready',
'unrelated_action_plan_and_previous_outcome_cannot_unlock'],
'reconcile': ['accepted_unstarted_keeps_ids_and_never_consumes_or_executes',
'authenticated_helper_outcome_is_imported_as_new_durable_evidence_not_reexecuted',
'clean_reconnect_and_reopen_require_new_signed_challenge',
'crash_after_durable_outcome_before_result_recovers_original_then_signed_sync_closes',
'crash_after_result_commit_before_finish_retains_exact_result_and_local_prior',
'crash_before_running_event_recovers_real_consumption_without_inventing_completion',
'definite_nonstart_result_is_unconsumed_not_ambiguous',
'exact_signatures_all_identity_channel_checkpoint_and_request_bindings',
'final_result_preserves_original_envelope_outputs_and_exact_acks',
'foreign_ack_and_noncanonical_outcome_are_transactionally_rejected',
'helper_gate_requires_exact_signed_instruction_and_applied_checkpoint',
'helper_omitting_a_consumed_root_attempt_is_a_sticky_restore_fault',
'independent_helper_checkpoint_regression_is_sticky',
'independent_local_outcome_mismatch_never_unlocks',
'missing_server_job_fault_is_sticky_even_if_attempt_disappears_later',
'negative_server_revision_never_rolls_back_local_unknown_revision',
'original_completion_after_reconnect_unknown_is_recovered_without_reexecuting',
'reboot_keeps_lock_until_signed_new_authenticated_boot_inventory_evidence',
'requesting_running_and_omitted_attempts_cannot_regain_readiness',
'rollback_and_false_clock_close_mutations_but_do_not_destroy_journal',
'signed_attempt_mutation_or_terminal_regression_is_rejected',
'signed_terminal_nonstart_stays_unconsumed_across_sync_and_pending_denial',
'signed_unlock_still_rejects_a_missing_local_outcome_in_legacy_crash_window',
'system_helper_import_requires_explicit_system_identity_and_never_root_alias',
'terminal_labels_never_override_grant_consumption_or_unclear_attempts',
'uncertain_request_preserves_pending_request_and_last_applied_anchor'],
'linux-helper': ['both_live_profiles_apply_one_signature_and_checkpoint_without_inheriting_readiness',
'checkpoint_repair_verifies_complete_signed_history_and_detects_removed_predecessor',
'checkpoint_rollback_is_sticky_and_cannot_be_fixed_by_omission',
'clean_ready_shared_lock_and_reopen_start_closed',
'definitive_unlock_is_transactional_idempotent_and_keeps_tombstones',
'exact_signatures_fake_key_wrong_domain_and_all_identity_bindings',
'false_clock_expiry_and_invalid_independent_key_stay_closed',
'general_and_apt_instances_share_fencing_but_never_inherit_a_process_gate',
'independently_remembered_agent_journal_cannot_be_replaced_by_server_ready',
'malformed_original_protobuf_or_digest_does_not_open_gate',
'missing_signed_checkpoint_history_closes_the_live_gate_stickily',
'mutated_root_ledger_after_capture_is_not_the_signed_snapshot',
'old_process_response_fails_after_fresh_capture_even_inside_ttl',
'omitted_unknown_root_row_is_sticky_despite_signed_ready',
'real_local_boot_must_match_signed_reboot_completion',
'shared_database_only_and_missing_local_start_fail_closed',
'signed_noncanonical_outcome_bytes_do_not_unlock_root_consumption',
'stale_process_connection_does_not_poison_a_new_fenced_process',
'targeted_final_unlock_does_not_release_an_unrelated_unknown',
'unknown_code_or_no_result_never_unlocks_even_signed_ready',
'unrelated_action_plan_and_previous_outcome_cannot_unlock']},
'windows': {'domain': ['apt_transaction::tests::closure_bytes_archives_and_code_are_bound',
'apt_transaction::tests::helper_schema_two_roundtrip_and_strict_action_binding',
'inventory_document::tests::additive_metadata_and_bounds',
'inventory_document::tests::exact_linux_recovery_scope_does_not_admit_other_hyphens_or_windows',
'inventory_document::tests::windows_scope_does_not_weaken_linux_or_accept_platform_spoofing',
'jobs::tests::additive_recipe_refs_preserve_legacy_plan_bytes',
'jobs::tests::codec_golden_and_exact_script_bytes',
'jobs::tests::no_terminal_replay_or_unknown_restart',
'jobs::tests::permit_codec_golden_all_bindings',
'jobs::tests::updates_require_exact_versions_and_never_implicit_reboot',
'jobs::tests::windows_event_log_fixture_scope_limits_and_exact_24h_preserve_linux_bytes',
'jobs::tests::windows_interpreter_and_capability_contract',
'jobs::tests::windows_remote_signed_profile_is_optional_exact_and_capability_bound',
'jobs::tests::windows_system_scm_is_explicit_and_preserves_linux_service_bytes',
'reconciliation::tests::outcome_codec_keeps_raw_output_and_sorts_evidence',
'reconciliation::tests::reconciliation_cannot_be_a_permit_or_unbounded_ticket',
'tests::production_never_accepts_development_auth',
'windows_execution::tests::ensure_msi_action_is_strict_opt_in_and_system_windows_only_without_linux_byte_changes',
'windows_execution::tests::immutable_fixture_recipe_rejects_reboot_url_transform_and_implicit_upgrade',
'windows_execution::tests::major_upgrade_requires_explicit_exact_predecessor_new_package_and_same_family'],
'contracts': ['atomic_begin_execution_rolls_back_both_rows_on_missing_witness_or_start_insert_failure',
'completion_cas_preserves_original_bytes_and_recovers_only_verified_bound_evidence',
'consumed_attempt_and_unknown_lock_survive_reopen_without_reexecution',
'exact_permit_bytes_time_and_all_identity_hash_bindings_are_required',
'historical_msi_nonstart_keeps_full_signature_binding_and_never_becomes_root_authority',
'historical_request_and_binding_codecs_keep_field_order_arrays_and_strictness',
'portable_acceptance_requires_platform_capability_and_exact_redelivery'],
'helper-reconcile': ['abandon_after_expiry_records_deny_only_evidence_and_requires_normal_signed_unlock',
'abandon_preserves_existing_known_unknown_missing_start_and_foreign_request_rows',
'abandon_rejects_wrong_signature_scope_clock_boot_lineage_instance_and_dispatch_proof',
'abandon_storage_failure_rolls_back_consumption_start_and_outcome_together',
'both_live_profiles_apply_one_signature_and_checkpoint_without_inheriting_readiness',
'checkpoint_repair_verifies_complete_signed_history_and_detects_removed_predecessor',
'checkpoint_rollback_is_sticky_and_cannot_be_fixed_by_omission',
'clean_ready_shared_lock_and_reopen_start_closed',
'definitive_unlock_is_transactional_idempotent_and_keeps_tombstones',
'exact_signatures_fake_key_wrong_domain_and_all_identity_bindings',
'false_clock_expiry_and_invalid_independent_key_stay_closed',
'general_and_apt_instances_share_fencing_but_never_inherit_a_process_gate',
'independently_remembered_agent_journal_cannot_be_replaced_by_server_ready',
'malformed_original_protobuf_or_digest_does_not_open_gate',
'missing_signed_checkpoint_history_closes_the_live_gate_stickily',
'mutated_root_ledger_after_capture_is_not_the_signed_snapshot',
'old_process_response_fails_after_fresh_capture_even_inside_ttl',
'omitted_unknown_root_row_is_sticky_despite_signed_ready',
'real_local_boot_must_match_signed_reboot_completion',
'root_and_system_are_distinct_explicit_helper_domains',
'shared_database_only_and_missing_local_start_fail_closed',
'signed_noncanonical_outcome_bytes_do_not_unlock_root_consumption',
'stale_process_connection_does_not_poison_a_new_fenced_process',
'targeted_final_unlock_does_not_release_an_unrelated_unknown',
'unknown_code_or_no_result_never_unlocks_even_signed_ready',
'unrelated_action_plan_and_previous_outcome_cannot_unlock'],
'reconcile': ['accepted_unstarted_keeps_ids_and_never_consumes_or_executes',
'authenticated_helper_outcome_is_imported_as_new_durable_evidence_not_reexecuted',
'clean_reconnect_and_reopen_require_new_signed_challenge',
'crash_after_durable_outcome_before_result_recovers_original_then_signed_sync_closes',
'crash_after_result_commit_before_finish_retains_exact_result_and_local_prior',
'crash_before_running_event_recovers_real_consumption_without_inventing_completion',
'definite_nonstart_result_is_unconsumed_not_ambiguous',
'exact_signatures_all_identity_channel_checkpoint_and_request_bindings',
'final_result_preserves_original_envelope_outputs_and_exact_acks',
'foreign_ack_and_noncanonical_outcome_are_transactionally_rejected',
'helper_gate_requires_exact_signed_instruction_and_applied_checkpoint',
'helper_omitting_a_consumed_root_attempt_is_a_sticky_restore_fault',
'independent_helper_checkpoint_regression_is_sticky',
'independent_local_outcome_mismatch_never_unlocks',
'missing_server_job_fault_is_sticky_even_if_attempt_disappears_later',
'negative_server_revision_never_rolls_back_local_unknown_revision',
'original_completion_after_reconnect_unknown_is_recovered_without_reexecuting',
'reboot_keeps_lock_until_signed_new_authenticated_boot_inventory_evidence',
'requesting_running_and_omitted_attempts_cannot_regain_readiness',
'rollback_and_false_clock_close_mutations_but_do_not_destroy_journal',
'signed_attempt_mutation_or_terminal_regression_is_rejected',
'signed_terminal_nonstart_stays_unconsumed_across_sync_and_pending_denial',
'signed_unlock_still_rejects_a_missing_local_outcome_in_legacy_crash_window',
'system_helper_import_requires_explicit_system_identity_and_never_root_alias',
'terminal_labels_never_override_grant_consumption_or_unclear_attempts',
'uncertain_request_preserves_pending_request_and_last_applied_anchor']}}
COUNTS = {platform: {kind: len(names) for kind, names in lists.items()} for platform, lists in EXPECTED.items()}
KINDS = {'linux': ('domain','contracts','helper-reconcile','reconcile','linux-helper'),
'windows': ('domain','contracts','helper-reconcile','reconcile')}
def require(value, code):
if not value:
raise RuntimeError(code)
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def object_pairs(items):
value = {}
for key, item in items:
require(key not in value, 'duplicate JSON field')
value[key] = item
return value
def private(path, directory=False):
item = Path(path).lstat()
require(not stat.S_ISLNK(item.st_mode) and item.st_uid == os.getuid()
and stat.S_IMODE(item.st_mode) == (0o700 if directory else 0o600)
and (stat.S_ISDIR(item.st_mode) if directory else stat.S_ISREG(item.st_mode) and item.st_nlink == 1),
'private owned regular path')
def load(path):
private(path)
require(Path(path).stat().st_size <= 2 * 1024 * 1024, 'bounded private JSON')
return json.loads(Path(path).read_bytes(), object_pairs_hook=object_pairs)
def save(path, value):
private(Path(path).parent, True)
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600)
with os.fdopen(fd, 'w') as stream:
json.dump(value, stream, indent=2); stream.write('\n'); stream.flush(); os.fsync(stream.fileno())
def setup_state():
os.umask(0o077)
STATE.parent.mkdir(mode=0o700, exist_ok=True)
metadata = STATE.parent.lstat()
require(stat.S_ISDIR(metadata.st_mode) and metadata.st_uid == os.getuid() and not metadata.st_mode & 0o002,
'owned non-world-writable devstate parent')
STATE.mkdir(mode=0o700, exist_ok=True)
private(STATE, True)
def source_files():
require(sha(BACKEND) == BACKEND_SHA, 'exact reviewed local backend qualification')
reviewed = load(BACKEND)
require(reviewed['source_files'] == REVIEWED_BACKEND, 'reviewed thirteen backend/common pins')
names = {'Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml', 'deploy/windows_msi_contract_acceptance.py',
'deploy/vm_access_check.py', 'deploy/vm_mvp_acceptance.py', 'deploy/remote_client_bootstrap.py',
'deploy/windows/client_bootstrap.py', 'tools/apt-transaction/apt_transaction.py',
'tools/apt-transaction/hook', 'deploy/linux/rmm-apt-helper.service',
'tests/apt_transaction/fixtures/planning-canonical.json'}
names.update(str(p.relative_to(ROOT)) for p in (ROOT / 'crates').glob('*/Cargo.toml'))
for crate in ('domain', 'agent-core', 'agent-linux', 'privileged-helper', 'protocol'):
names.update(str(p.relative_to(ROOT)) for p in (ROOT / 'crates' / crate).rglob('*')
if p.is_file() and p.suffix in ('.rs', '.toml', '.c', '.h', '.idl', '.proto'))
names.update(str(p.relative_to(ROOT)) for p in (ROOT / 'proto').rglob('*') if p.is_file())
names.update(REVIEWED_BACKEND)
for name in names: require((ROOT / name).is_file() and not (ROOT / name).is_symlink(), 'regular fixed source inputs')
result = {name: sha(ROOT / name) for name in sorted(names)}
require(all(result[name] == digest for name, digest in REVIEWED_BACKEND.items()), 'reviewed backend sources unchanged')
# No web source is a compiler input or part of this common-contract proof.
return result
def names(raw):
return sorted(re.findall(r'^([A-Za-z0-9_:]+): test\r?$', raw, re.M))
def check_list(raw, expected):
require(names(raw) == expected and len(set(expected)) == len(expected), 'all exact test names before execution')
require(all(not line.strip() or re.fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in raw.splitlines()),
'terse list contains only exact tests, no benchmarks or extra entries')
def check_output(raw, count):
require(re.search(rb'^test result: ok\. ' + str(count).encode()
+ rb' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;[^\r\n]*\r?$', raw, re.M),
'all tests passed without skipped or filtered tests')
def command(args, folder, timeout=300):
index = len(list(folder.glob('command-*.json')))
try:
done = subprocess.run(args, capture_output=True, timeout=timeout)
save(folder / ('command-%03d.json' % index), dict(returncode=done.returncode,
stdout_b64=base64.b64encode(done.stdout).decode(), stderr_b64=base64.b64encode(done.stderr).decode()))
require(done.returncode == 0, 'local qualification command failed; private output retained')
return done.stdout
except subprocess.TimeoutExpired as error:
save(folder / ('command-%03d.json' % index), dict(timed_out=True,
stdout_b64=base64.b64encode(error.stdout or b'').decode(), stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('local qualification timed out; no automatic retry') from None
def scripts():
return {'linux_case_sha256': hashlib.sha256(inspect.getsource(linux_case).encode()).hexdigest(),
'windows_script_sha256': hashlib.sha256(WINDOWS.encode()).hexdigest()}
def build():
setup_state()
folder = STATE / ('build-' + str(uuid.uuid4())); folder.mkdir(mode=0o700)
before = source_files(); save(folder / 'source-before.json', before)
image = command(['docker', 'image', 'inspect', '--format', '{{.Id}}', IMAGE], folder).decode().strip()
require(re.fullmatch(r'sha256:[a-f0-9]{64}', image), 'immutable compiler image')
target = STATE / 'target'; target.mkdir(mode=0o700, exist_ok=True); private(target, True)
common = ['docker','run','--rm','--network','none','--read-only','--tmpfs','/tmp:rw,size=512m',
'-v',str(ROOT)+':/src:ro','-v',str(target)+':/target','-e','CARGO_TARGET_DIR=/target','--entrypoint','cargo',image]
artifacts = {'linux': {}, 'windows': {}}
for platform, triple in [('linux','x86_64-unknown-linux-gnu'),('windows','x86_64-pc-windows-gnu')]:
options = ['--manifest-path','/src/Cargo.toml','--locked','--offline','--target',triple]
packages = ['-p','rmm-domain','-p','rmm-agent-core'] + (['-p','rmm-privileged-helper'] if platform == 'linux' else [])
command(common + ['clippy'] + options + packages + ['--all-targets','--','-D','warnings'], folder)
selections = [(['-p','rmm-domain','--lib'], 'domain'),
(['-p','rmm-agent-core'] + (['--features','openssl-verifier'] if platform == 'linux' else []) + ['--tests'], 'core')]
if platform == 'linux': selections.append((['-p','rmm-privileged-helper','--test','reconcile'], 'linux-helper'))
links = {}
for selection, group in selections:
raw = command(common + ['test'] + options + selection + ['--release','--no-run','--message-format=json'], folder)
for line in raw.splitlines():
try: item = json.loads(line)
except ValueError: continue
if item.get('reason') != 'compiler-artifact' or not item.get('executable') or not item.get('profile',{}).get('test'): continue
name = item['target']['name']
kind = 'domain' if group == 'domain' else 'linux-helper' if group == 'linux-helper' else {'contracts':'contracts','helper_reconcile':'helper-reconcile','reconcile':'reconcile'}.get(name)
if kind is None: continue # empty Core lib harness is not this profile
require(kind not in links and kind in KINDS[platform], 'exact distinct selected test link')
links[kind] = target / Path(item['executable']).relative_to('/target')
require(set(links) == set(KINDS[platform]), 'all selected native artifacts')
destination = folder / platform; destination.mkdir(mode=0o700)
for kind in KINDS[platform]:
original = destination / (kind + '.linked'); delivery = destination / (kind + ('.exe' if platform == 'windows' else ''))
for path in (original, delivery): shutil.copyfile(links[kind], path); path.chmod(0o600)
linked_sha = sha(original)
tool = 'x86_64-w64-mingw32-strip' if platform == 'windows' else 'strip'
command(['docker','run','--rm','--network','none','--read-only','-v',str(destination)+':/artifacts',
'--entrypoint',tool,image,'--strip-debug','/artifacts/'+delivery.name], folder)
require(sha(links[kind]) == sha(original) == linked_sha, 'original link preserved')
data = delivery.read_bytes()
if platform == 'linux': require(data[:6] == b'\x7fELF\x02\x01' and data[18:20] == b'\x3e\0', 'Linux x64 ELF')
else:
offset = int.from_bytes(data[60:64],'little'); require(data[:2] == b'MZ' and data[offset:offset+6] == b'PE\0\0\x64\x86', 'Windows x64 PE')
artifacts[platform][kind] = dict(path=str(delivery),sha256=sha(delivery),bytes=len(data),
original_link_path=str(original),original_link_sha256=linked_sha,debug_stripped_delivery=True)
# All local Linux lists precede any local tests, using exact delivery bytes.
def invoke(item, args):
script = 'import shutil,os,subprocess;shutil.copyfile("/unit","/tmp/unit");os.chmod("/tmp/unit",0o500);subprocess.run(["/tmp/unit"]+' + repr(args) + ',check=True,cwd="/tmp",env={"PATH":"/usr/bin:/bin","LANG":"C.UTF-8","TMPDIR":"/tmp","RUST_BACKTRACE":"0"})'
return command(['docker','run','--rm','--network','none','--read-only','--tmpfs','/tmp:rw,exec,size=128m',
'-v',item['path']+':/unit:ro','--entrypoint','python3',image,'-c',script], folder)
for kind, item in artifacts['linux'].items():
raw = invoke(item, ['--list','--format','terse']); check_list(raw.decode(), EXPECTED['linux'][kind])
save(folder / ('local-linux-'+kind+'-list.json'),dict(stdout_b64=base64.b64encode(raw).decode()))
for kind, item in artifacts['linux'].items():
raw = invoke(item, ['--test-threads=1']); check_output(raw, COUNTS['linux'][kind])
save(folder / ('local-linux-'+kind+'-run.json'),dict(stdout_b64=base64.b64encode(raw).decode()))
versions = command(['docker','run','--rm','--network','none','--read-only','-v',item['path']+':/unit:ro',
'--entrypoint','readelf',image,'--version-info','/unit'],folder).decode()
dynamic = command(['docker','run','--rm','--network','none','--read-only','-v',item['path']+':/unit:ro',
'--entrypoint','readelf',image,'-d','/unit'],folder).decode()
glibc = sorted(set(re.findall(r'GLIBC_(\d+\.\d+)',versions)),key=lambda n:tuple(map(int,n.split('.'))))
require(glibc and tuple(map(int,glibc[-1].split('.'))) <= (2,34), 'GLIBC at most 2.34 delivery requirement')
item['glibc_max'] = glibc[-1]; item['needed'] = sorted(re.findall(r'Shared library: \[([^\]]+)\]',dynamic))
require(source_files() == before, 'all sources and backend pins unchanged through build')
manifest = dict(schema_version=1,profile=PROFILE,source_files=before,source_before_after_equal=True,
reviewed_backend_source_pins=REVIEWED_BACKEND,backend_qualification_sha256=BACKEND_SHA,
backend_sources_hash_bound_only=True,native_postgresql_executed=False,live_installer_executed=False,
runner_sha256=sha(__file__),scripts=scripts(),test_names=EXPECTED,test_counts=COUNTS,artifacts=artifacts,
build_image_id=image,both_targets_clippy_D_warnings=True,linux_lists_actual=True,
windows_lists_expected_until_native=True,local_linux_tests_passed=sum(COUNTS['linux'].values()),
native_linux_executed=False,native_windows_executed=False,product_state_writes=False,rmm_jobs=False)
save(folder / 'manifest.json',manifest)
print(json.dumps(dict(manifest=str(folder/'manifest.json'),manifest_sha256=sha(folder/'manifest.json'),
linux_tests=sum(COUNTS['linux'].values()),windows_tests_expected=sum(COUNTS['windows'].values()),native_executed=False)))
def verified(path, new_run):
path = path.absolute(); private(path.parent, True)
require(path.name == 'manifest.json' and path.parent.parent == STATE and re.fullmatch(r'build-[0-9a-f-]{36}', path.parent.name), 'fixed build manifest path')
value = load(path)
require(value['schema_version'] == 1 and value['profile'] == PROFILE and value['runner_sha256'] == sha(__file__)
and value['scripts'] == scripts() and value['test_names'] == EXPECTED and value['test_counts'] == COUNTS
and value['source_before_after_equal'] is True and value['both_targets_clippy_D_warnings'] is True
and value['reviewed_backend_source_pins'] == REVIEWED_BACKEND and value['backend_qualification_sha256'] == BACKEND_SHA
and value['backend_sources_hash_bound_only'] is True and value['native_postgresql_executed'] is False
and value['live_installer_executed'] is False,
'original manifest/runner/remote scripts/profile binding')
if new_run: require(value['source_files'] == source_files(), 'new execution requires same current qualified source')
for platform in COUNTS:
require(set(value['artifacts'][platform]) == set(KINDS[platform]), 'all exact fixed artifacts')
for kind, item in value['artifacts'][platform].items():
suffix = '.exe' if platform == 'windows' else ''
require(Path(item['path']) == path.parent / platform / (kind + suffix)
and Path(item['original_link_path']) == path.parent / platform / (kind + '.linked'), 'fixed private artifact paths')
for field, digest in [('path', item['sha256']), ('original_link_path', item['original_link_sha256'])]:
private(item[field]); require(sha(item[field]) == digest, 'immutable original/delivery bytes')
require(Path(item['path']).stat().st_size == item['bytes'], 'artifact size unchanged')
return value
def access_settings(root, platform):
"""Read strictly parsed existing access only when the parent executes native."""
require(root == ACCESS_ROOT and not root.is_symlink(), 'original Main access-root only; no copied credentials')
root = root.absolute(); require(root.is_dir() and root.resolve() == root, 'canonical access-root')
if platform == 'linux':
cfg = access.load_config(root / 'credentials/linux-vm.conf')
require(cfg['address'] == '116.203.20.85' and cfg['username'] == 'root' and cfg.get('port', '22') == '22'
and cfg.get('ssh_key_path'), 'fixed Cloud Linux bootstrap target')
prefix = ['ssh', '-F', '/dev/null', '-T', '-p', '22', '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', '-i', str(Path(cfg['ssh_key_path']).expanduser()), 'root@116.203.20.85']
else:
cfg = access.load_config(root / 'credentials/server.conf')
require(cfg['address'] == '88.99.80.202' and cfg['username'] == 'root' and cfg.get('port', '22') == '22'
and cfg.get('ssh_key_path'), 'fixed server reverse-jump only')
credentials = root / 'credentials'; private(credentials, True)
record = load(credentials / 'windows-dev-access.json')
require(set(record) == {'ssh_prefix', 'expires_at'}, 'known Windows access schema')
expires = dt.datetime.fromisoformat(record['expires_at'])
require(expires.utcoffset() is not None and dt.datetime.now(dt.timezone.utc) < expires, 'existing dev access still valid')
key = str(Path(cfg['ssh_key_path']).expanduser())
jump = ['ssh', '-F', '/dev/null', '-T', '-p', '22', '-i', key, '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'ForwardAgent=no', '-o', 'IdentitiesOnly=yes', '-W', '127.0.0.1:22240', 'root@88.99.80.202']
prefix = ['ssh', '-F', '/dev/null', '-T', '-i', key, '-o', 'ProxyCommand=' + shlex.join(jump),
'-o', 'HostKeyAlias=rmm-windows-dev', '-o', 'UserKnownHostsFile=' + str(credentials / 'windows-dev.known_hosts'),
'-o', 'GlobalKnownHostsFile=/dev/null', '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', 'rmm-dev@127.0.0.1']
require(record['ssh_prefix'] == prefix, 'exact registered pinned reverse SSH prefix')
private(credentials / 'windows-dev.known_hosts')
return prefix
def transport(prefix, command_text, data, folder, timeout=60):
"""No stdout/stderr escapes the private case directory on transport failure."""
try:
result = subprocess.run(prefix + [command_text], input=data, capture_output=True, timeout=timeout)
save(folder / ('transport-' + str(uuid.uuid4()) + '.json'), dict(returncode=result.returncode,
stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode()))
require(result.returncode == 0, 'native transport incomplete; same-case readback only')
value = json.loads(result.stdout.decode('utf-8-sig'), object_pairs_hook=object_pairs)
require(isinstance(value, dict) and 'bootstrap_error' not in value, 'native bootstrap incomplete; private receipt retained')
return value
except subprocess.TimeoutExpired as error:
save(folder / ('transport-timeout-' + str(uuid.uuid4()) + '.json'), dict(timed_out=True,
stdout_b64=base64.b64encode(error.stdout or b'').decode(), stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('native reply lost; read original case only') from None
def linux_rpc(prefix, payload, folder):
code = 'import os,json,subprocess,base64,hashlib,uuid\nfrom pathlib import Path\n' + inspect.getsource(require) + '\n' + inspect.getsource(linux_case)
code += '\ntry:\n print(json.dumps(linux_case(' + repr(payload) + ')))\nexcept Exception as e:\n print(json.dumps(dict(bootstrap_error=True,error_class=type(e).__name__)))\n'
return transport(prefix, 'python3 -', code.encode(), folder)
def windows_rpc(prefix, payload, folder):
script = 'try {\n' + WINDOWS + '\n} catch {[pscustomobject]@{bootstrap_error=$true;error_id=$_.FullyQualifiedErrorId;line=$_.InvocationInfo.ScriptLineNumber}|ConvertTo-Json -Compress;exit 1}'
command_text = 'powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand ' + base64.b64encode(script.encode('utf-16le')).decode()
return transport(prefix, command_text, (json.dumps(payload) + '\n').encode(), folder)
def upload(prefix, item, destination, folder, kind):
args = ['sftp'] + [part for part in prefix[1:-1] if part != '-T'] + ['-b', '-', prefix[-1]]
# Linux sftp uses uppercase -P; Windows prefix has no -p option.
if '-p' in args: args[args.index('-p')] = '-P'
batch = ('put ' + json.dumps(item['path']) + ' ' + json.dumps(destination) + '\n').encode()
save(folder / ('transfer-' + kind + '-intent.json'), dict(sha256=item['sha256'], bytes=item['bytes']))
try:
result = subprocess.run(args, input=batch, capture_output=True, timeout=60)
save(folder / ('transfer-' + kind + '-result.json'), dict(returncode=result.returncode,
stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode()))
require(result.returncode == 0, 'fixed artifact transfer failed; no retry')
except subprocess.TimeoutExpired as error:
save(folder / ('transfer-' + kind + '-timeout.json'), dict(timed_out=True,
stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('artifact transfer incomplete; no retry') from None
def linux_case(p):
import resource
import stat
ident = str(uuid.UUID(p['id']))
require(ident == p['id'] and p['action'] in ('prepare', 'run', 'read') and p['profile'] == 'windows-msi-contracts-v1', 'fixed unit case')
require(os.geteuid() == 0 and os.uname().machine == 'x86_64' and set(p['artifacts']) == {'domain','contracts','helper-reconcile','reconcile','linux-helper'}, 'fixed Linux root qualification')
root = Path('/var/lib/rmm-windows-msi-contracts')
def safe(path, directory):
s = path.lstat()
require(s.st_uid == 0 and stat.S_IMODE(s.st_mode) == (0o700 if directory else 0o600)
and (stat.S_ISDIR(s.st_mode) if directory else stat.S_ISREG(s.st_mode) and s.st_nlink == 1), 'private fixed unit path')
def write(path, value):
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'w') as out: json.dump(value, out); out.flush(); os.fsync(out.fileno())
os.umask(0o077)
case = root / ident
if p['action'] == 'read' and not case.exists(): return dict(id=ident, status='remote_case_absent')
if p['action'] == 'prepare':
if not root.exists(): root.mkdir(mode=0o700)
safe(root, True); case.mkdir(mode=0o700); write(case / 'intent.json', p)
return dict(id=ident, prepared=True)
safe(root, True); safe(case, True); safe(case / 'intent.json', False)
original = json.loads((case / 'intent.json').read_bytes())
require({k: v for k, v in p.items() if k != 'action'} == {k: v for k, v in original.items() if k != 'action'}, 'original complete unit intent')
if p['action'] == 'read':
if not (case / 'result.json').exists():
partial = {}
for kind in ('domain','contracts','helper-reconcile','reconcile','linux-helper'):
for suffix in ('-list.json','-result.json'):
path = case / (kind + suffix)
if path.exists():
safe(path, False); require(path.stat().st_size <= 2*1024*1024, 'bounded original partial receipt')
partial[kind + suffix] = json.loads(path.read_bytes())
return dict(id=ident,status='started_without_result' if (case/'started.json').exists() else 'prepared_without_start',
both_lists_verified=(case/'all-lists-verified.json').exists(),tests_started=(case/'tests-started.json').exists(),partial=partial)
safe(case / 'result.json', False); return json.loads((case / 'result.json').read_bytes())
write(case / 'started.json', dict(manifest_sha256=p['manifest_sha256'], execute_once=True))
temp = case / 'tmp'; temp.mkdir(mode=0o700)
env = {'PATH': '/usr/bin:/bin', 'LANG': 'C.UTF-8', 'LC_ALL': 'C.UTF-8', 'TMPDIR': str(temp), 'RUST_BACKTRACE': '0'}
def limits():
resource.setrlimit(resource.RLIMIT_CORE, (0, 0)); resource.setrlimit(resource.RLIMIT_CPU, (15, 15)); resource.setrlimit(resource.RLIMIT_FSIZE, (1048576, 1048576))
require(subprocess.run(['/usr/bin/unshare', '--net', '--', '/usr/bin/true'], env=env, capture_output=True, timeout=3).returncode == 0, 'network namespace required')
listings = {}
for kind in ('domain','contracts','helper-reconcile','reconcile','linux-helper'):
binary = case / kind; safe(binary, False)
require(hashlib.sha256(binary.read_bytes()).hexdigest() == p['artifacts'][kind]['sha256'], 'exact Linux delivery')
binary.chmod(0o500)
listed = subprocess.run(['/usr/bin/unshare', '--net', '--', str(binary), '--list', '--format', 'terse'], cwd=case, env=env, capture_output=True, timeout=5, preexec_fn=limits)
require(listed.returncode == 0 and len(listed.stdout) <= 65536 and len(listed.stderr) <= 65536, 'bounded actual listing')
actual = sorted(line[:-6] for line in listed.stdout.decode().splitlines() if line.endswith(': test'))
write(case / (kind+'-list.json'),dict(names=actual,exit_code=listed.returncode,sha256=p['artifacts'][kind]['sha256'],
stdout_b64=base64.b64encode(listed.stdout).decode(),stderr_b64=base64.b64encode(listed.stderr).decode()))
require(all(not line.strip() or __import__('re').fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in listed.stdout.decode().splitlines())
and actual == p['names'][kind] and len(actual) == {'domain':20,'contracts':8,'helper-reconcile':26,'reconcile':26,'linux-helper':21}[kind], 'exact native test names before ANY test execution')
listings[kind] = actual
write(case/'all-lists-verified.json',dict(all_lists_before_any_tests=True,manifest_sha256=p['manifest_sha256']))
write(case/'tests-started.json',dict(execute_tests_once=True))
reports = {}
for kind in ('domain','contracts','helper-reconcile','reconcile','linux-helper'):
with (case / (kind + '-stdout.bin')).open('xb') as out, (case / (kind + '-stderr.bin')).open('xb') as err:
timed = False
try: code = subprocess.run(['/usr/bin/unshare', '--net', '--', str(case / kind), '--test-threads=1'], cwd=case, env=env,
stdin=subprocess.DEVNULL, stdout=out, stderr=err, timeout=18, preexec_fn=limits).returncode
except subprocess.TimeoutExpired: timed = True; code = None
out.flush(); err.flush(); os.fsync(out.fileno()); os.fsync(err.fileno())
raw, errors = [(case / (kind + '-' + stream + '.bin')).read_bytes() for stream in ('stdout', 'stderr')]
require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded native output')
reports[kind] = dict(sha256=p['artifacts'][kind]['sha256'], names=listings[kind], exit_code=code, timed_out=timed,
stdout_b64=base64.b64encode(raw).decode(), stderr_b64=base64.b64encode(errors).decode())
write(case / (kind + '-result.json'), reports[kind])
value = dict(id=ident, platform='linux', profile=p['profile'], manifest_sha256=p['manifest_sha256'], runner_sha256=p['runner_sha256'],
scripts=p['scripts'], reports=reports, all_lists_before_any_tests=True, network_namespace=True, environment_cleared=True, product_state_writes=False, rmm_jobs=False)
write(case / 'result.json', value); return value
WINDOWS = r'''
$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
if([string]([guid]$p.id)-cne$p.id-or$p.action-notin@('prepare','run','read')-or$p.profile-cne'windows-msi-contracts-v1'-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'-or$p.linux_proof_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed Linux-first profile case'}
$root='C:\ProgramData\RustDiscoveryBootstrap';$case=Join-Path $root ('windows-msi-contracts-'+$p.id)
function Safe($path,$dir){$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Unit path type'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Private unit owner'};$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty private ACL'};foreach($e in $rules){if($e.AccessControlType-ne'Allow'-or$e.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')-or($e.PropagationFlags-band[Security.AccessControl.PropagationFlags]::InheritOnly)){throw 'Broad private unit ACL'}}}
function WriteNew($path,$value){$f=[IO.File]::Open($path,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read);try{$b=[Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 16 -Compress));$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
function MatchIntent($old){if($old.id-cne$p.id-or$old.profile-cne$p.profile-or$old.manifest_sha256-cne$p.manifest_sha256-or$old.runner_sha256-cne$p.runner_sha256-or$old.linux_proof_sha256-cne$p.linux_proof_sha256-or$old.scripts.linux_case_sha256-cne$p.scripts.linux_case_sha256-or$old.scripts.windows_script_sha256-cne$p.scripts.windows_script_sha256){throw 'Original profile intent'};foreach($kind in @('domain','contracts','helper-reconcile','reconcile')){if($old.artifacts.$kind.sha256-cne$p.artifacts.$kind.sha256-or$old.artifacts.$kind.bytes-ne$p.artifacts.$kind.bytes-or(@($old.names.$kind)-join"`n")-cne(@($p.names.$kind)-join"`n")){throw 'Original artifact/test tuple'}}}
if($p.action-eq'read'-and!(Test-Path -LiteralPath $case)){@{id=$p.id;status='remote_case_absent'}|ConvertTo-Json -Compress;exit 0}
Safe $root $true
if($p.action-eq'prepare'){if(Test-Path -LiteralPath $case){throw 'Existing case retained'};New-Item -ItemType Directory -Path $case|Out-Null;Safe $case $true;WriteNew (Join-Path $case 'intent.json') $p;@{id=$p.id;prepared=$true}|ConvertTo-Json -Compress;exit 0}
Safe $case $true;$intent=Join-Path $case 'intent.json';Safe $intent $false;MatchIntent (Get-Content -LiteralPath $intent -Raw|ConvertFrom-Json)
if($p.action-eq'read'){$result=Join-Path $case 'result.json';if(!(Test-Path -LiteralPath $result)){$status=if(Test-Path -LiteralPath (Join-Path $case 'started.json')){'started_without_result'}else{'prepared_without_start'};$partial=@{};foreach($kind in @('domain','contracts','helper-reconcile','reconcile')){foreach($suffix in @('-list.json','-result.json')){$file=Join-Path $case ($kind+$suffix);if(Test-Path -LiteralPath $file){Safe $file $false;if((Get-Item -LiteralPath $file).Length-gt2097152){throw 'Partial report bound'};$partial[$kind+$suffix]=Get-Content -LiteralPath $file -Raw|ConvertFrom-Json}}};@{id=$p.id;status=$status;all_lists_verified=(Test-Path -LiteralPath (Join-Path $case 'all-lists-verified.json'));tests_started=(Test-Path -LiteralPath (Join-Path $case 'tests-started.json'));partial=$partial}|ConvertTo-Json -Depth 16 -Compress;exit 0};Safe $result $false;Get-Content -LiteralPath $result -Raw;exit 0}
function RunUnit($exe,[string]$arguments){$s=New-Object Diagnostics.ProcessStartInfo;$s.FileName=$exe;$s.Arguments=$arguments;$s.UseShellExecute=$false;$s.CreateNoWindow=$true;$s.WorkingDirectory=$case;$s.RedirectStandardOutput=$true;$s.RedirectStandardError=$true;$systemRoot=$env:WINDIR;$s.EnvironmentVariables.Clear();$s.EnvironmentVariables['SystemRoot']=$systemRoot;$s.EnvironmentVariables['WINDIR']=$systemRoot;$s.EnvironmentVariables['PATH']=$systemRoot+'\System32';$s.EnvironmentVariables['TEMP']=$script:temp;$s.EnvironmentVariables['TMP']=$script:temp;$s.EnvironmentVariables['RUST_BACKTRACE']='0';$c=New-Object Diagnostics.Process;$c.StartInfo=$s;if(!$c.Start()){throw 'Unit start'};try{$o=$c.StandardOutput.ReadToEndAsync();$e=$c.StandardError.ReadToEndAsync();$timed=$false;if(!$c.WaitForExit(18000)){$timed=$true;$c.Kill();if(!$c.WaitForExit(2000)){throw 'Own unit process did not exit'}};if(!$o.Wait(2000)-or!$e.Wait(2000)-or$o.Result.Length-gt1048576-or$e.Result.Length-gt1048576){throw 'Bounded unit output'};return @{exit_code=$c.ExitCode;timed_out=$timed;stdout_b64=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($o.Result));stderr_b64=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($e.Result))}}finally{$c.Dispose()}}
WriteNew (Join-Path $case 'started.json') @{execute_once=$true;manifest_sha256=$p.manifest_sha256};$script:temp=Join-Path $case 'tmp';New-Item -ItemType Directory -Path $script:temp|Out-Null;Safe $script:temp $true
$lists=@{};$executables=@{}
foreach($kind in @('domain','contracts','helper-reconcile','reconcile')){$item=$p.artifacts.$kind;if($item.sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed unit hash'};$exe=Join-Path $case ($kind+'.exe');Safe $exe $false;if((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()-cne$item.sha256-or(Get-Item -LiteralPath $exe).Length-ne$item.bytes){throw 'Exact unit bytes'};$list=RunUnit $exe '--list --format terse';if($list.exit_code-ne0-or$list.timed_out){throw 'Actual Windows listing'};$text=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($list.stdout_b64));$unexpected=@($text-split'\r?\n'|Where-Object{$_.Trim()-and$_-notmatch'^[A-Za-z0-9_:]+: test$'});if($unexpected.Count){throw 'Only exact terse test entries'};[string[]]$actual=@($text-split'\r?\n'|Where-Object{$_-match': test$'}|ForEach-Object{$_-replace': test$',''});[Array]::Sort($actual,[StringComparer]::Ordinal);$counts=@{domain=20;contracts=7;'helper-reconcile'=26;reconcile=26};$count=$counts[$kind];if($actual.Count-ne$count-or($actual-join"`n")-cne(@($p.names.$kind)-join"`n")){throw 'All exact names BEFORE any tests'};WriteNew (Join-Path $case ($kind+'-list.json')) @{names=$actual;sha256=$item.sha256;listed=$list};$lists[$kind]=$actual;$executables[$kind]=$exe}
WriteNew (Join-Path $case 'all-lists-verified.json') @{all_lists_before_any_tests=$true;manifest_sha256=$p.manifest_sha256};WriteNew (Join-Path $case 'tests-started.json') @{execute_tests_once=$true}
$reports=@{};foreach($kind in @('domain','contracts','helper-reconcile','reconcile')){$value=RunUnit $executables[$kind] '--test-threads=1';$value.sha256=$p.artifacts.$kind.sha256;$value.names=$lists[$kind];WriteNew (Join-Path $case ($kind+'-result.json')) $value;$reports[$kind]=$value}
$value=@{id=$p.id;platform='windows';profile=$p.profile;manifest_sha256=$p.manifest_sha256;runner_sha256=$p.runner_sha256;scripts=$p.scripts;linux_proof_sha256=$p.linux_proof_sha256;reports=$reports;all_lists_before_any_tests=$true;bootstrap_administrator_units=$true;local_service_proof=$false;environment_cleared=$true;product_state_writes=$false;rmm_jobs=$false};WriteNew (Join-Path $case 'result.json') $value;$value|ConvertTo-Json -Depth 16 -Compress
'''
def check_result(manifest, platform, value, payload):
require(value.get('id') == payload['id'] and value.get('platform') == platform and value.get('profile') == PROFILE
and value.get('manifest_sha256') == payload['manifest_sha256'] and value.get('runner_sha256') == manifest['runner_sha256']
and value.get('scripts') == manifest['scripts'] and value.get('product_state_writes') is False and value.get('rmm_jobs') is False
and value.get('environment_cleared') is True and value.get('all_lists_before_any_tests') is True and set(value['reports']) == set(KINDS[platform]), 'complete native original binding')
if platform == 'linux': require(value.get('network_namespace') is True, 'actual Linux netns proof')
else: require(value.get('linux_proof_sha256') == payload['linux_proof_sha256'] and value.get('local_service_proof') is False, 'original Linux proof and honest account scope')
for kind, item in value['reports'].items():
require(item['names'] == EXPECTED[platform][kind] and item['sha256'] == manifest['artifacts'][platform][kind]['sha256']
and item['exit_code'] == 0 and item['timed_out'] is False, 'all native exact test names/artifacts/exits')
raw = base64.b64decode(item['stdout_b64'], validate=True); errors = base64.b64decode(item['stderr_b64'], validate=True)
require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded native outputs')
check_output(raw, COUNTS[platform][kind])
def execute(path, platform, access_root, case_id=None):
setup_state(); path = path.absolute(); manifest = verified(path, new_run=case_id is None)
prefix = access_settings(access_root, platform)
if case_id is None:
case_id = str(uuid.uuid4()); folder = STATE / case_id; folder.mkdir(mode=0o700)
payload = dict(id=case_id, profile=PROFILE, manifest_sha256=sha(path), runner_sha256=manifest['runner_sha256'], scripts=manifest['scripts'],
artifacts={kind: {k: manifest['artifacts'][platform][kind][k] for k in ('sha256', 'bytes')} for kind in KINDS[platform]}, names=EXPECTED[platform])
if platform == 'windows':
proof_path = path.parent / 'linux-passed.json'; proof = load(proof_path)
require(proof['verified'] is True and proof['manifest_sha256'] == sha(path), 'same-manifest real Linux proof FIRST')
linux_payload = dict(payload, id=proof['case_id'], artifacts={kind: {k: manifest['artifacts']['linux'][kind][k] for k in ('sha256', 'bytes')} for kind in KINDS['linux']}, names=EXPECTED['linux'])
check_result(manifest, 'linux', proof['native'], linux_payload)
payload['linux_proof_sha256'] = sha(proof_path)
intent = dict(id=case_id, platform=platform, manifest_path=str(path), manifest_sha256=sha(path), runner_sha256=sha(__file__),
scripts=scripts(), access_root_sha256=hashlib.sha256(str(access_root.absolute()).encode()).hexdigest(), payload=payload)
save(folder / 'intent.json', intent)
save(folder / 'started-local.json', dict(create_once=True, no_retry=True))
run_read = False
else:
require(str(uuid.UUID(case_id)) == case_id, 'original canonical case id')
folder = STATE / case_id; private(folder, True); intent = load(folder / 'intent.json'); load(folder / 'started-local.json')
require(intent['id'] == case_id and intent['platform'] == platform and intent['manifest_path'] == str(path)
and intent['manifest_sha256'] == sha(path) and intent['runner_sha256'] == sha(__file__) and intent['scripts'] == scripts()
and intent['access_root_sha256'] == hashlib.sha256(str(access_root.absolute()).encode()).hexdigest(), 'immutable same-case readback')
payload = intent['payload']; run_read = True
rpc = linux_rpc if platform == 'linux' else windows_rpc
if not run_read:
result = rpc(prefix, dict(payload, action='prepare'), folder)
save(folder / 'prepared-remote.json', result); require(result == dict(id=case_id, prepared=True), 'fresh fixed case prepared')
for kind in KINDS[platform]:
destination = LINUX_REMOTE + '/' + case_id + '/' + kind if platform == 'linux' else '/C:/ProgramData/RustDiscoveryBootstrap/windows-msi-contracts-' + case_id + '/' + kind + '.exe'
upload(prefix, manifest['artifacts'][platform][kind], destination, folder, kind)
result = rpc(prefix, dict(payload, action='read' if run_read else 'run'), folder)
save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), result)
if result.get('status'):
require(run_read and result.get('id') == case_id and result['status'] in ('remote_case_absent', 'prepared_without_start', 'started_without_result'), 'fixed read-only incomplete status')
print(json.dumps(dict(verified=False, platform=platform, case_id=case_id, status=result['status'], retry_allowed=False))); return
check_result(manifest, platform, result, payload)
proof = dict(verified=True, case_id=case_id, platform=platform, manifest_sha256=sha(path), runner_sha256=manifest['runner_sha256'], native=result)
destination = path.parent / (platform + '-passed.json')
if destination.exists(): require(load(destination) == proof, 'preserve identical native proof')
else: save(destination, proof)
save(folder / 'verified.json', dict(verified=True, proof_sha256=sha(destination))) if not (folder / 'verified.json').exists() else require(load(folder / 'verified.json') == dict(verified=True, proof_sha256=sha(destination)), 'same verified receipt')
print(json.dumps(dict(verified=True, platform=platform, case_id=case_id, tests=sum(COUNTS[platform].values()),
manifest_sha256=sha(path), proof_sha256=sha(destination))))
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('build-local', 'linux', 'windows', 'readback-linux', 'readback-windows'))
parser.add_argument('--manifest', type=Path); parser.add_argument('--case'); parser.add_argument('--access-root', type=Path)
parser.add_argument('--execute-native-tests', action='store_true'); args = parser.parse_args()
if args.action == 'build-local':
require(not (args.manifest or args.case or args.access_root or args.execute_native_tests), 'local build only'); build()
elif args.action.startswith('readback-'):
require(args.manifest and args.case and args.access_root and not args.execute_native_tests, 'original case readback only')
execute(args.manifest, args.action.removeprefix('readback-'), args.access_root, args.case)
else:
require(args.manifest and args.access_root and args.execute_native_tests and not args.case, 'explicit new native platform run')
execute(args.manifest, args.action, args.access_root)
if __name__ == '__main__':
try: main()
except Exception as error:
print(json.dumps(dict(error='WINDOWS_MSI_CONTRACT_QUALIFICATION_INCOMPLETE', error_class=type(error).__name__, details_suppressed=True)))
raise SystemExit(2) from None
+485
View File
@@ -0,0 +1,485 @@
#!/usr/bin/env python3
"""Package24 pure profile contracts: Linux VM FIRST, then Windows VM.
Only two fixed test executables run in separate bootstrap scratch directories.
No RMM job, daemon, live database, PKI, policy, enrollment or capability change.
Native execution is explicit; any lost reply permits same-case readback only.
"""
import argparse
import base64
import datetime as dt
import hashlib
import inspect
import json
import os
from pathlib import Path
import re
import shlex
import shutil
import stat
import subprocess
import uuid
import vm_access_check as access
ROOT = Path(__file__).resolve().parents[1]
STATE = ROOT / 'devstate/windows-profile'
IMAGE = 'rust-discovery-durable-final-build:local'
PROFILE = 'windows-process-profile-v1'
LINUX_REMOTE = '/var/lib/rmm-windows-profile-units'
KINDS = ('domain', 'contracts')
COUNTS = {'linux': {'domain': 16, 'contracts': 7}, 'windows': {'domain': 16, 'contracts': 6}}
DOMAIN_NAMES = sorted(('apt_transaction::tests::closure_bytes_archives_and_code_are_bound',
'apt_transaction::tests::helper_schema_two_roundtrip_and_strict_action_binding',
'inventory_document::tests::additive_metadata_and_bounds',
'inventory_document::tests::exact_linux_recovery_scope_does_not_admit_other_hyphens_or_windows',
'inventory_document::tests::windows_scope_does_not_weaken_linux_or_accept_platform_spoofing',
'jobs::tests::additive_recipe_refs_preserve_legacy_plan_bytes', 'jobs::tests::codec_golden_and_exact_script_bytes',
'jobs::tests::no_terminal_replay_or_unknown_restart', 'jobs::tests::permit_codec_golden_all_bindings',
'jobs::tests::updates_require_exact_versions_and_never_implicit_reboot',
'jobs::tests::windows_interpreter_and_capability_contract',
'jobs::tests::windows_remote_signed_profile_is_optional_exact_and_capability_bound',
'jobs::tests::windows_system_scm_is_explicit_and_preserves_linux_service_bytes',
'reconciliation::tests::outcome_codec_keeps_raw_output_and_sorts_evidence',
'reconciliation::tests::reconciliation_cannot_be_a_permit_or_unbounded_ticket',
'tests::production_never_accepts_development_auth'))
CONTRACT_NAMES = sorted(('atomic_begin_execution_rolls_back_both_rows_on_missing_witness_or_start_insert_failure',
'completion_cas_preserves_original_bytes_and_recovers_only_verified_bound_evidence',
'consumed_attempt_and_unknown_lock_survive_reopen_without_reexecution',
'exact_permit_bytes_time_and_all_identity_hash_bindings_are_required',
'historical_request_and_binding_codecs_keep_field_order_arrays_and_strictness',
'openssl_and_portable_ed25519_agree_on_current_keys_bytes_and_tampering',
'portable_acceptance_requires_platform_capability_and_exact_redelivery'))
UNIX_ONLY = 'openssl_and_portable_ed25519_agree_on_current_keys_bytes_and_tampering'
EXPECTED = {'linux': {'domain': DOMAIN_NAMES, 'contracts': CONTRACT_NAMES},
'windows': {'domain': DOMAIN_NAMES, 'contracts': [x for x in CONTRACT_NAMES if x != UNIX_ONLY]}}
def require(value, code):
if not value:
raise RuntimeError(code)
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def object_pairs(items):
value = {}
for key, item in items:
require(key not in value, 'duplicate JSON field')
value[key] = item
return value
def private(path, directory=False):
item = Path(path).lstat()
require(not stat.S_ISLNK(item.st_mode) and item.st_uid == os.getuid()
and stat.S_IMODE(item.st_mode) == (0o700 if directory else 0o600)
and (stat.S_ISDIR(item.st_mode) if directory else stat.S_ISREG(item.st_mode) and item.st_nlink == 1),
'private owned regular path')
def load(path):
private(path)
require(Path(path).stat().st_size <= 2 * 1024 * 1024, 'bounded private JSON')
return json.loads(Path(path).read_bytes(), object_pairs_hook=object_pairs)
def save(path, value):
private(Path(path).parent, True)
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600)
with os.fdopen(fd, 'w') as stream:
json.dump(value, stream, indent=2); stream.write('\n'); stream.flush(); os.fsync(stream.fileno())
def setup_state():
os.umask(0o077)
STATE.parent.mkdir(mode=0o700, exist_ok=True)
metadata = STATE.parent.lstat()
require(stat.S_ISDIR(metadata.st_mode) and metadata.st_uid == os.getuid() and not metadata.st_mode & 0o002,
'owned non-world-writable devstate parent')
STATE.mkdir(mode=0o700, exist_ok=True)
private(STATE, True)
def source_files():
paths = [ROOT / p for p in ('Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml',
'deploy/windows_profile_acceptance.py', 'deploy/remote_client_bootstrap.py',
'deploy/vm_access_check.py', 'deploy/vm_mvp_acceptance.py', 'deploy/windows/client_bootstrap.py')]
paths += list((ROOT / 'crates').rglob('Cargo.toml'))
for name in ('domain', 'agent-core', 'protocol'):
paths += [p for p in (ROOT / 'crates' / name).rglob('*') if p.is_file()]
paths += [p for p in (ROOT / 'proto').rglob('*') if p.is_file()]
for path in paths:
require(not path.is_symlink() and path.is_file(), 'regular source inputs only')
return {str(p.relative_to(ROOT)): sha(p) for p in sorted(set(paths))}
def names(raw):
return sorted(re.findall(r'^([A-Za-z0-9_:]+): test\r?$', raw, re.M))
def check_list(raw, expected):
require(names(raw) == expected and len(set(expected)) == len(expected), 'all exact test names before execution')
require(all(not line.strip() or re.fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in raw.splitlines()),
'terse list contains only exact tests, no benchmarks or extra entries')
def check_output(raw, count):
require(re.search(rb'^test result: ok\. ' + str(count).encode()
+ rb' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;[^\r\n]*\r?$', raw, re.M),
'all tests passed without skipped or filtered tests')
def command(args, folder, timeout=300):
index = len(list(folder.glob('command-*.json')))
try:
done = subprocess.run(args, capture_output=True, timeout=timeout)
save(folder / ('command-%03d.json' % index), dict(returncode=done.returncode,
stdout_b64=base64.b64encode(done.stdout).decode(), stderr_b64=base64.b64encode(done.stderr).decode()))
require(done.returncode == 0, 'local qualification command failed; private output retained')
return done.stdout
except subprocess.TimeoutExpired as error:
save(folder / ('command-%03d.json' % index), dict(timed_out=True,
stdout_b64=base64.b64encode(error.stdout or b'').decode(), stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('local qualification timed out; no automatic retry') from None
def scripts():
return {'linux_case_sha256': hashlib.sha256(inspect.getsource(linux_case).encode()).hexdigest(),
'windows_script_sha256': hashlib.sha256(WINDOWS.encode()).hexdigest()}
def build():
setup_state()
folder = STATE / ('build-' + str(uuid.uuid4())); folder.mkdir(mode=0o700)
before = source_files(); save(folder / 'source-before.json', before)
image = command(['docker', 'image', 'inspect', '--format', '{{.Id}}', IMAGE], folder).decode().strip()
require(re.fullmatch(r'sha256:[a-f0-9]{64}', image), 'immutable local build image')
target = STATE / 'target'; target.mkdir(mode=0o700, exist_ok=True); private(target, True)
common = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=512m',
'-v', str(ROOT) + ':/src:ro', '-v', str(target) + ':/target', '-e', 'CARGO_TARGET_DIR=/target', '--entrypoint', 'cargo', image]
artifacts = {'linux': {}, 'windows': {}}
for platform, triple in [('linux', 'x86_64-unknown-linux-gnu'), ('windows', 'x86_64-pc-windows-gnu')]:
for kind in KINDS:
package, selection = ('rmm-domain', ['--lib']) if kind == 'domain' else ('rmm-agent-core', ['--test', 'contracts'])
options = ['--manifest-path', '/src/Cargo.toml', '--locked', '--offline', '--target', triple, '-p', package]
command(common + ['clippy'] + options + selection + ['--', '-D', 'warnings'], folder)
raw = command(common + ['test'] + options + selection + ['--release', '--no-run', '--message-format=json'], folder)
linked = []
for line in raw.splitlines():
try: item = json.loads(line)
except ValueError: continue
expected_name = 'rmm_domain' if kind == 'domain' else 'contracts'
if item.get('reason') == 'compiler-artifact' and item.get('executable') and item.get('profile', {}).get('test') and item['target']['name'] == expected_name:
linked.append(target / Path(item['executable']).relative_to('/target'))
require(len(linked) == 1, 'exact selected unit executable')
destination = folder / platform; destination.mkdir(mode=0o700, exist_ok=True)
original = destination / (kind + '.linked')
delivery = destination / (kind + ('.exe' if platform == 'windows' else ''))
for path in (original, delivery): shutil.copyfile(linked[0], path); path.chmod(0o600)
linked_sha = sha(original)
tool = 'x86_64-w64-mingw32-strip' if platform == 'windows' else 'strip'
command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', str(destination) + ':/artifacts',
'--entrypoint', tool, image, '--strip-debug', '/artifacts/' + delivery.name], folder)
require(sha(linked[0]) == sha(original) == linked_sha, 'unstripped original link preserved')
data = delivery.read_bytes()
if platform == 'linux':
require(data[:6] == b'\x7fELF\x02\x01' and data[18:20] == b'\x3e\0', 'Linux x64 ELF')
else:
offset = int.from_bytes(data[60:64], 'little')
require(data[:2] == b'MZ' and data[offset:offset + 6] == b'PE\0\0\x64\x86', 'Windows x64 PE')
artifacts[platform][kind] = dict(path=str(delivery.resolve()), sha256=sha(delivery), bytes=len(data),
original_link_path=str(original.resolve()), original_link_sha256=linked_sha, debug_stripped_delivery=True)
# Run exactly the deliverable Linux bytes in an offline disposable container.
for kind, item in artifacts['linux'].items():
invoke = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,exec,size=128m',
'-v', item['path'] + ':/unit:ro', '--entrypoint', 'python3', image, '-c']
for mode in ('list', 'run'):
args = ['--list', '--format', 'terse'] if mode == 'list' else ['--test-threads=1']
script = 'import shutil,os,subprocess;shutil.copyfile("/unit","/tmp/unit");os.chmod("/tmp/unit",0o500);subprocess.run(["/tmp/unit"]+' + repr(args) + ',check=True,cwd="/tmp",env={"PATH":"/usr/bin:/bin","LANG":"C.UTF-8","TMPDIR":"/tmp","RUST_BACKTRACE":"0"})'
raw = command(invoke + [script], folder)
save(folder / ('local-linux-' + kind + '-' + mode + '.json'), dict(stdout_b64=base64.b64encode(raw).decode()))
if mode == 'list': check_list(raw.decode(), EXPECTED['linux'][kind])
else: check_output(raw, COUNTS['linux'][kind])
dynamic = command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', item['path'] + ':/unit:ro',
'--entrypoint', 'readelf', image, '-d', '/unit'], folder).decode()
versions = command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', item['path'] + ':/unit:ro',
'--entrypoint', 'readelf', image, '--version-info', '/unit'], folder).decode()
glibc = sorted(set(re.findall(r'GLIBC_(\d+\.\d+)', versions)), key=lambda x: tuple(map(int, x.split('.'))))
require(glibc and tuple(map(int, glibc[-1].split('.'))) <= (2, 39), 'VM-compatible glibc requirement')
item['glibc_max'] = glibc[-1]; item['needed'] = sorted(re.findall(r'Shared library: \[([^\]]+)\]', dynamic))
require(source_files() == before, 'source and runner unchanged through qualification')
manifest = dict(schema_version=1, profile=PROFILE, source_files=before, source_before_after_equal=True,
runner_sha256=sha(__file__), scripts=scripts(), test_names=EXPECTED, test_counts=COUNTS, artifacts=artifacts,
build_image_id=image, both_targets_clippy_D_warnings=True, linux_lists_actual=True,
windows_lists_expected_until_native=True, local_linux_tests_passed=23, native_linux_executed=False,
native_windows_executed=False, product_state_writes=False, rmm_jobs=False)
save(folder / 'manifest.json', manifest)
print(json.dumps(dict(manifest=str((folder / 'manifest.json').resolve()), manifest_sha256=sha(folder / 'manifest.json'),
linux_tests=23, windows_tests_expected=22, native_executed=False)))
def verified(path, new_run):
path = path.absolute(); private(path.parent, True)
require(path.name == 'manifest.json' and path.parent.parent == STATE and re.fullmatch(r'build-[0-9a-f-]{36}', path.parent.name), 'fixed build manifest path')
value = load(path)
require(value['schema_version'] == 1 and value['profile'] == PROFILE and value['runner_sha256'] == sha(__file__)
and value['scripts'] == scripts() and value['test_names'] == EXPECTED and value['test_counts'] == COUNTS
and value['source_before_after_equal'] is True and value['both_targets_clippy_D_warnings'] is True,
'original manifest/runner/remote scripts/profile binding')
if new_run: require(value['source_files'] == source_files(), 'new execution requires same current qualified source')
for platform in COUNTS:
require(set(value['artifacts'][platform]) == set(KINDS), 'exact two artifacts')
for kind, item in value['artifacts'][platform].items():
suffix = '.exe' if platform == 'windows' else ''
require(Path(item['path']) == path.parent / platform / (kind + suffix)
and Path(item['original_link_path']) == path.parent / platform / (kind + '.linked'), 'fixed private artifact paths')
for field, digest in [('path', item['sha256']), ('original_link_path', item['original_link_sha256'])]:
private(item[field]); require(sha(item[field]) == digest, 'immutable original/delivery bytes')
require(Path(item['path']).stat().st_size == item['bytes'], 'artifact size unchanged')
return value
def access_settings(root, platform):
"""Read strictly parsed existing access only when the parent executes native."""
require(root is not None and not root.is_symlink(), 'explicit real access-root required')
root = root.absolute(); require(root.is_dir() and root.resolve() == root, 'canonical access-root')
if platform == 'linux':
cfg = access.load_config(root / 'credentials/linux-vm.conf')
require(cfg['address'] == '116.203.20.85' and cfg['username'] == 'root' and cfg.get('port', '22') == '22'
and cfg.get('ssh_key_path'), 'fixed Cloud Linux bootstrap target')
prefix = ['ssh', '-F', '/dev/null', '-T', '-p', '22', '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', '-i', str(Path(cfg['ssh_key_path']).expanduser()), 'root@116.203.20.85']
else:
cfg = access.load_config(root / 'credentials/server.conf')
require(cfg['address'] == '88.99.80.202' and cfg['username'] == 'root' and cfg.get('port', '22') == '22'
and cfg.get('ssh_key_path'), 'fixed server reverse-jump only')
credentials = root / 'credentials'; private(credentials, True)
record = load(credentials / 'windows-dev-access.json')
require(set(record) == {'ssh_prefix', 'expires_at'}, 'known Windows access schema')
expires = dt.datetime.fromisoformat(record['expires_at'])
require(expires.utcoffset() is not None and dt.datetime.now(dt.timezone.utc) < expires, 'existing dev access still valid')
key = str(Path(cfg['ssh_key_path']).expanduser())
jump = ['ssh', '-F', '/dev/null', '-T', '-p', '22', '-i', key, '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'ForwardAgent=no', '-o', 'IdentitiesOnly=yes', '-W', '127.0.0.1:22240', 'root@88.99.80.202']
prefix = ['ssh', '-F', '/dev/null', '-T', '-i', key, '-o', 'ProxyCommand=' + shlex.join(jump),
'-o', 'HostKeyAlias=rmm-windows-dev', '-o', 'UserKnownHostsFile=' + str(credentials / 'windows-dev.known_hosts'),
'-o', 'GlobalKnownHostsFile=/dev/null', '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', 'rmm-dev@127.0.0.1']
require(record['ssh_prefix'] == prefix, 'exact registered pinned reverse SSH prefix')
private(credentials / 'windows-dev.known_hosts')
return prefix
def transport(prefix, command_text, data, folder, timeout=60):
"""No stdout/stderr escapes the private case directory on transport failure."""
try:
result = subprocess.run(prefix + [command_text], input=data, capture_output=True, timeout=timeout)
save(folder / ('transport-' + str(uuid.uuid4()) + '.json'), dict(returncode=result.returncode,
stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode()))
require(result.returncode == 0, 'native transport incomplete; same-case readback only')
value = json.loads(result.stdout.decode('utf-8-sig'), object_pairs_hook=object_pairs)
require(isinstance(value, dict) and 'bootstrap_error' not in value, 'native bootstrap incomplete; private receipt retained')
return value
except subprocess.TimeoutExpired as error:
save(folder / ('transport-timeout-' + str(uuid.uuid4()) + '.json'), dict(timed_out=True,
stdout_b64=base64.b64encode(error.stdout or b'').decode(), stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('native reply lost; read original case only') from None
def linux_rpc(prefix, payload, folder):
code = 'import os,json,subprocess,base64,hashlib,uuid\nfrom pathlib import Path\n' + inspect.getsource(require) + '\n' + inspect.getsource(linux_case)
code += '\ntry:\n print(json.dumps(linux_case(' + repr(payload) + ')))\nexcept Exception as e:\n print(json.dumps(dict(bootstrap_error=True,error_class=type(e).__name__)))\n'
return transport(prefix, 'python3 -', code.encode(), folder)
def windows_rpc(prefix, payload, folder):
script = 'try {\n' + WINDOWS + '\n} catch {[pscustomobject]@{bootstrap_error=$true;error_id=$_.FullyQualifiedErrorId;line=$_.InvocationInfo.ScriptLineNumber}|ConvertTo-Json -Compress;exit 1}'
command_text = 'powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand ' + base64.b64encode(script.encode('utf-16le')).decode()
return transport(prefix, command_text, (json.dumps(payload) + '\n').encode(), folder)
def upload(prefix, item, destination, folder, kind):
args = ['sftp'] + [part for part in prefix[1:-1] if part != '-T'] + ['-b', '-', prefix[-1]]
# Linux sftp uses uppercase -P; Windows prefix has no -p option.
if '-p' in args: args[args.index('-p')] = '-P'
batch = ('put ' + json.dumps(item['path']) + ' ' + json.dumps(destination) + '\n').encode()
save(folder / ('transfer-' + kind + '-intent.json'), dict(sha256=item['sha256'], bytes=item['bytes']))
try:
result = subprocess.run(args, input=batch, capture_output=True, timeout=60)
save(folder / ('transfer-' + kind + '-result.json'), dict(returncode=result.returncode,
stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode()))
require(result.returncode == 0, 'fixed artifact transfer failed; no retry')
except subprocess.TimeoutExpired as error:
save(folder / ('transfer-' + kind + '-timeout.json'), dict(timed_out=True,
stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('artifact transfer incomplete; no retry') from None
def linux_case(p):
import resource
import stat
ident = str(uuid.UUID(p['id']))
require(ident == p['id'] and p['action'] in ('prepare', 'run', 'read') and p['profile'] == 'windows-process-profile-v1', 'fixed unit case')
require(os.geteuid() == 0 and os.uname().machine == 'x86_64' and set(p['artifacts']) == {'domain', 'contracts'}, 'fixed Linux root qualification')
root = Path('/var/lib/rmm-windows-profile-units')
def safe(path, directory):
s = path.lstat()
require(s.st_uid == 0 and stat.S_IMODE(s.st_mode) == (0o700 if directory else 0o600)
and (stat.S_ISDIR(s.st_mode) if directory else stat.S_ISREG(s.st_mode) and s.st_nlink == 1), 'private fixed unit path')
def write(path, value):
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'w') as out: json.dump(value, out); out.flush(); os.fsync(out.fileno())
os.umask(0o077)
case = root / ident
if p['action'] == 'read' and not case.exists(): return dict(id=ident, status='remote_case_absent')
if p['action'] == 'prepare':
if not root.exists(): root.mkdir(mode=0o700)
safe(root, True); case.mkdir(mode=0o700); write(case / 'intent.json', p)
return dict(id=ident, prepared=True)
safe(root, True); safe(case, True); safe(case / 'intent.json', False)
original = json.loads((case / 'intent.json').read_bytes())
require({k: v for k, v in p.items() if k != 'action'} == {k: v for k, v in original.items() if k != 'action'}, 'original complete unit intent')
if p['action'] == 'read':
if not (case / 'result.json').exists(): return dict(id=ident, status='started_without_result' if (case / 'started.json').exists() else 'prepared_without_start')
safe(case / 'result.json', False); return json.loads((case / 'result.json').read_bytes())
write(case / 'started.json', dict(manifest_sha256=p['manifest_sha256'], execute_once=True))
temp = case / 'tmp'; temp.mkdir(mode=0o700)
env = {'PATH': '/usr/bin:/bin', 'LANG': 'C.UTF-8', 'LC_ALL': 'C.UTF-8', 'TMPDIR': str(temp), 'RUST_BACKTRACE': '0'}
def limits():
resource.setrlimit(resource.RLIMIT_CORE, (0, 0)); resource.setrlimit(resource.RLIMIT_CPU, (15, 15)); resource.setrlimit(resource.RLIMIT_FSIZE, (1048576, 1048576))
require(subprocess.run(['/usr/bin/unshare', '--net', '--', '/usr/bin/true'], env=env, capture_output=True, timeout=3).returncode == 0, 'network namespace required')
listings = {}
for kind in ('domain', 'contracts'):
binary = case / kind; safe(binary, False)
require(hashlib.sha256(binary.read_bytes()).hexdigest() == p['artifacts'][kind]['sha256'], 'exact Linux delivery')
binary.chmod(0o500)
listed = subprocess.run(['/usr/bin/unshare', '--net', '--', str(binary), '--list', '--format', 'terse'], cwd=case, env=env, capture_output=True, timeout=5, preexec_fn=limits)
require(listed.returncode == 0 and len(listed.stdout) <= 65536 and len(listed.stderr) <= 65536, 'bounded actual listing')
actual = sorted(line[:-6] for line in listed.stdout.decode().splitlines() if line.endswith(': test'))
require(all(not line.strip() or __import__('re').fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in listed.stdout.decode().splitlines())
and actual == p['names'][kind] and len(actual) == {'domain': 16, 'contracts': 7}[kind], 'exact native test names before ANY test execution')
listings[kind] = actual
reports = {}
for kind in ('domain', 'contracts'):
with (case / (kind + '-stdout.bin')).open('xb') as out, (case / (kind + '-stderr.bin')).open('xb') as err:
timed = False
try: code = subprocess.run(['/usr/bin/unshare', '--net', '--', str(case / kind), '--test-threads=1'], cwd=case, env=env,
stdin=subprocess.DEVNULL, stdout=out, stderr=err, timeout=18, preexec_fn=limits).returncode
except subprocess.TimeoutExpired: timed = True; code = None
out.flush(); err.flush(); os.fsync(out.fileno()); os.fsync(err.fileno())
raw, errors = [(case / (kind + '-' + stream + '.bin')).read_bytes() for stream in ('stdout', 'stderr')]
require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded native output')
reports[kind] = dict(sha256=p['artifacts'][kind]['sha256'], names=listings[kind], exit_code=code, timed_out=timed,
stdout_b64=base64.b64encode(raw).decode(), stderr_b64=base64.b64encode(errors).decode())
write(case / (kind + '-result.json'), reports[kind])
value = dict(id=ident, platform='linux', profile=p['profile'], manifest_sha256=p['manifest_sha256'], runner_sha256=p['runner_sha256'],
scripts=p['scripts'], reports=reports, network_namespace=True, environment_cleared=True, product_state_writes=False, rmm_jobs=False)
write(case / 'result.json', value); return value
WINDOWS = r'''
$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
if([string]([guid]$p.id)-cne$p.id-or$p.action-notin@('prepare','run','read')-or$p.profile-cne'windows-process-profile-v1'-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'-or$p.linux_proof_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed Linux-first profile case'}
$root='C:\ProgramData\RustDiscoveryBootstrap';$case=Join-Path $root ('windows-profile-'+$p.id)
function Safe($path,$dir){$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Unit path type'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Private unit owner'};$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty private ACL'};foreach($e in $rules){if($e.AccessControlType-ne'Allow'-or$e.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')-or($e.PropagationFlags-band[Security.AccessControl.PropagationFlags]::InheritOnly)){throw 'Broad private unit ACL'}}}
function WriteNew($path,$value){$f=[IO.File]::Open($path,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read);try{$b=[Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 16 -Compress));$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
function MatchIntent($old){if($old.id-cne$p.id-or$old.profile-cne$p.profile-or$old.manifest_sha256-cne$p.manifest_sha256-or$old.runner_sha256-cne$p.runner_sha256-or$old.linux_proof_sha256-cne$p.linux_proof_sha256-or$old.scripts.linux_case_sha256-cne$p.scripts.linux_case_sha256-or$old.scripts.windows_script_sha256-cne$p.scripts.windows_script_sha256){throw 'Original profile intent'};foreach($kind in @('domain','contracts')){if($old.artifacts.$kind.sha256-cne$p.artifacts.$kind.sha256-or$old.artifacts.$kind.bytes-ne$p.artifacts.$kind.bytes-or(@($old.names.$kind)-join"`n")-cne(@($p.names.$kind)-join"`n")){throw 'Original artifact/test tuple'}}}
if($p.action-eq'read'-and!(Test-Path -LiteralPath $case)){@{id=$p.id;status='remote_case_absent'}|ConvertTo-Json -Compress;exit 0}
Safe $root $true
if($p.action-eq'prepare'){if(Test-Path -LiteralPath $case){throw 'Existing case retained'};New-Item -ItemType Directory -Path $case|Out-Null;Safe $case $true;WriteNew (Join-Path $case 'intent.json') $p;@{id=$p.id;prepared=$true}|ConvertTo-Json -Compress;exit 0}
Safe $case $true;$intent=Join-Path $case 'intent.json';Safe $intent $false;MatchIntent (Get-Content -LiteralPath $intent -Raw|ConvertFrom-Json)
if($p.action-eq'read'){$result=Join-Path $case 'result.json';if(!(Test-Path -LiteralPath $result)){$status=if(Test-Path -LiteralPath (Join-Path $case 'started.json')){'started_without_result'}else{'prepared_without_start'};@{id=$p.id;status=$status}|ConvertTo-Json -Compress;exit 0};Safe $result $false;Get-Content -LiteralPath $result -Raw;exit 0}
function RunUnit($exe,[string]$arguments){$s=New-Object Diagnostics.ProcessStartInfo;$s.FileName=$exe;$s.Arguments=$arguments;$s.UseShellExecute=$false;$s.CreateNoWindow=$true;$s.WorkingDirectory=$case;$s.RedirectStandardOutput=$true;$s.RedirectStandardError=$true;$systemRoot=$env:WINDIR;$s.EnvironmentVariables.Clear();$s.EnvironmentVariables['SystemRoot']=$systemRoot;$s.EnvironmentVariables['WINDIR']=$systemRoot;$s.EnvironmentVariables['PATH']=$systemRoot+'\System32';$s.EnvironmentVariables['TEMP']=$script:temp;$s.EnvironmentVariables['TMP']=$script:temp;$s.EnvironmentVariables['RUST_BACKTRACE']='0';$c=New-Object Diagnostics.Process;$c.StartInfo=$s;if(!$c.Start()){throw 'Unit start'};try{$o=$c.StandardOutput.ReadToEndAsync();$e=$c.StandardError.ReadToEndAsync();$timed=$false;if(!$c.WaitForExit(18000)){$timed=$true;$c.Kill();if(!$c.WaitForExit(2000)){throw 'Own unit process did not exit'}};if(!$o.Wait(2000)-or!$e.Wait(2000)-or$o.Result.Length-gt1048576-or$e.Result.Length-gt1048576){throw 'Bounded unit output'};return @{exit_code=$c.ExitCode;timed_out=$timed;stdout_b64=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($o.Result));stderr_b64=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($e.Result))}}finally{$c.Dispose()}}
WriteNew (Join-Path $case 'started.json') @{execute_once=$true;manifest_sha256=$p.manifest_sha256};$script:temp=Join-Path $case 'tmp';New-Item -ItemType Directory -Path $script:temp|Out-Null;Safe $script:temp $true
$lists=@{};$executables=@{}
foreach($kind in @('domain','contracts')){$item=$p.artifacts.$kind;if($item.sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed unit hash'};$exe=Join-Path $case ($kind+'.exe');Safe $exe $false;if((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()-cne$item.sha256-or(Get-Item -LiteralPath $exe).Length-ne$item.bytes){throw 'Exact unit bytes'};$list=RunUnit $exe '--list --format terse';if($list.exit_code-ne0-or$list.timed_out){throw 'Actual Windows listing'};$text=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($list.stdout_b64));$unexpected=@($text-split'\r?\n'|Where-Object{$_.Trim()-and$_-notmatch'^[A-Za-z0-9_:]+: test$'});if($unexpected.Count){throw 'Only exact terse test entries'};$actual=@($text-split'\r?\n'|Where-Object{$_-match': test$'}|ForEach-Object{$_-replace': test$',''}|Sort-Object);$count=if($kind-eq'domain'){16}else{6};if($actual.Count-ne$count-or($actual-join"`n")-cne(@($p.names.$kind)-join"`n")){throw 'All exact names BEFORE any tests'};$lists[$kind]=$actual;$executables[$kind]=$exe}
$reports=@{};foreach($kind in @('domain','contracts')){$value=RunUnit $executables[$kind] '--test-threads=1';$value.sha256=$p.artifacts.$kind.sha256;$value.names=$lists[$kind];WriteNew (Join-Path $case ($kind+'-result.json')) $value;$reports[$kind]=$value}
$value=@{id=$p.id;platform='windows';profile=$p.profile;manifest_sha256=$p.manifest_sha256;runner_sha256=$p.runner_sha256;scripts=$p.scripts;linux_proof_sha256=$p.linux_proof_sha256;reports=$reports;bootstrap_administrator_units=$true;local_service_proof=$false;environment_cleared=$true;product_state_writes=$false;rmm_jobs=$false};WriteNew (Join-Path $case 'result.json') $value;$value|ConvertTo-Json -Depth 16 -Compress
'''
def check_result(manifest, platform, value, payload):
require(value.get('id') == payload['id'] and value.get('platform') == platform and value.get('profile') == PROFILE
and value.get('manifest_sha256') == payload['manifest_sha256'] and value.get('runner_sha256') == manifest['runner_sha256']
and value.get('scripts') == manifest['scripts'] and value.get('product_state_writes') is False and value.get('rmm_jobs') is False
and value.get('environment_cleared') is True and set(value['reports']) == set(KINDS), 'complete native original binding')
if platform == 'linux': require(value.get('network_namespace') is True, 'actual Linux netns proof')
else: require(value.get('linux_proof_sha256') == payload['linux_proof_sha256'] and value.get('local_service_proof') is False, 'original Linux proof and honest account scope')
for kind, item in value['reports'].items():
require(item['names'] == EXPECTED[platform][kind] and item['sha256'] == manifest['artifacts'][platform][kind]['sha256']
and item['exit_code'] == 0 and item['timed_out'] is False, 'all native exact test names/artifacts/exits')
raw = base64.b64decode(item['stdout_b64'], validate=True); errors = base64.b64decode(item['stderr_b64'], validate=True)
require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded native outputs')
check_output(raw, COUNTS[platform][kind])
def execute(path, platform, access_root, case_id=None):
setup_state(); path = path.absolute(); manifest = verified(path, new_run=case_id is None)
prefix = access_settings(access_root, platform)
if case_id is None:
case_id = str(uuid.uuid4()); folder = STATE / case_id; folder.mkdir(mode=0o700)
payload = dict(id=case_id, profile=PROFILE, manifest_sha256=sha(path), runner_sha256=manifest['runner_sha256'], scripts=manifest['scripts'],
artifacts={kind: {k: manifest['artifacts'][platform][kind][k] for k in ('sha256', 'bytes')} for kind in KINDS}, names=EXPECTED[platform])
if platform == 'windows':
proof_path = path.parent / 'linux-passed.json'; proof = load(proof_path)
require(proof['verified'] is True and proof['manifest_sha256'] == sha(path), 'same-manifest real Linux proof FIRST')
linux_payload = dict(payload, id=proof['case_id'], artifacts={kind: {k: manifest['artifacts']['linux'][kind][k] for k in ('sha256', 'bytes')} for kind in KINDS}, names=EXPECTED['linux'])
check_result(manifest, 'linux', proof['native'], linux_payload)
payload['linux_proof_sha256'] = sha(proof_path)
intent = dict(id=case_id, platform=platform, manifest_path=str(path), manifest_sha256=sha(path), runner_sha256=sha(__file__),
scripts=scripts(), access_root_sha256=hashlib.sha256(str(access_root.absolute()).encode()).hexdigest(), payload=payload)
save(folder / 'intent.json', intent)
save(folder / 'started-local.json', dict(create_once=True, no_retry=True))
run_read = False
else:
require(str(uuid.UUID(case_id)) == case_id, 'original canonical case id')
folder = STATE / case_id; private(folder, True); intent = load(folder / 'intent.json'); load(folder / 'started-local.json')
require(intent['id'] == case_id and intent['platform'] == platform and intent['manifest_path'] == str(path)
and intent['manifest_sha256'] == sha(path) and intent['runner_sha256'] == sha(__file__) and intent['scripts'] == scripts()
and intent['access_root_sha256'] == hashlib.sha256(str(access_root.absolute()).encode()).hexdigest(), 'immutable same-case readback')
payload = intent['payload']; run_read = True
rpc = linux_rpc if platform == 'linux' else windows_rpc
if not run_read:
result = rpc(prefix, dict(payload, action='prepare'), folder)
save(folder / 'prepared-remote.json', result); require(result == dict(id=case_id, prepared=True), 'fresh fixed case prepared')
for kind in KINDS:
destination = LINUX_REMOTE + '/' + case_id + '/' + kind if platform == 'linux' else '/C:/ProgramData/RustDiscoveryBootstrap/windows-profile-' + case_id + '/' + kind + '.exe'
upload(prefix, manifest['artifacts'][platform][kind], destination, folder, kind)
result = rpc(prefix, dict(payload, action='read' if run_read else 'run'), folder)
save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), result)
if result.get('status'):
require(run_read and result.get('id') == case_id and result['status'] in ('remote_case_absent', 'prepared_without_start', 'started_without_result'), 'fixed read-only incomplete status')
print(json.dumps(dict(verified=False, platform=platform, case_id=case_id, status=result['status'], retry_allowed=False))); return
check_result(manifest, platform, result, payload)
proof = dict(verified=True, case_id=case_id, platform=platform, manifest_sha256=sha(path), runner_sha256=manifest['runner_sha256'], native=result)
destination = path.parent / (platform + '-passed.json')
if destination.exists(): require(load(destination) == proof, 'preserve identical native proof')
else: save(destination, proof)
save(folder / 'verified.json', dict(verified=True, proof_sha256=sha(destination))) if not (folder / 'verified.json').exists() else require(load(folder / 'verified.json') == dict(verified=True, proof_sha256=sha(destination)), 'same verified receipt')
print(json.dumps(dict(verified=True, platform=platform, case_id=case_id, tests=sum(COUNTS[platform].values()),
manifest_sha256=sha(path), proof_sha256=sha(destination))))
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('build-local', 'linux', 'windows', 'readback-linux', 'readback-windows'))
parser.add_argument('--manifest', type=Path); parser.add_argument('--case'); parser.add_argument('--access-root', type=Path)
parser.add_argument('--execute-native-tests', action='store_true'); args = parser.parse_args()
if args.action == 'build-local':
require(not (args.manifest or args.case or args.access_root or args.execute_native_tests), 'local build only'); build()
elif args.action.startswith('readback-'):
require(args.manifest and args.case and args.access_root and not args.execute_native_tests, 'original case readback only')
execute(args.manifest, args.action.removeprefix('readback-'), args.access_root, args.case)
else:
require(args.manifest and args.access_root and args.execute_native_tests and not args.case, 'explicit new native platform run')
execute(args.manifest, args.action, args.access_root)
if __name__ == '__main__':
try: main()
except Exception as error:
print(json.dumps(dict(error='WINDOWS_PROFILE_QUALIFICATION_INCOMPLETE', error_class=type(error).__name__, details_suppressed=True)))
raise SystemExit(2) from None
+1 -1
View File
@@ -1,6 +1,6 @@
# Linux-first-Entwicklung und reale VM-Abnahme
Stand: 2026-11-14 · Spezifikation 1.18. Das begrenzte Linux-MVP ist inzwischen
Stand: 2026-11-14 · Spezifikation 1.19. Das begrenzte Linux-MVP ist inzwischen
dokumentiert abgenommen; aktuelle Nachweise stehen in [handover.md](handover.md).
Die getrennte Windows-SYSTEM-Grenze ist in Spezifikation0.1 und
[windows-system-policy.md](windows-system-policy.md) präzisiert; Quellen-/Build-
-12
View File
@@ -53,18 +53,6 @@ Zugänge und private Rohbelege bleiben gitignoriert.
## Aktuelle Windowsfortsetzung
Separater Profilbranch `codex/windows-powershell-profile`, Commit `abea4eb`:
RemoteSigned als optionales festes Aktions-/Variantenfeld implementiert, alte
Bytes erhalten, UI-Planansichten streng gebunden. Lokal Rust-/Server-/35Web-
Prüfungen bestanden; danach nativ Cloud-Linux23 ohne Skips, Fall `f463acc9…`,
Manifest `26247a3a…`. Windows22 weiterhin nicht nativ ausgeführt, keine
Profilcapability veröffentlicht und kein PowerShelljob gestartet. Der
Hauptcheckout bleibt für die Komponentenwartung unverändert. Quellen/Nachweise:
[Profilbranch](https://gitea.incoso.eu/kevin_janssen/rust-discovery/src/branch/codex/windows-powershell-profile).
Ein separat tatsächlich bestätigter Schemars-Nullable-Metadatenunterschied
betrifft keine Berechtigung; sein enger Attributfix wird im isolierten folgenden
M3-Schnitt mitgeführt. Der ursprüngliche Nativebeleg wird nicht umgeschrieben.
Neue Userentscheidungen1.18: RemoteSigned nur für den einzelnen zuvor in der
WebUI genehmigten PowerShell5.1-Jobprozess, vor Genehmigung sichtbar und fest
gebunden; bestehendes W32Time gezielt starten ohne Startart-/NTP-/ACLänderung;
+1 -2
View File
@@ -1,6 +1,6 @@
# Entdeckungen und Aufgaben nach dem Linux-MVP
Stand 2026-11-14. Die begrenzten Linux-[M0–M5-Gates](mvp-gates.md) sind
Stand 2026-11-13. Die begrenzten Linux-[M0–M5-Gates](mvp-gates.md) sind
abgeschlossen. Windows wird auf eigenen Auftrag fortgesetzt; seine aktuellen
Voraussetzungen stehen in [Windows-Gates](windows-gates.md) und
[Jobgrenze](windows-job-boundary.md). Diese Liste erweitert den Auftrag nicht.
@@ -10,7 +10,6 @@ Pfad bleiben dort sofort relevant.
| Entdeckung / späteres Thema | Tatsächlicher heutiger Stand | Spätere Aufgabe |
| --- | --- | --- |
| Dev-Reversetunnel ohne Zielbanner | Windows-RMM-Heartbeats liefen tatsächlich weiter, während Serverlistener/TCP-Verbindung auf127.0.0.1:22240 vorhanden waren, aber kein SSH-Banner durchkam. Der Bootstraploop überwacht nur das äußere ssh.exe und verbindet nach dessen Ende neu; der Task hat kein RestartOnFailure. Konkrete Ursache des blockierten SSH-Ziels unbewiesen. Keine SSH-/Hostkey-/Expirygrenze gelockert. | Nach dem MVP begrenzte Transport-/Workerdiagnose verbessern. Keine automatische Schlüsselverlängerung, öffentliche Windowsportfreigabe oder pauschalen sshd-/UID-Resets. Der aktuelle manuelle Konsolenneustart bleibt ausdrücklich zeitlich abzustimmen und ist kein RMM-Rebootnachweis. |
| Legacy-Syncflag ohne signierten Sync | Bei Clients ohne `rmm.sync.v1` setzt der bisherige Hello-Kompatibilitätspfad `sync_ready=true`. Auf dem passiven Windowsclient nach Serverneustart tatsächlich beobachtet; weiterhin keine Jobcapabilities und kein signierter Syncnachweis. | In Status/API `sync_required`, Unterstützung und tatsächlichen signierten Checkpoint trennen. Das Legacyflag niemals als Windows-Jobabnahme verwenden. |
| Nichtstart zwischen Grant und Helperdelegation | Beim Windows-SCM-Source-Review2026-11-14 wurde eine lokale Consumption ohne Helperzeile als strenger Sync-Fault erkannt. Die Linux-Root-Quelle besitzt strukturell denselben frühen Pfad; dieser konkrete Linuxfall wurde noch nicht nativ reproduziert. Aktuelle Rootscope bleibt geschlossen. | Vor Wiederöffnung für weitere Rootjobs den engen Vor-Delegation-Cancel-/Fencefall reproduzieren und analog gebunden lösen; keine Missing-Row-Guardlockerung oder Historienänderung. Der aktuelle Windowsfixvertrag steht in Spec1.17/[Abandonvertrag](windows-system-abandon.md). Historische Linux-Abnahmen werden dadurch nicht rückwirkend als dieser Nachweis ausgegeben. |
| Rohoutput und kanonischer Sync-Outcome | Das vorhandene Sync-Outcome-Limit von 512 KiB betrifft JSON; Zahlenarrays können den erlaubten Rohoutput deutlich vergrößern. Kleine bisherige MVP-Fixturen sind davon nicht betroffen. | Vor breiter Freigabe großer Ausgaben effektive Adapterlimits, Codec-/Kontrollnachrichtenbudget und gegebenenfalls Artefaktreferenzen konsistent qualifizieren. Keinen erfolglosen Sync als übernommen ausgeben. |
+22 -1
View File
@@ -1,6 +1,27 @@
# Verbindliche Projektentscheidungen
Stand: **2026-11-14**, Spezifikation **1.18** (`Rust_RMM_Implementierungsspezifikation.md`). Die ausdrücklichen normativen Entscheidungen in Kapitel 0 haben Vorrang vor früheren Architekturannahmen. Version 1.6 ersetzt die lokale Servertopologie durch den dedizierten Internetserver; Version 1.7 präzisiert das Notebook als reinen Entwicklungsrechner; Version 1.8 erlaubt vorgezogene parallele Windows-Entwicklung.
Stand: **2026-11-14**, Spezifikation **1.19** (`Rust_RMM_Implementierungsspezifikation.md`). Die ausdrücklichen normativen Entscheidungen in Kapitel 0 haben Vorrang vor früheren Architekturannahmen. Version 1.6 ersetzt die lokale Servertopologie durch den dedizierten Internetserver; Version 1.7 präzisiert das Notebook als reinen Entwicklungsrechner; Version 1.8 erlaubt vorgezogene parallele Windows-Entwicklung.
## Enger Windows-M4-MSI-Schnitt (Version1.19)
Die beauftragte Windows-MVP-Fortsetzung erhält als nächsten getrennten Schnitt
zwei feste eigene MSI-Rezepte1.0 und1.0→1.1. Dies ist eine explizite technische
Präzisierung innerhalb des bereits beauftragten M4-Umfangs, keine neue pauschale
Userfreigabe für Paketwirkungen. Kapitel0 bindet vollständiges optionales
Windowsmanifest, unveränderlichen Tenantkatalog, exakte automatisch abgeleitete
Job-/Versuch-/Artefaktreferenz, neue getrennte SYSTEM-Paketerlaubnis und sichtbare
Planbytes. Alte SCM-only-Policies erteilen keine Paketrechte. Native
Installation/Upgrade/Noop bleiben jeweils eigene WebUI-genehmigte Jobs.
APT-/Windowsmanifest schließen sich aus; alte Linuxbytes und freie Linux-
Artefaktpfade behalten ihre bisherigen Verträge. Kein freier Installer oder
Rezeptargumentvektor, kein Repair/Downgrade/Fresh1.1, keine EXE-/Skript-/Reboot-
Erlaubnis in diesem Schnitt. Cache-/Provider-/Installerwirkung bleibt bei
Abandon ausgeschlossen. Noop und tatsächliche Nachbedingungen müssen innerhalb
des ursprünglichen Budgets unter gültigem Clock-/Fence-/Abbruchkontext liegen.
Ein später belegter Zustand heilt keinen Timeout. Die ursprünglichen MSI-
Artefakt- und Nativeberichte bleiben unverändert. Quelle/Build/Unitnachweis
öffnet keine Capability und ist keine tatsächliche Paketabnahme.
## Begrenzte Windowsfreigaben des Users (Version1.18)
@@ -0,0 +1,65 @@
# Native M3-Eventlog-Vertragsprüfung
`deploy/windows_eventlog_acceptance.py` ist ein neuer, separater Bootstraprunner.
Der unveränderte Profilrunner und dessen16/7- beziehungsweise16/6-Belege bleiben
readbackfähig. Neuer Namespace: `windows-eventlog-contracts`.
Der neue Pack enthält ausschließlich Domain-Lib17 und Core-Contracts7 auf Linux,
danach Domain-Lib17 und Core-Contracts6 auf Windows. Der Unix-OpenSSL-Paritätstest
entfällt unter Windows. Server-/Windows-M3-Quellen werden zusätzlich exakt an den
geprüften Stand gebunden, einschließlich Schemars-Metadatenfix und Gateway-
Ergebnisprüfung. Diese Adapterquellen werden durch die beiden Vertrags-EXEs
**nicht** als native Eventlogprovider qualifiziert. Es gibt weder Liveabfrage
noch RMM-Job, Capabilityaktivierung, Dienst-/Produktdatenbank-/PKIänderung.
Tatsächlich auf Cloud-Linux bestanden:24Prüfungen ohne Skips, Fall
`6f9bdfb7-3902-462e-a08f-ec612e36c635`. Gemeinsamer Build
`afb44f9b-8040-4efa-ac2c-fd6c3a43f8a6`, Manifest-SHA256
`ed1371e9b058f8e7f874b071fcfce1bc409769546d5e63235295adadb5ec1de7`,
Linuxproof-SHA256
`d37ce1644dd169c932176e3e9bd33cee22b9fa4698e9faa0f5aea0f2de09f7d4`.
Anschließend bestanden auf der Windows-VM alle23Prüfungen ohne Skips, Fall
`ccb258a7-5930-4e02-b955-d522f98f0c36`, Windowsproof-SHA256
`ee1ba206637f2465e7a066b6e23ca2f8bf9b57c0ae08ddc80fe23e0199b027e1`.
Dieser Beleg bindet denselben Build und den ursprünglichen Linuxproof.
Der lokale Build mit
98identischen Vorher-/Nachher-Inputs, vier erhaltenen Original-Linkdateien,
beiden Ziel-Clippyprüfungen und24lokalen Linux-Vertragstests ist bestanden.
Der lokale Offlinebuild erhält Original-Linkdateien neben gestrippten
Lieferkopien, prüft Clippy für beide Vertragsziele und führt die tatsächlichen
Linux-Lieferbytes mit exakter Liste und ungefiltert aus. Windowslisten bleiben
bis zur tatsächlichen Windowsausgabe erwartet. Vor/nach müssen sämtliche
gebundenen Cargo-/Toolchain-/Domain-/Core-/Protocol-/Proto-/Server-/Windows- und
Runner-/Bootstrapquellen gleich sein. Ein weiterer Backend-/PG-Testlauf ist
nicht Bestandteil dieses Runners.
**Aufrufschema; beide obigen nativen Fälle tatsächlich ausgeführt:**
```sh
python3 deploy/windows_eventlog_acceptance.py build-local
python3 deploy/windows_eventlog_acceptance.py linux --manifest devstate/windows-eventlog-contracts/build-UUID/manifest.json --access-root /ABSOLUTER/PFAD/ZUM/HAUPTREPO --execute-native-tests
python3 deploy/windows_eventlog_acceptance.py windows --manifest devstate/windows-eventlog-contracts/build-UUID/manifest.json --access-root /ABSOLUTER/PFAD/ZUM/HAUPTREPO --execute-native-tests
```
Artefakte und lokale Belege bleiben im isolierten Eventlogworktree. Ausschließlich
`--access-root` liest bei ausdrücklicher nativer Ausführung streng geparste
bestehende SSH-Konfigurationen für Cloud-Linux116.203.20.85 beziehungsweise den
bekannten gepinnten Windows-Reversezugang. Keine Credentialkopie oder neue
Hostkeyannahme. Windows bindet den SHA256 des zuvor tatsächlich verifizierten
Linuxbelegs desselben Manifests.
Jeder native Fall hat eigene Create-once-Intents und Startbelege. Linux nutzt
privaten Rootscratch, geleerte Umgebung und eigene Netzwerknamespace. Beide
Plattformen prüfen vor dem ersten Teststart die vollständigen Testnamen beider
Programme. Windows läuft als Bootstrapadministrator, kein LocalService-Nachweis.
Ausgaben und Transportfehler bleiben privat; stdout enthält nur Status und
Nachweishashes.
Nach Antwortverlust ausschließlich `readback-linux` beziehungsweise
`readback-windows` mit ursprünglichem Manifest, `--case UUID` und `--access-root`.
Readback lädt nichts hoch und startet nichts neu. Er bindet unveränderliche
Originalintents, Manifest sowie Runner-/Remotescripthashes; spätere
Produktquellenänderungen erzwingen keinen neuen Lauf. Nur neue Starts benötigen
den aktuellen exakt qualifizierten Quellstand. Unvollständige Fälle bleiben
unvollständig; kein automatischer zweiter Versuch.
+55
View File
@@ -0,0 +1,55 @@
# Windows-M3: begrenztes Ereignisprotokoll
Stand2026-11-14: Quelle implementiert und unabhängig gegenseitig geprüft,
noch nicht auf dem Windowsgast installiert oder als RMM-Aktion ausgeführt.
Der isolierte Branch enthält auch das bereits separat nativ qualifizierte
optionale PowerShell-Prozessprofil. Keine Capability wurde veröffentlicht.
`query_logs` bindet ausschließlich Quelle
`windows.eventlog.application.rustdiscovery-mvp-test`, Kanal `Application`
und Provider `RustDiscovery-MVP-Test`. Erforderlich sind Windows-/Sync- und
eigene Fixturecapability, `logs:read` und `agent_service`. Kein SYSTEM-Logpfad,
kein freies XPath, kein angeforderter Liveabruf als passives Inventar.
UTC-Zeitfenster höchstens24Stunden, höchstens65536Ausgabebytes und feste
innere5Sekunden-Grenze; äußerer Jobrahmen10–120Sekunden. Alle Werte stehen
aus hashgeprüften gespeicherten Planbytes vor der WebUI-Genehmigung fest.
Die synchrone native Eventlog-API läuft im begrenzten eigenen Prozess innerhalb
des vorhandenen atomaren JobObjects. Der Child prüft tatsächlichen LocalService-
Token samt Agent-Service-SID, echten SCM-/Kernel-Elternprozess, geschützte
Konfiguration, signierten Originalrequest, aktuelle qualifizierte Uhr und Boot,
den bereits dauerhaft gebuchten Verbrauch/Start samt tatsächlichem SQLite-
Dateihandle sowie einen einmaligen Startmarker. Der Aufruf über den festen
CLI-Modus allein verleiht keine Berechtigung. Keine Schlüssel-/Requestbytes
auf der Kommandozeile. Uhr-/Jobgates bleiben geschlossen.
Worker und Server prüfen konkrete Herkunft, Zeitfenster, Budget, Vollständigkeit
und Fehler. Bekannte Ereignis-/Byte-/Einzelereignisgrenzen bleiben ausdrücklich
partiell; Zeitüberschreitung oder Berechtigungsfehler werden kein vollständiger
Erfolg. Eine im Review gefundene Lücke im serverseitigen Successguard wurde
geschlossen: `win32_error` ausdrücklichnull, kein Neustartbedarf und generisches
Kürzungsflag identisch zur konkreten Evidenz.
Lokal tatsächlich bestanden:238Rusttests, ein isolierter PostgreSQL-Fall und
38Webtests samt Typecheck/Build/Clippy. Der PG-Fall prüfte unter anderem fehlendes
`logs:read`, verlorene Capability und `pending_approval` mit0Jobs/Outbox/Grants.
Nach dem Successguard-Fix wurden dessen bestehende Mutationsmatrix und
Server-Clippy gezielt erneut ausgeführt. Drei portable Provider-/Ergebnistests
liefen tatsächlich im Linux-Buildcontainer; zwei Windows-Workerprüfungen sind
bisher nur crosskompiliert. Keine dieser Ebenen ersetzt den Nativepfad.
Private Quellenbelege: `devstate/windows-eventlog-backend/qualification.json`
(`facab5cc…`), `qualification-success-flags.json` (`f5972644…`) und
`devstate/windows-eventlog/windows-source-qualification.json` (`feb16e79…`).
Die gesonderte Vertragsabnahme ist zuerst auf Cloud-Linux24, danach Windows23
ohne Skips bestanden. Manifest `ed1371e9…`; Linuxfall `6f9bdfb7…`, Windowsfall
`ccb258a7…`. [Native Runnerdokumentation](windows-eventlog-contract-acceptance.md)
hält genaue Bindungen und Grenzen fest. Kein Live-Eventlog-/Workerrollenbeweis.
Weiter offen: reale LocalService-Eventlog-API, eigene Fixtureereignisse,
Filter-/Zeit-/Ausgabe-/Fehlergrenzen und vollständiger WebUI-genehmigter Job.
Keine Registrierung oder Erhebung auf dem Ziel wurde durch diese Quellarbeiten
ausgeführt. Der Schemars-Attributfix entfernt lediglich die irreführende
Nullable-Angabe des optionalen Prozessprofils; strikte Deserialisierung und
fehlendes Feld bleiben unverändert. Die vorherigen Nativebelege bleiben an
ihre ursprünglichen Quellen gebunden.
+89
View File
@@ -0,0 +1,89 @@
# Gemeinsame MSI-Verträge: Linux-first-Unitpack
Der neue Runner `deploy/windows_msi_contract_acceptance.py` gehört zum isolierten
Worktree `rust-discovery-windows-msi-integration`. Historische M3-, Profil- und
NoStart-Runner sowie ihre ursprünglichen Manifeste bleiben unverändert.
Dieser Pack prüft gemeinsame Daten-/Autorisierungs-/Ledger-/Syncverträge und die
bestehenden selbstisolierten Unixhelper-Dateiguards. Er installiert kein MSI,
startet keinen RMM-Dienst, verändert keine Produktjournale oder Identitäten und
erzeugt keine Jobs oder Genehmigungen. Insbesondere ist er kein tatsächlicher
SYSTEM-, Clock-, Cache-, Download-, Installer- oder WebUI-Wirkungsnachweis.
## Exakte Listen und Quellen
Die zunächst tatsächlich lokal aus den Release-Testprogrammen ermittelten
Linuxlisten enthalten Domain20, Corecontracts8, Helpersync26, Agentsync26 und
Unixhelper21: insgesamt101 Fälle. Der zusätzliche MSI-Corevertrag heißt
`historical_msi_nonstart_keeps_full_signature_binding_and_never_becomes_root_authority`.
Die später tatsächlich nativ bestätigte Windowsliste enthält
20+7+26+26=79. Nur der Unix-OpenSSL-Vergleich und die gesamte
Unixhelper-Dateiguardsuite entfallen dort. Es gibt keine Mindestzahlen oder
Überspringen/Filtern von Fällen zur Erfüllung dieser Zahlen.
Das Manifest bindet68 Quellen einschließlich vollständiger Domain-/Core-/
Unixhelper-/Linuxadapterquellen, Cargo-/Protoinputs, eng benötigter Fixtures,
des neuen Runners und seiner Bootstraptransportquellen vor/nach dem Build.
Die13 separat geprüften Domain-/Backend-/SQL-Pins sind exakt an den lokalen
Qualifikationsbeleg `b7bced0a341ffb88af8b584cbe8355ff1021add541004347f609f6136a684b74`
gebunden. Diese Backendpins sind ausschließlich Quellenbindung: der Unitpack
führt weder PostgreSQL noch einen Server aus. Webquellen sind kein Compilerinput
und gehören zum unabhängigen UI-Nachweis ihres Owners.
## Tatsächlich lokal ausgeführt
Linux- und Windows-GNU-Clippy der ausgewählten Pakete mit allen Targets und
`-D warnings`, Release-Linken der fünf Linux- und vier Windows-Testprogramme,
Prüfung beider Dateiformate und der unveränderten Original-Links waren erfolgreich.
Alle fünf tatsächlichen Linux-Lieferdateien wurden mit vollständiger Liste und
101 erfolgreichen, ungefilterten Tests im isolierten Offlinecontainer geprüft.
Alle Linux-Dateien referenzieren maximal GLIBC2.34. Nur Auslieferungskopien wurden
von Debuginformationen befreit; `.linked`-Originale bleiben separat erhalten.
Python-Syntax und PowerShell-AST sind geprüft. Enge lokale Driverguards verweigern
fehlende/doppelte/fremde Listen und übersprungene/gefilterte Resultate. Ein
Mocklauf ohne Zielaufruf verlor die Antwort nach dem alleinigen Ausführungsaufruf;
der nachfolgende gleichnamige Readback lud keine Artefakte erneut hoch und
startete keinen Test erneut. Beide Plattformen verlangen sämtliche tatsächlichen
Listen vor irgendeinem Unitfall. Teilbelege bleiben create-only erhalten.
Geschütztes lokales Buildmanifest:
`devstate/windows-msi-contracts/build-484a3761-6c84-426f-968d-25a638e9c6f7/manifest.json`,
SHA256 `2d96a07be72f3d71a8097510eb5f647ced6577086a45417c599b772018c29a53`.
Die reine lokale Listenerhebung davor sowie Compiler-/Fehlerausgaben bleiben
privat erhalten. Es wurden durch diesen Arbeitsschritt keine VM-/SSH-Aufrufe,
Upload-, Server-, Dienst-, Registry- oder Installeraktionen ausgeführt.
## Native Abnahme und deren Grenzen
Nach unabhängiger Prüfung führt Root zuerst dieselben Lieferdateien auf der
tatsächlichen Linux-VM aus. Erst deren erfolgreicher, unveränderlich an dasselbe
Manifest gebundener Beleg erlaubt die Windows-Unitphase. Native Ausführung ist
ein ausdrücklicher CLI-Schritt mit dem ursprünglichen Main-`--access-root` nur
für den vorhandenen gepinnten SSH-Transport. Zugangsdaten und Main-`devstate`
werden weder kopiert noch verlinkt; alle neuen lokalen Belege bleiben im Worktree.
Beide Zielseiten erhalten eigene create-only Bootstrapfälle unter
`windows-msi-contracts`. Vor Tests müssen alle fünf beziehungsweise vier
nativen Listen exakt stimmen. Antwortverlust erlaubt ausschließlich denselben
Fall zu lesen, auch bei fehlenden oder unvollständigen Ergebnissen; kein Retry
oder automatisches Resume. Unter Linux laufen die Units zusätzlich in einem
neuen Netzwerknamespace mit begrenztem Prozess-/Ausgabebudget; ihre temporären
Dateien gehören zum eigenen Bootstrapfall. Windows läuft ehrlich als
Bootstrapadministrator, nicht als Produkt-LocalService oder SYSTEM-Executor.
Auf der tatsächlichen Cloud-Linux-VM anschließend alle101Prüfungen ohne Skips
bestanden: Fall `d015f861-e459-4b82-8ce5-460c3e4c570c`, gemeinsames Manifest
`2d96a07be72f3d71a8097510eb5f647ced6577086a45417c599b772018c29a53`,
Linuxproof-SHA256
`09fa24e32cd3f3563e80e91265c6cc7c612321b0fdd1febe7aef3ab6de53cf2a`.
Anschließend nach dem ausdrücklich bestätigten manuellen Konsolenneustart
auf der Windows-VM alle79Prüfungen ohne Skips bestanden: Fall
`1b1aeff3-a08f-4760-8225-8247df451fec`, Windowsproof-SHA256
`666ed196953abd0723de259a898b46c08ac84feee0140f1bb31d9db1fa1232c4`.
Der Windowsbeleg bindet denselben Manifest- und originalen Linuxproofhash.
Alle vier nativen Listen wurden vor irgendeinem Test exakt geprüft; keine
Produktdienste oder Produktdaten geändert. Der reine Unit-PASS
ist keine Installation-/Upgrade-/Noop-Abnahme: jede tatsächliche
Paketwirkung benötigt weiterhin ihren eigenen unveränderlichen Antrag und die
Genehmigung in der WebUI.
+90
View File
@@ -0,0 +1,90 @@
# Windows-M4: Domain und Backend
Stand2026-11-14, Spezifikation1.19. Implementierter und unabhängig geprüfter
Quellenschnitt im Branch `codex/windows-msi-integration`; **kein Clouddeployment
und keine native Paketabnahme**. Die folgenden Teile ergänzen die getrennten
[MSI-Providerquellen](windows-msi11-source.md).
`ensure_package` erhält das optionale, bei Vorhandensein strikt objektförmige
`windows_msi_manifest`. Intern Box, auf dem Draht unverändertes flaches
Rezeptobjekt; fehlend ausgelassen. Explizites Null, unbekannte Felder und
Objektformen der String-Enums werden verweigert. APT und MSI schließen sich aus.
Nur `msi`/`rmm-windows-msi-fixture`/`x64`/`machine`/SYSTEM mit exakt gebundener
Rezept-ID/-Version und gewünschter Produktversion. Alte Linux-Goldenbytes bleiben
erhalten. MSI-Jobrahmen10–120Sekunden und1024–65536Ausgabebytes.
Eigener unveränderlicher Windows-MSI-Katalog mit Migration0014, FORCE-Tenant-RLS,
zusammengesetztem Tenant-/Artifact-ID-/SHA-/Längen-FK und bestehenden interaktiven
Katalogrechten. Import/List sind vom APT-Katalog getrennt. Pro MSI-Job/Versuch
wird genau eine Artefaktreferenz automatisch aus dem Rezept abgeleitet; freie
`artifact_ids` sind hier verboten. Fehlende, zusätzliche oder doppelte Artefakte
und abweichende gesamte Rezeptmengen werden bei Planung, Revalidation,
Zustellung, Permit und Geräte-mTLS-Download verweigert. Linux-Artefaktpfade
behalten ihre bisherigen Verträge.
SYSTEM-Policyversion2 verlangt die eigene explizite Allowlist von höchstens
zwei vollständigen MSI-Rezepthashes, bestehende Geräte-/Principal-/Helperpins,
`system:execute` und getrennte Paketcaps. Schema1 bleibt SCM-only und verweigert
MSI. Die historische Core-Nichtstartprüfung kennt nur den zusätzlichen exakt
validierten MSI-Actiontyp; keine Missing-Row-/Signatur-/Lineageausnahme,
Installer- oder Cachewirkung durch Abandon.
Tatsächlich lokal bestanden:118betroffene Domain-/Core-/Servertests, danach
gezielter Test der verschärften vollständigen Rezeptmenge; isolierter realer
PostgreSQL-Fall mit Migration/RLS/Tenant-FK/Immutabilität/Planreferenzmutationen
und `pending_approval` mit0Jobs/Outbox/Permits. Fehlendes `system:execute`
verweigert. Fünf bestehende Serverfälle bleiben ausdrücklich ignoriert.
Linux-Clippy einschließlich Agent/privilegiertem Helper und WindowsGNU-
System-helper-Alltargets sowie Format-/Diffprüfung bestanden.
Der erste PG-Lauf belegte einen unnötigen `FOR SHARE`-Lock, der zusätzliche
UPDATE-Rechte erfordert hätte. Ausschließlich der Lock wurde entfernt;
Unveränderlichkeit/SELECT-/INSERT-Rechte bleiben erhalten. Fehlversuchslog
privat unverändert. Der erfolgreiche PG-Fall nutzte ausdrücklich opake
Metadaten-Testbytes, kein tatsächlich geprüftes oder installiertes MSI.
Lokaler Beleg `devstate/windows-msi-integration/local-qualification.json`,
SHA256 `b7bced0a341ffb88af8b584cbe8355ff1021add541004347f609f6136a684b74`,
bindet13Quelldateien. Unabhängiger Quellenreview ohne weiteren konkreten Blocker.
Weiter offen: Windows-Nativevertragsnachweise, tatsächliche WebUI-Abnahme,
Windowsdownload und geschützter SYSTEM-Cache, Helper-/Runtimeverdrahtung und
jeweils echte WebUI-genehmigte Installation/Upgrade/Noops. Keine Capability,
Helperpolicy oder Clock-/Jobkonfiguration auf der VM wurde geöffnet. Die
vorherige UI verweigerte SYSTEM-Nicht-SCM-Pläne bis zum folgenden separaten
Schnitt. Quellen/Units sind keine Paketfreigabe.
## Getrennter WebUI-Quellenschnitt
Feste SYSTEM-MSI-Auswahl und eigener kleiner Katalogbereich implementiert;
APT bleibt getrennt. Anzeige enthält Product-/Upgrade-/gegebenenfalls1.1-
PackageCode, Version, Artifact/Rezept/Nutzdateihashes, Vorgänger, feste Argumente
und No-Reboot-/Budgetvertrag. Sie stammt aus kopierter typisierter Projection
hashgeprüfter gespeicherter Planbytes. Alle Preview-Aliase und spätere Änderungen
werden vor Anzeige sowie erneut vor Submit/Genehmigung geprüft. Keine neue
Genehmigungsabkürzung oder Policy-/Capabilityveröffentlichung.
Rootreview fand einen echten Codecfehler: die erste UI-Fassung erwartete
`apt_manifest:null`, Rust lässt `None` tatsächlich aus. Die ursprünglichen
TS-Fixtures spiegelten diesen Fehler. Eng korrigiert: gespeicherte MSI-Actions
verlangen das fehlende Feld; nur das Formular akzeptiert fehlend/null, kein
APT-Objekt. Zwei echte, vom unveränderten Rust-Domaincodec erzeugte synthetische
PlanPayload-Goldens1.0/1.1 werden nun im bestehenden Webtest verifiziert und
gerendert. Keine Signer, realen Geräte oder Nativewirkungen in diesen Fixtures.
Abschließend42Webtests, Typecheck und Build bestanden; fünf Webdateien und
sämtliche Webinputs vor/nach gebunden, Rust13 unverändert. Neuer privater Beleg
`devstate/windows-msi-ui/wire-fix-955acab2-35af-4507-bb2b-d7cd1fa49347/qualification.json`,
SHA256 `f84d4962ab9a6ef64ef0327fcf7c524efb0bd4064d2416f174a9dfffb524a8a1`.
Der ursprüngliche `fe02…`-Beleg bleibt historisch und ist ausdrücklich wegen
des Codecfehlers abgelöst. Kein Clouddeployment, Browser-Nativlauf, Installer-
oder tatsächlicher WebUI-Freigabenachweis durch diese Quelltests.
## Tatsächlicher Linux-first-Vertragsnachweis
Auf der tatsächlichen Cloud-Linux-Test-VM bestanden anschließend alle101
ungefilterten Prüfungen ohne Skips: Domain20, Corecontracts8, HelperSync26,
AgentSync26 und Unixhelper21. Fall `d015f861-e459-4b82-8ce5-460c3e4c570c`,
Manifest `2d96a07b…`, Proof `09fa24e3…`. Nur eigene isolierte Unitprogramme,
kein RMM-Job, Dienst-/Agentdeployment, Produktjournal-/Schlüsselzugriff oder
Cloudserver-/MSI-/WebUI-Nativnachweis. Windows79 sind weiterhin erwartet und
noch nicht nativ ausgeführt. [Genauer Runnervertrag](windows-msi-contracts.md).
+6 -5
View File
@@ -1,10 +1,11 @@
# Windows PowerShell5.1: feste prozessbezogene RemoteSigned-Option
Stand2026-11-14, Spezifikation1.18. **Userentscheidung dokumentiert,
Implementierungsentwurf noch nicht umgesetzt und nicht nativ abgenommen.**
Diese Arbeit liest Produktquellen und ändert ausschließlich Dokumentation.
Laufende Rust-/Artefaktbindungen bleiben unverändert. Keine VM-/Server-/Gitaktion
oder Capability-/Clock-/Jobkonfigurationsänderung gehört zu diesem Schritt.
Stand2026-11-14, Spezifikation1.18. **Userentscheidung als Sourcekandidat im
isolierten Profilbranch umgesetzt und nativ Linux-first vertraglich geprüft.**
Die23 Domain-/Coreverträge bestanden auf der Cloud-Linux-VM; Windows22 und die
tatsächliche genehmigte PowerShellwirkung bleiben offen. Keine Capability-,
Clock- oder Jobkonfiguration aktiviert, kein Deployment. Hauptcheckout und
laufende Windowsartefakte bleiben unverändert. [Tatsächlicher Nachweis](windows-profile-acceptance.md).
## Autorisierter Umfang
+65
View File
@@ -0,0 +1,65 @@
# Native Prüfung des optionalen Windows-Prozessprofils
Stand2026-11-14: implementierter und unabhängig geprüfter Profilvertrag im
isolierten Branch `codex/windows-powershell-profile`. Domain-/Server-/Original-
Grantprüfungen, isolierter PostgreSQL-Fall, beide Windows-Cross-Clippy-Profile,
35Webtests, Typecheck und Webbuild lokal bestanden. Zwei UI-Aliasbefunde und
die zunächst akzeptierte Null-/Objekt-Profilform sind eng korrigiert.
Anschließend bestanden auf der tatsächlichen Cloud-Linux-VM alle23 Vertrags-
prüfungen ohne Skips, Fall `f463acc9-ab77-4b70-bcfb-a016f40c9410`.
Gemeinsamer Build `005b26fd-8269-40dd-8a35-798fabb024a5`, Manifest-SHA256
`26247a3a9c187e8ce315250ab3bb3a8b5c1fe681028b15143fb9f193e4af9c80`,
Linuxproof-SHA256 `7ecabd9a3ca8fac20aaa7a185b6e128735ea77f143988f058829ae642ad32d25`.
Danach bestanden alle22 Windows-Vertragstests ohne Skips, Fall
`9abd3e0d-d40f-4d6f-adc8-8fdbbefb98e8`, Windowsproof-SHA256
`47cee8c9c449a45699641d53c0fca48b89a53a90dd22cfd03a2ab7675c0a348d`.
Der Windowsbeleg bindet denselben Build und den vorangegangenen Linuxproof.
Kein Deployment oder tatsächlicher PowerShell-Job; neue Profilcapability nicht
veröffentlicht. Der Hauptcheckout und seine zuvor qualifizierten Artefakte
bleiben für die ausstehende Komponentenwartung unverändert.
`deploy/windows_profile_acceptance.py` ist ein eigener Bootstrap-Nachweisrunner,
kein RMM-Executor. Er verwendet ausschließlich zwei feste Unitprogramme:
Domain-Lib16 und Core-Contracts7 auf der Cloud-Linux-VM, danach Domain-Lib16 und
Core-Contracts6 auf der Windows-VM. Nur der Unix-OpenSSL-Paritätstest entfällt
unter Windows. Es werden keine Dienste, Produktjournale, PKI, Policies,
Capabilities oder RMM-Jobs verändert. SQLite-Fixturen entstehen ausschließlich
im eigenen temporären Testverzeichnis. Die Windows-Tests laufen als
Bootstrapadministrator; sie beweisen keinen LocalService- oder SYSTEM-Job.
Der lokale Build erhält Original-Linkdateien neben den gestrippten Lieferkopien,
prüft beide Clippy-Ziele und führt die tatsächlich lieferbaren Linuxbytes lokal
mit `--list` und ungefiltert aus. Alle Workspace-Cargomanifeste, Lock/Toolchain,
Domain/Core/Protocol/Proto sowie Runner und Bootstraptransport werden vorher und
nachher gehasht. Windows-Testnamen sind bis zur nativen Ausgabe nur erwartet.
Der lokale Linuxlauf ersetzt keinen Linux-VM-Nachweis.
**Aufrufschema; obige Fälle tatsächlich ausgeführt:**
```sh
python3 deploy/windows_profile_acceptance.py build-local
python3 deploy/windows_profile_acceptance.py linux --manifest devstate/windows-profile/build-UUID/manifest.json --access-root /ABSOLUTER/PFAD/ZUM/HAUPTREPO --execute-native-tests
python3 deploy/windows_profile_acceptance.py windows --manifest devstate/windows-profile/build-UUID/manifest.json --access-root /ABSOLUTER/PFAD/ZUM/HAUPTREPO --execute-native-tests
```
`--access-root` dient ausschließlich dem streng geparsten bestehenden
SSH-Zugang: Cloud-Linux `116.203.20.85` bzw. der unveränderten gepinnten
Windows-Reverse-SSH-Kette über Cloud-Loopback22240. Keine Credentialkopien,
Symlinks oder Hostkeyänderung. Alle Artefakte und lokalen Belege bleiben im
isolierten Profilworktree. Linux läuft mit geleerter Umgebung und eigener
Netzwerknamespace. Beide nativen Phasen prüfen vor dem ersten Teststart sämtliche
Testnamen beider Programme. Windows bindet den bereits verifizierten tatsächlichen
Linux-Beleg desselben Manifests über dessen SHA256.
Jeder Fall hat eigene Create-once-Intents und Startbelege. Eine verlorene Antwort
erlaubt ausschließlich beispielsweise `readback-linux --manifest … --case UUID
--access-root …` bzw. `readback-windows`. Dieser Pfad lädt nichts hoch und startet
keinen Prozess erneut. Er kann `remote_case_absent`, `prepared_without_start` oder
`started_without_result` als unvollständigen Stand berichten. Ein neuer Fall ist
keine automatische Fehlerwiederholung. Originale Readbacks bleiben an das feste
Manifest, Intents und Runner-/Remotescripthashes gebunden; spätere Änderungen an
Produktquellen erzwingen keine neue native Ausführung und verhindern ihren
Readback nicht. Neue Starts benötigen weiterhin die exakt qualifizierten
aktuellen Quellen. Vollständige Ausgaben/Transportfehler bleiben privat,
Standardausgabe enthält nur Status, Fallkennung und Nachweishashes.
+27
View File
@@ -0,0 +1,27 @@
-- Additive immutable tenant catalog; existing APT recipes/artifact semantics stay.
ALTER TABLE artifacts ADD CONSTRAINT artifacts_tenant_identity_digest
UNIQUE (tenant_id,artifact_id,sha256,size_bytes);
CREATE TABLE windows_msi_recipes (
tenant_id uuid NOT NULL REFERENCES tenants,
catalog_id uuid NOT NULL,
recipe_id text NOT NULL CHECK(recipe_id IN ('rmm-windows-msi-fixture-install-1.0','rmm-windows-msi-fixture-upgrade-1.1')),
recipe_version text NOT NULL CHECK(recipe_version='1'),
recipe_sha256 text NOT NULL CHECK(recipe_sha256 ~ '^[0-9a-f]{64}$'),
artifact_id uuid NOT NULL,
artifact_sha256 text NOT NULL CHECK(artifact_sha256 ~ '^[0-9a-f]{64}$'),
artifact_bytes bigint NOT NULL CHECK(artifact_bytes BETWEEN 1 AND 262144),
payload bytea NOT NULL CHECK(octet_length(payload) BETWEEN 1 AND 65536),
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY(tenant_id,catalog_id),
UNIQUE(tenant_id,recipe_id,recipe_version), UNIQUE(tenant_id,recipe_sha256),
FOREIGN KEY(tenant_id,artifact_id,artifact_sha256,artifact_bytes)
REFERENCES artifacts(tenant_id,artifact_id,sha256,size_bytes)
);
ALTER TABLE windows_msi_recipes ENABLE ROW LEVEL SECURITY;
ALTER TABLE windows_msi_recipes FORCE ROW LEVEL SECURITY;
CREATE POLICY tenant_scope ON windows_msi_recipes
USING (tenant_id::text=current_setting('app.tenant_id',true))
WITH CHECK (tenant_id::text=current_setting('app.tenant_id',true));
GRANT SELECT, INSERT ON windows_msi_recipes TO rmm_app;
CREATE TRIGGER immutable_content BEFORE UPDATE OR DELETE ON windows_msi_recipes
FOR EACH ROW EXECUTE FUNCTION immutable_plan();
+18
View File
@@ -65,6 +65,24 @@ describe('JSON contract boundary', () => {
expect(() => validateInput({ ...input, parameters: { ...input.parameters, execution_identity: 'root' } })).toThrow('agent_service');
validateInput({ ...input, parameters: { ...input.parameters, variants: [{ ...windows, script_utf8: "\ufeffWrite-Output 'é'\r\n" }] } });
});
it('bounds the fixed Event Log source and exact 24h interval without rewriting Linux queries', () => {
const base: PlanInput = { tenant_id: 't', action: 'query_logs', targets: { asset_ids: ['a'] }, parameters: { execution_identity: 'agent_service', unit: 'windows.eventlog.application.rustdiscovery-mvp-test', since: '2026-11-14T00:00:00Z', until: '2026-11-15T00:00:00Z', max_lines: 1000, timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: new Date().toISOString(), start_before: new Date(Date.now()+60000).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'fixed fixture logs' };
const before = JSON.stringify(base); validateInput(base); expect(JSON.stringify(base)).toBe(before);
for (const change of [{ execution_identity: 'root' }, { execution_identity: 'system' }, { unit: 'windows.eventlog.security.other' }, { timeout_seconds: 9 }, { timeout_seconds: 121 }, { max_output_bytes: 1023 }, { max_output_bytes: 65537 }, { max_lines: 1001 }, { until: '2026-11-15T00:00:00.000000001Z' }]) expect(() => validateInput({ ...base, parameters: { ...base.parameters, ...change } })).toThrow();
const linux = { ...base, parameters: { ...base.parameters, unit: 'rmm-test.service', execution_identity: 'root', timeout_seconds: 1, max_output_bytes: 512 } }; const original=JSON.stringify(linux); validateInput(linux); expect(JSON.stringify(linux)).toBe(original);
expect(() => validateInput({ ...linux, parameters: { ...linux.parameters, until: '2026-11-15T00:59:00Z' } })).toThrow('24Stunden');
});
it('accepts only the fixed Windows process profile without changing inherited variants', () => {
const windows = { os_family: 'windows', interpreter: 'powershell', encoding: 'utf-8', script_utf8: "Write-Output 'fixed'\r\n" };
const base: PlanInput = { tenant_id: 't', action: 'run_script', targets: { asset_ids: ['a'] }, parameters: { variants: [windows], execution_identity: 'agent_service', timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: new Date().toISOString(), start_before: new Date(Date.now() + 60000).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'fixed profile fixture' };
const original = JSON.stringify(base); validateInput(base); expect(JSON.stringify(base)).toBe(original);
const profiled = { ...windows, windows_execution_profile: 'powershell_51_remote_signed' };
validateInput({ ...base, parameters: { ...base.parameters, variants: [profiled] } });
expect(() => validateInput({ ...base, parameters: { ...base.parameters, windows_execution_profile: 'powershell_51_remote_signed' } })).toThrow('Skriptvariante');
for (const windows_execution_profile of ['Bypass', 'Unrestricted', 'RemoteSigned', 'inherited', null, {}]) expect(() => validateInput({ ...base, parameters: { ...base.parameters, variants: [{ ...windows, windows_execution_profile }] } })).toThrow('Windows-Ausführungsprofil');
for (const variant of [{ ...profiled, os_family: 'linux' }, { ...profiled, interpreter: 'bash' }, { ...profiled, interpreter: 'pwsh' }]) expect(() => validateInput({ ...base, parameters: { ...base.parameters, variants: [variant] } })).toThrow();
for (const execution_identity of ['root', 'system']) expect(() => validateInput({ ...base, parameters: { ...base.parameters, execution_identity, variants: [profiled] } })).toThrow('agent_service');
});
it('allows SYSTEM only for exact bounded fixture SCM parameters without changing Linux restart', () => {
const input: PlanInput = { tenant_id: 't', action: 'set_service_state', targets: { asset_ids: ['asset'] }, parameters: { execution_identity: 'system', unit: 'RmmDiscoveryFixtureService', state: 'running', timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: new Date().toISOString(), start_before: new Date(Date.now() + 60000).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'fixed SCM plan' };
const before = JSON.stringify(input); validateInput(input); expect(JSON.stringify(input)).toBe(before);
+104 -4
View File
@@ -59,7 +59,96 @@ export const pretty = (v: unknown) => JSON.stringify(v, null, 2);
export const actions = ['run_script', 'refresh_inventory', 'query_logs', 'set_service_state', 'ensure_package', 'apply_updates', 'reboot', 'apt_native_acceptance'] as const;
export type Action = typeof actions[number];
export const windowsPowerShellRemoteSignedProfile = 'powershell_51_remote_signed' as const;
/** A missing field is inherited policy; a present field is never silently coerced. */
export function windowsScriptProfile(value: RecordValue): 'inherited' | typeof windowsPowerShellRemoteSignedProfile {
if (!Object.prototype.hasOwnProperty.call(value, 'windows_execution_profile')) return 'inherited';
if (value.windows_execution_profile !== windowsPowerShellRemoteSignedProfile || value.interpreter !== 'powershell'
|| (value.os_family !== undefined && value.os_family !== 'windows')) throw new Error('Windows-Ausführungsprofil nur powershell_51_remote_signed für Windows PowerShell5.1');
return windowsPowerShellRemoteSignedProfile;
}
export const windowsEventLogFixtureSource = 'windows.eventlog.application.rustdiscovery-mvp-test';
export const windowsEventLogFixtureChannel = 'Application';
export const windowsEventLogFixtureProvider = 'RustDiscovery-MVP-Test';
/** Preserve sub-millisecond bounds; Date.parse alone would admit 24h + 1ns. */
export function logWindow(since: unknown, until: unknown): void {
const instant = (value: unknown): bigint => {
if (typeof value !== 'string') throw new Error('Exaktes UTC-Log-Zeitfenster erforderlich');
const match = /^(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d)(?:\.(\d{1,9}))?(Z|[+-]\d\d:\d\d)$/.exec(value);
if (!match) throw new Error('Exaktes UTC-Log-Zeitfenster erforderlich');
const seconds = Date.parse(match[1]! + match[3]!);
if (!Number.isFinite(seconds)) throw new Error('Exaktes UTC-Log-Zeitfenster erforderlich');
return BigInt(seconds) * 1000000n + BigInt((match[2] ?? '').padEnd(9, '0'));
};
const start = instant(since), end = instant(until);
if (end <= start || end - start > 86400000000000n) throw new Error('Exaktes Log-Zeitfenster höchstens24Stunden erforderlich');
}
export function validateWindowsLogLimits(identity: unknown, runtime: unknown, output: unknown, since: unknown): void {
if (identity !== 'agent_service' || typeof runtime !== 'number' || !Number.isSafeInteger(runtime) || runtime < 10 || runtime > 120
|| typeof output !== 'number' || !Number.isSafeInteger(output) || output < 1024 || output > 65536
|| typeof since !== 'string' || Date.parse(since) < 0) throw new Error('Windows-Fixture-Eventlog nur agent_service,10–120s und1024–65536Bytes');
}
export interface PlanInput { tenant_id: string; action: Action; targets: { asset_ids: string[] }; parameters: RecordValue; artifact_ids?: string[]; schedule: { not_before: string; start_before: string; offline_policy: 'wait_until_deadline' }; rollout: { max_parallel: number; halt_after_failures: number }; reason: string }
export const windowsMsi = {
package: 'rmm-windows-msi-fixture', installRecipe: 'rmm-windows-msi-fixture-install-1.0', upgradeRecipe: 'rmm-windows-msi-fixture-upgrade-1.1',
product: '{3F070B4B-9C08-4D65-BD41-13D81B884AEC}', upgradedProduct: '{D42BD387-079B-4BBF-A134-0DA7B7A97011}', family: '{C9BF1FB8-E31D-4BD7-BA0D-AB46539BBBAA}',
payload: 'C:\\Program Files\\RustDiscoveryFixtures\\msi-payload.txt', payload10: '0c90c4fc7233017cc88c0e925095d6662ac57abdb303c7527ef59d02b454fca0', payload11: 'ba0c83deff9eed014009bcd45369b2a356ae909ebf0c1434dc836b0e6d759c49',
} as const;
export interface MsiPostcondition { product_code: string; product_version: string; payload_path: string; payload_sha256: string; payload_bytes: number }
export interface WindowsMsiRecipe {
schema_version: 1; recipe_id: string; recipe_version: '1'; platform: 'windows'; upgrade_code: string; architecture: 'x64'; context: 'machine'; command_profile: 'fixture_quiet_no_reboot_v1';
artifact: { artifact_id: string; sha256: string; bytes: number }; postcondition: MsiPostcondition; no_reboot: true; package_code?: string; predecessor?: MsiPostcondition;
}
export interface WindowsMsiManifest { recipe: WindowsMsiRecipe; recipe_sha256: string }
function exactMsiFields(value: RecordValue, fields: string[]): void {
if (Object.keys(value).some(key => !fields.includes(key)) || fields.some(key => !Object.prototype.hasOwnProperty.call(value, key))) throw new Error('MSI-Schemafelder fehlen oder sind unbekannt');
}
export function msiDigest(value: unknown): string { if (typeof value !== 'string' || !/^[a-f0-9]{64}$/.test(value)) throw new Error('Exakter MSI-SHA256 erforderlich'); return value; }
export function msiUuid(value: unknown): string { if (typeof value !== 'string' || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(value) || value === '00000000-0000-0000-0000-000000000000') throw new Error('Exakte MSI-UUID erforderlich'); return value; }
function msiInteger(value: unknown, min: number, max: number): number { if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < min || value > max) throw new Error('MSI-Limit außerhalb des festen Budgets'); return value; }
/** Reconstruct every nested object in Rust declaration order before hashing.
* No unknown properties, null options, enum objects or caller-supplied argv.
*/
export function windowsMsiManifest(value: unknown): WindowsMsiManifest {
const m = record(value, 'windows_msi_manifest'); exactMsiFields(m, ['recipe', 'recipe_sha256']);
const r = record(m.recipe, 'MSI-Rezept'), upgrade = r.recipe_id === windowsMsi.upgradeRecipe;
exactMsiFields(r, ['schema_version', 'recipe_id', 'recipe_version', 'platform', 'upgrade_code', 'architecture', 'context', 'command_profile', 'artifact', 'postcondition', 'no_reboot', ...(upgrade ? ['package_code', 'predecessor'] : [])]);
if (r.schema_version !== 1 || (!upgrade && r.recipe_id !== windowsMsi.installRecipe) || r.recipe_version !== '1' || r.platform !== 'windows' || r.upgrade_code !== windowsMsi.family || r.architecture !== 'x64' || r.context !== 'machine' || r.command_profile !== 'fixture_quiet_no_reboot_v1' || r.no_reboot !== true) throw new Error('Nur feste Windows-Machine/x64-MSI-Rezepte mit No-Reboot-Vertrag');
const a = record(r.artifact); exactMsiFields(a, ['artifact_id', 'sha256', 'bytes']);
const post = (value: unknown): MsiPostcondition => { const p = record(value); exactMsiFields(p, ['product_code', 'product_version', 'payload_path', 'payload_sha256', 'payload_bytes']);
if (p.payload_path !== windowsMsi.payload) throw new Error('Exakter MSI-Nutzdateipfad erforderlich');
return { product_code: text(p.product_code, 'ProductCode'), product_version: text(p.product_version, 'Produktversion'), payload_path: p.payload_path, payload_sha256: msiDigest(p.payload_sha256), payload_bytes: msiInteger(p.payload_bytes, 1, 65536) };
};
const p = post(r.postcondition);
if (p.product_code !== (upgrade ? windowsMsi.upgradedProduct : windowsMsi.product) || p.product_version !== (upgrade ? '1.1.0' : '1.0.0')) throw new Error('MSI-Produkt/Version widerspricht festem Rezept');
const recipe: WindowsMsiRecipe = { schema_version: 1, recipe_id: r.recipe_id as string, recipe_version: '1', platform: 'windows', upgrade_code: windowsMsi.family, architecture: 'x64', context: 'machine', command_profile: 'fixture_quiet_no_reboot_v1',
artifact: { artifact_id: msiUuid(a.artifact_id), sha256: msiDigest(a.sha256), bytes: msiInteger(a.bytes, 1, 262144) }, postcondition: p, no_reboot: true };
if (upgrade) {
const code = text(r.package_code, 'PackageCode');
if (!/^\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}$/.test(code) || code === '{00000000-0000-0000-0000-000000000000}' || [windowsMsi.product, windowsMsi.upgradedProduct, windowsMsi.family].some(x => x === code)) throw new Error('Exakter eigener MSI-PackageCode erforderlich');
const old = post(r.predecessor);
if (p.payload_sha256 !== windowsMsi.payload11 || p.payload_bytes !== 33 || old.product_code !== windowsMsi.product || old.product_version !== '1.0.0' || old.payload_sha256 !== windowsMsi.payload10 || old.payload_bytes !== 33) throw new Error('MSI1.1 benötigt exakt den bekannten1.0-Vorgänger und die feste1.1-Nutzdatei');
recipe.package_code = code; recipe.predecessor = old;
}
return { recipe, recipe_sha256: msiDigest(m.recipe_sha256) };
}
export function validateWindowsMsiLimits(runtime: unknown, output: unknown): void { msiInteger(runtime, 10, 120); msiInteger(output, 1024, 65536); }
/** Stored Action bytes omit apt_manifest=None; WebParameters may accept null. */
export function windowsMsiAction(value: RecordValue): RecordValue {
exactMsiFields(value, ['action', 'provider', 'package', 'version', 'architecture', 'recipe_version', 'installation_context', 'recipe_id', 'windows_msi_manifest']);
const m = windowsMsiManifest(value.windows_msi_manifest);
if (value.action !== 'ensure_package' || value.provider !== 'msi' || value.package !== windowsMsi.package || value.version !== m.recipe.postcondition.product_version || value.architecture !== 'x64' || value.recipe_version !== m.recipe.recipe_version || value.installation_context !== 'machine' || value.recipe_id !== m.recipe.recipe_id) throw new Error('Äußere MSI-Felder widersprechen Manifest');
return { action: 'ensure_package', provider: 'msi', package: windowsMsi.package, version: value.version, architecture: 'x64', recipe_version: m.recipe.recipe_version, installation_context: 'machine', recipe_id: m.recipe.recipe_id, windows_msi_manifest: m };
}
export function validateWindowsMsiInput(input: PlanInput): WindowsMsiManifest {
const p = input.parameters;
exactMsiFields(p, ['execution_identity', 'timeout_seconds', 'max_output_bytes', 'provider', 'package', 'version', 'architecture', 'recipe_version', 'installation_context', 'recipe_id', 'windows_msi_manifest', ...(Object.prototype.hasOwnProperty.call(p, 'apt_manifest') ? ['apt_manifest'] : [])]);
if (input.action !== 'ensure_package' || p.execution_identity !== 'system' || (input.artifact_ids?.length ?? 0) !== 0) throw new Error('MSI ausschließlich als SYSTEM-ensure_package mit automatisch genau einem Artefakt');
validateWindowsMsiLimits(p.timeout_seconds, p.max_output_bytes);
if (p.apt_manifest !== undefined && p.apt_manifest !== null) throw new Error('APT-Manifest bei MSI nicht zulässig');
windowsMsiAction({ action: input.action, provider: p.provider, package: p.package, version: p.version, architecture: p.architecture, recipe_version: p.recipe_version, installation_context: p.installation_context, recipe_id: p.recipe_id, windows_msi_manifest: p.windows_msi_manifest });
return windowsMsiManifest(p.windows_msi_manifest);
}
/** Decode explicit escaped CRLF before planning; never alter approved output bytes. */
export function expectedStdout(value: string, format: string): string | null {
if (value === '') return null;
@@ -68,6 +157,7 @@ export function expectedStdout(value: string, format: string): string | null {
return output;
}
export function validateInput(input: PlanInput): void {
if (Object.prototype.hasOwnProperty.call(input.parameters, 'windows_execution_profile')) throw new Error('Windows-Ausführungsprofil muss an der festen Windows-Skriptvariante stehen');
if (!input.targets.asset_ids.length || new Set(input.targets.asset_ids).size !== input.targets.asset_ids.length) throw new Error('Feste eindeutige Ziele erforderlich');
if (!input.reason.trim()) throw new Error('Begründung erforderlich');
const start = Date.parse(input.schedule.not_before), end = Date.parse(input.schedule.start_before);
@@ -77,6 +167,7 @@ export function validateInput(input: PlanInput): void {
const variants = input.parameters.variants;
if (!Array.isArray(variants) || !variants.length || variants.length > 2 || !variants.every(v => {
const variant = record(v), script = typeof variant.script_utf8 === 'string' ? variant.script_utf8 : '';
windowsScriptProfile(variant);
const bytes = new TextEncoder().encode(script).length;
const platform = variant.os_family === 'linux' && ['posix_sh', 'bash'].includes(String(variant.interpreter))
|| variant.os_family === 'windows' && variant.interpreter === 'powershell';
@@ -87,13 +178,22 @@ export function validateInput(input: PlanInput): void {
}
if (!['agent_service', 'root', 'system'].includes(String(input.parameters.execution_identity))) throw new Error('Explizite Ausführungsidentität erforderlich');
if (input.parameters.execution_identity === 'system') {
if (input.action !== 'set_service_state') throw new Error('SYSTEM ausschließlich für typisierte eigene Windows-Fixturedienste; keine SYSTEM-Shell');
validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
if (Object.keys(input.parameters).some(k => !['execution_identity', 'unit', 'state', 'timeout_seconds', 'max_output_bytes'].includes(k))) throw new Error('SYSTEM-Dienstauftrag enthält fremde Parameter');
if (input.action === 'ensure_package') validateWindowsMsiInput(input);
else {
if (input.action !== 'set_service_state') throw new Error('SYSTEM ausschließlich für typisierte eigene Windows-Fixturedienste oder feste MSI-Rezepte; keine SYSTEM-Shell');
validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
if (Object.keys(input.parameters).some(k => !['execution_identity', 'unit', 'state', 'timeout_seconds', 'max_output_bytes'].includes(k))) throw new Error('SYSTEM-Dienstauftrag enthält fremde Parameter');
}
}
if (input.parameters.provider === 'msi' || Object.prototype.hasOwnProperty.call(input.parameters, 'windows_msi_manifest')) validateWindowsMsiInput(input);
const required = (key: string) => text(input.parameters[key], `parameters.${key}`);
if (input.action === 'refresh_inventory') required('scope');
if (input.action === 'query_logs') { required('unit'); const since = Date.parse(required('since')), until = Date.parse(required('until')); if (!Number.isFinite(since) || !Number.isFinite(until) || until <= since) throw new Error('Exaktes Log-Zeitfenster erforderlich'); if (typeof input.parameters.max_lines !== 'number' || !Number.isSafeInteger(input.parameters.max_lines) || input.parameters.max_lines < 1 || input.parameters.max_lines > 1000) throw new Error('Loglimit muss 1–1000 sein'); }
if (input.action === 'query_logs') {
const unit = required('unit'); logWindow(required('since'), required('until'));
if (unit.startsWith('windows.eventlog.') && unit !== windowsEventLogFixtureSource) throw new Error('Nur die feste Windows-Fixture-Eventlogquelle ist konfiguriert');
if (unit === windowsEventLogFixtureSource) validateWindowsLogLimits(input.parameters.execution_identity, input.parameters.timeout_seconds, input.parameters.max_output_bytes, input.parameters.since);
if (typeof input.parameters.max_lines !== 'number' || !Number.isSafeInteger(input.parameters.max_lines) || input.parameters.max_lines < 1 || input.parameters.max_lines > 1000) throw new Error('Loglimit muss 1–1000 sein');
}
if (input.action === 'set_service_state') { required('unit'); if (!['running', 'stopped', 'restarted'].includes(required('state'))) throw new Error('Ungültiger Dienstzustand'); }
if (input.action === 'ensure_package') { for (const key of ['provider', 'recipe_version', 'package', 'version', 'architecture', 'installation_context']) required(key); }
if (input.action === 'apply_updates') { required('provider'); if (!Array.isArray(input.parameters.packages) || !input.parameters.packages.length || !input.parameters.packages.every(v => typeof v === 'string' && v.length > 0)) throw new Error('Feste Updatepakete erforderlich'); if (input.parameters.reboot_policy !== 'never') throw new Error('Kein impliziter Reboot; eigenen festen Plan erstellen'); }
+37 -3
View File
@@ -1,9 +1,39 @@
import { expect, it, vi } from 'vitest';
import { renderToStaticMarkup } from 'react-dom/server';
import { sha256, verifyPlanIntegrity } from './safety';
// Import the actual renderer without mounting the application's network effects.
vi.mock('react-dom/client', () => ({ createRoot: () => ({ render: vi.fn() }) }));
it('shows fixed Event Log source, half-open UTC window and both runtime bounds before approval', async () => {
const fetch=vi.fn();vi.stubGlobal('fetch',fetch);vi.stubGlobal('document',{getElementById:()=>({})});
try{
const {QueryLogsPlanNotice}=await import('./main');
const payload={jobs:[{payload:{asset_id:'win-fixture',execution_identity:'agent_service',max_runtime_seconds:30,max_output_bytes:4096,action:{action:'query_logs',unit:'windows.eventlog.application.rustdiscovery-mvp-test',since:'2026-11-14T00:00:00Z',until:'2026-11-14T01:00:00Z',max_lines:1000}}}]};
const raw=new TextEncoder().encode(JSON.stringify(payload)),plan={plan_payload_bytes:Array.from(raw),plan_hash:await sha256(raw),plan_payload:payload};
expect(renderToStaticMarkup(<QueryLogsPlanNotice plan={plan}/>)).toContain('role="alert"');await verifyPlanIntegrity(plan);
const html=renderToStaticMarkup(<QueryLogsPlanNotice plan={plan}/>);for(const expected of ['Application','RustDiscovery-MVP-Test','1000','4096','30s','5000ms','kooperativ','2026-11-14T01:00:00Z)','Keine Bookmark'])expect(html).toContain(expected);
expect(html).not.toMatch(/<(button|input|form)\b/);expect(fetch).not.toHaveBeenCalled();
}finally{vi.unstubAllGlobals();}
});
it('shows the verified PowerShell process profile before approval without issuing requests', async () => {
const fetch = vi.fn(); vi.stubGlobal('fetch', fetch); vi.stubGlobal('document', { getElementById: () => ({}) });
try {
const { PowerShellPlanNotice } = await import('./main');
const payload = { jobs: [{ payload: { asset_id: 'fixed-windows', execution_identity: 'agent_service', action: { action: 'run_script', interpreter: 'powershell', script_utf8: 'Write-Output 1\r\n', arguments: [], expected_stdout: '1\r\n', windows_execution_profile: 'powershell_51_remote_signed' } } }] };
const raw = new TextEncoder().encode(JSON.stringify(payload)), plan = { plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), plan_payload: payload };
expect(renderToStaticMarkup(<PowerShellPlanNotice plan={plan}/>)).toContain('role="alert"');
await verifyPlanIntegrity(plan);
const html = renderToStaticMarkup(<PowerShellPlanNotice plan={plan}/>);
for (const expected of ['fixed-windows', 'Windows PowerShell5.1', 'RemoteSigned', 'nur Jobprozess', 'angeforderte Option']) expect(html).toContain(expected);
expect(html).not.toMatch(/<(button|input|form)\b/);
plan.plan_payload_bytes[0] = 0;
expect(renderToStaticMarkup(<PowerShellPlanNotice plan={plan}/>)).toContain('role="alert"');
expect(fetch).not.toHaveBeenCalled();
} finally { vi.unstubAllGlobals(); }
});
it('renders hostile log content only as text, without executable nodes, approval controls or requests', async () => {
const fetch = vi.fn();
vi.stubGlobal('fetch', fetch);
@@ -30,13 +60,17 @@ it('shows fixed SYSTEM identity and service state from stored plan bytes without
const fetch = vi.fn(); vi.stubGlobal('fetch', fetch); vi.stubGlobal('document', { getElementById: () => ({}) });
try {
const { SystemPlanNotice } = await import('./main');
const payload = { jobs: [{ payload: { execution_identity: 'system', asset_id: 'fixed-asset', action: { action: 'set_service_state', unit: 'RmmDiscoveryFixtureService', state: 'stopped' } } }] };
const plan = { plan_payload_bytes: Array.from(new TextEncoder().encode(JSON.stringify(payload))), jobs: [{ payload: { execution_identity: 'root', action: { unit: 'untrusted-view' } } }] };
const payload = { jobs: [{ payload: { execution_identity: 'system', asset_id: 'fixed-asset', max_runtime_seconds: 30, max_output_bytes: 4096, action: { action: 'set_service_state', unit: 'RmmDiscoveryFixtureService', state: 'stopped' } } }] };
const raw = new TextEncoder().encode(JSON.stringify(payload));
const plan = { plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), jobs: [{ payload: { execution_identity: 'root', action: { unit: 'untrusted-view' } } }] };
expect(renderToStaticMarkup(<SystemPlanNotice plan={plan}/>)).toContain('role="alert"');
await verifyPlanIntegrity(plan);
const html = renderToStaticMarkup(<SystemPlanNotice plan={plan}/>);
expect(html).toContain('SYSTEM'); expect(html).toContain('system:execute'); expect(html).toContain('Identität: system');
for (const expected of ['fixed-asset', 'RmmDiscoveryFixtureService', 'Zielzustand: stopped', 'Keine SYSTEM-Shell']) expect(html).toContain(expected);
expect(html).not.toContain('untrusted-view'); expect(html).not.toMatch(/<(button|input|form|pre)\b/);
expect(renderToStaticMarkup(<SystemPlanNotice plan={{ plan_payload_bytes: Array.from(new TextEncoder().encode('{"jobs":[]}')) }}/>)).toBe('');
const emptyRaw = new TextEncoder().encode('{"jobs":[]}'), empty = { plan_payload_bytes: Array.from(emptyRaw), plan_hash: await sha256(emptyRaw) }; await verifyPlanIntegrity(empty);
expect(renderToStaticMarkup(<SystemPlanNotice plan={empty}/>)).toBe('');
for (const plan_payload_bytes of [[255], [123], 'invalid']) {
const invalid = renderToStaticMarkup(<SystemPlanNotice plan={{ plan_payload_bytes }}/>);
expect(invalid).toContain('role="alert"'); expect(invalid).toContain('nicht lesbar');
+67 -12
View File
@@ -1,20 +1,48 @@
import React, { useEffect, useState } from 'react';
import { createRoot } from 'react-dom/client';
import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, page, Page, PlanInput, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, validateInput } from './api';
import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, page, Page, PlanInput, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, validateInput, windowsPowerShellRemoteSignedProfile } from './api';
import './style.css';
import { AdminControl, Catalog, TenantControls } from './management';
import { allowed, availableActions, parseStrictJson, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity } from './safety';
import { allowed, availableActions, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity, queryLogsApprovalBlockers, queryLogsPlanJobs, windowsMsiApprovalBlockers, windowsMsiPlanJobs, verifyWindowsMsiManifest } from './safety';
import { Login } from './login';
const errorText = (error: unknown) => error instanceof Error ? error.message : 'Unbekannter Fehler';
export function JsonView({ value, label = 'Vollständige Daten' }: { value: unknown; label?: string }) { return <details open><summary>{label}</summary><pre>{pretty(value)}</pre></details>; }
export function SystemPlanNotice({ plan }: { plan: RecordValue }) {
let jobs: RecordValue[];
try { jobs = systemPlanJobs(plan); }
try { jobs = systemPlanJobs(plan).filter(p => record(p.action).action === 'set_service_state'); }
catch { return <aside role="alert" className="error">Gespeicherte Planbytes sind nicht lesbar. Keine verlässliche SYSTEM-Plananzeige; Genehmigungsverifikation muss erfolgreich sein.</aside>; }
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste SYSTEM-Dienstaktionen"><p>{systemWarning}</p><ul>{jobs.map((payload, i) => { const action = record(payload.action); return <li key={i}>Identität: system · Asset: {String(payload.asset_id)} · Dienst: {String(action.unit)} · Zielzustand: {String(action.state)}</li>; })}</ul><p>Diese Definitionen stammen aus den gespeicherten Planbytes; die vollständigen Zielpayloads und Hashes stehen darunter.</p></aside>;
}
export function WindowsMsiPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = windowsMsiPlanJobs(plan); if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste SYSTEM-MSI-Paketaktionen"><p>{systemWarning}</p><p>Windows · SYSTEM · Machine · x64 · feste MSI-Profile, keine freie Installer-URL/Argumente. Diese Definition stammt ausschließlich aus hashgeprüften gespeicherten Planbytes.</p><ul>{jobs.map((job, i) => <li key={i}>
Asset: {job.assetId} · Rezept: {job.recipeId} · Rezept-SHA256: {job.recipeHash}<br/>
Artefakt: {job.artifactId} · SHA256: {job.artifactHash} · {job.artifactBytes} Bytes<br/>
ProductCode: {job.productCode} · UpgradeCode: {job.upgradeCode} · Version: {job.version} · PackageCode: {job.packageCode ?? 'im historischen1.0-Rezept nicht separat gebunden; vollständiger Artefakthash bleibt fest'}<br/>
Nutzdatei: {job.payloadPath} · SHA256: {job.payloadHash} · {job.payloadBytes} Bytes<br/>
Vorgänger: {job.predecessor ? `${job.predecessor.product_code} · ${job.predecessor.product_version} · ${job.predecessor.payload_path} · SHA256 ${job.predecessor.payload_sha256} · ${job.predecessor.payload_bytes} Bytes` : 'keine Upgrade-Reparatur; erste1.0-Installation oder separat belegter Noop'}<br/>
Fester Aufruf: %SystemRoot%\System32\msiexec.exe {job.arguments.map(arg => JSON.stringify(arg)).join(' ')}<br/>
No-Reboot: true · ursprüngliches Gesamtbudget: {job.runtimeSeconds}s · Ausgabelimit: {job.outputBytes} Bytes
</li>)}</ul><p>Upgrade1.1 setzt den exakten1.0-Vorgänger voraus und entfernt ihn. Erfolg/Noop benötigen unabhängige rechtzeitige Nachbedingungen.3010 meldet Neustartbedarf ohne Neustart;1641/unklare Wirkung bleiben unknown,1618 Konflikt ohne Retry. Planung und Anzeige behaupten keine native Installer-/Clock-/Helperbereitschaft.</p></aside>;
} catch { return <aside role="alert" className="error">MSI-Plan ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne unveränderte gespeicherte Planbytes.</aside>; }
}
export function PowerShellPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = powerShellPlanJobs(plan);
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste PowerShell-Prozessprofile"><p>Diese Ausführungsoptionen sind an die hashgeprüften gespeicherten Planbytes gebunden.</p><ul>{jobs.map((job, i) => <li key={i}>Asset: {job.assetId} · Windows PowerShell5.1 · agent_service · {job.profile === windowsPowerShellRemoteSignedProfile ? 'RemoteSigned · nur Jobprozess' : 'Geerbte Richtlinie · kein ExecutionPolicy-Prozessparameter'}</li>)}</ul><p>Keine Maschinen-/CurrentUser-/GPO-Änderung durch den Executor. GPO-Vorgaben bleiben wirksam; die angeforderte Option ist kein Nachweis der effektiven Policy.</p></aside>;
} catch { return <aside role="alert" className="error">PowerShell-Planprofil ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne gültige gespeicherte Planbytes.</aside>; }
}
export function QueryLogsPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = queryLogsPlanJobs(plan);
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste Live-Logfenster"><p>UI-genehmigte Liveabfrage aus hashgeprüften gespeicherten Planbytes; kein passives Inventar, keine automatische Erhebung.</p><ul>{jobs.map((job, i) => <li key={i}>Asset: {job.assetId} · Quelle: {job.source}{job.windows ? <> · Kanal: {job.channel} · Provider: {job.provider} · agent_service</> : ' · Linux-Journal'} · UTC-Fenster: [{job.since}, {job.until}) · maximal {job.maxLines} {job.windows ? 'Events' : 'Zeilen'} · {job.outputBytes} Bytes · äußere Joblaufzeit {job.runtimeSeconds}s{job.windows && ' · inneres Abfragebudget höchstens5000ms, zwischen Win32-Aufrufen kooperativ geprüft'}</li>)}</ul><p>Grenzen, Abbruch, fehlende Rechte und Teilabdeckung bleiben sichtbar. Keine Bookmarkfortschreibung durch diesen Auftrag; die Abfrage behauptet keine vollständige Sammlung aller Systemlogs.</p></aside>;
} catch { return <aside role="alert" className="error">Logfenster ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne gültige gespeicherte Planbytes.</aside>; }
}
function ErrorBox({ error }: { error: string | null }) { return error ? <div role="alert" className="error">{error}</div> : null; }
function useResource<T>(load: (signal: AbortSignal) => Promise<T>, deps: React.DependencyList, poll = false) {
const [data, setData] = useState<T | null>(null), [error, setError] = useState<string | null>(null), [revision, setRevision] = useState(0);
@@ -50,39 +78,66 @@ function Planner({ tenantId, auth, selected, showPlan }: { tenantId: string; aut
return <section><h2>Neuen unveränderlichen Plan vorbereiten</h2><p>Nur fest ausgewählte Asset-IDs. Keine Ausführung durch Planung oder Antrag; jede Aktion einschließlich Live-Inventar benötigt Genehmigung.</p>
<form onSubmit={async e => { e.preventDefault(); setBusy(true); setError(null); const f = new FormData(e.currentTarget); try {
const common = { execution_identity: String(f.get('identity')), timeout_seconds: Number(f.get('timeout')), max_output_bytes: Number(f.get('output')) };
const params = action === 'run_script' ? { ...common, variants: scriptPlatform === 'mixed' ? parseStrictJson(mixedVariants) : [{ os_family: scriptPlatform, interpreter: String(f.get('interpreter')), encoding: 'utf-8', script_utf8: String(f.get('script')) }], arguments: [], expected_stdout: expectedStdout(String(f.get('expected')), String(f.get('expected_format'))) } : { ...record(parseStrictJson(parameters)), ...common };
const params = action === 'run_script' ? { ...common, variants: scriptPlatform === 'mixed' ? parseStrictJson(mixedVariants) : [{ os_family: scriptPlatform, interpreter: String(f.get('interpreter')), encoding: 'utf-8', script_utf8: String(f.get('script')), ...(scriptPlatform === 'windows' ? { windows_execution_profile: windowsPowerShellRemoteSignedProfile } : {}) }], arguments: [], expected_stdout: expectedStdout(String(f.get('expected')), String(f.get('expected_format'))) } : { ...record(parseStrictJson(parameters)), ...common };
const input: PlanInput = { tenant_id: tenantId, action, targets: { asset_ids: [...selected] }, parameters: params, schedule: { not_before: new Date(String(f.get('not_before'))).toISOString(), start_before: new Date(String(f.get('expires'))).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: Number(f.get('parallel')), halt_after_failures: Number(f.get('failures')) }, reason: String(f.get('reason')) };
const ids = String(f.get('artifact_ids') ?? '').split(/[\s,]+/).filter(Boolean); if (ids.length) { if (ids.length > 16 || new Set(ids).size !== ids.length || ids.some(id => !/^[0-9a-f-]{36}$/i.test(id))) throw new Error('Maximal 16 eindeutige feste Artefakt-UUIDs'); input.artifact_ids = ids; }
validateInput(input); await validateSensitiveInput(input, auth); const plan = record(await request(tenantPath(tenantId, '/operation-plans'), { body: input, csrf: auth.csrf_token })); showPlan(objectId(plan, 'plan'));
} catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>
<label>Aktion<select aria-label="Aktion" value={action} onChange={e => { const next = availableActions(auth, actions).find(a => a === e.target.value); if (next) { setAction(next); setParameters(pretty(initialParameters[next])); } }}>{availableActions(auth, actions).map(a => <option key={a} value={a}>{a}</option>)}</select></label>
{action === 'query_logs' && <p>Windows-MVP nur Quelle windows.eventlog.application.rustdiscovery-mvp-test, Kanal Application, Provider RustDiscovery-MVP-Test, agent_service. Festes UTC-Fenster höchstens24h,1–1000Events,1024–65536Bytes,äußere Joblaufzeit10–120s; inneres kooperatives Abfragebudget höchstens5000ms. Keine freie Kanal-/XPathauswahl und keine Bookmarkfortschreibung. Linux behält seine feste Journalunit.</p>}
{action === 'apt_native_acceptance' && <p className="warning">NUR SIMULIERTE DEV/TEST-NATIVABNAHME. In Vorbereitung; Backend/Helper/Scope müssen diese eigene Aktion unterstützen. Nur rmm-apt-fixture-install-1.0 oder rmm-apt-fixture-update-1.1, Rezeptversion 1, vollständiges Schema-2-Manifest. null/Platzhalter sind nicht konfiguriert, keine Produktionsaktion, keine automatische Ausführung.</p>}
{action === 'run_script' ? <><label>Skriptplattform<select aria-label="Skriptplattform" value={scriptPlatform} onChange={e => setScriptPlatform(e.target.value)}><option value="linux">Linux</option><option value="windows">Windows</option><option value="mixed">Linux und Windows · feste Varianten</option></select></label>{scriptPlatform === 'mixed' ? <label>Exakte Plattformvarianten (JSON)<textarea aria-label="Skriptvarianten" value={mixedVariants} onChange={e => setMixedVariants(e.target.value)} rows={9} spellCheck={false}/></label> : <><label>Interpreter<select name="interpreter" key={scriptPlatform}>{scriptPlatform === 'windows' ? <option value="powershell">powershell · Windows PowerShell 5.1</option> : <><option value="posix_sh">posix_sh · /bin/sh</option><option value="bash">bash · nur mit gemeldeter Capability</option></>}</select></label><label>Exakte UTF-8 Skriptbytes (keine automatische Ergänzung)<textarea name="script" required rows={7} spellCheck={false}/></label></>}<label>Format der stdout-Nachbedingung<select name="expected_format" aria-label="Format der stdout-Nachbedingung"><option value="text">Text · Linux-Default</option><option value="json">JSON-String · explizite CRLF mit \r\n</option></select></label><label>Erwartete stdout-Ausgabe (exakte Rohbytes als UTF-8, optional)<textarea name="expected" rows={2} spellCheck={false}/></label>{scriptPlatform !== 'linux' && <p>PowerShell5.1: -NoLogo -NoProfile -NonInteractive; keine ExecutionPolicy-Umgehung. Nicht-ASCII benötigt ein ausdrücklich enthaltenes UTF-8-BOM vor Hashbildung. Skriptbytes und Ausgabe werden nicht normalisiert. Fehlende Plattform-/Interpreter-/Sync-Capability sperrt den ganzen Plan; kein stiller Zielausschluss.</p>}</> : <label>Typisierte Aktionsparameter (JSON; leere Pflichtwerte ergänzen)<textarea aria-label="Aktionsparameter" value={parameters} onChange={e => setParameters(e.target.value)} rows={9} spellCheck={false}/></label>}
<div className="grid"><label>Ausführungsidentität<select aria-label="Ausführungsidentität" name="identity" value={identity} onChange={e => setIdentity(e.target.value)}><option value="agent_service">agent_service</option><option value="root" disabled={!allowed(auth, 'root:execute')}>root · root:execute und unabhängiger Helper erforderlich</option><option value="system" disabled={action !== 'set_service_state' || !allowed(auth, 'system:execute')}>system · system:execute und Windows-SYSTEM-Helper erforderlich</option></select></label><label>Laufzeitlimit (s)<input name="timeout" type="number" min="1" max="86400" defaultValue="60" required/></label><label>Ausgabelimit (Bytes)<input name="output" type="number" min="1" max="524288" defaultValue="65536" required/></label><label>Frühester Start (lokale Zeit)<input name="not_before" type="datetime-local" defaultValue={localDate(new Date())} required/></label><label>Startfrist / Ablauf (lokale Zeit)<input name="expires" type="datetime-local" defaultValue={localDate(new Date(Date.now() + 86400000))} required/></label><label>Maximal parallel<input name="parallel" type="number" min="1" defaultValue="1" required/></label><label>Stopp nach Fehlern<input name="failures" type="number" min="1" defaultValue="1" required/></label></div>
{action === 'run_script' ? <><label>Skriptplattform<select aria-label="Skriptplattform" value={scriptPlatform} onChange={e => setScriptPlatform(e.target.value)}><option value="linux">Linux</option><option value="windows">Windows</option><option value="mixed">Linux und Windows · feste Varianten</option></select></label>{scriptPlatform === 'mixed' ? <label>Exakte Plattformvarianten (JSON)<textarea aria-label="Skriptvarianten" value={mixedVariants} onChange={e => setMixedVariants(e.target.value)} rows={9} spellCheck={false}/></label> : <><label>Interpreter<select name="interpreter" key={scriptPlatform}>{scriptPlatform === 'windows' ? <option value="powershell">powershell · Windows PowerShell 5.1</option> : <><option value="posix_sh">posix_sh · /bin/sh</option><option value="bash">bash · nur mit gemeldeter Capability</option></>}</select></label><label>Exakte UTF-8 Skriptbytes (keine automatische Ergänzung)<textarea name="script" required rows={7} spellCheck={false}/></label></>}<label>Format der stdout-Nachbedingung<select name="expected_format" aria-label="Format der stdout-Nachbedingung"><option value="text">Text · Linux-Default</option><option value="json">JSON-String · explizite CRLF mit \r\n</option></select></label><label>Erwartete stdout-Ausgabe (exakte Rohbytes als UTF-8, optional)<textarea name="expected" rows={2} spellCheck={false}/></label>{scriptPlatform !== 'linux' && <p>PowerShell5.1: -NoLogo -NoProfile -NonInteractive. Einzelne neue Windowspläne binden fest RemoteSigned nur für den Jobprozess. Bei gemischten Varianten ist powershell_51_remote_signed ausdrücklich an der Windowsvariante zu setzen; fehlendes Profil bleibt geerbt. Jede tatsächliche Prozessoption steht vor Genehmigung je Ziel im festen Plan. Nicht-ASCII benötigt ein ausdrücklich enthaltenes UTF-8-BOM vor Hashbildung. Skriptbytes und Ausgabe werden nicht normalisiert. Fehlende Plattform-/Interpreter-/Sync-Capability sperrt den ganzen Plan; kein stiller Zielausschluss.</p>}</> : <label>Typisierte Aktionsparameter (JSON; leere Pflichtwerte ergänzen)<textarea aria-label="Aktionsparameter" value={parameters} onChange={e => setParameters(e.target.value)} rows={9} spellCheck={false}/></label>}
<div className="grid"><label>Ausführungsidentität<select aria-label="Ausführungsidentität" name="identity" value={identity} onChange={e => setIdentity(e.target.value)}><option value="agent_service">agent_service</option><option value="root" disabled={!allowed(auth, 'root:execute')}>root · root:execute und unabhängiger Helper erforderlich</option><option value="system" disabled={!['set_service_state', 'ensure_package'].includes(action) || !allowed(auth, 'system:execute')}>system · system:execute und Windows-SYSTEM-Helper erforderlich</option></select></label><label>Laufzeitlimit (s)<input name="timeout" type="number" min="1" max="86400" defaultValue="60" required/></label><label>Ausgabelimit (Bytes)<input name="output" type="number" min="1" max="524288" defaultValue="65536" required/></label><label>Frühester Start (lokale Zeit)<input name="not_before" type="datetime-local" defaultValue={localDate(new Date())} required/></label><label>Startfrist / Ablauf (lokale Zeit)<input name="expires" type="datetime-local" defaultValue={localDate(new Date(Date.now() + 86400000))} required/></label><label>Maximal parallel<input name="parallel" type="number" min="1" defaultValue="1" required/></label><label>Stopp nach Fehlern<input name="failures" type="number" min="1" defaultValue="1" required/></label></div>
{identity === 'root' && <p className="warning">{rootWarning}</p>}
{identity === 'system' && <p className="warning">{systemWarning}</p>}
{identity === 'system' && action === 'ensure_package' && <p>MSI: provider=msi, package=rmm-windows-msi-fixture, architecture=x64, installation_context=machine, recipe_version=1 und vollständiges windows_msi_manifest aus dem getrennten MSI-Katalog. Genau zwei eigene Rezepte1.0/1.0→1.1;10–120s,1024–65536Bytes. APT-Manifest fehlt/null. Rezept-/Artefakthash und feste Nachbedingungen werden geprüft. Kein zusätzlicher Artefaktvektor.</p>}
{['ensure_package', 'apply_updates', 'apt_native_acceptance'].includes(action) && <details open><summary>Unveränderte Parameter-/Manifestpreview: gesamte Closure, alte/neue Versionen, Origins, Archivbytes/Hashes und Bindungen</summary><pre>{parameters}</pre><p>Struktur, exakte Transaktionsbytes und Hash werden vor Planung geprüft. Diese Vorschau behauptet keine native Akzeptanz oder Bereitschaft; keine automatische Ergänzung/Reduzierung der Closure.</p></details>}
<label>Feste importierte Artefakt-IDs (optional, maximal 16)<input name="artifact_ids" placeholder="UUIDs durch Komma getrennt; keine URL"/></label>
<label>Feste importierte Artefakt-IDs (optional, maximal 16)<input name="artifact_ids" disabled={identity === 'system' && action === 'ensure_package'} placeholder="MSI leitet genau eine Referenz aus dem Rezept ab; sonst UUIDs, keine URL"/></label>
<label>Begründung<input name="reason" required maxLength={1024}/></label><p>Feste Ziele ({selected.length}): {selected.join(', ') || 'keine ausgewählt'}</p>{action === 'reboot' || action === 'apply_updates' || action === 'ensure_package' ? <p className="warning">Zieländerung: Testumfang separat abstimmen. Keine implizite Reboot-/Updateerlaubnis. Neue Versuche und Folgejobs benötigen neue feste Pläne.</p> : null}<button disabled={busy || !selected.length}>Plan erstellen · noch keine Ausführung</button><ErrorBox error={error}/>
</form></section>;
}
function localDate(date: Date) { return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().slice(0, 16); }
function WindowsMsiCatalog({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [source, setSource] = useState('{}'), [cursor, setCursor] = useState<string | null>(null), [revision, setRevision] = useState(0), [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false), [receipt, setReceipt] = useState<unknown>(null);
const list = useResource(async signal => {
const result = page(await request(tenantPath(tenantId, `/windows-msi-recipes${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`), { signal }));
const items: RecordValue[] = [];
for (const item of result.items) { const manifest = await verifyWindowsMsiManifest(item.manifest); if (item.sha256 !== manifest.recipe_sha256 || item.recipe_id !== manifest.recipe.recipe_id) throw new Error('MSI-Katalogansicht widerspricht Rezeptbytes'); items.push({ catalog_id: item.catalog_id, recipe_id: manifest.recipe.recipe_id, sha256: manifest.recipe_sha256, manifest }); }
return { ...result, items };
}, [tenantId, cursor, revision]);
return <section><h2>Getrennter unveränderlicher Windows-MSI-Katalog</h2><p>Nur die zwei festen eigenen Machine/x64-Rezepte. Import ist Metadatenpflege mit catalog:write, keine Genehmigung, Installation oder Capabilityfreigabe. Öffentliche MSI-Artefakte werden über den bestehenden Artefaktimport gebunden. Vollständiges geprüftes Manifest für den Parametereditor kopieren.</p><ErrorBox error={list.error}/>
{list.data && <><PageStatus data={list.data}/><JsonView value={list.data.items} label="Hashgeprüfte feste MSI-Manifeste"/><button disabled={!cursor} onClick={() => setCursor(null)}>Erste MSI-Rezeptseite</button><button disabled={!list.data.next_cursor} onClick={() => setCursor(list.data?.next_cursor ?? null)}>Nächste MSI-Rezeptseite</button></>}
<details><summary>Neues festes MSI-Manifest importieren</summary><form onSubmit={async event => { event.preventDefault(); setBusy(true); setError(null); setReceipt(null); try {
if (!allowed(auth, 'catalog:write')) throw new Error('catalog:write unbekannt/nicht erteilt');
const manifest = await verifyWindowsMsiManifest(parseStrictJson(source));
const result = record(await request(tenantPath(tenantId, '/windows-msi-recipes'), { body: manifest, csrf: auth.csrf_token }));
const stored = await verifyWindowsMsiManifest(result.manifest);
if (result.sha256 !== manifest.recipe_sha256 || result.recipe_id !== manifest.recipe.recipe_id || JSON.stringify(stored) !== JSON.stringify(manifest)) throw new Error('MSI-Importbeleg widerspricht unveränderlichen Rezeptbytes');
setReceipt({ catalog_id: result.catalog_id, manifest: stored }); setRevision(n => n + 1);
} catch (error) { setError(errorText(error)); } finally { setBusy(false); } }}><label>Vollständiges MSI-Manifest JSON<textarea rows={10} value={source} onChange={e => setSource(e.target.value)} spellCheck={false}/></label><button disabled={busy || !allowed(auth, 'catalog:write')}>Festes MSI-Manifest importieren · keine Ausführung</button><ErrorBox error={error}/>{receipt !== null && <JsonView value={receipt} label="Verifizierter MSI-Importbeleg"/>}</form></details>
</section>;
}
function PlanDetail({ tenantId, id, auth, onOperation }: { tenantId: string; id: string; auth: Session; onOperation: (id: string) => void }) {
const plan = useResource(async signal => { const result = record(await request(tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}`), { signal })); await verifyPlanIntegrity(result); return result; }, [tenantId, id]);
const [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false), [confirmed, setConfirmed] = useState(false), [submitted, setSubmitted] = useState(false), [pending, setPending] = useState(false);
const [idempotency] = useState(() => crypto.randomUUID());
const blockers = plan.data ? approvalBlockers(plan.data) : ['Plan noch nicht geladen'];
const blockers = plan.data ? [...approvalBlockers(plan.data), ...powerShellApprovalBlockers(plan.data), ...queryLogsApprovalBlockers(plan.data), ...windowsMsiApprovalBlockers(plan.data)] : ['Plan noch nicht geladen'];
const recheck = async () => { if (!plan.data) throw new Error('Plan fehlt'); await verifyPlanIntegrity(plan.data); const errors = [...approvalBlockers(plan.data), ...powerShellApprovalBlockers(plan.data), ...queryLogsApprovalBlockers(plan.data), ...windowsMsiApprovalBlockers(plan.data)]; if (errors.length) throw new Error(errors.join('; ')); };
return <section><h2>Unveränderlicher Plan / Genehmigungsdetail</h2><ErrorBox error={plan.error}/><ErrorBox error={error}/>{plan.data && <>
<p>Plan-ID: {id}</p><p>Exakter gespeicherter Planhash: <code>{stringField(plan.data, 'plan_hash')}</code></p><p>Feste Ziele: {Array.isArray(plan.data.resolved_targets) ? plan.data.resolved_targets.length : 'unknown'}. Die folgenden Zielpreviews sind unveränderliche Plandefinitionen, keine ausführbaren Jobs oder angelegten Versuche. Diese entstehen erst nach Genehmigung.</p>
<SystemPlanNotice plan={plan.data}/>
<WindowsMsiPlanNotice plan={plan.data}/>
<PowerShellPlanNotice plan={plan.data}/>
<QueryLogsPlanNotice plan={plan.data}/>
<JsonView value={plan.data} label="Alle festen Zielpreviews, exakte Skriptinhalte/Hashes, Parameter, Rechte, Fristen, Rollout und Nachbedingungen"/>
<p className="warning">Genehmigung bindet ausschließlich diesen unveränderlichen Plan. Kein pauschaler Retry, keine Wildcard, kein impliziter Reboot. Unbekannte Wirkung wird nicht automatisch wiederholt. Ein Exitcode allein beweist keine fachliche Wirkung.</p>
{blockers.length > 0 && <div role="alert" className="error">Nicht genehmigungsfähig: {blockers.join('; ')}</div>}
<button disabled={busy || !!plan.error || blockers.length > 0 || submitted} onClick={async () => { setBusy(true); setError(null); try { const result = record(await request(tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}/submit`), { csrf: auth.csrf_token, body: { idempotency_key: idempotency } })); setSubmitted(true); setPending((result.approval_state ?? result.state) === 'pending_approval'); onOperation(objectId(result, 'operation')); } catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>Antrag absenden · pending_approval</button>
<label className="check"><input type="checkbox" checked={confirmed} onChange={e => setConfirmed(e.target.checked)}/>Ich habe sämtliche festen Ziele, Aktionen, Bytes/Hashes, Zielpreviews und Auswirkungen dieses Plans geprüft.</label>
<button disabled={busy || !!plan.error || blockers.length > 0 || submitted} onClick={async () => { setBusy(true); setError(null); try { await recheck(); const result = record(await request(tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}/submit`), { csrf: auth.csrf_token, body: { idempotency_key: idempotency } })); setSubmitted(true); setPending((result.approval_state ?? result.state) === 'pending_approval'); onOperation(objectId(result, 'operation')); } catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>Antrag absenden · pending_approval</button>
<label className="check"><input type="checkbox" checked={confirmed} onChange={e => setConfirmed(e.target.checked)}/>Ich habe sämtliche festen Ziele, Aktionen, Bytes/Hashes, Zielpreviews, Ausführungsprofile/Prozessumfänge und Auswirkungen dieses Plans geprüft.</label>
<button className="danger" disabled={!confirmed || busy || !!plan.error || blockers.length > 0 || !(pending || plan.data.approval_state === 'pending_approval')} onClick={async () => { setBusy(true); setError(null); try {
const result = record(await request(tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}/authorizations`), { csrf: auth.csrf_token, body: { plan_hash: plan.data?.plan_hash } })); setConfirmed(false); setPending(false); onOperation(objectId(result, 'operation')); plan.reload();
await recheck(); const result = record(await request(tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}/authorizations`), { csrf: auth.csrf_token, body: { plan_hash: plan.data?.plan_hash } })); setConfirmed(false); setPending(false); onOperation(objectId(result, 'operation')); plan.reload();
} catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}>{auth.principal.simulated ? 'SIMULIERT: Diesen festen Plan ausdrücklich genehmigen' : 'Diesen festen Plan ausdrücklich genehmigen'}</button>
<p>Nur für einen bestehenden Antrag pending_approval; Server prüft interaktive Sitzung, Rechte, Tenant, Policy und Frist erneut. Keine automatische Genehmigung.</p>
<AdminControl auth={auth} path={tenantPath(tenantId, `/operation-plans/${encodeURIComponent(id)}/revocation`)} permission="plans:revoke" title="Planberechtigung widerrufen" warning="Sperrt neue Starts dieses Plans; laufende Wirkungen folgen sicheren Abbruchregeln, kein Rollback. Ein widerrufener Antrag wird nicht reaktiviert." done={plan.reload}/>
@@ -119,7 +174,7 @@ function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
}
function TenantWorkspace({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [selected, setSelected] = useState<string[]>([]), [planId, setPlan] = useState<string | null>(null), [operationId, setOperation] = useState<string | null>(null);
return <><Devices tenantId={tenantId} auth={auth} selected={selected} setSelected={setSelected}/><Planner tenantId={tenantId} auth={auth} selected={selected} showPlan={setPlan}/><Catalog tenantId={tenantId} auth={auth}/><TenantControls tenantId={tenantId} auth={auth}/><Operations tenantId={tenantId} open={setOperation}/>{operationId && <OperationDetail key={operationId} tenantId={tenantId} id={operationId} auth={auth} openPlan={setPlan}/ >}{planId && <PlanDetail key={planId} tenantId={tenantId} id={planId} auth={auth} onOperation={setOperation}/>}</>;
return <><Devices tenantId={tenantId} auth={auth} selected={selected} setSelected={setSelected}/><Planner tenantId={tenantId} auth={auth} selected={selected} showPlan={setPlan}/><Catalog tenantId={tenantId} auth={auth}/><WindowsMsiCatalog tenantId={tenantId} auth={auth}/><TenantControls tenantId={tenantId} auth={auth}/><Operations tenantId={tenantId} open={setOperation}/>{operationId && <OperationDetail key={operationId} tenantId={tenantId} id={operationId} auth={auth} openPlan={setPlan}/ >}{planId && <PlanDetail key={planId} tenantId={tenantId} id={planId} auth={auth} onOperation={setOperation}/>}</>;
}
function App() {
const [auth, setAuth] = useState<Session | null>(null), [loading, setLoading] = useState(true), [error, setError] = useState<string | null>(null);
+158 -2
View File
@@ -1,10 +1,64 @@
import { describe, expect, it, vi } from 'vitest';
import { renderToStaticMarkup } from 'react-dom/server';
import { actions, PlanInput, Session, request, session } from './api';
import { adminIntent, allowed, availableActions, parseStrictJson, recipeInput, rootWarning, sha256, validateAptManifest, validateSensitiveInput, verifyAptManifest, verifyPlanIntegrity } from './safety';
import { actions, PlanInput, Session, request, session, windowsMsi, windowsMsiManifest, validateInput } from './api';
import { adminIntent, allowed, availableActions, windowsMsiPlanJobs, windowsMsiApprovalBlockers, verifyWindowsMsiManifest, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, queryLogsApprovalBlockers, queryLogsPlanJobs, recipeInput, rootWarning, sha256, validateAptManifest, validateSensitiveInput, verifyAptManifest, verifyPlanIntegrity } from './safety';
import { AdminControl } from './management';
vi.mock('react-dom/client', () => ({ createRoot: () => ({ render: vi.fn() }) }));
const auth: Session = { principal: { id: 'test', display_name: 'SIMULIERT', simulated: true }, csrf_token: 'csrf', tenants: [], permissions: ['root:execute', 'devices:revoke'] };
describe('immutable PowerShell process profile', () => {
async function plan(profile: unknown = 'powershell_51_remote_signed', identity = 'agent_service', interpreter = 'powershell') {
const action = { action: 'run_script', interpreter, script_utf8: 'Write-Output 1\r\n', arguments: [], expected_stdout: '1\r\n', ...(profile === undefined ? {} : { windows_execution_profile: profile }) };
const payload = { asset_id: 'fixed-windows', execution_identity: identity, action }, jobs = [{ asset_id: 'fixed-windows', job_payload_hash: 'a'.repeat(64), payload }];
const plan_payload = { jobs }, raw = new TextEncoder().encode(JSON.stringify(plan_payload));
return { plan_payload, plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), jobs };
}
it('requires verified bytes, rejects all profile/view mutations and preserves inherited plans', async () => {
const value = await plan(); expect(() => powerShellPlanJobs(value)).toThrow('nicht aus hashgeprüften');
await verifyPlanIntegrity(value); expect(powerShellPlanJobs(value)).toEqual([{ assetId: 'fixed-windows', profile: 'powershell_51_remote_signed' }]);
expect(powerShellApprovalBlockers(value)).toEqual([]);
const changed = structuredClone(value); changed.jobs[0]!.payload.action.windows_execution_profile = 'Bypass';
await expect(verifyPlanIntegrity(changed)).rejects.toThrow('widerspricht');
const viewOnly = { ...value, jobs: [{ ...value.jobs[0]!, payload: { ...value.jobs[0]!.payload, action: { ...value.jobs[0]!.payload.action, windows_execution_profile: 'Bypass' } } }] };
await expect(verifyPlanIntegrity(viewOnly)).rejects.toThrow('widerspricht');
const extraAlias = { ...value, resolved_targets: value.jobs, jobs: viewOnly.jobs };
await expect(verifyPlanIntegrity(extraAlias)).rejects.toThrow('widerspricht');
await expect(verifyPlanIntegrity({ ...value, payloads: viewOnly.jobs })).rejects.toThrow('widerspricht');
await expect(verifyPlanIntegrity({ ...value, payload: { jobs: viewOnly.jobs } })).rejects.toThrow('widerspricht');
const idsOnly = { ...value, resolved_targets: ['fixed-windows'] }; await verifyPlanIntegrity(idsOnly);
for (const alias of ['plan_payload', 'payload']) {
const later: Record<string, unknown> = { ...value, [alias]: value.plan_payload };
await verifyPlanIntegrity(later); later[alias] = { jobs: viewOnly.jobs };
expect(powerShellApprovalBlockers(later).length).toBeGreaterThan(0); expect(() => powerShellPlanJobs(later)).toThrow('widerspricht');
}
await expect(verifyPlanIntegrity({ ...value, plan_payload_bytes: undefined })).rejects.toThrow('gespeicherte Planbytes');
for (const profile of ['Bypass', null, {}, 'powershell_7_remote_signed']) await expect(verifyPlanIntegrity(await plan(profile))).rejects.toThrow('Windows-Ausführungsprofil');
for (const identity of ['root', 'system']) await expect(verifyPlanIntegrity(await plan('powershell_51_remote_signed', identity))).rejects.toThrow('agent_service');
await expect(verifyPlanIntegrity(await plan('powershell_51_remote_signed', 'agent_service', 'bash'))).rejects.toThrow();
const inherited = await plan(undefined); delete inherited.plan_payload.jobs[0]!.payload.action.windows_execution_profile;
const raw = new TextEncoder().encode(JSON.stringify(inherited.plan_payload)); inherited.plan_payload_bytes = Array.from(raw); inherited.plan_hash = await sha256(raw);
await verifyPlanIntegrity(inherited); expect(powerShellPlanJobs(inherited)[0]?.profile).toBe('inherited');
value.plan_payload_bytes[0] = 0; expect(powerShellApprovalBlockers(value).length).toBeGreaterThan(0); expect(() => powerShellPlanJobs(value)).toThrow('verändert');
});
});
describe('immutable live log window', () => {
it('binds source/window/limits and every supplied view to stored bytes, preserving Linux and SYSTEM plans', async () => {
const payload={asset_id:'windows-a',execution_identity:'agent_service',max_runtime_seconds:30,max_output_bytes:4096,action:{action:'query_logs',unit:'windows.eventlog.application.rustdiscovery-mvp-test',since:'2026-11-14T00:00:00Z',until:'2026-11-15T00:00:00Z',max_lines:1000}};
const plan_payload={jobs:[{payload}]},raw=new TextEncoder().encode(JSON.stringify(plan_payload));
const plan={plan_payload,plan_payload_bytes:Array.from(raw),plan_hash:await sha256(raw),jobs:plan_payload.jobs,resolved_targets:['windows-a']};
expect(()=>queryLogsPlanJobs(plan)).toThrow();await verifyPlanIntegrity(plan);
expect(queryLogsApprovalBlockers(plan)).toEqual([]);expect(queryLogsPlanJobs(plan)[0]).toMatchObject({source:payload.action.unit,channel:'Application',provider:'RustDiscovery-MVP-Test',maxLines:1000,outputBytes:4096,runtimeSeconds:30});
await expect(verifyPlanIntegrity({...plan,plan_payload_bytes:undefined})).rejects.toThrow('gespeicherte');
for(const action of [{...payload.action,max_lines:999},{...payload.action,until:'2026-11-14T23:59:59Z'}]){
const bad={...plan,payloads:[{payload:{...payload,action}}]};await expect(verifyPlanIntegrity(bad)).rejects.toThrow('widerspricht');
}
const changed={...plan,jobs:[{payload:{...payload,max_output_bytes:2048}}]};await expect(verifyPlanIntegrity(changed)).rejects.toThrow('widerspricht');
const cached={...plan};await verifyPlanIntegrity(cached);cached.jobs=[{payload:{...payload,max_runtime_seconds:31}}];expect(queryLogsApprovalBlockers(cached).length).toBeGreaterThan(0);
for(const execution_identity of ['root','system']){const p={jobs:[{payload:{...payload,execution_identity}}]};const b=new TextEncoder().encode(JSON.stringify(p));await expect(verifyPlanIntegrity({plan_payload_bytes:Array.from(b),plan_hash:await sha256(b)})).rejects.toThrow('agent_service');}
const linux={jobs:[{payload:{...payload,execution_identity:'root',action:{...payload.action,unit:'rmm-test.service'}}}]};const linuxBytes=new TextEncoder().encode(JSON.stringify(linux));const linuxPlan={plan_payload_bytes:Array.from(linuxBytes),plan_hash:await sha256(linuxBytes)};await verifyPlanIntegrity(linuxPlan);expect(queryLogsPlanJobs(linuxPlan)[0]?.windows).toBe(false);
const system={jobs:[{payload:{...payload,execution_identity:'system',action:{action:'set_service_state',unit:'RmmDiscoveryFixtureService',state:'running'}}}]};const systemBytes=new TextEncoder().encode(JSON.stringify(system));const systemPlan={plan_payload_bytes:Array.from(systemBytes),plan_hash:await sha256(systemBytes)};await verifyPlanIntegrity(systemPlan);expect(queryLogsPlanJobs(systemPlan)).toEqual([]);
});
});
async function manifest(acceptance = true) {
const transaction = { schema_version: 1, recipe_id: 'rmm-apt-fixture-install-1.0', recipe_version: '1', platform: 'ubuntu-24.04-amd64', resolver_config_version: 'rmm-apt-local-v1', no_reboot: true, status_fingerprint: 'a'.repeat(64), baseline_sha256: 'b'.repeat(64), packages: [{ name: 'rmm-mvp-test', architecture: 'all', old_version: null, new_version: '1.0', origin: 'rmm-test', sha256: '74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867', size: 20672, archive_path: '/var/lib/rmm-apt-transaction/archives/74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867.deb' }] };
const raw = new TextEncoder().encode(JSON.stringify(transaction));
@@ -142,3 +196,105 @@ describe('interactive administrative boundary', () => {
expect(fetch).toHaveBeenCalledWith('/api/v1/tenants/t/execution-stop', expect.objectContaining({ credentials: 'same-origin', headers: { 'Content-Type': 'application/json', 'X-CSRF-Token': 'csrf' }, body: '{"reason":"test only","stopped":true}' })); vi.unstubAllGlobals();
});
});
// Actual rmm_domain::jobs::encode(PlanPayload) output from the private synthetic
// offline harness (no signer, real device, database or native execution).
const msiDomainGoldens = [
"{\"schema_version\":1,\"plan_id\":\"00000000-0000-4000-8000-000000000006\",\"tenant_id\":\"00000000-0000-4000-8000-000000000001\",\"principal\":\"simulated-unit-only\",\"reason\":\"MSI UI contract, no execution\",\"jobs\":[{\"payload\":{\"schema_version\":1,\"tenant_id\":\"00000000-0000-4000-8000-000000000001\",\"asset_id\":\"00000000-0000-4000-8000-000000000002\",\"agent_id\":\"00000000-0000-4000-8000-000000000003\",\"enrollment_generation\":1,\"assignment_version\":1,\"job_id\":\"00000000-0000-4000-8000-000000000004\",\"attempt_id\":\"00000000-0000-4000-8000-000000000005\",\"action\":{\"action\":\"ensure_package\",\"provider\":\"msi\",\"package\":\"rmm-windows-msi-fixture\",\"version\":\"1.0.0\",\"architecture\":\"x64\",\"recipe_version\":\"1\",\"installation_context\":\"machine\",\"recipe_id\":\"rmm-windows-msi-fixture-install-1.0\",\"windows_msi_manifest\":{\"recipe\":{\"schema_version\":1,\"recipe_id\":\"rmm-windows-msi-fixture-install-1.0\",\"recipe_version\":\"1\",\"platform\":\"windows\",\"upgrade_code\":\"{C9BF1FB8-E31D-4BD7-BA0D-AB46539BBBAA}\",\"architecture\":\"x64\",\"context\":\"machine\",\"command_profile\":\"fixture_quiet_no_reboot_v1\",\"artifact\":{\"artifact_id\":\"00000000-0000-4000-8000-000000000010\",\"sha256\":\"abababababababababababababababababababababababababababababababab\",\"bytes\":32768},\"postcondition\":{\"product_code\":\"{3F070B4B-9C08-4D65-BD41-13D81B884AEC}\",\"product_version\":\"1.0.0\",\"payload_path\":\"C:\\\\Program Files\\\\RustDiscoveryFixtures\\\\msi-payload.txt\",\"payload_sha256\":\"0c90c4fc7233017cc88c0e925095d6662ac57abdb303c7527ef59d02b454fca0\",\"payload_bytes\":33},\"no_reboot\":true},\"recipe_sha256\":\"47e4a478f0e3b2976ededa6afa6058d6e56ceec4e0e36cc5950701c1e65190f5\"}},\"execution_identity\":\"system\",\"not_before\":\"2027-01-01T00:00:00Z\",\"start_before\":\"2027-01-01T01:00:00Z\",\"max_runtime_seconds\":30,\"max_output_bytes\":4096},\"job_payload_hash\":\"5df5828c52c2be0b005f31551319e5892a6daa80a4d30c76f95153e24eeec9b1\",\"script_sha256\":null}],\"max_parallel\":1,\"halt_after_failures\":1,\"recipe_references\":[{\"package\":\"rmm-windows-msi-fixture\",\"version\":\"1.0.0\",\"architecture\":\"x64\",\"recipe_version\":\"1\",\"sha256\":\"47e4a478f0e3b2976ededa6afa6058d6e56ceec4e0e36cc5950701c1e65190f5\"}],\"artifact_references\":[{\"job_id\":\"00000000-0000-4000-8000-000000000004\",\"attempt_id\":\"00000000-0000-4000-8000-000000000005\",\"artifact\":{\"artifact_id\":\"00000000-0000-4000-8000-000000000010\",\"sha256\":\"abababababababababababababababababababababababababababababababab\",\"size_bytes\":32768}}]}",
"{\"schema_version\":1,\"plan_id\":\"00000000-0000-4000-8000-000000000006\",\"tenant_id\":\"00000000-0000-4000-8000-000000000001\",\"principal\":\"simulated-unit-only\",\"reason\":\"MSI UI contract, no execution\",\"jobs\":[{\"payload\":{\"schema_version\":1,\"tenant_id\":\"00000000-0000-4000-8000-000000000001\",\"asset_id\":\"00000000-0000-4000-8000-000000000002\",\"agent_id\":\"00000000-0000-4000-8000-000000000003\",\"enrollment_generation\":1,\"assignment_version\":1,\"job_id\":\"00000000-0000-4000-8000-000000000004\",\"attempt_id\":\"00000000-0000-4000-8000-000000000005\",\"action\":{\"action\":\"ensure_package\",\"provider\":\"msi\",\"package\":\"rmm-windows-msi-fixture\",\"version\":\"1.1.0\",\"architecture\":\"x64\",\"recipe_version\":\"1\",\"installation_context\":\"machine\",\"recipe_id\":\"rmm-windows-msi-fixture-upgrade-1.1\",\"windows_msi_manifest\":{\"recipe\":{\"schema_version\":1,\"recipe_id\":\"rmm-windows-msi-fixture-upgrade-1.1\",\"recipe_version\":\"1\",\"platform\":\"windows\",\"upgrade_code\":\"{C9BF1FB8-E31D-4BD7-BA0D-AB46539BBBAA}\",\"architecture\":\"x64\",\"context\":\"machine\",\"command_profile\":\"fixture_quiet_no_reboot_v1\",\"artifact\":{\"artifact_id\":\"00000000-0000-4000-8000-000000000010\",\"sha256\":\"abababababababababababababababababababababababababababababababab\",\"bytes\":32768},\"postcondition\":{\"product_code\":\"{D42BD387-079B-4BBF-A134-0DA7B7A97011}\",\"product_version\":\"1.1.0\",\"payload_path\":\"C:\\\\Program Files\\\\RustDiscoveryFixtures\\\\msi-payload.txt\",\"payload_sha256\":\"ba0c83deff9eed014009bcd45369b2a356ae909ebf0c1434dc836b0e6d759c49\",\"payload_bytes\":33},\"no_reboot\":true,\"package_code\":\"{AF1C9887-391A-4BFF-B909-BC898300CF90}\",\"predecessor\":{\"product_code\":\"{3F070B4B-9C08-4D65-BD41-13D81B884AEC}\",\"product_version\":\"1.0.0\",\"payload_path\":\"C:\\\\Program Files\\\\RustDiscoveryFixtures\\\\msi-payload.txt\",\"payload_sha256\":\"0c90c4fc7233017cc88c0e925095d6662ac57abdb303c7527ef59d02b454fca0\",\"payload_bytes\":33}},\"recipe_sha256\":\"376d4a05fa43565a302cd1f90514e355e3f89a634d43abb9c31978e740bf7e9c\"}},\"execution_identity\":\"system\",\"not_before\":\"2027-01-01T00:00:00Z\",\"start_before\":\"2027-01-01T01:00:00Z\",\"max_runtime_seconds\":30,\"max_output_bytes\":4096},\"job_payload_hash\":\"33184fcde0395a48dccb5e0cbb4d48f92f59664c8c964db7489d6686a0002546\",\"script_sha256\":null}],\"max_parallel\":1,\"halt_after_failures\":1,\"recipe_references\":[{\"package\":\"rmm-windows-msi-fixture\",\"version\":\"1.1.0\",\"architecture\":\"x64\",\"recipe_version\":\"1\",\"sha256\":\"376d4a05fa43565a302cd1f90514e355e3f89a634d43abb9c31978e740bf7e9c\"}],\"artifact_references\":[{\"job_id\":\"00000000-0000-4000-8000-000000000004\",\"attempt_id\":\"00000000-0000-4000-8000-000000000005\",\"artifact\":{\"artifact_id\":\"00000000-0000-4000-8000-000000000010\",\"sha256\":\"abababababababababababababababababababababababababababababababab\",\"size_bytes\":32768}}]}"
] as const;
// Mirrors the Rust Recipe/Action/Job declaration order, not a preview alias.
async function msiFixture(upgrade = false) {
const id = (n: number) => `00000000-0000-4000-8000-${String(n).padStart(12, '0')}`;
const old = { product_code: windowsMsi.product, product_version: '1.0.0', payload_path: windowsMsi.payload, payload_sha256: windowsMsi.payload10, payload_bytes: 33 };
const recipe = { schema_version: 1, recipe_id: upgrade ? windowsMsi.upgradeRecipe : windowsMsi.installRecipe, recipe_version: '1', platform: 'windows', upgrade_code: windowsMsi.family, architecture: 'x64', context: 'machine', command_profile: 'fixture_quiet_no_reboot_v1', artifact: { artifact_id: id(10), sha256: 'ab'.repeat(32), bytes: 32768 }, postcondition: upgrade ? { ...old, product_code: windowsMsi.upgradedProduct, product_version: '1.1.0', payload_sha256: windowsMsi.payload11 } : old, no_reboot: true, ...(upgrade ? { package_code: '{AF1C9887-391A-4BFF-B909-BC898300CF90}', predecessor: old } : {}) };
const manifest = { recipe, recipe_sha256: await sha256(new TextEncoder().encode(JSON.stringify(recipe))) };
const action = { action: 'ensure_package', provider: 'msi', package: windowsMsi.package, version: recipe.postcondition.product_version, architecture: 'x64', recipe_version: '1', installation_context: 'machine', recipe_id: recipe.recipe_id, windows_msi_manifest: manifest };
const payload = { schema_version: 1, tenant_id: id(1), asset_id: id(2), agent_id: id(3), enrollment_generation: 1, assignment_version: 1, job_id: id(4), attempt_id: id(5), action, execution_identity: 'system', not_before: '2027-01-01T00:00:00Z', start_before: '2027-01-01T01:00:00Z', max_runtime_seconds: 30, max_output_bytes: 4096 };
const job = { payload, job_payload_hash: await sha256(new TextEncoder().encode(JSON.stringify(payload))), script_sha256: null };
const constructed = { schema_version: 1, plan_id: id(6), tenant_id: id(1), principal: 'simulated-unit-only', reason: 'MSI UI contract, no execution', jobs: [job], max_parallel: 1, halt_after_failures: 1, recipe_references: [{ package: windowsMsi.package, version: action.version, architecture: 'x64', recipe_version: '1', sha256: manifest.recipe_sha256 }], artifact_references: [{ job_id: payload.job_id, attempt_id: payload.attempt_id, artifact: { artifact_id: recipe.artifact.artifact_id, sha256: recipe.artifact.sha256, size_bytes: recipe.artifact.bytes } }] };
const golden = msiDomainGoldens[upgrade ? 1 : 0];
expect(JSON.stringify(constructed)).toBe(golden); // Independent Rust codec oracle.
const plan_payload = parseStrictJson(golden) as typeof constructed;
const actualJob = plan_payload.jobs[0]!;
const raw = new TextEncoder().encode(golden);
const preview = { ...actualJob, job_id: actualJob.payload.job_id, attempt_id: actualJob.payload.attempt_id, asset_id: actualJob.payload.asset_id, agent_id: actualJob.payload.agent_id };
const plan = structuredClone({ plan_id: plan_payload.plan_id, plan_payload, payload: plan_payload, plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), jobs: [preview], payloads: [preview], resolved_targets: [{ asset_id: payload.asset_id, agent_id: payload.agent_id }], expires_at: payload.start_before });
return { manifest: actualJob.payload.action.windows_msi_manifest, action: actualJob.payload.action, payload: actualJob.payload, plan_payload, plan };
}
describe('fixed SYSTEM MSI UI contract', () => {
it('renders only the verified fixed package definition and never issues an approval or download', async () => {
const fetch = vi.fn(); vi.stubGlobal('fetch', fetch); vi.stubGlobal('document', { getElementById: () => ({}) });
try {
const { WindowsMsiPlanNotice } = await import('./main');
for (const upgrade of [false, true]) {
const { plan } = await msiFixture(upgrade);
expect(renderToStaticMarkup(<WindowsMsiPlanNotice plan={plan}/>)).toContain('role="alert"');
await verifyPlanIntegrity(plan); const html = renderToStaticMarkup(<WindowsMsiPlanNotice plan={plan}/>);
for (const value of ['SYSTEM', 'Machine', 'x64', upgrade ? windowsMsi.upgradeRecipe : windowsMsi.installRecipe, windowsMsi.product, windowsMsi.family, 'Rezept-SHA256', 'Artefakt', 'Vorgänger', 'No-Reboot: true', '30s', '4096', '/norestart', 'REBOOT=ReallySuppress', 'ALLUSERS=1', '3010', '1641', '1618']) expect(html).toContain(value);
if (upgrade) { expect(html).toContain(windowsMsi.upgradedProduct); expect(html).toContain('AF1C9887'); }
else expect(html).toContain('historischen1.0-Rezept nicht separat gebunden');
expect(html).not.toMatch(/<(button|input|form|script)\b/); expect(fetch).not.toHaveBeenCalled();
plan.jobs[0]!.payload.action.provider = 'foreign-installer';
const invalid = renderToStaticMarkup(<WindowsMsiPlanNotice plan={plan}/>); expect(invalid).toContain('role="alert"'); expect(invalid).not.toContain('foreign-installer');
}
} finally { vi.unstubAllGlobals(); }
});
it('checks canonical nested recipe bytes, strict typed inputs and independent SYSTEM rights', async () => {
const { manifest, action } = await msiFixture(true);
const { action: _action, ...fields } = action;
const input: PlanInput = { tenant_id: 't', action: 'ensure_package', targets: { asset_ids: ['a'] }, parameters: { ...fields, execution_identity: 'system', timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: new Date().toISOString(), start_before: new Date(Date.now() + 60000).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'fixed MSI' };
const original = JSON.stringify(input); validateInput(input); await validateSensitiveInput(input, { ...auth, permissions: ['system:execute'] }); expect(JSON.stringify(input)).toBe(original);
const formNull = { ...input, parameters: { ...input.parameters, apt_manifest: null } }; validateInput(formNull); await validateSensitiveInput(formNull, { ...auth, permissions: ['system:execute'] });
const reversed = { ...manifest, recipe: Object.fromEntries(Object.entries(manifest.recipe).reverse()) };
expect(await verifyWindowsMsiManifest(reversed)).toEqual(windowsMsiManifest(manifest));
await expect(verifyWindowsMsiManifest({ ...manifest, recipe_sha256: 'cd'.repeat(32) })).rejects.toThrow('Rezepthash');
for (const permissions of [undefined, [], ['root:execute']]) await expect(validateSensitiveInput(input, { ...auth, permissions })).rejects.toThrow('system:execute');
for (const change of [{ execution_identity: 'root' }, { provider: 'apt' }, { architecture: 'amd64' }, { installation_context: 'system' }, { version: '2.0' }, { arguments: ['/quiet'] }, { apt_manifest: {} }, { timeout_seconds: 9 }, { timeout_seconds: 121 }, { max_output_bytes: 1023 }, { max_output_bytes: 65537 }, { windows_msi_manifest: null }]) expect(() => validateInput({ ...input, parameters: { ...input.parameters, ...change } })).toThrow();
expect(() => validateInput({ ...input, artifact_ids: [manifest.recipe.artifact.artifact_id] })).toThrow('automatisch');
for (const change of [{ architecture: { x64: null } }, { context: 'user' }, { command_profile: { fixture_quiet_no_reboot_v1: null } }, { no_reboot: false }, { installer_url: 'https://example.invalid/a.msi' }, { package_code: null }, { predecessor: { ...manifest.recipe.predecessor, product_version: '0.9' } }]) expect(() => windowsMsiManifest({ ...manifest, recipe: { ...manifest.recipe, ...change } })).toThrow();
});
it('requires the complete per-job recipe/artifact set and immutable full job hash', async () => {
for (const upgrade of [false, true]) {
const { plan } = await msiFixture(upgrade);
expect(() => windowsMsiPlanJobs(plan)).toThrow('nicht aus hashgeprüften');
await verifyPlanIntegrity(plan); const job = windowsMsiPlanJobs(plan)[0]!;
expect(job.version).toBe(upgrade ? '1.1.0' : '1.0.0'); expect(job.packageCode !== null).toBe(upgrade); expect(job.arguments).toEqual(['/i', `C:\\ProgramData\\RustDiscoverySystem\\cache\\${'ab'.repeat(32)}.msi`, '/qn', '/norestart', 'REBOOT=ReallySuppress', 'ALLUSERS=1']);
expect(windowsMsiApprovalBlockers(plan)).toEqual([]);
for (const mutate of [
(p: typeof plan.plan_payload) => { p.artifact_references = []; },
(p: typeof plan.plan_payload) => { p.artifact_references.push(structuredClone(p.artifact_references[0]!)); },
(p: typeof plan.plan_payload) => { p.artifact_references[0]!.artifact.size_bytes++; },
(p: typeof plan.plan_payload) => { p.artifact_references[0]!.attempt_id = '00000000-0000-4000-8000-000000000099'; },
(p: typeof plan.plan_payload) => { p.recipe_references.push(structuredClone(p.recipe_references[0]!)); },
(p: typeof plan.plan_payload) => { p.recipe_references = []; },
(p: typeof plan.plan_payload) => { p.jobs[0]!.payload.max_output_bytes++; },
(p: typeof plan.plan_payload) => { Object.assign(p.jobs[0]!.payload.action, { apt_manifest: null }); },
(p: typeof plan.plan_payload) => { Object.assign(p.jobs[0]!.payload.action, { apt_manifest: {} }); },
]) {
const changed = structuredClone(plan.plan_payload); mutate(changed); const raw = new TextEncoder().encode(JSON.stringify(changed));
await expect(verifyPlanIntegrity({ plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw) })).rejects.toThrow();
}
}
});
it('blocks every alias and late mutation without blessing changed bytes or issuing a request', async () => {
const fetch = vi.fn(); vi.stubGlobal('fetch', fetch);
try {
for (const alias of ['jobs', 'payloads', 'resolved_targets', 'payload', 'plan_payload']) {
const { plan } = await msiFixture(true); await verifyPlanIntegrity(plan);
const object = plan as Record<string, unknown>;
if (alias === 'resolved_targets') plan.resolved_targets[0]!.agent_id = '00000000-0000-4000-8000-000000000099';
else if (alias === 'jobs' || alias === 'payloads') { const view = structuredClone(plan.jobs); view[0]!.payload.max_runtime_seconds++; object[alias] = view; }
else { const view = structuredClone(plan.plan_payload); view.jobs[0]!.payload.action.windows_msi_manifest.recipe.artifact.bytes++; object[alias] = view; }
expect(windowsMsiApprovalBlockers(plan).length).toBeGreaterThan(0); await expect(verifyPlanIntegrity(plan)).rejects.toThrow();
}
const { plan } = await msiFixture(); await verifyPlanIntegrity(plan);
const copy = windowsMsiPlanJobs(plan)[0]!; (copy.arguments as string[]).push('FORGED=1'); expect(windowsMsiPlanJobs(plan)[0]!.arguments).not.toContain('FORGED=1');
const changed = structuredClone(plan.plan_payload); changed.reason = 'later'; const raw = new TextEncoder().encode(JSON.stringify(changed)); plan.plan_payload_bytes = Array.from(raw); plan.plan_hash = await sha256(raw);
await expect(verifyPlanIntegrity(plan)).rejects.toThrow('verändert');
expect(fetch).not.toHaveBeenCalled();
} finally { vi.unstubAllGlobals(); }
});
});
+257 -10
View File
@@ -1,8 +1,8 @@
import { Action, PlanInput, RecordValue, Session, record, text, validateSystemService } from './api';
import { Action, PlanInput, RecordValue, Session, planTargetPreviews, record, text, validateSystemService, windowsScriptProfile, logWindow, validateWindowsLogLimits, windowsEventLogFixtureSource, windowsEventLogFixtureChannel, windowsEventLogFixtureProvider, WindowsMsiManifest, MsiPostcondition, windowsMsi, windowsMsiManifest, windowsMsiAction, validateWindowsMsiInput, validateWindowsMsiLimits, msiUuid } from './api';
export const hashPattern = /^[0-9a-f]{64}$/;
export const rootWarning = 'HOHES RISIKO: root kann das Zielsystem verändern. Keine automatische Rechteerhöhung; eigener expliziter Plan, Scope, Helper und Genehmigung erforderlich.';
export const systemWarning = 'SYSTEM: ausschließlich fest benannter Windows-Fixturedienst und running/stopped. Eigenes system:execute, unabhängiger Helper und konkrete WebUI-Genehmigung erforderlich. Keine SYSTEM-Shell, kein impliziter Reboot oder Retry.';
export const systemWarning = 'SYSTEM: ausschließlich fest benannter Windows-Fixturedienst (running/stopped) oder eigenes festes MSI-Rezept. Eigenes system:execute, unabhängiger Helper und konkrete WebUI-Genehmigung erforderlich. Keine SYSTEM-Shell, kein impliziter Reboot oder Retry.';
export function permissions(auth: Session): string[] | null { return auth.permissions ?? null; }
export function allowed(auth: Session, permission: string): boolean { return permissions(auth)?.includes(permission) === true; }
export function availableActions(auth: Session, base: readonly Action[]): Action[] { return base.filter(a => a !== 'apt_native_acceptance' || auth.principal.simulated === true); }
@@ -75,8 +75,13 @@ export async function validateSensitiveInput(input: PlanInput, auth: Session) {
if (input.parameters.execution_identity === 'root' && !allowed(auth, 'root:execute')) throw new Error('root:execute unbekannt oder nicht erteilt; keine Rechteerhöhung');
if (input.parameters.execution_identity === 'system') {
if (!allowed(auth, 'system:execute')) throw new Error('system:execute unbekannt oder nicht erteilt; root:execute enthält dieses Recht nicht');
if (input.action !== 'set_service_state') throw new Error('SYSTEM ausschließlich für typisierte Dienstaktionen');
validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
if (input.action !== 'set_service_state' && input.action !== 'ensure_package') throw new Error('SYSTEM ausschließlich für typisierte Dienstaktionen oder feste MSI-Rezepte');
if (input.action === 'set_service_state') validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
}
if (Object.prototype.hasOwnProperty.call(input.parameters, 'windows_msi_manifest') || (input.action === 'ensure_package' && input.parameters.execution_identity === 'system')) {
const original = canonical(input), m = validateWindowsMsiInput(input); await verifyWindowsMsiManifest(m);
if (canonical(input) !== original) throw new Error('MSI-Antrag wurde während der Hashprüfung verändert');
return;
}
if (input.action === 'apt_native_acceptance') {
if (!auth.principal.simulated || input.parameters.execution_identity !== 'root') throw new Error('APT-Abnahme ausschließlich explizit simuliert und root');
@@ -96,12 +101,231 @@ export async function validateSensitiveInput(input: PlanInput, auth: Session) {
}
/** Display only definitions decoded from the exact hashed plan bytes. */
export function systemPlanJobs(plan: RecordValue): RecordValue[] {
if (plan.plan_payload_bytes === undefined) return [];
const parsed = record(parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(bytes(plan.plan_payload_bytes))));
if (!Array.isArray(parsed.jobs)) return [];
return parsed.jobs.map(value => record(record(value).payload)).filter(payload => payload.execution_identity === 'system');
powerShellPlanJobs(plan);
return structuredClone(verifiedPowerShellPlans.get(plan)!.systemJobs);
}
export interface PowerShellPlanJob { readonly assetId: string; readonly profile: 'inherited' | 'powershell_51_remote_signed' }
// Only successful verification writes this cache. Projection is copied from the
// verified bytes; later mutations of API views cannot change the displayed plan.
interface VerifiedPowerShellPlan { readonly jobs: readonly PowerShellPlanJob[]; readonly logJobs: readonly QueryLogsPlanJob[]; readonly msiJobs: readonly WindowsMsiPlanJob[]; readonly systemJobs: RecordValue[]; readonly planHash: unknown; readonly planBytes: readonly number[] }
const verifiedPowerShellPlans = new WeakMap<RecordValue, VerifiedPowerShellPlan>();
export function powerShellPlanJobs(plan: RecordValue): readonly PowerShellPlanJob[] {
const verified = verifiedPowerShellPlans.get(plan);
if (!verified) throw new Error('PowerShell-Plan wurde nicht aus hashgeprüften gespeicherten Bytes verifiziert');
if (verified.planBytes.length) {
const current = bytes(plan.plan_payload_bytes);
if (plan.plan_hash !== verified.planHash || current.length !== verified.planBytes.length || verified.planBytes.some((value, i) => current[i] !== value)) throw new Error('PowerShell-Planbytes wurden nach Verifikation verändert');
const parsed = record(parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(current)));
validatePlanAliases(plan, parsed);
validatePowerShellViews(plan, parsed.jobs);
validateQueryLogsViews(plan, parsed.jobs);
validateMsiViews(plan, parsed.jobs);
} else if (scriptPayloads(planTargetPreviews(plan)).some(hasPowerShellProfile)) {
throw new Error('PowerShell-Plan benötigt exakte gespeicherte Planbytes');
}
return verified.jobs.map(job => ({ ...job }));
}
export function powerShellApprovalBlockers(plan: RecordValue): string[] {
try { powerShellPlanJobs(plan); return []; }
catch (error) { return [error instanceof Error ? error.message : 'PowerShell-Profil ist nicht verifiziert']; }
}
function scriptPayloads(jobs: unknown): RecordValue[] {
if (!Array.isArray(jobs)) return [];
return jobs.flatMap(job => {
if (!job || typeof job !== 'object') return [];
const payload = record(job).payload;
return payload && typeof payload === 'object' ? [record(payload)] : [];
});
}
function hasPowerShellProfile(payload: RecordValue): boolean {
if (Object.prototype.hasOwnProperty.call(payload, 'windows_execution_profile')) throw new Error('Windows-Ausführungsprofil muss Teil der festen Skriptaktion sein');
const action = payload.action;
return action !== null && typeof action === 'object' && (record(action).interpreter === 'powershell'
|| Object.prototype.hasOwnProperty.call(action, 'windows_execution_profile'));
}
function projectPowerShellJobs(jobs: unknown): PowerShellPlanJob[] {
return scriptPayloads(jobs).filter(hasPowerShellProfile).map(payload => {
const action = record(payload.action);
if (action.action !== 'run_script' || action.interpreter !== 'powershell' || payload.execution_identity !== 'agent_service') throw new Error('PowerShell-Profil benötigt Windows PowerShell5.1 als agent_service');
exact(action, ['action', 'interpreter', 'script_utf8', 'arguments', 'expected_stdout', ...(Object.prototype.hasOwnProperty.call(action, 'windows_execution_profile') ? ['windows_execution_profile'] : [])]);
if (typeof action.script_utf8 !== 'string' || !action.script_utf8 || new TextEncoder().encode(action.script_utf8).length > 32768 || action.script_utf8.includes('\0')
|| (!/^[\x00-\x7f]*$/.test(action.script_utf8) && !action.script_utf8.startsWith('\ufeff'))
|| !Array.isArray(action.arguments) || action.arguments.length > 32 || action.arguments.some(arg => typeof arg !== 'string' || new TextEncoder().encode(arg).length > 4096 || arg.includes('\0'))
|| !(action.expected_stdout === null || (typeof action.expected_stdout === 'string' && new TextEncoder().encode(action.expected_stdout).length <= 65536))) throw new Error('Vollständige unveränderte PowerShell-Skriptaktion erforderlich');
return { assetId: text(payload.asset_id, 'PowerShell-Zielasset'), profile: windowsScriptProfile(action) };
});
}
function validatePlanAliases(plan: RecordValue, parsed: unknown): void {
for (const alias of ['plan_payload', 'payload']) if (plan[alias] !== undefined && canonical(parsed) !== canonical(plan[alias])) throw new Error('Planansicht widerspricht gespeicherten Bytes');
const p = record(parsed);
if (scriptPayloads(p.jobs).some(isMsi) && ((plan.plan_id !== undefined && plan.plan_id !== p.plan_id) || (plan.expires_at !== undefined && plan.expires_at !== scriptPayloads(p.jobs)[0]?.start_before))) throw new Error('MSI-Plan-ID/Fristansicht widerspricht gespeicherten Bytes');
}
function validateFixedViews(plan: RecordValue, rawJobs: unknown, selected: (payload: RecordValue) => boolean, label: string, fields = ['action', 'execution_identity']): void {
const rawPayloads = scriptPayloads(rawJobs), views = [planTargetPreviews(plan)];
for (const alias of ['jobs', 'payloads', 'resolved_targets']) {
if (plan[alias] !== undefined && !Array.isArray(plan[alias])) throw new Error(`${label}-Zielpreview ist keine vollständige Liste`);
if (Array.isArray(plan[alias])) views.push(plan[alias]);
}
for (const collection of new Set(views)) if (collection !== null) {
if (!collection.some(value => value !== null && typeof value === 'object' && !Array.isArray(value) && 'payload' in value)) continue;
const viewPayloads = scriptPayloads(collection);
for (const fixed of rawPayloads.filter(selected)) if (!viewPayloads.some(view => view.asset_id === fixed.asset_id)) throw new Error(`${label}-Zielpreview fehlt im festen Plan`);
for (const view of viewPayloads) {
const raw = rawPayloads.find(payload => payload.asset_id === view.asset_id);
if ((selected(view) || (raw && selected(raw))) && (!raw || fields.some(field => canonical(raw[field]) !== canonical(view[field])))) throw new Error(`${label}-Zielpreview widerspricht gespeicherten Planbytes`);
}
}
}
function validatePowerShellViews(plan: RecordValue, rawJobs: unknown): void {
validateFixedViews(plan, rawJobs, hasPowerShellProfile, 'PowerShell');
}
function isQueryLogs(payload: RecordValue): boolean {
return payload.action !== null && typeof payload.action === 'object' && record(payload.action).action === 'query_logs';
}
function validateQueryLogsViews(plan: RecordValue, rawJobs: unknown): void {
validateFixedViews(plan, rawJobs, isQueryLogs, 'Log', ['action', 'execution_identity', 'max_runtime_seconds', 'max_output_bytes']);
}
export interface QueryLogsPlanJob {
readonly assetId: string; readonly source: string; readonly since: string; readonly until: string;
readonly maxLines: number; readonly runtimeSeconds: number; readonly outputBytes: number; readonly windows: boolean;
readonly channel: string | null; readonly provider: string | null;
}
function projectQueryLogsJobs(jobs: unknown): QueryLogsPlanJob[] {
return scriptPayloads(jobs).filter(isQueryLogs).map(payload => {
const action = record(payload.action);
exact(action, ['action', 'unit', 'since', 'until', 'max_lines']);
const source = text(action.unit, 'Logquelle'), since = text(action.since, 'since'), until = text(action.until, 'until');
logWindow(since, until);
if (typeof action.max_lines !== 'number' || !Number.isSafeInteger(action.max_lines) || action.max_lines < 1 || action.max_lines > 1000
|| typeof payload.max_runtime_seconds !== 'number' || !Number.isSafeInteger(payload.max_runtime_seconds) || payload.max_runtime_seconds < 1 || payload.max_runtime_seconds > 3600
|| typeof payload.max_output_bytes !== 'number' || !Number.isSafeInteger(payload.max_output_bytes) || payload.max_output_bytes < 1 || payload.max_output_bytes > 262144) throw new Error('Vollständige feste Loglimits erforderlich');
const windows = source === windowsEventLogFixtureSource;
if (source.startsWith('windows.eventlog.') && !windows) throw new Error('Unbekannte Windows-Eventlogquelle');
if (windows) validateWindowsLogLimits(payload.execution_identity, payload.max_runtime_seconds, payload.max_output_bytes, since);
else if (!['agent_service', 'root'].includes(String(payload.execution_identity))) throw new Error('Unbekannte Log-Ausführungsidentität');
return { assetId: text(payload.asset_id, 'Log-Zielasset'), source, since, until, maxLines: action.max_lines,
runtimeSeconds: payload.max_runtime_seconds, outputBytes: payload.max_output_bytes, windows,
channel: windows ? windowsEventLogFixtureChannel : null, provider: windows ? windowsEventLogFixtureProvider : null };
});
}
export function queryLogsPlanJobs(plan: RecordValue): readonly QueryLogsPlanJob[] {
// Reuse the same verified-object/immutable-byte gate as the PowerShell view.
powerShellPlanJobs(plan);
const verified = verifiedPowerShellPlans.get(plan)!;
if (!verified.planBytes.length && ['jobs', 'payloads', 'resolved_targets'].some(alias => scriptPayloads(plan[alias]).some(isQueryLogs))) throw new Error('Logplan benötigt exakte gespeicherte Planbytes');
return verified.logJobs.map(job => ({ ...job }));
}
export function queryLogsApprovalBlockers(plan: RecordValue): string[] {
try { queryLogsPlanJobs(plan); return []; }
catch (error) { return [error instanceof Error ? error.message : 'Logplan ist nicht verifiziert']; }
}
export async function verifyWindowsMsiManifest(value: unknown): Promise<WindowsMsiManifest> {
const m = windowsMsiManifest(value);
if (await sha256(new TextEncoder().encode(JSON.stringify(m.recipe))) !== m.recipe_sha256) throw new Error('MSI-Rezepthash widerspricht kanonischen Rust-Rezeptbytes');
return m;
}
function isMsi(payload: RecordValue): boolean {
const action = payload.action;
return action !== null && typeof action === 'object' && (record(action).provider === 'msi' || Object.prototype.hasOwnProperty.call(action, 'windows_msi_manifest'));
}
function hasMsiView(plan: RecordValue): boolean {
return ['jobs', 'payloads', 'resolved_targets'].some(alias => scriptPayloads(plan[alias]).some(isMsi))
|| scriptPayloads(record(plan.plan_payload ?? {}).jobs).some(isMsi) || scriptPayloads(record(plan.payload ?? {}).jobs).some(isMsi);
}
/** MSI views bind the entire payload, preview identity and hash, not just argv. */
function validateMsiViews(plan: RecordValue, rawJobs: unknown): void {
const originals = Array.isArray(rawJobs) ? rawJobs.map(job => record(job)) : [];
const raw = scriptPayloads(rawJobs);
for (const alias of ['jobs', 'payloads', 'resolved_targets']) {
const values = plan[alias]; if (values === undefined) continue;
if (!Array.isArray(values)) { if (raw.some(isMsi)) throw new Error('MSI-Zielansicht ist keine vollständige Liste'); continue; }
if (!raw.some(isMsi) && !scriptPayloads(values).some(isMsi)) continue;
if (values.length !== raw.length) throw new Error('MSI-Zielansicht ist unvollständig oder enthält zusätzliche Ziele');
const seen = new Set<string>();
for (const value of values) {
const v = typeof value === 'string' ? { asset_id: value } : record(value);
const payload = v.payload === undefined ? null : record(v.payload);
const asset = text(v.asset_id ?? payload?.asset_id, 'MSI-Zielasset'), index = raw.findIndex(item => item.asset_id === asset);
if (index < 0 || seen.has(asset)) throw new Error('MSI-Zielansicht enthält fremde/doppelte Ziele'); seen.add(asset);
const fixed = raw[index]!, original = originals[index]!;
if (!isMsi(fixed)) throw new Error('MSI-Ansicht widerspricht gespeichertem Aktionstyp');
if (payload) {
const allowed = ['payload', 'job_payload_hash', 'script_sha256', 'asset_id', 'agent_id', 'job_id', 'attempt_id'];
if (Object.keys(v).some(key => !allowed.includes(key)) || canonical(payload) !== canonical(fixed) || v.job_payload_hash !== original.job_payload_hash || (v.script_sha256 !== undefined && v.script_sha256 !== original.script_sha256)
|| ['agent_id', 'job_id', 'attempt_id'].some(key => v[key] !== undefined && v[key] !== fixed[key])) throw new Error('MSI-Zielpreview widerspricht gespeicherten Planbytes');
} else if (alias !== 'resolved_targets' || (typeof value !== 'string' && (Object.keys(v).some(key => !['asset_id', 'agent_id'].includes(key)) || v.agent_id !== fixed.agent_id))) throw new Error('Vollständiger MSI-Zielpayload fehlt');
}
}
}
export interface WindowsMsiPlanJob {
readonly assetId: string; readonly recipeId: string; readonly recipeHash: string;
readonly artifactId: string; readonly artifactHash: string; readonly artifactBytes: number;
readonly productCode: string; readonly upgradeCode: string; readonly packageCode: string | null; readonly version: string;
readonly payloadPath: string; readonly payloadHash: string; readonly payloadBytes: number;
readonly predecessor: Readonly<MsiPostcondition> | null; readonly runtimeSeconds: number; readonly outputBytes: number; readonly arguments: readonly string[];
}
function msiArguments(sha: string): string[] { return ['/i', `C:\\ProgramData\\RustDiscoverySystem\\cache\\${sha}.msi`, '/qn', '/norestart', 'REBOOT=ReallySuppress', 'ALLUSERS=1']; }
async function projectMsiJobs(parsed: RecordValue): Promise<WindowsMsiPlanJob[]> {
const payloads = scriptPayloads(parsed.jobs); if (!payloads.some(isMsi)) return [];
exact(parsed, ['schema_version', 'plan_id', 'tenant_id', 'principal', 'reason', 'jobs', 'max_parallel', 'halt_after_failures', 'recipe_references', 'artifact_references']);
if (parsed.schema_version !== 1 || !Array.isArray(parsed.jobs) || !parsed.jobs.length || parsed.jobs.length > 100 || payloads.length !== parsed.jobs.length || payloads.some(p => !isMsi(p)) || !Array.isArray(parsed.recipe_references) || !Array.isArray(parsed.artifact_references)) throw new Error('Vollständiger fester MSI-Plan erforderlich');
msiUuid(parsed.plan_id); msiUuid(parsed.tenant_id); text(parsed.principal, 'MSI-Antragsteller'); text(parsed.reason, 'MSI-Grund');
if (!Number.isSafeInteger(parsed.max_parallel) || Number(parsed.max_parallel) < 1 || Number(parsed.max_parallel) > 10 || !Number.isSafeInteger(parsed.halt_after_failures) || Number(parsed.halt_after_failures) < 1) throw new Error('MSI-Rolloutlimits fehlen');
const projections: WindowsMsiPlanJob[] = [], recipes = new Map<string, RecordValue>(), jobs = new Set<string>(), assets = new Set<string>();
for (const value of parsed.jobs) {
const j = record(value); exact(j, ['payload', 'job_payload_hash', 'script_sha256']);
const p = record(j.payload); exact(p, ['schema_version', 'tenant_id', 'asset_id', 'agent_id', 'enrollment_generation', 'assignment_version', 'job_id', 'attempt_id', 'action', 'execution_identity', 'not_before', 'start_before', 'max_runtime_seconds', 'max_output_bytes']);
const asset = msiUuid(p.asset_id), tuple = `${msiUuid(p.job_id)}/${msiUuid(p.attempt_id)}`; msiUuid(p.agent_id);
if (p.schema_version !== 1 || p.tenant_id !== parsed.tenant_id || p.execution_identity !== 'system' || j.script_sha256 !== null || jobs.has(tuple) || assets.has(asset)
|| !Number.isSafeInteger(p.enrollment_generation) || Number(p.enrollment_generation) < 1 || !Number.isSafeInteger(p.assignment_version) || Number(p.assignment_version) < 1
|| typeof p.not_before !== 'string' || typeof p.start_before !== 'string' || !Number.isFinite(Date.parse(p.not_before)) || !Number.isFinite(Date.parse(p.start_before)) || Date.parse(p.not_before) >= Date.parse(p.start_before)) throw new Error('MSI-Jobidentität/Frist/Generation widerspricht festem Plan');
jobs.add(tuple); assets.add(asset); validateWindowsMsiLimits(p.max_runtime_seconds, p.max_output_bytes);
const action = windowsMsiAction(record(p.action)), m = await verifyWindowsMsiManifest(action.windows_msi_manifest), r = m.recipe;
// JobPayload declaration order and nested Action/Recipe order are fixed.
const ordered = { schema_version: p.schema_version, tenant_id: p.tenant_id, asset_id: p.asset_id, agent_id: p.agent_id, enrollment_generation: p.enrollment_generation, assignment_version: p.assignment_version, job_id: p.job_id, attempt_id: p.attempt_id, action, execution_identity: p.execution_identity, not_before: p.not_before, start_before: p.start_before, max_runtime_seconds: p.max_runtime_seconds, max_output_bytes: p.max_output_bytes };
if (await sha256(new TextEncoder().encode(JSON.stringify(ordered))) !== j.job_payload_hash) throw new Error('MSI-Jobhash widerspricht festen Rust-Payloadbytes');
const recipe = { package: windowsMsi.package, version: r.postcondition.product_version, architecture: 'x64', recipe_version: r.recipe_version, sha256: m.recipe_sha256 };
recipes.set(JSON.stringify(recipe), recipe);
const refs = parsed.artifact_references.map(value => record(value)).filter(ref => ref.job_id === p.job_id && ref.attempt_id === p.attempt_id);
const expectedArtifact = { artifact_id: r.artifact.artifact_id, sha256: r.artifact.sha256, size_bytes: r.artifact.bytes };
if (refs.length !== 1) throw new Error('MSI benötigt genau eine Artefaktreferenz pro Job/Versuch');
exact(refs[0]!, ['job_id', 'attempt_id', 'artifact']); exact(record(refs[0]!.artifact), ['artifact_id', 'sha256', 'size_bytes']);
if (canonical(refs[0]!.artifact) !== canonical(expectedArtifact)) throw new Error('MSI-Artefaktreferenz widerspricht signiertem Rezept');
projections.push({ assetId: asset, recipeId: r.recipe_id, recipeHash: m.recipe_sha256, artifactId: r.artifact.artifact_id, artifactHash: r.artifact.sha256, artifactBytes: r.artifact.bytes, productCode: r.postcondition.product_code, upgradeCode: r.upgrade_code, packageCode: r.package_code ?? null, version: r.postcondition.product_version, payloadPath: r.postcondition.payload_path, payloadHash: r.postcondition.payload_sha256, payloadBytes: r.postcondition.payload_bytes, predecessor: r.predecessor ?? null, runtimeSeconds: Number(p.max_runtime_seconds), outputBytes: Number(p.max_output_bytes), arguments: msiArguments(r.artifact.sha256) });
}
const expectedRecipes = [...recipes.values()].sort((a, b) => { for (const key of ['package', 'version', 'architecture', 'recipe_version', 'sha256']) { if (String(a[key]) < String(b[key])) return -1; if (String(a[key]) > String(b[key])) return 1; } return 0; });
for (const value of parsed.recipe_references) exact(record(value), ['package', 'version', 'architecture', 'recipe_version', 'sha256']);
if (parsed.artifact_references.length !== payloads.length || canonical(parsed.recipe_references) !== canonical(expectedRecipes)) throw new Error('Vollständige exakte MSI-Rezept-/Artefaktmenge widerspricht gespeichertem Plan');
return projections;
}
export function windowsMsiPlanJobs(plan: RecordValue): readonly WindowsMsiPlanJob[] {
powerShellPlanJobs(plan);
if (!verifiedPowerShellPlans.get(plan)!.planBytes.length && hasMsiView(plan)) throw new Error('MSI-Plan benötigt exakte gespeicherte Planbytes');
return structuredClone(verifiedPowerShellPlans.get(plan)!.msiJobs);
}
export function windowsMsiApprovalBlockers(plan: RecordValue): string[] { try { windowsMsiPlanJobs(plan); return []; } catch (error) { return [error instanceof Error ? error.message : 'MSI-Plan ist nicht verifiziert']; } }
export async function verifyPlanIntegrity(plan: RecordValue) {
// Rechecking a previously displayed object may not bless a replacement plan.
if (verifiedPowerShellPlans.has(plan)) { powerShellPlanJobs(plan); windowsMsiPlanJobs(plan); }
verifiedPowerShellPlans.delete(plan);
const views = planTargetPreviews(plan), hasScriptView = scriptPayloads(views).some(hasPowerShellProfile)
|| scriptPayloads(plan.jobs).some(hasPowerShellProfile) || scriptPayloads(plan.payloads).some(hasPowerShellProfile)
|| scriptPayloads(plan.resolved_targets).some(hasPowerShellProfile)
|| scriptPayloads(record(plan.plan_payload ?? {}).jobs).some(hasPowerShellProfile)
|| scriptPayloads(record(plan.payload ?? {}).jobs).some(hasPowerShellProfile);
if (hasScriptView && plan.plan_payload_bytes === undefined) throw new Error('PowerShell-Plan benötigt exakte gespeicherte Planbytes');
const hasLogView = ['jobs', 'payloads', 'resolved_targets'].some(alias => scriptPayloads(plan[alias]).some(isQueryLogs))
|| scriptPayloads(record(plan.plan_payload ?? {}).jobs).some(isQueryLogs) || scriptPayloads(record(plan.payload ?? {}).jobs).some(isQueryLogs);
if (hasLogView && plan.plan_payload_bytes === undefined) throw new Error('Logplan benötigt exakte gespeicherte Planbytes');
if (hasMsiView(plan) && plan.plan_payload_bytes === undefined) throw new Error('MSI-Plan benötigt exakte gespeicherte Planbytes');
let logJobs: QueryLogsPlanJob[] = [];
let powerShellJobs: PowerShellPlanJob[] = [];
let msiJobs: WindowsMsiPlanJob[] = [], systemJobs: RecordValue[] = [];
let verifiedBytes: readonly number[] = [];
let verifiedParsed: RecordValue | null = null;
const verifiedHash = plan.plan_hash;
if (plan.plan_payload_bytes === undefined && Array.isArray(plan.jobs) && plan.jobs.some(value => {
const payload = record(value).payload;
return payload !== null && typeof payload === 'object' && record(payload).execution_identity === 'system';
@@ -109,11 +333,25 @@ export async function verifyPlanIntegrity(plan: RecordValue) {
if (plan.plan_payload_bytes !== undefined) {
const exactBytes = bytes(plan.plan_payload_bytes); hash(plan.plan_hash);
if (await sha256(exactBytes) !== plan.plan_hash) throw new Error('Planhash stimmt nicht mit gespeicherten Bytes überein');
verifiedBytes = Array.from(exactBytes);
const parsed = parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(exactBytes));
if (plan.plan_payload !== undefined && canonical(parsed) !== canonical(plan.plan_payload)) throw new Error('Planansicht widerspricht gespeicherten Bytes');
validatePlanAliases(plan, parsed);
const parsedPlan = record(parsed), rawJobs = parsedPlan.jobs;
verifiedParsed = parsedPlan;
powerShellJobs = projectPowerShellJobs(rawJobs);
logJobs = projectQueryLogsJobs(rawJobs);
if (hasLogView || logJobs.length) validateQueryLogsViews(plan, rawJobs);
if (hasScriptView || powerShellJobs.length) {
if (!Array.isArray(rawJobs)) throw new Error('Vollständige feste PowerShell-Zielpayloads fehlen');
validatePowerShellViews(plan, rawJobs);
}
msiJobs = await projectMsiJobs(parsedPlan);
validateMsiViews(plan, rawJobs);
systemJobs = scriptPayloads(rawJobs).filter(payload => payload.execution_identity === 'system');
}
for (const payload of systemPlanJobs(plan)) {
for (const payload of systemJobs) {
const action = record(payload.action);
if (isMsi(payload)) continue; // Fully validated, hash-bound package projection above.
exact(action, ['action', 'unit', 'state']);
if (action.action !== 'set_service_state') throw new Error('SYSTEM-Plan enthält keine typisierte Dienstaktion');
validateSystemService(action.unit, action.state, payload.max_runtime_seconds, payload.max_output_bytes);
@@ -122,6 +360,15 @@ export async function verifyPlanIntegrity(plan: RecordValue) {
for (const value of jobs) { if (!value || typeof value !== 'object') continue; const p = record(value).payload; if (!p || typeof p !== 'object') continue; const action = record(p).action;
if (action && typeof action === 'object' && record(action).apt_manifest !== undefined && record(action).apt_manifest !== null) await verifyAptManifest(record(action).apt_manifest, record(action).action === 'apt_native_acceptance');
}
// No await after this check: asynchronous hash verification cannot publish a
// projection for bytes/views that changed while WebCrypto was running.
if (verifiedParsed) {
const current = bytes(plan.plan_payload_bytes);
if (plan.plan_hash !== verifiedHash || current.length !== verifiedBytes.length || current.some((n, i) => n !== verifiedBytes[i])) throw new Error('Planbytes wurden während der Verifikation verändert');
validatePlanAliases(plan, verifiedParsed); validateMsiViews(plan, verifiedParsed.jobs);
validatePowerShellViews(plan, verifiedParsed.jobs); validateQueryLogsViews(plan, verifiedParsed.jobs);
}
verifiedPowerShellPlans.set(plan, { jobs: powerShellJobs.map(job => Object.freeze({ ...job })), logJobs: logJobs.map(job => Object.freeze({ ...job })), msiJobs: structuredClone(msiJobs), systemJobs: structuredClone(systemJobs), planHash: verifiedHash, planBytes: verifiedBytes });
}
export function recipeInput(value: unknown): RecordValue {
const r = record(value); exact(r, ['schema_version', 'provider', 'package', 'version', 'architecture', 'recipe_version', 'installation_context', 'reboot_policy']);