Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 16: Falco

Ziel: Du installierst Falco mit dem modernen eBPF-Treiber, löst Standardregeln aus, schreibst eigene Regeln mit Listen und Makros und passt Ausgabeformat und Regelsatz an. · Dauer: ca. 75 min · Voraussetzung: Tag 0 und Tag 9

Briefing

  • CKS: Monitoring, Logging and Runtime Security – „Perform behavioral analytics to detect malicious activities“ und „Detect threats within physical infrastructure, apps, networks, data, users and workloads“.
  • Falco hängt sich per eBPF an Syscalls im Kernel, gleicht sie gegen Regeln ab und schreibt Treffer als Zeile ins Log. Falco meldet nur, es blockiert nichts.
  • Eine Regel besteht aus condition (Filter), output (Text mit %feld), priority und desc. Listen (list) und Makros (macro) machen Bedingungen wiederverwendbar.
  • Im Cluster läuft Falco als DaemonSet (Helm), auf Prüfungs-Nodes oft als systemd-Dienst mit Dateien unter /etc/falco/. Drill 7 zeigt beide Orte.
 Pod ──syscall──> Kernel ──eBPF (modern_ebpf)──> Falco-Pod auf demselben Node
                                                  | falco_rules.yaml (Standard)
                                                  | rules.d/*.yaml   (eigene)
                                                  v
                                       k -n falco logs <pod>   (stdout)
mkdir -p ~/cks/tag16 && cd ~/cks/tag16
k create ns tag16
k config set-context --current --namespace=tag16

Drill 1: Falco per Helm installieren

Die Worker haben nur 4 GB RAM, deshalb kleine Requests. Der Sidecar, der wöchentlich neue Regeln lädt, bleibt aus:

helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update falcosecurity
helm search repo falcosecurity/falco --versions | head -2
helm install falco falcosecurity/falco --version 9.2.2 -n falco --create-namespace \
  --set driver.kind=modern_ebpf --set tty=true \
  --set falcoctl.artifact.follow.enabled=false \
  --set resources.requests.cpu=50m --set resources.requests.memory=128Mi
k -n falco rollout status ds/falco
k -n falco get pods -o wide

Erwartet (gekürzt):

NAME                 CHART VERSION  APP VERSION  DESCRIPTION
falcosecurity/falco  9.2.2          0.45.2       Falco
STATUS: deployed
daemon set "falco" successfully rolled out
NAME          READY   STATUS    RESTARTS   AGE   IP             NODE      ...
falco-chdww   1/1     Running   0          46s   10.244.0.78    cp1       ...
falco-m2tvk   1/1     Running   0          46s   10.244.3.216   worker1   ...
falco-xshqs   1/1     Running   0          46s   10.244.1.161   worker2   ...

tty=true sorgt dafür, dass Falco jede Meldung sofort ins Log schreibt. Was Falco geladen hat, steht am Anfang des Logs:

F=$(k -n falco get pod -l app.kubernetes.io/name=falco \
  --field-selector spec.nodeName=worker1 -o name)
echo $F
k -n falco logs $F -c falco | grep -E 'version|rules|modern BPF'
k -n falco exec $F -c falco -- ls /etc/falco
k -n falco exec $F -c falco -- grep '^- rule:' /etc/falco/falco_rules.yaml | wc -l

Erwartet (gekürzt):

pod/falco-m2tvk
Wed Nov 18 18:28:57 2026: Falco version: 0.45.2 (x86_64)
Wed Nov 18 18:28:57 2026: Loading rules from:
Wed Nov 18 18:28:57 2026:    /etc/falco/falco_rules.yaml | schema validation: ok
Wed Nov 18 18:28:57 2026: Opening 'syscall' source with modern BPF probe.
config.d
falco.yaml
falco_rules.yaml
25

Falco meldet nur, was auf seinem Node passiert. Darum suchst du immer erst den Node des verdächtigen Pods und dann den Falco-Pod dort.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Shell im Container

Ein nginx-Pod auf worker1, dann eine interaktive Shell hinein:

k run web --image=nginx:1.29 \
  --overrides='{"spec":{"nodeSelector":{"kubernetes.io/hostname":"worker1"}}}'
k wait --for=condition=Ready pod/web
k exec -it web -- sh -c 'id; exit'
k -n falco logs $F -c falco --since=1m | grep -E '^[0-9]{2}:[0-9]{2}:'

Erwartet (gekürzt, eine Zeile):

uid=0(root) gid=0(root) groups=0(root)
18:29:28.896662585: Notice A shell was spawned in a container with an attached terminal
| evt_type=execve user=root user_uid=0 ... process=sh ... parent=runc
command=sh -c id; exit terminal=34816 ... container_id=737cedd49556 container_name=web
container_image_repository=docker.io/library/nginx container_image_tag=1.29
k8s_pod_name=web k8s_ns_name=tag16

Regel „Terminal shell in container“, Priorität Notice. Ohne -it (kein Terminal) bleibt diese Regel still – proc.tty != 0 steht in ihrer Bedingung. Die Felder ab container_id hängt Falco selbst an (append_output in falco.yaml).

Fortschritt speichern? Kostenlos registrieren

Drill 3: /etc/shadow lesen, unter /etc schreiben

k exec web -- cat /etc/shadow > /dev/null
k exec web -- touch /etc/hacked
k -n falco logs $F -c falco --since=1m | grep -E '^[0-9]{2}:[0-9]{2}:' | cut -c1-120

Erwartet (gekürzt):

18:29:30.134230996: Warning Sensitive file opened for reading by non-trusted program | f

Lesen von /etc/shadow meldet „Read sensitive file untrusted“ (Warning). Das Schreiben unter /etc bleibt still: Die Regel „Write below etc“ gehört nicht mehr zum stabilen Standard-Regelsatz. Die schreibst du in Drill 4 selbst.

k -n falco exec $F -c falco -- falco -L | grep -c 'below etc'
k -n falco exec $F -c falco -- grep -A1 '^- macro: open_write' \
  /etc/falco/falco_rules.yaml

Erwartet:

0
- macro: open_write
  condition: (evt.type in (open,openat,openat2) and evt.is_open_write=true and fd.typec
har='f' and fd.num>=0)

Fortschritt speichern? Kostenlos registrieren

Drill 4: Eigene Regel mit Liste und Makro

Eigene Regeln kommen nie in falco_rules.yaml (wird bei jedem Update überschrieben). Im Helm-Chart landen sie über customRules in der ConfigMap falco-rules, eingehängt unter /etc/falco/rules.d/:

cat > custom-rules.yaml <<'EOF'
customRules:
  tag16-rules.yaml: |-
    - list: tag16_etc_writer
      items: [touch, tee, cp, mv, sed, vi]
    - macro: tag16_write_below_etc
      condition: open_write and fd.name startswith /etc/
    - rule: Write below etc in container
      desc: Ein Prozess im Container schreibt unter /etc
      condition: >
        tag16_write_below_etc and container
        and proc.name in (tag16_etc_writer)
      output: >
        Schreibzugriff unter /etc (file=%fd.name process=%proc.name
        user=%user.name container=%container.name)
      priority: ERROR
      tags: [tag16, filesystem]
EOF
helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reuse-values \
  -f custom-rules.yaml
k -n falco rollout status ds/falco
F=$(k -n falco get pod -l app.kubernetes.io/name=falco \
  --field-selector spec.nodeName=worker1 -o name)
k -n falco logs $F -c falco | grep rules.d

Erwartet (gekürzt):

REVISION: 2
daemon set "falco" successfully rolled out
Wed Nov 18 18:30:23 2026:    /etc/falco/rules.d/tag16-rules.yaml | schema validation: ok

open_write und container sind Makros aus falco_rules.yaml, deine Regel nutzt sie mit. Jetzt auslösen – einmal mit touch, einmal mit einer Umleitung der Shell:

k exec web -- touch /etc/hacked
k exec web -- sh -c 'echo x > /etc/hacked2'
k -n falco logs $F -c falco --since=1m | grep -E '^[0-9]{2}:[0-9]{2}:' | cut -c1-110

Erwartet:

18:31:22.475902384: Error Schreibzugriff unter /etc (file=/etc/hacked process=touch user

Nur eine Meldung: Bei der Umleitung schreibt sh, und sh steht nicht in der Liste. Listen sind bequem, aber jede Lücke darin ist eine Lücke in der Erkennung.

Tipp: Ein Tippfehler in einer Regel lässt Falco nicht starten. Erst prüfen: k -n falco logs $F -c falco | grep -iE 'error|warn' und bei CrashLoop k -n falco logs $F -c falco --previous.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Ausgabeformat anpassen

Prüfungsklassiker: „Ändere die Ausgabe von Regel X auf das Format time,container-id,container-name,user-name“. Die Feldnamen liefert Falco selbst:

k -n falco exec $F -c falco -- falco --list | \
  grep -E '^(evt\.time|container\.(id|name)|user\.name|proc\.name) '

Erwartet (gekürzt):

evt.time                      event timestamp as a time string that includes the nanos
proc.name                     The process name (truncated after 16 characters) generati
user.name                     user name.
container.id                  The truncated container ID (first 12 characters), e.g. 3a
container.name                The container name. In instances of userspace container e

Eine bestehende Regel änderst du nicht in ihrer Datei, sondern überschreibst einzelne Schlüssel in einer später geladenen Datei (falco_rules.yaml lädt ohnehin zuerst; zz- sorgt dafür, dass die Datei auch nach allen anderen in rules.d/ kommt):

cat > override.yaml <<'EOF'
customRules:
  zz-overrides.yaml: |-
    - rule: Terminal shell in container
      output: "%evt.time,%container.id,%container.name,%user.name"
      override:
        output: replace
EOF
helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reuse-values \
  -f custom-rules.yaml -f override.yaml
k -n falco rollout status ds/falco
F=$(k -n falco get pod -l app.kubernetes.io/name=falco \
  --field-selector spec.nodeName=worker1 -o name)
k exec -it web -- sh -c 'id; exit'
k -n falco logs $F -c falco --since=1m | grep -E '^[0-9]{2}:[0-9]{2}:'

Erwartet (gekürzt):

18:34:54.855932161: Notice 18:34:54.855932161,737cedd49556,web,root container_id=737ce
dd49556 container_name=web container_image_repository=docker.io/library/nginx ...

Mit --reuse-values führt Helm die neue customRules-Map mit der alten zusammen – tag16-rules.yaml bliebe auch ohne -f custom-rules.yaml erhalten. Beide Dateien anzugeben macht den Stand nur explizit. Entfernen geht nur per --reset-values (Kontrollpunkt). override kennt append (z. B. für condition oder exceptions) und replace.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Regel abschalten

Die Regel „Contact K8S API Server From Container“ meldet jede Verbindung eines Containers zum API-Server – auch die von Traefik und local-path, wenn sie sich nach einem Neustart des API-Servers neu verbinden. Erst auslösen, dann den Lärm abstellen, aber sichtbar und begründet:

k exec web -- curl -sk -o /dev/null -w '%{http_code}\n' \
  https://kubernetes.default/version
k -n falco logs $F -c falco --since=1m | grep -c 'K8s API Server'
cat >> override.yaml <<'EOF'
    - rule: Contact K8S API Server From Container
      enabled: false
      override:
        enabled: replace
EOF
helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reuse-values \
  -f custom-rules.yaml -f override.yaml
k -n falco rollout status ds/falco
F=$(k -n falco get pod -l app.kubernetes.io/name=falco \
  --field-selector spec.nodeName=worker1 -o name)
k -n falco logs $F -c falco | grep -iE 'rules.d|warn'
k exec web -- curl -sk -o /dev/null -w '%{http_code}\n' \
  https://kubernetes.default/version
k -n falco logs $F -c falco --since=1m | grep -c 'K8s API Server'

Erwartet (gekürzt):

401
1
Wed Nov 18 18:39:24 2026:  /etc/falco/rules.d/tag16-rules.yaml | schema validation: ok
Wed Nov 18 18:39:24 2026:  /etc/falco/rules.d/zz-overrides.yaml | schema validation: ok
401
0

Ohne den override-Block funktioniert es auch, Falco 0.45 warnt dann aber: LOAD_DEPRECATED_ITEM … The standalone 'enabled' key usage is deprecated. Besser als eine Regel abzuschalten ist oft eine Ausnahme (exceptions oder condition mit override: append) – dann bleibt die Erkennung für alle anderen Pods erhalten.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Falco als Systemdienst

In der Prüfung läuft Falco häufig direkt auf dem Node. Dieselben Dateien liegen dann auf der Platte; im Labor nicht live geprüft (gekürzt, kann je nach Version abweichen):

/etc/falco/falco.yaml              Hauptkonfiguration (Ausgaben, rules_files, Format)
/etc/falco/falco_rules.yaml        Standardregeln – nicht ändern
/etc/falco/falco_rules.local.yaml  eigene Regeln und Overrides (bleibt bei Updates)
/etc/falco/rules.d/                weitere Regeldateien (alphabetisch geladen)
systemctl status falco-modern-bpf  Dienst (Unit-Name je nach Treiber)
journalctl -u falco-modern-bpf     Meldungen, wenn stdout_output aktiv ist

Die Reihenfolge der Dateien steht in rules_files der falco.yaml; im Pod nachsehen:

k -n falco exec $F -c falco -- grep -A3 '^rules_files' /etc/falco/falco.yaml
k -n falco exec $F -c falco -- falco --dry-run 2>&1 | grep 'rules.d'

Erwartet:

rules_files:
- /etc/falco/falco_rules.yaml
- /etc/falco/falco_rules.local.yaml
- /etc/falco/rules.d
Wed Nov 18 18:40:22 2026:  /etc/falco/rules.d/tag16-rules.yaml | schema validation: ok
Wed Nov 18 18:40:22 2026:  /etc/falco/rules.d/zz-overrides.yaml | schema validation: ok

falco --dry-run lädt Konfiguration und Regeln, ohne Ereignisse zu verarbeiten – der schnellste Syntaxtest nach dem Bearbeiten von falco_rules.local.yaml. Auf einem Node danach sudo systemctl restart falco-modern-bpf (oder auf das automatische Neuladen warten, watch_config_files: true).

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Finde heraus, welche Falco-Regel feuert, wenn im Pod web jemand cat /etc/shadow ausführt, und mit welcher Priorität. Zeitziel: 2 min
  2. Zeige die Beschreibung der Regel „Terminal shell in container“ mit dem Falco-Binary. Zeitziel: 1 min
  3. Stelle die Falco-Ausgabe auf JSON um und zeige eine Meldung. Zeitziel: 3 min
  4. Zähle, wie oft deine Regel „Write below etc in container“ auf worker1 angeschlagen hat. Zeitziel: 1 min

Lösung

k get pod web -o jsonpath='{.spec.nodeName}'; echo
F=$(k -n falco get pod -l app.kubernetes.io/name=falco \
  --field-selector spec.nodeName=worker1 -o name)
k exec web -- cat /etc/shadow > /dev/null
k -n falco logs $F -c falco --since=1m | grep shadow | cut -c1-90

Erwartet:

worker1
18:38:48.889169448: Warning Sensitive file opened for reading by non-trusted program
k -n falco exec $F -c falco -- falco -l 'Terminal shell in container' | head -3

Erwartet: Name der Regel und der Anfang ihrer desc („A shell was used as the entrypoint/exec point into a container with an attached terminal …“).

helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reuse-values \
  -f custom-rules.yaml -f override.yaml --set falco.json_output=true
k -n falco rollout status ds/falco
F=$(k -n falco get pod -l app.kubernetes.io/name=falco \
  --field-selector spec.nodeName=worker1 -o name)
k exec web -- touch /etc/hacked
k -n falco logs $F -c falco --since=1m | grep '^{' | head -1 \
  | jq -r '.time, .rule, .priority, .output_fields."container.name"'

Erwartet:

2026-11-18T18:45:39.705759714Z
Write below etc in container
Error
web

Jede Meldung ist jetzt ein JSON-Objekt mit rule, priority, time (ISO 8601) und allen Feldern einzeln unter output_fields – ideal für Log-Systeme. Auch falco -l antwortet dann in JSON.

k -n falco logs $F -c falco | grep -c 'Schreibzugriff unter /etc'

Erwartet: eine Zahl größer 0. Nach jedem Neustart des Falco-Pods beginnt die Zählung neu – Falco-Meldungen gehören in ein zentrales Log-System.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Zuerst den Regelsatz auf den Standard zurücksetzen. Falco selbst bleibt installiert für Tag 19 und die Probeprüfung:

helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reset-values \
  --set driver.kind=modern_ebpf --set tty=true \
  --set falcoctl.artifact.follow.enabled=false \
  --set resources.requests.cpu=50m --set resources.requests.memory=128Mi
k -n falco rollout status ds/falco
helm get values falco -n falco

Erwartet: nur driver, falcoctl, resources und tty – kein customRules, kein falco.json_output.

k -n falco get cm

Erwartet: falco, falco-falcoctl, kube-root-ca.crt – die ConfigMap falco-rules ist weg.

k -n falco get ds falco

Erwartet: DESIRED 3, READY 3.

k top pod -n falco

Erwartet: drei Pods, je etwa 40–60 Mi Speicher.

Challenge

Ein Team meldet, dass in Namespace tag16 jemand Paketmanager ausführt. Schreibe eine Regel „Package manager in container“ (Priorität CRITICAL), die apt, apt-get, apk und dpkg in Containern meldet, mit der Ausgabe time,container-name,k8s-namespace,process,user. Weise den Treffer mit k exec web -- apt-get --version nach.

Hinweis: spawned_process ist das Makro für neue Prozesse; den Namespace liefert k8s.ns.name.

Lösung

cat > challenge.yaml <<'EOF'
customRules:
  tag16-challenge.yaml: |-
    - list: tag16_pkg_mgr
      items: [apt, apt-get, apk, dpkg]
    - rule: Package manager in container
      desc: Paketmanager im Container gestartet
      condition: spawned_process and container and proc.name in (tag16_pkg_mgr)
      output: "%evt.time,%container.name,%k8s.ns.name,%proc.name,%user.name"
      priority: CRITICAL
      tags: [tag16]
EOF
helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reuse-values \
  -f challenge.yaml
k -n falco rollout status ds/falco
F=$(k -n falco get pod -l app.kubernetes.io/name=falco \
  --field-selector spec.nodeName=worker1 -o name)
k exec web -- apt-get --version | head -1
k -n falco logs $F -c falco --since=1m | grep Critical | cut -c1-100

Erwartet (gekürzt):

apt 3.0.3 (amd64)
18:49:21.899342994: Critical 18:49:21.899342994,web,tag16,apt-get,root container_id=7

Danach wieder zurück auf den Standard (Befehl aus dem Kontrollpunkt):

helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reset-values \
  --set driver.kind=modern_ebpf --set tty=true \
  --set falcoctl.artifact.follow.enabled=false \
  --set resources.requests.cpu=50m --set resources.requests.memory=128Mi

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Gilt für alle, auch ohne Challenge:

k config set-context --current --namespace=default
k delete ns tag16

Prüfungstipp

  • Erst den Node des Pods finden, dann das Log des Falco-Pods (oder journalctl des Dienstes) auf diesem Node lesen. --since=5m und grep sparen Zeit.
  • Ausgabeformate wie „time,container-id,container-name,user-name“ exakt mit %evt.time,%container.id,%container.name,%user.name umsetzen; Feldnamen per falco --list prüfen statt raten.
  • Eigene Regeln und Overrides nach falco_rules.local.yaml oder rules.d/, nie nach falco_rules.yaml. Doku: falco.org/docs → Rules → Overriding Rules, Supported Fields.

Enterprise-Notiz

  • Meldungen per falcosidekick an Slack, SIEM oder Loki weiterleiten; json_output=true erleichtert das Auswerten.
  • Regeln mit falcoctl als OCI-Artefakt versionieren und verteilen, statt sie per Hand in ConfigMaps zu pflegen.
  • Lärm über exceptions pro Image oder Namespace dämpfen, nicht über das Abschalten ganzer Regeln – sonst fehlt die Meldung genau beim Angriff.
  • Falco Talon oder eigene Webhooks können auf Meldungen reagieren (Pod isolieren, Label setzen). Blockieren im Kernel kann Tetragon (Tag 17).
  • Requests und Limits nach Messung setzen: Unter Last wächst der Ringpuffer-Verbrauch mit der Zahl der CPUs.