Protokol Ayrıştırıcıları Neden İlk Kırılan Kod: Uzunluk Alanları, Tamsayı Taşması ve Fuzzing
Bir cihazın dış dünyayla ilk temas ettiği kod, gelen baytları anlamlandıran ayrıştırıcıdır. Kimlik doğrulamadan önce çalışır, güvenilmeyen veriyi işler ve çoğu zaman C ile yazılmıştır. Zafiyetlerin orada birikmesi tesadüf değil.

İçindekiler
- Ayrıştırıcı neden özel
- Hata 1: uzunluk alanına güvenmek
- Hata 2: tamsayı aritmetiği
- Hata 3: durum ve sıra
- Hata 4: iki ayrıştırıcı, iki yorum
- Dayanıklı bir ayrıştırıcı nasıl yazılır
- Bir örnek: Modbus “birden fazla yazmaç yaz” isteği
- Metin tabanlı protokoller de muaf değil
- Genel ilkeler
- Fuzzing: hatayı saldırgandan önce bulmak
- Savunma tarafı
- Adli bilişim açısı
- Kapanış
Gömülü cihazlardaki ciddi zafiyetlerin listesine baktığında bir desen görürsün. 2019’da VxWorks’ün ağ yığınında bulunan URGENT/11, 2020’de çok sayıda üreticinin cihazını etkileyen Ripple20 ve AMNESIA:33, 2021’de DNS işleme kodlarındaki NAME:WRECK. Hepsi farklı üreticilerin farklı kodlarında, ama hepsi aynı tür yerde: ağdan gelen paketi ayrıştıran kodda.
Bunun bir nedeni var. Ayrıştırıcı (parser), cihazın güvenilmeyen veriyle karşılaştığı ilk koddur. Paket kimden gelirse gelsin, kimlik doğrulama yapılmadan önce birinin o baytları okuyup “bu bir başlık, bu bir uzunluk, bu bir veri” demesi gerekir. O kod hata yaparsa, saldırganın ne parolaya ne de yetkiye ihtiyacı kalır.
Önceki yazıda tampon taşmasının bir mikrodenetleyicide nasıl göründüğünü inceledik. Bu yazıda bir adım geri gidip o taşmaların en sık doğduğu yere bakacağız: protokol ayrıştırıcılarındaki klasik hatalara, bunlardan kaçınan kodun nasıl yazıldığına ve hataları saldırgandan önce bulmanın en etkili yolu olan fuzzing’e.
Ayrıştırıcı neden özel
Bir firmware’in büyük kısmı kendi ürettiği veriyle çalışır: sensör okur, hesap yapar, çıkış sürer. Bu kodun girdileri sınırlıdır ve geliştirici ne geleceğini bilir. Ayrıştırıcı ise tek istisnadır; girdisini başkası belirler.
Üç özellik onu kırılgan yapar:
- Kimlik doğrulamadan önce çalışır. TLS el sıkışmasını, MQTT bağlantı paketini ya da Modbus isteğini anlamak için önce ayrıştırmak gerekir. Buradaki bir hata, hiçbir yetkisi olmayan birine açıktır.
- Karmaşıktır. Protokoller isteğe bağlı alanlar, değişken uzunluklar, iç içe yapılar ve sürüm farklarıyla doludur. Her dal ayrı bir hata fırsatıdır.
- Yalnızca “iyi” girdiyle test edilir. Geliştirici kodu, kendi yazdığı ve protokole uyan karşı tarafla dener. Bozuk girdi yolları genellikle hiç çalıştırılmamıştır.
Bu üçüne, gömülü tarafta kodun C ile yazılması ve önceki yazıda gördüğümüz korumaların çoğunun bulunmaması eklenir.
Hata 1: uzunluk alanına güvenmek
İkili protokollerin çoğu aynı kalıbı kullanır: önce bir uzunluk alanı, ardından o kadar bayt veri. Ayrıştırıcının elinde iki ayrı bilgi vardır: paketin kendi beyan ettiği uzunluk ve gerçekte alınan bayt sayısı. Hataların büyük kısmı bu ikisinin aynı olduğunu varsaymaktan doğar.
Bu hatanın en ünlü örneği gömülü değil ama öğretici: 2014’teki Heartbleed. TLS’nin “kalp atışı” mesajında istemci bir veri ve o verinin uzunluğunu gönderir, sunucu aynı veriyi geri yollar. OpenSSL, beyan edilen uzunluğu gerçekte gelen veriyle karşılaştırmıyordu. İstemci 1 bayt gönderip “64 kilobayt gönderdim” dediğinde, sunucu belleğinden 64 kilobaytı okuyup geri yolluyordu; buna özel anahtarlar ve parolalar da dahildi.
Aynı kalıp endüstriyel protokollerde her yerdedir. Modbus TCP başlığında bir uzunluk alanı bulunur. “Birden fazla yazmaç yaz” isteğinin içinde ayrıca kaç yazmaç (register) yazılacağı ve bunun kaç bayt tuttuğu ayrı ayrı belirtilir. Standart bu üç değerin birbiriyle tutarlı olmasını ister: bayt sayısı yazmaç sayısının iki katı olmalı, yazmaç sayısı 123’ü geçmemelidir. Ama standardın istemesi, gelen paketin buna uyduğu anlamına gelmez. Ayrıştırıcı bu tutarlılığı kendisi denetlemezse, hangi değere güvendiğine göre ya tamponun dışını okur ya da dışına yazar.
MQTT’de durum biraz daha inceliklidir. “Kalan uzunluk” alanı değişken boyutludur: her baytın yedi biti değer, sekizinci biti “devamı var” işaretidir ve alan en fazla dört bayt olabilir. Devam bitini sınırsız izleyen bir ayrıştırıcı, beşinci ve altıncı baytı da okumaya devam eder. Dört baytlık üst sınırla 256 megabayta kadar uzunluk beyan edilebilir; birkaç kilobayt RAM’i olan bir cihazda bu değeri sorgulamadan tampon ayırmaya ya da veri beklemeye çalışmak, başlı başına bir hizmet engelleme yoludur (bkz. MQTT güvenliği).

