Modern Linux İkili Bellek Güvenliği: ELF Mimarisi, Derleyici Savunmaları ve ROP Mekanikleri

x86_64 ELF bellek bozulma mekaniklerinin derin teknik analizi: Derleyici korumaları (Canaries, Full RELRO, PIE, Intel CET), AddressSanitizer ile hata triyajı, ROP teorisi ve ikili savunma mühendisliği.

13 dk okuma
ibrahimsql
2.493 kelime

Modern Linux İkili Bellek Güvenliği: ELF Mimarisi, Derleyici Savunmaları ve ROP Mekanikleri#

Modern 64-bit Linux işletim sistemlerinde düşük seviyeli zaafiyet analizi ve ikili (binary) güvenlik mühendisliği; işletim sisteminin süreç modeli, derleyici optimizasyonları, çekirdek koruma alt sistemleri ve donanım destekli akış bütünlüğü mekanizmalarının derinlemesine anlaşılmasını gerektirir. Basit bir yığın arabellek taşmasının (stack buffer overflow), yığına enjekte edilen kabuk kodunun (shellcode) doğrudan çalıştırılmasına yettiği dönemler geride kalmıştır. Günümüz sistemleri; Adres Alanı Yerleşim Rastgeleleştirmesi (ASLR), Yürütülemez Yığın (NX), Yığın Koruması (Stack Canary / SSP), Salt Okunur Yeniden Konumlandırma (Full RELRO) ve Donanımsal Akış Denetimi (Intel CET) gibi çok katmanlı savunma hatları uygular.

Bu referans; x86_64 ELF yürütme ortamlarını, bellek bozulma primitiflerini, modern koruma mekanizmalarının çekirdek ve derleyici seviyesindeki mimarisini, hata triyaj yöntemlerini ve savunma odaklı derleme tekniklerini kapsamlı bir şekilde inceler.

1. x86_64 Linux Süreç Bellek Mimarisi#

Linux çekirdeği (fs/binfmt_elf.c), execve() sistem çağrısı üzerinden bir ELF ikilisini belleğe yüklediğinde, sayfa tabloları üzerinden sanal bir adres alanı inşa eder. 4 seviyeli sayfalama (4-level paging) kullanan standart 64-bit AMD64 mimarisinde kullanıcı alanı sanal belleği 0x0000000000000000 ile 0x00007fffffffffff adresleri arasında konumlanır (47 bitlik adresleme, 48. bit çekirdek alanı için işaret genişletilmiştir).

+-------------------------------------------------------------------------+ 0x7fffffffffff
| Çekirdek Alanı (Kernel Space - Kullanıcı Halkaları 1-3 Erişemez)        |
+-------------------------------------------------------------------------+ 0x800000000000
| Çevre Değişkenleri ve Program Argümanları (argc, argv, envp)           |
+-------------------------------------------------------------------------+
| Yığın Segmenti (Stack - Aşağıya Doğru Büyür) [RSP / RBP]                |
|   - Fonksiyon Çerçeveleri, Yerel Değişkenler, Dönüş Adresleri           |
+-------------------------------------------------------------------------+
|                                  | (Yığının büyüme yönü)                |
|                                  v                                      |
|                                                                         |
|                                  ^                                      |
|                                  | (Öbeğin büyüme yönü - brk/sbrk)      |
+-------------------------------------------------------------------------+
| Bellek Eşleme Segmenti (mmap)                                           |
|   - Paylaşımlı Kütüphaneler (libc.so), İş Parçacığı Yığınları, Dosyalar |
+-------------------------------------------------------------------------+
| Öbek Segmenti (Heap - glibc ptmalloc3 / tcache / bins tarafından yönetilir)
+-------------------------------------------------------------------------+
| .bss Segmenti (Başlatılmamış Genel Değişkenler, açılışta sıfırlanır)    |
+-------------------------------------------------------------------------+
| .data Segmenti (İlk Değeri Verilmiş Genel ve Statik Değişkenler)        |
+-------------------------------------------------------------------------+
| .rodata Segmenti (Salt Okunur Sabit Veriler, Sabit Karakter Dizileri)   |
+-------------------------------------------------------------------------+
| .text Segmenti (Çalıştırılabilir Makine Talimatları) [RIP]              |
+-------------------------------------------------------------------------+ 0x000000000000

1.1 Yığın Çerçevesi Anatomisi (System V AMD64 ABI)#

