Bugünün planı (3 saat)

Öğrenme çıktısı (ÖÇ.3): gizlemeyi bir güvenlik kuralı olarak yazmak · her tekniğin maliyetini/sınırını söylemek · bir korumayı ölçüp gerekçelendirmek

Kaynak kod nedir?

• Sizin yazdığınız, insanın okuyabildiği program metni (ör. C dosyası).
• Örnek: int topla(int a, int b) { return a + b; }

Kaynak kod derlenir ve makinenin çalıştırdığı biçime döner.

Derleyici ve binary dosya

• Derleyici (compiler): kaynak kodu makine koduna çeviren program (gcc, clang).
• Binary dosya (binary): derleme sonucu; bilgisayarın doğrudan çalıştırdığı dosya (.exe, .so).

Makine kodu ve assembly

• Makine kodu: işlemcinin anladığı sayısal komutlar.
• Assembly: makine kodunun insana biraz daha okunur hali (mov, cmp, jmp).

Binary dosyayı açtığınızda gördüğünüz şey budur.

Tersine mühendislik nedir?

Tersine mühendislik (reverse engineering): binary dosyaya bakıp programın ne yaptığını anlamaya çalışmak.

Saldırganın temel işi budur.

Tersine derleyici (decompiler)

• Tersine derleyici (decompiler): binary dosyayı geri, okunabilir koda yakın bir biçime çeviren araç.
• Örnekler: Ghidra, IDA.

Amaç: kaynağa erişimi olmayan biri, binary'ye bakarak mantığı çıkarsın.

Bit, bayt, onaltılık

• Bit: 0 veya 1.
• Bayt: 8 bit.
• Onaltılık (hex): 0x ile yazılır; 0x2A = 42.

Kodda 0x5A gibi değerler göreceğiz; bunlar sadece sayılardır.

XOR nedir?

• XOR (^): iki bit farklıysa 1, aynıysa 0.
• Özelliği: a ^ b ^ b == a → kendini geri alır.

c = a ^ 0x5A;   /* encode */
a = c ^ 0x5A;   /* decode */

Gizlemede çok kullanılır çünkü tersine çevrilebilir.

Entropi (rastgelelik) nedir?

• Entropi: bir verinin ne kadar "rastgele" göründüğü.
• Kriptografik anahtarlar yüksek entropili görünür (düzensiz baytlar).

Saldırgan, binary'de yüksek entropili bir blok görürse "burada anahtar olabilir" der.

Fonksiyon, dal, koşul

• Fonksiyon: bir işi yapan kod bloğu (grant_access).
• Dal (branch): if gibi bir yol ayrımı.
• Koşul: dalın hangi yöne gideceğini belirleyen ifade.

Temel blok (basic block)

• Temel blok: dalsız, baştan sona akan komut dizisi.
• Bir if gelince blok biter, iki yeni blok başlar.

Program = temel blokların birbirine bağlanması.

Kontrol akışı grafiği (CFG)

• CFG (Control Flow Graph): temel blokları düğüm, geçişleri kenar yapan şema.
• Programın "yol haritası"dır.

Bir cümlede bu haftanın sorusu

Programı kullanıcıya teslim ettim; saldırgan artık ona sahip. Kodumu okumasını ve değiştirmesini nasıl
zorlaştırırım?

Yanıt: kod gizleme kuralları. Başlıyoruz.

Önce bir soru

Bir mobil uygulamayı kullanıcıya teslim ettiniz.

• Kod artık kimin makinesinde çalışıyor?
• Sunucudaki güvenlik denetimleriniz burada geçerli mi?
• Saldırgan kaç kez deneyebilir?

MATE: uçtaki saldırgan

Man-At-The-End = programın kendisine sahip saldırgan.

• Binary dosya onda
• Belleği okuyup değiştirebilir
• Tersine derleyici, hata ayıklayıcı elinde
• İstediği kadar dener

Buna beyaz kutu da denir (1. hafta).

MATE saldırgan modeli — şema

Dürüst gerçek

