Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: Ingress mit TLS und Binaries prüfen

Ziel: Du veröffentlichst eine App per Ingress nur noch über HTTPS mit eigenem Zertifikat und weist nach, dass die Kubernetes-Binaries auf deinen Nodes echt sind. · Dauer: ca. 60 min · Voraussetzung: Tag 1

Briefing

CKS: Cluster Setup (15 %) – „Properly set up Ingress objects with TLS“ und „Verify platform binaries before deploying“.

  • TLS am Ingress: Zertifikat und Schlüssel liegen in einem Secret vom Typ kubernetes.io/tls, der Ingress verweist unter spec.tls darauf.
  • Ohne eigenes Zertifikat liefert Traefik sein selbst signiertes Default-Zertifikat aus.
  • Binaries: Versionsausgabe beweist nichts. Nur die Prüfsumme gegen die offizielle Release-Datei auf dl.k8s.io zählt.
curl --resolve web.lab.local:30443:172.16.0.126
   │ https://web.lab.local:30443
   ▼
Traefik (NodePort 30443) ── Secret web-tls ──> Service web:80 ──> Pods nginx
Traefik (NodePort 30080) ── Middleware to-https ──> 301 auf :30443
mkdir -p ~/cks/tag04 && cd ~/cks/tag04
k create ns tag04
k config set-context --current --namespace=tag04

Drill 1: Ingress ohne TLS

k create deployment web --image=nginx:1.29 --replicas=2
k expose deployment web --port=80
k create ingress web --class=traefik --rule="web.lab.local/*=web:80"
k rollout status deploy/web
curl -s -o /dev/null -w "%{http_code}\n" -H "Host: web.lab.local" \
  http://172.16.0.126:30080/
curl -sv -o /dev/null -k --resolve web.lab.local:30443:172.16.0.126 \
  https://web.lab.local:30443/ 2>&1 | grep -E "subject:|issuer:"
curl -sS --resolve web.lab.local:30443:172.16.0.126 https://web.lab.local:30443/

Erwartet (gekürzt):

200
*  subject: CN=TRAEFIK DEFAULT CERT
*  issuer: CN=TRAEFIK DEFAULT CERT
curl: (60) SSL certificate problem: self-signed certificate

Die App läuft im Klartext über Port 30080, und HTTPS gibt es nur mit einem Zertifikat, dem kein Client traut. --resolve ersetzt den DNS-Eintrag: curl schickt den richtigen Hostnamen (SNI und Host-Header) an die IP von cp1.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Eigenes Zertifikat als TLS-Secret

openssl req -x509 -newkey rsa:2048 -nodes -days 365 \
  -keyout web.key -out web.crt -subj "/CN=web.lab.local" \
  -addext "subjectAltName=DNS:web.lab.local"
openssl x509 -in web.crt -noout -subject -ext subjectAltName -enddate
k create secret tls web-tls --cert=web.crt --key=web.key
k get secret web-tls
k describe secret web-tls | tail -2

Erwartet (gekürzt):

subject=CN = web.lab.local
X509v3 Subject Alternative Name:
    DNS:web.lab.local
notAfter=Nov 18 17:29:26 2027 GMT
secret/web-tls created
NAME      TYPE                DATA   AGE
web-tls   kubernetes.io/tls   2      0s
tls.crt:  1159 bytes
tls.key:  1704 bytes

Clients prüfen den Hostnamen im subjectAltName, nicht im CN – fehlt der SAN-Eintrag, scheitert curl trotz passenden CNs. k create secret tls prüft, ob Schlüssel und Zertifikat zusammenpassen:

openssl req -x509 -newkey rsa:2048 -nodes -days 30 -keyout api.key -out api.crt \
  -subj "/CN=api.lab.local" -addext "subjectAltName=DNS:api.lab.local" 2>/dev/null
k create secret tls bad-tls --cert=api.crt --key=web.key

Erwartet:

error: tls: private key does not match public key

Fortschritt speichern? Kostenlos registrieren

Drill 3: Ingress mit spec.tls

k create ingress kennt die TLS-Angabe direkt in der Regel (tls=<secret>):