System V AMD64 ABI standardında fonksiyon çağrıları katı kurallara tabidir:

  • Argüman Aktarımı: İlk altı tamsayı/işaretçi argümanı yazmaçlar üzerinden aktarılır: RDI, RSI, RDX, RCX, R8, R9. Sonraki argümanlar yığına ters sırada itilir.
  • Dönüş Adresi: call talimatı bir sonraki makine komutunun adresini (RIP) yığına iter ve hedef fonksiyona dallanır.
  • Çerçeve Kurulumu (Prologue): Fonksiyon girişi çerçeveyi oluşturur: 
    push rbp          ; Önceki taban işaretçisini kaydet
mov  rbp, rsp     ; Yeni yığın çerçeve tabanını sabitle
sub  rsp, 0x40    ; Yerel değişkenler için yığında yer aç
  • Çerçeve Temizliği (Epilogue): Fonksiyon çıkışı bağlamı geri yükler: 
    leave             ; Karşılığı: mov rsp, rbp; pop rbp
ret               ; Yığından kaydedilmiş RIP değerini alıp RIP yazmacına yükler
Yüksek Bellek Adresleri
+-------------------------------------------------------------+
| Fonksiyon Argümanları (7., 8., vb.)                         |
+-------------------------------------------------------------+
| Kaydedilmiş Dönüş Adresi (CALL komutu tarafından itilir)     | <-- Hedeflenen RIP Adresi
+-------------------------------------------------------------+
| Kaydedilmiş Taban İşaretçisi (Önceki RBP)                    |
+-------------------------------------------------------------+
| Yığın Kanaryası (Stack Canary / fs:0x28)                    | <-- Koruma Sınırı
+-------------------------------------------------------------+
| Yerel Değişken Arabelleği (Örn: char buffer[64])            |
+-------------------------------------------------------------+ <-- RSP (Yığın İşaretçisi)
Düşük Bellek Adresleri

2. Bellek Bozulma Primitifleri#

Bellek bozulması (Memory Corruption), bir işlemin bir nesneye ayrılan sınırların veya yaşam süresinin dışındaki bellek adreslerine okuma ya da yazma yapmasıyla ortaya çıkar.

2.1 Yığın Tabanlı Arabellek Taşması (Stack Buffer Overflow)#

Boyut denetimi yapmayan işlevler (örneğin gets(), sınırsız scanf("%s") veya hatalı hesaplanmış memcpy()):

void zayif_fonksiyon(int fd) {
    char arabellek[64];
    // Güvensiz okuma: 64 baytlık alana 512 bayt veri okur
    read(fd, arabellek, 512);
}

Koruma mekanizmaları bulunmadığında veya atlatıldığında arabelleğin üzerindeki bitişik bellek ezilir:

  1. Yerel yığın değişkenleri bozulur.
  2. Derleyicinin yerleştirdiği kanarya değeri ezilir.
  3. Kaydedilmiş Taban İşaretçisi (RBP) bozulur.
  4. Kaydedilmiş Dönüş Adresi (RIP) saldırganın kontrolündeki değerle değiştirilir. Fonksiyon ret komutunu çalıştırdığında işlemci akışı doğrudan belirlenen yeni adrese yönlendirilir.

2.2 Tek Baytlık Taşma (Off-by-One / Single-Byte Overwrite)#

Sınır kontrolünde < yerine <= kullanılması ya da dizge sonlandırıcı (\0) baytının yanlış hesaplanması durumunda ortaya çıkar:

char arabellek[64];
for (int i = 0; i <= 64; i++) { // 65 bayt yazar
    arabellek[i] = bayt_oku();
}

Little-endian x86_64 mimarisinde sınırdan taşan tek bir bayt, çağıran fonksiyonun kaydedilmiş RBP değerinin en anlamsız baytını (Least Significant Byte - LSB) ezer. Fonksiyon tamamlanıp çağıran fonksiyona dönüldüğünde leave komutu bozulmuş taban işaretçisini RSP yazmacına yükler; böylece yığın çerçevesi saldırganın kontrolündeki bir bellek alanına kaydırılır (Stack Pivot).

2.3 Öbek Bozulması: Use-After-Free (UAF) ve Double-Free#

