Titelbild: SSH-Zugang mit Ablaufdatum, kurzlebige Zertifikate statt langlebiger Schlüssel

SSH-Schlüssel mit Ablaufdatum: kurzlebiger Zugang mit OpenBao und Keycloak

Langlebige SSH-Schlüssel sammeln sich auf Servern an, und niemand weiß, welche davon noch gebraucht werden. Dieser Beitrag zeigt eine Alternative, die ich einsetze: eine vertrauenswürdige CA (Certificate Authority), die Schlüssel für 30 Minuten signiert, mit Keycloak als Identität davor. Auf den Hosts wird nichts außer OpenSSH benötigt, und das Ganze funktioniert On-Premise und auch in Air-Gap-Umgebungen.

Bemerkung

Terminologie

OpenSSH spricht von einem Zertifikat, wenn ein öffentlicher Schlüssel signiert wird. Das ist kein X.509-Zertifikat, sondern ein anderes, OpenSSH-spezifisches Format. Die CA (Certificate Authority) ist die Instanz, die den öffentlichen SSH-Schlüssel des Benutzers signiert, und der signierte öffentliche Schlüssel wird Zertifikat genannt. Zertifikat kann sich auch auf den Metadateninhalt des signierten Schlüssels beziehen, etwa Gültigkeitszeitraum, Principals, Key-ID, Signaturschlüssel usw. Ich verwende beide Begriffe - signierter Schlüssel und Zertifikat - je nach Kontext.

Welche Vorteile hat dieser Aufbau?

  • Keine langlebigen Schlüssel auf den Hosts, nur der öffentliche Schlüssel der CA.

  • Kurzlebige Zertifikate, automatisch erneuert, gebunden an eine Single-Sign-On-Identität.

  • Die Zugriffskontrolle liegt zentral in Keycloak, nicht auf jedem Host.

  • Skalierbar: Benutzer hinzuzufügen oder zu entfernen erfordert keine Änderung an jedem Host.

  • Nachvollziehbar: Die Logs zeigen anhand der Key-ID des Zertifikats, wer sich wann angemeldet hat.

  • Bei einem kompromittierten signierten Schlüssel ist das Zeitfenster des Missbrauchs begrenzt. Wird die Kompromittierung erkannt, lässt sie sich zusätzlich eindämmen, indem die vertrauten CA-Schlüssel auf den entfernten Hosts entfernt werden, also durch eine Rotation des CA-Schlüssels im Vault und seiner öffentlichen Schlüssel auf den vertrauenden Hosts. Diese Maßnahme greift auf Infrastrukturebene, nicht auf Benutzerebene, und lässt sich dadurch viel schneller und zuverlässiger durchführen. OpenSSH kann außerdem einzelne Zertifikate (sogar anhand der Seriennummer) mit einer Key Revocation List (KRL, siehe die ssh-keygen-Manpage) sperren, die sshd über RevokedKeys einliest. Soweit ich sehe, erzeugt und verteilt weder die SSH-Engine von OpenBao noch OpenSSH selbst eine solche Liste, man müsste sie also selbst bauen und auf jeden Host ausrollen. Kurze TTLs bleiben der wichtigste Schutz.

Die Bausteine für unseren experimentellen Aufbau:

  • OpenBao (der Open-Source-Fork von Hashicorp Vault) ist die CA und signiert meinen öffentlichen Schlüssel.

  • Keycloak ist der Identity Provider. Er weiß, wer ich bin und welche Rollen ich habe. Wir definieren eine neue Client-Rolle, die das Signieren von Schlüsseln in OpenBao erlaubt.

  • OpenSSH unterstützt all das bereits. Kein Agent, keine zusätzliche Software auf den Hosts, nur ein paar Zeilen sshd_config. Das lässt sich mit Ansible automatisieren, ist aber nicht der Fokus dieses Beitrags.

Dieser Beitrag lässt sich auch mit Hashicorps Vault nachvollziehen.

Warum signierte Schlüssel?

Es gibt zwei Hauptvorteile signierter Schlüssel: Skalierbarkeit und Sicherheit.

Skalierbarkeit