k create ingress web --class=traefik --rule="web.lab.local/*=web:80,tls=web-tls" \
  $do > web-ing.yaml
grep -A3 "tls:" web-ing.yaml
k replace -f web-ing.yaml
k get ingress web
curl -s -o /dev/null -w "%{http_code}\n" --cacert web.crt \
  --resolve web.lab.local:30443:172.16.0.126 https://web.lab.local:30443/
curl -sv -o /dev/null --cacert web.crt --resolve web.lab.local:30443:172.16.0.126 \
  https://web.lab.local:30443/ 2>&1 | grep -E "subject:|verify ok"

Erwartet:

  tls:
  - hosts:
    - web.lab.local
    secretName: web-tls
ingress.networking.k8s.io/web replaced
NAME   CLASS     HOSTS           ADDRESS   PORTS     AGE
web    traefik   web.lab.local             80, 443   26s
200
*  subject: CN=web.lab.local
*  SSL certificate verify ok.

Diesmal ohne -k: curl vertraut dem eigenen Zertifikat über --cacert. Das Secret muss im selben Namespace wie der Ingress liegen, und der Host unter tls.hosts muss zu einem Host in rules passen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: HTTP auf HTTPS umleiten

Port 30080 liefert die App weiterhin im Klartext aus. Traefik leitet mit einer Middleware (CRD traefik.io/v1alpha1) um, die der Ingress per Annotation einbindet:

k explain middleware.spec.redirectScheme | grep -A1 -E "^  [a-z]"
k apply -f - <<'EOF'
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: to-https
spec:
  redirectScheme:
    scheme: https
    port: "30443"
    permanent: true
EOF
k annotate ingress web \
  traefik.ingress.kubernetes.io/router.middlewares=tag04-to-https@kubernetescrd
curl -s -o /dev/null -w "%{http_code} %{redirect_url}\n" -H "Host: web.lab.local" \
  http://172.16.0.126:30080/
curl -s -o /dev/null -w "%{http_code}\n" --cacert web.crt \
  --resolve web.lab.local:30443:172.16.0.126 https://web.lab.local:30443/

Erwartet:

  permanent <boolean>
    Permanent defines whether the redirection is permanent.
--
  port  <string>
    Port defines the port of the new URL.
--
  scheme    <string>
    Scheme defines the scheme of the new URL.
middleware.traefik.io/to-https created
ingress.networking.k8s.io/web annotated
301 https://web.lab.local:30443/
200

Der Verweis lautet <namespace>-<name>@kubernetescrd. Ein Tippfehler darin führt nicht zu einer Fehlermeldung am Ingress – Traefik verwirft den Router, die Seite liefert 404. Ohne port würde auf 443 umgeleitet, das es im Labor nicht gibt.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Versionen der Binaries

kubectl version --client
kubeadm version -o short
kubelet --version
dpkg -l kubelet kubeadm kubectl | tail -3 | cut -c1-40
which kubelet kubeadm kubectl

Erwartet:

Client Version: v1.37.1
Kustomize Version: v5.8.1
v1.37.1
Kubernetes v1.37.1
hi  kubeadm        1.37.1-1.1   amd64
hi  kubectl        1.37.1-1.1   amd64
hi  kubelet        1.37.1-1.1   amd64
/usr/bin/kubelet
/usr/bin/kubeadm
/usr/bin/kubectl

hi heißt: installiert und auf hold. Diese Versionsnummern meldet das Binary selbst – ein manipuliertes Binary meldet, was der Angreifer will (Drill 7).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Prüfsummen gegen dl.k8s.io

Zu jedem Binary veröffentlicht das Projekt eine .sha512- (und .sha256-)Datei. Sie enthält nur die Prüfsumme, ohne Dateinamen:

V=v1.37.1
ARCH=$(dpkg --print-architecture)
U=https://dl.k8s.io/release/$V/bin/linux/${ARCH}
curl -sSLO $U/kubelet.sha512
curl -sSLO $U/kubeadm.sha512
curl -sSLO $U/kubectl.sha512
cat kubelet.sha512; echo
sha512sum /usr/bin/kubelet | cut -c1-40
echo "$(cat kubelet.sha512)  /usr/bin/kubelet" | sha512sum -c
echo "$(cat kubeadm.sha512)  /usr/bin/kubeadm" | sha512sum -c
echo "$(cat kubectl.sha512)  /usr/bin/kubectl" | sha512sum -c