glibc bellek yöneticisi (ptmalloc), dinamik öbek belleğini parçalar (chunks), çöp kutuları (bins) ve iş parçacığı önbellekleri (tcache) üzerinden yönetir.

  • Use-After-Free (UAF): Bir bellek alanının free() ile serbest bırakılmasına rağmen işaretçisinin sıfırlanmaması (dangling pointer) durumudur. Uygulama bu işaretçiyi daha sonra okur, yazar veya yapının içerisindeki bir fonksiyon işaretçisini çağırırsa: 
    struct Oturum {
    void (*islem_logla)(const char *);
    char kullanici_adi[32];
};

struct Oturum *o = malloc(sizeof(struct Oturum));
free(o); // Bellek serbest bırakıldı, ancak 'o' işaretçisi yığında geçerli kalır

// Aynı boyutta yeni bir bellek alanı tahsis edildiğinde aynı blok yeniden verilir:
char *sahte_veri = malloc(sizeof(struct Oturum));
// Saldırgan sahte_veri içeriğini kontrol edebiliyorsa fonksiyon işaretçisi tablosunu ezebilir!

o->islem_logla("Giris yapildi"); // Program akışı saptırılır

3. Modern Linux Savunma Hiyerarşisi#

Sıradan bellek taşmalarını engellemek amacıyla modern sistemler katmanlı güvenlik halkaları uygular.

+-----------------------------------------------------------------------------------+
|                        MODERN LINUX SAVUNMA MATRİSİ                               |
+-----------------------------------------------------------------------------------+
| Savunma         | Uygulama Katmanı  | Çekirdek / Derleyici Mekanizması            |
+-----------------+-------------------+---------------------------------------------+
| NX / DEP        | CPU MMU + Kernel  | Sayfa tablosu NX biti; W^X sanal sayfa ilkesi|
| Stack Canary    | GCC / Clang       | Thread Local Storage (fs:0x28) nöbetçi baytı|
| ASLR            | Çekirdek (Kernel) | randomize_va_space; rastgele taban ofsetleri|
| PIE             | Derleyici/Bağlayıcı| ET_DYN konumdan bağımsız çalıştırılabilir kod|
| Full RELRO      | Bağlayıcı / Glibc | BIND_NOW çözümleme; salt okunur GOT segmenti|
| Intel CET       | Donanım (CPU)     | Shadow Stack & Dolaylı Dal İzleme (IBT)     |
| Seccomp-BPF     | Linux Çekirdeği   | prctl() üzerinden BPF sistem çağrısı filtresi|
+-----------------------------------------------------------------------------------+

3.1 Çalıştırılamaz Bellek (NX / DEP)#

  • Mekanizma: Bellek Yönetim Birimi (MMU) tarafından sayfa tablosu girdilerindeki 63. bit (XD/NX) ile donanımsal olarak uygulanır. Linux çekirdeği yığın ve öbek sayfalarını PROT_READ | PROT_WRITE olarak işaretler, PROT_EXEC yetkisi vermez (W^X: Yazılabilir ya da Çalıştırılabilir, ikisi birden olamaz).
  • Yaptırım: CPU'nun komut işaretçisi (RIP) NX olarak işaretlenmiş bir sayfadan komut çekmeye çalıştığında, donanım bir Sayfa Hatası (Page Fault) üretir (P=1, ID=1). Çekirdek sürece anında SIGSEGV gönderir ve süreci sonlandırır.
  • Sömürüye Etkisi: Saldırganın yığına veya öbeğe enjekte ettiği kabuk kodunu (shellcode) doğrudan çalıştırması imkansız hale gelir. Kod yeniden kullanımı (Code Reuse) teknikleri zorunlu hale gelir.

3.2 Yığın Kanaryası (Stack Smashing Protector - SSP)#

  • Mekanizma: Derleyici (-fstack-protector-strong) tarafından yerleştirilir. Fonksiyon başlangıcında Thread Local Storage (fs:0x28) alanından rastgele 64-bitlik bir değer okunur ve kaydedilmiş taban işaretçisinden hemen önce yığına yazılır: 
    mov    rax, QWORD PTR fs:0x28   ; TLS üzerinden kanaryayı al
mov    QWORD PTR [rbp-0x8], rax ; Yığına nöbetçi olarak yaz
xor    eax, eax                 ; Yazmacı temizle
  • Doğrulama: Fonksiyon dönüşünden önce yığındaki değer ile fs:0x28 karşılaştırılır: 
    mov    rax, QWORD PTR [rbp-0x8]