Yeterli zamanı, becerisi ve motivasyonu olan saldırgan her gizlemeyi çözer.

Cookbook (Tarif 12.1): anti-tampering "kırılamaz" değildir.

Öyleyse amaç ne?

Amaç: kırmayı ekonomik olmaktan çıkarmak

Gizleme bir maliyet yükseltme aracıdır, sır saklama değil.

• Kırmayı pahalı yap
• Otomatikleştirmeyi zorlaştır
• Diğer katmanlara zaman kazandır

Bunları üç kurala dökelim.

Kural 1 — Maliyeti değerin üstüne çıkar

Saldırı, korunan varlıktan pahalı olmalı.

• 10 TL'lik sırrı 1000 TL'lik çabayla korumak: israf
• 1000 TL'lik sırrı 10 TL'lik çabayla korumak: yetersiz

Önce varlığın değerini belirle, sonra korumayı seç.

Kural 2 — Otomasyonu kır

Bir kopyada işe yarayan saldırı, bütün kopyalarda işe yaramasın.

• Bunun adı çeşitlendirme (bu haftanın 5. bölümü)
• 14. haftada araçla (Tigress --Seed)

Bir kırık, her yeri açmamalı.

Kural 3 — Diğer katmanlara zaman kazandır

Gizleme tek başına savunma değil; bir katman.

• RASP (6. hafta) çalışırken korur
• Bütünlük denetimi, sunucu denetimi
• Anahtar/sürüm yenilenene kadar dayanmak yeter

Gizleme neyi gizler?

Collberg'in sınıflandırması: gizlemeyi neyi gizlediğine göre ayırırız.

Beş aile var. Sırayla görelim.

Sanallaştırma — şema

Beş aile — güç ↑ maliyet ↑

Sahada: hepsi bir arada

Sertifikalı bir üründe listelenen native önlemler bu haritanın tamamını kapsar:

sembol gizleme · ad anlamsızlaştırma · aritmetik dönüşüm · dize kodlama · opak boolean · sahte işlem · ölü dal · düzleştirme · rastgele çıkış · günlük kaldırma

Hiçbiri tek başına güçlü değil; güç birliktelikten.

Animasyon · Beş aile, tek fonksiyon

Animasyon · Beş aile — uç durum (hepsi geçerli)

Gizleme ne VERİR?

• Statik analize gecikme (strings, sembol, tersine derleme)
• Otomatik saldırıya direnç (çeşitlendirmeyle)
• Diğer katmanlara zaman
• Ölçülebilir bir maliyet artışı

Gizleme ne VERMEZ?

• Bir sırrın gizliliği → o kriptonun işi
• Bellekten okumaya koruma → RASP, whitebox
• Kalıcı güvenlik → "kırılamaz" yoktur
• Bedava koruma → her gizleme maliyet getirir

Gizleme ne verir, ne vermez — şema

⚠️ En sık hata

Gizlemeyi anahtar saklama sanmak.

• Gömülü/gizlenmiş anahtar yine oradadır
• Program çalışırken onu kullanmak zorunda → bellekte açığa çıkar
• Çözme mantığı da içeride

Gizlilik kriptonun işidir, gizlemenin değil. (3. hafta)

"Koruma kuralı" şablonu

KURAL K-xx: <teknik>
  Neyi korur?  : hangi varlık / kod bölümü
  Hangi tehdit?: statik / dinamik / otomatik / kurcalama
  Nasıl?       : bir cümle (kavram)
  Maliyet      : boyut, hız, bakım, hata ayıklama
  Sınır        : neyi korumaz
  Ölçüm        : etkinlik nasıl doğrulanır

Neden "Ölçüm" satırı şart?

Gizleme "var/yok" değildir.

• Değerlendirici (13. hafta) her katmanın saldırıyı ne kadar geciktirdiğini sorar
• Ölçümsüz koruma = iddia, kanıt değil

Projede S9'u bu şablonla yazacaksınız.

Dört ölçüt — şema

Animasyon · Koruma kuralı şablonu

