Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 17: Tetragon

Ziel: Du beobachtest Prozesse, Dateizugriffe und Verbindungen mit Tetragon und blockierst unerwünschte Aktionen direkt im Kernel – cluster-weit oder pro Namespace. · Dauer: ca. 75 min · Voraussetzung: Tag 16

Briefing

  • CKS: Monitoring, Logging and Runtime Security – Verhaltensanalyse und Erkennung zur Laufzeit; Tetragon ist das eBPF-Werkzeug aus dem Cilium-Projekt.
  • Ohne Policy meldet Tetragon Prozessstart und -ende (process_exec, process_exit) mit Pod, Namespace und Binary. Alles andere beschreibt eine TracingPolicy (Kernelfunktion, Argumente, Filter).
  • Anders als Falco kann Tetragon im Kernel eingreifen: Sigkill beendet den Prozess, Override lässt den Aufruf mit einem Fehler zurückkehren.
  • TracingPolicyNamespaced gilt nur in einem Namespace, podSelector grenzt weiter ein.
  • Heute nur zum Üben: Am Ende wird Tetragon wieder entfernt (Ressourcen der Worker).
 Pod ──> Kernel: execve, security_file_permission, tcp_connect ...
            | eBPF (kprobe aus TracingPolicy)
            |   Selector passt? ── nein ──> nichts
            |        | ja
            |        v
            |   matchActions: Post (melden) · Sigkill · Override (Fehler)
            v
 tetragon-Pod (DaemonSet) ──> tetra getevents -o compact · Log export-stdout (JSON)
mkdir -p ~/cks/tag17 && cd ~/cks/tag17
k create ns tag17
k config set-context --current --namespace=tag17
k run web --image=nginx:1.29 \
  --overrides='{"spec":{"nodeSelector":{"kubernetes.io/hostname":"worker1"}}}'
k wait --for=condition=Ready pod/web

Drill 1: Tetragon per Helm installieren

Das Chart liegt im Cilium-Repo (aus Tag 12 bereits eingetragen):

helm repo add cilium https://helm.cilium.io/
helm repo update cilium
helm search repo cilium/tetragon --versions | head -2
helm install tetragon cilium/tetragon --version 1.8.0 -n kube-system \
  --set tetragon.resources.requests.cpu=50m \
  --set tetragon.resources.requests.memory=128Mi
k -n kube-system rollout status ds/tetragon
k -n kube-system get pods -l app.kubernetes.io/name=tetragon -o wide
k get crd | grep tracingpolic

Erwartet (gekürzt):

NAME             CHART VERSION  APP VERSION  DESCRIPTION
cilium/tetragon  1.8.0          1.8.0        Helm chart for Tetragon
STATUS: deployed
daemon set "tetragon" successfully rolled out
NAME             READY   STATUS    RESTARTS   AGE   IP             NODE      ...
tetragon-mmpft   2/2     Running   0          61s   172.16.0.83    worker2   ...
tetragon-qtwgc   2/2     Running   0          61s   172.16.0.228   worker1   ...
tetragon-xtn77   2/2     Running   0          61s   172.16.0.126   cp1       ...
tracingpolicies.cilium.io                    2026-11-18T18:51:58Z
tracingpoliciesnamespaced.cilium.io          2026-11-18T18:52:00Z

Zwei Container pro Pod: tetragon (Agent, mit der CLI tetra) und export-stdout (schreibt alle Ereignisse als JSON ins Log). Die Pods laufen im Host-Netz, daher die Node-IPs. Was der Kernel kann, steht im Agent-Log:

T=$(k -n kube-system get pod -l app.kubernetes.io/name=tetragon \
  --field-selector spec.nodeName=worker1 -o name)
k -n kube-system exec $T -c tetragon -- tetra version
k -n kube-system exec $T -c tetragon -- tetra status
k -n kube-system logs $T -c tetragon | grep -o 'override_return: [a-z]*'

Erwartet:

CLI version: v1.8.0
Health Status: running
override_return: true

Fortschritt speichern? Kostenlos registrieren

Drill 2: Prozesse beobachten

Zwei Terminals auf cp1. Im neuen Terminal zuerst cd ~/cks/tag17 und T=$(…) aus Drill 1 wiederholen. Terminal 1 zeigt die Ereignisse des Namespace tag17:

k -n kube-system exec $T -c tetragon -- \
  tetra getevents -o compact --namespace tag17

Terminal 2:

k exec web -- sh -c \
  'cat /etc/shadow > /dev/null; curl -s -o /dev/null http://example.com'

Erwartet (Terminal 1, gekürzt, Symbole am Zeilenanfang weggelassen):

process tag17/web /usr/bin/sh "-c \"cat /etc/shadow > /dev/null; curl -s -o ...\""
process tag17/web /usr/bin/cat /etc/shadow
exit    tag17/web /usr/bin/cat /etc/shadow 0
process tag17/web /usr/bin/curl "-s -o /dev/null http://example.com"
exit    tag17/web /usr/bin/curl "-s -o /dev/null http://example.com" 0
exit    tag17/web /usr/bin/sh "-c \"cat /etc/shadow > /dev/null; curl -s -o ...\"" 0

Jede Zeile: Ereignistyp, Namespace/Pod, Binary, Argumente, beim exit der Rückgabewert. Dass cat gerade /etc/shadow liest, siehst du nur an den Argumenten – den Dateizugriff selbst meldet erst eine Policy. Weitere Filter: --pod, --process, --timestamps. Terminal 1 mit Strg+C beenden, wenn ein Drill fertig ist.

Fortschritt speichern? Kostenlos registrieren

Drill 3: TracingPolicy für /etc/shadow

security_file_permission ist die Kernelfunktion, die bei jedem Lese- und Schreibzugriff auf eine offene Datei prüft, ob er erlaubt ist. Ihr erstes Argument ist die Datei, Tetragon löst daraus den vollständigen Pfad auf:

cat > shadow.yaml <<'EOF'
apiVersion: cilium.io/v1alpha1
kind: TracingPolicy
metadata:
  name: tag17-shadow
spec:
  kprobes:
  - call: security_file_permission
    syscall: false
    args:
    - index: 0
      type: file
    - index: 1
      type: int
    selectors:
    - matchArgs:
      - index: 0
        operator: Equal
        values:
        - /etc/shadow
EOF
k apply -f shadow.yaml
k get tracingpolicies
k -n kube-system exec $T -c tetragon -- tetra tracingpolicy list

Erwartet (gekürzt):

tracingpolicy.cilium.io/tag17-shadow created
NAME           AGE
tag17-shadow   1s
ID   NAME           DOMAIN   STATE     FILTERID   NAMESPACE   ...  MODE
2    tag17-shadow   k8s      enabled   0          (global)    ...  monitor_only

Terminal 1 wieder starten, in Terminal 2:

k exec web -- cat /etc/shadow > /dev/null

Erwartet (Terminal 1, gekürzt):

process tag17/web /usr/bin/cat /etc/shadow
read    tag17/web /usr/bin/cat /etc/shadow
read    tag17/web /usr/bin/cat /etc/shadow
exit    tag17/web /usr/bin/cat /etc/shadow 0

read ist das neue Ereignis aus der Policy (process_kprobe). Mehrere Zeilen, weil cat in Blöcken liest und jeder Block geprüft wird. STATE enabled und MODE monitor_only heißen: geladen, meldet nur.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Verbindungen nach außen

tcp_connect meldet jede ausgehende TCP-Verbindung. Interessant sind nur Ziele außerhalb von Cluster- und Loopback-Netz:

cat > connect.yaml <<'EOF'
apiVersion: cilium.io/v1alpha1
kind: TracingPolicy
metadata:
  name: tag17-connect
spec:
  kprobes:
  - call: tcp_connect
    syscall: false
    args:
    - index: 0
      type: sock
    selectors:
    - matchArgs:
      - index: 0
        operator: NotDAddr
        values:
        - 127.0.0.0/8
        - 10.0.0.0/8
EOF
k apply -f connect.yaml

Terminal 1 läuft, in Terminal 2:

k exec web -- curl -s -o /dev/null -w '%{http_code}\n' http://example.com
k exec web -- curl -s -o /dev/null -w '%{http_code}\n' http://kubernetes.default:443

Erwartet (Terminal 2, dann Terminal 1 gekürzt):

