Falco 0.41: Detekcia hrozieb Linux/K8s 2…

Q: Aké požiadavky má Falco na Linux kernel?

Pre predvolený modern_ebpf driver potrebujete kernel 5.8+ s CONFIG_BPF, CONFIG_BPF_SYSCALL a CONFIG_DEBUG_INFO_BTF zapnutým. Túto konfiguráciu má Ubuntu 22.04+, Debian 12+, RHEL 9+ a väčšina moderných distribúcií. Pre staršie jadrá 4.14+ je dostupný legacy eBPF probe alebo kernel modul (kmod) cez DKMS.

Q: Ako aktualizujem Falco pravidlá bez reštartu?

Použite falcoctl artifact install falco-rules:3 na stiahnutie najnovšej verzie z OCI registra a následne systemctl reload falco-modern-bpf – tento reload nezastaví engine, len preloadne pravidlá. V Kubernetes s Helm chartom stačí zmeniť ConfigMap a Falco pod automaticky detekuje zmenu (ak máte enabled reload on change ).

Aktualizované: 29. augusta 2026

Falco je open-source runtime security engine, ktorý pozoruje syscalls a Kubernetes audit eventy v reálnom čase a strieľa alerty, keď správanie procesu poruší politiku – projekt graduoval na CNCF a v roku 2026 beží vo verzii 0.41 s modern_ebpf probom ako predvoleným driverom. Ak už používate Tetragon alebo auditd, Falco pridáva deklaratívny rules engine založený na YAML a bohatý ekosystém výstupov – Falcosidekick, Talon a natívne mapovanie na MITRE ATT&CK. V tejto príručke nasadíme Falco na Debian 12 aj Kubernetes 1.30+, napíšeme vlastné pravidlá a ukážeme, prečo je stále mojou východiskovou voľbou pre detekciu na produkčných systémoch.

Falco 0.41 (marec 2026) štandardne používa modern_ebpf driver – vyžaduje kernel ≥ 5.8 s CO-RE podporou a odstraňuje potrebu kompilovať kernel moduly na cieľovom stroji.
Pravidlá sa píšu v YAML s conditions jazykom podobným Sysdigu (napr. evt.type = execve and container.image.repository = "nginx") a distribuujú sa cez falcoctl z OCI registrov.
Falcosidekick 2.30+ podporuje 90+ výstupov vrátane Slack, PagerDuty, Loki, Elasticsearch a webhookov pre custom SOAR pipelines.
Falco Talon (GA v roku 2025) umožňuje automatické remediation akcie – killnutie podu, izolácia network policy, kordón nódu – reagujúce na Falco alerty.
Na Linuxe bez Kubernetesu môže Falco monitorovať systemd služby, kontajnery Podman/Docker aj holé procesy a bez modifikácií mapuje detekcie na MITRE ATT&CK for Containers.

Čo je Falco a ako funguje?

Falco je runtime security engine, ktorý zachytáva systémové udalosti na úrovni jadra a vyhodnocuje ich voči sade YAML pravidiel. Pôvodne ho vyvinul Sysdig v roku 2016, v januári 2024 dosiahol status Graduated v CNCF a dnes ho spravuje komunita s podporou Sysdigu, Red Hatu a Microsoftu. Na rozdiel od klasického IDS ako Suricata, ktorý sleduje sieťový premávok, Falco pozoruje syscalls – napríklad execve(), openat(), connect() – a Kubernetes audit log entries.

Verzia 0.41 (marec 2026) používa tri možné zdroje udalostí. Prvý a predvolený je modern_ebpf: eBPF probe kompilovaný ako CO-RE (Compile Once, Run Everywhere) objekt, ktorý načíta libbpf. Vyžaduje kernel 5.8+ (RHEL 9, Ubuntu 22.04+, Debian 12+). Druhý je legacy eBPF probe pre staršie jadrá 4.14+. Tretí je klasický kmod – kernel modul, ktorý sa kompiluje pri inštalácii cez DKMS; v roku 2026 sa už používa len na exotických jadrách bez BPF podpory. Vo všetkých prípadoch sa eventy prenesú do userspace ringbufferom, kde ich Falco engine vyhodnotí a pošle na výstup (stdout, JSON, gRPC).

Inštalácia Falco 0.41 na Linuxe

Falco poskytuje oficiálne balíky pre Debian/Ubuntu (deb) a RHEL/Fedora (rpm) v repozitári download.falco.org. Nasledujúci postup platí pre Debian 12 (kernel 6.1) a Ubuntu 24.04 LTS (kernel 6.8) – oba spĺňajú požiadavky pre modern_ebpf.