Erwartet (gekürzt):

c776d6e2d26573c7d76697a959939eb9e513157f57333474cc30a988276c0a47d3de7bc819a6d0...
c776d6e2d26573c7d76697a959939eb9e513157f
/usr/bin/kubelet: OK
/usr/bin/kubeadm: OK
/usr/bin/kubectl: OK

sha512sum -c erwartet Zeilen im Format <summe><zwei Leerzeichen><datei> – das baut das echo. Die Binaries aus den Debian-Paketen von pkgs.k8s.io sind bitgleich mit den Release-Dateien. Achte auf die Version im Pfad: Die Summe von v1.37.2 passt nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Ein manipuliertes Binary erkennen

Simuliere eine Manipulation an einer Kopie – ein einziges angehängtes Byte genügt:

cp /usr/bin/kubectl ./kubectl-fake
printf '\x00' >> kubectl-fake
./kubectl-fake version --client | head -1
stat -c "%s %n" /usr/bin/kubectl kubectl-fake
echo "$(cat kubectl.sha512)  kubectl-fake" | sha512sum -c
sha512sum /usr/bin/kubectl kubectl-fake | cut -c1-32

Erwartet:

Client Version: v1.37.1
61886626 /usr/bin/kubectl
61886627 kubectl-fake
kubectl-fake: FAILED
sha512sum: WARNING: 1 computed checksum did NOT match
ff56b9d53b024d0bf4ab6a5c802936d6
de1fe7725a4e23435520dd77f7212784

Die Kopie läuft und meldet brav v1.37.1 – nur die Prüfsumme verrät sie. Ein Byte Unterschied ändert den ganzen Hash.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Laufende Binaries prüfen

API-Server, Controller-Manager und Scheduler laufen als Static Pods aus Images. Was wirklich läuft, zeigt /proc/<PID>/exe – egal, aus welchem Container es stammt:

P=$(pidof kube-apiserver)
sudo readlink /proc/$P/exe
curl -sSLO $U/kube-apiserver.sha512
echo "$(cat kube-apiserver.sha512)  /proc/$P/exe" | sudo sha512sum -c

Erwartet:

/usr/local/bin/kube-apiserver
/proc/16754/exe: OK

pidof statt pgrep -x: Der Kernel kürzt Prozessnamen auf 15 Zeichen, pgrep -x kube-controller-manager findet deshalb nichts. Ist U in einer neuen Shell leer, setze V und U aus Drill 6 erneut.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Erzeuge aus api.crt und api.key (Drill 2) im Namespace tag04 das TLS-Secret api-tls. Zeitziel: 30 s
  2. Ingress api (Klasse traefik) für api.lab.local auf Service web:80, nur mit TLS-Secret api-tls; teste mit curl über 30443. Zeitziel: 2 min
  3. Lies Subject und Ablaufdatum des Zertifikats direkt aus dem Secret api-tls. Zeitziel: 1 min
  4. Prüfe /usr/bin/kubeadm gegen die offizielle sha512-Summe von v1.37.1. Zeitziel: 1 min

Lösung

k create secret tls api-tls --cert=api.crt --key=api.key
k create ingress api --class=traefik --rule="api.lab.local/*=web:80,tls=api-tls"
curl -s -o /dev/null -w "%{http_code}\n" --cacert api.crt \
  --resolve api.lab.local:30443:172.16.0.126 https://api.lab.local:30443/
k get secret api-tls -o jsonpath='{.data.tls\.crt}' | base64 -d \
  | openssl x509 -noout -subject -enddate
ARCH=$(dpkg --print-architecture)
U=https://dl.k8s.io/release/v1.37.1/bin/linux/${ARCH}
echo "$(curl -sSL $U/kubeadm.sha512)  /usr/bin/kubeadm" | sha512sum -c

Erwartet:

secret/api-tls created
ingress.networking.k8s.io/api created
200
subject=CN = api.lab.local
notAfter=Dec 18 17:29:28 2026 GMT
/usr/bin/kubeadm: OK

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k get ingress web -o jsonpath='{.spec.tls[0].secretName}{"\n"}'

Erwartet: web-tls

curl -s -o /dev/null -w "%{http_code} %{redirect_url}\n" -H "Host: web.lab.local" \
  http://172.16.0.126:30080/

Erwartet: 301 https://web.lab.local:30443/

curl -s -o /dev/null -w "%{http_code}\n" --cacert web.crt \
  --resolve web.lab.local:30443:172.16.0.126 https://web.lab.local:30443/

Erwartet: 200

echo "$(cat kubelet.sha512)  /usr/bin/kubelet" | sha512sum -c

Erwartet: /usr/bin/kubelet: OK

Challenge

Im Ordner ~/cks/tag04/bins liegen Kopien von kubelet, kubectl und kubeadm; eine davon ist manipuliert. Finde sie mit einem einzigen sha512sum -c-Aufruf und lösche sie. Prüfe danach auch den laufenden kube-controller-manager auf cp1 und das laufende kubelet auf worker1.

Vorbereitung (spielt den Angreifer):

mkdir -p ~/cks/tag04/bins
cp /usr/bin/kubelet /usr/bin/kubectl /usr/bin/kubeadm ~/cks/tag04/bins/
printf '\x00' >> ~/cks/tag04/bins/kubeadm

Hinweis: sha512sum -c liest beliebig viele Zeilen <summe> <datei> von stdin.

Lösung

cd ~/cks/tag04/bins
for b in kubelet kubectl kubeadm; do echo "$(cat ../$b.sha512)  $b"; done \
  | sha512sum -c
rm kubeadm
cd ~/cks/tag04
P=$(pidof kube-controller-manager)
echo "$(curl -sSL $U/kube-controller-manager.sha512)  /proc/$P/exe" | sudo sha512sum -c

Erwartet (gekürzt):

kubelet: OK
kubectl: OK
kubeadm: FAILED
sha512sum: WARNING: 1 computed checksum did NOT match
/proc/15860/exe: OK

Auf worker1 (ssh [email protected]):

ARCH=$(dpkg --print-architecture)
U=https://dl.k8s.io/release/v1.37.1/bin/linux/${ARCH}
P=$(pidof kubelet)
echo "$(curl -sSL $U/kubelet.sha512)  /proc/$P/exe" | sudo sha512sum -c

Erwartet:

/proc/2342/exe: OK

Aufräumen (auf cp1):

k config set-context --current --namespace=default
k delete ns tag04
rm -rf ~/cks/tag04/bins ~/cks/tag04/kubectl-fake

Fortschritt speichern? Kostenlos registrieren

Prüfungstipp

  • k create secret tls und k create ingress … --rule="host/*=svc:port,tls=secret" sparen das YAML; Secret und Ingress gehören in denselben Namespace.
  • Prüfsummen in der Prüfung: Version genau lesen (kubelet --version), dann die Datei …/release/<version>/bin/linux/amd64/<binary>.sha512 laden. Falsches Binary heißt löschen, nicht reparieren.
  • Doku: kubernetes.io → Concepts → Services → Ingress, Abschnitt „TLS“; Downloads unter kubernetes.io/releases/download.

Enterprise-Notiz

  • Zertifikate kommen von cert-manager (ACME oder interne CA) und erneuern sich selbst; selbst signierte Zertifikate von Hand laufen irgendwann unbemerkt ab.
  • HTTPS-Zwang zentral: Redirect als Default am Entrypoint des Ingress-Controllers (Traefik entryPoints.web.http.redirections) statt pro Ingress, dazu HSTS.
  • Neben TLS am Rand bleibt der Verkehr dahinter im Klartext – Pod-zu-Pod-Verschlüsselung folgt in Tag 12.
  • Binaries signiert prüfen: Kubernetes signiert Release-Artefakte mit cosign (Sigstore); Paketquellen sind per GPG-Schlüssel gesichert.
  • Images der Control Plane per Digest pinnen und Dateiintegrität auf Nodes überwachen (AIDE, Falco in Tag 16).