From f66d87ad11e1ece604ea5610574a65f3ec43ffc9 Mon Sep 17 00:00:00 2001
From: Florian Wilde <wilde.florian@gmail.com>
Date: Mon, 12 Oct 2026 10:17:35 +0200
Subject: [PATCH 1/3] feat(ausrollen): Public Keys mit Trockenlauf und Backup
 ausrollen (#016)

Zuweisungen von Public Keys an Hosts oder Hostgruppen, ein Trockenlauf
mit Diff je Ziel und das Ausrollen genau dieses Plans. Hat sich die
Datei oder das Soll seit dem Trockenlauf geaendert, bricht das Ziel
ab: es wird nie etwas anderes geschrieben, als jemand gesehen hat.

Auf dem Host geschieht alles als Zielbenutzer, mit Sicherung, Temp-
Datei, mv und 0700/0600; der Hash wird dort erneut geprueft. Der
Deployment-Key gehoert immer zum Soll des Anmeldebenutzers.

Integrationstests gegen echtes sshd, die Oberflaechenbausteine folgen
mit der Schluesselseite aus #012.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/components/ausrollen/AusrollenPanel.tsx   | 133 +++++++++
 .../ausrollen/PublicZuweisenFormular.tsx      |  77 +++++
 src/components/vorgang/useVorgang.ts          |  53 ++++
 src/server/actions/verwendungen.ts            |  96 +++++++
 src/server/queries/ziele.ts                   |  22 ++
 src/server/services/soll.ts                   | 131 +++++++++
 src/server/services/verwendungen.ts           | 149 ++++++++++
 src/worker/ablaeufe/ausrollen.ts              | 267 ++++++++++++++++++
 src/worker/handler.ts                         |   5 +-
 src/worker/ssh/authorized-keys-datei.ts       | 141 +++++++++
 src/worker/ssh/verbindung.ts                  |  13 +-
 tests/integration/ausrollen.test.ts           | 195 +++++++++++++
 tests/integration/hilfen/host.ts              |  60 ++++
 13 files changed, 1339 insertions(+), 3 deletions(-)
 create mode 100644 src/components/ausrollen/AusrollenPanel.tsx
 create mode 100644 src/components/ausrollen/PublicZuweisenFormular.tsx
 create mode 100644 src/components/vorgang/useVorgang.ts
 create mode 100644 src/server/actions/verwendungen.ts
 create mode 100644 src/server/queries/ziele.ts
 create mode 100644 src/server/services/soll.ts
 create mode 100644 src/server/services/verwendungen.ts
 create mode 100644 src/worker/ablaeufe/ausrollen.ts
 create mode 100644 src/worker/ssh/authorized-keys-datei.ts
 create mode 100644 tests/integration/ausrollen.test.ts
 create mode 100644 tests/integration/hilfen/host.ts

diff --git a/src/components/ausrollen/AusrollenPanel.tsx b/src/components/ausrollen/AusrollenPanel.tsx
new file mode 100644
index 0000000..fc4a82b
--- /dev/null
+++ b/src/components/ausrollen/AusrollenPanel.tsx
@@ -0,0 +1,133 @@
+"use client";
+
+import { Play, ScanSearch } from "lucide-react";
+import { useRouter } from "next/navigation";
+import { useEffect, useState, useTransition } from "react";
+import { Button } from "@/components/ui/Button";
+import { DiffBox } from "@/components/ui/DiffBox";
+import { laeuftNoch, useVorgang } from "@/components/vorgang/useVorgang";
+import { ausrollenAktion, trockenlaufAktion } from "@/server/actions/verwendungen";
+import type { DiffZeile } from "@/lib/ssh/zeilen-diff";
+
+/**
+ * Dry-Run-Vorschau und Ausfuehren (#016). Was angezeigt wird, ist genau das, was der Worker
+ * schreibt: der Plan traegt die Hashes, und das Ausrollen bricht ab, wenn sich seitdem auf
+ * dem Host oder an den Zuweisungen etwas geaendert hat.
+ */
+type PlanZiel = {
+  hostName: string;
+  zielbenutzer: string;
+  pfad?: string;
+  geaendert: boolean;
+  diff: DiffZeile[];
+  hinweise: string[];
+  fehler?: string;
+};
+
+export function AusrollenPanel({ schluesselId, offen }: { schluesselId: string; offen: number }) {
+  const router = useRouter();
+  const [trockenlaufId, setTrockenlaufId] = useState<string>();
+  const [ausrollenId, setAusrollenId] = useState<string>();
+  const [fehler, setFehler] = useState<string>();
+  const [startet, starten] = useTransition();
+  const trockenlauf = useVorgang(trockenlaufId);
+  const ausrollen = useVorgang(ausrollenId);
+
+  useEffect(() => {
+    if (ausrollen.stand && !laeuftNoch(ausrollen.stand)) router.refresh();
+  }, [ausrollen.stand, router]);
+
+  const plan = (trockenlauf.stand?.plan as { ziele?: PlanZiel[] } | null)?.ziele;
+  const aenderungen = plan?.filter((z) => z.geaendert && !z.fehler).length ?? 0;
+  const laeuft = startet || laeuftNoch(trockenlauf.stand) || laeuftNoch(ausrollen.stand);
+  const fertig = ausrollen.stand?.status === "ERLEDIGT";
+
+  return (
+    <div className="flex flex-col gap-4">
+      <div className="flex flex-wrap items-center gap-3">
+        <Button
+          icon={<ScanSearch className="size-4" />}
+          disabled={laeuft}
+          onClick={() =>
+            starten(async () => {
+              setFehler(undefined);
+              setAusrollenId(undefined);
+              const antwort = await trockenlaufAktion(schluesselId);
+              if (antwort.fehler) setFehler(antwort.fehler);
+              else setTrockenlaufId(antwort.vorgangId);
+            })
+          }
+        >
+          {laeuftNoch(trockenlauf.stand) ? "Trockenlauf läuft …" : "Dry-Run starten"}
+        </Button>
+        {offen > 0 && !plan && (
+          <span className="text-accent text-[13.5px]">{offen} Zuweisung(en) noch nicht ausgerollt.</span>
+        )}
+      </div>
+
+      {(fehler || trockenlauf.fehler || trockenlauf.stand?.status === "FEHLGESCHLAGEN") && (
+        <p role="status" className="text-danger text-[14px]">
+          {fehler ?? trockenlauf.fehler ?? trockenlauf.stand?.fehler}
+        </p>
+      )}
+
+      {plan?.map((ziel) => (
+        <div key={`${ziel.hostName}-${ziel.zielbenutzer}`} className="flex flex-col gap-2">
+          {ziel.fehler ? (
+            <p className="border-danger-border bg-danger-soft text-danger rounded-box border px-4 py-3 font-mono text-[13px]">
+              {ziel.zielbenutzer}@{ziel.hostName}: {ziel.fehler}
+            </p>
+          ) : (
+            <DiffBox
+              datei={`${ziel.zielbenutzer}@${ziel.hostName}:${ziel.pfad ?? "~/.ssh/authorized_keys"}`}
+              zeilen={ziel.geaendert ? ziel.diff : [{ art: "kontext", text: "Keine Änderung nötig." }]}
+            />
+          )}
+          {ziel.hinweise.map((h) => (
+            <p key={h} className="text-accent text-[13px]">
+              ▲ {h}
+            </p>
+          ))}
+        </div>
+      ))}
+
+      {plan && aenderungen > 0 && !fertig && (
+        <div className="border-border flex flex-col gap-3 border-t pt-4">
+          <label className="text-muted flex min-h-11 items-center gap-3 text-[14px]">
+            <input type="checkbox" checked disabled className="accent-accent size-5" />
+            Backup jeder Datei anlegen (
+            <code className="font-mono text-[12.5px]">authorized_keys.sshkv.bak.…</code>)
+          </label>
+          <div className="flex flex-wrap gap-3">
+            <Button
+              variante="primaer"
+              icon={<Play className="size-4" />}
+              disabled={laeuft}
+              onClick={() =>
+                starten(async () => {
+                  const antwort = await ausrollenAktion(trockenlaufId!);
+                  if (antwort.fehler) setFehler(antwort.fehler);
+                  else setAusrollenId(antwort.vorgangId);
+                })
+              }
+            >
+              {laeuftNoch(ausrollen.stand) ? "Wird ausgerollt …" : `Änderung anwenden (${aenderungen})`}
+            </Button>
+            <Button disabled={laeuft} onClick={() => setTrockenlaufId(undefined)}>
+              Verwerfen
+            </Button>
+          </div>
+        </div>
+      )}
+      {plan && aenderungen === 0 && (
+        <p className="text-ok text-[14px]">Alles ist bereits auf dem Soll-Stand.</p>
+      )}
+      {ausrollen.stand?.status === "FEHLGESCHLAGEN" && (
+        <p role="status" className="text-danger text-[14px]">
+          {ausrollen.stand.fehler}
+        </p>
+      )}
+      {fertig && <p className="text-ok text-[14px]">Ausgerollt.</p>}
+    </div>
+  );
+}
diff --git a/src/components/ausrollen/PublicZuweisenFormular.tsx b/src/components/ausrollen/PublicZuweisenFormular.tsx
new file mode 100644
index 0000000..2ff5080
--- /dev/null
+++ b/src/components/ausrollen/PublicZuweisenFormular.tsx
@@ -0,0 +1,77 @@
+"use client";
+
+import { Button, Feld, Formularfehler } from "@/components/ui";
+import { Auswahlliste } from "@/components/ui/Feld";
+import { useFormularAktion } from "@/components/hosts/useFormularAktion";
+import { publicZuweisenAktion } from "@/server/actions/verwendungen";
+import type { ZielAuswahl } from "@/server/queries/ziele";
+
+/**
+ * Public Key einem Host oder einer Hostgruppe zuweisen (#016). Die Zuweisung allein aendert
+ * noch nichts auf dem Host – erst Trockenlauf und Ausrollen.
+ */
+export function PublicZuweisenFormular({
+  schluesselId,
+  auswahl,
+  beiErfolg,
+}: {
+  schluesselId: string;
+  auswahl: ZielAuswahl;
+  beiErfolg?: () => void;
+}) {
+  const { zustand, absenden, laeuft } = useFormularAktion(async (vorher, formular) => {
+    const ergebnis = await publicZuweisenAktion(vorher, formular);
+    if (!ergebnis.fehler && !ergebnis.feldfehler) beiErfolg?.();
+    return ergebnis;
+  });
+  return (
+    <form onSubmit={absenden} className="flex flex-col gap-4">
+      <input type="hidden" name="schluesselId" value={schluesselId} />
+      <Formularfehler text={zustand.fehler} />
+      <Auswahlliste beschriftung="Ziel" name="ziel" defaultValue="" required>
+        <option value="" disabled>
+          Host oder Hostgruppe wählen …
+        </option>
+        <optgroup label="Hosts">
+          {auswahl.hosts.map((h) => (
+            <option key={h.id} value={`host:${h.id}`}>
+              {h.name}
+              {h.bereit ? "" : " (noch kein Bootstrap)"}
+            </option>
+          ))}
+        </optgroup>
+        {auswahl.gruppen.length > 0 && (
+          <optgroup label="Hostgruppen">
+            {auswahl.gruppen.map((g) => (
+              <option key={g.id} value={`gruppe:${g.id}`}>
+                {g.name} ({g.mitglieder} Hosts)
+              </option>
+            ))}
+          </optgroup>
+        )}
+      </Auswahlliste>
+      {zustand.feldfehler?.["ziel"] && (
+        <p className="text-danger -mt-2 text-[13px]">{zustand.feldfehler["ziel"]}</p>
+      )}
+      <Feld
+        beschriftung="Zielbenutzer"
+        name="zielbenutzer"
+        defaultValue="root"
+        mono
+        required
+        autoComplete="off"
+      />
+      <Feld
+        beschriftung="Einschränkungen in authorized_keys (optional)"
+        name="optionen"
+        mono
+        autoComplete="off"
+        placeholder='restrict,from="10.0.0.12"'
+        hinweis='z. B. restrict, from="IP", command="…", no-pty, no-port-forwarding'
+      />
+      <Button type="submit" variante="primaer" disabled={laeuft}>
+        {laeuft ? "Speichere …" : "Zuweisen"}
+      </Button>
+    </form>
+  );
+}
diff --git a/src/components/vorgang/useVorgang.ts b/src/components/vorgang/useVorgang.ts
new file mode 100644
index 0000000..6560463
--- /dev/null
+++ b/src/components/vorgang/useVorgang.ts
@@ -0,0 +1,53 @@
+"use client";
+
+import { useEffect, useState } from "react";
+
+/** Was /api/vorgaenge/[id] liefert (#009, #016). */
+export type VorgangsStand = {
+  readonly id: string;
+  readonly status: string;
+  readonly fehler: string | null;
+  readonly plan: unknown;
+  readonly ergebnis: unknown;
+};
+
+const LAUFEND = new Set(["WARTEND", "LAEUFT"]);
+
+export function laeuftNoch(stand: VorgangsStand | undefined): boolean {
+  return stand !== undefined && LAUFEND.has(stand.status);
+}
+
+/** Fragt einen Vorgang jede Sekunde ab, bis er fertig ist. */
+export function useVorgang(vorgangId: string | undefined): { stand?: VorgangsStand; fehler?: string } {
+  // Der Stand merkt sich seine Vorgangs-ID: so zeigt ein neuer Vorgang nie den alten Stand,
+  // ohne dass der Effekt synchron zuruecksetzen muss.
+  const [stand, setStand] = useState<VorgangsStand>();
+  const [fehler, setFehler] = useState<{ id: string; text: string }>();
+
+  useEffect(() => {
+    if (!vorgangId) return;
+    let abgebrochen = false;
+    void (async () => {
+      while (!abgebrochen) {
+        const antwort = await fetch(`/api/vorgaenge/${vorgangId}`, { cache: "no-store" });
+        if (!antwort.ok) {
+          setFehler({ id: vorgangId, text: "Status des Vorgangs nicht abrufbar." });
+          return;
+        }
+        const neu = (await antwort.json()) as VorgangsStand;
+        if (abgebrochen) return;
+        setStand(neu);
+        if (!LAUFEND.has(neu.status)) return;
+        await new Promise((weiter) => setTimeout(weiter, 1000));
+      }
+    })();
+    return () => {
+      abgebrochen = true;
+    };
+  }, [vorgangId]);
+
+  return {
+    ...(stand && stand.id === vorgangId ? { stand } : {}),
+    ...(fehler && fehler.id === vorgangId ? { fehler: fehler.text } : {}),
+  };
+}
diff --git a/src/server/actions/verwendungen.ts b/src/server/actions/verwendungen.ts
new file mode 100644
index 0000000..a88ac82
--- /dev/null
+++ b/src/server/actions/verwendungen.ts
@@ -0,0 +1,96 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { z } from "@/lib/validierung";
+import { BestaetigungFehler, RechteFehler, rechtErforderlich } from "@/server/auth/sitzungspflicht";
+import { akteurVon, textfeld, type FormularZustand } from "@/server/actions/formular";
+import {
+  VerwendungsFehler,
+  ausrollenStarten,
+  publicVerwendungAnlegen,
+  publicVerwendungEntfernen,
+  trockenlaufStarten,
+} from "@/server/services/verwendungen";
+
+/** Public-Key-Zuweisungen und Ausrollen (#016). Duenn: Recht, Eingabe, Service. */
+
+export type VorgangsAntwort = { readonly vorgangId?: string; readonly fehler?: string };
+
+function alsAntwort(fehler: unknown): { fehler: string } {
+  if (
+    fehler instanceof VerwendungsFehler ||
+    fehler instanceof RechteFehler ||
+    fehler instanceof BestaetigungFehler
+  ) {
+    return { fehler: fehler.message };
+  }
+  throw fehler;
+}
+
+export async function publicZuweisenAktion(
+  _vorher: FormularZustand,
+  formular: FormData,
+): Promise<FormularZustand> {
+  try {
+    const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    const schluesselId = z.string().min(1).max(64).parse(textfeld(formular, "schluesselId"));
+    // „host:<id>“ oder „gruppe:<id>“ aus einer einzigen Auswahlliste.
+    const ziel = textfeld(formular, "ziel") ?? "";
+    const [art, id] = ziel.split(":");
+    if (!id || (art !== "host" && art !== "gruppe"))
+      return { feldfehler: { ziel: "Bitte ein Ziel wählen." } };
+    await publicVerwendungAnlegen(
+      {
+        schluesselId,
+        hostId: art === "host" ? id : null,
+        hostgruppeId: art === "gruppe" ? id : null,
+        zielbenutzer: (textfeld(formular, "zielbenutzer") ?? "").trim(),
+        optionen: textfeld(formular, "optionen") ?? null,
+      },
+      akteurVon(benutzer),
+    );
+    revalidatePath(`/schluessel/${schluesselId}`);
+    return {};
+  } catch (fehler) {
+    return alsAntwort(fehler);
+  }
+}
+
+export async function publicEntfernenAktion(
+  verwendungId: string,
+  schluesselId: string,
+): Promise<{ fehler?: string }> {
+  try {
+    const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    await publicVerwendungEntfernen(z.string().min(1).max(64).parse(verwendungId), akteurVon(benutzer));
+    revalidatePath(`/schluessel/${schluesselId}`);
+    return {};
+  } catch (fehler) {
+    return alsAntwort(fehler);
+  }
+}
+
+export async function trockenlaufAktion(schluesselId: string): Promise<VorgangsAntwort> {
+  try {
+    const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    return {
+      vorgangId: await trockenlaufStarten(
+        { schluesselId: z.string().min(1).max(64).parse(schluesselId) },
+        akteurVon(benutzer),
+      ),
+    };
+  } catch (fehler) {
+    return alsAntwort(fehler);
+  }
+}
+
+export async function ausrollenAktion(trockenlaufId: string): Promise<VorgangsAntwort> {
+  try {
+    const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    return {
+      vorgangId: await ausrollenStarten(z.string().min(1).max(64).parse(trockenlaufId), akteurVon(benutzer)),
+    };
+  } catch (fehler) {
+    return alsAntwort(fehler);
+  }
+}
diff --git a/src/server/queries/ziele.ts b/src/server/queries/ziele.ts
new file mode 100644
index 0000000..a30b48b
--- /dev/null
+++ b/src/server/queries/ziele.ts
@@ -0,0 +1,22 @@
+import { prisma } from "@/lib/db";
+
+/** Auswahl fuer „Public Key ausrollen auf …“ (#016): Hosts mit Bootstrap und Hostgruppen. */
+export async function zielAuswahl() {
+  const [hosts, gruppen] = await Promise.all([
+    prisma.host.findMany({
+      where: { archiviertAm: null },
+      select: { id: true, name: true, bootstrapAm: true },
+      orderBy: { name: "asc" },
+    }),
+    prisma.hostgruppe.findMany({
+      select: { id: true, name: true, _count: { select: { mitglieder: true } } },
+      orderBy: { name: "asc" },
+    }),
+  ]);
+  return {
+    hosts: hosts.map((h) => ({ id: h.id, name: h.name, bereit: h.bootstrapAm !== null })),
+    gruppen: gruppen.map((g) => ({ id: g.id, name: g.name, mitglieder: g._count.mitglieder })),
+  };
+}
+
+export type ZielAuswahl = Awaited<ReturnType<typeof zielAuswahl>>;
diff --git a/src/server/services/soll.ts b/src/server/services/soll.ts
new file mode 100644
index 0000000..7ca83ba
--- /dev/null
+++ b/src/server/services/soll.ts
@@ -0,0 +1,131 @@
+import type { Host } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+import type { SollEintrag } from "@/lib/ssh/authorized-keys";
+
+/**
+ * Der Soll-Zustand einer authorized_keys (#016): welche Public Keys gehoeren in den
+ * verwalteten Block eines Benutzers auf einem Host – direkt zugewiesen oder ueber eine
+ * Hostgruppe. Laeuft im Worker und im Web (Vorschau), deshalb hier und nicht in src/worker.
+ */
+
+/** Dienstbenutzer auf den Hosts (Freigabe Frage 1); gleiche Regel wie im Worker. */
+export function anmeldebenutzerVon(host: Pick<Host, "anmeldeart">): string {
+  return host.anmeldeart === "ROOT" ? "root" : "sshkv";
+}
+
+/** Zustaende, in denen eine Verwendung zum Soll gehoert. */
+const IM_SOLL = ["GEPLANT", "AUSGEROLLT", "ABWEICHUNG", "FEHLGESCHLAGEN"] as const;
+
+export type Soll = {
+  readonly eintraege: SollEintrag[];
+  /** Fingerprints, die nie aus dem Block fallen duerfen (Deployment-Key). */
+  readonly pflicht: string[];
+  /** Verwendungen, die in diesem Soll stecken oder entfernt werden – fuer den Zustand danach. */
+  readonly verwendungIds: { readonly drin: string[]; readonly raus: string[] };
+};
+
+async function deploymentKeyFuer(host: Pick<Host, "id" | "deploymentSchluesselId">) {
+  if (host.deploymentSchluesselId) {
+    return prisma.schluessel.findUnique({
+      where: { id: host.deploymentSchluesselId },
+      select: { publicKey: true, fingerprint: true },
+    });
+  }
+  const gruppe = await prisma.hostgruppeMitglied.findFirst({
+    where: { hostId: host.id, hostgruppe: { deploymentSchluesselId: { not: null } } },
+    select: {
+      hostgruppe: { select: { deploymentSchluessel: { select: { publicKey: true, fingerprint: true } } } },
+    },
+  });
+  if (gruppe?.hostgruppe.deploymentSchluessel) return gruppe.hostgruppe.deploymentSchluessel;
+  return prisma.schluessel.findFirst({
+    where: { kategorie: "DEPLOYMENT", instanzStandard: true, status: "AKTIV" },
+    select: { publicKey: true, fingerprint: true },
+  });
+}
+
+export async function sollFuer(hostId: string, zielbenutzer: string): Promise<Soll> {
+  const host = await prisma.host.findUniqueOrThrow({
+    where: { id: hostId },
+    select: { id: true, anmeldeart: true, deploymentSchluesselId: true },
+  });
+  const verwendungen = await prisma.publicVerwendung.findMany({
+    where: {
+      zielbenutzer,
+      OR: [{ hostId }, { hostgruppe: { mitglieder: { some: { hostId } } } }],
+      zustand: { not: "ENTFERNT" },
+    },
+    select: {
+      id: true,
+      optionen: true,
+      zustand: true,
+      angelegtAm: true,
+      schluessel: { select: { publicKey: true, fingerprint: true, status: true } },
+    },
+    // Deterministische Reihenfolge im Block: aelteste Zuweisung zuerst.
+    orderBy: [{ angelegtAm: "asc" }, { id: "asc" }],
+  });
+
+  const eintraege: SollEintrag[] = [];
+  const pflicht: string[] = [];
+  if (zielbenutzer === anmeldebenutzerVon(host)) {
+    const deployment = await deploymentKeyFuer(host);
+    if (deployment) {
+      eintraege.push({ publicKey: deployment.publicKey, fingerprint: deployment.fingerprint });
+      pflicht.push(deployment.fingerprint);
+    }
+  }
+
+  const drin: string[] = [];
+  const raus: string[] = [];
+  for (const verwendung of verwendungen) {
+    const aktiv = verwendung.schluessel.status === "AKTIV" || verwendung.schluessel.status === "ROTIERT";
+    if ((IM_SOLL as readonly string[]).includes(verwendung.zustand) && aktiv) {
+      eintraege.push({
+        publicKey: verwendung.schluessel.publicKey,
+        fingerprint: verwendung.schluessel.fingerprint,
+        optionen: verwendung.optionen,
+      });
+      drin.push(verwendung.id);
+    } else {
+      raus.push(verwendung.id);
+    }
+  }
+  return { eintraege, pflicht, verwendungIds: { drin, raus } };
+}
+
+export type Ziel = { readonly hostId: string; readonly zielbenutzer: string };
+
+/** Alle (Host, Benutzer)-Paare, die eine Public-Key-Verwendung betrifft – Gruppen aufgeloest. */
+export async function zieleVonVerwendungen(where: {
+  schluesselId?: string;
+  ids?: string[];
+}): Promise<Ziel[]> {
+  const verwendungen = await prisma.publicVerwendung.findMany({
+    where: {
+      ...(where.schluesselId ? { schluesselId: where.schluesselId } : {}),
+      ...(where.ids ? { id: { in: where.ids } } : {}),
+      zustand: { not: "ENTFERNT" },
+    },
+    select: {
+      zielbenutzer: true,
+      hostId: true,
+      hostgruppe: {
+        select: { mitglieder: { select: { hostId: true, host: { select: { archiviertAm: true } } } } },
+      },
+    },
+  });
+  const ziele = new Map<string, Ziel>();
+  for (const verwendung of verwendungen) {
+    const hostIds = verwendung.hostId
+      ? [verwendung.hostId]
+      : (verwendung.hostgruppe?.mitglieder.filter((m) => !m.host.archiviertAm).map((m) => m.hostId) ?? []);
+    for (const hostId of hostIds) {
+      ziele.set(`${hostId}\u0000${verwendung.zielbenutzer}`, {
+        hostId,
+        zielbenutzer: verwendung.zielbenutzer,
+      });
+    }
+  }
+  return [...ziele.values()];
+}
diff --git a/src/server/services/verwendungen.ts b/src/server/services/verwendungen.ts
new file mode 100644
index 0000000..6e5e466
--- /dev/null
+++ b/src/server/services/verwendungen.ts
@@ -0,0 +1,149 @@
+import { Prisma } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+import { BENUTZERNAME_MUSTER } from "@/lib/shell";
+import { OptionenFehler, optionenPruefen } from "@/lib/ssh/optionen";
+import { protokollieren } from "@/server/services/protokoll";
+import { zieleVonVerwendungen, type Ziel } from "@/server/services/soll";
+import { vorgangEinreihen } from "@/server/vorgaenge/vorgaenge";
+
+/**
+ * Public-Key-Zuweisungen (#016): anlegen, zum Entfernen vormerken, Trockenlauf und
+ * Ausfuehren anstossen. Geschrieben wird nur im Worker.
+ */
+export class VerwendungsFehler extends Error {
+  constructor(nachricht: string) {
+    super(nachricht);
+    this.name = "VerwendungsFehler";
+  }
+}
+
+type Akteur = { readonly id: string; readonly name: string };
+
+export type PublicZuweisung = {
+  readonly schluesselId: string;
+  readonly hostId?: string | null;
+  readonly hostgruppeId?: string | null;
+  readonly zielbenutzer: string;
+  readonly optionen?: string | null;
+};
+
+export async function publicVerwendungAnlegen(eingabe: PublicZuweisung, akteur: Akteur): Promise<string> {
+  if (!BENUTZERNAME_MUSTER.test(eingabe.zielbenutzer)) {
+    throw new VerwendungsFehler(
+      "Ungültiger Zielbenutzer (Kleinbuchstaben, Ziffern, _ und -, höchstens 32 Zeichen).",
+    );
+  }
+  if (Boolean(eingabe.hostId) === Boolean(eingabe.hostgruppeId)) {
+    throw new VerwendungsFehler("Bitte genau einen Host oder eine Hostgruppe wählen.");
+  }
+  let optionen: string | null = null;
+  try {
+    optionen = optionenPruefen(eingabe.optionen ?? "") || null;
+  } catch (fehler) {
+    if (fehler instanceof OptionenFehler) throw new VerwendungsFehler(fehler.message);
+    throw fehler;
+  }
+  const schluessel = await prisma.schluessel.findUnique({
+    where: { id: eingabe.schluesselId },
+    select: { status: true, fingerprint: true, kategorie: true },
+  });
+  if (!schluessel) throw new VerwendungsFehler("Diesen Schlüssel gibt es nicht.");
+  if (schluessel.status !== "AKTIV")
+    throw new VerwendungsFehler("Nur aktive Schlüssel lassen sich zuweisen.");
+  if (schluessel.kategorie === "DEPLOYMENT") {
+    throw new VerwendungsFehler("Der Deployment-Key wird von sshkv selbst verwaltet.");
+  }
+  const ziel = eingabe.hostId
+    ? await prisma.host.findUnique({
+        where: { id: eingabe.hostId },
+        select: { name: true, archiviertAm: true },
+      })
+    : await prisma.hostgruppe.findUnique({ where: { id: eingabe.hostgruppeId! }, select: { name: true } });
+  if (!ziel || ("archiviertAm" in ziel && ziel.archiviertAm))
+    throw new VerwendungsFehler("Das Ziel gibt es nicht (mehr).");
+
+  try {
+    const verwendung = await prisma.publicVerwendung.create({
+      data: {
+        schluesselId: eingabe.schluesselId,
+        hostId: eingabe.hostId ?? null,
+        hostgruppeId: eingabe.hostgruppeId ?? null,
+        zielbenutzer: eingabe.zielbenutzer,
+        optionen,
+        angelegtVonId: akteur.id,
+      },
+    });
+    await protokollieren({
+      akteur,
+      aktion: "verwendung.public.angelegt",
+      ergebnis: "ERFOLG",
+      hostName: eingabe.hostId ? ziel.name : null,
+      zielbenutzer: eingabe.zielbenutzer,
+      fingerprint: schluessel.fingerprint,
+      details: { hostgruppe: eingabe.hostgruppeId ? ziel.name : null, optionen },
+    });
+    return verwendung.id;
+  } catch (fehler) {
+    if (fehler instanceof Prisma.PrismaClientKnownRequestError && fehler.code === "P2002") {
+      throw new VerwendungsFehler("Dieser Schlüssel ist dort für diesen Benutzer bereits zugewiesen.");
+    }
+    throw fehler;
+  }
+}
+
+/** Merkt eine Verwendung zum Entfernen vor; wirksam mit dem naechsten Ausrollen. */
+export async function publicVerwendungEntfernen(id: string, akteur: Akteur): Promise<void> {
+  const verwendung = await prisma.publicVerwendung.findUnique({
+    where: { id },
+    include: { schluessel: { select: { fingerprint: true } }, host: { select: { name: true } } },
+  });
+  if (!verwendung || verwendung.zustand === "ENTFERNT")
+    throw new VerwendungsFehler("Diese Zuweisung gibt es nicht.");
+  // Nie ausgerollt: einfach weg, auf dem Host steht noch nichts.
+  const nieAusgerollt = verwendung.zustand === "GEPLANT" && !verwendung.zuletztAngewendetAm;
+  await prisma.publicVerwendung.update({
+    where: { id },
+    data: { zustand: nieAusgerollt ? "ENTFERNT" : "ENTFERNEN" },
+  });
+  await protokollieren({
+    akteur,
+    aktion: "verwendung.public.entfernen",
+    ergebnis: "ERFOLG",
+    hostName: verwendung.host?.name ?? null,
+    zielbenutzer: verwendung.zielbenutzer,
+    fingerprint: verwendung.schluessel.fingerprint,
+  });
+}
+
+/** Trockenlauf fuer die Ziele eines Schluessels oder fuer ausgewaehlte Verwendungen. */
+export async function trockenlaufStarten(
+  auswahl: { schluesselId?: string; verwendungIds?: string[]; ziele?: Ziel[] },
+  akteur: Akteur,
+): Promise<string> {
+  const ziele =
+    auswahl.ziele ??
+    (await zieleVonVerwendungen({
+      ...(auswahl.schluesselId ? { schluesselId: auswahl.schluesselId } : {}),
+      ...(auswahl.verwendungIds ? { ids: auswahl.verwendungIds } : {}),
+    }));
+  if (ziele.length === 0) throw new VerwendungsFehler("Es gibt nichts auszurollen.");
+  return vorgangEinreihen({
+    art: "TROCKENLAUF",
+    angefordertVonId: akteur.id,
+    schluesselId: auswahl.schluesselId ?? null,
+    eingabe: { ziele },
+  });
+}
+
+export async function ausrollenStarten(trockenlaufId: string, akteur: Akteur): Promise<string> {
+  const trockenlauf = await prisma.vorgang.findUnique({ where: { id: trockenlaufId } });
+  if (!trockenlauf || trockenlauf.art !== "TROCKENLAUF" || trockenlauf.status !== "ERLEDIGT") {
+    throw new VerwendungsFehler("Erst den Trockenlauf abwarten.");
+  }
+  return vorgangEinreihen({
+    art: "AUSROLLEN",
+    angefordertVonId: akteur.id,
+    schluesselId: trockenlauf.schluesselId,
+    eingabe: { trockenlaufId },
+  });
+}
diff --git a/src/worker/ablaeufe/ausrollen.ts b/src/worker/ablaeufe/ausrollen.ts
new file mode 100644
index 0000000..e1ed08f
--- /dev/null
+++ b/src/worker/ablaeufe/ausrollen.ts
@@ -0,0 +1,267 @@
+import { createHash } from "node:crypto";
+import type { Client } from "ssh2";
+import type { Host } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+import { BlockFehler, blockSetzen } from "@/lib/ssh/authorized-keys";
+import { diffVerdichten, type DiffZeile } from "@/lib/ssh/zeilen-diff";
+import { sollFuer, type Ziel } from "@/server/services/soll";
+import { protokollieren } from "@/server/services/protokoll";
+import { VorgangsFehler, type Handler } from "@/worker/ausfuehren";
+import { authorizedKeysHolen, authorizedKeysSchreiben, inhaltHash } from "@/worker/ssh/authorized-keys-datei";
+import { hostVerbinden } from "@/worker/ssh/host";
+
+/**
+ * Public Keys ausrollen (#016) in zwei Schritten:
+ *
+ * 1. TROCKENLAUF: je Ziel (Host, Benutzer) die Datei lesen, den Block aus dem Soll setzen und
+ *    Diff, Hinweise und beide Hashes festhalten. Auf dem Host aendert sich nichts.
+ * 2. AUSROLLEN: genau diesen Plan ausfuehren. Hat sich die Datei oder das Soll seitdem
+ *    geaendert, bricht das Ziel ab (optimistische Sperre ueber die Hashes) – der Mensch
+ *    soll nie etwas anderes schreiben, als er gesehen hat.
+ */
+
+/** So lange darf ein Trockenlauf alt sein, bevor er ausgefuehrt wird. */
+export const TROCKENLAUF_GUELTIG_MS = 15 * 60 * 1000;
+
+export type PlanZiel = {
+  readonly hostId: string;
+  readonly hostName: string;
+  readonly zielbenutzer: string;
+  readonly pfad?: string;
+  readonly vorher?: string;
+  readonly nachher?: string;
+  readonly geaendert: boolean;
+  readonly diff: DiffZeile[];
+  readonly hinweise: string[];
+  readonly fehler?: string;
+};
+
+export type Plan = { readonly ziele: PlanZiel[] };
+
+function hashVon(text: string): string {
+  return createHash("sha256").update(Buffer.from(text, "utf8")).digest("hex");
+}
+
+function fehlerText(fehler: unknown): string {
+  if (fehler instanceof VorgangsFehler || fehler instanceof BlockFehler) return fehler.message;
+  return "Interner Fehler – Details im Worker-Log.";
+}
+
+function zieleLesen(eingabe: unknown): Ziel[] {
+  const ziele = (eingabe as { ziele?: unknown } | null)?.ziele;
+  if (!Array.isArray(ziele) || ziele.length === 0)
+    throw new VorgangsFehler("Der Trockenlauf nennt keine Ziele.");
+  return ziele.map((z) => {
+    const ziel = z as Partial<Ziel>;
+    if (typeof ziel.hostId !== "string" || typeof ziel.zielbenutzer !== "string") {
+      throw new VorgangsFehler("Ungültiges Ziel im Trockenlauf.");
+    }
+    return { hostId: ziel.hostId, zielbenutzer: ziel.zielbenutzer };
+  });
+}
+
+/** Ziele nach Host gruppieren: je Host genau eine SSH-Verbindung. */
+async function jeHost<T>(
+  ziele: readonly Ziel[],
+  arbeit: (host: Host, verbindung: Client, benutzer: string) => Promise<T>,
+  beiFehler: (host: Pick<Host, "id" | "name">, benutzer: string, fehler: unknown) => T,
+): Promise<T[]> {
+  const nachHost = new Map<string, string[]>();
+  for (const ziel of ziele)
+    nachHost.set(ziel.hostId, [...(nachHost.get(ziel.hostId) ?? []), ziel.zielbenutzer]);
+  const ergebnisse: T[] = [];
+  for (const [hostId, benutzerListe] of nachHost) {
+    const host = await prisma.host.findUnique({ where: { id: hostId } });
+    if (!host || host.archiviertAm) {
+      for (const benutzer of benutzerListe) {
+        ergebnisse.push(
+          beiFehler(
+            { id: hostId, name: host?.name ?? "?" },
+            benutzer,
+            new VorgangsFehler("Host ist archiviert oder fehlt."),
+          ),
+        );
+      }
+      continue;
+    }
+    let verbindung: Client;
+    try {
+      verbindung = await hostVerbinden(host);
+    } catch (fehler) {
+      for (const benutzer of benutzerListe) ergebnisse.push(beiFehler(host, benutzer, fehler));
+      continue;
+    }
+    try {
+      for (const benutzer of benutzerListe) {
+        try {
+          ergebnisse.push(await arbeit(host, verbindung, benutzer));
+        } catch (fehler) {
+          ergebnisse.push(beiFehler(host, benutzer, fehler));
+        }
+      }
+    } finally {
+      verbindung.end();
+    }
+  }
+  return ergebnisse;
+}
+
+export const trockenlaufHandler: Handler = async ({ vorgang }) => {
+  const ziele = zieleLesen(vorgang.eingabe);
+  const planZiele = await jeHost<PlanZiel>(
+    ziele,
+    async (host, verbindung, benutzer) => {
+      const stand = await authorizedKeysHolen(verbindung, host, benutzer);
+      const soll = await sollFuer(host.id, benutzer);
+      const ergebnis = blockSetzen(stand.inhalt, soll.eintraege, soll.pflicht);
+      return {
+        hostId: host.id,
+        hostName: host.name,
+        zielbenutzer: benutzer,
+        pfad: stand.pfad,
+        vorher: stand.sha256,
+        nachher: hashVon(ergebnis.inhalt),
+        geaendert: ergebnis.geaendert || !stand.vorhanden,
+        diff: diffVerdichten(ergebnis.diff),
+        hinweise: ergebnis.hinweise,
+      };
+    },
+    (host, benutzer, fehler) => ({
+      hostId: host.id,
+      hostName: host.name,
+      zielbenutzer: benutzer,
+      geaendert: false,
+      diff: [],
+      hinweise: [],
+      fehler: fehlerText(fehler),
+    }),
+  );
+  return { plan: { ziele: planZiele }, ergebnis: { ziele: planZiele.length } };
+};
+
+export const ausrollenHandler: Handler = async ({ vorgang }) => {
+  const trockenlaufId = (vorgang.eingabe as { trockenlaufId?: unknown } | null)?.trockenlaufId;
+  if (typeof trockenlaufId !== "string") throw new VorgangsFehler("Kein Trockenlauf angegeben.");
+  const trockenlauf = await prisma.vorgang.findUnique({ where: { id: trockenlaufId } });
+  if (
+    !trockenlauf ||
+    trockenlauf.art !== "TROCKENLAUF" ||
+    trockenlauf.status !== "ERLEDIGT" ||
+    !trockenlauf.plan
+  ) {
+    throw new VorgangsFehler("Der Trockenlauf ist nicht abgeschlossen.");
+  }
+  if (Date.now() - (trockenlauf.beendetAm ?? trockenlauf.angelegtAm).getTime() > TROCKENLAUF_GUELTIG_MS) {
+    throw new VorgangsFehler("Der Trockenlauf ist älter als 15 Minuten. Bitte neu starten.");
+  }
+  const bereitsAusgefuehrt = await prisma.vorgang.findFirst({
+    where: {
+      art: "AUSROLLEN",
+      id: { not: vorgang.id },
+      status: { in: ["LAEUFT", "ERLEDIGT"] },
+      eingabe: { equals: { trockenlaufId } },
+    },
+  });
+  if (bereitsAusgefuehrt) throw new VorgangsFehler("Dieser Trockenlauf wurde bereits ausgeführt.");
+
+  const plan = trockenlauf.plan as unknown as Plan;
+  const auszufuehren = plan.ziele.filter((ziel) => ziel.geaendert && !ziel.fehler);
+  const akteur = vorgang.angefordertVonId
+    ? await prisma.benutzer.findUnique({
+        where: { id: vorgang.angefordertVonId },
+        select: { id: true, name: true },
+      })
+    : null;
+
+  type Ausgang = {
+    readonly hostId: string;
+    readonly zielbenutzer: string;
+    readonly erfolg: boolean;
+    readonly fehler?: string;
+  };
+  const geplant = new Map(auszufuehren.map((z) => [`${z.hostId}\u0000${z.zielbenutzer}`, z]));
+
+  const ausgaenge = await jeHost<Ausgang>(
+    auszufuehren,
+    async (host, verbindung, benutzer) => {
+      const ziel = geplant.get(`${host.id}\u0000${benutzer}`)!;
+      const stand = await authorizedKeysHolen(verbindung, host, benutzer);
+      if (stand.sha256 !== ziel.vorher) {
+        throw new VorgangsFehler(
+          `authorized_keys von ${benutzer}@${host.name} wurde seit dem Trockenlauf geändert. Bitte neuen Trockenlauf starten.`,
+        );
+      }
+      const soll = await sollFuer(host.id, benutzer);
+      const ergebnis = blockSetzen(stand.inhalt, soll.eintraege, soll.pflicht);
+      if (hashVon(ergebnis.inhalt) !== ziel.nachher) {
+        throw new VorgangsFehler(
+          `Die Zuweisungen für ${benutzer}@${host.name} haben sich seit dem Trockenlauf geändert. Bitte neuen Trockenlauf starten.`,
+        );
+      }
+      await authorizedKeysSchreiben(verbindung, host, benutzer, ergebnis.inhalt, stand.sha256);
+      await protokollieren({
+        akteur: akteur ?? "System",
+        aktion: "authorized_keys.geschrieben",
+        ergebnis: "ERFOLG",
+        hostName: host.name,
+        zielbenutzer: benutzer,
+        diff: ergebnis.diff
+          .filter((z) => z.art !== "kontext")
+          .map((z) => `${z.art === "hinzu" ? "+" : "-"} ${z.text}`)
+          .join("\n"),
+        details: {
+          vorher: stand.sha256,
+          nachher: inhaltHash(Buffer.from(ergebnis.inhalt, "utf8")),
+          trockenlaufId,
+        },
+      });
+      return { hostId: host.id, zielbenutzer: benutzer, erfolg: true };
+    },
+    (host, benutzer, fehler) => ({
+      hostId: host.id,
+      zielbenutzer: benutzer,
+      erfolg: false,
+      fehler: fehlerText(fehler),
+    }),
+  );
+
+  // Zustand der Verwendungen nachziehen – auch fuer Ziele ohne Aenderung, die schon stimmten.
+  const fehlgeschlagen = new Set(
+    ausgaenge.filter((a) => !a.erfolg).map((a) => `${a.hostId}\u0000${a.zielbenutzer}`),
+  );
+  // Fehlschlaege zuletzt: eine Gruppen-Verwendung, die auf einem Host scheitert, soll
+  // FEHLGESCHLAGEN bleiben, auch wenn ein anderer Host danach erfolgreich war.
+  const reihenfolge = plan.ziele
+    .filter((z) => !z.fehler)
+    .sort(
+      (a, b) =>
+        Number(fehlgeschlagen.has(`${a.hostId}\u0000${a.zielbenutzer}`)) -
+        Number(fehlgeschlagen.has(`${b.hostId}\u0000${b.zielbenutzer}`)),
+    );
+  for (const ziel of reihenfolge) {
+    const schluessel = `${ziel.hostId}\u0000${ziel.zielbenutzer}`;
+    const soll = await sollFuer(ziel.hostId, ziel.zielbenutzer);
+    const jetzt = new Date();
+    if (fehlgeschlagen.has(schluessel)) {
+      await prisma.publicVerwendung.updateMany({
+        where: { id: { in: soll.verwendungIds.drin } },
+        data: { zustand: "FEHLGESCHLAGEN" },
+      });
+      continue;
+    }
+    await prisma.publicVerwendung.updateMany({
+      where: { id: { in: soll.verwendungIds.drin } },
+      data: { zustand: "AUSGEROLLT", zuletztAngewendetAm: jetzt },
+    });
+    await prisma.publicVerwendung.updateMany({
+      where: { id: { in: soll.verwendungIds.raus }, zustand: "ENTFERNEN" },
+      data: { zustand: "ENTFERNT", zuletztAngewendetAm: jetzt },
+    });
+  }
+
+  const fehler = ausgaenge.filter((a) => !a.erfolg);
+  if (fehler.length > 0 && fehler.length === ausgaenge.length) {
+    throw new VorgangsFehler(fehler.map((f) => f.fehler).join(" "));
+  }
+  return { ergebnis: { geschrieben: ausgaenge.filter((a) => a.erfolg).length, fehler } };
+};
diff --git a/src/worker/handler.ts b/src/worker/handler.ts
index 0596c06..dae834e 100644
--- a/src/worker/handler.ts
+++ b/src/worker/handler.ts
@@ -1,12 +1,15 @@
 import type { HandlerTabelle } from "@/worker/ausfuehren";
+import { ausrollenHandler, trockenlaufHandler } from "@/worker/ablaeufe/ausrollen";
 import { bootstrapHandler } from "@/worker/ablaeufe/bootstrap";
 import { erreichbarkeitHandler, hostKeyAbrufenHandler } from "@/worker/ablaeufe/hostkey";
 
 /**
- * Welche Vorgangsart wer ausfuehrt. Waechst mit den Issues: Ausrollen (#016), Abgleich (#021) …
+ * Welche Vorgangsart wer ausfuehrt. Waechst mit den Issues: Abgleich (#021) …
  */
 export const HANDLER: HandlerTabelle = {
   HOSTKEY_ABRUFEN: hostKeyAbrufenHandler,
   ERREICHBARKEIT: erreichbarkeitHandler,
   BOOTSTRAP: bootstrapHandler,
+  TROCKENLAUF: trockenlaufHandler,
+  AUSROLLEN: ausrollenHandler,
 };
diff --git a/src/worker/ssh/authorized-keys-datei.ts b/src/worker/ssh/authorized-keys-datei.ts
new file mode 100644
index 0000000..db2226d
--- /dev/null
+++ b/src/worker/ssh/authorized-keys-datei.ts
@@ -0,0 +1,141 @@
+import { createHash } from "node:crypto";
+import type { Client } from "ssh2";
+import type { Host } from "@/generated/prisma/client";
+import { BENUTZERNAME_MUSTER, shellQuote } from "@/lib/shell";
+import { VorgangsFehler } from "@/worker/ausfuehren";
+import { befehlAusfuehren } from "@/worker/ssh/verbindung";
+
+/**
+ * authorized_keys eines Benutzers auf einem Host lesen und schreiben (#016).
+ *
+ * Wie beim Bootstrap: alles im Home des Zielbenutzers geschieht **als dieser Benutzer**
+ * (`runuser`), damit ein Symlink root nie eine fremde Datei lesen oder schreiben laesst.
+ * Der Hash der Datei wird auf dem Host berechnet und beim Schreiben dort erneut geprueft –
+ * hat sich die Datei seit dem Trockenlauf geaendert, bricht der Vorgang ab.
+ */
+
+/** Hash fuer „Datei gibt es nicht“. */
+export const KEINE_DATEI = "keine-datei";
+/** So viele Sicherungen bleiben je Datei liegen. */
+const SICHERUNGEN_BEHALTEN = 5;
+
+const MARKE_FEHLT = "SSHKV-BENUTZER-FEHLT";
+const MARKE_GEAENDERT = "SSHKV-GEAENDERT";
+const MARKE_OK = "SSHKV-GESCHRIEBEN";
+
+export type DateiStand = {
+  readonly pfad: string;
+  readonly vorhanden: boolean;
+  readonly sha256: string;
+  readonly inhalt: string;
+};
+
+function praefix(host: Pick<Host, "anmeldeart">): string {
+  return host.anmeldeart === "ROOT" ? "" : "sudo -n ";
+}
+
+function benutzerPruefen(benutzer: string): void {
+  if (!BENUTZERNAME_MUSTER.test(benutzer)) throw new VorgangsFehler(`Ungültiger Zielbenutzer „${benutzer}“.`);
+}
+
+export function inhaltHash(inhalt: Buffer | null): string {
+  return inhalt === null ? KEINE_DATEI : createHash("sha256").update(inhalt).digest("hex");
+}
+
+/**
+ * Liest die Datei. Ausgabeformat des Skripts: erste Zeile `<Home> <ja|nein>`, danach die Datei
+ * unveraendert – so kommen auch Bytes an, die kein Text sind.
+ */
+export async function authorizedKeysHolen(
+  verbindung: Client,
+  host: Host,
+  benutzer: string,
+): Promise<DateiStand> {
+  benutzerPruefen(benutzer);
+  const skript = `set -eu
+B=${shellQuote(benutzer)}
+getent passwd "$B" >/dev/null || { echo ${MARKE_FEHLT}; exit 3; }
+H=$(getent passwd "$B" | cut -d: -f6)
+D="$H/.ssh/authorized_keys"
+if runuser -u "$B" -- test -e "$D"; then echo "$H ja"; runuser -u "$B" -- cat "$D"; else echo "$H nein"; fi`;
+  const ergebnis = await befehlAusfuehren(
+    verbindung,
+    `${praefix(host)}sh -c ${shellQuote(skript)}`,
+    undefined,
+    true,
+  );
+  const roh = ergebnis.rohStdout ?? Buffer.alloc(0);
+  if (roh.toString("utf8").startsWith(MARKE_FEHLT)) {
+    throw new VorgangsFehler(`Den Benutzer „${benutzer}“ gibt es auf ${host.name} nicht.`);
+  }
+  if (ergebnis.code !== 0) {
+    throw new VorgangsFehler(`authorized_keys von ${benutzer}@${host.name} ließ sich nicht lesen.`);
+  }
+  const zeilenende = roh.indexOf(0x0a);
+  const kopf = roh.subarray(0, zeilenende).toString("utf8");
+  const vorhanden = kopf.endsWith(" ja");
+  const home = kopf.replace(/ (ja|nein)$/, "");
+  const inhalt = roh.subarray(zeilenende + 1);
+  // Nur gueltiges UTF-8 wird bearbeitet: sonst gingen fremde Bytes beim Zurueckschreiben
+  // verloren, und „bytegenau“ waere gebrochen.
+  if (!Buffer.from(inhalt.toString("utf8"), "utf8").equals(inhalt)) {
+    throw new VorgangsFehler(
+      `authorized_keys von ${benutzer}@${host.name} enthält ungültiges UTF-8. Bitte von Hand prüfen.`,
+    );
+  }
+  return {
+    pfad: `${home}/.ssh/authorized_keys`,
+    vorhanden,
+    sha256: inhaltHash(vorhanden ? inhalt : null),
+    inhalt: inhalt.toString("utf8"),
+  };
+}
+
+/**
+ * Schreibt die Datei, wenn ihr Hash auf dem Host noch `erwartet` ist: Sicherung, Temp-Datei,
+ * Rechte, `mv`. Alte Sicherungen ueber SICHERUNGEN_BEHALTEN hinaus werden entfernt.
+ */
+export async function authorizedKeysSchreiben(
+  verbindung: Client,
+  host: Host,
+  benutzer: string,
+  inhalt: string,
+  erwartet: string,
+): Promise<{ sicherung: boolean }> {
+  benutzerPruefen(benutzer);
+  if (!/^([0-9a-f]{64}|keine-datei)$/.test(erwartet)) throw new VorgangsFehler("Ungültiger Datei-Hash.");
+  const skript = `set -eu
+umask 077
+B=${shellQuote(benutzer)}
+ERWARTET=${shellQuote(erwartet)}
+getent passwd "$B" >/dev/null || { echo ${MARKE_FEHLT}; exit 3; }
+H=$(getent passwd "$B" | cut -d: -f6)
+als() { runuser -u "$B" -- "$@"; }
+als mkdir -p "$H/.ssh"
+als chmod 0700 "$H/.ssh"
+D="$H/.ssh/authorized_keys"
+if als test -e "$D"; then IST=$(als cat "$D" | sha256sum | cut -d' ' -f1); else IST=${KEINE_DATEI}; fi
+[ "$IST" = "$ERWARTET" ] || { echo ${MARKE_GEAENDERT}; exit 4; }
+if als test -e "$D"; then
+  als cp -p "$D" "$D.sshkv.bak.$(date +%Y%m%d-%H%M%S)"
+  als sh -c 'ls -1t "$1".sshkv.bak.* 2>/dev/null | tail -n +${SICHERUNGEN_BEHALTEN + 1} | while read -r alt; do rm -f -- "$alt"; done' sh "$D"
+fi
+N=$(als mktemp "$H/.ssh/.sshkv.tmp.XXXXXX")
+als tee "$N" >/dev/null
+als chmod 0600 "$N"
+als mv "$N" "$D"
+echo ${MARKE_OK}`;
+  const ergebnis = await befehlAusfuehren(verbindung, `${praefix(host)}sh -c ${shellQuote(skript)}`, inhalt);
+  if (ergebnis.stdout.includes(MARKE_GEAENDERT)) {
+    throw new VorgangsFehler(
+      `authorized_keys von ${benutzer}@${host.name} wurde seit dem Trockenlauf geändert. Bitte neuen Trockenlauf starten.`,
+    );
+  }
+  if (ergebnis.stdout.includes(MARKE_FEHLT)) {
+    throw new VorgangsFehler(`Den Benutzer „${benutzer}“ gibt es auf ${host.name} nicht.`);
+  }
+  if (ergebnis.code !== 0 || !ergebnis.stdout.includes(MARKE_OK)) {
+    throw new VorgangsFehler(`authorized_keys von ${benutzer}@${host.name} ließ sich nicht schreiben.`);
+  }
+  return { sicherung: erwartet !== KEINE_DATEI };
+}
diff --git a/src/worker/ssh/verbindung.ts b/src/worker/ssh/verbindung.ts
index 8f1f972..c00ebf9 100644
--- a/src/worker/ssh/verbindung.ts
+++ b/src/worker/ssh/verbindung.ts
@@ -189,7 +189,13 @@ function verbindungsFehler(fehler: unknown, ziel: Ziel): VorgangsFehler {
   return new VorgangsFehler(`SSH-Verbindung zu ${ziel.adresse} fehlgeschlagen.`, { cause: fehler });
 }
 
-export type Befehlsergebnis = { readonly stdout: string; readonly stderr: string; readonly code: number };
+export type Befehlsergebnis = {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly code: number;
+  /** Nur mit `roh = true`: stdout als Bytes, fuer Dateien, die exakt ankommen muessen. */
+  readonly rohStdout?: Buffer;
+};
 
 /**
  * Fuehrt einen Befehl aus. `stdin` wird geschrieben und geschlossen – so reisen Dateiinhalte
@@ -199,6 +205,7 @@ export function befehlAusfuehren(
   client: Client,
   befehl: string,
   stdin?: string | Buffer,
+  roh = false,
 ): Promise<Befehlsergebnis> {
   return new Promise((erfuellen, ablehnen) => {
     client.exec(befehl, (fehler, strom) => {
@@ -227,8 +234,10 @@ export function befehlAusfuehren(
         if (laenge > AUSGABE_HOECHSTENS) {
           return ablehnen(new VorgangsFehler("Der Host lieferte mehr Ausgabe als erwartet."));
         }
+        const stdout = Buffer.concat(ausgabe);
         erfuellen({
-          stdout: Buffer.concat(ausgabe).toString("utf8"),
+          ...(roh ? { rohStdout: stdout } : {}),
+          stdout: stdout.toString("utf8"),
           stderr: Buffer.concat(fehlerAusgabe).toString("utf8"),
           code: code ?? -1,
         });
diff --git a/tests/integration/ausrollen.test.ts b/tests/integration/ausrollen.test.ts
new file mode 100644
index 0000000..47e714c
--- /dev/null
+++ b/tests/integration/ausrollen.test.ts
@@ -0,0 +1,195 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { prisma } from "@/lib/db";
+import { schluesselpaarErzeugen } from "@/lib/ssh/openssh";
+import { publicVerwendungAnlegen, publicVerwendungEntfernen } from "@/server/services/verwendungen";
+import { deploymentKeySicherstellen } from "@/worker/geheimnisse";
+import type { Plan } from "@/worker/ablaeufe/ausrollen";
+import { datenbankLeeren } from "../hilfen/db";
+import { eingerichteterHost, masterKeyAnlegen, vorgangLaufen } from "./hilfen/host";
+import { befehlAlsRoot, zielA, zielBereit } from "./hilfen/ziele";
+
+/** Public Keys ausrollen gegen ein echtes sshd (#016). */
+
+const AKTEUR = { id: "test", name: "Test" };
+let aufraeumen: () => void;
+
+beforeAll(async () => {
+  await zielBereit(zielA);
+  aufraeumen = masterKeyAnlegen();
+});
+afterAll(() => aufraeumen());
+
+beforeEach(async () => {
+  await datenbankLeeren();
+  await deploymentKeySicherstellen();
+  await befehlAlsRoot(
+    zielA,
+    "userdel -r sshkv 2>/dev/null; rm -f /etc/sudoers.d/sshkv /root/.ssh/authorized_keys* /home/test/.ssh/authorized_keys*; true",
+  );
+});
+
+async function schluesselAnlegen(name: string) {
+  const paar = await schluesselpaarErzeugen("ED25519", { kommentar: `sshkv:${name}` });
+  return prisma.schluessel.create({
+    data: {
+      name,
+      slug: name,
+      typ: "ED25519",
+      kategorie: "DIENST",
+      publicKey: paar.publicKeyZeile,
+      fingerprint: paar.fingerprint,
+      kommentar: `sshkv:${name}`,
+    },
+  });
+}
+
+async function trockenlauf(schluesselId: string) {
+  const vorgang = await vorgangLaufen("TROCKENLAUF", {
+    eingabe: {
+      ziele: (
+        await prisma.publicVerwendung.findMany({
+          where: { schluesselId },
+          include: { hostgruppe: { include: { mitglieder: true } } },
+        })
+      ).flatMap((v) =>
+        v.hostId
+          ? [{ hostId: v.hostId, zielbenutzer: v.zielbenutzer }]
+          : (v.hostgruppe?.mitglieder.map((m) => ({ hostId: m.hostId, zielbenutzer: v.zielbenutzer })) ?? []),
+      ),
+    },
+  });
+  expect(vorgang.status).toBe("ERLEDIGT");
+  return { id: vorgang.id, plan: vorgang.plan as unknown as Plan };
+}
+
+const datei = async (pfad: string) => (await befehlAlsRoot(zielA, `cat ${pfad} 2>/dev/null || true`)).stdout;
+
+describe("Public Key ausrollen", () => {
+  it("zeigt im Trockenlauf die Aenderung, schreibt erst beim Ausrollen", async () => {
+    const host = await eingerichteterHost(zielA, "ziel-a");
+    await befehlAlsRoot(zielA, "mkdir -p /root/.ssh && printf '# von Hand\\n' > /root/.ssh/authorized_keys");
+    const schluessel = await schluesselAnlegen("backup");
+    const verwendungId = await publicVerwendungAnlegen(
+      {
+        schluesselId: schluessel.id,
+        hostId: host.id,
+        zielbenutzer: "root",
+        optionen: 'restrict,from="10.0.0.12"',
+      },
+      AKTEUR,
+    );
+
+    const { id, plan } = await trockenlauf(schluessel.id);
+    expect(plan.ziele).toHaveLength(1);
+    expect(plan.ziele[0]).toMatchObject({
+      zielbenutzer: "root",
+      geaendert: true,
+      pfad: "/root/.ssh/authorized_keys",
+    });
+    expect(plan.ziele[0]!.diff).toContainEqual({
+      art: "hinzu",
+      text: `restrict,from="10.0.0.12" ${schluessel.publicKey}`,
+    });
+    expect(await datei("/root/.ssh/authorized_keys")).toBe("# von Hand\n");
+
+    const ausrollen = await vorgangLaufen("AUSROLLEN", { eingabe: { trockenlaufId: id } });
+    expect(ausrollen.fehler).toBeNull();
+    const inhalt = await datei("/root/.ssh/authorized_keys");
+    expect(inhalt).toBe(
+      `# von Hand\n# BEGIN SSHKV MANAGED – nicht manuell bearbeiten\nrestrict,from="10.0.0.12" ${schluessel.publicKey}\n# END SSHKV MANAGED\n`,
+    );
+    expect((await prisma.publicVerwendung.findUniqueOrThrow({ where: { id: verwendungId } })).zustand).toBe(
+      "AUSGEROLLT",
+    );
+    expect((await befehlAlsRoot(zielA, "ls /root/.ssh | grep -c sshkv.bak")).stdout.trim()).toBe("1");
+    expect((await befehlAlsRoot(zielA, "stat -c %a /root/.ssh/authorized_keys")).stdout.trim()).toBe("600");
+    const eintrag = await prisma.protokoll.findFirst({ where: { aktion: "authorized_keys.geschrieben" } });
+    expect(eintrag?.diff).toContain("+ restrict");
+
+    // Derselbe Trockenlauf nicht zweimal.
+    const nochmal = await vorgangLaufen("AUSROLLEN", { eingabe: { trockenlaufId: id } });
+    expect(nochmal.fehler).toMatch(/bereits ausgeführt/);
+  });
+
+  it("bricht ab, wenn die Datei seit dem Trockenlauf geaendert wurde", async () => {
+    const host = await eingerichteterHost(zielA, "ziel-a");
+    const schluessel = await schluesselAnlegen("backup");
+    await publicVerwendungAnlegen(
+      { schluesselId: schluessel.id, hostId: host.id, zielbenutzer: "root" },
+      AKTEUR,
+    );
+    const { id } = await trockenlauf(schluessel.id);
+    await befehlAlsRoot(zielA, "mkdir -p /root/.ssh && echo '# dazwischen' >> /root/.ssh/authorized_keys");
+    const ausrollen = await vorgangLaufen("AUSROLLEN", { eingabe: { trockenlaufId: id } });
+    expect(ausrollen.status).toBe("FEHLGESCHLAGEN");
+    expect(ausrollen.fehler).toMatch(/seit dem Trockenlauf geändert/);
+    expect(await datei("/root/.ssh/authorized_keys")).toBe("# dazwischen\n");
+  });
+
+  it("bricht ab, wenn sich die Zuweisungen seit dem Trockenlauf geaendert haben", async () => {
+    const host = await eingerichteterHost(zielA, "ziel-a");
+    const a = await schluesselAnlegen("a");
+    const b = await schluesselAnlegen("b");
+    await publicVerwendungAnlegen({ schluesselId: a.id, hostId: host.id, zielbenutzer: "root" }, AKTEUR);
+    const { id } = await trockenlauf(a.id);
+    await publicVerwendungAnlegen({ schluesselId: b.id, hostId: host.id, zielbenutzer: "root" }, AKTEUR);
+    const ausrollen = await vorgangLaufen("AUSROLLEN", { eingabe: { trockenlaufId: id } });
+    expect(ausrollen.fehler).toMatch(/Zuweisungen .* geändert/);
+  });
+
+  it("entfernt einen Schluessel wieder, und der Deployment-Key bleibt", async () => {
+    const host = await eingerichteterHost(zielA, "ziel-a");
+    const schluessel = await schluesselAnlegen("weg");
+    const id = await publicVerwendungAnlegen(
+      { schluesselId: schluessel.id, hostId: host.id, zielbenutzer: "sshkv" },
+      AKTEUR,
+    );
+    const erster = await trockenlauf(schluessel.id);
+    // Im Block des Dienstbenutzers steht der Deployment-Key schon; nur der neue kommt hinzu.
+    expect(erster.plan.ziele[0]!.diff.filter((z) => z.art !== "kontext")).toEqual([
+      { art: "hinzu", text: schluessel.publicKey },
+    ]);
+    await vorgangLaufen("AUSROLLEN", { eingabe: { trockenlaufId: erster.id } });
+    expect(await datei("/home/sshkv/.ssh/authorized_keys")).toContain(schluessel.publicKey);
+
+    await publicVerwendungEntfernen(id, AKTEUR);
+    const zweiter = await trockenlauf(schluessel.id);
+    expect(zweiter.plan.ziele[0]!.diff).toContainEqual({ art: "entfernt", text: schluessel.publicKey });
+    await vorgangLaufen("AUSROLLEN", { eingabe: { trockenlaufId: zweiter.id } });
+    const inhalt = await datei("/home/sshkv/.ssh/authorized_keys");
+    expect(inhalt).not.toContain(schluessel.publicKey);
+    expect(inhalt).toContain("sshkv-deployment@");
+    expect((await prisma.publicVerwendung.findUniqueOrThrow({ where: { id } })).zustand).toBe("ENTFERNT");
+  });
+
+  it("rollt ueber eine Hostgruppe fuer einen gewoehnlichen Benutzer aus", async () => {
+    const host = await eingerichteterHost(zielA, "ziel-a");
+    const gruppe = await prisma.hostgruppe.create({
+      data: { name: "Test", mitglieder: { create: { hostId: host.id } } },
+    });
+    const schluessel = await schluesselAnlegen("gruppe");
+    await publicVerwendungAnlegen(
+      { schluesselId: schluessel.id, hostgruppeId: gruppe.id, zielbenutzer: "test" },
+      AKTEUR,
+    );
+    const { id } = await trockenlauf(schluessel.id);
+    await vorgangLaufen("AUSROLLEN", { eingabe: { trockenlaufId: id } });
+    expect(await datei("/home/test/.ssh/authorized_keys")).toContain(schluessel.publicKey);
+    const besitz = await befehlAlsRoot(
+      zielA,
+      "stat -c '%U %a' /home/test/.ssh /home/test/.ssh/authorized_keys",
+    );
+    expect(besitz.stdout).toBe("test 700\ntest 600\n");
+  });
+
+  it("meldet einen fehlenden Benutzer im Trockenlauf je Ziel", async () => {
+    const host = await eingerichteterHost(zielA, "ziel-a");
+    const schluessel = await schluesselAnlegen("niemand");
+    await publicVerwendungAnlegen(
+      { schluesselId: schluessel.id, hostId: host.id, zielbenutzer: "gibtsnicht" },
+      AKTEUR,
+    );
+    const { plan } = await trockenlauf(schluessel.id);
+    expect(plan.ziele[0]!.fehler).toMatch(/gibt es auf ziel-a nicht/);
+  });
+});
diff --git a/tests/integration/hilfen/host.ts b/tests/integration/hilfen/host.ts
new file mode 100644
index 0000000..455352b
--- /dev/null
+++ b/tests/integration/hilfen/host.ts
@@ -0,0 +1,60 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { prisma } from "@/lib/db";
+import { verschluesseln } from "@/lib/geheimnisse";
+import { vorgangAusfuehren } from "@/worker/ausfuehren";
+import { masterKeyVergessen } from "@/worker/geheimnisse";
+import { HANDLER } from "@/worker/handler";
+import { rootPasswort, type Ziel } from "./ziele";
+
+/** Gemeinsame Vorbereitung fuer Integrationstests: Master-Key, Host mit Bootstrap (#016). */
+
+export function masterKeyAnlegen(): () => void {
+  const verzeichnis = mkdtempSync(path.join(tmpdir(), "sshkv-master-"));
+  const datei = path.join(verzeichnis, "master.key");
+  writeFileSync(datei, randomBytes(32), { mode: 0o600 });
+  process.env["SSHKV_MASTER_KEY_FILE"] = datei;
+  masterKeyVergessen();
+  return () => rmSync(verzeichnis, { recursive: true, force: true });
+}
+
+export async function vorgangLaufen(
+  art: "HOSTKEY_ABRUFEN" | "BOOTSTRAP" | "TROCKENLAUF" | "AUSROLLEN",
+  daten: {
+    hostId?: string;
+    eingabe?: object;
+    geheim?: string;
+    angefordertVonId?: string;
+  },
+) {
+  const vorgang = await prisma.vorgang.create({
+    data: {
+      art,
+      hostId: daten.hostId ?? null,
+      eingabe: daten.eingabe ?? {},
+      angefordertVonId: daten.angefordertVonId ?? null,
+    },
+  });
+  await vorgangAusfuehren(vorgang.id, HANDLER, daten.geheim);
+  return prisma.vorgang.findUniqueOrThrow({ where: { id: vorgang.id } });
+}
+
+/** Host anlegen, Host-Key vertrauen, Bootstrap per root-Passwort. */
+export async function eingerichteterHost(
+  ziel: Ziel,
+  name: string,
+  anmeldeart: "DIENSTBENUTZER" | "ROOT" = "DIENSTBENUTZER",
+) {
+  const host = await prisma.host.create({ data: { name, adresse: ziel.host, port: ziel.port, anmeldeart } });
+  await vorgangLaufen("HOSTKEY_ABRUFEN", { hostId: host.id });
+  await prisma.hostSchluessel.updateMany({ where: { hostId: host.id }, data: { status: "VERTRAUT" } });
+  const bootstrap = await vorgangLaufen("BOOTSTRAP", {
+    hostId: host.id,
+    eingabe: { modus: "passwort", benutzer: "root" },
+    geheim: verschluesseln(rootPasswort()),
+  });
+  if (bootstrap.status !== "ERLEDIGT") throw new Error(`Bootstrap fehlgeschlagen: ${bootstrap.fehler}`);
+  return prisma.host.findUniqueOrThrow({ where: { id: host.id } });
+}

From 30f271b23a1e7c834f9e1e19bac7b3e0d85e0f26 Mon Sep 17 00:00:00 2001
From: Florian Wilde <wilde.florian@gmail.com>
Date: Mon, 12 Oct 2026 10:19:27 +0200
Subject: [PATCH 2/3] feat(hosts): Schluessel auf dem Host anzeigen und
 ausrollen (#016)

Die Hostseite listet, welche Public und Private Keys sshkv dort
verwaltet - direkt oder ueber eine Hostgruppe - mit Zustand als Punkt
und Text. Ein Dry-Run je Host zeigt das Diff aller Benutzer dieses
Hosts und rollt nach Bestaetigung aus.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/app/(app)/hosts/[id]/page.tsx             | 70 +++++++++++++++++--
 src/components/ausrollen/AusrollenPanel.tsx   |  6 +-
 .../ausrollen/VerwendungsZustand.tsx          | 28 ++++++++
 src/server/actions/verwendungen.ts            |  9 ++-
 src/server/queries/ziele.ts                   | 33 +++++++++
 src/server/services/soll.ts                   | 13 +++-
 src/server/services/verwendungen.ts           |  5 +-
 7 files changed, 151 insertions(+), 13 deletions(-)
 create mode 100644 src/components/ausrollen/VerwendungsZustand.tsx

diff --git a/src/app/(app)/hosts/[id]/page.tsx b/src/app/(app)/hosts/[id]/page.tsx
index 90fa9f8..8ddf26d 100644
--- a/src/app/(app)/hosts/[id]/page.tsx
+++ b/src/app/(app)/hosts/[id]/page.tsx
@@ -18,6 +18,9 @@ import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { hostDetail, type HostDetail } from "@/server/queries/hosts";
 import { BootstrapAktionen } from "./BootstrapAktionen";
 import { sshdHinweise } from "@/lib/sshd-hinweise";
+import { AusrollenPanel } from "@/components/ausrollen/AusrollenPanel";
+import { VerwendungsZustand } from "@/components/ausrollen/VerwendungsZustand";
+import { verwendungenAufHost } from "@/server/queries/ziele";
 import { HostKeyAktionen } from "./HostKeyAktionen";
 import { HostKeyEntscheidung } from "./HostKeyEntscheidung";
 import { bootstrapBefehlFuer } from "@/server/queries/bootstrap";
@@ -95,6 +98,8 @@ export default async function HostSeite({ params }: { params: Promise<{ id: stri
   const archiviert = host.archiviertAm !== null;
   const verwalten = darf(benutzer.rolle, "hostsVerwalten") && !archiviert;
   const darfEntscheiden = darf(benutzer.rolle, "hostKeyEntscheiden") && !archiviert;
+  const darfAusrollen = darf(benutzer.rolle, "publicKeyAusrollen") && !archiviert;
+  const verwendungen = await verwendungenAufHost(host.id);
   const jetzt = new Date();
 
   return (
@@ -217,7 +222,7 @@ export default async function HostSeite({ params }: { params: Promise<{ id: stri
 
       <Karte
         titel="Schlüssel auf diesem Host"
-        untertitel={`${host.publicVerwendungen} Public-Key-Verwendungen · ${host.privateVerwendungen} Private-Key-Verwendungen`}
+        untertitel="Public Keys in authorized_keys und Private Keys, die sshkv hier verwaltet"
       >
         {host.zielkonten.length > 0 && (
           <p className="text-muted mb-4 text-[14px]">
@@ -230,11 +235,64 @@ export default async function HostSeite({ params }: { params: Promise<{ id: stri
             ))}
           </p>
         )}
-        <Leerzustand
-          icon={<KeyRound className="size-5" />}
-          titel="Folgt mit #016"
-          text="Hier erscheinen die Public und Private Keys, die sshkv auf diesem Host verwaltet."
-        />
+        {verwendungen.oeffentlich.length === 0 && verwendungen.privat.length === 0 ? (
+          <Leerzustand
+            icon={<KeyRound className="size-5" />}
+            titel="Noch keine Schlüssel zugewiesen"
+            text="Zuweisen geht über die Seite eines Schlüssels („+ Ausrollen“)."
+          />
+        ) : (
+          <ul className="flex flex-col">
+            {verwendungen.oeffentlich.map((v) => (
+              <li
+                key={v.id}
+                className="border-border flex flex-col gap-1 border-b py-3 first:pt-0 last:border-b-0 sm:flex-row sm:items-center sm:justify-between sm:gap-4"
+              >
+                <span className="min-w-0">
+                  <a
+                    href={`/schluessel/${v.schluessel.id}`}
+                    className="text-text hover:text-accent font-medium"
+                  >
+                    {v.schluessel.name}
+                  </a>
+                  <span className="text-muted block font-mono text-[12.5px] break-all">
+                    Public · {v.zielbenutzer}@{host.name}
+                    {v.hostgruppe ? ` · über ${v.hostgruppe.name}` : ""}
+                    {v.optionen ? ` · ${v.optionen}` : ""}
+                  </span>
+                </span>
+                <VerwendungsZustand zustand={v.zustand} />
+              </li>
+            ))}
+            {verwendungen.privat.map((v) => (
+              <li
+                key={v.id}
+                className="border-border flex flex-col gap-1 border-b py-3 first:pt-0 last:border-b-0 sm:flex-row sm:items-center sm:justify-between sm:gap-4"
+              >
+                <span className="min-w-0">
+                  <a
+                    href={`/schluessel/${v.schluessel.id}`}
+                    className="text-text hover:text-accent font-medium"
+                  >
+                    {v.schluessel.name}
+                  </a>
+                  <span className="text-muted block font-mono text-[12.5px] break-all">
+                    Private · {v.zielbenutzer}@{host.name}:{v.pfad}
+                  </span>
+                </span>
+                <VerwendungsZustand zustand={v.zustand} />
+              </li>
+            ))}
+          </ul>
+        )}
+        {darfAusrollen && verwendungen.oeffentlich.length > 0 && host.bootstrapAm && (
+          <div className="border-border mt-5 border-t pt-5">
+            <AusrollenPanel
+              auswahl={{ hostId: host.id }}
+              offen={verwendungen.oeffentlich.filter((v) => v.zustand !== "AUSGEROLLT").length}
+            />
+          </div>
+        )}
       </Karte>
 
       {verwalten && (
diff --git a/src/components/ausrollen/AusrollenPanel.tsx b/src/components/ausrollen/AusrollenPanel.tsx
index fc4a82b..96d236e 100644
--- a/src/components/ausrollen/AusrollenPanel.tsx
+++ b/src/components/ausrollen/AusrollenPanel.tsx
@@ -6,7 +6,7 @@ import { useEffect, useState, useTransition } from "react";
 import { Button } from "@/components/ui/Button";
 import { DiffBox } from "@/components/ui/DiffBox";
 import { laeuftNoch, useVorgang } from "@/components/vorgang/useVorgang";
-import { ausrollenAktion, trockenlaufAktion } from "@/server/actions/verwendungen";
+import { ausrollenAktion, trockenlaufAktion, type AusrollAuswahl } from "@/server/actions/verwendungen";
 import type { DiffZeile } from "@/lib/ssh/zeilen-diff";
 
 /**
@@ -24,7 +24,7 @@ type PlanZiel = {
   fehler?: string;
 };
 
-export function AusrollenPanel({ schluesselId, offen }: { schluesselId: string; offen: number }) {
+export function AusrollenPanel({ auswahl, offen }: { auswahl: AusrollAuswahl; offen: number }) {
   const router = useRouter();
   const [trockenlaufId, setTrockenlaufId] = useState<string>();
   const [ausrollenId, setAusrollenId] = useState<string>();
@@ -52,7 +52,7 @@ export function AusrollenPanel({ schluesselId, offen }: { schluesselId: string;
             starten(async () => {
               setFehler(undefined);
               setAusrollenId(undefined);
-              const antwort = await trockenlaufAktion(schluesselId);
+              const antwort = await trockenlaufAktion(auswahl);
               if (antwort.fehler) setFehler(antwort.fehler);
               else setTrockenlaufId(antwort.vorgangId);
             })
diff --git a/src/components/ausrollen/VerwendungsZustand.tsx b/src/components/ausrollen/VerwendungsZustand.tsx
new file mode 100644
index 0000000..16d6b10
--- /dev/null
+++ b/src/components/ausrollen/VerwendungsZustand.tsx
@@ -0,0 +1,28 @@
+import type { VerwendungsZustand as Zustand } from "@/generated/prisma/enums";
+import { clsx } from "clsx";
+
+/** Zustand einer Verwendung – immer Punkt und Text, nie nur Farbe (#016). */
+const ANZEIGE: Record<Zustand, { text: string; klasse: string; punkt: string }> = {
+  GEPLANT: { text: "noch nicht ausgerollt", klasse: "text-accent", punkt: "○" },
+  AUSGEROLLT: { text: "synchron", klasse: "text-ok", punkt: "●" },
+  ABWEICHUNG: { text: "Drift", klasse: "text-danger", punkt: "●" },
+  ENTFERNEN: { text: "wird entfernt", klasse: "text-accent", punkt: "○" },
+  ENTFERNT: { text: "entfernt", klasse: "text-muted", punkt: "○" },
+  FEHLGESCHLAGEN: { text: "fehlgeschlagen", klasse: "text-danger", punkt: "●" },
+};
+
+export function VerwendungsZustand({ zustand, className }: { zustand: Zustand; className?: string }) {
+  const anzeige = ANZEIGE[zustand];
+  return (
+    <span
+      className={clsx(
+        "inline-flex items-center gap-1.5 text-[13px] whitespace-nowrap",
+        anzeige.klasse,
+        className,
+      )}
+    >
+      <span aria-hidden>{anzeige.punkt}</span>
+      {anzeige.text}
+    </span>
+  );
+}
diff --git a/src/server/actions/verwendungen.ts b/src/server/actions/verwendungen.ts
index a88ac82..0a4e944 100644
--- a/src/server/actions/verwendungen.ts
+++ b/src/server/actions/verwendungen.ts
@@ -70,12 +70,17 @@ export async function publicEntfernenAktion(
   }
 }
 
-export async function trockenlaufAktion(schluesselId: string): Promise<VorgangsAntwort> {
+export type AusrollAuswahl = { readonly schluesselId: string } | { readonly hostId: string };
+
+export async function trockenlaufAktion(auswahl: AusrollAuswahl): Promise<VorgangsAntwort> {
   try {
     const { benutzer } = await rechtErforderlich("publicKeyAusrollen");
+    const id = z.string().min(1).max(64);
     return {
       vorgangId: await trockenlaufStarten(
-        { schluesselId: z.string().min(1).max(64).parse(schluesselId) },
+        "schluesselId" in auswahl
+          ? { schluesselId: id.parse(auswahl.schluesselId) }
+          : { hostId: id.parse(auswahl.hostId) },
         akteurVon(benutzer),
       ),
     };
diff --git a/src/server/queries/ziele.ts b/src/server/queries/ziele.ts
index a30b48b..06717b8 100644
--- a/src/server/queries/ziele.ts
+++ b/src/server/queries/ziele.ts
@@ -20,3 +20,36 @@ export async function zielAuswahl() {
 }
 
 export type ZielAuswahl = Awaited<ReturnType<typeof zielAuswahl>>;
+
+/** Was sshkv auf einem Host verwaltet (#016): Public Keys direkt und ueber Gruppen. */
+export async function verwendungenAufHost(hostId: string) {
+  const [oeffentlich, privat] = await Promise.all([
+    prisma.publicVerwendung.findMany({
+      where: {
+        zustand: { not: "ENTFERNT" },
+        OR: [{ hostId }, { hostgruppe: { mitglieder: { some: { hostId } } } }],
+      },
+      select: {
+        id: true,
+        zielbenutzer: true,
+        optionen: true,
+        zustand: true,
+        hostgruppe: { select: { name: true } },
+        schluessel: { select: { id: true, name: true, typ: true, fingerprint: true } },
+      },
+      orderBy: [{ zielbenutzer: "asc" }, { angelegtAm: "asc" }],
+    }),
+    prisma.privateVerwendung.findMany({
+      where: { hostId, zustand: { not: "ENTFERNT" } },
+      select: {
+        id: true,
+        zielbenutzer: true,
+        pfad: true,
+        zustand: true,
+        schluessel: { select: { id: true, name: true, typ: true, fingerprint: true } },
+      },
+      orderBy: [{ zielbenutzer: "asc" }, { pfad: "asc" }],
+    }),
+  ]);
+  return { oeffentlich, privat };
+}
diff --git a/src/server/services/soll.ts b/src/server/services/soll.ts
index 7ca83ba..698f6fa 100644
--- a/src/server/services/soll.ts
+++ b/src/server/services/soll.ts
@@ -100,11 +100,20 @@ export type Ziel = { readonly hostId: string; readonly zielbenutzer: string };
 export async function zieleVonVerwendungen(where: {
   schluesselId?: string;
   ids?: string[];
+  hostId?: string;
 }): Promise<Ziel[]> {
   const verwendungen = await prisma.publicVerwendung.findMany({
     where: {
       ...(where.schluesselId ? { schluesselId: where.schluesselId } : {}),
       ...(where.ids ? { id: { in: where.ids } } : {}),
+      ...(where.hostId
+        ? {
+            OR: [
+              { hostId: where.hostId },
+              { hostgruppe: { mitglieder: { some: { hostId: where.hostId } } } },
+            ],
+          }
+        : {}),
       zustand: { not: "ENTFERNT" },
     },
     select: {
@@ -117,9 +126,11 @@ export async function zieleVonVerwendungen(where: {
   });
   const ziele = new Map<string, Ziel>();
   for (const verwendung of verwendungen) {
-    const hostIds = verwendung.hostId
+    const alleHostIds = verwendung.hostId
       ? [verwendung.hostId]
       : (verwendung.hostgruppe?.mitglieder.filter((m) => !m.host.archiviertAm).map((m) => m.hostId) ?? []);
+    // Bei der Auswahl nach Host nur diesen Host, auch wenn die Verwendung an einer Gruppe haengt.
+    const hostIds = where.hostId ? alleHostIds.filter((id) => id === where.hostId) : alleHostIds;
     for (const hostId of hostIds) {
       ziele.set(`${hostId}\u0000${verwendung.zielbenutzer}`, {
         hostId,
diff --git a/src/server/services/verwendungen.ts b/src/server/services/verwendungen.ts
index 6e5e466..f375a93 100644
--- a/src/server/services/verwendungen.ts
+++ b/src/server/services/verwendungen.ts
@@ -117,13 +117,14 @@ export async function publicVerwendungEntfernen(id: string, akteur: Akteur): Pro
 
 /** Trockenlauf fuer die Ziele eines Schluessels oder fuer ausgewaehlte Verwendungen. */
 export async function trockenlaufStarten(
-  auswahl: { schluesselId?: string; verwendungIds?: string[]; ziele?: Ziel[] },
+  auswahl: { schluesselId?: string; hostId?: string; verwendungIds?: string[]; ziele?: Ziel[] },
   akteur: Akteur,
 ): Promise<string> {
   const ziele =
     auswahl.ziele ??
     (await zieleVonVerwendungen({
       ...(auswahl.schluesselId ? { schluesselId: auswahl.schluesselId } : {}),
+      ...(auswahl.hostId ? { hostId: auswahl.hostId } : {}),
       ...(auswahl.verwendungIds ? { ids: auswahl.verwendungIds } : {}),
     }));
   if (ziele.length === 0) throw new VerwendungsFehler("Es gibt nichts auszurollen.");
@@ -131,6 +132,7 @@ export async function trockenlaufStarten(
     art: "TROCKENLAUF",
     angefordertVonId: akteur.id,
     schluesselId: auswahl.schluesselId ?? null,
+    hostId: auswahl.hostId ?? null,
     eingabe: { ziele },
   });
 }
@@ -144,6 +146,7 @@ export async function ausrollenStarten(trockenlaufId: string, akteur: Akteur): P
     art: "AUSROLLEN",
     angefordertVonId: akteur.id,
     schluesselId: trockenlauf.schluesselId,
+    hostId: trockenlauf.hostId,
     eingabe: { trockenlaufId },
   });
 }

From 8056b8a0c9b8a12c633cc570234c76f7a5fd6f23 Mon Sep 17 00:00:00 2001
From: Florian Wilde <wilde.florian@gmail.com>
Date: Mon, 12 Oct 2026 10:21:54 +0200
Subject: [PATCH 3/3] test(ausrollen): Dry-Run und Ausrollen im Browser (#016)

Gebauter Stand mit Worker gegen das Testziel: Host einrichten, Dry-Run
zeigt das Diff, auf dem Host aendert sich noch nichts, nach dem
Anwenden steht der Key mit seinen Einschraenkungen im Block.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/anleitung/bilder/dry-run-desktop.png | Bin 0 -> 147635 bytes
 tests/e2e/ausrollen.spec.ts               | 103 ++++++++++++++++++++++
 2 files changed, 103 insertions(+)
 create mode 100644 docs/anleitung/bilder/dry-run-desktop.png
 create mode 100644 tests/e2e/ausrollen.spec.ts

diff --git a/docs/anleitung/bilder/dry-run-desktop.png b/docs/anleitung/bilder/dry-run-desktop.png
new file mode 100644
index 0000000000000000000000000000000000000000..534a8d8ce211dcb30e2cd14f02e3ae82ea80866e
GIT binary patch
literal 147635
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%0Ao9m=dkQ@l|`~
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%0DEhUr7gz?g4uWIv@Q_Cp>y~V83Ja6u2
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
DTC#^0

literal 0
HcmV?d00001

diff --git a/tests/e2e/ausrollen.spec.ts b/tests/e2e/ausrollen.spec.ts
new file mode 100644
index 0000000..44ca83c
--- /dev/null
+++ b/tests/e2e/ausrollen.spec.ts
@@ -0,0 +1,103 @@
+import { execFileSync } from "node:child_process";
+import { generateKeyPairSync, randomUUID } from "node:crypto";
+import { expect, test, type Page } from "@playwright/test";
+import pg from "pg";
+import "dotenv/config";
+import { fingerprintSha256 } from "../../src/lib/ssh/openssh";
+
+/**
+ * Public Key ausrollen ueber die Hostseite (#016), gebauter Stand + Worker, Testziel B.
+ * Schluessel und Zuweisung legt der Test direkt in der Entwicklungsdatenbank an (Praefix zz-),
+ * damit er nur den Ausroll-Weg prueft.
+ */
+const ZIEL_PORT = (process.env["SSHKV_TEST_ZIEL_B"] ?? "127.0.0.1:2222").split(":")[1] ?? "2222";
+const ROOT_PASSWORT = process.env["SSHKV_TEST_ROOT_PASSWORT"] || "sshkv-test";
+
+test.setTimeout(150_000);
+
+function aufZielB(befehl: string): string {
+  return execFileSync(
+    "docker",
+    ["compose", "-f", "docker-compose.test.yml", "exec", "-T", "ziel-b", "sh", "-c", befehl],
+    {
+      encoding: "utf8",
+    },
+  );
+}
+
+function publicKey(kommentar: string) {
+  const { publicKey: schluessel } = generateKeyPairSync("ed25519");
+  const roh = schluessel.export({ format: "der", type: "spki" }).subarray(-32);
+  const typ = Buffer.from("ssh-ed25519");
+  const blob = Buffer.concat([Buffer.from([0, 0, 0, typ.length]), typ, Buffer.from([0, 0, 0, 32]), roh]);
+  return {
+    zeile: `ssh-ed25519 ${blob.toString("base64")} ${kommentar}`,
+    fingerprint: fingerprintSha256(blob),
+  };
+}
+
+async function anmelden(page: Page) {
+  await page.goto("/anmelden");
+  await page.getByRole("link", { name: /Mit Mock-OIDC anmelden/ }).click();
+  await page.locator('button[data-rolle="admin"]').click();
+  await page.getByRole("button", { name: "Anmelden", exact: true }).click();
+  await expect(page.getByRole("heading", { name: "Übersicht" })).toBeVisible();
+}
+
+test.beforeAll(() => {
+  aufZielB("userdel -r sshkv 2>/dev/null; rm -f /etc/sudoers.d/sshkv /root/.ssh/authorized_keys*; true");
+});
+
+test("Public Key ueber die Hostseite ausrollen", async ({ page }) => {
+  const name = `zz-e2e-${Date.now().toString(36)}`;
+  await anmelden(page);
+
+  // Host einrichten wie in host-einrichten.spec.ts.
+  await page.goto("/hosts/neu");
+  await page.getByLabel("Name").fill(name);
+  await page.getByLabel("Adresse").fill("127.0.0.1");
+  await page.getByLabel("Port").fill(ZIEL_PORT);
+  await page.getByRole("button", { name: "Host anlegen" }).click();
+  await page.getByRole("button", { name: "Host-Key abrufen" }).click();
+  await page.getByRole("button", { name: "Fingerprint stimmt – vertrauen" }).click({ timeout: 30_000 });
+  await page.getByLabel("Passwort", { exact: true }).fill(ROOT_PASSWORT);
+  await page.getByRole("button", { name: "Zugang einrichten" }).click();
+  await expect(page.getByRole("button", { name: "Verbindung prüfen" })).toBeVisible({ timeout: 60_000 });
+  const hostId = page.url().split("/").pop()!;
+
+  // Schluessel und Zuweisung direkt anlegen.
+  const key = publicKey(`sshkv:${name}`);
+  const client = new pg.Client({ connectionString: process.env["DATABASE_URL"] });
+  await client.connect();
+  try {
+    const schluesselId = randomUUID();
+    await client.query(
+      `INSERT INTO "Schluessel" ("id","name","slug","typ","kategorie","publicKey","fingerprint","kommentar","geaendertAm")
+       VALUES ($1,$2,$3,'ED25519','DIENST',$4,$5,$6,now())`,
+      [schluesselId, `${name} Backup`, name, key.zeile, key.fingerprint, `sshkv:${name}`],
+    );
+    await client.query(
+      `INSERT INTO "PublicVerwendung" ("id","schluesselId","hostId","zielbenutzer","optionen") VALUES ($1,$2,$3,'root',$4)`,
+      [randomUUID(), schluesselId, hostId, 'restrict,from="10.0.0.12"'],
+    );
+  } finally {
+    await client.end();
+  }
+
+  await page.reload();
+  await expect(page.getByText("1 Zuweisung(en) noch nicht ausgerollt.")).toBeVisible();
+  await page.getByRole("button", { name: "Dry-Run starten" }).click();
+  await expect(page.getByText(`root@${name}:/root/.ssh/authorized_keys`)).toBeVisible({ timeout: 30_000 });
+  await expect(page.getByText(`restrict,from="10.0.0.12" ${key.zeile}`)).toBeVisible();
+  expect(aufZielB("cat /root/.ssh/authorized_keys 2>/dev/null || true")).not.toContain(key.fingerprint);
+  await page.screenshot({ path: "docs/anleitung/bilder/dry-run-desktop.png", fullPage: true });
+
+  await page.getByRole("button", { name: /Änderung anwenden/ }).click();
+  await expect(page.getByText("Ausgerollt.")).toBeVisible({ timeout: 30_000 });
+  await expect(page.getByText("synchron").first()).toBeVisible();
+  expect(aufZielB("cat /root/.ssh/authorized_keys")).toContain(`restrict,from="10.0.0.12" ${key.zeile}`);
+
+  await page.getByRole("button", { name: "Host archivieren" }).click();
+  await page.getByRole("dialog").getByRole("button", { name: "Archivieren", exact: true }).click();
+  await expect(page).toHaveURL(/\/hosts$/);
+});