sub    rax, QWORD PTR fs:0x28
jne    __stack_chk_fail         ; Eşleşmiyorsa derhal süreci sonlandır
  • Bayt Mimarisi: Linux glibc uygulamasında kanaryanın en düşük anlamlı baytı bilerek 0x00 (null bayt) yapılır. Bu sayede strcpy() veya printf("%s") gibi sonlandırıcı sıfır baytına duyarlı fonksiyonlar kanaryayı bellekten sızdıramaz.

3.3 ASLR ve PIE (Position Independent Executables)#

  • ASLR: /proc/sys/kernel/randomize_va_space üzerinden yönetilen çekirdek mekanizmasıdır.
    • 0: Devre dışı.
    • 1: Yığın, vdso ve mmap sayfaları rastgeleleştirilir.
    • 2: Tam rastgeleleştirme (Yığın, Heap/brk, mmap ve Paylaşımlı Kütüphaneler).
  • PIE: Program -fPIE -pie ile derlendiğinde göreceli adresleme (RIP-relative) kullanır. Bağlayıcı ET_EXEC sabit ikilisi yerine ET_DYN türünde dinamik bir nesne üretir.
  • Bileşik Etki: Programın ana kod segmenti, standart kütüphaneler (libc), yığın ve öbek adresleri her çalıştırmada tamamen değişir. Saldırgan sabit adresler kullanamaz.

3.4 Salt Okunur Yeniden Konumlandırma (RELRO)#

Dinamik sembol çözümlemesinde Global Offset Table (GOT) ve Procedure Linkage Table (PLT) kullanılır.

+---------------------------------------------------------------------+
| Dinamik Sembol Çözümleme Akışı (Lazy Binding)                       |
| 1. Program puts@plt fonksiyonunu çağırır                            |
| 2. puts@plt komutu puts@got.plt adresindeki değere atlar            |
| 3. İlk çalıştırma: GOT alanı PLT içerisindeki çözümleyiciyi gösterir|
| 4. Çözümleyici ld-linux.so içindeki _dl_runtime_resolve() çağırır   |
| 5. puts() fonksiyonunun gerçek libc adresi puts@got.plt alanına yazılır
| 6. Sonraki çağrılarda doğrudan libc adresine zıplanır               |
+---------------------------------------------------------------------+
  • Partial RELRO (-Wl,-z,relro): Dahili ELF kesitleri başlatma sonrasında salt okunur yapılır, ancak tembel bağlama (lazy binding) yapılabilmesi için .got.plt yazılabilir bırakılır.
  • Full RELRO (-Wl,-z,relro,-z,now): Dinamik bağlayıcı (ld-linux.so) program başlarken tüm harici kütüphane sembollerini çözer (BIND_NOW). Ardından mprotect() çağrısıyla tüm GOT sayfalarını salt okunur (PROT_READ) yapar. Bu sayede GOT üzerine fonksiyon işaretçisi ezme saldırıları SIGSEGV ile çöker.

3.5 Donanımsal Akış Bütünlüğü (Intel CET)#

Modern işlemciler donanımsal koruma komut setleri barındırır:

  1. Shadow Stack (Gölge Yığın): İşlemci, kullanıcı erişimine kapalı ayrı bir yığın tutar. call komutu çalıştığında dönüş adresi hem normal yığına hem gölge yığına yazılır. ret çalıştığında iki adres karşılaştırılır. Uyuşmazlık durumunda #CP (Control Protection) donanım kesmesi üretilir.
  2. Indirect Branch Tracking (IBT): Dolaylı fonksiyon çağrılarını (call rax) ve zıplamaları denetler. İkili koddaki tüm geçerli atlama hedefleri ENDBR64 talimatıyla başlamak zorundadır.

4. Analiz ve Hata Triyaj Yöntemleri#

Bellek bozulması hatalarını tespit etmek ve doğrulamak için deterministik hata ayıklayıcılar ve enstrümantasyon araçları kullanılır.

4.1 AddressSanitizer (ASan) ile Bellek Gölgeleme#

AddressSanitizer (-fsanitize=address), derleme aşamasında eklenen ve bellek ihlallerini anında yakalayan bir LLVM/GCC eklentisidir.

  • Gölge Bellek (Shadow Memory): Sanal adres alanının 1/8'lik kısmı gölge bellek olarak ayrılır. Her gölge baytı, uygulamadaki 8 baytlık bellek bölgesinin geçerliliğini temsil eder.
  • Kırmızı Bölgeler (Redzones): ASan, yığın arabelleklerinin ve öbek tahsislerinin etrafına zehirli kırmızı bölgeler (fa, f1) yerleştirir.
