Rust development slice / linux (push) Failing after 7s
Bind the administrative connection-205 review to original signed history and preserve closed readiness. Include the qualified server dependency closure, UI review, native ARM64 build provenance, and guarded deployment evidence. Migration, API/gateway replacement and TLS checks passed with unchanged job authority, protected mounts and time/database services; native Windows receipt application remains separate.
412 lines
42 KiB
TypeScript
412 lines
42 KiB
TypeScript
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<string>(); 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<ArrayBuffer> { 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<ArrayBuffer>): Promise<string> { 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<string>();
|
|
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<RecordValue, VerifiedPowerShellPlan>();
|
|
export function powerShellPlanJobs(plan: RecordValue): readonly PowerShellPlanJob[] {
|
|
const verified = verifiedPowerShellPlans.get(plan);
|
|
if (!verified) throw new Error('PowerShell-Plan wurde nicht aus hashgeprüften gespeicherten Bytes verifiziert');
|
|
if (verified.planBytes.length) {
|
|
const current = bytes(plan.plan_payload_bytes);
|
|
if (plan.plan_hash !== verified.planHash || current.length !== verified.planBytes.length || verified.planBytes.some((value, i) => current[i] !== value)) throw new Error('PowerShell-Planbytes wurden nach Verifikation verändert');
|
|
const parsed = record(parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(current)));
|
|
validatePlanAliases(plan, parsed);
|
|
validatePowerShellViews(plan, parsed.jobs);
|
|
validateQueryLogsViews(plan, parsed.jobs);
|
|
validateMsiViews(plan, parsed.jobs);
|
|
} else if (scriptPayloads(planTargetPreviews(plan)).some(hasPowerShellProfile)) {
|
|
throw new Error('PowerShell-Plan benötigt exakte gespeicherte Planbytes');
|
|
}
|
|
return verified.jobs.map(job => ({ ...job }));
|
|
}
|
|
export function powerShellApprovalBlockers(plan: RecordValue): string[] {
|
|
try { powerShellPlanJobs(plan); return []; }
|
|
catch (error) { return [error instanceof Error ? error.message : 'PowerShell-Profil ist nicht verifiziert']; }
|
|
}
|
|
function scriptPayloads(jobs: unknown): RecordValue[] {
|
|
if (!Array.isArray(jobs)) return [];
|
|
return jobs.flatMap(job => {
|
|
if (!job || typeof job !== 'object') return [];
|
|
const payload = record(job).payload;
|
|
return payload && typeof payload === 'object' ? [record(payload)] : [];
|
|
});
|
|
}
|
|
function hasPowerShellProfile(payload: RecordValue): boolean {
|
|
if (Object.prototype.hasOwnProperty.call(payload, 'windows_execution_profile')) throw new Error('Windows-Ausführungsprofil muss Teil der festen Skriptaktion sein');
|
|
const action = payload.action;
|
|
return action !== null && typeof action === 'object' && (record(action).interpreter === 'powershell'
|
|
|| Object.prototype.hasOwnProperty.call(action, 'windows_execution_profile'));
|
|
}
|
|
function projectPowerShellJobs(jobs: unknown): PowerShellPlanJob[] {
|
|
return scriptPayloads(jobs).filter(hasPowerShellProfile).map(payload => {
|
|
const action = record(payload.action);
|
|
if (action.action !== 'run_script' || action.interpreter !== 'powershell') 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<WindowsMsiManifest> {
|
|
const m = windowsMsiManifest(value);
|
|
if (await sha256(new TextEncoder().encode(JSON.stringify(m.recipe))) !== m.recipe_sha256) throw new Error('MSI-Rezepthash widerspricht kanonischen Rust-Rezeptbytes');
|
|
return m;
|
|
}
|
|
function isMsi(payload: RecordValue): boolean {
|
|
const action = payload.action;
|
|
return action !== null && typeof action === 'object' && (record(action).provider === 'msi' || Object.prototype.hasOwnProperty.call(action, 'windows_msi_manifest'));
|
|
}
|
|
function hasMsiView(plan: RecordValue): boolean {
|
|
return ['jobs', 'payloads', 'resolved_targets'].some(alias => scriptPayloads(plan[alias]).some(isMsi))
|
|
|| scriptPayloads(record(plan.plan_payload ?? {}).jobs).some(isMsi) || scriptPayloads(record(plan.payload ?? {}).jobs).some(isMsi);
|
|
}
|
|
/** MSI views bind the entire payload, preview identity and hash, not just argv. */
|
|
function validateMsiViews(plan: RecordValue, rawJobs: unknown): void {
|
|
const originals = Array.isArray(rawJobs) ? rawJobs.map(job => record(job)) : [];
|
|
const raw = scriptPayloads(rawJobs);
|
|
for (const alias of ['jobs', 'payloads', 'resolved_targets']) {
|
|
const values = plan[alias]; if (values === undefined) continue;
|
|
if (!Array.isArray(values)) { if (raw.some(isMsi)) throw new Error('MSI-Zielansicht ist keine vollständige Liste'); continue; }
|
|
if (!raw.some(isMsi) && !scriptPayloads(values).some(isMsi)) continue;
|
|
if (values.length !== raw.length) throw new Error('MSI-Zielansicht ist unvollständig oder enthält zusätzliche Ziele');
|
|
const seen = new Set<string>();
|
|
for (const value of values) {
|
|
const v = typeof value === 'string' ? { asset_id: value } : record(value);
|
|
const payload = v.payload === undefined ? null : record(v.payload);
|
|
const asset = text(v.asset_id ?? payload?.asset_id, 'MSI-Zielasset'), index = raw.findIndex(item => item.asset_id === asset);
|
|
if (index < 0 || seen.has(asset)) throw new Error('MSI-Zielansicht enthält fremde/doppelte Ziele'); seen.add(asset);
|
|
const fixed = raw[index]!, original = originals[index]!;
|
|
if (!isMsi(fixed)) throw new Error('MSI-Ansicht widerspricht gespeichertem Aktionstyp');
|
|
if (payload) {
|
|
const allowed = ['payload', 'job_payload_hash', 'script_sha256', 'asset_id', 'agent_id', 'job_id', 'attempt_id'];
|
|
if (Object.keys(v).some(key => !allowed.includes(key)) || canonical(payload) !== canonical(fixed) || v.job_payload_hash !== original.job_payload_hash || (v.script_sha256 !== undefined && v.script_sha256 !== original.script_sha256)
|
|
|| ['agent_id', 'job_id', 'attempt_id'].some(key => v[key] !== undefined && v[key] !== fixed[key])) throw new Error('MSI-Zielpreview widerspricht gespeicherten Planbytes');
|
|
} else if (alias !== 'resolved_targets' || (typeof value !== 'string' && (Object.keys(v).some(key => !['asset_id', 'agent_id'].includes(key)) || v.agent_id !== fixed.agent_id))) throw new Error('Vollständiger MSI-Zielpayload fehlt');
|
|
}
|
|
}
|
|
}
|
|
export interface WindowsMsiPlanJob {
|
|
readonly assetId: string; readonly recipeId: string; readonly recipeHash: string;
|
|
readonly artifactId: string; readonly artifactHash: string; readonly artifactBytes: number;
|
|
readonly productCode: string; readonly upgradeCode: string; readonly packageCode: string | null; readonly version: string;
|
|
readonly payloadPath: string; readonly payloadHash: string; readonly payloadBytes: number;
|
|
readonly predecessor: Readonly<MsiPostcondition> | null; readonly runtimeSeconds: number; readonly outputBytes: number; readonly arguments: readonly string[];
|
|
}
|
|
function msiArguments(sha: string): string[] { return ['/i', `C:\\ProgramData\\RustDiscoverySystem\\cache\\${sha}.msi`, '/qn', '/norestart', 'REBOOT=ReallySuppress', 'ALLUSERS=1']; }
|
|
async function projectMsiJobs(parsed: RecordValue): Promise<WindowsMsiPlanJob[]> {
|
|
const payloads = scriptPayloads(parsed.jobs); if (!payloads.some(isMsi)) return [];
|
|
exact(parsed, ['schema_version', 'plan_id', 'tenant_id', 'principal', 'reason', 'jobs', 'max_parallel', 'halt_after_failures', 'recipe_references', 'artifact_references']);
|
|
if (parsed.schema_version !== 1 || !Array.isArray(parsed.jobs) || !parsed.jobs.length || parsed.jobs.length > 100 || payloads.length !== parsed.jobs.length || payloads.some(p => !isMsi(p)) || !Array.isArray(parsed.recipe_references) || !Array.isArray(parsed.artifact_references)) throw new Error('Vollständiger fester MSI-Plan erforderlich');
|
|
msiUuid(parsed.plan_id); msiUuid(parsed.tenant_id); text(parsed.principal, 'MSI-Antragsteller'); text(parsed.reason, 'MSI-Grund');
|
|
if (!Number.isSafeInteger(parsed.max_parallel) || Number(parsed.max_parallel) < 1 || Number(parsed.max_parallel) > 10 || !Number.isSafeInteger(parsed.halt_after_failures) || Number(parsed.halt_after_failures) < 1) throw new Error('MSI-Rolloutlimits fehlen');
|
|
const projections: WindowsMsiPlanJob[] = [], recipes = new Map<string, RecordValue>(), jobs = new Set<string>(), assets = new Set<string>();
|
|
for (const value of parsed.jobs) {
|
|
const j = record(value); exact(j, ['payload', 'job_payload_hash', 'script_sha256']);
|
|
const p = record(j.payload); exact(p, ['schema_version', 'tenant_id', 'asset_id', 'agent_id', 'enrollment_generation', 'assignment_version', 'job_id', 'attempt_id', 'action', 'execution_identity', 'not_before', 'start_before', 'max_runtime_seconds', 'max_output_bytes']);
|
|
const asset = msiUuid(p.asset_id), tuple = `${msiUuid(p.job_id)}/${msiUuid(p.attempt_id)}`; msiUuid(p.agent_id);
|
|
if (p.schema_version !== 1 || p.tenant_id !== parsed.tenant_id || p.execution_identity !== 'system' || j.script_sha256 !== null || jobs.has(tuple) || assets.has(asset)
|
|
|| !Number.isSafeInteger(p.enrollment_generation) || Number(p.enrollment_generation) < 1 || !Number.isSafeInteger(p.assignment_version) || Number(p.assignment_version) < 1
|
|
|| typeof p.not_before !== 'string' || typeof p.start_before !== 'string' || !Number.isFinite(Date.parse(p.not_before)) || !Number.isFinite(Date.parse(p.start_before)) || Date.parse(p.not_before) >= Date.parse(p.start_before)) throw new Error('MSI-Jobidentität/Frist/Generation widerspricht festem Plan');
|
|
jobs.add(tuple); assets.add(asset); validateWindowsMsiLimits(p.max_runtime_seconds, p.max_output_bytes);
|
|
const action = windowsMsiAction(record(p.action)), m = await verifyWindowsMsiManifest(action.windows_msi_manifest), r = m.recipe;
|
|
// JobPayload declaration order and nested Action/Recipe order are fixed.
|
|
const ordered = { schema_version: p.schema_version, tenant_id: p.tenant_id, asset_id: p.asset_id, agent_id: p.agent_id, enrollment_generation: p.enrollment_generation, assignment_version: p.assignment_version, job_id: p.job_id, attempt_id: p.attempt_id, action, execution_identity: p.execution_identity, not_before: p.not_before, start_before: p.start_before, max_runtime_seconds: p.max_runtime_seconds, max_output_bytes: p.max_output_bytes };
|
|
if (await sha256(new TextEncoder().encode(JSON.stringify(ordered))) !== j.job_payload_hash) throw new Error('MSI-Jobhash widerspricht festen Rust-Payloadbytes');
|
|
const recipe = { package: windowsMsi.package, version: r.postcondition.product_version, architecture: 'x64', recipe_version: r.recipe_version, sha256: m.recipe_sha256 };
|
|
recipes.set(JSON.stringify(recipe), recipe);
|
|
const refs = parsed.artifact_references.map(value => record(value)).filter(ref => ref.job_id === p.job_id && ref.attempt_id === p.attempt_id);
|
|
const expectedArtifact = { artifact_id: r.artifact.artifact_id, sha256: r.artifact.sha256, size_bytes: r.artifact.bytes };
|
|
if (refs.length !== 1) throw new Error('MSI benötigt genau eine Artefaktreferenz pro Job/Versuch');
|
|
exact(refs[0]!, ['job_id', 'attempt_id', 'artifact']); exact(record(refs[0]!.artifact), ['artifact_id', 'sha256', 'size_bytes']);
|
|
if (canonical(refs[0]!.artifact) !== canonical(expectedArtifact)) throw new Error('MSI-Artefaktreferenz widerspricht signiertem Rezept');
|
|
projections.push({ assetId: asset, recipeId: r.recipe_id, recipeHash: m.recipe_sha256, artifactId: r.artifact.artifact_id, artifactHash: r.artifact.sha256, artifactBytes: r.artifact.bytes, productCode: r.postcondition.product_code, upgradeCode: r.upgrade_code, packageCode: r.package_code ?? null, version: r.postcondition.product_version, payloadPath: r.postcondition.payload_path, payloadHash: r.postcondition.payload_sha256, payloadBytes: r.postcondition.payload_bytes, predecessor: r.predecessor ?? null, runtimeSeconds: Number(p.max_runtime_seconds), outputBytes: Number(p.max_output_bytes), arguments: msiArguments(r.artifact.sha256) });
|
|
}
|
|
const expectedRecipes = [...recipes.values()].sort((a, b) => { for (const key of ['package', 'version', 'architecture', 'recipe_version', 'sha256']) { if (String(a[key]) < String(b[key])) return -1; if (String(a[key]) > String(b[key])) return 1; } return 0; });
|
|
for (const value of parsed.recipe_references) exact(record(value), ['package', 'version', 'architecture', 'recipe_version', 'sha256']);
|
|
if (parsed.artifact_references.length !== payloads.length || canonical(parsed.recipe_references) !== canonical(expectedRecipes)) throw new Error('Vollständige exakte MSI-Rezept-/Artefaktmenge widerspricht gespeichertem Plan');
|
|
return projections;
|
|
}
|
|
export function windowsMsiPlanJobs(plan: RecordValue): readonly WindowsMsiPlanJob[] {
|
|
powerShellPlanJobs(plan);
|
|
if (!verifiedPowerShellPlans.get(plan)!.planBytes.length && hasMsiView(plan)) throw new Error('MSI-Plan benötigt exakte gespeicherte Planbytes');
|
|
return structuredClone(verifiedPowerShellPlans.get(plan)!.msiJobs);
|
|
}
|
|
export function windowsMsiApprovalBlockers(plan: RecordValue): string[] { try { windowsMsiPlanJobs(plan); return []; } catch (error) { return [error instanceof Error ? error.message : 'MSI-Plan ist nicht verifiziert']; } }
|
|
|
|
export async function verifyPlanIntegrity(plan: RecordValue) {
|
|
// Rechecking a previously displayed object may not bless a replacement plan.
|
|
if (verifiedPowerShellPlans.has(plan)) { powerShellPlanJobs(plan); windowsMsiPlanJobs(plan); }
|
|
verifiedPowerShellPlans.delete(plan);
|
|
const views = planTargetPreviews(plan), hasScriptView = scriptPayloads(views).some(hasPowerShellProfile)
|
|
|| scriptPayloads(plan.jobs).some(hasPowerShellProfile) || scriptPayloads(plan.payloads).some(hasPowerShellProfile)
|
|
|| scriptPayloads(plan.resolved_targets).some(hasPowerShellProfile)
|
|
|| scriptPayloads(record(plan.plan_payload ?? {}).jobs).some(hasPowerShellProfile)
|
|
|| scriptPayloads(record(plan.payload ?? {}).jobs).some(hasPowerShellProfile);
|
|
if (hasScriptView && plan.plan_payload_bytes === undefined) throw new Error('PowerShell-Plan benötigt exakte gespeicherte Planbytes');
|
|
const hasLogView = ['jobs', 'payloads', 'resolved_targets'].some(alias => scriptPayloads(plan[alias]).some(isQueryLogs))
|
|
|| scriptPayloads(record(plan.plan_payload ?? {}).jobs).some(isQueryLogs) || scriptPayloads(record(plan.payload ?? {}).jobs).some(isQueryLogs);
|
|
if (hasLogView && plan.plan_payload_bytes === undefined) throw new Error('Logplan benötigt exakte gespeicherte Planbytes');
|
|
if (hasMsiView(plan) && plan.plan_payload_bytes === undefined) throw new Error('MSI-Plan benötigt exakte gespeicherte Planbytes');
|
|
let logJobs: QueryLogsPlanJob[] = [];
|
|
let powerShellJobs: PowerShellPlanJob[] = [];
|
|
let msiJobs: WindowsMsiPlanJob[] = [], systemJobs: RecordValue[] = [];
|
|
let verifiedBytes: readonly number[] = [];
|
|
let verifiedParsed: RecordValue | null = null;
|
|
const verifiedHash = plan.plan_hash;
|
|
if (plan.plan_payload_bytes === undefined && Array.isArray(plan.jobs) && plan.jobs.some(value => {
|
|
const payload = record(value).payload;
|
|
return payload !== null && typeof payload === 'object' && record(payload).execution_identity === 'system';
|
|
})) 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 };
|
|
}
|