mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/binary-exploitation/libc-heap/heap-overflow.md', 'src/b
This commit is contained in:
Translator
parent
187841111f
commit
c739530dcc
@ -6,43 +6,75 @@
|
||||
|
||||
Heap overflow ni kama [**stack overflow**](../stack-overflow/index.html) lakini katika heap. Kimsingi inamaanisha kwamba nafasi fulani ilihifadhiwa katika heap kuhifadhi data fulani na **data iliyohifadhiwa ilikuwa kubwa kuliko nafasi iliyohifadhiwa.**
|
||||
|
||||
Katika stack overflows tunajua kwamba baadhi ya register kama vile pointer ya maagizo au stack frame zitarejeshwa kutoka kwenye stack na inaweza kuwa na uwezekano wa kutumia hii vibaya. Katika kesi ya heap overflows, **hakuna taarifa nyeti iliyohifadhiwa kwa chaguo-msingi** katika kipande cha heap ambacho kinaweza kujaa. Hata hivyo, inaweza kuwa taarifa nyeti au pointers, hivyo **umuhimu** wa udhaifu huu **unategemea** **ni data ipi inaweza kuandikwa upya** na jinsi mshambuliaji anaweza kutumia hii vibaya.
|
||||
Katika stack overflows tunajua kwamba baadhi ya register kama vile pointer ya maagizo au stack frame zitarejeshwa kutoka kwenye stack na inaweza kuwa na uwezekano wa kutumia hii. Katika kesi ya heap overflows, **hakuna taarifa nyeti iliyohifadhiwa kwa chaguo katika chunk ya heap ambayo inaweza kujaa.** Hata hivyo, inaweza kuwa taarifa nyeti au pointers, hivyo **ukali** wa udhaifu huu **unategemea** **ni data gani inaweza kuandikwa upya** na jinsi mshambuliaji anaweza kutumia hii.
|
||||
|
||||
> [!TIP]
|
||||
> Ili kupata overflow offsets unaweza kutumia mifumo sawa kama katika [**stack overflows**](../stack-overflow/index.html#finding-stack-overflows-offsets).
|
||||
|
||||
### Stack Overflows vs Heap Overflows
|
||||
|
||||
Katika stack overflows, kupanga na data ambayo itakuwa katika stack wakati udhaifu unaweza kuchochewa ni ya kuaminika sana. Hii ni kwa sababu stack ni ya mstari, kila wakati inakua katika kumbukumbu inayopingana, katika **sehemu maalum za programu inayoendesha kumbukumbu ya stack kawaida huhifadhi aina sawa ya data** na ina muundo maalum na pointers kadhaa mwishoni mwa sehemu ya stack inayotumiwa na kila kazi.
|
||||
Katika stack overflows, mpangilio na data ambayo itakuwa katika stack wakati udhaifu unaweza kuchochewa ni wa kuaminika sana. Hii ni kwa sababu stack ni ya mstari, kila wakati ikiongezeka katika kumbukumbu inayopingana, katika **sehemu maalum za programu inayoendesha kumbukumbu ya stack kawaida huhifadhi aina sawa ya data** na ina muundo maalum na pointers kadhaa mwishoni mwa sehemu ya stack inayotumiwa na kila kazi.
|
||||
|
||||
Hata hivyo, katika kesi ya heap overflow, kumbukumbu inayotumika si ya mstari bali **vipande vilivyotengwa kawaida viko katika nafasi tofauti za kumbukumbu** (sio kando ya nyingine) kwa sababu ya **bins na maeneo** yanayogawanya allocations kwa ukubwa na kwa sababu **kumbukumbu iliyotolewa awali inatumika** kabla ya kutenga vipande vipya. Ni **ngumu kujua kitu ambacho kitakuwa kinagongana na kile kilicho hatarini** kwa heap overflow. Hivyo, wakati heap overflow inapatikana, inahitajika kupata **njia ya kuaminika kufanya kitu kinachotakiwa kuwa karibu katika kumbukumbu** na kile kinachoweza kujaa.
|
||||
Hata hivyo, katika kesi ya heap overflow, kumbukumbu inayotumika si ya mstari bali **chunks zilizotengwa kawaida ziko katika nafasi tofauti za kumbukumbu** (sio moja karibu na nyingine) kwa sababu ya **bins na maeneo** yanayogawanya allocations kwa ukubwa na kwa sababu **kumbukumbu iliyotolewa awali inatumika** kabla ya kutenga chunks mpya. Ni **ngumu kujua kitu ambacho kitakuwa kinagongana na kile kilicho hatarini** kwa heap overflow. Hivyo, wakati heap overflow inapatikana, inahitajika kupata **njia ya kuaminika kufanya kitu kinachotakiwa kuwa karibu katika kumbukumbu** na kile kinachoweza kujaa.
|
||||
|
||||
Moja ya mbinu zinazotumika kwa hili ni **Heap Grooming** ambayo inatumika kwa mfano [**katika chapisho hili**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). Katika chapisho inaelezwa jinsi wakati katika kernel ya iOS wakati eneo linapokosa kumbukumbu ya kuhifadhi vipande vya kumbukumbu, linaipanua kwa ukurasa wa kernel, na ukurasa huu unagawanywa katika vipande vya ukubwa unaotarajiwa ambavyo vitatumika kwa mpangilio (hadi toleo la iOS 9.2, kisha vipande hivi vinatumika kwa njia ya nasibu ili kuleta ugumu katika unyakuzi wa mashambulizi haya).
|
||||
Moja ya mbinu zinazotumika kwa hili ni **Heap Grooming** ambayo inatumika kwa mfano [**katika chapisho hili**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). Katika chapisho inaelezwa jinsi wakati katika kernel ya iOS wakati eneo linapokosa kumbukumbu ya kuhifadhi chunks za kumbukumbu, linaipanua kwa ukurasa wa kernel, na ukurasa huu unagawanywa katika chunks za ukubwa unaotarajiwa ambazo zitatumika kwa mpangilio (hadi toleo la iOS 9.2, kisha chunks hizi zinatumika kwa njia ya nasibu ili kuleta ugumu katika unyakuzi wa mashambulizi haya).
|
||||
|
||||
Hivyo, katika chapisho la awali ambapo heap overflow inatokea, ili kulazimisha kipande kilichojazwa kuwa kinagongana na agizo la mwathirika, **`kallocs` kadhaa zinapaswa kulazimishwa na nyuzi kadhaa ili kujaribu kuhakikisha kwamba vipande vyote vilivyotolewa vimejaa na kwamba ukurasa mpya unaundwa**.
|
||||
Kwa hivyo, katika chapisho la awali ambapo heap overflow inatokea, ili kulazimisha kitu kilichojazwa kuungana na agizo la mwathirika, **`kallocs` kadhaa zinapaswa kulazimishwa na nyuzi kadhaa ili kujaribu kuhakikisha kwamba chunks zote za bure zimejaa na kwamba ukurasa mpya umeundwa**.
|
||||
|
||||
Ili kulazimisha kujaza hili kwa vitu vya ukubwa maalum, **allocation isiyo ya mstari inayohusishwa na iOS mach port** ni mgombea bora. Kwa kubuni ukubwa wa ujumbe, inawezekana kubaini kwa usahihi ukubwa wa `kalloc` allocation na wakati mach port inayohusiana inaharibiwa, allocation inayohusiana itarejeshwa mara moja kwa `kfree`.
|
||||
Ili kulazimisha kujaza hili kwa vitu vya ukubwa maalum, **allocation ya nje ya mstari inayohusishwa na iOS mach port** ni mgombea bora. Kwa kubuni ukubwa wa ujumbe, inawezekana kubaini kwa usahihi ukubwa wa `kalloc` allocation na wakati mach port inayohusiana inaharibiwa, allocation inayohusiana itarejeshwa mara moja kwa `kfree`.
|
||||
|
||||
Kisha, baadhi ya hizi placeholders zinaweza kuwa **zimeachiliwa**. **Orodha ya bure ya `kalloc.4096` inatoa vipengele kwa mpangilio wa mwisho-kuingia-wa-kwanza-kuondolewa**, ambayo kimsingi inamaanisha kwamba ikiwa baadhi ya placeholders zimeachiliwa na unyakuzi unajaribu kutenga vitu kadhaa vya mwathirika wakati akijaribu kutenga kipande kilicho hatarini kujaa, kuna uwezekano kwamba kipande hiki kitafuatiwa na kipande cha mwathirika.
|
||||
Kisha, baadhi ya hizi placeholders zinaweza kuwa **zimeachiliwa**. **Orodha ya bure ya `kalloc.4096` inatoa vipengele kwa mpangilio wa mwisho-kuingia-wa-kwanza**, ambayo kimsingi inamaanisha kwamba ikiwa baadhi ya placeholders zimeachiliwa na unyakuzi unajaribu kutenga vitu kadhaa vya mwathirika wakati akijaribu kutenga kitu kilicho hatarini kujaa, kuna uwezekano kwamba kitu hiki kitafuatiwa na kitu cha mwathirika.
|
||||
|
||||
### Example libc
|
||||
|
||||
[**Katika ukurasa huu**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) inawezekana kupata mfano wa msingi wa Heap overflow unaoonyesha jinsi ya kuandika upya prev in use bit ya kipande kinachofuata na nafasi ya prev size inawezekana **kuunganisha kipande kilichotumika** (kwa kulifanya kufikiri hakijatumika) na **kisha kukitenga tena** ikiwa na uwezo wa kuandika data inayotumiwa katika pointer tofauti pia.
|
||||
[**Katika ukurasa huu**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) inawezekana kupata mfano wa msingi wa Heap overflow unaoonyesha jinsi ya kuandika upya prev in use bit ya chunk inayofuata na nafasi ya prev size inawezekana **kuunganisha chunk inayotumika** (kwa kumfanya aone kama haijatumika) na **kisha kuipatia tena** ikiwa na uwezo wa kuandika data inayotumika katika pointer tofauti pia.
|
||||
|
||||
Mfano mwingine kutoka [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) unaonyesha mfano wa msingi wa CTF ambapo **heap overflow** inaweza kutumika vibaya kuita kazi ya mshindi ili **kupata bendera**.
|
||||
Mfano mwingine kutoka [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) unaonyesha mfano wa msingi wa CTF ambapo **heap overflow** inaweza kutumika kuita kazi ya mshindi ili **kupata bendera**.
|
||||
|
||||
Katika mfano wa [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap1/index.html) inawezekana kuona jinsi ya kutumia overflow ya buffer inaweza **kuandika upya katika kipande kilichokaribu anwani** ambapo **data ya mtumiaji isiyo na mipaka** itakuwa imeandikwa.
|
||||
Katika mfano wa [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap1/index.html) inawezekana kuona jinsi ya kutumia overflow ya buffer inawezekana **kuandika upya katika chunk ya karibu anwani** ambapo **data ya kiholela kutoka kwa mtumiaji** itakuwa imeandikwa.
|
||||
|
||||
### Example ARM64
|
||||
|
||||
Katika ukurasa [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) unaweza kupata mfano wa heap overflow ambapo amri ambayo itatekelezwa inahifadhiwa katika kipande kinachofuata kutoka kwa kipande kilichojazwa. Hivyo, inawezekana kubadilisha amri inayotekelezwa kwa kuandika upya kwa unyakuzi rahisi kama:
|
||||
Katika ukurasa [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) unaweza kupata mfano wa heap overflow ambapo amri ambayo itatekelezwa inahifadhiwa katika chunk ifuatayo kutoka kwa chunk iliyojazwa. Hivyo, inawezekana kubadilisha amri inayotekelezwa kwa kuandika upya kwa unyakuzi rahisi kama:
|
||||
```bash
|
||||
python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
|
||||
```
|
||||
### Mifano mingine
|
||||
### Mifano Mingine
|
||||
|
||||
- [**Auth-or-out. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/auth-or-out/)
|
||||
- Tunatumia udhaifu wa Integer Overflow kupata Heap Overflow.
|
||||
- Tunaharibu viashiria vya kazi ndani ya `struct` ya kipande kilichozidi uwezo ili kuweka kazi kama `system` na kupata utekelezaji wa msimbo.
|
||||
|
||||
### Mfano wa Uhalisia: CVE-2025-40597 – Kutumia vibaya `__sprintf_chk`
|
||||
|
||||
Katika firmware ya SonicWall SMA100 10.2.1.15 moduli ya reverse-proxy `mod_httprp.so` inatenga kipande cha **0x80-byte** cha heap kisha inachanganya nyuzi kadhaa ndani yake kwa kutumia `__sprintf_chk`:
|
||||
```c
|
||||
char *buf = calloc(0x80, 1);
|
||||
/* … */
|
||||
__sprintf_chk(buf, /* destination (0x80-byte chunk) */
|
||||
-1, /* <-- size argument !!! */
|
||||
0, /* flags */
|
||||
"%s%s%s%s", /* format */
|
||||
"/", "https://", path, host);
|
||||
```
|
||||
`__sprintf_chk` ni sehemu ya **_FORTIFY_SOURCE**. Wakati inapata parameter ya **chaguo** `size` yenye **thamani chanya**, inathibitisha kwamba string inayotokana inafaa ndani ya buffer ya marudio. Kwa kupitisha **`-1` (0xFFFFFFFFFFFFFFFF)** waendelezaji kwa ufanisi **walizima ukaguzi wa mipaka**, wakirudisha wito ulioimarishwa kuwa `sprintf` ya kawaida, isiyo salama.
|
||||
|
||||
Kutoa kichwa cha **`Host:`** chenye urefu kupita kiasi hivyo inaruhusu mshambuliaji **kuvuka kipande cha 0x80-byte na kuharibu metadata ya kipande kinachofuata cha heap** (tcache / fast-bin / small-bin kulingana na mtoaji). Crash inaweza kuzalishwa kwa:
|
||||
```python
|
||||
import requests, warnings
|
||||
warnings.filterwarnings('ignore')
|
||||
requests.get(
|
||||
'https://TARGET/__api__/',
|
||||
headers={'Host': 'A'*750},
|
||||
verify=False
|
||||
)
|
||||
```
|
||||
Practical exploitation would require **heap grooming** to place a controllable object right after the vulnerable chunk, but the root cause highlights two important takeaways:
|
||||
|
||||
1. **_FORTIFY_SOURCE si risasi ya fedha** – matumizi mabaya yanaweza kufuta ulinzi.
|
||||
2. Daima pitisha **ukubwa sahihi wa buffer** kwa familia ya `_chk` (au, hata bora, tumia `snprintf`).
|
||||
|
||||
## References
|
||||
* [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## What is a Stack Overflow
|
||||
|
||||
A **stack overflow** ni udhaifu unaotokea wakati programu inapoandika data zaidi kwenye stack kuliko ilivyopewa kushikilia. Data hii ya ziada it **andika nafasi ya kumbukumbu iliyo karibu**, ikisababisha uharibifu wa data halali, kuingiliwa kwa mtiririko wa udhibiti, na kwa uwezekano wa kutekelezwa kwa msimbo mbaya. Tatizo hili mara nyingi linatokea kutokana na matumizi ya kazi zisizo salama ambazo hazifanyi ukaguzi wa mipaka kwenye ingizo.
|
||||
A **stack overflow** ni udhaifu unaotokea wakati programu inapoandika data zaidi kwenye stack kuliko ilivyopewa kushikilia. Data hii ya ziada it **andika nafasi ya kumbukumbu iliyo karibu**, ikisababisha uharibifu wa data halali, kuingiliwa kwa mtiririko wa udhibiti, na kwa uwezekano wa utekelezaji wa msimbo mbaya. Tatizo hili mara nyingi linatokea kutokana na matumizi ya kazi zisizo salama ambazo hazifanyi ukaguzi wa mipaka kwenye ingizo.
|
||||
|
||||
Tatizo kuu la kuandika tena ni kwamba **pointer ya maagizo iliyohifadhiwa (EIP/RIP)** na **pointer ya msingi iliyohifadhiwa (EBP/RBP)** za kurudi kwenye kazi ya awali zime **hifadhiwa kwenye stack**. Hivyo, mshambuliaji ataweza kuandika tena hizo na **kudhibiti mtiririko wa utekelezaji wa programu**.
|
||||
|
||||
@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
|
||||
printf("You entered: %s\n", buffer);
|
||||
}
|
||||
```
|
||||
### Kutafuta ofseti za Stack Overflows
|
||||
### Kupata Mipangilio ya Stack Overflows
|
||||
|
||||
Njia ya kawaida zaidi ya kutafuta stack overflows ni kutoa ingizo kubwa la `A`s (kwa mfano `python3 -c 'print("A"*1000)'`) na kutarajia `Segmentation Fault` ikionyesha kwamba **anwani `0x41414141` ilijaribu kufikiwa**.
|
||||
Njia ya kawaida zaidi ya kupata stack overflows ni kutoa ingizo kubwa sana la `A`s (kwa mfano, `python3 -c 'print("A"*1000)'`) na kutarajia `Segmentation Fault` ikionyesha kwamba **anwani `0x41414141` ilijaribu kufikiwa**.
|
||||
|
||||
Zaidi ya hayo, mara tu unapogundua kwamba kuna udhaifu wa Stack Overflow utahitaji kutafuta ofseti hadi iwezekane **kufuta anwani ya kurudi**, kwa hili mara nyingi hutumiwa **De Bruijn sequence.** Ambayo kwa alfabeti iliyotolewa ya ukubwa _k_ na subsequences za urefu _n_ ni **mfuatano wa mzunguko ambapo kila subsequence inayowezekana ya urefu _n_ inaonekana mara moja tu** kama subsequence iliyo karibu.
|
||||
Zaidi ya hayo, mara tu unapogundua kwamba kuna udhaifu wa Stack Overflow utahitaji kupata mipangilio hadi iwezekane **kufuta anwani ya kurudi**, kwa hili mara nyingi hutumiwa **De Bruijn sequence.** Ambayo kwa alfabeti iliyotolewa ya ukubwa _k_ na subsequences za urefu _n_ ni **mfululizo wa mzunguko ambapo kila subsequence inayowezekana ya urefu _n_ inaonekana mara moja tu** kama subsequence iliyo karibu.
|
||||
|
||||
Kwa njia hii, badala ya kuhitaji kubaini ni ofseti ipi inahitajika kudhibiti EIP kwa mkono, inawezekana kutumia kama padding moja ya hizi sequences na kisha kutafuta ofseti ya bytes ambazo zilimaliza kufuta hiyo.
|
||||
Kwa njia hii, badala ya kuhitaji kubaini ni mipangilio gani inahitajika kudhibiti EIP kwa mkono, inawezekana kutumia kama padding moja ya hizi sequences na kisha kupata mipangilio ya bytes ambazo zilimaliza kufuta hiyo.
|
||||
|
||||
Inawezekana kutumia **pwntools** kwa hili:
|
||||
```python
|
||||
@ -50,14 +50,14 @@ pattern search $rsp #Search the offset given the content of $rsp
|
||||
```
|
||||
## Kutumia Stack Overflows
|
||||
|
||||
Wakati wa overflow (ikiwa saizi ya overflow ni kubwa vya kutosha) utaweza **kuandika upya** thamani za mabadiliko ya ndani ya stack hadi kufikia **EBP/RBP na EIP/RIP (au hata zaidi)**.\
|
||||
Wakati wa overflow (ikiwa saizi ya overflow ni kubwa vya kutosha) utaweza **kuandika upya** thamani za mabadiliko ya ndani ndani ya stack hadi kufikia **EBP/RBP na EIP/RIP (au hata zaidi)**.\
|
||||
Njia ya kawaida zaidi ya kutumia aina hii ya udhaifu ni kwa **kubadilisha anwani ya kurudi** ili wakati kazi inamalizika **mchakato wa udhibiti utaelekezwa popote mtumiaji alivyobaini** katika kiashiria hiki.
|
||||
|
||||
Hata hivyo, katika hali nyingine labda tu **kuandika upya baadhi ya thamani za mabadiliko katika stack** inaweza kuwa ya kutosha kwa matumizi (kama katika changamoto rahisi za CTF).
|
||||
|
||||
### Ret2win
|
||||
|
||||
Katika aina hii ya changamoto za CTF, kuna **kazi** **ndani** ya binary ambayo **haitaitwa kamwe** na ambayo **unahitaji kuitwa ili kushinda**. Kwa changamoto hizi unahitaji tu kupata **offset ya kuandika upya anwani ya kurudi** na **kupata anwani ya kazi** ya kuitwa (kawaida [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) itakuwa imezimwa) ili wakati kazi iliyo hatarini inarudi, kazi iliyofichwa itaitwa:
|
||||
Katika aina hii ya changamoto za CTF, kuna **kazi** **ndani** ya binary ambayo **haitaitwa kamwe** na ambayo **unahitaji kuitwa ili kushinda**. Kwa ajili ya changamoto hizi unahitaji tu kupata **offset ya kuandika upya anwani ya kurudi** na **kupata anwani ya kazi** ya kuita (kawaida [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) itakuwa imezimwa) ili wakati kazi iliyo hatarini inarudi, kazi iliyofichwa itaitwa:
|
||||
|
||||
{{#ref}}
|
||||
ret2win/
|
||||
@ -71,9 +71,9 @@ Katika hali hii mshambuliaji anaweza kuweka shellcode katika stack na kutumia EI
|
||||
stack-shellcode/
|
||||
{{#endref}}
|
||||
|
||||
### ROP & Ret2... techniques
|
||||
### ROP & Ret2... mbinu
|
||||
|
||||
Teknolojia hii ni muundo wa msingi wa kupita ulinzi mkuu wa teknolojia ya awali: **No executable stack (NX)**. Na inaruhusu kutekeleza mbinu kadhaa nyingine (ret2lib, ret2syscall...) ambazo zitamaliza kwa kutekeleza amri za kiholela kwa kutumia maagizo yaliyopo katika binary:
|
||||
Mbinu hii ni muundo wa msingi wa kupita ulinzi mkuu wa mbinu ya awali: **No executable stack (NX)**. Na inaruhusu kutekeleza mbinu kadhaa nyingine (ret2lib, ret2syscall...) ambazo zitamaliza kwa kutekeleza amri za kiholela kwa kutumia maagizo yaliyopo katika binary:
|
||||
|
||||
{{#ref}}
|
||||
../rop-return-oriented-programing/
|
||||
@ -81,7 +81,7 @@ Teknolojia hii ni muundo wa msingi wa kupita ulinzi mkuu wa teknolojia ya awali:
|
||||
|
||||
## Heap Overflows
|
||||
|
||||
Overflow si kila wakati itakuwa katika stack, inaweza pia kuwa katika **heap** kwa mfano:
|
||||
Overflow si kila wakati utaenda kuwa katika stack, inaweza pia kuwa katika **heap** kwa mfano:
|
||||
|
||||
{{#ref}}
|
||||
../libc-heap/heap-overflow.md
|
||||
@ -89,10 +89,39 @@ Overflow si kila wakati itakuwa katika stack, inaweza pia kuwa katika **heap** k
|
||||
|
||||
## Aina za ulinzi
|
||||
|
||||
Kuna ulinzi kadhaa zinazojaribu kuzuia matumizi ya udhaifu, angalia hizo katika:
|
||||
Kuna ulinzi kadhaa zinazojaribu kuzuia matumizi ya udhaifu, angalia katika:
|
||||
|
||||
{{#ref}}
|
||||
../common-binary-protections-and-bypasses/
|
||||
{{#endref}}
|
||||
|
||||
### Mfano wa Uhalisia: CVE-2025-40596 (SonicWall SMA100)
|
||||
|
||||
Onyesho zuri la kwa nini **`sscanf` haipaswi kuaminika kamwe kwa kuchambua pembejeo zisizoaminika** lilionekana mwaka wa 2025 katika kifaa cha SonicWall SMA100 SSL-VPN.
|
||||
Ruti iliyo hatarini ndani ya `/usr/src/EasyAccess/bin/httpd` inajaribu kutoa toleo na kiungo kutoka kwa URI yoyote inayaanza na `/__api__/`:
|
||||
```c
|
||||
char version[3];
|
||||
char endpoint[0x800] = {0};
|
||||
/* simplified proto-type */
|
||||
sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
|
||||
```
|
||||
1. Mabadiliko ya kwanza (`%2s`) hifadhi salama **bytes mbili** ndani ya `version` (kwa mfano, `"v1"`).
|
||||
2. Mabadiliko ya pili (`%s`) **hayana mwelekeo wa urefu**, kwa hivyo `sscanf` itaendelea nakala **hadi byte ya kwanza ya NUL**.
|
||||
3. Kwa sababu `endpoint` iko kwenye **stack** na ina **urefu wa 0x800 bytes**, kutoa njia ndefu zaidi ya 0x800 bytes inaharibu kila kitu kilichopo baada ya buffer ‑ ikiwa ni pamoja na **stack canary** na **anwani ya kurudi iliyohifadhiwa**.
|
||||
|
||||
Uthibitisho wa dhana wa mstari mmoja unatosha kuanzisha ajali **kabla ya uthibitisho**:
|
||||
```python
|
||||
import requests, warnings
|
||||
warnings.filterwarnings('ignore')
|
||||
url = "https://TARGET/__api__/v1/" + "A"*3000
|
||||
requests.get(url, verify=False)
|
||||
```
|
||||
Ingawa stack canaries zinaweza kusitisha mchakato, mshambuliaji bado anapata **Denial-of-Service** primitive (na, kwa uvujaji wa habari za ziada, huenda akapata utekelezaji wa msimbo). Somo ni rahisi:
|
||||
|
||||
* Daima toa **upana wa uwanja wa juu** (kwa mfano, `%511s`).
|
||||
* Prefer njia salama kama `snprintf`/`strncpy_s`.
|
||||
|
||||
## References
|
||||
* [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user