// Örnek ASan Raporu
==4192==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000000054
WRITE of size 4 at 0x603000000054 thread T0
    #0 0x40120b in ayrıştırıcı /src/parser.c:42
    #1 0x401490 in main /src/main.c:18
0x603000000054 is located 4 bytes to the right of 80-byte region

Kırmızı bölgeye yazma girişiminde bulunulduğu anda ASan süreci durdurur ve çağrı yığınını ekrana basar.

4.2 GDB ve Pwndbg ile Hata Ayıklama#

Çökme anındaki yazmaç ve yığın durumunun incelenmesi:

# Hata ayıklama sembolleriyle derleme:
gcc -g -fno-stack-protector -z noexecstack hedef.c -o hedef

# GDB başlatma:
gdb ./hedef

Önemli triyaj komutları:

  • checksec: İkilideki aktif koruma bayraklarını listeler (NX, Canary, PIE, RELRO).
  • vmmap: Sürecin sanal bellek haritasını, yetkilerini (rwxp) ve taban adreslerini gösterir.
  • info registers: Genel amaçlı yazmaçları (RAX, RBX, RSP, RBP, RIP) listeler.
  • x/20gx $rsp: Yığındaki tepe 20 alanı 8 baytlık onaltılık formatta gösterir.
  • backtrace (bt): Çökmeye neden olan çağrı zincirini raporlar.

5. Akış Saptırma ve Gadget Teorisi#

NX ve ASLR aktif olduğunda doğrudan kabuk kodu çalıştırmak imkansızdır. Savunma mühendisliği açısından saldırganın akışı nasıl saptırabileceğini anlamak hayati önem taşır.

5.1 Bilgi Sızıntısı (Information Leak) İhtiyacı#

ASLR ve PIE devredeyken bellek adresleri her çalıştırmada değişir. Bir saldırı akışı oluşturabilmek için öncelikle bir Bilgi Sızıntısı gereklidir:

  • Biçimlendirme dizgisi açığı (printf(kullanici_girdisi)) veya başlatılmamış bellek okuması ile yığındaki bir kütüphane işaretçisi sızdırılır.
  • Sızan adresten kütüphanenin bilinen sembol ofseti çıkarılarak taban adresi hesaplanır: Taban Adres = Sızdırılan Çalışma Zamanı Adresi - ELF Sembol Ofseti

5.2 Return-Oriented Programming (ROP) Mimarisi#

Dönüş Odaklı Programlama (ROP), çalıştırılabilir bellek alanlarında (.text veya libc.so.6) zaten var olan küçük makine komut dizilerini birbirine bağlayarak NX korumasını atlatır. Bu komut dizilerine gadget denir ve mutlaka bir ret (0xc3) talimatı ile sonlanırlar.

; Tipik x86_64 Yazmaç Doldurma Gadget'ı
pop rdi         ; Yığındaki en üst değeri RDI yazmacına yükler (1. argüman)
ret             ; Yığından sonraki adresi alıp oraya zıplar

ret komutu yığındaki bir sonraki adrese atladığından, yığına arka arkaya gadget adresleri ve parametreler dizilerek yeni bir kod enjekte etmeden mantıksal bir yürütme zinciri kurulabilir.

Örnek ROP Yığın Durumu:#

Yığın Tepesi (RSP)
+-----------------------------------+
| 'pop rdi; ret' gadget adresi      | <-- ret komutu buraya atlar
+-----------------------------------+
| "/bin/sh" dizge işaretçisi        | <-- pop rdi ile RDI'ya yüklenir
+-----------------------------------+
| 'pop rsi; ret' gadget adresi      | <-- ret komutu buraya atlar
+-----------------------------------+
| 0x0000000000000000 (NULL)         | <-- pop rsi ile RSI'ya yüklenir
+-----------------------------------+
| Hedef fonksiyonun adresi          | <-- ret komutu hedefe dallanır
+-----------------------------------+
Yığın Tabanı

5.3 Yığın Kaydırma (Stack Pivoting)#

Arabellek taşması alanı çok kısıtlı olduğunda (örneğin yalnızca kaydedilmiş çerçeve işaretçisi ezilebiliyorsa), leave; ret gadget'ı kullanılarak RSP yazmacı öbekte veya .bss alanında hazırlanan geniş ROP zincirine yönlendirilir.

6. Savunma Mühendisliği ve Derleyici Sertleştirme#

