From e87b730a7b4952afc7c0779a125b8dd27e748797 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 29 Sep 2025 09:00:06 +0000 Subject: [PATCH] Translated ['', 'src/binary-exploitation/ios-exploiting/ios-physical-uaf --- .../ios-physical-uaf-iosurface.md | 132 +++++++++--------- 1 file changed, 66 insertions(+), 66 deletions(-) diff --git a/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md index 26a5fa568..08c4b7eaa 100644 --- a/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md +++ b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md @@ -1,99 +1,99 @@ -# iOS Physical Use-After-Free via IOSurface +# iOS Physical Use After Free via IOSurface {{#include ../../banners/hacktricks-training.md}} ## Physical use-after-free -Bu, [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) adresindeki gönderiden alınmış bir özet olup, bu tekniği kullanan exploit hakkında daha fazla bilgi için [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) adresine bakabilirsiniz. +Bu, [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) adresindeki gönderiden bir özet olup, bu teknikle ilgili daha fazla bilgiye [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) üzerinden ulaşılabilir. -### XNU'da Bellek Yönetimi +### XNU'de Bellek Yönetimi -iOS'taki kullanıcı süreçleri için **sanal bellek adres alanı** **0x0 ile 0x8000000000** arasını kapsar. Ancak bu adresler doğrudan fiziksel belleğe karşılık gelmez. Bunun yerine **kernel**, sanal adresleri gerçek **fiziksel adreslere** çevirmek için **sayfa tabloları** kullanır. +iOS'teki kullanıcı süreçleri için sanal bellek adres uzayı **0x0 ile 0x8000000000** arasındadır. Ancak bu adresler doğrudan fiziksel belleğe eşlenmez. Bunun yerine **kernel**, sanal adresleri gerçek **fiziksel adreslere** çevirmek için **sayfa tabloları** kullanır. -#### iOS'ta Sayfa Tablolarının Seviyeleri +#### iOS'te Sayfa Tablosu Seviyeleri -Sayfa tabloları hiyerarşik olarak üç seviyede düzenlenmiştir: +Sayfa tabloları hiyerarşik olarak üç seviyede düzenlenir: 1. **L1 Page Table (Level 1)**: * Buradaki her giriş sanal belleğin büyük bir aralığını temsil eder. -* **0x1000000000 byte** (veya **256 GB**) sanal belleği kapsar. +* **0x1000000000 bytes** (veya **256 GB**) sanal belleği kapsar. 2. **L2 Page Table (Level 2)**: -* Buradaki bir giriş, daha küçük bir sanal bellek bölgesini, özellikle **0x2000000 byte** (32 MB) kapsar. -* Bir L1 girişi, tüm bölgeyi kendisi eşleyemiyorsa bir L2 tablosuna işaret edebilir. +* Buradaki bir giriş daha küçük bir sanal bellek bölgesini, spesifik olarak **0x2000000 bytes** (32 MB) temsil eder. +* Bir L1 girişi tüm bölgeyi kendi başına eşleyemiyorsa bir L2 tablosuna işaret edebilir. 3. **L3 Page Table (Level 3)**: -* En ince seviye budur; her giriş tek bir **4 KB** bellek sayfasını eşler. -* Daha ayrıntılı kontrol gerektiğinde bir L2 girişi bir L3 tablosuna işaret edebilir. +* En ince seviye budur; her giriş tek bir **4 KB** bellek sayfasını haritalar. +* Daha ayrıntılı kontrol gerektiğinde bir L2 girişi L3 tablosuna işaret edebilir. #### Sanalden Fiziksele Haritalama * **Direct Mapping (Block Mapping)**: -* Sayfa tablosundaki bazı girişler, sanal adreslerin bir aralığını bitişik bir fiziksel adres aralığına doğrudan **eşler** (kısayol gibi). + * Sayfa tablosundaki bazı girişler sanal adreslerin bir aralığını doğrudan fiziksel adreslerin bitişik bir aralığına eşler (kısayol gibi). * **Pointer to Child Page Table**: -* Daha ince kontrol gerektiğinde, bir seviyedeki bir giriş (ör. L1) bir alt seviye sayfa tablosuna (ör. L2) işaret edebilir. + * Daha ince kontrol gerekiyorsa, bir seviyedeki bir giriş (ör. L1) bir alt seviye sayfa tablosuna (ör. L2) işaret edebilir. -#### Sanal Adresin Haritalanmasına Örnek +#### Bir Sanal Adresin Haritalanması Örneği -Örneğin sanal adres **0x1000000000**'a erişmeye çalıştığınızı varsayalım: +Diyelim ki **0x1000000000** sanal adresine erişmeye çalıştınız: 1. **L1 Table**: -* kernel, bu sanal adrese karşılık gelen L1 sayfa tablosu girişini kontrol eder. Eğer bir **L2 sayfa tablosuna** işaret ediyorsa, o L2 tablosuna gider. +* Kernel bu sanal adrese karşılık gelen L1 girişini kontrol eder. Eğer bir **L2 page table** işaretçisine sahipse, o L2 tablosuna gider. 2. **L2 Table**: -* kernel daha ayrıntılı bir haritalama için L2 sayfa tablosunu denetler. Eğer bu giriş bir **L3 sayfa tablosuna** işaret ediyorsa, oraya ilerler. +* Kernel daha ayrıntılı bir eşleme için L2 sayfa tablosunu kontrol eder. Eğer bu giriş bir **L3 page table** işaret ediyorsa, oraya ilerler. 3. **L3 Table**: -* kernel son L3 girişini arar; bu giriş gerçek bellek sayfasının **fiziksel adresine** işaret eder. +* Kernel son L3 girişine bakar; bu giriş gerçek bellek sayfasının **fiziksel adresine** işaret eder. -#### Adres Haritalamaya Örnek +#### Adres Haritalama Örneği Eğer L2 tablosunun ilk indeksine fiziksel adres **0x800004000** yazarsanız: -* **0x1000000000** ile **0x1002000000** arasındaki sanal adresler, **0x800004000** ile **0x802004000** arasındaki fiziksel adreslere eşlenir. +* **0x1000000000** ile **0x1002000000** arasındaki sanal adresler **0x800004000** ile **0x802004000** arasındaki fiziksel adreslere eşlenir. * Bu, L2 seviyesinde bir **block mapping**'dir. -Alternatif olarak, eğer L2 girişi bir L3 tablosuna işaret ediyorsa: +Alternatif olarak, L2 girişi bir L3 tablosuna işaret ediyorsa: -* **0x1000000000 -> 0x1002000000** sanal adres aralığındaki her 4 KB sayfa, L3 tablosundaki bireysel girişlerle eşlenecektir. +* **0x1000000000 -> 0x1002000000** sanal adres aralığındaki her 4 KB sayfa, L3 tablosundaki bireysel girişler tarafından haritalanır. ### Physical use-after-free -Bir **physical use-after-free** (UAF) şu durumda ortaya çıkar: +Bir **physical use-after-free (UAF)** şu durumda oluşur: -1. Bir süreç belli bir belleği **okunabilir ve yazılabilir** olarak **ayırır** (allocate). -2. Bu belleğe süreç erişebilmesi için **sayfa tabloları**, bu belleği belirli bir fiziksel adrese eşleyecek şekilde güncellenir. -3. Süreç belleği **serbest bırakır** (deallocate/free). -4. Ancak bir **bug** nedeniyle kernel, ilgili fiziksel belleğin serbest olarak işaretlenmesine rağmen sayfa tablosundaki **eşlemeyi kaldırmayı unutabilir**. -5. kernel daha sonra bu "serbest" fiziksel belleği başka amaçlar için, örneğin **kernel verisi** için **yeniden ayırabilir**. -6. Eşleme kaldırılmadığı için süreç hala bu fiziksel belleği **okuyup yazabilir**. +1. Bir süreç belleği **okunabilir ve yazılabilir** olarak **ayırır**. +2. Bu belleği sürecin erişebileceği belirli bir fiziksel adrese eşlemek için **sayfa tabloları** güncellenir. +3. Süreç belleği **serbest bırakır (free)**. +4. Ancak bir **bug** nedeniyle kernel, ilgili fiziksel belleği serbest olarak işaretlese bile sayfa tablolarından bu **eşlemeyi kaldırmayı unutur**. +5. Kernel daha sonra bu "serbest" fiziksel belleği başka amaçlarla, örneğin **kernel verisi** için **yeniden ayırabilir**. +6. Eşleme kaldırılmadığı için süreç yine de bu fiziksel belleği **okuyup yazabilir**. -Bu, sürecin **kernel belleği sayfalarına** erişebilmesi anlamına gelir; bu sayfalar hassas veri veya yapılar içerebilir ve saldırganın **kernel belleğini manipüle etmesine** izin verebilir. +Bu, sürecin içinde bulunduğu sayfalar vasıtasıyla **kernel belleğine** erişebileceği anlamına gelir; bu bellek hassas veri veya yapılar içerebilir ve saldırganın **kernel belleğini manipüle etmesine** olanak sağlayabilir. ### IOSurface Heap Spray -Saldırgan, hangi kernel sayfalarının serbest kalan belleğe atanacağını kontrol edemediği için **heap spray** adı verilen bir teknik kullanır: +Saldırganın hangi spesifik kernel sayfalarının serbest belleğe atanacağını kontrol edememesi nedeniyle, bir teknik olan **heap spray** kullanılır: 1. Saldırgan kernel belleğinde çok sayıda **IOSurface** nesnesi oluşturur. -2. Her IOSurface nesnesi bir alanında kolayca tanımlanabilen bir **magic value** içerir. -3. Serbest bırakılmış sayfaları **tarayarak** bu IOSurface nesnelerinden herhangi birinin serbest sayfaya yerleşip yerleşmediğine bakarlar. -4. Bir serbest sayfada bir IOSurface nesnesi bulduklarında, bunu **kernel belleğini okumak ve yazmak** için kullanabilirler. +2. Her IOSurface nesnesi alanlarından birinde bir **magic value** içerir, bu da onları tanımlamayı kolaylaştırır. +3. Serbest bırakılan sayfaları tarayarak bu IOSurface nesnelerinden herhangi birinin serbest bir sayfaya yerleşip yerleşmediğine bakarlar. +4. Bir serbest sayfada bir IOSurface nesnesi bulduklarında, bunu kullanarak **kernel belleğini okuyup yazabilirler**. -Bu konuda daha fazla bilgi için [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) adresine bakın. +Bu konu hakkında daha fazla bilgi için bakınız: [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) > [!TIP] -> iOS 16+ (A12+) cihazlarının donanım tabanlı mitigasyonlar (PPL veya SPTM gibi) getirdiğini ve bunun fiziksel UAF tekniklerini büyük ölçüde daha az uygulanabilir hale getirdiğini unutmayın. -> PPL, kod imzalama, yetkiler ve hassas kernel verileriyle ilişkili sayfalar üzerinde sıkı MMU korumaları uygular; dolayısıyla bir sayfa yeniden kullanılsa bile userland'den veya ele geçirilmiş kernel kodundan PPL ile korunan sayfalara yazmalar engellenir. -> Secure Page Table Monitor (SPTM), PPL'yi sayfa tablosu güncellemelerini sertleştirerek genişletir. Bu, ayrıcalıklı kernel kodunun bile serbest bırakılmış sayfaları sessizce yeniden eşlemesine veya eşlemeleri kötüye kullanmasına izin vermeyen güvenli kontrollerden geçmesi gerektiğini sağlar. -> KTRR (Kernel Text Read-Only Region), kernel'in kod bölümünü boot sonrası salt okunur olarak kilitler. Bu, runtime sırasında kernel kodu üzerinde yapılacak değişiklikleri engelleyerek fiziksel UAF exploit'lerinin sıklıkla dayandığı önemli bir saldırı vektörünü kapatır. -> Ayrıca, `IOSurface` tahsisleri artık daha az öngörülebilir ve kullanıcı tarafından erişilebilir bölgelere eşlemek zor olduğundan, "magic value tarama" hilesi çok daha az güvenilir hale gelmiştir. Ve `IOSurface` artık entitlements ve sandbox kısıtlamaları ile korunmaktadır. +> iOS 16+ (A12+) cihazların donanımsal hafifletmeleri (PPL veya SPTM gibi) physical UAF tekniklerini büyük ölçüde daha az uygulanabilir hale getirdiğini unutmayın. +> PPL, code signing, entitlements ve hassas kernel verileriyle ilişkili sayfalara sıkı MMU korumaları uygular; bu yüzden bir sayfa yeniden kullanılsa bile userland veya ele geçirilmiş kernel kodundan PPL-korumalı sayfalara yapılan yazmalar engellenir. +> Secure Page Table Monitor (SPTM) PPL'yi sayfa tablosu güncellemelerini sertleştirerek genişletir. Bu, ayrıcalıklı kernel kodunun bile serbest bırakılmış sayfaları sessizce yeniden eşlememesini veya eşlemelerle oynamamasını sağlamak için güvenli kontroller gerektirir. +> KTRR (Kernel Text Read-Only Region), kernel'in kod bölümünü boot sonrası salt okunur hale kilitler. Bu, runtime'da kernel kodunun değiştirilmesini engelleyerek physical UAF exploitlerinin sıklıkla dayandığı büyük bir saldırı vektörünü kapatır. +> Ayrıca, `IOSurface` tahsisleri daha az öngörülebilir ve user-accessible bölgelere eşlemek daha zor hale geldi; bu da "magic value tarama" numarasını çok daha güvensiz kılar. Ve `IOSurface` artık entitlements ve sandbox kısıtlamaları ile korunur. -### Adım Adım Heap Spray Süreci +### Step-by-Step Heap Spray Process 1. **Spray IOSurface Objects**: Saldırgan özel bir tanımlayıcı ("magic value") ile çok sayıda IOSurface nesnesi oluşturur. -2. **Scan Freed Pages**: Oluşturulan nesnelerden herhangi birinin serbest bırakılmış bir sayfaya yerleşip yerleşmediğini kontrol ederler. -3. **Read/Write Kernel Memory**: IOSurface nesnesindeki alanları manipüle ederek, kernel belleğinde **keyfi okuma ve yazma** yapma yeteneği kazanırlar. Bu sayede: -* Bir alanı kernel belleğindeki herhangi bir 32-bit değeri **okumak** için kullanabilirler. -* Başka bir alanı 64-bit değerleri **yazmak** için kullanarak kararlı bir **kernel read/write primitive** elde edebilirler. +2. **Scan Freed Pages**: Nesnelerden herhangi birinin serbest bir sayfaya atanıp atanmadığını kontrol ederler. +3. **Read/Write Kernel Memory**: IOSurface nesnesindeki alanları manipüle ederek kernel belleğinde **keyfi okuma ve yazma** yeteneği kazanırlar. Bu onlara şunları sağlar: +* Bir alanı kullanarak kernel belleğindeki herhangi bir 32-bit değeri **okuyabilme**. +* Başka bir alanı kullanarak 64-bit değerleri **yazabilme**, böylece kararlı bir **kernel read/write primitive** elde etme. -Daha sonra aramak için IOSurface nesnelerini IOSURFACE\_MAGIC sihirli değeriyle oluşturun: +Generate IOSurface objects with the magic value IOSURFACE\_MAGIC to later search for: ```c void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { if (*nClients >= 0x4000) return; @@ -148,25 +148,25 @@ free(surfaceIDs); return 0; } ``` -### IOSurface ile Kernel Okuma/Yazma Elde Etme +### IOSurface ile Kernel Read/Write Elde Etme -Kernel belleğindeki bir IOSurface nesnesi üzerinde kontrol elde ettikten sonra (userspace'ten erişilebilen boşaltılmış bir fiziksel sayfaya eşlenmiş), bunu **arbitrary kernel read and write operations** için kullanabiliriz. +Kullanıcı alanından erişilebilen serbest bırakılmış bir fiziksel sayfaya eşlenmiş kernel belleğindeki bir IOSurface nesnesi üzerinde kontrol elde ettikten sonra, bunu **arbitrary kernel read and write operations** için kullanabiliriz. -**IOSurface İçindeki Ana Alanlar** +**Key Fields in IOSurface** IOSurface nesnesinin iki kritik alanı vardır: -1. **Use Count Pointer**: Bir **32-bit read** sağlar. -2. **Indexed Timestamp Pointer**: Bir **64-bit write** sağlar. +1. **Use Count Pointer**: Allows a **32-bit read**. +2. **Indexed Timestamp Pointer**: Allows a **64-bit write**. -Bu pointer'ları overwrite ederek bunları kernel memory içindeki arbitrary adreslere yönlendiririz ve böylece read/write yetenekleri elde ederiz. +Bu işaretçileri overwrite ederek, bunları kernel belleğindeki arbitrary adreslere yönlendirir ve read/write yeteneklerini mümkün kılabiliriz. -#### 32-Bit Kernel Okuma +#### 32-Bit Kernel Read -Bir okuma gerçekleştirmek için: +Okuma gerçekleştirmek için: -1. **use count pointer**'ı hedef adresin 0x14-byte offset eksiğine işaret edecek şekilde overwrite edin. -2. `get_use_count` metodunu kullanarak o adresteki değeri okuyun. +1. **use count pointer**'ı hedef adres eksi 0x14 bayt offsetine işaret edecek şekilde overwrite edin. +2. `get_use_count` methodunu kullanarak o adresteki değeri okuyun. ```c uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) { uint64_t args[1] = {surfaceID}; @@ -184,12 +184,12 @@ iosurface_set_use_count_pointer(info.object, orig); return value; } ``` -#### 64-Bit Kernel Write +#### 64-Bit Çekirdek Yazma -Bir yazma işlemi gerçekleştirmek için: +Yazma işlemini gerçekleştirmek için: -1. Hedef adrese **indexed timestamp pointer**'ı üzerine yazın. -2. `set_indexed_timestamp` yöntemini kullanarak 64-bit bir değer yazın. +1. Hedef adrese **indekslenmiş zaman damgası işaretçisini** yeniden yazın. +2. 64-bit bir değer yazmak için `set_indexed_timestamp` metodunu kullanın. ```c void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) { uint64_t args[3] = {surfaceID, 0, value}; @@ -203,13 +203,13 @@ set_indexed_timestamp(info.client, info.surface, value); iosurface_set_indexed_timestamp_pointer(info.object, orig); } ``` -#### Exploit Akışı Özeti +#### Exploit Flow Recap -1. **Trigger Physical Use-After-Free**: Boş sayfalar yeniden kullanım için uygun hale gelir. -2. **Spray IOSurface Objects**: Çekirdek bellekte benzersiz bir "magic value" ile çok sayıda IOSurface nesnesi ayırın. -3. **Identify Accessible IOSurface**: Kontrolünüzdeki serbest bırakılmış bir sayfada bir IOSurface bulun. -4. **Abuse Use-After-Free**: IOSurface nesnesindeki pointerları değiştirerek IOSurface yöntemleri aracılığıyla keyfi **kernel read/write** sağlayın. +1. **Trigger Physical Use-After-Free**: Serbest bırakılmış sayfalar yeniden kullanım için mevcuttur. +2. **Spray IOSurface Objects**: Çekirdek belleğinde benzersiz bir "magic value" içeren çok sayıda IOSurface nesnesi tahsis edin. +3. **Identify Accessible IOSurface**: Kontrolünüzdeki serbest bırakılmış bir sayfada bulunan bir IOSurface'i tespit edin. +4. **Abuse Use-After-Free**: IOSurface yöntemleri aracılığıyla rastgele **kernel read/write** sağlamak için IOSurface nesnesindeki işaretçileri değiştirin. -Bu primitives ile exploit, çekirdek belleğe kontrollü **32-bit reads** ve **64-bit writes** sağlar. İlave jailbreak adımları daha stabil read/write primitives gerektirebilir; bu da ek korumaların atlatılmasını (ör. yeni arm64e cihazlarda PPL) gerektirebilir. +With these primitives, the exploit provides controlled **32-bit reads** and **64-bit writes** to kernel memory. Further jailbreak steps could involve more stable read/write primitives, which may require bypassing additional protections (e.g., PPL on newer arm64e devices). {{#include ../../banners/hacktricks-training.md}}