From 5621efd1f613e64ee6982bce2513c82a914d7b9c Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 13 Aug 2025 22:38:59 +0000 Subject: [PATCH] Translated ['src/hardware-physical-access/firmware-analysis/README.md', --- src/SUMMARY.md | 1 + .../firmware-analysis/README.md | 36 ++-- .../synology-encrypted-archive-decryption.md | 162 ++++++++++++++++++ src/pentesting-web/command-injection.md | 38 +++- 4 files changed, 215 insertions(+), 22 deletions(-) create mode 100644 src/hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index bb1d3f659..0c1f23d74 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -769,6 +769,7 @@ - [Ret2vDSO](binary-exploitation/rop-return-oriented-programing/ret2vdso.md) - [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md) - [SROP - ARM64](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md) + - [Synology Encrypted Archive Decryption](hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md) - [Array Indexing](binary-exploitation/array-indexing.md) - [Chrome Exploiting](binary-exploitation/chrome-exploiting.md) - [Integer Overflow](binary-exploitation/integer-overflow.md) diff --git a/src/hardware-physical-access/firmware-analysis/README.md b/src/hardware-physical-access/firmware-analysis/README.md index 6235ddf5f..8ee05dc98 100644 --- a/src/hardware-physical-access/firmware-analysis/README.md +++ b/src/hardware-physical-access/firmware-analysis/README.md @@ -4,7 +4,13 @@ ## **Wprowadzenie** -Oprogramowanie układowe to niezbędne oprogramowanie, które umożliwia urządzeniom prawidłowe działanie, zarządzając i ułatwiając komunikację między komponentami sprzętowymi a oprogramowaniem, z którym użytkownicy wchodzą w interakcje. Jest przechowywane w pamięci trwałej, co zapewnia, że urządzenie może uzyskać dostęp do istotnych instrukcji od momentu włączenia, co prowadzi do uruchomienia systemu operacyjnego. Badanie i potencjalna modyfikacja oprogramowania układowego to kluczowy krok w identyfikacji luk w zabezpieczeniach. +### Powiązane zasoby + +{{#ref}} +synology-encrypted-archive-decryption.md +{{#endref}} + +Oprogramowanie układowe to niezbędne oprogramowanie, które umożliwia urządzeniom prawidłowe działanie, zarządzając i ułatwiając komunikację między komponentami sprzętowymi a oprogramowaniem, z którym użytkownicy wchodzą w interakcję. Jest przechowywane w pamięci trwałej, co zapewnia, że urządzenie może uzyskać dostęp do istotnych instrukcji od momentu włączenia, co prowadzi do uruchomienia systemu operacyjnego. Badanie i potencjalne modyfikowanie oprogramowania układowego jest kluczowym krokiem w identyfikacji luk w zabezpieczeniach. ## **Zbieranie informacji** @@ -16,10 +22,10 @@ Oprogramowanie układowe to niezbędne oprogramowanie, które umożliwia urządz - Metryk bazy kodu i lokalizacji źródłowych - Zewnętrznych bibliotek i typów licencji - Historii aktualizacji i certyfikacji regulacyjnych -- Diagramów architektonicznych i przepływowych +- Diagramów architektonicznych i przepływów - Oceny bezpieczeństwa i zidentyfikowanych luk -W tym celu narzędzia **inteligencji open-source (OSINT)** są nieocenione, podobnie jak analiza dostępnych komponentów oprogramowania open-source poprzez ręczne i zautomatyzowane procesy przeglądowe. Narzędzia takie jak [Coverity Scan](https://scan.coverity.com) i [Semmle’s LGTM](https://lgtm.com/#explore) oferują darmową analizę statyczną, która może być wykorzystana do znalezienia potencjalnych problemów. +W tym celu narzędzia **inteligencji open-source (OSINT)** są nieocenione, podobnie jak analiza wszelkich dostępnych komponentów oprogramowania open-source poprzez ręczne i zautomatyzowane procesy przeglądowe. Narzędzia takie jak [Coverity Scan](https://scan.coverity.com) i [Semmle’s LGTM](https://lgtm.com/#explore) oferują darmową analizę statyczną, która może być wykorzystana do znalezienia potencjalnych problemów. ## **Pozyskiwanie oprogramowania układowego** @@ -29,7 +35,7 @@ Pozyskiwanie oprogramowania układowego można podejść na różne sposoby, z k - **Budując** je na podstawie dostarczonych instrukcji - **Pobierając** z oficjalnych stron wsparcia - Wykorzystując zapytania **Google dork** do znajdowania hostowanych plików oprogramowania układowego -- Uzyskując dostęp do **chmury** bezpośrednio, z narzędziami takimi jak [S3Scanner](https://github.com/sa7mon/S3Scanner) +- Uzyskując dostęp do **chmury** bezpośrednio, za pomocą narzędzi takich jak [S3Scanner](https://github.com/sa7mon/S3Scanner) - Przechwytując **aktualizacje** za pomocą technik man-in-the-middle - **Ekstrahując** z urządzenia przez połączenia takie jak **UART**, **JTAG** lub **PICit** - **Podsłuchując** żądania aktualizacji w komunikacji urządzenia @@ -113,7 +119,7 @@ Pliki będą w katalogu "`squashfs-root`" po tym. ## Analiza Oprogramowania Układowego -Gdy oprogramowanie układowe jest już uzyskane, istotne jest jego rozłożenie na części w celu zrozumienia jego struktury i potencjalnych luk. Proces ten polega na wykorzystaniu różnych narzędzi do analizy i wydobywania cennych danych z obrazu oprogramowania układowego. +Gdy oprogramowanie układowe jest już zdobyte, istotne jest jego rozłożenie na części w celu zrozumienia struktury i potencjalnych luk. Proces ten polega na wykorzystaniu różnych narzędzi do analizy i wydobywania cennych danych z obrazu oprogramowania układowego. ### Narzędzia do Wstępnej Analizy @@ -132,7 +138,7 @@ Do ekstrakcji **osadzonych plików** zaleca się korzystanie z dokumentacji **fi ### Ekstrakcja systemu plików -Używając `binwalk -ev `, można zazwyczaj wyodrębnić system plików, często do katalogu nazwanego na cześć typu systemu plików (np. squashfs, ubifs). Jednak gdy **binwalk** nie rozpoznaje typu systemu plików z powodu brakujących bajtów magicznych, konieczna jest ręczna ekstrakcja. Polega to na użyciu `binwalk` do zlokalizowania offsetu systemu plików, a następnie polecenia `dd` do wycięcia systemu plików: +Używając `binwalk -ev `, można zazwyczaj wyodrębnić system plików, często do katalogu nazwanego na cześć typu systemu plików (np. squashfs, ubifs). Jednak gdy **binwalk** nie rozpoznaje typu systemu plików z powodu brakujących bajtów magicznych, konieczna jest ręczna ekstrakcja. Polega to na użyciu `binwalk` do zlokalizowania offsetu systemu plików, a następnie polecenia `dd` do wyodrębnienia systemu plików: ```bash $ binwalk DIR850L_REVB.bin @@ -196,11 +202,11 @@ Na tym etapie używa się rzeczywistego lub emulowanego środowiska urządzenia ## Techniki analizy w czasie rzeczywistym -Analiza w czasie rzeczywistym polega na interakcji z procesem lub binariami w ich środowisku operacyjnym, przy użyciu narzędzi takich jak gdb-multiarch, Frida i Ghidra do ustawiania punktów przerwania i identyfikacji luk poprzez fuzzing i inne techniki. +Analiza w czasie rzeczywistym polega na interakcji z procesem lub binariami w jego środowisku operacyjnym, przy użyciu narzędzi takich jak gdb-multiarch, Frida i Ghidra do ustawiania punktów przerwania i identyfikacji luk poprzez fuzzing i inne techniki. ## Eksploatacja binarna i dowód koncepcji -Opracowanie PoC dla zidentyfikowanych luk wymaga głębokiego zrozumienia docelowej architektury i programowania w językach niskiego poziomu. Ochrony w czasie rzeczywistym w systemach wbudowanych są rzadkie, ale gdy są obecne, techniki takie jak Return Oriented Programming (ROP) mogą być konieczne. +Opracowanie PoC dla zidentyfikowanych luk wymaga głębokiego zrozumienia architektury docelowej i programowania w językach niskiego poziomu. Ochrony w czasie rzeczywistym w systemach wbudowanych są rzadkie, ale gdy są obecne, techniki takie jak Return Oriented Programming (ROP) mogą być konieczne. ## Przygotowane systemy operacyjne do analizy firmware'u @@ -208,22 +214,22 @@ Systemy operacyjne takie jak [AttifyOS](https://github.com/adi0x90/attifyos) i [ ## Przygotowane systemy operacyjne do analizy firmware'u -- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS to dystrybucja mająca na celu pomoc w przeprowadzaniu oceny bezpieczeństwa i testów penetracyjnych urządzeń Internetu Rzeczy (IoT). Oszczędza dużo czasu, zapewniając wstępnie skonfigurowane środowisko z wszystkimi niezbędnymi narzędziami. +- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS to dystrybucja mająca na celu pomoc w przeprowadzaniu ocen bezpieczeństwa i testów penetracyjnych urządzeń Internetu Rzeczy (IoT). Oszczędza dużo czasu, oferując wstępnie skonfigurowane środowisko z wszystkimi niezbędnymi narzędziami. - [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): System operacyjny do testowania bezpieczeństwa wbudowanego, oparty na Ubuntu 18.04, wstępnie załadowany narzędziami do testowania bezpieczeństwa firmware'u. ## Ataki na obniżenie wersji firmware'u i niebezpieczne mechanizmy aktualizacji -Nawet gdy dostawca wdraża kontrole podpisu kryptograficznego dla obrazów firmware'u, **ochrona przed cofaniem wersji (downgrade) jest często pomijana**. Gdy boot- lub recovery-loader tylko weryfikuje podpis za pomocą osadzonego klucza publicznego, ale nie porównuje *wersji* (lub monotonicznego licznika) obrazu, który jest wgrywany, atakujący może legalnie zainstalować **starszy, podatny firmware, który nadal ma ważny podpis** i w ten sposób ponownie wprowadzić załatane luki. +Nawet gdy dostawca wdraża kontrole podpisu kryptograficznego dla obrazów firmware'u, **ochrona przed obniżeniem wersji (downgrade) jest często pomijana**. Gdy boot- lub recovery-loader tylko weryfikuje podpis za pomocą osadzonego klucza publicznego, ale nie porównuje *wersji* (lub monotonicznego licznika) obrazu, który jest wgrywany, atakujący może legalnie zainstalować **starszy, podatny firmware, który nadal ma ważny podpis** i w ten sposób ponownie wprowadzić załatane luki. Typowy przebieg ataku: 1. **Uzyskaj starszy podpisany obraz** * Pobierz go z publicznego portalu pobierania dostawcy, CDN lub strony wsparcia. -* Wyodrębnij go z towarzyszących aplikacji mobilnych/desktopowych (np. wewnątrz aplikacji Android APK w `assets/firmware/`). +* Wyodrębnij go z towarzyszących aplikacji mobilnych/desktopowych (np. wewnątrz Android APK pod `assets/firmware/`). * Pobierz go z repozytoriów stron trzecich, takich jak VirusTotal, archiwa internetowe, fora itp. -2. **Prześlij lub udostępnij obraz urządzeniu** za pośrednictwem dowolnego narażonego kanału aktualizacji: +2. **Prześlij lub udostępnij obraz urządzeniu** przez dowolny narażony kanał aktualizacji: * Interfejs webowy, API aplikacji mobilnej, USB, TFTP, MQTT itp. -* Wiele konsumenckich urządzeń IoT udostępnia *nieautoryzowane* punkty końcowe HTTP(S), które akceptują blob'y firmware'u zakodowane w Base64, dekodują je po stronie serwera i uruchamiają proces odzyskiwania/aktualizacji. +* Wiele konsumenckich urządzeń IoT udostępnia *nieautoryzowane* punkty końcowe HTTP(S), które akceptują blob'y firmware'u zakodowane w Base64, dekodują je po stronie serwera i uruchamiają odzyskiwanie/aktualizację. 3. Po obniżeniu wersji wykorzystaj lukę, która została załatana w nowszej wersji (na przykład filtr wstrzykiwania poleceń, który został dodany później). 4. Opcjonalnie wgraj najnowszy obraz z powrotem lub wyłącz aktualizacje, aby uniknąć wykrycia po uzyskaniu trwałości. @@ -260,7 +266,7 @@ Aby ćwiczyć odkrywanie luk w oprogramowaniu układowym, użyj następujących - OWASP IoTGoat - [https://github.com/OWASP/IoTGoat](https://github.com/OWASP/IoTGoat) -- Projekt Damn Vulnerable Router Firmware +- Projekt Oprogramowania Układowego Routera z Wrażliwościami - [https://github.com/praetorian-code/DVRF](https://github.com/praetorian-code/DVRF) - Damn Vulnerable ARM Router (DVAR) - [https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html](https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html) @@ -277,7 +283,7 @@ Aby ćwiczyć odkrywanie luk w oprogramowaniu układowym, użyj następujących - [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://www.amazon.co.uk/Practical-IoT-Hacking-F-Chantzis/dp/1718500904) - [Exploiting zero days in abandoned hardware – Trail of Bits blog](https://blog.trailofbits.com/2025/07/25/exploiting-zero-days-in-abandoned-hardware/) -## Szkolenie i certyfikacja +## Szkolenie i Certyfikacja - [https://www.attify-store.com/products/offensive-iot-exploitation](https://www.attify-store.com/products/offensive-iot-exploitation) diff --git a/src/hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md b/src/hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md new file mode 100644 index 000000000..aa0539da3 --- /dev/null +++ b/src/hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md @@ -0,0 +1,162 @@ +# Synology PAT/SPK Encrypted Archive Decryption + +{{#include ../../banners/hacktricks-training.md}} + +## Overview + +Kilka urządzeń Synology (DSM/BSM NAS, BeeStation, …) dystrybuuje swoje oprogramowanie i pakiety aplikacji w **zaszyfrowanych archiwach PAT / SPK**. Te archiwa można odszyfrować *offline* przy użyciu jedynie publicznych plików do pobrania, dzięki wbudowanym w oficjalne biblioteki ekstrakcji kluczom zakodowanym na stałe. + +Ta strona dokumentuje, krok po kroku, jak działa zaszyfrowany format i jak w pełni odzyskać tekst jawny **TAR**, który znajduje się w każdym pakiecie. Procedura opiera się na badaniach Synacktiv przeprowadzonych podczas Pwn2Own Ireland 2024 i została zaimplementowana w narzędziu open-source [`synodecrypt`](https://github.com/synacktiv/synodecrypt). + +> ⚠️ Format jest dokładnie taki sam dla archiwów `*.pat` (aktualizacja systemu) i `*.spk` (aplikacja) – różnią się tylko parą kluczy zakodowanych na stałe, które są wybierane. + +--- + +## 1. Grab the archive + +Aktualizację oprogramowania/aplikacji można zazwyczaj pobrać z publicznego portalu Synology: +```bash +$ wget https://archive.synology.com/download/Os/BSM/BSM_BST150-4T_65374.pat +``` +## 2. Zrzut struktury PAT (opcjonalnie) + +`*.pat` obrazy są same w sobie **pakietem cpio**, który zawiera kilka plików (boot loader, kernel, rootfs, pakiety…). Darmowe narzędzie [`patology`](https://github.com/sud0woodo/patology) jest wygodne do inspekcji tego opakowania: +```bash +$ python3 patology.py --dump -i BSM_BST150-4T_65374.pat +[…] +$ ls +DiskCompatibilityDB.tar hda1.tgz rd.bin packages/ … +``` +Dla `*.spk` możesz bezpośrednio przejść do kroku 3. + +## 3. Wyodrębnij biblioteki wyodrębniania Synology + +Prawdziwa logika deszyfrowania znajduje się w: + +* `/usr/syno/sbin/synoarchive` → główny wrapper CLI +* `/usr/lib/libsynopkg.so.1` → wywołuje wrapper z interfejsu DSM +* `libsynocodesign.so` → **zawiera implementację kryptograficzną** + +Oba pliki binarne są obecne w systemowym rootfs (`hda1.tgz`) **i** w skompresowanym init-rd (`rd.bin`). Jeśli masz tylko PAT, możesz je uzyskać w ten sposób: +```bash +# rd.bin is LZMA-compressed CPIO +$ lzcat rd.bin | cpio -id 2>/dev/null +$ file usr/lib/libsynocodesign.so +usr/lib/libsynocodesign.so: ELF 64-bit LSB shared object, ARM aarch64, … +``` +## 4. Odzyskiwanie twardo zakodowanych kluczy (`get_keys`) + +Wewnątrz `libsynocodesign.so` funkcja `get_keys(int keytype)` po prostu zwraca dwie 128-bitowe zmienne globalne dla żądanej rodziny archiwów: +```c +case 0: // PAT (system) +case 10: +case 11: +signature_key = qword_23A40; +master_key = qword_23A68; +break; + +case 3: // SPK (applications) +signature_key = qword_23AE0; +master_key = qword_23B08; +break; +``` +* **signature_key** → Klucz publiczny Ed25519 używany do weryfikacji nagłówka archiwum. +* **master_key** → Klucz główny używany do wyprowadzenia klucza szyfrowania dla archiwum. + +Musisz zrzucić te dwa stałe tylko raz dla każdej głównej wersji DSM. + +## 5. Struktura nagłówka i weryfikacja podpisu + +`synoarchive_open()` → `support_format_synoarchive()` → `archive_read_support_format_synoarchive()` wykonuje następujące czynności: + +1. Odczytaj magiczne (3 bajty) `0xBFBAAD` **lub** `0xADBEEF`. +2. Odczytaj 32-bitowy `header_len` w formacie little-endian. +3. Odczytaj `header_len` bajtów + następny **0x40-bajtowy podpis Ed25519**. +4. Iteruj przez wszystkie osadzone klucze publiczne, aż `crypto_sign_verify_detached()` zakończy się sukcesem. +5. Zdekoduj nagłówek za pomocą **MessagePack**, co daje: +```python +[ +data: bytes, +entries: [ [size: int, sha256: bytes], … ], +archive_description: bytes, +serial_number: [bytes], +not_valid_before: int +] +``` +`entries` później pozwala libarchive na sprawdzenie integralności każdego pliku w miarę jego deszyfrowania. + +## 6. Wyprowadź podklucz dla archiwum + +Z obiektu `data` zawartego w nagłówku MessagePack: + +* `subkey_id` = little-endian `uint64` w przesunięciu 0x10 +* `ctx` = 7 bajtów w przesunięciu 0x18 + +32-bajtowy **klucz strumieniowy** uzyskuje się za pomocą libsodium: +```c +crypto_kdf_derive_from_key(kdf_subkey, 32, subkey_id, ctx, master_key); +``` +## 7. Własny backend **libarchive** Synology + +Synology dołącza poprawioną wersję libarchive, która rejestruje fałszywy format "tar", gdy magiczne liczby to `0xADBEEF`: +```c +register_format( +"tar", spk_bid, spk_options, +spk_read_header, spk_read_data, spk_read_data_skip, +NULL, spk_cleanup, NULL, NULL); +``` +### spk_read_header() +``` +- Read 0x200 bytes +- nonce = buf[0:0x18] +- cipher = buf[0x18:0x18+0x193] +- crypto_secretstream_xchacha20poly1305_init_pull(state, nonce, kdf_subkey) +- crypto_secretstream_xchacha20poly1305_pull(state, tar_hdr, …, cipher, 0x193) +``` +Zdechifrowany `tar_hdr` to **klasyczny nagłówek TAR POSIX**. + +### spk_read_data() +``` +while (remaining > 0): +chunk_len = min(0x400000, remaining) + 0x11 # +tag +buf = archive_read_ahead(chunk_len) +crypto_secretstream_xchacha20poly1305_pull(state, out, …, buf, chunk_len) +remaining -= chunk_len - 0x11 +``` +Każdy **0x18-bajtowy nonce** jest dodawany na początku zaszyfrowanego fragmentu. + +Gdy wszystkie wpisy zostaną przetworzone, libarchive generuje całkowicie poprawny **`.tar`**, który można rozpakować za pomocą dowolnego standardowego narzędzia. + +## 8. Odszyfruj wszystko za pomocą synodecrypt +```bash +$ python3 synodecrypt.py SynologyPhotos-rtd1619b-1.7.0-0794.spk +[+] found matching keys (SPK) +[+] header signature verified +[+] 104 entries +[+] archive successfully decrypted → SynologyPhotos-rtd1619b-1.7.0-0794.tar + +$ tar xf SynologyPhotos-rtd1619b-1.7.0-0794.tar +``` +`synodecrypt` automatycznie wykrywa PAT/SPK, ładuje odpowiednie klucze i stosuje pełny łańcuch opisany powyżej. + +## 9. Typowe pułapki + +* Nie zamieniaj `signature_key` i `master_key` – pełnią różne funkcje. +* **Nonce** występuje *przed* szyfrogramem dla każdego bloku (nagłówek i dane). +* Maksymalny rozmiar zaszyfrowanego kawałka to **0x400000 + 0x11** (tag libsodium). +* Archiwa utworzone dla jednej generacji DSM mogą przejść na różne zakodowane klucze w następnej wersji. + +## 10. Dodatkowe narzędzia + +* [`patology`](https://github.com/sud0woodo/patology) – analiza/zrzut archiwów PAT. +* [`synodecrypt`](https://github.com/synacktiv/synodecrypt) – deszyfrowanie PAT/SPK/innych. +* [`libsodium`](https://github.com/jedisct1/libsodium) – referencyjna implementacja XChaCha20-Poly1305 secretstream. +* [`msgpack`](https://msgpack.org/) – serializacja nagłówków. + +## Odniesienia + +- [Extraction of Synology encrypted archives – Synacktiv (Pwn2Own IE 2024)](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html) +- [synodecrypt on GitHub](https://github.com/synacktiv/synodecrypt) +- [patology on GitHub](https://github.com/sud0woodo/patology) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index d3267beca..6df61f0ad 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,15 +2,15 @@ {{#include ../banners/hacktricks-training.md}} -## Czym jest wstrzykiwanie poleceń? +## Czym jest wstrzyknięcie polecenia? -**Wstrzykiwanie poleceń** pozwala na wykonanie dowolnych poleceń systemu operacyjnego przez atakującego na serwerze hostującym aplikację. W rezultacie aplikacja i wszystkie jej dane mogą być całkowicie skompromitowane. Wykonanie tych poleceń zazwyczaj pozwala atakującemu uzyskać nieautoryzowany dostęp lub kontrolę nad środowiskiem aplikacji i systemem bazowym. +**Wstrzyknięcie polecenia** pozwala atakującemu na wykonanie dowolnych poleceń systemu operacyjnego na serwerze hostującym aplikację. W rezultacie aplikacja i wszystkie jej dane mogą zostać całkowicie skompromitowane. Wykonanie tych poleceń zazwyczaj pozwala atakującemu uzyskać nieautoryzowany dostęp lub kontrolę nad środowiskiem aplikacji i systemem bazowym. ### Kontekst -W zależności od **tego, gdzie twoje dane wejściowe są wstrzykiwane**, może być konieczne **zakończenie cytowanego kontekstu** (używając `"` lub `'`) przed poleceniami. +W zależności od **tego, gdzie wprowadzane są dane** możesz potrzebować **zakończyć kontekst cytatu** (używając `"` lub `'`) przed poleceniami. -## Wstrzykiwanie poleceń/Wykonanie +## Wstrzyknięcie polecenia/Wykonanie ```bash #Both Unix and Windows supported ls||id; ls ||id; ls|| id; ls || id # Execute both @@ -31,7 +31,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful ``` ### **Ominięcia** ograniczeń -Jeśli próbujesz wykonać **dowolne polecenia wewnątrz maszyny linux** zainteresuje Cię przeczytanie o tych **Ominięciach:** +Jeśli próbujesz wykonać **dowolne polecenia wewnątrz maszyny linux**, zainteresuje Cię przeczytanie o tych **Ominięciach:** {{#ref}} ../linux-hardening/bypass-bash-restrictions/ @@ -117,15 +117,39 @@ powershell C:**2\n??e*d.*? # notepad ../linux-hardening/bypass-bash-restrictions/ {{#endref}} -## Lista wykrywania ataków brute-force +### Node.js `child_process.exec` vs `execFile` + +Podczas audytowania backendów JavaScript/TypeScript często napotkasz API Node.js `child_process`. +```javascript +// Vulnerable: user-controlled variables interpolated inside a template string +const { exec } = require('child_process'); +exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(payload)}'`, (err, stdout) => { +/* … */ +}); +``` +`exec()` uruchamia **powłokę** (`/bin/sh -c`), dlatego każdy znak, który ma specjalne znaczenie dla powłoki (back-ticki, `;`, `&&`, `|`, `$()`, …) spowoduje **iniekcję poleceń**, gdy dane wejściowe użytkownika są konkatenowane w ciągu. + +**Łagodzenie:** użyj `execFile()` (lub `spawn()` bez opcji `shell`) i podaj **każdy argument jako osobny element tablicy**, aby żadna powłoka nie była zaangażowana: +```javascript +const { execFile } = require('child_process'); +execFile('/usr/bin/do-something', [ +'--id_user', id_user, +'--payload', JSON.stringify(payload) +]); +``` +Real-world case: *Synology Photos* ≤ 1.7.0-0794 był podatny na atak przez nieautoryzowane zdarzenie WebSocket, które umieszczało dane kontrolowane przez atakującego w `id_user`, które później zostały osadzone w wywołaniu `exec()`, osiągając RCE (Pwn2Own Ireland 2024). + +## Brute-Force Detection List {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt {{#endref}} -## Odniesienia +## References +- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection) - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection) - [https://portswigger.net/web-security/os-command-injection](https://portswigger.net/web-security/os-command-injection) +- [Extraction of Synology encrypted archives – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html) {{#include ../banners/hacktricks-training.md}}