Falco ile Kubernetes Runtime Security: eBPF ile Gercek Zamanli Tehdit Tespiti

Container tabanlı mikro servis mimarilerinde uygulama katmanı guvenligi, derleme zamaninda tarama yapan statik analiz araclarinin otesine gecen bir tehdit yuzeyi olusturur. Bir konteyner calisma zamaninda (runtime) zararli bir komut yuruttugunde, yanlis yapilandirilmis bir pod ayricalikli erisim elde ettiginde veya bir saldırgan container escape teknigi ile ana makineye sizarak konak degistirdiginde, bu davranislari yakalayacak bir izleme mekanizmasi gerekir. Iste tam bu noktada CNCF gradueli bir proje olan Falco devreye girer. Falco, Linux sistem cagirilarini (syscall) eBPF araciligiyla dinleyerek Kubernetes ortamlarinda gercek zamanli tehdit tespiti saglayan acik kaynakli bir runtime security aracidir. Bu makalede Falco'nun mimarisini, Kubernetes'e Helm ile kurulumunu, modern eBPF surucusunu, ozel kural yazimini ve FalcoSidekick ile alert yonlendirme stratejilerini derinlemesine ele aliyoruz.

Runtime Security Kavrami ve Falco'nun Yeri

Geleneksel guvenlik yaklasimlari genellikle sol tarafta (shift-left) konumlanir: statik kod analizi, bagimlilik taramasi, konteyner imaj tarama araclari ve CI/CD pipeline'ina entegre edilen linter kontrolleri. Ancak bu araclar calisma zamaninda gerceklese davranislari goremez. Bir saldırgan, sisteme sizdikdan sonra yanal hareket (lateral movement) yapabilir, bir pod icinde beklenmedik bir surec calistirabilir veya kritik sistem dosyalarini okuyabilir. Bu tur saldirilar, imaj tarama araclarinin gormedigi bir yuzeyde gerceklese.

Runtime security araclari bu boslugu doldurur. Kubernetes ortaminda runtime security uc temel katmanda calisir: Linux kernel seviyesinde syscall izleme, Kubernetes API server audit loglari ve konteyner davranis analizi. Falco, bu uc katmanin hepsini kapsayan bir mimari sunar. Varsayilan olarak Linux syscall'larini eBPF probe'lari araciligiyla yakalar, Kubernetes audit event'lerini k8saudit plugin ile toplar ve bulut saglayici loglarini cloudtrail gibi eklentilerle isler.

Falco'nun temel calisma prensibi sudur: kernel seviyesinde yakalanan her sistem cagirisi, Falco'nun kural motorunda tanimli kosullara karsi test edilir. Bir kosul eslestiginde, yapilandirilmis output formatinda alert uretilir. Falco kendisi bir tehdit durdurma (enforcement) araci degildir — algilar, raporlar; karar operasyon ekibine aittir. Bu design choice, Falco'yu Kubernetes RBAC ve NetworkPolicy gibi enforcement mekanizmalariyla tamamlayici kilar.

Falco'nun Mimarisi ve eBPF Surucu Modeli

Falco'nun mimarisi iki ana bileşenden olusur: kernel seviyesi veri toplayici (driver) ve kullanic seviyesi kural motoru (rules engine). Kernel tarafinda uc farkli surucu secenegi bulunur: modern eBPF (CO-RE), legacy eBPF ve kernel modulu (kmod). 2024 sonrasi önerilen yapilandirma modern eBPF surucusudur. Bu surucu kernel 5.8 ve uzeri surumlerde calisir, custom kernel modulu yuklemeye gerek birakmaz ve kernel panic riskini ortadan kaldirir.

Modern eBPF surucusu CO-RE (Compile Once - Run Everywhere) teknigini kullanir. Bu, eBPF programinin farkli kernel surumlerinde yeniden derlenmesine gerek kalmadan calismasini saglar. Falco binary'si icinde gomulu olan bu surucu, calisma zamaninda dogru BPF bytecode'u secer ve kernel probe'larini syscall entry/exit noktalarina baglar. Kernel tarafinda ham syscall verisi toplanir ve halka tampona (ring buffer) yazilir. Kullanici seviyesindeki Falco sureci bu tamponu okur ve kural eslestirmesini gerceklestirir.

Bu mimari onemli bir performans avantaji sunar: Falco, kernel seviyesinde mumkun olan en erken filtrelemeyi uygular. Her syscall'u userspace'e tasimak yerine, eBPF programi yalnizca ilgi cekici event'leri secer. Bu sayede yuksek traffic'li bir Kubernetes node'unda bile CPU kullanimi yuzde 1-3 civarinda kalir.

