Bind typed SYSTEM service plans and qualify Domain contract on cloud Linux
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -65,6 +65,20 @@ describe('JSON contract boundary', () => {
|
||||
expect(() => validateInput({ ...input, parameters: { ...input.parameters, execution_identity: 'root' } })).toThrow('agent_service');
|
||||
validateInput({ ...input, parameters: { ...input.parameters, variants: [{ ...windows, script_utf8: "\ufeffWrite-Output 'é'\r\n" }] } });
|
||||
});
|
||||
it('allows SYSTEM only for exact bounded fixture SCM parameters without changing Linux restart', () => {
|
||||
const input: PlanInput = { tenant_id: 't', action: 'set_service_state', targets: { asset_ids: ['asset'] }, parameters: { execution_identity: 'system', unit: 'RmmDiscoveryFixtureService', state: 'running', timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: new Date().toISOString(), start_before: new Date(Date.now() + 60000).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'fixed SCM plan' };
|
||||
const before = JSON.stringify(input); validateInput(input); expect(JSON.stringify(input)).toBe(before);
|
||||
validateInput({ ...input, parameters: { ...input.parameters, state: 'stopped' } });
|
||||
for (const parameters of [
|
||||
{ ...input.parameters, unit: 'Spooler' }, { ...input.parameters, unit: 'RmmDiscoveryFixture*' },
|
||||
{ ...input.parameters, state: 'restarted' }, { ...input.parameters, timeout_seconds: 121 },
|
||||
{ ...input.parameters, max_output_bytes: 65537 }, { ...input.parameters, script_utf8: 'whoami' },
|
||||
{ ...input.parameters, execution_identity: 'SYSTEM' },
|
||||
]) expect(() => validateInput({ ...input, parameters })).toThrow();
|
||||
expect(() => validateInput({ ...input, action: 'refresh_inventory' })).toThrow('SYSTEM');
|
||||
expect(() => validateInput({ ...input, action: 'run_script', parameters: { ...input.parameters, variants: [{ os_family: 'windows', interpreter: 'powershell', encoding: 'utf-8', script_utf8: 'whoami' }] } })).toThrow('agent_service');
|
||||
validateInput({ ...input, parameters: { ...input.parameters, execution_identity: 'root', unit: 'rmm-mvp-test.service', state: 'restarted', timeout_seconds: 180 } });
|
||||
});
|
||||
it('accepts explicit existing dev simulation evidence but not a principal-name guess', () => {
|
||||
expect(session({ principal: 'sim-test', tenant_id: 't', testsimulation: true, csrf_token: 'csrf' }).principal.simulated).toBe(true);
|
||||
expect(() => session({ principal: 'sim-test', tenant_id: 't', csrf_token: 'csrf' })).toThrow();
|
||||
|
||||
+11
-1
@@ -85,7 +85,12 @@ export function validateInput(input: PlanInput): void {
|
||||
}) || new Set(variants.map(v => record(v).os_family)).size !== variants.length) throw new Error('Je Plattform genau eine passende UTF-8 Variante (max.32KiB); PowerShell5.1: ASCII oder explizites UTF-8-BOM vor Hashbildung');
|
||||
if (variants.some(v => record(v).os_family === 'windows') && input.parameters.execution_identity !== 'agent_service') throw new Error('Windows PowerShell benötigt agent_service; kein SYSTEM-/Root-Fallback');
|
||||
}
|
||||
if (!['agent_service', 'root'].includes(String(input.parameters.execution_identity))) throw new Error('Explizite Ausführungsidentität erforderlich');
|
||||
if (!['agent_service', 'root', 'system'].includes(String(input.parameters.execution_identity))) throw new Error('Explizite Ausführungsidentität erforderlich');
|
||||
if (input.parameters.execution_identity === 'system') {
|
||||
if (input.action !== 'set_service_state') throw new Error('SYSTEM ausschließlich für typisierte eigene Windows-Fixturedienste; keine SYSTEM-Shell');
|
||||
validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
|
||||
if (Object.keys(input.parameters).some(k => !['execution_identity', 'unit', 'state', 'timeout_seconds', 'max_output_bytes'].includes(k))) throw new Error('SYSTEM-Dienstauftrag enthält fremde Parameter');
|
||||
}
|
||||
const required = (key: string) => text(input.parameters[key], `parameters.${key}`);
|
||||
if (input.action === 'refresh_inventory') required('scope');
|
||||
if (input.action === 'query_logs') { required('unit'); const since = Date.parse(required('since')), until = Date.parse(required('until')); if (!Number.isFinite(since) || !Number.isFinite(until) || until <= since) throw new Error('Exaktes Log-Zeitfenster erforderlich'); if (typeof input.parameters.max_lines !== 'number' || !Number.isSafeInteger(input.parameters.max_lines) || input.parameters.max_lines < 1 || input.parameters.max_lines > 1000) throw new Error('Loglimit muss 1–1000 sein'); }
|
||||
@@ -94,6 +99,11 @@ export function validateInput(input: PlanInput): void {
|
||||
if (input.action === 'apply_updates') { required('provider'); if (!Array.isArray(input.parameters.packages) || !input.parameters.packages.length || !input.parameters.packages.every(v => typeof v === 'string' && v.length > 0)) throw new Error('Feste Updatepakete erforderlich'); if (input.parameters.reboot_policy !== 'never') throw new Error('Kein impliziter Reboot; eigenen festen Plan erstellen'); }
|
||||
if (input.action === 'reboot') { required('reason'); required('dependency_group'); const n = input.parameters.reconnect_timeout_seconds; if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 60 || n > 3600) throw new Error('Reboot-Wiederanmeldefrist muss 60–3600 s sein'); }
|
||||
}
|
||||
export function validateSystemService(unit: unknown, state: unknown, runtime: unknown, output: unknown): void {
|
||||
if (typeof unit !== 'string' || !/^RmmDiscoveryFixture[A-Za-z0-9_-]+$/.test(unit) || unit.length > 80) throw new Error('Exakter eigener Windows-Fixturedienst erforderlich');
|
||||
if (state !== 'running' && state !== 'stopped') throw new Error('SYSTEM-Dienstzustand ausschließlich running oder stopped');
|
||||
if (typeof runtime !== 'number' || !Number.isSafeInteger(runtime) || runtime < 1 || runtime > 120 || typeof output !== 'number' || !Number.isSafeInteger(output) || output < 1 || output > 65536) throw new Error('SYSTEM-Dienstlimits maximal 120 s und 64 KiB');
|
||||
}
|
||||
/** These are immutable target definitions, never evidence of executable jobs. */
|
||||
export function planTargetPreviews(plan: RecordValue): unknown[] | null {
|
||||
if (Array.isArray(plan.resolved_targets) && plan.resolved_targets.some(value =>
|
||||
|
||||
@@ -25,3 +25,23 @@ it('renders hostile log content only as text, without executable nodes, approval
|
||||
vi.unstubAllGlobals();
|
||||
}
|
||||
});
|
||||
|
||||
it('shows fixed SYSTEM identity and service state from stored plan bytes without approving or issuing requests', async () => {
|
||||
const fetch = vi.fn(); vi.stubGlobal('fetch', fetch); vi.stubGlobal('document', { getElementById: () => ({}) });
|
||||
try {
|
||||
const { SystemPlanNotice } = await import('./main');
|
||||
const payload = { jobs: [{ payload: { execution_identity: 'system', asset_id: 'fixed-asset', action: { action: 'set_service_state', unit: 'RmmDiscoveryFixtureService', state: 'stopped' } } }] };
|
||||
const plan = { plan_payload_bytes: Array.from(new TextEncoder().encode(JSON.stringify(payload))), jobs: [{ payload: { execution_identity: 'root', action: { unit: 'untrusted-view' } } }] };
|
||||
const html = renderToStaticMarkup(<SystemPlanNotice plan={plan}/>);
|
||||
expect(html).toContain('SYSTEM'); expect(html).toContain('system:execute'); expect(html).toContain('Identität: system');
|
||||
for (const expected of ['fixed-asset', 'RmmDiscoveryFixtureService', 'Zielzustand: stopped', 'Keine SYSTEM-Shell']) expect(html).toContain(expected);
|
||||
expect(html).not.toContain('untrusted-view'); expect(html).not.toMatch(/<(button|input|form|pre)\b/);
|
||||
expect(renderToStaticMarkup(<SystemPlanNotice plan={{ plan_payload_bytes: Array.from(new TextEncoder().encode('{"jobs":[]}')) }}/>)).toBe('');
|
||||
for (const plan_payload_bytes of [[255], [123], 'invalid']) {
|
||||
const invalid = renderToStaticMarkup(<SystemPlanNotice plan={{ plan_payload_bytes }}/>);
|
||||
expect(invalid).toContain('role="alert"'); expect(invalid).toContain('nicht lesbar');
|
||||
expect(invalid).not.toMatch(/<(button|input|form)\b/);
|
||||
}
|
||||
expect(fetch).not.toHaveBeenCalled();
|
||||
} finally { vi.unstubAllGlobals(); }
|
||||
});
|
||||
|
||||
+11
-2
@@ -3,11 +3,18 @@ import { createRoot } from 'react-dom/client';
|
||||
import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, page, Page, PlanInput, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, validateInput } from './api';
|
||||
import './style.css';
|
||||
import { AdminControl, Catalog, TenantControls } from './management';
|
||||
import { allowed, availableActions, parseStrictJson, rootWarning, validateSensitiveInput, verifyPlanIntegrity } from './safety';
|
||||
import { allowed, availableActions, parseStrictJson, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity } from './safety';
|
||||
import { Login } from './login';
|
||||
|
||||
const errorText = (error: unknown) => error instanceof Error ? error.message : 'Unbekannter Fehler';
|
||||
export function JsonView({ value, label = 'Vollständige Daten' }: { value: unknown; label?: string }) { return <details open><summary>{label}</summary><pre>{pretty(value)}</pre></details>; }
|
||||
export function SystemPlanNotice({ plan }: { plan: RecordValue }) {
|
||||
let jobs: RecordValue[];
|
||||
try { jobs = systemPlanJobs(plan); }
|
||||
catch { return <aside role="alert" className="error">Gespeicherte Planbytes sind nicht lesbar. Keine verlässliche SYSTEM-Plananzeige; Genehmigungsverifikation muss erfolgreich sein.</aside>; }
|
||||
if (!jobs.length) return null;
|
||||
return <aside className="warning" aria-label="Feste SYSTEM-Dienstaktionen"><p>{systemWarning}</p><ul>{jobs.map((payload, i) => { const action = record(payload.action); return <li key={i}>Identität: system · Asset: {String(payload.asset_id)} · Dienst: {String(action.unit)} · Zielzustand: {String(action.state)}</li>; })}</ul><p>Diese Definitionen stammen aus den gespeicherten Planbytes; die vollständigen Zielpayloads und Hashes stehen darunter.</p></aside>;
|
||||
}
|
||||
function ErrorBox({ error }: { error: string | null }) { return error ? <div role="alert" className="error">{error}</div> : null; }
|
||||
function useResource<T>(load: (signal: AbortSignal) => Promise<T>, deps: React.DependencyList, poll = false) {
|
||||
const [data, setData] = useState<T | null>(null), [error, setError] = useState<string | null>(null), [revision, setRevision] = useState(0);
|
||||
@@ -51,8 +58,9 @@ function Planner({ tenantId, auth, selected, showPlan }: { tenantId: string; aut
|
||||
<label>Aktion<select aria-label="Aktion" value={action} onChange={e => { const next = availableActions(auth, actions).find(a => a === e.target.value); if (next) { setAction(next); setParameters(pretty(initialParameters[next])); } }}>{availableActions(auth, actions).map(a => <option key={a} value={a}>{a}</option>)}</select></label>
|
||||
{action === 'apt_native_acceptance' && <p className="warning">NUR SIMULIERTE DEV/TEST-NATIVABNAHME. In Vorbereitung; Backend/Helper/Scope müssen diese eigene Aktion unterstützen. Nur rmm-apt-fixture-install-1.0 oder rmm-apt-fixture-update-1.1, Rezeptversion 1, vollständiges Schema-2-Manifest. null/Platzhalter sind nicht konfiguriert, keine Produktionsaktion, keine automatische Ausführung.</p>}
|
||||
{action === 'run_script' ? <><label>Skriptplattform<select aria-label="Skriptplattform" value={scriptPlatform} onChange={e => setScriptPlatform(e.target.value)}><option value="linux">Linux</option><option value="windows">Windows</option><option value="mixed">Linux und Windows · feste Varianten</option></select></label>{scriptPlatform === 'mixed' ? <label>Exakte Plattformvarianten (JSON)<textarea aria-label="Skriptvarianten" value={mixedVariants} onChange={e => setMixedVariants(e.target.value)} rows={9} spellCheck={false}/></label> : <><label>Interpreter<select name="interpreter" key={scriptPlatform}>{scriptPlatform === 'windows' ? <option value="powershell">powershell · Windows PowerShell 5.1</option> : <><option value="posix_sh">posix_sh · /bin/sh</option><option value="bash">bash · nur mit gemeldeter Capability</option></>}</select></label><label>Exakte UTF-8 Skriptbytes (keine automatische Ergänzung)<textarea name="script" required rows={7} spellCheck={false}/></label></>}<label>Format der stdout-Nachbedingung<select name="expected_format" aria-label="Format der stdout-Nachbedingung"><option value="text">Text · Linux-Default</option><option value="json">JSON-String · explizite CRLF mit \r\n</option></select></label><label>Erwartete stdout-Ausgabe (exakte Rohbytes als UTF-8, optional)<textarea name="expected" rows={2} spellCheck={false}/></label>{scriptPlatform !== 'linux' && <p>PowerShell5.1: -NoLogo -NoProfile -NonInteractive; keine ExecutionPolicy-Umgehung. Nicht-ASCII benötigt ein ausdrücklich enthaltenes UTF-8-BOM vor Hashbildung. Skriptbytes und Ausgabe werden nicht normalisiert. Fehlende Plattform-/Interpreter-/Sync-Capability sperrt den ganzen Plan; kein stiller Zielausschluss.</p>}</> : <label>Typisierte Aktionsparameter (JSON; leere Pflichtwerte ergänzen)<textarea aria-label="Aktionsparameter" value={parameters} onChange={e => setParameters(e.target.value)} rows={9} spellCheck={false}/></label>}
|
||||
<div className="grid"><label>Ausführungsidentität<select aria-label="Ausführungsidentität" name="identity" value={identity} onChange={e => setIdentity(e.target.value)}><option value="agent_service">agent_service</option><option value="root" disabled={!allowed(auth, 'root:execute')}>root · root:execute und unabhängiger Helper erforderlich</option></select></label><label>Laufzeitlimit (s)<input name="timeout" type="number" min="1" max="86400" defaultValue="60" required/></label><label>Ausgabelimit (Bytes)<input name="output" type="number" min="1" max="524288" defaultValue="65536" required/></label><label>Frühester Start (lokale Zeit)<input name="not_before" type="datetime-local" defaultValue={localDate(new Date())} required/></label><label>Startfrist / Ablauf (lokale Zeit)<input name="expires" type="datetime-local" defaultValue={localDate(new Date(Date.now() + 86400000))} required/></label><label>Maximal parallel<input name="parallel" type="number" min="1" defaultValue="1" required/></label><label>Stopp nach Fehlern<input name="failures" type="number" min="1" defaultValue="1" required/></label></div>
|
||||
<div className="grid"><label>Ausführungsidentität<select aria-label="Ausführungsidentität" name="identity" value={identity} onChange={e => setIdentity(e.target.value)}><option value="agent_service">agent_service</option><option value="root" disabled={!allowed(auth, 'root:execute')}>root · root:execute und unabhängiger Helper erforderlich</option><option value="system" disabled={action !== 'set_service_state' || !allowed(auth, 'system:execute')}>system · system:execute und Windows-SYSTEM-Helper erforderlich</option></select></label><label>Laufzeitlimit (s)<input name="timeout" type="number" min="1" max="86400" defaultValue="60" required/></label><label>Ausgabelimit (Bytes)<input name="output" type="number" min="1" max="524288" defaultValue="65536" required/></label><label>Frühester Start (lokale Zeit)<input name="not_before" type="datetime-local" defaultValue={localDate(new Date())} required/></label><label>Startfrist / Ablauf (lokale Zeit)<input name="expires" type="datetime-local" defaultValue={localDate(new Date(Date.now() + 86400000))} required/></label><label>Maximal parallel<input name="parallel" type="number" min="1" defaultValue="1" required/></label><label>Stopp nach Fehlern<input name="failures" type="number" min="1" defaultValue="1" required/></label></div>
|
||||
{identity === 'root' && <p className="warning">{rootWarning}</p>}
|
||||
{identity === 'system' && <p className="warning">{systemWarning}</p>}
|
||||
{['ensure_package', 'apply_updates', 'apt_native_acceptance'].includes(action) && <details open><summary>Unveränderte Parameter-/Manifestpreview: gesamte Closure, alte/neue Versionen, Origins, Archivbytes/Hashes und Bindungen</summary><pre>{parameters}</pre><p>Struktur, exakte Transaktionsbytes und Hash werden vor Planung geprüft. Diese Vorschau behauptet keine native Akzeptanz oder Bereitschaft; keine automatische Ergänzung/Reduzierung der Closure.</p></details>}
|
||||
<label>Feste importierte Artefakt-IDs (optional, maximal 16)<input name="artifact_ids" placeholder="UUIDs durch Komma getrennt; keine URL"/></label>
|
||||
<label>Begründung<input name="reason" required maxLength={1024}/></label><p>Feste Ziele ({selected.length}): {selected.join(', ') || 'keine ausgewählt'}</p>{action === 'reboot' || action === 'apply_updates' || action === 'ensure_package' ? <p className="warning">Zieländerung: Testumfang separat abstimmen. Keine implizite Reboot-/Updateerlaubnis. Neue Versuche und Folgejobs benötigen neue feste Pläne.</p> : null}<button disabled={busy || !selected.length}>Plan erstellen · noch keine Ausführung</button><ErrorBox error={error}/>
|
||||
@@ -67,6 +75,7 @@ function PlanDetail({ tenantId, id, auth, onOperation }: { tenantId: string; id:
|
||||
const blockers = plan.data ? approvalBlockers(plan.data) : ['Plan noch nicht geladen'];
|
||||
return <section><h2>Unveränderlicher Plan / Genehmigungsdetail</h2><ErrorBox error={plan.error}/><ErrorBox error={error}/>{plan.data && <>
|
||||
<p>Plan-ID: {id}</p><p>Exakter gespeicherter Planhash: <code>{stringField(plan.data, 'plan_hash')}</code></p><p>Feste Ziele: {Array.isArray(plan.data.resolved_targets) ? plan.data.resolved_targets.length : 'unknown'}. Die folgenden Zielpreviews sind unveränderliche Plandefinitionen, keine ausführbaren Jobs oder angelegten Versuche. Diese entstehen erst nach Genehmigung.</p>
|
||||
<SystemPlanNotice plan={plan.data}/>
|
||||
<JsonView value={plan.data} label="Alle festen Zielpreviews, exakte Skriptinhalte/Hashes, Parameter, Rechte, Fristen, Rollout und Nachbedingungen"/>
|
||||
<p className="warning">Genehmigung bindet ausschließlich diesen unveränderlichen Plan. Kein pauschaler Retry, keine Wildcard, kein impliziter Reboot. Unbekannte Wirkung wird nicht automatisch wiederholt. Ein Exitcode allein beweist keine fachliche Wirkung.</p>
|
||||
{blockers.length > 0 && <div role="alert" className="error">Nicht genehmigungsfähig: {blockers.join('; ')}</div>}
|
||||
|
||||
@@ -30,6 +30,24 @@ describe('immutable catalog and strict import contracts', () => {
|
||||
});
|
||||
});
|
||||
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');
|
||||
|
||||
+24
-1
@@ -1,7 +1,8 @@
|
||||
import { Action, PlanInput, RecordValue, Session, record, text } from './api';
|
||||
import { Action, PlanInput, RecordValue, Session, record, text, validateSystemService } from './api';
|
||||
|
||||
export const hashPattern = /^[0-9a-f]{64}$/;
|
||||
export const rootWarning = 'HOHES RISIKO: root kann das Zielsystem verändern. Keine automatische Rechteerhöhung; eigener expliziter Plan, Scope, Helper und Genehmigung erforderlich.';
|
||||
export const systemWarning = 'SYSTEM: ausschließlich fest benannter Windows-Fixturedienst und running/stopped. Eigenes system:execute, unabhängiger Helper und konkrete WebUI-Genehmigung erforderlich. Keine SYSTEM-Shell, kein impliziter Reboot oder Retry.';
|
||||
export 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); }
|
||||
@@ -72,6 +73,11 @@ export function validateAptManifest(value: unknown, acceptance: boolean): Record
|
||||
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.parameters.execution_identity === 'root' && !allowed(auth, 'root:execute')) throw new Error('root:execute unbekannt oder nicht erteilt; keine Rechteerhöhung');
|
||||
if (input.parameters.execution_identity === 'system') {
|
||||
if (!allowed(auth, 'system:execute')) throw new Error('system:execute unbekannt oder nicht erteilt; root:execute enthält dieses Recht nicht');
|
||||
if (input.action !== 'set_service_state') throw new Error('SYSTEM ausschließlich für typisierte Dienstaktionen');
|
||||
validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
|
||||
}
|
||||
if (input.action === '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);
|
||||
@@ -88,13 +94,30 @@ export async function validateSensitiveInput(input: PlanInput, auth: Session) {
|
||||
}
|
||||
}
|
||||
}
|
||||
/** Display only definitions decoded from the exact hashed plan bytes. */
|
||||
export function systemPlanJobs(plan: RecordValue): RecordValue[] {
|
||||
if (plan.plan_payload_bytes === undefined) return [];
|
||||
const parsed = record(parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(bytes(plan.plan_payload_bytes))));
|
||||
if (!Array.isArray(parsed.jobs)) return [];
|
||||
return parsed.jobs.map(value => record(record(value).payload)).filter(payload => payload.execution_identity === 'system');
|
||||
}
|
||||
export async function verifyPlanIntegrity(plan: RecordValue) {
|
||||
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');
|
||||
const parsed = parseStrictJson(new TextDecoder('utf-8', { fatal: true }).decode(exactBytes));
|
||||
if (plan.plan_payload !== undefined && canonical(parsed) !== canonical(plan.plan_payload)) throw new Error('Planansicht widerspricht gespeicherten Bytes');
|
||||
}
|
||||
for (const payload of systemPlanJobs(plan)) {
|
||||
const action = record(payload.action);
|
||||
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');
|
||||
|
||||
Reference in New Issue
Block a user