Add the independently reviewed Windows recovery interface
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-15 23:15:21 +01:00
parent f16f4cd2bc
commit 27779ef954
7 changed files with 255 additions and 9 deletions
+5
View File
@@ -55,6 +55,11 @@ export async function request(path: string, options: { body?: unknown; csrf?: st
}
export const tenantPath = (id: string, suffix = '') => `/api/v1/tenants/${encodeURIComponent(id)}${suffix}`;
export const objectId = (r: RecordValue, kind: string) => text(r[`${kind}_id`] ?? r.id, `${kind}_id`);
export function canonicalJson(value: unknown): string {
if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
if (value && typeof value === 'object') return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(',')}}`;
return JSON.stringify(value);
}
export const pretty = (v: unknown) => JSON.stringify(v, null, 2);
export const actions = ['run_script', 'refresh_inventory', 'query_logs', 'set_service_state', 'ensure_package', 'apply_updates', 'reboot', 'apt_native_acceptance', 'update_agent'] as const;
+3
View File
@@ -5,6 +5,7 @@ import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout
import './style.css';
import { AdminControl, Catalog, TenantControls } from './management';
import { allowed, availableActions, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity, queryLogsApprovalBlockers, queryLogsPlanJobs, windowsMsiApprovalBlockers, windowsMsiPlanJobs, verifyWindowsMsiManifest, fullMaintenanceWarning } from './safety';
import { RecoveryReview, recoveryAsset, recoveryTenant } from './recovery-review';
import { Login } from './login';
import { ConsoleOutput, outputText } from './console-output';
import { scriptApprovalBlockers, scriptPlanJobs, verifyScriptPlan } from './script-console';
@@ -99,6 +100,8 @@ function Devices({ tenantId, auth, selected, setSelected }: { tenantId: string;
{!list.data ? <p>Lade Geräte …</p> : <><PageStatus data={list.data}/><div className="table"><table><thead><tr><th>Fest auswählen</th><th>Gerät / Asset-ID</th><th>Präsenz / Gesundheit</th><th>Quelle / Qualität</th><th>Erhebung / Alter / Empfang</th></tr></thead><tbody>{list.data.items.map(d => { const id = objectId(d, 'asset'); return <tr key={id}><td><input aria-label={`Ziel ${id}`} type="checkbox" checked={selected.includes(id)} onChange={e => setSelected(e.target.checked ? [...selected, id] : selected.filter(v => v !== id))}/></td><td><button className="link" onClick={() => setAsset(id)}>{typeof d.hostname === 'string' ? d.hostname : id}</button><small>{id}</small></td><td>{stringField(d, 'presence')} / {stringField(d, 'health')}<small>Kontakt: {stringField(d, 'last_contact_at')}</small></td><td>{stringField(d, 'source_id')} / {stringField(d, 'quality')}<small>{stringField(d, 'completeness')}</small></td><td>{stringField(d, 'observed_at')}<small>Alter: <Age value={d.observed_at}/> · empfangen: {stringField(d, 'received_at')}</small></td></tr>; })}</tbody></table></div>{!list.data.items.length && <p>Keine sichtbaren Geräte in diesem Listenabschnitt.</p>}<button disabled={!cursor} onClick={() => setCursor(null)}>Erste Seite</button> <button disabled={!list.data.next_cursor} onClick={() => setCursor(list.data?.next_cursor ?? null)}>Nächste Seite</button></>}
<p>Fester Auswahlsnapshot ({selected.length}): {selected.join(', ') || 'keine Ziele'}</p>
{asset && <article><h3>Inventardetail {asset}</h3><ErrorBox error={detail.error}/>{detail.data && <><CatalogCheckNotice device={detail.data}/><JsonView value={detail.data} label="Inventar, Capabilities, Metriken, Dienste, Software, Updates, Logs und Quellen (soweit geliefert)"/></>}<AdminControl auth={auth} path={tenantPath(tenantId, `/devices/${encodeURIComponent(asset)}/revocation`)} permission="devices:revoke" title="Geräteidentität widerrufen" warning="ACHTUNG: Widerruf unterbricht die Geräteverwaltung und sperrt neue Starts. Kein Entfernen aus einer Liste, kein Rollback. Wiederaufnahme erfordert einen gesonderten sicheren Enrollment-/Recoveryprozess." done={detail.reload}/></article>}
{tenantId === recoveryTenant && asset === recoveryAsset && allowed(auth, 'inventory:read') &&
<RecoveryReview key={auth.principal.id} auth={auth}/>}
</section>;
}
const initialParameters: Record<Action, RecordValue> = {
+49
View File
@@ -0,0 +1,49 @@
import { readFileSync } from 'node:fs';
import { describe, expect, it } from 'vitest';
import { canonicalJson, type Session } from './api';
import { mayConfirmRecovery, readReview, recoveryAsset, recoveryTenant } from './recovery-review';
import { sha256 } from './safety';
const witness = JSON.parse(readFileSync(new URL('../../crates/domain/src/windows_sync_history_case.json', import.meta.url), 'utf8'));
const human = 'oidc:' + 'a'.repeat(64);
const row = {
request_id: '06e55f7a-0263-4def-b7c3-7d28b1202a51',
status: 'pending_review', tenant_id: recoveryTenant, asset_id: recoveryAsset, agent_id: witness.agent_id,
witness, witness_sha256: 'f29b5afadaf2debab9610282725c2493cb7405784640a4616e1998c304309cab',
confirmed_by: null, confirmed_at: null, receipt_id: null, receipt_valid_until: null,
};
describe('Historische Windows-Journalprüfung', () => {
it('liest beide bestätigten Journalstände mit dem kanonischen SHA-256 der gemeinsamen Domainreferenz', async () => {
const review = await readReview({ request: row });
expect(review?.witness.server_head_checkpoint).toBe(6755);
expect(review?.witness.local_head_checkpoint).toBe(6756);
expect(review?.confirmed).toBeNull();
});
it('verweigert einen geänderten Beleg auch mit passendem neu berechnetem Hash', async () => {
const changed = { ...witness, guest_evidence_sha256: '0'.repeat(64) };
await expect(readReview({ request: { ...row, witness: changed } })).rejects.toThrow();
const digest = await sha256(new TextEncoder().encode(canonicalJson(changed)));
await expect(readReview({ request: { ...row, witness: changed, witness_sha256: digest } })).rejects.toThrow();
await expect(readReview({ request: { ...row, tenant_id: row.request_id } })).rejects.toThrow();
});
it('benötigt eine persönliche OIDC-Sitzung, Tenantmitgliedschaft, CSRF und das unabhängige Recht', () => {
const auth: Session = { principal: { id: human, display_name: 'Operator', simulated: false },
tenants: [{ tenant_id: recoveryTenant, name: 'Test' }], csrf_token: 'csrf', permissions: ['recovery:confirm'] };
expect(mayConfirmRecovery(auth)).toBe(true);
for (const changed of [
{ ...auth, principal: { ...auth.principal, simulated: true } },
{ ...auth, principal: { ...auth.principal, id: 'simulated-testprincipal-a' } },
{ ...auth, permissions: ['operations:authorize'] }, { ...auth, tenants: [] }, { ...auth, csrf_token: '' },
]) expect(mayConfirmRecovery(changed)).toBe(false);
});
it('zeigt eine Quittung erst beim vollständigen bestätigten Antrag', async () => {
await expect(readReview({ request: { ...row, status: 'confirmed' } })).rejects.toThrow();
const receipt = { status: 'confirmed', confirmed_by: human, confirmed_at: '2026-11-15T22:30:00Z',
receipt_id: 'b09b4e2e-c378-4837-81b1-cae9a8af38e9', receipt_valid_until: '2026-11-15T22:45:00Z' };
expect((await readReview({ request: { ...row, ...receipt } }))?.confirmed?.receipt).toBe(receipt.receipt_id);
});
});
+131
View File
@@ -0,0 +1,131 @@
import React, { useEffect, useRef, useState } from 'react';
import { canonicalJson, pretty, record, RecordValue, request, Session, tenantPath } from './api';
import { allowed, sha256 } from './safety';
export const recoveryTenant = '11111111-1111-4111-8111-111111111111';
export const recoveryAsset = 'a176520e-8a91-4e93-a78b-8e7620f430e0';
const agent = '63ea15b2-0643-403d-b5b4-cba1288dbea3';
// Canonical SHA-256 of the single historical case in rmm_domain::windows_sync_history.
const historicalWitnessHash = 'f29b5afadaf2debab9610282725c2493cb7405784640a4616e1998c304309cab';
const path = tenantPath(recoveryTenant, '/windows-checkpoint-recovery');
const humanOidc = /^oidc:[0-9a-f]{64}$/;
const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
interface Review {
id: string;
hash: string;
witness: RecordValue;
confirmed: { by: string; at: string; receipt: string; until: string } | null;
}
export async function readReview(value: unknown): Promise<Review | null> {
const row = record(value).request;
if (row === null) return null;
const r = record(row), w = record(r.witness, 'Wiederherstellungsbeleg');
const id = r.request_id, hash = r.witness_sha256;
if (typeof id !== 'string' || !uuid.test(id) || typeof hash !== 'string' || hash !== historicalWitnessHash ||
r.tenant_id !== recoveryTenant || w.tenant_id !== r.tenant_id || r.asset_id !== recoveryAsset ||
w.asset_id !== r.asset_id || r.agent_id !== agent || w.agent_id !== agent ||
w.schema_version !== 1 || w.connection_generation !== 150 ||
w.server_head_checkpoint !== 6755 || w.local_head_checkpoint !== 6756 ||
w.server_head_decision_id !== 'b6a3101f-68ad-41c8-be4e-4c7c2bc963d6' ||
w.local_head_decision_id !== '0633a4de-7e52-4e5d-a2a1-59fb134817fe' ||
await sha256(new TextEncoder().encode(canonicalJson(w))) !== hash) {
throw new Error('Gerätebindung, Journalstände oder SHA-256 des gespeicherten Belegs stimmen nicht überein.');
}
if (r.status === 'pending_review' && r.confirmed_by === null && r.confirmed_at === null &&
r.receipt_id === null && r.receipt_valid_until === null) return { id, hash, witness: w, confirmed: null };
if (r.status !== 'confirmed' || typeof r.confirmed_by !== 'string' || !humanOidc.test(r.confirmed_by) ||
typeof r.confirmed_at !== 'string' || !Number.isFinite(Date.parse(r.confirmed_at)) ||
typeof r.receipt_id !== 'string' || !uuid.test(r.receipt_id) ||
typeof r.receipt_valid_until !== 'string' || !Number.isFinite(Date.parse(r.receipt_valid_until)) ||
Date.parse(r.receipt_valid_until) <= Date.parse(r.confirmed_at)) {
throw new Error('Unvollständiger Bestätigungsstand.');
}
return { id, hash, witness: w, confirmed: { by: r.confirmed_by, at: r.confirmed_at,
receipt: r.receipt_id, until: r.receipt_valid_until } };
}
export function mayConfirmRecovery(auth: Session): boolean {
return auth.principal.simulated === false && humanOidc.test(auth.principal.id) &&
auth.tenants.some(t => t.tenant_id === recoveryTenant) && !!auth.csrf_token && allowed(auth, 'recovery:confirm');
}
export function RecoveryReview({ auth }: { auth: Session }) {
const [row, setRow] = useState<Review | null | undefined>(undefined);
const [error, setError] = useState(''), [busy, setBusy] = useState(false);
const [reviewed, setReviewed] = useState(false), [revision, setRevision] = useState(0);
const activeSubmit = useRef<AbortController | null>(null);
const [elapsedReceipt, setElapsedReceipt] = useState('');
useEffect(() => () => activeSubmit.current?.abort(), []);
useEffect(() => {
const controller = new AbortController();
setRow(undefined); setReviewed(false); setError('');
request(path, { signal: controller.signal }).then(readReview).then(response => {
if (!controller.signal.aborted) setRow(response);
}).catch(e => { if (!controller.signal.aborted) setError(String(e)); });
return () => controller.abort();
}, [revision]);
const eligible = mayConfirmRecovery(auth);
const confirmed = row?.confirmed;
const expired = !!confirmed && (confirmed.receipt === elapsedReceipt || Date.parse(confirmed.until) <= Date.now());
useEffect(() => {
if (!confirmed) return;
const timer = window.setTimeout(() => {
setElapsedReceipt(confirmed.receipt);
setReviewed(false);
}, Math.max(0, Date.parse(confirmed.until) - Date.now()));
return () => window.clearTimeout(timer);
}, [confirmed]);
async function submit() {
if (activeSubmit.current || row === undefined) return;
if (row && (!eligible || !reviewed || (row.confirmed && !expired))) return;
if (!row && !allowed(auth, 'operations:submit')) return;
const controller = new AbortController();
activeSubmit.current = controller;
setBusy(true); setReviewed(false); setError('');
try {
const url = row ? path + '/' + row.id + '/confirm' : path;
const body = row ? { witness_sha256: row.hash, reviewed: true,
...(row.confirmed ? { previous_receipt_id: row.confirmed.receipt } : {}) } : {};
const reply = await readReview(await request(url, { body, csrf: auth.csrf_token, signal: controller.signal }));
if (!reply || (row && (reply.id !== row.id || reply.hash !== row.hash || !reply.confirmed))) {
throw new Error('Antwort passt nicht zum geprüften Antrag. Bitte den gespeicherten Stand abrufen.');
}
if (!controller.signal.aborted) setRow(reply);
} catch (e) {
if (!controller.signal.aborted) { setRow(undefined); setError(String(e)); }
} finally {
activeSubmit.current = null;
if (!controller.signal.aborted) setBusy(false);
}
}
return <section aria-label="Windows-Journalwiederherstellung">
<h3>Windows-Journalwiederherstellung</h3>
{error && <p role="alert">{error}</p>}
{row === undefined && !error && <p>Prüfantrag wird geladen …</p>}
{row === null && <p>Für diese Testinstallation liegt noch kein Prüfantrag vor.</p>}
{row === null && allowed(auth, 'operations:submit') &&
<button disabled={busy} onClick={submit}>Prüfantrag aus gespeicherten Belegen anlegen</button>}
{row && <>
<p>Antrag <code>{row.id}</code> · Windows-Verbindung {String(row.witness.connection_generation)}</p>
<p>Gültiger historischer Serverstand <strong>{String(row.witness.server_head_checkpoint)}</strong>.
Agent und Helper haben die signierte Ablehnung <strong>{String(row.witness.local_head_checkpoint)}</strong> gespeichert.</p>
<p>Beleg-SHA-256 <code>{row.hash}</code></p>
<details open><summary>Öffentliche Server- und Gastbelege</summary><pre>{pretty(row.witness)}</pre></details>
{confirmed && <p>Bestätigt durch {confirmed.by} am {confirmed.at}. Quittung gültig bis {confirmed.until}.</p>}
{eligible && confirmed && !expired &&
<a href={path + '/' + row.id + '/receipt'} download="windows-checkpoint-recovery.json">Signierte Quittung herunterladen</a>}
{(!confirmed || expired) && (eligible ? <>
<p>{confirmed ? 'Die erneute Prüfung stellt eine neue befristete Quittung aus.' :
'Mit der Bestätigung übernimmt der Server die bereits signierte Ablehnung 6756 als Kontrollstand und stellt eine befristete Quittung für den Gast aus.'}
{' '}Vor einem späteren Job sind der reguläre signierte Abgleich und die gesonderte Plangenehmigung erforderlich.</p>
<label><input type="checkbox" checked={reviewed} disabled={busy}
onChange={e => setReviewed(e.currentTarget.checked)}/> Ich habe beide Journalstände, die Gerätebindung und die öffentlichen Belege geprüft.</label>
<button disabled={busy || !reviewed} onClick={submit}>{confirmed ? 'Neue Quittung ausdrücklich bestätigen' : 'Übernahme des dokumentierten Kontrollstands bestätigen'}</button>
</> : <p>Die Bestätigung erfordert eine persönliche OIDC-Sitzung mit der Berechtigung <code>recovery:confirm</code>.</p>)}
</>}
<button disabled={busy || (row === undefined && !error)} onClick={() => setRevision(n => n + 1)}>Gespeicherten Stand aktualisieren</button>
</section>;
}
+5 -9
View File
@@ -1,4 +1,4 @@
import { record, RecordValue, text, windowsScriptProfile, privilegedScriptProfile, fullMaintenanceScriptProfile, validateScriptIdentityProfile } from './api';
import { canonicalJson, record, RecordValue, text, windowsScriptProfile, privilegedScriptProfile, fullMaintenanceScriptProfile, validateScriptIdentityProfile } from './api';
import { bytes, hashPattern, parseStrictJson, sha256 } from './safety';
export interface ScriptPlanJob {
@@ -10,13 +10,9 @@ export interface ScriptPlanJob {
}
interface Verified { snapshot: string; jobs: ScriptPlanJob[] }
const verified = new WeakMap<RecordValue, Verified>();
function canonical(value: unknown): string {
if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
if (value && typeof value === 'object') return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(',')}}`;
return JSON.stringify(value);
}
function snapshot(plan: RecordValue): string {
return canonical(Object.fromEntries(['plan_hash', 'plan_payload_bytes', 'plan_payload', 'payload', 'jobs', 'payloads', 'resolved_targets', 'plan_id', 'expires_at'].filter(key => key in plan).map(key => [key, plan[key]])));
return canonicalJson(Object.fromEntries(['plan_hash', 'plan_payload_bytes', 'plan_payload', 'payload', 'jobs', 'payloads', 'resolved_targets', 'plan_id', 'expires_at'].filter(key => key in plan).map(key => [key, plan[key]])));
}
function exact(value: RecordValue, fields: string[]) {
if (Object.keys(value).some(key => !fields.includes(key)) || fields.some(key => !Object.hasOwn(value, key))) throw new Error('Skriptplan: vollständige bekannte Schemafelder erforderlich');
@@ -33,7 +29,7 @@ function integer(value: unknown, min: number, max: number): number {
function digest(value: unknown): string { const hash = text(value, 'SHA256'); if (!hashPattern.test(hash)) throw new Error('Skriptplan: exakter SHA256 fehlt'); return hash; }
function isScript(value: unknown): boolean { return value !== null && typeof value === 'object' && record(value).action === 'run_script'; }
function validateViews(plan: RecordValue, parsed: RecordValue, jobs: RecordValue[]): void {
for (const alias of ['plan_payload', 'payload']) if (plan[alias] !== undefined && canonical(plan[alias]) !== canonical(parsed)) throw new Error('Skriptplanansicht widerspricht gespeicherten Bytes');
for (const alias of ['plan_payload', 'payload']) if (plan[alias] !== undefined && canonicalJson(plan[alias]) !== canonicalJson(parsed)) throw new Error('Skriptplanansicht widerspricht gespeicherten Bytes');
if (plan.plan_id !== undefined && plan.plan_id !== parsed.plan_id) throw new Error('Skript-Plan-ID widerspricht gespeicherten Bytes');
for (const alias of ['jobs', 'payloads', 'resolved_targets']) {
if (plan[alias] === undefined) continue;
@@ -46,7 +42,7 @@ function validateViews(plan: RecordValue, parsed: RecordValue, jobs: RecordValue
const p = record(fixed.payload);
if (payload) {
if (Object.keys(view).some(key => !['payload', 'job_payload_hash', 'script_sha256', 'asset_id', 'agent_id', 'job_id', 'attempt_id'].includes(key))
|| canonical(payload) !== canonical(p) || view.job_payload_hash !== fixed.job_payload_hash
|| canonicalJson(payload) !== canonicalJson(p) || view.job_payload_hash !== fixed.job_payload_hash
|| (view.script_sha256 !== undefined && view.script_sha256 !== fixed.script_sha256)
|| ['agent_id', 'job_id', 'attempt_id'].some(key => view[key] !== undefined && view[key] !== p[key])) throw new Error('Skript-Zielpreview widerspricht gespeicherten Bytes');
} else if (alias !== 'resolved_targets' || (typeof item !== 'string' && (Object.keys(view).some(key => !['asset_id', 'agent_id'].includes(key)) || view.agent_id !== p.agent_id))) throw new Error('Vollständiger Skript-Zielpayload fehlt');