Animasyon · Koruma kuralı şablonu — uç durum (yalnız kavramsal varlık)

Bölüm 2 — kısa sınama

1. MATE saldırgan kara kutudan nasıl ayrılır?
2. Gizlemenin üç kuralı neydi?
3. Gizleme bir anahtarı korur mu? Neden?

Bu bölümün amacı

CFG'yi (ön bilgide tanımladık) bu bölümün iskeleti sayıyoruz; saldırganın ilk işi bu iskeleti çıkarmaktır.

4. haftada düzleştirmeye giriş yaptık.

Bu bölümde onu güçlendiren kuralları ekliyoruz:

K-01 opak yüklem · K-02 aritmetik kodlama · K-03 sahte/ölü · K-04 düzleştirme (derin) · K-05 rastgele çıkış · K-06 çağrı gizleme

Tüm örnekler sentetik, tek denetim: grant_access.

Opak yüklem — şema

K-01 · Neyi korur?

• Bir dalın hangi koşulda alındığını
• Bir döngünün kaç kez döndüğünü

Fikir: değeri programcının bildiği ama aracın kolay çözemediği bir ifadeyle dallan.

K-01 · Opak yüklem örneği

/* x*(x+1) is always even → result is always true */
static int opaque_true(unsigned x) {
    return ((x * (x + 1)) & 1u) == 0;
}

Programcı bilir: hep true. Statik analiz bunu kolay kanıtlayamaz.

K-01 · Nasıl kullanılır?

if (opaque_true(counter)) {
    state = real_step(state);   /* always entered */
} else {
    state = fake_step(state);    /* dead path: never runs */
}

Analist iki yolu da "gerçek" sanır; zamanını sahte yola harcar.

K-01 · Opak döngü

Kılavuz döngüleri ayrı kural yapar:

• for/while doğrudan görünmez
• Düzleştirmenin içine gizlenir
• Gövde küçük bloklara bölünür
• Yineleme bir durum değişkeniyle yönetilir

"Şu döngü N kez dönüyor" bilgisi CFG'den okunmaz.

Animasyon · Opak yüklem ekleme

Animasyon · Opak yüklem — uç durum (büyük değerler)

K-02 · Neyi korur?

Sabitleri ve basit hesapları.

"Bu sayı 0x1F, bu işlem bir XOR" gibi doğrudan okunabilir ipuçlarını gizler.

K-02 · Denk ifadeler (MBA)

Bir işlemi, sonucu değişmeyen ama karmaşık görünen denkiyle değiştir:

a + b   ≡   (a ^ b) + 2*(a & b)
x * 2   ≡   x << 1

Sonuç aynı, görünüm karmaşık. (MBA = mixed boolean-arithmetic)

K-02 · Sabiti gizle

/* 0x2A is not written directly; produced from two parts */
static uint8_t threshold(void) {
    uint8_t a = 0x37, b = 0x1D;
    return (uint8_t)(a ^ b);   /* = 0x2A */
}

Binary dosyada 0x2A araması sonuç vermez.

Sahte işlem ≠ ölü dal — şema

K-03 · İkisi farklıdır!

Kılavuz bunları ayrı kurallar yapar. Fark kritik:

• Sahte işlem: çalışır, sonucu değiştirmez
• Ölü dal: hiç çalışmaz (opak yüklemle korunur)

K-03 · Sahte işlem örneği

crc = crc32_update(crc, data, n);
crc ^= (constant ^ constant);   /* = crc; result unchanged */

constant ^ constant == 0 → CRC değişmez, ama kod kalabalıklaşır.

K-03 · Ölü dal örneği

if (opaque_false()) {        /* always false */
    fake_check();        /* never runs */
}

Analist bu bloğu "gerçek" sanıp inceler; zaman kaybeder.

K-04 · Neyi korur?

Algoritmanın yapısını:

• Blokların doğal komşuluğunu
• "Hangi bloktan hangisine gidilir" bilgisini

K-04 · Fikir: dikey → yatay