# Pridanie GPG kľúča a repozitára
curl -fsSL https://falco.org/repo/falcosecurity-packages.asc | \
  sudo gpg --dearmor -o /usr/share/keyrings/falco-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/falco-archive-keyring.gpg] \
  https://download.falco.org/packages/deb stable main" | \
  sudo tee /etc/apt/sources.list.d/falcosecurity.list

sudo apt update
sudo apt install -y falco

# Overenie verzie a driver typu
falco --version
# Falco version: 0.41.0
# Driver:
#   API version:    8.0.0
#   Default driver: 8.0.0+driver

Pri prvej inštalácii spustí falco-driver-loader automaticky – zvolí modern_ebpf, ak jadro spĺňa 5.8+ a máte namontovaný debugfs. Konfiguračný súbor je /etc/falco/falco.yaml; v ňom nastavíte engine (engine: kind: modern_ebpf), buffer size a výstupy. Pravidlá načíta zo /etc/falco/falco_rules.yaml (základné) a /etc/falco/rules.d/*.yaml (vlastné).

# Spustenie a overenie
sudo systemctl enable --now falco-modern-bpf
sudo systemctl status falco-modern-bpf

# Test – v inom termináli spustite podozrivý event:
docker run --rm -it alpine sh -c "cat /etc/shadow"

# Vo Falco logu uvidíte:
# 15:42:11.234567890: Warning Sensitive file opened for reading by non-trusted program
#   (user=root user_loginuid=-1 program=cat command=cat /etc/shadow ...)

Nasadenie Falco na Kubernetes cluster

V Kubernetes prostredí beží Falco ako DaemonSet – jeden pod na každý worker node. Oficiálny Helm chart z falcosecurity/charts je stále odporúčaný spôsob nasadenia a v 2026 podporuje Kubernetes 1.28 až 1.31. DaemonSet vyžaduje hostPID: true a privileged: true pre eBPF load, alebo minimalne CAP_SYS_ADMIN, CAP_BPF a CAP_PERFMON na kerneli 5.8+.

# Pridanie Helm repa a nasadenie
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 tty=true \
  --set falcosidekick.enabled=true \
  --set falcosidekick.webui.enabled=true \
  --set collectors.kubernetes.enabled=true

# Overenie: každý node má bežiaci Falco pod
kubectl get pods -n falco -o wide
kubectl logs -n falco -l app.kubernetes.io/name=falco --tail=50

Kľúčová novinka pre rok 2026 je natívna integrácia s Kubernetes Audit Logs. Namiesto behu dodatočného webhook servera (ako v starších verziách) Falco 0.40+ číta audit eventy priamo cez k8saudit plugin – nakonfigurujete API server na zápis do lokálneho socketu a plugin ich streamuje do rules enginu. Táto architektúra podľa changelogu Falco 0.41 znížila latenciu detekcie o ~40 % oproti webhook módu.

Písanie vlastných Falco pravidiel

Toto je časť, kde sa Falco naozaj oplatí. Pravidlá sú YAML dokumenty s tromi hlavnými typmi: rule (detekcia), macro (znovupoužiteľná časť podmienky) a list (množina hodnôt). Podmienky používajú Sysdig-style dotazovací jazyk s poľami ako evt.type, proc.name, container.image, fd.name, k8s.pod.label. Nasledujúca ukážka detekuje pokus o čítanie /etc/shadow z akéhokoľvek kontajnera okrem povolených image-ov.

# /etc/falco/rules.d/custom.yaml
- list: allowed_shadow_readers
  items: [sssd, systemd, login, sshd]

- macro: sensitive_file_read
  condition: >
    evt.type in (open, openat, openat2) and
    evt.is_open_read=true and
    fd.name in (/etc/shadow, /etc/gshadow, /etc/sudoers)

- rule: Sensitive file read in container
  desc: >
    Detekuje čítanie systémových credential súborov procesom, ktorý
    nie je súčasťou dôveryhodnej triedy allowed_shadow_readers.
  condition: >
    sensitive_file_read and
    container and
    not proc.name in (allowed_shadow_readers)
  output: >
    Sensitive file %fd.name opened by non-trusted process
    (user=%user.name pid=%proc.pid command=%proc.cmdline
    container_id=%container.id image=%container.image.repository)
  priority: WARNING
  tags: [filesystem, mitre_credential_access, T1552]

Pravidlá načítate falco --validate /etc/falco/rules.d/custom.yaml; syntaktická validácia prebehne bez reštartu enginu. Ostrý reload zabezpečí systemctl reload falco-modern-bpf alebo v Kubernetes kubectl rollout restart daemonset/falco -n falco. Pre distribuovanú správu pravidiel odporúčam falcoctl – utility, ktorá stiahne pravidlá z OCI registra (typicky ghcr.io/falcosecurity/rules) a overí ich Cosign podpisom, čo je detailne opísané v článku o Sigstore Cosign.

Falcosidekick a smerovanie alertov

Samotný Falco vypisuje alerty na stdout alebo do JSON/HTTP endpointu, ale reálne SOC nasadenie potrebuje viac. Falcosidekick je odľahčený proxy server, ktorý prijíma Falco eventy cez HTTP a rozposiela ich do 90+ backendov. Verzia 2.30 (jún 2026) pridala natívnu podporu pre Grafana Alloy, Amazon EventBridge a Google Chat, ako je uvedené v release notes na GitHub releases Falcosidekick.

# Príklad konfigurácie – Slack + Loki + PagerDuty
# /etc/falco/falcosidekick.yaml
slack:
  webhookurl: "https://hooks.slack.com/services/T00/B00/XXX"
  minimumpriority: "warning"
  outputformat: "all"

loki:
  hostport: "http://loki.observability.svc:3100"
  minimumpriority: "notice"

pagerduty:
  routingkey: "R01A..."
  minimumpriority: "critical"

customfields:
  environment: "production"
  cluster: "eu-central-1"

Osobitne užitočný je Falcosidekick UI – jednoduchý webový dashboard, ktorý zobrazuje posledné alerty, počet detekcií podľa priority a top pravidiel za posledných 24 hodín. Nenahradí plnohodnotný SIEM ako Wazuh, ale je výborný pre rýchly triage v malých tímoch.

Automatická odpoveď s Falco Talon

Úprimne, detekcia bez odpovede je len drahé logovanie. Falco Talon je response engine, ktorý spája Falco alerty s konkrétnymi remediation akciami. V roku 2025 dosiahol GA status a v 2026 podporuje 20+ akcií vrátane kubernetes:terminate (killne pod), kubernetes:networkpolicy (aplikuje deny-all NetworkPolicy), calico:networkpolicy, aws:lambda a lokálne akcie ako syscall:kill na hostiteľovi.

# talon-rules.yaml – automatická karanténa pri kritickom aleryte
- action: Terminate Pod
  actionner: kubernetes:terminate
  parameters:
    grace_period_seconds: 5
    ignore_daemonsets: true
    ignore_statefulsets: false

- rule: Quarantine on shadow read
  match:
    rules:
      - Sensitive file read in container
    priority_numgte: warning
  actions:
    - action: Terminate Pod
    - action: NetworkPolicy Isolate
      actionner: kubernetes:networkpolicy
      parameters:
        allow_egress: []
        allow_ingress: []

Talon som osobne nasadila pri troch produkčných klientoch v roku 2025 a pravidlo je jasné: začnite s dry-run režimom (parameter --dry-run) minimálne dva týždne a zbierajte metriky falošne pozitívnych. Pri prvom ostrom nasadení sa mi stalo, že overeagerné pravidlo pre reverse shell detection killlo legitímny CI/CD job, ktorý spúšťal bash -i. Vždy majte kill switch cez node label alebo namespace exclude.

Mapovanie detekcií na MITRE ATT&CK

Falco komunitné pravidlá (repozitár falcosecurity/rules) sú od verzie 3.0.0 (2024) mapované na MITRE ATT&CK for Containers matrix. Každé pravidlo má tag typu T1055 (Process Injection), T1552 (Unsecured Credentials) alebo T1611 (Escape to Host). Túto konvenciu odporúčam nasledovať aj vo vlastných pravidlách, ako sme urobili vyššie s tagom T1552.

Praktický prínos je dvojaký. Po prvé, pri incident response viete okamžite priradiť detekciu k technike a hľadať súvisiace TTP z rovnakej útočnej kill chain. Po druhé, pre compliance frameworky ako PCI-DSS 4.0 alebo NIS2 je mapovanie na ATT&CK vyžadovaným artefaktom auditu. Rovnaký prístup som opísala aj v článku o auditd a MITRE ATT&CK – Falco a auditd sa dobre dopĺňajú: auditd pokrýva hostiteľské procesy s hlbším telemetry, Falco pridá kontajnerový kontext a Kubernetes audit stream.

Porovnanie: Falco vs Tetragon

Obe technológie riešia runtime security na Linuxe cez eBPF, ale majú odlišnú filozofiu. Tabuľka nižšie zhŕňa hlavné rozdiely, ktoré vidím pri architektonickom rozhodovaní v roku 2026.

Vlastnosť	Falco 0.41	Tetragon 1.3
Sponzor / správca	CNCF Graduated (2024)	Isovalent / Cisco (CNCF Incubating)
Zdroj eventov	modern_ebpf, kmod, k8s audit	eBPF (kprobes, tracepoints, uprobes)
Jazyk pravidiel	YAML s Sysdig condition syntaxou	YAML TracingPolicy CRD
Enforcement (kill)	Externé cez Talon	Natívne cez `SIGKILL` action v BPF
MITRE ATT&CK mapping	Vstavané tagy v pravidlách	Vlastný sekcia v policy
Kubernetes integrácia	DaemonSet + audit webhook plugin	DaemonSet, natívny s Cilium
Overhead (idle)	~1–3 % CPU per node	~0.5–2 % CPU per node
Krivka učenia	Nižšia – YAML rules, veľa príkladov	Vyššia – nutná znalosť kernel tracing

Moje odporúčanie: Falco ak potrebujete rýchlu detekciu s bohatým ekosystémom výstupov a nechcete sa hrať s BPF internals. Tetragon ak máte Cilium CNI, chcete in-kernel enforcement bez userspace round-tripu, alebo ak sledujete výkon pri desiatkach tisíc podov na klaster. V mnohých tímoch bežia oba paralelne – Falco na kompliance a alerting, Tetragon na real-time enforcement citlivých syscalls.

Produkčné tipy a známe úskalia

Poďme k veciam, na ktoré vás dokumentácia nepripraví. Za štyri roky nasadzovania Falco v prostrediach od 50 do 4 000 nódov som narazila na niekoľko opakovaných problémov. Najčastejší je event drop – ringbuffer sa preplní pri záťaži nad ~200 000 syscalls/s a Falco eventy zahodí. Riešením je zväčšenie bufferu (engine.modern_ebpf.buf_size_preset: 6 pre 8 MB per CPU) a agresívne filtrovanie na úrovni driveru cez base_syscalls, ktoré redukujú kernel-to-user prenos.

Druhý problém sú CO-RE relocation errors na exotických jadrách – napríklad Amazon Linux 2 s backportovanými patchmi alebo Talos Linux, kde chýba niektorý BTF symbol. Falco 0.41 rieši toto elegantne cez btfhub archív, ktorý stiahne externé BTF profily pre 400+ kernel verzií; aktivujete ho cez engine.modern_ebpf.load_btf_from: "auto". Detaily nájdete v dokumentácii modern_ebpf driveru.

Tretí je rule tuning. Základné pravidlá sú konzervatívne, ale vygenerujú stovky alertov denne na typickom Kubernetes clustri. Odporúčam prvý mesiac beh v notice-only režime, zber všetkých alertov do Loki a potom postupné pridávanie exceptions pre legitímne správanie – napr. Datadog agent, ktorý číta procfs, alebo cert-manager, ktorý vytvára subprocesy. Falco 0.40 zaviedol nový format exceptions ako súčasť pravidla, čo je oveľa lepšie než starý globálny whitelist.

Často kladené otázky

Na čo sa Falco používa?

Falco sa používa na runtime detekciu hrozieb na Linuxe a v Kubernetes clusteroch. Sleduje syscalls a Kubernetes audit log a spúšťa alerty pri porušení YAML pravidiel – typické use cases sú detekcia úniku z kontajnera, čítanie citlivých súborov, spustenie shellov v produkčných podoch a compliance monitoring pre PCI-DSS alebo SOC2.

Je Falco zadarmo?

Áno. Falco je open-source pod Apache 2.0 licenciou a CNCF Graduated projekt. Nie sú žiadne edition tiery ani platené moduly – celá funkcionalita vrátane modern_ebpf driveru, Falcosidekicku, Talonu a webového UI je zdarma. Sysdig ponúka komerčný produkt Sysdig Secure postavený nad Falco enginom, ale samotný Falco je plne funkčný samostatne.

Aký je rozdiel medzi Falco a Tetragonom?

Oba používajú eBPF, ale Falco je zameraný na detekciu s YAML pravidlami a externým enforcementom (Talon), zatiaľ čo Tetragon má in-kernel enforcement priamo v BPF programe (napr. SIGKILL action). Falco má nižšiu krivku učenia a širší ekosystém výstupov, Tetragon má nižší overhead a lepšiu integráciu s Cilium CNI.

Aké požiadavky má Falco na Linux kernel?

Pre predvolený modern_ebpf driver potrebujete kernel 5.8+ s CONFIG_BPF, CONFIG_BPF_SYSCALL a CONFIG_DEBUG_INFO_BTF zapnutým. Túto konfiguráciu má Ubuntu 22.04+, Debian 12+, RHEL 9+ a väčšina moderných distribúcií. Pre staršie jadrá 4.14+ je dostupný legacy eBPF probe alebo kernel modul (kmod) cez DKMS.

Ako aktualizujem Falco pravidlá bez reštartu?

Použite falcoctl artifact install falco-rules:3 na stiahnutie najnovšej verzie z OCI registra a následne systemctl reload falco-modern-bpf – tento reload nezastaví engine, len preloadne pravidlá. V Kubernetes s Helm chartom stačí zmeniť ConfigMap a Falco pod automaticky detekuje zmenu (ak máte enabled reload on change).