Kural basit: beyan edilen her uzunluk üç şeyle karşılaştırılır. Elde gerçekten o kadar bayt var mı? Hedef tampon o kadarını alır mı? Protokolün izin verdiği en büyük değerin altında mı?
Hata 2: tamsayı aritmetiği
Uzunluk denetimi yazılmış olsa bile, denetimin kendisi aritmetik hatalar yüzünden boşa çıkabilir. Gömülü kodda küçük tamsayı tipleri sık kullanıldığı için bu hatalar özellikle yaygındır.
Sarma (wraparound). İşaretsiz bir tamsayı en büyük değerini aştığında sıfırdan devam eder:
uint8_t baslik = 6;
uint8_t veri_uzunlugu = cerceve[2]; /* saldırgan: 250 */
uint8_t toplam = baslik + veri_uzunlugu; /* 256 → 0 */
if (toplam <= sizeof(tampon)) { /* 0 <= 64, geçer */
memcpy(tampon, cerceve, baslik + veri_uzunlugu); /* 256 bayt kopyalar */
}
Denetim toplam üzerinden yapılıyor ve o değer sekiz bite sığmadığı için sıfıra dönmüş. Kopyalama ise ifadeyi yeniden hesaplıyor; C’nin tip yükseltme kuralları gereği bu kez sonuç 256.
Alttan taşma. Çıkarma işlemleri daha da sinsidir:
uint16_t yuk_uzunlugu = cerceve_uzunlugu - BASLIK_BOYUTU;
Çerçeve başlıktan kısaysa sonuç negatif olmaz; işaretsiz tipte 65 bine yakın bir değere sarar. Ardından gelen kopyalama bu değeri kullanır.
İşaret karışıklığı. Uzunluk işaretli bir tipte tutuluyorsa, negatif bir değer “en büyük boyuttan küçük mü” denetimini rahatça geçer. Sonra boyut bekleyen bir fonksiyona verildiğinde işaretsize çevrilir ve devasa bir sayıya dönüşür.
| Hata | Örnek | Sonuç |
|---|---|---|
| Sarma | 8 bitlik değişkende 6 + 250 |
0 |
| Alttan taşma | 16 bitlik işaretsiz değişkende 3 - 6 |
65533 |
| İşaret karışıklığı | -1 değeri boyut olarak kullanılır |
Tipin alabileceği en büyük değer |
Bu üçünün ortak çözümü şudur: uzunlukları her zaman işaretsiz ve yeterince geniş bir tipte tut, toplama ve çıkarmadan önce sonucun sığıp sığmayacağını denetle ve denetimi yaptığın değerle işlemi yaptığın değerin aynı değişken olduğundan emin ol. Çıkarmadan önce “çerçeve başlıktan uzun mu” diye sormak tek satırdır.
Hata 3: durum ve sıra
Her hata bellekle ilgili değildir. Protokoller bir sıra tanımlar: önce bağlantı, sonra kimlik doğrulama, sonra komutlar. Ayrıştırıcı her mesajı tek başına doğru işlese bile, mesajların beklenen sırayla geleceğini varsayıyorsa bir açık bırakmış olur.
Tipik örnekler:
- Kimlik doğrulama tamamlanmadan gönderilen bir komut mesajının işlenmesi.
- Bir aktarımın “başla” mesajı gelmeden “veri” mesajının kabul edilmesi ve henüz ayrılmamış bir tampona yazılması.
- Aynı “başla” mesajının iki kez gönderilmesiyle ilk tamponun sızdırılması ya da boyutların karışması.
- Parçalı bir mesajın son parçasının hiç gelmemesi ve ayrılan belleğin sonsuza kadar tutulması.
Şarj istasyonu protokollerinde bunun karşılığı, istasyonun kendini sunucuya tanıtıp kabul almadan önce gelen mesajlara nasıl davrandığıdır (bkz. OCPP 2.0.1’in güvenlik modeli). Savunması, durumu açık bir durum makinesi olarak yazmak ve her durumda yalnızca o durumda geçerli olan mesajları kabul etmektir. Geri kalan her şey reddedilir ve sayılır.
Hata 4: iki ayrıştırıcı, iki yorum
Dördüncü hata sınıfı tek bir kodda değil, iki kod arasındaki farkta yaşar. Aynı bayt dizisini iki farklı ayrıştırıcı iki farklı biçimde yorumlayabilir. Biri fazladan baytları yok sayar, diğeri reddeder. Biri tekrarlanan bir alanın ilkini alır, diğeri sonuncusunu.
Bu, arada bir güvenlik cihazı olduğunda önem kazanır. Saldırı tespit sistemi ya da protokolü tanıyan bir güvenlik duvarı paketi bir biçimde yorumlayıp zararsız bulur; arkasındaki cihaz aynı paketi başka biçimde yorumlayıp komutu çalıştırır. Bu konu, bir sonraki yazıda ele alacağımız adli bilişim araçları için de geçerlidir: analiz aracının gösterdiği ile cihazın gerçekte anladığı aynı olmayabilir.
Savunması katılıktır. Protokole tam uymayan girdiyi “düzeltmeye” ya da “elinden geleni yapmaya” çalışan ayrıştırıcı, yorum farklarının kaynağıdır. Uymayan girdi reddedilmelidir.
Dayanıklı bir ayrıştırıcı nasıl yazılır
Yukarıdaki hataların çoğu, tek bir tasarım kararıyla önlenebilir: ham tampona doğrudan indeksle erişmek yerine, kalan bayt sayısını takip eden küçük bir okuyucu kullanmak.
typedef struct {
const uint8_t *veri;
size_t kalan;
} okuyucu_t;
static bool oku_u8(okuyucu_t *o, uint8_t *cikti)
{
if (o->kalan < 1) return false;
*cikti = o->veri[0];
o->veri += 1;
o->kalan -= 1;
return true;
}
static bool oku_u16(okuyucu_t *o, uint16_t *cikti) /* büyük uçlu */
{
if (o->kalan < 2) return false;
*cikti = (uint16_t)((o->veri[0] << 8) | o->veri[1]);
o->veri += 2;
o->kalan -= 2;
return true;
}
static bool oku_bayt(okuyucu_t *o, uint8_t *hedef, size_t hedef_boyut, size_t n)
{
if (n > o->kalan || n > hedef_boyut) return false;
memcpy(hedef, o->veri, n);
o->veri += n;
o->kalan -= n;
return true;
}
Bütün okuma bu fonksiyonlardan geçtiğinde, sınır denetimi tek bir yerde yazılmış ve unutulması imkânsız hâle gelmiş olur. Ayrıştırıcının geri kalanı “oku, başarısızsa çık” satırlarından oluşur.
Bir örnek: Modbus “birden fazla yazmaç yaz” isteği
Bu okuyucuyla, yukarıda bahsettiğim Modbus isteğinin nasıl ayrıştırılacağına bakalım. İstek sırasıyla şunları içerir: bir baytlık fonksiyon kodu, iki baytlık başlangıç adresi, iki baytlık yazmaç sayısı, bir baytlık bayt sayısı ve ardından yazmaç değerleri. Fonksiyon kodunun çağıran tarafından okunduğunu varsayalım:
#define AZAMI_YAZMAC 123
bool coklu_yazma_ayristir(okuyucu_t *o, yazma_istegi_t *istek)
{
uint8_t bayt_sayisi;
if (!oku_u16(o, &istek->adres)) return false;
if (!oku_u16(o, &istek->yazmac_sayisi)) return false;
if (!oku_u8(o, &bayt_sayisi)) return false;
if (istek->yazmac_sayisi == 0 ||
istek->yazmac_sayisi > AZAMI_YAZMAC) return false;
if (bayt_sayisi != istek->yazmac_sayisi * 2) return false;
if (o->kalan != bayt_sayisi) return false;
if ((uint32_t)istek->adres + istek->yazmac_sayisi
> YAZMAC_TABLOSU_BOYUTU) return false;
return oku_bayt(o, istek->veri, sizeof(istek->veri), bayt_sayisi);
}
İstek yapısı ve tablo boyutu başka yerde tanımlı. Dört denetimin her biri ayrı bir hatayı kapatır. İlki yazmaç sayısını protokolün sınırına bağlar. İkincisi paketin kendi içindeki iki uzunluk beyanının tutarlı olmasını ister. Üçüncüsü beyan edilen uzunluğu gerçekte gelen veriyle karşılaştırır; ne eksik ne fazla bayt kabul edilir. Dördüncüsü isteğin cihazın yazmaç tablosunun dışına taşmadığını doğrular ve toplamayı daha geniş bir tipte yaparak sarma olasılığını ortadan kaldırır.
Bu denetimlerden herhangi biri eksik olduğunda kod, protokole uyan bütün isteklerde yine doğru çalışır. Fark yalnızca uymayan istekte ortaya çıkar; o isteği de test sırasında kimse göndermez.
Metin tabanlı protokoller de muaf değil
Buraya kadarki örnekler ikili protokollerdendi, ama JSON ya da XML taşıyan protokoller aynı sorunların başka biçimlerini yaşar. OCPP gibi JSON tabanlı bir protokolü küçük bir cihazda ayrıştırırken dikkat edilecekler:
- Derinlik. İç içe binlerce köşeli parantez içeren bir mesaj, özyinelemeli bir ayrıştırıcıda yığını tüketir.
- Boyut. Tek bir dizgi alanı megabaytlarca olabilir. Alan başına ve mesaj başına üst sınır gerekir.
- Sayılar. JSON sayılarının üst sınırı yoktur. 32 bitlik bir değişkene sığmayan değer ayrıştırılırken sarabilir ya da kırpılabilir.
- Tekrarlanan anahtarlar. Aynı anahtar iki kez geçtiğinde hangisinin geçerli olacağı ayrıştırıcıya göre değişir; iki sistem aynı mesajı farklı okuyabilir.
- Tip varsayımı. Sayı beklenen yerde dizgi, nesne beklenen yerde dizi gelebilir. Tipi denetlemeden değeri kullanmak, C’de tanımsız davranışa kadar gider.
Hazır bir JSON kütüphanesi kullanmak sözdizimi hatalarını çözer, ama bu denetimlerin çoğu yine uygulama kodunda kalır.
Genel ilkeler
İkili ya da metin tabanlı, her ayrıştırıcı için geçerli birkaç ilke:
- Önce tamamını ayrıştır, sonra işle. Mesajın yarısını işleyip ikinci yarısında hata bulmak, cihazı yarım bir durumda bırakır. Mesaj baştan sona geçerli bulunmadan hiçbir durum değişmemeli.
- Her alan için üst sınır tanımla. Protokolün izin verdiği en büyük değer değil, senin cihazının desteklediği en büyük değer.
- Reddet, düzeltme. Tutarsız uzunluk, bilinmeyen tip, fazladan bayt: hepsi ret nedeni.
- Reddedileni say. Hata sayaçları hem hata ayıklamada hem de saldırı tespitinde işe yarar.
- Mümkünse elle yazma. Protokol tanımından ayrıştırıcı üreten araçlar ve gömülü sistemler için yazılmış küçük serileştirme kütüphaneleri, elle yazılmış ayrıştırıcıların düştüğü tuzakların çoğunu baştan eler.
Fuzzing: hatayı saldırgandan önce bulmak
Dikkatli yazmak yetmez, çünkü ayrıştırıcı hataları tam da geliştiricinin aklına gelmeyen girdilerde saklanır. Fuzzing bu sorunu kaba kuvvetle çözer: koda otomatik üretilmiş milyonlarca bozuk girdi verir ve çöküp çökmediğine bakar.
Modern fuzzer’lar rastgele bayt üretmekle yetinmez. Kodun hangi dallarının çalıştığını izler, yeni bir dala ulaşan girdiyi saklar ve onu değiştirerek devam eder. Böylece birkaç geçerli örnek mesajdan başlayıp ayrıştırıcının derin köşelerine kendi kendine ulaşır. Buna kapsam güdümlü fuzzing denir; AFL++ ve libFuzzer en yaygın araçlardır.