• Normal: bloklar birbirini izler (dikey akış)
• Düzleştirilmiş: tüm bloklar tek switch dağıtıcıda (yatay)
• Sıra yalnız bir durum değişkeninden okunur

K-04 · Şablon

int state = START;
for (;;) switch (state) {
  case START: state = STEP1; break;
  case STEP1: state = condition ? STEP2 : FAIL; break;
  case STEP2: state = DONE; break;
  case FAIL:  return DENIED;
  case DONE:  return GRANTED;
  default:    return DENIED;   /* random exit (K-05) */
}

K-04 · Tek başına zayıf

4. haftada söylemiştik: bu şablon deneyimli analiste kısa sürede çözülür.

Güç, güçlendirmelerden gelir. Sırayla:

K-04 · Güçlendirme 1 — durum değerleri (K-02)

• case 1, 2, 3 yerine dağınık, aritmetikle üretilen değerler
• Ardışıklık görünmez
• Hangi adımın hangisini izlediği okunmaz

K-04 · Güçlendirme 2 — sahte/ölü (K-03)

• Sahte case'ler eklenir
• Hangi case gerçek, ayırt etmek zorlaşır

K-04 · Güçlendirme 3 — rastgele çıkış (K-05)

• Hata, default dalından öngörülemeyen durumla çıkar
• Başarısızlığın nerede olduğu okunmaz

K-04 · Güçlendirme 4 — opak geçişler (K-01)

• case geçişleri sabit değil, opak koşullara bağlı
• Statik izleme daha da zorlaşır

Animasyon · Kontrol akışı düzleştirme

Animasyon · Düzleştirme — uç durum (en kısa yol)

K-05 · Neyi korur?

Bir denetimin nerede başarısız olduğunu.

Saldırgan tipik olarak:

• "Başarısızlık dalını" bulur
• Onu "başarı dalına" çevirir

K-05 · Nasıl?

if (!signature_valid(p)) {
    state = unpredictable_value();  /* not defined in the switch → default */
    break;
}

Doğrudan return DENIED yok; durum öngörülemeyen bir değere gider.

K-05 · Başarı da benzer çıksın

• Başarılı çıkış da aynı yöntemle
• Böylece başarı ve başarısızlık akışta birbirine benzer
• Analist "işte kabul dalı" diyemez

K-06 · Neyi korur?

İpuçlarını: "Şu fonksiyon memcmp çağırıyor → bir karşılaştırma yapıyor."

Standart kütüphane çağrıları ne yaptığınızı söyler.

K-06 · Nasıl?

• Kritik yolda memcmp yerine kendi sabit-zamanlı esit_mi
• Bağlantı çözümleyicide tanınan ad görünmez
• Sahte parametreler: hiç kullanılmayan parametreler ekle → imza yanıltıcı

K-06 · ⚠️ Sabit zamanlılığı bozma

Kendi karşılaştırmanı yazarken sabit zamanlı olsun (3. hafta).

• Erken çıkışlı karşılaştırma → yan kanal açar
• Koruma eklerken yeni açık yaratma

Bölüm 3 — özet

• K-01 opak yüklem/döngü · K-02 aritmetik kodlama
• K-03 sahte işlem ≠ ölü dal
• K-04 düzleştirme (güçlendirmelerle)
• K-05 rastgele çıkış · K-06 çağrı gizleme

Hiçbiri tek başına yeterli değil; birlikte ve ölçülmüş.

Bölüm 3 — kısa sınama

1. Sahte işlem ile ölü dal farkı?
2. Düzleştirmeyi güçlendiren 4 kural?
3. Rastgele çıkış hangi saldırıyı zorlaştırır?

Veri gizleme kuralları K-07–K-09 — şema

Kontrol akışı ≠ veri

• Kontrol akışı (bölüm 3): algoritmanın yapısını gizler
• Veri gizleme (bu bölüm): programın işlediği değerleri gizler

Dizeler, sabitler, tablolar, değişkenler.

K-07 · Neyi korur?

Binary dosyadaki okunabilir metinleri.

En ucuz saldırı adımı: strings.