Kubernetes'e Helm ile Falco Kurulumu

Falco'yu Kubernetes'e kurmanin en yaygin ve önerilen yolu Helm chart'idir. Falco chart'i, Falco daemon set'ini, gerekli RBAC yapilandirmalarini ve opsiyonel olarak FalcoSidekick'i tek bir deploy ile hayata gecirir. Kuruluma baslamadan once bazi on gereksinimlerin karsilandigindan emin olunmalidir: Kubernetes 1.16 ve uzeri, kubectl ve helm kurulu olmali, Linux worker node'lar kernel 5.8 ve uzeri surumde olmalidir. macOS uzerinde Docker Desktop kullaniyorsaniz Falco dogrudan calismaz; minikube veya bulut saglayici uzerinde Linux tabanli bir cluster kullanmaniz gerekir.

Helm Repository Yapilandirmasi

Ilk olarak Falco Helm repository'sini ekleyin ve index'i guncelleyin:

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

Ardindan falco namespace'ini olusturun:

kubectl create namespace falco

Modern eBPF ile Minimal Kurulum

Asagidaki values dosyasi modern eBPF surucusunu etkinlestirir, JSON formatinda cikti verir ve container engine entegrasyonunu yapilandirir. Bu yapilandirma cogu uretim ortami icin iyi bir baslangic noktasidir:

driver:
  kind: modern_ebpf

falco:
  json_output: true
  json_include_output_property: true
  log_level: info
  priority: debug
  buffered_outputs: true

falcoctl:
  artifact:
    install:
      enabled: true
    follow:
      enabled: false
  config:
    artifact:
      install:
        refs:
          - falco-rules:5

collectors:
  enabled: true
  container_engine: containerd

tty: true

Bu yapilandirmayi falco-values.yaml dosyasina kaydedin ve kurulumu baslatin:

helm install falco -n falco -f falco-values.yaml falcosecurity/falco

Kurulum tamamlandiktan sonra pod'larin calisip calismadigini kontrol edin:

kubectl wait pods --for=condition=Ready --all -n falco
kubectl get pods -n falco

Tum pod'lar Running durumuna gectiginde Falco aktif demektir. Ilk baslatmada modern eBPF probe'unun kernel header'lari taramasi birkac saniye surebilir. Eger kernel header'lari sisteminizde mevcut degilse Falco pod'u hata durumuna duselbilir. Bu durumda her node uzerinde linux-headers paketini yukleyin:

sudo apt-get install -y linux-headers-$(uname -r)

Cogu modern Kubernetes dagitiminda (GKE, EKS, AKS, k3s) kernel header'lar otomatik olarak mevcuttur ve bu adima gerek kalmaz.

Resource Limit ve Least-Privilege Yapilandirmasi

Uretim ortaminda Falco'nun kaynak tuketimini sinirlamak onemlidir. Asagidaki yapilandirma CPU ve bellek limitleri belirlerken modern eBPF surucusunun least-privileged modunu etkinlestirir:

driver:
  kind: modern_ebpf
  modern_ebpf:
    least_privileged: true
    cpus_for_each_buffer: 2
    buf_size_preset: 4

falco:
  json_output: true
  resources:
    requests:
      cpu: 100m
      memory: 256Mi
    limits:
      cpu: 500m
      memory: 512Mi

cpus_for_each_buffer parametresi eBPF tamponlarini kac CPU cekirdegine dagitacagini belirler. Yuksek performansli node'larda 4 degeri kullanmak throughput'u artirir. buf_size_preset ise her tamponun boyutunu belirler; 4 degeri yaklasik 8MB tampon basina cekirdek anlamina gelir.

Falco Kurallari: Anatomi ve Sozdizimi

Falco'nun tum politika katmani YAML formatindaki kurallardan olusur. Her kural, bir kosul (condition) ile tanimlanmis bir davranisi izler ve eslesme durumunda yapilandirilmis bir mesaj (output) uretir. Kural dosyalari /etc/falco/rules.d/ dizini altinda .yaml uzantisisiyla tanimlanir. Varsayilan kurallar /etc/falco/falco_rules.yaml dosyasinda gelir ve guncellemelerde korunmasi gereken ozellestirmeler customRules mekanizmasiyla ayri bir dosyada tutulur.

Kural Bilesenleri: Rule, Macro, List

