import { Action, PlanInput, RecordValue, Session, planTargetPreviews, record, text, validateSystemService, validateWindowsReboot, windowsScriptProfile, logWindow, validateWindowsLogLimits, windowsEventLogFixtureSource, windowsEventLogFixtureChannel, windowsEventLogFixtureProvider, WindowsMsiManifest, MsiPostcondition, windowsMsi, windowsMsiManifest, windowsMsiAction, validateWindowsMsiInput, validateWindowsMsiLimits, msiUuid, fullMaintenanceScriptProfile, privilegedScriptProfile, validateScriptIdentityProfile } from './api'; import { validateAgentUpdateAction } from './agent-updates'; 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 (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 const fullMaintenanceWarning = 'VOLLE HOSTWARTUNG · full_maintenance_v1: Das genehmigte Skript läuft als root/SYSTEM mit vollständiger Hostautorität, einschließlich Netzwerk, Dateisystem und Diensten. Es kann auch Agent, PKI und Schutzmechanismen ändern oder einen Neustart auslösen. Keine Sandbox- oder No-Reboot-Zusage. scripts:execute plus root:execute/system:execute, lokaler und zentraler Opt-in, passende Capability, unabhängiger Helper und konkrete WebUI-Genehmigung bleiben erforderlich.'; 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); } export function parseStrictJson(source: string): unknown { if (new TextEncoder().encode(source).length > 1048576) throw new Error('JSON über 1 MiB'); let i = 0; const space = () => { while (/\s/.test(source[i] ?? '') && i < source.length) i++; }; const string = (): string => { const start = i++; while (i < source.length) { if (source[i] === '\\') i += 2; else if (source[i++] === '"') return JSON.parse(source.slice(start, i)); } throw new Error('Ungültiger JSON-String'); }; const value = (depth: number): void => { if (depth > 64) throw new Error('JSON zu tief verschachtelt'); space(); if (source[i] === '{') { i++; space(); const keys = new Set(); if (source[i] === '}') { i++; return; } while (i < source.length) { space(); if (source[i] !== '"') throw new Error('JSON-Objektschlüssel erwartet'); const key = string(); if (keys.has(key)) throw new Error(`Doppeltes JSON-Feld: ${key}`); keys.add(key); space(); if (source[i++] !== ':') throw new Error('JSON-Doppelpunkt erwartet'); value(depth + 1); space(); const end = source[i++]; if (end === '}') return; if (end !== ',') throw new Error('Ungültiges JSON-Objekt'); } throw new Error('Unvollständiges JSON-Objekt'); } if (source[i] === '[') { i++; space(); if (source[i] === ']') { i++; return; } while (i < source.length) { value(depth + 1); space(); const end = source[i++]; if (end === ']') return; if (end !== ',') throw new Error('Ungültiges JSON-Array'); } throw new Error('Unvollständiges JSON-Array'); } if (source[i] === '"') { string(); return; } const token = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(source.slice(i)); if (!token) throw new Error('Ungültiger JSON-Wert'); i += token[0].length; }; value(0); space(); if (i !== source.length) throw new Error('Zusätzliche JSON-Daten'); return JSON.parse(source); } function exact(r: RecordValue, fields: string[]) { if (Object.keys(r).some(k => !fields.includes(k)) || fields.some(k => !(k in r))) throw new Error('Schemafelder fehlen oder sind unbekannt'); } function hash(v: unknown) { if (typeof v !== 'string' || !hashPattern.test(v) || /^0{64}$/.test(v)) throw new Error('Exakter SHA-256 fehlt/Platzhalter'); } export function bytes(value: unknown): Uint8Array { if (!Array.isArray(value) || !value.length || value.length > 1048576 || value.some(n => !Number.isInteger(n) || n < 0 || n > 255)) throw new Error('Exakte Bytefolge fehlt'); return new Uint8Array(value); } export async function sha256(value: Uint8Array): Promise { return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', value)), n => n.toString(16).padStart(2, '0')).join(''); } function canonical(v: unknown): string { if (Array.isArray(v)) return `[${v.map(canonical).join(',')}]`; if (v !== null && typeof v === 'object') return `{${Object.entries(v).sort(([a], [b]) => a.localeCompare(b)).map(([k, x]) => `${JSON.stringify(k)}:${canonical(x)}`).join(',')}}`; return JSON.stringify(v); } export function validateAptManifest(value: unknown, acceptance: boolean): RecordValue { const m = record(value, 'apt_manifest'); exact(m, ['type', 'schema_version', 'action', 'execution_profile', 'transaction_sha256', 'resolved_apt_transaction', 'transaction_bytes', 'provider_sha256', 'hook_sha256', 'apt_config_sha256', 'runtime_sha256', 'test_result_id', ...(m.schema_version === 3 ? ['native_retry'] : []), ...(m.schema_version === 4 ? ['native_recovery'] : [])]); if (m.type !== 'rmm.apt.helper-action' || ![2, 3, 4].includes(Number(m.schema_version)) || typeof m.schema_version !== 'number' || m.execution_profile !== 'dev-test' || m.action !== (acceptance ? 'apt-native-acceptance' : 'apt-execute')) throw new Error('APT Schema 2/3/4 / explizites dev-test-Profil erforderlich'); if (m.schema_version === 3) { if (!acceptance) throw new Error('Wiederaufnahme nur als eigener nativer Abnahmeplan'); const retry = record(m.native_retry); exact(retry, ['schema_version', 'previous_grant_id', 'previous_attempt_id', 'bootstrap_marker_sha256']); const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/; if (retry.schema_version !== 1 || ['previous_grant_id', 'previous_attempt_id'].some(k => typeof retry[k] !== 'string' || !uuid.test(retry[k] as string) || retry[k] === '00000000-0000-0000-0000-000000000000')) throw new Error('Exakte ursprüngliche Grant-/Versuchsbindung erforderlich'); hash(retry.bootstrap_marker_sha256); } const recovery = m.schema_version === 4; if (recovery) { if (!acceptance) throw new Error('Configure-only benötigt einen eigenen nativen Abnahmeplan'); const ref = record(m.native_recovery); exact(ref, ['schema_version', 'previous_grant_id', 'previous_attempt_id', 'partial_proof_sha256']); const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/; if (ref.schema_version !== 1 || ['previous_grant_id', 'previous_attempt_id'].some(k => typeof ref[k] !== 'string' || !uuid.test(ref[k] as string) || ref[k] === '00000000-0000-0000-0000-000000000000')) throw new Error('Exakte geschlossene Partial-Grant-/Versuchsbindung erforderlich'); hash(ref.partial_proof_sha256); } for (const k of ['transaction_sha256', 'provider_sha256', 'hook_sha256', 'apt_config_sha256', 'runtime_sha256']) hash(m[k]); if (typeof m.test_result_id !== 'string' || !/^[A-Za-z0-9_.-]{1,128}$/.test(m.test_result_id)) throw new Error('Exakte Testnachweis-ID erforderlich'); const transaction = record(m.resolved_apt_transaction); exact(transaction, ['schema_version', 'recipe_id', 'recipe_version', 'platform', 'resolver_config_version', 'no_reboot', 'status_fingerprint', 'baseline_sha256', 'packages', ...(recovery ? ['operation'] : [])]); if (transaction.schema_version !== (recovery ? 2 : 1) || (recovery && transaction.operation !== 'configure_only') || transaction.recipe_version !== '1' || transaction.platform !== 'ubuntu-24.04-amd64' || transaction.resolver_config_version !== 'rmm-apt-local-v1' || transaction.no_reboot !== true) throw new Error('APT Transaktionsschema/Plattform/No-Reboot ungültig'); text(transaction.recipe_id, 'recipe_id'); hash(transaction.status_fingerprint); hash(transaction.baseline_sha256); if (!Array.isArray(transaction.packages) || !transaction.packages.length || transaction.packages.length > 128) throw new Error('Vollständige Paketclosure erforderlich'); const identities = new Set(); for (const value of transaction.packages) { const p = record(value); exact(p, ['name', 'architecture', 'old_version', 'new_version', 'origin', 'sha256', 'size', 'archive_path']); for (const k of ['name', 'architecture', 'new_version', 'origin']) text(p[k], k); if (p.old_version !== null) text(p.old_version, 'old_version'); hash(p.sha256); if (typeof p.size !== 'number' || !Number.isSafeInteger(p.size) || p.size < 1 || p.archive_path !== `/var/lib/rmm-apt-transaction/archives/${p.sha256}.deb`) throw new Error('APT Archivgröße/Pfadbindung fehlt'); const id = `${p.name}:${p.architecture}`; if (identities.has(id)) throw new Error('Doppelte Paketidentität'); identities.add(id); } const parsed = parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(bytes(m.transaction_bytes))); if (canonical(parsed) !== canonical(transaction)) throw new Error('Exakte Transaktionsbytes widersprechen Manifestobjekt'); if (acceptance) { const install = transaction.recipe_id === 'rmm-apt-fixture-install-1.0', update = transaction.recipe_id === 'rmm-apt-fixture-update-1.1'; if ((!install && !update) || (recovery && !install) || transaction.packages.length !== 1) throw new Error('Nur genaue native Fixture-Rezepte erlaubt'); const p = record(transaction.packages[0]); if (p.name !== 'rmm-mvp-test' || p.architecture !== 'all' || p.origin !== 'rmm-test' || p.size !== 20672 || p.old_version !== (recovery ? '1.0' : install ? null : '1.0') || p.new_version !== (install ? '1.0' : '1.1') || p.sha256 !== (install ? '74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867' : 'ef67c9fe0ba1443fcfe465768e1204763063c369a2a1da04af6027d8a9c00491')) throw new Error('Native Fixture-Bytes/Version/Origin stimmen nicht überein'); } return m; } export async function verifyAptManifest(value: unknown, acceptance: boolean) { const m = validateAptManifest(value, acceptance); if (await sha256(bytes(m.transaction_bytes)) !== m.transaction_sha256) throw new Error('APT Transaktionshash stimmt nicht überein'); } export async function validateSensitiveInput(input: PlanInput, auth: Session) { if (input.action === 'update_agent') { if (!allowed(auth, 'updates:apply') || !['root', 'system'].includes(String(input.parameters.execution_identity)) || !allowed(auth, input.parameters.execution_identity === 'root' ? 'root:execute' : 'system:execute')) throw new Error('Agentupdate: updates:apply und getrennte Root-/SYSTEM-Rechte erforderlich'); return; } if (input.action === 'run_script' && privilegedScriptProfile(input.parameters, input.parameters.execution_identity) === fullMaintenanceScriptProfile && !allowed(auth, 'scripts:execute')) throw new Error('scripts:execute für Vollwartung unbekannt oder nicht erteilt'); 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 === 'run_script') { if (privilegedScriptProfile(input.parameters, 'system') !== fullMaintenanceScriptProfile) throw new Error('SYSTEM ausschließlich für typisierte Aktionen oder explizit full_maintenance_v1'); } else if (input.action !== 'set_service_state' && input.action !== 'ensure_package' && input.action !== 'reboot') throw new Error('SYSTEM ausschließlich für typisierte Dienstaktionen, feste MSI-Rezepte oder den gesonderten festen Neustart'); if (input.action === 'set_service_state') validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes); if (input.action === 'reboot') validateWindowsReboot(input.parameters.reason, input.parameters.dependency_group, input.parameters.reconnect_timeout_seconds, 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'); const m = validateAptManifest(input.parameters.apt_manifest, true), t = record(m.resolved_apt_transaction); if (input.parameters.recipe_id !== t.recipe_id || input.parameters.recipe_version !== t.recipe_version) throw new Error('Äußeres Rezept widerspricht Manifest'); await verifyAptManifest(m, true); } else if (input.action === 'ensure_package' || input.action === 'apply_updates') { if (input.parameters.apt_manifest !== undefined && input.parameters.apt_manifest !== null) { const m = validateAptManifest(input.parameters.apt_manifest, false), t = record(m.resolved_apt_transaction), packages = t.packages; if (!Array.isArray(packages)) throw new Error('Paketclosure fehlt'); if (input.action === 'ensure_package' && (input.parameters.recipe_version !== t.recipe_version || (input.parameters.recipe_id !== undefined && input.parameters.recipe_id !== t.recipe_id))) throw new Error('Äußere Rezeptbindung widerspricht Manifest'); if (input.action === 'ensure_package' && !packages.some(v => { const p = record(v); return p.name === input.parameters.package && p.new_version === input.parameters.version && p.architecture === input.parameters.architecture; })) throw new Error('Exakte Paketidentität fehlt in Closure'); if (input.action === 'apply_updates' && (!Array.isArray(input.parameters.packages) || input.parameters.packages.length !== packages.length || !input.parameters.packages.every(v => typeof v === 'string' && packages.some(x => { const p = record(x); return v === p.name; })))) throw new Error('Exakte Updateauswahl fehlt in versionsgebundener Closure'); await verifyAptManifest(m, false); } } } /** Display only definitions decoded from the exact hashed plan bytes. */ export function systemPlanJobs(plan: RecordValue): RecordValue[] { powerShellPlanJobs(plan); return structuredClone(verifiedPowerShellPlans.get(plan)!.systemJobs); } export interface PowerShellPlanJob { readonly assetId: string; readonly profile: 'inherited' | 'powershell_51_remote_signed'; readonly identity?: 'system' } // Only successful verification writes this cache. Projection is copied from the // verified bytes; later mutations of API views cannot change the displayed plan. interface VerifiedPowerShellPlan { readonly jobs: readonly PowerShellPlanJob[]; readonly logJobs: readonly QueryLogsPlanJob[]; readonly msiJobs: readonly WindowsMsiPlanJob[]; readonly systemJobs: RecordValue[]; readonly planHash: unknown; readonly planBytes: readonly number[] } const verifiedPowerShellPlans = new WeakMap(); export function powerShellPlanJobs(plan: RecordValue): readonly PowerShellPlanJob[] { const verified = verifiedPowerShellPlans.get(plan); if (!verified) throw new Error('PowerShell-Plan wurde nicht aus hashgeprüften gespeicherten Bytes verifiziert'); if (verified.planBytes.length) { const current = bytes(plan.plan_payload_bytes); if (plan.plan_hash !== verified.planHash || current.length !== verified.planBytes.length || verified.planBytes.some((value, i) => current[i] !== value)) throw new Error('PowerShell-Planbytes wurden nach Verifikation verändert'); const parsed = record(parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(current))); validatePlanAliases(plan, parsed); validatePowerShellViews(plan, parsed.jobs); validateQueryLogsViews(plan, parsed.jobs); validateMsiViews(plan, parsed.jobs); } else if (scriptPayloads(planTargetPreviews(plan)).some(hasPowerShellProfile)) { throw new Error('PowerShell-Plan benötigt exakte gespeicherte Planbytes'); } return verified.jobs.map(job => ({ ...job })); } export function powerShellApprovalBlockers(plan: RecordValue): string[] { try { powerShellPlanJobs(plan); return []; } catch (error) { return [error instanceof Error ? error.message : 'PowerShell-Profil ist nicht verifiziert']; } } function scriptPayloads(jobs: unknown): RecordValue[] { if (!Array.isArray(jobs)) return []; return jobs.flatMap(job => { if (!job || typeof job !== 'object') return []; const payload = record(job).payload; return payload && typeof payload === 'object' ? [record(payload)] : []; }); } function hasPowerShellProfile(payload: RecordValue): boolean { if (Object.prototype.hasOwnProperty.call(payload, 'windows_execution_profile')) throw new Error('Windows-Ausführungsprofil muss Teil der festen Skriptaktion sein'); const action = payload.action; return action !== null && typeof action === 'object' && (record(action).interpreter === 'powershell' || Object.prototype.hasOwnProperty.call(action, 'windows_execution_profile')); } function projectPowerShellJobs(jobs: unknown): PowerShellPlanJob[] { return scriptPayloads(jobs).filter(hasPowerShellProfile).map(payload => { const action = record(payload.action); if (action.action !== 'run_script' || action.interpreter !== 'powershell') throw new Error('PowerShell-Profil benötigt Windows PowerShell5.1 als agent_service oder explizit SYSTEM'); validateScriptIdentityProfile(action, payload.execution_identity, action.interpreter); exact(action, ['action', 'interpreter', 'script_utf8', 'arguments', 'expected_stdout', ...(Object.prototype.hasOwnProperty.call(action, 'windows_execution_profile') ? ['windows_execution_profile'] : []), ...(Object.hasOwn(action, 'privileged_script_profile') ? ['privileged_script_profile'] : [])]); if (typeof action.script_utf8 !== 'string' || !action.script_utf8 || new TextEncoder().encode(action.script_utf8).length > 32768 || action.script_utf8.includes('\0') || (!/^[\x00-\x7f]*$/.test(action.script_utf8) && !action.script_utf8.startsWith('\ufeff')) || !Array.isArray(action.arguments) || action.arguments.length > 32 || action.arguments.some(arg => typeof arg !== 'string' || new TextEncoder().encode(arg).length > 4096 || arg.includes('\0')) || !(action.expected_stdout === null || (typeof action.expected_stdout === 'string' && new TextEncoder().encode(action.expected_stdout).length <= 65536))) throw new Error('Vollständige unveränderte PowerShell-Skriptaktion erforderlich'); return { assetId: text(payload.asset_id, 'PowerShell-Zielasset'), profile: windowsScriptProfile(action), ...(payload.execution_identity === 'system' ? { identity: 'system' as const } : {}) }; }); } function validatePlanAliases(plan: RecordValue, parsed: unknown): void { for (const alias of ['plan_payload', 'payload']) if (plan[alias] !== undefined && canonical(parsed) !== canonical(plan[alias])) throw new Error('Planansicht widerspricht gespeicherten Bytes'); const p = record(parsed); if (scriptPayloads(p.jobs).some(isMsi) && ((plan.plan_id !== undefined && plan.plan_id !== p.plan_id) || (plan.expires_at !== undefined && plan.expires_at !== scriptPayloads(p.jobs)[0]?.start_before))) throw new Error('MSI-Plan-ID/Fristansicht widerspricht gespeicherten Bytes'); } function validateFixedViews(plan: RecordValue, rawJobs: unknown, selected: (payload: RecordValue) => boolean, label: string, fields = ['action', 'execution_identity']): void { const rawPayloads = scriptPayloads(rawJobs), views = [planTargetPreviews(plan)]; for (const alias of ['jobs', 'payloads', 'resolved_targets']) { if (plan[alias] !== undefined && !Array.isArray(plan[alias])) throw new Error(`${label}-Zielpreview ist keine vollständige Liste`); if (Array.isArray(plan[alias])) views.push(plan[alias]); } for (const collection of new Set(views)) if (collection !== null) { if (!collection.some(value => value !== null && typeof value === 'object' && !Array.isArray(value) && 'payload' in value)) continue; const viewPayloads = scriptPayloads(collection); for (const fixed of rawPayloads.filter(selected)) if (!viewPayloads.some(view => view.asset_id === fixed.asset_id)) throw new Error(`${label}-Zielpreview fehlt im festen Plan`); for (const view of viewPayloads) { const raw = rawPayloads.find(payload => payload.asset_id === view.asset_id); if ((selected(view) || (raw && selected(raw))) && (!raw || fields.some(field => canonical(raw[field]) !== canonical(view[field])))) throw new Error(`${label}-Zielpreview widerspricht gespeicherten Planbytes`); } } } function validatePowerShellViews(plan: RecordValue, rawJobs: unknown): void { validateFixedViews(plan, rawJobs, hasPowerShellProfile, 'PowerShell'); } function isQueryLogs(payload: RecordValue): boolean { return payload.action !== null && typeof payload.action === 'object' && record(payload.action).action === 'query_logs'; } function validateQueryLogsViews(plan: RecordValue, rawJobs: unknown): void { validateFixedViews(plan, rawJobs, isQueryLogs, 'Log', ['action', 'execution_identity', 'max_runtime_seconds', 'max_output_bytes']); } export interface QueryLogsPlanJob { readonly assetId: string; readonly source: string; readonly since: string; readonly until: string; readonly maxLines: number; readonly runtimeSeconds: number; readonly outputBytes: number; readonly windows: boolean; readonly channel: string | null; readonly provider: string | null; } function projectQueryLogsJobs(jobs: unknown): QueryLogsPlanJob[] { return scriptPayloads(jobs).filter(isQueryLogs).map(payload => { const action = record(payload.action); exact(action, ['action', 'unit', 'since', 'until', 'max_lines']); const source = text(action.unit, 'Logquelle'), since = text(action.since, 'since'), until = text(action.until, 'until'); logWindow(since, until); if (typeof action.max_lines !== 'number' || !Number.isSafeInteger(action.max_lines) || action.max_lines < 1 || action.max_lines > 1000 || typeof payload.max_runtime_seconds !== 'number' || !Number.isSafeInteger(payload.max_runtime_seconds) || payload.max_runtime_seconds < 1 || payload.max_runtime_seconds > 3600 || typeof payload.max_output_bytes !== 'number' || !Number.isSafeInteger(payload.max_output_bytes) || payload.max_output_bytes < 1 || payload.max_output_bytes > 262144) throw new Error('Vollständige feste Loglimits erforderlich'); const windows = source === windowsEventLogFixtureSource; if (source.startsWith('windows.eventlog.') && !windows) throw new Error('Unbekannte Windows-Eventlogquelle'); if (windows) validateWindowsLogLimits(payload.execution_identity, payload.max_runtime_seconds, payload.max_output_bytes, since); else if (!['agent_service', 'root'].includes(String(payload.execution_identity))) throw new Error('Unbekannte Log-Ausführungsidentität'); return { assetId: text(payload.asset_id, 'Log-Zielasset'), source, since, until, maxLines: action.max_lines, runtimeSeconds: payload.max_runtime_seconds, outputBytes: payload.max_output_bytes, windows, channel: windows ? windowsEventLogFixtureChannel : null, provider: windows ? windowsEventLogFixtureProvider : null }; }); } export function queryLogsPlanJobs(plan: RecordValue): readonly QueryLogsPlanJob[] { // Reuse the same verified-object/immutable-byte gate as the PowerShell view. powerShellPlanJobs(plan); const verified = verifiedPowerShellPlans.get(plan)!; if (!verified.planBytes.length && ['jobs', 'payloads', 'resolved_targets'].some(alias => scriptPayloads(plan[alias]).some(isQueryLogs))) throw new Error('Logplan benötigt exakte gespeicherte Planbytes'); return verified.logJobs.map(job => ({ ...job })); } export function queryLogsApprovalBlockers(plan: RecordValue): string[] { try { queryLogsPlanJobs(plan); return []; } catch (error) { return [error instanceof Error ? error.message : 'Logplan ist nicht verifiziert']; } } export async function verifyWindowsMsiManifest(value: unknown): Promise { 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(); 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 | 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 { 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(), jobs = new Set(), assets = new Set(); for (const value of parsed.jobs) { const j = record(value); exact(j, ['payload', 'job_payload_hash', 'script_sha256']); const p = record(j.payload); exact(p, ['schema_version', 'tenant_id', 'asset_id', 'agent_id', 'enrollment_generation', 'assignment_version', 'job_id', 'attempt_id', 'action', 'execution_identity', 'not_before', 'start_before', 'max_runtime_seconds', 'max_output_bytes']); const asset = msiUuid(p.asset_id), tuple = `${msiUuid(p.job_id)}/${msiUuid(p.attempt_id)}`; msiUuid(p.agent_id); if (p.schema_version !== 1 || p.tenant_id !== parsed.tenant_id || p.execution_identity !== 'system' || j.script_sha256 !== null || jobs.has(tuple) || assets.has(asset) || !Number.isSafeInteger(p.enrollment_generation) || Number(p.enrollment_generation) < 1 || !Number.isSafeInteger(p.assignment_version) || Number(p.assignment_version) < 1 || typeof p.not_before !== 'string' || typeof p.start_before !== 'string' || !Number.isFinite(Date.parse(p.not_before)) || !Number.isFinite(Date.parse(p.start_before)) || Date.parse(p.not_before) >= Date.parse(p.start_before)) throw new Error('MSI-Jobidentität/Frist/Generation widerspricht festem Plan'); jobs.add(tuple); assets.add(asset); validateWindowsMsiLimits(p.max_runtime_seconds, p.max_output_bytes); const action = windowsMsiAction(record(p.action)), m = await verifyWindowsMsiManifest(action.windows_msi_manifest), r = m.recipe; // JobPayload declaration order and nested Action/Recipe order are fixed. const ordered = { schema_version: p.schema_version, tenant_id: p.tenant_id, asset_id: p.asset_id, agent_id: p.agent_id, enrollment_generation: p.enrollment_generation, assignment_version: p.assignment_version, job_id: p.job_id, attempt_id: p.attempt_id, action, execution_identity: p.execution_identity, not_before: p.not_before, start_before: p.start_before, max_runtime_seconds: p.max_runtime_seconds, max_output_bytes: p.max_output_bytes }; if (await sha256(new TextEncoder().encode(JSON.stringify(ordered))) !== j.job_payload_hash) throw new Error('MSI-Jobhash widerspricht festen Rust-Payloadbytes'); const recipe = { package: windowsMsi.package, version: r.postcondition.product_version, architecture: 'x64', recipe_version: r.recipe_version, sha256: m.recipe_sha256 }; recipes.set(JSON.stringify(recipe), recipe); const refs = parsed.artifact_references.map(value => record(value)).filter(ref => ref.job_id === p.job_id && ref.attempt_id === p.attempt_id); const expectedArtifact = { artifact_id: r.artifact.artifact_id, sha256: r.artifact.sha256, size_bytes: r.artifact.bytes }; if (refs.length !== 1) throw new Error('MSI benötigt genau eine Artefaktreferenz pro Job/Versuch'); exact(refs[0]!, ['job_id', 'attempt_id', 'artifact']); exact(record(refs[0]!.artifact), ['artifact_id', 'sha256', 'size_bytes']); if (canonical(refs[0]!.artifact) !== canonical(expectedArtifact)) throw new Error('MSI-Artefaktreferenz widerspricht signiertem Rezept'); projections.push({ assetId: asset, recipeId: r.recipe_id, recipeHash: m.recipe_sha256, artifactId: r.artifact.artifact_id, artifactHash: r.artifact.sha256, artifactBytes: r.artifact.bytes, productCode: r.postcondition.product_code, upgradeCode: r.upgrade_code, packageCode: r.package_code ?? null, version: r.postcondition.product_version, payloadPath: r.postcondition.payload_path, payloadHash: r.postcondition.payload_sha256, payloadBytes: r.postcondition.payload_bytes, predecessor: r.predecessor ?? null, runtimeSeconds: Number(p.max_runtime_seconds), outputBytes: Number(p.max_output_bytes), arguments: msiArguments(r.artifact.sha256) }); } const expectedRecipes = [...recipes.values()].sort((a, b) => { for (const key of ['package', 'version', 'architecture', 'recipe_version', 'sha256']) { if (String(a[key]) < String(b[key])) return -1; if (String(a[key]) > String(b[key])) return 1; } return 0; }); for (const value of parsed.recipe_references) exact(record(value), ['package', 'version', 'architecture', 'recipe_version', 'sha256']); if (parsed.artifact_references.length !== payloads.length || canonical(parsed.recipe_references) !== canonical(expectedRecipes)) throw new Error('Vollständige exakte MSI-Rezept-/Artefaktmenge widerspricht gespeichertem Plan'); return projections; } export function windowsMsiPlanJobs(plan: RecordValue): readonly WindowsMsiPlanJob[] { powerShellPlanJobs(plan); if (!verifiedPowerShellPlans.get(plan)!.planBytes.length && hasMsiView(plan)) throw new Error('MSI-Plan benötigt exakte gespeicherte Planbytes'); return structuredClone(verifiedPowerShellPlans.get(plan)!.msiJobs); } export function windowsMsiApprovalBlockers(plan: RecordValue): string[] { try { windowsMsiPlanJobs(plan); return []; } catch (error) { return [error instanceof Error ? error.message : 'MSI-Plan ist nicht verifiziert']; } } export async function verifyPlanIntegrity(plan: RecordValue) { // Rechecking a previously displayed object may not bless a replacement plan. if (verifiedPowerShellPlans.has(plan)) { powerShellPlanJobs(plan); windowsMsiPlanJobs(plan); } verifiedPowerShellPlans.delete(plan); const views = planTargetPreviews(plan), hasScriptView = scriptPayloads(views).some(hasPowerShellProfile) || scriptPayloads(plan.jobs).some(hasPowerShellProfile) || scriptPayloads(plan.payloads).some(hasPowerShellProfile) || scriptPayloads(plan.resolved_targets).some(hasPowerShellProfile) || scriptPayloads(record(plan.plan_payload ?? {}).jobs).some(hasPowerShellProfile) || scriptPayloads(record(plan.payload ?? {}).jobs).some(hasPowerShellProfile); if (hasScriptView && plan.plan_payload_bytes === undefined) throw new Error('PowerShell-Plan benötigt exakte gespeicherte Planbytes'); const hasLogView = ['jobs', 'payloads', 'resolved_targets'].some(alias => scriptPayloads(plan[alias]).some(isQueryLogs)) || scriptPayloads(record(plan.plan_payload ?? {}).jobs).some(isQueryLogs) || scriptPayloads(record(plan.payload ?? {}).jobs).some(isQueryLogs); if (hasLogView && plan.plan_payload_bytes === undefined) throw new Error('Logplan benötigt exakte gespeicherte Planbytes'); if (hasMsiView(plan) && plan.plan_payload_bytes === undefined) throw new Error('MSI-Plan benötigt exakte gespeicherte Planbytes'); let logJobs: QueryLogsPlanJob[] = []; let powerShellJobs: PowerShellPlanJob[] = []; let msiJobs: WindowsMsiPlanJob[] = [], systemJobs: RecordValue[] = []; let verifiedBytes: readonly number[] = []; let verifiedParsed: RecordValue | null = null; const verifiedHash = plan.plan_hash; if (plan.plan_payload_bytes === undefined && Array.isArray(plan.jobs) && plan.jobs.some(value => { const payload = record(value).payload; return payload !== null && typeof payload === 'object' && record(payload).execution_identity === 'system'; })) throw new Error('SYSTEM-Plan benötigt exakte gespeicherte Planbytes'); if (plan.plan_payload_bytes !== undefined) { const exactBytes = bytes(plan.plan_payload_bytes); hash(plan.plan_hash); if (await sha256(exactBytes) !== plan.plan_hash) throw new Error('Planhash stimmt nicht mit gespeicherten Bytes überein'); verifiedBytes = Array.from(exactBytes); const parsed = parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(exactBytes)); validatePlanAliases(plan, parsed); const parsedPlan = record(parsed), rawJobs = parsedPlan.jobs; verifiedParsed = parsedPlan; powerShellJobs = projectPowerShellJobs(rawJobs); logJobs = projectQueryLogsJobs(rawJobs); if (hasLogView || logJobs.length) validateQueryLogsViews(plan, rawJobs); if (hasScriptView || powerShellJobs.length) { if (!Array.isArray(rawJobs)) throw new Error('Vollständige feste PowerShell-Zielpayloads fehlen'); validatePowerShellViews(plan, rawJobs); } msiJobs = await projectMsiJobs(parsedPlan); validateMsiViews(plan, rawJobs); systemJobs = scriptPayloads(rawJobs).filter(payload => payload.execution_identity === 'system'); } for (const payload of systemJobs) { const action = record(payload.action); if (action.action === 'reboot') { exact(action, ['action', 'reason', 'dependency_group', 'reconnect_timeout_seconds']); validateWindowsReboot(action.reason, action.dependency_group, action.reconnect_timeout_seconds, payload.max_runtime_seconds, payload.max_output_bytes); continue; } if (action.action === 'update_agent') { validateAgentUpdateAction(action, payload.execution_identity); if (payload.max_runtime_seconds !== 600 || typeof payload.max_output_bytes !== 'number' || !Number.isSafeInteger(payload.max_output_bytes) || payload.max_output_bytes < 1 || payload.max_output_bytes > 65536) throw new Error('SYSTEM-Agentupdate benötigt festes600s/64KiB-Budget'); continue; } if (isMsi(payload)) continue; // Fully validated, hash-bound package projection above. if (action.action === 'run_script') { validateScriptIdentityProfile(action, payload.execution_identity, action.interpreter); if (privilegedScriptProfile(action, payload.execution_identity) !== fullMaintenanceScriptProfile || action.interpreter !== 'powershell' || !Number.isInteger(payload.max_runtime_seconds) || Number(payload.max_runtime_seconds) < 1 || Number(payload.max_runtime_seconds) > 120 || !Number.isInteger(payload.max_output_bytes) || Number(payload.max_output_bytes) < 1 || Number(payload.max_output_bytes) > 65536) throw new Error('SYSTEM-Skript benötigt explizites Vollwartungsprofil und feste Budgets'); continue; } 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); } const jobs = Array.isArray(plan.jobs) ? plan.jobs : Array.isArray(plan.resolved_targets) ? plan.resolved_targets : []; for (const value of jobs) { if (!value || typeof value !== 'object') continue; const p = record(value).payload; if (!p || typeof p !== 'object') continue; const action = record(p).action; if (action && typeof action === 'object' && record(action).apt_manifest !== undefined && record(action).apt_manifest !== null) await verifyAptManifest(record(action).apt_manifest, record(action).action === 'apt_native_acceptance'); } // No await after this check: asynchronous hash verification cannot publish a // projection for bytes/views that changed while WebCrypto was running. if (verifiedParsed) { const current = bytes(plan.plan_payload_bytes); if (plan.plan_hash !== verifiedHash || current.length !== verifiedBytes.length || current.some((n, i) => n !== verifiedBytes[i])) throw new Error('Planbytes wurden während der Verifikation verändert'); validatePlanAliases(plan, verifiedParsed); validateMsiViews(plan, verifiedParsed.jobs); validatePowerShellViews(plan, verifiedParsed.jobs); validateQueryLogsViews(plan, verifiedParsed.jobs); } verifiedPowerShellPlans.set(plan, { jobs: powerShellJobs.map(job => Object.freeze({ ...job })), logJobs: logJobs.map(job => Object.freeze({ ...job })), msiJobs: structuredClone(msiJobs), systemJobs: structuredClone(systemJobs), planHash: verifiedHash, planBytes: verifiedBytes }); } export function recipeInput(value: unknown): RecordValue { const r = record(value); exact(r, ['schema_version', 'provider', 'package', 'version', 'architecture', 'recipe_version', 'installation_context', 'reboot_policy']); if (r.schema_version !== 1 || r.provider !== 'apt' || r.architecture !== 'amd64' || r.installation_context !== 'system' || r.reboot_policy !== 'never') throw new Error('Nur unveränderliches APT/amd64/system/never-Rezept unterstützt'); for (const k of ['package', 'version', 'recipe_version']) { const v = text(r[k], k); if (!/^[A-Za-z0-9_.:+~-]+$/.test(v) || v.startsWith('-')) throw new Error('Exakte Paket-/Rezeptidentität erforderlich; keine URL/Installerargumente'); } return { schema_version: 1, provider: r.provider, package: r.package, version: r.version, architecture: r.architecture, recipe_version: r.recipe_version, installation_context: r.installation_context, reboot_policy: r.reboot_policy }; } export function adminIntent(confirmed: boolean, reason: string, nonce: string, expected: string): { reason: string } { if (!confirmed || !reason.trim() || new TextEncoder().encode(reason).length > 1024 || nonce !== expected || !expected) throw new Error('Explizite Bestätigung, aktuelle Bestätigungskennung und Grund erforderlich'); return { reason }; }