İkili seviyedeki bellek açıklarını ortadan kaldırmak; güvenli derleme bayrakları, modern bellek güvenli diller ve çekirdek seviyesinde kum havuzu (sandboxing) uygulamalarını gerektirir.

6.1 Üretim Seviyesi Derleyici Güvenlik Bayrakları#

C/C++ servisleri derlenirken aşağıdaki çok katmanlı bayraklar uygulanmalıdır:

# Modern Üretim Seviyesi Sertleştirilmiş Derleme
gcc -O2 \
    -Wall -Wextra -Werror \
    -D_FORTIFY_SOURCE=3 \
    -fstack-protector-strong \
    -fPIE -pie \
    -Wl,-z,relro,-z,now \
    -Wl,-z,noexecstack \
    -fcf-protection=full \
    hedef.c -o hedef

Bayrakların Güvenlik Görevleri:#

  • -D_FORTIFY_SOURCE=3: memcpy, strcpy, snprintf gibi fonksiyonların bellek sınır kontrollerini derleme ve çalışma zamanında otomatik denetler.
  • -fstack-protector-strong: Arabellek tanımlayan veya yerel değişken referansı alan tüm fonksiyonlara yığın kanaryası ekler.
  • -fPIE -pie: Konumdan bağımsız ikili üreterek tam ASLR entropisi sağlar.
  • -Wl,-z,relro,-z,now: Full RELRO uygulayarak GOT tablosunu salt okunur yapar.
  • -Wl,-z,noexecstack: Yığın segmentinin yürütülemez olduğunu ELF başlığına işler.
  • -fcf-protection=full: Intel CET akış bütünlüğü talimatlarını (ENDBR64 ve gölge yığın) üretir.

6.2 Linux Seccomp-BPF ile Çekirdek İzolasyonu#

Kod çalıştırma zafiyeti oluşsa dahi sürecin işletim sistemine zarar vermesini engellemek için Berkeley Packet Filter (BPF) ile sistem çağrıları sınırlandırılmalıdır:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <stddef.h>
#include <sys/syscall.h>

void seccomp_izolasyonu_uygula(void) {
    // Alt süreçlerin yetki yükseltmesini engelle
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) == -1) {
        perror("prctl(NO_NEW_PRIVS)");
        exit(EXIT_FAILURE);
    }

    struct sock_filter filtre[] = {
        // Mimarinin x86_64 olduğunu doğrula
        BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, arch))),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, AUDIT_ARCH_X86_64, 1, 0),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL),

        // Sistem çağrı numarasını yükle
        BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, nr))),

        // İzin verilen güvenli sistem çağrıları: read, write, exit_group, exit
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_read, 3, 0),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_write, 2, 0),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_exit_group, 1, 0),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_exit, 0, 1),

        // İzin ver
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),

        // Kalan tüm sistem çağrılarını anında sonlandır
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL),
    };

    struct sock_fprog program = {
        .len = (unsigned short)(sizeof(filtre) / sizeof(filtre[0])),
        .filter = filtre,
    };

    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &program) == -1) {
        perror("prctl(PR_SET_SECCOMP)");
        exit(EXIT_FAILURE);
    }
}

Uygulamada bellek taşması gerçekleşse dahi saldırganın execve, socket veya fork çağırması çekirdek tarafından engellenir (SECCOMP_RET_KILL).

7. İkili Güvenlik Denetim Kontrol Listesi#

  • Üretim ortamındaki tüm ikililerin Full RELRO ile derlendiğini doğrulayın (checksec --file=ikili).
  • Dahili ve üçüncü parti paylaşımlı kütüphanelerde PIE ve yığın kanaryasının etkin olduğunu teyit edin.
  • Güvensiz C fonksiyonlarının (gets, strcpy, strcat, sprintf) kullanımını yasaklayın ve sınır kontrollü alternatiflerle (snprintf, strlcpy veya Rust/C++ RAII) değiştirin.
  • AddressSanitizer ve UndefinedBehaviorSanitizer testlerini CI/CD fuzzing süreçlerine entegre edin.
  • Seccomp-BPF filtreleri ve systemd kum havuzu yönergeleri (ProtectSystem=strict, NoNewPrivileges=true) ile süreçleri çekirdek seviyesinde yalıtın.
---
Bu yazıyı paylaş:
TwitterLinkedInFacebook

Ne düşünüyorsun?

Tepki bırakarak geri bildirim ver

İlgili Yazılar