Tag 13: Falco – Alarme und Störungen
Ziel: Du führst einen Falco-Alarm auf Knoten, Pod und Container zurück, stellst einen Fehlalarm mit einer engen Ausnahme ab und erkennst, wann Falco selbst kaputt ist oder keine Kubernetes-Metadaten mehr liefert. · Dauer: ca. 60 min · Voraussetzung: Tag 12
Briefing
- Falco liest per eBPF die Systemaufrufe jedes Knotens und vergleicht sie mit Regeln. Es blockiert nichts, es meldet nur – als JSON-Zeile im Log des Falco-Pods.
- Fehler mit Falco sind Fragen an den Betrieb: Woher kommt der Alarm? Warum jede Nacht derselbe? Warum startet Falco nach einer Regeländerung nicht? Warum fehlt der Pod?
- Die Container-ID kommt aus dem Kernel, Pod und Namespace aus der Container-Runtime.
| Fehlerbild | Symptom | Wo die Antwort steht |
|---|---|---|
Alarm nach exec -it |
Terminal shell in container |
output_fields, crictl |
| Fehlalarm durch Job | derselbe Alarm alle 10 min | Regel, exceptions |
| Kaputte Regeldatei | ein Falco-Pod CrashLoopBackOff |
Start-Log, LOAD_ERR_… |
| Keine Metadaten | k8s_pod_name=<NA> |
Socket-Liste, crictl.yaml |
Drill 1: Falco installieren
Falco läuft als DaemonSet, ein Pod je Knoten.
modern_ebpf braucht kein Kernel-Modul;
json_output macht jeden Alarm zu einer JSON-Zeile, die du
mit jq auswertest.
# auf cp1
mkdir -p ~/debug/tag13 && cd ~/debug/tag13
helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update falcosecurity
cat > falco-values.yaml <<'EOF'
tty: true
driver:
kind: modern_ebpf
falco:
json_output: true
EOF
helm upgrade --install falco falcosecurity/falco -n falco --create-namespace \
--version 9.2.2 -f falco-values.yaml --wait --timeout 5m | grep -E 'STATUS|REV'
kubectl -n falco get pods -o wide | cut -c1-72Erwartet (gekürzt):
STATUS: deployed
REVISION: 1
NAME READY STATUS RESTARTS AGE IP NODE
falco-2cb48 2/2 Running 0 22s 10.42.2.105 worker2
falco-79l4k 2/2 Running 0 22s 10.42.0.131 cp1
falco-w6t4z 2/2 Running 0 22s 10.42.1.96 worker1
Chart 9.2.2 bringt Falco 0.45.2 mit. Ob Falco wirklich arbeitet, steht im Start-Log:
# auf cp1
kubectl -n falco logs ds/falco -c falco \
| grep -E 'Falco version|rules from|schema|k3s|BPF probe' | cut -c27-114Erwartet:
Found 3 pods, using pod/falco-2cb48
Falco version: 0.45.2 (x86_64)
/etc/falco/falco.yaml | schema validation: ok
[libs]: container: * enabled container runtime socket at '/host/run/k3s/containerd/conta
Loading rules from:
/etc/falco/falco_rules.yaml | schema validation: ok
Opening 'syscall' source with modern BPF probe.
Drei Zeilen zählen: jede Regeldatei mit
schema validation: ok, der Socket der Container-Runtime und
modern BPF probe. cut -c27- schneidet den
Zeitstempel ab; logs ds/falco liest nur einen der drei Pods
und sagt, welchen.
Talos: Dort scheitert dasselbe DaemonSet zuerst an Pod Security
baseline(privileged,hostPath) – Tag 19.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Wer hat die Shell geöffnet?
Einbauen: Ein Pod auf worker1, in dem
jemand eine Shell mit Terminal öffnet:
# auf cp1
kubectl create namespace tag13
cat > web.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag13}
spec:
replicas: 1
selector: {matchLabels: {app: web}}
template:
metadata: {labels: {app: web}}
spec:
nodeSelector: {kubernetes.io/hostname: worker1}
containers:
- name: web
image: busybox:1.37
command: [sleep, infinity]
EOF
kubectl apply -f web.yaml
kubectl -n tag13 rollout status deploy/web
kubectl -n tag13 exec -it deploy/web -- sh -c 'id; exit'Erwartet:
namespace/tag13 created
deployment.apps/web created
deployment "web" successfully rolled out
uid=0(root) gid=0(root) groups=0(root),10(wheel)
Symptom: Im Log eines Falco-Pods steht eine lange
JSON-Zeile. Der lesbare Teil steckt in output:
# auf cp1
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| grep 'Terminal shell' | jq -r .output | fold -w 86Erwartet (gekürzt):
10:28:26.553927374: Notice A shell was spawned in a container with an attached termina
l | evt_type=execve user=root user_uid=0 user_loginuid=-1 process=sh proc_exepath=/bin
/sh parent=containerd-shim command=sh -c id; exit terminal=34816 exe_flags=EXE_WRITABL
E|EXE_LOWER_LAYER container_id=03479ff2b911 container_name=web container_image_reposit
ory=docker.io/library/busybox container_image_tag=1.37 k8s_pod_name=web-6f88f4fd9c-l5r
b4 k8s_ns_name=tag13
Untersuchen: Mit jq holst du die Felder
aus output_fields. fromjson? überspringt die
Textzeilen vom Start:
# auf cp1
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| jq -cR 'fromjson? | select(.rule=="Terminal shell in container")
| {hostname, ns: .output_fields["k8s.ns.name"],
pod: .output_fields["k8s.pod.name"], id: .output_fields["container.id"],
cmd: .output_fields["proc.cmdline"]}'Erwartet (Zeile umbrochen):
{"hostname":"worker1","ns":"tag13","pod":"web-6f88f4fd9c-l5rb4","id":"03479ff2b911",
"cmd":"sh -c id; exit"}
hostname ist der Knoten, container.id die
ersten zwölf Zeichen der Container-ID. Sie ist der sichere Anker, auch
wenn Pod-Namen fehlen. Container-ID aus deiner Ausgabe übernehmen –
einmal über die API, einmal direkt bei der Runtime des Knotens:
# auf cp1
J='{range .items[*]}{.metadata.namespace} {.metadata.name} '
J="$J"'{.status.containerStatuses[*].containerID}{"\n"}{end}'
kubectl get pods -A -o jsonpath="$J" | grep 03479ff2b911 | cut -c1-60
ssh -n worker1 sudo -i crictl inspect 03479ff2b911 | jq .status.labelsErwartet:
tag13 web-6f88f4fd9c-l5rb4 containerd://03479ff2b911ba953f53
{
"io.kubernetes.container.name": "web",
"io.kubernetes.pod.name": "web-6f88f4fd9c-l5rb4",
"io.kubernetes.pod.namespace": "tag13",
"io.kubernetes.pod.uid": "3ece3899-938c-4195-a6eb-590282063b47"
}
Genau diese Labels des Containers liest Falco über den Runtime-Socket – merk dir das für Drill 5.
Ursache: Kein Defekt: Die Regel
Terminal shell in container meldet jede Shell mit Terminal,
die als neuer Prozess in einen Container kommt – genau das ist
kubectl exec -it. user_loginuid=-1 heißt „kein
Login“. Wer den Befehl abgesetzt hat, weiß Falco nicht;
das steht nur im Audit-Log des API-Servers (in RKE2 standardmäßig
aus).
Fix: Keiner nötig – aber die Grenze der Regel kennen.
Nachweis: Ohne -it bleibt Falco
still:
# auf cp1
kubectl -n tag13 exec deploy/web -- id
sleep 5
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| grep -c 'Terminal shell'Erwartet:
uid=0(root) gid=0(root) groups=0(root),10(wheel)
1
Weiter genau ein Treffer – der aus dem exec -it.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Der Fehlalarm jede zehnte Minute
Einbauen: Ein Aufräum-Job löscht alle zehn Minuten
fertige Pods. Dazu spricht er mit kubectl die
Kubernetes-API an:
# auf cp1
cat > aufraeumer.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: aufraeumer, namespace: tag13}
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata: {name: aufraeumer, namespace: tag13}
rules:
- apiGroups: [""]
resources: [pods]
verbs: [get, list, delete]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata: {name: aufraeumer, namespace: tag13}
subjects:
- {kind: ServiceAccount, name: aufraeumer, namespace: tag13}
roleRef: {apiGroup: rbac.authorization.k8s.io, kind: Role, name: aufraeumer}
---
apiVersion: batch/v1
kind: CronJob
metadata: {name: aufraeumer, namespace: tag13}
spec:
schedule: "*/10 * * * *"
jobTemplate:
spec:
template:
spec:
serviceAccountName: aufraeumer
restartPolicy: Never
containers:
- name: kubectl
image: registry.k8s.io/kubectl:v1.37.2
args: [delete, pods, -n, tag13, --field-selector=status.phase==Succeeded]
EOF
kubectl apply -f aufraeumer.yaml
kubectl -n tag13 create job --from=cronjob/aufraeumer aufraeumer-1
kubectl -n tag13 wait --for=condition=complete job/aufraeumer-1 --timeout=90sErwartet (gekürzt):
cronjob.batch/aufraeumer created
job.batch/aufraeumer-1 created
job.batch/aufraeumer-1 condition met
create job --from=cronjob/… startet den Lauf sofort,
statt auf die nächste zehnte Minute zu warten.
Symptom:
# auf cp1
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| grep 'Contact K8S' | jq -r .output | fold -w 86Erwartet (gekürzt):
10:28:55.224711757: Notice Unexpected connection to K8s API Server from container | co
nnection=10.42.0.132:40924->10.43.0.1:443 lport=40924 rport=443 fd_type=ipv4 fd_proto=
tcp evt_type=connect user=root user_uid=0 user_loginuid=-1 process=kubectl proc_exepat
h=/bin/kubectl parent=containerd-shim command=kubectl delete pods -n tag13 --field-sel
ector=status.phase==Succeeded terminal=0 container_id=6eaeb4308ebe container_name=kube
ctl container_image_repository=registry.k8s.io/kubectl container_image_tag=v1.37.2 k8s
_pod_name=aufraeumer-1-cvmcn k8s_ns_name=tag13
Ab jetzt sechsmal pro Stunde. Wer so etwas eine Woche lang sieht, liest Falco-Alarme nicht mehr.
Untersuchen: Welche Bedingung hat angeschlagen? Die Regel steht so, wie Falco sie geladen hat, im Pod:
# auf cp1
kubectl -n falco exec ds/falco -c falco -- \
grep -A14 'rule: Contact K8S API Server From Container' /etc/falco/falco_rules.yaml \
| sed -n '1p;/condition/,$p'
kubectl -n falco exec ds/falco -c falco -- \
grep -A1 'macro: k8s_api_server' /etc/falco/falco_rules.yamlErwartet:
- rule: Contact K8S API Server From Container
condition: >
evt.type=connect
and (fd.typechar=4 or fd.typechar=6)
and container
and k8s_api_server
and not k8s_containers
and not user_known_contact_k8s_api_server_activities
- macro: k8s_api_server
condition: (fd.sip.name="kubernetes.default.svc.cluster.local")
k8s_containers ist eine feste Liste bekannter Images
plus kube-system; unser Job steht nicht darin.
Ursache: Die Regel ist bewusst laut: Ein Container, der die API anspricht, kann ein Angreifer mit gestohlenem Token sein. Unser Job tut das aber legitim und regelmäßig – das Rauschen verdeckt echte Treffer derselben Regel.
Fix: Nicht die Regel abschalten, sondern eine enge Ausnahme ergänzen: dieser Namespace, dieses Image, dieser Prozess – das ist Drill 4.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Die Ausnahme legt Falco lahm
Einbauen: Der erste Versuch einer Ausnahme – Felder genannt, Werte vergessen:
# auf cp1
cat > ausnahme.yaml <<'EOF'
customRules:
tag13-ausnahmen.yaml: |-
- rule: Contact K8S API Server From Container
exceptions:
- name: tag13_aufraeumer
fields: [k8s.ns.name, container.image.repository, proc.name]
comps: [=, =, =]
override:
exceptions: append
EOF
helm upgrade falco falcosecurity/falco -n falco --version 9.2.2 \
-f falco-values.yaml -f ausnahme.yaml --wait --timeout 90s 2>&1 | tail -2Erwartet (nach 90 s, Zeile umbrochen):
Error: UPGRADE FAILED: resource DaemonSet/falco/falco not ready. status: InProgress,
message: Updated: 1/3
context deadline exceeded
Symptom:
# auf cp1
kubectl -n falco get pods
helm -n falco history falco -o json | jq -r '.[] | "\(.revision) \(.status)"'Erwartet:
NAME READY STATUS RESTARTS AGE
falco-2cb48 2/2 Running 0 2m50s
falco-79l4k 2/2 Running 0 2m50s
falco-sjnrl 1/2 CrashLoopBackOff 3 (34s ago) 87s
1 deployed
2 failed
Untersuchen: Pod-Namen aus deiner Ausgabe übernehmen:
# auf cp1
kubectl -n falco logs falco-sjnrl -c falco \
| grep -E 'ausnahmen.yaml \||^Error|LOAD_ERR' | sed 's/^.*[0-9]\{4\}: //'
kubectl -n falco get ds falco -o jsonpath='{.spec.updateStrategy}{"\n"}'Erwartet (Zeilen umbrochen):
/etc/falco/rules.d/tag13-ausnahmen.yaml | schema validation: ok
Error: /etc/falco/rules.d/tag13-ausnahmen.yaml: Invalid
LOAD_ERR_VALIDATE (Error validating rule/macro/list/exception objects): Rule
exception must have values property with a list of values
{"rollingUpdate":{"maxSurge":0,"maxUnavailable":1},"type":"RollingUpdate"}
Ursache: Jede Ausnahme braucht values –
eine Liste von Tupeln passend zu fields und
comps. schema validation: ok täuscht: Das
Schema prüft nur die Form der Datei, die Regel-Engine lehnt sie danach
ab und Falco beendet sich. Das DaemonSet tauscht nur einen Pod
gleichzeitig (maxUnavailable: 1): Zwei Knoten laufen mit
den alten Regeln weiter, ein Knoten ist blind – und
Helm meldet nur einen Timeout.
Fix:
# auf cp1
cat > ausnahme.yaml <<'EOF'
customRules:
tag13-ausnahmen.yaml: |-
- rule: Contact K8S API Server From Container
exceptions:
- name: tag13_aufraeumer
fields: [k8s.ns.name, container.image.repository, proc.name]
comps: [=, =, =]
values:
- [tag13, registry.k8s.io/kubectl, kubectl]
override:
exceptions: append
EOF
helm upgrade falco falcosecurity/falco -n falco --version 9.2.2 \
-f falco-values.yaml -f ausnahme.yaml --wait --timeout 5m | grep -E 'STATUS|REV'Erwartet:
STATUS: deployed
REVISION: 3
override: exceptions: append hängt die Ausnahme an die
bestehende Regel, ohne Bedingung oder Ausgabe anzufassen. Das Chart legt
customRules nach /etc/falco/rules.d/, das
Falco nach den Standardregeln lädt.
Nachweis: Ein neuer Lauf des Jobs bleibt still, die Regel selbst lebt:
# auf cp1
kubectl -n falco logs ds/falco -c falco | grep rules.d | cut -c27-
kubectl -n tag13 create job --from=cronjob/aufraeumer aufraeumer-2
kubectl -n tag13 wait --for=condition=complete job/aufraeumer-2 --timeout=90s
kubectl -n tag13 run apitest --image=busybox:1.37 --restart=Never -- \
wget -T 2 -q -O /dev/null https://kubernetes.default.svc
sleep 15
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| jq -rR 'fromjson? | [.rule, .output_fields["k8s.pod.name"]] | @tsv'Erwartet:
Found 3 pods, using pod/falco-pw5bs
/etc/falco/rules.d/tag13-ausnahmen.yaml | schema validation: ok
job.batch/aufraeumer-2 created
job.batch/aufraeumer-2 condition met
pod/apitest created
Contact K8S API Server From Container apitest
Die Alarme aus Drill 2 und 3 sind übrigens weg: Jedes Helm-Upgrade startet die Falco-Pods neu, und ihr Log beginnt von vorn. In Produktion gehören Alarme deshalb in ein zentrales System, nicht ins Pod-Log.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Alarme ohne Pod
Einbauen: Jemand „vereinheitlicht“ die Falco-Werte für alle Cluster und setzt die CRI-Sockets auf den Standardpfad von containerd:
# auf cp1
cat > sockets.yaml <<'EOF'
collectors:
containerEngine:
engines:
cri:
enabled: true
sockets: [/run/containerd/containerd.sock]
EOF
helm upgrade falco falcosecurity/falco -n falco --version 9.2.2 -f falco-values.yaml \
-f ausnahme.yaml -f sockets.yaml --wait --timeout 5m | grep STATUS
kubectl -n tag13 exec -it deploy/web -- sh -c exitErwartet:
STATUS: deployed
Symptom:
# auf cp1
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| grep 'Terminal shell' | jq -r .output | grep -o 'container_id.*'Erwartet (Zeile umbrochen):
container_id=03479ff2b911 container_name=<NA> container_image_repository=<NA>
container_image_tag=<NA> k8s_pod_name=<NA> k8s_ns_name=<NA>
Falco läuft, alle Pods sind Running, die Alarme kommen.
Nur Pod, Namespace und Image fehlen – und die Ausnahme aus Drill 4
vergleicht k8s.ns.name. Ein neuer Aufräum-Lauf meldet sich
wieder:
# auf cp1
kubectl -n tag13 create job --from=cronjob/aufraeumer aufraeumer-3
kubectl -n tag13 wait --for=condition=complete job/aufraeumer-3 --timeout=90s
sleep 5
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| jq -rR 'fromjson? | [.rule, .output_fields["container.id"]] | @tsv'Erwartet (gekürzt):
job.batch/aufraeumer-3 created
job.batch/aufraeumer-3 condition met
Contact K8S API Server From Container 616776102f5b
Terminal shell in container 03479ff2b911
Untersuchen: Die Container-ID kommt aus dem Kernel,
alles andere fragt das Plugin container bei der Runtime ab.
Welche Sockets sucht Falco, und wo liegt der echte?
# auf cp1
kubectl -n falco logs ds/falco -c falco | grep 'runtime socket' | cut -c27-114
ssh -n worker1 sudo grep runtime-endpoint /var/lib/rancher/rke2/agent/etc/crictl.yaml
ssh -n worker1 sudo ls /run/containerd/containerd.sock \
/run/k3s/containerd/containerd.sockErwartet (gekürzt):
Found 3 pods, using pod/falco-pqzlp
[libs]: container: * enabled container runtime socket at '/host/run/podman/podman.sock'
[libs]: container: * enabled container runtime socket at '/host/var/run/docker.sock'
[libs]: container: * enabled container runtime socket at '/host/run/containerd/contain
[libs]: container: * enabled container runtime socket at '/host/run/host-containerd/co
runtime-endpoint: unix:///run/k3s/containerd/containerd.sock
ls: cannot access '/run/containerd/containerd.sock': No such file or directory
/run/k3s/containerd/containerd.sock
Ursache: RKE2 bringt ein eigenes containerd mit,
dessen Socket unter /run/k3s/containerd/ liegt. Die Werte
überschreiben die Liste des Charts komplett (Listen werden bei
-f ersetzt, nicht zusammengeführt), also fragt Falco nur
noch Pfade, unter denen keine Runtime antwortet. Ohne Runtime bleiben
alle Container- und Pod-Felder leer: <NA>. Das Chart
mountet übrigens nur die Verzeichnisse der konfigurierten Sockets –
/run/k3s/containerd fehlt jetzt auch unter den Volumes.
Fix: Die Überschreibung weglassen; die Chart-Liste enthält den RKE2-Pfad schon:
# auf cp1
helm upgrade falco falcosecurity/falco -n falco --version 9.2.2 \
-f falco-values.yaml -f ausnahme.yaml --wait --timeout 5m | grep STATUS
kubectl -n tag13 exec -it deploy/web -- sh -c exitErwartet:
STATUS: deployed
Nachweis:
# auf cp1
kubectl -n falco get ds falco \
-o jsonpath='{range .spec.template.spec.volumes[*]}{.hostPath.path}{"\n"}{end}' \
| grep k3s
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| grep 'Terminal shell' | jq -r .output | grep -o 'k8s_pod_name.*'Erwartet:
/run/k3s/containerd
k8s_pod_name=web-6f88f4fd9c-l5rb4 k8s_ns_name=tag13
Talos: Dort ist
/run/containerd/containerd.sockder richtige Pfad für die Kubelet-Pods – derselbe Pfad, der auf RKE2 alles kaputt macht (Tag 19).
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zähl alle Falco-Alarme des Clusters nach Knoten und Regel. Zeitziel: 60 s
- Zeig, welche Regeldateien der Falco-Pod auf
cp1geladen hat. Zeitziel: 30 s - Finde zur Container-ID des
web-Pods (aus einem Alarm) Namespace und Pod über die API. Zeitziel: 45 s
Lösung
# auf cp1
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| jq -rR 'fromjson? | [.hostname, .rule] | @tsv' | sort | uniq -c
P=$(kubectl -n falco get pod -l app.kubernetes.io/name=falco \
--field-selector spec.nodeName=cp1 -o name)
kubectl -n falco logs $P -c falco | grep 'schema validation' | cut -c27-
J='{range .items[*]}{.metadata.namespace} {.metadata.name} '
J="$J"'{.status.containerStatuses[*].containerID}{"\n"}{end}'
kubectl get pods -A -o jsonpath="$J" | grep 03479ff2b911 | cut -c1-60Erwartet:
1 worker1 Terminal shell in container
/etc/falco/falco.yaml | schema validation: ok
/etc/falco/falco_rules.yaml | schema validation: ok
/etc/falco/rules.d/tag13-ausnahmen.yaml | schema validation: ok
tag13 web-6f88f4fd9c-l5rb4 containerd://03479ff2b911ba953f53
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
# auf cp1
kubectl -n falco get ds falco | cut -c1-60
kubectl -n falco logs ds/falco -c falco | grep -c 'modern BPF probe'Erwartet:
NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE
falco 3 3 3 3 3
Found 3 pods, using pod/falco-nqw96
1
Challenge
Ein Härtungs-Check pruefer prüft jede Nacht, ob im Image
ein Eintrag für root in /etc/shadow steht.
Falco meldet ihn als Read sensitive file untrusted. Stell
genau diesen Alarm ab – andere Leser von /etc/shadow sollen
weiter auffallen, und die Ausnahme aus Drill 4 muss erhalten
bleiben.
# auf cp1
cat > pruefer.yaml <<'EOF'
apiVersion: batch/v1
kind: CronJob
metadata: {name: pruefer, namespace: tag13}
spec:
schedule: "0 3 * * *"
jobTemplate:
spec:
template:
spec:
restartPolicy: Never
containers:
- name: pruefer
image: busybox:1.37
command: [grep, -c, root, /etc/shadow]
EOF
kubectl apply -f pruefer.yaml
kubectl -n tag13 create job --from=cronjob/pruefer pruefer-1Hinweis: Gleicher Schlüssel unter
customRules in zwei -f-Dateien heißt: Die
zweite Datei gewinnt. Die zweite Ausnahme gehört also entweder in
dieselbe Regeldatei oder unter einen neuen Schlüssel.
Lösung
Zuerst warten, bis der Job gelaufen ist und Falco den Alarm geschrieben hat, dann die Felder des Alarms ansehen und die Ausnahme aus genau diesen Feldern bauen:
# auf cp1
kubectl -n tag13 wait --for=condition=complete job/pruefer-1 --timeout=60s
sleep 15
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| jq -cR 'fromjson? | select(.rule=="Read sensitive file untrusted")
| .output_fields | {"k8s.ns.name", "container.name", "proc.name", "fd.name"}'Erwartet:
job.batch/pruefer-1 condition met
{"k8s.ns.name":"tag13","container.name":"pruefer","proc.name":"grep",
"fd.name":"/etc/shadow"}
# auf cp1
cat >> ausnahme.yaml <<'EOF'
- rule: Read sensitive file untrusted
exceptions:
- name: tag13_pruefer
fields: [k8s.ns.name, container.name, proc.name, fd.name]
comps: [=, =, =, =]
values:
- [tag13, pruefer, grep, /etc/shadow]
override:
exceptions: append
EOF
helm upgrade falco falcosecurity/falco -n falco --version 9.2.2 \
-f falco-values.yaml -f ausnahme.yaml --wait --timeout 5m | grep STATUS
kubectl -n tag13 create job --from=cronjob/pruefer pruefer-2
kubectl -n tag13 wait --for=condition=complete job/pruefer-2 --timeout=60s
kubectl -n tag13 run leser --image=busybox:1.37 --restart=Never -- cat /etc/shadow
sleep 15
kubectl -n falco logs -l app.kubernetes.io/name=falco -c falco --tail=-1 \
| jq -rR 'fromjson? | [.rule, .output_fields["k8s.pod.name"]] | @tsv'Erwartet:
STATUS: deployed
job.batch/pruefer-2 created
job.batch/pruefer-2 condition met
pod/leser created
Read sensitive file untrusted leser
pruefer-2 bleibt still, leser fällt weiter
auf. Die Ausnahme hängt am Containernamen, am Prozess
und an der Datei – ein cat /etc/shadow im
selben Container würde weiter gemeldet.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Falco wird später nicht mehr gebraucht und kostet auf jedem Knoten Speicher:
# auf cp1
helm uninstall falco -n falco
kubectl delete namespace falco tag13
helm list -A | grep -c falcoErwartet:
release "falco" uninstalled
namespace "falco" deleted
namespace "tag13" deleted
0
Interview-Notiz
- Woher kommt ein Falco-Alarm?
hostname= Knoten,container.idaus dem Kernel, Pod und Namespace über die Container-Runtime; den Menschen dahinter kennt nur das Audit-Log des API-Servers. - Fehlalarm – was tun? Nie die Regel abschalten, sondern eine
enge
exceptions-Liste mitoverride: exceptions: appendaus den Feldern des Alarms bauen. <NA>in jedem Alarm? Falco erreicht die Runtime nicht – Socket-Liste gegen den echten Pfad (crictl.yaml) prüfen; bei RKE2/run/k3s/containerd/containerd.sock.
Enterprise-Notiz
- Alarme zentral sammeln (Falcosidekick, SIEM), nicht im Pod-Log: Jeder Neustart löscht es, und ein blinder Knoten fällt nur auf, wenn jemand die Zahl der Melder überwacht.
- Regeländerungen vorab prüfen:
falco --dry-runbzw. ein Test-Pod mit der neuen Regeldatei in CI; das Schema allein findet fehlendevaluesnicht. - Ausnahmen versionieren und reviewen wie Code – jede Ausnahme ist ein bewusstes Sicherheitsloch.
- Falco als Angriffserkennung und Härtung: „CKS zum Anfassen“ und „Kubernetes angreifen und absichern“.