Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Desaster-Drills

Ziel: Acht Störungen finden und beheben, wie sie im Betrieb von Keycloak vorkommen, jede mit Zeitlimit. · Dauer: ca. 120 min · Voraussetzung: Tag 13

Briefing

  • Jede Runde hat eine Spielleitung: einen Block, der den Fehler einbaut. Lies ihn erst nach der Runde, sonst ist es keine Übung. Am besten tippt ihn jemand anderes.
  • Lage beschreibt, was gemeldet wird, Zeitlimit die Zeit bis zur Lösung.
  • Werkzeuge: Fehlermeldungen der Endpunkte, das Log von Keycloak (type="LOGIN_ERROR", ERROR), jwt, kcadm, die Admin-Konsole und der Export aus Tag 12.
  • Alle Runden laufen auf der VM kc mit TLS und zwei Instanzen aus Tag 12.
 Symptom ──► Wer antwortet? (Keycloak, oauth2-proxy, notes-api, Proxy)
         ──► Was steht im Token? (jwt: aud, roles, exp)
         ──► Was sagt das Log? (error="…", Exception)
         ──► Was hat sich geändert? (kcadm get, Export vergleichen)

Tagesstart:

source ~/kc-lab/setup/env.sh
mkdir -p ~/kc-lab/tag15 && cd ~/kc-lab/tag15
kclogin
api() { docker run --rm --network lab curlimages/curl:8.17.0 -s "$@"; }
uid() { kcadm get users -r lab -q username=$1 -q exact=true | jq -r '.[0].id'; }
cid() { kcadm get clients -r lab -q clientId=$1 | jq -r '.[0].id'; }
kclog() { docker compose -f ~/kc-lab/keycloak/compose.yaml logs --since 2m 2>&1; }
api -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer $(token)" \
  notes-api:8080/whoami

Erwartet: anna kommt durch.

Logging into http://localhost:8080 as user kcadmin of realm master
200

Runde 1: Die falsche Adresse

Spielleitung:

kcadm update clients/$(cid notes-web) -r lab \
  -s 'redirectUris=["http://notes.example/oauth2/callback"]'

Lage: „Beim Login zeigt Keycloak nur noch eine Fehlerseite statt des Formulars.” Zeitlimit: 10 min

L="$KC_URL/realms/lab/protocol/openid-connect/auth?client_id=notes-web"
L="$L&response_type=code&scope=openid&redirect_uri=$NOTES_URL/oauth2/callback"
curl -s "$L" | grep -o 'Invalid parameter: [a-z_]*'

Erwartet:

Invalid parameter: redirect_uri

Lösung

Keycloak prüft die redirect_uri jeder Anfrage gegen die Liste des Clients – exakt oder mit * am Ende. Ein Blick auf die Liste:

kcadm get clients/$(cid notes-web) -r lab | jq -c .redirectUris
kcadm update clients/$(cid notes-web) -r lab \
  -s "redirectUris=[\"$NOTES_URL/oauth2/callback\"]"
curl -s -o /dev/null -w '%{http_code}\n' "$L"

Erwartet:

["http://notes.example/oauth2/callback"]
302

302: Keycloak leitet wieder zum Login-Formular weiter. Die Fehlerseite verrät dem Browser absichtlich nicht, welche Adresse erlaubt wäre.

Fortschritt speichern? Kostenlos registrieren

Runde 2: Das neue Secret

Spielleitung:

kcadm create clients/$(cid notes-cli)/client-secret -r lab >/dev/null

Lage: „Unser Skript bekommt seit heute Morgen keine Tokens mehr.” Zeitlimit: 10 min

curl -s -d grant_type=password -d client_id=notes-cli \
  -d client_secret=lab-client-secret-123 -d username=anna -d password=lab-user-pw-123 \
  $KC_URL/realms/lab/protocol/openid-connect/token | jq -c '{error, error_description}'

Erwartet:

{"error":"unauthorized_client","error_description":"Invalid client or Invalid client c…

Lösung

unauthorized_client betrifft den Client, nicht den Benutzer. Jemand hat das Secret neu erzeugt (Credentials → Regenerate). Entweder bekommt das Skript das neue Secret – oder, wie hier im Labor, der Client wieder das alte:

kcadm update clients/$(cid notes-cli) -r lab -s secret=lab-client-secret-123
token >/dev/null && echo "Token ok"

Erwartet:

Token ok

Fortschritt speichern? Kostenlos registrieren

Runde 3: Nur ben

Spielleitung:

SC=$(kcadm get client-scopes -r lab | jq -r '.[] | select(.name=="notes-api") | .id')
MID=$(kcadm get client-scopes/$SC/protocol-mappers/models -r lab \
  | jq -r '.[] | select(.name=="aud-notes-api") | .id')
kcadm delete client-scopes/$SC/protocol-mappers/models/$MID -r lab

Lage: „ben bekommt von notes-api 401. Bei anna geht alles.” Zeitlimit: 15 min

api -H "Authorization: Bearer $(token ben lab-user-pw-456)" notes-api:8080/whoami; echo
api -o /dev/null -w 'anna %{http_code}\n' -H "Authorization: Bearer $(token)" \
  notes-api:8080/whoami

Erwartet:

{"error":"Audience \"notes-api\" fehlt"}
anna 200

Lösung

Die Meldung nennt den Grund. Der Vergleich der beiden Tokens zeigt, warum anna trotzdem durchkommt:

jwt "$(token ben lab-user-pw-456)" | jq -c .aud
jwt "$(token)" | jq -c '{aud, client_roles: (.resource_access | keys)}'

Erwartet:

"account"
{"aud":["account","notes-api"],"client_roles":["account","notes-api"]}

anna hat die Client-Rolle archiv von notes-api (Tag 5). Für jeden Client, dessen Rollen im Token stehen, setzt Keycloak ihn auch in aud. ben hatte notes-api nur über den Audience-Mapper – und der ist weg:

kcadm create client-scopes/$SC/protocol-mappers/models -r lab -s name=aud-notes-api \
  -s protocol=openid-connect -s protocolMapper=oidc-audience-mapper \
  -s 'config."included.client.audience"=notes-api' \
  -s 'config."access.token.claim"=true' -s 'config."introspection.token.claim"=true'
api -o /dev/null -w 'ben %{http_code}\n' \
  -H "Authorization: Bearer $(token ben lab-user-pw-456)" notes-api:8080/whoami

Erwartet:

Created new model with id '…'
ben 200

Fortschritt speichern? Kostenlos registrieren

Runde 4: Das Verzeichnis schweigt

Spielleitung:

docker compose -f ~/kc-lab/ldap/compose.yaml stop 2>&1 | tail -1
kcadm create clear-user-cache -r lab

Lage: „carla kann sich nicht anmelden. Die Fehlermeldung ist nichtssagend.” Zeitlimit: 10 min

curl -s -d grant_type=password -d client_id=notes-cli \
  -d client_secret=lab-client-secret-123 -d username=carla -d password=lab-user-pw-123 \
  $KC_URL/realms/lab/protocol/openid-connect/token | jq -c '{error, error_description}'

Erwartet:

{"error":"unknown_error","error_description":"For more on this error consult the serv…

Lösung

unknown_error heißt: Keycloak selbst hatte ein Problem. Also ins Log:

kclog | grep -o -E 'ModelException: [A-Za-z ]*' | sort -u
docker compose -f ~/kc-lab/ldap/compose.yaml ps -a --format '{{.Service}} {{.State}}'
docker compose -f ~/kc-lab/ldap/compose.yaml start 2>&1 | tail -1
until token carla | grep -q '^ey'; do sleep 3; done; echo "carla ok"

Erwartet:

ModelException: Could not query server using DN 
ModelException: Querying of LDAP failed org
ldap exited
 Container ldap-ldap-1 Started
carla ok

Ist das Verzeichnis weg, scheitern auch Logins von Benutzern, die Keycloak schon kennt: Mit dem Provider im Modus WRITABLE oder READ_ONLY prüft Keycloak Passwörter immer im Verzeichnis.

Fortschritt speichern? Kostenlos registrieren

Runde 5: ben ist ausgesperrt

Spielleitung:

for i in 1 2 3; do
  curl -s -o /dev/null -d grant_type=password -d client_id=notes-cli \
    -d client_secret=lab-client-secret-123 -d username=ben -d password=geraten \
    $KC_URL/realms/lab/protocol/openid-connect/token
done

Lage: „ben sagt, sein Passwort stimmt – Keycloak sagt nein.” Zeitlimit: 10 min

curl -s -d grant_type=password -d client_id=notes-cli \
  -d client_secret=lab-client-secret-123 -d username=ben -d password=lab-user-pw-456 \
  $KC_URL/realms/lab/protocol/openid-connect/token | jq -c '{error_description}'

Erwartet:

{"error_description":"Invalid user credentials"}

Lösung

Dieselbe Meldung wie bei einem falschen Passwort. Das Log sagt mehr:

kclog | grep -o 'error="user_temporarily_disabled"' | sort -u
kcadm get attack-detection/brute-force/users/$(uid ben) -r lab | jq -c '{disabled}'
kcadm delete attack-detection/brute-force/users/$(uid ben) -r lab
token ben lab-user-pw-456 | grep -q '^ey' && echo "ben ok"

Erwartet:

error="user_temporarily_disabled"
{"disabled":true}
ben ok

Drei Fehlversuche reichen in diesem Realm (Tag 10). Im echten Betrieb folgt die Frage: Wer hat es dreimal probiert? lastIPFailure im Ergebnis von attack-detection nennt die Adresse.

Fortschritt speichern? Kostenlos registrieren

Runde 6: Kurze Freude

Spielleitung:

kcadm update realms/lab -s accessTokenLifespan=10

Lage: „Unsere Anwendung bekommt schon Sekunden nach der Anmeldung 401 von Keycloak.” Zeitlimit: 10 min

T=$(token); sleep 12
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer $T" \
  $KC_URL/realms/lab/protocol/openid-connect/userinfo

Erwartet:

401

Lösung

Ein 401 von userinfo direkt nach dem Holen heißt: Das Token ist schon abgelaufen. Die Lebensdauer steht im Token selbst:

jwt "$(token)" | jq '.exp - .iat'
kcadm update realms/lab -s accessTokenLifespan=120
jwt "$(token)" | jq '.exp - .iat'

Erwartet:

10
120

Eine Lebensdauer kann auch am Client stehen (Advanced → Access Token Lifespan) und überschreibt dann den Wert des Realms. notes-api gibt abgelaufenen Tokens übrigens noch 30 Sekunden Toleranz – deshalb fällt der Fehler dort später auf.

Fortschritt speichern? Kostenlos registrieren

Runde 7: Fremdes Zertifikat

Spielleitung:

cd ~/kc-lab/tls && cp kc.pem kc.pem.bak && cp kc.key kc.key.bak
openssl req -x509 -newkey rsa:2048 -nodes -days 30 -subj "/CN=kc.example" \
  -keyout kc.key -out kc.pem 2>/dev/null && chmod 644 kc.key
docker compose -f ~/kc-lab/keycloak/compose.yaml restart proxy 2>&1 | tail -1
until curl -sk -o /dev/null $KC_URL/realms/lab; do sleep 2; done
cd ~/kc-lab/tag15

Lage: „Nichts geht mehr. Der Browser warnt vor einer unsicheren Verbindung.” Zeitlimit: 10 min

curl -sS -o /dev/null $KC_URL/realms/lab 2>&1 | head -1

Erwartet:

curl: (60) SSL certificate problem: self-signed certificate

Lösung

Welches Zertifikat liefert der Proxy aus?

openssl s_client -connect kc.$VM_IP.sslip.io:443 -servername kc.$VM_IP.sslip.io \
  </dev/null 2>/dev/null | openssl x509 -noout -subject -issuer
ls ~/kc-lab/tls | grep bak
cd ~/kc-lab/tls && mv kc.pem.bak kc.pem && mv kc.key.bak kc.key && cd ~/kc-lab/tag15
docker compose -f ~/kc-lab/keycloak/compose.yaml restart proxy 2>&1 | tail -1
until curl -s -o /dev/null $KC_URL/realms/lab; do sleep 2; done
curl -s -o /dev/null -w '%{http_code}\n' $KC_URL/realms/lab

Erwartet:

subject=CN = kc.example
issuer=CN = kc.example
kc.key.bak
kc.pem.bak
 Container keycloak-proxy-1 Started
200

Selbst signiert, falscher Name: Hier hat jemand das Zertifikat ersetzt. Zum Glück gab es eine Sicherung. Ohne sie stellst du mit der Lab-CA aus Tag 12, Drill 1 ein neues aus.

Fortschritt speichern? Kostenlos registrieren

Runde 8: Die gelöschte Gruppe

Spielleitung:

GID=$(kcadm get groups -r lab -q search=team-notes \
  | jq -r '.[] | select(.name=="team-notes") | .id')
kcadm delete groups/$GID -r lab

Lage: „anna darf keine Notizen mehr schreiben. Gestern ging es noch.” Zeitlimit: 20 min

api -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer $(token)" \
  -H 'Content-Type: application/json' -d '{"text":"heute"}' notes-api:8080/notes
jwt "$(token)" | jq -c '.realm_access.roles | map(select(startswith("notes")))'

Erwartet:

403
[]

Lösung

anna hat keine einzige notes-Rolle mehr. Sie hatte beide über die Gruppe team-notes, und die gibt es nicht mehr:

kcadm get users/$(uid anna)/groups -r lab | jq length
E=~/kc-lab/tag12/export/lab-realm.json
jq -c '.groups[] | select(.name=="team-notes") | {name, realmRoles, clientRoles}' $E
jq -r '.users[] | select(.groups // [] | index("/team-notes")) | .username' $E

Erwartet:

0
{"name":"team-notes","realmRoles":["notes-schreiben","notes-lesen"],"clientRoles":{"no…
anna

Der Export aus Tag 12 kennt die Gruppe samt Rollen und Mitgliedern. Ein Partial Import legt nur die Gruppe wieder an; die Mitgliedschaft setzen wir selbst:

jq '{ifResourceExists: "SKIP", groups: [.groups[] | select(.name=="team-notes")]}' $E \
  | kcadm create partialImport -r lab -f - -o | jq -c '{added, skipped}'
GID=$(kcadm get groups -r lab -q search=team-notes \
  | jq -r '.[] | select(.name=="team-notes") | .id')
kcadm update users/$(uid anna)/groups/$GID -r lab -n
api -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer $(token)" \
  -H 'Content-Type: application/json' -d '{"text":"wieder da"}' notes-api:8080/notes

Erwartet:

{"added":1,"skipped":0}
201

Deshalb gehört ein regelmäßiger Export zum Betrieb – neben dem Datenbank-Backup, das alles auf einmal zurückholt.

Fortschritt speichern? Kostenlos registrieren

Auswertung

Punkte je Runde
3 im Zeitlimit, ohne in die Lösung zu schauen
2 im Zeitlimit, mit einem Blick ins Log einer anderen Komponente als gedacht
1 nach dem Zeitlimit

20 Punkte und mehr: Du bist bereit für den Bereitschaftsdienst.

Kontrollpunkt

for u in "anna lab-user-pw-123" "ben lab-user-pw-456" "carla lab-user-pw-123"; do
  set -- $u
  api -o /dev/null -w "$1 %{http_code}\n" -H "Authorization: Bearer $(token $1 $2)" \
    notes-api:8080/whoami
done

Erwartet: Alle drei kommen wieder durch.

anna 200
ben 200
carla 200
kcadm get realms/lab --fields accessTokenLifespan

Erwartet:

{
  "accessTokenLifespan" : 120
}

Enterprise-Notiz

  • Alarme statt Anrufe: Fehlerraten pro error aus den Events (Tag 10), die Ablaufdaten der Zertifikate und /health/ready gehören ins Monitoring.
  • Änderungen nachvollziehen: Admin events speichern jede Änderung über die Admin API mit Benutzer und Zeit. Ohne sie bleibt bei Runde 1, 2, 3 und 8 nur Raten.
  • Runbooks: Jede Runde hier ist ein Kandidat für ein Runbook – Symptom, erste Befehle, Lösung, Ansprechpartner.
  • Konfiguration als Code (Tag 13) macht Runde 3 und 8 zu einem terraform apply.