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
27 changed files with 3047 additions and 101 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
+1 -2
View File
@@ -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 {
+93
View File
@@ -480,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()
);
}
+521 -31
View File
@@ -4,8 +4,8 @@
//! attempt before start(). Cache population is a separate verified RMM artifact
//! operation: this module has no network, URL, UNC, transform or free arguments.
//!
//! Only first install/exact noop of v1.0.0 is implemented. Upgrade and EXE are
//! separate deliveries, not guessed modes of this MSI executor.
//! Only fixed1.0 first install/noop and fixed1.0→1.1 major-upgrade/noop.
//! No fresh1.1, downgrade, repair, arbitrary predecessor, or EXE mode.
//! MSI metadata APIs are synchronous. The caller owns the outer observation
//! deadline; a poll timeout is not a promise that Windows Installer stopped.
//! Do not put this controller in a kill-on-close process-tree executor.
@@ -15,33 +15,80 @@
//! https://learn.microsoft.com/en-us/windows/win32/msi/error-codes
#[cfg(windows)]
use anyhow::{Result, ensure};
#[cfg(windows)]
use rmm_domain::windows_execution::ResolvedWindowsMsi;
#[cfg(any(windows, test))]
use rmm_domain::windows_execution::{ResolvedWindowsMsi, valid_package_code};
use serde::Serialize;
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
pub struct Snapshot {
pub product_code: String,
pub package_code: Option<String>,
pub related_products: Vec<String>,
pub predecessor_state: Option<String>,
pub predecessor_version: Option<String>,
pub predecessor_package_code: Option<String>,
pub product_state: Option<String>,
pub product_version: Option<String>,
pub payload_sha256: Option<String>,
pub payload_bytes: Option<u64>,
}
impl Snapshot {
#[cfg(windows)]
#[cfg(any(windows, test))]
fn desired(&self, r: &ResolvedWindowsMsi) -> bool {
let p = &r.recipe.postcondition;
self.product_state.as_deref() == Some("5")
self.product_code == p.product_code
&& self.related_products == [p.product_code.clone()]
&& self.predecessor_state.is_none()
&& self.predecessor_version.is_none()
&& self.predecessor_package_code.is_none()
&& r.recipe
.package_code
.as_ref()
.is_none_or(|code| self.package_code.as_ref() == Some(code))
&& self.product_state.as_deref() == Some("5")
&& self.product_version.as_deref() == Some(&p.product_version)
&& self.payload_sha256.as_deref() == Some(&p.payload_sha256)
&& self.payload_bytes == Some(p.payload_bytes)
}
#[cfg(any(windows, test))]
fn absent(&self) -> bool {
self.product_state.is_none()
self.related_products.is_empty()
&& self.package_code.is_none()
&& self.predecessor_state.is_none()
&& self.predecessor_version.is_none()
&& self.predecessor_package_code.is_none()
&& self.product_state.is_none()
&& self.product_version.is_none()
&& self.payload_sha256.is_none()
&& self.payload_bytes.is_none()
}
#[cfg(any(windows, test))]
fn predecessor(&self, r: &ResolvedWindowsMsi) -> bool {
let Some(old) = &r.recipe.predecessor else {
return false;
};
self.product_code == r.recipe.postcondition.product_code
&& self.related_products == [old.product_code.clone()]
&& self.product_state.is_none()
&& self.product_version.is_none()
&& self.package_code.is_none()
&& self.predecessor_state.as_deref() == Some("5")
&& self.predecessor_version.as_ref() == Some(&old.product_version)
&& self.predecessor_package_code.as_ref().is_some_and(|code| {
valid_package_code(code) && Some(code) != r.recipe.package_code.as_ref()
})
&& self.payload_sha256.as_ref() == Some(&old.payload_sha256)
&& self.payload_bytes == Some(old.payload_bytes)
}
#[cfg(any(windows, test))]
fn baseline_allowed(&self, r: &ResolvedWindowsMsi) -> bool {
self.desired(r)
|| if r.recipe.predecessor.is_some() {
self.predecessor(r)
} else {
self.absent()
}
}
}
#[derive(Debug, Serialize)]
pub struct Observation {
@@ -93,6 +140,94 @@ fn classification(
_ => ("unknown", "MSI_FAILURE_EFFECT_UNRESOLVED", None, false),
}
}
#[cfg(any(windows, test))]
fn within_budget(began: std::time::Instant, timeout: std::time::Duration) -> bool {
began.elapsed() < timeout
}
/// Classify only evidence actually observed inside the original budget. An
/// installer may already have changed the machine when a late poll sees exit0;
/// late evidence cannot retroactively turn that timed-out attempt into success.
#[cfg(any(windows, test))]
fn observed_classification(
exit: u32,
postconditions: bool,
within_deadline: bool,
) -> (&'static str, &'static str, Option<bool>, bool) {
let result = classification(exit, postconditions);
if within_deadline {
result
} else {
(
"unknown",
"MSI_TIMEOUT_EFFECT_UNRESOLVED",
result.2,
result.3,
)
}
}
#[cfg(any(windows, test))]
fn expected_upgrade_rows() -> Vec<Vec<Option<String>>> {
use rmm_domain::windows_execution::*;
let row = |min: &str, max: Option<&str>, attributes: &str, property: &str| {
vec![
Some(MSI_UPGRADE_CODE.into()),
Some(min.into()),
max.map(str::to_owned),
None,
Some(attributes.into()),
Some("ALL".into()),
Some(property.into()),
]
};
// Both lists must contain exactly the one approved ProductCode in the
// LaunchCondition. OnlyDetect never removes an unexpected family member.
vec![
row("0.0.0", None, "258", MSI_ALL_PRODUCTS),
row(MSI_VERSION, Some(MSI_VERSION), "768", MSI_OLD_PRODUCTS),
]
}
#[cfg(any(windows, test))]
fn expected_sequence_rows(upgrade: bool) -> Vec<Vec<Option<String>>> {
let mut rows = vec![
("LaunchConditions", 100),
("CostInitialize", 800),
("FileCost", 900),
("CostFinalize", 1000),
("InstallValidate", 1400),
("InstallInitialize", 1500),
("ProcessComponents", 1600),
("UnpublishFeatures", 1800),
("RemoveFiles", 3500),
("RemoveFolders", 3600),
("CreateFolders", 3700),
("InstallFiles", 4000),
("RegisterUser", 6000),
("RegisterProduct", 6100),
("PublishFeatures", 6300),
("PublishProduct", 6400),
("InstallFinalize", 6600),
];
if upgrade {
rows.extend([
("FindRelatedProducts", 25),
("RemoveExistingProducts", 1550),
]);
}
rows.sort_by_key(|r| r.1);
rows.into_iter()
.map(|(action, seq)| {
vec![
Some(action.into()),
if action == "RemoveExistingProducts" {
Some("NOT Installed".into())
} else {
None
},
Some(seq.to_string()),
]
})
.collect()
}
/// Contract and locally protected policy must agree, independently of the job.
/// The policy hash must come from the helper's protected settings, never a field
/// copied back out of the job being checked.
@@ -108,7 +243,7 @@ fn validate(r: &ResolvedWindowsMsi, allowed_recipe_sha256: &str) -> Result<()> {
#[cfg(windows)]
mod windows {
use super::*;
use rmm_domain::windows_execution::{MSI_PAYLOAD, MSI_PRODUCT_CODE};
use rmm_domain::windows_execution::*;
use sha2::{Digest, Sha256};
use std::{
fs::{File, OpenOptions},
@@ -352,6 +487,106 @@ mod windows {
ensure!(code == ERROR_NO_MORE_ITEMS, "MSI_DATABASE_NOT_UNIQUE");
Ok(String::from_utf16(&text[..len as usize])?)
}
fn msi_rows(db: u32, query: &str, fields: u32) -> Result<Vec<Vec<Option<String>>>> {
let mut view = 0;
ensure!(
unsafe { MsiDatabaseOpenViewW(db, wide(query).as_ptr(), &mut view) } == 0,
"MSI_ROWS_VIEW"
);
let view = Msi(view);
ensure!(
unsafe { MsiViewExecute(view.0, 0) } == 0,
"MSI_ROWS_EXECUTE"
);
let mut rows = Vec::new();
loop {
let mut record = 0;
let code = unsafe { MsiViewFetch(view.0, &mut record) };
let record = Msi(record);
if code == ERROR_NO_MORE_ITEMS {
return Ok(rows);
}
ensure!(
code == 0
&& rows.len() < 64
&& unsafe { MsiRecordGetFieldCount(record.0) } == fields,
"MSI_ROWS_BOUND"
);
let mut row = Vec::new();
for field in 1..=fields {
if unsafe { MsiRecordIsNull(record.0, field) } != 0 {
row.push(None);
continue;
}
let mut text = [0u16; 256];
let mut count = 255;
ensure!(
unsafe { MsiRecordGetStringW(record.0, field, text.as_mut_ptr(), &mut count) }
== 0
&& count < 256,
"MSI_ROW_STRING"
);
row.push(Some(String::from_utf16(&text[..count as usize])?));
}
rows.push(row);
}
}
fn inspect_upgrade(db: u32, r: &ResolvedWindowsMsi) -> Result<()> {
let upgrade = r.recipe.predecessor.is_some();
let tables = msi_rows(db, "SELECT `Name` FROM `_Tables` WHERE `Name`='Upgrade'", 1)?;
if upgrade {
ensure!(
tables == vec![vec![Some("Upgrade".into())]],
"MSI_UPGRADE_TABLE_REQUIRED"
);
ensure!(
msi_rows(
db,
"SELECT `UpgradeCode`,`VersionMin`,`VersionMax`,`Language`,`Attributes`,`Remove`,`ActionProperty` FROM `Upgrade` ORDER BY `ActionProperty`",
7
)? == expected_upgrade_rows(),
"MSI_EXACT_UPGRADE_TABLE_REQUIRED"
);
ensure!(
msi_text(
db,
"SELECT `Value` FROM `Property` WHERE `Property`='SecureCustomProperties'"
)? == format!("{MSI_ALL_PRODUCTS};{MSI_OLD_PRODUCTS}"),
"MSI_SECURE_UPGRADE_PROPERTIES"
);
ensure!(
msi_rows(
db,
"SELECT `Condition`,`Description` FROM `LaunchCondition` ORDER BY `Condition`",
2
)? == vec![
vec![
Some(MSI_UPGRADE_CONDITION.into()),
Some(
"Only the exact approved fixture1.0 predecessor may be upgraded."
.into()
)
],
vec![
Some("VersionNT64".into()),
Some("This fixture requires 64-bit Windows.".into())
]
],
"MSI_EXACT_UPGRADE_LAUNCH_CONDITIONS"
);
} else {
ensure!(tables.is_empty(), "MSI_UNEXPECTED_UPGRADE_TABLE");
}
ensure!(
msi_rows(
db,
"SELECT `Action`,`Condition`,`Sequence` FROM `InstallExecuteSequence` ORDER BY `Sequence`",
3
)? == expected_sequence_rows(upgrade),
"MSI_EXACT_EXECUTE_SEQUENCE_REQUIRED"
);
Ok(())
}
fn no_custom_actions(db: u32) -> Result<()> {
let mut view = 0;
ensure!(
@@ -409,6 +644,7 @@ mod windows {
);
let db = Msi(db);
no_custom_actions(db.0)?;
inspect_upgrade(db.0, r)?;
let cabinet = msi_text(db.0, "SELECT `Cabinet` FROM `Media`")?;
ensure!(
cabinet.starts_with('#')
@@ -420,7 +656,7 @@ mod windows {
"MSI_EMBEDDED_CABINET_REQUIRED"
);
for (field, value) in [
("ProductCode", MSI_PRODUCT_CODE),
("ProductCode", r.recipe.postcondition.product_code.as_str()),
(
"ProductVersion",
r.recipe.postcondition.product_version.as_str(),
@@ -467,15 +703,41 @@ mod windows {
String::from_utf16(&text[..len as usize])?.starts_with("x64;"),
"MSI_NOT_X64"
);
let mut len = 255;
ensure!(
unsafe {
MsiSummaryInfoGetPropertyW(
summary.0,
9,
&mut kind,
&mut value,
&mut time,
text.as_mut_ptr(),
&mut len,
)
} == 0
&& kind == 30
&& len < 256,
"MSI_PACKAGE_SUMMARY"
);
let package_code = String::from_utf16(&text[..len as usize])?;
ensure!(
valid_package_code(&package_code)
&& r.recipe
.package_code
.as_ref()
.is_none_or(|code| code == &package_code),
"MSI_PACKAGE_CODE_BINDING"
);
file.check()?;
Ok(())
}
fn property(name: &str) -> Result<Option<String>> {
fn property(product: &str, name: &str) -> Result<Option<String>> {
let mut value = [0u16; 256];
let mut len = 255;
let code = unsafe {
MsiGetProductInfoExW(
wide(MSI_PRODUCT_CODE).as_ptr(),
wide(product).as_ptr(),
ptr::null(),
MSIINSTALLCONTEXT_MACHINE,
wide(name).as_ptr(),
@@ -489,13 +751,58 @@ mod windows {
ensure!(code == 0 && len < 256, "MSI_MACHINE_PRODUCT_QUERY");
Ok(Some(String::from_utf16(&value[..len as usize])?))
}
pub fn snapshot() -> Result<Snapshot> {
let product_state = property("State")?;
fn snapshot_product(product: &str, predecessor: Option<&str>) -> Result<Snapshot> {
let product_state = property(product, "State")?;
let product_version = if product_state.as_deref() == Some("5") {
property("VersionString")?
property(product, "VersionString")?
} else {
None
};
let package_code = if product_state.as_deref() == Some("5") {
property(product, "PackageCode")?
} else {
None
};
let predecessor_state = predecessor
.map(|p| property(p, "State"))
.transpose()?
.flatten();
let predecessor_version = if predecessor_state.as_deref() == Some("5") {
property(predecessor.unwrap(), "VersionString")?
} else {
None
};
let predecessor_package_code = if predecessor_state.as_deref() == Some("5") {
property(predecessor.unwrap(), "PackageCode")?
} else {
None
};
let mut related_products = Vec::new();
for index in 0..=16 {
let mut code = [0u16; 39];
let status = unsafe {
MsiEnumRelatedProductsW(
wide(MSI_UPGRADE_CODE).as_ptr(),
0,
index,
code.as_mut_ptr(),
)
};
if status == ERROR_NO_MORE_ITEMS {
break;
}
ensure!(
status == ERROR_SUCCESS && index < 16 && code[38] == 0,
"MSI_RELATED_PRODUCT_QUERY"
);
let code = String::from_utf16(&code[..38])?;
ensure!(
!related_products.contains(&code),
"MSI_DUPLICATE_RELATED_PRODUCT"
);
related_products.push(code);
}
related_products.sort();
let (payload_sha256, payload_bytes) = match std::fs::symlink_metadata(MSI_PAYLOAD) {
Ok(_) => {
let mut file = Held::open(Path::new(MSI_PAYLOAD), false)?;
@@ -506,12 +813,32 @@ mod windows {
Err(e) => return Err(e.into()),
};
Ok(Snapshot {
product_code: product.into(),
package_code,
related_products,
predecessor_state,
predecessor_version,
predecessor_package_code,
product_state,
product_version,
payload_sha256,
payload_bytes,
})
}
/// Retained1.0 read-only witness. No implicit choice of upgrade recipe.
pub fn snapshot() -> Result<Snapshot> {
snapshot_product(MSI_PRODUCT_CODE, None)
}
pub fn snapshot_for(r: &ResolvedWindowsMsi) -> Result<Snapshot> {
ensure!(r.validate(), "MSI_RECIPE_INVALID");
snapshot_product(
&r.recipe.postcondition.product_code,
r.recipe
.predecessor
.as_ref()
.map(|old| old.product_code.as_str()),
)
}
fn system_root() -> Result<PathBuf> {
let mut value = [0u16; 32768];
let len = unsafe { GetSystemWindowsDirectoryW(value.as_mut_ptr(), value.len() as u32) };
@@ -547,9 +874,9 @@ mod windows {
inspect_archive(&mut archive, r)?;
let system_root = system_root()?;
let msiexec = Held::open(&system_root.join("System32").join("msiexec.exe"), true)?;
let before = snapshot()?;
let before = snapshot_for(r)?;
ensure!(
before.absent() || before.desired(r),
before.baseline_allowed(r),
"MSI_EXISTING_PRODUCT_OR_PAYLOAD_CONFLICT"
);
Ok(Self {
@@ -561,6 +888,25 @@ mod windows {
system_root,
})
}
fn verification_timeout(&self, after: Option<Snapshot>) -> Run {
Run::Noop(Box::new(Observation {
recipe_sha256: self.recipe.recipe_sha256.clone(),
artifact_sha256: self.recipe.recipe.artifact.sha256.clone(),
process_id: None,
state: "unknown",
code: "MSI_VERIFICATION_TIMEOUT_NO_INSTALLER_START",
exit_code: None,
postconditions_passed: false,
already_desired: false,
installer_process_started: false,
transaction_started: Some(false),
installer_reboot_required: None,
reboot_initiated: false,
before: self.before.clone(),
after,
automatic_retry: false,
}))
}
/// Called only after durable original-grant consumption. No change of
/// config, privilege, policy, clock, reboot or foreign process occurs.
pub fn start(
@@ -575,10 +921,35 @@ mod windows {
&& !cancelled.load(Ordering::SeqCst),
"MSI_START_LIMIT_OR_CANCELLED"
);
inspect_archive(&mut self.archive, &self.recipe)?;
self.msiexec.check()?;
let before = snapshot()?;
// One original budget includes all synchronous verification and
// the eventual installer. A late Noop is not retroactive success.
let began = Instant::now();
let archive = inspect_archive(&mut self.archive, &self.recipe);
if !within_budget(began, timeout) {
return Ok(self.verification_timeout(None));
}
archive?;
let executable = self.msiexec.check();
if !within_budget(began, timeout) {
return Ok(self.verification_timeout(None));
}
executable?;
let observation = snapshot_for(&self.recipe);
if !within_budget(began, timeout) {
return Ok(self.verification_timeout(observation.ok()));
}
let before = observation?;
ensure!(before == self.before, "MSI_BASELINE_CHANGED");
// Both a Noop and an installer decision require a fresh caller
// authorization fence; no bypass for the already-desired branch.
check_effect_fence()?;
if !within_budget(began, timeout) {
return Ok(self.verification_timeout(Some(before)));
}
ensure!(
!cancelled.load(Ordering::SeqCst),
"MSI_CANCELLED_BEFORE_START"
);
if before.desired(&self.recipe) {
return Ok(Run::Noop(Box::new(Observation {
recipe_sha256: self.recipe.recipe_sha256.clone(),
@@ -598,14 +969,11 @@ mod windows {
automatic_retry: false,
})));
}
ensure!(before.absent(), "MSI_INSTALL_BASELINE_CONFLICT");
use std::os::windows::process::CommandExt;
check_effect_fence()?;
ensure!(
!cancelled.load(Ordering::SeqCst),
"MSI_CANCELLED_BEFORE_START"
before.baseline_allowed(&self.recipe),
"MSI_INSTALL_BASELINE_CONFLICT"
);
let began = Instant::now();
use std::os::windows::process::CommandExt;
let child = Command::new(&self.msiexec.path)
.args([
std::ffi::OsStr::new("/i"),
@@ -657,14 +1025,21 @@ mod windows {
};
if exit.is_none()
&& !cancelled.load(Ordering::SeqCst)
&& self.began.elapsed() < self.timeout
&& within_budget(self.began, self.timeout)
{
return Ok(None);
}
let mut after = None;
let (state, error, reboot, initiated) = if let Some(code) = code {
after = snapshot().ok();
if after.is_none() && matches!(code, 0 | 3010) {
// No extra synchronous MSI query once the original budget has
// expired. try_wait and snapshot can themselves return late.
if within_budget(self.began, self.timeout) {
after = snapshot_for(&self.prepared.recipe).ok();
}
let within_deadline = within_budget(self.began, self.timeout);
if !within_deadline {
observed_classification(code, false, false)
} else if after.is_none() && matches!(code, 0 | 3010) {
(
"unknown",
"MSI_POSTCONDITION_QUERY_FAILED",
@@ -672,11 +1047,12 @@ mod windows {
false,
)
} else {
classification(
observed_classification(
code,
after
.as_ref()
.is_some_and(|s| s.desired(&self.prepared.recipe)),
within_deadline,
)
}
} else {
@@ -716,11 +1092,124 @@ mod windows {
}
}
#[cfg(windows)]
pub use windows::{Installer, Prepared, Run, snapshot};
pub use windows::{Installer, Prepared, Run, snapshot, snapshot_for};
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn upgrade_and_noop_need_independent_exact_products_family_and_payload() {
use rmm_domain::windows_execution::*;
let recipe = WindowsMsiRecipe {
schema_version: 1,
recipe_id: MSI_UPGRADE_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::Uuid::new_v4(),
sha256: "ab".repeat(32),
bytes: 20480,
},
postcondition: MsiPostcondition {
product_code: MSI_UPGRADE_PRODUCT_CODE.into(),
product_version: MSI_UPGRADE_VERSION.into(),
payload_path: MSI_PAYLOAD.into(),
payload_sha256: MSI_PAYLOAD_11_SHA256.into(),
payload_bytes: MSI_PAYLOAD_BYTES,
},
no_reboot: true,
package_code: Some("{8475C4D1-6EE2-4C3A-B41D-D834A20F4135}".into()),
predecessor: Some(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,
}),
};
let r = ResolvedWindowsMsi {
recipe_sha256: recipe.sha256().unwrap(),
recipe,
};
assert!(r.validate());
let mut before = Snapshot {
product_code: MSI_UPGRADE_PRODUCT_CODE.into(),
related_products: vec![MSI_PRODUCT_CODE.into()],
predecessor_state: Some("5".into()),
predecessor_version: Some(MSI_VERSION.into()),
predecessor_package_code: Some("{D1C4ECE2-7025-4E16-A842-A20F320CE783}".into()),
payload_sha256: Some(MSI_PAYLOAD_10_SHA256.into()),
payload_bytes: Some(MSI_PAYLOAD_BYTES),
..Snapshot::default()
};
assert!(before.predecessor(&r));
assert!(before.baseline_allowed(&r));
assert!(!before.desired(&r));
assert!(!Snapshot::default().baseline_allowed(&r)); // no fresh1.1 fallback
before
.related_products
.push("{11111111-1111-4111-8111-111111111111}".into());
assert!(!before.baseline_allowed(&r));
let mut after = Snapshot {
product_code: MSI_UPGRADE_PRODUCT_CODE.into(),
package_code: r.recipe.package_code.clone(),
related_products: vec![MSI_UPGRADE_PRODUCT_CODE.into()],
product_state: Some("5".into()),
product_version: Some(MSI_UPGRADE_VERSION.into()),
payload_sha256: Some(MSI_PAYLOAD_11_SHA256.into()),
payload_bytes: Some(MSI_PAYLOAD_BYTES),
..Snapshot::default()
};
assert!(after.desired(&r));
after.predecessor_state = Some("5".into());
assert!(!after.desired(&r));
after.predecessor_state = None;
after.payload_sha256 = Some(MSI_PAYLOAD_10_SHA256.into());
assert!(!after.desired(&r));
let table = expected_upgrade_rows();
assert_eq!(table.len(), 2);
assert_eq!(table[0][4].as_deref(), Some("258"));
assert_eq!(table[1][4].as_deref(), Some("768"));
let sequence = expected_sequence_rows(true);
let position = |name: &str| {
sequence
.iter()
.position(|r| r[0].as_deref() == Some(name))
.unwrap()
};
assert!(position("FindRelatedProducts") < position("LaunchConditions"));
assert!(position("InstallInitialize") < position("RemoveExistingProducts"));
assert!(position("RemoveExistingProducts") < position("ProcessComponents"));
}
#[test]
fn late_exit_or_postcondition_cannot_retroactively_succeed_or_retry() {
use std::time::{Duration, Instant};
let original = Instant::now().checked_sub(Duration::from_secs(2)).unwrap();
let timely = within_budget(Instant::now(), Duration::from_secs(60));
let late = within_budget(original, Duration::from_secs(1));
assert!(timely);
assert!(!late);
// This same budget gates the Noop decision and the installer poll;
// metadata returning late does not receive a fresh timer.
assert_eq!(observed_classification(0, true, late).0, "unknown");
for exit in [0, 3010, 1618, 1603, 1641] {
let late = observed_classification(exit, true, false);
assert_eq!(
(late.0, late.1),
("unknown", "MSI_TIMEOUT_EFFECT_UNRESOLVED")
);
assert_eq!(
(late.2, late.3),
(classification(exit, true).2, classification(exit, true).3)
);
}
assert_eq!(observed_classification(0, true, true).0, "succeeded");
assert_eq!(observed_classification(0, false, true).0, "failed");
}
#[test]
fn exit_code_never_substitutes_for_independent_postconditions_or_reboot_authority() {
assert_eq!(
classification(0, true),
@@ -752,6 +1241,7 @@ mod tests {
product_version: None,
payload_sha256: None,
payload_bytes: None,
..Snapshot::default()
};
assert!(!advertised.absent());
}
+70 -1
View File
@@ -48,6 +48,17 @@ where
}
}
/// 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 {
@@ -88,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,
@@ -185,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)
@@ -243,6 +283,20 @@ 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)
}
@@ -250,6 +304,9 @@ impl Action {
/// 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)
@@ -268,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);
@@ -304,6 +361,17 @@ 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") =>
{
@@ -349,6 +417,7 @@ impl Action {
installation_context,
recipe_id: None,
apt_manifest: None,
windows_msi_manifest: None,
} => {
provider == "apt"
&& !package.is_empty()
+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";
+241 -14
View File
@@ -1,39 +1,84 @@
//! Unexported Windows MSI fixture contract. No legacy Linux codec is changed.
//! This version supports first installation or independently proven exact noop;
//! an upgrade requires a separate reviewed recipe with explicit predecessor
//! products/UpgradeCode semantics. No implicit REINSTALL flags are inferred.
//! 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}";
pub const MSI_VERSION: &str = "1.0.0";
pub const MSI_PAYLOAD: &str = r"C:\Program Files\RustDiscoveryFixtures\msi-payload.txt";
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub const MSI_UPGRADE_RECIPE_ID: &str = "rmm-windows-msi-fixture-upgrade-1.1";
pub const MSI_UPGRADE_PRODUCT_CODE: &str = "{D42BD387-079B-4BBF-A134-0DA7B7A97011}";
pub const MSI_UPGRADE_VERSION: &str = "1.1.0";
pub const MSI_PAYLOAD_BYTES: u64 = 33;
pub const MSI_PAYLOAD_10_SHA256: &str =
"0c90c4fc7233017cc88c0e925095d6662ac57abdb303c7527ef59d02b454fca0";
pub const MSI_PAYLOAD_11_SHA256: &str =
"ba0c83deff9eed014009bcd45369b2a356ae909ebf0c1434dc836b0e6d759c49";
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, 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,
@@ -42,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,
@@ -56,8 +101,13 @@ pub struct WindowsMsiRecipe {
pub artifact: MsiArtifact,
pub postcondition: MsiPostcondition,
pub no_reboot: bool,
// Appended opt-in metadata: old1.0 recipes retain exactly their old bytes.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub package_code: Option<String>,
#[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,
@@ -70,10 +120,16 @@ pub fn digest(value: &str) -> bool {
.bytes()
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
}
pub fn valid_package_code(value: &str) -> bool {
Uuid::parse_str(value).is_ok_and(|id| {
!id.is_nil()
&& value == format!("{{{}}}", id.to_string().to_uppercase())
&& ![MSI_PRODUCT_CODE, MSI_UPGRADE_PRODUCT_CODE, MSI_UPGRADE_CODE].contains(&value)
})
}
impl WindowsMsiRecipe {
pub fn validate(&self) -> bool {
self.schema_version == 1
&& self.recipe_id == MSI_RECIPE_ID
&& self.recipe_version == "1"
&& self.platform == "windows"
&& self.upgrade_code == MSI_UPGRADE_CODE
@@ -81,11 +137,32 @@ impl WindowsMsiRecipe {
&& !self.artifact.artifact_id.is_nil()
&& digest(&self.artifact.sha256)
&& (1..=262144).contains(&self.artifact.bytes)
&& self.postcondition.product_code == MSI_PRODUCT_CODE
&& self.postcondition.product_version == MSI_VERSION
&& self.postcondition.payload_path == MSI_PAYLOAD
&& digest(&self.postcondition.payload_sha256)
&& (1..=65536).contains(&self.postcondition.payload_bytes)
&& match self.recipe_id.as_str() {
MSI_RECIPE_ID => {
self.postcondition.product_code == MSI_PRODUCT_CODE
&& self.postcondition.product_version == MSI_VERSION
&& self.package_code.is_none()
&& self.predecessor.is_none()
}
MSI_UPGRADE_RECIPE_ID => {
self.postcondition.product_code == MSI_UPGRADE_PRODUCT_CODE
&& self.postcondition.product_version == MSI_UPGRADE_VERSION
&& self.postcondition.payload_sha256 == MSI_PAYLOAD_11_SHA256
&& self.postcondition.payload_bytes == MSI_PAYLOAD_BYTES
&& self.package_code.as_deref().is_some_and(valid_package_code)
&& self.predecessor.as_ref().is_some_and(|old| {
old.product_code == MSI_PRODUCT_CODE
&& old.product_version == MSI_VERSION
&& old.payload_path == MSI_PAYLOAD
&& old.payload_sha256 == MSI_PAYLOAD_10_SHA256
&& old.payload_bytes == MSI_PAYLOAD_BYTES
})
}
_ => false,
}
}
pub fn sha256(&self) -> Result<String, serde_json::Error> {
Ok(format!("{:x}", Sha256::digest(serde_json::to_vec(self)?)))
@@ -127,6 +204,156 @@ mod tests {
payload_bytes: 20,
},
no_reboot: true,
package_code: None,
predecessor: None,
}
}
#[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();
assert!(
!String::from_utf8(old_bytes.clone())
.unwrap()
.contains("predecessor")
);
assert_eq!(
serde_json::to_vec(&serde_json::from_slice::<WindowsMsiRecipe>(&old_bytes).unwrap())
.unwrap(),
old_bytes
);
let mut r = old.clone();
r.recipe_id = MSI_UPGRADE_RECIPE_ID.into();
r.package_code = Some("{8475C4D1-6EE2-4C3A-B41D-D834A20F4135}".into());
r.postcondition.product_code = MSI_UPGRADE_PRODUCT_CODE.into();
r.postcondition.product_version = MSI_UPGRADE_VERSION.into();
r.postcondition.payload_sha256 = MSI_PAYLOAD_11_SHA256.into();
r.postcondition.payload_bytes = MSI_PAYLOAD_BYTES;
r.predecessor = Some(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,
});
assert!(r.validate());
assert_ne!(r.sha256().unwrap(), old.sha256().unwrap());
for case in 0..8 {
let mut bad = r.clone();
match case {
0 => bad.predecessor = None,
1 => bad.package_code = None,
2 => bad.package_code = Some(MSI_PRODUCT_CODE.into()),
3 => bad.upgrade_code = Uuid::new_v4().to_string(),
4 => {
bad.predecessor.as_mut().unwrap().product_code = MSI_UPGRADE_PRODUCT_CODE.into()
}
5 => bad.predecessor.as_mut().unwrap().payload_sha256 = "aa".repeat(32),
6 => bad.postcondition.product_version = "1.2.0".into(),
_ => bad.postcondition.payload_sha256 = MSI_PAYLOAD_10_SHA256.into(),
};
assert!(!bad.validate());
}
}
#[test]
+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"
+17
View File
@@ -491,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
@@ -736,6 +739,20 @@ 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)
+207 -1
View File
@@ -181,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>,
@@ -205,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() {
@@ -251,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)?,
@@ -435,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"));
@@ -458,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?;
@@ -531,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?;
@@ -565,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,
@@ -1511,6 +1535,188 @@ mod windows_contract_tests {
"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};
+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());
}
}
}
+79 -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 {
@@ -410,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()));
+49 -12
View File
@@ -1,9 +1,9 @@
#requires -Version 5.1
<#
Build-only, fixed MSI 1.0.0 fixture. Writes only a NEW private child directory.
Build-only, fixed MSI1.0.0 or1.1.0 major-upgrade fixture. Writes only a NEW private child directory.
Never calls InstallProduct/OpenPackage/msiexec, modifies installed products,
services, execution policy, certificate trust or reboot state. No downloads.
No upgrade/EXE package is authored by this version.
1.1 removes only the exact known1.0 predecessor; no EXE/repair mode.
Primary API/format contracts:
https://learn.microsoft.com/en-us/windows/win32/msi/installer-opendatabase
@@ -17,7 +17,8 @@ https://learn.microsoft.com/en-us/windows/win32/msi/package-codes
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)][string]$OutputParent,
[Guid]$CaseId=([Guid]::NewGuid())
[Guid]$CaseId=([Guid]::NewGuid()),
[ValidateSet('1.0.0','1.1.0')][string]$FixtureVersion='1.0.0'
)
Set-StrictMode -Version Latest
$ErrorActionPreference='Stop'
@@ -25,14 +26,18 @@ $case=$null;$created=$false;$installer=$null;$database=$null;$summary=$null;$mak
$product='{3F070B4B-9C08-4D65-BD41-13D81B884AEC}'
$upgrade='{C9BF1FB8-E31D-4BD7-BA0D-AB46539BBBAA}'
$component='{4D1CA80F-9AF8-4F54-B426-450AFBAFF92E}'
$version='1.0.0'
$version=$FixtureVersion
$isUpgrade=$version -ceq '1.1.0'
$oldProduct=$product
if($isUpgrade){$product='{D42BD387-079B-4BBF-A134-0DA7B7A97011}'}
$upgradeCondition='Installed OR (RMM_OLD_PRODUCTS = "{3F070B4B-9C08-4D65-BD41-13D81B884AEC}" AND RMM_ALL_PRODUCTS = "{3F070B4B-9C08-4D65-BD41-13D81B884AEC}")'
# Product/family/component identities are fixed. Nonidentical MSI bytes must
# have distinct PackageCodes, so each new authoring case gets its own code.
$package='{'+([Guid]::NewGuid().ToString().ToUpperInvariant())+'}'
$artifact=[Guid]::NewGuid().ToString()
$report=[ordered]@{schema_version=1;case_id=$CaseId.ToString();completed=$false;stage='preflight';
build_only=$true;native_installation_tested=$false;product_changes=$false;services_changed=$false;
reboot_requested=$false;trust_changed=$false;downloads=$false;upgrade_authored=$false;
reboot_requested=$false;trust_changed=$false;downloads=$false;upgrade_authored=$isUpgrade;
product_code=$product;upgrade_code=$upgrade;component_code=$component;package_code=$package;version=$version}
function Require([bool]$Value,[string]$Code) {if (!$Value) {throw $Code}}
@@ -169,7 +174,7 @@ try {
$report.tools=$tools
$report.stage='payload_and_cabinet'
$payload=Join-Path $case 'msi-payload.txt'
$payloadBytes=[Text.Encoding]::ASCII.GetBytes("RustDiscovery MSI fixture 1.0.0`r`n")
$payloadBytes=[Text.Encoding]::ASCII.GetBytes("RustDiscovery MSI fixture $version`r`n")
Write-New $payload $payloadBytes
$ddf=Join-Path $case 'fixture.ddf'
$ddfText=@"
@@ -190,7 +195,7 @@ try {
$cab=Join-Path $case 'fixture.cab';No-Reparse $cab
Require ((Get-Item -LiteralPath $cab).Length -gt 0 -and (Get-Item -LiteralPath $cab).Length -le 65536) 'MSI_CABINET_LIMIT'
$report.stage='database_authoring:com_activation'
$msi=Join-Path $case 'RustDiscoveryFixture-1.0.0-x64.msi';Require (!(Test-Path -LiteralPath $msi)) 'MSI_OUTPUT_EXISTS'
$msi=Join-Path $case ('RustDiscoveryFixture-'+$version+'-x64.msi');Require (!(Test-Path -LiteralPath $msi)) 'MSI_OUTPUT_EXISTS'
$installer=New-Object -ComObject WindowsInstaller.Installer
$report.stage='database_authoring:open_create'
$database=Com-Method $installer 'OpenDatabase' @($msi,[int]3)
@@ -205,9 +210,11 @@ try {
InstallExecuteSequence='`Action` CHAR(72) NOT NULL, `Condition` CHAR(255), `Sequence` SHORT PRIMARY KEY `Action`'
LaunchCondition='`Condition` CHAR(255) NOT NULL, `Description` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `Condition`'
}
if($isUpgrade){$tables.Upgrade='`UpgradeCode` CHAR(38) NOT NULL, `VersionMin` CHAR(20), `VersionMax` CHAR(20), `Language` CHAR(255), `Attributes` SHORT NOT NULL, `Remove` CHAR(255), `ActionProperty` CHAR(72) NOT NULL PRIMARY KEY `UpgradeCode`, `VersionMin`, `VersionMax`, `Language`, `Attributes`'}
foreach ($table in $tables.Keys) {$report.stage='database_authoring:create_table:'+$table;Sql ('CREATE TABLE `'+$table+'` ('+$tables[$table]+')')}
$report.stage='database_authoring:insert_rows'
$properties=[ordered]@{ProductCode=$product;UpgradeCode=$upgrade;ProductVersion=$version;ProductLanguage='1033';ProductName='RustDiscovery MSI Fixture';Manufacturer='Ease Technologies';ALLUSERS='1';INSTALLLEVEL='1';REBOOT='ReallySuppress'}
if($isUpgrade){$properties.SecureCustomProperties='RMM_ALL_PRODUCTS;RMM_OLD_PRODUCTS'}
foreach ($key in $properties.Keys) {Sql ("INSERT INTO ``Property`` (``Property``,``Value``) VALUES ('$key','$($properties[$key])')")}
Sql 'INSERT INTO `Directory` (`Directory`,`DefaultDir`) VALUES (''TARGETDIR'',''SourceDir'')'
Sql 'INSERT INTO `Directory` (`Directory`,`Directory_Parent`,`DefaultDir`) VALUES (''ProgramFiles64Folder'',''TARGETDIR'',''.'')'
@@ -218,8 +225,17 @@ try {
Sql ("INSERT INTO ``File`` (``File``,``Component_``,``FileName``,``FileSize``,``Attributes``,``Sequence``) VALUES ('PayloadFile','PayloadComponent','MSIPAY~1.TXT|msi-payload.txt',$($payloadBytes.Length),16896,1)")
Sql 'INSERT INTO `Media` (`DiskId`,`LastSequence`,`Cabinet`) VALUES (1,1,''#fixture.cab'')'
Sql 'INSERT INTO `LaunchCondition` (`Condition`,`Description`) VALUES (''VersionNT64'',''This fixture requires 64-bit Windows.'')'
if($isUpgrade){
Sql ("INSERT INTO ``Upgrade`` (``UpgradeCode``,``VersionMin``,``VersionMax``,``Attributes``,``Remove``,``ActionProperty``) VALUES ('$upgrade','1.0.0','1.0.0',768,'ALL','RMM_OLD_PRODUCTS')")
Sql ("INSERT INTO ``Upgrade`` (``UpgradeCode``,``VersionMin``,``Attributes``,``Remove``,``ActionProperty``) VALUES ('$upgrade','0.0.0',258,'ALL','RMM_ALL_PRODUCTS')")
Sql ("INSERT INTO ``LaunchCondition`` (``Condition``,``Description``) VALUES ('$upgradeCondition','Only the exact approved fixture1.0 predecessor may be upgraded.')")
}
$sequence=[ordered]@{LaunchConditions=100;CostInitialize=800;FileCost=900;CostFinalize=1000;InstallValidate=1400;InstallInitialize=1500;ProcessComponents=1600;UnpublishFeatures=1800;RemoveFiles=3500;RemoveFolders=3600;CreateFolders=3700;InstallFiles=4000;RegisterUser=6000;RegisterProduct=6100;PublishFeatures=6300;PublishProduct=6400;InstallFinalize=6600}
foreach ($action in $sequence.Keys) {Sql ("INSERT INTO ``InstallExecuteSequence`` (``Action``,``Sequence``) VALUES ('$action',$($sequence[$action]))")}
if($isUpgrade){$sequence.FindRelatedProducts=25;$sequence.RemoveExistingProducts=1550}
foreach ($action in $sequence.Keys) {
if($action -ceq 'RemoveExistingProducts'){Sql ("INSERT INTO ``InstallExecuteSequence`` (``Action``,``Condition``,``Sequence``) VALUES ('$action','NOT Installed',$($sequence[$action]))")}
else {Sql ("INSERT INTO ``InstallExecuteSequence`` (``Action``,``Sequence``) VALUES ('$action',$($sequence[$action]))")}
}
$view=Com-Method $database 'OpenView' @('INSERT INTO `_Streams` (`Name`,`Data`) VALUES (?,?)');$record=$null
try {$record=Com-Method $installer 'CreateRecord' @([int]2);Com-Set $record 'StringData' @([int]1,'fixture.cab');[void](Com-Method $record 'SetStream' @([int]2,$cab));[void](Com-Method $view 'Execute' @($record));[void](Com-Method $view 'Close')}
finally {Release-Com $record;Release-Com $view}
@@ -236,7 +252,23 @@ try {
foreach ($key in $properties.Keys) {$row=Rows ("SELECT ``Value`` FROM ``Property`` WHERE ``Property``='$key'");Require ($row.Count -eq 1 -and $row[0][0] -ceq $properties[$key]) 'MSI_PROPERTY_READBACK'}
$allTables=Rows 'SELECT `Name` FROM `_Tables`';$names=@($allTables|ForEach-Object {$_[0]})
Require ($names.Count -eq $tables.Count -and @($names|Where-Object {$_ -notin $tables.Keys}).Count -eq 0) 'MSI_UNEXPECTED_TABLE'
Require ('CustomAction' -notin $names -and 'Upgrade' -notin $names -and 'Registry' -notin $names -and 'ServiceInstall' -notin $names) 'MSI_FORBIDDEN_TABLE'
Require ('CustomAction' -notin $names -and 'Registry' -notin $names -and 'ServiceInstall' -notin $names -and ($isUpgrade -or 'Upgrade' -notin $names)) 'MSI_FORBIDDEN_TABLE'
# Independently read committed upgrade/sequence metadata; no install APIs.
foreach($action in $sequence.Keys){
$row=Rows ("SELECT ``Condition``,``Sequence`` FROM ``InstallExecuteSequence`` WHERE ``Action``='$action'")
$condition=if($action -ceq 'RemoveExistingProducts'){'NOT Installed'}else{''}
Require ($row.Count -eq 1 -and $row[0][0] -ceq $condition -and $row[0][1] -ceq [string]$sequence[$action]) 'MSI_SEQUENCE_READBACK'
}
if($isUpgrade){
$rows=Rows 'SELECT `UpgradeCode`,`VersionMin`,`VersionMax`,`Attributes`,`Remove`,`ActionProperty` FROM `Upgrade` WHERE `Language` IS NULL ORDER BY `ActionProperty`'
Require ($rows.Count -eq 2) 'MSI_UPGRADE_ROW_COUNT'
$expected=@(@($upgrade,'0.0.0','','258','ALL','RMM_ALL_PRODUCTS'),@($upgrade,'1.0.0','1.0.0','768','ALL','RMM_OLD_PRODUCTS'))
for($i=0;$i -lt 2;$i++){for($j=0;$j -lt 6;$j++){Require ($rows[$i][$j] -ceq $expected[$i][$j]) 'MSI_UPGRADE_ROW_READBACK'}}
$nullMax=Rows 'SELECT `ActionProperty` FROM `Upgrade` WHERE `VersionMax` IS NULL'
Require ($nullMax.Count -eq 1 -and $nullMax[0][0] -ceq 'RMM_ALL_PRODUCTS') 'MSI_UPGRADE_NULL_MAX_READBACK'
$launch=Rows ("SELECT ``Description`` FROM ``LaunchCondition`` WHERE ``Condition``='$upgradeCondition'")
Require ($launch.Count -eq 1 -and $launch[0][0] -ceq 'Only the exact approved fixture1.0 predecessor may be upgraded.' -and $readback.LaunchCondition.Count -eq 2) 'MSI_UPGRADE_LAUNCH_READBACK'
}
$summary=Com-Get $database 'SummaryInformation' @([int]0)
Require ((Com-Get $summary 'Property' @([int]7)) -ceq 'x64;1033' -and (Com-Get $summary 'Property' @([int]9)) -ceq $package -and [int](Com-Get $summary 'Property' @([int]15)) -eq 2) 'MSI_SUMMARY_READBACK'
Release-Com $summary;$summary=$null
@@ -253,12 +285,17 @@ try {
$extra=Com-Method $view 'Fetch';Require ($null -eq $extra) 'MSI_DUPLICATE_CAB_STREAM';[void](Com-Method $view 'Close')
} finally {Release-Com $record;Release-Com $view}
Release-Com $database;$database=$null
$recipe=[ordered]@{schema_version=1;recipe_id='rmm-windows-msi-fixture-install-1.0';recipe_version='1';platform='windows';upgrade_code=$upgrade;architecture='x64';context='machine';command_profile='fixture_quiet_no_reboot_v1';artifact=[ordered]@{artifact_id=$artifact;sha256=(Hash $msi);bytes=$length};postcondition=[ordered]@{product_code=$product;product_version=$version;payload_path='C:\Program Files\RustDiscoveryFixtures\msi-payload.txt';payload_sha256=(Hash $payload);payload_bytes=$payloadBytes.Length};no_reboot=$true}
$recipe=[ordered]@{schema_version=1;recipe_id=$(if($isUpgrade){'rmm-windows-msi-fixture-upgrade-1.1'}else{'rmm-windows-msi-fixture-install-1.0'});recipe_version='1';platform='windows';upgrade_code=$upgrade;architecture='x64';context='machine';command_profile='fixture_quiet_no_reboot_v1';artifact=[ordered]@{artifact_id=$artifact;sha256=(Hash $msi);bytes=$length};postcondition=[ordered]@{product_code=$product;product_version=$version;payload_path='C:\Program Files\RustDiscoveryFixtures\msi-payload.txt';payload_sha256=(Hash $payload);payload_bytes=$payloadBytes.Length};no_reboot=$true}
if($isUpgrade){
$recipe.package_code=$package
$oldBytes=[Text.Encoding]::ASCII.GetBytes("RustDiscovery MSI fixture 1.0.0`r`n")
$recipe.predecessor=[ordered]@{product_code=$oldProduct;product_version='1.0.0';payload_path=$recipe.postcondition.payload_path;payload_sha256=(Hash-Bytes $oldBytes);payload_bytes=$oldBytes.Length}
}
$recipeJson=$recipe|ConvertTo-Json -Depth 12 -Compress
Write-New (Join-Path $case 'recipe.json') ([Text.Encoding]::UTF8.GetBytes($recipeJson))
Write-Json (Join-Path $case 'tables.json') $readback
$report.artifact=[ordered]@{path=$msi;sha256=(Hash $msi);bytes=$length;artifact_id_proposal=$artifact}
$report.payload=[ordered]@{sha256=(Hash $payload);bytes=$payloadBytes.Length;content_ascii="RustDiscovery MSI fixture 1.0.0`r`n";installed_path=$recipe.postcondition.payload_path}
$report.payload=[ordered]@{sha256=(Hash $payload);bytes=$payloadBytes.Length;content_ascii="RustDiscovery MSI fixture $version`r`n";installed_path=$recipe.postcondition.payload_path}
$report.cabinet=[ordered]@{sha256=(Hash $cab);bytes=(Get-Item -LiteralPath $cab).Length;embedded_hash_verified=$true;stream='fixture.cab'}
$report.tables_sha256=Hash (Join-Path $case 'tables.json');$report.table_names=$names
$report.resolved_recipe=[ordered]@{recipe=$recipe;recipe_sha256=(Hash (Join-Path $case 'recipe.json'))}
@@ -267,7 +304,7 @@ try {
Require ((Hash $PSCommandPath) -ceq $report.builder_sha256) 'MSI_BUILDER_CHANGED'
$report.completed=$true;$report.stage='authored_and_read_back_not_installed'
Write-Json (Join-Path $case 'result.json') $report
[ordered]@{completed=$true;build_only=$true;report_path=(Join-Path $case 'result.json');artifact=$report.artifact;native_installation_tested=$false;upgrade_authored=$false}|ConvertTo-Json -Depth 5
[ordered]@{completed=$true;build_only=$true;report_path=(Join-Path $case 'result.json');artifact=$report.artifact;native_installation_tested=$false;upgrade_authored=$isUpgrade}|ConvertTo-Json -Depth 5
} catch {
$report.completed=$false;$report.error_type=$_.Exception.GetType().FullName;$report.error_hresult=$_.Exception.HResult
$report.error_line=$_.InvocationInfo.ScriptLineNumber
+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
+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-
+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)
+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).
+44
View File
@@ -0,0 +1,44 @@
# Eigene MSI-Fixture1.1: Quellenstand
Stand2026-11-14: drei unexportierte Quellen im isolierten Branch
`codex/windows-msi-provider` erweitert und unabhängig geprüft. Keine Änderung
an produktiven Cargo-/Action-/Helper-/Serverpfaden und keine Capability oder
Paketfreigabe. MSI1.1 wurde noch nicht gebaut, registriert oder installiert.
Der tatsächliche alte MSI1.0-Artefaktbeleg bleibt unverändert erhalten.
Neues festes Rezept `rmm-windows-msi-fixture-upgrade-1.1`, ProductCode
`{D42BD387-079B-4BBF-A134-0DA7B7A97011}`, gleicher UpgradeCode wie1.0.
Das vollständige Rezept bindet zusätzlich den konkreten neuen PackageCode und
genau den bekannten1.0-Vorgänger samt Version/33-Byte-Nutzdateihash. Alte1.0-
Rezeptbytes bleiben durch am Ende angefügte, bei None ausgelassene Felder gleich.
Kein Fresh1.1, Repair, Downgrade oder beliebiger Vorgänger.
Provider und Builder verlangen feste Upgrade-Tabelle, LaunchCondition und
Ausführungssequenz, keine CustomActions. Vorheriger Machine-Produktzustand,
Familie und Nutzdatei müssen passen. Nachher1.1 exakt installiert und1.0 entfernt;
ein eigener Noop verlangt denselben konkreten1.1-PackageCode. Ein anderes neu
gebautes1.1-MSI erhält keine implizite Neuinstallationserlaubnis.
Zwei Quellenfehler wurden korrigiert: spät beobachteter Installerexit oder
Nachzustand wird nicht rückwirkend erfolgreich; zusätzlich beginnt das eine
Verifikations-/Installationsbudget vor allen synchronen Prüfungen und umfasst
auch Noop samt frischem Fence und erneuter Abbruchprüfung. Timeout bleibt
Unknown, kein globales Installerkillen oder Retry. `Run::Noop` kann dadurch
auch eine Unknown-Observation enthalten; spätere Aufrufer müssen deren State
auswerten und dürfen die Enumvariante nicht pauschal als Erfolg behandeln.
Tatsächlich lokal bestanden: fünf gezielte Harness-Tests ohne Skips,
Linux-/WindowsGNU-Harness-Clippy mit Warnungen als Fehler und PowerShell-AST.
Der Harness bindet explizit diesen Worktree und exportiert keine Produktmodule.
Originaler Quellenbeleg `devstate/windows-package-msi11/local-source-qualification.json`
(`0b562dc2…`) bleibt historisch; enger Folgebeleg
`noop-deadline-qualification.json` (`23ed1175…`) bindet den korrigierten Stand.
Finale Packagequelle `617b2a73…`, Domain `070a8dfa…`, Builder `6365ac16…`.
Im Builder wurde anschließend nur ein überflüssiges Leerzeichen entfernt:
PowerShell-Parse erfolgreich und vollständige Tokenliste vorher/nachher
identisch; vorheriger Builderquellenbeleg `2d63eaba…` bleibt historisch.
Offen sind Linux-first-Vertragsintegration, Tenantkatalog, geschützter
Artefakttransport/Cache, typisierte SYSTEM-Paketerlaubnis und tatsächliche
WebUI-genehmigte Installation/Upgrade/Noops auf der Windows-VM. Lokale Tests
und Crossbuilds sind keine native Installerabnahme.
+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();
+67 -3
View File
@@ -89,6 +89,66 @@ export function validateWindowsLogLimits(identity: unknown, runtime: unknown, ou
|| 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;
@@ -118,10 +178,14 @@ 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') {
+7 -3
View File
@@ -60,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');
+46 -8
View File
@@ -3,18 +3,32 @@ 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, windowsPowerShellRemoteSignedProfile } from './api';
import './style.css';
import { AdminControl, Catalog, TenantControls } from './management';
import { allowed, availableActions, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity, queryLogsApprovalBlockers, queryLogsPlanJobs } 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);
@@ -73,33 +87,57 @@ function Planner({ tenantId, auth, selected, showPlan }: { tenantId: string; aut
{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. 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={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>
<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), ...powerShellApprovalBlockers(plan.data), ...queryLogsApprovalBlockers(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>
<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}/>
@@ -136,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);
+105 -2
View File
@@ -1,8 +1,9 @@
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, powerShellApprovalBlockers, powerShellPlanJobs, queryLogsApprovalBlockers, queryLogsPlanJobs, 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', () => {
@@ -195,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(); }
});
});
+123 -12
View File
@@ -1,8 +1,8 @@
import { Action, PlanInput, RecordValue, Session, planTargetPreviews, record, text, validateSystemService, windowsScriptProfile, logWindow, validateWindowsLogLimits, windowsEventLogFixtureSource, windowsEventLogFixtureChannel, windowsEventLogFixtureProvider } 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,15 +101,13 @@ 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 planHash: unknown; readonly planBytes: readonly number[] }
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);
@@ -116,6 +119,7 @@ export function powerShellPlanJobs(plan: RecordValue): readonly PowerShellPlanJo
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');
}
@@ -153,6 +157,8 @@ function projectPowerShellJobs(jobs: unknown): PowerShellPlanJob[] {
}
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)];
@@ -214,7 +220,95 @@ export function queryLogsApprovalBlockers(plan: RecordValue): string[] {
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)
@@ -225,9 +319,13 @@ export async function verifyPlanIntegrity(plan: RecordValue) {
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';
@@ -238,7 +336,8 @@ export async function verifyPlanIntegrity(plan: RecordValue) {
verifiedBytes = Array.from(exactBytes);
const parsed = parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(exactBytes));
validatePlanAliases(plan, parsed);
const rawJobs = record(parsed).jobs;
const parsedPlan = record(parsed), rawJobs = parsedPlan.jobs;
verifiedParsed = parsedPlan;
powerShellJobs = projectPowerShellJobs(rawJobs);
logJobs = projectQueryLogsJobs(rawJobs);
if (hasLogView || logJobs.length) validateQueryLogsViews(plan, rawJobs);
@@ -246,9 +345,13 @@ export async function verifyPlanIntegrity(plan: RecordValue) {
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);
@@ -257,7 +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');
}
verifiedPowerShellPlans.set(plan, { jobs: powerShellJobs.map(job => Object.freeze({ ...job })), logJobs: logJobs.map(job => Object.freeze({ ...job })), planHash: plan.plan_hash, planBytes: verifiedBytes });
// 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']);