Bir Falco kurali bes zorunlu alandan olusur: rule (kural adi), desc (aciklama), condition (eslestirme kosulu), output (alert formati) ve priority (oncelik seviyesi). Kosul ifadeleri icinde tekrar eden mantik parcalari macro olarak tanimlanir ve listeler ise deger kumelerini gruplamak icin kullanilir. Bu uc yapi birlikte okunabilir ve surdurulebilir kural dosyalari olusturur.

Asagida varsayilan kurallardan birinin yapisi gorulmektedir:

- rule: Terminal shell in container
  desc: A shell was spawned in a container with an attached terminal.
  condition: >
    spawned_process and container and shell_procs and proc.tty != 0
    and container_entrypoint
  output: >
    A shell was spawned in a container with an attached terminal
    (user=%user.name container=%container.name shell=%proc.name
    parent=%proc.pname cmdline=%proc.cmdline)
  priority: NOTICE
  tags: [container, shell, mitre_execution, T1059]

Bu kuralda kullanilan macro'lar acikca gorulur: spawned_process, container, shell_procs ve container_entrypoint birer macro'dur. Her biri ayri bir kosul parcasini temsil eder ve farkli kurallarda yeniden kullanilabilir. Falco varsayilan kurallarinda bu yaklasimi yogun bicimde kullanir. Bu sayede kural sozdizimi okunabilir kalir ve macro degisiklikleri tum etkilenen kurallara otomatik olarak yansir.

Syscall Event Turleri

Falco kosullarinda en sik kullanilan event turleri syscall kategorilerine gore su sekilde gruplanir: dosya islemleri (open, openat, read, write, unlink, rename, chmod), ag islemleri (connect, accept, sendto, recvfrom), surec yonetimi (execve, execveat, fork, clone, prctl) ve sistem yapilandirmasi (setns, mount, pivot_root, setuid). Her event turu icin yon (direction) belirtilebilir: evt.dir = "" giris (syscall'a girildiginde), evt.dir = ">" cikis (syscall'tan dondugunde).

Ozel Kural Yazimi: Gercek Dunya Ornekleri

Varsayilan kurallar genel tehditleri kapsar, ancak her organizasyonun kendi guvenlik politikasi ve beklenen davranis profili farklidir. Bu nedenle ozel kurallar yazmak, Falco'nun gercek degerini ortaya cikaran adimdir. Asagida farkli saldirivektorlerini hedefleyen ozel kural ornekleri verilmektedir.

Container Escape Tespiti: cgroup release_agent

Container escape saldirilarinin klasik vektorlerinden biri, bir konteyner icinden cgroup release_agent dosyasina yazmaktir. Saldirgan, host uzerinde keyfi kod calistirabilmek icin bir cgroup'un release_agent parametresini kendi sectigi bir binary olarak ayarlar:

- rule: Container Escape via cgroup release_agent
  desc: Detect a process writing to cgroup release_agent file.
  condition: >
    open_write and
    container.id != host and
    (fd.name contains "release_agent" or
     fd.name contains "notify_on_release")
  output: >
    Container escape attempt: cgroup release_agent write
    (user=%user.name container=%container.name
    proc=%proc.name file=%fd.name cmdline=%proc.cmdline)
  priority: CRITICAL
  tags: [container, container_breakout, mitre_privilege_escalation, T1611]

Bu kural, bir konteyner icinden host'un cgroup dosya sistemindeki release_agent dosyalarina yazma girisimlerini yakalar. MITRE ATT and CK framework'unde T1611 kodu ile etiketlenmistir — Escape to Host teknigi.

Hassas Dosya Erisimi Tespiti

Uretim ortaminda /etc/shadow, SSH private key'leri ve .env dosyalari kritik oneme sahiptir. Bu dosyalara beklenmedik surecler tarafindan erisim bir tehdit isaretidir:

