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),priorityunddesc. 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=tag16Drill 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 wideErwartet (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 -lErwartet (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-120Erwartet (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.yamlErwartet:
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.dErwartet (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-110Erwartet:
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 CrashLoopk -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
- Finde heraus, welche Falco-Regel feuert, wenn im Pod
webjemandcat /etc/shadowausführt, und mit welcher Priorität. Zeitziel: 2 min - Zeige die Beschreibung der Regel „Terminal shell in container“ mit dem Falco-Binary. Zeitziel: 1 min
- Stelle die Falco-Ausgabe auf JSON um und zeige eine Meldung. Zeitziel: 3 min
- 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-90Erwartet:
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 -3Erwartet: 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/falcohelm get values falco -n falcoErwartet: nur driver,
falcoctl, resources und tty –
kein customRules, kein falco.json_output.
k -n falco get cmErwartet: falco,
falco-falcoctl, kube-root-ca.crt – die
ConfigMap falco-rules ist weg.
k -n falco get ds falcoErwartet: DESIRED 3,
READY 3.
k top pod -n falcoErwartet: 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-100Erwartet (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=128MiFortschritt speichern? Kostenlos registrieren
Aufräumen
Gilt für alle, auch ohne Challenge:
k config set-context --current --namespace=default
k delete ns tag16Prüfungstipp
- Erst den Node des Pods finden, dann das Log des Falco-Pods (oder
journalctldes Dienstes) auf diesem Node lesen.--since=5mundgrepsparen Zeit. - Ausgabeformate wie „time,container-id,container-name,user-name“
exakt mit
%evt.time,%container.id,%container.name,%user.nameumsetzen; Feldnamen perfalco --listprüfen statt raten. - Eigene Regeln und Overrides nach
falco_rules.local.yamloderrules.d/, nie nachfalco_rules.yaml. Doku: falco.org/docs → Rules → Overriding Rules, Supported Fields.
Enterprise-Notiz
- Meldungen per falcosidekick an Slack, SIEM oder Loki weiterleiten;
json_output=trueerleichtert das Auswerten. - Regeln mit
falcoctlals OCI-Artefakt versionieren und verteilen, statt sie per Hand in ConfigMaps zu pflegen. - Lärm über
exceptionspro 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.