hacktricks/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md

# Temel İkili Sömürü Metodolojisi

{% hint style="success" %}
AWS Hacking'i öğrenin ve uygulayın:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Eğitim AWS Kırmızı Takım Uzmanı (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
GCP Hacking'i öğrenin ve uygulayın: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Eğitim GCP Kırmızı Takım Uzmanı (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>HackTricks'i Destekleyin</summary>

* [**Abonelik planlarını**](https://github.com/sponsors/carlospolop) kontrol edin!
* 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) katılın veya bizi **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)** takip edin.**
* **Hacking püf noktalarını göndererek HackTricks ve HackTricks Cloud github depolarına PR göndererek paylaşın.**

</details>
{% endhint %}

## ELF Temel Bilgileri

Herhangi bir şeyi sömürmeye başlamadan önce bir **ELF ikilisinin** yapısının bir kısmını anlamak ilginç olabilir:

{% content-ref url="elf-tricks.md" %}
[elf-tricks.md](elf-tricks.md)
{% endcontent-ref %}

## Sömürü Araçları

{% content-ref url="tools/" %}
[tools](tools/)
{% endcontent-ref %}

## Yığın Taşması Metodolojisi

Bu kadar teknikle, her tekniğin ne zaman kullanışlı olacağını belirlemek için bir plana sahip olmak iyidir. Aynı korumaların farklı teknikleri etkileyeceğini unutmayın. Her koruma bölümünde korumaları atlatma yollarını bulabilirsiniz, ancak bu metodolojide değil.

## Akışı Kontrol Etme

Bir programın akışını kontrol etmenin farklı yolları olabilir:

* [**Yığın Taşmaları**](../stack-overflow/): Yığından dönüş işaretçisini veya EBP -> ESP -> EIP'yi üzerine yazarak.
* Taşmayı tetiklemek için bir [**Tamsayı Taşmaları**](../integer-overflow.md) kullanmanız gerekebilir
* Veya **Keyfi Yazma + Ne Nerede Yazma ile Yürütme**
* [**Biçim Dizileri**](../format-strings/)**:** `printf`'i kötüye kullanarak keyfi içeriği keyfi adreslere yazmak.
* [**Dizi İndeksleme**](../array-indexing.md): Kötü tasarlanmış bir dizinlemeyi kötüye kullanarak bazı dizileri kontrol edebilir ve keyfi yazma alabilirsiniz.
* Taşmayı tetiklemek için bir [**Tamsayı Taşmaları**](../integer-overflow.md) kullanmanız gerekebilir
* **bof to WWW via ROP**: Bir tampon taşmasını kötüye kullanarak bir ROP oluşturmak ve bir WWW almak için.

**Ne Nerede Yazma ile Yürütme** tekniklerini şurada bulabilirsiniz:

{% content-ref url="../arbitrary-write-2-exec/" %}
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
{% endcontent-ref %}

## Sonsuz Döngüler

Dikkate alınması gereken bir şey genellikle **bir zafiyetin sadece bir kez sömürülmesinin yeterli olmayabileceğidir**, özellikle bazı korumaların atlatılması gerekebilir. Bu nedenle, **bir zafiyeti aynı ikili çalıştırmada birkaç kez sömürülebilir hale getirmek için bazı seçenekleri** tartışmak ilginçtir:

* Bir **ROP** zincirine **`main` işlevinin adresini** veya **zafiyetin meydana geldiği adrese** yazın.
* Uygun bir ROP zincirini kontrol ederek o zincirdeki tüm işlemleri gerçekleştirebilirsiniz
* **`exit` adresini GOT'a** (veya bitmeden önce ikili tarafından kullanılan başka bir işlev) **zafiyete geri dönmek için adresi yazın**
* [**.fini\_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md#eternal-loop)**'de açıklandığı gibi,** buraya 2 işlev saklayın, biri zafiyeti tekrar çağırmak için diğeri ise `.fini_array`'dan işlevi tekrar çağıracak olan**`__libc_csu_fini`**'yi çağırmak için.

## Sömürü Hedefleri

### Hedef: Varolan bir işlevi Çağırmak

* [**ret2win**](./#ret2win): Çağırmanız gereken bir işlev var (belki belirli parametrelerle) bayrağı almak için.
* [**PIE**](../common-binary-protections-and-bypasses/pie/) olmadan ve [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) olmadan düzenli bir bof'ta, yığında depolanan dönüş adresine adresi yazmanız yeterli olacaktır.
* [**PIE**](../common-binary-protections-and-bypasses/pie/) ile bir bof'ta, bunu atlatmanız gerekecektir
* [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) ile bir bof'ta, bunu atlatmanız gerekecektir
* **ret2win** işlevini doğru şekilde çağırmak için birden fazla parametre ayarlamanız gerekiyorsa şunları kullanabilirsiniz:
* **Yeterli sayıda** kısayol varsa [**ROP**](./#rop-and-ret2...-techniques) **zinciri tüm parametreleri hazırlamak için**
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (bu sistem çağrısını yapabiliyorsanız) birçok kaydı kontrol etmek için
* [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) ve [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) 'dan kısayolları kontrol etmek için
* Bir [**Ne Nerede Yazma**](../arbitrary-write-2-exec/) ile başka zafiyetleri (bof olmayanlar) kötüye kullanarak **`win`** işlevini çağırabilirsiniz.
* [**İşaretçileri Yönlendirme**](../stack-overflow/pointer-redirecting.md): Yığın, çağrılacak bir işlevin işaretçilerini veya bir işlev tarafından kullanılacak bir dizeye işaret ediyorsa (system veya printf gibi), o adresi üzerine yazabilirsiniz.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) veya [**PIE**](../common-binary-protections-and-bypasses/pie/) adresleri etkileyebilir.
* [**İlklenmemiş değişkenler**](../stack-overflow/uninitialized-variables.md): Asla bilemezsiniz.

### Hedef: Uzaktan Kod Yürütme (RCE)

#### Nx devre dışı bırakılmışsa veya kodu karıştırarak shellcode ile:

* [**(Yığın) Shellcode**](./#stack-shellcode): Bu, bir shellcode'u yığında depolamak ve ardından dönüş işaretçisini üzerine yazdıktan sonra ona atlamak ve çalıştırmak için kullanışlıdır:
* **Her durumda, bir** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)** varsa,** düzenli bir bof'ta bunu atlatmanız (sızdırmanız) gerekecektir
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **ve** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) olmadan, yığının adresine atlamak mümkündür çünkü asla değişmeyecektir
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ile, ona atlamak için [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) gibi tekniklere ihtiyacınız olacaktır
* [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) ile, birkaç [**ROP**](../rop-return-oriented-programing/) kullanmanız gerekecektir **`memprotect`'ı çağırmak** ve bazı sayfaları `rwx` yapmak için, ardından oraya **shellcode'u depolamak** (örneğin okuma çağırarak) ve ardından oraya atlamak için.
* Bu, shellcode'u bir ROP zinciri ile karıştıracaktır.
#### Syscall ile

* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Herhangi bir komutu çalıştırmak için `execve`'yi çağırmak için kullanışlıdır. **Belirli bir syscall'ı parametrelerle çağırmak için gerekli olan gadget'ları bulabilmelisiniz**.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) veya [**PIE**](../common-binary-protections-and-bypasses/pie/) etkinse, ROP gadget'larını kullanabilmek için bunları **geçmek gerekecek**.
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) **ret2execve'yi hazırlamak için** kullanışlı olabilir
* [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) ve [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) ile çeşitli register'ları kontrol etmek için gadget'lar

#### Libc ile

* [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Genellikle **`libc`** gibi bir kütüphaneden bir fonksiyonu (genellikle **`system`**) çağırmak için kullanışlıdır ve bazı hazırlanmış argümanlarla (ör. `'/bin/sh'`). Çağırmak istediğiniz fonksiyonu içeren kütüphanenin **yüklenmiş olması gerekmektedir**.
* **Statik olarak derlenmiş ve** [**PIE**](../common-binary-protections-and-bypasses/pie/) **olmayan durumlarda**, `system` ve `/bin/sh`'nin **adresleri değişmeyecek**, bu yüzden bunları statik olarak kullanmak mümkün olacaktır.
* **ASLR olmadan** [**ve yüklü olan libc sürümünü** bilerek, `system` ve `/bin/sh`'nin **adresleri değişmeyecek**, bu yüzden bunları statik olarak kullanmak mümkün olacaktır.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **var ancak** [**PIE**](../common-binary-protections-and-bypasses/pie/) **yoksa, libc bilinir ve binary `system`** fonksiyonunu kullandığında, `'/bin/sh'` adresine **GOT'taki system adresine** `ret` yapmak mümkün olacaktır (bunu çözmeniz gerekecek).
* [ASLR](../common-binary-protections-and-bypasses/aslr/) **var ancak** [PIE](../common-binary-protections-and-bypasses/pie/) **yoksa, libc bilinir ve binary `system`'i kullanmadığında**:
* **`ret2dlresolve`**'yi kullanarak `system`'in adresini çözümlemek ve çağırmak mümkündür.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **geçmek ve `system` ve `'/bin/sh'`'nin adresini hesaplamak** için
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **ve** [**PIE**](../common-binary-protections-and-bypasses/pie/) **var ve libc bilinmiyorsa**: 
* [**PIE**](../common-binary-protections-and-bypasses/pie/) **geçmek**
* Kullanılan **`libc` sürümünü** bulmak (birkaç fonksiyon adresini sızdırmak)
* Devam etmek için **ASLR ile önceki senaryoları kontrol etmek** gerekecek.

#### EBP/RBP ile

* [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): ESP'yi kontrol ederek stack'te depolanan EBP aracılığıyla RET'i kontrol etmek.
* **Off-by-one** stack overflow'lar için kullanışlıdır
* EIP'yi kontrol etmeyi sonlandırmanın alternatif bir yol olarak kullanışlıdır, EIP'yi kontrol ederken bellekte payload'ı oluşturmak ve ardından EBP aracılığıyla ona atlamak için

#### Çeşitli

* [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): Stack'te çağrılacak bir fonksiyonun adreslerini veya bir dizeyi içeren işlevin (system veya printf gibi) kullanılacağına dair işaretçiler varsa, o adresi üzerine yazmak mümkündür.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) veya [**PIE**](../common-binary-protections-and-bypasses/pie/) adresleri etkileyebilir.
* [**İlklenmemiş değişkenler**](../stack-overflow/uninitialized-variables.md): Asla bilemezsiniz