200
400
process tag17/web /usr/bin/curl "-s -o /dev/null -w %{http_code}\\n http://example.com"
connect tag17/web /usr/bin/curl tcp 10.244.3.241:53206 -> 172.66.147.243:80
exit    tag17/web /usr/bin/curl "... http://example.com" 0
process tag17/web /usr/bin/curl "... http://kubernetes.default:443"
exit    tag17/web /usr/bin/curl "... http://kubernetes.default:443" 0

Die Verbindung zum API-Server (Service-IP 10.96.0.1) fällt unter 10.0.0.0/8 und wird nicht gemeldet, die nach außen schon – mit Pod-IP, Ziel-IP und Port.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Durchsetzen mit Sigkill

Jetzt nur im Namespace tag17 und mit Aktion. Ein zweiter Namespace zeigt die Grenze:

cat > shadow-kill.yaml <<'EOF'
apiVersion: cilium.io/v1alpha1
kind: TracingPolicyNamespaced
metadata:
  name: tag17-shadow-kill
  namespace: tag17
spec:
  kprobes:
  - call: security_file_permission
    syscall: false
    args:
    - index: 0
      type: file
    - index: 1
      type: int
    selectors:
    - matchArgs:
      - index: 0
        operator: Equal
        values:
        - /etc/shadow
      matchActions:
      - action: Sigkill
EOF
k apply -f shadow-kill.yaml
k get tracingpoliciesnamespaced
k exec web -- cat /etc/shadow
k exec web -- head -1 /etc/passwd
k create ns tag17-b
k -n tag17-b run web --image=nginx:1.29 \
  --overrides='{"spec":{"nodeSelector":{"kubernetes.io/hostname":"worker1"}}}'
k -n tag17-b wait --for=condition=Ready pod/web
k -n tag17-b exec web -- cat /etc/shadow | head -1

Erwartet:

tracingpolicynamespaced.cilium.io/tag17-shadow-kill created
NAME                AGE
tag17-shadow-kill   1s
command terminated with exit code 137
root:x:0:0:root:/root:/bin/bash
pod/web created
pod/web condition met
root:*:20578:0:99999:7:::

Exit 137 = 128 + 9 (SIGKILL). Der Prozess wird beendet, bevor er die Daten ausgeben kann; /etc/passwd bleibt lesbar, und in tag17-b greift die Policy nicht.

Was ist passiert? Das JSON-Log des Agents nennt Policy, Aktion, Pod und Datei:

k -n kube-system logs $T -c export-stdout --since=5m | grep tag17-shadow-kill \
  | tail -1 | jq -c '{pol: .process_kprobe.policy_name,
  act: .process_kprobe.action, pod: .process_kprobe.process.pod.name,
  file: .process_kprobe.args[0].file_arg.path}'

Erwartet (umbrochen):

{"pol":"tag17-shadow-kill","act":"KPROBE_ACTION_SIGKILL","pod":"web",
"file":"/etc/shadow"}

Fortschritt speichern? Kostenlos registrieren

Drill 6: Durchsetzen mit Override

Terminal 1 wieder starten. Override beendet nicht den Prozess, sondern lässt den Aufruf mit einem Fehler zurückkehren – die Anwendung bekommt „Operation not permitted“ und läuft weiter. Erster Versuch: dieselbe Policy, nur mit Override:

k delete -f shadow-kill.yaml
sed 's/- action: Sigkill/- action: Override\n        argError: -1/;
  s/tag17-shadow-kill/tag17-shadow-deny/' shadow-kill.yaml > shadow-deny.yaml
k apply -f shadow-deny.yaml
k -n kube-system exec $T -c tetragon -- tetra tracingpolicy list | grep deny
k -n kube-system logs $T -c tetragon | grep -o "can't override.*option" | tail -1

Erwartet:

5    tag17-shadow-deny   k8s      load_error   0          tag17   ...   unknown
can't override 'security_file_permission' function with kprobe_multi, use
--disable-kprobe-multi option

Die Policy ist angelegt, aber nicht geladen (load_error) – k apply meldet keinen Fehler. Mit kprobe_multi (Standard) erlaubt Tetragon Override nur auf Syscalls; statt den Agent umzukonfigurieren, nehmen wir sys_openat mit dem Pfad als zweitem Argument:

k delete -f shadow-deny.yaml
cat > shadow-deny.yaml <<'EOF'
apiVersion: cilium.io/v1alpha1
kind: TracingPolicyNamespaced
metadata:
  name: tag17-shadow-deny
  namespace: tag17
spec:
  kprobes:
  - call: sys_openat
    syscall: true
    args:
    - index: 0
      type: int
    - index: 1
      type: string
    selectors:
    - matchArgs:
      - index: 1
        operator: Equal
        values:
        - /etc/shadow
      matchActions:
      - action: Override
        argError: -1
EOF
k apply -f shadow-deny.yaml
k -n kube-system exec $T -c tetragon -- tetra tracingpolicy list | grep deny
k exec web -- cat /etc/shadow

Erwartet (gekürzt):

6    tag17-shadow-deny   k8s      enabled   6          tag17   ...   enforce   ...
cat: /etc/shadow: Operation not permitted
command terminated with exit code 1

argError: -1 ist -EPERM. Im Terminal 1 erscheint dazu eine Zeile openat tag17/web /usr/bin/cat /etc/shadow.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeige alle geladenen Tetragon-Policies mit Zustand und Modus auf worker1. Zeitziel: 1 min
  2. Zeige nur die Prozess-Ereignisse des Binaries curl im Namespace tag17. Zeitziel: 2 min
  3. Beende im Namespace tag17 jeden Start von /usr/bin/curl, aber nur in Pods mit dem Label app=legacy. Zeitziel: 5 min

Lösung

k -n kube-system exec $T -c tetragon -- tetra tracingpolicy list

Erwartet: tag17-shadow und tag17-connect als (global)/monitor_only, tag17-shadow-deny mit Namespace tag17 und enforce.

k -n kube-system exec $T -c tetragon -- \
  tetra getevents -o compact --namespace tag17 --process curl

Erwartet (sobald in web ein curl läuft, gekürzt):

process tag17/web /usr/bin/curl "-s -o /dev/null http://example.com"
connect tag17/web /usr/bin/curl tcp 10.244.3.241:46750 -> 104.20.23.154:80
exit    tag17/web /usr/bin/curl "-s -o /dev/null http://example.com" 0

Andere Programme (ls, cat) tauchen nicht auf.

security_bprm_check prüft jedes Programm vor dem Start; podSelector schränkt die Policy auf passende Pods ein:

cat > curl-kill.yaml <<'EOF'
apiVersion: cilium.io/v1alpha1
kind: TracingPolicyNamespaced
metadata:
  name: tag17-curl-kill
  namespace: tag17
spec:
  podSelector:
    matchLabels:
      app: legacy
  kprobes:
  - call: security_bprm_check
    syscall: false
    args:
    - index: 0
      type: linux_binprm
    selectors:
    - matchArgs:
      - index: 0
        operator: Equal
        values:
        - /usr/bin/curl
      matchActions:
      - action: Sigkill
EOF
k apply -f curl-kill.yaml
k exec web -- curl -s -o /dev/null -w '%{http_code}\n' http://example.com
k label pod web app=legacy
k exec web -- curl -s -o /dev/null -w '%{http_code}\n' http://example.com

Erwartet:

tracingpolicynamespaced.cilium.io/tag17-curl-kill created
200
pod/web labeled
command terminated with exit code 137

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k get tracingpolicies,tracingpoliciesnamespaced -A

Erwartet: tag17-shadow, tag17-connect (cluster-weit) sowie tag17-shadow-deny und tag17-curl-kill in tag17 (ggf. auch tag17-shadow-kill aus der Challenge).

k exec web -- cat /etc/shadow

Erwartet: cat: /etc/shadow: Operation not permitted oder Exit-Code 137.

k -n tag17-b exec web -- cat /etc/shadow | head -1

Erwartet: root:*:… – der andere Namespace ist nicht betroffen.

Tetragon wird am Ende des Tages wieder deinstalliert (Abschnitt „Aufräumen“); Falco aus Tag 16 bleibt.

Challenge

Die Override-Policy aus Drill 6 vergleicht nur den String, den das Programm an openat übergibt. Lies /etc/shadow im Pod web trotzdem und schließe die Lücke so, dass auch dein Umweg scheitert.