"Lisans gecersiz" ya da bir URL → saldırgana nereye bakacağını söyler.

K-07 · Fikir

• Hassas dize derleme öncesi kodlanır (ör. XOR)
• Binary dosyada kodlanmış durur
• Kullanım anında çözülür
• İş biter bitmez silinir

K-07 · Örnek (sentetik)

static const uint8_t HIDDEN[] = {0x3B,0x2A,0x2E,0x2E,0x2D};
void use(void) {
    char tmp[sizeof HIDDEN];
    for (size_t i=0;i<sizeof HIDDEN;i++)
        tmp[i] = HIDDEN[i] ^ 0x5A;      /* decode */
    process(tmp, sizeof HIDDEN);
    secure_wipe(tmp, sizeof tmp); /* wipe immediately */
}

K-07 · ⚠️ Kritik sınır

• Çalışırken çözülmüş dize bellekte açık
• Çözme anahtarı da binary dosyada
• Bu bir statik tarama önlemidir

Sahada: çözme anahtarı parçalanır ve dağıtılır, çözme fonksiyonu ek denetimlerle korunur.

K-07 · Dize gizleme ≠ anahtar saklama

Tekrar: dize gizleme strings'i durdurur, anahtar korumaz.

• Anahtar için → whitebox (11. hafta) ya da donanım
• Ölçüm: strings çıktısında hassas dize bulunmamalı

Animasyon · Dize şifreleme

Animasyon · Dize şifreleme — uç durum (hiçbiri geçerli değil)

K-08 · Sorun: düz 0/1 tehlikeli

Bir denetimin sonucunu düz 0/1 döndürmek:

• Saldırgan tek baytı çevirir
• "Başarısız" → "başarılı" olur

K-08 · Fikir

Doğru/yanlış değerini:

• Birden çok değere bağla
• Tek bayt yamasıyla çevrilemeyecek biçimde tut

Fonksiyonlar düz boolean yerine opak dönüş kodu verir.

K-08 · Örnek (kavram)

typedef struct { uint32_t a, b; } Karar;
static Karar izin_ver(void) {
    return (Karar){ 0xA3C1u, 0x5C3Eu };  /* a ^ b == 0xFFFF */
}
static int karar_izin_mi(Karar k) {
    return (k.a ^ k.b) == 0xFFFFu;
}

Çağıran taraf iki alanı da doğrular.

Animasyon · Veri kodlama (opak boolean)

Animasyon · Veri kodlama — uç durum (hepsi geçerli)

K-09 · Neyi korur?

Hassas bir değişkenin bellekteki tanınabilir izini.

"32 baytlık blok = AES anahtarı" gibi kalıplar yol gösterir.

K-09 · Nasıl?