Gömülü kod için kritik adım, ayrıştırıcıyı donanımdan ayırmaktır. Ayrıştırıcı bir bayt dizisi alıp bir sonuç döndüren saf bir fonksiyon olarak yazıldıysa, masaüstünde derlenip saniyede on binlerce girdiyle sınanabilir. Gereken bağlama kodu birkaç satırdır:
#include <stdint.h>
#include <stddef.h>
#include "modbus_ayristirici.h"
int LLVMFuzzerTestOneInput(const uint8_t *veri, size_t boyut)
{
modbus_istek_t istek;
modbus_ayristir(veri, boyut, &istek);
return 0;
}
clang -g -O1 -fsanitize=fuzzer,address,undefined \
fuzz_modbus.c modbus_ayristirici.c -o fuzz_modbus
./fuzz_modbus ornek_girdiler/
Buradaki -fsanitize seçenekleri işin yarısıdır. Bir tampon dışı okuma her zaman çökmeye yol açmaz; adres denetleyicisi (AddressSanitizer) her bellek erişimini izler ve tek baytlık bir taşmayı bile anında yakalar. Tanımsız davranış denetleyicisi işaretli tamsayı taşmalarını ve geçersiz kaydırmaları bildirir. Bir ayrıntı: işaretsiz sarma C’de tanımlı bir davranış olduğu için varsayılan olarak hata sayılmaz; Clang’de bunu ayrıca açmak gerekir.
Pratikte işe yarayan birkaç şey:
- Başlangıç örnekleri gerçek trafikten gelsin. Daha önce kaydedilmiş bir ağ trafiğinden çıkarılan geçerli mesajlar, fuzzer’ın protokolün yapısını çok daha hızlı keşfetmesini sağlar.
- Sağlama toplamlarını devre dışı bırak. Fuzzer geçerli bir CRC üretemez ve bütün girdileri ilk denetimde elenir. Test derlemesinde denetimi atla ya da bağlama kodunda CRC’yi sen hesapla.
- Durumlu protokollerde mesaj dizisi ver. Tek mesaj yerine, girdiyi birkaç mesaja bölüp sırayla ayrıştırıcıya gönderen bir bağlama kodu, sıra hatalarını da ortaya çıkarır.
- Sürekli çalıştır. Fuzzing bir kez yapılan bir test değildir. Bulunan her çökme girdisi regresyon testine eklenir ve fuzzer her kod değişikliğinde yeniden çalıştırılır.
Donanıma sıkı bağlı, ayrılamayan kodlar için öykünücü üzerinde ya da doğrudan cihaz üzerinde fuzzing mümkündür ama çok daha yavaştır ve çökmeyi tespit etmek zordur. Ayrıştırıcıyı baştan donanımdan bağımsız yazmak, hem test edilebilirlik hem de güvenlik açısından en ucuz yatırımdır.
Savunma tarafı
- Beyan edilen uzunluğu üç şeyle karşılaştır: eldeki bayt sayısı, hedef tamponun boyutu, senin belirlediğin üst sınır.
- Uzunluk aritmetiğini geniş ve işaretsiz tiplerle yap, çıkarmadan önce büyüklüğü denetle.
- Ham indeks yerine sınır denetimli okuyucu kullan.
- Protokol durumunu açık bir durum makinesiyle yönet, sırası gelmemiş mesajı reddet.
- Uymayan girdiyi düzeltmeye çalışma, reddet ve say.
- Ayrıştırıcıyı donanımdan ayır ve sürekli fuzz et.
- Kullandığın hazır ağ yığınının güvenlik duyurularını izle. Başta saydığım zafiyet ailelerinin hepsi, üreticilerin kendi yazmadığı, hazır aldığı bileşenlerdeydi. Cihazında hangi yığının hangi sürümünün çalıştığını bilmek, bir duyuru çıktığında etkilenip etkilenmediğini söyleyebilmenin ön şartıdır.
Adli bilişim açısı
Ayrıştırıcı hataları, inceleme tarafında üç biçimde karşına çıkar.
Bozuk çerçeve bir izdir. Bir ağ kaydında protokole uymayan mesajlar görmek, birinin ayrıştırıcıyı yokladığına işaret edebilir: beyan edilen uzunluğu gerçek boyutuyla tutmayan paketler, izin verilen sınırı aşan alan değerleri, sırası gelmeden gönderilen komutlar, küçük farklarla tekrarlanan denemeler. Fuzzing yapan bir saldırganın trafiği, normal bir cihazın trafiğinden kolayca ayırt edilir. Arızalı bir cihaz da bozuk çerçeve üretir, ama onunki rastgeledir; yoklama ise sistematiktir.
Çökme ile trafik birlikte okunur. Cihazın yeniden başladığı an ile o andan hemen önce gelen mesaj yan yana konduğunda, tetikleyici girdi çoğu zaman doğrudan görünür. Bu yüzden OT ağlarında pasif trafik kaydı, yalnızca kimliksiz protokoller için değil, bu tür olaylar için de temel delildir (bkz. bir SCADA/PLC ağında ne loglanır).
Analiz aracına körü körüne güvenme. Trafiği incelediğin araç da bir ayrıştırıcıdır ve cihazdakiyle aynı kararları vermeyebilir. Araç bir paketi “bozuk” diye işaretleyip içeriğini göstermiyorsa, cihaz o paketi işlemiş olabilir. Şüpheli çerçevelerde ham baytlara bakmak ve cihazın gerçek davranışını firmware’den ya da testle doğrulamak gerekir. Raporda da “araç şunu gösterdi” ile “cihaz şunu yaptı” ayrımı korunmalıdır.
Kapanış
Ayrıştırıcı, cihazın güvenilmeyen dünyayla arasındaki ilk ve çoğunlukla tek kapıdır. Oradaki hatalar kimlik doğrulamadan önce tetiklenir ve bu yüzden en değerli zafiyetlerdir. Hataların türleri ise şaşırtıcı derecede sınırlıdır: beyan edilen uzunluğa güvenmek, tamsayı aritmetiğini denetlememek, mesaj sırasını varsaymak ve uymayan girdiyi hoş görmek.
Bunların hepsi bilinen yöntemlerle önlenebilir. Sınır denetimli bir okuyucu, açık bir durum makinesi, katı bir ret politikası ve sürekli çalışan bir fuzzer, saldırganın bulacağı hataların çoğunu ondan önce bulur.
Bu içerik eğitim amaçlıdır.