Files
rust-discovery/web/src/safety.test.tsx
T
2026-11-14 12:29:01 +01:00

301 lines
39 KiB
TypeScript

import { describe, expect, it, vi } from 'vitest';
import { renderToStaticMarkup } from 'react-dom/server';
import { actions, PlanInput, Session, request, session, windowsMsi, windowsMsiManifest, validateInput } from './api';
import { adminIntent, allowed, availableActions, windowsMsiPlanJobs, windowsMsiApprovalBlockers, verifyWindowsMsiManifest, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, queryLogsApprovalBlockers, queryLogsPlanJobs, recipeInput, rootWarning, sha256, validateAptManifest, validateSensitiveInput, verifyAptManifest, verifyPlanIntegrity } from './safety';
import { AdminControl } from './management';
vi.mock('react-dom/client', () => ({ createRoot: () => ({ render: vi.fn() }) }));
const auth: Session = { principal: { id: 'test', display_name: 'SIMULIERT', simulated: true }, csrf_token: 'csrf', tenants: [], permissions: ['root:execute', 'devices:revoke'] };
describe('immutable PowerShell process profile', () => {
async function plan(profile: unknown = 'powershell_51_remote_signed', identity = 'agent_service', interpreter = 'powershell') {
const action = { action: 'run_script', interpreter, script_utf8: 'Write-Output 1\r\n', arguments: [], expected_stdout: '1\r\n', ...(profile === undefined ? {} : { windows_execution_profile: profile }) };
const payload = { asset_id: 'fixed-windows', execution_identity: identity, action }, jobs = [{ asset_id: 'fixed-windows', job_payload_hash: 'a'.repeat(64), payload }];
const plan_payload = { jobs }, raw = new TextEncoder().encode(JSON.stringify(plan_payload));
return { plan_payload, plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), jobs };
}
it('requires verified bytes, rejects all profile/view mutations and preserves inherited plans', async () => {
const value = await plan(); expect(() => powerShellPlanJobs(value)).toThrow('nicht aus hashgeprüften');
await verifyPlanIntegrity(value); expect(powerShellPlanJobs(value)).toEqual([{ assetId: 'fixed-windows', profile: 'powershell_51_remote_signed' }]);
expect(powerShellApprovalBlockers(value)).toEqual([]);
const changed = structuredClone(value); changed.jobs[0]!.payload.action.windows_execution_profile = 'Bypass';
await expect(verifyPlanIntegrity(changed)).rejects.toThrow('widerspricht');
const viewOnly = { ...value, jobs: [{ ...value.jobs[0]!, payload: { ...value.jobs[0]!.payload, action: { ...value.jobs[0]!.payload.action, windows_execution_profile: 'Bypass' } } }] };
await expect(verifyPlanIntegrity(viewOnly)).rejects.toThrow('widerspricht');
const extraAlias = { ...value, resolved_targets: value.jobs, jobs: viewOnly.jobs };
await expect(verifyPlanIntegrity(extraAlias)).rejects.toThrow('widerspricht');
await expect(verifyPlanIntegrity({ ...value, payloads: viewOnly.jobs })).rejects.toThrow('widerspricht');
await expect(verifyPlanIntegrity({ ...value, payload: { jobs: viewOnly.jobs } })).rejects.toThrow('widerspricht');
const idsOnly = { ...value, resolved_targets: ['fixed-windows'] }; await verifyPlanIntegrity(idsOnly);
for (const alias of ['plan_payload', 'payload']) {
const later: Record<string, unknown> = { ...value, [alias]: value.plan_payload };
await verifyPlanIntegrity(later); later[alias] = { jobs: viewOnly.jobs };
expect(powerShellApprovalBlockers(later).length).toBeGreaterThan(0); expect(() => powerShellPlanJobs(later)).toThrow('widerspricht');
}
await expect(verifyPlanIntegrity({ ...value, plan_payload_bytes: undefined })).rejects.toThrow('gespeicherte Planbytes');
for (const profile of ['Bypass', null, {}, 'powershell_7_remote_signed']) await expect(verifyPlanIntegrity(await plan(profile))).rejects.toThrow('Windows-Ausführungsprofil');
for (const identity of ['root', 'system']) await expect(verifyPlanIntegrity(await plan('powershell_51_remote_signed', identity))).rejects.toThrow('agent_service');
await expect(verifyPlanIntegrity(await plan('powershell_51_remote_signed', 'agent_service', 'bash'))).rejects.toThrow();
const inherited = await plan(undefined); delete inherited.plan_payload.jobs[0]!.payload.action.windows_execution_profile;
const raw = new TextEncoder().encode(JSON.stringify(inherited.plan_payload)); inherited.plan_payload_bytes = Array.from(raw); inherited.plan_hash = await sha256(raw);
await verifyPlanIntegrity(inherited); expect(powerShellPlanJobs(inherited)[0]?.profile).toBe('inherited');
value.plan_payload_bytes[0] = 0; expect(powerShellApprovalBlockers(value).length).toBeGreaterThan(0); expect(() => powerShellPlanJobs(value)).toThrow('verändert');
});
});
describe('immutable live log window', () => {
it('binds source/window/limits and every supplied view to stored bytes, preserving Linux and SYSTEM plans', async () => {
const payload={asset_id:'windows-a',execution_identity:'agent_service',max_runtime_seconds:30,max_output_bytes:4096,action:{action:'query_logs',unit:'windows.eventlog.application.rustdiscovery-mvp-test',since:'2026-11-14T00:00:00Z',until:'2026-11-15T00:00:00Z',max_lines:1000}};
const plan_payload={jobs:[{payload}]},raw=new TextEncoder().encode(JSON.stringify(plan_payload));
const plan={plan_payload,plan_payload_bytes:Array.from(raw),plan_hash:await sha256(raw),jobs:plan_payload.jobs,resolved_targets:['windows-a']};
expect(()=>queryLogsPlanJobs(plan)).toThrow();await verifyPlanIntegrity(plan);
expect(queryLogsApprovalBlockers(plan)).toEqual([]);expect(queryLogsPlanJobs(plan)[0]).toMatchObject({source:payload.action.unit,channel:'Application',provider:'RustDiscovery-MVP-Test',maxLines:1000,outputBytes:4096,runtimeSeconds:30});
await expect(verifyPlanIntegrity({...plan,plan_payload_bytes:undefined})).rejects.toThrow('gespeicherte');
for(const action of [{...payload.action,max_lines:999},{...payload.action,until:'2026-11-14T23:59:59Z'}]){
const bad={...plan,payloads:[{payload:{...payload,action}}]};await expect(verifyPlanIntegrity(bad)).rejects.toThrow('widerspricht');
}
const changed={...plan,jobs:[{payload:{...payload,max_output_bytes:2048}}]};await expect(verifyPlanIntegrity(changed)).rejects.toThrow('widerspricht');
const cached={...plan};await verifyPlanIntegrity(cached);cached.jobs=[{payload:{...payload,max_runtime_seconds:31}}];expect(queryLogsApprovalBlockers(cached).length).toBeGreaterThan(0);
for(const execution_identity of ['root','system']){const p={jobs:[{payload:{...payload,execution_identity}}]};const b=new TextEncoder().encode(JSON.stringify(p));await expect(verifyPlanIntegrity({plan_payload_bytes:Array.from(b),plan_hash:await sha256(b)})).rejects.toThrow('agent_service');}
const linux={jobs:[{payload:{...payload,execution_identity:'root',action:{...payload.action,unit:'rmm-test.service'}}}]};const linuxBytes=new TextEncoder().encode(JSON.stringify(linux));const linuxPlan={plan_payload_bytes:Array.from(linuxBytes),plan_hash:await sha256(linuxBytes)};await verifyPlanIntegrity(linuxPlan);expect(queryLogsPlanJobs(linuxPlan)[0]?.windows).toBe(false);
const system={jobs:[{payload:{...payload,execution_identity:'system',action:{action:'set_service_state',unit:'RmmDiscoveryFixtureService',state:'running'}}}]};const systemBytes=new TextEncoder().encode(JSON.stringify(system));const systemPlan={plan_payload_bytes:Array.from(systemBytes),plan_hash:await sha256(systemBytes)};await verifyPlanIntegrity(systemPlan);expect(queryLogsPlanJobs(systemPlan)).toEqual([]);
});
});
async function manifest(acceptance = true) {
const transaction = { schema_version: 1, recipe_id: 'rmm-apt-fixture-install-1.0', recipe_version: '1', platform: 'ubuntu-24.04-amd64', resolver_config_version: 'rmm-apt-local-v1', no_reboot: true, status_fingerprint: 'a'.repeat(64), baseline_sha256: 'b'.repeat(64), packages: [{ name: 'rmm-mvp-test', architecture: 'all', old_version: null, new_version: '1.0', origin: 'rmm-test', sha256: '74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867', size: 20672, archive_path: '/var/lib/rmm-apt-transaction/archives/74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867.deb' }] };
const raw = new TextEncoder().encode(JSON.stringify(transaction));
return { type: 'rmm.apt.helper-action', schema_version: 2, action: acceptance ? 'apt-native-acceptance' : 'apt-execute', execution_profile: 'dev-test', transaction_sha256: await sha256(raw), transaction_bytes: Array.from(raw), resolved_apt_transaction: transaction, provider_sha256: 'c'.repeat(64), hook_sha256: 'd'.repeat(64), apt_config_sha256: 'e'.repeat(64), runtime_sha256: 'f'.repeat(64), test_result_id: 'unit-test-only-not-native-evidence' };
}
async function recoveryManifest() {
const base = await manifest();
const transaction = { ...base.resolved_apt_transaction, schema_version: 2, operation: 'configure_only', packages: base.resolved_apt_transaction.packages.map(p => ({ ...p, old_version: '1.0' })) };
const raw = new TextEncoder().encode(JSON.stringify(transaction));
return { ...base, schema_version: 4, resolved_apt_transaction: transaction, transaction_bytes: Array.from(raw), transaction_sha256: await sha256(raw),
native_recovery: { schema_version: 1, previous_grant_id: '11111111-1111-4111-8111-111111111111', previous_attempt_id: '22222222-2222-4222-8222-222222222222', partial_proof_sha256: 'a'.repeat(64) } };
}
function input(apt_manifest: unknown): PlanInput { return { tenant_id: 't', action: 'apt_native_acceptance', targets: { asset_ids: ['asset'] }, parameters: { execution_identity: 'root', recipe_id: 'rmm-apt-fixture-install-1.0', recipe_version: '1', apt_manifest }, schedule: { not_before: '', start_before: '', offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'unit only' }; }
describe('immutable catalog and strict import contracts', () => {
it('only accepts full immutable exact APT package metadata, never URLs or unknown fields', () => {
const r = { schema_version: 1, provider: 'apt', package: 'rmm-test', version: '1.0+test1', architecture: 'amd64', recipe_version: '1', installation_context: 'system', reboot_policy: 'never' };
expect(recipeInput(r)).toEqual(r);
expect(() => recipeInput({ ...r, url: 'https://example.invalid' })).toThrow();
expect(() => recipeInput({ ...r, package: 'https://example.invalid/a.deb' })).toThrow();
expect(() => recipeInput({ ...r, version: '' })).toThrow();
expect(() => parseStrictJson('{"version":"1","version":"2"}')).toThrow('Doppeltes');
expect(() => parseStrictJson('{"a":{"\u0078":1,"x":2}}')).toThrow('Doppeltes');
});
});
describe('root and dedicated dev-test APT actions', () => {
it('requires independent system scope and verifies the exact bounded SYSTEM service plan', async () => {
const value: PlanInput = { tenant_id: 't', action: 'set_service_state', targets: { asset_ids: ['asset'] }, parameters: { execution_identity: 'system', unit: 'RmmDiscoveryFixtureService', state: 'running', timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: '', start_before: '', offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'unit only' };
for (const permissions of [undefined, [], ['root:execute']]) await expect(validateSensitiveInput(value, { ...auth, permissions })).rejects.toThrow('system:execute');
const systemAuth = { ...auth, permissions: ['system:execute'] };
const before = JSON.stringify(value); await validateSensitiveInput(value, systemAuth); expect(JSON.stringify(value)).toBe(before);
await expect(validateSensitiveInput({ ...value, action: 'run_script' }, systemAuth)).rejects.toThrow('typisierte');
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, state: 'restarted' } }, systemAuth)).rejects.toThrow('running');
const payload = { execution_identity: 'system', asset_id: 'asset', action: { action: 'set_service_state', unit: 'RmmDiscoveryFixtureService', state: 'running' }, max_runtime_seconds: 30, max_output_bytes: 4096 };
const plan_payload = { jobs: [{ payload }] }, raw = new TextEncoder().encode(JSON.stringify(plan_payload));
const plan = { plan_payload, plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), jobs: plan_payload.jobs };
await verifyPlanIntegrity(plan);
await expect(verifyPlanIntegrity({ ...plan, plan_payload_bytes: undefined })).rejects.toThrow('exakte gespeicherte');
const changed = structuredClone(plan_payload), first = changed.jobs[0]; if (!first) throw new Error('One fixed service job required'); first.payload.action.state = 'stopped';
await expect(verifyPlanIntegrity({ ...plan, plan_payload: changed })).rejects.toThrow('widerspricht');
const shell = { jobs: [{ payload: { ...payload, action: { action: 'run_script', interpreter: 'powershell' } } }] }, shellRaw = new TextEncoder().encode(JSON.stringify(shell));
await expect(verifyPlanIntegrity({ plan_payload_bytes: Array.from(shellRaw), plan_hash: await sha256(shellRaw) })).rejects.toThrow();
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, execution_identity: 'root' } }, systemAuth)).rejects.toThrow('root:execute');
});
it('shows native acceptance only with explicit server simulation evidence, never upgrades identity', async () => {
expect(availableActions(auth, actions)).toContain('apt_native_acceptance');
expect(availableActions({ ...auth, principal: { ...auth.principal, simulated: false } }, actions)).not.toContain('apt_native_acceptance');
const value = input(await manifest());
await validateSensitiveInput(value, auth); expect(value.parameters.execution_identity).toBe('root');
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, execution_identity: 'agent_service' } }, auth)).rejects.toThrow('root');
await expect(validateSensitiveInput(value, { ...auth, permissions: [] })).rejects.toThrow('root:execute');
await expect(validateSensitiveInput(value, { ...auth, principal: { ...auth.principal, simulated: false } })).rejects.toThrow('simuliert');
expect(rootWarning).toContain('HOHES RISIKO'); expect(rootWarning).toContain('Keine automatische Rechteerhöhung');
});
it('checks schema2, full closure, exact bytes, pinned versions/hashes/origins and placeholders', async () => {
const m = await manifest(); await verifyAptManifest(m, true);
expect(() => validateAptManifest({ ...m, schema_version: 1 }, true)).toThrow();
expect(() => validateAptManifest({ ...m, provider_sha256: '<placeholder>' }, true)).toThrow();
expect(() => validateAptManifest({ ...m, transaction_bytes: [] }, true)).toThrow();
expect(() => validateAptManifest({ ...m, resolved_apt_transaction: { ...m.resolved_apt_transaction, packages: [] } }, true)).toThrow();
expect(() => validateAptManifest({ ...m, unknown: true }, true)).toThrow();
await expect(verifyAptManifest({ ...m, transaction_sha256: 'a'.repeat(64) }, true)).rejects.toThrow('Transaktionshash');
await expect(validateSensitiveInput({ ...input(m), parameters: { ...input(m).parameters, recipe_id: 'other' } }, auth)).rejects.toThrow('Rezept');
});
it('preserves ordinary package manifest closure unchanged, validates outer package identity', async () => {
const m = await manifest(false), value = input(m); value.action = 'ensure_package'; value.parameters = { ...value.parameters, provider: 'apt', package: 'rmm-mvp-test', version: '1.0', architecture: 'all', installation_context: 'system' };
const before = JSON.stringify(value); await validateSensitiveInput(value, auth); expect(JSON.stringify(value)).toBe(before);
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, version: '2' } }, auth)).rejects.toThrow('Paketidentität');
});
it('requires an explicit schema3 native retry reference; rejects missing/unknown/normal retry fields', async () => {
const base = await manifest();
const native_retry = { schema_version: 1, previous_grant_id: '11111111-1111-4111-8111-111111111111', previous_attempt_id: '22222222-2222-4222-8222-222222222222', bootstrap_marker_sha256: 'a'.repeat(64) };
const m = { ...base, schema_version: 3, native_retry };
await validateSensitiveInput(input(m), auth);
expect(() => validateAptManifest({ ...base, schema_version: 3 }, true)).toThrow();
expect(() => validateAptManifest({ ...base, native_retry }, true)).toThrow();
expect(() => validateAptManifest({ ...m, native_retry: { ...native_retry, previous_grant_id: '../active' } }, true)).toThrow();
expect(() => validateAptManifest({ ...m, native_retry: { ...native_retry, previous_attempt_id: '00000000-0000-0000-0000-000000000000' } }, true)).toThrow();
expect(() => validateAptManifest({ ...m, native_retry: { ...native_retry, bootstrap_marker_sha256: '0'.repeat(64) } }, true)).toThrow();
expect(() => validateAptManifest({ ...m, action: 'apt-execute' }, false)).toThrow('eigener nativer');
});
it('accepts only an explicit schema4 configure-only partial binding and preserves all byte/plan checks', async () => {
const m = await recoveryManifest(), before = JSON.stringify(m);
await validateSensitiveInput(input(m), auth); expect(JSON.stringify(m)).toBe(before);
expect(() => validateAptManifest({ ...m, action: 'apt-execute' }, false)).toThrow('eigenen nativen');
expect(() => validateAptManifest({ ...m, native_recovery: { ...m.native_recovery, previous_grant_id: '00000000-0000-0000-0000-000000000000' } }, true)).toThrow();
expect(() => validateAptManifest({ ...m, native_recovery: { ...m.native_recovery, partial_proof_sha256: '0'.repeat(64) } }, true)).toThrow();
expect(() => validateAptManifest({ ...m, native_retry: {} }, true)).toThrow();
const wrongVersion = { ...m.resolved_apt_transaction, packages: m.resolved_apt_transaction.packages.map(p => ({ ...p, old_version: null })) };
const wrongRaw = new TextEncoder().encode(JSON.stringify(wrongVersion));
expect(() => validateAptManifest({ ...m, resolved_apt_transaction: wrongVersion, transaction_bytes: Array.from(wrongRaw) }, true)).toThrow('Version');
const normal = await manifest();
expect(() => validateAptManifest({ ...normal, resolved_apt_transaction: { ...normal.resolved_apt_transaction, operation: 'configure_only' } }, true)).toThrow('Schemafelder');
expect(() => validateAptManifest({ ...m, resolved_apt_transaction: { ...m.resolved_apt_transaction, operation: 'install' } }, true)).toThrow('Transaktionsschema');
await expect(verifyAptManifest({ ...m, transaction_sha256: 'b'.repeat(64) }, true)).rejects.toThrow('Transaktionshash');
const payload = { jobs: [{ payload: { action: { action: 'apt_native_acceptance', apt_manifest: m } } }] };
const raw = new TextEncoder().encode(JSON.stringify(payload));
const plan = { plan_payload: payload, plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), jobs: payload.jobs };
await verifyPlanIntegrity(plan);
const changed = structuredClone(payload), changedJob = changed.jobs[0];
if (!changedJob) throw new Error('One fixture job required');
changedJob.payload.action.apt_manifest.native_recovery.partial_proof_sha256 = 'b'.repeat(64);
await expect(verifyPlanIntegrity({ ...plan, plan_payload: changed })).rejects.toThrow('widerspricht');
});
it('binds update package names to the exact versions in the unchanged signed manifest', async () => {
const m = await manifest(false); const value = input(m); value.action = 'apply_updates';
value.parameters = { execution_identity: 'root', provider: 'apt', packages: ['rmm-mvp-test'], reboot_policy: 'never', apt_manifest: m };
await validateSensitiveInput(value, auth);
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, packages: ['other'] } }, auth)).rejects.toThrow('Updateauswahl');
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, packages: [] } }, auth)).rejects.toThrow('Updateauswahl');
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, packages: ['rmm-mvp-test=1.0'] } }, auth)).rejects.toThrow('Updateauswahl');
});
it('checks exact plan byte hash and manifest consistency without demanding execution IDs', async () => {
const p = { targets: ['asset'], jobs: [{ payload: { asset_id: 'asset', action: { action: 'apt_native_acceptance', apt_manifest: await manifest() } } }] }, raw = new TextEncoder().encode(JSON.stringify(p));
const plan = { plan_payload: p, plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), jobs: p.jobs };
await verifyPlanIntegrity(plan);
await expect(verifyPlanIntegrity({ ...plan, plan_hash: 'a'.repeat(64) })).rejects.toThrow('Planhash');
await expect(verifyPlanIntegrity({ ...plan, plan_payload: { ...p, targets: ['foreign'] } })).rejects.toThrow('widerspricht');
});
});
describe('interactive administrative boundary', () => {
it('retains explicit membership permissions and never treats roles as implicit rights', () => {
const s = session({ principal: 'test', tenant_id: 't', csrf_token: 'csrf', testsimulation: true, permissions: ['devices:revoke'], roles: ['dev_test_member'] });
expect(allowed(s, 'devices:revoke')).toBe(true); expect(allowed({ ...s, permissions: undefined }, 'devices:revoke')).toBe(false);
});
it('requires explicit click confirmation, reason and current nonce; rendering causes no request', () => {
const fetch = vi.fn(); vi.stubGlobal('fetch', fetch);
const html = renderToStaticMarkup(<AdminControl auth={auth} path="/api/v1/tenants/t/devices/a/revocation" title="Widerrufen" permission="devices:revoke" warning="Unterbricht Verwaltung"/>);
expect(html).toContain('Unterbricht Verwaltung'); expect(html).toContain('Bestätigungskennung'); expect(fetch).not.toHaveBeenCalled();
expect(() => adminIntent(false, 'reason', 'nonce', 'nonce')).toThrow(); expect(() => adminIntent(true, '', 'nonce', 'nonce')).toThrow(); expect(() => adminIntent(true, 'reason', 'old', 'nonce')).toThrow();
expect(adminIntent(true, 'reason', 'nonce', 'nonce')).toEqual({ reason: 'reason' }); vi.unstubAllGlobals();
});
it('sends exact admin JSON with cookie credentials and CSRF, never a secret-bearing nonce API field', async () => {
const fetch = vi.fn().mockResolvedValue(new Response('{}')); vi.stubGlobal('fetch', fetch);
await request('/api/v1/tenants/t/execution-stop', { csrf: 'csrf', body: { ...adminIntent(true, 'test only', 'nonce', 'nonce'), stopped: true } });
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(); }
});
});