• Değişkeni böl (32-bit'i iki 16-bit paydan üret)
• Birden çok değişkeni tek söze birleştir
• Dizileri yeniden düzenle
• Tampon boyut/sıra/yerleşimini değiştir
• Kullanımdan sonra rastgele değerle doldur

K-10 · Sanallaştırma (kavram)

Neyi korur? Bir fonksiyonun makine kodunu.

Nasıl? Fonksiyon → özel bir VM'in bayt koduna; binary'ye bayt kodu + küçük yorumlayıcı gömülür.

Saldırgan tanıdık kodu değil, önce çözmesi gereken özel komut kümesini görür.

K-11 · Derleyici tabanlı (O-LLVM)

Neyi korur? Yukarıdaki kuralları, el ile değil derleyici geçişiyle.

• LLVM tabanlı gizleyiciler: düzleştirme, sahte akış, komut değiştirme geçişleri
• Kaynak okunur kalır; koruma bir derleme seçeneği
• Her sürümde farklı tohum → çeşitlendirme kolay

K-12 · Dinamik şifreleme (kavram)

Neyi korur? En hassas kod bölümlerini, binary'de şifreli tutarak.

Nasıl? Bölüm şifreli durur → yalnız çalışacağı an çözülür → sonra yeniden şifrelenir/silinir.

K-12 · ⚠️ Risk

• OS bellek korumalarıyla (DEP/NX, W^X) doğrudan çatışır
• Yanlış uygulanırsa hem çöker hem yeni açık yaratır
• Çalışırken bir an kod bellekte açık → döküm yakalar

K-12 · Kural

Bir koruma eklerken başka bir korumayı kapatıyorsan, net kazancı ölç ve ödünleşim kaydına yaz.

Uygulamada çok seçici, küçük bölümlerde kullanılır.

Java/yönetilen taraf (5. haftadan)

• Bu haftanın kuralları native (C/C++) için
• Yönetilen dilde karşılığı: ProGuard/R8 ad gizleme + ölü kod eleme + küçültme
• -keep ve reflection ile çağrılan API'ler

İki taraf birlikte çalışır

• Java tarafı R8 ile gizlenir
• Native taraf bu haftanın kurallarıyla
• Çapraz denetim: native Java'nın bütünlüğünü, Java native'in sağlamasını denetler (6. hafta RASP)

Bölüm 4 — özet

• K-07 dize kodlama · K-08 opak boolean · K-09 değişken bölme
• K-10 sanallaştırma (pahalı) · K-11 derleyici (O-LLVM) · K-12 dinamik (riskli)

Veri gizleme, kontrol akışı gizlemeyi tamamlar.

Bölüm 4 — kısa sınama

1. Dize gizleme anahtarı korur mu?
2. Opak boolean neden tek-bayt yamayı zorlaştırır?
3. Sanallaştırmanın iki büyük maliyeti?

Çeşitlendirme — şema

Çeşitlendirme: Kural 2'yi hatırla

Bir kopyada işe yarayan saldırı, bütün kopyalarda işe yaramasın.

Saldırgan bir kopyayı kırıp yamayı/betiği herkese dağıtabiliyorsa, bir kırık her yeri açar.

Çeşitlendirme nedir?

Aynı kaynaktan davranışça eş, yapıca farklı binary dosyalar üretmek.

Opak yüklemler, sahte bloklar, durum değerleri kopyadan kopyaya değişir.

İki tür çeşitlendirme

• Uzayda: her yapı/dağıtım farklı tohumla
  • Bir kopyaya yazılan saldırı diğerinde çalışmaz
• Zamanda: her sürüm yeni düzenle
  • Eski sürüme yazılan saldırı yeni sürümde bozulur

10. haftadaki anahtar/sürüm yenilemeyle birlikte çalışır.

Çeşitlendirme neyi engeller?

• Gizlemenin gücünü artırmaz (bir kopyayı kırmak yine mümkün)
• Ama ölçeklenmesini engeller

14. hafta: Tigress --Seed, RandomFuns ile araçla.

Çeşitlendirme etkinliği: basit ölçüt

• Aynı kaynağı iki farklı tohumla derle
• Korunan fonksiyonların bayt farkını ölç
• Fark ne kadar yüksekse, bir saldırının diğerinde çalışma olasılığı o kadar düşük

Ölçütü S9'a yaz.

Animasyon · Çeşitlendirme

Animasyon · Çeşitlendirme — uç durum (uzunluk hiç uymuyor)

Neden ölçmek?

Bir koruma kararını savunmak için.

Collberg'in çerçevesi: dört boyut.

Bu dördü 13. haftadaki saldırı potansiyeli puanlamasının temeli.

Ölçüt 1 — Güç (potency)

Soru: insana ne kadar anlaşılmaz?

Nasıl: karmaşıklık ölçütleri — CFG düğüm/kenar, çevrimsel karmaşıklık, iç içe geçme derinliği (önce/sonra).

Ölçüt 2 — Dayanıklılık (resilience)

Soru: otomatik araca ne kadar dayanır?

Nasıl: bir deobfuscation aracının (sembolik yürütme, sadeleştirici) korumayı geri açma süresi/başarısı.

Ölçüt 3 — Gizlilik (stealth)

Soru: gizleme kendini ele veriyor mu?

Nasıl: gizlenmiş kod normal koddan istatistiksel ayırt edilebiliyor mu?

Ayırt edilirse saldırgan nereye bakacağını bilir.

Ölçüt 4 — Maliyet (cost)

Soru: bize ne kadara mal oluyor?

Nasıl: boyut artışı, çalışma süresi, bellek, bakım, hata ayıklama zorluğu.

Düzleştirme öncesi (kavram)

Az düğüm, okunur akış.

Düzleştirme sonrası (kavram)

Çok düğüm, tek merkez; "sonra hangi blok" okunmaz.

Maliyet ölçümü örneği

size ./program_clean ./program_obfuscated   # boyut
# süre: aynı girdiyle N kez çalıştır, ortalama

Ölçümü yorumlamak

• Güç ↑ (34 blok) ve maliyet ↑ (%28 boyut, 1.7× süre)
• Bu ödünleşim beklenir
• Karar: kazanç, varlık değerine göre kabul edilebilir mi?

"Güçlü" deme; bu sayıları göster.

Animasyon · Gizlemenin ölçülmesi

Animasyon · Ölçüm — uç durum (en pahalı yol)

Karar kuralı (S9'a yazılır)

Neden karşı tarafın araçlarını bilmeliyiz?

Dayanıklılığı doğru ölçmek için.

Bunları savunmayı sınamak için öğreniriz — saldırı için değil.

Karşı tarafın araçları — şema

Araç 1 — sembolik yürütme (KLEE)

• Program yolları matematiksel kısıt olarak çözülür
• Opak yüklem ve düzleştirme bu yolla açılabilir

Dayanıklılık kuralı: opak yüklemleri çözmesi pahalı (çarpanlara ayırma, karma) yapılara bağla, durum uzayını büyüt — ama maliyeti ölç.

Animasyon · Deobfuscation

Animasyon · Deobfuscation — uç durum (sıralı çift/tek)

Araç 2 — MBA sadeleştirici

• Aritmetik kodlamayı (K-02) açar

• Karşı önlem: kodlanmış sabitleri de opak yüklemlere bağla — birbirine bağlı katmanları ayrı ayrı çözmek zorlaşır

Kural: aritmetik kodlamayı tek başına bir sır katmanı sayma; kontrol akışıyla birleştir.

Araç 3 — kalıp tanıma

• Bilinen kütüphane/geçiş kalıplarını tanır

Kural: çeşitlendir; tek bir opak yüklem kalıbına ya da tek VM tasarımına bağlı kalma.

(uzayda: birden çok kalıp/tohum · zamanda: her sürümde kalıpları değiştir)

Ana çıkarım

Banescu vd. (Tigress + KLEE): hangi dönüşüm sembolik yürütmeye ne kadar dayanıyor, ölçülür.

Dayanıklılık bir iddia değil, ölçülen bir niceliktir.

"Güçlü" deme; bir sayı üret: "şu dönüşüm hattı, şu araca karşı, şu boyutta bir problemi şu sürede çözdürmedi."

Katmanlı savunmada gizleme — şema

Sahadan bir gözlem

Sertifikalı üründe native önlemler bu haftanın kurallarının tümünü kapsar.

Ama belge her önlemin yanına: "tek başına güçlü değildir."

Değerlendiriciyi ikna eden: birliktelik + çeşitlendirme + ölçülmüş geciktirme.

Bu örneğin amacı

Tek bir sentetik denetimi (grant_access) alıp katman katman koruyacağız.

Her adımda: ne eklendi · ne kazandık · ne ödedik.

Adım 0 · Korumasız başlangıç

int grant_access(const char *token) {
    if (token_valid(token))
        return GRANTED;      /* single branch, single return */
    return DENIED;
}

Zayıflık: tek dal, strings, tek bayt yamasıyla atlanır.

Adım 0 · Saldırgan ne yapar?

• strings → GRANTED/DENIED ve ilgili dizeler
• Tersine derle → tek if, iki dönüş
• Başarısızlık dalını başarıya çevir (tek bayt)

Süre: dakikalar. Uzmanlık: düşük.

Adım 1 · K-07 dize/sabit kodla

/* GRANTED/DENIED and strings no longer appear in plain text */
static int grant_code(void){ return 0x9E ^ 0x9F; } /* =1 */

• Kazanç: strings hassas metni bulmaz
• Maliyet: çok düşük

Adım 1 · Ölçüm

İlk katman en ucuz, en yüksek getiri.

Adım 2 · K-02 aritmetik kodla

/* comparison turns into a complex but equivalent expression */
int threshold = ((a ^ b) + 2*(a & b));   /* = a + b */

• Kazanç: sabit/hesap doğrudan okunmaz
• Maliyet: düşük

Adım 3 · K-04 düzleştir

int state = START;
for(;;) switch(state){
  case START: state = check()?STEP:FAIL; break;
  case STEP:  state = DONE; break;
  case FAIL:  return DENIED;
  case DONE: return GRANTED;
}

Tek if yok; sıra durum değişkeninde.

Adım 3 · Ne değişti?

• CFG artık "yatay" — bloklar tek switch'te
• "Hangi dal başarı" doğrudan okunmaz
• Maliyet: orta (blok/dal artar, biraz yavaşlar)

Adım 4 · K-05 rastgele çıkış

if (!check()) { state = unpredictable_value(); break; } /* →default */

• Hata nerede yakalandı, akıştan okunmaz
• Tek bayt yaması artık yetmez

Adım 5 · K-03 sahte + ölü

crc ^= (s ^ s);            /* bogus operation: result unchanged */
if (opaque_false()) fake(); /* dead branch: never runs */

• Gerçek mantık kalabalık içinde
• Maliyet: orta

Adım 6 · K-08 opak boolean

Decision k = allow();               /* a^b==0xFFFF */
if (decision_grants(k)) apply();

• Sonuç düz 0/1 değil → tek bayt çeviremez
• Çevirmek için birden çok nokta gerekir

Adım 7 · K-10 sanallaştırma?

• Yalnız en kritik fonksiyon için
• Maliyet: yüksek (onlarca kat yavaş)
• Çoğu denetim için gereksiz

Kural: değeri düşükse buraya gelme.

Uçtan uca: çıkarım

• Her katman saldırıyı biraz daha pahalı yaptı
• Her katman bir maliyet ekledi
• Nerede durduğun varlığın değerine ve ölçtüğüne bağlı

Bu tablo, S9'a koyacağın koruma tablosunun ta kendisidir.

Proje · S9 (ileri sağlamlaştırma) — 1

1. Koruma tablosu

2–3 kritik bölüm için (lisans, anahtar türetme, bütünlük) kural şablonunu doldur:

neyi korur · tehdit · nasıl · maliyet · sınır · ölçüm

Proje · S9 — 2

2. Ölçüm

En az bir teknik için önce/sonra:

• strings çıktısındaki hassas dize sayısı
• CFG düğüm sayısı
• binary boyut, bir işlemin süresi

Proje · S9 — 3, 4

3. Çeşitlendirme kararı: evet/hayır + gerekçe

4. Sınır ve kalan risk: her koruma neyi korumaz?

"Bu dize gizleme anahtarı korumaz; anahtar için S8 whitebox/donanım."

İleride: S15 (14. hafta, gizlemeyi derleme hattına koymak) · S16 (12. hafta, davranışın bozulmadığının testi).

Değerlendirici gözüyle

S9'da aranan: "çok teknik kullandım" değil.

Aranan: her tekniğin gerekçesi ve ölçüsü.

Ölçülmemiş koruma = iddia. Kanıt değil.

Kaynaklar

• Cookbook (Viega & Messier) Bölüm 12 — anti-tampering
• Güvenli programlama teknik kılavuzu — native karşı önlemler
• Collberg & Nagra, Surreptitious Software — taksonomi, ölçme
• Schrittwieser vd. (ACM CSUR 2016) — genel bakış, deobfuscation
• Banescu vd. — Tigress + KLEE dayanıklılık ölçümü
• Obfuscator-LLVM — derleyici tabanlı