Bei einfachen Schlüsseln hat jeder Host eine Liste öffentlicher Schlüssel. Eine Person hinzuzufügen oder zu entfernen bedeutet, jeden Host anzufassen, und an der Liste lässt sich nicht erkennen, ob ein Schlüssel noch gebraucht wird.

Bei Zertifikaten hält der entfernte Host eine Sache: den öffentlichen Schlüssel der CA. Wer einen Schlüssel vorzeigt, den die CA signiert hat, mit gültigem Zeitfenster und erlaubtem Principal, kommt hinein. Der Zugriff wird dort entschieden, wo die Identität liegt, nicht auf jeder Maschine (im OIDC-Provider, hier Keycloak).

Soll eine Person den Zugang verlieren, genügt es, die Rolle in Keycloak zu entfernen. Beim nächsten Versuch, ein Zertifikat zu bekommen, schlägt dies fehl, und die Person kann sich nicht mehr anmelden. Kein Host muss dafür angefasst werden.

Durch die Abstraktionsebene der Principals sind lokale Accounts vom SSH-Schlüssel entkoppelt. Details zu Principals folgen weiter unten.

Sicherheit

Ein gestohlenes 30-Minuten-Zertifikat ist ein kleines Problem, ein gestohlener Schlüssel von vor einem Jahr kann ein roßes Problem` sein.

Das Zertifikat eines signierten Schlüssels enthält eine zeitliche Begrenzung (TTL: Time to Live). Die CA kann den Schlüssel nur für kurze Zeit signieren (etwa 30 Minuten).

Das Zertifikat enthält außerdem eine Seriennummer, mit der sich Logins dem Signiervorgang zuordnen lassen. In dem hier beschriebenen Aufbau lässt sich sogar nachvollziehen, wer die Signatur angefordert hat, denn der Anfragende (Person oder Bot) authentifiziert sich bei Keycloak.

Die CA: woher das Vertrauen kommt

Alles ruht auf einem einzigen privaten Schlüssel, dem CA-Schlüssel. Wer ihn besitzt, kann Zugang zu jedem Host signieren, der ihm vertraut. Also stellt sich die Frage, wo er liegt. In diesem Aufbau ist der OpenBao-Vault die CA.

Offline-Root-Schlüssel und Online-CA-Schlüssel, beiden vertraut der Host

Zwei Schlüssel: ein Online-Schlüssel, der täglich signiert, und ein Offline-Schlüssel für Notfälle.

Bemerkung

Zertifikatsketten

Ein wichtiges Detail: OpenSSH-CA-Schlüssel kennen keine Ketten, anders als X.509/TLS-Zertifikate. Es ist nicht möglich, Zwischenzertifikate abzuleiten. Der Host hat schlicht eine Liste vertrauter öffentlicher CA-Schlüssel (TrustedUserCAKeys). Trotzdem lässt sich das Verhalten einer Zertifikatskette (bis zu einem gewissen Grad) mit mehreren Schlüsseln nachbilden: einem Online-Schlüssel und einem Offline-„Root“-Schlüssel. Die Anzahl vertrauter Offline-Schlüssel richtet sich nach dem eigenen Grad an Paranoia.

  • Ein Online-CA-Schlüssel im Vault, der die täglichen Zertifikate signiert. Er wird im Vault erzeugt (generate_signing_key=true).

  • Ein Offline-CA-Schlüssel, der nur ein Notfall-Schlüssel ist. Sein öffentlicher Teil wird ebenfalls von den Hosts vertraut. Ist der Online-CA-Schlüssel kompromittiert oder der Vault nicht erreichbar, holt man den Offline-Schlüssel hervor, signiert von Hand ein Zertifikat und kommt hinein. So lässt sich der kompromittierte Online-Schlüssel entfernen, ohne sich auszusperren: beiden vertrauen, tauschen, dann den alten auf jedem Host entfernen (Konfigurationsmanagement empfohlen).

Wie man den Offline-Schlüssel aufbewahrt, ist ein Abwägen zwischen Paranoia und Komfort:

  • Auf Papier (ausgedruckter Schlüssel, im Safe oder unter Omas Kopfkissen): günstig und robust, hält Jahrhunderte, nicht für den produktiven Einsatz - oder doch?

  • Auf einem HSM oder YubiKey: Der Schlüssel verlässt das Gerät nie, das Signieren findet darauf statt. Schön und praktisch, passt zu Unternehmensrichtlinien, aber teuer (der YubiKey ist die Variante für den kleinen Geldbeutel und in regulierten Umgebungen nicht empfohlen).

  • Eine KeePass-Datei mit starkem Passwort, an einem sicheren Ort aufbewahrt.

  • Aufgeteilt mit Shamir’s Secret Sharing (zum Beispiel 3 von 5 Anteilen), verteilt an verschiedene Personen oder Orte. Kein einzelner Anteil verrät etwas, beliebige drei rekonstruieren den Schlüssel. Lässt sich mit den genannten Aufbewahrungsmethoden kombinieren.

OpenBao für das SSH-Signieren vorbereiten

OpenBao bringt eine eingebaute SSH-Secret-Engine mit. Sie kann einen Signaturschlüssel erzeugen und öffentliche Schlüssel signieren. Der Signaturschlüssel verlässt OpenBao nie, der öffentliche Signaturschlüssel kann ausgelesen und auf die entfernten Hosts verteilt werden, damit diese ihm vertrauen. Die entfernten Hosts können mit dem öffentlichen Signaturschlüssel die Echtheit eingehender signierter Schlüssel prüfen.

# einmalig, auf der OpenBao-Seite
bao secrets enable -path=ssh ssh
bao write ssh/config/ca generate_signing_key=true

Bemerkung

Die Konfiguration von OpenBao für das SSH-Signieren erfordert erhöhte Rechte. Aus den Unseal-Keys lässt sich ein temporäres Root-Token erzeugen, das nach der Konfiguration wieder verworfen wird. Details stehen in der OpenBao-Dokumentation.

Als Nächstes kommt die SSH-Rolle. Sie legt fest, welche Werte OpenBao in die Signatur schreibt. Die weiter unten erstellte Policy erlaubt das Signieren auf ssh/sign/admin, und diese Rolle steckt hinter diesem Pfad:

bao write ssh/roles/admin - <<'JSON'
{
  "key_type": "ca",
  "allow_user_certificates": true,
  "allowed_users": "infra-admin",
  "default_user": "infra-admin",
  "ttl": "30m",
  "max_ttl": "1h",
  "key_id_format": "{{token_display_name}}",
  "default_extensions": {"permit-pty": ""}
}
JSON
  • allowed_users ist die Liste der Principals, die in einem über diese Rolle signierten Zertifikat vorkommen dürfen (kommagetrennt, bewusst ohne Wildcard). Jede andere Anfrage scheitert beim Signieren.

  • default_user wird verwendet, wenn die Anfrage keine valid_principals enthält.

  • ttl und max_ttl halten die Zertifikate kurzlebig.

  • key_id_format schreibt die authentifizierte OpenBao-Identität in die Key-ID, die später im sshd-Log auftaucht.

  • default_extensions erlaubt ein Terminal (permit-pty). Ohne jede Extension ist das Zertifikat gültig, liefert aber keine interaktive Shell.

Das Vertrauen auf dem entfernten Host einrichten

Der entfernte Host (der, der SSH-Verbindungen annimmt) braucht drei Dinge. Alle sind öffentliche Informationen:

Öffentlicher CA-Schlüssel, Principal-Datei und sshd-Drop-in auf dem Host

Was eine Ansible-Rolle auf dem Server ablegt (oder ein anderer Deployment-Mechanismus, das kann zum Testen auch ein manuelles scp sein).

Den öffentlichen Schlüssel der CA haben wir oben schon behandelt. Was ist die Principal-Datei? Eine einfache Textdatei, die lokale Accounts auf dem entfernten Host den Principals zuordnet, die sich als dieser Account anmelden dürfen. Es kann pro lokalem Account auf dem entfernten Host eine Datei mit der Liste erlaubter Principals geben, die beim SSH-Login in der Signatur mitgeliefert werden. Dazu später mehr.

Das Drop-in für sshd ist ein kleines Konfigurationsschnipsel, das auf den öffentlichen CA-Schlüssel und die Principal-Datei(en) verweist. Es ist im Grunde die Konfiguration, mit der der SSH-Daemon der CA vertraut und die Principals prüft. Details unten.

Wie kommt man an den öffentlichen CA-Schlüssel aus OpenBao? Die bao-CLI kann ihn lesen:

bao read -field=public_key ssh/config/ca > ssh-user-ca.pub

Falls Sie sich noch nicht bei OpenBao angemeldet haben, geht das so:

# bao login -method oidc benötigt zusätzliche Policies, um den öffentlichen Schlüssel zu lesen.
# Außerhalb des Rahmens dieses Beitrags.
bao login # erfordert ein Root-Token.

Bemerkung

Berechtigungen zum Herunterladen des öffentlichen CA-Schlüssels

Das Lesen des öffentlichen Schlüssels erfordert Berechtigungen. Der Einfachheit halber nehmen wir das Root-Token, man kann aber eine dedizierte Policy anlegen, die nur das Lesen des öffentlichen Schlüssels erlaubt. Auch das ist außerhalb des Rahmens dieses Beitrags.

Auf dem entfernten Host legen wir ein Drop-in für sshd an, das auf den öffentlichen CA-Schlüssel und eine Datei mit den erlaubten Principals verweist:

# /etc/ssh/sshd_config.d/10-ssh-ca.conf
TrustedUserCAKeys /etc/ssh/trusted-user-ca.pem
AuthorizedPrincipalsFile /etc/ssh/auth_principals/%u
  • sshd verwendet den ersten Wert, den es liest, das Drop-in muss also vor 50-cloud-init.conf einsortiert werden.

  • Prüfen Sie die Konfiguration immer mit sshd -t, bevor Sie neu laden, halten Sie eine zweite Sitzung offen und schalten Sie authorized_keys (AuthorizedKeysFile none) erst ab, nachdem der Zertifikats-Login nachweislich funktioniert. Ich überlasse das Ansible und lasse das Drop-in zurückrollen, wenn die Validierung fehlschlägt.

Wer bin ich: Keycloak, OIDC und ein Rollen-Claim

OpenBao kennt mich nicht. Das delegieren wir an einen OIDC-Provider (OpenID Connect), etwa Keycloak. Der Trick: Keycloak schreibt meine Client-Rolle als Claim in das Token, und OpenBao entscheidet anhand dieses Claims, ob ich eine SSH-Schlüssel-Signatur anfordern darf.

Sequenz: OIDC-Login bei Keycloak, OpenBao-Token, Signieren, SSH-Login

Von bao login bis zur Shell, in acht Schritten.

Die Keycloak-Seite braucht eine einmalige Konfiguration (im Realm):

  1. Einen Client openbao (Client meint hier die OpenBao-Instanz, sie ist eine Client-Anwendung des OIDC-Providers). Wir gehen davon aus, dass er bereits existiert, Details stehen in der Dokumentation von OpenBao.

  2. Eine Client-Rolle ssh-sign, zugewiesen an jeden Benutzer, der SSH-Zertifikate mit dem angegebenen Principal signieren lassen darf.

  3. Einen Mapper, der die Client-Rollen des Benutzers in einen roles-Claim des ID-Tokens schreibt. Das konfiguriert im Grunde, wie die Rolle ssh-sign im Authentifizierungs-Token landet.

Die OpenBao-Seite: eine OIDC-Auth-Methode und eine Rolle, die einen Benutzer nur dann hineinlässt, wenn der Claim die richtige Rolle enthält, und ihm dann nichts außer einer Policy gibt. Das erfordert erhöhte Rechte, die sich über ein Root-Token im Vault beschaffen lassen. Ab OpenBao v2.6.0 kann ein Root-Token aus den Unseal-Keys erzeugt und danach verworfen werden, was ich für ein sehr nützliches Sicherheitsfeature halte.

bao write auth/oidc/role/admin-ssh - <<'JSON'
{
  "role_type": "oidc",
  "user_claim": "preferred_username",
  "bound_audiences": "openbao",
  "bound_claims": {"roles": ["ssh-sign"]},
  "policies": "ssh-sign-admin",
  "ttl": "30m"
}
JSON

bao policy write ssh-sign-admin - <<'HCL'
path "ssh/sign/admin" {
  capabilities = ["update"]
}
HCL

Diese OpenBao-Rolle verbindet die Claims im OIDC-Token mit der Policy ssh-sign-admin im Vault. Die Policy ssh-sign-admin erlaubt es, auf ssh/sign/admin eine Signatur anzufordern, die von der SSH-Secret-Engine von OpenBao bereitgestellt wird. Soll eine weitere Benutzergruppe mit anderen Berechtigungen unterstützt werden (z. B. um den Zugriff auf verschiedene Teile der Infrastruktur aufzuteilen), fügt man eine weitere Keycloak-Rolle hinzu, bildet sie im Identitäts-Token des OIDC-Providers (z. B. Keycloak) ab und legt eine weitere Policy an.

Signieren und ein kleines Hilfsskript

Jetzt sind wir auf der Zielgeraden. So erzeuge ich auf meinem Laptop einen signierten SSH-Schlüssel, um mich am entfernten Host anzumelden:

bao login -method=oidc role=admin-ssh
bao write -field=signed_key ssh/sign/admin \
  public_key=@$HOME/.ssh/id_ed25519_bao.pub \
  valid_principals=infra-admin > ~/.ssh/id_ed25519_bao-cert.pub
ssh-keygen -L -f ~/.ssh/id_ed25519_bao-cert.pub

Das Schlüsselpaar bleibt gleich, nur das Zertifikat daneben (-cert.pub) wird ersetzt.

Jetzt richten wir das lokale SSH so ein, dass es den signierten Schlüssel verwendet und bei einer neuen SSH-Sitzung automatisch erneuert. Dafür braucht es zwei Dinge: 1. ein Skript, das den signierten Schlüssel erneuert, und 2. eine Match exec-Zeile in der ~/.ssh/config, die das Skript vor dem Verbinden zum Host aufruft.

Hier das Skript, legen Sie es für dieses Beispiel als ~/bao-ssh-cert.sh in Ihr Home-Verzeichnis.

bao-ssh-cert.sh
 1#!/usr/bin/env bash
 2# Renews the SSH user certificate from the OpenBao SSH CA when it is missing or about to expire.
 3# Logs in to OpenBao with OIDC (Keycloak) only if the current token is not valid. The key pair is reused, only the certificate changes.
 4# It requires the `bao` CLI to be installed and configured.
 5#
 6#   bao-ssh-cert            renew if less than MIN_SECONDS of validity are left
 7#   bao-ssh-cert --check    only report, exit 0 if the certificate is valid long enough, 1 if it needs renewal
 8#   bao-ssh-cert --force    renew now
 9#
10# Settings (environment): BAO_ADDR, SSH_KEY, MIN_SECONDS, BAO_SSH_SIGN_PATH, BAO_SSH_PRINCIPAL, BAO_OIDC_ROLE
11set -euo pipefail
12
13export BAO_ADDR="${BAO_ADDR:-http://localhost:8443}"
14key="${SSH_KEY:-$HOME/.ssh/id_ed25519_bao}"
15cert="${key}-cert.pub"
16min_seconds="${MIN_SECONDS:-300}"
17sign_path="${BAO_SSH_SIGN_PATH:-ssh/sign/admin}"
18principal="${BAO_SSH_PRINCIPAL:-infra-admin}"
19oidc_role="${BAO_OIDC_ROLE:-admin-ssh}"
20
21mode=renew
22case "${1:-}" in
23  "") ;;
24  --check) mode=check ;;
25  --force) mode=force ;;
26  *) echo "usage: ${0##*/} [--check|--force]" >&2; exit 2 ;;
27esac
28
29# Seconds until the certificate expires; negative when expired, empty when there is none
30seconds_left() {
31  [[ -f $cert ]] || return 0
32  local until
33  until=$(ssh-keygen -L -f "$cert" | sed -n 's/^ *Valid: from .* to \([^ ]*\)$/\1/p')
34  [[ -n $until ]] || return 0   # "Valid: forever" or unreadable: treat as unknown
35  echo $(( $(date -d "$until" +%s) - $(date +%s) ))
36}
37
38left=$(seconds_left)
39if [[ -n $left ]]; then
40  if (( left > 0 )); then echo "certificate $cert valid for another $(( left / 60 )) minutes"
41  else echo "certificate $cert expired $(( -left / 60 )) minutes ago"; fi
42else
43  echo "no usable certificate at $cert"
44fi
45
46needs_renewal=true
47if [[ $mode != force && -n $left ]] && (( left >= min_seconds )); then needs_renewal=false; fi
48
49if [[ $mode == check ]]; then
50  if $needs_renewal; then exit 1; else exit 0; fi
51fi
52$needs_renewal || exit 0
53
54[[ -f $key.pub ]] || { echo "public key $key.pub is missing (ssh-keygen -t ed25519 -f $key -N '')" >&2; exit 1; }
55command -v bao >/dev/null || { echo "bao CLI not found" >&2; exit 1; }
56
57if ! bao token lookup >/dev/null 2>&1; then
58  echo "OpenBao token missing or expired, logging in with OIDC (role $oidc_role)"
59  bao login -method=oidc role="$oidc_role" >/dev/null
60fi
61
62# Written to a temporary file first, so a failed signing does not destroy the old certificate
63umask 077
64tmp=$(mktemp "$cert.XXXXXX")
65trap 'rm -f "$tmp"' EXIT
66bao write -field=signed_key "$sign_path" public_key=@"$key.pub" valid_principals="$principal" > "$tmp"
67ssh-keygen -L -f "$tmp" >/dev/null   # refuses anything that is not a certificate
68chmod 644 "$tmp"
69mv "$tmp" "$cert"
70trap - EXIT
71
72echo "new certificate $cert:"
73ssh-keygen -L -f "$cert" | sed -n 's/^ *\(Valid:.*\)$/  \1/p; s/^ *\(Key ID:.*\)$/  \1/p'

Setzen Sie die Umgebungsvariable BAO_ADDR auf die URL Ihrer OpenBao-Instanz (Standard: http://localhost:8443) und optional SSH_KEY auf den Pfad zu Ihrem privaten Schlüssel (Standard: ~/.ssh/id_ed25519_bao).

Damit das Skript bei neuen SSH-Sitzungen automatisch aufgerufen wird, konfigurieren wir das lokale SSH. Fügen Sie Ihrer ~/.ssh/config eine Host-Definition hinzu (Hostname, Schlüsseldatei und Benutzer durch Ihre eigenen ersetzen):

# ~/.ssh/config

# Die Hosts definieren, bei denen das signierte Zertifikat verwendet und eine Erzeugung ausgelöst werden soll.
Host remote-host1
  HostName <your host url or ip>
  User <your user>

  # Der private Schlüssel, einmalig erzeugen mit `ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_bao`
  IdentityFile ~/.ssh/id_ed25519_bao

  # Der signierte öffentliche Schlüssel aus dem Erneuerungsskript.
  CertificateFile ~/.ssh/id_ed25519_bao-cert.pub

  # verhindert, dass im Fehlerfall andere Schlüssel an den Host geschickt werden.
  IdentitiesOnly yes

  # Die automatische Erneuerung des signierten öffentlichen Schlüssels vor dem Verbinden.
  # Den Skriptpfad entsprechend anpassen.
  Match exec "test -t 2 && ~/bao-ssh-cert.sh >&2; false"

Die Magie steckt in der Match exec-Zeile, die das Erneuerungsskript vor dem Verbinden aufruft.

Principals: wer darf wer werden

Ein Zertifikat legt keine Accounts auf dem entfernten Host an. Es trägt eine Liste von Principals: Namen, für die die CA bürgt. Der Host entscheidet dann, auf welche lokalen Accounts diese Namen sich anmelden dürfen („Allow“). Ein Principal ist eine Art Abstraktionsebene zwischen der Identitäts-/CA-Welt (Keycloak, OpenBao) und den Linux-Accounts auf den entfernten Hosts.

Kette von der Keycloak-Rolle zum Linux-Account und zwei Gruppen

Jede Ebene schränkt ein, was die vorherige darf.

  • Die OpenBao-SSH-Rolle begrenzt, welche Principals überhaupt in eine Signatur geschrieben werden können (allowed_users). Die Anfrage eines nicht erlaubten Principals scheitert beim Signieren.

  • Die Host-Datei /etc/ssh/auth_principals/<account> listet, welche Principals sich als dieser Account anmelden dürfen. Ein signierter Schlüssel für infra-admin funktioniert für user1 auf den Hosts, deren user1-Datei ihn aufführt, und sonst nirgends.

  • Best Practice ist, dass ein Principal eine Rolle oder Gruppe benennt (infra-admin, ops, dba), keine Person. Die Key-ID im Zertifikat hält fest, wer tatsächlich angefragt hat, und sie erscheint im sshd-Log.

Auf dem Host besteht die Zuordnung aus einer kleinen Datei pro Account, auf die die AuthorizedPrincipalsFile-Zeile aus dem obigen Drop-in verweist. Der Dateiname ist der lokale Account, der Inhalt die Liste der Principals, die sich als dieser anmelden dürfen:

/etc/ssh/auth_principals/
├── user1      # Principals, die sich als user1 anmelden dürfen
├── deploy     # Principals, die sich als deploy anmelden dürfen
└── root       # Principals, die sich als root anmelden dürfen
# /etc/ssh/auth_principals/user1
infra-admin
ops

Die Anmeldung als user1 funktioniert nun mit jedem Zertifikat, das den Principal infra-admin oder ops enthält. Verschiedene Hosts können denselben Principal unterschiedlichen Accounts zuordnen oder gar nicht. Ein Account ohne Datei ist mit einem Zertifikat nicht erreichbar. Die Dateien entscheiden, wer hineinkommt, sie sollten daher root gehören und für andere nicht beschreibbar sein.

Die Signatur sagt, was Sie sein dürfen, der Login-Name sagt, was Sie sein wollen: Den Account wählen Sie weiterhin selbst (ssh user1@host oder User in der ~/.ssh/config), und sshd prüft nur, ob beides zusammenpasst. Das ist ein reiner Allow-Mechanismus. Ohne passenden Eintrag in der Principal-Datei kommt niemand mit einem Zertifikat als dieser Account hinein, und der Zugang wird durch Entfernen des Eintrags widerrufen.

Bemerkung

Ohne AuthorizedPrincipalsFile verlangt sshd, dass der Principal mit dem Unix-Benutzernamen identisch ist. Das funktioniert, aber die CA muss dann die Account-Namen auf jedem Host kennen, und die Abstraktion ist weg. Setzen Sie beim Signieren außerdem immer explizit Principals: Eine Signatur ohne Principals kann in manchen Konfigurationen für beliebige Benutzer akzeptiert werden.

Was schiefgehen kann

  • OpenBao versiegelt oder Keycloak down: keine neuen Signaturen. Bestehende funktionieren bis zu ihrem Ablauf, und offene Sitzungen bleiben offen.

  • Sich auf dem entfernten Host aussperren: Testen Sie in einem zweiten Terminal mit aktiver Sitzung, bevor Sie authorized_keys abschalten. Stellen Sie sicher, dass Sie im Falle eines Aussperrens noch auf den Host kommen (z. B. physischer Zugang, eine Konsole des Hypervisors oder Cloud-Anbieters).

  • Unbeaufsichtigte Jobs: Eine Erneuerung öffnet einen Browser für den Keycloak-Login. Erneuern Sie von Hand, bevor Sie Ansible oder ein anderes Konfigurationsmanagement-Tool ausführen.

Zum Schluss

Wir haben jetzt einen funktionierenden Aufbau mit einer PKI, die den Login auf entfernten Hosts mit einem signierten Schlüssel erlaubt, Signaturen automatisch erneuert und den Zugang zentral in Keycloak gewährt oder entzieht. Der Prozess ist skalierbar und nachvollziehbar, erfordert aber Anpassungen an reale Umgebungen.

Ich hoffe, dieser Beitrag hat sein Ziel erreicht: die grundlegenden Mechanismen und die Vertrauenskette zu zeigen, etwas Terminologie zu klären, ein funktionierendes Beispiel zu geben und aufzuzeigen, wie sich OpenBao, Keycloak und OpenSSH miteinander verbinden lassen.