- list: sensitive_file_paths
  items:
    - /etc/shadow
    - /etc/ssl/private
    - /root/.ssh
    - /home/*/.ssh
    - /var/www/html/.env
    - /app/.env

- list: allowed_env_readers
  items: [node, npm, python, java]

- macro: sensitive_file_access
  condition: >
    evt.type = openat and
    evt.is_open_read = true and
    fd.name rmatch sensitive_file_paths

- rule: Sensitive File Accessed by Unexpected Process
  desc: A sensitive file was read by a process outside the allowed list.
  condition: >
    sensitive_file_access and
    not proc.name in (allowed_env_readers)
  output: >
    Sensitive file accessed by unexpected process
    (file=%fd.name proc=%proc.name parent=%proc.pname
    user=%user.name container=%container.name)
  priority: WARNING
  tags: [filesystem, credentials, T1552]

Namespace Manipulasyonu Tespiti

setns syscall'u bir surecin namespace'lerini degistirmek icin kullanilir. Bir konteyner icinden host namespace'lerine baglanmak potansiyel bir saldirivektorudur:

- rule: Namespace Change via setns
  desc: Detect setns syscall for namespace manipulation inside containers.
  condition: >
    evt.type = setns and
    container.id != host
  output: >
    Namespace manipulation via setns detected
    (user=%user.name container=%container.name
    proc=%proc.name syscall=%evt.type flags=%evt.args.flags)
  priority: WARNING
  tags: [container, namespace, mitre_privilege_escalation, T1613]

Kural Ince Ayarlama: Exceptions ve False Positive Yonetimi

Falco'yu uretim ortamina aldikdan sonra karsilastigi en buyuk zorluk false positive'lerdir. Varsayilan kurallar cok genis olabilir ve organizasyonun normal operasyonlarini tetikleyebilir. Yanlis pozitifleri elemek icin exception mekanizmasi kullanilir. Exception, bir kuralin belirli kosullar altinda alert uretmemesini saglar ve kuralin kendisini degistirmez:

- rule: Sensitive File Accessed by Unexpected Process
  exceptions:
    - name: kubernetes_probe
      fields: [proc.name, container.image.repository]
      values:
        - [curl, k8s.gcr.io/k8s-dns-node-cache]
    - name: monitoring_agent
      fields: [container.name]
      values:
        - [prometheus-node-exporter]
  desc: A sensitive file was read by a process outside the allowed list.
  condition: >
    sensitive_file_access and
    not proc.name in (allowed_env_readers)
  output: >
    Sensitive file accessed by unexpected process
    (file=%fd.name proc=%proc.name parent=%proc.pname
    user=%user.name container=%container.name)
  priority: WARNING
  tags: [filesystem, credentials, T1552]

Bu ornekte kurala iki exception eklenmistir: kubernetes_probe exception'i belirli bir container image'dan gelen curl surecini false positive olarak isaretler; monitoring_agent exception'i ise Prometheus node exporter gibi izleme araclarinin hassas dosyalara erisimini gormezden gelir.

Ozel Kurallari Helm ile Deploy Etmek

Helm ile kurulumda ozel kurallari eklemek icin customRules mekanizmasi kullanilir. Bu mekanizma, Kubernetes ConfigMap olarak yuklenen kural dosyalarini /etc/falco/rules.d/ dizinine baglar:

customRules:
  custom-rules.yaml: |
    - rule: Container Escape via cgroup release_agent
      desc: Detect a process writing to cgroup release_agent.
      condition: >
        open_write and
        container.id != host and
        (fd.name contains "release_agent" or
         fd.name contains "notify_on_release")
      output: >
        Container escape attempt: cgroup release_agent write
        (user=%user.name container=%container.name
        proc=%proc.name file=%fd.name)
      priority: CRITICAL
      tags: [container, container_breakout]

Degisiklikleri uygulamak icin:

helm upgrade falco -n falco -f falco-values.yaml falcosecurity/falco

Kural sozdizimini dogrulamak icin:

kubectl exec -n falco -c falco deploy/falco -- falco --validate /etc/falco/rules.d/custom-rules.yaml

FalcoSidekick ile Alert Yonlendirme

Falco varsayilan olarak stdout ve JSON formatinda log yazar. Uretim ortaminda bu alert'leri merkezi bir sistemde toplamak ve operasyon ekibine anlik bildirim gondermek gerekir. FalcoSidekick, Falco alert'lerini 60'tan fazla hedef sisteme yonlendiren bir proxy forwarder'dir. Slack, Discord, Teams, PagerDuty, Opsgenie, ElasticSearch, Splunk, Grafana, Prometheus, Loki ve daha bircok sistem desteklenir.

FalcoSidekick Kurulumu

FalcoSidekick, Falco Helm chart'i ile birlikte tek bir komutla kurulabilir:

helm upgrade falco -n falco -f falco-values.yaml falcosecurity/falco \
  --set falcosidekick.enabled=true \
  --set falcosidekick.webui.enabled=true \
  --set falcosidekick.config.slack.webhookurl="YOUR_SLACK_WEBHOOK_URL" \
  --set falcosidekick.config.slack.minimumpriority=warning

webui.enabled=true parametresi FalcoSidekick'in kendi web arayuzunu etkinlestirir:

kubectl port-forward svc/falco-falcosidekick-ui -n falco 2802
# Arayuze http://localhost:2802 adresinden erisilir
# Varsayilan kimlik bilgileri: admin/admin

Prometheus Metrics Endpoint

FalcoSidekick Prometheus metrics endpoint sunar. Bu endpoint uzerinden Falco alert'leri Prometheus'ta toplanabilir ve Grafana'da gorsellestirilebilir:

helm upgrade falco -n falco -f falco-values.yaml falcosecurity/falco \
  --set falcosidekick.enabled=true \
  --set falcosidekick.config.prometheus.exporter.enabled=true

Metrics endpoint'i http://falco-falcosidekick:2801/metrics adresinde sunulur. Toplanan temel metrikler falco_events_total (toplam alert sayisi), falco_sidekick_errors (hata sayisi) ve falco_sidekick_reconnect (yeniden baglanti sayisi) icerir.

Event Generator ile Kural Testi

Yazdiginiz kurallari uretim ortaminda gercek bir saldiribeklemeden test etmek icin Sysdig'in resmi event-generator araci kullanilir:

kubectl run event-generator --image=falcosecurity/event-generator \
  --restart=Never -- /bin/sh -c "sleep 5 && event-generator run syscall --loop"
kubectl logs -f event-generator

event-generator simulate ettigi her aktivite icin Falco'dan alert bekler. Eger bir kural yazdigniz ancak event-generator onu tetiklemiyorsa, kural kosulunuzda bir hata veya yanlis eslesme vardir.

En Iyi Uygulamalar ve Uretim Checklist'i

Falco'yu uretim ortaminda etkin bicimde calistirmak icin asagidaki kontroller gozonunde bulundurulmalidir. Surucu secimi acisindan kernel 5.8 ve uzeri bir Linux dagitiminda modern eBPF her zaman tercih edilmeli, kernel modulu yalnizca geriye uyumluluk gerektirdiginde kullanilmalidir.

Kaynak yapilandirmasi acisindan CPU limit'i 500m-1000m, bellek limit'i 512Mi-1Gi arasinda tutulmalidir. Yuksek traffic'li production cluster'larda Falco'nun CPU kullanimini izleyin ve gerektiginde limit'leri artirin.

Kural yonetimi acisindan stock kurallari dogrudan duzenlemeyin. /etc/falco/falco_rules.yaml dosyasini degistirmek paket guncellemelerinde uzerine yazilacagi icin customRules mekanizmasi kullanilmalidir. False positive yonetimi acisinda exception kullanimi tercih edilmeli, bir kurali tamamen kapatmak yerine istisnalarla daraltmak daha guvenlidir.

Output ve izleme acisindan json_output etkinlestirilmeli ve alert'ler merkezi bir log sistemine (Elasticsearch, Loki, Splunk) gonderilmelidir. Slack entegrasyonu minimum WARNING seviyesi icin yapilandirilmalidir. Prometheus metrics endpoint'i etkinlestirilmeli ve alert frekansi Grafana dashboard'unda izlenmelidir.

Sonuc

Falco, Kubernetes ortamlarinda runtime security icin CNCF'in destekledigi en olgun acik kaynak cozumlerinden biridir. eBPF tabanli syscall izleme mimarisi, dusunuk performans overhead'i ve esnek kural sozdizimi ile saldırganlarin calisma zamaninda sergiledigi suphehli davranislari gercek zamanli olarak tespit eder. Modern eBPF surucusu, kernel modulu gerektirmeden kernel 5.8 ve uzeri sistemlerde calisir ve kurulum karmasikligini onemli olcu azaltir.

Bu makalede ele aldigmiz konular — Helm ile kurulum, modern eBPF yapilandirmasi, ozel kural yazimi, exception mekanizmasi ile false positive azaltma ve FalcoSidekick ile Slack Prometheus entegrasyonu — Falco'yu bir proof-of-concept'ten uretim guvenlik sistemine donusturmek icin gereken temel yapi taslarini olusturur. Runtime security, savunma derinliginin (defense in depth) en kritik katmanlarindan biridir. Statik tarama ve konteyner imaj guvenligi araclari guvenlik zincirinin onemli halkalari olsa da, bir saldırgan sisteme sizdikdan sonra gerceklestirdigi davranislari yakalayabilecek tek katman runtime izlemedir. Falco bu katmani doldurur ve Kubernetes guvenlik stratejinizin ayrilmaz bir parcasi haline gelir.