Hinweis: Relativer Pfad oder doppelter Schrägstrich – und welcher Argumenttyp liefert den aufgelösten Pfad?

Lösung

k exec web -- sh -c 'cd /etc && cat shadow | head -1'
k exec web -- cat /etc//shadow | head -1

Erwartet:

root:*:20578:0:99999:7:::
root:*:20578:0:99999:7:::

Beide Umwege lesen die Datei, weil "shadow" und "/etc//shadow" nicht gleich "/etc/shadow" sind. Der Typ file an security_file_permission (Drill 5) prüft dagegen die geöffnete Datei mit aufgelöstem Pfad:

k apply -f shadow-kill.yaml
k exec web -- sh -c 'cd /etc && cat shadow | head -1'
k -n kube-system exec $T -c tetragon -- tetra tracingpolicy list | grep kill

Erwartet (gekürzt):

tracingpolicynamespaced.cilium.io/tag17-shadow-kill created
Killed
7    tag17-shadow-kill   k8s      enabled   7    tag17   ...   enforce   2   2   0

Faustregel: Bei Syscalls mit Pfad-Strings filterst du Benutzereingaben, bei file-Argumenten an LSM-Funktionen das echte Objekt.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Gilt für alle, auch ohne Challenge – Policies, Namespaces und Tetragon selbst:

k delete tracingpolicies tag17-shadow tag17-connect
k config set-context --current --namespace=default
k delete ns tag17 tag17-b
helm uninstall tetragon -n kube-system
k delete crd tracingpolicies.cilium.io tracingpoliciesnamespaced.cilium.io

Nach etwa einer Minute:

k -n kube-system get pods | grep -c tetragon

Erwartet (gekürzt):

release "tetragon" uninstalled
customresourcedefinition.apiextensions.k8s.io "tracingpolicies.cilium.io" deleted
customresourcedefinition.apiextensions.k8s.io "tracingpoliciesnamespaced.cilium.io" ...
0

Die CRDs legt der Tetragon-Operator an, nicht Helm – daher löscht helm uninstall sie nicht. Auf jedem Node bleiben /var/log/tetragon/ und eine gepinnte BPF-Map unter /sys/fs/bpf/tetragon/ zurück; harmlos, wer es sauber will:

ssh [email protected] \
  'sudo rm -rf /var/log/tetragon /var/run/tetragon /sys/fs/bpf/tetragon'

Dasselbe per ssh auf 172.16.0.83 und lokal auf cp1 (172.16.0.126) mit sudo rm -rf ….

Prüfungstipp

  • Tetragon-Aufgaben sind meist „Policy anwenden und Ereignisse finden“: k apply, dann tetra tracingpolicy list (Zustand enabled, nicht load_error) und tetra getevents -o compact im Agent-Pod des richtigen Nodes.
  • Falco oder Tetragon? Falco: fertige Regeln, Meldung als Logzeile, Anpassung über Regeldateien. Tetragon: Kernelfunktionen und Argumente selbst wählen, Ereignisse als JSON, Durchsetzen mit Sigkill/Override.
  • Doku: tetragon.io → Concepts → Tracing Policy (Selectors, Actions), Getting Started → File Access und Network Monitoring.

Enterprise-Notiz

  • Erst beobachten (Post), dann durchsetzen: Ein falscher Selector mit Sigkill beendet sonst Systemprozesse auf dem ganzen Node.
  • Ereignisse aus export-stdout bzw. /var/log/tetragon/tetragon.log per Fluent Bit oder Vector ins SIEM; export-denylist und Rate-Limits gegen Datenflut setzen.
  • Policies wie Code behandeln: Git, Review, gestaffelter Rollout, gemessener Speicherbedarf (jede kprobe-Policy belegt Kernel-Speicher, siehe Spalte KERNELMEMORY in tetra tracingpolicy list).
  • Mit CiliumNetworkPolicies (Tag 2) und Tetragon deckt ein eBPF-Stack Netz und Laufzeit ab; Falco bleibt stark bei fertigen Erkennungsregeln und Integrationen.
  • Für Kernelfunktionen gibt es keine stabile API: Policies nach Kernel-Updates testen.